bin/default/librpc/gen_ndr/ndr_srvsvc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_srvsvc.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_svcctl.h"
   9 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfo0 *r)
  10 {
  11         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  12         if (ndr_flags & NDR_SCALARS) {
  13                 NDR_CHECK(ndr_push_align(ndr, 5));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
  15                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  16         }
  17         if (ndr_flags & NDR_BUFFERS) {
  18                 if (r->device) {
  19                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
  20                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  21                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
  22                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  23                 }
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfo0 *r)
  29 {
  30         uint32_t _ptr_device;
  31         uint32_t size_device_1 = 0;
  32         uint32_t length_device_1 = 0;
  33         TALLOC_CTX *_mem_save_device_0;
  34         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  35         if (ndr_flags & NDR_SCALARS) {
  36                 NDR_CHECK(ndr_pull_align(ndr, 5));
  37                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
  38                 if (_ptr_device) {
  39                         NDR_PULL_ALLOC(ndr, r->device);
  40                 } else {
  41                         r->device = NULL;
  42                 }
  43                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  44         }
  45         if (ndr_flags & NDR_BUFFERS) {
  46                 if (r->device) {
  47                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
  48                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
  49                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
  50                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
  51                         size_device_1 = ndr_get_array_size(ndr, &r->device);
  52                         length_device_1 = ndr_get_array_length(ndr, &r->device);
  53                         if (length_device_1 > size_device_1) {
  54                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_1, length_device_1);
  55                         }
  56                         NDR_CHECK(ndr_check_string_terminator(ndr, length_device_1, sizeof(uint16_t)));
  57                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, length_device_1, sizeof(uint16_t), CH_UTF16));
  58                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
  59                 }
  60         }
  61         return NDR_ERR_SUCCESS;
  62 }
  63
  64 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo0 *r)
  65 {
  66         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo0");
  67         if (r == NULL) { ndr_print_null(ndr); return; }
  68         ndr->depth++;
  69         ndr_print_ptr(ndr, "device", r->device);
  70         ndr->depth++;
  71         if (r->device) {
  72                 ndr_print_string(ndr, "device", r->device);
  73         }
  74         ndr->depth--;
  75         ndr->depth--;
  76 }
  77
  78 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr0 *r)
  79 {
  80         uint32_t cntr_array_1;
  81         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  82         if (ndr_flags & NDR_SCALARS) {
  83                 NDR_CHECK(ndr_push_align(ndr, 5));
  84                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  85                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
  86                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  87         }
  88         if (ndr_flags & NDR_BUFFERS) {
  89                 if (r->array) {
  90                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
  91                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
  92                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
  93                         }
  94                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
  95                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
  96                         }
  97                 }
  98         }
  99         return NDR_ERR_SUCCESS;
 100 }
 101
 102 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr0 *r)
 103 {
 104         uint32_t _ptr_array;
 105         uint32_t size_array_1 = 0;
 106         uint32_t cntr_array_1;
 107         TALLOC_CTX *_mem_save_array_0;
 108         TALLOC_CTX *_mem_save_array_1;
 109         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 110         if (ndr_flags & NDR_SCALARS) {
 111                 NDR_CHECK(ndr_pull_align(ndr, 5));
 112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 114                 if (_ptr_array) {
 115                         NDR_PULL_ALLOC(ndr, r->array);
 116                 } else {
 117                         r->array = NULL;
 118                 }
 119                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 120         }
 121         if (ndr_flags & NDR_BUFFERS) {
 122                 if (r->array) {
 123                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 124                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 125                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 126                         size_array_1 = ndr_get_array_size(ndr, &r->array);
 127                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
 128                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 129                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 130                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 131                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 132                         }
 133                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 134                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 135                         }
 136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 138                 }
 139                 if (r->array) {
 140                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 141                 }
 142         }
 143         return NDR_ERR_SUCCESS;
 144 }
 145
 146 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr0 *r)
 147 {
 148         uint32_t cntr_array_1;
 149         ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr0");
 150         if (r == NULL) { ndr_print_null(ndr); return; }
 151         ndr->depth++;
 152         ndr_print_uint32(ndr, "count", r->count);
 153         ndr_print_ptr(ndr, "array", r->array);
 154         ndr->depth++;
 155         if (r->array) {
 156                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 157                 ndr->depth++;
 158                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 159                         ndr_print_srvsvc_NetCharDevInfo0(ndr, "array", &r->array[cntr_array_1]);
 160                 }
 161                 ndr->depth--;
 162         }
 163         ndr->depth--;
 164         ndr->depth--;
 165 }
 166
 167 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfo1 *r)
 168 {
 169         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 170         if (ndr_flags & NDR_SCALARS) {
 171                 NDR_CHECK(ndr_push_align(ndr, 5));
 172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
 174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
 175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
 176                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 177         }
 178         if (ndr_flags & NDR_BUFFERS) {
 179                 if (r->device) {
 180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 184                 }
 185                 if (r->user) {
 186                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
 187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
 189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 190                 }
 191         }
 192         return NDR_ERR_SUCCESS;
 193 }
 194
 195 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfo1 *r)
 196 {
 197         uint32_t _ptr_device;
 198         uint32_t size_device_1 = 0;
 199         uint32_t length_device_1 = 0;
 200         TALLOC_CTX *_mem_save_device_0;
 201         uint32_t _ptr_user;
 202         uint32_t size_user_1 = 0;
 203         uint32_t length_user_1 = 0;
 204         TALLOC_CTX *_mem_save_user_0;
 205         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 206         if (ndr_flags & NDR_SCALARS) {
 207                 NDR_CHECK(ndr_pull_align(ndr, 5));
 208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 209                 if (_ptr_device) {
 210                         NDR_PULL_ALLOC(ndr, r->device);
 211                 } else {
 212                         r->device = NULL;
 213                 }
 214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
 216                 if (_ptr_user) {
 217                         NDR_PULL_ALLOC(ndr, r->user);
 218                 } else {
 219                         r->user = NULL;
 220                 }
 221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
 222                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 223         }
 224         if (ndr_flags & NDR_BUFFERS) {
 225                 if (r->device) {
 226                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 227                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 229                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 230                         size_device_1 = ndr_get_array_size(ndr, &r->device);
 231                         length_device_1 = ndr_get_array_length(ndr, &r->device);
 232                         if (length_device_1 > size_device_1) {
 233                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_1, length_device_1);
 234                         }
 235                         NDR_CHECK(ndr_check_string_terminator(ndr, length_device_1, sizeof(uint16_t)));
 236                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, length_device_1, sizeof(uint16_t), CH_UTF16));
 237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 238                 }
 239                 if (r->user) {
 240                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
 241                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
 242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
 243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
 244                         size_user_1 = ndr_get_array_size(ndr, &r->user);
 245                         length_user_1 = ndr_get_array_length(ndr, &r->user);
 246                         if (length_user_1 > size_user_1) {
 247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
 248                         }
 249                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
 250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
 251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
 252                 }
 253         }
 254         return NDR_ERR_SUCCESS;
 255 }
 256
 257 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo1 *r)
 258 {
 259         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo1");
 260         if (r == NULL) { ndr_print_null(ndr); return; }
 261         ndr->depth++;
 262         ndr_print_ptr(ndr, "device", r->device);
 263         ndr->depth++;
 264         if (r->device) {
 265                 ndr_print_string(ndr, "device", r->device);
 266         }
 267         ndr->depth--;
 268         ndr_print_uint32(ndr, "status", r->status);
 269         ndr_print_ptr(ndr, "user", r->user);
 270         ndr->depth++;
 271         if (r->user) {
 272                 ndr_print_string(ndr, "user", r->user);
 273         }
 274         ndr->depth--;
 275         ndr_print_uint32(ndr, "time", r->time);
 276         ndr->depth--;
 277 }
 278
 279 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr1 *r)
 280 {
 281         uint32_t cntr_array_1;
 282         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 283         if (ndr_flags & NDR_SCALARS) {
 284                 NDR_CHECK(ndr_push_align(ndr, 5));
 285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 287                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 288         }
 289         if (ndr_flags & NDR_BUFFERS) {
 290                 if (r->array) {
 291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 292                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 293                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 294                         }
 295                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 296                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 297                         }
 298                 }
 299         }
 300         return NDR_ERR_SUCCESS;
 301 }
 302
 303 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr1 *r)
 304 {
 305         uint32_t _ptr_array;
 306         uint32_t size_array_1 = 0;
 307         uint32_t cntr_array_1;
 308         TALLOC_CTX *_mem_save_array_0;
 309         TALLOC_CTX *_mem_save_array_1;
 310         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 311         if (ndr_flags & NDR_SCALARS) {
 312                 NDR_CHECK(ndr_pull_align(ndr, 5));
 313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 315                 if (_ptr_array) {
 316                         NDR_PULL_ALLOC(ndr, r->array);
 317                 } else {
 318                         r->array = NULL;
 319                 }
 320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 321         }
 322         if (ndr_flags & NDR_BUFFERS) {
 323                 if (r->array) {
 324                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 325                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 326                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 327                         size_array_1 = ndr_get_array_size(ndr, &r->array);
 328                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
 329                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 330                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 331                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 332                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 333                         }
 334                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 335                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 336                         }
 337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 339                 }
 340                 if (r->array) {
 341                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 342                 }
 343         }
 344         return NDR_ERR_SUCCESS;
 345 }
 346
 347 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr1 *r)
 348 {
 349         uint32_t cntr_array_1;
 350         ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr1");
 351         if (r == NULL) { ndr_print_null(ndr); return; }
 352         ndr->depth++;
 353         ndr_print_uint32(ndr, "count", r->count);
 354         ndr_print_ptr(ndr, "array", r->array);
 355         ndr->depth++;
 356         if (r->array) {
 357                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 358                 ndr->depth++;
 359                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 360                         ndr_print_srvsvc_NetCharDevInfo1(ndr, "array", &r->array[cntr_array_1]);
 361                 }
 362                 ndr->depth--;
 363         }
 364         ndr->depth--;
 365         ndr->depth--;
 366 }
 367
 368 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevInfo *r)
 369 {
 370         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 371         if (ndr_flags & NDR_SCALARS) {
 372                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 373                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 375                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 376                 switch (level) {
 377                         case 0: {
 378                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
 379                         break; }
 380
 381                         case 1: {
 382                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
 383                         break; }
 384
 385                         default: {
 386                         break; }
 387
 388                 }
 389         }
 390         if (ndr_flags & NDR_BUFFERS) {
 391                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 392                 switch (level) {
 393                         case 0:
 394                                 if (r->info0) {
 395                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
 396                                 }
 397                         break;
 398
 399                         case 1:
 400                                 if (r->info1) {
 401                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
 402                                 }
 403                         break;
 404
 405                         default:
 406                         break;
 407
 408                 }
 409         }
 410         return NDR_ERR_SUCCESS;
 411 }
 412
 413 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevInfo *r)
 414 {
 415         uint32_t level;
 416         uint32_t _level;
 417         TALLOC_CTX *_mem_save_info0_0;
 418         uint32_t _ptr_info0;
 419         TALLOC_CTX *_mem_save_info1_0;
 420         uint32_t _ptr_info1;
 421         level = ndr_pull_get_switch_value(ndr, r);
 422         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 423         if (ndr_flags & NDR_SCALARS) {
 424                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 426                 if (_level != level) {
 427                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 428                 }
 429                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 430                 switch (level) {
 431                         case 0: {
 432                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
 433                                 if (_ptr_info0) {
 434                                         NDR_PULL_ALLOC(ndr, r->info0);
 435                                 } else {
 436                                         r->info0 = NULL;
 437                                 }
 438                         break; }
 439
 440                         case 1: {
 441                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
 442                                 if (_ptr_info1) {
 443                                         NDR_PULL_ALLOC(ndr, r->info1);
 444                                 } else {
 445                                         r->info1 = NULL;
 446                                 }
 447                         break; }
 448
 449                         default: {
 450                         break; }
 451
 452                 }
 453         }
 454         if (ndr_flags & NDR_BUFFERS) {
 455                 switch (level) {
 456                         case 0:
 457                                 if (r->info0) {
 458                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
 459                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
 460                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
 461                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
 462                                 }
 463                         break;
 464
 465                         case 1:
 466                                 if (r->info1) {
 467                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
 468                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
 469                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
 470                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
 471                                 }
 472                         break;
 473
 474                         default:
 475                         break;
 476
 477                 }
 478         }
 479         return NDR_ERR_SUCCESS;
 480 }
 481
 482 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevInfo *r)
 483 {
 484         uint32_t level;
 485         level = ndr_print_get_switch_value(ndr, r);
 486         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevInfo");
 487         switch (level) {
 488                 case 0:
 489                         ndr_print_ptr(ndr, "info0", r->info0);
 490                         ndr->depth++;
 491                         if (r->info0) {
 492                                 ndr_print_srvsvc_NetCharDevInfo0(ndr, "info0", r->info0);
 493                         }
 494                         ndr->depth--;
 495                 break;
 496
 497                 case 1:
 498                         ndr_print_ptr(ndr, "info1", r->info1);
 499                         ndr->depth++;
 500                         if (r->info1) {
 501                                 ndr_print_srvsvc_NetCharDevInfo1(ndr, "info1", r->info1);
 502                         }
 503                         ndr->depth--;
 504                 break;
 505
 506                 default:
 507                 break;
 508
 509         }
 510 }
 511
 512 static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevCtr *r)
 513 {
 514         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 515         if (ndr_flags & NDR_SCALARS) {
 516                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 517                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
 519                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 520                 switch (level) {
 521                         case 0: {
 522                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
 523                         break; }
 524
 525                         case 1: {
 526                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
 527                         break; }
 528
 529                         default: {
 530                         break; }
 531
 532                 }
 533         }
 534         if (ndr_flags & NDR_BUFFERS) {
 535                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 536                 switch (level) {
 537                         case 0:
 538                                 if (r->ctr0) {
 539                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
 540                                 }
 541                         break;
 542
 543                         case 1:
 544                                 if (r->ctr1) {
 545                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
 546                                 }
 547                         break;
 548
 549                         default:
 550                         break;
 551
 552                 }
 553         }
 554         return NDR_ERR_SUCCESS;
 555 }
 556
 557 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevCtr *r)
 558 {
 559         uint32_t level;
 560         uint32_t _level;
 561         TALLOC_CTX *_mem_save_ctr0_0;
 562         uint32_t _ptr_ctr0;
 563         TALLOC_CTX *_mem_save_ctr1_0;
 564         uint32_t _ptr_ctr1;
 565         level = ndr_pull_get_switch_value(ndr, r);
 566         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 567         if (ndr_flags & NDR_SCALARS) {
 568                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
 570                 if (_level != level) {
 571                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 572                 }
 573                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 574                 switch (level) {
 575                         case 0: {
 576                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
 577                                 if (_ptr_ctr0) {
 578                                         NDR_PULL_ALLOC(ndr, r->ctr0);
 579                                 } else {
 580                                         r->ctr0 = NULL;
 581                                 }
 582                         break; }
 583
 584                         case 1: {
 585                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
 586                                 if (_ptr_ctr1) {
 587                                         NDR_PULL_ALLOC(ndr, r->ctr1);
 588                                 } else {
 589                                         r->ctr1 = NULL;
 590                                 }
 591                         break; }
 592
 593                         default: {
 594                         break; }
 595
 596                 }
 597         }
 598         if (ndr_flags & NDR_BUFFERS) {
 599                 switch (level) {
 600                         case 0:
 601                                 if (r->ctr0) {
 602                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
 603                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
 604                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
 605                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
 606                                 }
 607                         break;
 608
 609                         case 1:
 610                                 if (r->ctr1) {
 611                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
 612                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
 613                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
 614                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
 615                                 }
 616                         break;
 617
 618                         default:
 619                         break;
 620
 621                 }
 622         }
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 _PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevCtr *r)
 627 {
 628         uint32_t level;
 629         level = ndr_print_get_switch_value(ndr, r);
 630         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevCtr");
 631         switch (level) {
 632                 case 0:
 633                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
 634                         ndr->depth++;
 635                         if (r->ctr0) {
 636                                 ndr_print_srvsvc_NetCharDevCtr0(ndr, "ctr0", r->ctr0);
 637                         }
 638                         ndr->depth--;
 639                 break;
 640
 641                 case 1:
 642                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
 643                         ndr->depth++;
 644                         if (r->ctr1) {
 645                                 ndr_print_srvsvc_NetCharDevCtr1(ndr, "ctr1", r->ctr1);
 646                         }
 647                         ndr->depth--;
 648                 break;
 649
 650                 default:
 651                 break;
 652
 653         }
 654 }
 655
 656 static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfoCtr *r)
 657 {
 658         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 659         if (ndr_flags & NDR_SCALARS) {
 660                 NDR_CHECK(ndr_push_align(ndr, 5));
 661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
 662                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
 663                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
 664                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 665         }
 666         if (ndr_flags & NDR_BUFFERS) {
 667                 NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
 668         }
 669         return NDR_ERR_SUCCESS;
 670 }
 671
 672 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfoCtr *r)
 673 {
 674         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 675         if (ndr_flags & NDR_SCALARS) {
 676                 NDR_CHECK(ndr_pull_align(ndr, 5));
 677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
 678                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
 679                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));
 680                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 681         }
 682         if (ndr_flags & NDR_BUFFERS) {
 683                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));
 684         }
 685         return NDR_ERR_SUCCESS;
 686 }
 687
 688 _PUBLIC_ void ndr_print_srvsvc_NetCharDevInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfoCtr *r)
 689 {
 690         ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfoCtr");
 691         if (r == NULL) { ndr_print_null(ndr); return; }
 692         ndr->depth++;
 693         ndr_print_uint32(ndr, "level", r->level);
 694         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
 695         ndr_print_srvsvc_NetCharDevCtr(ndr, "ctr", &r->ctr);
 696         ndr->depth--;
 697 }
 698
 699 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo0 *r)
 700 {
 701         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 702         if (ndr_flags & NDR_SCALARS) {
 703                 NDR_CHECK(ndr_push_align(ndr, 5));
 704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 705                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 706         }
 707         if (ndr_flags & NDR_BUFFERS) {
 708                 if (r->device) {
 709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 713                 }
 714         }
 715         return NDR_ERR_SUCCESS;
 716 }
 717
 718 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo0 *r)
 719 {
 720         uint32_t _ptr_device;
 721         uint32_t size_device_1 = 0;
 722         uint32_t length_device_1 = 0;
 723         TALLOC_CTX *_mem_save_device_0;
 724         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 725         if (ndr_flags & NDR_SCALARS) {
 726                 NDR_CHECK(ndr_pull_align(ndr, 5));
 727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 728                 if (_ptr_device) {
 729                         NDR_PULL_ALLOC(ndr, r->device);
 730                 } else {
 731                         r->device = NULL;
 732                 }
 733                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 734         }
 735         if (ndr_flags & NDR_BUFFERS) {
 736                 if (r->device) {
 737                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 738                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 739                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 740                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 741                         size_device_1 = ndr_get_array_size(ndr, &r->device);
 742                         length_device_1 = ndr_get_array_length(ndr, &r->device);
 743                         if (length_device_1 > size_device_1) {
 744                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_1, length_device_1);
 745                         }
 746                         NDR_CHECK(ndr_check_string_terminator(ndr, length_device_1, sizeof(uint16_t)));
 747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, length_device_1, sizeof(uint16_t), CH_UTF16));
 748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 749                 }
 750         }
 751         return NDR_ERR_SUCCESS;
 752 }
 753
 754 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo0 *r)
 755 {
 756         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo0");
 757         if (r == NULL) { ndr_print_null(ndr); return; }
 758         ndr->depth++;
 759         ndr_print_ptr(ndr, "device", r->device);
 760         ndr->depth++;
 761         if (r->device) {
 762                 ndr_print_string(ndr, "device", r->device);
 763         }
 764         ndr->depth--;
 765         ndr->depth--;
 766 }
 767
 768 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr0 *r)
 769 {
 770         uint32_t cntr_array_1;
 771         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 772         if (ndr_flags & NDR_SCALARS) {
 773                 NDR_CHECK(ndr_push_align(ndr, 5));
 774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 776                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 777         }
 778         if (ndr_flags & NDR_BUFFERS) {
 779                 if (r->array) {
 780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 781                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 782                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 783                         }
 784                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 785                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 786                         }
 787                 }
 788         }
 789         return NDR_ERR_SUCCESS;
 790 }
 791
 792 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr0 *r)
 793 {
 794         uint32_t _ptr_array;
 795         uint32_t size_array_1 = 0;
 796         uint32_t cntr_array_1;
 797         TALLOC_CTX *_mem_save_array_0;
 798         TALLOC_CTX *_mem_save_array_1;
 799         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 800         if (ndr_flags & NDR_SCALARS) {
 801                 NDR_CHECK(ndr_pull_align(ndr, 5));
 802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 804                 if (_ptr_array) {
 805                         NDR_PULL_ALLOC(ndr, r->array);
 806                 } else {
 807                         r->array = NULL;
 808                 }
 809                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 810         }
 811         if (ndr_flags & NDR_BUFFERS) {
 812                 if (r->array) {
 813                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 814                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 816                         size_array_1 = ndr_get_array_size(ndr, &r->array);
 817                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
 818                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 819                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 820                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 821                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 822                         }
 823                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
 824                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 825                         }
 826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 828                 }
 829                 if (r->array) {
 830                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
 831                 }
 832         }
 833         return NDR_ERR_SUCCESS;
 834 }
 835
 836 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr0 *r)
 837 {
 838         uint32_t cntr_array_1;
 839         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr0");
 840         if (r == NULL) { ndr_print_null(ndr); return; }
 841         ndr->depth++;
 842         ndr_print_uint32(ndr, "count", r->count);
 843         ndr_print_ptr(ndr, "array", r->array);
 844         ndr->depth++;
 845         if (r->array) {
 846                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
 847                 ndr->depth++;
 848                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
 849                         ndr_print_srvsvc_NetCharDevQInfo0(ndr, "array", &r->array[cntr_array_1]);
 850                 }
 851                 ndr->depth--;
 852         }
 853         ndr->depth--;
 854         ndr->depth--;
 855 }
 856
 857 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo1 *r)
 858 {
 859         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 860         if (ndr_flags & NDR_SCALARS) {
 861                 NDR_CHECK(ndr_push_align(ndr, 5));
 862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->device));
 863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
 864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devices));
 865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
 866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_ahead));
 867                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 868         }
 869         if (ndr_flags & NDR_BUFFERS) {
 870                 if (r->device) {
 871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 873                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));
 874                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device, ndr_charset_length(r->device, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 875                 }
 876                 if (r->devices) {
 877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));
 880                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devices, ndr_charset_length(r->devices, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 881                 }
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo1 *r)
 887 {
 888         uint32_t _ptr_device;
 889         uint32_t size_device_1 = 0;
 890         uint32_t length_device_1 = 0;
 891         TALLOC_CTX *_mem_save_device_0;
 892         uint32_t _ptr_devices;
 893         uint32_t size_devices_1 = 0;
 894         uint32_t length_devices_1 = 0;
 895         TALLOC_CTX *_mem_save_devices_0;
 896         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 897         if (ndr_flags & NDR_SCALARS) {
 898                 NDR_CHECK(ndr_pull_align(ndr, 5));
 899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));
 900                 if (_ptr_device) {
 901                         NDR_PULL_ALLOC(ndr, r->device);
 902                 } else {
 903                         r->device = NULL;
 904                 }
 905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
 906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devices));
 907                 if (_ptr_devices) {
 908                         NDR_PULL_ALLOC(ndr, r->devices);
 909                 } else {
 910                         r->devices = NULL;
 911                 }
 912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
 913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_ahead));
 914                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 915         }
 916         if (ndr_flags & NDR_BUFFERS) {
 917                 if (r->device) {
 918                         _mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);
 919                         NDR_PULL_SET_MEM_CTX(ndr, r->device, 0);
 920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->device));
 921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->device));
 922                         size_device_1 = ndr_get_array_size(ndr, &r->device);
 923                         length_device_1 = ndr_get_array_length(ndr, &r->device);
 924                         if (length_device_1 > size_device_1) {
 925                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_1, length_device_1);
 926                         }
 927                         NDR_CHECK(ndr_check_string_terminator(ndr, length_device_1, sizeof(uint16_t)));
 928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device, length_device_1, sizeof(uint16_t), CH_UTF16));
 929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);
 930                 }
 931                 if (r->devices) {
 932                         _mem_save_devices_0 = NDR_PULL_GET_MEM_CTX(ndr);
 933                         NDR_PULL_SET_MEM_CTX(ndr, r->devices, 0);
 934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->devices));
 935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->devices));
 936                         size_devices_1 = ndr_get_array_size(ndr, &r->devices);
 937                         length_devices_1 = ndr_get_array_length(ndr, &r->devices);
 938                         if (length_devices_1 > size_devices_1) {
 939                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_devices_1, length_devices_1);
 940                         }
 941                         NDR_CHECK(ndr_check_string_terminator(ndr, length_devices_1, sizeof(uint16_t)));
 942                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devices, length_devices_1, sizeof(uint16_t), CH_UTF16));
 943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devices_0, 0);
 944                 }
 945         }
 946         return NDR_ERR_SUCCESS;
 947 }
 948
 949 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo1 *r)
 950 {
 951         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo1");
 952         if (r == NULL) { ndr_print_null(ndr); return; }
 953         ndr->depth++;
 954         ndr_print_ptr(ndr, "device", r->device);
 955         ndr->depth++;
 956         if (r->device) {
 957                 ndr_print_string(ndr, "device", r->device);
 958         }
 959         ndr->depth--;
 960         ndr_print_uint32(ndr, "priority", r->priority);
 961         ndr_print_ptr(ndr, "devices", r->devices);
 962         ndr->depth++;
 963         if (r->devices) {
 964                 ndr_print_string(ndr, "devices", r->devices);
 965         }
 966         ndr->depth--;
 967         ndr_print_uint32(ndr, "users", r->users);
 968         ndr_print_uint32(ndr, "num_ahead", r->num_ahead);
 969         ndr->depth--;
 970 }
 971
 972 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr1 *r)
 973 {
 974         uint32_t cntr_array_1;
 975         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 976         if (ndr_flags & NDR_SCALARS) {
 977                 NDR_CHECK(ndr_push_align(ndr, 5));
 978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 979                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 980                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 981         }
 982         if (ndr_flags & NDR_BUFFERS) {
 983                 if (r->array) {
 984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 985                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 986                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 987                         }
 988                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
 989                                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
 990                         }
 991                 }
 992         }
 993         return NDR_ERR_SUCCESS;
 994 }
 995
 996 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr1 *r)
 997 {
 998         uint32_t _ptr_array;
 999         uint32_t size_array_1 = 0;
1000         uint32_t cntr_array_1;
1001         TALLOC_CTX *_mem_save_array_0;
1002         TALLOC_CTX *_mem_save_array_1;
1003         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1004         if (ndr_flags & NDR_SCALARS) {
1005                 NDR_CHECK(ndr_pull_align(ndr, 5));
1006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1008                 if (_ptr_array) {
1009                         NDR_PULL_ALLOC(ndr, r->array);
1010                 } else {
1011                         r->array = NULL;
1012                 }
1013                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1014         }
1015         if (ndr_flags & NDR_BUFFERS) {
1016                 if (r->array) {
1017                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1018                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1020                         size_array_1 = ndr_get_array_size(ndr, &r->array);
1021                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
1022                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1023                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1024                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1025                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1026                         }
1027                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1028                                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1029                         }
1030                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1032                 }
1033                 if (r->array) {
1034                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1035                 }
1036         }
1037         return NDR_ERR_SUCCESS;
1038 }
1039
1040 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr1 *r)
1041 {
1042         uint32_t cntr_array_1;
1043         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr1");
1044         if (r == NULL) { ndr_print_null(ndr); return; }
1045         ndr->depth++;
1046         ndr_print_uint32(ndr, "count", r->count);
1047         ndr_print_ptr(ndr, "array", r->array);
1048         ndr->depth++;
1049         if (r->array) {
1050                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1051                 ndr->depth++;
1052                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1053                         ndr_print_srvsvc_NetCharDevQInfo1(ndr, "array", &r->array[cntr_array_1]);
1054                 }
1055                 ndr->depth--;
1056         }
1057         ndr->depth--;
1058         ndr->depth--;
1059 }
1060
1061 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQInfo *r)
1062 {
1063         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1064         if (ndr_flags & NDR_SCALARS) {
1065                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1066                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1068                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1069                 switch (level) {
1070                         case 0: {
1071                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
1072                         break; }
1073
1074                         case 1: {
1075                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
1076                         break; }
1077
1078                         default: {
1079                         break; }
1080
1081                 }
1082         }
1083         if (ndr_flags & NDR_BUFFERS) {
1084                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1085                 switch (level) {
1086                         case 0:
1087                                 if (r->info0) {
1088                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
1089                                 }
1090                         break;
1091
1092                         case 1:
1093                                 if (r->info1) {
1094                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1095                                 }
1096                         break;
1097
1098                         default:
1099                         break;
1100
1101                 }
1102         }
1103         return NDR_ERR_SUCCESS;
1104 }
1105
1106 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQInfo *r)
1107 {
1108         uint32_t level;
1109         uint32_t _level;
1110         TALLOC_CTX *_mem_save_info0_0;
1111         uint32_t _ptr_info0;
1112         TALLOC_CTX *_mem_save_info1_0;
1113         uint32_t _ptr_info1;
1114         level = ndr_pull_get_switch_value(ndr, r);
1115         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1116         if (ndr_flags & NDR_SCALARS) {
1117                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1119                 if (_level != level) {
1120                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1121                 }
1122                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1123                 switch (level) {
1124                         case 0: {
1125                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
1126                                 if (_ptr_info0) {
1127                                         NDR_PULL_ALLOC(ndr, r->info0);
1128                                 } else {
1129                                         r->info0 = NULL;
1130                                 }
1131                         break; }
1132
1133                         case 1: {
1134                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
1135                                 if (_ptr_info1) {
1136                                         NDR_PULL_ALLOC(ndr, r->info1);
1137                                 } else {
1138                                         r->info1 = NULL;
1139                                 }
1140                         break; }
1141
1142                         default: {
1143                         break; }
1144
1145                 }
1146         }
1147         if (ndr_flags & NDR_BUFFERS) {
1148                 switch (level) {
1149                         case 0:
1150                                 if (r->info0) {
1151                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1152                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
1153                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
1154                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
1155                                 }
1156                         break;
1157
1158                         case 1:
1159                                 if (r->info1) {
1160                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1161                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
1162                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
1163                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
1164                                 }
1165                         break;
1166
1167                         default:
1168                         break;
1169
1170                 }
1171         }
1172         return NDR_ERR_SUCCESS;
1173 }
1174
1175 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQInfo *r)
1176 {
1177         uint32_t level;
1178         level = ndr_print_get_switch_value(ndr, r);
1179         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQInfo");
1180         switch (level) {
1181                 case 0:
1182                         ndr_print_ptr(ndr, "info0", r->info0);
1183                         ndr->depth++;
1184                         if (r->info0) {
1185                                 ndr_print_srvsvc_NetCharDevQInfo0(ndr, "info0", r->info0);
1186                         }
1187                         ndr->depth--;
1188                 break;
1189
1190                 case 1:
1191                         ndr_print_ptr(ndr, "info1", r->info1);
1192                         ndr->depth++;
1193                         if (r->info1) {
1194                                 ndr_print_srvsvc_NetCharDevQInfo1(ndr, "info1", r->info1);
1195                         }
1196                         ndr->depth--;
1197                 break;
1198
1199                 default:
1200                 break;
1201
1202         }
1203 }
1204
1205 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQCtr *r)
1206 {
1207         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1208         if (ndr_flags & NDR_SCALARS) {
1209                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1210                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1212                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1213                 switch (level) {
1214                         case 0: {
1215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1216                         break; }
1217
1218                         case 1: {
1219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1220                         break; }
1221
1222                         default: {
1223                         break; }
1224
1225                 }
1226         }
1227         if (ndr_flags & NDR_BUFFERS) {
1228                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1229                 switch (level) {
1230                         case 0:
1231                                 if (r->ctr0) {
1232                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1233                                 }
1234                         break;
1235
1236                         case 1:
1237                                 if (r->ctr1) {
1238                                         NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1239                                 }
1240                         break;
1241
1242                         default:
1243                         break;
1244
1245                 }
1246         }
1247         return NDR_ERR_SUCCESS;
1248 }
1249
1250 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQCtr *r)
1251 {
1252         uint32_t level;
1253         uint32_t _level;
1254         TALLOC_CTX *_mem_save_ctr0_0;
1255         uint32_t _ptr_ctr0;
1256         TALLOC_CTX *_mem_save_ctr1_0;
1257         uint32_t _ptr_ctr1;
1258         level = ndr_pull_get_switch_value(ndr, r);
1259         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1260         if (ndr_flags & NDR_SCALARS) {
1261                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1263                 if (_level != level) {
1264                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1265                 }
1266                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1267                 switch (level) {
1268                         case 0: {
1269                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1270                                 if (_ptr_ctr0) {
1271                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1272                                 } else {
1273                                         r->ctr0 = NULL;
1274                                 }
1275                         break; }
1276
1277                         case 1: {
1278                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1279                                 if (_ptr_ctr1) {
1280                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1281                                 } else {
1282                                         r->ctr1 = NULL;
1283                                 }
1284                         break; }
1285
1286                         default: {
1287                         break; }
1288
1289                 }
1290         }
1291         if (ndr_flags & NDR_BUFFERS) {
1292                 switch (level) {
1293                         case 0:
1294                                 if (r->ctr0) {
1295                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1296                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1297                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1298                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1299                                 }
1300                         break;
1301
1302                         case 1:
1303                                 if (r->ctr1) {
1304                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1305                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1306                                         NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1307                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1308                                 }
1309                         break;
1310
1311                         default:
1312                         break;
1313
1314                 }
1315         }
1316         return NDR_ERR_SUCCESS;
1317 }
1318
1319 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQCtr *r)
1320 {
1321         uint32_t level;
1322         level = ndr_print_get_switch_value(ndr, r);
1323         ndr_print_union(ndr, name, level, "srvsvc_NetCharDevQCtr");
1324         switch (level) {
1325                 case 0:
1326                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1327                         ndr->depth++;
1328                         if (r->ctr0) {
1329                                 ndr_print_srvsvc_NetCharDevQCtr0(ndr, "ctr0", r->ctr0);
1330                         }
1331                         ndr->depth--;
1332                 break;
1333
1334                 case 1:
1335                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1336                         ndr->depth++;
1337                         if (r->ctr1) {
1338                                 ndr_print_srvsvc_NetCharDevQCtr1(ndr, "ctr1", r->ctr1);
1339                         }
1340                         ndr->depth--;
1341                 break;
1342
1343                 default:
1344                 break;
1345
1346         }
1347 }
1348
1349 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfoCtr *r)
1350 {
1351         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1352         if (ndr_flags & NDR_SCALARS) {
1353                 NDR_CHECK(ndr_push_align(ndr, 5));
1354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
1355                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
1356                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
1357                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1358         }
1359         if (ndr_flags & NDR_BUFFERS) {
1360                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
1361         }
1362         return NDR_ERR_SUCCESS;
1363 }
1364
1365 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfoCtr *r)
1366 {
1367         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1368         if (ndr_flags & NDR_SCALARS) {
1369                 NDR_CHECK(ndr_pull_align(ndr, 5));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
1371                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
1372                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));
1373                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1374         }
1375         if (ndr_flags & NDR_BUFFERS) {
1376                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));
1377         }
1378         return NDR_ERR_SUCCESS;
1379 }
1380
1381 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfoCtr *r)
1382 {
1383         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfoCtr");
1384         if (r == NULL) { ndr_print_null(ndr); return; }
1385         ndr->depth++;
1386         ndr_print_uint32(ndr, "level", r->level);
1387         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
1388         ndr_print_srvsvc_NetCharDevQCtr(ndr, "ctr", &r->ctr);
1389         ndr->depth--;
1390 }
1391
1392 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo0 *r)
1393 {
1394         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1395         if (ndr_flags & NDR_SCALARS) {
1396                 NDR_CHECK(ndr_push_align(ndr, 4));
1397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1398                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1399         }
1400         if (ndr_flags & NDR_BUFFERS) {
1401         }
1402         return NDR_ERR_SUCCESS;
1403 }
1404
1405 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo0 *r)
1406 {
1407         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1408         if (ndr_flags & NDR_SCALARS) {
1409                 NDR_CHECK(ndr_pull_align(ndr, 4));
1410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1412         }
1413         if (ndr_flags & NDR_BUFFERS) {
1414         }
1415         return NDR_ERR_SUCCESS;
1416 }
1417
1418 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo0 *r)
1419 {
1420         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo0");
1421         if (r == NULL) { ndr_print_null(ndr); return; }
1422         ndr->depth++;
1423         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1424         ndr->depth--;
1425 }
1426
1427 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr0 *r)
1428 {
1429         uint32_t cntr_array_1;
1430         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1431         if (ndr_flags & NDR_SCALARS) {
1432                 NDR_CHECK(ndr_push_align(ndr, 5));
1433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1435                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1436         }
1437         if (ndr_flags & NDR_BUFFERS) {
1438                 if (r->array) {
1439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1440                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1441                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1442                         }
1443                 }
1444         }
1445         return NDR_ERR_SUCCESS;
1446 }
1447
1448 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr0 *r)
1449 {
1450         uint32_t _ptr_array;
1451         uint32_t size_array_1 = 0;
1452         uint32_t cntr_array_1;
1453         TALLOC_CTX *_mem_save_array_0;
1454         TALLOC_CTX *_mem_save_array_1;
1455         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1456         if (ndr_flags & NDR_SCALARS) {
1457                 NDR_CHECK(ndr_pull_align(ndr, 5));
1458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1460                 if (_ptr_array) {
1461                         NDR_PULL_ALLOC(ndr, r->array);
1462                 } else {
1463                         r->array = NULL;
1464                 }
1465                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1466         }
1467         if (ndr_flags & NDR_BUFFERS) {
1468                 if (r->array) {
1469                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1470                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1471                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1472                         size_array_1 = ndr_get_array_size(ndr, &r->array);
1473                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
1474                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1475                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1476                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1477                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1478                         }
1479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1481                 }
1482                 if (r->array) {
1483                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1484                 }
1485         }
1486         return NDR_ERR_SUCCESS;
1487 }
1488
1489 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr0 *r)
1490 {
1491         uint32_t cntr_array_1;
1492         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr0");
1493         if (r == NULL) { ndr_print_null(ndr); return; }
1494         ndr->depth++;
1495         ndr_print_uint32(ndr, "count", r->count);
1496         ndr_print_ptr(ndr, "array", r->array);
1497         ndr->depth++;
1498         if (r->array) {
1499                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1500                 ndr->depth++;
1501                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1502                         ndr_print_srvsvc_NetConnInfo0(ndr, "array", &r->array[cntr_array_1]);
1503                 }
1504                 ndr->depth--;
1505         }
1506         ndr->depth--;
1507         ndr->depth--;
1508 }
1509
1510 static enum ndr_err_code ndr_push_srvsvc_NetConnInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo1 *r)
1511 {
1512         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1513         if (ndr_flags & NDR_SCALARS) {
1514                 NDR_CHECK(ndr_push_align(ndr, 5));
1515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_id));
1516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_type));
1517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
1518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));
1519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->conn_time));
1520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
1521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->share));
1522                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1523         }
1524         if (ndr_flags & NDR_BUFFERS) {
1525                 if (r->user) {
1526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
1529                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1530                 }
1531                 if (r->share) {
1532                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));
1535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->share, ndr_charset_length(r->share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1536                 }
1537         }
1538         return NDR_ERR_SUCCESS;
1539 }
1540
1541 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo1 *r)
1542 {
1543         uint32_t _ptr_user;
1544         uint32_t size_user_1 = 0;
1545         uint32_t length_user_1 = 0;
1546         TALLOC_CTX *_mem_save_user_0;
1547         uint32_t _ptr_share;
1548         uint32_t size_share_1 = 0;
1549         uint32_t length_share_1 = 0;
1550         TALLOC_CTX *_mem_save_share_0;
1551         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1552         if (ndr_flags & NDR_SCALARS) {
1553                 NDR_CHECK(ndr_pull_align(ndr, 5));
1554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_id));
1555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_type));
1556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
1557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));
1558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->conn_time));
1559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
1560                 if (_ptr_user) {
1561                         NDR_PULL_ALLOC(ndr, r->user);
1562                 } else {
1563                         r->user = NULL;
1564                 }
1565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
1566                 if (_ptr_share) {
1567                         NDR_PULL_ALLOC(ndr, r->share);
1568                 } else {
1569                         r->share = NULL;
1570                 }
1571                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1572         }
1573         if (ndr_flags & NDR_BUFFERS) {
1574                 if (r->user) {
1575                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
1576                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
1577                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
1578                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
1579                         size_user_1 = ndr_get_array_size(ndr, &r->user);
1580                         length_user_1 = ndr_get_array_length(ndr, &r->user);
1581                         if (length_user_1 > size_user_1) {
1582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
1583                         }
1584                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
1585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
1586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
1587                 }
1588                 if (r->share) {
1589                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
1590                         NDR_PULL_SET_MEM_CTX(ndr, r->share, 0);
1591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->share));
1592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->share));
1593                         size_share_1 = ndr_get_array_size(ndr, &r->share);
1594                         length_share_1 = ndr_get_array_length(ndr, &r->share);
1595                         if (length_share_1 > size_share_1) {
1596                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_1, length_share_1);
1597                         }
1598                         NDR_CHECK(ndr_check_string_terminator(ndr, length_share_1, sizeof(uint16_t)));
1599                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->share, length_share_1, sizeof(uint16_t), CH_UTF16));
1600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
1601                 }
1602         }
1603         return NDR_ERR_SUCCESS;
1604 }
1605
1606 _PUBLIC_ void ndr_print_srvsvc_NetConnInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo1 *r)
1607 {
1608         ndr_print_struct(ndr, name, "srvsvc_NetConnInfo1");
1609         if (r == NULL) { ndr_print_null(ndr); return; }
1610         ndr->depth++;
1611         ndr_print_uint32(ndr, "conn_id", r->conn_id);
1612         ndr_print_uint32(ndr, "conn_type", r->conn_type);
1613         ndr_print_uint32(ndr, "num_open", r->num_open);
1614         ndr_print_uint32(ndr, "num_users", r->num_users);
1615         ndr_print_uint32(ndr, "conn_time", r->conn_time);
1616         ndr_print_ptr(ndr, "user", r->user);
1617         ndr->depth++;
1618         if (r->user) {
1619                 ndr_print_string(ndr, "user", r->user);
1620         }
1621         ndr->depth--;
1622         ndr_print_ptr(ndr, "share", r->share);
1623         ndr->depth++;
1624         if (r->share) {
1625                 ndr_print_string(ndr, "share", r->share);
1626         }
1627         ndr->depth--;
1628         ndr->depth--;
1629 }
1630
1631 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr1 *r)
1632 {
1633         uint32_t cntr_array_1;
1634         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1635         if (ndr_flags & NDR_SCALARS) {
1636                 NDR_CHECK(ndr_push_align(ndr, 5));
1637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1639                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1640         }
1641         if (ndr_flags & NDR_BUFFERS) {
1642                 if (r->array) {
1643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1644                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1645                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1646                         }
1647                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1648                                 NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1649                         }
1650                 }
1651         }
1652         return NDR_ERR_SUCCESS;
1653 }
1654
1655 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr1 *r)
1656 {
1657         uint32_t _ptr_array;
1658         uint32_t size_array_1 = 0;
1659         uint32_t cntr_array_1;
1660         TALLOC_CTX *_mem_save_array_0;
1661         TALLOC_CTX *_mem_save_array_1;
1662         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1663         if (ndr_flags & NDR_SCALARS) {
1664                 NDR_CHECK(ndr_pull_align(ndr, 5));
1665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1667                 if (_ptr_array) {
1668                         NDR_PULL_ALLOC(ndr, r->array);
1669                 } else {
1670                         r->array = NULL;
1671                 }
1672                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1673         }
1674         if (ndr_flags & NDR_BUFFERS) {
1675                 if (r->array) {
1676                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1677                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1679                         size_array_1 = ndr_get_array_size(ndr, &r->array);
1680                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
1681                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1682                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1683                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1684                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1685                         }
1686                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1687                                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
1688                         }
1689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1691                 }
1692                 if (r->array) {
1693                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1694                 }
1695         }
1696         return NDR_ERR_SUCCESS;
1697 }
1698
1699 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr1 *r)
1700 {
1701         uint32_t cntr_array_1;
1702         ndr_print_struct(ndr, name, "srvsvc_NetConnCtr1");
1703         if (r == NULL) { ndr_print_null(ndr); return; }
1704         ndr->depth++;
1705         ndr_print_uint32(ndr, "count", r->count);
1706         ndr_print_ptr(ndr, "array", r->array);
1707         ndr->depth++;
1708         if (r->array) {
1709                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1710                 ndr->depth++;
1711                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
1712                         ndr_print_srvsvc_NetConnInfo1(ndr, "array", &r->array[cntr_array_1]);
1713                 }
1714                 ndr->depth--;
1715         }
1716         ndr->depth--;
1717         ndr->depth--;
1718 }
1719
1720 static enum ndr_err_code ndr_push_srvsvc_NetConnCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetConnCtr *r)
1721 {
1722         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1723         if (ndr_flags & NDR_SCALARS) {
1724                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1725                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
1727                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1728                 switch (level) {
1729                         case 0: {
1730                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
1731                         break; }
1732
1733                         case 1: {
1734                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
1735                         break; }
1736
1737                         default: {
1738                         break; }
1739
1740                 }
1741         }
1742         if (ndr_flags & NDR_BUFFERS) {
1743                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1744                 switch (level) {
1745                         case 0:
1746                                 if (r->ctr0) {
1747                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1748                                 }
1749                         break;
1750
1751                         case 1:
1752                                 if (r->ctr1) {
1753                                         NDR_CHECK(ndr_push_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1754                                 }
1755                         break;
1756
1757                         default:
1758                         break;
1759
1760                 }
1761         }
1762         return NDR_ERR_SUCCESS;
1763 }
1764
1765 static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetConnCtr *r)
1766 {
1767         uint32_t level;
1768         uint32_t _level;
1769         TALLOC_CTX *_mem_save_ctr0_0;
1770         uint32_t _ptr_ctr0;
1771         TALLOC_CTX *_mem_save_ctr1_0;
1772         uint32_t _ptr_ctr1;
1773         level = ndr_pull_get_switch_value(ndr, r);
1774         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1775         if (ndr_flags & NDR_SCALARS) {
1776                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
1778                 if (_level != level) {
1779                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1780                 }
1781                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1782                 switch (level) {
1783                         case 0: {
1784                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
1785                                 if (_ptr_ctr0) {
1786                                         NDR_PULL_ALLOC(ndr, r->ctr0);
1787                                 } else {
1788                                         r->ctr0 = NULL;
1789                                 }
1790                         break; }
1791
1792                         case 1: {
1793                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
1794                                 if (_ptr_ctr1) {
1795                                         NDR_PULL_ALLOC(ndr, r->ctr1);
1796                                 } else {
1797                                         r->ctr1 = NULL;
1798                                 }
1799                         break; }
1800
1801                         default: {
1802                         break; }
1803
1804                 }
1805         }
1806         if (ndr_flags & NDR_BUFFERS) {
1807                 switch (level) {
1808                         case 0:
1809                                 if (r->ctr0) {
1810                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1811                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
1812                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
1813                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
1814                                 }
1815                         break;
1816
1817                         case 1:
1818                                 if (r->ctr1) {
1819                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1820                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
1821                                         NDR_CHECK(ndr_pull_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
1822                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
1823                                 }
1824                         break;
1825
1826                         default:
1827                         break;
1828
1829                 }
1830         }
1831         return NDR_ERR_SUCCESS;
1832 }
1833
1834 _PUBLIC_ void ndr_print_srvsvc_NetConnCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetConnCtr *r)
1835 {
1836         uint32_t level;
1837         level = ndr_print_get_switch_value(ndr, r);
1838         ndr_print_union(ndr, name, level, "srvsvc_NetConnCtr");
1839         switch (level) {
1840                 case 0:
1841                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
1842                         ndr->depth++;
1843                         if (r->ctr0) {
1844                                 ndr_print_srvsvc_NetConnCtr0(ndr, "ctr0", r->ctr0);
1845                         }
1846                         ndr->depth--;
1847                 break;
1848
1849                 case 1:
1850                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
1851                         ndr->depth++;
1852                         if (r->ctr1) {
1853                                 ndr_print_srvsvc_NetConnCtr1(ndr, "ctr1", r->ctr1);
1854                         }
1855                         ndr->depth--;
1856                 break;
1857
1858                 default:
1859                 break;
1860
1861         }
1862 }
1863
1864 static enum ndr_err_code ndr_push_srvsvc_NetConnInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfoCtr *r)
1865 {
1866         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1867         if (ndr_flags & NDR_SCALARS) {
1868                 NDR_CHECK(ndr_push_align(ndr, 5));
1869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
1870                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
1871                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
1872                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1873         }
1874         if (ndr_flags & NDR_BUFFERS) {
1875                 NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
1876         }
1877         return NDR_ERR_SUCCESS;
1878 }
1879
1880 static enum ndr_err_code ndr_pull_srvsvc_NetConnInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfoCtr *r)
1881 {
1882         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1883         if (ndr_flags & NDR_SCALARS) {
1884                 NDR_CHECK(ndr_pull_align(ndr, 5));
1885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
1886                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
1887                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));
1888                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1889         }
1890         if (ndr_flags & NDR_BUFFERS) {
1891                 NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));
1892         }
1893         return NDR_ERR_SUCCESS;
1894 }
1895
1896 _PUBLIC_ void ndr_print_srvsvc_NetConnInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfoCtr *r)
1897 {
1898         ndr_print_struct(ndr, name, "srvsvc_NetConnInfoCtr");
1899         if (r == NULL) { ndr_print_null(ndr); return; }
1900         ndr->depth++;
1901         ndr_print_uint32(ndr, "level", r->level);
1902         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
1903         ndr_print_srvsvc_NetConnCtr(ndr, "ctr", &r->ctr);
1904         ndr->depth--;
1905 }
1906
1907 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo2 *r)
1908 {
1909         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1910         if (ndr_flags & NDR_SCALARS) {
1911                 NDR_CHECK(ndr_push_align(ndr, 4));
1912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
1913                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1914         }
1915         if (ndr_flags & NDR_BUFFERS) {
1916         }
1917         return NDR_ERR_SUCCESS;
1918 }
1919
1920 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo2 *r)
1921 {
1922         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1923         if (ndr_flags & NDR_SCALARS) {
1924                 NDR_CHECK(ndr_pull_align(ndr, 4));
1925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
1926                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1927         }
1928         if (ndr_flags & NDR_BUFFERS) {
1929         }
1930         return NDR_ERR_SUCCESS;
1931 }
1932
1933 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo2 *r)
1934 {
1935         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo2");
1936         if (r == NULL) { ndr_print_null(ndr); return; }
1937         ndr->depth++;
1938         ndr_print_uint32(ndr, "fid", r->fid);
1939         ndr->depth--;
1940 }
1941
1942 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr2 *r)
1943 {
1944         uint32_t cntr_array_1;
1945         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1946         if (ndr_flags & NDR_SCALARS) {
1947                 NDR_CHECK(ndr_push_align(ndr, 5));
1948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
1950                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1951         }
1952         if (ndr_flags & NDR_BUFFERS) {
1953                 if (r->array) {
1954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1955                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
1956                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1957                         }
1958                 }
1959         }
1960         return NDR_ERR_SUCCESS;
1961 }
1962
1963 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr2 *r)
1964 {
1965         uint32_t _ptr_array;
1966         uint32_t size_array_1 = 0;
1967         uint32_t cntr_array_1;
1968         TALLOC_CTX *_mem_save_array_0;
1969         TALLOC_CTX *_mem_save_array_1;
1970         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1971         if (ndr_flags & NDR_SCALARS) {
1972                 NDR_CHECK(ndr_pull_align(ndr, 5));
1973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
1975                 if (_ptr_array) {
1976                         NDR_PULL_ALLOC(ndr, r->array);
1977                 } else {
1978                         r->array = NULL;
1979                 }
1980                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1981         }
1982         if (ndr_flags & NDR_BUFFERS) {
1983                 if (r->array) {
1984                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1985                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1986                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
1987                         size_array_1 = ndr_get_array_size(ndr, &r->array);
1988                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
1989                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
1990                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1991                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
1992                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
1993                         }
1994                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
1995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1996                 }
1997                 if (r->array) {
1998                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
1999                 }
2000         }
2001         return NDR_ERR_SUCCESS;
2002 }
2003
2004 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr2 *r)
2005 {
2006         uint32_t cntr_array_1;
2007         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr2");
2008         if (r == NULL) { ndr_print_null(ndr); return; }
2009         ndr->depth++;
2010         ndr_print_uint32(ndr, "count", r->count);
2011         ndr_print_ptr(ndr, "array", r->array);
2012         ndr->depth++;
2013         if (r->array) {
2014                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2015                 ndr->depth++;
2016                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2017                         ndr_print_srvsvc_NetFileInfo2(ndr, "array", &r->array[cntr_array_1]);
2018                 }
2019                 ndr->depth--;
2020         }
2021         ndr->depth--;
2022         ndr->depth--;
2023 }
2024
2025 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo3 *r)
2026 {
2027         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2028         if (ndr_flags & NDR_SCALARS) {
2029                 NDR_CHECK(ndr_push_align(ndr, 5));
2030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fid));
2031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
2032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_locks));
2033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
2034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2035                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2036         }
2037         if (ndr_flags & NDR_BUFFERS) {
2038                 if (r->path) {
2039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
2040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2041                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
2042                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2043                 }
2044                 if (r->user) {
2045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2047                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2049                 }
2050         }
2051         return NDR_ERR_SUCCESS;
2052 }
2053
2054 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo3 *r)
2055 {
2056         uint32_t _ptr_path;
2057         uint32_t size_path_1 = 0;
2058         uint32_t length_path_1 = 0;
2059         TALLOC_CTX *_mem_save_path_0;
2060         uint32_t _ptr_user;
2061         uint32_t size_user_1 = 0;
2062         uint32_t length_user_1 = 0;
2063         TALLOC_CTX *_mem_save_user_0;
2064         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2065         if (ndr_flags & NDR_SCALARS) {
2066                 NDR_CHECK(ndr_pull_align(ndr, 5));
2067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fid));
2068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
2069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_locks));
2070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
2071                 if (_ptr_path) {
2072                         NDR_PULL_ALLOC(ndr, r->path);
2073                 } else {
2074                         r->path = NULL;
2075                 }
2076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2077                 if (_ptr_user) {
2078                         NDR_PULL_ALLOC(ndr, r->user);
2079                 } else {
2080                         r->user = NULL;
2081                 }
2082                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2083         }
2084         if (ndr_flags & NDR_BUFFERS) {
2085                 if (r->path) {
2086                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
2087                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
2088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
2089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
2090                         size_path_1 = ndr_get_array_size(ndr, &r->path);
2091                         length_path_1 = ndr_get_array_length(ndr, &r->path);
2092                         if (length_path_1 > size_path_1) {
2093                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
2094                         }
2095                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
2096                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, length_path_1, sizeof(uint16_t), CH_UTF16));
2097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
2098                 }
2099                 if (r->user) {
2100                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2101                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2104                         size_user_1 = ndr_get_array_size(ndr, &r->user);
2105                         length_user_1 = ndr_get_array_length(ndr, &r->user);
2106                         if (length_user_1 > size_user_1) {
2107                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
2108                         }
2109                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
2110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
2111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2112                 }
2113         }
2114         return NDR_ERR_SUCCESS;
2115 }
2116
2117 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo3 *r)
2118 {
2119         ndr_print_struct(ndr, name, "srvsvc_NetFileInfo3");
2120         if (r == NULL) { ndr_print_null(ndr); return; }
2121         ndr->depth++;
2122         ndr_print_uint32(ndr, "fid", r->fid);
2123         ndr_print_uint32(ndr, "permissions", r->permissions);
2124         ndr_print_uint32(ndr, "num_locks", r->num_locks);
2125         ndr_print_ptr(ndr, "path", r->path);
2126         ndr->depth++;
2127         if (r->path) {
2128                 ndr_print_string(ndr, "path", r->path);
2129         }
2130         ndr->depth--;
2131         ndr_print_ptr(ndr, "user", r->user);
2132         ndr->depth++;
2133         if (r->user) {
2134                 ndr_print_string(ndr, "user", r->user);
2135         }
2136         ndr->depth--;
2137         ndr->depth--;
2138 }
2139
2140 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr3 *r)
2141 {
2142         uint32_t cntr_array_1;
2143         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2144         if (ndr_flags & NDR_SCALARS) {
2145                 NDR_CHECK(ndr_push_align(ndr, 5));
2146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2148                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2149         }
2150         if (ndr_flags & NDR_BUFFERS) {
2151                 if (r->array) {
2152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2153                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2154                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2155                         }
2156                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2157                                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2158                         }
2159                 }
2160         }
2161         return NDR_ERR_SUCCESS;
2162 }
2163
2164 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr3 *r)
2165 {
2166         uint32_t _ptr_array;
2167         uint32_t size_array_1 = 0;
2168         uint32_t cntr_array_1;
2169         TALLOC_CTX *_mem_save_array_0;
2170         TALLOC_CTX *_mem_save_array_1;
2171         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2172         if (ndr_flags & NDR_SCALARS) {
2173                 NDR_CHECK(ndr_pull_align(ndr, 5));
2174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2176                 if (_ptr_array) {
2177                         NDR_PULL_ALLOC(ndr, r->array);
2178                 } else {
2179                         r->array = NULL;
2180                 }
2181                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2182         }
2183         if (ndr_flags & NDR_BUFFERS) {
2184                 if (r->array) {
2185                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2186                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2188                         size_array_1 = ndr_get_array_size(ndr, &r->array);
2189                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
2190                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2191                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2192                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2193                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2194                         }
2195                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2196                                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2197                         }
2198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2200                 }
2201                 if (r->array) {
2202                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2203                 }
2204         }
2205         return NDR_ERR_SUCCESS;
2206 }
2207
2208 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr3 *r)
2209 {
2210         uint32_t cntr_array_1;
2211         ndr_print_struct(ndr, name, "srvsvc_NetFileCtr3");
2212         if (r == NULL) { ndr_print_null(ndr); return; }
2213         ndr->depth++;
2214         ndr_print_uint32(ndr, "count", r->count);
2215         ndr_print_ptr(ndr, "array", r->array);
2216         ndr->depth++;
2217         if (r->array) {
2218                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2219                 ndr->depth++;
2220                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2221                         ndr_print_srvsvc_NetFileInfo3(ndr, "array", &r->array[cntr_array_1]);
2222                 }
2223                 ndr->depth--;
2224         }
2225         ndr->depth--;
2226         ndr->depth--;
2227 }
2228
2229 static enum ndr_err_code ndr_push_srvsvc_NetFileInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileInfo *r)
2230 {
2231         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2232         if (ndr_flags & NDR_SCALARS) {
2233                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2234                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2236                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2237                 switch (level) {
2238                         case 2: {
2239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
2240                         break; }
2241
2242                         case 3: {
2243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
2244                         break; }
2245
2246                         default: {
2247                         break; }
2248
2249                 }
2250         }
2251         if (ndr_flags & NDR_BUFFERS) {
2252                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2253                 switch (level) {
2254                         case 2:
2255                                 if (r->info2) {
2256                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
2257                                 }
2258                         break;
2259
2260                         case 3:
2261                                 if (r->info3) {
2262                                         NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2263                                 }
2264                         break;
2265
2266                         default:
2267                         break;
2268
2269                 }
2270         }
2271         return NDR_ERR_SUCCESS;
2272 }
2273
2274 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileInfo *r)
2275 {
2276         uint32_t level;
2277         uint32_t _level;
2278         TALLOC_CTX *_mem_save_info2_0;
2279         uint32_t _ptr_info2;
2280         TALLOC_CTX *_mem_save_info3_0;
2281         uint32_t _ptr_info3;
2282         level = ndr_pull_get_switch_value(ndr, r);
2283         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2284         if (ndr_flags & NDR_SCALARS) {
2285                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2287                 if (_level != level) {
2288                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
2289                 }
2290                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2291                 switch (level) {
2292                         case 2: {
2293                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
2294                                 if (_ptr_info2) {
2295                                         NDR_PULL_ALLOC(ndr, r->info2);
2296                                 } else {
2297                                         r->info2 = NULL;
2298                                 }
2299                         break; }
2300
2301                         case 3: {
2302                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
2303                                 if (_ptr_info3) {
2304                                         NDR_PULL_ALLOC(ndr, r->info3);
2305                                 } else {
2306                                         r->info3 = NULL;
2307                                 }
2308                         break; }
2309
2310                         default: {
2311                         break; }
2312
2313                 }
2314         }
2315         if (ndr_flags & NDR_BUFFERS) {
2316                 switch (level) {
2317                         case 2:
2318                                 if (r->info2) {
2319                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2320                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
2321                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));
2322                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
2323                                 }
2324                         break;
2325
2326                         case 3:
2327                                 if (r->info3) {
2328                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2329                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
2330                                         NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2331                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
2332                                 }
2333                         break;
2334
2335                         default:
2336                         break;
2337
2338                 }
2339         }
2340         return NDR_ERR_SUCCESS;
2341 }
2342
2343 _PUBLIC_ void ndr_print_srvsvc_NetFileInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileInfo *r)
2344 {
2345         uint32_t level;
2346         level = ndr_print_get_switch_value(ndr, r);
2347         ndr_print_union(ndr, name, level, "srvsvc_NetFileInfo");
2348         switch (level) {
2349                 case 2:
2350                         ndr_print_ptr(ndr, "info2", r->info2);
2351                         ndr->depth++;
2352                         if (r->info2) {
2353                                 ndr_print_srvsvc_NetFileInfo2(ndr, "info2", r->info2);
2354                         }
2355                         ndr->depth--;
2356                 break;
2357
2358                 case 3:
2359                         ndr_print_ptr(ndr, "info3", r->info3);
2360                         ndr->depth++;
2361                         if (r->info3) {
2362                                 ndr_print_srvsvc_NetFileInfo3(ndr, "info3", r->info3);
2363                         }
2364                         ndr->depth--;
2365                 break;
2366
2367                 default:
2368                 break;
2369
2370         }
2371 }
2372
2373 static enum ndr_err_code ndr_push_srvsvc_NetFileCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileCtr *r)
2374 {
2375         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2376         if (ndr_flags & NDR_SCALARS) {
2377                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2378                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2380                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2381                 switch (level) {
2382                         case 2: {
2383                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
2384                         break; }
2385
2386                         case 3: {
2387                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
2388                         break; }
2389
2390                         default: {
2391                         break; }
2392
2393                 }
2394         }
2395         if (ndr_flags & NDR_BUFFERS) {
2396                 uint32_t level = ndr_push_get_switch_value(ndr, r);
2397                 switch (level) {
2398                         case 2:
2399                                 if (r->ctr2) {
2400                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2401                                 }
2402                         break;
2403
2404                         case 3:
2405                                 if (r->ctr3) {
2406                                         NDR_CHECK(ndr_push_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2407                                 }
2408                         break;
2409
2410                         default:
2411                         break;
2412
2413                 }
2414         }
2415         return NDR_ERR_SUCCESS;
2416 }
2417
2418 static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileCtr *r)
2419 {
2420         uint32_t level;
2421         uint32_t _level;
2422         TALLOC_CTX *_mem_save_ctr2_0;
2423         uint32_t _ptr_ctr2;
2424         TALLOC_CTX *_mem_save_ctr3_0;
2425         uint32_t _ptr_ctr3;
2426         level = ndr_pull_get_switch_value(ndr, r);
2427         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2428         if (ndr_flags & NDR_SCALARS) {
2429                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
2431                 if (_level != level) {
2432                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
2433                 }
2434                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2435                 switch (level) {
2436                         case 2: {
2437                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
2438                                 if (_ptr_ctr2) {
2439                                         NDR_PULL_ALLOC(ndr, r->ctr2);
2440                                 } else {
2441                                         r->ctr2 = NULL;
2442                                 }
2443                         break; }
2444
2445                         case 3: {
2446                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
2447                                 if (_ptr_ctr3) {
2448                                         NDR_PULL_ALLOC(ndr, r->ctr3);
2449                                 } else {
2450                                         r->ctr3 = NULL;
2451                                 }
2452                         break; }
2453
2454                         default: {
2455                         break; }
2456
2457                 }
2458         }
2459         if (ndr_flags & NDR_BUFFERS) {
2460                 switch (level) {
2461                         case 2:
2462                                 if (r->ctr2) {
2463                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
2464                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
2465                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
2466                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
2467                                 }
2468                         break;
2469
2470                         case 3:
2471                                 if (r->ctr3) {
2472                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
2473                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
2474                                         NDR_CHECK(ndr_pull_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
2475                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
2476                                 }
2477                         break;
2478
2479                         default:
2480                         break;
2481
2482                 }
2483         }
2484         return NDR_ERR_SUCCESS;
2485 }
2486
2487 _PUBLIC_ void ndr_print_srvsvc_NetFileCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileCtr *r)
2488 {
2489         uint32_t level;
2490         level = ndr_print_get_switch_value(ndr, r);
2491         ndr_print_union(ndr, name, level, "srvsvc_NetFileCtr");
2492         switch (level) {
2493                 case 2:
2494                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
2495                         ndr->depth++;
2496                         if (r->ctr2) {
2497                                 ndr_print_srvsvc_NetFileCtr2(ndr, "ctr2", r->ctr2);
2498                         }
2499                         ndr->depth--;
2500                 break;
2501
2502                 case 3:
2503                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
2504                         ndr->depth++;
2505                         if (r->ctr3) {
2506                                 ndr_print_srvsvc_NetFileCtr3(ndr, "ctr3", r->ctr3);
2507                         }
2508                         ndr->depth--;
2509                 break;
2510
2511                 default:
2512                 break;
2513
2514         }
2515 }
2516
2517 static enum ndr_err_code ndr_push_srvsvc_NetFileInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfoCtr *r)
2518 {
2519         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2520         if (ndr_flags & NDR_SCALARS) {
2521                 NDR_CHECK(ndr_push_align(ndr, 5));
2522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2523                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
2524                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
2525                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
2529         }
2530         return NDR_ERR_SUCCESS;
2531 }
2532
2533 static enum ndr_err_code ndr_pull_srvsvc_NetFileInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfoCtr *r)
2534 {
2535         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2536         if (ndr_flags & NDR_SCALARS) {
2537                 NDR_CHECK(ndr_pull_align(ndr, 5));
2538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
2539                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
2540                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));
2541                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2542         }
2543         if (ndr_flags & NDR_BUFFERS) {
2544                 NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));
2545         }
2546         return NDR_ERR_SUCCESS;
2547 }
2548
2549 _PUBLIC_ void ndr_print_srvsvc_NetFileInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfoCtr *r)
2550 {
2551         ndr_print_struct(ndr, name, "srvsvc_NetFileInfoCtr");
2552         if (r == NULL) { ndr_print_null(ndr); return; }
2553         ndr->depth++;
2554         ndr_print_uint32(ndr, "level", r->level);
2555         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
2556         ndr_print_srvsvc_NetFileCtr(ndr, "ctr", &r->ctr);
2557         ndr->depth--;
2558 }
2559
2560 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo0 *r)
2561 {
2562         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2563         if (ndr_flags & NDR_SCALARS) {
2564                 NDR_CHECK(ndr_push_align(ndr, 5));
2565                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2566                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2567         }
2568         if (ndr_flags & NDR_BUFFERS) {
2569                 if (r->client) {
2570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2571                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2574                 }
2575         }
2576         return NDR_ERR_SUCCESS;
2577 }
2578
2579 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo0 *r)
2580 {
2581         uint32_t _ptr_client;
2582         uint32_t size_client_1 = 0;
2583         uint32_t length_client_1 = 0;
2584         TALLOC_CTX *_mem_save_client_0;
2585         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2586         if (ndr_flags & NDR_SCALARS) {
2587                 NDR_CHECK(ndr_pull_align(ndr, 5));
2588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2589                 if (_ptr_client) {
2590                         NDR_PULL_ALLOC(ndr, r->client);
2591                 } else {
2592                         r->client = NULL;
2593                 }
2594                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2595         }
2596         if (ndr_flags & NDR_BUFFERS) {
2597                 if (r->client) {
2598                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2599                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2601                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2602                         size_client_1 = ndr_get_array_size(ndr, &r->client);
2603                         length_client_1 = ndr_get_array_length(ndr, &r->client);
2604                         if (length_client_1 > size_client_1) {
2605                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
2606                         }
2607                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
2608                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
2609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2610                 }
2611         }
2612         return NDR_ERR_SUCCESS;
2613 }
2614
2615 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo0 *r)
2616 {
2617         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo0");
2618         if (r == NULL) { ndr_print_null(ndr); return; }
2619         ndr->depth++;
2620         ndr_print_ptr(ndr, "client", r->client);
2621         ndr->depth++;
2622         if (r->client) {
2623                 ndr_print_string(ndr, "client", r->client);
2624         }
2625         ndr->depth--;
2626         ndr->depth--;
2627 }
2628
2629 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr0 *r)
2630 {
2631         uint32_t cntr_array_1;
2632         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2633         if (ndr_flags & NDR_SCALARS) {
2634                 NDR_CHECK(ndr_push_align(ndr, 5));
2635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2637                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2638         }
2639         if (ndr_flags & NDR_BUFFERS) {
2640                 if (r->array) {
2641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2642                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2643                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2644                         }
2645                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2646                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2647                         }
2648                 }
2649         }
2650         return NDR_ERR_SUCCESS;
2651 }
2652
2653 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr0 *r)
2654 {
2655         uint32_t _ptr_array;
2656         uint32_t size_array_1 = 0;
2657         uint32_t cntr_array_1;
2658         TALLOC_CTX *_mem_save_array_0;
2659         TALLOC_CTX *_mem_save_array_1;
2660         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2661         if (ndr_flags & NDR_SCALARS) {
2662                 NDR_CHECK(ndr_pull_align(ndr, 5));
2663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2665                 if (_ptr_array) {
2666                         NDR_PULL_ALLOC(ndr, r->array);
2667                 } else {
2668                         r->array = NULL;
2669                 }
2670                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2671         }
2672         if (ndr_flags & NDR_BUFFERS) {
2673                 if (r->array) {
2674                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2675                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2677                         size_array_1 = ndr_get_array_size(ndr, &r->array);
2678                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
2679                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2680                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2681                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2682                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2683                         }
2684                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2685                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2686                         }
2687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2689                 }
2690                 if (r->array) {
2691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2692                 }
2693         }
2694         return NDR_ERR_SUCCESS;
2695 }
2696
2697 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr0 *r)
2698 {
2699         uint32_t cntr_array_1;
2700         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr0");
2701         if (r == NULL) { ndr_print_null(ndr); return; }
2702         ndr->depth++;
2703         ndr_print_uint32(ndr, "count", r->count);
2704         ndr_print_ptr(ndr, "array", r->array);
2705         ndr->depth++;
2706         if (r->array) {
2707                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2708                 ndr->depth++;
2709                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2710                         ndr_print_srvsvc_NetSessInfo0(ndr, "array", &r->array[cntr_array_1]);
2711                 }
2712                 ndr->depth--;
2713         }
2714         ndr->depth--;
2715         ndr->depth--;
2716 }
2717
2718 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo1 *r)
2719 {
2720         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2721         if (ndr_flags & NDR_SCALARS) {
2722                 NDR_CHECK(ndr_push_align(ndr, 5));
2723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2729                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2730         }
2731         if (ndr_flags & NDR_BUFFERS) {
2732                 if (r->client) {
2733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2737                 }
2738                 if (r->user) {
2739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2743                 }
2744         }
2745         return NDR_ERR_SUCCESS;
2746 }
2747
2748 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo1 *r)
2749 {
2750         uint32_t _ptr_client;
2751         uint32_t size_client_1 = 0;
2752         uint32_t length_client_1 = 0;
2753         TALLOC_CTX *_mem_save_client_0;
2754         uint32_t _ptr_user;
2755         uint32_t size_user_1 = 0;
2756         uint32_t length_user_1 = 0;
2757         TALLOC_CTX *_mem_save_user_0;
2758         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2762                 if (_ptr_client) {
2763                         NDR_PULL_ALLOC(ndr, r->client);
2764                 } else {
2765                         r->client = NULL;
2766                 }
2767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2768                 if (_ptr_user) {
2769                         NDR_PULL_ALLOC(ndr, r->user);
2770                 } else {
2771                         r->user = NULL;
2772                 }
2773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2777                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2778         }
2779         if (ndr_flags & NDR_BUFFERS) {
2780                 if (r->client) {
2781                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
2782                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
2783                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
2784                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
2785                         size_client_1 = ndr_get_array_size(ndr, &r->client);
2786                         length_client_1 = ndr_get_array_length(ndr, &r->client);
2787                         if (length_client_1 > size_client_1) {
2788                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
2789                         }
2790                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
2791                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
2792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
2793                 }
2794                 if (r->user) {
2795                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
2796                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
2797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
2798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
2799                         size_user_1 = ndr_get_array_size(ndr, &r->user);
2800                         length_user_1 = ndr_get_array_length(ndr, &r->user);
2801                         if (length_user_1 > size_user_1) {
2802                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
2803                         }
2804                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
2805                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
2806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
2807                 }
2808         }
2809         return NDR_ERR_SUCCESS;
2810 }
2811
2812 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo1 *r)
2813 {
2814         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo1");
2815         if (r == NULL) { ndr_print_null(ndr); return; }
2816         ndr->depth++;
2817         ndr_print_ptr(ndr, "client", r->client);
2818         ndr->depth++;
2819         if (r->client) {
2820                 ndr_print_string(ndr, "client", r->client);
2821         }
2822         ndr->depth--;
2823         ndr_print_ptr(ndr, "user", r->user);
2824         ndr->depth++;
2825         if (r->user) {
2826                 ndr_print_string(ndr, "user", r->user);
2827         }
2828         ndr->depth--;
2829         ndr_print_uint32(ndr, "num_open", r->num_open);
2830         ndr_print_uint32(ndr, "time", r->time);
2831         ndr_print_uint32(ndr, "idle_time", r->idle_time);
2832         ndr_print_uint32(ndr, "user_flags", r->user_flags);
2833         ndr->depth--;
2834 }
2835
2836 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr1 *r)
2837 {
2838         uint32_t cntr_array_1;
2839         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2840         if (ndr_flags & NDR_SCALARS) {
2841                 NDR_CHECK(ndr_push_align(ndr, 5));
2842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
2844                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2845         }
2846         if (ndr_flags & NDR_BUFFERS) {
2847                 if (r->array) {
2848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2849                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2850                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2851                         }
2852                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
2853                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2854                         }
2855                 }
2856         }
2857         return NDR_ERR_SUCCESS;
2858 }
2859
2860 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr1 *r)
2861 {
2862         uint32_t _ptr_array;
2863         uint32_t size_array_1 = 0;
2864         uint32_t cntr_array_1;
2865         TALLOC_CTX *_mem_save_array_0;
2866         TALLOC_CTX *_mem_save_array_1;
2867         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2868         if (ndr_flags & NDR_SCALARS) {
2869                 NDR_CHECK(ndr_pull_align(ndr, 5));
2870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2871                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
2872                 if (_ptr_array) {
2873                         NDR_PULL_ALLOC(ndr, r->array);
2874                 } else {
2875                         r->array = NULL;
2876                 }
2877                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2878         }
2879         if (ndr_flags & NDR_BUFFERS) {
2880                 if (r->array) {
2881                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
2882                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
2884                         size_array_1 = ndr_get_array_size(ndr, &r->array);
2885                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
2886                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
2887                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
2888                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2889                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
2890                         }
2891                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
2892                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
2893                         }
2894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
2895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
2896                 }
2897                 if (r->array) {
2898                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
2899                 }
2900         }
2901         return NDR_ERR_SUCCESS;
2902 }
2903
2904 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr1 *r)
2905 {
2906         uint32_t cntr_array_1;
2907         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr1");
2908         if (r == NULL) { ndr_print_null(ndr); return; }
2909         ndr->depth++;
2910         ndr_print_uint32(ndr, "count", r->count);
2911         ndr_print_ptr(ndr, "array", r->array);
2912         ndr->depth++;
2913         if (r->array) {
2914                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
2915                 ndr->depth++;
2916                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
2917                         ndr_print_srvsvc_NetSessInfo1(ndr, "array", &r->array[cntr_array_1]);
2918                 }
2919                 ndr->depth--;
2920         }
2921         ndr->depth--;
2922         ndr->depth--;
2923 }
2924
2925 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo2 *r)
2926 {
2927         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2928         if (ndr_flags & NDR_SCALARS) {
2929                 NDR_CHECK(ndr_push_align(ndr, 5));
2930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
2931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
2932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
2933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
2935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
2936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
2937                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2938         }
2939         if (ndr_flags & NDR_BUFFERS) {
2940                 if (r->client) {
2941                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
2944                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2945                 }
2946                 if (r->user) {
2947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
2950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2951                 }
2952                 if (r->client_type) {
2953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
2956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2957                 }
2958         }
2959         return NDR_ERR_SUCCESS;
2960 }
2961
2962 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo2 *r)
2963 {
2964         uint32_t _ptr_client;
2965         uint32_t size_client_1 = 0;
2966         uint32_t length_client_1 = 0;
2967         TALLOC_CTX *_mem_save_client_0;
2968         uint32_t _ptr_user;
2969         uint32_t size_user_1 = 0;
2970         uint32_t length_user_1 = 0;
2971         TALLOC_CTX *_mem_save_user_0;
2972         uint32_t _ptr_client_type;
2973         uint32_t size_client_type_1 = 0;
2974         uint32_t length_client_type_1 = 0;
2975         TALLOC_CTX *_mem_save_client_type_0;
2976         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2977         if (ndr_flags & NDR_SCALARS) {
2978                 NDR_CHECK(ndr_pull_align(ndr, 5));
2979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
2980                 if (_ptr_client) {
2981                         NDR_PULL_ALLOC(ndr, r->client);
2982                 } else {
2983                         r->client = NULL;
2984                 }
2985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
2986                 if (_ptr_user) {
2987                         NDR_PULL_ALLOC(ndr, r->user);
2988                 } else {
2989                         r->user = NULL;
2990                 }
2991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
2992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
2993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
2994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
2995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
2996                 if (_ptr_client_type) {
2997                         NDR_PULL_ALLOC(ndr, r->client_type);
2998                 } else {
2999                         r->client_type = NULL;
3000                 }
3001                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
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                         size_client_1 = ndr_get_array_size(ndr, &r->client);
3010                         length_client_1 = ndr_get_array_length(ndr, &r->client);
3011                         if (length_client_1 > size_client_1) {
3012                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
3013                         }
3014                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
3015                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
3016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3017                 }
3018                 if (r->user) {
3019                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3020                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3021                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3022                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3023                         size_user_1 = ndr_get_array_size(ndr, &r->user);
3024                         length_user_1 = ndr_get_array_length(ndr, &r->user);
3025                         if (length_user_1 > size_user_1) {
3026                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
3027                         }
3028                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
3029                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
3030                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3031                 }
3032                 if (r->client_type) {
3033                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3034                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
3035                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
3036                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
3037                         size_client_type_1 = ndr_get_array_size(ndr, &r->client_type);
3038                         length_client_type_1 = ndr_get_array_length(ndr, &r->client_type);
3039                         if (length_client_type_1 > size_client_type_1) {
3040                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_type_1, length_client_type_1);
3041                         }
3042                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_type_1, sizeof(uint16_t)));
3043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, length_client_type_1, sizeof(uint16_t), CH_UTF16));
3044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
3045                 }
3046         }
3047         return NDR_ERR_SUCCESS;
3048 }
3049
3050 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo2 *r)
3051 {
3052         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo2");
3053         if (r == NULL) { ndr_print_null(ndr); return; }
3054         ndr->depth++;
3055         ndr_print_ptr(ndr, "client", r->client);
3056         ndr->depth++;
3057         if (r->client) {
3058                 ndr_print_string(ndr, "client", r->client);
3059         }
3060         ndr->depth--;
3061         ndr_print_ptr(ndr, "user", r->user);
3062         ndr->depth++;
3063         if (r->user) {
3064                 ndr_print_string(ndr, "user", r->user);
3065         }
3066         ndr->depth--;
3067         ndr_print_uint32(ndr, "num_open", r->num_open);
3068         ndr_print_uint32(ndr, "time", r->time);
3069         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3070         ndr_print_uint32(ndr, "user_flags", r->user_flags);
3071         ndr_print_ptr(ndr, "client_type", r->client_type);
3072         ndr->depth++;
3073         if (r->client_type) {
3074                 ndr_print_string(ndr, "client_type", r->client_type);
3075         }
3076         ndr->depth--;
3077         ndr->depth--;
3078 }
3079
3080 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr2 *r)
3081 {
3082         uint32_t cntr_array_1;
3083         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3084         if (ndr_flags & NDR_SCALARS) {
3085                 NDR_CHECK(ndr_push_align(ndr, 5));
3086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3088                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3089         }
3090         if (ndr_flags & NDR_BUFFERS) {
3091                 if (r->array) {
3092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3093                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3094                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3095                         }
3096                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3097                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3098                         }
3099                 }
3100         }
3101         return NDR_ERR_SUCCESS;
3102 }
3103
3104 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr2 *r)
3105 {
3106         uint32_t _ptr_array;
3107         uint32_t size_array_1 = 0;
3108         uint32_t cntr_array_1;
3109         TALLOC_CTX *_mem_save_array_0;
3110         TALLOC_CTX *_mem_save_array_1;
3111         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3112         if (ndr_flags & NDR_SCALARS) {
3113                 NDR_CHECK(ndr_pull_align(ndr, 5));
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3116                 if (_ptr_array) {
3117                         NDR_PULL_ALLOC(ndr, r->array);
3118                 } else {
3119                         r->array = NULL;
3120                 }
3121                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3122         }
3123         if (ndr_flags & NDR_BUFFERS) {
3124                 if (r->array) {
3125                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3126                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3127                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3128                         size_array_1 = ndr_get_array_size(ndr, &r->array);
3129                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
3130                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3131                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3132                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3133                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3134                         }
3135                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3136                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3137                         }
3138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3140                 }
3141                 if (r->array) {
3142                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3143                 }
3144         }
3145         return NDR_ERR_SUCCESS;
3146 }
3147
3148 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr2 *r)
3149 {
3150         uint32_t cntr_array_1;
3151         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr2");
3152         if (r == NULL) { ndr_print_null(ndr); return; }
3153         ndr->depth++;
3154         ndr_print_uint32(ndr, "count", r->count);
3155         ndr_print_ptr(ndr, "array", r->array);
3156         ndr->depth++;
3157         if (r->array) {
3158                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3159                 ndr->depth++;
3160                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3161                         ndr_print_srvsvc_NetSessInfo2(ndr, "array", &r->array[cntr_array_1]);
3162                 }
3163                 ndr->depth--;
3164         }
3165         ndr->depth--;
3166         ndr->depth--;
3167 }
3168
3169 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo10 *r)
3170 {
3171         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3172         if (ndr_flags & NDR_SCALARS) {
3173                 NDR_CHECK(ndr_push_align(ndr, 5));
3174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
3175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
3176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
3178                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3179         }
3180         if (ndr_flags & NDR_BUFFERS) {
3181                 if (r->client) {
3182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3185                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3186                 }
3187                 if (r->user) {
3188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3192                 }
3193         }
3194         return NDR_ERR_SUCCESS;
3195 }
3196
3197 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo10 *r)
3198 {
3199         uint32_t _ptr_client;
3200         uint32_t size_client_1 = 0;
3201         uint32_t length_client_1 = 0;
3202         TALLOC_CTX *_mem_save_client_0;
3203         uint32_t _ptr_user;
3204         uint32_t size_user_1 = 0;
3205         uint32_t length_user_1 = 0;
3206         TALLOC_CTX *_mem_save_user_0;
3207         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3208         if (ndr_flags & NDR_SCALARS) {
3209                 NDR_CHECK(ndr_pull_align(ndr, 5));
3210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
3211                 if (_ptr_client) {
3212                         NDR_PULL_ALLOC(ndr, r->client);
3213                 } else {
3214                         r->client = NULL;
3215                 }
3216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
3217                 if (_ptr_user) {
3218                         NDR_PULL_ALLOC(ndr, r->user);
3219                 } else {
3220                         r->user = NULL;
3221                 }
3222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
3224                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3225         }
3226         if (ndr_flags & NDR_BUFFERS) {
3227                 if (r->client) {
3228                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
3229                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
3230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
3231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
3232                         size_client_1 = ndr_get_array_size(ndr, &r->client);
3233                         length_client_1 = ndr_get_array_length(ndr, &r->client);
3234                         if (length_client_1 > size_client_1) {
3235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
3236                         }
3237                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
3238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
3239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3240                 }
3241                 if (r->user) {
3242                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3243                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3246                         size_user_1 = ndr_get_array_size(ndr, &r->user);
3247                         length_user_1 = ndr_get_array_length(ndr, &r->user);
3248                         if (length_user_1 > size_user_1) {
3249                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
3250                         }
3251                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
3252                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
3253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3254                 }
3255         }
3256         return NDR_ERR_SUCCESS;
3257 }
3258
3259 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo10 *r)
3260 {
3261         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo10");
3262         if (r == NULL) { ndr_print_null(ndr); return; }
3263         ndr->depth++;
3264         ndr_print_ptr(ndr, "client", r->client);
3265         ndr->depth++;
3266         if (r->client) {
3267                 ndr_print_string(ndr, "client", r->client);
3268         }
3269         ndr->depth--;
3270         ndr_print_ptr(ndr, "user", r->user);
3271         ndr->depth++;
3272         if (r->user) {
3273                 ndr_print_string(ndr, "user", r->user);
3274         }
3275         ndr->depth--;
3276         ndr_print_uint32(ndr, "time", r->time);
3277         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3278         ndr->depth--;
3279 }
3280
3281 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr10 *r)
3282 {
3283         uint32_t cntr_array_1;
3284         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3285         if (ndr_flags & NDR_SCALARS) {
3286                 NDR_CHECK(ndr_push_align(ndr, 5));
3287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3289                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3290         }
3291         if (ndr_flags & NDR_BUFFERS) {
3292                 if (r->array) {
3293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3294                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3295                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3296                         }
3297                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3298                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3299                         }
3300                 }
3301         }
3302         return NDR_ERR_SUCCESS;
3303 }
3304
3305 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr10 *r)
3306 {
3307         uint32_t _ptr_array;
3308         uint32_t size_array_1 = 0;
3309         uint32_t cntr_array_1;
3310         TALLOC_CTX *_mem_save_array_0;
3311         TALLOC_CTX *_mem_save_array_1;
3312         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3313         if (ndr_flags & NDR_SCALARS) {
3314                 NDR_CHECK(ndr_pull_align(ndr, 5));
3315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3317                 if (_ptr_array) {
3318                         NDR_PULL_ALLOC(ndr, r->array);
3319                 } else {
3320                         r->array = NULL;
3321                 }
3322                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3323         }
3324         if (ndr_flags & NDR_BUFFERS) {
3325                 if (r->array) {
3326                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3327                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3329                         size_array_1 = ndr_get_array_size(ndr, &r->array);
3330                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
3331                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3332                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3333                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3334                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3335                         }
3336                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3337                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3338                         }
3339                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3341                 }
3342                 if (r->array) {
3343                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3344                 }
3345         }
3346         return NDR_ERR_SUCCESS;
3347 }
3348
3349 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr10 *r)
3350 {
3351         uint32_t cntr_array_1;
3352         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr10");
3353         if (r == NULL) { ndr_print_null(ndr); return; }
3354         ndr->depth++;
3355         ndr_print_uint32(ndr, "count", r->count);
3356         ndr_print_ptr(ndr, "array", r->array);
3357         ndr->depth++;
3358         if (r->array) {
3359                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3360                 ndr->depth++;
3361                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3362                         ndr_print_srvsvc_NetSessInfo10(ndr, "array", &r->array[cntr_array_1]);
3363                 }
3364                 ndr->depth--;
3365         }
3366         ndr->depth--;
3367         ndr->depth--;
3368 }
3369
3370 static enum ndr_err_code ndr_push_srvsvc_NetSessInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo502 *r)
3371 {
3372         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3373         if (ndr_flags & NDR_SCALARS) {
3374                 NDR_CHECK(ndr_push_align(ndr, 5));
3375                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
3376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
3377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_open));
3378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idle_time));
3380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->user_flags));
3381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_type));
3382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport));
3383                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 if (r->client) {
3387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
3390                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3391                 }
3392                 if (r->user) {
3393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3395                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
3396                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3397                 }
3398                 if (r->client_type) {
3399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));
3402                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_type, ndr_charset_length(r->client_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3403                 }
3404                 if (r->transport) {
3405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3407                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));
3408                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->transport, ndr_charset_length(r->transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3409                 }
3410         }
3411         return NDR_ERR_SUCCESS;
3412 }
3413
3414 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo502 *r)
3415 {
3416         uint32_t _ptr_client;
3417         uint32_t size_client_1 = 0;
3418         uint32_t length_client_1 = 0;
3419         TALLOC_CTX *_mem_save_client_0;
3420         uint32_t _ptr_user;
3421         uint32_t size_user_1 = 0;
3422         uint32_t length_user_1 = 0;
3423         TALLOC_CTX *_mem_save_user_0;
3424         uint32_t _ptr_client_type;
3425         uint32_t size_client_type_1 = 0;
3426         uint32_t length_client_type_1 = 0;
3427         TALLOC_CTX *_mem_save_client_type_0;
3428         uint32_t _ptr_transport;
3429         uint32_t size_transport_1 = 0;
3430         uint32_t length_transport_1 = 0;
3431         TALLOC_CTX *_mem_save_transport_0;
3432         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3433         if (ndr_flags & NDR_SCALARS) {
3434                 NDR_CHECK(ndr_pull_align(ndr, 5));
3435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
3436                 if (_ptr_client) {
3437                         NDR_PULL_ALLOC(ndr, r->client);
3438                 } else {
3439                         r->client = NULL;
3440                 }
3441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
3442                 if (_ptr_user) {
3443                         NDR_PULL_ALLOC(ndr, r->user);
3444                 } else {
3445                         r->user = NULL;
3446                 }
3447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_open));
3448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idle_time));
3450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->user_flags));
3451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));
3452                 if (_ptr_client_type) {
3453                         NDR_PULL_ALLOC(ndr, r->client_type);
3454                 } else {
3455                         r->client_type = NULL;
3456                 }
3457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
3458                 if (_ptr_transport) {
3459                         NDR_PULL_ALLOC(ndr, r->transport);
3460                 } else {
3461                         r->transport = NULL;
3462                 }
3463                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3464         }
3465         if (ndr_flags & NDR_BUFFERS) {
3466                 if (r->client) {
3467                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
3468                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
3469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
3470                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
3471                         size_client_1 = ndr_get_array_size(ndr, &r->client);
3472                         length_client_1 = ndr_get_array_length(ndr, &r->client);
3473                         if (length_client_1 > size_client_1) {
3474                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
3475                         }
3476                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
3477                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, length_client_1, sizeof(uint16_t), CH_UTF16));
3478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
3479                 }
3480                 if (r->user) {
3481                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
3482                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
3483                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
3484                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
3485                         size_user_1 = ndr_get_array_size(ndr, &r->user);
3486                         length_user_1 = ndr_get_array_length(ndr, &r->user);
3487                         if (length_user_1 > size_user_1) {
3488                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
3489                         }
3490                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
3491                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, length_user_1, sizeof(uint16_t), CH_UTF16));
3492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
3493                 }
3494                 if (r->client_type) {
3495                         _mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3496                         NDR_PULL_SET_MEM_CTX(ndr, r->client_type, 0);
3497                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_type));
3498                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_type));
3499                         size_client_type_1 = ndr_get_array_size(ndr, &r->client_type);
3500                         length_client_type_1 = ndr_get_array_length(ndr, &r->client_type);
3501                         if (length_client_type_1 > size_client_type_1) {
3502                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_type_1, length_client_type_1);
3503                         }
3504                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_type_1, sizeof(uint16_t)));
3505                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_type, length_client_type_1, sizeof(uint16_t), CH_UTF16));
3506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);
3507                 }
3508                 if (r->transport) {
3509                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
3510                         NDR_PULL_SET_MEM_CTX(ndr, r->transport, 0);
3511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport));
3512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport));
3513                         size_transport_1 = ndr_get_array_size(ndr, &r->transport);
3514                         length_transport_1 = ndr_get_array_length(ndr, &r->transport);
3515                         if (length_transport_1 > size_transport_1) {
3516                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_transport_1, length_transport_1);
3517                         }
3518                         NDR_CHECK(ndr_check_string_terminator(ndr, length_transport_1, sizeof(uint16_t)));
3519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport, length_transport_1, sizeof(uint16_t), CH_UTF16));
3520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
3521                 }
3522         }
3523         return NDR_ERR_SUCCESS;
3524 }
3525
3526 _PUBLIC_ void ndr_print_srvsvc_NetSessInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo502 *r)
3527 {
3528         ndr_print_struct(ndr, name, "srvsvc_NetSessInfo502");
3529         if (r == NULL) { ndr_print_null(ndr); return; }
3530         ndr->depth++;
3531         ndr_print_ptr(ndr, "client", r->client);
3532         ndr->depth++;
3533         if (r->client) {
3534                 ndr_print_string(ndr, "client", r->client);
3535         }
3536         ndr->depth--;
3537         ndr_print_ptr(ndr, "user", r->user);
3538         ndr->depth++;
3539         if (r->user) {
3540                 ndr_print_string(ndr, "user", r->user);
3541         }
3542         ndr->depth--;
3543         ndr_print_uint32(ndr, "num_open", r->num_open);
3544         ndr_print_uint32(ndr, "time", r->time);
3545         ndr_print_uint32(ndr, "idle_time", r->idle_time);
3546         ndr_print_uint32(ndr, "user_flags", r->user_flags);
3547         ndr_print_ptr(ndr, "client_type", r->client_type);
3548         ndr->depth++;
3549         if (r->client_type) {
3550                 ndr_print_string(ndr, "client_type", r->client_type);
3551         }
3552         ndr->depth--;
3553         ndr_print_ptr(ndr, "transport", r->transport);
3554         ndr->depth++;
3555         if (r->transport) {
3556                 ndr_print_string(ndr, "transport", r->transport);
3557         }
3558         ndr->depth--;
3559         ndr->depth--;
3560 }
3561
3562 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr502 *r)
3563 {
3564         uint32_t cntr_array_1;
3565         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3566         if (ndr_flags & NDR_SCALARS) {
3567                 NDR_CHECK(ndr_push_align(ndr, 5));
3568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
3570                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3571         }
3572         if (ndr_flags & NDR_BUFFERS) {
3573                 if (r->array) {
3574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
3575                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3576                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3577                         }
3578                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
3579                                 NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3580                         }
3581                 }
3582         }
3583         return NDR_ERR_SUCCESS;
3584 }
3585
3586 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr502 *r)
3587 {
3588         uint32_t _ptr_array;
3589         uint32_t size_array_1 = 0;
3590         uint32_t cntr_array_1;
3591         TALLOC_CTX *_mem_save_array_0;
3592         TALLOC_CTX *_mem_save_array_1;
3593         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3594         if (ndr_flags & NDR_SCALARS) {
3595                 NDR_CHECK(ndr_pull_align(ndr, 5));
3596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
3598                 if (_ptr_array) {
3599                         NDR_PULL_ALLOC(ndr, r->array);
3600                 } else {
3601                         r->array = NULL;
3602                 }
3603                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3604         }
3605         if (ndr_flags & NDR_BUFFERS) {
3606                 if (r->array) {
3607                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
3608                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3609                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
3610                         size_array_1 = ndr_get_array_size(ndr, &r->array);
3611                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
3612                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
3613                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
3614                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3615                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
3616                         }
3617                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
3618                                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
3619                         }
3620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
3621                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
3622                 }
3623                 if (r->array) {
3624                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
3625                 }
3626         }
3627         return NDR_ERR_SUCCESS;
3628 }
3629
3630 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr502 *r)
3631 {
3632         uint32_t cntr_array_1;
3633         ndr_print_struct(ndr, name, "srvsvc_NetSessCtr502");
3634         if (r == NULL) { ndr_print_null(ndr); return; }
3635         ndr->depth++;
3636         ndr_print_uint32(ndr, "count", r->count);
3637         ndr_print_ptr(ndr, "array", r->array);
3638         ndr->depth++;
3639         if (r->array) {
3640                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3641                 ndr->depth++;
3642                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
3643                         ndr_print_srvsvc_NetSessInfo502(ndr, "array", &r->array[cntr_array_1]);
3644                 }
3645                 ndr->depth--;
3646         }
3647         ndr->depth--;
3648         ndr->depth--;
3649 }
3650
3651 static enum ndr_err_code ndr_push_srvsvc_NetSessCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSessCtr *r)
3652 {
3653         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3654         if (ndr_flags & NDR_SCALARS) {
3655                 uint32_t level = ndr_push_get_switch_value(ndr, r);
3656                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
3658                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3659                 switch (level) {
3660                         case 0: {
3661                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
3662                         break; }
3663
3664                         case 1: {
3665                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
3666                         break; }
3667
3668                         case 2: {
3669                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
3670                         break; }
3671
3672                         case 10: {
3673                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr10));
3674                         break; }
3675
3676                         case 502: {
3677                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
3678                         break; }
3679
3680                         default: {
3681                         break; }
3682
3683                 }
3684         }
3685         if (ndr_flags & NDR_BUFFERS) {
3686                 uint32_t level = ndr_push_get_switch_value(ndr, r);
3687                 switch (level) {
3688                         case 0:
3689                                 if (r->ctr0) {
3690                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3691                                 }
3692                         break;
3693
3694                         case 1:
3695                                 if (r->ctr1) {
3696                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3697                                 }
3698                         break;
3699
3700                         case 2:
3701                                 if (r->ctr2) {
3702                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3703                                 }
3704                         break;
3705
3706                         case 10:
3707                                 if (r->ctr10) {
3708                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3709                                 }
3710                         break;
3711
3712                         case 502:
3713                                 if (r->ctr502) {
3714                                         NDR_CHECK(ndr_push_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3715                                 }
3716                         break;
3717
3718                         default:
3719                         break;
3720
3721                 }
3722         }
3723         return NDR_ERR_SUCCESS;
3724 }
3725
3726 static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSessCtr *r)
3727 {
3728         uint32_t level;
3729         uint32_t _level;
3730         TALLOC_CTX *_mem_save_ctr0_0;
3731         uint32_t _ptr_ctr0;
3732         TALLOC_CTX *_mem_save_ctr1_0;
3733         uint32_t _ptr_ctr1;
3734         TALLOC_CTX *_mem_save_ctr2_0;
3735         uint32_t _ptr_ctr2;
3736         TALLOC_CTX *_mem_save_ctr10_0;
3737         uint32_t _ptr_ctr10;
3738         TALLOC_CTX *_mem_save_ctr502_0;
3739         uint32_t _ptr_ctr502;
3740         level = ndr_pull_get_switch_value(ndr, r);
3741         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3742         if (ndr_flags & NDR_SCALARS) {
3743                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3745                 if (_level != level) {
3746                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3747                 }
3748                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3749                 switch (level) {
3750                         case 0: {
3751                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
3752                                 if (_ptr_ctr0) {
3753                                         NDR_PULL_ALLOC(ndr, r->ctr0);
3754                                 } else {
3755                                         r->ctr0 = NULL;
3756                                 }
3757                         break; }
3758
3759                         case 1: {
3760                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
3761                                 if (_ptr_ctr1) {
3762                                         NDR_PULL_ALLOC(ndr, r->ctr1);
3763                                 } else {
3764                                         r->ctr1 = NULL;
3765                                 }
3766                         break; }
3767
3768                         case 2: {
3769                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
3770                                 if (_ptr_ctr2) {
3771                                         NDR_PULL_ALLOC(ndr, r->ctr2);
3772                                 } else {
3773                                         r->ctr2 = NULL;
3774                                 }
3775                         break; }
3776
3777                         case 10: {
3778                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr10));
3779                                 if (_ptr_ctr10) {
3780                                         NDR_PULL_ALLOC(ndr, r->ctr10);
3781                                 } else {
3782                                         r->ctr10 = NULL;
3783                                 }
3784                         break; }
3785
3786                         case 502: {
3787                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
3788                                 if (_ptr_ctr502) {
3789                                         NDR_PULL_ALLOC(ndr, r->ctr502);
3790                                 } else {
3791                                         r->ctr502 = NULL;
3792                                 }
3793                         break; }
3794
3795                         default: {
3796                         break; }
3797
3798                 }
3799         }
3800         if (ndr_flags & NDR_BUFFERS) {
3801                 switch (level) {
3802                         case 0:
3803                                 if (r->ctr0) {
3804                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3805                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
3806                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
3807                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
3808                                 }
3809                         break;
3810
3811                         case 1:
3812                                 if (r->ctr1) {
3813                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3814                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
3815                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
3816                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
3817                                 }
3818                         break;
3819
3820                         case 2:
3821                                 if (r->ctr2) {
3822                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
3823                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
3824                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
3825                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
3826                                 }
3827                         break;
3828
3829                         case 10:
3830                                 if (r->ctr10) {
3831                                         _mem_save_ctr10_0 = NDR_PULL_GET_MEM_CTX(ndr);
3832                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr10, 0);
3833                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));
3834                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr10_0, 0);
3835                                 }
3836                         break;
3837
3838                         case 502:
3839                                 if (r->ctr502) {
3840                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
3841                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
3842                                         NDR_CHECK(ndr_pull_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
3843                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
3844                                 }
3845                         break;
3846
3847                         default:
3848                         break;
3849
3850                 }
3851         }
3852         return NDR_ERR_SUCCESS;
3853 }
3854
3855 _PUBLIC_ void ndr_print_srvsvc_NetSessCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetSessCtr *r)
3856 {
3857         uint32_t level;
3858         level = ndr_print_get_switch_value(ndr, r);
3859         ndr_print_union(ndr, name, level, "srvsvc_NetSessCtr");
3860         switch (level) {
3861                 case 0:
3862                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
3863                         ndr->depth++;
3864                         if (r->ctr0) {
3865                                 ndr_print_srvsvc_NetSessCtr0(ndr, "ctr0", r->ctr0);
3866                         }
3867                         ndr->depth--;
3868                 break;
3869
3870                 case 1:
3871                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
3872                         ndr->depth++;
3873                         if (r->ctr1) {
3874                                 ndr_print_srvsvc_NetSessCtr1(ndr, "ctr1", r->ctr1);
3875                         }
3876                         ndr->depth--;
3877                 break;
3878
3879                 case 2:
3880                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
3881                         ndr->depth++;
3882                         if (r->ctr2) {
3883                                 ndr_print_srvsvc_NetSessCtr2(ndr, "ctr2", r->ctr2);
3884                         }
3885                         ndr->depth--;
3886                 break;
3887
3888                 case 10:
3889                         ndr_print_ptr(ndr, "ctr10", r->ctr10);
3890                         ndr->depth++;
3891                         if (r->ctr10) {
3892                                 ndr_print_srvsvc_NetSessCtr10(ndr, "ctr10", r->ctr10);
3893                         }
3894                         ndr->depth--;
3895                 break;
3896
3897                 case 502:
3898                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
3899                         ndr->depth++;
3900                         if (r->ctr502) {
3901                                 ndr_print_srvsvc_NetSessCtr502(ndr, "ctr502", r->ctr502);
3902                         }
3903                         ndr->depth--;
3904                 break;
3905
3906                 default:
3907                 break;
3908
3909         }
3910 }
3911
3912 static enum ndr_err_code ndr_push_srvsvc_NetSessInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfoCtr *r)
3913 {
3914         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3915         if (ndr_flags & NDR_SCALARS) {
3916                 NDR_CHECK(ndr_push_align(ndr, 5));
3917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
3918                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
3919                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
3920                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3921         }
3922         if (ndr_flags & NDR_BUFFERS) {
3923                 NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
3924         }
3925         return NDR_ERR_SUCCESS;
3926 }
3927
3928 static enum ndr_err_code ndr_pull_srvsvc_NetSessInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfoCtr *r)
3929 {
3930         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3931         if (ndr_flags & NDR_SCALARS) {
3932                 NDR_CHECK(ndr_pull_align(ndr, 5));
3933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
3934                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
3935                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));
3936                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3937         }
3938         if (ndr_flags & NDR_BUFFERS) {
3939                 NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));
3940         }
3941         return NDR_ERR_SUCCESS;
3942 }
3943
3944 _PUBLIC_ void ndr_print_srvsvc_NetSessInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfoCtr *r)
3945 {
3946         ndr_print_struct(ndr, name, "srvsvc_NetSessInfoCtr");
3947         if (r == NULL) { ndr_print_null(ndr); return; }
3948         ndr->depth++;
3949         ndr_print_uint32(ndr, "level", r->level);
3950         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
3951         ndr_print_srvsvc_NetSessCtr(ndr, "ctr", &r->ctr);
3952         ndr->depth--;
3953 }
3954
3955 static enum ndr_err_code ndr_push_srvsvc_ShareType(struct ndr_push *ndr, int ndr_flags, enum srvsvc_ShareType r)
3956 {
3957         {
3958                 uint32_t _flags_save_ENUM = ndr->flags;
3959                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3960                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
3961                 ndr->flags = _flags_save_ENUM;
3962         }
3963         return NDR_ERR_SUCCESS;
3964 }
3965
3966 static enum ndr_err_code ndr_pull_srvsvc_ShareType(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_ShareType *r)
3967 {
3968         uint32_t v;
3969         {
3970                 uint32_t _flags_save_ENUM = ndr->flags;
3971                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3972                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
3973                 *r = v;
3974                 ndr->flags = _flags_save_ENUM;
3975         }
3976         return NDR_ERR_SUCCESS;
3977 }
3978
3979 _PUBLIC_ void ndr_print_srvsvc_ShareType(struct ndr_print *ndr, const char *name, enum srvsvc_ShareType r)
3980 {
3981         const char *val = NULL;
3982
3983         {
3984                 uint32_t _flags_save_ENUM = ndr->flags;
3985                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3986                 switch (r) {
3987                         case STYPE_DISKTREE: val = "STYPE_DISKTREE"; break;
3988                         case STYPE_DISKTREE_TEMPORARY: val = "STYPE_DISKTREE_TEMPORARY"; break;
3989                         case STYPE_DISKTREE_HIDDEN: val = "STYPE_DISKTREE_HIDDEN"; break;
3990                         case STYPE_PRINTQ: val = "STYPE_PRINTQ"; break;
3991                         case STYPE_PRINTQ_TEMPORARY: val = "STYPE_PRINTQ_TEMPORARY"; break;
3992                         case STYPE_PRINTQ_HIDDEN: val = "STYPE_PRINTQ_HIDDEN"; break;
3993                         case STYPE_DEVICE: val = "STYPE_DEVICE"; break;
3994                         case STYPE_DEVICE_TEMPORARY: val = "STYPE_DEVICE_TEMPORARY"; break;
3995                         case STYPE_DEVICE_HIDDEN: val = "STYPE_DEVICE_HIDDEN"; break;
3996                         case STYPE_IPC: val = "STYPE_IPC"; break;
3997                         case STYPE_IPC_TEMPORARY: val = "STYPE_IPC_TEMPORARY"; break;
3998                         case STYPE_IPC_HIDDEN: val = "STYPE_IPC_HIDDEN"; break;
3999                 }
4000                 ndr_print_enum(ndr, name, "ENUM", val, r);
4001                 ndr->flags = _flags_save_ENUM;
4002         }
4003 }
4004
4005 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo0 *r)
4006 {
4007         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4008         if (ndr_flags & NDR_SCALARS) {
4009                 NDR_CHECK(ndr_push_align(ndr, 5));
4010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4011                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4012         }
4013         if (ndr_flags & NDR_BUFFERS) {
4014                 if (r->name) {
4015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4017                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4018                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4019                 }
4020         }
4021         return NDR_ERR_SUCCESS;
4022 }
4023
4024 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo0 *r)
4025 {
4026         uint32_t _ptr_name;
4027         uint32_t size_name_1 = 0;
4028         uint32_t length_name_1 = 0;
4029         TALLOC_CTX *_mem_save_name_0;
4030         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4031         if (ndr_flags & NDR_SCALARS) {
4032                 NDR_CHECK(ndr_pull_align(ndr, 5));
4033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4034                 if (_ptr_name) {
4035                         NDR_PULL_ALLOC(ndr, r->name);
4036                 } else {
4037                         r->name = NULL;
4038                 }
4039                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4040         }
4041         if (ndr_flags & NDR_BUFFERS) {
4042                 if (r->name) {
4043                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4044                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4047                         size_name_1 = ndr_get_array_size(ndr, &r->name);
4048                         length_name_1 = ndr_get_array_length(ndr, &r->name);
4049                         if (length_name_1 > size_name_1) {
4050                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
4051                         }
4052                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
4053                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
4054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4055                 }
4056         }
4057         return NDR_ERR_SUCCESS;
4058 }
4059
4060 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo0 *r)
4061 {
4062         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo0");
4063         if (r == NULL) { ndr_print_null(ndr); return; }
4064         ndr->depth++;
4065         ndr_print_ptr(ndr, "name", r->name);
4066         ndr->depth++;
4067         if (r->name) {
4068                 ndr_print_string(ndr, "name", r->name);
4069         }
4070         ndr->depth--;
4071         ndr->depth--;
4072 }
4073
4074 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr0 *r)
4075 {
4076         uint32_t cntr_array_1;
4077         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4078         if (ndr_flags & NDR_SCALARS) {
4079                 NDR_CHECK(ndr_push_align(ndr, 5));
4080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4082                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4083         }
4084         if (ndr_flags & NDR_BUFFERS) {
4085                 if (r->array) {
4086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4087                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4088                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4089                         }
4090                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4091                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4092                         }
4093                 }
4094         }
4095         return NDR_ERR_SUCCESS;
4096 }
4097
4098 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr0 *r)
4099 {
4100         uint32_t _ptr_array;
4101         uint32_t size_array_1 = 0;
4102         uint32_t cntr_array_1;
4103         TALLOC_CTX *_mem_save_array_0;
4104         TALLOC_CTX *_mem_save_array_1;
4105         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4106         if (ndr_flags & NDR_SCALARS) {
4107                 NDR_CHECK(ndr_pull_align(ndr, 5));
4108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4110                 if (_ptr_array) {
4111                         NDR_PULL_ALLOC(ndr, r->array);
4112                 } else {
4113                         r->array = NULL;
4114                 }
4115                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4116         }
4117         if (ndr_flags & NDR_BUFFERS) {
4118                 if (r->array) {
4119                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4120                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4122                         size_array_1 = ndr_get_array_size(ndr, &r->array);
4123                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
4124                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4125                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4126                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4127                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4128                         }
4129                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4130                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4131                         }
4132                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4134                 }
4135                 if (r->array) {
4136                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4137                 }
4138         }
4139         return NDR_ERR_SUCCESS;
4140 }
4141
4142 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr0 *r)
4143 {
4144         uint32_t cntr_array_1;
4145         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr0");
4146         if (r == NULL) { ndr_print_null(ndr); return; }
4147         ndr->depth++;
4148         ndr_print_uint32(ndr, "count", r->count);
4149         ndr_print_ptr(ndr, "array", r->array);
4150         ndr->depth++;
4151         if (r->array) {
4152                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4153                 ndr->depth++;
4154                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4155                         ndr_print_srvsvc_NetShareInfo0(ndr, "array", &r->array[cntr_array_1]);
4156                 }
4157                 ndr->depth--;
4158         }
4159         ndr->depth--;
4160         ndr->depth--;
4161 }
4162
4163 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1 *r)
4164 {
4165         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4166         if (ndr_flags & NDR_SCALARS) {
4167                 NDR_CHECK(ndr_push_align(ndr, 5));
4168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4169                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4171                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4172         }
4173         if (ndr_flags & NDR_BUFFERS) {
4174                 if (r->name) {
4175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4179                 }
4180                 if (r->comment) {
4181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4185                 }
4186         }
4187         return NDR_ERR_SUCCESS;
4188 }
4189
4190 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1 *r)
4191 {
4192         uint32_t _ptr_name;
4193         uint32_t size_name_1 = 0;
4194         uint32_t length_name_1 = 0;
4195         TALLOC_CTX *_mem_save_name_0;
4196         uint32_t _ptr_comment;
4197         uint32_t size_comment_1 = 0;
4198         uint32_t length_comment_1 = 0;
4199         TALLOC_CTX *_mem_save_comment_0;
4200         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4201         if (ndr_flags & NDR_SCALARS) {
4202                 NDR_CHECK(ndr_pull_align(ndr, 5));
4203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4204                 if (_ptr_name) {
4205                         NDR_PULL_ALLOC(ndr, r->name);
4206                 } else {
4207                         r->name = NULL;
4208                 }
4209                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4211                 if (_ptr_comment) {
4212                         NDR_PULL_ALLOC(ndr, r->comment);
4213                 } else {
4214                         r->comment = NULL;
4215                 }
4216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4217         }
4218         if (ndr_flags & NDR_BUFFERS) {
4219                 if (r->name) {
4220                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4221                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4222                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4223                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4224                         size_name_1 = ndr_get_array_size(ndr, &r->name);
4225                         length_name_1 = ndr_get_array_length(ndr, &r->name);
4226                         if (length_name_1 > size_name_1) {
4227                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
4228                         }
4229                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
4230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
4231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4232                 }
4233                 if (r->comment) {
4234                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4235                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4238                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
4239                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
4240                         if (length_comment_1 > size_comment_1) {
4241                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
4242                         }
4243                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
4244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
4245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4246                 }
4247         }
4248         return NDR_ERR_SUCCESS;
4249 }
4250
4251 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1 *r)
4252 {
4253         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1");
4254         if (r == NULL) { ndr_print_null(ndr); return; }
4255         ndr->depth++;
4256         ndr_print_ptr(ndr, "name", r->name);
4257         ndr->depth++;
4258         if (r->name) {
4259                 ndr_print_string(ndr, "name", r->name);
4260         }
4261         ndr->depth--;
4262         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4263         ndr_print_ptr(ndr, "comment", r->comment);
4264         ndr->depth++;
4265         if (r->comment) {
4266                 ndr_print_string(ndr, "comment", r->comment);
4267         }
4268         ndr->depth--;
4269         ndr->depth--;
4270 }
4271
4272 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1 *r)
4273 {
4274         uint32_t cntr_array_1;
4275         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4276         if (ndr_flags & NDR_SCALARS) {
4277                 NDR_CHECK(ndr_push_align(ndr, 5));
4278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4279                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4280                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4281         }
4282         if (ndr_flags & NDR_BUFFERS) {
4283                 if (r->array) {
4284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4285                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4286                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4287                         }
4288                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4289                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4290                         }
4291                 }
4292         }
4293         return NDR_ERR_SUCCESS;
4294 }
4295
4296 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1 *r)
4297 {
4298         uint32_t _ptr_array;
4299         uint32_t size_array_1 = 0;
4300         uint32_t cntr_array_1;
4301         TALLOC_CTX *_mem_save_array_0;
4302         TALLOC_CTX *_mem_save_array_1;
4303         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4304         if (ndr_flags & NDR_SCALARS) {
4305                 NDR_CHECK(ndr_pull_align(ndr, 5));
4306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4307                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4308                 if (_ptr_array) {
4309                         NDR_PULL_ALLOC(ndr, r->array);
4310                 } else {
4311                         r->array = NULL;
4312                 }
4313                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4314         }
4315         if (ndr_flags & NDR_BUFFERS) {
4316                 if (r->array) {
4317                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4318                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4320                         size_array_1 = ndr_get_array_size(ndr, &r->array);
4321                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
4322                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4323                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4324                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4325                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4326                         }
4327                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4328                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4329                         }
4330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4332                 }
4333                 if (r->array) {
4334                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4335                 }
4336         }
4337         return NDR_ERR_SUCCESS;
4338 }
4339
4340 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1 *r)
4341 {
4342         uint32_t cntr_array_1;
4343         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1");
4344         if (r == NULL) { ndr_print_null(ndr); return; }
4345         ndr->depth++;
4346         ndr_print_uint32(ndr, "count", r->count);
4347         ndr_print_ptr(ndr, "array", r->array);
4348         ndr->depth++;
4349         if (r->array) {
4350                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4351                 ndr->depth++;
4352                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4353                         ndr_print_srvsvc_NetShareInfo1(ndr, "array", &r->array[cntr_array_1]);
4354                 }
4355                 ndr->depth--;
4356         }
4357         ndr->depth--;
4358         ndr->depth--;
4359 }
4360
4361 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo2 *r)
4362 {
4363         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4364         if (ndr_flags & NDR_SCALARS) {
4365                 NDR_CHECK(ndr_push_align(ndr, 5));
4366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4367                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
4370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
4371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
4372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
4373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4374                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4375         }
4376         if (ndr_flags & NDR_BUFFERS) {
4377                 if (r->name) {
4378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4381                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4382                 }
4383                 if (r->comment) {
4384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4385                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4388                 }
4389                 if (r->path) {
4390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4393                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4394                 }
4395                 if (r->password) {
4396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4399                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4400                 }
4401         }
4402         return NDR_ERR_SUCCESS;
4403 }
4404
4405 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo2 *r)
4406 {
4407         uint32_t _ptr_name;
4408         uint32_t size_name_1 = 0;
4409         uint32_t length_name_1 = 0;
4410         TALLOC_CTX *_mem_save_name_0;
4411         uint32_t _ptr_comment;
4412         uint32_t size_comment_1 = 0;
4413         uint32_t length_comment_1 = 0;
4414         TALLOC_CTX *_mem_save_comment_0;
4415         uint32_t _ptr_path;
4416         uint32_t size_path_1 = 0;
4417         uint32_t length_path_1 = 0;
4418         TALLOC_CTX *_mem_save_path_0;
4419         uint32_t _ptr_password;
4420         uint32_t size_password_1 = 0;
4421         uint32_t length_password_1 = 0;
4422         TALLOC_CTX *_mem_save_password_0;
4423         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4424         if (ndr_flags & NDR_SCALARS) {
4425                 NDR_CHECK(ndr_pull_align(ndr, 5));
4426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4427                 if (_ptr_name) {
4428                         NDR_PULL_ALLOC(ndr, r->name);
4429                 } else {
4430                         r->name = NULL;
4431                 }
4432                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4433                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4434                 if (_ptr_comment) {
4435                         NDR_PULL_ALLOC(ndr, r->comment);
4436                 } else {
4437                         r->comment = NULL;
4438                 }
4439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
4440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
4441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
4442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
4443                 if (_ptr_path) {
4444                         NDR_PULL_ALLOC(ndr, r->path);
4445                 } else {
4446                         r->path = NULL;
4447                 }
4448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4449                 if (_ptr_password) {
4450                         NDR_PULL_ALLOC(ndr, r->password);
4451                 } else {
4452                         r->password = NULL;
4453                 }
4454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4455         }
4456         if (ndr_flags & NDR_BUFFERS) {
4457                 if (r->name) {
4458                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4459                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4460                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4461                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4462                         size_name_1 = ndr_get_array_size(ndr, &r->name);
4463                         length_name_1 = ndr_get_array_length(ndr, &r->name);
4464                         if (length_name_1 > size_name_1) {
4465                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
4466                         }
4467                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
4468                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
4469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4470                 }
4471                 if (r->comment) {
4472                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4473                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4474                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4475                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4476                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
4477                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
4478                         if (length_comment_1 > size_comment_1) {
4479                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
4480                         }
4481                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
4482                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
4483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4484                 }
4485                 if (r->path) {
4486                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4487                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
4488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
4489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
4490                         size_path_1 = ndr_get_array_size(ndr, &r->path);
4491                         length_path_1 = ndr_get_array_length(ndr, &r->path);
4492                         if (length_path_1 > size_path_1) {
4493                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
4494                         }
4495                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
4496                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, length_path_1, sizeof(uint16_t), CH_UTF16));
4497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
4498                 }
4499                 if (r->password) {
4500                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4501                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4504                         size_password_1 = ndr_get_array_size(ndr, &r->password);
4505                         length_password_1 = ndr_get_array_length(ndr, &r->password);
4506                         if (length_password_1 > size_password_1) {
4507                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_password_1, length_password_1);
4508                         }
4509                         NDR_CHECK(ndr_check_string_terminator(ndr, length_password_1, sizeof(uint16_t)));
4510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, length_password_1, sizeof(uint16_t), CH_UTF16));
4511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4512                 }
4513         }
4514         return NDR_ERR_SUCCESS;
4515 }
4516
4517 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo2 *r)
4518 {
4519         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo2");
4520         if (r == NULL) { ndr_print_null(ndr); return; }
4521         ndr->depth++;
4522         ndr_print_ptr(ndr, "name", r->name);
4523         ndr->depth++;
4524         if (r->name) {
4525                 ndr_print_string(ndr, "name", r->name);
4526         }
4527         ndr->depth--;
4528         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4529         ndr_print_ptr(ndr, "comment", r->comment);
4530         ndr->depth++;
4531         if (r->comment) {
4532                 ndr_print_string(ndr, "comment", r->comment);
4533         }
4534         ndr->depth--;
4535         ndr_print_uint32(ndr, "permissions", r->permissions);
4536         ndr_print_uint32(ndr, "max_users", r->max_users);
4537         ndr_print_uint32(ndr, "current_users", r->current_users);
4538         ndr_print_ptr(ndr, "path", r->path);
4539         ndr->depth++;
4540         if (r->path) {
4541                 ndr_print_string(ndr, "path", r->path);
4542         }
4543         ndr->depth--;
4544         ndr_print_ptr(ndr, "password", r->password);
4545         ndr->depth++;
4546         if (r->password) {
4547                 ndr_print_string(ndr, "password", r->password);
4548         }
4549         ndr->depth--;
4550         ndr->depth--;
4551 }
4552
4553 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr2 *r)
4554 {
4555         uint32_t cntr_array_1;
4556         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4557         if (ndr_flags & NDR_SCALARS) {
4558                 NDR_CHECK(ndr_push_align(ndr, 5));
4559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4561                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4562         }
4563         if (ndr_flags & NDR_BUFFERS) {
4564                 if (r->array) {
4565                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4566                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4567                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4568                         }
4569                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4570                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4571                         }
4572                 }
4573         }
4574         return NDR_ERR_SUCCESS;
4575 }
4576
4577 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr2 *r)
4578 {
4579         uint32_t _ptr_array;
4580         uint32_t size_array_1 = 0;
4581         uint32_t cntr_array_1;
4582         TALLOC_CTX *_mem_save_array_0;
4583         TALLOC_CTX *_mem_save_array_1;
4584         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4585         if (ndr_flags & NDR_SCALARS) {
4586                 NDR_CHECK(ndr_pull_align(ndr, 5));
4587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4589                 if (_ptr_array) {
4590                         NDR_PULL_ALLOC(ndr, r->array);
4591                 } else {
4592                         r->array = NULL;
4593                 }
4594                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4595         }
4596         if (ndr_flags & NDR_BUFFERS) {
4597                 if (r->array) {
4598                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4599                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4600                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4601                         size_array_1 = ndr_get_array_size(ndr, &r->array);
4602                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
4603                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4604                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4605                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4606                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4607                         }
4608                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4609                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4610                         }
4611                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4612                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4613                 }
4614                 if (r->array) {
4615                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4616                 }
4617         }
4618         return NDR_ERR_SUCCESS;
4619 }
4620
4621 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr2 *r)
4622 {
4623         uint32_t cntr_array_1;
4624         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr2");
4625         if (r == NULL) { ndr_print_null(ndr); return; }
4626         ndr->depth++;
4627         ndr_print_uint32(ndr, "count", r->count);
4628         ndr_print_ptr(ndr, "array", r->array);
4629         ndr->depth++;
4630         if (r->array) {
4631                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4632                 ndr->depth++;
4633                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4634                         ndr_print_srvsvc_NetShareInfo2(ndr, "array", &r->array[cntr_array_1]);
4635                 }
4636                 ndr->depth--;
4637         }
4638         ndr->depth--;
4639         ndr->depth--;
4640 }
4641
4642 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo501 *r)
4643 {
4644         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4645         if (ndr_flags & NDR_SCALARS) {
4646                 NDR_CHECK(ndr_push_align(ndr, 5));
4647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4648                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->csc_policy));
4651                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4652         }
4653         if (ndr_flags & NDR_BUFFERS) {
4654                 if (r->name) {
4655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4659                 }
4660                 if (r->comment) {
4661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4665                 }
4666         }
4667         return NDR_ERR_SUCCESS;
4668 }
4669
4670 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo501 *r)
4671 {
4672         uint32_t _ptr_name;
4673         uint32_t size_name_1 = 0;
4674         uint32_t length_name_1 = 0;
4675         TALLOC_CTX *_mem_save_name_0;
4676         uint32_t _ptr_comment;
4677         uint32_t size_comment_1 = 0;
4678         uint32_t length_comment_1 = 0;
4679         TALLOC_CTX *_mem_save_comment_0;
4680         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4681         if (ndr_flags & NDR_SCALARS) {
4682                 NDR_CHECK(ndr_pull_align(ndr, 5));
4683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4684                 if (_ptr_name) {
4685                         NDR_PULL_ALLOC(ndr, r->name);
4686                 } else {
4687                         r->name = NULL;
4688                 }
4689                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4690                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4691                 if (_ptr_comment) {
4692                         NDR_PULL_ALLOC(ndr, r->comment);
4693                 } else {
4694                         r->comment = NULL;
4695                 }
4696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->csc_policy));
4697                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4698         }
4699         if (ndr_flags & NDR_BUFFERS) {
4700                 if (r->name) {
4701                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4702                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4704                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4705                         size_name_1 = ndr_get_array_size(ndr, &r->name);
4706                         length_name_1 = ndr_get_array_length(ndr, &r->name);
4707                         if (length_name_1 > size_name_1) {
4708                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
4709                         }
4710                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
4711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
4712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4713                 }
4714                 if (r->comment) {
4715                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4716                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4719                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
4720                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
4721                         if (length_comment_1 > size_comment_1) {
4722                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
4723                         }
4724                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
4725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
4726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4727                 }
4728         }
4729         return NDR_ERR_SUCCESS;
4730 }
4731
4732 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo501 *r)
4733 {
4734         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo501");
4735         if (r == NULL) { ndr_print_null(ndr); return; }
4736         ndr->depth++;
4737         ndr_print_ptr(ndr, "name", r->name);
4738         ndr->depth++;
4739         if (r->name) {
4740                 ndr_print_string(ndr, "name", r->name);
4741         }
4742         ndr->depth--;
4743         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
4744         ndr_print_ptr(ndr, "comment", r->comment);
4745         ndr->depth++;
4746         if (r->comment) {
4747                 ndr_print_string(ndr, "comment", r->comment);
4748         }
4749         ndr->depth--;
4750         ndr_print_uint32(ndr, "csc_policy", r->csc_policy);
4751         ndr->depth--;
4752 }
4753
4754 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr501 *r)
4755 {
4756         uint32_t cntr_array_1;
4757         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4758         if (ndr_flags & NDR_SCALARS) {
4759                 NDR_CHECK(ndr_push_align(ndr, 5));
4760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4761                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
4762                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4763         }
4764         if (ndr_flags & NDR_BUFFERS) {
4765                 if (r->array) {
4766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
4767                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4768                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4769                         }
4770                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
4771                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4772                         }
4773                 }
4774         }
4775         return NDR_ERR_SUCCESS;
4776 }
4777
4778 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr501 *r)
4779 {
4780         uint32_t _ptr_array;
4781         uint32_t size_array_1 = 0;
4782         uint32_t cntr_array_1;
4783         TALLOC_CTX *_mem_save_array_0;
4784         TALLOC_CTX *_mem_save_array_1;
4785         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4786         if (ndr_flags & NDR_SCALARS) {
4787                 NDR_CHECK(ndr_pull_align(ndr, 5));
4788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
4790                 if (_ptr_array) {
4791                         NDR_PULL_ALLOC(ndr, r->array);
4792                 } else {
4793                         r->array = NULL;
4794                 }
4795                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4796         }
4797         if (ndr_flags & NDR_BUFFERS) {
4798                 if (r->array) {
4799                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4800                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
4802                         size_array_1 = ndr_get_array_size(ndr, &r->array);
4803                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
4804                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4805                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
4806                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4807                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
4808                         }
4809                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
4810                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
4811                         }
4812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
4813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
4814                 }
4815                 if (r->array) {
4816                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
4817                 }
4818         }
4819         return NDR_ERR_SUCCESS;
4820 }
4821
4822 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr501 *r)
4823 {
4824         uint32_t cntr_array_1;
4825         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr501");
4826         if (r == NULL) { ndr_print_null(ndr); return; }
4827         ndr->depth++;
4828         ndr_print_uint32(ndr, "count", r->count);
4829         ndr_print_ptr(ndr, "array", r->array);
4830         ndr->depth++;
4831         if (r->array) {
4832                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
4833                 ndr->depth++;
4834                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
4835                         ndr_print_srvsvc_NetShareInfo501(ndr, "array", &r->array[cntr_array_1]);
4836                 }
4837                 ndr->depth--;
4838         }
4839         ndr->depth--;
4840         ndr->depth--;
4841 }
4842
4843 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo502 *r)
4844 {
4845         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
4846         if (ndr_flags & NDR_SCALARS) {
4847                 NDR_CHECK(ndr_push_align(ndr, 5));
4848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4849                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));
4850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));
4852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
4853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));
4854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));
4855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
4856                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
4857                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4858         }
4859         if (ndr_flags & NDR_BUFFERS) {
4860                 if (r->name) {
4861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4864                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4865                 }
4866                 if (r->comment) {
4867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4870                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4871                 }
4872                 if (r->path) {
4873                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4874                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));
4876                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4877                 }
4878                 if (r->password) {
4879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));
4882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4883                 }
4884                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));
4885         }
4886         return NDR_ERR_SUCCESS;
4887 }
4888
4889 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo502 *r)
4890 {
4891         uint32_t _ptr_name;
4892         uint32_t size_name_1 = 0;
4893         uint32_t length_name_1 = 0;
4894         TALLOC_CTX *_mem_save_name_0;
4895         uint32_t _ptr_comment;
4896         uint32_t size_comment_1 = 0;
4897         uint32_t length_comment_1 = 0;
4898         TALLOC_CTX *_mem_save_comment_0;
4899         uint32_t _ptr_path;
4900         uint32_t size_path_1 = 0;
4901         uint32_t length_path_1 = 0;
4902         TALLOC_CTX *_mem_save_path_0;
4903         uint32_t _ptr_password;
4904         uint32_t size_password_1 = 0;
4905         uint32_t length_password_1 = 0;
4906         TALLOC_CTX *_mem_save_password_0;
4907         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
4908         if (ndr_flags & NDR_SCALARS) {
4909                 NDR_CHECK(ndr_pull_align(ndr, 5));
4910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4911                 if (_ptr_name) {
4912                         NDR_PULL_ALLOC(ndr, r->name);
4913                 } else {
4914                         r->name = NULL;
4915                 }
4916                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));
4917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4918                 if (_ptr_comment) {
4919                         NDR_PULL_ALLOC(ndr, r->comment);
4920                 } else {
4921                         r->comment = NULL;
4922                 }
4923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));
4924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
4925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));
4926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
4927                 if (_ptr_path) {
4928                         NDR_PULL_ALLOC(ndr, r->path);
4929                 } else {
4930                         r->path = NULL;
4931                 }
4932                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4933                 if (_ptr_password) {
4934                         NDR_PULL_ALLOC(ndr, r->password);
4935                 } else {
4936                         r->password = NULL;
4937                 }
4938                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));
4939                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4940         }
4941         if (ndr_flags & NDR_BUFFERS) {
4942                 if (r->name) {
4943                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4944                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4947                         size_name_1 = ndr_get_array_size(ndr, &r->name);
4948                         length_name_1 = ndr_get_array_length(ndr, &r->name);
4949                         if (length_name_1 > size_name_1) {
4950                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
4951                         }
4952                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
4953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
4954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4955                 }
4956                 if (r->comment) {
4957                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4958                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4961                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
4962                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
4963                         if (length_comment_1 > size_comment_1) {
4964                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
4965                         }
4966                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
4967                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
4968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4969                 }
4970                 if (r->path) {
4971                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4972                         NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);
4973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->path));
4974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->path));
4975                         size_path_1 = ndr_get_array_size(ndr, &r->path);
4976                         length_path_1 = ndr_get_array_length(ndr, &r->path);
4977                         if (length_path_1 > size_path_1) {
4978                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, length_path_1, sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
4983                 }
4984                 if (r->password) {
4985                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4986                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
4987                         NDR_CHECK(ndr_pull_array_size(ndr, &r->password));
4988                         NDR_CHECK(ndr_pull_array_length(ndr, &r->password));
4989                         size_password_1 = ndr_get_array_size(ndr, &r->password);
4990                         length_password_1 = ndr_get_array_length(ndr, &r->password);
4991                         if (length_password_1 > size_password_1) {
4992                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_password_1, length_password_1);
4993                         }
4994                         NDR_CHECK(ndr_check_string_terminator(ndr, length_password_1, sizeof(uint16_t)));
4995                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, length_password_1, sizeof(uint16_t), CH_UTF16));
4996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4997                 }
4998                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));
4999         }
5000         return NDR_ERR_SUCCESS;
5001 }
5002
5003 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo502 *r)
5004 {
5005         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo502");
5006         if (r == NULL) { ndr_print_null(ndr); return; }
5007         ndr->depth++;
5008         ndr_print_ptr(ndr, "name", r->name);
5009         ndr->depth++;
5010         if (r->name) {
5011                 ndr_print_string(ndr, "name", r->name);
5012         }
5013         ndr->depth--;
5014         ndr_print_srvsvc_ShareType(ndr, "type", r->type);
5015         ndr_print_ptr(ndr, "comment", r->comment);
5016         ndr->depth++;
5017         if (r->comment) {
5018                 ndr_print_string(ndr, "comment", r->comment);
5019         }
5020         ndr->depth--;
5021         ndr_print_uint32(ndr, "permissions", r->permissions);
5022         ndr_print_uint32(ndr, "max_users", r->max_users);
5023         ndr_print_uint32(ndr, "current_users", r->current_users);
5024         ndr_print_ptr(ndr, "path", r->path);
5025         ndr->depth++;
5026         if (r->path) {
5027                 ndr_print_string(ndr, "path", r->path);
5028         }
5029         ndr->depth--;
5030         ndr_print_ptr(ndr, "password", r->password);
5031         ndr->depth++;
5032         if (r->password) {
5033                 ndr_print_string(ndr, "password", r->password);
5034         }
5035         ndr->depth--;
5036         ndr_print_sec_desc_buf(ndr, "sd_buf", &r->sd_buf);
5037         ndr->depth--;
5038 }
5039
5040 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr502 *r)
5041 {
5042         uint32_t cntr_array_1;
5043         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5044         if (ndr_flags & NDR_SCALARS) {
5045                 NDR_CHECK(ndr_push_align(ndr, 5));
5046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5048                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5049         }
5050         if (ndr_flags & NDR_BUFFERS) {
5051                 if (r->array) {
5052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5053                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5054                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5055                         }
5056                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5057                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5058                         }
5059                 }
5060         }
5061         return NDR_ERR_SUCCESS;
5062 }
5063
5064 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr502 *r)
5065 {
5066         uint32_t _ptr_array;
5067         uint32_t size_array_1 = 0;
5068         uint32_t cntr_array_1;
5069         TALLOC_CTX *_mem_save_array_0;
5070         TALLOC_CTX *_mem_save_array_1;
5071         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5072         if (ndr_flags & NDR_SCALARS) {
5073                 NDR_CHECK(ndr_pull_align(ndr, 5));
5074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5076                 if (_ptr_array) {
5077                         NDR_PULL_ALLOC(ndr, r->array);
5078                 } else {
5079                         r->array = NULL;
5080                 }
5081                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5082         }
5083         if (ndr_flags & NDR_BUFFERS) {
5084                 if (r->array) {
5085                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5086                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5088                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5089                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5090                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5091                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5092                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5093                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5094                         }
5095                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5096                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5097                         }
5098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5100                 }
5101                 if (r->array) {
5102                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5103                 }
5104         }
5105         return NDR_ERR_SUCCESS;
5106 }
5107
5108 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr502 *r)
5109 {
5110         uint32_t cntr_array_1;
5111         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr502");
5112         if (r == NULL) { ndr_print_null(ndr); return; }
5113         ndr->depth++;
5114         ndr_print_uint32(ndr, "count", r->count);
5115         ndr_print_ptr(ndr, "array", r->array);
5116         ndr->depth++;
5117         if (r->array) {
5118                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5119                 ndr->depth++;
5120                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5121                         ndr_print_srvsvc_NetShareInfo502(ndr, "array", &r->array[cntr_array_1]);
5122                 }
5123                 ndr->depth--;
5124         }
5125         ndr->depth--;
5126         ndr->depth--;
5127 }
5128
5129 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1004 *r)
5130 {
5131         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5132         if (ndr_flags & NDR_SCALARS) {
5133                 NDR_CHECK(ndr_push_align(ndr, 5));
5134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5135                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5136         }
5137         if (ndr_flags & NDR_BUFFERS) {
5138                 if (r->comment) {
5139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5142                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5143                 }
5144         }
5145         return NDR_ERR_SUCCESS;
5146 }
5147
5148 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1004 *r)
5149 {
5150         uint32_t _ptr_comment;
5151         uint32_t size_comment_1 = 0;
5152         uint32_t length_comment_1 = 0;
5153         TALLOC_CTX *_mem_save_comment_0;
5154         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5155         if (ndr_flags & NDR_SCALARS) {
5156                 NDR_CHECK(ndr_pull_align(ndr, 5));
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5158                 if (_ptr_comment) {
5159                         NDR_PULL_ALLOC(ndr, r->comment);
5160                 } else {
5161                         r->comment = NULL;
5162                 }
5163                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5164         }
5165         if (ndr_flags & NDR_BUFFERS) {
5166                 if (r->comment) {
5167                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5168                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5171                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
5172                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
5173                         if (length_comment_1 > size_comment_1) {
5174                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
5175                         }
5176                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
5177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
5178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5179                 }
5180         }
5181         return NDR_ERR_SUCCESS;
5182 }
5183
5184 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1004 *r)
5185 {
5186         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1004");
5187         if (r == NULL) { ndr_print_null(ndr); return; }
5188         ndr->depth++;
5189         ndr_print_ptr(ndr, "comment", r->comment);
5190         ndr->depth++;
5191         if (r->comment) {
5192                 ndr_print_string(ndr, "comment", r->comment);
5193         }
5194         ndr->depth--;
5195         ndr->depth--;
5196 }
5197
5198 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1004 *r)
5199 {
5200         uint32_t cntr_array_1;
5201         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5202         if (ndr_flags & NDR_SCALARS) {
5203                 NDR_CHECK(ndr_push_align(ndr, 5));
5204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5206                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5207         }
5208         if (ndr_flags & NDR_BUFFERS) {
5209                 if (r->array) {
5210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5211                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5212                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5213                         }
5214                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5215                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5216                         }
5217                 }
5218         }
5219         return NDR_ERR_SUCCESS;
5220 }
5221
5222 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1004 *r)
5223 {
5224         uint32_t _ptr_array;
5225         uint32_t size_array_1 = 0;
5226         uint32_t cntr_array_1;
5227         TALLOC_CTX *_mem_save_array_0;
5228         TALLOC_CTX *_mem_save_array_1;
5229         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5230         if (ndr_flags & NDR_SCALARS) {
5231                 NDR_CHECK(ndr_pull_align(ndr, 5));
5232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5234                 if (_ptr_array) {
5235                         NDR_PULL_ALLOC(ndr, r->array);
5236                 } else {
5237                         r->array = NULL;
5238                 }
5239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5240         }
5241         if (ndr_flags & NDR_BUFFERS) {
5242                 if (r->array) {
5243                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5244                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5246                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5247                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5248                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5249                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5250                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5251                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5252                         }
5253                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5254                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5255                         }
5256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5258                 }
5259                 if (r->array) {
5260                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5261                 }
5262         }
5263         return NDR_ERR_SUCCESS;
5264 }
5265
5266 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1004 *r)
5267 {
5268         uint32_t cntr_array_1;
5269         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1004");
5270         if (r == NULL) { ndr_print_null(ndr); return; }
5271         ndr->depth++;
5272         ndr_print_uint32(ndr, "count", r->count);
5273         ndr_print_ptr(ndr, "array", r->array);
5274         ndr->depth++;
5275         if (r->array) {
5276                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5277                 ndr->depth++;
5278                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5279                         ndr_print_srvsvc_NetShareInfo1004(ndr, "array", &r->array[cntr_array_1]);
5280                 }
5281                 ndr->depth--;
5282         }
5283         ndr->depth--;
5284         ndr->depth--;
5285 }
5286
5287 static enum ndr_err_code ndr_push_NetShareInfo1005Flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
5288 {
5289         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5290         return NDR_ERR_SUCCESS;
5291 }
5292
5293 static enum ndr_err_code ndr_pull_NetShareInfo1005Flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
5294 {
5295         uint32_t v;
5296         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5297         *r = v;
5298         return NDR_ERR_SUCCESS;
5299 }
5300
5301 _PUBLIC_ void ndr_print_NetShareInfo1005Flags(struct ndr_print *ndr, const char *name, uint32_t r)
5302 {
5303         ndr_print_uint32(ndr, name, r);
5304         ndr->depth++;
5305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_IN_DFS", SHARE_1005_IN_DFS, r);
5306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_DFS_ROOT", SHARE_1005_DFS_ROOT, r);
5307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_CSC_CACHE_AUTO_REINT", SHARE_1005_CSC_CACHE_AUTO_REINT, r);
5308         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_CSC_CACHE_VDO", SHARE_1005_CSC_CACHE_VDO, r);
5309         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_CSC_CACHE_NONE", SHARE_1005_CSC_CACHE_NONE, r);
5310         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_RESTRICT_EXCLUSIVE_OPENS", SHARE_1005_RESTRICT_EXCLUSIVE_OPENS, r);
5311         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_FORCE_SHARED_DELETE", SHARE_1005_FORCE_SHARED_DELETE, r);
5312         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_ALLOW_NAMESPACE_CACHING", SHARE_1005_ALLOW_NAMESPACE_CACHING, r);
5313         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM", SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM, r);
5314         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_FORCE_LEVELII_OPLOCK", SHARE_1005_FORCE_LEVELII_OPLOCK, r);
5315         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_ENABLE_HASH", SHARE_1005_ENABLE_HASH, r);
5316         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_ENABLE_CA", SHARE_1005_ENABLE_CA, r);
5317         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_ENCRYPT_DATA", SHARE_1005_ENCRYPT_DATA, r);
5318         ndr->depth--;
5319 }
5320
5321 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1005 *r)
5322 {
5323         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5324         if (ndr_flags & NDR_SCALARS) {
5325                 NDR_CHECK(ndr_push_align(ndr, 4));
5326                 NDR_CHECK(ndr_push_NetShareInfo1005Flags(ndr, NDR_SCALARS, r->dfs_flags));
5327                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
5328         }
5329         if (ndr_flags & NDR_BUFFERS) {
5330         }
5331         return NDR_ERR_SUCCESS;
5332 }
5333
5334 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1005 *r)
5335 {
5336         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5337         if (ndr_flags & NDR_SCALARS) {
5338                 NDR_CHECK(ndr_pull_align(ndr, 4));
5339                 NDR_CHECK(ndr_pull_NetShareInfo1005Flags(ndr, NDR_SCALARS, &r->dfs_flags));
5340                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
5341         }
5342         if (ndr_flags & NDR_BUFFERS) {
5343         }
5344         return NDR_ERR_SUCCESS;
5345 }
5346
5347 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1005 *r)
5348 {
5349         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1005");
5350         if (r == NULL) { ndr_print_null(ndr); return; }
5351         ndr->depth++;
5352         ndr_print_NetShareInfo1005Flags(ndr, "dfs_flags", r->dfs_flags);
5353         ndr->depth--;
5354 }
5355
5356 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1005 *r)
5357 {
5358         uint32_t cntr_array_1;
5359         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5360         if (ndr_flags & NDR_SCALARS) {
5361                 NDR_CHECK(ndr_push_align(ndr, 5));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5364                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5365         }
5366         if (ndr_flags & NDR_BUFFERS) {
5367                 if (r->array) {
5368                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5369                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5370                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5371                         }
5372                 }
5373         }
5374         return NDR_ERR_SUCCESS;
5375 }
5376
5377 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1005 *r)
5378 {
5379         uint32_t _ptr_array;
5380         uint32_t size_array_1 = 0;
5381         uint32_t cntr_array_1;
5382         TALLOC_CTX *_mem_save_array_0;
5383         TALLOC_CTX *_mem_save_array_1;
5384         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5385         if (ndr_flags & NDR_SCALARS) {
5386                 NDR_CHECK(ndr_pull_align(ndr, 5));
5387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5389                 if (_ptr_array) {
5390                         NDR_PULL_ALLOC(ndr, r->array);
5391                 } else {
5392                         r->array = NULL;
5393                 }
5394                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5395         }
5396         if (ndr_flags & NDR_BUFFERS) {
5397                 if (r->array) {
5398                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5399                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5401                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5402                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5403                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5404                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5405                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5406                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5407                         }
5408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5410                 }
5411                 if (r->array) {
5412                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5413                 }
5414         }
5415         return NDR_ERR_SUCCESS;
5416 }
5417
5418 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1005 *r)
5419 {
5420         uint32_t cntr_array_1;
5421         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1005");
5422         if (r == NULL) { ndr_print_null(ndr); return; }
5423         ndr->depth++;
5424         ndr_print_uint32(ndr, "count", r->count);
5425         ndr_print_ptr(ndr, "array", r->array);
5426         ndr->depth++;
5427         if (r->array) {
5428                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5429                 ndr->depth++;
5430                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5431                         ndr_print_srvsvc_NetShareInfo1005(ndr, "array", &r->array[cntr_array_1]);
5432                 }
5433                 ndr->depth--;
5434         }
5435         ndr->depth--;
5436         ndr->depth--;
5437 }
5438
5439 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1006 *r)
5440 {
5441         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5442         if (ndr_flags & NDR_SCALARS) {
5443                 NDR_CHECK(ndr_push_align(ndr, 4));
5444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));
5445                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
5446         }
5447         if (ndr_flags & NDR_BUFFERS) {
5448         }
5449         return NDR_ERR_SUCCESS;
5450 }
5451
5452 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1006 *r)
5453 {
5454         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5455         if (ndr_flags & NDR_SCALARS) {
5456                 NDR_CHECK(ndr_pull_align(ndr, 4));
5457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));
5458                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
5459         }
5460         if (ndr_flags & NDR_BUFFERS) {
5461         }
5462         return NDR_ERR_SUCCESS;
5463 }
5464
5465 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1006 *r)
5466 {
5467         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1006");
5468         if (r == NULL) { ndr_print_null(ndr); return; }
5469         ndr->depth++;
5470         ndr_print_uint32(ndr, "max_users", r->max_users);
5471         ndr->depth--;
5472 }
5473
5474 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1006 *r)
5475 {
5476         uint32_t cntr_array_1;
5477         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5478         if (ndr_flags & NDR_SCALARS) {
5479                 NDR_CHECK(ndr_push_align(ndr, 5));
5480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5482                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5483         }
5484         if (ndr_flags & NDR_BUFFERS) {
5485                 if (r->array) {
5486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5487                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5488                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5489                         }
5490                 }
5491         }
5492         return NDR_ERR_SUCCESS;
5493 }
5494
5495 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1006 *r)
5496 {
5497         uint32_t _ptr_array;
5498         uint32_t size_array_1 = 0;
5499         uint32_t cntr_array_1;
5500         TALLOC_CTX *_mem_save_array_0;
5501         TALLOC_CTX *_mem_save_array_1;
5502         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5503         if (ndr_flags & NDR_SCALARS) {
5504                 NDR_CHECK(ndr_pull_align(ndr, 5));
5505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5507                 if (_ptr_array) {
5508                         NDR_PULL_ALLOC(ndr, r->array);
5509                 } else {
5510                         r->array = NULL;
5511                 }
5512                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5513         }
5514         if (ndr_flags & NDR_BUFFERS) {
5515                 if (r->array) {
5516                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5517                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5519                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5520                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5521                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5522                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5523                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5524                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5525                         }
5526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5528                 }
5529                 if (r->array) {
5530                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5531                 }
5532         }
5533         return NDR_ERR_SUCCESS;
5534 }
5535
5536 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1006 *r)
5537 {
5538         uint32_t cntr_array_1;
5539         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1006");
5540         if (r == NULL) { ndr_print_null(ndr); return; }
5541         ndr->depth++;
5542         ndr_print_uint32(ndr, "count", r->count);
5543         ndr_print_ptr(ndr, "array", r->array);
5544         ndr->depth++;
5545         if (r->array) {
5546                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5547                 ndr->depth++;
5548                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5549                         ndr_print_srvsvc_NetShareInfo1006(ndr, "array", &r->array[cntr_array_1]);
5550                 }
5551                 ndr->depth--;
5552         }
5553         ndr->depth--;
5554         ndr->depth--;
5555 }
5556
5557 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1007 *r)
5558 {
5559         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5560         if (ndr_flags & NDR_SCALARS) {
5561                 NDR_CHECK(ndr_push_align(ndr, 5));
5562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5563                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alternate_directory_name));
5564                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5565         }
5566         if (ndr_flags & NDR_BUFFERS) {
5567                 if (r->alternate_directory_name) {
5568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));
5571                         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));
5572                 }
5573         }
5574         return NDR_ERR_SUCCESS;
5575 }
5576
5577 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1007 *r)
5578 {
5579         uint32_t _ptr_alternate_directory_name;
5580         uint32_t size_alternate_directory_name_1 = 0;
5581         uint32_t length_alternate_directory_name_1 = 0;
5582         TALLOC_CTX *_mem_save_alternate_directory_name_0;
5583         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5584         if (ndr_flags & NDR_SCALARS) {
5585                 NDR_CHECK(ndr_pull_align(ndr, 5));
5586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alternate_directory_name));
5588                 if (_ptr_alternate_directory_name) {
5589                         NDR_PULL_ALLOC(ndr, r->alternate_directory_name);
5590                 } else {
5591                         r->alternate_directory_name = NULL;
5592                 }
5593                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5594         }
5595         if (ndr_flags & NDR_BUFFERS) {
5596                 if (r->alternate_directory_name) {
5597                         _mem_save_alternate_directory_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5598                         NDR_PULL_SET_MEM_CTX(ndr, r->alternate_directory_name, 0);
5599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alternate_directory_name));
5600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alternate_directory_name));
5601                         size_alternate_directory_name_1 = ndr_get_array_size(ndr, &r->alternate_directory_name);
5602                         length_alternate_directory_name_1 = ndr_get_array_length(ndr, &r->alternate_directory_name);
5603                         if (length_alternate_directory_name_1 > size_alternate_directory_name_1) {
5604                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_alternate_directory_name_1, length_alternate_directory_name_1);
5605                         }
5606                         NDR_CHECK(ndr_check_string_terminator(ndr, length_alternate_directory_name_1, sizeof(uint16_t)));
5607                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alternate_directory_name, length_alternate_directory_name_1, sizeof(uint16_t), CH_UTF16));
5608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alternate_directory_name_0, 0);
5609                 }
5610         }
5611         return NDR_ERR_SUCCESS;
5612 }
5613
5614 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1007 *r)
5615 {
5616         ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1007");
5617         if (r == NULL) { ndr_print_null(ndr); return; }
5618         ndr->depth++;
5619         ndr_print_uint32(ndr, "flags", r->flags);
5620         ndr_print_ptr(ndr, "alternate_directory_name", r->alternate_directory_name);
5621         ndr->depth++;
5622         if (r->alternate_directory_name) {
5623                 ndr_print_string(ndr, "alternate_directory_name", r->alternate_directory_name);
5624         }
5625         ndr->depth--;
5626         ndr->depth--;
5627 }
5628
5629 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1007 *r)
5630 {
5631         uint32_t cntr_array_1;
5632         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5633         if (ndr_flags & NDR_SCALARS) {
5634                 NDR_CHECK(ndr_push_align(ndr, 5));
5635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5637                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5638         }
5639         if (ndr_flags & NDR_BUFFERS) {
5640                 if (r->array) {
5641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5642                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5643                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5644                         }
5645                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5646                                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5647                         }
5648                 }
5649         }
5650         return NDR_ERR_SUCCESS;
5651 }
5652
5653 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1007 *r)
5654 {
5655         uint32_t _ptr_array;
5656         uint32_t size_array_1 = 0;
5657         uint32_t cntr_array_1;
5658         TALLOC_CTX *_mem_save_array_0;
5659         TALLOC_CTX *_mem_save_array_1;
5660         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5661         if (ndr_flags & NDR_SCALARS) {
5662                 NDR_CHECK(ndr_pull_align(ndr, 5));
5663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5665                 if (_ptr_array) {
5666                         NDR_PULL_ALLOC(ndr, r->array);
5667                 } else {
5668                         r->array = NULL;
5669                 }
5670                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5671         }
5672         if (ndr_flags & NDR_BUFFERS) {
5673                 if (r->array) {
5674                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5675                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5677                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5678                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5679                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5680                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5681                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5682                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5683                         }
5684                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5685                                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5686                         }
5687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5689                 }
5690                 if (r->array) {
5691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5692                 }
5693         }
5694         return NDR_ERR_SUCCESS;
5695 }
5696
5697 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1007 *r)
5698 {
5699         uint32_t cntr_array_1;
5700         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1007");
5701         if (r == NULL) { ndr_print_null(ndr); return; }
5702         ndr->depth++;
5703         ndr_print_uint32(ndr, "count", r->count);
5704         ndr_print_ptr(ndr, "array", r->array);
5705         ndr->depth++;
5706         if (r->array) {
5707                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5708                 ndr->depth++;
5709                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5710                         ndr_print_srvsvc_NetShareInfo1007(ndr, "array", &r->array[cntr_array_1]);
5711                 }
5712                 ndr->depth--;
5713         }
5714         ndr->depth--;
5715         ndr->depth--;
5716 }
5717
5718 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1501 *r)
5719 {
5720         uint32_t cntr_array_1;
5721         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5722         if (ndr_flags & NDR_SCALARS) {
5723                 NDR_CHECK(ndr_push_align(ndr, 5));
5724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5726                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5727         }
5728         if (ndr_flags & NDR_BUFFERS) {
5729                 if (r->array) {
5730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5731                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5732                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5733                         }
5734                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5735                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5736                         }
5737                 }
5738         }
5739         return NDR_ERR_SUCCESS;
5740 }
5741
5742 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1501 *r)
5743 {
5744         uint32_t _ptr_array;
5745         uint32_t size_array_1 = 0;
5746         uint32_t cntr_array_1;
5747         TALLOC_CTX *_mem_save_array_0;
5748         TALLOC_CTX *_mem_save_array_1;
5749         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5750         if (ndr_flags & NDR_SCALARS) {
5751                 NDR_CHECK(ndr_pull_align(ndr, 5));
5752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5754                 if (_ptr_array) {
5755                         NDR_PULL_ALLOC(ndr, r->array);
5756                 } else {
5757                         r->array = NULL;
5758                 }
5759                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5760         }
5761         if (ndr_flags & NDR_BUFFERS) {
5762                 if (r->array) {
5763                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5764                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5766                         size_array_1 = ndr_get_array_size(ndr, &r->array);
5767                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
5768                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5769                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5770                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5771                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5772                         }
5773                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
5774                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5775                         }
5776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5778                 }
5779                 if (r->array) {
5780                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5781                 }
5782         }
5783         return NDR_ERR_SUCCESS;
5784 }
5785
5786 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1501 *r)
5787 {
5788         uint32_t cntr_array_1;
5789         ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1501");
5790         if (r == NULL) { ndr_print_null(ndr); return; }
5791         ndr->depth++;
5792         ndr_print_uint32(ndr, "count", r->count);
5793         ndr_print_ptr(ndr, "array", r->array);
5794         ndr->depth++;
5795         if (r->array) {
5796                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
5797                 ndr->depth++;
5798                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
5799                         ndr_print_sec_desc_buf(ndr, "array", &r->array[cntr_array_1]);
5800                 }
5801                 ndr->depth--;
5802         }
5803         ndr->depth--;
5804         ndr->depth--;
5805 }
5806
5807 static enum ndr_err_code ndr_push_srvsvc_NetShareInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareInfo *r)
5808 {
5809         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
5810         if (ndr_flags & NDR_SCALARS) {
5811                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5812                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5814                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5815                 switch (level) {
5816                         case 0: {
5817                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
5818                         break; }
5819
5820                         case 1: {
5821                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5822                         break; }
5823
5824                         case 2: {
5825                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5826                         break; }
5827
5828                         case 501: {
5829                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info501));
5830                         break; }
5831
5832                         case 502: {
5833                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
5834                         break; }
5835
5836                         case 1004: {
5837                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1004));
5838                         break; }
5839
5840                         case 1005: {
5841                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
5842                         break; }
5843
5844                         case 1006: {
5845                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1006));
5846                         break; }
5847
5848                         case 1007: {
5849                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1007));
5850                         break; }
5851
5852                         case 1501: {
5853                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
5854                         break; }
5855
5856                         default: {
5857                         break; }
5858
5859                 }
5860         }
5861         if (ndr_flags & NDR_BUFFERS) {
5862                 uint32_t level = ndr_push_get_switch_value(ndr, r);
5863                 switch (level) {
5864                         case 0:
5865                                 if (r->info0) {
5866                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5867                                 }
5868                         break;
5869
5870                         case 1:
5871                                 if (r->info1) {
5872                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5873                                 }
5874                         break;
5875
5876                         case 2:
5877                                 if (r->info2) {
5878                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5879                                 }
5880                         break;
5881
5882                         case 501:
5883                                 if (r->info501) {
5884                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
5885                                 }
5886                         break;
5887
5888                         case 502:
5889                                 if (r->info502) {
5890                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
5891                                 }
5892                         break;
5893
5894                         case 1004:
5895                                 if (r->info1004) {
5896                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
5897                                 }
5898                         break;
5899
5900                         case 1005:
5901                                 if (r->info1005) {
5902                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
5903                                 }
5904                         break;
5905
5906                         case 1006:
5907                                 if (r->info1006) {
5908                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
5909                                 }
5910                         break;
5911
5912                         case 1007:
5913                                 if (r->info1007) {
5914                                         NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
5915                                 }
5916                         break;
5917
5918                         case 1501:
5919                                 if (r->info1501) {
5920                                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
5921                                 }
5922                         break;
5923
5924                         default:
5925                         break;
5926
5927                 }
5928         }
5929         return NDR_ERR_SUCCESS;
5930 }
5931
5932 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareInfo *r)
5933 {
5934         uint32_t level;
5935         uint32_t _level;
5936         TALLOC_CTX *_mem_save_info0_0;
5937         uint32_t _ptr_info0;
5938         TALLOC_CTX *_mem_save_info1_0;
5939         uint32_t _ptr_info1;
5940         TALLOC_CTX *_mem_save_info2_0;
5941         uint32_t _ptr_info2;
5942         TALLOC_CTX *_mem_save_info501_0;
5943         uint32_t _ptr_info501;
5944         TALLOC_CTX *_mem_save_info502_0;
5945         uint32_t _ptr_info502;
5946         TALLOC_CTX *_mem_save_info1004_0;
5947         uint32_t _ptr_info1004;
5948         TALLOC_CTX *_mem_save_info1005_0;
5949         uint32_t _ptr_info1005;
5950         TALLOC_CTX *_mem_save_info1006_0;
5951         uint32_t _ptr_info1006;
5952         TALLOC_CTX *_mem_save_info1007_0;
5953         uint32_t _ptr_info1007;
5954         TALLOC_CTX *_mem_save_info1501_0;
5955         uint32_t _ptr_info1501;
5956         level = ndr_pull_get_switch_value(ndr, r);
5957         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
5958         if (ndr_flags & NDR_SCALARS) {
5959                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5961                 if (_level != level) {
5962                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5963                 }
5964                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5965                 switch (level) {
5966                         case 0: {
5967                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
5968                                 if (_ptr_info0) {
5969                                         NDR_PULL_ALLOC(ndr, r->info0);
5970                                 } else {
5971                                         r->info0 = NULL;
5972                                 }
5973                         break; }
5974
5975                         case 1: {
5976                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5977                                 if (_ptr_info1) {
5978                                         NDR_PULL_ALLOC(ndr, r->info1);
5979                                 } else {
5980                                         r->info1 = NULL;
5981                                 }
5982                         break; }
5983
5984                         case 2: {
5985                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5986                                 if (_ptr_info2) {
5987                                         NDR_PULL_ALLOC(ndr, r->info2);
5988                                 } else {
5989                                         r->info2 = NULL;
5990                                 }
5991                         break; }
5992
5993                         case 501: {
5994                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info501));
5995                                 if (_ptr_info501) {
5996                                         NDR_PULL_ALLOC(ndr, r->info501);
5997                                 } else {
5998                                         r->info501 = NULL;
5999                                 }
6000                         break; }
6001
6002                         case 502: {
6003                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
6004                                 if (_ptr_info502) {
6005                                         NDR_PULL_ALLOC(ndr, r->info502);
6006                                 } else {
6007                                         r->info502 = NULL;
6008                                 }
6009                         break; }
6010
6011                         case 1004: {
6012                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1004));
6013                                 if (_ptr_info1004) {
6014                                         NDR_PULL_ALLOC(ndr, r->info1004);
6015                                 } else {
6016                                         r->info1004 = NULL;
6017                                 }
6018                         break; }
6019
6020                         case 1005: {
6021                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
6022                                 if (_ptr_info1005) {
6023                                         NDR_PULL_ALLOC(ndr, r->info1005);
6024                                 } else {
6025                                         r->info1005 = NULL;
6026                                 }
6027                         break; }
6028
6029                         case 1006: {
6030                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1006));
6031                                 if (_ptr_info1006) {
6032                                         NDR_PULL_ALLOC(ndr, r->info1006);
6033                                 } else {
6034                                         r->info1006 = NULL;
6035                                 }
6036                         break; }
6037
6038                         case 1007: {
6039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1007));
6040                                 if (_ptr_info1007) {
6041                                         NDR_PULL_ALLOC(ndr, r->info1007);
6042                                 } else {
6043                                         r->info1007 = NULL;
6044                                 }
6045                         break; }
6046
6047                         case 1501: {
6048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
6049                                 if (_ptr_info1501) {
6050                                         NDR_PULL_ALLOC(ndr, r->info1501);
6051                                 } else {
6052                                         r->info1501 = NULL;
6053                                 }
6054                         break; }
6055
6056                         default: {
6057                         break; }
6058
6059                 }
6060         }
6061         if (ndr_flags & NDR_BUFFERS) {
6062                 switch (level) {
6063                         case 0:
6064                                 if (r->info0) {
6065                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6066                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
6067                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6068                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
6069                                 }
6070                         break;
6071
6072                         case 1:
6073                                 if (r->info1) {
6074                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6075                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6076                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6077                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6078                                 }
6079                         break;
6080
6081                         case 2:
6082                                 if (r->info2) {
6083                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6084                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6085                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6086                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6087                                 }
6088                         break;
6089
6090                         case 501:
6091                                 if (r->info501) {
6092                                         _mem_save_info501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6093                                         NDR_PULL_SET_MEM_CTX(ndr, r->info501, 0);
6094                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));
6095                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info501_0, 0);
6096                                 }
6097                         break;
6098
6099                         case 502:
6100                                 if (r->info502) {
6101                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
6102                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
6103                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));
6104                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
6105                                 }
6106                         break;
6107
6108                         case 1004:
6109                                 if (r->info1004) {
6110                                         _mem_save_info1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
6111                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1004, 0);
6112                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));
6113                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1004_0, 0);
6114                                 }
6115                         break;
6116
6117                         case 1005:
6118                                 if (r->info1005) {
6119                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
6120                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
6121                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));
6122                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
6123                                 }
6124                         break;
6125
6126                         case 1006:
6127                                 if (r->info1006) {
6128                                         _mem_save_info1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
6129                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1006, 0);
6130                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));
6131                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1006_0, 0);
6132                                 }
6133                         break;
6134
6135                         case 1007:
6136                                 if (r->info1007) {
6137                                         _mem_save_info1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
6138                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1007, 0);
6139                                         NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));
6140                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1007_0, 0);
6141                                 }
6142                         break;
6143
6144                         case 1501:
6145                                 if (r->info1501) {
6146                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6147                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
6148                                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));
6149                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
6150                                 }
6151                         break;
6152
6153                         default:
6154                         break;
6155
6156                 }
6157         }
6158         return NDR_ERR_SUCCESS;
6159 }
6160
6161 _PUBLIC_ void ndr_print_srvsvc_NetShareInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareInfo *r)
6162 {
6163         uint32_t level;
6164         level = ndr_print_get_switch_value(ndr, r);
6165         ndr_print_union(ndr, name, level, "srvsvc_NetShareInfo");
6166         switch (level) {
6167                 case 0:
6168                         ndr_print_ptr(ndr, "info0", r->info0);
6169                         ndr->depth++;
6170                         if (r->info0) {
6171                                 ndr_print_srvsvc_NetShareInfo0(ndr, "info0", r->info0);
6172                         }
6173                         ndr->depth--;
6174                 break;
6175
6176                 case 1:
6177                         ndr_print_ptr(ndr, "info1", r->info1);
6178                         ndr->depth++;
6179                         if (r->info1) {
6180                                 ndr_print_srvsvc_NetShareInfo1(ndr, "info1", r->info1);
6181                         }
6182                         ndr->depth--;
6183                 break;
6184
6185                 case 2:
6186                         ndr_print_ptr(ndr, "info2", r->info2);
6187                         ndr->depth++;
6188                         if (r->info2) {
6189                                 ndr_print_srvsvc_NetShareInfo2(ndr, "info2", r->info2);
6190                         }
6191                         ndr->depth--;
6192                 break;
6193
6194                 case 501:
6195                         ndr_print_ptr(ndr, "info501", r->info501);
6196                         ndr->depth++;
6197                         if (r->info501) {
6198                                 ndr_print_srvsvc_NetShareInfo501(ndr, "info501", r->info501);
6199                         }
6200                         ndr->depth--;
6201                 break;
6202
6203                 case 502:
6204                         ndr_print_ptr(ndr, "info502", r->info502);
6205                         ndr->depth++;
6206                         if (r->info502) {
6207                                 ndr_print_srvsvc_NetShareInfo502(ndr, "info502", r->info502);
6208                         }
6209                         ndr->depth--;
6210                 break;
6211
6212                 case 1004:
6213                         ndr_print_ptr(ndr, "info1004", r->info1004);
6214                         ndr->depth++;
6215                         if (r->info1004) {
6216                                 ndr_print_srvsvc_NetShareInfo1004(ndr, "info1004", r->info1004);
6217                         }
6218                         ndr->depth--;
6219                 break;
6220
6221                 case 1005:
6222                         ndr_print_ptr(ndr, "info1005", r->info1005);
6223                         ndr->depth++;
6224                         if (r->info1005) {
6225                                 ndr_print_srvsvc_NetShareInfo1005(ndr, "info1005", r->info1005);
6226                         }
6227                         ndr->depth--;
6228                 break;
6229
6230                 case 1006:
6231                         ndr_print_ptr(ndr, "info1006", r->info1006);
6232                         ndr->depth++;
6233                         if (r->info1006) {
6234                                 ndr_print_srvsvc_NetShareInfo1006(ndr, "info1006", r->info1006);
6235                         }
6236                         ndr->depth--;
6237                 break;
6238
6239                 case 1007:
6240                         ndr_print_ptr(ndr, "info1007", r->info1007);
6241                         ndr->depth++;
6242                         if (r->info1007) {
6243                                 ndr_print_srvsvc_NetShareInfo1007(ndr, "info1007", r->info1007);
6244                         }
6245                         ndr->depth--;
6246                 break;
6247
6248                 case 1501:
6249                         ndr_print_ptr(ndr, "info1501", r->info1501);
6250                         ndr->depth++;
6251                         if (r->info1501) {
6252                                 ndr_print_sec_desc_buf(ndr, "info1501", r->info1501);
6253                         }
6254                         ndr->depth--;
6255                 break;
6256
6257                 default:
6258                 break;
6259
6260         }
6261 }
6262
6263 static enum ndr_err_code ndr_push_srvsvc_NetShareCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareCtr *r)
6264 {
6265         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
6266         if (ndr_flags & NDR_SCALARS) {
6267                 uint32_t level = ndr_push_get_switch_value(ndr, r);
6268                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6270                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6271                 switch (level) {
6272                         case 0: {
6273                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
6274                         break; }
6275
6276                         case 1: {
6277                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6278                         break; }
6279
6280                         case 2: {
6281                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
6282                         break; }
6283
6284                         case 501: {
6285                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr501));
6286                         break; }
6287
6288                         case 502: {
6289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));
6290                         break; }
6291
6292                         case 1004: {
6293                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1004));
6294                         break; }
6295
6296                         case 1005: {
6297                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1005));
6298                         break; }
6299
6300                         case 1006: {
6301                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1006));
6302                         break; }
6303
6304                         case 1007: {
6305                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1007));
6306                         break; }
6307
6308                         case 1501: {
6309                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1501));
6310                         break; }
6311
6312                         default: {
6313                         break; }
6314
6315                 }
6316         }
6317         if (ndr_flags & NDR_BUFFERS) {
6318                 uint32_t level = ndr_push_get_switch_value(ndr, r);
6319                 switch (level) {
6320                         case 0:
6321                                 if (r->ctr0) {
6322                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
6323                                 }
6324                         break;
6325
6326                         case 1:
6327                                 if (r->ctr1) {
6328                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6329                                 }
6330                         break;
6331
6332                         case 2:
6333                                 if (r->ctr2) {
6334                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
6335                                 }
6336                         break;
6337
6338                         case 501:
6339                                 if (r->ctr501) {
6340                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
6341                                 }
6342                         break;
6343
6344                         case 502:
6345                                 if (r->ctr502) {
6346                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
6347                                 }
6348                         break;
6349
6350                         case 1004:
6351                                 if (r->ctr1004) {
6352                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
6353                                 }
6354                         break;
6355
6356                         case 1005:
6357                                 if (r->ctr1005) {
6358                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
6359                                 }
6360                         break;
6361
6362                         case 1006:
6363                                 if (r->ctr1006) {
6364                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
6365                                 }
6366                         break;
6367
6368                         case 1007:
6369                                 if (r->ctr1007) {
6370                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
6371                                 }
6372                         break;
6373
6374                         case 1501:
6375                                 if (r->ctr1501) {
6376                                         NDR_CHECK(ndr_push_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
6377                                 }
6378                         break;
6379
6380                         default:
6381                         break;
6382
6383                 }
6384         }
6385         return NDR_ERR_SUCCESS;
6386 }
6387
6388 static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareCtr *r)
6389 {
6390         uint32_t level;
6391         uint32_t _level;
6392         TALLOC_CTX *_mem_save_ctr0_0;
6393         uint32_t _ptr_ctr0;
6394         TALLOC_CTX *_mem_save_ctr1_0;
6395         uint32_t _ptr_ctr1;
6396         TALLOC_CTX *_mem_save_ctr2_0;
6397         uint32_t _ptr_ctr2;
6398         TALLOC_CTX *_mem_save_ctr501_0;
6399         uint32_t _ptr_ctr501;
6400         TALLOC_CTX *_mem_save_ctr502_0;
6401         uint32_t _ptr_ctr502;
6402         TALLOC_CTX *_mem_save_ctr1004_0;
6403         uint32_t _ptr_ctr1004;
6404         TALLOC_CTX *_mem_save_ctr1005_0;
6405         uint32_t _ptr_ctr1005;
6406         TALLOC_CTX *_mem_save_ctr1006_0;
6407         uint32_t _ptr_ctr1006;
6408         TALLOC_CTX *_mem_save_ctr1007_0;
6409         uint32_t _ptr_ctr1007;
6410         TALLOC_CTX *_mem_save_ctr1501_0;
6411         uint32_t _ptr_ctr1501;
6412         level = ndr_pull_get_switch_value(ndr, r);
6413         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
6414         if (ndr_flags & NDR_SCALARS) {
6415                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6417                 if (_level != level) {
6418                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6419                 }
6420                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6421                 switch (level) {
6422                         case 0: {
6423                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
6424                                 if (_ptr_ctr0) {
6425                                         NDR_PULL_ALLOC(ndr, r->ctr0);
6426                                 } else {
6427                                         r->ctr0 = NULL;
6428                                 }
6429                         break; }
6430
6431                         case 1: {
6432                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6433                                 if (_ptr_ctr1) {
6434                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6435                                 } else {
6436                                         r->ctr1 = NULL;
6437                                 }
6438                         break; }
6439
6440                         case 2: {
6441                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
6442                                 if (_ptr_ctr2) {
6443                                         NDR_PULL_ALLOC(ndr, r->ctr2);
6444                                 } else {
6445                                         r->ctr2 = NULL;
6446                                 }
6447                         break; }
6448
6449                         case 501: {
6450                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr501));
6451                                 if (_ptr_ctr501) {
6452                                         NDR_PULL_ALLOC(ndr, r->ctr501);
6453                                 } else {
6454                                         r->ctr501 = NULL;
6455                                 }
6456                         break; }
6457
6458                         case 502: {
6459                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));
6460                                 if (_ptr_ctr502) {
6461                                         NDR_PULL_ALLOC(ndr, r->ctr502);
6462                                 } else {
6463                                         r->ctr502 = NULL;
6464                                 }
6465                         break; }
6466
6467                         case 1004: {
6468                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1004));
6469                                 if (_ptr_ctr1004) {
6470                                         NDR_PULL_ALLOC(ndr, r->ctr1004);
6471                                 } else {
6472                                         r->ctr1004 = NULL;
6473                                 }
6474                         break; }
6475
6476                         case 1005: {
6477                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1005));
6478                                 if (_ptr_ctr1005) {
6479                                         NDR_PULL_ALLOC(ndr, r->ctr1005);
6480                                 } else {
6481                                         r->ctr1005 = NULL;
6482                                 }
6483                         break; }
6484
6485                         case 1006: {
6486                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1006));
6487                                 if (_ptr_ctr1006) {
6488                                         NDR_PULL_ALLOC(ndr, r->ctr1006);
6489                                 } else {
6490                                         r->ctr1006 = NULL;
6491                                 }
6492                         break; }
6493
6494                         case 1007: {
6495                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1007));
6496                                 if (_ptr_ctr1007) {
6497                                         NDR_PULL_ALLOC(ndr, r->ctr1007);
6498                                 } else {
6499                                         r->ctr1007 = NULL;
6500                                 }
6501                         break; }
6502
6503                         case 1501: {
6504                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1501));
6505                                 if (_ptr_ctr1501) {
6506                                         NDR_PULL_ALLOC(ndr, r->ctr1501);
6507                                 } else {
6508                                         r->ctr1501 = NULL;
6509                                 }
6510                         break; }
6511
6512                         default: {
6513                         break; }
6514
6515                 }
6516         }
6517         if (ndr_flags & NDR_BUFFERS) {
6518                 switch (level) {
6519                         case 0:
6520                                 if (r->ctr0) {
6521                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
6522                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
6523                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
6524                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
6525                                 }
6526                         break;
6527
6528                         case 1:
6529                                 if (r->ctr1) {
6530                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6531                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6532                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6533                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6534                                 }
6535                         break;
6536
6537                         case 2:
6538                                 if (r->ctr2) {
6539                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6540                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
6541                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
6542                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
6543                                 }
6544                         break;
6545
6546                         case 501:
6547                                 if (r->ctr501) {
6548                                         _mem_save_ctr501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6549                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr501, 0);
6550                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));
6551                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr501_0, 0);
6552                                 }
6553                         break;
6554
6555                         case 502:
6556                                 if (r->ctr502) {
6557                                         _mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);
6558                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);
6559                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));
6560                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);
6561                                 }
6562                         break;
6563
6564                         case 1004:
6565                                 if (r->ctr1004) {
6566                                         _mem_save_ctr1004_0 = NDR_PULL_GET_MEM_CTX(ndr);
6567                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1004, 0);
6568                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));
6569                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1004_0, 0);
6570                                 }
6571                         break;
6572
6573                         case 1005:
6574                                 if (r->ctr1005) {
6575                                         _mem_save_ctr1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
6576                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1005, 0);
6577                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));
6578                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1005_0, 0);
6579                                 }
6580                         break;
6581
6582                         case 1006:
6583                                 if (r->ctr1006) {
6584                                         _mem_save_ctr1006_0 = NDR_PULL_GET_MEM_CTX(ndr);
6585                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1006, 0);
6586                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));
6587                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1006_0, 0);
6588                                 }
6589                         break;
6590
6591                         case 1007:
6592                                 if (r->ctr1007) {
6593                                         _mem_save_ctr1007_0 = NDR_PULL_GET_MEM_CTX(ndr);
6594                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1007, 0);
6595                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));
6596                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1007_0, 0);
6597                                 }
6598                         break;
6599
6600                         case 1501:
6601                                 if (r->ctr1501) {
6602                                         _mem_save_ctr1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
6603                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1501, 0);
6604                                         NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));
6605                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1501_0, 0);
6606                                 }
6607                         break;
6608
6609                         default:
6610                         break;
6611
6612                 }
6613         }
6614         return NDR_ERR_SUCCESS;
6615 }
6616
6617 _PUBLIC_ void ndr_print_srvsvc_NetShareCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareCtr *r)
6618 {
6619         uint32_t level;
6620         level = ndr_print_get_switch_value(ndr, r);
6621         ndr_print_union(ndr, name, level, "srvsvc_NetShareCtr");
6622         switch (level) {
6623                 case 0:
6624                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
6625                         ndr->depth++;
6626                         if (r->ctr0) {
6627                                 ndr_print_srvsvc_NetShareCtr0(ndr, "ctr0", r->ctr0);
6628                         }
6629                         ndr->depth--;
6630                 break;
6631
6632                 case 1:
6633                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6634                         ndr->depth++;
6635                         if (r->ctr1) {
6636                                 ndr_print_srvsvc_NetShareCtr1(ndr, "ctr1", r->ctr1);
6637                         }
6638                         ndr->depth--;
6639                 break;
6640
6641                 case 2:
6642                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
6643                         ndr->depth++;
6644                         if (r->ctr2) {
6645                                 ndr_print_srvsvc_NetShareCtr2(ndr, "ctr2", r->ctr2);
6646                         }
6647                         ndr->depth--;
6648                 break;
6649
6650                 case 501:
6651                         ndr_print_ptr(ndr, "ctr501", r->ctr501);
6652                         ndr->depth++;
6653                         if (r->ctr501) {
6654                                 ndr_print_srvsvc_NetShareCtr501(ndr, "ctr501", r->ctr501);
6655                         }
6656                         ndr->depth--;
6657                 break;
6658
6659                 case 502:
6660                         ndr_print_ptr(ndr, "ctr502", r->ctr502);
6661                         ndr->depth++;
6662                         if (r->ctr502) {
6663                                 ndr_print_srvsvc_NetShareCtr502(ndr, "ctr502", r->ctr502);
6664                         }
6665                         ndr->depth--;
6666                 break;
6667
6668                 case 1004:
6669                         ndr_print_ptr(ndr, "ctr1004", r->ctr1004);
6670                         ndr->depth++;
6671                         if (r->ctr1004) {
6672                                 ndr_print_srvsvc_NetShareCtr1004(ndr, "ctr1004", r->ctr1004);
6673                         }
6674                         ndr->depth--;
6675                 break;
6676
6677                 case 1005:
6678                         ndr_print_ptr(ndr, "ctr1005", r->ctr1005);
6679                         ndr->depth++;
6680                         if (r->ctr1005) {
6681                                 ndr_print_srvsvc_NetShareCtr1005(ndr, "ctr1005", r->ctr1005);
6682                         }
6683                         ndr->depth--;
6684                 break;
6685
6686                 case 1006:
6687                         ndr_print_ptr(ndr, "ctr1006", r->ctr1006);
6688                         ndr->depth++;
6689                         if (r->ctr1006) {
6690                                 ndr_print_srvsvc_NetShareCtr1006(ndr, "ctr1006", r->ctr1006);
6691                         }
6692                         ndr->depth--;
6693                 break;
6694
6695                 case 1007:
6696                         ndr_print_ptr(ndr, "ctr1007", r->ctr1007);
6697                         ndr->depth++;
6698                         if (r->ctr1007) {
6699                                 ndr_print_srvsvc_NetShareCtr1007(ndr, "ctr1007", r->ctr1007);
6700                         }
6701                         ndr->depth--;
6702                 break;
6703
6704                 case 1501:
6705                         ndr_print_ptr(ndr, "ctr1501", r->ctr1501);
6706                         ndr->depth++;
6707                         if (r->ctr1501) {
6708                                 ndr_print_srvsvc_NetShareCtr1501(ndr, "ctr1501", r->ctr1501);
6709                         }
6710                         ndr->depth--;
6711                 break;
6712
6713                 default:
6714                 break;
6715
6716         }
6717 }
6718
6719 static enum ndr_err_code ndr_push_srvsvc_NetShareInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfoCtr *r)
6720 {
6721         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
6722         if (ndr_flags & NDR_SCALARS) {
6723                 NDR_CHECK(ndr_push_align(ndr, 5));
6724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6725                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
6726                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6727                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6728         }
6729         if (ndr_flags & NDR_BUFFERS) {
6730                 NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6731         }
6732         return NDR_ERR_SUCCESS;
6733 }
6734
6735 static enum ndr_err_code ndr_pull_srvsvc_NetShareInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfoCtr *r)
6736 {
6737         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
6738         if (ndr_flags & NDR_SCALARS) {
6739                 NDR_CHECK(ndr_pull_align(ndr, 5));
6740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6741                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
6742                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));
6743                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6744         }
6745         if (ndr_flags & NDR_BUFFERS) {
6746                 NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));
6747         }
6748         return NDR_ERR_SUCCESS;
6749 }
6750
6751 _PUBLIC_ void ndr_print_srvsvc_NetShareInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfoCtr *r)
6752 {
6753         ndr_print_struct(ndr, name, "srvsvc_NetShareInfoCtr");
6754         if (r == NULL) { ndr_print_null(ndr); return; }
6755         ndr->depth++;
6756         ndr_print_uint32(ndr, "level", r->level);
6757         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
6758         ndr_print_srvsvc_NetShareCtr(ndr, "ctr", &r->ctr);
6759         ndr->depth--;
6760 }
6761
6762 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_PlatformId(struct ndr_push *ndr, int ndr_flags, enum srvsvc_PlatformId r)
6763 {
6764         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6765         return NDR_ERR_SUCCESS;
6766 }
6767
6768 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_PlatformId(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_PlatformId *r)
6769 {
6770         uint32_t v;
6771         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6772         *r = v;
6773         return NDR_ERR_SUCCESS;
6774 }
6775
6776 _PUBLIC_ void ndr_print_srvsvc_PlatformId(struct ndr_print *ndr, const char *name, enum srvsvc_PlatformId r)
6777 {
6778         const char *val = NULL;
6779
6780         switch (r) {
6781                 case PLATFORM_ID_DOS: val = "PLATFORM_ID_DOS"; break;
6782                 case PLATFORM_ID_OS2: val = "PLATFORM_ID_OS2"; break;
6783                 case PLATFORM_ID_NT: val = "PLATFORM_ID_NT"; break;
6784                 case PLATFORM_ID_OSF: val = "PLATFORM_ID_OSF"; break;
6785                 case PLATFORM_ID_VMS: val = "PLATFORM_ID_VMS"; break;
6786         }
6787         ndr_print_enum(ndr, name, "ENUM", val, r);
6788 }
6789
6790 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo100(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo100 *r)
6791 {
6792         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
6793         if (ndr_flags & NDR_SCALARS) {
6794                 NDR_CHECK(ndr_push_align(ndr, 5));
6795                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6797                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6798         }
6799         if (ndr_flags & NDR_BUFFERS) {
6800                 if (r->server_name) {
6801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6804                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6805                 }
6806         }
6807         return NDR_ERR_SUCCESS;
6808 }
6809
6810 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo100(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo100 *r)
6811 {
6812         uint32_t _ptr_server_name;
6813         uint32_t size_server_name_1 = 0;
6814         uint32_t length_server_name_1 = 0;
6815         TALLOC_CTX *_mem_save_server_name_0;
6816         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
6817         if (ndr_flags & NDR_SCALARS) {
6818                 NDR_CHECK(ndr_pull_align(ndr, 5));
6819                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6821                 if (_ptr_server_name) {
6822                         NDR_PULL_ALLOC(ndr, r->server_name);
6823                 } else {
6824                         r->server_name = NULL;
6825                 }
6826                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6827         }
6828         if (ndr_flags & NDR_BUFFERS) {
6829                 if (r->server_name) {
6830                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6831                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6834                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
6835                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
6836                         if (length_server_name_1 > size_server_name_1) {
6837                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
6838                         }
6839                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
6840                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
6841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6842                 }
6843         }
6844         return NDR_ERR_SUCCESS;
6845 }
6846
6847 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo100(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo100 *r)
6848 {
6849         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo100");
6850         if (r == NULL) { ndr_print_null(ndr); return; }
6851         ndr->depth++;
6852         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6853         ndr_print_ptr(ndr, "server_name", r->server_name);
6854         ndr->depth++;
6855         if (r->server_name) {
6856                 ndr_print_string(ndr, "server_name", r->server_name);
6857         }
6858         ndr->depth--;
6859         ndr->depth--;
6860 }
6861
6862 _PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo101(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo101 *r)
6863 {
6864         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
6865         if (ndr_flags & NDR_SCALARS) {
6866                 NDR_CHECK(ndr_push_align(ndr, 5));
6867                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6871                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6873                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6874         }
6875         if (ndr_flags & NDR_BUFFERS) {
6876                 if (r->server_name) {
6877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6878                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6880                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6881                 }
6882                 if (r->comment) {
6883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6884                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6886                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6887                 }
6888         }
6889         return NDR_ERR_SUCCESS;
6890 }
6891
6892 _PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo101(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo101 *r)
6893 {
6894         uint32_t _ptr_server_name;
6895         uint32_t size_server_name_1 = 0;
6896         uint32_t length_server_name_1 = 0;
6897         TALLOC_CTX *_mem_save_server_name_0;
6898         uint32_t _ptr_comment;
6899         uint32_t size_comment_1 = 0;
6900         uint32_t length_comment_1 = 0;
6901         TALLOC_CTX *_mem_save_comment_0;
6902         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
6903         if (ndr_flags & NDR_SCALARS) {
6904                 NDR_CHECK(ndr_pull_align(ndr, 5));
6905                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
6906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6907                 if (_ptr_server_name) {
6908                         NDR_PULL_ALLOC(ndr, r->server_name);
6909                 } else {
6910                         r->server_name = NULL;
6911                 }
6912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
6913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
6914                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
6915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6916                 if (_ptr_comment) {
6917                         NDR_PULL_ALLOC(ndr, r->comment);
6918                 } else {
6919                         r->comment = NULL;
6920                 }
6921                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6922         }
6923         if (ndr_flags & NDR_BUFFERS) {
6924                 if (r->server_name) {
6925                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6926                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6929                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
6930                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
6931                         if (length_server_name_1 > size_server_name_1) {
6932                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
6933                         }
6934                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
6935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
6936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6937                 }
6938                 if (r->comment) {
6939                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6940                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6942                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6943                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
6944                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
6945                         if (length_comment_1 > size_comment_1) {
6946                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
6947                         }
6948                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
6949                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
6950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6951                 }
6952         }
6953         return NDR_ERR_SUCCESS;
6954 }
6955
6956 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo101(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo101 *r)
6957 {
6958         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo101");
6959         if (r == NULL) { ndr_print_null(ndr); return; }
6960         ndr->depth++;
6961         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
6962         ndr_print_ptr(ndr, "server_name", r->server_name);
6963         ndr->depth++;
6964         if (r->server_name) {
6965                 ndr_print_string(ndr, "server_name", r->server_name);
6966         }
6967         ndr->depth--;
6968         ndr_print_uint32(ndr, "version_major", r->version_major);
6969         ndr_print_uint32(ndr, "version_minor", r->version_minor);
6970         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
6971         ndr_print_ptr(ndr, "comment", r->comment);
6972         ndr->depth++;
6973         if (r->comment) {
6974                 ndr_print_string(ndr, "comment", r->comment);
6975         }
6976         ndr->depth--;
6977         ndr->depth--;
6978 }
6979
6980 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo102(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo102 *r)
6981 {
6982         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
6983         if (ndr_flags & NDR_SCALARS) {
6984                 NDR_CHECK(ndr_push_align(ndr, 5));
6985                 NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));
6986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
6988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
6989                 NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));
6990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
6992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
6993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
6994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
6995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
6996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->licenses));
6997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->userpath));
6998                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6999         }
7000         if (ndr_flags & NDR_BUFFERS) {
7001                 if (r->server_name) {
7002                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
7003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
7005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7006                 }
7007                 if (r->comment) {
7008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7010                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7011                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7012                 }
7013                 if (r->userpath) {
7014                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
7015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));
7017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->userpath, ndr_charset_length(r->userpath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7018                 }
7019         }
7020         return NDR_ERR_SUCCESS;
7021 }
7022
7023 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo102(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo102 *r)
7024 {
7025         uint32_t _ptr_server_name;
7026         uint32_t size_server_name_1 = 0;
7027         uint32_t length_server_name_1 = 0;
7028         TALLOC_CTX *_mem_save_server_name_0;
7029         uint32_t _ptr_comment;
7030         uint32_t size_comment_1 = 0;
7031         uint32_t length_comment_1 = 0;
7032         TALLOC_CTX *_mem_save_comment_0;
7033         uint32_t _ptr_userpath;
7034         uint32_t size_userpath_1 = 0;
7035         uint32_t length_userpath_1 = 0;
7036         TALLOC_CTX *_mem_save_userpath_0;
7037         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
7038         if (ndr_flags & NDR_SCALARS) {
7039                 NDR_CHECK(ndr_pull_align(ndr, 5));
7040                 NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));
7041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
7042                 if (_ptr_server_name) {
7043                         NDR_PULL_ALLOC(ndr, r->server_name);
7044                 } else {
7045                         r->server_name = NULL;
7046                 }
7047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
7048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
7049                 NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));
7050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7051                 if (_ptr_comment) {
7052                         NDR_PULL_ALLOC(ndr, r->comment);
7053                 } else {
7054                         r->comment = NULL;
7055                 }
7056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
7057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
7058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
7059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
7060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
7061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->licenses));
7062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_userpath));
7063                 if (_ptr_userpath) {
7064                         NDR_PULL_ALLOC(ndr, r->userpath);
7065                 } else {
7066                         r->userpath = NULL;
7067                 }
7068                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7069         }
7070         if (ndr_flags & NDR_BUFFERS) {
7071                 if (r->server_name) {
7072                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7073                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
7074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
7075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
7076                         size_server_name_1 = ndr_get_array_size(ndr, &r->server_name);
7077                         length_server_name_1 = ndr_get_array_length(ndr, &r->server_name);
7078                         if (length_server_name_1 > size_server_name_1) {
7079                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_name_1, length_server_name_1);
7080                         }
7081                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_name_1, sizeof(uint16_t)));
7082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, length_server_name_1, sizeof(uint16_t), CH_UTF16));
7083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
7084                 }
7085                 if (r->comment) {
7086                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7087                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7090                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
7091                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
7092                         if (length_comment_1 > size_comment_1) {
7093                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
7094                         }
7095                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
7096                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
7097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7098                 }
7099                 if (r->userpath) {
7100                         _mem_save_userpath_0 = NDR_PULL_GET_MEM_CTX(ndr);
7101                         NDR_PULL_SET_MEM_CTX(ndr, r->userpath, 0);
7102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->userpath));
7103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->userpath));
7104                         size_userpath_1 = ndr_get_array_size(ndr, &r->userpath);
7105                         length_userpath_1 = ndr_get_array_length(ndr, &r->userpath);
7106                         if (length_userpath_1 > size_userpath_1) {
7107                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_userpath_1, length_userpath_1);
7108                         }
7109                         NDR_CHECK(ndr_check_string_terminator(ndr, length_userpath_1, sizeof(uint16_t)));
7110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->userpath, length_userpath_1, sizeof(uint16_t), CH_UTF16));
7111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userpath_0, 0);
7112                 }
7113         }
7114         return NDR_ERR_SUCCESS;
7115 }
7116
7117 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo102(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo102 *r)
7118 {
7119         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo102");
7120         if (r == NULL) { ndr_print_null(ndr); return; }
7121         ndr->depth++;
7122         ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);
7123         ndr_print_ptr(ndr, "server_name", r->server_name);
7124         ndr->depth++;
7125         if (r->server_name) {
7126                 ndr_print_string(ndr, "server_name", r->server_name);
7127         }
7128         ndr->depth--;
7129         ndr_print_uint32(ndr, "version_major", r->version_major);
7130         ndr_print_uint32(ndr, "version_minor", r->version_minor);
7131         ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);
7132         ndr_print_ptr(ndr, "comment", r->comment);
7133         ndr->depth++;
7134         if (r->comment) {
7135                 ndr_print_string(ndr, "comment", r->comment);
7136         }
7137         ndr->depth--;
7138         ndr_print_uint32(ndr, "users", r->users);
7139         ndr_print_uint32(ndr, "disc", r->disc);
7140         ndr_print_uint32(ndr, "hidden", r->hidden);
7141         ndr_print_uint32(ndr, "announce", r->announce);
7142         ndr_print_uint32(ndr, "anndelta", r->anndelta);
7143         ndr_print_uint32(ndr, "licenses", r->licenses);
7144         ndr_print_ptr(ndr, "userpath", r->userpath);
7145         ndr->depth++;
7146         if (r->userpath) {
7147                 ndr_print_string(ndr, "userpath", r->userpath);
7148         }
7149         ndr->depth--;
7150         ndr->depth--;
7151 }
7152
7153 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo402(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo402 *r)
7154 {
7155         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
7156         if (ndr_flags & NDR_SCALARS) {
7157                 NDR_CHECK(ndr_push_align(ndr, 5));
7158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
7159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
7160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
7161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
7162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
7163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
7164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
7165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
7166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
7167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
7168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
7169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
7170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
7171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
7172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
7175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
7177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));
7178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
7180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
7181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
7182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));
7183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
7184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
7185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
7186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
7187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
7188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
7189                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7190         }
7191         if (ndr_flags & NDR_BUFFERS) {
7192                 if (r->alerts) {
7193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
7194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
7196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7197                 }
7198                 if (r->guestaccount) {
7199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
7200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
7202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7203                 }
7204                 if (r->srvheuristics) {
7205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
7206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
7208                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7209                 }
7210         }
7211         return NDR_ERR_SUCCESS;
7212 }
7213
7214 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo402(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo402 *r)
7215 {
7216         uint32_t _ptr_alerts;
7217         uint32_t size_alerts_1 = 0;
7218         uint32_t length_alerts_1 = 0;
7219         TALLOC_CTX *_mem_save_alerts_0;
7220         uint32_t _ptr_guestaccount;
7221         uint32_t size_guestaccount_1 = 0;
7222         uint32_t length_guestaccount_1 = 0;
7223         TALLOC_CTX *_mem_save_guestaccount_0;
7224         uint32_t _ptr_srvheuristics;
7225         uint32_t size_srvheuristics_1 = 0;
7226         uint32_t length_srvheuristics_1 = 0;
7227         TALLOC_CTX *_mem_save_srvheuristics_0;
7228         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
7229         if (ndr_flags & NDR_SCALARS) {
7230                 NDR_CHECK(ndr_pull_align(ndr, 5));
7231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
7232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
7233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
7234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
7235                 if (_ptr_alerts) {
7236                         NDR_PULL_ALLOC(ndr, r->alerts);
7237                 } else {
7238                         r->alerts = NULL;
7239                 }
7240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
7241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
7242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
7243                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
7244                 if (_ptr_guestaccount) {
7245                         NDR_PULL_ALLOC(ndr, r->guestaccount);
7246                 } else {
7247                         r->guestaccount = NULL;
7248                 }
7249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
7250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
7251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
7252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
7253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
7254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
7255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
7258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
7260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));
7261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
7263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
7264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
7265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));
7266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
7267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
7268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
7269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
7270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
7271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
7272                 if (_ptr_srvheuristics) {
7273                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
7274                 } else {
7275                         r->srvheuristics = NULL;
7276                 }
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280                 if (r->alerts) {
7281                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
7282                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
7283                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
7284                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
7285                         size_alerts_1 = ndr_get_array_size(ndr, &r->alerts);
7286                         length_alerts_1 = ndr_get_array_length(ndr, &r->alerts);
7287                         if (length_alerts_1 > size_alerts_1) {
7288                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_alerts_1, length_alerts_1);
7289                         }
7290                         NDR_CHECK(ndr_check_string_terminator(ndr, length_alerts_1, sizeof(uint16_t)));
7291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, length_alerts_1, sizeof(uint16_t), CH_UTF16));
7292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
7293                 }
7294                 if (r->guestaccount) {
7295                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
7296                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
7297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
7298                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
7299                         size_guestaccount_1 = ndr_get_array_size(ndr, &r->guestaccount);
7300                         length_guestaccount_1 = ndr_get_array_length(ndr, &r->guestaccount);
7301                         if (length_guestaccount_1 > size_guestaccount_1) {
7302                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_guestaccount_1, length_guestaccount_1);
7303                         }
7304                         NDR_CHECK(ndr_check_string_terminator(ndr, length_guestaccount_1, sizeof(uint16_t)));
7305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, length_guestaccount_1, sizeof(uint16_t), CH_UTF16));
7306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
7307                 }
7308                 if (r->srvheuristics) {
7309                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
7310                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
7311                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
7312                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
7313                         size_srvheuristics_1 = ndr_get_array_size(ndr, &r->srvheuristics);
7314                         length_srvheuristics_1 = ndr_get_array_length(ndr, &r->srvheuristics);
7315                         if (length_srvheuristics_1 > size_srvheuristics_1) {
7316                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_srvheuristics_1, length_srvheuristics_1);
7317                         }
7318                         NDR_CHECK(ndr_check_string_terminator(ndr, length_srvheuristics_1, sizeof(uint16_t)));
7319                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, length_srvheuristics_1, sizeof(uint16_t), CH_UTF16));
7320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
7321                 }
7322         }
7323         return NDR_ERR_SUCCESS;
7324 }
7325
7326 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo402(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo402 *r)
7327 {
7328         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo402");
7329         if (r == NULL) { ndr_print_null(ndr); return; }
7330         ndr->depth++;
7331         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
7332         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
7333         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
7334         ndr_print_ptr(ndr, "alerts", r->alerts);
7335         ndr->depth++;
7336         if (r->alerts) {
7337                 ndr_print_string(ndr, "alerts", r->alerts);
7338         }
7339         ndr->depth--;
7340         ndr_print_uint32(ndr, "security", r->security);
7341         ndr_print_uint32(ndr, "numadmin", r->numadmin);
7342         ndr_print_uint32(ndr, "lanmask", r->lanmask);
7343         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
7344         ndr->depth++;
7345         if (r->guestaccount) {
7346                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
7347         }
7348         ndr->depth--;
7349         ndr_print_uint32(ndr, "chdevs", r->chdevs);
7350         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
7351         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
7352         ndr_print_uint32(ndr, "connections", r->connections);
7353         ndr_print_uint32(ndr, "shares", r->shares);
7354         ndr_print_uint32(ndr, "openfiles", r->openfiles);
7355         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7356         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7357         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
7358         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7359         ndr_print_uint32(ndr, "activelocks", r->activelocks);
7360         ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);
7361         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7362         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
7363         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
7364         ndr_print_uint32(ndr, "alertsched", r->alertsched);
7365         ndr_print_uint32(ndr, "erroralert", r->erroralert);
7366         ndr_print_uint32(ndr, "logonalert", r->logonalert);
7367         ndr_print_uint32(ndr, "accessalert", r->accessalert);
7368         ndr_print_uint32(ndr, "diskalert", r->diskalert);
7369         ndr_print_uint32(ndr, "netioalert", r->netioalert);
7370         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
7371         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
7372         ndr->depth++;
7373         if (r->srvheuristics) {
7374                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
7375         }
7376         ndr->depth--;
7377         ndr->depth--;
7378 }
7379
7380 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo403(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo403 *r)
7381 {
7382         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
7383         if (ndr_flags & NDR_SCALARS) {
7384                 NDR_CHECK(ndr_push_align(ndr, 5));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));
7386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));
7387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));
7388                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));
7389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));
7390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));
7391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));
7392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));
7393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));
7394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));
7395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));
7396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));
7397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));
7398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));
7399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));
7402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));
7404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));
7405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));
7407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));
7408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
7409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));
7410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));
7411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));
7412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));
7413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));
7414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));
7415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));
7416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditedevents));
7417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditprofile));
7418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->autopath));
7419                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7420         }
7421         if (ndr_flags & NDR_BUFFERS) {
7422                 if (r->alerts) {
7423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
7424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));
7426                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7427                 }
7428                 if (r->guestaccount) {
7429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
7430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));
7432                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7433                 }
7434                 if (r->srvheuristics) {
7435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
7436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));
7438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7439                 }
7440                 if (r->autopath) {
7441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
7442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));
7444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->autopath, ndr_charset_length(r->autopath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7445                 }
7446         }
7447         return NDR_ERR_SUCCESS;
7448 }
7449
7450 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo403(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo403 *r)
7451 {
7452         uint32_t _ptr_alerts;
7453         uint32_t size_alerts_1 = 0;
7454         uint32_t length_alerts_1 = 0;
7455         TALLOC_CTX *_mem_save_alerts_0;
7456         uint32_t _ptr_guestaccount;
7457         uint32_t size_guestaccount_1 = 0;
7458         uint32_t length_guestaccount_1 = 0;
7459         TALLOC_CTX *_mem_save_guestaccount_0;
7460         uint32_t _ptr_srvheuristics;
7461         uint32_t size_srvheuristics_1 = 0;
7462         uint32_t length_srvheuristics_1 = 0;
7463         TALLOC_CTX *_mem_save_srvheuristics_0;
7464         uint32_t _ptr_autopath;
7465         uint32_t size_autopath_1 = 0;
7466         uint32_t length_autopath_1 = 0;
7467         TALLOC_CTX *_mem_save_autopath_0;
7468         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
7469         if (ndr_flags & NDR_SCALARS) {
7470                 NDR_CHECK(ndr_pull_align(ndr, 5));
7471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));
7472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));
7473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));
7474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));
7475                 if (_ptr_alerts) {
7476                         NDR_PULL_ALLOC(ndr, r->alerts);
7477                 } else {
7478                         r->alerts = NULL;
7479                 }
7480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));
7481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));
7482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));
7483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));
7484                 if (_ptr_guestaccount) {
7485                         NDR_PULL_ALLOC(ndr, r->guestaccount);
7486                 } else {
7487                         r->guestaccount = NULL;
7488                 }
7489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));
7490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));
7491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));
7492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));
7493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));
7494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));
7495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));
7498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));
7500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));
7501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));
7503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));
7504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
7505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));
7506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));
7507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));
7508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));
7509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));
7510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));
7511                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));
7512                 if (_ptr_srvheuristics) {
7513                         NDR_PULL_ALLOC(ndr, r->srvheuristics);
7514                 } else {
7515                         r->srvheuristics = NULL;
7516                 }
7517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditedevents));
7518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditprofile));
7519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_autopath));
7520                 if (_ptr_autopath) {
7521                         NDR_PULL_ALLOC(ndr, r->autopath);
7522                 } else {
7523                         r->autopath = NULL;
7524                 }
7525                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7526         }
7527         if (ndr_flags & NDR_BUFFERS) {
7528                 if (r->alerts) {
7529                         _mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);
7530                         NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);
7531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));
7532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));
7533                         size_alerts_1 = ndr_get_array_size(ndr, &r->alerts);
7534                         length_alerts_1 = ndr_get_array_length(ndr, &r->alerts);
7535                         if (length_alerts_1 > size_alerts_1) {
7536                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_alerts_1, length_alerts_1);
7537                         }
7538                         NDR_CHECK(ndr_check_string_terminator(ndr, length_alerts_1, sizeof(uint16_t)));
7539                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, length_alerts_1, sizeof(uint16_t), CH_UTF16));
7540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);
7541                 }
7542                 if (r->guestaccount) {
7543                         _mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);
7544                         NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);
7545                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));
7546                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));
7547                         size_guestaccount_1 = ndr_get_array_size(ndr, &r->guestaccount);
7548                         length_guestaccount_1 = ndr_get_array_length(ndr, &r->guestaccount);
7549                         if (length_guestaccount_1 > size_guestaccount_1) {
7550                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_guestaccount_1, length_guestaccount_1);
7551                         }
7552                         NDR_CHECK(ndr_check_string_terminator(ndr, length_guestaccount_1, sizeof(uint16_t)));
7553                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, length_guestaccount_1, sizeof(uint16_t), CH_UTF16));
7554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);
7555                 }
7556                 if (r->srvheuristics) {
7557                         _mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);
7558                         NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);
7559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));
7560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));
7561                         size_srvheuristics_1 = ndr_get_array_size(ndr, &r->srvheuristics);
7562                         length_srvheuristics_1 = ndr_get_array_length(ndr, &r->srvheuristics);
7563                         if (length_srvheuristics_1 > size_srvheuristics_1) {
7564                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_srvheuristics_1, length_srvheuristics_1);
7565                         }
7566                         NDR_CHECK(ndr_check_string_terminator(ndr, length_srvheuristics_1, sizeof(uint16_t)));
7567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, length_srvheuristics_1, sizeof(uint16_t), CH_UTF16));
7568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);
7569                 }
7570                 if (r->autopath) {
7571                         _mem_save_autopath_0 = NDR_PULL_GET_MEM_CTX(ndr);
7572                         NDR_PULL_SET_MEM_CTX(ndr, r->autopath, 0);
7573                         NDR_CHECK(ndr_pull_array_size(ndr, &r->autopath));
7574                         NDR_CHECK(ndr_pull_array_length(ndr, &r->autopath));
7575                         size_autopath_1 = ndr_get_array_size(ndr, &r->autopath);
7576                         length_autopath_1 = ndr_get_array_length(ndr, &r->autopath);
7577                         if (length_autopath_1 > size_autopath_1) {
7578                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_autopath_1, length_autopath_1);
7579                         }
7580                         NDR_CHECK(ndr_check_string_terminator(ndr, length_autopath_1, sizeof(uint16_t)));
7581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->autopath, length_autopath_1, sizeof(uint16_t), CH_UTF16));
7582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_autopath_0, 0);
7583                 }
7584         }
7585         return NDR_ERR_SUCCESS;
7586 }
7587
7588 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo403(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo403 *r)
7589 {
7590         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo403");
7591         if (r == NULL) { ndr_print_null(ndr); return; }
7592         ndr->depth++;
7593         ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);
7594         ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);
7595         ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);
7596         ndr_print_ptr(ndr, "alerts", r->alerts);
7597         ndr->depth++;
7598         if (r->alerts) {
7599                 ndr_print_string(ndr, "alerts", r->alerts);
7600         }
7601         ndr->depth--;
7602         ndr_print_uint32(ndr, "security", r->security);
7603         ndr_print_uint32(ndr, "numadmin", r->numadmin);
7604         ndr_print_uint32(ndr, "lanmask", r->lanmask);
7605         ndr_print_ptr(ndr, "guestaccount", r->guestaccount);
7606         ndr->depth++;
7607         if (r->guestaccount) {
7608                 ndr_print_string(ndr, "guestaccount", r->guestaccount);
7609         }
7610         ndr->depth--;
7611         ndr_print_uint32(ndr, "chdevs", r->chdevs);
7612         ndr_print_uint32(ndr, "chdevqs", r->chdevqs);
7613         ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);
7614         ndr_print_uint32(ndr, "connections", r->connections);
7615         ndr_print_uint32(ndr, "shares", r->shares);
7616         ndr_print_uint32(ndr, "openfiles", r->openfiles);
7617         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7618         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7619         ndr_print_uint32(ndr, "sessreqs", r->sessreqs);
7620         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7621         ndr_print_uint32(ndr, "activelocks", r->activelocks);
7622         ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);
7623         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7624         ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);
7625         ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);
7626         ndr_print_uint32(ndr, "alertsched", r->alertsched);
7627         ndr_print_uint32(ndr, "erroralert", r->erroralert);
7628         ndr_print_uint32(ndr, "logonalert", r->logonalert);
7629         ndr_print_uint32(ndr, "accessalert", r->accessalert);
7630         ndr_print_uint32(ndr, "diskalert", r->diskalert);
7631         ndr_print_uint32(ndr, "netioalert", r->netioalert);
7632         ndr_print_uint32(ndr, "maxaudits", r->maxaudits);
7633         ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);
7634         ndr->depth++;
7635         if (r->srvheuristics) {
7636                 ndr_print_string(ndr, "srvheuristics", r->srvheuristics);
7637         }
7638         ndr->depth--;
7639         ndr_print_uint32(ndr, "auditedevents", r->auditedevents);
7640         ndr_print_uint32(ndr, "auditprofile", r->auditprofile);
7641         ndr_print_ptr(ndr, "autopath", r->autopath);
7642         ndr->depth++;
7643         if (r->autopath) {
7644                 ndr_print_string(ndr, "autopath", r->autopath);
7645         }
7646         ndr->depth--;
7647         ndr->depth--;
7648 }
7649
7650 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo502 *r)
7651 {
7652         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
7653         if (ndr_flags & NDR_SCALARS) {
7654                 NDR_CHECK(ndr_push_align(ndr, 4));
7655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7673                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7674         }
7675         if (ndr_flags & NDR_BUFFERS) {
7676         }
7677         return NDR_ERR_SUCCESS;
7678 }
7679
7680 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo502 *r)
7681 {
7682         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
7683         if (ndr_flags & NDR_SCALARS) {
7684                 NDR_CHECK(ndr_pull_align(ndr, 4));
7685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7703                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7704         }
7705         if (ndr_flags & NDR_BUFFERS) {
7706         }
7707         return NDR_ERR_SUCCESS;
7708 }
7709
7710 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo502 *r)
7711 {
7712         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo502");
7713         if (r == NULL) { ndr_print_null(ndr); return; }
7714         ndr->depth++;
7715         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7716         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7717         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7718         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7719         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7720         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7721         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7722         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7723         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7724         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7725         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7726         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7727         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7728         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7729         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7730         ndr_print_uint32(ndr, "timesource", r->timesource);
7731         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7732         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7733         ndr->depth--;
7734 }
7735
7736 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo503 *r)
7737 {
7738         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
7739         if (ndr_flags & NDR_SCALARS) {
7740                 NDR_CHECK(ndr_push_align(ndr, 5));
7741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
7764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7783                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7784         }
7785         if (ndr_flags & NDR_BUFFERS) {
7786                 if (r->domain) {
7787                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7790                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7791                 }
7792         }
7793         return NDR_ERR_SUCCESS;
7794 }
7795
7796 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo503 *r)
7797 {
7798         uint32_t _ptr_domain;
7799         uint32_t size_domain_1 = 0;
7800         uint32_t length_domain_1 = 0;
7801         TALLOC_CTX *_mem_save_domain_0;
7802         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
7803         if (ndr_flags & NDR_SCALARS) {
7804                 NDR_CHECK(ndr_pull_align(ndr, 5));
7805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
7806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
7807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
7808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
7809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
7810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
7811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
7812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
7813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
7814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
7815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
7816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
7817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
7818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
7819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
7820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
7821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
7822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
7823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
7824                 if (_ptr_domain) {
7825                         NDR_PULL_ALLOC(ndr, r->domain);
7826                 } else {
7827                         r->domain = NULL;
7828                 }
7829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
7830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
7831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
7832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
7833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
7834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
7835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
7836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
7837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
7838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
7839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
7840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
7841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
7842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
7843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
7844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
7845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
7846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
7847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
7848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
7849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
7850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
7851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
7852                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7853         }
7854         if (ndr_flags & NDR_BUFFERS) {
7855                 if (r->domain) {
7856                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
7857                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
7858                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
7859                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
7860                         size_domain_1 = ndr_get_array_size(ndr, &r->domain);
7861                         length_domain_1 = ndr_get_array_length(ndr, &r->domain);
7862                         if (length_domain_1 > size_domain_1) {
7863                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_1, length_domain_1);
7864                         }
7865                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_1, sizeof(uint16_t)));
7866                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, length_domain_1, sizeof(uint16_t), CH_UTF16));
7867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
7868                 }
7869         }
7870         return NDR_ERR_SUCCESS;
7871 }
7872
7873 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo503 *r)
7874 {
7875         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo503");
7876         if (r == NULL) { ndr_print_null(ndr); return; }
7877         ndr->depth++;
7878         ndr_print_uint32(ndr, "sessopen", r->sessopen);
7879         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
7880         ndr_print_uint32(ndr, "opensearch", r->opensearch);
7881         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
7882         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
7883         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
7884         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
7885         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
7886         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
7887         ndr_print_uint32(ndr, "sessusers", r->sessusers);
7888         ndr_print_uint32(ndr, "sessconns", r->sessconns);
7889         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
7890         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
7891         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
7892         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
7893         ndr_print_uint32(ndr, "timesource", r->timesource);
7894         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
7895         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
7896         ndr_print_ptr(ndr, "domain", r->domain);
7897         ndr->depth++;
7898         if (r->domain) {
7899                 ndr_print_string(ndr, "domain", r->domain);
7900         }
7901         ndr->depth--;
7902         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
7903         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
7904         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
7905         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
7906         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
7907         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
7908         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
7909         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
7910         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
7911         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
7912         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
7913         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
7914         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
7915         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
7916         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
7917         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
7918         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
7919         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
7920         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
7921         ndr_print_uint32(ndr, "enableraw", r->enableraw);
7922         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
7923         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
7924         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
7925         ndr->depth--;
7926 }
7927
7928 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo599(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo599 *r)
7929 {
7930         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
7931         if (ndr_flags & NDR_SCALARS) {
7932                 NDR_CHECK(ndr_push_align(ndr, 5));
7933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));
7934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));
7935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
7936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));
7937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));
7938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
7939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));
7940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));
7941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
7942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
7943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));
7944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
7945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
7946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
7947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
7948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
7949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));
7950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
7951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
7952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
7953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
7954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
7955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
7956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
7957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));
7958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));
7959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
7960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
7961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
7962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));
7963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));
7964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
7965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
7966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
7967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
7968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
7969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
7970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
7971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
7972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
7973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
7974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
7975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
7976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
7977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
7978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
7979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
7980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
7981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
7982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
7983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
7984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
7985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
7986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
7987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
7988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7989         }
7990         if (ndr_flags & NDR_BUFFERS) {
7991                 if (r->domain) {
7992                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
7995                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7996                 }
7997         }
7998         return NDR_ERR_SUCCESS;
7999 }
8000
8001 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo599(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo599 *r)
8002 {
8003         uint32_t _ptr_domain;
8004         uint32_t size_domain_1 = 0;
8005         uint32_t length_domain_1 = 0;
8006         TALLOC_CTX *_mem_save_domain_0;
8007         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8008         if (ndr_flags & NDR_SCALARS) {
8009                 NDR_CHECK(ndr_pull_align(ndr, 5));
8010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));
8011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));
8012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
8013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));
8014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));
8015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
8016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));
8017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));
8018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
8019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
8020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));
8021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
8022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
8023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
8024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
8025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
8026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));
8027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
8028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
8029                 if (_ptr_domain) {
8030                         NDR_PULL_ALLOC(ndr, r->domain);
8031                 } else {
8032                         r->domain = NULL;
8033                 }
8034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
8035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
8036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
8037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
8038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
8039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));
8040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));
8041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
8042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
8043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
8044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));
8045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));
8046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
8047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
8048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
8049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
8050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
8051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
8052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
8053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
8054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
8055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
8056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
8057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
8058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
8059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
8060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
8061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
8062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
8063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
8064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
8065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
8066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
8067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
8068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
8069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
8070                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8071         }
8072         if (ndr_flags & NDR_BUFFERS) {
8073                 if (r->domain) {
8074                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
8075                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
8076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
8077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
8078                         size_domain_1 = ndr_get_array_size(ndr, &r->domain);
8079                         length_domain_1 = ndr_get_array_length(ndr, &r->domain);
8080                         if (length_domain_1 > size_domain_1) {
8081                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_1, length_domain_1);
8082                         }
8083                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_1, sizeof(uint16_t)));
8084                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, length_domain_1, sizeof(uint16_t), CH_UTF16));
8085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
8086                 }
8087         }
8088         return NDR_ERR_SUCCESS;
8089 }
8090
8091 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo599(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo599 *r)
8092 {
8093         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo599");
8094         if (r == NULL) { ndr_print_null(ndr); return; }
8095         ndr->depth++;
8096         ndr_print_uint32(ndr, "sessopen", r->sessopen);
8097         ndr_print_uint32(ndr, "sesssvc", r->sesssvc);
8098         ndr_print_uint32(ndr, "opensearch", r->opensearch);
8099         ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);
8100         ndr_print_uint32(ndr, "initworkitems", r->initworkitems);
8101         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
8102         ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);
8103         ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);
8104         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
8105         ndr_print_uint32(ndr, "sessusers", r->sessusers);
8106         ndr_print_uint32(ndr, "sessconns", r->sessconns);
8107         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
8108         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
8109         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
8110         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
8111         ndr_print_uint32(ndr, "timesource", r->timesource);
8112         ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);
8113         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
8114         ndr_print_ptr(ndr, "domain", r->domain);
8115         ndr->depth++;
8116         if (r->domain) {
8117                 ndr_print_string(ndr, "domain", r->domain);
8118         }
8119         ndr->depth--;
8120         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
8121         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
8122         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
8123         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
8124         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
8125         ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);
8126         ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);
8127         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
8128         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
8129         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
8130         ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);
8131         ndr_print_uint32(ndr, "threadpriority", r->threadpriority);
8132         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
8133         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
8134         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
8135         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
8136         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
8137         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
8138         ndr_print_uint32(ndr, "enableraw", r->enableraw);
8139         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
8140         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
8141         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
8142         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
8143         ndr_print_uint32(ndr, "initconntable", r->initconntable);
8144         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
8145         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
8146         ndr_print_uint32(ndr, "alertsched", r->alertsched);
8147         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
8148         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
8149         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
8150         ndr_print_uint32(ndr, "reserved", r->reserved);
8151         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
8152         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
8153         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
8154         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
8155         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
8156         ndr->depth--;
8157 }
8158
8159 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1005 *r)
8160 {
8161         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8162         if (ndr_flags & NDR_SCALARS) {
8163                 NDR_CHECK(ndr_push_align(ndr, 5));
8164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
8165                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8166         }
8167         if (ndr_flags & NDR_BUFFERS) {
8168                 if (r->comment) {
8169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
8170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
8172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8173                 }
8174         }
8175         return NDR_ERR_SUCCESS;
8176 }
8177
8178 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1005 *r)
8179 {
8180         uint32_t _ptr_comment;
8181         uint32_t size_comment_1 = 0;
8182         uint32_t length_comment_1 = 0;
8183         TALLOC_CTX *_mem_save_comment_0;
8184         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8185         if (ndr_flags & NDR_SCALARS) {
8186                 NDR_CHECK(ndr_pull_align(ndr, 5));
8187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
8188                 if (_ptr_comment) {
8189                         NDR_PULL_ALLOC(ndr, r->comment);
8190                 } else {
8191                         r->comment = NULL;
8192                 }
8193                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8194         }
8195         if (ndr_flags & NDR_BUFFERS) {
8196                 if (r->comment) {
8197                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
8198                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
8199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
8200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
8201                         size_comment_1 = ndr_get_array_size(ndr, &r->comment);
8202                         length_comment_1 = ndr_get_array_length(ndr, &r->comment);
8203                         if (length_comment_1 > size_comment_1) {
8204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_comment_1, length_comment_1);
8205                         }
8206                         NDR_CHECK(ndr_check_string_terminator(ndr, length_comment_1, sizeof(uint16_t)));
8207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, length_comment_1, sizeof(uint16_t), CH_UTF16));
8208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
8209                 }
8210         }
8211         return NDR_ERR_SUCCESS;
8212 }
8213
8214 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1005 *r)
8215 {
8216         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1005");
8217         if (r == NULL) { ndr_print_null(ndr); return; }
8218         ndr->depth++;
8219         ndr_print_ptr(ndr, "comment", r->comment);
8220         ndr->depth++;
8221         if (r->comment) {
8222                 ndr_print_string(ndr, "comment", r->comment);
8223         }
8224         ndr->depth--;
8225         ndr->depth--;
8226 }
8227
8228 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1010(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1010 *r)
8229 {
8230         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8231         if (ndr_flags & NDR_SCALARS) {
8232                 NDR_CHECK(ndr_push_align(ndr, 4));
8233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));
8234                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8235         }
8236         if (ndr_flags & NDR_BUFFERS) {
8237         }
8238         return NDR_ERR_SUCCESS;
8239 }
8240
8241 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1010(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1010 *r)
8242 {
8243         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8244         if (ndr_flags & NDR_SCALARS) {
8245                 NDR_CHECK(ndr_pull_align(ndr, 4));
8246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));
8247                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8248         }
8249         if (ndr_flags & NDR_BUFFERS) {
8250         }
8251         return NDR_ERR_SUCCESS;
8252 }
8253
8254 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1010(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1010 *r)
8255 {
8256         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1010");
8257         if (r == NULL) { ndr_print_null(ndr); return; }
8258         ndr->depth++;
8259         ndr_print_uint32(ndr, "disc", r->disc);
8260         ndr->depth--;
8261 }
8262
8263 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1016(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1016 *r)
8264 {
8265         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8266         if (ndr_flags & NDR_SCALARS) {
8267                 NDR_CHECK(ndr_push_align(ndr, 4));
8268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));
8269                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8270         }
8271         if (ndr_flags & NDR_BUFFERS) {
8272         }
8273         return NDR_ERR_SUCCESS;
8274 }
8275
8276 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1016(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1016 *r)
8277 {
8278         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8279         if (ndr_flags & NDR_SCALARS) {
8280                 NDR_CHECK(ndr_pull_align(ndr, 4));
8281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));
8282                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8283         }
8284         if (ndr_flags & NDR_BUFFERS) {
8285         }
8286         return NDR_ERR_SUCCESS;
8287 }
8288
8289 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1016(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1016 *r)
8290 {
8291         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1016");
8292         if (r == NULL) { ndr_print_null(ndr); return; }
8293         ndr->depth++;
8294         ndr_print_uint32(ndr, "hidden", r->hidden);
8295         ndr->depth--;
8296 }
8297
8298 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1017(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1017 *r)
8299 {
8300         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8301         if (ndr_flags & NDR_SCALARS) {
8302                 NDR_CHECK(ndr_push_align(ndr, 4));
8303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));
8304                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8305         }
8306         if (ndr_flags & NDR_BUFFERS) {
8307         }
8308         return NDR_ERR_SUCCESS;
8309 }
8310
8311 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1017(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1017 *r)
8312 {
8313         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8314         if (ndr_flags & NDR_SCALARS) {
8315                 NDR_CHECK(ndr_pull_align(ndr, 4));
8316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));
8317                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8318         }
8319         if (ndr_flags & NDR_BUFFERS) {
8320         }
8321         return NDR_ERR_SUCCESS;
8322 }
8323
8324 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1017(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1017 *r)
8325 {
8326         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1017");
8327         if (r == NULL) { ndr_print_null(ndr); return; }
8328         ndr->depth++;
8329         ndr_print_uint32(ndr, "announce", r->announce);
8330         ndr->depth--;
8331 }
8332
8333 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1018(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1018 *r)
8334 {
8335         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8336         if (ndr_flags & NDR_SCALARS) {
8337                 NDR_CHECK(ndr_push_align(ndr, 4));
8338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));
8339                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8340         }
8341         if (ndr_flags & NDR_BUFFERS) {
8342         }
8343         return NDR_ERR_SUCCESS;
8344 }
8345
8346 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1018(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1018 *r)
8347 {
8348         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8349         if (ndr_flags & NDR_SCALARS) {
8350                 NDR_CHECK(ndr_pull_align(ndr, 4));
8351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));
8352                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8353         }
8354         if (ndr_flags & NDR_BUFFERS) {
8355         }
8356         return NDR_ERR_SUCCESS;
8357 }
8358
8359 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1018(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1018 *r)
8360 {
8361         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1018");
8362         if (r == NULL) { ndr_print_null(ndr); return; }
8363         ndr->depth++;
8364         ndr_print_uint32(ndr, "anndelta", r->anndelta);
8365         ndr->depth--;
8366 }
8367
8368 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1107(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1107 *r)
8369 {
8370         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8371         if (ndr_flags & NDR_SCALARS) {
8372                 NDR_CHECK(ndr_push_align(ndr, 4));
8373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));
8374                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8375         }
8376         if (ndr_flags & NDR_BUFFERS) {
8377         }
8378         return NDR_ERR_SUCCESS;
8379 }
8380
8381 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1107(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1107 *r)
8382 {
8383         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8384         if (ndr_flags & NDR_SCALARS) {
8385                 NDR_CHECK(ndr_pull_align(ndr, 4));
8386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));
8387                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8388         }
8389         if (ndr_flags & NDR_BUFFERS) {
8390         }
8391         return NDR_ERR_SUCCESS;
8392 }
8393
8394 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1107(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1107 *r)
8395 {
8396         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1107");
8397         if (r == NULL) { ndr_print_null(ndr); return; }
8398         ndr->depth++;
8399         ndr_print_uint32(ndr, "users", r->users);
8400         ndr->depth--;
8401 }
8402
8403 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1501 *r)
8404 {
8405         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8406         if (ndr_flags & NDR_SCALARS) {
8407                 NDR_CHECK(ndr_push_align(ndr, 4));
8408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopens));
8409                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8410         }
8411         if (ndr_flags & NDR_BUFFERS) {
8412         }
8413         return NDR_ERR_SUCCESS;
8414 }
8415
8416 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1501 *r)
8417 {
8418         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8419         if (ndr_flags & NDR_SCALARS) {
8420                 NDR_CHECK(ndr_pull_align(ndr, 4));
8421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopens));
8422                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8423         }
8424         if (ndr_flags & NDR_BUFFERS) {
8425         }
8426         return NDR_ERR_SUCCESS;
8427 }
8428
8429 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1501 *r)
8430 {
8431         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1501");
8432         if (r == NULL) { ndr_print_null(ndr); return; }
8433         ndr->depth++;
8434         ndr_print_uint32(ndr, "sessopens", r->sessopens);
8435         ndr->depth--;
8436 }
8437
8438 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1502 *r)
8439 {
8440         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8441         if (ndr_flags & NDR_SCALARS) {
8442                 NDR_CHECK(ndr_push_align(ndr, 4));
8443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessvcs));
8444                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8445         }
8446         if (ndr_flags & NDR_BUFFERS) {
8447         }
8448         return NDR_ERR_SUCCESS;
8449 }
8450
8451 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1502 *r)
8452 {
8453         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8454         if (ndr_flags & NDR_SCALARS) {
8455                 NDR_CHECK(ndr_pull_align(ndr, 4));
8456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessvcs));
8457                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8458         }
8459         if (ndr_flags & NDR_BUFFERS) {
8460         }
8461         return NDR_ERR_SUCCESS;
8462 }
8463
8464 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1502 *r)
8465 {
8466         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1502");
8467         if (r == NULL) { ndr_print_null(ndr); return; }
8468         ndr->depth++;
8469         ndr_print_uint32(ndr, "sessvcs", r->sessvcs);
8470         ndr->depth--;
8471 }
8472
8473 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1503 *r)
8474 {
8475         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8476         if (ndr_flags & NDR_SCALARS) {
8477                 NDR_CHECK(ndr_push_align(ndr, 4));
8478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));
8479                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8480         }
8481         if (ndr_flags & NDR_BUFFERS) {
8482         }
8483         return NDR_ERR_SUCCESS;
8484 }
8485
8486 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1503 *r)
8487 {
8488         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8489         if (ndr_flags & NDR_SCALARS) {
8490                 NDR_CHECK(ndr_pull_align(ndr, 4));
8491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));
8492                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8493         }
8494         if (ndr_flags & NDR_BUFFERS) {
8495         }
8496         return NDR_ERR_SUCCESS;
8497 }
8498
8499 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1503 *r)
8500 {
8501         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1503");
8502         if (r == NULL) { ndr_print_null(ndr); return; }
8503         ndr->depth++;
8504         ndr_print_uint32(ndr, "opensearch", r->opensearch);
8505         ndr->depth--;
8506 }
8507
8508 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1506(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1506 *r)
8509 {
8510         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8511         if (ndr_flags & NDR_SCALARS) {
8512                 NDR_CHECK(ndr_push_align(ndr, 4));
8513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));
8514                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8515         }
8516         if (ndr_flags & NDR_BUFFERS) {
8517         }
8518         return NDR_ERR_SUCCESS;
8519 }
8520
8521 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1506(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1506 *r)
8522 {
8523         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8524         if (ndr_flags & NDR_SCALARS) {
8525                 NDR_CHECK(ndr_pull_align(ndr, 4));
8526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));
8527                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8528         }
8529         if (ndr_flags & NDR_BUFFERS) {
8530         }
8531         return NDR_ERR_SUCCESS;
8532 }
8533
8534 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1506(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1506 *r)
8535 {
8536         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1506");
8537         if (r == NULL) { ndr_print_null(ndr); return; }
8538         ndr->depth++;
8539         ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);
8540         ndr->depth--;
8541 }
8542
8543 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1509(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1509 *r)
8544 {
8545         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8546         if (ndr_flags & NDR_SCALARS) {
8547                 NDR_CHECK(ndr_push_align(ndr, 4));
8548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));
8549                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8550         }
8551         if (ndr_flags & NDR_BUFFERS) {
8552         }
8553         return NDR_ERR_SUCCESS;
8554 }
8555
8556 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1509(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1509 *r)
8557 {
8558         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8559         if (ndr_flags & NDR_SCALARS) {
8560                 NDR_CHECK(ndr_pull_align(ndr, 4));
8561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));
8562                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8563         }
8564         if (ndr_flags & NDR_BUFFERS) {
8565         }
8566         return NDR_ERR_SUCCESS;
8567 }
8568
8569 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1509(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1509 *r)
8570 {
8571         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1509");
8572         if (r == NULL) { ndr_print_null(ndr); return; }
8573         ndr->depth++;
8574         ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);
8575         ndr->depth--;
8576 }
8577
8578 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1510(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1510 *r)
8579 {
8580         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8581         if (ndr_flags & NDR_SCALARS) {
8582                 NDR_CHECK(ndr_push_align(ndr, 4));
8583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));
8584                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8585         }
8586         if (ndr_flags & NDR_BUFFERS) {
8587         }
8588         return NDR_ERR_SUCCESS;
8589 }
8590
8591 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1510(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1510 *r)
8592 {
8593         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8594         if (ndr_flags & NDR_SCALARS) {
8595                 NDR_CHECK(ndr_pull_align(ndr, 4));
8596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));
8597                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8598         }
8599         if (ndr_flags & NDR_BUFFERS) {
8600         }
8601         return NDR_ERR_SUCCESS;
8602 }
8603
8604 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1510(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1510 *r)
8605 {
8606         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1510");
8607         if (r == NULL) { ndr_print_null(ndr); return; }
8608         ndr->depth++;
8609         ndr_print_uint32(ndr, "sessusers", r->sessusers);
8610         ndr->depth--;
8611 }
8612
8613 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1511(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1511 *r)
8614 {
8615         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8616         if (ndr_flags & NDR_SCALARS) {
8617                 NDR_CHECK(ndr_push_align(ndr, 4));
8618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesscons));
8619                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8620         }
8621         if (ndr_flags & NDR_BUFFERS) {
8622         }
8623         return NDR_ERR_SUCCESS;
8624 }
8625
8626 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1511(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1511 *r)
8627 {
8628         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8629         if (ndr_flags & NDR_SCALARS) {
8630                 NDR_CHECK(ndr_pull_align(ndr, 4));
8631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesscons));
8632                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8633         }
8634         if (ndr_flags & NDR_BUFFERS) {
8635         }
8636         return NDR_ERR_SUCCESS;
8637 }
8638
8639 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1511(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1511 *r)
8640 {
8641         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1511");
8642         if (r == NULL) { ndr_print_null(ndr); return; }
8643         ndr->depth++;
8644         ndr_print_uint32(ndr, "sesscons", r->sesscons);
8645         ndr->depth--;
8646 }
8647
8648 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1512(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1512 *r)
8649 {
8650         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8651         if (ndr_flags & NDR_SCALARS) {
8652                 NDR_CHECK(ndr_push_align(ndr, 4));
8653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));
8654                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8655         }
8656         if (ndr_flags & NDR_BUFFERS) {
8657         }
8658         return NDR_ERR_SUCCESS;
8659 }
8660
8661 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1512(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1512 *r)
8662 {
8663         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8664         if (ndr_flags & NDR_SCALARS) {
8665                 NDR_CHECK(ndr_pull_align(ndr, 4));
8666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));
8667                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8668         }
8669         if (ndr_flags & NDR_BUFFERS) {
8670         }
8671         return NDR_ERR_SUCCESS;
8672 }
8673
8674 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1512(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1512 *r)
8675 {
8676         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1512");
8677         if (r == NULL) { ndr_print_null(ndr); return; }
8678         ndr->depth++;
8679         ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);
8680         ndr->depth--;
8681 }
8682
8683 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1513(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1513 *r)
8684 {
8685         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8686         if (ndr_flags & NDR_SCALARS) {
8687                 NDR_CHECK(ndr_push_align(ndr, 4));
8688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));
8689                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8690         }
8691         if (ndr_flags & NDR_BUFFERS) {
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1513(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1513 *r)
8697 {
8698         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8699         if (ndr_flags & NDR_SCALARS) {
8700                 NDR_CHECK(ndr_pull_align(ndr, 4));
8701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));
8702                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8703         }
8704         if (ndr_flags & NDR_BUFFERS) {
8705         }
8706         return NDR_ERR_SUCCESS;
8707 }
8708
8709 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1513(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1513 *r)
8710 {
8711         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1513");
8712         if (r == NULL) { ndr_print_null(ndr); return; }
8713         ndr->depth++;
8714         ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);
8715         ndr->depth--;
8716 }
8717
8718 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1514(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1514 *r)
8719 {
8720         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8721         if (ndr_flags & NDR_SCALARS) {
8722                 NDR_CHECK(ndr_push_align(ndr, 4));
8723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));
8724                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8725         }
8726         if (ndr_flags & NDR_BUFFERS) {
8727         }
8728         return NDR_ERR_SUCCESS;
8729 }
8730
8731 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1514(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1514 *r)
8732 {
8733         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8734         if (ndr_flags & NDR_SCALARS) {
8735                 NDR_CHECK(ndr_pull_align(ndr, 4));
8736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));
8737                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8738         }
8739         if (ndr_flags & NDR_BUFFERS) {
8740         }
8741         return NDR_ERR_SUCCESS;
8742 }
8743
8744 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1514(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1514 *r)
8745 {
8746         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1514");
8747         if (r == NULL) { ndr_print_null(ndr); return; }
8748         ndr->depth++;
8749         ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);
8750         ndr->depth--;
8751 }
8752
8753 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1515(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1515 *r)
8754 {
8755         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8756         if (ndr_flags & NDR_SCALARS) {
8757                 NDR_CHECK(ndr_push_align(ndr, 4));
8758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));
8759                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8760         }
8761         if (ndr_flags & NDR_BUFFERS) {
8762         }
8763         return NDR_ERR_SUCCESS;
8764 }
8765
8766 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1515(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1515 *r)
8767 {
8768         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8769         if (ndr_flags & NDR_SCALARS) {
8770                 NDR_CHECK(ndr_pull_align(ndr, 4));
8771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));
8772                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8773         }
8774         if (ndr_flags & NDR_BUFFERS) {
8775         }
8776         return NDR_ERR_SUCCESS;
8777 }
8778
8779 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1515(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1515 *r)
8780 {
8781         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1515");
8782         if (r == NULL) { ndr_print_null(ndr); return; }
8783         ndr->depth++;
8784         ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);
8785         ndr->depth--;
8786 }
8787
8788 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1516(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1516 *r)
8789 {
8790         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8791         if (ndr_flags & NDR_SCALARS) {
8792                 NDR_CHECK(ndr_push_align(ndr, 4));
8793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));
8794                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8795         }
8796         if (ndr_flags & NDR_BUFFERS) {
8797         }
8798         return NDR_ERR_SUCCESS;
8799 }
8800
8801 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1516(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1516 *r)
8802 {
8803         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8804         if (ndr_flags & NDR_SCALARS) {
8805                 NDR_CHECK(ndr_pull_align(ndr, 4));
8806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));
8807                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8808         }
8809         if (ndr_flags & NDR_BUFFERS) {
8810         }
8811         return NDR_ERR_SUCCESS;
8812 }
8813
8814 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1516(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1516 *r)
8815 {
8816         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1516");
8817         if (r == NULL) { ndr_print_null(ndr); return; }
8818         ndr->depth++;
8819         ndr_print_uint32(ndr, "timesource", r->timesource);
8820         ndr->depth--;
8821 }
8822
8823 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1518(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1518 *r)
8824 {
8825         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8826         if (ndr_flags & NDR_SCALARS) {
8827                 NDR_CHECK(ndr_push_align(ndr, 4));
8828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));
8829                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8830         }
8831         if (ndr_flags & NDR_BUFFERS) {
8832         }
8833         return NDR_ERR_SUCCESS;
8834 }
8835
8836 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1518(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1518 *r)
8837 {
8838         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8839         if (ndr_flags & NDR_SCALARS) {
8840                 NDR_CHECK(ndr_pull_align(ndr, 4));
8841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));
8842                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8843         }
8844         if (ndr_flags & NDR_BUFFERS) {
8845         }
8846         return NDR_ERR_SUCCESS;
8847 }
8848
8849 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1518(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1518 *r)
8850 {
8851         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1518");
8852         if (r == NULL) { ndr_print_null(ndr); return; }
8853         ndr->depth++;
8854         ndr_print_uint32(ndr, "lmannounce", r->lmannounce);
8855         ndr->depth--;
8856 }
8857
8858 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1520(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1520 *r)
8859 {
8860         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8861         if (ndr_flags & NDR_SCALARS) {
8862                 NDR_CHECK(ndr_push_align(ndr, 4));
8863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));
8864                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8865         }
8866         if (ndr_flags & NDR_BUFFERS) {
8867         }
8868         return NDR_ERR_SUCCESS;
8869 }
8870
8871 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1520(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1520 *r)
8872 {
8873         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8874         if (ndr_flags & NDR_SCALARS) {
8875                 NDR_CHECK(ndr_pull_align(ndr, 4));
8876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));
8877                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8878         }
8879         if (ndr_flags & NDR_BUFFERS) {
8880         }
8881         return NDR_ERR_SUCCESS;
8882 }
8883
8884 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1520(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1520 *r)
8885 {
8886         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1520");
8887         if (r == NULL) { ndr_print_null(ndr); return; }
8888         ndr->depth++;
8889         ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);
8890         ndr->depth--;
8891 }
8892
8893 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1521(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1521 *r)
8894 {
8895         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8896         if (ndr_flags & NDR_SCALARS) {
8897                 NDR_CHECK(ndr_push_align(ndr, 4));
8898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));
8899                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8900         }
8901         if (ndr_flags & NDR_BUFFERS) {
8902         }
8903         return NDR_ERR_SUCCESS;
8904 }
8905
8906 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1521(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1521 *r)
8907 {
8908         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8909         if (ndr_flags & NDR_SCALARS) {
8910                 NDR_CHECK(ndr_pull_align(ndr, 4));
8911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));
8912                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8913         }
8914         if (ndr_flags & NDR_BUFFERS) {
8915         }
8916         return NDR_ERR_SUCCESS;
8917 }
8918
8919 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1521(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1521 *r)
8920 {
8921         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1521");
8922         if (r == NULL) { ndr_print_null(ndr); return; }
8923         ndr->depth++;
8924         ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);
8925         ndr->depth--;
8926 }
8927
8928 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1522(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1522 *r)
8929 {
8930         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8931         if (ndr_flags & NDR_SCALARS) {
8932                 NDR_CHECK(ndr_push_align(ndr, 4));
8933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));
8934                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8935         }
8936         if (ndr_flags & NDR_BUFFERS) {
8937         }
8938         return NDR_ERR_SUCCESS;
8939 }
8940
8941 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1522(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1522 *r)
8942 {
8943         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8944         if (ndr_flags & NDR_SCALARS) {
8945                 NDR_CHECK(ndr_pull_align(ndr, 4));
8946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));
8947                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8948         }
8949         if (ndr_flags & NDR_BUFFERS) {
8950         }
8951         return NDR_ERR_SUCCESS;
8952 }
8953
8954 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1522(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1522 *r)
8955 {
8956         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1522");
8957         if (r == NULL) { ndr_print_null(ndr); return; }
8958         ndr->depth++;
8959         ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);
8960         ndr->depth--;
8961 }
8962
8963 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1523(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1523 *r)
8964 {
8965         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
8966         if (ndr_flags & NDR_SCALARS) {
8967                 NDR_CHECK(ndr_push_align(ndr, 4));
8968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));
8969                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8970         }
8971         if (ndr_flags & NDR_BUFFERS) {
8972         }
8973         return NDR_ERR_SUCCESS;
8974 }
8975
8976 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1523(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1523 *r)
8977 {
8978         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
8979         if (ndr_flags & NDR_SCALARS) {
8980                 NDR_CHECK(ndr_pull_align(ndr, 4));
8981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));
8982                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8983         }
8984         if (ndr_flags & NDR_BUFFERS) {
8985         }
8986         return NDR_ERR_SUCCESS;
8987 }
8988
8989 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1523(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1523 *r)
8990 {
8991         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1523");
8992         if (r == NULL) { ndr_print_null(ndr); return; }
8993         ndr->depth++;
8994         ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);
8995         ndr->depth--;
8996 }
8997
8998 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1524(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1524 *r)
8999 {
9000         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9001         if (ndr_flags & NDR_SCALARS) {
9002                 NDR_CHECK(ndr_push_align(ndr, 4));
9003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));
9004                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9005         }
9006         if (ndr_flags & NDR_BUFFERS) {
9007         }
9008         return NDR_ERR_SUCCESS;
9009 }
9010
9011 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1524(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1524 *r)
9012 {
9013         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9014         if (ndr_flags & NDR_SCALARS) {
9015                 NDR_CHECK(ndr_pull_align(ndr, 4));
9016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));
9017                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9018         }
9019         if (ndr_flags & NDR_BUFFERS) {
9020         }
9021         return NDR_ERR_SUCCESS;
9022 }
9023
9024 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1524(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1524 *r)
9025 {
9026         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1524");
9027         if (r == NULL) { ndr_print_null(ndr); return; }
9028         ndr->depth++;
9029         ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);
9030         ndr->depth--;
9031 }
9032
9033 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1525(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1525 *r)
9034 {
9035         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9036         if (ndr_flags & NDR_SCALARS) {
9037                 NDR_CHECK(ndr_push_align(ndr, 4));
9038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));
9039                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9040         }
9041         if (ndr_flags & NDR_BUFFERS) {
9042         }
9043         return NDR_ERR_SUCCESS;
9044 }
9045
9046 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1525(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1525 *r)
9047 {
9048         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9049         if (ndr_flags & NDR_SCALARS) {
9050                 NDR_CHECK(ndr_pull_align(ndr, 4));
9051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));
9052                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9053         }
9054         if (ndr_flags & NDR_BUFFERS) {
9055         }
9056         return NDR_ERR_SUCCESS;
9057 }
9058
9059 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1525(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1525 *r)
9060 {
9061         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1525");
9062         if (r == NULL) { ndr_print_null(ndr); return; }
9063         ndr->depth++;
9064         ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);
9065         ndr->depth--;
9066 }
9067
9068 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1528(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1528 *r)
9069 {
9070         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9071         if (ndr_flags & NDR_SCALARS) {
9072                 NDR_CHECK(ndr_push_align(ndr, 4));
9073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));
9074                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9075         }
9076         if (ndr_flags & NDR_BUFFERS) {
9077         }
9078         return NDR_ERR_SUCCESS;
9079 }
9080
9081 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1528(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1528 *r)
9082 {
9083         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9084         if (ndr_flags & NDR_SCALARS) {
9085                 NDR_CHECK(ndr_pull_align(ndr, 4));
9086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));
9087                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9088         }
9089         if (ndr_flags & NDR_BUFFERS) {
9090         }
9091         return NDR_ERR_SUCCESS;
9092 }
9093
9094 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1528(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1528 *r)
9095 {
9096         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1528");
9097         if (r == NULL) { ndr_print_null(ndr); return; }
9098         ndr->depth++;
9099         ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);
9100         ndr->depth--;
9101 }
9102
9103 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1529(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1529 *r)
9104 {
9105         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9106         if (ndr_flags & NDR_SCALARS) {
9107                 NDR_CHECK(ndr_push_align(ndr, 4));
9108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));
9109                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9110         }
9111         if (ndr_flags & NDR_BUFFERS) {
9112         }
9113         return NDR_ERR_SUCCESS;
9114 }
9115
9116 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1529(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1529 *r)
9117 {
9118         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9119         if (ndr_flags & NDR_SCALARS) {
9120                 NDR_CHECK(ndr_pull_align(ndr, 4));
9121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));
9122                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9123         }
9124         if (ndr_flags & NDR_BUFFERS) {
9125         }
9126         return NDR_ERR_SUCCESS;
9127 }
9128
9129 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1529(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1529 *r)
9130 {
9131         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1529");
9132         if (r == NULL) { ndr_print_null(ndr); return; }
9133         ndr->depth++;
9134         ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);
9135         ndr->depth--;
9136 }
9137
9138 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1530(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1530 *r)
9139 {
9140         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9141         if (ndr_flags & NDR_SCALARS) {
9142                 NDR_CHECK(ndr_push_align(ndr, 4));
9143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));
9144                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9145         }
9146         if (ndr_flags & NDR_BUFFERS) {
9147         }
9148         return NDR_ERR_SUCCESS;
9149 }
9150
9151 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1530(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1530 *r)
9152 {
9153         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9154         if (ndr_flags & NDR_SCALARS) {
9155                 NDR_CHECK(ndr_pull_align(ndr, 4));
9156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));
9157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9158         }
9159         if (ndr_flags & NDR_BUFFERS) {
9160         }
9161         return NDR_ERR_SUCCESS;
9162 }
9163
9164 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1530(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1530 *r)
9165 {
9166         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1530");
9167         if (r == NULL) { ndr_print_null(ndr); return; }
9168         ndr->depth++;
9169         ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);
9170         ndr->depth--;
9171 }
9172
9173 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1533(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1533 *r)
9174 {
9175         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9176         if (ndr_flags & NDR_SCALARS) {
9177                 NDR_CHECK(ndr_push_align(ndr, 4));
9178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));
9179                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9180         }
9181         if (ndr_flags & NDR_BUFFERS) {
9182         }
9183         return NDR_ERR_SUCCESS;
9184 }
9185
9186 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1533(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1533 *r)
9187 {
9188         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9189         if (ndr_flags & NDR_SCALARS) {
9190                 NDR_CHECK(ndr_pull_align(ndr, 4));
9191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));
9192                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9193         }
9194         if (ndr_flags & NDR_BUFFERS) {
9195         }
9196         return NDR_ERR_SUCCESS;
9197 }
9198
9199 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1533(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1533 *r)
9200 {
9201         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1533");
9202         if (r == NULL) { ndr_print_null(ndr); return; }
9203         ndr->depth++;
9204         ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);
9205         ndr->depth--;
9206 }
9207
9208 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1534(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1534 *r)
9209 {
9210         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9211         if (ndr_flags & NDR_SCALARS) {
9212                 NDR_CHECK(ndr_push_align(ndr, 4));
9213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));
9214                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9215         }
9216         if (ndr_flags & NDR_BUFFERS) {
9217         }
9218         return NDR_ERR_SUCCESS;
9219 }
9220
9221 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1534(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1534 *r)
9222 {
9223         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9224         if (ndr_flags & NDR_SCALARS) {
9225                 NDR_CHECK(ndr_pull_align(ndr, 4));
9226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));
9227                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9228         }
9229         if (ndr_flags & NDR_BUFFERS) {
9230         }
9231         return NDR_ERR_SUCCESS;
9232 }
9233
9234 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1534(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1534 *r)
9235 {
9236         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1534");
9237         if (r == NULL) { ndr_print_null(ndr); return; }
9238         ndr->depth++;
9239         ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);
9240         ndr->depth--;
9241 }
9242
9243 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1535(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1535 *r)
9244 {
9245         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9246         if (ndr_flags & NDR_SCALARS) {
9247                 NDR_CHECK(ndr_push_align(ndr, 4));
9248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));
9249                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9250         }
9251         if (ndr_flags & NDR_BUFFERS) {
9252         }
9253         return NDR_ERR_SUCCESS;
9254 }
9255
9256 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1535(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1535 *r)
9257 {
9258         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9259         if (ndr_flags & NDR_SCALARS) {
9260                 NDR_CHECK(ndr_pull_align(ndr, 4));
9261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));
9262                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9263         }
9264         if (ndr_flags & NDR_BUFFERS) {
9265         }
9266         return NDR_ERR_SUCCESS;
9267 }
9268
9269 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1535(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1535 *r)
9270 {
9271         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1535");
9272         if (r == NULL) { ndr_print_null(ndr); return; }
9273         ndr->depth++;
9274         ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);
9275         ndr->depth--;
9276 }
9277
9278 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1536(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1536 *r)
9279 {
9280         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9281         if (ndr_flags & NDR_SCALARS) {
9282                 NDR_CHECK(ndr_push_align(ndr, 4));
9283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));
9284                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9285         }
9286         if (ndr_flags & NDR_BUFFERS) {
9287         }
9288         return NDR_ERR_SUCCESS;
9289 }
9290
9291 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1536(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1536 *r)
9292 {
9293         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9294         if (ndr_flags & NDR_SCALARS) {
9295                 NDR_CHECK(ndr_pull_align(ndr, 4));
9296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));
9297                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9298         }
9299         if (ndr_flags & NDR_BUFFERS) {
9300         }
9301         return NDR_ERR_SUCCESS;
9302 }
9303
9304 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1536(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1536 *r)
9305 {
9306         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1536");
9307         if (r == NULL) { ndr_print_null(ndr); return; }
9308         ndr->depth++;
9309         ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);
9310         ndr->depth--;
9311 }
9312
9313 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1537(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1537 *r)
9314 {
9315         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9316         if (ndr_flags & NDR_SCALARS) {
9317                 NDR_CHECK(ndr_push_align(ndr, 4));
9318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));
9319                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9320         }
9321         if (ndr_flags & NDR_BUFFERS) {
9322         }
9323         return NDR_ERR_SUCCESS;
9324 }
9325
9326 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1537(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1537 *r)
9327 {
9328         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9329         if (ndr_flags & NDR_SCALARS) {
9330                 NDR_CHECK(ndr_pull_align(ndr, 4));
9331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));
9332                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9333         }
9334         if (ndr_flags & NDR_BUFFERS) {
9335         }
9336         return NDR_ERR_SUCCESS;
9337 }
9338
9339 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1537(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1537 *r)
9340 {
9341         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1537");
9342         if (r == NULL) { ndr_print_null(ndr); return; }
9343         ndr->depth++;
9344         ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);
9345         ndr->depth--;
9346 }
9347
9348 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1538(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1538 *r)
9349 {
9350         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9351         if (ndr_flags & NDR_SCALARS) {
9352                 NDR_CHECK(ndr_push_align(ndr, 4));
9353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));
9354                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9355         }
9356         if (ndr_flags & NDR_BUFFERS) {
9357         }
9358         return NDR_ERR_SUCCESS;
9359 }
9360
9361 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1538(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1538 *r)
9362 {
9363         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9364         if (ndr_flags & NDR_SCALARS) {
9365                 NDR_CHECK(ndr_pull_align(ndr, 4));
9366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));
9367                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9368         }
9369         if (ndr_flags & NDR_BUFFERS) {
9370         }
9371         return NDR_ERR_SUCCESS;
9372 }
9373
9374 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1538(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1538 *r)
9375 {
9376         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1538");
9377         if (r == NULL) { ndr_print_null(ndr); return; }
9378         ndr->depth++;
9379         ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);
9380         ndr->depth--;
9381 }
9382
9383 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1539(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1539 *r)
9384 {
9385         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9386         if (ndr_flags & NDR_SCALARS) {
9387                 NDR_CHECK(ndr_push_align(ndr, 4));
9388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));
9389                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9390         }
9391         if (ndr_flags & NDR_BUFFERS) {
9392         }
9393         return NDR_ERR_SUCCESS;
9394 }
9395
9396 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1539(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1539 *r)
9397 {
9398         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9399         if (ndr_flags & NDR_SCALARS) {
9400                 NDR_CHECK(ndr_pull_align(ndr, 4));
9401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));
9402                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9403         }
9404         if (ndr_flags & NDR_BUFFERS) {
9405         }
9406         return NDR_ERR_SUCCESS;
9407 }
9408
9409 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1539(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1539 *r)
9410 {
9411         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1539");
9412         if (r == NULL) { ndr_print_null(ndr); return; }
9413         ndr->depth++;
9414         ndr_print_uint32(ndr, "enableraw", r->enableraw);
9415         ndr->depth--;
9416 }
9417
9418 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1540(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1540 *r)
9419 {
9420         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9421         if (ndr_flags & NDR_SCALARS) {
9422                 NDR_CHECK(ndr_push_align(ndr, 4));
9423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));
9424                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9425         }
9426         if (ndr_flags & NDR_BUFFERS) {
9427         }
9428         return NDR_ERR_SUCCESS;
9429 }
9430
9431 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1540(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1540 *r)
9432 {
9433         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9434         if (ndr_flags & NDR_SCALARS) {
9435                 NDR_CHECK(ndr_pull_align(ndr, 4));
9436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));
9437                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9438         }
9439         if (ndr_flags & NDR_BUFFERS) {
9440         }
9441         return NDR_ERR_SUCCESS;
9442 }
9443
9444 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1540(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1540 *r)
9445 {
9446         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1540");
9447         if (r == NULL) { ndr_print_null(ndr); return; }
9448         ndr->depth++;
9449         ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);
9450         ndr->depth--;
9451 }
9452
9453 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1541(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1541 *r)
9454 {
9455         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9456         if (ndr_flags & NDR_SCALARS) {
9457                 NDR_CHECK(ndr_push_align(ndr, 4));
9458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));
9459                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9460         }
9461         if (ndr_flags & NDR_BUFFERS) {
9462         }
9463         return NDR_ERR_SUCCESS;
9464 }
9465
9466 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1541(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1541 *r)
9467 {
9468         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9469         if (ndr_flags & NDR_SCALARS) {
9470                 NDR_CHECK(ndr_pull_align(ndr, 4));
9471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));
9472                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9473         }
9474         if (ndr_flags & NDR_BUFFERS) {
9475         }
9476         return NDR_ERR_SUCCESS;
9477 }
9478
9479 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1541(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1541 *r)
9480 {
9481         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1541");
9482         if (r == NULL) { ndr_print_null(ndr); return; }
9483         ndr->depth++;
9484         ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);
9485         ndr->depth--;
9486 }
9487
9488 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1542(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1542 *r)
9489 {
9490         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9491         if (ndr_flags & NDR_SCALARS) {
9492                 NDR_CHECK(ndr_push_align(ndr, 4));
9493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));
9494                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9495         }
9496         if (ndr_flags & NDR_BUFFERS) {
9497         }
9498         return NDR_ERR_SUCCESS;
9499 }
9500
9501 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1542(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1542 *r)
9502 {
9503         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9504         if (ndr_flags & NDR_SCALARS) {
9505                 NDR_CHECK(ndr_pull_align(ndr, 4));
9506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));
9507                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9508         }
9509         if (ndr_flags & NDR_BUFFERS) {
9510         }
9511         return NDR_ERR_SUCCESS;
9512 }
9513
9514 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1542(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1542 *r)
9515 {
9516         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1542");
9517         if (r == NULL) { ndr_print_null(ndr); return; }
9518         ndr->depth++;
9519         ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);
9520         ndr->depth--;
9521 }
9522
9523 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1543(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1543 *r)
9524 {
9525         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9526         if (ndr_flags & NDR_SCALARS) {
9527                 NDR_CHECK(ndr_push_align(ndr, 4));
9528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));
9529                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9530         }
9531         if (ndr_flags & NDR_BUFFERS) {
9532         }
9533         return NDR_ERR_SUCCESS;
9534 }
9535
9536 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1543(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1543 *r)
9537 {
9538         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9539         if (ndr_flags & NDR_SCALARS) {
9540                 NDR_CHECK(ndr_pull_align(ndr, 4));
9541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));
9542                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9543         }
9544         if (ndr_flags & NDR_BUFFERS) {
9545         }
9546         return NDR_ERR_SUCCESS;
9547 }
9548
9549 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1543(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1543 *r)
9550 {
9551         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1543");
9552         if (r == NULL) { ndr_print_null(ndr); return; }
9553         ndr->depth++;
9554         ndr_print_uint32(ndr, "initsesstable", r->initsesstable);
9555         ndr->depth--;
9556 }
9557
9558 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1544(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1544 *r)
9559 {
9560         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9561         if (ndr_flags & NDR_SCALARS) {
9562                 NDR_CHECK(ndr_push_align(ndr, 4));
9563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));
9564                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9565         }
9566         if (ndr_flags & NDR_BUFFERS) {
9567         }
9568         return NDR_ERR_SUCCESS;
9569 }
9570
9571 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1544(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1544 *r)
9572 {
9573         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9574         if (ndr_flags & NDR_SCALARS) {
9575                 NDR_CHECK(ndr_pull_align(ndr, 4));
9576                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));
9577                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9578         }
9579         if (ndr_flags & NDR_BUFFERS) {
9580         }
9581         return NDR_ERR_SUCCESS;
9582 }
9583
9584 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1544(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1544 *r)
9585 {
9586         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1544");
9587         if (r == NULL) { ndr_print_null(ndr); return; }
9588         ndr->depth++;
9589         ndr_print_uint32(ndr, "initconntable", r->initconntable);
9590         ndr->depth--;
9591 }
9592
9593 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1545(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1545 *r)
9594 {
9595         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9596         if (ndr_flags & NDR_SCALARS) {
9597                 NDR_CHECK(ndr_push_align(ndr, 4));
9598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));
9599                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9600         }
9601         if (ndr_flags & NDR_BUFFERS) {
9602         }
9603         return NDR_ERR_SUCCESS;
9604 }
9605
9606 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1545(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1545 *r)
9607 {
9608         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9609         if (ndr_flags & NDR_SCALARS) {
9610                 NDR_CHECK(ndr_pull_align(ndr, 4));
9611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));
9612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9613         }
9614         if (ndr_flags & NDR_BUFFERS) {
9615         }
9616         return NDR_ERR_SUCCESS;
9617 }
9618
9619 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1545(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1545 *r)
9620 {
9621         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1545");
9622         if (r == NULL) { ndr_print_null(ndr); return; }
9623         ndr->depth++;
9624         ndr_print_uint32(ndr, "initfiletable", r->initfiletable);
9625         ndr->depth--;
9626 }
9627
9628 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1546(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1546 *r)
9629 {
9630         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9631         if (ndr_flags & NDR_SCALARS) {
9632                 NDR_CHECK(ndr_push_align(ndr, 4));
9633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));
9634                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9635         }
9636         if (ndr_flags & NDR_BUFFERS) {
9637         }
9638         return NDR_ERR_SUCCESS;
9639 }
9640
9641 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1546(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1546 *r)
9642 {
9643         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9644         if (ndr_flags & NDR_SCALARS) {
9645                 NDR_CHECK(ndr_pull_align(ndr, 4));
9646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));
9647                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9648         }
9649         if (ndr_flags & NDR_BUFFERS) {
9650         }
9651         return NDR_ERR_SUCCESS;
9652 }
9653
9654 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1546(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1546 *r)
9655 {
9656         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1546");
9657         if (r == NULL) { ndr_print_null(ndr); return; }
9658         ndr->depth++;
9659         ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);
9660         ndr->depth--;
9661 }
9662
9663 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1547(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1547 *r)
9664 {
9665         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9666         if (ndr_flags & NDR_SCALARS) {
9667                 NDR_CHECK(ndr_push_align(ndr, 4));
9668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));
9669                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9670         }
9671         if (ndr_flags & NDR_BUFFERS) {
9672         }
9673         return NDR_ERR_SUCCESS;
9674 }
9675
9676 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1547(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1547 *r)
9677 {
9678         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9679         if (ndr_flags & NDR_SCALARS) {
9680                 NDR_CHECK(ndr_pull_align(ndr, 4));
9681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));
9682                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9683         }
9684         if (ndr_flags & NDR_BUFFERS) {
9685         }
9686         return NDR_ERR_SUCCESS;
9687 }
9688
9689 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1547(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1547 *r)
9690 {
9691         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1547");
9692         if (r == NULL) { ndr_print_null(ndr); return; }
9693         ndr->depth++;
9694         ndr_print_uint32(ndr, "alertsched", r->alertsched);
9695         ndr->depth--;
9696 }
9697
9698 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1548(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1548 *r)
9699 {
9700         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9701         if (ndr_flags & NDR_SCALARS) {
9702                 NDR_CHECK(ndr_push_align(ndr, 4));
9703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));
9704                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9705         }
9706         if (ndr_flags & NDR_BUFFERS) {
9707         }
9708         return NDR_ERR_SUCCESS;
9709 }
9710
9711 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1548(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1548 *r)
9712 {
9713         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9714         if (ndr_flags & NDR_SCALARS) {
9715                 NDR_CHECK(ndr_pull_align(ndr, 4));
9716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));
9717                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9718         }
9719         if (ndr_flags & NDR_BUFFERS) {
9720         }
9721         return NDR_ERR_SUCCESS;
9722 }
9723
9724 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1548(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1548 *r)
9725 {
9726         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1548");
9727         if (r == NULL) { ndr_print_null(ndr); return; }
9728         ndr->depth++;
9729         ndr_print_uint32(ndr, "errortreshold", r->errortreshold);
9730         ndr->depth--;
9731 }
9732
9733 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1549(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1549 *r)
9734 {
9735         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9736         if (ndr_flags & NDR_SCALARS) {
9737                 NDR_CHECK(ndr_push_align(ndr, 4));
9738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));
9739                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9740         }
9741         if (ndr_flags & NDR_BUFFERS) {
9742         }
9743         return NDR_ERR_SUCCESS;
9744 }
9745
9746 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1549(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1549 *r)
9747 {
9748         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9749         if (ndr_flags & NDR_SCALARS) {
9750                 NDR_CHECK(ndr_pull_align(ndr, 4));
9751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));
9752                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9753         }
9754         if (ndr_flags & NDR_BUFFERS) {
9755         }
9756         return NDR_ERR_SUCCESS;
9757 }
9758
9759 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1549(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1549 *r)
9760 {
9761         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1549");
9762         if (r == NULL) { ndr_print_null(ndr); return; }
9763         ndr->depth++;
9764         ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);
9765         ndr->depth--;
9766 }
9767
9768 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1550(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1550 *r)
9769 {
9770         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9771         if (ndr_flags & NDR_SCALARS) {
9772                 NDR_CHECK(ndr_push_align(ndr, 4));
9773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));
9774                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9775         }
9776         if (ndr_flags & NDR_BUFFERS) {
9777         }
9778         return NDR_ERR_SUCCESS;
9779 }
9780
9781 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1550(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1550 *r)
9782 {
9783         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9784         if (ndr_flags & NDR_SCALARS) {
9785                 NDR_CHECK(ndr_pull_align(ndr, 4));
9786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));
9787                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9788         }
9789         if (ndr_flags & NDR_BUFFERS) {
9790         }
9791         return NDR_ERR_SUCCESS;
9792 }
9793
9794 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1550(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1550 *r)
9795 {
9796         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1550");
9797         if (r == NULL) { ndr_print_null(ndr); return; }
9798         ndr->depth++;
9799         ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);
9800         ndr->depth--;
9801 }
9802
9803 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1552(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1552 *r)
9804 {
9805         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9806         if (ndr_flags & NDR_SCALARS) {
9807                 NDR_CHECK(ndr_push_align(ndr, 4));
9808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));
9809                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9810         }
9811         if (ndr_flags & NDR_BUFFERS) {
9812         }
9813         return NDR_ERR_SUCCESS;
9814 }
9815
9816 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1552(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1552 *r)
9817 {
9818         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9819         if (ndr_flags & NDR_SCALARS) {
9820                 NDR_CHECK(ndr_pull_align(ndr, 4));
9821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));
9822                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9823         }
9824         if (ndr_flags & NDR_BUFFERS) {
9825         }
9826         return NDR_ERR_SUCCESS;
9827 }
9828
9829 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1552(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1552 *r)
9830 {
9831         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1552");
9832         if (r == NULL) { ndr_print_null(ndr); return; }
9833         ndr->depth++;
9834         ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);
9835         ndr->depth--;
9836 }
9837
9838 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1553(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1553 *r)
9839 {
9840         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9841         if (ndr_flags & NDR_SCALARS) {
9842                 NDR_CHECK(ndr_push_align(ndr, 4));
9843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));
9844                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9845         }
9846         if (ndr_flags & NDR_BUFFERS) {
9847         }
9848         return NDR_ERR_SUCCESS;
9849 }
9850
9851 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1553(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1553 *r)
9852 {
9853         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9854         if (ndr_flags & NDR_SCALARS) {
9855                 NDR_CHECK(ndr_pull_align(ndr, 4));
9856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));
9857                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9858         }
9859         if (ndr_flags & NDR_BUFFERS) {
9860         }
9861         return NDR_ERR_SUCCESS;
9862 }
9863
9864 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1553(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1553 *r)
9865 {
9866         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1553");
9867         if (r == NULL) { ndr_print_null(ndr); return; }
9868         ndr->depth++;
9869         ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);
9870         ndr->depth--;
9871 }
9872
9873 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1554(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1554 *r)
9874 {
9875         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9876         if (ndr_flags & NDR_SCALARS) {
9877                 NDR_CHECK(ndr_push_align(ndr, 4));
9878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));
9879                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9880         }
9881         if (ndr_flags & NDR_BUFFERS) {
9882         }
9883         return NDR_ERR_SUCCESS;
9884 }
9885
9886 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1554(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1554 *r)
9887 {
9888         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9889         if (ndr_flags & NDR_SCALARS) {
9890                 NDR_CHECK(ndr_pull_align(ndr, 4));
9891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));
9892                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9893         }
9894         if (ndr_flags & NDR_BUFFERS) {
9895         }
9896         return NDR_ERR_SUCCESS;
9897 }
9898
9899 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1554(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1554 *r)
9900 {
9901         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1554");
9902         if (r == NULL) { ndr_print_null(ndr); return; }
9903         ndr->depth++;
9904         ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);
9905         ndr->depth--;
9906 }
9907
9908 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1555(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1555 *r)
9909 {
9910         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9911         if (ndr_flags & NDR_SCALARS) {
9912                 NDR_CHECK(ndr_push_align(ndr, 4));
9913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));
9914                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9915         }
9916         if (ndr_flags & NDR_BUFFERS) {
9917         }
9918         return NDR_ERR_SUCCESS;
9919 }
9920
9921 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1555(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1555 *r)
9922 {
9923         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9924         if (ndr_flags & NDR_SCALARS) {
9925                 NDR_CHECK(ndr_pull_align(ndr, 4));
9926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));
9927                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9928         }
9929         if (ndr_flags & NDR_BUFFERS) {
9930         }
9931         return NDR_ERR_SUCCESS;
9932 }
9933
9934 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1555(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1555 *r)
9935 {
9936         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1555");
9937         if (r == NULL) { ndr_print_null(ndr); return; }
9938         ndr->depth++;
9939         ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);
9940         ndr->depth--;
9941 }
9942
9943 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1556(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1556 *r)
9944 {
9945         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9946         if (ndr_flags & NDR_SCALARS) {
9947                 NDR_CHECK(ndr_push_align(ndr, 4));
9948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));
9949                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9950         }
9951         if (ndr_flags & NDR_BUFFERS) {
9952         }
9953         return NDR_ERR_SUCCESS;
9954 }
9955
9956 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1556(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1556 *r)
9957 {
9958         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
9959         if (ndr_flags & NDR_SCALARS) {
9960                 NDR_CHECK(ndr_pull_align(ndr, 4));
9961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));
9962                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9963         }
9964         if (ndr_flags & NDR_BUFFERS) {
9965         }
9966         return NDR_ERR_SUCCESS;
9967 }
9968
9969 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1556(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1556 *r)
9970 {
9971         ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1556");
9972         if (r == NULL) { ndr_print_null(ndr); return; }
9973         ndr->depth++;
9974         ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);
9975         ndr->depth--;
9976 }
9977
9978 static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSrvInfo *r)
9979 {
9980         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
9981         if (ndr_flags & NDR_SCALARS) {
9982                 uint32_t level = ndr_push_get_switch_value(ndr, r);
9983                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9985                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9986                 switch (level) {
9987                         case 100: {
9988                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
9989                         break; }
9990
9991                         case 101: {
9992                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
9993                         break; }
9994
9995                         case 102: {
9996                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
9997                         break; }
9998
9999                         case 402: {
10000                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info402));
10001                         break; }
10002
10003                         case 403: {
10004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info403));
10005                         break; }
10006
10007                         case 502: {
10008                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
10009                         break; }
10010
10011                         case 503: {
10012                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info503));
10013                         break; }
10014
10015                         case 599: {
10016                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info599));
10017                         break; }
10018
10019                         case 1005: {
10020                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));
10021                         break; }
10022
10023                         case 1010: {
10024                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
10025                         break; }
10026
10027                         case 1016: {
10028                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1016));
10029                         break; }
10030
10031                         case 1017: {
10032                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1017));
10033                         break; }
10034
10035                         case 1018: {
10036                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
10037                         break; }
10038
10039                         case 1107: {
10040                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1107));
10041                         break; }
10042
10043                         case 1501: {
10044                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));
10045                         break; }
10046
10047                         case 1502: {
10048                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1502));
10049                         break; }
10050
10051                         case 1503: {
10052                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1503));
10053                         break; }
10054
10055                         case 1506: {
10056                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1506));
10057                         break; }
10058
10059                         case 1509: {
10060                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1509));
10061                         break; }
10062
10063                         case 1510: {
10064                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1510));
10065                         break; }
10066
10067                         case 1511: {
10068                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1511));
10069                         break; }
10070
10071                         case 1512: {
10072                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1512));
10073                         break; }
10074
10075                         case 1513: {
10076                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1513));
10077                         break; }
10078
10079                         case 1514: {
10080                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1514));
10081                         break; }
10082
10083                         case 1515: {
10084                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1515));
10085                         break; }
10086
10087                         case 1516: {
10088                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1516));
10089                         break; }
10090
10091                         case 1518: {
10092                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1518));
10093                         break; }
10094
10095                         case 1520: {
10096                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1520));
10097                         break; }
10098
10099                         case 1521: {
10100                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1521));
10101                         break; }
10102
10103                         case 1522: {
10104                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1522));
10105                         break; }
10106
10107                         case 1523: {
10108                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1523));
10109                         break; }
10110
10111                         case 1524: {
10112                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1524));
10113                         break; }
10114
10115                         case 1525: {
10116                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1525));
10117                         break; }
10118
10119                         case 1528: {
10120                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1528));
10121                         break; }
10122
10123                         case 1529: {
10124                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1529));
10125                         break; }
10126
10127                         case 1530: {
10128                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1530));
10129                         break; }
10130
10131                         case 1533: {
10132                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1533));
10133                         break; }
10134
10135                         case 1534: {
10136                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1534));
10137                         break; }
10138
10139                         case 1535: {
10140                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1535));
10141                         break; }
10142
10143                         case 1536: {
10144                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1536));
10145                         break; }
10146
10147                         case 1537: {
10148                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1537));
10149                         break; }
10150
10151                         case 1538: {
10152                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1538));
10153                         break; }
10154
10155                         case 1539: {
10156                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1539));
10157                         break; }
10158
10159                         case 1540: {
10160                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1540));
10161                         break; }
10162
10163                         case 1541: {
10164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1541));
10165                         break; }
10166
10167                         case 1542: {
10168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1542));
10169                         break; }
10170
10171                         case 1543: {
10172                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1543));
10173                         break; }
10174
10175                         case 1544: {
10176                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1544));
10177                         break; }
10178
10179                         case 1545: {
10180                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1545));
10181                         break; }
10182
10183                         case 1546: {
10184                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1546));
10185                         break; }
10186
10187                         case 1547: {
10188                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1547));
10189                         break; }
10190
10191                         case 1548: {
10192                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1548));
10193                         break; }
10194
10195                         case 1549: {
10196                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1549));
10197                         break; }
10198
10199                         case 1550: {
10200                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1550));
10201                         break; }
10202
10203                         case 1552: {
10204                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1552));
10205                         break; }
10206
10207                         case 1553: {
10208                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1553));
10209                         break; }
10210
10211                         case 1554: {
10212                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1554));
10213                         break; }
10214
10215                         case 1555: {
10216                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1555));
10217                         break; }
10218
10219                         case 1556: {
10220                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1556));
10221                         break; }
10222
10223                         default: {
10224                         break; }
10225
10226                 }
10227         }
10228         if (ndr_flags & NDR_BUFFERS) {
10229                 uint32_t level = ndr_push_get_switch_value(ndr, r);
10230                 switch (level) {
10231                         case 100:
10232                                 if (r->info100) {
10233                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
10234                                 }
10235                         break;
10236
10237                         case 101:
10238                                 if (r->info101) {
10239                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
10240                                 }
10241                         break;
10242
10243                         case 102:
10244                                 if (r->info102) {
10245                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
10246                                 }
10247                         break;
10248
10249                         case 402:
10250                                 if (r->info402) {
10251                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
10252                                 }
10253                         break;
10254
10255                         case 403:
10256                                 if (r->info403) {
10257                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
10258                                 }
10259                         break;
10260
10261                         case 502:
10262                                 if (r->info502) {
10263                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
10264                                 }
10265                         break;
10266
10267                         case 503:
10268                                 if (r->info503) {
10269                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
10270                                 }
10271                         break;
10272
10273                         case 599:
10274                                 if (r->info599) {
10275                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
10276                                 }
10277                         break;
10278
10279                         case 1005:
10280                                 if (r->info1005) {
10281                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
10282                                 }
10283                         break;
10284
10285                         case 1010:
10286                                 if (r->info1010) {
10287                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
10288                                 }
10289                         break;
10290
10291                         case 1016:
10292                                 if (r->info1016) {
10293                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
10294                                 }
10295                         break;
10296
10297                         case 1017:
10298                                 if (r->info1017) {
10299                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
10300                                 }
10301                         break;
10302
10303                         case 1018:
10304                                 if (r->info1018) {
10305                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
10306                                 }
10307                         break;
10308
10309                         case 1107:
10310                                 if (r->info1107) {
10311                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
10312                                 }
10313                         break;
10314
10315                         case 1501:
10316                                 if (r->info1501) {
10317                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
10318                                 }
10319                         break;
10320
10321                         case 1502:
10322                                 if (r->info1502) {
10323                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
10324                                 }
10325                         break;
10326
10327                         case 1503:
10328                                 if (r->info1503) {
10329                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
10330                                 }
10331                         break;
10332
10333                         case 1506:
10334                                 if (r->info1506) {
10335                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
10336                                 }
10337                         break;
10338
10339                         case 1509:
10340                                 if (r->info1509) {
10341                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
10342                                 }
10343                         break;
10344
10345                         case 1510:
10346                                 if (r->info1510) {
10347                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
10348                                 }
10349                         break;
10350
10351                         case 1511:
10352                                 if (r->info1511) {
10353                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
10354                                 }
10355                         break;
10356
10357                         case 1512:
10358                                 if (r->info1512) {
10359                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
10360                                 }
10361                         break;
10362
10363                         case 1513:
10364                                 if (r->info1513) {
10365                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
10366                                 }
10367                         break;
10368
10369                         case 1514:
10370                                 if (r->info1514) {
10371                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
10372                                 }
10373                         break;
10374
10375                         case 1515:
10376                                 if (r->info1515) {
10377                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
10378                                 }
10379                         break;
10380
10381                         case 1516:
10382                                 if (r->info1516) {
10383                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
10384                                 }
10385                         break;
10386
10387                         case 1518:
10388                                 if (r->info1518) {
10389                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
10390                                 }
10391                         break;
10392
10393                         case 1520:
10394                                 if (r->info1520) {
10395                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
10396                                 }
10397                         break;
10398
10399                         case 1521:
10400                                 if (r->info1521) {
10401                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
10402                                 }
10403                         break;
10404
10405                         case 1522:
10406                                 if (r->info1522) {
10407                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
10408                                 }
10409                         break;
10410
10411                         case 1523:
10412                                 if (r->info1523) {
10413                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
10414                                 }
10415                         break;
10416
10417                         case 1524:
10418                                 if (r->info1524) {
10419                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
10420                                 }
10421                         break;
10422
10423                         case 1525:
10424                                 if (r->info1525) {
10425                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
10426                                 }
10427                         break;
10428
10429                         case 1528:
10430                                 if (r->info1528) {
10431                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
10432                                 }
10433                         break;
10434
10435                         case 1529:
10436                                 if (r->info1529) {
10437                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
10438                                 }
10439                         break;
10440
10441                         case 1530:
10442                                 if (r->info1530) {
10443                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
10444                                 }
10445                         break;
10446
10447                         case 1533:
10448                                 if (r->info1533) {
10449                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
10450                                 }
10451                         break;
10452
10453                         case 1534:
10454                                 if (r->info1534) {
10455                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
10456                                 }
10457                         break;
10458
10459                         case 1535:
10460                                 if (r->info1535) {
10461                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
10462                                 }
10463                         break;
10464
10465                         case 1536:
10466                                 if (r->info1536) {
10467                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
10468                                 }
10469                         break;
10470
10471                         case 1537:
10472                                 if (r->info1537) {
10473                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
10474                                 }
10475                         break;
10476
10477                         case 1538:
10478                                 if (r->info1538) {
10479                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
10480                                 }
10481                         break;
10482
10483                         case 1539:
10484                                 if (r->info1539) {
10485                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
10486                                 }
10487                         break;
10488
10489                         case 1540:
10490                                 if (r->info1540) {
10491                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
10492                                 }
10493                         break;
10494
10495                         case 1541:
10496                                 if (r->info1541) {
10497                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
10498                                 }
10499                         break;
10500
10501                         case 1542:
10502                                 if (r->info1542) {
10503                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
10504                                 }
10505                         break;
10506
10507                         case 1543:
10508                                 if (r->info1543) {
10509                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
10510                                 }
10511                         break;
10512
10513                         case 1544:
10514                                 if (r->info1544) {
10515                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
10516                                 }
10517                         break;
10518
10519                         case 1545:
10520                                 if (r->info1545) {
10521                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
10522                                 }
10523                         break;
10524
10525                         case 1546:
10526                                 if (r->info1546) {
10527                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
10528                                 }
10529                         break;
10530
10531                         case 1547:
10532                                 if (r->info1547) {
10533                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
10534                                 }
10535                         break;
10536
10537                         case 1548:
10538                                 if (r->info1548) {
10539                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
10540                                 }
10541                         break;
10542
10543                         case 1549:
10544                                 if (r->info1549) {
10545                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
10546                                 }
10547                         break;
10548
10549                         case 1550:
10550                                 if (r->info1550) {
10551                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
10552                                 }
10553                         break;
10554
10555                         case 1552:
10556                                 if (r->info1552) {
10557                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
10558                                 }
10559                         break;
10560
10561                         case 1553:
10562                                 if (r->info1553) {
10563                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
10564                                 }
10565                         break;
10566
10567                         case 1554:
10568                                 if (r->info1554) {
10569                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
10570                                 }
10571                         break;
10572
10573                         case 1555:
10574                                 if (r->info1555) {
10575                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
10576                                 }
10577                         break;
10578
10579                         case 1556:
10580                                 if (r->info1556) {
10581                                         NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
10582                                 }
10583                         break;
10584
10585                         default:
10586                         break;
10587
10588                 }
10589         }
10590         return NDR_ERR_SUCCESS;
10591 }
10592
10593 static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSrvInfo *r)
10594 {
10595         uint32_t level;
10596         uint32_t _level;
10597         TALLOC_CTX *_mem_save_info100_0;
10598         uint32_t _ptr_info100;
10599         TALLOC_CTX *_mem_save_info101_0;
10600         uint32_t _ptr_info101;
10601         TALLOC_CTX *_mem_save_info102_0;
10602         uint32_t _ptr_info102;
10603         TALLOC_CTX *_mem_save_info402_0;
10604         uint32_t _ptr_info402;
10605         TALLOC_CTX *_mem_save_info403_0;
10606         uint32_t _ptr_info403;
10607         TALLOC_CTX *_mem_save_info502_0;
10608         uint32_t _ptr_info502;
10609         TALLOC_CTX *_mem_save_info503_0;
10610         uint32_t _ptr_info503;
10611         TALLOC_CTX *_mem_save_info599_0;
10612         uint32_t _ptr_info599;
10613         TALLOC_CTX *_mem_save_info1005_0;
10614         uint32_t _ptr_info1005;
10615         TALLOC_CTX *_mem_save_info1010_0;
10616         uint32_t _ptr_info1010;
10617         TALLOC_CTX *_mem_save_info1016_0;
10618         uint32_t _ptr_info1016;
10619         TALLOC_CTX *_mem_save_info1017_0;
10620         uint32_t _ptr_info1017;
10621         TALLOC_CTX *_mem_save_info1018_0;
10622         uint32_t _ptr_info1018;
10623         TALLOC_CTX *_mem_save_info1107_0;
10624         uint32_t _ptr_info1107;
10625         TALLOC_CTX *_mem_save_info1501_0;
10626         uint32_t _ptr_info1501;
10627         TALLOC_CTX *_mem_save_info1502_0;
10628         uint32_t _ptr_info1502;
10629         TALLOC_CTX *_mem_save_info1503_0;
10630         uint32_t _ptr_info1503;
10631         TALLOC_CTX *_mem_save_info1506_0;
10632         uint32_t _ptr_info1506;
10633         TALLOC_CTX *_mem_save_info1509_0;
10634         uint32_t _ptr_info1509;
10635         TALLOC_CTX *_mem_save_info1510_0;
10636         uint32_t _ptr_info1510;
10637         TALLOC_CTX *_mem_save_info1511_0;
10638         uint32_t _ptr_info1511;
10639         TALLOC_CTX *_mem_save_info1512_0;
10640         uint32_t _ptr_info1512;
10641         TALLOC_CTX *_mem_save_info1513_0;
10642         uint32_t _ptr_info1513;
10643         TALLOC_CTX *_mem_save_info1514_0;
10644         uint32_t _ptr_info1514;
10645         TALLOC_CTX *_mem_save_info1515_0;
10646         uint32_t _ptr_info1515;
10647         TALLOC_CTX *_mem_save_info1516_0;
10648         uint32_t _ptr_info1516;
10649         TALLOC_CTX *_mem_save_info1518_0;
10650         uint32_t _ptr_info1518;
10651         TALLOC_CTX *_mem_save_info1520_0;
10652         uint32_t _ptr_info1520;
10653         TALLOC_CTX *_mem_save_info1521_0;
10654         uint32_t _ptr_info1521;
10655         TALLOC_CTX *_mem_save_info1522_0;
10656         uint32_t _ptr_info1522;
10657         TALLOC_CTX *_mem_save_info1523_0;
10658         uint32_t _ptr_info1523;
10659         TALLOC_CTX *_mem_save_info1524_0;
10660         uint32_t _ptr_info1524;
10661         TALLOC_CTX *_mem_save_info1525_0;
10662         uint32_t _ptr_info1525;
10663         TALLOC_CTX *_mem_save_info1528_0;
10664         uint32_t _ptr_info1528;
10665         TALLOC_CTX *_mem_save_info1529_0;
10666         uint32_t _ptr_info1529;
10667         TALLOC_CTX *_mem_save_info1530_0;
10668         uint32_t _ptr_info1530;
10669         TALLOC_CTX *_mem_save_info1533_0;
10670         uint32_t _ptr_info1533;
10671         TALLOC_CTX *_mem_save_info1534_0;
10672         uint32_t _ptr_info1534;
10673         TALLOC_CTX *_mem_save_info1535_0;
10674         uint32_t _ptr_info1535;
10675         TALLOC_CTX *_mem_save_info1536_0;
10676         uint32_t _ptr_info1536;
10677         TALLOC_CTX *_mem_save_info1537_0;
10678         uint32_t _ptr_info1537;
10679         TALLOC_CTX *_mem_save_info1538_0;
10680         uint32_t _ptr_info1538;
10681         TALLOC_CTX *_mem_save_info1539_0;
10682         uint32_t _ptr_info1539;
10683         TALLOC_CTX *_mem_save_info1540_0;
10684         uint32_t _ptr_info1540;
10685         TALLOC_CTX *_mem_save_info1541_0;
10686         uint32_t _ptr_info1541;
10687         TALLOC_CTX *_mem_save_info1542_0;
10688         uint32_t _ptr_info1542;
10689         TALLOC_CTX *_mem_save_info1543_0;
10690         uint32_t _ptr_info1543;
10691         TALLOC_CTX *_mem_save_info1544_0;
10692         uint32_t _ptr_info1544;
10693         TALLOC_CTX *_mem_save_info1545_0;
10694         uint32_t _ptr_info1545;
10695         TALLOC_CTX *_mem_save_info1546_0;
10696         uint32_t _ptr_info1546;
10697         TALLOC_CTX *_mem_save_info1547_0;
10698         uint32_t _ptr_info1547;
10699         TALLOC_CTX *_mem_save_info1548_0;
10700         uint32_t _ptr_info1548;
10701         TALLOC_CTX *_mem_save_info1549_0;
10702         uint32_t _ptr_info1549;
10703         TALLOC_CTX *_mem_save_info1550_0;
10704         uint32_t _ptr_info1550;
10705         TALLOC_CTX *_mem_save_info1552_0;
10706         uint32_t _ptr_info1552;
10707         TALLOC_CTX *_mem_save_info1553_0;
10708         uint32_t _ptr_info1553;
10709         TALLOC_CTX *_mem_save_info1554_0;
10710         uint32_t _ptr_info1554;
10711         TALLOC_CTX *_mem_save_info1555_0;
10712         uint32_t _ptr_info1555;
10713         TALLOC_CTX *_mem_save_info1556_0;
10714         uint32_t _ptr_info1556;
10715         level = ndr_pull_get_switch_value(ndr, r);
10716         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
10717         if (ndr_flags & NDR_SCALARS) {
10718                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10720                 if (_level != level) {
10721                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10722                 }
10723                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10724                 switch (level) {
10725                         case 100: {
10726                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
10727                                 if (_ptr_info100) {
10728                                         NDR_PULL_ALLOC(ndr, r->info100);
10729                                 } else {
10730                                         r->info100 = NULL;
10731                                 }
10732                         break; }
10733
10734                         case 101: {
10735                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
10736                                 if (_ptr_info101) {
10737                                         NDR_PULL_ALLOC(ndr, r->info101);
10738                                 } else {
10739                                         r->info101 = NULL;
10740                                 }
10741                         break; }
10742
10743                         case 102: {
10744                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
10745                                 if (_ptr_info102) {
10746                                         NDR_PULL_ALLOC(ndr, r->info102);
10747                                 } else {
10748                                         r->info102 = NULL;
10749                                 }
10750                         break; }
10751
10752                         case 402: {
10753                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info402));
10754                                 if (_ptr_info402) {
10755                                         NDR_PULL_ALLOC(ndr, r->info402);
10756                                 } else {
10757                                         r->info402 = NULL;
10758                                 }
10759                         break; }
10760
10761                         case 403: {
10762                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info403));
10763                                 if (_ptr_info403) {
10764                                         NDR_PULL_ALLOC(ndr, r->info403);
10765                                 } else {
10766                                         r->info403 = NULL;
10767                                 }
10768                         break; }
10769
10770                         case 502: {
10771                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
10772                                 if (_ptr_info502) {
10773                                         NDR_PULL_ALLOC(ndr, r->info502);
10774                                 } else {
10775                                         r->info502 = NULL;
10776                                 }
10777                         break; }
10778
10779                         case 503: {
10780                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info503));
10781                                 if (_ptr_info503) {
10782                                         NDR_PULL_ALLOC(ndr, r->info503);
10783                                 } else {
10784                                         r->info503 = NULL;
10785                                 }
10786                         break; }
10787
10788                         case 599: {
10789                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info599));
10790                                 if (_ptr_info599) {
10791                                         NDR_PULL_ALLOC(ndr, r->info599);
10792                                 } else {
10793                                         r->info599 = NULL;
10794                                 }
10795                         break; }
10796
10797                         case 1005: {
10798                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));
10799                                 if (_ptr_info1005) {
10800                                         NDR_PULL_ALLOC(ndr, r->info1005);
10801                                 } else {
10802                                         r->info1005 = NULL;
10803                                 }
10804                         break; }
10805
10806                         case 1010: {
10807                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
10808                                 if (_ptr_info1010) {
10809                                         NDR_PULL_ALLOC(ndr, r->info1010);
10810                                 } else {
10811                                         r->info1010 = NULL;
10812                                 }
10813                         break; }
10814
10815                         case 1016: {
10816                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1016));
10817                                 if (_ptr_info1016) {
10818                                         NDR_PULL_ALLOC(ndr, r->info1016);
10819                                 } else {
10820                                         r->info1016 = NULL;
10821                                 }
10822                         break; }
10823
10824                         case 1017: {
10825                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1017));
10826                                 if (_ptr_info1017) {
10827                                         NDR_PULL_ALLOC(ndr, r->info1017);
10828                                 } else {
10829                                         r->info1017 = NULL;
10830                                 }
10831                         break; }
10832
10833                         case 1018: {
10834                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
10835                                 if (_ptr_info1018) {
10836                                         NDR_PULL_ALLOC(ndr, r->info1018);
10837                                 } else {
10838                                         r->info1018 = NULL;
10839                                 }
10840                         break; }
10841
10842                         case 1107: {
10843                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1107));
10844                                 if (_ptr_info1107) {
10845                                         NDR_PULL_ALLOC(ndr, r->info1107);
10846                                 } else {
10847                                         r->info1107 = NULL;
10848                                 }
10849                         break; }
10850
10851                         case 1501: {
10852                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));
10853                                 if (_ptr_info1501) {
10854                                         NDR_PULL_ALLOC(ndr, r->info1501);
10855                                 } else {
10856                                         r->info1501 = NULL;
10857                                 }
10858                         break; }
10859
10860                         case 1502: {
10861                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1502));
10862                                 if (_ptr_info1502) {
10863                                         NDR_PULL_ALLOC(ndr, r->info1502);
10864                                 } else {
10865                                         r->info1502 = NULL;
10866                                 }
10867                         break; }
10868
10869                         case 1503: {
10870                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1503));
10871                                 if (_ptr_info1503) {
10872                                         NDR_PULL_ALLOC(ndr, r->info1503);
10873                                 } else {
10874                                         r->info1503 = NULL;
10875                                 }
10876                         break; }
10877
10878                         case 1506: {
10879                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1506));
10880                                 if (_ptr_info1506) {
10881                                         NDR_PULL_ALLOC(ndr, r->info1506);
10882                                 } else {
10883                                         r->info1506 = NULL;
10884                                 }
10885                         break; }
10886
10887                         case 1509: {
10888                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1509));
10889                                 if (_ptr_info1509) {
10890                                         NDR_PULL_ALLOC(ndr, r->info1509);
10891                                 } else {
10892                                         r->info1509 = NULL;
10893                                 }
10894                         break; }
10895
10896                         case 1510: {
10897                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1510));
10898                                 if (_ptr_info1510) {
10899                                         NDR_PULL_ALLOC(ndr, r->info1510);
10900                                 } else {
10901                                         r->info1510 = NULL;
10902                                 }
10903                         break; }
10904
10905                         case 1511: {
10906                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1511));
10907                                 if (_ptr_info1511) {
10908                                         NDR_PULL_ALLOC(ndr, r->info1511);
10909                                 } else {
10910                                         r->info1511 = NULL;
10911                                 }
10912                         break; }
10913
10914                         case 1512: {
10915                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1512));
10916                                 if (_ptr_info1512) {
10917                                         NDR_PULL_ALLOC(ndr, r->info1512);
10918                                 } else {
10919                                         r->info1512 = NULL;
10920                                 }
10921                         break; }
10922
10923                         case 1513: {
10924                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1513));
10925                                 if (_ptr_info1513) {
10926                                         NDR_PULL_ALLOC(ndr, r->info1513);
10927                                 } else {
10928                                         r->info1513 = NULL;
10929                                 }
10930                         break; }
10931
10932                         case 1514: {
10933                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1514));
10934                                 if (_ptr_info1514) {
10935                                         NDR_PULL_ALLOC(ndr, r->info1514);
10936                                 } else {
10937                                         r->info1514 = NULL;
10938                                 }
10939                         break; }
10940
10941                         case 1515: {
10942                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1515));
10943                                 if (_ptr_info1515) {
10944                                         NDR_PULL_ALLOC(ndr, r->info1515);
10945                                 } else {
10946                                         r->info1515 = NULL;
10947                                 }
10948                         break; }
10949
10950                         case 1516: {
10951                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1516));
10952                                 if (_ptr_info1516) {
10953                                         NDR_PULL_ALLOC(ndr, r->info1516);
10954                                 } else {
10955                                         r->info1516 = NULL;
10956                                 }
10957                         break; }
10958
10959                         case 1518: {
10960                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1518));
10961                                 if (_ptr_info1518) {
10962                                         NDR_PULL_ALLOC(ndr, r->info1518);
10963                                 } else {
10964                                         r->info1518 = NULL;
10965                                 }
10966                         break; }
10967
10968                         case 1520: {
10969                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1520));
10970                                 if (_ptr_info1520) {
10971                                         NDR_PULL_ALLOC(ndr, r->info1520);
10972                                 } else {
10973                                         r->info1520 = NULL;
10974                                 }
10975                         break; }
10976
10977                         case 1521: {
10978                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1521));
10979                                 if (_ptr_info1521) {
10980                                         NDR_PULL_ALLOC(ndr, r->info1521);
10981                                 } else {
10982                                         r->info1521 = NULL;
10983                                 }
10984                         break; }
10985
10986                         case 1522: {
10987                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1522));
10988                                 if (_ptr_info1522) {
10989                                         NDR_PULL_ALLOC(ndr, r->info1522);
10990                                 } else {
10991                                         r->info1522 = NULL;
10992                                 }
10993                         break; }
10994
10995                         case 1523: {
10996                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1523));
10997                                 if (_ptr_info1523) {
10998                                         NDR_PULL_ALLOC(ndr, r->info1523);
10999                                 } else {
11000                                         r->info1523 = NULL;
11001                                 }
11002                         break; }
11003
11004                         case 1524: {
11005                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1524));
11006                                 if (_ptr_info1524) {
11007                                         NDR_PULL_ALLOC(ndr, r->info1524);
11008                                 } else {
11009                                         r->info1524 = NULL;
11010                                 }
11011                         break; }
11012
11013                         case 1525: {
11014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1525));
11015                                 if (_ptr_info1525) {
11016                                         NDR_PULL_ALLOC(ndr, r->info1525);
11017                                 } else {
11018                                         r->info1525 = NULL;
11019                                 }
11020                         break; }
11021
11022                         case 1528: {
11023                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1528));
11024                                 if (_ptr_info1528) {
11025                                         NDR_PULL_ALLOC(ndr, r->info1528);
11026                                 } else {
11027                                         r->info1528 = NULL;
11028                                 }
11029                         break; }
11030
11031                         case 1529: {
11032                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1529));
11033                                 if (_ptr_info1529) {
11034                                         NDR_PULL_ALLOC(ndr, r->info1529);
11035                                 } else {
11036                                         r->info1529 = NULL;
11037                                 }
11038                         break; }
11039
11040                         case 1530: {
11041                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1530));
11042                                 if (_ptr_info1530) {
11043                                         NDR_PULL_ALLOC(ndr, r->info1530);
11044                                 } else {
11045                                         r->info1530 = NULL;
11046                                 }
11047                         break; }
11048
11049                         case 1533: {
11050                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1533));
11051                                 if (_ptr_info1533) {
11052                                         NDR_PULL_ALLOC(ndr, r->info1533);
11053                                 } else {
11054                                         r->info1533 = NULL;
11055                                 }
11056                         break; }
11057
11058                         case 1534: {
11059                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1534));
11060                                 if (_ptr_info1534) {
11061                                         NDR_PULL_ALLOC(ndr, r->info1534);
11062                                 } else {
11063                                         r->info1534 = NULL;
11064                                 }
11065                         break; }
11066
11067                         case 1535: {
11068                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1535));
11069                                 if (_ptr_info1535) {
11070                                         NDR_PULL_ALLOC(ndr, r->info1535);
11071                                 } else {
11072                                         r->info1535 = NULL;
11073                                 }
11074                         break; }
11075
11076                         case 1536: {
11077                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1536));
11078                                 if (_ptr_info1536) {
11079                                         NDR_PULL_ALLOC(ndr, r->info1536);
11080                                 } else {
11081                                         r->info1536 = NULL;
11082                                 }
11083                         break; }
11084
11085                         case 1537: {
11086                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1537));
11087                                 if (_ptr_info1537) {
11088                                         NDR_PULL_ALLOC(ndr, r->info1537);
11089                                 } else {
11090                                         r->info1537 = NULL;
11091                                 }
11092                         break; }
11093
11094                         case 1538: {
11095                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1538));
11096                                 if (_ptr_info1538) {
11097                                         NDR_PULL_ALLOC(ndr, r->info1538);
11098                                 } else {
11099                                         r->info1538 = NULL;
11100                                 }
11101                         break; }
11102
11103                         case 1539: {
11104                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1539));
11105                                 if (_ptr_info1539) {
11106                                         NDR_PULL_ALLOC(ndr, r->info1539);
11107                                 } else {
11108                                         r->info1539 = NULL;
11109                                 }
11110                         break; }
11111
11112                         case 1540: {
11113                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1540));
11114                                 if (_ptr_info1540) {
11115                                         NDR_PULL_ALLOC(ndr, r->info1540);
11116                                 } else {
11117                                         r->info1540 = NULL;
11118                                 }
11119                         break; }
11120
11121                         case 1541: {
11122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1541));
11123                                 if (_ptr_info1541) {
11124                                         NDR_PULL_ALLOC(ndr, r->info1541);
11125                                 } else {
11126                                         r->info1541 = NULL;
11127                                 }
11128                         break; }
11129
11130                         case 1542: {
11131                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1542));
11132                                 if (_ptr_info1542) {
11133                                         NDR_PULL_ALLOC(ndr, r->info1542);
11134                                 } else {
11135                                         r->info1542 = NULL;
11136                                 }
11137                         break; }
11138
11139                         case 1543: {
11140                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1543));
11141                                 if (_ptr_info1543) {
11142                                         NDR_PULL_ALLOC(ndr, r->info1543);
11143                                 } else {
11144                                         r->info1543 = NULL;
11145                                 }
11146                         break; }
11147
11148                         case 1544: {
11149                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1544));
11150                                 if (_ptr_info1544) {
11151                                         NDR_PULL_ALLOC(ndr, r->info1544);
11152                                 } else {
11153                                         r->info1544 = NULL;
11154                                 }
11155                         break; }
11156
11157                         case 1545: {
11158                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1545));
11159                                 if (_ptr_info1545) {
11160                                         NDR_PULL_ALLOC(ndr, r->info1545);
11161                                 } else {
11162                                         r->info1545 = NULL;
11163                                 }
11164                         break; }
11165
11166                         case 1546: {
11167                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1546));
11168                                 if (_ptr_info1546) {
11169                                         NDR_PULL_ALLOC(ndr, r->info1546);
11170                                 } else {
11171                                         r->info1546 = NULL;
11172                                 }
11173                         break; }
11174
11175                         case 1547: {
11176                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1547));
11177                                 if (_ptr_info1547) {
11178                                         NDR_PULL_ALLOC(ndr, r->info1547);
11179                                 } else {
11180                                         r->info1547 = NULL;
11181                                 }
11182                         break; }
11183
11184                         case 1548: {
11185                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1548));
11186                                 if (_ptr_info1548) {
11187                                         NDR_PULL_ALLOC(ndr, r->info1548);
11188                                 } else {
11189                                         r->info1548 = NULL;
11190                                 }
11191                         break; }
11192
11193                         case 1549: {
11194                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1549));
11195                                 if (_ptr_info1549) {
11196                                         NDR_PULL_ALLOC(ndr, r->info1549);
11197                                 } else {
11198                                         r->info1549 = NULL;
11199                                 }
11200                         break; }
11201
11202                         case 1550: {
11203                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1550));
11204                                 if (_ptr_info1550) {
11205                                         NDR_PULL_ALLOC(ndr, r->info1550);
11206                                 } else {
11207                                         r->info1550 = NULL;
11208                                 }
11209                         break; }
11210
11211                         case 1552: {
11212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1552));
11213                                 if (_ptr_info1552) {
11214                                         NDR_PULL_ALLOC(ndr, r->info1552);
11215                                 } else {
11216                                         r->info1552 = NULL;
11217                                 }
11218                         break; }
11219
11220                         case 1553: {
11221                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1553));
11222                                 if (_ptr_info1553) {
11223                                         NDR_PULL_ALLOC(ndr, r->info1553);
11224                                 } else {
11225                                         r->info1553 = NULL;
11226                                 }
11227                         break; }
11228
11229                         case 1554: {
11230                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1554));
11231                                 if (_ptr_info1554) {
11232                                         NDR_PULL_ALLOC(ndr, r->info1554);
11233                                 } else {
11234                                         r->info1554 = NULL;
11235                                 }
11236                         break; }
11237
11238                         case 1555: {
11239                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1555));
11240                                 if (_ptr_info1555) {
11241                                         NDR_PULL_ALLOC(ndr, r->info1555);
11242                                 } else {
11243                                         r->info1555 = NULL;
11244                                 }
11245                         break; }
11246
11247                         case 1556: {
11248                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1556));
11249                                 if (_ptr_info1556) {
11250                                         NDR_PULL_ALLOC(ndr, r->info1556);
11251                                 } else {
11252                                         r->info1556 = NULL;
11253                                 }
11254                         break; }
11255
11256                         default: {
11257                         break; }
11258
11259                 }
11260         }
11261         if (ndr_flags & NDR_BUFFERS) {
11262                 switch (level) {
11263                         case 100:
11264                                 if (r->info100) {
11265                                         _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
11266                                         NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
11267                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
11268                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
11269                                 }
11270                         break;
11271
11272                         case 101:
11273                                 if (r->info101) {
11274                                         _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
11275                                         NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
11276                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
11277                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
11278                                 }
11279                         break;
11280
11281                         case 102:
11282                                 if (r->info102) {
11283                                         _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
11284                                         NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
11285                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
11286                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
11287                                 }
11288                         break;
11289
11290                         case 402:
11291                                 if (r->info402) {
11292                                         _mem_save_info402_0 = NDR_PULL_GET_MEM_CTX(ndr);
11293                                         NDR_PULL_SET_MEM_CTX(ndr, r->info402, 0);
11294                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));
11295                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info402_0, 0);
11296                                 }
11297                         break;
11298
11299                         case 403:
11300                                 if (r->info403) {
11301                                         _mem_save_info403_0 = NDR_PULL_GET_MEM_CTX(ndr);
11302                                         NDR_PULL_SET_MEM_CTX(ndr, r->info403, 0);
11303                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));
11304                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info403_0, 0);
11305                                 }
11306                         break;
11307
11308                         case 502:
11309                                 if (r->info502) {
11310                                         _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
11311                                         NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
11312                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));
11313                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
11314                                 }
11315                         break;
11316
11317                         case 503:
11318                                 if (r->info503) {
11319                                         _mem_save_info503_0 = NDR_PULL_GET_MEM_CTX(ndr);
11320                                         NDR_PULL_SET_MEM_CTX(ndr, r->info503, 0);
11321                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));
11322                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info503_0, 0);
11323                                 }
11324                         break;
11325
11326                         case 599:
11327                                 if (r->info599) {
11328                                         _mem_save_info599_0 = NDR_PULL_GET_MEM_CTX(ndr);
11329                                         NDR_PULL_SET_MEM_CTX(ndr, r->info599, 0);
11330                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));
11331                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info599_0, 0);
11332                                 }
11333                         break;
11334
11335                         case 1005:
11336                                 if (r->info1005) {
11337                                         _mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);
11338                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);
11339                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));
11340                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);
11341                                 }
11342                         break;
11343
11344                         case 1010:
11345                                 if (r->info1010) {
11346                                         _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
11347                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
11348                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));
11349                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
11350                                 }
11351                         break;
11352
11353                         case 1016:
11354                                 if (r->info1016) {
11355                                         _mem_save_info1016_0 = NDR_PULL_GET_MEM_CTX(ndr);
11356                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1016, 0);
11357                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));
11358                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1016_0, 0);
11359                                 }
11360                         break;
11361
11362                         case 1017:
11363                                 if (r->info1017) {
11364                                         _mem_save_info1017_0 = NDR_PULL_GET_MEM_CTX(ndr);
11365                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1017, 0);
11366                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));
11367                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1017_0, 0);
11368                                 }
11369                         break;
11370
11371                         case 1018:
11372                                 if (r->info1018) {
11373                                         _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
11374                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
11375                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));
11376                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
11377                                 }
11378                         break;
11379
11380                         case 1107:
11381                                 if (r->info1107) {
11382                                         _mem_save_info1107_0 = NDR_PULL_GET_MEM_CTX(ndr);
11383                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1107, 0);
11384                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));
11385                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1107_0, 0);
11386                                 }
11387                         break;
11388
11389                         case 1501:
11390                                 if (r->info1501) {
11391                                         _mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);
11392                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);
11393                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));
11394                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);
11395                                 }
11396                         break;
11397
11398                         case 1502:
11399                                 if (r->info1502) {
11400                                         _mem_save_info1502_0 = NDR_PULL_GET_MEM_CTX(ndr);
11401                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1502, 0);
11402                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));
11403                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1502_0, 0);
11404                                 }
11405                         break;
11406
11407                         case 1503:
11408                                 if (r->info1503) {
11409                                         _mem_save_info1503_0 = NDR_PULL_GET_MEM_CTX(ndr);
11410                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1503, 0);
11411                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));
11412                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1503_0, 0);
11413                                 }
11414                         break;
11415
11416                         case 1506:
11417                                 if (r->info1506) {
11418                                         _mem_save_info1506_0 = NDR_PULL_GET_MEM_CTX(ndr);
11419                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1506, 0);
11420                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));
11421                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1506_0, 0);
11422                                 }
11423                         break;
11424
11425                         case 1509:
11426                                 if (r->info1509) {
11427                                         _mem_save_info1509_0 = NDR_PULL_GET_MEM_CTX(ndr);
11428                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1509, 0);
11429                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));
11430                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1509_0, 0);
11431                                 }
11432                         break;
11433
11434                         case 1510:
11435                                 if (r->info1510) {
11436                                         _mem_save_info1510_0 = NDR_PULL_GET_MEM_CTX(ndr);
11437                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1510, 0);
11438                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));
11439                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1510_0, 0);
11440                                 }
11441                         break;
11442
11443                         case 1511:
11444                                 if (r->info1511) {
11445                                         _mem_save_info1511_0 = NDR_PULL_GET_MEM_CTX(ndr);
11446                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1511, 0);
11447                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));
11448                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1511_0, 0);
11449                                 }
11450                         break;
11451
11452                         case 1512:
11453                                 if (r->info1512) {
11454                                         _mem_save_info1512_0 = NDR_PULL_GET_MEM_CTX(ndr);
11455                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1512, 0);
11456                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));
11457                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1512_0, 0);
11458                                 }
11459                         break;
11460
11461                         case 1513:
11462                                 if (r->info1513) {
11463                                         _mem_save_info1513_0 = NDR_PULL_GET_MEM_CTX(ndr);
11464                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1513, 0);
11465                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));
11466                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1513_0, 0);
11467                                 }
11468                         break;
11469
11470                         case 1514:
11471                                 if (r->info1514) {
11472                                         _mem_save_info1514_0 = NDR_PULL_GET_MEM_CTX(ndr);
11473                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1514, 0);
11474                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));
11475                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1514_0, 0);
11476                                 }
11477                         break;
11478
11479                         case 1515:
11480                                 if (r->info1515) {
11481                                         _mem_save_info1515_0 = NDR_PULL_GET_MEM_CTX(ndr);
11482                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1515, 0);
11483                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));
11484                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1515_0, 0);
11485                                 }
11486                         break;
11487
11488                         case 1516:
11489                                 if (r->info1516) {
11490                                         _mem_save_info1516_0 = NDR_PULL_GET_MEM_CTX(ndr);
11491                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1516, 0);
11492                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));
11493                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1516_0, 0);
11494                                 }
11495                         break;
11496
11497                         case 1518:
11498                                 if (r->info1518) {
11499                                         _mem_save_info1518_0 = NDR_PULL_GET_MEM_CTX(ndr);
11500                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1518, 0);
11501                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));
11502                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1518_0, 0);
11503                                 }
11504                         break;
11505
11506                         case 1520:
11507                                 if (r->info1520) {
11508                                         _mem_save_info1520_0 = NDR_PULL_GET_MEM_CTX(ndr);
11509                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1520, 0);
11510                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));
11511                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1520_0, 0);
11512                                 }
11513                         break;
11514
11515                         case 1521:
11516                                 if (r->info1521) {
11517                                         _mem_save_info1521_0 = NDR_PULL_GET_MEM_CTX(ndr);
11518                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1521, 0);
11519                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));
11520                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1521_0, 0);
11521                                 }
11522                         break;
11523
11524                         case 1522:
11525                                 if (r->info1522) {
11526                                         _mem_save_info1522_0 = NDR_PULL_GET_MEM_CTX(ndr);
11527                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1522, 0);
11528                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));
11529                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1522_0, 0);
11530                                 }
11531                         break;
11532
11533                         case 1523:
11534                                 if (r->info1523) {
11535                                         _mem_save_info1523_0 = NDR_PULL_GET_MEM_CTX(ndr);
11536                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1523, 0);
11537                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));
11538                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1523_0, 0);
11539                                 }
11540                         break;
11541
11542                         case 1524:
11543                                 if (r->info1524) {
11544                                         _mem_save_info1524_0 = NDR_PULL_GET_MEM_CTX(ndr);
11545                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1524, 0);
11546                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));
11547                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1524_0, 0);
11548                                 }
11549                         break;
11550
11551                         case 1525:
11552                                 if (r->info1525) {
11553                                         _mem_save_info1525_0 = NDR_PULL_GET_MEM_CTX(ndr);
11554                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1525, 0);
11555                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));
11556                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1525_0, 0);
11557                                 }
11558                         break;
11559
11560                         case 1528:
11561                                 if (r->info1528) {
11562                                         _mem_save_info1528_0 = NDR_PULL_GET_MEM_CTX(ndr);
11563                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1528, 0);
11564                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));
11565                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1528_0, 0);
11566                                 }
11567                         break;
11568
11569                         case 1529:
11570                                 if (r->info1529) {
11571                                         _mem_save_info1529_0 = NDR_PULL_GET_MEM_CTX(ndr);
11572                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1529, 0);
11573                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));
11574                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1529_0, 0);
11575                                 }
11576                         break;
11577
11578                         case 1530:
11579                                 if (r->info1530) {
11580                                         _mem_save_info1530_0 = NDR_PULL_GET_MEM_CTX(ndr);
11581                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1530, 0);
11582                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));
11583                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1530_0, 0);
11584                                 }
11585                         break;
11586
11587                         case 1533:
11588                                 if (r->info1533) {
11589                                         _mem_save_info1533_0 = NDR_PULL_GET_MEM_CTX(ndr);
11590                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1533, 0);
11591                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));
11592                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1533_0, 0);
11593                                 }
11594                         break;
11595
11596                         case 1534:
11597                                 if (r->info1534) {
11598                                         _mem_save_info1534_0 = NDR_PULL_GET_MEM_CTX(ndr);
11599                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1534, 0);
11600                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));
11601                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1534_0, 0);
11602                                 }
11603                         break;
11604
11605                         case 1535:
11606                                 if (r->info1535) {
11607                                         _mem_save_info1535_0 = NDR_PULL_GET_MEM_CTX(ndr);
11608                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1535, 0);
11609                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));
11610                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1535_0, 0);
11611                                 }
11612                         break;
11613
11614                         case 1536:
11615                                 if (r->info1536) {
11616                                         _mem_save_info1536_0 = NDR_PULL_GET_MEM_CTX(ndr);
11617                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1536, 0);
11618                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));
11619                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1536_0, 0);
11620                                 }
11621                         break;
11622
11623                         case 1537:
11624                                 if (r->info1537) {
11625                                         _mem_save_info1537_0 = NDR_PULL_GET_MEM_CTX(ndr);
11626                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1537, 0);
11627                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));
11628                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1537_0, 0);
11629                                 }
11630                         break;
11631
11632                         case 1538:
11633                                 if (r->info1538) {
11634                                         _mem_save_info1538_0 = NDR_PULL_GET_MEM_CTX(ndr);
11635                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1538, 0);
11636                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));
11637                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1538_0, 0);
11638                                 }
11639                         break;
11640
11641                         case 1539:
11642                                 if (r->info1539) {
11643                                         _mem_save_info1539_0 = NDR_PULL_GET_MEM_CTX(ndr);
11644                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1539, 0);
11645                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));
11646                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1539_0, 0);
11647                                 }
11648                         break;
11649
11650                         case 1540:
11651                                 if (r->info1540) {
11652                                         _mem_save_info1540_0 = NDR_PULL_GET_MEM_CTX(ndr);
11653                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1540, 0);
11654                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));
11655                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1540_0, 0);
11656                                 }
11657                         break;
11658
11659                         case 1541:
11660                                 if (r->info1541) {
11661                                         _mem_save_info1541_0 = NDR_PULL_GET_MEM_CTX(ndr);
11662                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1541, 0);
11663                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));
11664                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1541_0, 0);
11665                                 }
11666                         break;
11667
11668                         case 1542:
11669                                 if (r->info1542) {
11670                                         _mem_save_info1542_0 = NDR_PULL_GET_MEM_CTX(ndr);
11671                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1542, 0);
11672                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));
11673                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1542_0, 0);
11674                                 }
11675                         break;
11676
11677                         case 1543:
11678                                 if (r->info1543) {
11679                                         _mem_save_info1543_0 = NDR_PULL_GET_MEM_CTX(ndr);
11680                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1543, 0);
11681                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));
11682                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1543_0, 0);
11683                                 }
11684                         break;
11685
11686                         case 1544:
11687                                 if (r->info1544) {
11688                                         _mem_save_info1544_0 = NDR_PULL_GET_MEM_CTX(ndr);
11689                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1544, 0);
11690                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));
11691                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1544_0, 0);
11692                                 }
11693                         break;
11694
11695                         case 1545:
11696                                 if (r->info1545) {
11697                                         _mem_save_info1545_0 = NDR_PULL_GET_MEM_CTX(ndr);
11698                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1545, 0);
11699                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));
11700                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1545_0, 0);
11701                                 }
11702                         break;
11703
11704                         case 1546:
11705                                 if (r->info1546) {
11706                                         _mem_save_info1546_0 = NDR_PULL_GET_MEM_CTX(ndr);
11707                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1546, 0);
11708                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));
11709                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1546_0, 0);
11710                                 }
11711                         break;
11712
11713                         case 1547:
11714                                 if (r->info1547) {
11715                                         _mem_save_info1547_0 = NDR_PULL_GET_MEM_CTX(ndr);
11716                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1547, 0);
11717                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));
11718                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1547_0, 0);
11719                                 }
11720                         break;
11721
11722                         case 1548:
11723                                 if (r->info1548) {
11724                                         _mem_save_info1548_0 = NDR_PULL_GET_MEM_CTX(ndr);
11725                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1548, 0);
11726                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));
11727                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1548_0, 0);
11728                                 }
11729                         break;
11730
11731                         case 1549:
11732                                 if (r->info1549) {
11733                                         _mem_save_info1549_0 = NDR_PULL_GET_MEM_CTX(ndr);
11734                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1549, 0);
11735                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));
11736                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1549_0, 0);
11737                                 }
11738                         break;
11739
11740                         case 1550:
11741                                 if (r->info1550) {
11742                                         _mem_save_info1550_0 = NDR_PULL_GET_MEM_CTX(ndr);
11743                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1550, 0);
11744                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));
11745                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1550_0, 0);
11746                                 }
11747                         break;
11748
11749                         case 1552:
11750                                 if (r->info1552) {
11751                                         _mem_save_info1552_0 = NDR_PULL_GET_MEM_CTX(ndr);
11752                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1552, 0);
11753                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));
11754                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1552_0, 0);
11755                                 }
11756                         break;
11757
11758                         case 1553:
11759                                 if (r->info1553) {
11760                                         _mem_save_info1553_0 = NDR_PULL_GET_MEM_CTX(ndr);
11761                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1553, 0);
11762                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));
11763                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1553_0, 0);
11764                                 }
11765                         break;
11766
11767                         case 1554:
11768                                 if (r->info1554) {
11769                                         _mem_save_info1554_0 = NDR_PULL_GET_MEM_CTX(ndr);
11770                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1554, 0);
11771                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));
11772                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1554_0, 0);
11773                                 }
11774                         break;
11775
11776                         case 1555:
11777                                 if (r->info1555) {
11778                                         _mem_save_info1555_0 = NDR_PULL_GET_MEM_CTX(ndr);
11779                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1555, 0);
11780                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));
11781                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1555_0, 0);
11782                                 }
11783                         break;
11784
11785                         case 1556:
11786                                 if (r->info1556) {
11787                                         _mem_save_info1556_0 = NDR_PULL_GET_MEM_CTX(ndr);
11788                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1556, 0);
11789                                         NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));
11790                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1556_0, 0);
11791                                 }
11792                         break;
11793
11794                         default:
11795                         break;
11796
11797                 }
11798         }
11799         return NDR_ERR_SUCCESS;
11800 }
11801
11802 _PUBLIC_ void ndr_print_srvsvc_NetSrvInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetSrvInfo *r)
11803 {
11804         uint32_t level;
11805         level = ndr_print_get_switch_value(ndr, r);
11806         ndr_print_union(ndr, name, level, "srvsvc_NetSrvInfo");
11807         switch (level) {
11808                 case 100:
11809                         ndr_print_ptr(ndr, "info100", r->info100);
11810                         ndr->depth++;
11811                         if (r->info100) {
11812                                 ndr_print_srvsvc_NetSrvInfo100(ndr, "info100", r->info100);
11813                         }
11814                         ndr->depth--;
11815                 break;
11816
11817                 case 101:
11818                         ndr_print_ptr(ndr, "info101", r->info101);
11819                         ndr->depth++;
11820                         if (r->info101) {
11821                                 ndr_print_srvsvc_NetSrvInfo101(ndr, "info101", r->info101);
11822                         }
11823                         ndr->depth--;
11824                 break;
11825
11826                 case 102:
11827                         ndr_print_ptr(ndr, "info102", r->info102);
11828                         ndr->depth++;
11829                         if (r->info102) {
11830                                 ndr_print_srvsvc_NetSrvInfo102(ndr, "info102", r->info102);
11831                         }
11832                         ndr->depth--;
11833                 break;
11834
11835                 case 402:
11836                         ndr_print_ptr(ndr, "info402", r->info402);
11837                         ndr->depth++;
11838                         if (r->info402) {
11839                                 ndr_print_srvsvc_NetSrvInfo402(ndr, "info402", r->info402);
11840                         }
11841                         ndr->depth--;
11842                 break;
11843
11844                 case 403:
11845                         ndr_print_ptr(ndr, "info403", r->info403);
11846                         ndr->depth++;
11847                         if (r->info403) {
11848                                 ndr_print_srvsvc_NetSrvInfo403(ndr, "info403", r->info403);
11849                         }
11850                         ndr->depth--;
11851                 break;
11852
11853                 case 502:
11854                         ndr_print_ptr(ndr, "info502", r->info502);
11855                         ndr->depth++;
11856                         if (r->info502) {
11857                                 ndr_print_srvsvc_NetSrvInfo502(ndr, "info502", r->info502);
11858                         }
11859                         ndr->depth--;
11860                 break;
11861
11862                 case 503:
11863                         ndr_print_ptr(ndr, "info503", r->info503);
11864                         ndr->depth++;
11865                         if (r->info503) {
11866                                 ndr_print_srvsvc_NetSrvInfo503(ndr, "info503", r->info503);
11867                         }
11868                         ndr->depth--;
11869                 break;
11870
11871                 case 599:
11872                         ndr_print_ptr(ndr, "info599", r->info599);
11873                         ndr->depth++;
11874                         if (r->info599) {
11875                                 ndr_print_srvsvc_NetSrvInfo599(ndr, "info599", r->info599);
11876                         }
11877                         ndr->depth--;
11878                 break;
11879
11880                 case 1005:
11881                         ndr_print_ptr(ndr, "info1005", r->info1005);
11882                         ndr->depth++;
11883                         if (r->info1005) {
11884                                 ndr_print_srvsvc_NetSrvInfo1005(ndr, "info1005", r->info1005);
11885                         }
11886                         ndr->depth--;
11887                 break;
11888
11889                 case 1010:
11890                         ndr_print_ptr(ndr, "info1010", r->info1010);
11891                         ndr->depth++;
11892                         if (r->info1010) {
11893                                 ndr_print_srvsvc_NetSrvInfo1010(ndr, "info1010", r->info1010);
11894                         }
11895                         ndr->depth--;
11896                 break;
11897
11898                 case 1016:
11899                         ndr_print_ptr(ndr, "info1016", r->info1016);
11900                         ndr->depth++;
11901                         if (r->info1016) {
11902                                 ndr_print_srvsvc_NetSrvInfo1016(ndr, "info1016", r->info1016);
11903                         }
11904                         ndr->depth--;
11905                 break;
11906
11907                 case 1017:
11908                         ndr_print_ptr(ndr, "info1017", r->info1017);
11909                         ndr->depth++;
11910                         if (r->info1017) {
11911                                 ndr_print_srvsvc_NetSrvInfo1017(ndr, "info1017", r->info1017);
11912                         }
11913                         ndr->depth--;
11914                 break;
11915
11916                 case 1018:
11917                         ndr_print_ptr(ndr, "info1018", r->info1018);
11918                         ndr->depth++;
11919                         if (r->info1018) {
11920                                 ndr_print_srvsvc_NetSrvInfo1018(ndr, "info1018", r->info1018);
11921                         }
11922                         ndr->depth--;
11923                 break;
11924
11925                 case 1107:
11926                         ndr_print_ptr(ndr, "info1107", r->info1107);
11927                         ndr->depth++;
11928                         if (r->info1107) {
11929                                 ndr_print_srvsvc_NetSrvInfo1107(ndr, "info1107", r->info1107);
11930                         }
11931                         ndr->depth--;
11932                 break;
11933
11934                 case 1501:
11935                         ndr_print_ptr(ndr, "info1501", r->info1501);
11936                         ndr->depth++;
11937                         if (r->info1501) {
11938                                 ndr_print_srvsvc_NetSrvInfo1501(ndr, "info1501", r->info1501);
11939                         }
11940                         ndr->depth--;
11941                 break;
11942
11943                 case 1502:
11944                         ndr_print_ptr(ndr, "info1502", r->info1502);
11945                         ndr->depth++;
11946                         if (r->info1502) {
11947                                 ndr_print_srvsvc_NetSrvInfo1502(ndr, "info1502", r->info1502);
11948                         }
11949                         ndr->depth--;
11950                 break;
11951
11952                 case 1503:
11953                         ndr_print_ptr(ndr, "info1503", r->info1503);
11954                         ndr->depth++;
11955                         if (r->info1503) {
11956                                 ndr_print_srvsvc_NetSrvInfo1503(ndr, "info1503", r->info1503);
11957                         }
11958                         ndr->depth--;
11959                 break;
11960
11961                 case 1506:
11962                         ndr_print_ptr(ndr, "info1506", r->info1506);
11963                         ndr->depth++;
11964                         if (r->info1506) {
11965                                 ndr_print_srvsvc_NetSrvInfo1506(ndr, "info1506", r->info1506);
11966                         }
11967                         ndr->depth--;
11968                 break;
11969
11970                 case 1509:
11971                         ndr_print_ptr(ndr, "info1509", r->info1509);
11972                         ndr->depth++;
11973                         if (r->info1509) {
11974                                 ndr_print_srvsvc_NetSrvInfo1509(ndr, "info1509", r->info1509);
11975                         }
11976                         ndr->depth--;
11977                 break;
11978
11979                 case 1510:
11980                         ndr_print_ptr(ndr, "info1510", r->info1510);
11981                         ndr->depth++;
11982                         if (r->info1510) {
11983                                 ndr_print_srvsvc_NetSrvInfo1510(ndr, "info1510", r->info1510);
11984                         }
11985                         ndr->depth--;
11986                 break;
11987
11988                 case 1511:
11989                         ndr_print_ptr(ndr, "info1511", r->info1511);
11990                         ndr->depth++;
11991                         if (r->info1511) {
11992                                 ndr_print_srvsvc_NetSrvInfo1511(ndr, "info1511", r->info1511);
11993                         }
11994                         ndr->depth--;
11995                 break;
11996
11997                 case 1512:
11998                         ndr_print_ptr(ndr, "info1512", r->info1512);
11999                         ndr->depth++;
12000                         if (r->info1512) {
12001                                 ndr_print_srvsvc_NetSrvInfo1512(ndr, "info1512", r->info1512);
12002                         }
12003                         ndr->depth--;
12004                 break;
12005
12006                 case 1513:
12007                         ndr_print_ptr(ndr, "info1513", r->info1513);
12008                         ndr->depth++;
12009                         if (r->info1513) {
12010                                 ndr_print_srvsvc_NetSrvInfo1513(ndr, "info1513", r->info1513);
12011                         }
12012                         ndr->depth--;
12013                 break;
12014
12015                 case 1514:
12016                         ndr_print_ptr(ndr, "info1514", r->info1514);
12017                         ndr->depth++;
12018                         if (r->info1514) {
12019                                 ndr_print_srvsvc_NetSrvInfo1514(ndr, "info1514", r->info1514);
12020                         }
12021                         ndr->depth--;
12022                 break;
12023
12024                 case 1515:
12025                         ndr_print_ptr(ndr, "info1515", r->info1515);
12026                         ndr->depth++;
12027                         if (r->info1515) {
12028                                 ndr_print_srvsvc_NetSrvInfo1515(ndr, "info1515", r->info1515);
12029                         }
12030                         ndr->depth--;
12031                 break;
12032
12033                 case 1516:
12034                         ndr_print_ptr(ndr, "info1516", r->info1516);
12035                         ndr->depth++;
12036                         if (r->info1516) {
12037                                 ndr_print_srvsvc_NetSrvInfo1516(ndr, "info1516", r->info1516);
12038                         }
12039                         ndr->depth--;
12040                 break;
12041
12042                 case 1518:
12043                         ndr_print_ptr(ndr, "info1518", r->info1518);
12044                         ndr->depth++;
12045                         if (r->info1518) {
12046                                 ndr_print_srvsvc_NetSrvInfo1518(ndr, "info1518", r->info1518);
12047                         }
12048                         ndr->depth--;
12049                 break;
12050
12051                 case 1520:
12052                         ndr_print_ptr(ndr, "info1520", r->info1520);
12053                         ndr->depth++;
12054                         if (r->info1520) {
12055                                 ndr_print_srvsvc_NetSrvInfo1520(ndr, "info1520", r->info1520);
12056                         }
12057                         ndr->depth--;
12058                 break;
12059
12060                 case 1521:
12061                         ndr_print_ptr(ndr, "info1521", r->info1521);
12062                         ndr->depth++;
12063                         if (r->info1521) {
12064                                 ndr_print_srvsvc_NetSrvInfo1521(ndr, "info1521", r->info1521);
12065                         }
12066                         ndr->depth--;
12067                 break;
12068
12069                 case 1522:
12070                         ndr_print_ptr(ndr, "info1522", r->info1522);
12071                         ndr->depth++;
12072                         if (r->info1522) {
12073                                 ndr_print_srvsvc_NetSrvInfo1522(ndr, "info1522", r->info1522);
12074                         }
12075                         ndr->depth--;
12076                 break;
12077
12078                 case 1523:
12079                         ndr_print_ptr(ndr, "info1523", r->info1523);
12080                         ndr->depth++;
12081                         if (r->info1523) {
12082                                 ndr_print_srvsvc_NetSrvInfo1523(ndr, "info1523", r->info1523);
12083                         }
12084                         ndr->depth--;
12085                 break;
12086
12087                 case 1524:
12088                         ndr_print_ptr(ndr, "info1524", r->info1524);
12089                         ndr->depth++;
12090                         if (r->info1524) {
12091                                 ndr_print_srvsvc_NetSrvInfo1524(ndr, "info1524", r->info1524);
12092                         }
12093                         ndr->depth--;
12094                 break;
12095
12096                 case 1525:
12097                         ndr_print_ptr(ndr, "info1525", r->info1525);
12098                         ndr->depth++;
12099                         if (r->info1525) {
12100                                 ndr_print_srvsvc_NetSrvInfo1525(ndr, "info1525", r->info1525);
12101                         }
12102                         ndr->depth--;
12103                 break;
12104
12105                 case 1528:
12106                         ndr_print_ptr(ndr, "info1528", r->info1528);
12107                         ndr->depth++;
12108                         if (r->info1528) {
12109                                 ndr_print_srvsvc_NetSrvInfo1528(ndr, "info1528", r->info1528);
12110                         }
12111                         ndr->depth--;
12112                 break;
12113
12114                 case 1529:
12115                         ndr_print_ptr(ndr, "info1529", r->info1529);
12116                         ndr->depth++;
12117                         if (r->info1529) {
12118                                 ndr_print_srvsvc_NetSrvInfo1529(ndr, "info1529", r->info1529);
12119                         }
12120                         ndr->depth--;
12121                 break;
12122
12123                 case 1530:
12124                         ndr_print_ptr(ndr, "info1530", r->info1530);
12125                         ndr->depth++;
12126                         if (r->info1530) {
12127                                 ndr_print_srvsvc_NetSrvInfo1530(ndr, "info1530", r->info1530);
12128                         }
12129                         ndr->depth--;
12130                 break;
12131
12132                 case 1533:
12133                         ndr_print_ptr(ndr, "info1533", r->info1533);
12134                         ndr->depth++;
12135                         if (r->info1533) {
12136                                 ndr_print_srvsvc_NetSrvInfo1533(ndr, "info1533", r->info1533);
12137                         }
12138                         ndr->depth--;
12139                 break;
12140
12141                 case 1534:
12142                         ndr_print_ptr(ndr, "info1534", r->info1534);
12143                         ndr->depth++;
12144                         if (r->info1534) {
12145                                 ndr_print_srvsvc_NetSrvInfo1534(ndr, "info1534", r->info1534);
12146                         }
12147                         ndr->depth--;
12148                 break;
12149
12150                 case 1535:
12151                         ndr_print_ptr(ndr, "info1535", r->info1535);
12152                         ndr->depth++;
12153                         if (r->info1535) {
12154                                 ndr_print_srvsvc_NetSrvInfo1535(ndr, "info1535", r->info1535);
12155                         }
12156                         ndr->depth--;
12157                 break;
12158
12159                 case 1536:
12160                         ndr_print_ptr(ndr, "info1536", r->info1536);
12161                         ndr->depth++;
12162                         if (r->info1536) {
12163                                 ndr_print_srvsvc_NetSrvInfo1536(ndr, "info1536", r->info1536);
12164                         }
12165                         ndr->depth--;
12166                 break;
12167
12168                 case 1537:
12169                         ndr_print_ptr(ndr, "info1537", r->info1537);
12170                         ndr->depth++;
12171                         if (r->info1537) {
12172                                 ndr_print_srvsvc_NetSrvInfo1537(ndr, "info1537", r->info1537);
12173                         }
12174                         ndr->depth--;
12175                 break;
12176
12177                 case 1538:
12178                         ndr_print_ptr(ndr, "info1538", r->info1538);
12179                         ndr->depth++;
12180                         if (r->info1538) {
12181                                 ndr_print_srvsvc_NetSrvInfo1538(ndr, "info1538", r->info1538);
12182                         }
12183                         ndr->depth--;
12184                 break;
12185
12186                 case 1539:
12187                         ndr_print_ptr(ndr, "info1539", r->info1539);
12188                         ndr->depth++;
12189                         if (r->info1539) {
12190                                 ndr_print_srvsvc_NetSrvInfo1539(ndr, "info1539", r->info1539);
12191                         }
12192                         ndr->depth--;
12193                 break;
12194
12195                 case 1540:
12196                         ndr_print_ptr(ndr, "info1540", r->info1540);
12197                         ndr->depth++;
12198                         if (r->info1540) {
12199                                 ndr_print_srvsvc_NetSrvInfo1540(ndr, "info1540", r->info1540);
12200                         }
12201                         ndr->depth--;
12202                 break;
12203
12204                 case 1541:
12205                         ndr_print_ptr(ndr, "info1541", r->info1541);
12206                         ndr->depth++;
12207                         if (r->info1541) {
12208                                 ndr_print_srvsvc_NetSrvInfo1541(ndr, "info1541", r->info1541);
12209                         }
12210                         ndr->depth--;
12211                 break;
12212
12213                 case 1542:
12214                         ndr_print_ptr(ndr, "info1542", r->info1542);
12215                         ndr->depth++;
12216                         if (r->info1542) {
12217                                 ndr_print_srvsvc_NetSrvInfo1542(ndr, "info1542", r->info1542);
12218                         }
12219                         ndr->depth--;
12220                 break;
12221
12222                 case 1543:
12223                         ndr_print_ptr(ndr, "info1543", r->info1543);
12224                         ndr->depth++;
12225                         if (r->info1543) {
12226                                 ndr_print_srvsvc_NetSrvInfo1543(ndr, "info1543", r->info1543);
12227                         }
12228                         ndr->depth--;
12229                 break;
12230
12231                 case 1544:
12232                         ndr_print_ptr(ndr, "info1544", r->info1544);
12233                         ndr->depth++;
12234                         if (r->info1544) {
12235                                 ndr_print_srvsvc_NetSrvInfo1544(ndr, "info1544", r->info1544);
12236                         }
12237                         ndr->depth--;
12238                 break;
12239
12240                 case 1545:
12241                         ndr_print_ptr(ndr, "info1545", r->info1545);
12242                         ndr->depth++;
12243                         if (r->info1545) {
12244                                 ndr_print_srvsvc_NetSrvInfo1545(ndr, "info1545", r->info1545);
12245                         }
12246                         ndr->depth--;
12247                 break;
12248
12249                 case 1546:
12250                         ndr_print_ptr(ndr, "info1546", r->info1546);
12251                         ndr->depth++;
12252                         if (r->info1546) {
12253                                 ndr_print_srvsvc_NetSrvInfo1546(ndr, "info1546", r->info1546);
12254                         }
12255                         ndr->depth--;
12256                 break;
12257
12258                 case 1547:
12259                         ndr_print_ptr(ndr, "info1547", r->info1547);
12260                         ndr->depth++;
12261                         if (r->info1547) {
12262                                 ndr_print_srvsvc_NetSrvInfo1547(ndr, "info1547", r->info1547);
12263                         }
12264                         ndr->depth--;
12265                 break;
12266
12267                 case 1548:
12268                         ndr_print_ptr(ndr, "info1548", r->info1548);
12269                         ndr->depth++;
12270                         if (r->info1548) {
12271                                 ndr_print_srvsvc_NetSrvInfo1548(ndr, "info1548", r->info1548);
12272                         }
12273                         ndr->depth--;
12274                 break;
12275
12276                 case 1549:
12277                         ndr_print_ptr(ndr, "info1549", r->info1549);
12278                         ndr->depth++;
12279                         if (r->info1549) {
12280                                 ndr_print_srvsvc_NetSrvInfo1549(ndr, "info1549", r->info1549);
12281                         }
12282                         ndr->depth--;
12283                 break;
12284
12285                 case 1550:
12286                         ndr_print_ptr(ndr, "info1550", r->info1550);
12287                         ndr->depth++;
12288                         if (r->info1550) {
12289                                 ndr_print_srvsvc_NetSrvInfo1550(ndr, "info1550", r->info1550);
12290                         }
12291                         ndr->depth--;
12292                 break;
12293
12294                 case 1552:
12295                         ndr_print_ptr(ndr, "info1552", r->info1552);
12296                         ndr->depth++;
12297                         if (r->info1552) {
12298                                 ndr_print_srvsvc_NetSrvInfo1552(ndr, "info1552", r->info1552);
12299                         }
12300                         ndr->depth--;
12301                 break;
12302
12303                 case 1553:
12304                         ndr_print_ptr(ndr, "info1553", r->info1553);
12305                         ndr->depth++;
12306                         if (r->info1553) {
12307                                 ndr_print_srvsvc_NetSrvInfo1553(ndr, "info1553", r->info1553);
12308                         }
12309                         ndr->depth--;
12310                 break;
12311
12312                 case 1554:
12313                         ndr_print_ptr(ndr, "info1554", r->info1554);
12314                         ndr->depth++;
12315                         if (r->info1554) {
12316                                 ndr_print_srvsvc_NetSrvInfo1554(ndr, "info1554", r->info1554);
12317                         }
12318                         ndr->depth--;
12319                 break;
12320
12321                 case 1555:
12322                         ndr_print_ptr(ndr, "info1555", r->info1555);
12323                         ndr->depth++;
12324                         if (r->info1555) {
12325                                 ndr_print_srvsvc_NetSrvInfo1555(ndr, "info1555", r->info1555);
12326                         }
12327                         ndr->depth--;
12328                 break;
12329
12330                 case 1556:
12331                         ndr_print_ptr(ndr, "info1556", r->info1556);
12332                         ndr->depth++;
12333                         if (r->info1556) {
12334                                 ndr_print_srvsvc_NetSrvInfo1556(ndr, "info1556", r->info1556);
12335                         }
12336                         ndr->depth--;
12337                 break;
12338
12339                 default:
12340                 break;
12341
12342         }
12343 }
12344
12345 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo0 *r)
12346 {
12347         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12348         if (ndr_flags & NDR_SCALARS) {
12349                 NDR_CHECK(ndr_push_align(ndr, 4));
12350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->disk) + 1));
12352                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->disk, strlen(r->disk) + 1, sizeof(uint16_t), CH_UTF16));
12353                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12354         }
12355         if (ndr_flags & NDR_BUFFERS) {
12356         }
12357         return NDR_ERR_SUCCESS;
12358 }
12359
12360 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo0 *r)
12361 {
12362         uint32_t size_disk_0 = 0;
12363         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12364         if (ndr_flags & NDR_SCALARS) {
12365                 NDR_CHECK(ndr_pull_align(ndr, 4));
12366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_offset));
12367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_length));
12368                 size_disk_0 = r->__disk_length;
12369                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->disk, size_disk_0, sizeof(uint16_t), CH_UTF16));
12370                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12371         }
12372         if (ndr_flags & NDR_BUFFERS) {
12373         }
12374         return NDR_ERR_SUCCESS;
12375 }
12376
12377 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo0 *r)
12378 {
12379         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo0");
12380         if (r == NULL) { ndr_print_null(ndr); return; }
12381         ndr->depth++;
12382         ndr_print_uint32(ndr, "__disk_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->__disk_offset);
12383         ndr_print_uint32(ndr, "__disk_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->disk) + 1:r->__disk_length);
12384         ndr_print_string(ndr, "disk", r->disk);
12385         ndr->depth--;
12386 }
12387
12388 static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo *r)
12389 {
12390         uint32_t cntr_disks_1;
12391         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12392         if (ndr_flags & NDR_SCALARS) {
12393                 NDR_CHECK(ndr_push_align(ndr, 5));
12394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->disks));
12396                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12397         }
12398         if (ndr_flags & NDR_BUFFERS) {
12399                 if (r->disks) {
12400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12403                         for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {
12404                                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
12405                         }
12406                 }
12407         }
12408         return NDR_ERR_SUCCESS;
12409 }
12410
12411 static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo *r)
12412 {
12413         uint32_t _ptr_disks;
12414         uint32_t size_disks_1 = 0;
12415         uint32_t length_disks_1 = 0;
12416         uint32_t cntr_disks_1;
12417         TALLOC_CTX *_mem_save_disks_0;
12418         TALLOC_CTX *_mem_save_disks_1;
12419         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12420         if (ndr_flags & NDR_SCALARS) {
12421                 NDR_CHECK(ndr_pull_align(ndr, 5));
12422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disks));
12424                 if (_ptr_disks) {
12425                         NDR_PULL_ALLOC(ndr, r->disks);
12426                 } else {
12427                         r->disks = NULL;
12428                 }
12429                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12430         }
12431         if (ndr_flags & NDR_BUFFERS) {
12432                 if (r->disks) {
12433                         _mem_save_disks_0 = NDR_PULL_GET_MEM_CTX(ndr);
12434                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
12435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->disks));
12436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->disks));
12437                         size_disks_1 = ndr_get_array_size(ndr, &r->disks);
12438                         length_disks_1 = ndr_get_array_length(ndr, &r->disks);
12439                         if (length_disks_1 > size_disks_1) {
12440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_disks_1, length_disks_1);
12441                         }
12442                         NDR_PULL_ALLOC_N(ndr, r->disks, size_disks_1);
12443                         _mem_save_disks_1 = NDR_PULL_GET_MEM_CTX(ndr);
12444                         NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);
12445                         for (cntr_disks_1 = 0; cntr_disks_1 < length_disks_1; cntr_disks_1++) {
12446                                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));
12447                         }
12448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_1, 0);
12449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_0, 0);
12450                 }
12451                 if (r->disks) {
12452                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->disks, r->count));
12453                 }
12454                 if (r->disks) {
12455                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->disks, r->count));
12456                 }
12457         }
12458         return NDR_ERR_SUCCESS;
12459 }
12460
12461 _PUBLIC_ void ndr_print_srvsvc_NetDiskInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo *r)
12462 {
12463         uint32_t cntr_disks_1;
12464         ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo");
12465         if (r == NULL) { ndr_print_null(ndr); return; }
12466         ndr->depth++;
12467         ndr_print_uint32(ndr, "count", r->count);
12468         ndr_print_ptr(ndr, "disks", r->disks);
12469         ndr->depth++;
12470         if (r->disks) {
12471                 ndr->print(ndr, "%s: ARRAY(%d)", "disks", (int)r->count);
12472                 ndr->depth++;
12473                 for (cntr_disks_1=0;cntr_disks_1<r->count;cntr_disks_1++) {
12474                         ndr_print_srvsvc_NetDiskInfo0(ndr, "disks", &r->disks[cntr_disks_1]);
12475                 }
12476                 ndr->depth--;
12477         }
12478         ndr->depth--;
12479         ndr->depth--;
12480 }
12481
12482 static enum ndr_err_code ndr_push_srvsvc_Statistics(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_Statistics *r)
12483 {
12484         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12485         if (ndr_flags & NDR_SCALARS) {
12486                 NDR_CHECK(ndr_push_align(ndr, 4));
12487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start));
12488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fopens));
12489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devopens));
12490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->jobsqueued));
12491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sopens));
12492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stimeouts));
12493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serrorout));
12494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwerrors));
12495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permerrors));
12496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->syserrors));
12497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_low));
12498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_high));
12499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_low));
12500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_high));
12501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->avresponse));
12502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reqbufneed));
12503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bigbufneed));
12504                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12505         }
12506         if (ndr_flags & NDR_BUFFERS) {
12507         }
12508         return NDR_ERR_SUCCESS;
12509 }
12510
12511 static enum ndr_err_code ndr_pull_srvsvc_Statistics(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_Statistics *r)
12512 {
12513         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12514         if (ndr_flags & NDR_SCALARS) {
12515                 NDR_CHECK(ndr_pull_align(ndr, 4));
12516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start));
12517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fopens));
12518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devopens));
12519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->jobsqueued));
12520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sopens));
12521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stimeouts));
12522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serrorout));
12523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwerrors));
12524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permerrors));
12525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->syserrors));
12526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_low));
12527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_high));
12528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_low));
12529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_high));
12530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->avresponse));
12531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reqbufneed));
12532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bigbufneed));
12533                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12534         }
12535         if (ndr_flags & NDR_BUFFERS) {
12536         }
12537         return NDR_ERR_SUCCESS;
12538 }
12539
12540 _PUBLIC_ void ndr_print_srvsvc_Statistics(struct ndr_print *ndr, const char *name, const struct srvsvc_Statistics *r)
12541 {
12542         ndr_print_struct(ndr, name, "srvsvc_Statistics");
12543         if (r == NULL) { ndr_print_null(ndr); return; }
12544         ndr->depth++;
12545         ndr_print_uint32(ndr, "start", r->start);
12546         ndr_print_uint32(ndr, "fopens", r->fopens);
12547         ndr_print_uint32(ndr, "devopens", r->devopens);
12548         ndr_print_uint32(ndr, "jobsqueued", r->jobsqueued);
12549         ndr_print_uint32(ndr, "sopens", r->sopens);
12550         ndr_print_uint32(ndr, "stimeouts", r->stimeouts);
12551         ndr_print_uint32(ndr, "serrorout", r->serrorout);
12552         ndr_print_uint32(ndr, "pwerrors", r->pwerrors);
12553         ndr_print_uint32(ndr, "permerrors", r->permerrors);
12554         ndr_print_uint32(ndr, "syserrors", r->syserrors);
12555         ndr_print_uint32(ndr, "bytessent_low", r->bytessent_low);
12556         ndr_print_uint32(ndr, "bytessent_high", r->bytessent_high);
12557         ndr_print_uint32(ndr, "bytesrcvd_low", r->bytesrcvd_low);
12558         ndr_print_uint32(ndr, "bytesrcvd_high", r->bytesrcvd_high);
12559         ndr_print_uint32(ndr, "avresponse", r->avresponse);
12560         ndr_print_uint32(ndr, "reqbufneed", r->reqbufneed);
12561         ndr_print_uint32(ndr, "bigbufneed", r->bigbufneed);
12562         ndr->depth--;
12563 }
12564
12565 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo0 *r)
12566 {
12567         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12568         if (ndr_flags & NDR_SCALARS) {
12569                 NDR_CHECK(ndr_push_align(ndr, 5));
12570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12575                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12576         }
12577         if (ndr_flags & NDR_BUFFERS) {
12578                 if (r->name) {
12579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12582                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12583                 }
12584                 if (r->addr) {
12585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->addr_len));
12586                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12587                 }
12588                 if (r->net_addr) {
12589                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12592                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12593                 }
12594         }
12595         return NDR_ERR_SUCCESS;
12596 }
12597
12598 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo0 *r)
12599 {
12600         uint32_t _ptr_name;
12601         uint32_t size_name_1 = 0;
12602         uint32_t length_name_1 = 0;
12603         TALLOC_CTX *_mem_save_name_0;
12604         uint32_t _ptr_addr;
12605         uint32_t size_addr_1 = 0;
12606         TALLOC_CTX *_mem_save_addr_0;
12607         uint32_t _ptr_net_addr;
12608         uint32_t size_net_addr_1 = 0;
12609         uint32_t length_net_addr_1 = 0;
12610         TALLOC_CTX *_mem_save_net_addr_0;
12611         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12612         if (ndr_flags & NDR_SCALARS) {
12613                 NDR_CHECK(ndr_pull_align(ndr, 5));
12614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12616                 if (_ptr_name) {
12617                         NDR_PULL_ALLOC(ndr, r->name);
12618                 } else {
12619                         r->name = NULL;
12620                 }
12621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12622                 if (_ptr_addr) {
12623                         NDR_PULL_ALLOC(ndr, r->addr);
12624                 } else {
12625                         r->addr = NULL;
12626                 }
12627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12629                 if (_ptr_net_addr) {
12630                         NDR_PULL_ALLOC(ndr, r->net_addr);
12631                 } else {
12632                         r->net_addr = NULL;
12633                 }
12634                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12635         }
12636         if (ndr_flags & NDR_BUFFERS) {
12637                 if (r->name) {
12638                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12639                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12642                         size_name_1 = ndr_get_array_size(ndr, &r->name);
12643                         length_name_1 = ndr_get_array_length(ndr, &r->name);
12644                         if (length_name_1 > size_name_1) {
12645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
12646                         }
12647                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
12648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
12649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12650                 }
12651                 if (r->addr) {
12652                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12653                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12655                         size_addr_1 = ndr_get_array_size(ndr, &r->addr);
12656                         NDR_PULL_ALLOC_N(ndr, r->addr, size_addr_1);
12657                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, size_addr_1));
12658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12659                 }
12660                 if (r->net_addr) {
12661                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12662                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12663                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12664                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12665                         size_net_addr_1 = ndr_get_array_size(ndr, &r->net_addr);
12666                         length_net_addr_1 = ndr_get_array_length(ndr, &r->net_addr);
12667                         if (length_net_addr_1 > size_net_addr_1) {
12668                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_net_addr_1, length_net_addr_1);
12669                         }
12670                         NDR_CHECK(ndr_check_string_terminator(ndr, length_net_addr_1, sizeof(uint16_t)));
12671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, length_net_addr_1, sizeof(uint16_t), CH_UTF16));
12672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12673                 }
12674                 if (r->addr) {
12675                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12676                 }
12677         }
12678         return NDR_ERR_SUCCESS;
12679 }
12680
12681 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo0 *r)
12682 {
12683         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo0");
12684         if (r == NULL) { ndr_print_null(ndr); return; }
12685         ndr->depth++;
12686         ndr_print_uint32(ndr, "vcs", r->vcs);
12687         ndr_print_ptr(ndr, "name", r->name);
12688         ndr->depth++;
12689         if (r->name) {
12690                 ndr_print_string(ndr, "name", r->name);
12691         }
12692         ndr->depth--;
12693         ndr_print_ptr(ndr, "addr", r->addr);
12694         ndr->depth++;
12695         if (r->addr) {
12696                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12697         }
12698         ndr->depth--;
12699         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12700         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12701         ndr->depth++;
12702         if (r->net_addr) {
12703                 ndr_print_string(ndr, "net_addr", r->net_addr);
12704         }
12705         ndr->depth--;
12706         ndr->depth--;
12707 }
12708
12709 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr0 *r)
12710 {
12711         uint32_t cntr_array_1;
12712         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12713         if (ndr_flags & NDR_SCALARS) {
12714                 NDR_CHECK(ndr_push_align(ndr, 5));
12715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12717                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12718         }
12719         if (ndr_flags & NDR_BUFFERS) {
12720                 if (r->array) {
12721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12722                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12723                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12724                         }
12725                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12726                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12727                         }
12728                 }
12729         }
12730         return NDR_ERR_SUCCESS;
12731 }
12732
12733 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr0 *r)
12734 {
12735         uint32_t _ptr_array;
12736         uint32_t size_array_1 = 0;
12737         uint32_t cntr_array_1;
12738         TALLOC_CTX *_mem_save_array_0;
12739         TALLOC_CTX *_mem_save_array_1;
12740         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12741         if (ndr_flags & NDR_SCALARS) {
12742                 NDR_CHECK(ndr_pull_align(ndr, 5));
12743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
12745                 if (_ptr_array) {
12746                         NDR_PULL_ALLOC(ndr, r->array);
12747                 } else {
12748                         r->array = NULL;
12749                 }
12750                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12751         }
12752         if (ndr_flags & NDR_BUFFERS) {
12753                 if (r->array) {
12754                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12755                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12757                         size_array_1 = ndr_get_array_size(ndr, &r->array);
12758                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
12759                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12760                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12761                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
12762                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12763                         }
12764                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
12765                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12766                         }
12767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
12768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12769                 }
12770                 if (r->array) {
12771                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12772                 }
12773         }
12774         return NDR_ERR_SUCCESS;
12775 }
12776
12777 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr0 *r)
12778 {
12779         uint32_t cntr_array_1;
12780         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr0");
12781         if (r == NULL) { ndr_print_null(ndr); return; }
12782         ndr->depth++;
12783         ndr_print_uint32(ndr, "count", r->count);
12784         ndr_print_ptr(ndr, "array", r->array);
12785         ndr->depth++;
12786         if (r->array) {
12787                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12788                 ndr->depth++;
12789                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
12790                         ndr_print_srvsvc_NetTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
12791                 }
12792                 ndr->depth--;
12793         }
12794         ndr->depth--;
12795         ndr->depth--;
12796 }
12797
12798 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo1 *r)
12799 {
12800         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12801         if (ndr_flags & NDR_SCALARS) {
12802                 NDR_CHECK(ndr_push_align(ndr, 5));
12803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
12804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
12805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
12806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
12807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
12808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
12809                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12810         }
12811         if (ndr_flags & NDR_BUFFERS) {
12812                 if (r->name) {
12813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
12816                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12817                 }
12818                 if (r->addr) {
12819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->addr_len));
12820                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
12821                 }
12822                 if (r->net_addr) {
12823                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
12826                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12827                 }
12828                 if (r->domain) {
12829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
12832                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12833                 }
12834         }
12835         return NDR_ERR_SUCCESS;
12836 }
12837
12838 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo1 *r)
12839 {
12840         uint32_t _ptr_name;
12841         uint32_t size_name_1 = 0;
12842         uint32_t length_name_1 = 0;
12843         TALLOC_CTX *_mem_save_name_0;
12844         uint32_t _ptr_addr;
12845         uint32_t size_addr_1 = 0;
12846         TALLOC_CTX *_mem_save_addr_0;
12847         uint32_t _ptr_net_addr;
12848         uint32_t size_net_addr_1 = 0;
12849         uint32_t length_net_addr_1 = 0;
12850         TALLOC_CTX *_mem_save_net_addr_0;
12851         uint32_t _ptr_domain;
12852         uint32_t size_domain_1 = 0;
12853         uint32_t length_domain_1 = 0;
12854         TALLOC_CTX *_mem_save_domain_0;
12855         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
12856         if (ndr_flags & NDR_SCALARS) {
12857                 NDR_CHECK(ndr_pull_align(ndr, 5));
12858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
12859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
12860                 if (_ptr_name) {
12861                         NDR_PULL_ALLOC(ndr, r->name);
12862                 } else {
12863                         r->name = NULL;
12864                 }
12865                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
12866                 if (_ptr_addr) {
12867                         NDR_PULL_ALLOC(ndr, r->addr);
12868                 } else {
12869                         r->addr = NULL;
12870                 }
12871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
12872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
12873                 if (_ptr_net_addr) {
12874                         NDR_PULL_ALLOC(ndr, r->net_addr);
12875                 } else {
12876                         r->net_addr = NULL;
12877                 }
12878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
12879                 if (_ptr_domain) {
12880                         NDR_PULL_ALLOC(ndr, r->domain);
12881                 } else {
12882                         r->domain = NULL;
12883                 }
12884                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12885         }
12886         if (ndr_flags & NDR_BUFFERS) {
12887                 if (r->name) {
12888                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12889                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
12890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
12891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
12892                         size_name_1 = ndr_get_array_size(ndr, &r->name);
12893                         length_name_1 = ndr_get_array_length(ndr, &r->name);
12894                         if (length_name_1 > size_name_1) {
12895                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
12896                         }
12897                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
12898                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
12899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
12900                 }
12901                 if (r->addr) {
12902                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12903                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
12904                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
12905                         size_addr_1 = ndr_get_array_size(ndr, &r->addr);
12906                         NDR_PULL_ALLOC_N(ndr, r->addr, size_addr_1);
12907                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, size_addr_1));
12908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
12909                 }
12910                 if (r->net_addr) {
12911                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
12912                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
12913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
12914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
12915                         size_net_addr_1 = ndr_get_array_size(ndr, &r->net_addr);
12916                         length_net_addr_1 = ndr_get_array_length(ndr, &r->net_addr);
12917                         if (length_net_addr_1 > size_net_addr_1) {
12918                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_net_addr_1, length_net_addr_1);
12919                         }
12920                         NDR_CHECK(ndr_check_string_terminator(ndr, length_net_addr_1, sizeof(uint16_t)));
12921                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, length_net_addr_1, sizeof(uint16_t), CH_UTF16));
12922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
12923                 }
12924                 if (r->domain) {
12925                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
12926                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
12927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
12928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
12929                         size_domain_1 = ndr_get_array_size(ndr, &r->domain);
12930                         length_domain_1 = ndr_get_array_length(ndr, &r->domain);
12931                         if (length_domain_1 > size_domain_1) {
12932                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_1, length_domain_1);
12933                         }
12934                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_1, sizeof(uint16_t)));
12935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, length_domain_1, sizeof(uint16_t), CH_UTF16));
12936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
12937                 }
12938                 if (r->addr) {
12939                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
12940                 }
12941         }
12942         return NDR_ERR_SUCCESS;
12943 }
12944
12945 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo1 *r)
12946 {
12947         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo1");
12948         if (r == NULL) { ndr_print_null(ndr); return; }
12949         ndr->depth++;
12950         ndr_print_uint32(ndr, "vcs", r->vcs);
12951         ndr_print_ptr(ndr, "name", r->name);
12952         ndr->depth++;
12953         if (r->name) {
12954                 ndr_print_string(ndr, "name", r->name);
12955         }
12956         ndr->depth--;
12957         ndr_print_ptr(ndr, "addr", r->addr);
12958         ndr->depth++;
12959         if (r->addr) {
12960                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
12961         }
12962         ndr->depth--;
12963         ndr_print_uint32(ndr, "addr_len", r->addr_len);
12964         ndr_print_ptr(ndr, "net_addr", r->net_addr);
12965         ndr->depth++;
12966         if (r->net_addr) {
12967                 ndr_print_string(ndr, "net_addr", r->net_addr);
12968         }
12969         ndr->depth--;
12970         ndr_print_ptr(ndr, "domain", r->domain);
12971         ndr->depth++;
12972         if (r->domain) {
12973                 ndr_print_string(ndr, "domain", r->domain);
12974         }
12975         ndr->depth--;
12976         ndr->depth--;
12977 }
12978
12979 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr1 *r)
12980 {
12981         uint32_t cntr_array_1;
12982         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
12983         if (ndr_flags & NDR_SCALARS) {
12984                 NDR_CHECK(ndr_push_align(ndr, 5));
12985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
12987                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12988         }
12989         if (ndr_flags & NDR_BUFFERS) {
12990                 if (r->array) {
12991                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12992                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12993                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
12994                         }
12995                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
12996                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
12997                         }
12998                 }
12999         }
13000         return NDR_ERR_SUCCESS;
13001 }
13002
13003 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr1 *r)
13004 {
13005         uint32_t _ptr_array;
13006         uint32_t size_array_1 = 0;
13007         uint32_t cntr_array_1;
13008         TALLOC_CTX *_mem_save_array_0;
13009         TALLOC_CTX *_mem_save_array_1;
13010         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13011         if (ndr_flags & NDR_SCALARS) {
13012                 NDR_CHECK(ndr_pull_align(ndr, 5));
13013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
13015                 if (_ptr_array) {
13016                         NDR_PULL_ALLOC(ndr, r->array);
13017                 } else {
13018                         r->array = NULL;
13019                 }
13020                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13021         }
13022         if (ndr_flags & NDR_BUFFERS) {
13023                 if (r->array) {
13024                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
13025                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13026                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
13027                         size_array_1 = ndr_get_array_size(ndr, &r->array);
13028                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
13029                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
13030                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13031                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13032                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
13033                         }
13034                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13035                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
13036                         }
13037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
13038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
13039                 }
13040                 if (r->array) {
13041                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
13042                 }
13043         }
13044         return NDR_ERR_SUCCESS;
13045 }
13046
13047 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr1 *r)
13048 {
13049         uint32_t cntr_array_1;
13050         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr1");
13051         if (r == NULL) { ndr_print_null(ndr); return; }
13052         ndr->depth++;
13053         ndr_print_uint32(ndr, "count", r->count);
13054         ndr_print_ptr(ndr, "array", r->array);
13055         ndr->depth++;
13056         if (r->array) {
13057                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
13058                 ndr->depth++;
13059                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
13060                         ndr_print_srvsvc_NetTransportInfo1(ndr, "array", &r->array[cntr_array_1]);
13061                 }
13062                 ndr->depth--;
13063         }
13064         ndr->depth--;
13065         ndr->depth--;
13066 }
13067
13068 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo2 *r)
13069 {
13070         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13071         if (ndr_flags & NDR_SCALARS) {
13072                 NDR_CHECK(ndr_push_align(ndr, 5));
13073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
13074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
13075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
13076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
13077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
13078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
13079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
13080                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13081         }
13082         if (ndr_flags & NDR_BUFFERS) {
13083                 if (r->name) {
13084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
13085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
13087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13088                 }
13089                 if (r->addr) {
13090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->addr_len));
13091                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
13092                 }
13093                 if (r->net_addr) {
13094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
13095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13096                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
13097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13098                 }
13099                 if (r->domain) {
13100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
13101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
13103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13104                 }
13105         }
13106         return NDR_ERR_SUCCESS;
13107 }
13108
13109 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo2 *r)
13110 {
13111         uint32_t _ptr_name;
13112         uint32_t size_name_1 = 0;
13113         uint32_t length_name_1 = 0;
13114         TALLOC_CTX *_mem_save_name_0;
13115         uint32_t _ptr_addr;
13116         uint32_t size_addr_1 = 0;
13117         TALLOC_CTX *_mem_save_addr_0;
13118         uint32_t _ptr_net_addr;
13119         uint32_t size_net_addr_1 = 0;
13120         uint32_t length_net_addr_1 = 0;
13121         TALLOC_CTX *_mem_save_net_addr_0;
13122         uint32_t _ptr_domain;
13123         uint32_t size_domain_1 = 0;
13124         uint32_t length_domain_1 = 0;
13125         TALLOC_CTX *_mem_save_domain_0;
13126         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13127         if (ndr_flags & NDR_SCALARS) {
13128                 NDR_CHECK(ndr_pull_align(ndr, 5));
13129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
13130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
13131                 if (_ptr_name) {
13132                         NDR_PULL_ALLOC(ndr, r->name);
13133                 } else {
13134                         r->name = NULL;
13135                 }
13136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
13137                 if (_ptr_addr) {
13138                         NDR_PULL_ALLOC(ndr, r->addr);
13139                 } else {
13140                         r->addr = NULL;
13141                 }
13142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
13143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
13144                 if (_ptr_net_addr) {
13145                         NDR_PULL_ALLOC(ndr, r->net_addr);
13146                 } else {
13147                         r->net_addr = NULL;
13148                 }
13149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
13150                 if (_ptr_domain) {
13151                         NDR_PULL_ALLOC(ndr, r->domain);
13152                 } else {
13153                         r->domain = NULL;
13154                 }
13155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13156                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13157         }
13158         if (ndr_flags & NDR_BUFFERS) {
13159                 if (r->name) {
13160                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13161                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
13162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
13163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
13164                         size_name_1 = ndr_get_array_size(ndr, &r->name);
13165                         length_name_1 = ndr_get_array_length(ndr, &r->name);
13166                         if (length_name_1 > size_name_1) {
13167                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
13168                         }
13169                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
13170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
13171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
13172                 }
13173                 if (r->addr) {
13174                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13175                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
13176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
13177                         size_addr_1 = ndr_get_array_size(ndr, &r->addr);
13178                         NDR_PULL_ALLOC_N(ndr, r->addr, size_addr_1);
13179                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, size_addr_1));
13180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
13181                 }
13182                 if (r->net_addr) {
13183                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13184                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
13185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
13186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
13187                         size_net_addr_1 = ndr_get_array_size(ndr, &r->net_addr);
13188                         length_net_addr_1 = ndr_get_array_length(ndr, &r->net_addr);
13189                         if (length_net_addr_1 > size_net_addr_1) {
13190                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_net_addr_1, length_net_addr_1);
13191                         }
13192                         NDR_CHECK(ndr_check_string_terminator(ndr, length_net_addr_1, sizeof(uint16_t)));
13193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, length_net_addr_1, sizeof(uint16_t), CH_UTF16));
13194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
13195                 }
13196                 if (r->domain) {
13197                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
13198                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
13199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
13200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
13201                         size_domain_1 = ndr_get_array_size(ndr, &r->domain);
13202                         length_domain_1 = ndr_get_array_length(ndr, &r->domain);
13203                         if (length_domain_1 > size_domain_1) {
13204                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_1, length_domain_1);
13205                         }
13206                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_1, sizeof(uint16_t)));
13207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, length_domain_1, sizeof(uint16_t), CH_UTF16));
13208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
13209                 }
13210                 if (r->addr) {
13211                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
13212                 }
13213         }
13214         return NDR_ERR_SUCCESS;
13215 }
13216
13217 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo2 *r)
13218 {
13219         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo2");
13220         if (r == NULL) { ndr_print_null(ndr); return; }
13221         ndr->depth++;
13222         ndr_print_uint32(ndr, "vcs", r->vcs);
13223         ndr_print_ptr(ndr, "name", r->name);
13224         ndr->depth++;
13225         if (r->name) {
13226                 ndr_print_string(ndr, "name", r->name);
13227         }
13228         ndr->depth--;
13229         ndr_print_ptr(ndr, "addr", r->addr);
13230         ndr->depth++;
13231         if (r->addr) {
13232                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
13233         }
13234         ndr->depth--;
13235         ndr_print_uint32(ndr, "addr_len", r->addr_len);
13236         ndr_print_ptr(ndr, "net_addr", r->net_addr);
13237         ndr->depth++;
13238         if (r->net_addr) {
13239                 ndr_print_string(ndr, "net_addr", r->net_addr);
13240         }
13241         ndr->depth--;
13242         ndr_print_ptr(ndr, "domain", r->domain);
13243         ndr->depth++;
13244         if (r->domain) {
13245                 ndr_print_string(ndr, "domain", r->domain);
13246         }
13247         ndr->depth--;
13248         ndr_print_uint32(ndr, "unknown", r->unknown);
13249         ndr->depth--;
13250 }
13251
13252 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr2 *r)
13253 {
13254         uint32_t cntr_array_1;
13255         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13256         if (ndr_flags & NDR_SCALARS) {
13257                 NDR_CHECK(ndr_push_align(ndr, 5));
13258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
13260                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13261         }
13262         if (ndr_flags & NDR_BUFFERS) {
13263                 if (r->array) {
13264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
13265                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
13266                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
13267                         }
13268                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
13269                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
13270                         }
13271                 }
13272         }
13273         return NDR_ERR_SUCCESS;
13274 }
13275
13276 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr2 *r)
13277 {
13278         uint32_t _ptr_array;
13279         uint32_t size_array_1 = 0;
13280         uint32_t cntr_array_1;
13281         TALLOC_CTX *_mem_save_array_0;
13282         TALLOC_CTX *_mem_save_array_1;
13283         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13284         if (ndr_flags & NDR_SCALARS) {
13285                 NDR_CHECK(ndr_pull_align(ndr, 5));
13286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
13288                 if (_ptr_array) {
13289                         NDR_PULL_ALLOC(ndr, r->array);
13290                 } else {
13291                         r->array = NULL;
13292                 }
13293                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13294         }
13295         if (ndr_flags & NDR_BUFFERS) {
13296                 if (r->array) {
13297                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
13298                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
13300                         size_array_1 = ndr_get_array_size(ndr, &r->array);
13301                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
13302                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
13303                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13304                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13305                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
13306                         }
13307                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13308                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
13309                         }
13310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
13311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
13312                 }
13313                 if (r->array) {
13314                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
13315                 }
13316         }
13317         return NDR_ERR_SUCCESS;
13318 }
13319
13320 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr2 *r)
13321 {
13322         uint32_t cntr_array_1;
13323         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr2");
13324         if (r == NULL) { ndr_print_null(ndr); return; }
13325         ndr->depth++;
13326         ndr_print_uint32(ndr, "count", r->count);
13327         ndr_print_ptr(ndr, "array", r->array);
13328         ndr->depth++;
13329         if (r->array) {
13330                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
13331                 ndr->depth++;
13332                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
13333                         ndr_print_srvsvc_NetTransportInfo2(ndr, "array", &r->array[cntr_array_1]);
13334                 }
13335                 ndr->depth--;
13336         }
13337         ndr->depth--;
13338         ndr->depth--;
13339 }
13340
13341 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo3 *r)
13342 {
13343         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13344         if (ndr_flags & NDR_SCALARS) {
13345                 NDR_CHECK(ndr_push_align(ndr, 5));
13346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));
13347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
13348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
13349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));
13350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));
13351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
13352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
13353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
13354                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));
13355                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13356         }
13357         if (ndr_flags & NDR_BUFFERS) {
13358                 if (r->name) {
13359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
13360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
13362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13363                 }
13364                 if (r->addr) {
13365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->addr_len));
13366                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));
13367                 }
13368                 if (r->net_addr) {
13369                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
13370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));
13372                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13373                 }
13374                 if (r->domain) {
13375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
13376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));
13378                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13379                 }
13380         }
13381         return NDR_ERR_SUCCESS;
13382 }
13383
13384 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo3 *r)
13385 {
13386         uint32_t _ptr_name;
13387         uint32_t size_name_1 = 0;
13388         uint32_t length_name_1 = 0;
13389         TALLOC_CTX *_mem_save_name_0;
13390         uint32_t _ptr_addr;
13391         uint32_t size_addr_1 = 0;
13392         TALLOC_CTX *_mem_save_addr_0;
13393         uint32_t _ptr_net_addr;
13394         uint32_t size_net_addr_1 = 0;
13395         uint32_t length_net_addr_1 = 0;
13396         TALLOC_CTX *_mem_save_net_addr_0;
13397         uint32_t _ptr_domain;
13398         uint32_t size_domain_1 = 0;
13399         uint32_t length_domain_1 = 0;
13400         TALLOC_CTX *_mem_save_domain_0;
13401         uint32_t size_unknown3_0 = 0;
13402         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13403         if (ndr_flags & NDR_SCALARS) {
13404                 NDR_CHECK(ndr_pull_align(ndr, 5));
13405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));
13406                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
13407                 if (_ptr_name) {
13408                         NDR_PULL_ALLOC(ndr, r->name);
13409                 } else {
13410                         r->name = NULL;
13411                 }
13412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
13413                 if (_ptr_addr) {
13414                         NDR_PULL_ALLOC(ndr, r->addr);
13415                 } else {
13416                         r->addr = NULL;
13417                 }
13418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));
13419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));
13420                 if (_ptr_net_addr) {
13421                         NDR_PULL_ALLOC(ndr, r->net_addr);
13422                 } else {
13423                         r->net_addr = NULL;
13424                 }
13425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
13426                 if (_ptr_domain) {
13427                         NDR_PULL_ALLOC(ndr, r->domain);
13428                 } else {
13429                         r->domain = NULL;
13430                 }
13431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
13432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
13433                 size_unknown3_0 = 256;
13434                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unknown3, size_unknown3_0));
13435                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13436         }
13437         if (ndr_flags & NDR_BUFFERS) {
13438                 if (r->name) {
13439                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13440                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
13441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
13442                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
13443                         size_name_1 = ndr_get_array_size(ndr, &r->name);
13444                         length_name_1 = ndr_get_array_length(ndr, &r->name);
13445                         if (length_name_1 > size_name_1) {
13446                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_1, length_name_1);
13447                         }
13448                         NDR_CHECK(ndr_check_string_terminator(ndr, length_name_1, sizeof(uint16_t)));
13449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, length_name_1, sizeof(uint16_t), CH_UTF16));
13450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
13451                 }
13452                 if (r->addr) {
13453                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13454                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
13455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
13456                         size_addr_1 = ndr_get_array_size(ndr, &r->addr);
13457                         NDR_PULL_ALLOC_N(ndr, r->addr, size_addr_1);
13458                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, size_addr_1));
13459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
13460                 }
13461                 if (r->net_addr) {
13462                         _mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13463                         NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);
13464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));
13465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));
13466                         size_net_addr_1 = ndr_get_array_size(ndr, &r->net_addr);
13467                         length_net_addr_1 = ndr_get_array_length(ndr, &r->net_addr);
13468                         if (length_net_addr_1 > size_net_addr_1) {
13469                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_net_addr_1, length_net_addr_1);
13470                         }
13471                         NDR_CHECK(ndr_check_string_terminator(ndr, length_net_addr_1, sizeof(uint16_t)));
13472                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, length_net_addr_1, sizeof(uint16_t), CH_UTF16));
13473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);
13474                 }
13475                 if (r->domain) {
13476                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
13477                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
13478                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));
13479                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));
13480                         size_domain_1 = ndr_get_array_size(ndr, &r->domain);
13481                         length_domain_1 = ndr_get_array_length(ndr, &r->domain);
13482                         if (length_domain_1 > size_domain_1) {
13483                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_1, length_domain_1);
13484                         }
13485                         NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_1, sizeof(uint16_t)));
13486                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, length_domain_1, sizeof(uint16_t), CH_UTF16));
13487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
13488                 }
13489                 if (r->addr) {
13490                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));
13491                 }
13492         }
13493         return NDR_ERR_SUCCESS;
13494 }
13495
13496 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo3 *r)
13497 {
13498         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo3");
13499         if (r == NULL) { ndr_print_null(ndr); return; }
13500         ndr->depth++;
13501         ndr_print_uint32(ndr, "vcs", r->vcs);
13502         ndr_print_ptr(ndr, "name", r->name);
13503         ndr->depth++;
13504         if (r->name) {
13505                 ndr_print_string(ndr, "name", r->name);
13506         }
13507         ndr->depth--;
13508         ndr_print_ptr(ndr, "addr", r->addr);
13509         ndr->depth++;
13510         if (r->addr) {
13511                 ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);
13512         }
13513         ndr->depth--;
13514         ndr_print_uint32(ndr, "addr_len", r->addr_len);
13515         ndr_print_ptr(ndr, "net_addr", r->net_addr);
13516         ndr->depth++;
13517         if (r->net_addr) {
13518                 ndr_print_string(ndr, "net_addr", r->net_addr);
13519         }
13520         ndr->depth--;
13521         ndr_print_ptr(ndr, "domain", r->domain);
13522         ndr->depth++;
13523         if (r->domain) {
13524                 ndr_print_string(ndr, "domain", r->domain);
13525         }
13526         ndr->depth--;
13527         ndr_print_uint32(ndr, "unknown1", r->unknown1);
13528         ndr_print_uint32(ndr, "unknown2", r->unknown2);
13529         ndr_print_array_uint8(ndr, "unknown3", r->unknown3, 256);
13530         ndr->depth--;
13531 }
13532
13533 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr3 *r)
13534 {
13535         uint32_t cntr_array_1;
13536         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13537         if (ndr_flags & NDR_SCALARS) {
13538                 NDR_CHECK(ndr_push_align(ndr, 5));
13539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
13540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
13541                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13542         }
13543         if (ndr_flags & NDR_BUFFERS) {
13544                 if (r->array) {
13545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
13546                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
13547                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
13548                         }
13549                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
13550                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
13551                         }
13552                 }
13553         }
13554         return NDR_ERR_SUCCESS;
13555 }
13556
13557 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr3 *r)
13558 {
13559         uint32_t _ptr_array;
13560         uint32_t size_array_1 = 0;
13561         uint32_t cntr_array_1;
13562         TALLOC_CTX *_mem_save_array_0;
13563         TALLOC_CTX *_mem_save_array_1;
13564         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13565         if (ndr_flags & NDR_SCALARS) {
13566                 NDR_CHECK(ndr_pull_align(ndr, 5));
13567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
13568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
13569                 if (_ptr_array) {
13570                         NDR_PULL_ALLOC(ndr, r->array);
13571                 } else {
13572                         r->array = NULL;
13573                 }
13574                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13575         }
13576         if (ndr_flags & NDR_BUFFERS) {
13577                 if (r->array) {
13578                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
13579                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13580                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
13581                         size_array_1 = ndr_get_array_size(ndr, &r->array);
13582                         NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
13583                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
13584                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
13585                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13586                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
13587                         }
13588                         for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
13589                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
13590                         }
13591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
13592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
13593                 }
13594                 if (r->array) {
13595                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
13596                 }
13597         }
13598         return NDR_ERR_SUCCESS;
13599 }
13600
13601 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr3 *r)
13602 {
13603         uint32_t cntr_array_1;
13604         ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr3");
13605         if (r == NULL) { ndr_print_null(ndr); return; }
13606         ndr->depth++;
13607         ndr_print_uint32(ndr, "count", r->count);
13608         ndr_print_ptr(ndr, "array", r->array);
13609         ndr->depth++;
13610         if (r->array) {
13611                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
13612                 ndr->depth++;
13613                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
13614                         ndr_print_srvsvc_NetTransportInfo3(ndr, "array", &r->array[cntr_array_1]);
13615                 }
13616                 ndr->depth--;
13617         }
13618         ndr->depth--;
13619         ndr->depth--;
13620 }
13621
13622 static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportCtr *r)
13623 {
13624         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13625         if (ndr_flags & NDR_SCALARS) {
13626                 uint32_t level = ndr_push_get_switch_value(ndr, r);
13627                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13629                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13630                 switch (level) {
13631                         case 0: {
13632                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
13633                         break; }
13634
13635                         case 1: {
13636                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
13637                         break; }
13638
13639                         case 2: {
13640                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));
13641                         break; }
13642
13643                         case 3: {
13644                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));
13645                         break; }
13646
13647                         default: {
13648                         break; }
13649
13650                 }
13651         }
13652         if (ndr_flags & NDR_BUFFERS) {
13653                 uint32_t level = ndr_push_get_switch_value(ndr, r);
13654                 switch (level) {
13655                         case 0:
13656                                 if (r->ctr0) {
13657                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
13658                                 }
13659                         break;
13660
13661                         case 1:
13662                                 if (r->ctr1) {
13663                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
13664                                 }
13665                         break;
13666
13667                         case 2:
13668                                 if (r->ctr2) {
13669                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
13670                                 }
13671                         break;
13672
13673                         case 3:
13674                                 if (r->ctr3) {
13675                                         NDR_CHECK(ndr_push_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
13676                                 }
13677                         break;
13678
13679                         default:
13680                         break;
13681
13682                 }
13683         }
13684         return NDR_ERR_SUCCESS;
13685 }
13686
13687 static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportCtr *r)
13688 {
13689         uint32_t level;
13690         uint32_t _level;
13691         TALLOC_CTX *_mem_save_ctr0_0;
13692         uint32_t _ptr_ctr0;
13693         TALLOC_CTX *_mem_save_ctr1_0;
13694         uint32_t _ptr_ctr1;
13695         TALLOC_CTX *_mem_save_ctr2_0;
13696         uint32_t _ptr_ctr2;
13697         TALLOC_CTX *_mem_save_ctr3_0;
13698         uint32_t _ptr_ctr3;
13699         level = ndr_pull_get_switch_value(ndr, r);
13700         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13701         if (ndr_flags & NDR_SCALARS) {
13702                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13704                 if (_level != level) {
13705                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13706                 }
13707                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13708                 switch (level) {
13709                         case 0: {
13710                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
13711                                 if (_ptr_ctr0) {
13712                                         NDR_PULL_ALLOC(ndr, r->ctr0);
13713                                 } else {
13714                                         r->ctr0 = NULL;
13715                                 }
13716                         break; }
13717
13718                         case 1: {
13719                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
13720                                 if (_ptr_ctr1) {
13721                                         NDR_PULL_ALLOC(ndr, r->ctr1);
13722                                 } else {
13723                                         r->ctr1 = NULL;
13724                                 }
13725                         break; }
13726
13727                         case 2: {
13728                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));
13729                                 if (_ptr_ctr2) {
13730                                         NDR_PULL_ALLOC(ndr, r->ctr2);
13731                                 } else {
13732                                         r->ctr2 = NULL;
13733                                 }
13734                         break; }
13735
13736                         case 3: {
13737                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));
13738                                 if (_ptr_ctr3) {
13739                                         NDR_PULL_ALLOC(ndr, r->ctr3);
13740                                 } else {
13741                                         r->ctr3 = NULL;
13742                                 }
13743                         break; }
13744
13745                         default: {
13746                         break; }
13747
13748                 }
13749         }
13750         if (ndr_flags & NDR_BUFFERS) {
13751                 switch (level) {
13752                         case 0:
13753                                 if (r->ctr0) {
13754                                         _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
13755                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
13756                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
13757                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
13758                                 }
13759                         break;
13760
13761                         case 1:
13762                                 if (r->ctr1) {
13763                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
13764                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
13765                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
13766                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
13767                                 }
13768                         break;
13769
13770                         case 2:
13771                                 if (r->ctr2) {
13772                                         _mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);
13773                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);
13774                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));
13775                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);
13776                                 }
13777                         break;
13778
13779                         case 3:
13780                                 if (r->ctr3) {
13781                                         _mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);
13782                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);
13783                                         NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));
13784                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);
13785                                 }
13786                         break;
13787
13788                         default:
13789                         break;
13790
13791                 }
13792         }
13793         return NDR_ERR_SUCCESS;
13794 }
13795
13796 _PUBLIC_ void ndr_print_srvsvc_NetTransportCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportCtr *r)
13797 {
13798         uint32_t level;
13799         level = ndr_print_get_switch_value(ndr, r);
13800         ndr_print_union(ndr, name, level, "srvsvc_NetTransportCtr");
13801         switch (level) {
13802                 case 0:
13803                         ndr_print_ptr(ndr, "ctr0", r->ctr0);
13804                         ndr->depth++;
13805                         if (r->ctr0) {
13806                                 ndr_print_srvsvc_NetTransportCtr0(ndr, "ctr0", r->ctr0);
13807                         }
13808                         ndr->depth--;
13809                 break;
13810
13811                 case 1:
13812                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
13813                         ndr->depth++;
13814                         if (r->ctr1) {
13815                                 ndr_print_srvsvc_NetTransportCtr1(ndr, "ctr1", r->ctr1);
13816                         }
13817                         ndr->depth--;
13818                 break;
13819
13820                 case 2:
13821                         ndr_print_ptr(ndr, "ctr2", r->ctr2);
13822                         ndr->depth++;
13823                         if (r->ctr2) {
13824                                 ndr_print_srvsvc_NetTransportCtr2(ndr, "ctr2", r->ctr2);
13825                         }
13826                         ndr->depth--;
13827                 break;
13828
13829                 case 3:
13830                         ndr_print_ptr(ndr, "ctr3", r->ctr3);
13831                         ndr->depth++;
13832                         if (r->ctr3) {
13833                                 ndr_print_srvsvc_NetTransportCtr3(ndr, "ctr3", r->ctr3);
13834                         }
13835                         ndr->depth--;
13836                 break;
13837
13838                 default:
13839                 break;
13840
13841         }
13842 }
13843
13844 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfoCtr *r)
13845 {
13846         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13847         if (ndr_flags & NDR_SCALARS) {
13848                 NDR_CHECK(ndr_push_align(ndr, 5));
13849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
13850                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));
13851                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
13852                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13853         }
13854         if (ndr_flags & NDR_BUFFERS) {
13855                 NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
13856         }
13857         return NDR_ERR_SUCCESS;
13858 }
13859
13860 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfoCtr *r)
13861 {
13862         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13863         if (ndr_flags & NDR_SCALARS) {
13864                 NDR_CHECK(ndr_pull_align(ndr, 5));
13865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
13866                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));
13867                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));
13868                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13869         }
13870         if (ndr_flags & NDR_BUFFERS) {
13871                 NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));
13872         }
13873         return NDR_ERR_SUCCESS;
13874 }
13875
13876 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfoCtr *r)
13877 {
13878         ndr_print_struct(ndr, name, "srvsvc_NetTransportInfoCtr");
13879         if (r == NULL) { ndr_print_null(ndr); return; }
13880         ndr->depth++;
13881         ndr_print_uint32(ndr, "level", r->level);
13882         ndr_print_set_switch_value(ndr, &r->ctr, r->level);
13883         ndr_print_srvsvc_NetTransportCtr(ndr, "ctr", &r->ctr);
13884         ndr->depth--;
13885 }
13886
13887 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTODInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetRemoteTODInfo *r)
13888 {
13889         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13890         if (ndr_flags & NDR_SCALARS) {
13891                 NDR_CHECK(ndr_push_align(ndr, 4));
13892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->elapsed));
13893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->msecs));
13894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hours));
13895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mins));
13896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secs));
13897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hunds));
13898                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->timezone));
13899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tinterval));
13900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));
13901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
13902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
13903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->weekday));
13904                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
13905         }
13906         if (ndr_flags & NDR_BUFFERS) {
13907         }
13908         return NDR_ERR_SUCCESS;
13909 }
13910
13911 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTODInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetRemoteTODInfo *r)
13912 {
13913         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
13914         if (ndr_flags & NDR_SCALARS) {
13915                 NDR_CHECK(ndr_pull_align(ndr, 4));
13916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->elapsed));
13917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->msecs));
13918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hours));
13919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mins));
13920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secs));
13921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hunds));
13922                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->timezone));
13923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tinterval));
13924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));
13925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
13926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
13927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->weekday));
13928                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
13929         }
13930         if (ndr_flags & NDR_BUFFERS) {
13931         }
13932         return NDR_ERR_SUCCESS;
13933 }
13934
13935 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTODInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetRemoteTODInfo *r)
13936 {
13937         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTODInfo");
13938         if (r == NULL) { ndr_print_null(ndr); return; }
13939         ndr->depth++;
13940         ndr_print_uint32(ndr, "elapsed", r->elapsed);
13941         ndr_print_uint32(ndr, "msecs", r->msecs);
13942         ndr_print_uint32(ndr, "hours", r->hours);
13943         ndr_print_uint32(ndr, "mins", r->mins);
13944         ndr_print_uint32(ndr, "secs", r->secs);
13945         ndr_print_uint32(ndr, "hunds", r->hunds);
13946         ndr_print_int32(ndr, "timezone", r->timezone);
13947         ndr_print_uint32(ndr, "tinterval", r->tinterval);
13948         ndr_print_uint32(ndr, "day", r->day);
13949         ndr_print_uint32(ndr, "month", r->month);
13950         ndr_print_uint32(ndr, "year", r->year);
13951         ndr_print_uint32(ndr, "weekday", r->weekday);
13952         ndr->depth--;
13953 }
13954
13955 static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportInfo *r)
13956 {
13957         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
13958         if (ndr_flags & NDR_SCALARS) {
13959                 uint32_t level = ndr_push_get_switch_value(ndr, r);
13960                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13962                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13963                 switch (level) {
13964                         case 0: {
13965                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
13966                         break; }
13967
13968                         case 1: {
13969                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
13970                         break; }
13971
13972                         case 2: {
13973                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
13974                         break; }
13975
13976                         case 3: {
13977                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
13978                         break; }
13979
13980                         default:
13981                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13982                 }
13983         }
13984         if (ndr_flags & NDR_BUFFERS) {
13985                 uint32_t level = ndr_push_get_switch_value(ndr, r);
13986                 switch (level) {
13987                         case 0:
13988                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
13989                         break;
13990
13991                         case 1:
13992                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
13993                         break;
13994
13995                         case 2:
13996                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
13997                         break;
13998
13999                         case 3:
14000                                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
14001                         break;
14002
14003                         default:
14004                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
14005                 }
14006         }
14007         return NDR_ERR_SUCCESS;
14008 }
14009
14010 static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportInfo *r)
14011 {
14012         uint32_t level;
14013         uint32_t _level;
14014         level = ndr_pull_get_switch_value(ndr, r);
14015         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
14016         if (ndr_flags & NDR_SCALARS) {
14017                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14019                 if (_level != level) {
14020                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
14021                 }
14022                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
14023                 switch (level) {
14024                         case 0: {
14025                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));
14026                         break; }
14027
14028                         case 1: {
14029                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));
14030                         break; }
14031
14032                         case 2: {
14033                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));
14034                         break; }
14035
14036                         case 3: {
14037                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));
14038                         break; }
14039
14040                         default:
14041                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
14042                 }
14043         }
14044         if (ndr_flags & NDR_BUFFERS) {
14045                 switch (level) {
14046                         case 0:
14047                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));
14048                         break;
14049
14050                         case 1:
14051                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));
14052                         break;
14053
14054                         case 2:
14055                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));
14056                         break;
14057
14058                         case 3:
14059                                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));
14060                         break;
14061
14062                         default:
14063                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
14064                 }
14065         }
14066         return NDR_ERR_SUCCESS;
14067 }
14068
14069 _PUBLIC_ void ndr_print_srvsvc_NetTransportInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportInfo *r)
14070 {
14071         uint32_t level;
14072         level = ndr_print_get_switch_value(ndr, r);
14073         ndr_print_union(ndr, name, level, "srvsvc_NetTransportInfo");
14074         switch (level) {
14075                 case 0:
14076                         ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", &r->info0);
14077                 break;
14078
14079                 case 1:
14080                         ndr_print_srvsvc_NetTransportInfo1(ndr, "info1", &r->info1);
14081                 break;
14082
14083                 case 2:
14084                         ndr_print_srvsvc_NetTransportInfo2(ndr, "info2", &r->info2);
14085                 break;
14086
14087                 case 3:
14088                         ndr_print_srvsvc_NetTransportInfo3(ndr, "info3", &r->info3);
14089                 break;
14090
14091                 default:
14092                         ndr_print_bad_level(ndr, name, level);
14093         }
14094 }
14095
14096 static enum ndr_err_code ndr_push_srvsvc_NetCharDevEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevEnum *r)
14097 {
14098         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14099         if (flags & NDR_IN) {
14100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14101                 if (r->in.server_unc) {
14102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14104                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14105                         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));
14106                 }
14107                 if (r->in.info_ctr == NULL) {
14108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14109                 }
14110                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14113                 if (r->in.resume_handle) {
14114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14115                 }
14116         }
14117         if (flags & NDR_OUT) {
14118                 if (r->out.info_ctr == NULL) {
14119                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14120                 }
14121                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14122                 if (r->out.totalentries == NULL) {
14123                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14124                 }
14125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14126                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14127                 if (r->out.resume_handle) {
14128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14129                 }
14130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14131         }
14132         return NDR_ERR_SUCCESS;
14133 }
14134
14135 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevEnum *r)
14136 {
14137         uint32_t _ptr_server_unc;
14138         uint32_t size_server_unc_1 = 0;
14139         uint32_t length_server_unc_1 = 0;
14140         uint32_t _ptr_resume_handle;
14141         TALLOC_CTX *_mem_save_server_unc_0;
14142         TALLOC_CTX *_mem_save_info_ctr_0;
14143         TALLOC_CTX *_mem_save_totalentries_0;
14144         TALLOC_CTX *_mem_save_resume_handle_0;
14145         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14146         if (flags & NDR_IN) {
14147                 ZERO_STRUCT(r->out);
14148
14149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14150                 if (_ptr_server_unc) {
14151                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14152                 } else {
14153                         r->in.server_unc = NULL;
14154                 }
14155                 if (r->in.server_unc) {
14156                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14157                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14160                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14161                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14162                         if (length_server_unc_1 > size_server_unc_1) {
14163                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14164                         }
14165                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14168                 }
14169                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14170                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
14171                 }
14172                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14173                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14174                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14177                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14178                 if (_ptr_resume_handle) {
14179                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14180                 } else {
14181                         r->in.resume_handle = NULL;
14182                 }
14183                 if (r->in.resume_handle) {
14184                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14185                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14186                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14188                 }
14189                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14190                 *r->out.info_ctr = *r->in.info_ctr;
14191                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14192                 ZERO_STRUCTP(r->out.totalentries);
14193         }
14194         if (flags & NDR_OUT) {
14195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14196                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14197                 }
14198                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14199                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14200                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14203                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14204                 }
14205                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14206                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14210                 if (_ptr_resume_handle) {
14211                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14212                 } else {
14213                         r->out.resume_handle = NULL;
14214                 }
14215                 if (r->out.resume_handle) {
14216                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14217                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14218                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14220                 }
14221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14222         }
14223         return NDR_ERR_SUCCESS;
14224 }
14225
14226 _PUBLIC_ void ndr_print_srvsvc_NetCharDevEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevEnum *r)
14227 {
14228         ndr_print_struct(ndr, name, "srvsvc_NetCharDevEnum");
14229         if (r == NULL) { ndr_print_null(ndr); return; }
14230         ndr->depth++;
14231         if (flags & NDR_SET_VALUES) {
14232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14233         }
14234         if (flags & NDR_IN) {
14235                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevEnum");
14236                 ndr->depth++;
14237                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14238                 ndr->depth++;
14239                 if (r->in.server_unc) {
14240                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14241                 }
14242                 ndr->depth--;
14243                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
14244                 ndr->depth++;
14245                 ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->in.info_ctr);
14246                 ndr->depth--;
14247                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14248                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14249                 ndr->depth++;
14250                 if (r->in.resume_handle) {
14251                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14252                 }
14253                 ndr->depth--;
14254                 ndr->depth--;
14255         }
14256         if (flags & NDR_OUT) {
14257                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevEnum");
14258                 ndr->depth++;
14259                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
14260                 ndr->depth++;
14261                 ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->out.info_ctr);
14262                 ndr->depth--;
14263                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14264                 ndr->depth++;
14265                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14266                 ndr->depth--;
14267                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14268                 ndr->depth++;
14269                 if (r->out.resume_handle) {
14270                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14271                 }
14272                 ndr->depth--;
14273                 ndr_print_WERROR(ndr, "result", r->out.result);
14274                 ndr->depth--;
14275         }
14276         ndr->depth--;
14277 }
14278
14279 static enum ndr_err_code ndr_push_srvsvc_NetCharDevGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevGetInfo *r)
14280 {
14281         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14282         if (flags & NDR_IN) {
14283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14284                 if (r->in.server_unc) {
14285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14288                         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));
14289                 }
14290                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
14291                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14292                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
14293                 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));
14294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14295         }
14296         if (flags & NDR_OUT) {
14297                 if (r->out.info == NULL) {
14298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14299                 }
14300                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
14301                 NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14302                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14303         }
14304         return NDR_ERR_SUCCESS;
14305 }
14306
14307 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevGetInfo *r)
14308 {
14309         uint32_t _ptr_server_unc;
14310         uint32_t size_server_unc_1 = 0;
14311         uint32_t length_server_unc_1 = 0;
14312         uint32_t size_device_name_0 = 0;
14313         uint32_t length_device_name_0 = 0;
14314         TALLOC_CTX *_mem_save_server_unc_0;
14315         TALLOC_CTX *_mem_save_info_0;
14316         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14317         if (flags & NDR_IN) {
14318                 ZERO_STRUCT(r->out);
14319
14320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14321                 if (_ptr_server_unc) {
14322                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14323                 } else {
14324                         r->in.server_unc = NULL;
14325                 }
14326                 if (r->in.server_unc) {
14327                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14328                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14331                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14332                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14333                         if (length_server_unc_1 > size_server_unc_1) {
14334                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14335                         }
14336                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14339                 }
14340                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
14341                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
14342                 size_device_name_0 = ndr_get_array_size(ndr, &r->in.device_name);
14343                 length_device_name_0 = ndr_get_array_length(ndr, &r->in.device_name);
14344                 if (length_device_name_0 > size_device_name_0) {
14345                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_name_0, length_device_name_0);
14346                 }
14347                 NDR_CHECK(ndr_check_string_terminator(ndr, length_device_name_0, sizeof(uint16_t)));
14348                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, length_device_name_0, sizeof(uint16_t), CH_UTF16));
14349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14350                 NDR_PULL_ALLOC(ndr, r->out.info);
14351                 ZERO_STRUCTP(r->out.info);
14352         }
14353         if (flags & NDR_OUT) {
14354                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14355                         NDR_PULL_ALLOC(ndr, r->out.info);
14356                 }
14357                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14358                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14359                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
14360                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14362                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14363         }
14364         return NDR_ERR_SUCCESS;
14365 }
14366
14367 _PUBLIC_ void ndr_print_srvsvc_NetCharDevGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevGetInfo *r)
14368 {
14369         ndr_print_struct(ndr, name, "srvsvc_NetCharDevGetInfo");
14370         if (r == NULL) { ndr_print_null(ndr); return; }
14371         ndr->depth++;
14372         if (flags & NDR_SET_VALUES) {
14373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14374         }
14375         if (flags & NDR_IN) {
14376                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevGetInfo");
14377                 ndr->depth++;
14378                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14379                 ndr->depth++;
14380                 if (r->in.server_unc) {
14381                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14382                 }
14383                 ndr->depth--;
14384                 ndr_print_string(ndr, "device_name", r->in.device_name);
14385                 ndr_print_uint32(ndr, "level", r->in.level);
14386                 ndr->depth--;
14387         }
14388         if (flags & NDR_OUT) {
14389                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevGetInfo");
14390                 ndr->depth++;
14391                 ndr_print_ptr(ndr, "info", r->out.info);
14392                 ndr->depth++;
14393                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14394                 ndr_print_srvsvc_NetCharDevInfo(ndr, "info", r->out.info);
14395                 ndr->depth--;
14396                 ndr_print_WERROR(ndr, "result", r->out.result);
14397                 ndr->depth--;
14398         }
14399         ndr->depth--;
14400 }
14401
14402 static enum ndr_err_code ndr_push_srvsvc_NetCharDevControl(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevControl *r)
14403 {
14404         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14405         if (flags & NDR_IN) {
14406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14407                 if (r->in.server_unc) {
14408                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14411                         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));
14412                 }
14413                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
14414                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14415                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
14416                 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));
14417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.opcode));
14418         }
14419         if (flags & NDR_OUT) {
14420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14421         }
14422         return NDR_ERR_SUCCESS;
14423 }
14424
14425 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevControl(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevControl *r)
14426 {
14427         uint32_t _ptr_server_unc;
14428         uint32_t size_server_unc_1 = 0;
14429         uint32_t length_server_unc_1 = 0;
14430         uint32_t size_device_name_0 = 0;
14431         uint32_t length_device_name_0 = 0;
14432         TALLOC_CTX *_mem_save_server_unc_0;
14433         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14434         if (flags & NDR_IN) {
14435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14436                 if (_ptr_server_unc) {
14437                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14438                 } else {
14439                         r->in.server_unc = NULL;
14440                 }
14441                 if (r->in.server_unc) {
14442                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14445                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14446                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14447                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14448                         if (length_server_unc_1 > size_server_unc_1) {
14449                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14450                         }
14451                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14452                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14454                 }
14455                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
14456                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
14457                 size_device_name_0 = ndr_get_array_size(ndr, &r->in.device_name);
14458                 length_device_name_0 = ndr_get_array_length(ndr, &r->in.device_name);
14459                 if (length_device_name_0 > size_device_name_0) {
14460                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_name_0, length_device_name_0);
14461                 }
14462                 NDR_CHECK(ndr_check_string_terminator(ndr, length_device_name_0, sizeof(uint16_t)));
14463                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, length_device_name_0, sizeof(uint16_t), CH_UTF16));
14464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.opcode));
14465         }
14466         if (flags & NDR_OUT) {
14467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14468         }
14469         return NDR_ERR_SUCCESS;
14470 }
14471
14472 _PUBLIC_ void ndr_print_srvsvc_NetCharDevControl(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevControl *r)
14473 {
14474         ndr_print_struct(ndr, name, "srvsvc_NetCharDevControl");
14475         if (r == NULL) { ndr_print_null(ndr); return; }
14476         ndr->depth++;
14477         if (flags & NDR_SET_VALUES) {
14478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14479         }
14480         if (flags & NDR_IN) {
14481                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevControl");
14482                 ndr->depth++;
14483                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14484                 ndr->depth++;
14485                 if (r->in.server_unc) {
14486                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14487                 }
14488                 ndr->depth--;
14489                 ndr_print_string(ndr, "device_name", r->in.device_name);
14490                 ndr_print_uint32(ndr, "opcode", r->in.opcode);
14491                 ndr->depth--;
14492         }
14493         if (flags & NDR_OUT) {
14494                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevControl");
14495                 ndr->depth++;
14496                 ndr_print_WERROR(ndr, "result", r->out.result);
14497                 ndr->depth--;
14498         }
14499         ndr->depth--;
14500 }
14501
14502 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQEnum *r)
14503 {
14504         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14505         if (flags & NDR_IN) {
14506                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14507                 if (r->in.server_unc) {
14508                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14511                         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));
14512                 }
14513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
14514                 if (r->in.user) {
14515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14518                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14519                 }
14520                 if (r->in.info_ctr == NULL) {
14521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14522                 }
14523                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
14525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
14526                 if (r->in.resume_handle) {
14527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
14528                 }
14529         }
14530         if (flags & NDR_OUT) {
14531                 if (r->out.info_ctr == NULL) {
14532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14533                 }
14534                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14535                 if (r->out.totalentries == NULL) {
14536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14537                 }
14538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
14539                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
14540                 if (r->out.resume_handle) {
14541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
14542                 }
14543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14544         }
14545         return NDR_ERR_SUCCESS;
14546 }
14547
14548 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQEnum *r)
14549 {
14550         uint32_t _ptr_server_unc;
14551         uint32_t size_server_unc_1 = 0;
14552         uint32_t length_server_unc_1 = 0;
14553         uint32_t _ptr_user;
14554         uint32_t size_user_1 = 0;
14555         uint32_t length_user_1 = 0;
14556         uint32_t _ptr_resume_handle;
14557         TALLOC_CTX *_mem_save_server_unc_0;
14558         TALLOC_CTX *_mem_save_user_0;
14559         TALLOC_CTX *_mem_save_info_ctr_0;
14560         TALLOC_CTX *_mem_save_totalentries_0;
14561         TALLOC_CTX *_mem_save_resume_handle_0;
14562         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14563         if (flags & NDR_IN) {
14564                 ZERO_STRUCT(r->out);
14565
14566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14567                 if (_ptr_server_unc) {
14568                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14569                 } else {
14570                         r->in.server_unc = NULL;
14571                 }
14572                 if (r->in.server_unc) {
14573                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14574                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14577                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14578                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14579                         if (length_server_unc_1 > size_server_unc_1) {
14580                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14581                         }
14582                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14583                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14585                 }
14586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
14587                 if (_ptr_user) {
14588                         NDR_PULL_ALLOC(ndr, r->in.user);
14589                 } else {
14590                         r->in.user = NULL;
14591                 }
14592                 if (r->in.user) {
14593                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
14594                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
14595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14597                         size_user_1 = ndr_get_array_size(ndr, &r->in.user);
14598                         length_user_1 = ndr_get_array_length(ndr, &r->in.user);
14599                         if (length_user_1 > size_user_1) {
14600                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
14601                         }
14602                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
14603                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, length_user_1, sizeof(uint16_t), CH_UTF16));
14604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
14605                 }
14606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14607                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
14608                 }
14609                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14610                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14611                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
14612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
14614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14615                 if (_ptr_resume_handle) {
14616                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
14617                 } else {
14618                         r->in.resume_handle = NULL;
14619                 }
14620                 if (r->in.resume_handle) {
14621                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14622                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
14623                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
14624                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14625                 }
14626                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14627                 *r->out.info_ctr = *r->in.info_ctr;
14628                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
14629                 ZERO_STRUCTP(r->out.totalentries);
14630         }
14631         if (flags & NDR_OUT) {
14632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14633                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
14634                 }
14635                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14636                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
14637                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
14638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14639                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14640                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
14641                 }
14642                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
14643                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
14644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
14645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
14646                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
14647                 if (_ptr_resume_handle) {
14648                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
14649                 } else {
14650                         r->out.resume_handle = NULL;
14651                 }
14652                 if (r->out.resume_handle) {
14653                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14654                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
14655                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
14656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
14657                 }
14658                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14659         }
14660         return NDR_ERR_SUCCESS;
14661 }
14662
14663 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQEnum *r)
14664 {
14665         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQEnum");
14666         if (r == NULL) { ndr_print_null(ndr); return; }
14667         ndr->depth++;
14668         if (flags & NDR_SET_VALUES) {
14669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14670         }
14671         if (flags & NDR_IN) {
14672                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQEnum");
14673                 ndr->depth++;
14674                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14675                 ndr->depth++;
14676                 if (r->in.server_unc) {
14677                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14678                 }
14679                 ndr->depth--;
14680                 ndr_print_ptr(ndr, "user", r->in.user);
14681                 ndr->depth++;
14682                 if (r->in.user) {
14683                         ndr_print_string(ndr, "user", r->in.user);
14684                 }
14685                 ndr->depth--;
14686                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
14687                 ndr->depth++;
14688                 ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->in.info_ctr);
14689                 ndr->depth--;
14690                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
14691                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
14692                 ndr->depth++;
14693                 if (r->in.resume_handle) {
14694                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
14695                 }
14696                 ndr->depth--;
14697                 ndr->depth--;
14698         }
14699         if (flags & NDR_OUT) {
14700                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQEnum");
14701                 ndr->depth++;
14702                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
14703                 ndr->depth++;
14704                 ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->out.info_ctr);
14705                 ndr->depth--;
14706                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
14707                 ndr->depth++;
14708                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
14709                 ndr->depth--;
14710                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
14711                 ndr->depth++;
14712                 if (r->out.resume_handle) {
14713                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
14714                 }
14715                 ndr->depth--;
14716                 ndr_print_WERROR(ndr, "result", r->out.result);
14717                 ndr->depth--;
14718         }
14719         ndr->depth--;
14720 }
14721
14722 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
14723 {
14724         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14725         if (flags & NDR_IN) {
14726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14727                 if (r->in.server_unc) {
14728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14731                         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));
14732                 }
14733                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14734                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14735                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14736                 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));
14737                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14738                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14739                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
14740                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14742         }
14743         if (flags & NDR_OUT) {
14744                 if (r->out.info == NULL) {
14745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14746                 }
14747                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
14748                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14750         }
14751         return NDR_ERR_SUCCESS;
14752 }
14753
14754 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQGetInfo *r)
14755 {
14756         uint32_t _ptr_server_unc;
14757         uint32_t size_server_unc_1 = 0;
14758         uint32_t length_server_unc_1 = 0;
14759         uint32_t size_queue_name_0 = 0;
14760         uint32_t length_queue_name_0 = 0;
14761         uint32_t size_user_0 = 0;
14762         uint32_t length_user_0 = 0;
14763         TALLOC_CTX *_mem_save_server_unc_0;
14764         TALLOC_CTX *_mem_save_info_0;
14765         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14766         if (flags & NDR_IN) {
14767                 ZERO_STRUCT(r->out);
14768
14769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14770                 if (_ptr_server_unc) {
14771                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14772                 } else {
14773                         r->in.server_unc = NULL;
14774                 }
14775                 if (r->in.server_unc) {
14776                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14780                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14781                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14782                         if (length_server_unc_1 > size_server_unc_1) {
14783                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14784                         }
14785                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14786                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14788                 }
14789                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
14790                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
14791                 size_queue_name_0 = ndr_get_array_size(ndr, &r->in.queue_name);
14792                 length_queue_name_0 = ndr_get_array_length(ndr, &r->in.queue_name);
14793                 if (length_queue_name_0 > size_queue_name_0) {
14794                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_queue_name_0, length_queue_name_0);
14795                 }
14796                 NDR_CHECK(ndr_check_string_terminator(ndr, length_queue_name_0, sizeof(uint16_t)));
14797                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, length_queue_name_0, sizeof(uint16_t), CH_UTF16));
14798                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
14799                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
14800                 size_user_0 = ndr_get_array_size(ndr, &r->in.user);
14801                 length_user_0 = ndr_get_array_length(ndr, &r->in.user);
14802                 if (length_user_0 > size_user_0) {
14803                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_0, length_user_0);
14804                 }
14805                 NDR_CHECK(ndr_check_string_terminator(ndr, length_user_0, sizeof(uint16_t)));
14806                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, length_user_0, sizeof(uint16_t), CH_UTF16));
14807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14808                 NDR_PULL_ALLOC(ndr, r->out.info);
14809                 ZERO_STRUCTP(r->out.info);
14810         }
14811         if (flags & NDR_OUT) {
14812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14813                         NDR_PULL_ALLOC(ndr, r->out.info);
14814                 }
14815                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
14818                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14821         }
14822         return NDR_ERR_SUCCESS;
14823 }
14824
14825 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQGetInfo *r)
14826 {
14827         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQGetInfo");
14828         if (r == NULL) { ndr_print_null(ndr); return; }
14829         ndr->depth++;
14830         if (flags & NDR_SET_VALUES) {
14831                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14832         }
14833         if (flags & NDR_IN) {
14834                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQGetInfo");
14835                 ndr->depth++;
14836                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14837                 ndr->depth++;
14838                 if (r->in.server_unc) {
14839                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14840                 }
14841                 ndr->depth--;
14842                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14843                 ndr_print_string(ndr, "user", r->in.user);
14844                 ndr_print_uint32(ndr, "level", r->in.level);
14845                 ndr->depth--;
14846         }
14847         if (flags & NDR_OUT) {
14848                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQGetInfo");
14849                 ndr->depth++;
14850                 ndr_print_ptr(ndr, "info", r->out.info);
14851                 ndr->depth++;
14852                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
14853                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", r->out.info);
14854                 ndr->depth--;
14855                 ndr_print_WERROR(ndr, "result", r->out.result);
14856                 ndr->depth--;
14857         }
14858         ndr->depth--;
14859 }
14860
14861 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
14862 {
14863         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
14864         if (flags & NDR_IN) {
14865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
14866                 if (r->in.server_unc) {
14867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
14870                         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));
14871                 }
14872                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14873                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
14874                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
14875                 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));
14876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14877                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
14878                 NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
14879                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
14880                 if (r->in.parm_error) {
14881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
14882                 }
14883         }
14884         if (flags & NDR_OUT) {
14885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
14886                 if (r->out.parm_error) {
14887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
14888                 }
14889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQSetInfo *r)
14895 {
14896         uint32_t _ptr_server_unc;
14897         uint32_t size_server_unc_1 = 0;
14898         uint32_t length_server_unc_1 = 0;
14899         uint32_t size_queue_name_0 = 0;
14900         uint32_t length_queue_name_0 = 0;
14901         uint32_t _ptr_parm_error;
14902         TALLOC_CTX *_mem_save_server_unc_0;
14903         TALLOC_CTX *_mem_save_parm_error_0;
14904         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
14905         if (flags & NDR_IN) {
14906                 ZERO_STRUCT(r->out);
14907
14908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
14909                 if (_ptr_server_unc) {
14910                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
14911                 } else {
14912                         r->in.server_unc = NULL;
14913                 }
14914                 if (r->in.server_unc) {
14915                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14916                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
14917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
14918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
14919                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
14920                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
14921                         if (length_server_unc_1 > size_server_unc_1) {
14922                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
14923                         }
14924                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
14925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
14926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
14927                 }
14928                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
14929                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
14930                 size_queue_name_0 = ndr_get_array_size(ndr, &r->in.queue_name);
14931                 length_queue_name_0 = ndr_get_array_length(ndr, &r->in.queue_name);
14932                 if (length_queue_name_0 > size_queue_name_0) {
14933                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_queue_name_0, length_queue_name_0);
14934                 }
14935                 NDR_CHECK(ndr_check_string_terminator(ndr, length_queue_name_0, sizeof(uint16_t)));
14936                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, length_queue_name_0, sizeof(uint16_t), CH_UTF16));
14937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14938                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
14939                 NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
14940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
14941                 if (_ptr_parm_error) {
14942                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
14943                 } else {
14944                         r->in.parm_error = NULL;
14945                 }
14946                 if (r->in.parm_error) {
14947                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
14948                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
14949                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
14950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
14951                 }
14952         }
14953         if (flags & NDR_OUT) {
14954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
14955                 if (_ptr_parm_error) {
14956                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
14957                 } else {
14958                         r->out.parm_error = NULL;
14959                 }
14960                 if (r->out.parm_error) {
14961                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
14962                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
14963                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
14964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
14965                 }
14966                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14967         }
14968         return NDR_ERR_SUCCESS;
14969 }
14970
14971 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQSetInfo *r)
14972 {
14973         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQSetInfo");
14974         if (r == NULL) { ndr_print_null(ndr); return; }
14975         ndr->depth++;
14976         if (flags & NDR_SET_VALUES) {
14977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14978         }
14979         if (flags & NDR_IN) {
14980                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQSetInfo");
14981                 ndr->depth++;
14982                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
14983                 ndr->depth++;
14984                 if (r->in.server_unc) {
14985                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
14986                 }
14987                 ndr->depth--;
14988                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
14989                 ndr_print_uint32(ndr, "level", r->in.level);
14990                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
14991                 ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", &r->in.info);
14992                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
14993                 ndr->depth++;
14994                 if (r->in.parm_error) {
14995                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
14996                 }
14997                 ndr->depth--;
14998                 ndr->depth--;
14999         }
15000         if (flags & NDR_OUT) {
15001                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQSetInfo");
15002                 ndr->depth++;
15003                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
15004                 ndr->depth++;
15005                 if (r->out.parm_error) {
15006                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
15007                 }
15008                 ndr->depth--;
15009                 ndr_print_WERROR(ndr, "result", r->out.result);
15010                 ndr->depth--;
15011         }
15012         ndr->depth--;
15013 }
15014
15015 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurge(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurge *r)
15016 {
15017         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15018         if (flags & NDR_IN) {
15019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15020                 if (r->in.server_unc) {
15021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15024                         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));
15025                 }
15026                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
15027                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15028                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
15029                 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));
15030         }
15031         if (flags & NDR_OUT) {
15032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15033         }
15034         return NDR_ERR_SUCCESS;
15035 }
15036
15037 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurge(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurge *r)
15038 {
15039         uint32_t _ptr_server_unc;
15040         uint32_t size_server_unc_1 = 0;
15041         uint32_t length_server_unc_1 = 0;
15042         uint32_t size_queue_name_0 = 0;
15043         uint32_t length_queue_name_0 = 0;
15044         TALLOC_CTX *_mem_save_server_unc_0;
15045         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15046         if (flags & NDR_IN) {
15047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15048                 if (_ptr_server_unc) {
15049                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15050                 } else {
15051                         r->in.server_unc = NULL;
15052                 }
15053                 if (r->in.server_unc) {
15054                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15055                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15056                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15057                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15058                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15059                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15060                         if (length_server_unc_1 > size_server_unc_1) {
15061                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15062                         }
15063                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15064                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15066                 }
15067                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
15068                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
15069                 size_queue_name_0 = ndr_get_array_size(ndr, &r->in.queue_name);
15070                 length_queue_name_0 = ndr_get_array_length(ndr, &r->in.queue_name);
15071                 if (length_queue_name_0 > size_queue_name_0) {
15072                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_queue_name_0, length_queue_name_0);
15073                 }
15074                 NDR_CHECK(ndr_check_string_terminator(ndr, length_queue_name_0, sizeof(uint16_t)));
15075                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, length_queue_name_0, sizeof(uint16_t), CH_UTF16));
15076         }
15077         if (flags & NDR_OUT) {
15078                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15079         }
15080         return NDR_ERR_SUCCESS;
15081 }
15082
15083 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurge(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurge *r)
15084 {
15085         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurge");
15086         if (r == NULL) { ndr_print_null(ndr); return; }
15087         ndr->depth++;
15088         if (flags & NDR_SET_VALUES) {
15089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15090         }
15091         if (flags & NDR_IN) {
15092                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurge");
15093                 ndr->depth++;
15094                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15095                 ndr->depth++;
15096                 if (r->in.server_unc) {
15097                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15098                 }
15099                 ndr->depth--;
15100                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
15101                 ndr->depth--;
15102         }
15103         if (flags & NDR_OUT) {
15104                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurge");
15105                 ndr->depth++;
15106                 ndr_print_WERROR(ndr, "result", r->out.result);
15107                 ndr->depth--;
15108         }
15109         ndr->depth--;
15110 }
15111
15112 static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurgeSelf(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
15113 {
15114         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15115         if (flags & NDR_IN) {
15116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15117                 if (r->in.server_unc) {
15118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15121                         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));
15122                 }
15123                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
15124                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15125                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));
15126                 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));
15127                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
15128                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15129                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));
15130                 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));
15131         }
15132         if (flags & NDR_OUT) {
15133                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15134         }
15135         return NDR_ERR_SUCCESS;
15136 }
15137
15138 static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurgeSelf(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurgeSelf *r)
15139 {
15140         uint32_t _ptr_server_unc;
15141         uint32_t size_server_unc_1 = 0;
15142         uint32_t length_server_unc_1 = 0;
15143         uint32_t size_queue_name_0 = 0;
15144         uint32_t length_queue_name_0 = 0;
15145         uint32_t size_computer_name_0 = 0;
15146         uint32_t length_computer_name_0 = 0;
15147         TALLOC_CTX *_mem_save_server_unc_0;
15148         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15149         if (flags & NDR_IN) {
15150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15151                 if (_ptr_server_unc) {
15152                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15153                 } else {
15154                         r->in.server_unc = NULL;
15155                 }
15156                 if (r->in.server_unc) {
15157                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15158                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15161                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15162                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15163                         if (length_server_unc_1 > size_server_unc_1) {
15164                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15165                         }
15166                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15167                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15169                 }
15170                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));
15171                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));
15172                 size_queue_name_0 = ndr_get_array_size(ndr, &r->in.queue_name);
15173                 length_queue_name_0 = ndr_get_array_length(ndr, &r->in.queue_name);
15174                 if (length_queue_name_0 > size_queue_name_0) {
15175                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_queue_name_0, length_queue_name_0);
15176                 }
15177                 NDR_CHECK(ndr_check_string_terminator(ndr, length_queue_name_0, sizeof(uint16_t)));
15178                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, length_queue_name_0, sizeof(uint16_t), CH_UTF16));
15179                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.computer_name));
15180                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.computer_name));
15181                 size_computer_name_0 = ndr_get_array_size(ndr, &r->in.computer_name);
15182                 length_computer_name_0 = ndr_get_array_length(ndr, &r->in.computer_name);
15183                 if (length_computer_name_0 > size_computer_name_0) {
15184                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_name_0, length_computer_name_0);
15185                 }
15186                 NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_name_0, sizeof(uint16_t)));
15187                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.computer_name, length_computer_name_0, sizeof(uint16_t), CH_UTF16));
15188         }
15189         if (flags & NDR_OUT) {
15190                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15191         }
15192         return NDR_ERR_SUCCESS;
15193 }
15194
15195 _PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurgeSelf(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)
15196 {
15197         ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurgeSelf");
15198         if (r == NULL) { ndr_print_null(ndr); return; }
15199         ndr->depth++;
15200         if (flags & NDR_SET_VALUES) {
15201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15202         }
15203         if (flags & NDR_IN) {
15204                 ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurgeSelf");
15205                 ndr->depth++;
15206                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15207                 ndr->depth++;
15208                 if (r->in.server_unc) {
15209                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15210                 }
15211                 ndr->depth--;
15212                 ndr_print_string(ndr, "queue_name", r->in.queue_name);
15213                 ndr_print_string(ndr, "computer_name", r->in.computer_name);
15214                 ndr->depth--;
15215         }
15216         if (flags & NDR_OUT) {
15217                 ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurgeSelf");
15218                 ndr->depth++;
15219                 ndr_print_WERROR(ndr, "result", r->out.result);
15220                 ndr->depth--;
15221         }
15222         ndr->depth--;
15223 }
15224
15225 static enum ndr_err_code ndr_push_srvsvc_NetConnEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetConnEnum *r)
15226 {
15227         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15228         if (flags & NDR_IN) {
15229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15230                 if (r->in.server_unc) {
15231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15234                         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));
15235                 }
15236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
15237                 if (r->in.path) {
15238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
15239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
15241                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15242                 }
15243                 if (r->in.info_ctr == NULL) {
15244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15245                 }
15246                 NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
15248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
15249                 if (r->in.resume_handle) {
15250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
15251                 }
15252         }
15253         if (flags & NDR_OUT) {
15254                 if (r->out.info_ctr == NULL) {
15255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15256                 }
15257                 NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15258                 if (r->out.totalentries == NULL) {
15259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15260                 }
15261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
15262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
15263                 if (r->out.resume_handle) {
15264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
15265                 }
15266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 static enum ndr_err_code ndr_pull_srvsvc_NetConnEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetConnEnum *r)
15272 {
15273         uint32_t _ptr_server_unc;
15274         uint32_t size_server_unc_1 = 0;
15275         uint32_t length_server_unc_1 = 0;
15276         uint32_t _ptr_path;
15277         uint32_t size_path_1 = 0;
15278         uint32_t length_path_1 = 0;
15279         uint32_t _ptr_resume_handle;
15280         TALLOC_CTX *_mem_save_server_unc_0;
15281         TALLOC_CTX *_mem_save_path_0;
15282         TALLOC_CTX *_mem_save_info_ctr_0;
15283         TALLOC_CTX *_mem_save_totalentries_0;
15284         TALLOC_CTX *_mem_save_resume_handle_0;
15285         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15286         if (flags & NDR_IN) {
15287                 ZERO_STRUCT(r->out);
15288
15289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15290                 if (_ptr_server_unc) {
15291                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15292                 } else {
15293                         r->in.server_unc = NULL;
15294                 }
15295                 if (r->in.server_unc) {
15296                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15297                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15299                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15300                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15301                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15302                         if (length_server_unc_1 > size_server_unc_1) {
15303                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15304                         }
15305                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15306                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15308                 }
15309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
15310                 if (_ptr_path) {
15311                         NDR_PULL_ALLOC(ndr, r->in.path);
15312                 } else {
15313                         r->in.path = NULL;
15314                 }
15315                 if (r->in.path) {
15316                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
15317                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
15318                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
15319                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
15320                         size_path_1 = ndr_get_array_size(ndr, &r->in.path);
15321                         length_path_1 = ndr_get_array_length(ndr, &r->in.path);
15322                         if (length_path_1 > size_path_1) {
15323                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
15324                         }
15325                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
15326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_1, sizeof(uint16_t), CH_UTF16));
15327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
15328                 }
15329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15330                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15331                 }
15332                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15333                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15334                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
15337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15338                 if (_ptr_resume_handle) {
15339                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
15340                 } else {
15341                         r->in.resume_handle = NULL;
15342                 }
15343                 if (r->in.resume_handle) {
15344                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15345                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
15346                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
15347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15348                 }
15349                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15350                 *r->out.info_ctr = *r->in.info_ctr;
15351                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
15352                 ZERO_STRUCTP(r->out.totalentries);
15353         }
15354         if (flags & NDR_OUT) {
15355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15356                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15357                 }
15358                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15359                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15360                 NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15362                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15363                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
15364                 }
15365                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
15366                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
15367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
15368                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
15369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15370                 if (_ptr_resume_handle) {
15371                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
15372                 } else {
15373                         r->out.resume_handle = NULL;
15374                 }
15375                 if (r->out.resume_handle) {
15376                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15377                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15378                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15380                 }
15381                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15382         }
15383         return NDR_ERR_SUCCESS;
15384 }
15385
15386 _PUBLIC_ void ndr_print_srvsvc_NetConnEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetConnEnum *r)
15387 {
15388         ndr_print_struct(ndr, name, "srvsvc_NetConnEnum");
15389         if (r == NULL) { ndr_print_null(ndr); return; }
15390         ndr->depth++;
15391         if (flags & NDR_SET_VALUES) {
15392                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15393         }
15394         if (flags & NDR_IN) {
15395                 ndr_print_struct(ndr, "in", "srvsvc_NetConnEnum");
15396                 ndr->depth++;
15397                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15398                 ndr->depth++;
15399                 if (r->in.server_unc) {
15400                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15401                 }
15402                 ndr->depth--;
15403                 ndr_print_ptr(ndr, "path", r->in.path);
15404                 ndr->depth++;
15405                 if (r->in.path) {
15406                         ndr_print_string(ndr, "path", r->in.path);
15407                 }
15408                 ndr->depth--;
15409                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15410                 ndr->depth++;
15411                 ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15412                 ndr->depth--;
15413                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15414                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15415                 ndr->depth++;
15416                 if (r->in.resume_handle) {
15417                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15418                 }
15419                 ndr->depth--;
15420                 ndr->depth--;
15421         }
15422         if (flags & NDR_OUT) {
15423                 ndr_print_struct(ndr, "out", "srvsvc_NetConnEnum");
15424                 ndr->depth++;
15425                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
15426                 ndr->depth++;
15427                 ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->out.info_ctr);
15428                 ndr->depth--;
15429                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15430                 ndr->depth++;
15431                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15432                 ndr->depth--;
15433                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15434                 ndr->depth++;
15435                 if (r->out.resume_handle) {
15436                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15437                 }
15438                 ndr->depth--;
15439                 ndr_print_WERROR(ndr, "result", r->out.result);
15440                 ndr->depth--;
15441         }
15442         ndr->depth--;
15443 }
15444
15445 static enum ndr_err_code ndr_push_srvsvc_NetFileEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileEnum *r)
15446 {
15447         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15448         if (flags & NDR_IN) {
15449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15450                 if (r->in.server_unc) {
15451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15454                         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));
15455                 }
15456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));
15457                 if (r->in.path) {
15458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
15459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
15461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15462                 }
15463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
15464                 if (r->in.user) {
15465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15469                 }
15470                 if (r->in.info_ctr == NULL) {
15471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15472                 }
15473                 NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
15475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
15476                 if (r->in.resume_handle) {
15477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
15478                 }
15479         }
15480         if (flags & NDR_OUT) {
15481                 if (r->out.info_ctr == NULL) {
15482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15483                 }
15484                 NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15485                 if (r->out.totalentries == NULL) {
15486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15487                 }
15488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
15489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
15490                 if (r->out.resume_handle) {
15491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
15492                 }
15493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15494         }
15495         return NDR_ERR_SUCCESS;
15496 }
15497
15498 static enum ndr_err_code ndr_pull_srvsvc_NetFileEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileEnum *r)
15499 {
15500         uint32_t _ptr_server_unc;
15501         uint32_t size_server_unc_1 = 0;
15502         uint32_t length_server_unc_1 = 0;
15503         uint32_t _ptr_path;
15504         uint32_t size_path_1 = 0;
15505         uint32_t length_path_1 = 0;
15506         uint32_t _ptr_user;
15507         uint32_t size_user_1 = 0;
15508         uint32_t length_user_1 = 0;
15509         uint32_t _ptr_resume_handle;
15510         TALLOC_CTX *_mem_save_server_unc_0;
15511         TALLOC_CTX *_mem_save_path_0;
15512         TALLOC_CTX *_mem_save_user_0;
15513         TALLOC_CTX *_mem_save_info_ctr_0;
15514         TALLOC_CTX *_mem_save_totalentries_0;
15515         TALLOC_CTX *_mem_save_resume_handle_0;
15516         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15517         if (flags & NDR_IN) {
15518                 ZERO_STRUCT(r->out);
15519
15520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15521                 if (_ptr_server_unc) {
15522                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15523                 } else {
15524                         r->in.server_unc = NULL;
15525                 }
15526                 if (r->in.server_unc) {
15527                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15531                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15532                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15533                         if (length_server_unc_1 > size_server_unc_1) {
15534                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15535                         }
15536                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15539                 }
15540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));
15541                 if (_ptr_path) {
15542                         NDR_PULL_ALLOC(ndr, r->in.path);
15543                 } else {
15544                         r->in.path = NULL;
15545                 }
15546                 if (r->in.path) {
15547                         _mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
15548                         NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);
15549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
15550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
15551                         size_path_1 = ndr_get_array_size(ndr, &r->in.path);
15552                         length_path_1 = ndr_get_array_length(ndr, &r->in.path);
15553                         if (length_path_1 > size_path_1) {
15554                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_1, length_path_1);
15555                         }
15556                         NDR_CHECK(ndr_check_string_terminator(ndr, length_path_1, sizeof(uint16_t)));
15557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_1, sizeof(uint16_t), CH_UTF16));
15558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);
15559                 }
15560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
15561                 if (_ptr_user) {
15562                         NDR_PULL_ALLOC(ndr, r->in.user);
15563                 } else {
15564                         r->in.user = NULL;
15565                 }
15566                 if (r->in.user) {
15567                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
15568                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
15569                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
15570                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
15571                         size_user_1 = ndr_get_array_size(ndr, &r->in.user);
15572                         length_user_1 = ndr_get_array_length(ndr, &r->in.user);
15573                         if (length_user_1 > size_user_1) {
15574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
15575                         }
15576                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
15577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, length_user_1, sizeof(uint16_t), CH_UTF16));
15578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
15579                 }
15580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15581                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
15582                 }
15583                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15585                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
15588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15589                 if (_ptr_resume_handle) {
15590                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
15591                 } else {
15592                         r->in.resume_handle = NULL;
15593                 }
15594                 if (r->in.resume_handle) {
15595                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15596                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
15597                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
15598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15599                 }
15600                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15601                 *r->out.info_ctr = *r->in.info_ctr;
15602                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
15603                 ZERO_STRUCTP(r->out.totalentries);
15604         }
15605         if (flags & NDR_OUT) {
15606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15607                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
15608                 }
15609                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15610                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
15611                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15613                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15614                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
15615                 }
15616                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
15617                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
15618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
15619                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
15620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
15621                 if (_ptr_resume_handle) {
15622                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
15623                 } else {
15624                         r->out.resume_handle = NULL;
15625                 }
15626                 if (r->out.resume_handle) {
15627                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15628                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
15629                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
15630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
15631                 }
15632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15633         }
15634         return NDR_ERR_SUCCESS;
15635 }
15636
15637 _PUBLIC_ void ndr_print_srvsvc_NetFileEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileEnum *r)
15638 {
15639         ndr_print_struct(ndr, name, "srvsvc_NetFileEnum");
15640         if (r == NULL) { ndr_print_null(ndr); return; }
15641         ndr->depth++;
15642         if (flags & NDR_SET_VALUES) {
15643                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15644         }
15645         if (flags & NDR_IN) {
15646                 ndr_print_struct(ndr, "in", "srvsvc_NetFileEnum");
15647                 ndr->depth++;
15648                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15649                 ndr->depth++;
15650                 if (r->in.server_unc) {
15651                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15652                 }
15653                 ndr->depth--;
15654                 ndr_print_ptr(ndr, "path", r->in.path);
15655                 ndr->depth++;
15656                 if (r->in.path) {
15657                         ndr_print_string(ndr, "path", r->in.path);
15658                 }
15659                 ndr->depth--;
15660                 ndr_print_ptr(ndr, "user", r->in.user);
15661                 ndr->depth++;
15662                 if (r->in.user) {
15663                         ndr_print_string(ndr, "user", r->in.user);
15664                 }
15665                 ndr->depth--;
15666                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
15667                 ndr->depth++;
15668                 ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->in.info_ctr);
15669                 ndr->depth--;
15670                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
15671                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
15672                 ndr->depth++;
15673                 if (r->in.resume_handle) {
15674                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
15675                 }
15676                 ndr->depth--;
15677                 ndr->depth--;
15678         }
15679         if (flags & NDR_OUT) {
15680                 ndr_print_struct(ndr, "out", "srvsvc_NetFileEnum");
15681                 ndr->depth++;
15682                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
15683                 ndr->depth++;
15684                 ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->out.info_ctr);
15685                 ndr->depth--;
15686                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
15687                 ndr->depth++;
15688                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
15689                 ndr->depth--;
15690                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
15691                 ndr->depth++;
15692                 if (r->out.resume_handle) {
15693                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
15694                 }
15695                 ndr->depth--;
15696                 ndr_print_WERROR(ndr, "result", r->out.result);
15697                 ndr->depth--;
15698         }
15699         ndr->depth--;
15700 }
15701
15702 static enum ndr_err_code ndr_push_srvsvc_NetFileGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileGetInfo *r)
15703 {
15704         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15705         if (flags & NDR_IN) {
15706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15707                 if (r->in.server_unc) {
15708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15711                         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));
15712                 }
15713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
15714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15715         }
15716         if (flags & NDR_OUT) {
15717                 if (r->out.info == NULL) {
15718                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15719                 }
15720                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
15721                 NDR_CHECK(ndr_push_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15723         }
15724         return NDR_ERR_SUCCESS;
15725 }
15726
15727 static enum ndr_err_code ndr_pull_srvsvc_NetFileGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileGetInfo *r)
15728 {
15729         uint32_t _ptr_server_unc;
15730         uint32_t size_server_unc_1 = 0;
15731         uint32_t length_server_unc_1 = 0;
15732         TALLOC_CTX *_mem_save_server_unc_0;
15733         TALLOC_CTX *_mem_save_info_0;
15734         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15735         if (flags & NDR_IN) {
15736                 ZERO_STRUCT(r->out);
15737
15738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15739                 if (_ptr_server_unc) {
15740                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15741                 } else {
15742                         r->in.server_unc = NULL;
15743                 }
15744                 if (r->in.server_unc) {
15745                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15748                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15749                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15750                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15751                         if (length_server_unc_1 > size_server_unc_1) {
15752                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15753                         }
15754                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15755                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15757                 }
15758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
15759                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15760                 NDR_PULL_ALLOC(ndr, r->out.info);
15761                 ZERO_STRUCTP(r->out.info);
15762         }
15763         if (flags & NDR_OUT) {
15764                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15765                         NDR_PULL_ALLOC(ndr, r->out.info);
15766                 }
15767                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15768                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15769                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
15770                 NDR_CHECK(ndr_pull_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15773         }
15774         return NDR_ERR_SUCCESS;
15775 }
15776
15777 _PUBLIC_ void ndr_print_srvsvc_NetFileGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileGetInfo *r)
15778 {
15779         ndr_print_struct(ndr, name, "srvsvc_NetFileGetInfo");
15780         if (r == NULL) { ndr_print_null(ndr); return; }
15781         ndr->depth++;
15782         if (flags & NDR_SET_VALUES) {
15783                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15784         }
15785         if (flags & NDR_IN) {
15786                 ndr_print_struct(ndr, "in", "srvsvc_NetFileGetInfo");
15787                 ndr->depth++;
15788                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15789                 ndr->depth++;
15790                 if (r->in.server_unc) {
15791                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15792                 }
15793                 ndr->depth--;
15794                 ndr_print_uint32(ndr, "fid", r->in.fid);
15795                 ndr_print_uint32(ndr, "level", r->in.level);
15796                 ndr->depth--;
15797         }
15798         if (flags & NDR_OUT) {
15799                 ndr_print_struct(ndr, "out", "srvsvc_NetFileGetInfo");
15800                 ndr->depth++;
15801                 ndr_print_ptr(ndr, "info", r->out.info);
15802                 ndr->depth++;
15803                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
15804                 ndr_print_srvsvc_NetFileInfo(ndr, "info", r->out.info);
15805                 ndr->depth--;
15806                 ndr_print_WERROR(ndr, "result", r->out.result);
15807                 ndr->depth--;
15808         }
15809         ndr->depth--;
15810 }
15811
15812 static enum ndr_err_code ndr_push_srvsvc_NetFileClose(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileClose *r)
15813 {
15814         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15815         if (flags & NDR_IN) {
15816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15817                 if (r->in.server_unc) {
15818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15821                         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));
15822                 }
15823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));
15824         }
15825         if (flags & NDR_OUT) {
15826                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15827         }
15828         return NDR_ERR_SUCCESS;
15829 }
15830
15831 static enum ndr_err_code ndr_pull_srvsvc_NetFileClose(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileClose *r)
15832 {
15833         uint32_t _ptr_server_unc;
15834         uint32_t size_server_unc_1 = 0;
15835         uint32_t length_server_unc_1 = 0;
15836         TALLOC_CTX *_mem_save_server_unc_0;
15837         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15838         if (flags & NDR_IN) {
15839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15840                 if (_ptr_server_unc) {
15841                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15842                 } else {
15843                         r->in.server_unc = NULL;
15844                 }
15845                 if (r->in.server_unc) {
15846                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15847                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15848                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15849                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15850                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15851                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15852                         if (length_server_unc_1 > size_server_unc_1) {
15853                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15854                         }
15855                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15858                 }
15859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));
15860         }
15861         if (flags & NDR_OUT) {
15862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15863         }
15864         return NDR_ERR_SUCCESS;
15865 }
15866
15867 _PUBLIC_ void ndr_print_srvsvc_NetFileClose(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileClose *r)
15868 {
15869         ndr_print_struct(ndr, name, "srvsvc_NetFileClose");
15870         if (r == NULL) { ndr_print_null(ndr); return; }
15871         ndr->depth++;
15872         if (flags & NDR_SET_VALUES) {
15873                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15874         }
15875         if (flags & NDR_IN) {
15876                 ndr_print_struct(ndr, "in", "srvsvc_NetFileClose");
15877                 ndr->depth++;
15878                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
15879                 ndr->depth++;
15880                 if (r->in.server_unc) {
15881                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
15882                 }
15883                 ndr->depth--;
15884                 ndr_print_uint32(ndr, "fid", r->in.fid);
15885                 ndr->depth--;
15886         }
15887         if (flags & NDR_OUT) {
15888                 ndr_print_struct(ndr, "out", "srvsvc_NetFileClose");
15889                 ndr->depth++;
15890                 ndr_print_WERROR(ndr, "result", r->out.result);
15891                 ndr->depth--;
15892         }
15893         ndr->depth--;
15894 }
15895
15896 static enum ndr_err_code ndr_push_srvsvc_NetSessEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessEnum *r)
15897 {
15898         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
15899         if (flags & NDR_IN) {
15900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
15901                 if (r->in.server_unc) {
15902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
15905                         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));
15906                 }
15907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
15908                 if (r->in.client) {
15909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
15912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15913                 }
15914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
15915                 if (r->in.user) {
15916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
15919                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15920                 }
15921                 if (r->in.info_ctr == NULL) {
15922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15923                 }
15924                 NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
15925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
15926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
15927                 if (r->in.resume_handle) {
15928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
15929                 }
15930         }
15931         if (flags & NDR_OUT) {
15932                 if (r->out.info_ctr == NULL) {
15933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15934                 }
15935                 NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
15936                 if (r->out.totalentries == NULL) {
15937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15938                 }
15939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
15940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
15941                 if (r->out.resume_handle) {
15942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
15943                 }
15944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15945         }
15946         return NDR_ERR_SUCCESS;
15947 }
15948
15949 static enum ndr_err_code ndr_pull_srvsvc_NetSessEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessEnum *r)
15950 {
15951         uint32_t _ptr_server_unc;
15952         uint32_t size_server_unc_1 = 0;
15953         uint32_t length_server_unc_1 = 0;
15954         uint32_t _ptr_client;
15955         uint32_t size_client_1 = 0;
15956         uint32_t length_client_1 = 0;
15957         uint32_t _ptr_user;
15958         uint32_t size_user_1 = 0;
15959         uint32_t length_user_1 = 0;
15960         uint32_t _ptr_resume_handle;
15961         TALLOC_CTX *_mem_save_server_unc_0;
15962         TALLOC_CTX *_mem_save_client_0;
15963         TALLOC_CTX *_mem_save_user_0;
15964         TALLOC_CTX *_mem_save_info_ctr_0;
15965         TALLOC_CTX *_mem_save_totalentries_0;
15966         TALLOC_CTX *_mem_save_resume_handle_0;
15967         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
15968         if (flags & NDR_IN) {
15969                 ZERO_STRUCT(r->out);
15970
15971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
15972                 if (_ptr_server_unc) {
15973                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
15974                 } else {
15975                         r->in.server_unc = NULL;
15976                 }
15977                 if (r->in.server_unc) {
15978                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15979                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
15980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
15981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
15982                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
15983                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
15984                         if (length_server_unc_1 > size_server_unc_1) {
15985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
15986                         }
15987                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
15988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
15989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
15990                 }
15991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
15992                 if (_ptr_client) {
15993                         NDR_PULL_ALLOC(ndr, r->in.client);
15994                 } else {
15995                         r->in.client = NULL;
15996                 }
15997                 if (r->in.client) {
15998                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
15999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
16000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
16001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
16002                         size_client_1 = ndr_get_array_size(ndr, &r->in.client);
16003                         length_client_1 = ndr_get_array_length(ndr, &r->in.client);
16004                         if (length_client_1 > size_client_1) {
16005                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
16006                         }
16007                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
16008                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, length_client_1, sizeof(uint16_t), CH_UTF16));
16009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
16010                 }
16011                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
16012                 if (_ptr_user) {
16013                         NDR_PULL_ALLOC(ndr, r->in.user);
16014                 } else {
16015                         r->in.user = NULL;
16016                 }
16017                 if (r->in.user) {
16018                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
16019                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
16020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
16021                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
16022                         size_user_1 = ndr_get_array_size(ndr, &r->in.user);
16023                         length_user_1 = ndr_get_array_length(ndr, &r->in.user);
16024                         if (length_user_1 > size_user_1) {
16025                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
16026                         }
16027                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
16028                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, length_user_1, sizeof(uint16_t), CH_UTF16));
16029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
16030                 }
16031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16032                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
16033                 }
16034                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16035                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16036                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
16039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16040                 if (_ptr_resume_handle) {
16041                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16042                 } else {
16043                         r->in.resume_handle = NULL;
16044                 }
16045                 if (r->in.resume_handle) {
16046                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16047                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16048                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16050                 }
16051                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
16052                 *r->out.info_ctr = *r->in.info_ctr;
16053                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16054                 ZERO_STRUCTP(r->out.totalentries);
16055         }
16056         if (flags & NDR_OUT) {
16057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16058                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
16059                 }
16060                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16062                 NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
16063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16065                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16066                 }
16067                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16072                 if (_ptr_resume_handle) {
16073                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16074                 } else {
16075                         r->out.resume_handle = NULL;
16076                 }
16077                 if (r->out.resume_handle) {
16078                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16079                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16080                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16081                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16082                 }
16083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16084         }
16085         return NDR_ERR_SUCCESS;
16086 }
16087
16088 _PUBLIC_ void ndr_print_srvsvc_NetSessEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessEnum *r)
16089 {
16090         ndr_print_struct(ndr, name, "srvsvc_NetSessEnum");
16091         if (r == NULL) { ndr_print_null(ndr); return; }
16092         ndr->depth++;
16093         if (flags & NDR_SET_VALUES) {
16094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16095         }
16096         if (flags & NDR_IN) {
16097                 ndr_print_struct(ndr, "in", "srvsvc_NetSessEnum");
16098                 ndr->depth++;
16099                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16100                 ndr->depth++;
16101                 if (r->in.server_unc) {
16102                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16103                 }
16104                 ndr->depth--;
16105                 ndr_print_ptr(ndr, "client", r->in.client);
16106                 ndr->depth++;
16107                 if (r->in.client) {
16108                         ndr_print_string(ndr, "client", r->in.client);
16109                 }
16110                 ndr->depth--;
16111                 ndr_print_ptr(ndr, "user", r->in.user);
16112                 ndr->depth++;
16113                 if (r->in.user) {
16114                         ndr_print_string(ndr, "user", r->in.user);
16115                 }
16116                 ndr->depth--;
16117                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
16118                 ndr->depth++;
16119                 ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->in.info_ctr);
16120                 ndr->depth--;
16121                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
16122                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16123                 ndr->depth++;
16124                 if (r->in.resume_handle) {
16125                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16126                 }
16127                 ndr->depth--;
16128                 ndr->depth--;
16129         }
16130         if (flags & NDR_OUT) {
16131                 ndr_print_struct(ndr, "out", "srvsvc_NetSessEnum");
16132                 ndr->depth++;
16133                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
16134                 ndr->depth++;
16135                 ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->out.info_ctr);
16136                 ndr->depth--;
16137                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16138                 ndr->depth++;
16139                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16140                 ndr->depth--;
16141                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16142                 ndr->depth++;
16143                 if (r->out.resume_handle) {
16144                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16145                 }
16146                 ndr->depth--;
16147                 ndr_print_WERROR(ndr, "result", r->out.result);
16148                 ndr->depth--;
16149         }
16150         ndr->depth--;
16151 }
16152
16153 static enum ndr_err_code ndr_push_srvsvc_NetSessDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessDel *r)
16154 {
16155         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16156         if (flags & NDR_IN) {
16157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16158                 if (r->in.server_unc) {
16159                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16162                         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));
16163                 }
16164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));
16165                 if (r->in.client) {
16166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
16167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));
16169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16170                 }
16171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));
16172                 if (r->in.user) {
16173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
16174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));
16176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16177                 }
16178         }
16179         if (flags & NDR_OUT) {
16180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16181         }
16182         return NDR_ERR_SUCCESS;
16183 }
16184
16185 static enum ndr_err_code ndr_pull_srvsvc_NetSessDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessDel *r)
16186 {
16187         uint32_t _ptr_server_unc;
16188         uint32_t size_server_unc_1 = 0;
16189         uint32_t length_server_unc_1 = 0;
16190         uint32_t _ptr_client;
16191         uint32_t size_client_1 = 0;
16192         uint32_t length_client_1 = 0;
16193         uint32_t _ptr_user;
16194         uint32_t size_user_1 = 0;
16195         uint32_t length_user_1 = 0;
16196         TALLOC_CTX *_mem_save_server_unc_0;
16197         TALLOC_CTX *_mem_save_client_0;
16198         TALLOC_CTX *_mem_save_user_0;
16199         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16200         if (flags & NDR_IN) {
16201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16202                 if (_ptr_server_unc) {
16203                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16204                 } else {
16205                         r->in.server_unc = NULL;
16206                 }
16207                 if (r->in.server_unc) {
16208                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16209                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16211                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16212                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16213                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16214                         if (length_server_unc_1 > size_server_unc_1) {
16215                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16216                         }
16217                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16220                 }
16221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
16222                 if (_ptr_client) {
16223                         NDR_PULL_ALLOC(ndr, r->in.client);
16224                 } else {
16225                         r->in.client = NULL;
16226                 }
16227                 if (r->in.client) {
16228                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
16229                         NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);
16230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));
16231                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));
16232                         size_client_1 = ndr_get_array_size(ndr, &r->in.client);
16233                         length_client_1 = ndr_get_array_length(ndr, &r->in.client);
16234                         if (length_client_1 > size_client_1) {
16235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_1, length_client_1);
16236                         }
16237                         NDR_CHECK(ndr_check_string_terminator(ndr, length_client_1, sizeof(uint16_t)));
16238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, length_client_1, sizeof(uint16_t), CH_UTF16));
16239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
16240                 }
16241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
16242                 if (_ptr_user) {
16243                         NDR_PULL_ALLOC(ndr, r->in.user);
16244                 } else {
16245                         r->in.user = NULL;
16246                 }
16247                 if (r->in.user) {
16248                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
16249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);
16250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));
16251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));
16252                         size_user_1 = ndr_get_array_size(ndr, &r->in.user);
16253                         length_user_1 = ndr_get_array_length(ndr, &r->in.user);
16254                         if (length_user_1 > size_user_1) {
16255                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_user_1, length_user_1);
16256                         }
16257                         NDR_CHECK(ndr_check_string_terminator(ndr, length_user_1, sizeof(uint16_t)));
16258                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, length_user_1, sizeof(uint16_t), CH_UTF16));
16259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
16260                 }
16261         }
16262         if (flags & NDR_OUT) {
16263                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16264         }
16265         return NDR_ERR_SUCCESS;
16266 }
16267
16268 _PUBLIC_ void ndr_print_srvsvc_NetSessDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessDel *r)
16269 {
16270         ndr_print_struct(ndr, name, "srvsvc_NetSessDel");
16271         if (r == NULL) { ndr_print_null(ndr); return; }
16272         ndr->depth++;
16273         if (flags & NDR_SET_VALUES) {
16274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16275         }
16276         if (flags & NDR_IN) {
16277                 ndr_print_struct(ndr, "in", "srvsvc_NetSessDel");
16278                 ndr->depth++;
16279                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16280                 ndr->depth++;
16281                 if (r->in.server_unc) {
16282                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16283                 }
16284                 ndr->depth--;
16285                 ndr_print_ptr(ndr, "client", r->in.client);
16286                 ndr->depth++;
16287                 if (r->in.client) {
16288                         ndr_print_string(ndr, "client", r->in.client);
16289                 }
16290                 ndr->depth--;
16291                 ndr_print_ptr(ndr, "user", r->in.user);
16292                 ndr->depth++;
16293                 if (r->in.user) {
16294                         ndr_print_string(ndr, "user", r->in.user);
16295                 }
16296                 ndr->depth--;
16297                 ndr->depth--;
16298         }
16299         if (flags & NDR_OUT) {
16300                 ndr_print_struct(ndr, "out", "srvsvc_NetSessDel");
16301                 ndr->depth++;
16302                 ndr_print_WERROR(ndr, "result", r->out.result);
16303                 ndr->depth--;
16304         }
16305         ndr->depth--;
16306 }
16307
16308 static enum ndr_err_code ndr_push_srvsvc_NetShareAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareAdd *r)
16309 {
16310         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16311         if (flags & NDR_IN) {
16312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16313                 if (r->in.server_unc) {
16314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16317                         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));
16318                 }
16319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16320                 if (r->in.info == NULL) {
16321                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16322                 }
16323                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
16324                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
16326                 if (r->in.parm_error) {
16327                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
16328                 }
16329         }
16330         if (flags & NDR_OUT) {
16331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
16332                 if (r->out.parm_error) {
16333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
16334                 }
16335                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16336         }
16337         return NDR_ERR_SUCCESS;
16338 }
16339
16340 static enum ndr_err_code ndr_pull_srvsvc_NetShareAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareAdd *r)
16341 {
16342         uint32_t _ptr_server_unc;
16343         uint32_t size_server_unc_1 = 0;
16344         uint32_t length_server_unc_1 = 0;
16345         uint32_t _ptr_parm_error;
16346         TALLOC_CTX *_mem_save_server_unc_0;
16347         TALLOC_CTX *_mem_save_info_0;
16348         TALLOC_CTX *_mem_save_parm_error_0;
16349         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16350         if (flags & NDR_IN) {
16351                 ZERO_STRUCT(r->out);
16352
16353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16354                 if (_ptr_server_unc) {
16355                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16356                 } else {
16357                         r->in.server_unc = NULL;
16358                 }
16359                 if (r->in.server_unc) {
16360                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16361                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16364                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16365                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16366                         if (length_server_unc_1 > size_server_unc_1) {
16367                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16368                         }
16369                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16372                 }
16373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16375                         NDR_PULL_ALLOC(ndr, r->in.info);
16376                 }
16377                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16378                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16379                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
16380                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16383                 if (_ptr_parm_error) {
16384                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
16385                 } else {
16386                         r->in.parm_error = NULL;
16387                 }
16388                 if (r->in.parm_error) {
16389                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16390                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
16391                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
16392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16393                 }
16394         }
16395         if (flags & NDR_OUT) {
16396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16397                 if (_ptr_parm_error) {
16398                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
16399                 } else {
16400                         r->out.parm_error = NULL;
16401                 }
16402                 if (r->out.parm_error) {
16403                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16404                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
16405                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
16406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16407                 }
16408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16409         }
16410         return NDR_ERR_SUCCESS;
16411 }
16412
16413 _PUBLIC_ void ndr_print_srvsvc_NetShareAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareAdd *r)
16414 {
16415         ndr_print_struct(ndr, name, "srvsvc_NetShareAdd");
16416         if (r == NULL) { ndr_print_null(ndr); return; }
16417         ndr->depth++;
16418         if (flags & NDR_SET_VALUES) {
16419                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16420         }
16421         if (flags & NDR_IN) {
16422                 ndr_print_struct(ndr, "in", "srvsvc_NetShareAdd");
16423                 ndr->depth++;
16424                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16425                 ndr->depth++;
16426                 if (r->in.server_unc) {
16427                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16428                 }
16429                 ndr->depth--;
16430                 ndr_print_uint32(ndr, "level", r->in.level);
16431                 ndr_print_ptr(ndr, "info", r->in.info);
16432                 ndr->depth++;
16433                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
16434                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
16435                 ndr->depth--;
16436                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
16437                 ndr->depth++;
16438                 if (r->in.parm_error) {
16439                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
16440                 }
16441                 ndr->depth--;
16442                 ndr->depth--;
16443         }
16444         if (flags & NDR_OUT) {
16445                 ndr_print_struct(ndr, "out", "srvsvc_NetShareAdd");
16446                 ndr->depth++;
16447                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
16448                 ndr->depth++;
16449                 if (r->out.parm_error) {
16450                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
16451                 }
16452                 ndr->depth--;
16453                 ndr_print_WERROR(ndr, "result", r->out.result);
16454                 ndr->depth--;
16455         }
16456         ndr->depth--;
16457 }
16458
16459 static enum ndr_err_code ndr_push_srvsvc_NetShareEnumAll(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnumAll *r)
16460 {
16461         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16462         if (flags & NDR_IN) {
16463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16464                 if (r->in.server_unc) {
16465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16468                         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));
16469                 }
16470                 if (r->in.info_ctr == NULL) {
16471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16472                 }
16473                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
16475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
16476                 if (r->in.resume_handle) {
16477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
16478                 }
16479         }
16480         if (flags & NDR_OUT) {
16481                 if (r->out.info_ctr == NULL) {
16482                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16483                 }
16484                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
16485                 if (r->out.totalentries == NULL) {
16486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16487                 }
16488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
16489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
16490                 if (r->out.resume_handle) {
16491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
16492                 }
16493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16494         }
16495         return NDR_ERR_SUCCESS;
16496 }
16497
16498 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnumAll(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnumAll *r)
16499 {
16500         uint32_t _ptr_server_unc;
16501         uint32_t size_server_unc_1 = 0;
16502         uint32_t length_server_unc_1 = 0;
16503         uint32_t _ptr_resume_handle;
16504         TALLOC_CTX *_mem_save_server_unc_0;
16505         TALLOC_CTX *_mem_save_info_ctr_0;
16506         TALLOC_CTX *_mem_save_totalentries_0;
16507         TALLOC_CTX *_mem_save_resume_handle_0;
16508         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16509         if (flags & NDR_IN) {
16510                 ZERO_STRUCT(r->out);
16511
16512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16513                 if (_ptr_server_unc) {
16514                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16515                 } else {
16516                         r->in.server_unc = NULL;
16517                 }
16518                 if (r->in.server_unc) {
16519                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16520                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16521                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16522                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16523                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16524                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16525                         if (length_server_unc_1 > size_server_unc_1) {
16526                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16527                         }
16528                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16531                 }
16532                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16533                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
16534                 }
16535                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16536                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16537                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
16538                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
16540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16541                 if (_ptr_resume_handle) {
16542                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
16543                 } else {
16544                         r->in.resume_handle = NULL;
16545                 }
16546                 if (r->in.resume_handle) {
16547                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16548                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
16549                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
16550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16551                 }
16552                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
16553                 *r->out.info_ctr = *r->in.info_ctr;
16554                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
16555                 ZERO_STRUCTP(r->out.totalentries);
16556         }
16557         if (flags & NDR_OUT) {
16558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16559                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
16560                 }
16561                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
16562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
16563                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
16564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
16565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16566                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
16567                 }
16568                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
16569                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
16570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
16571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
16572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
16573                 if (_ptr_resume_handle) {
16574                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
16575                 } else {
16576                         r->out.resume_handle = NULL;
16577                 }
16578                 if (r->out.resume_handle) {
16579                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16580                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
16581                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
16582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
16583                 }
16584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16585         }
16586         return NDR_ERR_SUCCESS;
16587 }
16588
16589 _PUBLIC_ void ndr_print_srvsvc_NetShareEnumAll(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnumAll *r)
16590 {
16591         ndr_print_struct(ndr, name, "srvsvc_NetShareEnumAll");
16592         if (r == NULL) { ndr_print_null(ndr); return; }
16593         ndr->depth++;
16594         if (flags & NDR_SET_VALUES) {
16595                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16596         }
16597         if (flags & NDR_IN) {
16598                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnumAll");
16599                 ndr->depth++;
16600                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16601                 ndr->depth++;
16602                 if (r->in.server_unc) {
16603                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16604                 }
16605                 ndr->depth--;
16606                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
16607                 ndr->depth++;
16608                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
16609                 ndr->depth--;
16610                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
16611                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
16612                 ndr->depth++;
16613                 if (r->in.resume_handle) {
16614                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
16615                 }
16616                 ndr->depth--;
16617                 ndr->depth--;
16618         }
16619         if (flags & NDR_OUT) {
16620                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnumAll");
16621                 ndr->depth++;
16622                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
16623                 ndr->depth++;
16624                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
16625                 ndr->depth--;
16626                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
16627                 ndr->depth++;
16628                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
16629                 ndr->depth--;
16630                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
16631                 ndr->depth++;
16632                 if (r->out.resume_handle) {
16633                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
16634                 }
16635                 ndr->depth--;
16636                 ndr_print_WERROR(ndr, "result", r->out.result);
16637                 ndr->depth--;
16638         }
16639         ndr->depth--;
16640 }
16641
16642 static enum ndr_err_code ndr_push_srvsvc_NetShareGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareGetInfo *r)
16643 {
16644         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16645         if (flags & NDR_IN) {
16646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16647                 if (r->in.server_unc) {
16648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16651                         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));
16652                 }
16653                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16654                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16655                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16656                 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));
16657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16658         }
16659         if (flags & NDR_OUT) {
16660                 if (r->out.info == NULL) {
16661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16662                 }
16663                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
16664                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16666         }
16667         return NDR_ERR_SUCCESS;
16668 }
16669
16670 static enum ndr_err_code ndr_pull_srvsvc_NetShareGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareGetInfo *r)
16671 {
16672         uint32_t _ptr_server_unc;
16673         uint32_t size_server_unc_1 = 0;
16674         uint32_t length_server_unc_1 = 0;
16675         uint32_t size_share_name_0 = 0;
16676         uint32_t length_share_name_0 = 0;
16677         TALLOC_CTX *_mem_save_server_unc_0;
16678         TALLOC_CTX *_mem_save_info_0;
16679         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16680         if (flags & NDR_IN) {
16681                 ZERO_STRUCT(r->out);
16682
16683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16684                 if (_ptr_server_unc) {
16685                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16686                 } else {
16687                         r->in.server_unc = NULL;
16688                 }
16689                 if (r->in.server_unc) {
16690                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16691                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16694                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16695                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16696                         if (length_server_unc_1 > size_server_unc_1) {
16697                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16698                         }
16699                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16700                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16702                 }
16703                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
16704                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
16705                 size_share_name_0 = ndr_get_array_size(ndr, &r->in.share_name);
16706                 length_share_name_0 = ndr_get_array_length(ndr, &r->in.share_name);
16707                 if (length_share_name_0 > size_share_name_0) {
16708                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_name_0, length_share_name_0);
16709                 }
16710                 NDR_CHECK(ndr_check_string_terminator(ndr, length_share_name_0, sizeof(uint16_t)));
16711                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, length_share_name_0, sizeof(uint16_t), CH_UTF16));
16712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16713                 NDR_PULL_ALLOC(ndr, r->out.info);
16714                 ZERO_STRUCTP(r->out.info);
16715         }
16716         if (flags & NDR_OUT) {
16717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16718                         NDR_PULL_ALLOC(ndr, r->out.info);
16719                 }
16720                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16721                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
16722                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
16723                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
16724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16725                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16726         }
16727         return NDR_ERR_SUCCESS;
16728 }
16729
16730 _PUBLIC_ void ndr_print_srvsvc_NetShareGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareGetInfo *r)
16731 {
16732         ndr_print_struct(ndr, name, "srvsvc_NetShareGetInfo");
16733         if (r == NULL) { ndr_print_null(ndr); return; }
16734         ndr->depth++;
16735         if (flags & NDR_SET_VALUES) {
16736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16737         }
16738         if (flags & NDR_IN) {
16739                 ndr_print_struct(ndr, "in", "srvsvc_NetShareGetInfo");
16740                 ndr->depth++;
16741                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16742                 ndr->depth++;
16743                 if (r->in.server_unc) {
16744                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16745                 }
16746                 ndr->depth--;
16747                 ndr_print_string(ndr, "share_name", r->in.share_name);
16748                 ndr_print_uint32(ndr, "level", r->in.level);
16749                 ndr->depth--;
16750         }
16751         if (flags & NDR_OUT) {
16752                 ndr_print_struct(ndr, "out", "srvsvc_NetShareGetInfo");
16753                 ndr->depth++;
16754                 ndr_print_ptr(ndr, "info", r->out.info);
16755                 ndr->depth++;
16756                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
16757                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->out.info);
16758                 ndr->depth--;
16759                 ndr_print_WERROR(ndr, "result", r->out.result);
16760                 ndr->depth--;
16761         }
16762         ndr->depth--;
16763 }
16764
16765 static enum ndr_err_code ndr_push_srvsvc_NetShareSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareSetInfo *r)
16766 {
16767         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16768         if (flags & NDR_IN) {
16769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16770                 if (r->in.server_unc) {
16771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16774                         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));
16775                 }
16776                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16777                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16778                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16779                 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));
16780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16781                 if (r->in.info == NULL) {
16782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16783                 }
16784                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
16785                 NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
16787                 if (r->in.parm_error) {
16788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
16789                 }
16790         }
16791         if (flags & NDR_OUT) {
16792                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
16793                 if (r->out.parm_error) {
16794                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
16795                 }
16796                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16797         }
16798         return NDR_ERR_SUCCESS;
16799 }
16800
16801 static enum ndr_err_code ndr_pull_srvsvc_NetShareSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareSetInfo *r)
16802 {
16803         uint32_t _ptr_server_unc;
16804         uint32_t size_server_unc_1 = 0;
16805         uint32_t length_server_unc_1 = 0;
16806         uint32_t size_share_name_0 = 0;
16807         uint32_t length_share_name_0 = 0;
16808         uint32_t _ptr_parm_error;
16809         TALLOC_CTX *_mem_save_server_unc_0;
16810         TALLOC_CTX *_mem_save_info_0;
16811         TALLOC_CTX *_mem_save_parm_error_0;
16812         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16813         if (flags & NDR_IN) {
16814                 ZERO_STRUCT(r->out);
16815
16816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16817                 if (_ptr_server_unc) {
16818                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16819                 } else {
16820                         r->in.server_unc = NULL;
16821                 }
16822                 if (r->in.server_unc) {
16823                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16824                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16825                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16826                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16827                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16828                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16829                         if (length_server_unc_1 > size_server_unc_1) {
16830                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16831                         }
16832                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16833                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16835                 }
16836                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
16837                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
16838                 size_share_name_0 = ndr_get_array_size(ndr, &r->in.share_name);
16839                 length_share_name_0 = ndr_get_array_length(ndr, &r->in.share_name);
16840                 if (length_share_name_0 > size_share_name_0) {
16841                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_name_0, length_share_name_0);
16842                 }
16843                 NDR_CHECK(ndr_check_string_terminator(ndr, length_share_name_0, sizeof(uint16_t)));
16844                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, length_share_name_0, sizeof(uint16_t), CH_UTF16));
16845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16846                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16847                         NDR_PULL_ALLOC(ndr, r->in.info);
16848                 }
16849                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16850                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
16851                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
16852                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
16853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
16854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16855                 if (_ptr_parm_error) {
16856                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
16857                 } else {
16858                         r->in.parm_error = NULL;
16859                 }
16860                 if (r->in.parm_error) {
16861                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
16863                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
16864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16865                 }
16866         }
16867         if (flags & NDR_OUT) {
16868                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
16869                 if (_ptr_parm_error) {
16870                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
16871                 } else {
16872                         r->out.parm_error = NULL;
16873                 }
16874                 if (r->out.parm_error) {
16875                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
16876                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
16877                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
16878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
16879                 }
16880                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16881         }
16882         return NDR_ERR_SUCCESS;
16883 }
16884
16885 _PUBLIC_ void ndr_print_srvsvc_NetShareSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareSetInfo *r)
16886 {
16887         ndr_print_struct(ndr, name, "srvsvc_NetShareSetInfo");
16888         if (r == NULL) { ndr_print_null(ndr); return; }
16889         ndr->depth++;
16890         if (flags & NDR_SET_VALUES) {
16891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16892         }
16893         if (flags & NDR_IN) {
16894                 ndr_print_struct(ndr, "in", "srvsvc_NetShareSetInfo");
16895                 ndr->depth++;
16896                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
16897                 ndr->depth++;
16898                 if (r->in.server_unc) {
16899                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
16900                 }
16901                 ndr->depth--;
16902                 ndr_print_string(ndr, "share_name", r->in.share_name);
16903                 ndr_print_uint32(ndr, "level", r->in.level);
16904                 ndr_print_ptr(ndr, "info", r->in.info);
16905                 ndr->depth++;
16906                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
16907                 ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);
16908                 ndr->depth--;
16909                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
16910                 ndr->depth++;
16911                 if (r->in.parm_error) {
16912                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
16913                 }
16914                 ndr->depth--;
16915                 ndr->depth--;
16916         }
16917         if (flags & NDR_OUT) {
16918                 ndr_print_struct(ndr, "out", "srvsvc_NetShareSetInfo");
16919                 ndr->depth++;
16920                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
16921                 ndr->depth++;
16922                 if (r->out.parm_error) {
16923                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
16924                 }
16925                 ndr->depth--;
16926                 ndr_print_WERROR(ndr, "result", r->out.result);
16927                 ndr->depth--;
16928         }
16929         ndr->depth--;
16930 }
16931
16932 static enum ndr_err_code ndr_push_srvsvc_NetShareDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDel *r)
16933 {
16934         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
16935         if (flags & NDR_IN) {
16936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
16937                 if (r->in.server_unc) {
16938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
16941                         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));
16942                 }
16943                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16944                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16945                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
16946                 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));
16947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
16948         }
16949         if (flags & NDR_OUT) {
16950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16951         }
16952         return NDR_ERR_SUCCESS;
16953 }
16954
16955 static enum ndr_err_code ndr_pull_srvsvc_NetShareDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDel *r)
16956 {
16957         uint32_t _ptr_server_unc;
16958         uint32_t size_server_unc_1 = 0;
16959         uint32_t length_server_unc_1 = 0;
16960         uint32_t size_share_name_0 = 0;
16961         uint32_t length_share_name_0 = 0;
16962         TALLOC_CTX *_mem_save_server_unc_0;
16963         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
16964         if (flags & NDR_IN) {
16965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
16966                 if (_ptr_server_unc) {
16967                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
16968                 } else {
16969                         r->in.server_unc = NULL;
16970                 }
16971                 if (r->in.server_unc) {
16972                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
16973                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
16974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
16975                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
16976                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
16977                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
16978                         if (length_server_unc_1 > size_server_unc_1) {
16979                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
16980                         }
16981                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
16982                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
16983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
16984                 }
16985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
16986                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
16987                 size_share_name_0 = ndr_get_array_size(ndr, &r->in.share_name);
16988                 length_share_name_0 = ndr_get_array_length(ndr, &r->in.share_name);
16989                 if (length_share_name_0 > size_share_name_0) {
16990                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_name_0, length_share_name_0);
16991                 }
16992                 NDR_CHECK(ndr_check_string_terminator(ndr, length_share_name_0, sizeof(uint16_t)));
16993                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, length_share_name_0, sizeof(uint16_t), CH_UTF16));
16994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
16995         }
16996         if (flags & NDR_OUT) {
16997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16998         }
16999         return NDR_ERR_SUCCESS;
17000 }
17001
17002 _PUBLIC_ void ndr_print_srvsvc_NetShareDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDel *r)
17003 {
17004         ndr_print_struct(ndr, name, "srvsvc_NetShareDel");
17005         if (r == NULL) { ndr_print_null(ndr); return; }
17006         ndr->depth++;
17007         if (flags & NDR_SET_VALUES) {
17008                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17009         }
17010         if (flags & NDR_IN) {
17011                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDel");
17012                 ndr->depth++;
17013                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17014                 ndr->depth++;
17015                 if (r->in.server_unc) {
17016                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17017                 }
17018                 ndr->depth--;
17019                 ndr_print_string(ndr, "share_name", r->in.share_name);
17020                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
17021                 ndr->depth--;
17022         }
17023         if (flags & NDR_OUT) {
17024                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDel");
17025                 ndr->depth++;
17026                 ndr_print_WERROR(ndr, "result", r->out.result);
17027                 ndr->depth--;
17028         }
17029         ndr->depth--;
17030 }
17031
17032 static enum ndr_err_code ndr_push_srvsvc_NetShareDelSticky(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelSticky *r)
17033 {
17034         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17035         if (flags & NDR_IN) {
17036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17037                 if (r->in.server_unc) {
17038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17041                         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));
17042                 }
17043                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
17044                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17045                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));
17046                 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));
17047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
17048         }
17049         if (flags & NDR_OUT) {
17050                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17051         }
17052         return NDR_ERR_SUCCESS;
17053 }
17054
17055 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelSticky(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelSticky *r)
17056 {
17057         uint32_t _ptr_server_unc;
17058         uint32_t size_server_unc_1 = 0;
17059         uint32_t length_server_unc_1 = 0;
17060         uint32_t size_share_name_0 = 0;
17061         uint32_t length_share_name_0 = 0;
17062         TALLOC_CTX *_mem_save_server_unc_0;
17063         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17064         if (flags & NDR_IN) {
17065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17066                 if (_ptr_server_unc) {
17067                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17068                 } else {
17069                         r->in.server_unc = NULL;
17070                 }
17071                 if (r->in.server_unc) {
17072                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17075                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17076                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17077                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17078                         if (length_server_unc_1 > size_server_unc_1) {
17079                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17080                         }
17081                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17084                 }
17085                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));
17086                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));
17087                 size_share_name_0 = ndr_get_array_size(ndr, &r->in.share_name);
17088                 length_share_name_0 = ndr_get_array_length(ndr, &r->in.share_name);
17089                 if (length_share_name_0 > size_share_name_0) {
17090                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_name_0, length_share_name_0);
17091                 }
17092                 NDR_CHECK(ndr_check_string_terminator(ndr, length_share_name_0, sizeof(uint16_t)));
17093                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, length_share_name_0, sizeof(uint16_t), CH_UTF16));
17094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
17095         }
17096         if (flags & NDR_OUT) {
17097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17098         }
17099         return NDR_ERR_SUCCESS;
17100 }
17101
17102 _PUBLIC_ void ndr_print_srvsvc_NetShareDelSticky(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelSticky *r)
17103 {
17104         ndr_print_struct(ndr, name, "srvsvc_NetShareDelSticky");
17105         if (r == NULL) { ndr_print_null(ndr); return; }
17106         ndr->depth++;
17107         if (flags & NDR_SET_VALUES) {
17108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17109         }
17110         if (flags & NDR_IN) {
17111                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelSticky");
17112                 ndr->depth++;
17113                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17114                 ndr->depth++;
17115                 if (r->in.server_unc) {
17116                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17117                 }
17118                 ndr->depth--;
17119                 ndr_print_string(ndr, "share_name", r->in.share_name);
17120                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
17121                 ndr->depth--;
17122         }
17123         if (flags & NDR_OUT) {
17124                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelSticky");
17125                 ndr->depth++;
17126                 ndr_print_WERROR(ndr, "result", r->out.result);
17127                 ndr->depth--;
17128         }
17129         ndr->depth--;
17130 }
17131
17132 static enum ndr_err_code ndr_push_srvsvc_NetShareCheck(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareCheck *r)
17133 {
17134         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17135         if (flags & NDR_IN) {
17136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17137                 if (r->in.server_unc) {
17138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17141                         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));
17142                 }
17143                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
17144                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17145                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));
17146                 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));
17147         }
17148         if (flags & NDR_OUT) {
17149                 if (r->out.type == NULL) {
17150                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17151                 }
17152                 NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, *r->out.type));
17153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17154         }
17155         return NDR_ERR_SUCCESS;
17156 }
17157
17158 static enum ndr_err_code ndr_pull_srvsvc_NetShareCheck(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareCheck *r)
17159 {
17160         uint32_t _ptr_server_unc;
17161         uint32_t size_server_unc_1 = 0;
17162         uint32_t length_server_unc_1 = 0;
17163         uint32_t size_device_name_0 = 0;
17164         uint32_t length_device_name_0 = 0;
17165         TALLOC_CTX *_mem_save_server_unc_0;
17166         TALLOC_CTX *_mem_save_type_0;
17167         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17168         if (flags & NDR_IN) {
17169                 ZERO_STRUCT(r->out);
17170
17171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17172                 if (_ptr_server_unc) {
17173                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17174                 } else {
17175                         r->in.server_unc = NULL;
17176                 }
17177                 if (r->in.server_unc) {
17178                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17179                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17181                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17182                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17183                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17184                         if (length_server_unc_1 > size_server_unc_1) {
17185                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17186                         }
17187                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17188                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17190                 }
17191                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));
17192                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));
17193                 size_device_name_0 = ndr_get_array_size(ndr, &r->in.device_name);
17194                 length_device_name_0 = ndr_get_array_length(ndr, &r->in.device_name);
17195                 if (length_device_name_0 > size_device_name_0) {
17196                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_device_name_0, length_device_name_0);
17197                 }
17198                 NDR_CHECK(ndr_check_string_terminator(ndr, length_device_name_0, sizeof(uint16_t)));
17199                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, length_device_name_0, sizeof(uint16_t), CH_UTF16));
17200                 NDR_PULL_ALLOC(ndr, r->out.type);
17201                 ZERO_STRUCTP(r->out.type);
17202         }
17203         if (flags & NDR_OUT) {
17204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17205                         NDR_PULL_ALLOC(ndr, r->out.type);
17206                 }
17207                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
17208                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
17209                 NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, r->out.type));
17210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
17211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17212         }
17213         return NDR_ERR_SUCCESS;
17214 }
17215
17216 _PUBLIC_ void ndr_print_srvsvc_NetShareCheck(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareCheck *r)
17217 {
17218         ndr_print_struct(ndr, name, "srvsvc_NetShareCheck");
17219         if (r == NULL) { ndr_print_null(ndr); return; }
17220         ndr->depth++;
17221         if (flags & NDR_SET_VALUES) {
17222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17223         }
17224         if (flags & NDR_IN) {
17225                 ndr_print_struct(ndr, "in", "srvsvc_NetShareCheck");
17226                 ndr->depth++;
17227                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17228                 ndr->depth++;
17229                 if (r->in.server_unc) {
17230                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17231                 }
17232                 ndr->depth--;
17233                 ndr_print_string(ndr, "device_name", r->in.device_name);
17234                 ndr->depth--;
17235         }
17236         if (flags & NDR_OUT) {
17237                 ndr_print_struct(ndr, "out", "srvsvc_NetShareCheck");
17238                 ndr->depth++;
17239                 ndr_print_ptr(ndr, "type", r->out.type);
17240                 ndr->depth++;
17241                 ndr_print_srvsvc_ShareType(ndr, "type", *r->out.type);
17242                 ndr->depth--;
17243                 ndr_print_WERROR(ndr, "result", r->out.result);
17244                 ndr->depth--;
17245         }
17246         ndr->depth--;
17247 }
17248
17249 static enum ndr_err_code ndr_push_srvsvc_NetSrvGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvGetInfo *r)
17250 {
17251         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17252         if (flags & NDR_IN) {
17253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17254                 if (r->in.server_unc) {
17255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17258                         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));
17259                 }
17260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17261         }
17262         if (flags & NDR_OUT) {
17263                 if (r->out.info == NULL) {
17264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17265                 }
17266                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
17267                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17269         }
17270         return NDR_ERR_SUCCESS;
17271 }
17272
17273 static enum ndr_err_code ndr_pull_srvsvc_NetSrvGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvGetInfo *r)
17274 {
17275         uint32_t _ptr_server_unc;
17276         uint32_t size_server_unc_1 = 0;
17277         uint32_t length_server_unc_1 = 0;
17278         TALLOC_CTX *_mem_save_server_unc_0;
17279         TALLOC_CTX *_mem_save_info_0;
17280         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17281         if (flags & NDR_IN) {
17282                 ZERO_STRUCT(r->out);
17283
17284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17285                 if (_ptr_server_unc) {
17286                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17287                 } else {
17288                         r->in.server_unc = NULL;
17289                 }
17290                 if (r->in.server_unc) {
17291                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17292                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17295                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17296                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17297                         if (length_server_unc_1 > size_server_unc_1) {
17298                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17299                         }
17300                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17303                 }
17304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17305                 NDR_PULL_ALLOC(ndr, r->out.info);
17306                 ZERO_STRUCTP(r->out.info);
17307         }
17308         if (flags & NDR_OUT) {
17309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17310                         NDR_PULL_ALLOC(ndr, r->out.info);
17311                 }
17312                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17313                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
17314                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
17315                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17318         }
17319         return NDR_ERR_SUCCESS;
17320 }
17321
17322 _PUBLIC_ void ndr_print_srvsvc_NetSrvGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvGetInfo *r)
17323 {
17324         ndr_print_struct(ndr, name, "srvsvc_NetSrvGetInfo");
17325         if (r == NULL) { ndr_print_null(ndr); return; }
17326         ndr->depth++;
17327         if (flags & NDR_SET_VALUES) {
17328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17329         }
17330         if (flags & NDR_IN) {
17331                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvGetInfo");
17332                 ndr->depth++;
17333                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17334                 ndr->depth++;
17335                 if (r->in.server_unc) {
17336                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17337                 }
17338                 ndr->depth--;
17339                 ndr_print_uint32(ndr, "level", r->in.level);
17340                 ndr->depth--;
17341         }
17342         if (flags & NDR_OUT) {
17343                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvGetInfo");
17344                 ndr->depth++;
17345                 ndr_print_ptr(ndr, "info", r->out.info);
17346                 ndr->depth++;
17347                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17348                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->out.info);
17349                 ndr->depth--;
17350                 ndr_print_WERROR(ndr, "result", r->out.result);
17351                 ndr->depth--;
17352         }
17353         ndr->depth--;
17354 }
17355
17356 static enum ndr_err_code ndr_push_srvsvc_NetSrvSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvSetInfo *r)
17357 {
17358         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17359         if (flags & NDR_IN) {
17360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17361                 if (r->in.server_unc) {
17362                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17363                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17364                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17365                         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));
17366                 }
17367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17368                 if (r->in.info == NULL) {
17369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17370                 }
17371                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
17372                 NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
17373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));
17374                 if (r->in.parm_error) {
17375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
17376                 }
17377         }
17378         if (flags & NDR_OUT) {
17379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));
17380                 if (r->out.parm_error) {
17381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
17382                 }
17383                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17384         }
17385         return NDR_ERR_SUCCESS;
17386 }
17387
17388 static enum ndr_err_code ndr_pull_srvsvc_NetSrvSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvSetInfo *r)
17389 {
17390         uint32_t _ptr_server_unc;
17391         uint32_t size_server_unc_1 = 0;
17392         uint32_t length_server_unc_1 = 0;
17393         uint32_t _ptr_parm_error;
17394         TALLOC_CTX *_mem_save_server_unc_0;
17395         TALLOC_CTX *_mem_save_info_0;
17396         TALLOC_CTX *_mem_save_parm_error_0;
17397         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17398         if (flags & NDR_IN) {
17399                 ZERO_STRUCT(r->out);
17400
17401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17402                 if (_ptr_server_unc) {
17403                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17404                 } else {
17405                         r->in.server_unc = NULL;
17406                 }
17407                 if (r->in.server_unc) {
17408                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17409                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17411                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17412                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17413                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17414                         if (length_server_unc_1 > size_server_unc_1) {
17415                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17416                         }
17417                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17418                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17420                 }
17421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17422                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17423                         NDR_PULL_ALLOC(ndr, r->in.info);
17424                 }
17425                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17426                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
17427                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
17428                 NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
17429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
17431                 if (_ptr_parm_error) {
17432                         NDR_PULL_ALLOC(ndr, r->in.parm_error);
17433                 } else {
17434                         r->in.parm_error = NULL;
17435                 }
17436                 if (r->in.parm_error) {
17437                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
17438                         NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);
17439                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
17440                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
17441                 }
17442         }
17443         if (flags & NDR_OUT) {
17444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));
17445                 if (_ptr_parm_error) {
17446                         NDR_PULL_ALLOC(ndr, r->out.parm_error);
17447                 } else {
17448                         r->out.parm_error = NULL;
17449                 }
17450                 if (r->out.parm_error) {
17451                         _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
17452                         NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);
17453                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
17454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);
17455                 }
17456                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17457         }
17458         return NDR_ERR_SUCCESS;
17459 }
17460
17461 _PUBLIC_ void ndr_print_srvsvc_NetSrvSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvSetInfo *r)
17462 {
17463         ndr_print_struct(ndr, name, "srvsvc_NetSrvSetInfo");
17464         if (r == NULL) { ndr_print_null(ndr); return; }
17465         ndr->depth++;
17466         if (flags & NDR_SET_VALUES) {
17467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17468         }
17469         if (flags & NDR_IN) {
17470                 ndr_print_struct(ndr, "in", "srvsvc_NetSrvSetInfo");
17471                 ndr->depth++;
17472                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17473                 ndr->depth++;
17474                 if (r->in.server_unc) {
17475                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17476                 }
17477                 ndr->depth--;
17478                 ndr_print_uint32(ndr, "level", r->in.level);
17479                 ndr_print_ptr(ndr, "info", r->in.info);
17480                 ndr->depth++;
17481                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
17482                 ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->in.info);
17483                 ndr->depth--;
17484                 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
17485                 ndr->depth++;
17486                 if (r->in.parm_error) {
17487                         ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
17488                 }
17489                 ndr->depth--;
17490                 ndr->depth--;
17491         }
17492         if (flags & NDR_OUT) {
17493                 ndr_print_struct(ndr, "out", "srvsvc_NetSrvSetInfo");
17494                 ndr->depth++;
17495                 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
17496                 ndr->depth++;
17497                 if (r->out.parm_error) {
17498                         ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
17499                 }
17500                 ndr->depth--;
17501                 ndr_print_WERROR(ndr, "result", r->out.result);
17502                 ndr->depth--;
17503         }
17504         ndr->depth--;
17505 }
17506
17507 static enum ndr_err_code ndr_push_srvsvc_NetDiskEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetDiskEnum *r)
17508 {
17509         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17510         if (flags & NDR_IN) {
17511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17512                 if (r->in.server_unc) {
17513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17514                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17515                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17516                         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));
17517                 }
17518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17519                 if (r->in.info == NULL) {
17520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17521                 }
17522                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
17523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxlen));
17524                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
17525                 if (r->in.resume_handle) {
17526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
17527                 }
17528         }
17529         if (flags & NDR_OUT) {
17530                 if (r->out.info == NULL) {
17531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17532                 }
17533                 NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17534                 if (r->out.totalentries == NULL) {
17535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17536                 }
17537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
17538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
17539                 if (r->out.resume_handle) {
17540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
17541                 }
17542                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17543         }
17544         return NDR_ERR_SUCCESS;
17545 }
17546
17547 static enum ndr_err_code ndr_pull_srvsvc_NetDiskEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetDiskEnum *r)
17548 {
17549         uint32_t _ptr_server_unc;
17550         uint32_t size_server_unc_1 = 0;
17551         uint32_t length_server_unc_1 = 0;
17552         uint32_t _ptr_resume_handle;
17553         TALLOC_CTX *_mem_save_server_unc_0;
17554         TALLOC_CTX *_mem_save_info_0;
17555         TALLOC_CTX *_mem_save_totalentries_0;
17556         TALLOC_CTX *_mem_save_resume_handle_0;
17557         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17558         if (flags & NDR_IN) {
17559                 ZERO_STRUCT(r->out);
17560
17561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17562                 if (_ptr_server_unc) {
17563                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17564                 } else {
17565                         r->in.server_unc = NULL;
17566                 }
17567                 if (r->in.server_unc) {
17568                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17569                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17572                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17573                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17574                         if (length_server_unc_1 > size_server_unc_1) {
17575                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17576                         }
17577                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17578                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17579                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17580                 }
17581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17583                         NDR_PULL_ALLOC(ndr, r->in.info);
17584                 }
17585                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17586                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
17587                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
17588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxlen));
17590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17591                 if (_ptr_resume_handle) {
17592                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
17593                 } else {
17594                         r->in.resume_handle = NULL;
17595                 }
17596                 if (r->in.resume_handle) {
17597                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17598                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
17599                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
17600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17601                 }
17602                 NDR_PULL_ALLOC(ndr, r->out.info);
17603                 *r->out.info = *r->in.info;
17604                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
17605                 ZERO_STRUCTP(r->out.totalentries);
17606         }
17607         if (flags & NDR_OUT) {
17608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17609                         NDR_PULL_ALLOC(ndr, r->out.info);
17610                 }
17611                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
17613                 NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
17615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17616                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
17617                 }
17618                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
17619                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
17620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
17621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
17622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
17623                 if (_ptr_resume_handle) {
17624                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
17625                 } else {
17626                         r->out.resume_handle = NULL;
17627                 }
17628                 if (r->out.resume_handle) {
17629                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17630                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
17631                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
17632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
17633                 }
17634                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17635         }
17636         return NDR_ERR_SUCCESS;
17637 }
17638
17639 _PUBLIC_ void ndr_print_srvsvc_NetDiskEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetDiskEnum *r)
17640 {
17641         ndr_print_struct(ndr, name, "srvsvc_NetDiskEnum");
17642         if (r == NULL) { ndr_print_null(ndr); return; }
17643         ndr->depth++;
17644         if (flags & NDR_SET_VALUES) {
17645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17646         }
17647         if (flags & NDR_IN) {
17648                 ndr_print_struct(ndr, "in", "srvsvc_NetDiskEnum");
17649                 ndr->depth++;
17650                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17651                 ndr->depth++;
17652                 if (r->in.server_unc) {
17653                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17654                 }
17655                 ndr->depth--;
17656                 ndr_print_uint32(ndr, "level", r->in.level);
17657                 ndr_print_ptr(ndr, "info", r->in.info);
17658                 ndr->depth++;
17659                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->in.info);
17660                 ndr->depth--;
17661                 ndr_print_uint32(ndr, "maxlen", r->in.maxlen);
17662                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
17663                 ndr->depth++;
17664                 if (r->in.resume_handle) {
17665                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
17666                 }
17667                 ndr->depth--;
17668                 ndr->depth--;
17669         }
17670         if (flags & NDR_OUT) {
17671                 ndr_print_struct(ndr, "out", "srvsvc_NetDiskEnum");
17672                 ndr->depth++;
17673                 ndr_print_ptr(ndr, "info", r->out.info);
17674                 ndr->depth++;
17675                 ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->out.info);
17676                 ndr->depth--;
17677                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
17678                 ndr->depth++;
17679                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
17680                 ndr->depth--;
17681                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
17682                 ndr->depth++;
17683                 if (r->out.resume_handle) {
17684                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
17685                 }
17686                 ndr->depth--;
17687                 ndr_print_WERROR(ndr, "result", r->out.result);
17688                 ndr->depth--;
17689         }
17690         ndr->depth--;
17691 }
17692
17693 static enum ndr_err_code ndr_push_srvsvc_NetServerStatisticsGet(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerStatisticsGet *r)
17694 {
17695         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17696         if (flags & NDR_IN) {
17697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17698                 if (r->in.server_unc) {
17699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17702                         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));
17703                 }
17704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service));
17705                 if (r->in.service) {
17706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
17707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));
17709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service, ndr_charset_length(r->in.service, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17710                 }
17711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
17713         }
17714         if (flags & NDR_OUT) {
17715                 if (r->out.stats == NULL) {
17716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17717                 }
17718                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.stats));
17719                 if (*r->out.stats) {
17720                         NDR_CHECK(ndr_push_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));
17721                 }
17722                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17723         }
17724         return NDR_ERR_SUCCESS;
17725 }
17726
17727 static enum ndr_err_code ndr_pull_srvsvc_NetServerStatisticsGet(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerStatisticsGet *r)
17728 {
17729         uint32_t _ptr_server_unc;
17730         uint32_t size_server_unc_1 = 0;
17731         uint32_t length_server_unc_1 = 0;
17732         uint32_t _ptr_service;
17733         uint32_t size_service_1 = 0;
17734         uint32_t length_service_1 = 0;
17735         uint32_t _ptr_stats;
17736         TALLOC_CTX *_mem_save_server_unc_0;
17737         TALLOC_CTX *_mem_save_service_0;
17738         TALLOC_CTX *_mem_save_stats_0;
17739         TALLOC_CTX *_mem_save_stats_1;
17740         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17741         if (flags & NDR_IN) {
17742                 ZERO_STRUCT(r->out);
17743
17744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17745                 if (_ptr_server_unc) {
17746                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17747                 } else {
17748                         r->in.server_unc = NULL;
17749                 }
17750                 if (r->in.server_unc) {
17751                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17752                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17755                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17756                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17757                         if (length_server_unc_1 > size_server_unc_1) {
17758                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17759                         }
17760                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17763                 }
17764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service));
17765                 if (_ptr_service) {
17766                         NDR_PULL_ALLOC(ndr, r->in.service);
17767                 } else {
17768                         r->in.service = NULL;
17769                 }
17770                 if (r->in.service) {
17771                         _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
17772                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service, 0);
17773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service));
17774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service));
17775                         size_service_1 = ndr_get_array_size(ndr, &r->in.service);
17776                         length_service_1 = ndr_get_array_length(ndr, &r->in.service);
17777                         if (length_service_1 > size_service_1) {
17778                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_1, length_service_1);
17779                         }
17780                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_1, sizeof(uint16_t)));
17781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service, length_service_1, sizeof(uint16_t), CH_UTF16));
17782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, 0);
17783                 }
17784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
17786                 NDR_PULL_ALLOC(ndr, r->out.stats);
17787                 ZERO_STRUCTP(r->out.stats);
17788         }
17789         if (flags & NDR_OUT) {
17790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17791                         NDR_PULL_ALLOC(ndr, r->out.stats);
17792                 }
17793                 _mem_save_stats_0 = NDR_PULL_GET_MEM_CTX(ndr);
17794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.stats, LIBNDR_FLAG_REF_ALLOC);
17795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stats));
17796                 if (_ptr_stats) {
17797                         NDR_PULL_ALLOC(ndr, *r->out.stats);
17798                 } else {
17799                         *r->out.stats = NULL;
17800                 }
17801                 if (*r->out.stats) {
17802                         _mem_save_stats_1 = NDR_PULL_GET_MEM_CTX(ndr);
17803                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.stats, 0);
17804                         NDR_CHECK(ndr_pull_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));
17805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_1, 0);
17806                 }
17807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_0, LIBNDR_FLAG_REF_ALLOC);
17808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17809         }
17810         return NDR_ERR_SUCCESS;
17811 }
17812
17813 _PUBLIC_ void ndr_print_srvsvc_NetServerStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerStatisticsGet *r)
17814 {
17815         ndr_print_struct(ndr, name, "srvsvc_NetServerStatisticsGet");
17816         if (r == NULL) { ndr_print_null(ndr); return; }
17817         ndr->depth++;
17818         if (flags & NDR_SET_VALUES) {
17819                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17820         }
17821         if (flags & NDR_IN) {
17822                 ndr_print_struct(ndr, "in", "srvsvc_NetServerStatisticsGet");
17823                 ndr->depth++;
17824                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17825                 ndr->depth++;
17826                 if (r->in.server_unc) {
17827                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17828                 }
17829                 ndr->depth--;
17830                 ndr_print_ptr(ndr, "service", r->in.service);
17831                 ndr->depth++;
17832                 if (r->in.service) {
17833                         ndr_print_string(ndr, "service", r->in.service);
17834                 }
17835                 ndr->depth--;
17836                 ndr_print_uint32(ndr, "level", r->in.level);
17837                 ndr_print_uint32(ndr, "options", r->in.options);
17838                 ndr->depth--;
17839         }
17840         if (flags & NDR_OUT) {
17841                 ndr_print_struct(ndr, "out", "srvsvc_NetServerStatisticsGet");
17842                 ndr->depth++;
17843                 ndr_print_ptr(ndr, "stats", r->out.stats);
17844                 ndr->depth++;
17845                 ndr_print_ptr(ndr, "stats", *r->out.stats);
17846                 ndr->depth++;
17847                 if (*r->out.stats) {
17848                         ndr_print_srvsvc_Statistics(ndr, "stats", *r->out.stats);
17849                 }
17850                 ndr->depth--;
17851                 ndr->depth--;
17852                 ndr_print_WERROR(ndr, "result", r->out.result);
17853                 ndr->depth--;
17854         }
17855         ndr->depth--;
17856 }
17857
17858 static enum ndr_err_code ndr_push_srvsvc_NetTransportAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportAdd *r)
17859 {
17860         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17861         if (flags & NDR_IN) {
17862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17863                 if (r->in.server_unc) {
17864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17867                         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));
17868                 }
17869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17870                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
17871                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17872         }
17873         if (flags & NDR_OUT) {
17874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17875         }
17876         return NDR_ERR_SUCCESS;
17877 }
17878
17879 static enum ndr_err_code ndr_pull_srvsvc_NetTransportAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportAdd *r)
17880 {
17881         uint32_t _ptr_server_unc;
17882         uint32_t size_server_unc_1 = 0;
17883         uint32_t length_server_unc_1 = 0;
17884         TALLOC_CTX *_mem_save_server_unc_0;
17885         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17886         if (flags & NDR_IN) {
17887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
17888                 if (_ptr_server_unc) {
17889                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
17890                 } else {
17891                         r->in.server_unc = NULL;
17892                 }
17893                 if (r->in.server_unc) {
17894                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
17895                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
17896                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
17897                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
17898                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
17899                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
17900                         if (length_server_unc_1 > size_server_unc_1) {
17901                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
17902                         }
17903                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
17904                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
17905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
17906                 }
17907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17908                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
17909                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
17910         }
17911         if (flags & NDR_OUT) {
17912                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17913         }
17914         return NDR_ERR_SUCCESS;
17915 }
17916
17917 _PUBLIC_ void ndr_print_srvsvc_NetTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportAdd *r)
17918 {
17919         ndr_print_struct(ndr, name, "srvsvc_NetTransportAdd");
17920         if (r == NULL) { ndr_print_null(ndr); return; }
17921         ndr->depth++;
17922         if (flags & NDR_SET_VALUES) {
17923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17924         }
17925         if (flags & NDR_IN) {
17926                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportAdd");
17927                 ndr->depth++;
17928                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
17929                 ndr->depth++;
17930                 if (r->in.server_unc) {
17931                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
17932                 }
17933                 ndr->depth--;
17934                 ndr_print_uint32(ndr, "level", r->in.level);
17935                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
17936                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
17937                 ndr->depth--;
17938         }
17939         if (flags & NDR_OUT) {
17940                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportAdd");
17941                 ndr->depth++;
17942                 ndr_print_WERROR(ndr, "result", r->out.result);
17943                 ndr->depth--;
17944         }
17945         ndr->depth--;
17946 }
17947
17948 static enum ndr_err_code ndr_push_srvsvc_NetTransportEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportEnum *r)
17949 {
17950         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
17951         if (flags & NDR_IN) {
17952                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
17953                 if (r->in.server_unc) {
17954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
17957                         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));
17958                 }
17959                 if (r->in.transports == NULL) {
17960                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17961                 }
17962                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
17963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
17964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
17965                 if (r->in.resume_handle) {
17966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
17967                 }
17968         }
17969         if (flags & NDR_OUT) {
17970                 if (r->out.transports == NULL) {
17971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17972                 }
17973                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
17974                 if (r->out.totalentries == NULL) {
17975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17976                 }
17977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
17978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
17979                 if (r->out.resume_handle) {
17980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
17981                 }
17982                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17983         }
17984         return NDR_ERR_SUCCESS;
17985 }
17986
17987 static enum ndr_err_code ndr_pull_srvsvc_NetTransportEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportEnum *r)
17988 {
17989         uint32_t _ptr_server_unc;
17990         uint32_t size_server_unc_1 = 0;
17991         uint32_t length_server_unc_1 = 0;
17992         uint32_t _ptr_resume_handle;
17993         TALLOC_CTX *_mem_save_server_unc_0;
17994         TALLOC_CTX *_mem_save_transports_0;
17995         TALLOC_CTX *_mem_save_totalentries_0;
17996         TALLOC_CTX *_mem_save_resume_handle_0;
17997         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
17998         if (flags & NDR_IN) {
17999                 ZERO_STRUCT(r->out);
18000
18001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18002                 if (_ptr_server_unc) {
18003                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18004                 } else {
18005                         r->in.server_unc = NULL;
18006                 }
18007                 if (r->in.server_unc) {
18008                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18009                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18010                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18011                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18012                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18013                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18014                         if (length_server_unc_1 > size_server_unc_1) {
18015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18016                         }
18017                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18020                 }
18021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18022                         NDR_PULL_ALLOC(ndr, r->in.transports);
18023                 }
18024                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
18025                 NDR_PULL_SET_MEM_CTX(ndr, r->in.transports, LIBNDR_FLAG_REF_ALLOC);
18026                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));
18027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
18028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
18029                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
18030                 if (_ptr_resume_handle) {
18031                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
18032                 } else {
18033                         r->in.resume_handle = NULL;
18034                 }
18035                 if (r->in.resume_handle) {
18036                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18037                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
18038                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
18039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
18040                 }
18041                 NDR_PULL_ALLOC(ndr, r->out.transports);
18042                 *r->out.transports = *r->in.transports;
18043                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
18044                 ZERO_STRUCTP(r->out.totalentries);
18045         }
18046         if (flags & NDR_OUT) {
18047                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18048                         NDR_PULL_ALLOC(ndr, r->out.transports);
18049                 }
18050                 _mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);
18051                 NDR_PULL_SET_MEM_CTX(ndr, r->out.transports, LIBNDR_FLAG_REF_ALLOC);
18052                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));
18053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);
18054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18055                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
18056                 }
18057                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
18058                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
18059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
18060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
18061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
18062                 if (_ptr_resume_handle) {
18063                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
18064                 } else {
18065                         r->out.resume_handle = NULL;
18066                 }
18067                 if (r->out.resume_handle) {
18068                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18069                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
18070                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
18071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
18072                 }
18073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18074         }
18075         return NDR_ERR_SUCCESS;
18076 }
18077
18078 _PUBLIC_ void ndr_print_srvsvc_NetTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportEnum *r)
18079 {
18080         ndr_print_struct(ndr, name, "srvsvc_NetTransportEnum");
18081         if (r == NULL) { ndr_print_null(ndr); return; }
18082         ndr->depth++;
18083         if (flags & NDR_SET_VALUES) {
18084                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18085         }
18086         if (flags & NDR_IN) {
18087                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportEnum");
18088                 ndr->depth++;
18089                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18090                 ndr->depth++;
18091                 if (r->in.server_unc) {
18092                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18093                 }
18094                 ndr->depth--;
18095                 ndr_print_ptr(ndr, "transports", r->in.transports);
18096                 ndr->depth++;
18097                 ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->in.transports);
18098                 ndr->depth--;
18099                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
18100                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
18101                 ndr->depth++;
18102                 if (r->in.resume_handle) {
18103                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
18104                 }
18105                 ndr->depth--;
18106                 ndr->depth--;
18107         }
18108         if (flags & NDR_OUT) {
18109                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportEnum");
18110                 ndr->depth++;
18111                 ndr_print_ptr(ndr, "transports", r->out.transports);
18112                 ndr->depth++;
18113                 ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->out.transports);
18114                 ndr->depth--;
18115                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
18116                 ndr->depth++;
18117                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
18118                 ndr->depth--;
18119                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
18120                 ndr->depth++;
18121                 if (r->out.resume_handle) {
18122                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
18123                 }
18124                 ndr->depth--;
18125                 ndr_print_WERROR(ndr, "result", r->out.result);
18126                 ndr->depth--;
18127         }
18128         ndr->depth--;
18129 }
18130
18131 static enum ndr_err_code ndr_push_srvsvc_NetTransportDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportDel *r)
18132 {
18133         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18134         if (flags & NDR_IN) {
18135                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18136                 if (r->in.server_unc) {
18137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18140                         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));
18141                 }
18142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18143                 if (r->in.info0 == NULL) {
18144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18145                 }
18146                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
18147         }
18148         if (flags & NDR_OUT) {
18149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18150         }
18151         return NDR_ERR_SUCCESS;
18152 }
18153
18154 static enum ndr_err_code ndr_pull_srvsvc_NetTransportDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportDel *r)
18155 {
18156         uint32_t _ptr_server_unc;
18157         uint32_t size_server_unc_1 = 0;
18158         uint32_t length_server_unc_1 = 0;
18159         TALLOC_CTX *_mem_save_server_unc_0;
18160         TALLOC_CTX *_mem_save_info0_0;
18161         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18162         if (flags & NDR_IN) {
18163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18164                 if (_ptr_server_unc) {
18165                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18166                 } else {
18167                         r->in.server_unc = NULL;
18168                 }
18169                 if (r->in.server_unc) {
18170                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18174                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18175                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18176                         if (length_server_unc_1 > size_server_unc_1) {
18177                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18178                         }
18179                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18182                 }
18183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18185                         NDR_PULL_ALLOC(ndr, r->in.info0);
18186                 }
18187                 _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);
18189                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));
18190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);
18191         }
18192         if (flags & NDR_OUT) {
18193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18194         }
18195         return NDR_ERR_SUCCESS;
18196 }
18197
18198 _PUBLIC_ void ndr_print_srvsvc_NetTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportDel *r)
18199 {
18200         ndr_print_struct(ndr, name, "srvsvc_NetTransportDel");
18201         if (r == NULL) { ndr_print_null(ndr); return; }
18202         ndr->depth++;
18203         if (flags & NDR_SET_VALUES) {
18204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18205         }
18206         if (flags & NDR_IN) {
18207                 ndr_print_struct(ndr, "in", "srvsvc_NetTransportDel");
18208                 ndr->depth++;
18209                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18210                 ndr->depth++;
18211                 if (r->in.server_unc) {
18212                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18213                 }
18214                 ndr->depth--;
18215                 ndr_print_uint32(ndr, "level", r->in.level);
18216                 ndr_print_ptr(ndr, "info0", r->in.info0);
18217                 ndr->depth++;
18218                 ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", r->in.info0);
18219                 ndr->depth--;
18220                 ndr->depth--;
18221         }
18222         if (flags & NDR_OUT) {
18223                 ndr_print_struct(ndr, "out", "srvsvc_NetTransportDel");
18224                 ndr->depth++;
18225                 ndr_print_WERROR(ndr, "result", r->out.result);
18226                 ndr->depth--;
18227         }
18228         ndr->depth--;
18229 }
18230
18231 static enum ndr_err_code ndr_push_srvsvc_NetRemoteTOD(struct ndr_push *ndr, int flags, const struct srvsvc_NetRemoteTOD *r)
18232 {
18233         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18234         if (flags & NDR_IN) {
18235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18236                 if (r->in.server_unc) {
18237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18240                         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));
18241                 }
18242         }
18243         if (flags & NDR_OUT) {
18244                 if (r->out.info == NULL) {
18245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18246                 }
18247                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
18248                 if (*r->out.info) {
18249                         NDR_CHECK(ndr_push_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
18250                 }
18251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18252         }
18253         return NDR_ERR_SUCCESS;
18254 }
18255
18256 static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTOD(struct ndr_pull *ndr, int flags, struct srvsvc_NetRemoteTOD *r)
18257 {
18258         uint32_t _ptr_server_unc;
18259         uint32_t size_server_unc_1 = 0;
18260         uint32_t length_server_unc_1 = 0;
18261         uint32_t _ptr_info;
18262         TALLOC_CTX *_mem_save_server_unc_0;
18263         TALLOC_CTX *_mem_save_info_0;
18264         TALLOC_CTX *_mem_save_info_1;
18265         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18266         if (flags & NDR_IN) {
18267                 ZERO_STRUCT(r->out);
18268
18269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18270                 if (_ptr_server_unc) {
18271                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18272                 } else {
18273                         r->in.server_unc = NULL;
18274                 }
18275                 if (r->in.server_unc) {
18276                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18277                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18280                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18281                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18282                         if (length_server_unc_1 > size_server_unc_1) {
18283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18284                         }
18285                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18288                 }
18289                 NDR_PULL_ALLOC(ndr, r->out.info);
18290                 ZERO_STRUCTP(r->out.info);
18291         }
18292         if (flags & NDR_OUT) {
18293                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18294                         NDR_PULL_ALLOC(ndr, r->out.info);
18295                 }
18296                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18297                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
18298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18299                 if (_ptr_info) {
18300                         NDR_PULL_ALLOC(ndr, *r->out.info);
18301                 } else {
18302                         *r->out.info = NULL;
18303                 }
18304                 if (*r->out.info) {
18305                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
18306                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
18307                         NDR_CHECK(ndr_pull_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));
18308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
18309                 }
18310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
18311                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18312         }
18313         return NDR_ERR_SUCCESS;
18314 }
18315
18316 _PUBLIC_ void ndr_print_srvsvc_NetRemoteTOD(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetRemoteTOD *r)
18317 {
18318         ndr_print_struct(ndr, name, "srvsvc_NetRemoteTOD");
18319         if (r == NULL) { ndr_print_null(ndr); return; }
18320         ndr->depth++;
18321         if (flags & NDR_SET_VALUES) {
18322                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18323         }
18324         if (flags & NDR_IN) {
18325                 ndr_print_struct(ndr, "in", "srvsvc_NetRemoteTOD");
18326                 ndr->depth++;
18327                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18328                 ndr->depth++;
18329                 if (r->in.server_unc) {
18330                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18331                 }
18332                 ndr->depth--;
18333                 ndr->depth--;
18334         }
18335         if (flags & NDR_OUT) {
18336                 ndr_print_struct(ndr, "out", "srvsvc_NetRemoteTOD");
18337                 ndr->depth++;
18338                 ndr_print_ptr(ndr, "info", r->out.info);
18339                 ndr->depth++;
18340                 ndr_print_ptr(ndr, "info", *r->out.info);
18341                 ndr->depth++;
18342                 if (*r->out.info) {
18343                         ndr_print_srvsvc_NetRemoteTODInfo(ndr, "info", *r->out.info);
18344                 }
18345                 ndr->depth--;
18346                 ndr->depth--;
18347                 ndr_print_WERROR(ndr, "result", r->out.result);
18348                 ndr->depth--;
18349         }
18350         ndr->depth--;
18351 }
18352
18353 static enum ndr_err_code ndr_push_srvsvc_NetSetServiceBits(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetServiceBits *r)
18354 {
18355         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18356         if (flags & NDR_IN) {
18357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18358                 if (r->in.server_unc) {
18359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18362                         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));
18363                 }
18364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
18365                 if (r->in.transport) {
18366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18368                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
18369                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18370                 }
18371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
18372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
18373         }
18374         if (flags & NDR_OUT) {
18375                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18376         }
18377         return NDR_ERR_SUCCESS;
18378 }
18379
18380 static enum ndr_err_code ndr_pull_srvsvc_NetSetServiceBits(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetServiceBits *r)
18381 {
18382         uint32_t _ptr_server_unc;
18383         uint32_t size_server_unc_1 = 0;
18384         uint32_t length_server_unc_1 = 0;
18385         uint32_t _ptr_transport;
18386         uint32_t size_transport_1 = 0;
18387         uint32_t length_transport_1 = 0;
18388         TALLOC_CTX *_mem_save_server_unc_0;
18389         TALLOC_CTX *_mem_save_transport_0;
18390         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18391         if (flags & NDR_IN) {
18392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18393                 if (_ptr_server_unc) {
18394                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18395                 } else {
18396                         r->in.server_unc = NULL;
18397                 }
18398                 if (r->in.server_unc) {
18399                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18400                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18403                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18404                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18405                         if (length_server_unc_1 > size_server_unc_1) {
18406                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18407                         }
18408                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18409                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18411                 }
18412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
18413                 if (_ptr_transport) {
18414                         NDR_PULL_ALLOC(ndr, r->in.transport);
18415                 } else {
18416                         r->in.transport = NULL;
18417                 }
18418                 if (r->in.transport) {
18419                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
18420                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
18421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
18422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
18423                         size_transport_1 = ndr_get_array_size(ndr, &r->in.transport);
18424                         length_transport_1 = ndr_get_array_length(ndr, &r->in.transport);
18425                         if (length_transport_1 > size_transport_1) {
18426                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_transport_1, length_transport_1);
18427                         }
18428                         NDR_CHECK(ndr_check_string_terminator(ndr, length_transport_1, sizeof(uint16_t)));
18429                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, length_transport_1, sizeof(uint16_t), CH_UTF16));
18430                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
18431                 }
18432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
18433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
18434         }
18435         if (flags & NDR_OUT) {
18436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18437         }
18438         return NDR_ERR_SUCCESS;
18439 }
18440
18441 _PUBLIC_ void ndr_print_srvsvc_NetSetServiceBits(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetServiceBits *r)
18442 {
18443         ndr_print_struct(ndr, name, "srvsvc_NetSetServiceBits");
18444         if (r == NULL) { ndr_print_null(ndr); return; }
18445         ndr->depth++;
18446         if (flags & NDR_SET_VALUES) {
18447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18448         }
18449         if (flags & NDR_IN) {
18450                 ndr_print_struct(ndr, "in", "srvsvc_NetSetServiceBits");
18451                 ndr->depth++;
18452                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18453                 ndr->depth++;
18454                 if (r->in.server_unc) {
18455                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18456                 }
18457                 ndr->depth--;
18458                 ndr_print_ptr(ndr, "transport", r->in.transport);
18459                 ndr->depth++;
18460                 if (r->in.transport) {
18461                         ndr_print_string(ndr, "transport", r->in.transport);
18462                 }
18463                 ndr->depth--;
18464                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
18465                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
18466                 ndr->depth--;
18467         }
18468         if (flags & NDR_OUT) {
18469                 ndr_print_struct(ndr, "out", "srvsvc_NetSetServiceBits");
18470                 ndr->depth++;
18471                 ndr_print_WERROR(ndr, "result", r->out.result);
18472                 ndr->depth--;
18473         }
18474         ndr->depth--;
18475 }
18476
18477 static enum ndr_err_code ndr_push_srvsvc_NetPathType(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathType *r)
18478 {
18479         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18480         if (flags & NDR_IN) {
18481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18482                 if (r->in.server_unc) {
18483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18486                         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));
18487                 }
18488                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
18489                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18490                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
18491                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
18493         }
18494         if (flags & NDR_OUT) {
18495                 if (r->out.pathtype == NULL) {
18496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18497                 }
18498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
18499                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18500         }
18501         return NDR_ERR_SUCCESS;
18502 }
18503
18504 static enum ndr_err_code ndr_pull_srvsvc_NetPathType(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathType *r)
18505 {
18506         uint32_t _ptr_server_unc;
18507         uint32_t size_server_unc_1 = 0;
18508         uint32_t length_server_unc_1 = 0;
18509         uint32_t size_path_0 = 0;
18510         uint32_t length_path_0 = 0;
18511         TALLOC_CTX *_mem_save_server_unc_0;
18512         TALLOC_CTX *_mem_save_pathtype_0;
18513         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18514         if (flags & NDR_IN) {
18515                 ZERO_STRUCT(r->out);
18516
18517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18518                 if (_ptr_server_unc) {
18519                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18520                 } else {
18521                         r->in.server_unc = NULL;
18522                 }
18523                 if (r->in.server_unc) {
18524                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18525                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18528                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18529                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18530                         if (length_server_unc_1 > size_server_unc_1) {
18531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18532                         }
18533                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18536                 }
18537                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
18538                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
18539                 size_path_0 = ndr_get_array_size(ndr, &r->in.path);
18540                 length_path_0 = ndr_get_array_length(ndr, &r->in.path);
18541                 if (length_path_0 > size_path_0) {
18542                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_0, length_path_0);
18543                 }
18544                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path_0, sizeof(uint16_t)));
18545                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_0, sizeof(uint16_t), CH_UTF16));
18546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
18547                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
18548                 ZERO_STRUCTP(r->out.pathtype);
18549         }
18550         if (flags & NDR_OUT) {
18551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18552                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
18553                 }
18554                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18555                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
18556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
18557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
18558                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18559         }
18560         return NDR_ERR_SUCCESS;
18561 }
18562
18563 _PUBLIC_ void ndr_print_srvsvc_NetPathType(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathType *r)
18564 {
18565         ndr_print_struct(ndr, name, "srvsvc_NetPathType");
18566         if (r == NULL) { ndr_print_null(ndr); return; }
18567         ndr->depth++;
18568         if (flags & NDR_SET_VALUES) {
18569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18570         }
18571         if (flags & NDR_IN) {
18572                 ndr_print_struct(ndr, "in", "srvsvc_NetPathType");
18573                 ndr->depth++;
18574                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18575                 ndr->depth++;
18576                 if (r->in.server_unc) {
18577                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18578                 }
18579                 ndr->depth--;
18580                 ndr_print_string(ndr, "path", r->in.path);
18581                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
18582                 ndr->depth--;
18583         }
18584         if (flags & NDR_OUT) {
18585                 ndr_print_struct(ndr, "out", "srvsvc_NetPathType");
18586                 ndr->depth++;
18587                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
18588                 ndr->depth++;
18589                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
18590                 ndr->depth--;
18591                 ndr_print_WERROR(ndr, "result", r->out.result);
18592                 ndr->depth--;
18593         }
18594         ndr->depth--;
18595 }
18596
18597 static enum ndr_err_code ndr_push_srvsvc_NetPathCanonicalize(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCanonicalize *r)
18598 {
18599         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18600         if (flags & NDR_IN) {
18601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18602                 if (r->in.server_unc) {
18603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18606                         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));
18607                 }
18608                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
18609                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18610                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));
18611                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));
18613                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
18614                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18615                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));
18616                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.prefix, ndr_charset_length(r->in.prefix, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18617                 if (r->in.pathtype == NULL) {
18618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18619                 }
18620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.pathtype));
18621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
18622         }
18623         if (flags & NDR_OUT) {
18624                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.maxbuf));
18625                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.can_path, r->in.maxbuf));
18626                 if (r->out.pathtype == NULL) {
18627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18628                 }
18629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));
18630                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18631         }
18632         return NDR_ERR_SUCCESS;
18633 }
18634
18635 static enum ndr_err_code ndr_pull_srvsvc_NetPathCanonicalize(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCanonicalize *r)
18636 {
18637         uint32_t _ptr_server_unc;
18638         uint32_t size_server_unc_1 = 0;
18639         uint32_t length_server_unc_1 = 0;
18640         uint32_t size_path_0 = 0;
18641         uint32_t length_path_0 = 0;
18642         uint32_t size_can_path_0 = 0;
18643         uint32_t size_prefix_0 = 0;
18644         uint32_t length_prefix_0 = 0;
18645         TALLOC_CTX *_mem_save_server_unc_0;
18646         TALLOC_CTX *_mem_save_pathtype_0;
18647         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18648         if (flags & NDR_IN) {
18649                 ZERO_STRUCT(r->out);
18650
18651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18652                 if (_ptr_server_unc) {
18653                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18654                 } else {
18655                         r->in.server_unc = NULL;
18656                 }
18657                 if (r->in.server_unc) {
18658                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18661                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18662                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18663                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18664                         if (length_server_unc_1 > size_server_unc_1) {
18665                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18666                         }
18667                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18668                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18670                 }
18671                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));
18672                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));
18673                 size_path_0 = ndr_get_array_size(ndr, &r->in.path);
18674                 length_path_0 = ndr_get_array_length(ndr, &r->in.path);
18675                 if (length_path_0 > size_path_0) {
18676                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path_0, length_path_0);
18677                 }
18678                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path_0, sizeof(uint16_t)));
18679                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, length_path_0, sizeof(uint16_t), CH_UTF16));
18680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxbuf));
18681                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.prefix));
18682                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.prefix));
18683                 size_prefix_0 = ndr_get_array_size(ndr, &r->in.prefix);
18684                 length_prefix_0 = ndr_get_array_length(ndr, &r->in.prefix);
18685                 if (length_prefix_0 > size_prefix_0) {
18686                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_prefix_0, length_prefix_0);
18687                 }
18688                 NDR_CHECK(ndr_check_string_terminator(ndr, length_prefix_0, sizeof(uint16_t)));
18689                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.prefix, length_prefix_0, sizeof(uint16_t), CH_UTF16));
18690                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18691                         NDR_PULL_ALLOC(ndr, r->in.pathtype);
18692                 }
18693                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18694                 NDR_PULL_SET_MEM_CTX(ndr, r->in.pathtype, LIBNDR_FLAG_REF_ALLOC);
18695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.pathtype));
18696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
18697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
18698                 NDR_PULL_ALLOC(ndr, r->out.pathtype);
18699                 *r->out.pathtype = *r->in.pathtype;
18700         }
18701         if (flags & NDR_OUT) {
18702                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.can_path));
18703                 size_can_path_0 = ndr_get_array_size(ndr, &r->out.can_path);
18704                 NDR_PULL_ALLOC_N(ndr, r->out.can_path, size_can_path_0);
18705                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.can_path, size_can_path_0));
18706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18707                         NDR_PULL_ALLOC(ndr, r->out.pathtype);
18708                 }
18709                 _mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18710                 NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);
18711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));
18712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);
18713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18714                 if (r->out.can_path) {
18715                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.can_path, r->in.maxbuf));
18716                 }
18717         }
18718         return NDR_ERR_SUCCESS;
18719 }
18720
18721 _PUBLIC_ void ndr_print_srvsvc_NetPathCanonicalize(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCanonicalize *r)
18722 {
18723         ndr_print_struct(ndr, name, "srvsvc_NetPathCanonicalize");
18724         if (r == NULL) { ndr_print_null(ndr); return; }
18725         ndr->depth++;
18726         if (flags & NDR_SET_VALUES) {
18727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18728         }
18729         if (flags & NDR_IN) {
18730                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCanonicalize");
18731                 ndr->depth++;
18732                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18733                 ndr->depth++;
18734                 if (r->in.server_unc) {
18735                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18736                 }
18737                 ndr->depth--;
18738                 ndr_print_string(ndr, "path", r->in.path);
18739                 ndr_print_uint32(ndr, "maxbuf", r->in.maxbuf);
18740                 ndr_print_string(ndr, "prefix", r->in.prefix);
18741                 ndr_print_ptr(ndr, "pathtype", r->in.pathtype);
18742                 ndr->depth++;
18743                 ndr_print_uint32(ndr, "pathtype", *r->in.pathtype);
18744                 ndr->depth--;
18745                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
18746                 ndr->depth--;
18747         }
18748         if (flags & NDR_OUT) {
18749                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCanonicalize");
18750                 ndr->depth++;
18751                 ndr_print_array_uint8(ndr, "can_path", r->out.can_path, r->in.maxbuf);
18752                 ndr_print_ptr(ndr, "pathtype", r->out.pathtype);
18753                 ndr->depth++;
18754                 ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);
18755                 ndr->depth--;
18756                 ndr_print_WERROR(ndr, "result", r->out.result);
18757                 ndr->depth--;
18758         }
18759         ndr->depth--;
18760 }
18761
18762 static enum ndr_err_code ndr_push_srvsvc_NetPathCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCompare *r)
18763 {
18764         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18765         if (flags & NDR_IN) {
18766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18767                 if (r->in.server_unc) {
18768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18771                         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));
18772                 }
18773                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
18774                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18775                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));
18776                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path1, ndr_charset_length(r->in.path1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18777                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
18778                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18779                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));
18780                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path2, ndr_charset_length(r->in.path2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathtype));
18782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));
18783         }
18784         if (flags & NDR_OUT) {
18785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18786         }
18787         return NDR_ERR_SUCCESS;
18788 }
18789
18790 static enum ndr_err_code ndr_pull_srvsvc_NetPathCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCompare *r)
18791 {
18792         uint32_t _ptr_server_unc;
18793         uint32_t size_server_unc_1 = 0;
18794         uint32_t length_server_unc_1 = 0;
18795         uint32_t size_path1_0 = 0;
18796         uint32_t length_path1_0 = 0;
18797         uint32_t size_path2_0 = 0;
18798         uint32_t length_path2_0 = 0;
18799         TALLOC_CTX *_mem_save_server_unc_0;
18800         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18801         if (flags & NDR_IN) {
18802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18803                 if (_ptr_server_unc) {
18804                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18805                 } else {
18806                         r->in.server_unc = NULL;
18807                 }
18808                 if (r->in.server_unc) {
18809                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18813                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18814                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18815                         if (length_server_unc_1 > size_server_unc_1) {
18816                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18817                         }
18818                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18821                 }
18822                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path1));
18823                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path1));
18824                 size_path1_0 = ndr_get_array_size(ndr, &r->in.path1);
18825                 length_path1_0 = ndr_get_array_length(ndr, &r->in.path1);
18826                 if (length_path1_0 > size_path1_0) {
18827                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path1_0, length_path1_0);
18828                 }
18829                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path1_0, sizeof(uint16_t)));
18830                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path1, length_path1_0, sizeof(uint16_t), CH_UTF16));
18831                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path2));
18832                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path2));
18833                 size_path2_0 = ndr_get_array_size(ndr, &r->in.path2);
18834                 length_path2_0 = ndr_get_array_length(ndr, &r->in.path2);
18835                 if (length_path2_0 > size_path2_0) {
18836                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_path2_0, length_path2_0);
18837                 }
18838                 NDR_CHECK(ndr_check_string_terminator(ndr, length_path2_0, sizeof(uint16_t)));
18839                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path2, length_path2_0, sizeof(uint16_t), CH_UTF16));
18840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathtype));
18841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));
18842         }
18843         if (flags & NDR_OUT) {
18844                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18845         }
18846         return NDR_ERR_SUCCESS;
18847 }
18848
18849 _PUBLIC_ void ndr_print_srvsvc_NetPathCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCompare *r)
18850 {
18851         ndr_print_struct(ndr, name, "srvsvc_NetPathCompare");
18852         if (r == NULL) { ndr_print_null(ndr); return; }
18853         ndr->depth++;
18854         if (flags & NDR_SET_VALUES) {
18855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18856         }
18857         if (flags & NDR_IN) {
18858                 ndr_print_struct(ndr, "in", "srvsvc_NetPathCompare");
18859                 ndr->depth++;
18860                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18861                 ndr->depth++;
18862                 if (r->in.server_unc) {
18863                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18864                 }
18865                 ndr->depth--;
18866                 ndr_print_string(ndr, "path1", r->in.path1);
18867                 ndr_print_string(ndr, "path2", r->in.path2);
18868                 ndr_print_uint32(ndr, "pathtype", r->in.pathtype);
18869                 ndr_print_uint32(ndr, "pathflags", r->in.pathflags);
18870                 ndr->depth--;
18871         }
18872         if (flags & NDR_OUT) {
18873                 ndr_print_struct(ndr, "out", "srvsvc_NetPathCompare");
18874                 ndr->depth++;
18875                 ndr_print_WERROR(ndr, "result", r->out.result);
18876                 ndr->depth--;
18877         }
18878         ndr->depth--;
18879 }
18880
18881 static enum ndr_err_code ndr_push_srvsvc_NetNameValidate(struct ndr_push *ndr, int flags, const struct srvsvc_NetNameValidate *r)
18882 {
18883         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18884         if (flags & NDR_IN) {
18885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
18886                 if (r->in.server_unc) {
18887                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18888                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18889                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
18890                         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));
18891                 }
18892                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
18893                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
18894                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));
18895                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
18897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
18898         }
18899         if (flags & NDR_OUT) {
18900                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18901         }
18902         return NDR_ERR_SUCCESS;
18903 }
18904
18905 static enum ndr_err_code ndr_pull_srvsvc_NetNameValidate(struct ndr_pull *ndr, int flags, struct srvsvc_NetNameValidate *r)
18906 {
18907         uint32_t _ptr_server_unc;
18908         uint32_t size_server_unc_1 = 0;
18909         uint32_t length_server_unc_1 = 0;
18910         uint32_t size_name_0 = 0;
18911         uint32_t length_name_0 = 0;
18912         TALLOC_CTX *_mem_save_server_unc_0;
18913         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18914         if (flags & NDR_IN) {
18915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
18916                 if (_ptr_server_unc) {
18917                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
18918                 } else {
18919                         r->in.server_unc = NULL;
18920                 }
18921                 if (r->in.server_unc) {
18922                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
18923                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
18924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
18925                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
18926                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
18927                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
18928                         if (length_server_unc_1 > size_server_unc_1) {
18929                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
18930                         }
18931                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
18932                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
18933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
18934                 }
18935                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));
18936                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));
18937                 size_name_0 = ndr_get_array_size(ndr, &r->in.name);
18938                 length_name_0 = ndr_get_array_length(ndr, &r->in.name);
18939                 if (length_name_0 > size_name_0) {
18940                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name_0, length_name_0);
18941                 }
18942                 NDR_CHECK(ndr_check_string_terminator(ndr, length_name_0, sizeof(uint16_t)));
18943                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, length_name_0, sizeof(uint16_t), CH_UTF16));
18944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
18945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
18946         }
18947         if (flags & NDR_OUT) {
18948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18949         }
18950         return NDR_ERR_SUCCESS;
18951 }
18952
18953 _PUBLIC_ void ndr_print_srvsvc_NetNameValidate(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetNameValidate *r)
18954 {
18955         ndr_print_struct(ndr, name, "srvsvc_NetNameValidate");
18956         if (r == NULL) { ndr_print_null(ndr); return; }
18957         ndr->depth++;
18958         if (flags & NDR_SET_VALUES) {
18959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18960         }
18961         if (flags & NDR_IN) {
18962                 ndr_print_struct(ndr, "in", "srvsvc_NetNameValidate");
18963                 ndr->depth++;
18964                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
18965                 ndr->depth++;
18966                 if (r->in.server_unc) {
18967                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
18968                 }
18969                 ndr->depth--;
18970                 ndr_print_string(ndr, "name", r->in.name);
18971                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
18972                 ndr_print_uint32(ndr, "flags", r->in.flags);
18973                 ndr->depth--;
18974         }
18975         if (flags & NDR_OUT) {
18976                 ndr_print_struct(ndr, "out", "srvsvc_NetNameValidate");
18977                 ndr->depth++;
18978                 ndr_print_WERROR(ndr, "result", r->out.result);
18979                 ndr->depth--;
18980         }
18981         ndr->depth--;
18982 }
18983
18984 static enum ndr_err_code ndr_push_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
18985 {
18986         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
18987         if (flags & NDR_IN) {
18988         }
18989         if (flags & NDR_OUT) {
18990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18991         }
18992         return NDR_ERR_SUCCESS;
18993 }
18994
18995 static enum ndr_err_code ndr_pull_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRPRNAMECANONICALIZE *r)
18996 {
18997         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
18998         if (flags & NDR_IN) {
18999         }
19000         if (flags & NDR_OUT) {
19001                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19002         }
19003         return NDR_ERR_SUCCESS;
19004 }
19005
19006 _PUBLIC_ void ndr_print_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)
19007 {
19008         ndr_print_struct(ndr, name, "srvsvc_NETRPRNAMECANONICALIZE");
19009         if (r == NULL) { ndr_print_null(ndr); return; }
19010         ndr->depth++;
19011         if (flags & NDR_SET_VALUES) {
19012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19013         }
19014         if (flags & NDR_IN) {
19015                 ndr_print_struct(ndr, "in", "srvsvc_NETRPRNAMECANONICALIZE");
19016                 ndr->depth++;
19017                 ndr->depth--;
19018         }
19019         if (flags & NDR_OUT) {
19020                 ndr_print_struct(ndr, "out", "srvsvc_NETRPRNAMECANONICALIZE");
19021                 ndr->depth++;
19022                 ndr_print_WERROR(ndr, "result", r->out.result);
19023                 ndr->depth--;
19024         }
19025         ndr->depth--;
19026 }
19027
19028 static enum ndr_err_code ndr_push_srvsvc_NetPRNameCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPRNameCompare *r)
19029 {
19030         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19031         if (flags & NDR_IN) {
19032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19033                 if (r->in.server_unc) {
19034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19036                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19037                         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));
19038                 }
19039                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
19040                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19041                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));
19042                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name1, ndr_charset_length(r->in.name1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19043                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
19044                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19045                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));
19046                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name2, ndr_charset_length(r->in.name2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));
19048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
19049         }
19050         if (flags & NDR_OUT) {
19051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19052         }
19053         return NDR_ERR_SUCCESS;
19054 }
19055
19056 static enum ndr_err_code ndr_pull_srvsvc_NetPRNameCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPRNameCompare *r)
19057 {
19058         uint32_t _ptr_server_unc;
19059         uint32_t size_server_unc_1 = 0;
19060         uint32_t length_server_unc_1 = 0;
19061         uint32_t size_name1_0 = 0;
19062         uint32_t length_name1_0 = 0;
19063         uint32_t size_name2_0 = 0;
19064         uint32_t length_name2_0 = 0;
19065         TALLOC_CTX *_mem_save_server_unc_0;
19066         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19067         if (flags & NDR_IN) {
19068                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19069                 if (_ptr_server_unc) {
19070                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19071                 } else {
19072                         r->in.server_unc = NULL;
19073                 }
19074                 if (r->in.server_unc) {
19075                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19076                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19079                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19080                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19081                         if (length_server_unc_1 > size_server_unc_1) {
19082                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19083                         }
19084                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19087                 }
19088                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name1));
19089                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name1));
19090                 size_name1_0 = ndr_get_array_size(ndr, &r->in.name1);
19091                 length_name1_0 = ndr_get_array_length(ndr, &r->in.name1);
19092                 if (length_name1_0 > size_name1_0) {
19093                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name1_0, length_name1_0);
19094                 }
19095                 NDR_CHECK(ndr_check_string_terminator(ndr, length_name1_0, sizeof(uint16_t)));
19096                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name1, length_name1_0, sizeof(uint16_t), CH_UTF16));
19097                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name2));
19098                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name2));
19099                 size_name2_0 = ndr_get_array_size(ndr, &r->in.name2);
19100                 length_name2_0 = ndr_get_array_length(ndr, &r->in.name2);
19101                 if (length_name2_0 > size_name2_0) {
19102                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_name2_0, length_name2_0);
19103                 }
19104                 NDR_CHECK(ndr_check_string_terminator(ndr, length_name2_0, sizeof(uint16_t)));
19105                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name2, length_name2_0, sizeof(uint16_t), CH_UTF16));
19106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));
19107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
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_NetPRNameCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPRNameCompare *r)
19116 {
19117         ndr_print_struct(ndr, name, "srvsvc_NetPRNameCompare");
19118         if (r == NULL) { ndr_print_null(ndr); return; }
19119         ndr->depth++;
19120         if (flags & NDR_SET_VALUES) {
19121                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19122         }
19123         if (flags & NDR_IN) {
19124                 ndr_print_struct(ndr, "in", "srvsvc_NetPRNameCompare");
19125                 ndr->depth++;
19126                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19127                 ndr->depth++;
19128                 if (r->in.server_unc) {
19129                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19130                 }
19131                 ndr->depth--;
19132                 ndr_print_string(ndr, "name1", r->in.name1);
19133                 ndr_print_string(ndr, "name2", r->in.name2);
19134                 ndr_print_uint32(ndr, "name_type", r->in.name_type);
19135                 ndr_print_uint32(ndr, "flags", r->in.flags);
19136                 ndr->depth--;
19137         }
19138         if (flags & NDR_OUT) {
19139                 ndr_print_struct(ndr, "out", "srvsvc_NetPRNameCompare");
19140                 ndr->depth++;
19141                 ndr_print_WERROR(ndr, "result", r->out.result);
19142                 ndr->depth--;
19143         }
19144         ndr->depth--;
19145 }
19146
19147 static enum ndr_err_code ndr_push_srvsvc_NetShareEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnum *r)
19148 {
19149         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19150         if (flags & NDR_IN) {
19151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19152                 if (r->in.server_unc) {
19153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19156                         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));
19157                 }
19158                 if (r->in.info_ctr == NULL) {
19159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19160                 }
19161                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
19163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
19164                 if (r->in.resume_handle) {
19165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
19166                 }
19167         }
19168         if (flags & NDR_OUT) {
19169                 if (r->out.info_ctr == NULL) {
19170                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19171                 }
19172                 NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
19173                 if (r->out.totalentries == NULL) {
19174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19175                 }
19176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
19177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
19178                 if (r->out.resume_handle) {
19179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
19180                 }
19181                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19182         }
19183         return NDR_ERR_SUCCESS;
19184 }
19185
19186 static enum ndr_err_code ndr_pull_srvsvc_NetShareEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnum *r)
19187 {
19188         uint32_t _ptr_server_unc;
19189         uint32_t size_server_unc_1 = 0;
19190         uint32_t length_server_unc_1 = 0;
19191         uint32_t _ptr_resume_handle;
19192         TALLOC_CTX *_mem_save_server_unc_0;
19193         TALLOC_CTX *_mem_save_info_ctr_0;
19194         TALLOC_CTX *_mem_save_totalentries_0;
19195         TALLOC_CTX *_mem_save_resume_handle_0;
19196         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19197         if (flags & NDR_IN) {
19198                 ZERO_STRUCT(r->out);
19199
19200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19201                 if (_ptr_server_unc) {
19202                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19203                 } else {
19204                         r->in.server_unc = NULL;
19205                 }
19206                 if (r->in.server_unc) {
19207                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19208                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19211                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19212                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19213                         if (length_server_unc_1 > size_server_unc_1) {
19214                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19215                         }
19216                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19219                 }
19220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19221                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19222                 }
19223                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19225                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
19228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
19229                 if (_ptr_resume_handle) {
19230                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
19231                 } else {
19232                         r->in.resume_handle = NULL;
19233                 }
19234                 if (r->in.resume_handle) {
19235                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19236                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
19237                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
19238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
19239                 }
19240                 NDR_PULL_ALLOC(ndr, r->out.info_ctr);
19241                 *r->out.info_ctr = *r->in.info_ctr;
19242                 NDR_PULL_ALLOC(ndr, r->out.totalentries);
19243                 ZERO_STRUCTP(r->out.totalentries);
19244         }
19245         if (flags & NDR_OUT) {
19246                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19247                         NDR_PULL_ALLOC(ndr, r->out.info_ctr);
19248                 }
19249                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19250                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19251                 NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));
19252                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19254                         NDR_PULL_ALLOC(ndr, r->out.totalentries);
19255                 }
19256                 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
19257                 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);
19258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
19259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);
19260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
19261                 if (_ptr_resume_handle) {
19262                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
19263                 } else {
19264                         r->out.resume_handle = NULL;
19265                 }
19266                 if (r->out.resume_handle) {
19267                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19268                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
19269                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
19270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
19271                 }
19272                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19273         }
19274         return NDR_ERR_SUCCESS;
19275 }
19276
19277 _PUBLIC_ void ndr_print_srvsvc_NetShareEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnum *r)
19278 {
19279         ndr_print_struct(ndr, name, "srvsvc_NetShareEnum");
19280         if (r == NULL) { ndr_print_null(ndr); return; }
19281         ndr->depth++;
19282         if (flags & NDR_SET_VALUES) {
19283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19284         }
19285         if (flags & NDR_IN) {
19286                 ndr_print_struct(ndr, "in", "srvsvc_NetShareEnum");
19287                 ndr->depth++;
19288                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19289                 ndr->depth++;
19290                 if (r->in.server_unc) {
19291                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19292                 }
19293                 ndr->depth--;
19294                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19295                 ndr->depth++;
19296                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19297                 ndr->depth--;
19298                 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
19299                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
19300                 ndr->depth++;
19301                 if (r->in.resume_handle) {
19302                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
19303                 }
19304                 ndr->depth--;
19305                 ndr->depth--;
19306         }
19307         if (flags & NDR_OUT) {
19308                 ndr_print_struct(ndr, "out", "srvsvc_NetShareEnum");
19309                 ndr->depth++;
19310                 ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);
19311                 ndr->depth++;
19312                 ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);
19313                 ndr->depth--;
19314                 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
19315                 ndr->depth++;
19316                 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
19317                 ndr->depth--;
19318                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
19319                 ndr->depth++;
19320                 if (r->out.resume_handle) {
19321                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
19322                 }
19323                 ndr->depth--;
19324                 ndr_print_WERROR(ndr, "result", r->out.result);
19325                 ndr->depth--;
19326         }
19327         ndr->depth--;
19328 }
19329
19330 static enum ndr_err_code ndr_push_srvsvc_NetShareDelStart(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelStart *r)
19331 {
19332         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19333         if (flags & NDR_IN) {
19334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19335                 if (r->in.server_unc) {
19336                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19337                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19339                         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));
19340                 }
19341                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19342                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19343                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19344                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));
19346         }
19347         if (flags & NDR_OUT) {
19348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
19349                 if (r->out.hnd) {
19350                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
19351                 }
19352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19353         }
19354         return NDR_ERR_SUCCESS;
19355 }
19356
19357 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelStart(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelStart *r)
19358 {
19359         uint32_t _ptr_server_unc;
19360         uint32_t size_server_unc_1 = 0;
19361         uint32_t length_server_unc_1 = 0;
19362         uint32_t size_share_0 = 0;
19363         uint32_t length_share_0 = 0;
19364         uint32_t _ptr_hnd;
19365         TALLOC_CTX *_mem_save_server_unc_0;
19366         TALLOC_CTX *_mem_save_hnd_0;
19367         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19368         if (flags & NDR_IN) {
19369                 ZERO_STRUCT(r->out);
19370
19371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19372                 if (_ptr_server_unc) {
19373                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19374                 } else {
19375                         r->in.server_unc = NULL;
19376                 }
19377                 if (r->in.server_unc) {
19378                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19379                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19382                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19383                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19384                         if (length_server_unc_1 > size_server_unc_1) {
19385                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19386                         }
19387                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19388                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19390                 }
19391                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
19392                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
19393                 size_share_0 = ndr_get_array_size(ndr, &r->in.share);
19394                 length_share_0 = ndr_get_array_length(ndr, &r->in.share);
19395                 if (length_share_0 > size_share_0) {
19396                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_0, length_share_0);
19397                 }
19398                 NDR_CHECK(ndr_check_string_terminator(ndr, length_share_0, sizeof(uint16_t)));
19399                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, length_share_0, sizeof(uint16_t), CH_UTF16));
19400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));
19401         }
19402         if (flags & NDR_OUT) {
19403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
19404                 if (_ptr_hnd) {
19405                         NDR_PULL_ALLOC(ndr, r->out.hnd);
19406                 } else {
19407                         r->out.hnd = NULL;
19408                 }
19409                 if (r->out.hnd) {
19410                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
19411                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
19412                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
19413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
19414                 }
19415                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19416         }
19417         return NDR_ERR_SUCCESS;
19418 }
19419
19420 _PUBLIC_ void ndr_print_srvsvc_NetShareDelStart(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelStart *r)
19421 {
19422         ndr_print_struct(ndr, name, "srvsvc_NetShareDelStart");
19423         if (r == NULL) { ndr_print_null(ndr); return; }
19424         ndr->depth++;
19425         if (flags & NDR_SET_VALUES) {
19426                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19427         }
19428         if (flags & NDR_IN) {
19429                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelStart");
19430                 ndr->depth++;
19431                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19432                 ndr->depth++;
19433                 if (r->in.server_unc) {
19434                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19435                 }
19436                 ndr->depth--;
19437                 ndr_print_string(ndr, "share", r->in.share);
19438                 ndr_print_uint32(ndr, "reserved", r->in.reserved);
19439                 ndr->depth--;
19440         }
19441         if (flags & NDR_OUT) {
19442                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelStart");
19443                 ndr->depth++;
19444                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
19445                 ndr->depth++;
19446                 if (r->out.hnd) {
19447                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
19448                 }
19449                 ndr->depth--;
19450                 ndr_print_WERROR(ndr, "result", r->out.result);
19451                 ndr->depth--;
19452         }
19453         ndr->depth--;
19454 }
19455
19456 static enum ndr_err_code ndr_push_srvsvc_NetShareDelCommit(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelCommit *r)
19457 {
19458         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19459         if (flags & NDR_IN) {
19460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hnd));
19461                 if (r->in.hnd) {
19462                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.hnd));
19463                 }
19464         }
19465         if (flags & NDR_OUT) {
19466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));
19467                 if (r->out.hnd) {
19468                         NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
19469                 }
19470                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19471         }
19472         return NDR_ERR_SUCCESS;
19473 }
19474
19475 static enum ndr_err_code ndr_pull_srvsvc_NetShareDelCommit(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelCommit *r)
19476 {
19477         uint32_t _ptr_hnd;
19478         TALLOC_CTX *_mem_save_hnd_0;
19479         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19480         if (flags & NDR_IN) {
19481                 ZERO_STRUCT(r->out);
19482
19483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
19484                 if (_ptr_hnd) {
19485                         NDR_PULL_ALLOC(ndr, r->in.hnd);
19486                 } else {
19487                         r->in.hnd = NULL;
19488                 }
19489                 if (r->in.hnd) {
19490                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
19491                         NDR_PULL_SET_MEM_CTX(ndr, r->in.hnd, 0);
19492                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.hnd));
19493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
19494                 }
19495         }
19496         if (flags & NDR_OUT) {
19497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));
19498                 if (_ptr_hnd) {
19499                         NDR_PULL_ALLOC(ndr, r->out.hnd);
19500                 } else {
19501                         r->out.hnd = NULL;
19502                 }
19503                 if (r->out.hnd) {
19504                         _mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);
19505                         NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);
19506                         NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));
19507                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);
19508                 }
19509                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19510         }
19511         return NDR_ERR_SUCCESS;
19512 }
19513
19514 _PUBLIC_ void ndr_print_srvsvc_NetShareDelCommit(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelCommit *r)
19515 {
19516         ndr_print_struct(ndr, name, "srvsvc_NetShareDelCommit");
19517         if (r == NULL) { ndr_print_null(ndr); return; }
19518         ndr->depth++;
19519         if (flags & NDR_SET_VALUES) {
19520                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19521         }
19522         if (flags & NDR_IN) {
19523                 ndr_print_struct(ndr, "in", "srvsvc_NetShareDelCommit");
19524                 ndr->depth++;
19525                 ndr_print_ptr(ndr, "hnd", r->in.hnd);
19526                 ndr->depth++;
19527                 if (r->in.hnd) {
19528                         ndr_print_policy_handle(ndr, "hnd", r->in.hnd);
19529                 }
19530                 ndr->depth--;
19531                 ndr->depth--;
19532         }
19533         if (flags & NDR_OUT) {
19534                 ndr_print_struct(ndr, "out", "srvsvc_NetShareDelCommit");
19535                 ndr->depth++;
19536                 ndr_print_ptr(ndr, "hnd", r->out.hnd);
19537                 ndr->depth++;
19538                 if (r->out.hnd) {
19539                         ndr_print_policy_handle(ndr, "hnd", r->out.hnd);
19540                 }
19541                 ndr->depth--;
19542                 ndr_print_WERROR(ndr, "result", r->out.result);
19543                 ndr->depth--;
19544         }
19545         ndr->depth--;
19546 }
19547
19548 static enum ndr_err_code ndr_push_srvsvc_NetGetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetGetFileSecurity *r)
19549 {
19550         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19551         if (flags & NDR_IN) {
19552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19553                 if (r->in.server_unc) {
19554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19555                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19556                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19557                         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));
19558                 }
19559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
19560                 if (r->in.share) {
19561                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19564                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19565                 }
19566                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
19567                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19568                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
19569                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19570                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
19571         }
19572         if (flags & NDR_OUT) {
19573                 if (r->out.sd_buf == NULL) {
19574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19575                 }
19576                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sd_buf));
19577                 if (*r->out.sd_buf) {
19578                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
19579                 }
19580                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19581         }
19582         return NDR_ERR_SUCCESS;
19583 }
19584
19585 static enum ndr_err_code ndr_pull_srvsvc_NetGetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetGetFileSecurity *r)
19586 {
19587         uint32_t _ptr_server_unc;
19588         uint32_t size_server_unc_1 = 0;
19589         uint32_t length_server_unc_1 = 0;
19590         uint32_t _ptr_share;
19591         uint32_t size_share_1 = 0;
19592         uint32_t length_share_1 = 0;
19593         uint32_t size_file_0 = 0;
19594         uint32_t length_file_0 = 0;
19595         uint32_t _ptr_sd_buf;
19596         TALLOC_CTX *_mem_save_server_unc_0;
19597         TALLOC_CTX *_mem_save_share_0;
19598         TALLOC_CTX *_mem_save_sd_buf_0;
19599         TALLOC_CTX *_mem_save_sd_buf_1;
19600         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19601         if (flags & NDR_IN) {
19602                 ZERO_STRUCT(r->out);
19603
19604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19605                 if (_ptr_server_unc) {
19606                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19607                 } else {
19608                         r->in.server_unc = NULL;
19609                 }
19610                 if (r->in.server_unc) {
19611                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19613                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19614                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19615                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19616                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19617                         if (length_server_unc_1 > size_server_unc_1) {
19618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19619                         }
19620                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19623                 }
19624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
19625                 if (_ptr_share) {
19626                         NDR_PULL_ALLOC(ndr, r->in.share);
19627                 } else {
19628                         r->in.share = NULL;
19629                 }
19630                 if (r->in.share) {
19631                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
19632                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
19633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
19634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
19635                         size_share_1 = ndr_get_array_size(ndr, &r->in.share);
19636                         length_share_1 = ndr_get_array_length(ndr, &r->in.share);
19637                         if (length_share_1 > size_share_1) {
19638                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_1, length_share_1);
19639                         }
19640                         NDR_CHECK(ndr_check_string_terminator(ndr, length_share_1, sizeof(uint16_t)));
19641                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, length_share_1, sizeof(uint16_t), CH_UTF16));
19642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
19643                 }
19644                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
19645                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
19646                 size_file_0 = ndr_get_array_size(ndr, &r->in.file);
19647                 length_file_0 = ndr_get_array_length(ndr, &r->in.file);
19648                 if (length_file_0 > size_file_0) {
19649                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_file_0, length_file_0);
19650                 }
19651                 NDR_CHECK(ndr_check_string_terminator(ndr, length_file_0, sizeof(uint16_t)));
19652                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, length_file_0, sizeof(uint16_t), CH_UTF16));
19653                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
19654                 NDR_PULL_ALLOC(ndr, r->out.sd_buf);
19655                 ZERO_STRUCTP(r->out.sd_buf);
19656         }
19657         if (flags & NDR_OUT) {
19658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19659                         NDR_PULL_ALLOC(ndr, r->out.sd_buf);
19660                 }
19661                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
19662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sd_buf, LIBNDR_FLAG_REF_ALLOC);
19663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_buf));
19664                 if (_ptr_sd_buf) {
19665                         NDR_PULL_ALLOC(ndr, *r->out.sd_buf);
19666                 } else {
19667                         *r->out.sd_buf = NULL;
19668                 }
19669                 if (*r->out.sd_buf) {
19670                         _mem_save_sd_buf_1 = NDR_PULL_GET_MEM_CTX(ndr);
19671                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sd_buf, 0);
19672                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));
19673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_1, 0);
19674                 }
19675                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
19676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19677         }
19678         return NDR_ERR_SUCCESS;
19679 }
19680
19681 _PUBLIC_ void ndr_print_srvsvc_NetGetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetGetFileSecurity *r)
19682 {
19683         ndr_print_struct(ndr, name, "srvsvc_NetGetFileSecurity");
19684         if (r == NULL) { ndr_print_null(ndr); return; }
19685         ndr->depth++;
19686         if (flags & NDR_SET_VALUES) {
19687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19688         }
19689         if (flags & NDR_IN) {
19690                 ndr_print_struct(ndr, "in", "srvsvc_NetGetFileSecurity");
19691                 ndr->depth++;
19692                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19693                 ndr->depth++;
19694                 if (r->in.server_unc) {
19695                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19696                 }
19697                 ndr->depth--;
19698                 ndr_print_ptr(ndr, "share", r->in.share);
19699                 ndr->depth++;
19700                 if (r->in.share) {
19701                         ndr_print_string(ndr, "share", r->in.share);
19702                 }
19703                 ndr->depth--;
19704                 ndr_print_string(ndr, "file", r->in.file);
19705                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
19706                 ndr->depth--;
19707         }
19708         if (flags & NDR_OUT) {
19709                 ndr_print_struct(ndr, "out", "srvsvc_NetGetFileSecurity");
19710                 ndr->depth++;
19711                 ndr_print_ptr(ndr, "sd_buf", r->out.sd_buf);
19712                 ndr->depth++;
19713                 ndr_print_ptr(ndr, "sd_buf", *r->out.sd_buf);
19714                 ndr->depth++;
19715                 if (*r->out.sd_buf) {
19716                         ndr_print_sec_desc_buf(ndr, "sd_buf", *r->out.sd_buf);
19717                 }
19718                 ndr->depth--;
19719                 ndr->depth--;
19720                 ndr_print_WERROR(ndr, "result", r->out.result);
19721                 ndr->depth--;
19722         }
19723         ndr->depth--;
19724 }
19725
19726 static enum ndr_err_code ndr_push_srvsvc_NetSetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetFileSecurity *r)
19727 {
19728         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19729         if (flags & NDR_IN) {
19730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19731                 if (r->in.server_unc) {
19732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19735                         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));
19736                 }
19737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));
19738                 if (r->in.share) {
19739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));
19742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19743                 }
19744                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
19745                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19746                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));
19747                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19748                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));
19749                 if (r->in.sd_buf == NULL) {
19750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19751                 }
19752                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
19753         }
19754         if (flags & NDR_OUT) {
19755                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19756         }
19757         return NDR_ERR_SUCCESS;
19758 }
19759
19760 static enum ndr_err_code ndr_pull_srvsvc_NetSetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetFileSecurity *r)
19761 {
19762         uint32_t _ptr_server_unc;
19763         uint32_t size_server_unc_1 = 0;
19764         uint32_t length_server_unc_1 = 0;
19765         uint32_t _ptr_share;
19766         uint32_t size_share_1 = 0;
19767         uint32_t length_share_1 = 0;
19768         uint32_t size_file_0 = 0;
19769         uint32_t length_file_0 = 0;
19770         TALLOC_CTX *_mem_save_server_unc_0;
19771         TALLOC_CTX *_mem_save_share_0;
19772         TALLOC_CTX *_mem_save_sd_buf_0;
19773         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19774         if (flags & NDR_IN) {
19775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19776                 if (_ptr_server_unc) {
19777                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19778                 } else {
19779                         r->in.server_unc = NULL;
19780                 }
19781                 if (r->in.server_unc) {
19782                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19783                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19786                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19787                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19788                         if (length_server_unc_1 > size_server_unc_1) {
19789                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19790                         }
19791                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19792                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19794                 }
19795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));
19796                 if (_ptr_share) {
19797                         NDR_PULL_ALLOC(ndr, r->in.share);
19798                 } else {
19799                         r->in.share = NULL;
19800                 }
19801                 if (r->in.share) {
19802                         _mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);
19803                         NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);
19804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));
19805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));
19806                         size_share_1 = ndr_get_array_size(ndr, &r->in.share);
19807                         length_share_1 = ndr_get_array_length(ndr, &r->in.share);
19808                         if (length_share_1 > size_share_1) {
19809                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_share_1, length_share_1);
19810                         }
19811                         NDR_CHECK(ndr_check_string_terminator(ndr, length_share_1, sizeof(uint16_t)));
19812                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, length_share_1, sizeof(uint16_t), CH_UTF16));
19813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);
19814                 }
19815                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));
19816                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));
19817                 size_file_0 = ndr_get_array_size(ndr, &r->in.file);
19818                 length_file_0 = ndr_get_array_length(ndr, &r->in.file);
19819                 if (length_file_0 > size_file_0) {
19820                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_file_0, length_file_0);
19821                 }
19822                 NDR_CHECK(ndr_check_string_terminator(ndr, length_file_0, sizeof(uint16_t)));
19823                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, length_file_0, sizeof(uint16_t), CH_UTF16));
19824                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));
19825                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19826                         NDR_PULL_ALLOC(ndr, r->in.sd_buf);
19827                 }
19828                 _mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
19829                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sd_buf, LIBNDR_FLAG_REF_ALLOC);
19830                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));
19831                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);
19832         }
19833         if (flags & NDR_OUT) {
19834                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19835         }
19836         return NDR_ERR_SUCCESS;
19837 }
19838
19839 _PUBLIC_ void ndr_print_srvsvc_NetSetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetFileSecurity *r)
19840 {
19841         ndr_print_struct(ndr, name, "srvsvc_NetSetFileSecurity");
19842         if (r == NULL) { ndr_print_null(ndr); return; }
19843         ndr->depth++;
19844         if (flags & NDR_SET_VALUES) {
19845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19846         }
19847         if (flags & NDR_IN) {
19848                 ndr_print_struct(ndr, "in", "srvsvc_NetSetFileSecurity");
19849                 ndr->depth++;
19850                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19851                 ndr->depth++;
19852                 if (r->in.server_unc) {
19853                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19854                 }
19855                 ndr->depth--;
19856                 ndr_print_ptr(ndr, "share", r->in.share);
19857                 ndr->depth++;
19858                 if (r->in.share) {
19859                         ndr_print_string(ndr, "share", r->in.share);
19860                 }
19861                 ndr->depth--;
19862                 ndr_print_string(ndr, "file", r->in.file);
19863                 ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);
19864                 ndr_print_ptr(ndr, "sd_buf", r->in.sd_buf);
19865                 ndr->depth++;
19866                 ndr_print_sec_desc_buf(ndr, "sd_buf", r->in.sd_buf);
19867                 ndr->depth--;
19868                 ndr->depth--;
19869         }
19870         if (flags & NDR_OUT) {
19871                 ndr_print_struct(ndr, "out", "srvsvc_NetSetFileSecurity");
19872                 ndr->depth++;
19873                 ndr_print_WERROR(ndr, "result", r->out.result);
19874                 ndr->depth--;
19875         }
19876         ndr->depth--;
19877 }
19878
19879 static enum ndr_err_code ndr_push_srvsvc_NetServerTransportAddEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerTransportAddEx *r)
19880 {
19881         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19882         if (flags & NDR_IN) {
19883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19884                 if (r->in.server_unc) {
19885                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19886                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19887                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19888                         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));
19889                 }
19890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19891                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
19892                 NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
19893         }
19894         if (flags & NDR_OUT) {
19895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19896         }
19897         return NDR_ERR_SUCCESS;
19898 }
19899
19900 static enum ndr_err_code ndr_pull_srvsvc_NetServerTransportAddEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerTransportAddEx *r)
19901 {
19902         uint32_t _ptr_server_unc;
19903         uint32_t size_server_unc_1 = 0;
19904         uint32_t length_server_unc_1 = 0;
19905         TALLOC_CTX *_mem_save_server_unc_0;
19906         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
19907         if (flags & NDR_IN) {
19908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
19909                 if (_ptr_server_unc) {
19910                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
19911                 } else {
19912                         r->in.server_unc = NULL;
19913                 }
19914                 if (r->in.server_unc) {
19915                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
19916                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
19917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
19918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
19919                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
19920                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
19921                         if (length_server_unc_1 > size_server_unc_1) {
19922                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
19923                         }
19924                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
19925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
19926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
19927                 }
19928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19929                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
19930                 NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
19931         }
19932         if (flags & NDR_OUT) {
19933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19934         }
19935         return NDR_ERR_SUCCESS;
19936 }
19937
19938 _PUBLIC_ void ndr_print_srvsvc_NetServerTransportAddEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerTransportAddEx *r)
19939 {
19940         ndr_print_struct(ndr, name, "srvsvc_NetServerTransportAddEx");
19941         if (r == NULL) { ndr_print_null(ndr); return; }
19942         ndr->depth++;
19943         if (flags & NDR_SET_VALUES) {
19944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19945         }
19946         if (flags & NDR_IN) {
19947                 ndr_print_struct(ndr, "in", "srvsvc_NetServerTransportAddEx");
19948                 ndr->depth++;
19949                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
19950                 ndr->depth++;
19951                 if (r->in.server_unc) {
19952                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
19953                 }
19954                 ndr->depth--;
19955                 ndr_print_uint32(ndr, "level", r->in.level);
19956                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
19957                 ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);
19958                 ndr->depth--;
19959         }
19960         if (flags & NDR_OUT) {
19961                 ndr_print_struct(ndr, "out", "srvsvc_NetServerTransportAddEx");
19962                 ndr->depth++;
19963                 ndr_print_WERROR(ndr, "result", r->out.result);
19964                 ndr->depth--;
19965         }
19966         ndr->depth--;
19967 }
19968
19969 static enum ndr_err_code ndr_push_srvsvc_NetServerSetServiceBitsEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
19970 {
19971         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
19972         if (flags & NDR_IN) {
19973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));
19974                 if (r->in.server_unc) {
19975                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));
19978                         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));
19979                 }
19980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.emulated_server_unc));
19981                 if (r->in.emulated_server_unc) {
19982                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
19983                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19984                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));
19985                         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));
19986                 }
19987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));
19988                 if (r->in.transport) {
19989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
19990                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19991                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));
19992                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19993                 }
19994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebitsofinterest));
19995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));
19996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));
19997         }
19998         if (flags & NDR_OUT) {
19999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20000         }
20001         return NDR_ERR_SUCCESS;
20002 }
20003
20004 static enum ndr_err_code ndr_pull_srvsvc_NetServerSetServiceBitsEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerSetServiceBitsEx *r)
20005 {
20006         uint32_t _ptr_server_unc;
20007         uint32_t size_server_unc_1 = 0;
20008         uint32_t length_server_unc_1 = 0;
20009         uint32_t _ptr_emulated_server_unc;
20010         uint32_t size_emulated_server_unc_1 = 0;
20011         uint32_t length_emulated_server_unc_1 = 0;
20012         uint32_t _ptr_transport;
20013         uint32_t size_transport_1 = 0;
20014         uint32_t length_transport_1 = 0;
20015         TALLOC_CTX *_mem_save_server_unc_0;
20016         TALLOC_CTX *_mem_save_emulated_server_unc_0;
20017         TALLOC_CTX *_mem_save_transport_0;
20018         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20019         if (flags & NDR_IN) {
20020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));
20021                 if (_ptr_server_unc) {
20022                         NDR_PULL_ALLOC(ndr, r->in.server_unc);
20023                 } else {
20024                         r->in.server_unc = NULL;
20025                 }
20026                 if (r->in.server_unc) {
20027                         _mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
20028                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);
20029                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));
20030                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));
20031                         size_server_unc_1 = ndr_get_array_size(ndr, &r->in.server_unc);
20032                         length_server_unc_1 = ndr_get_array_length(ndr, &r->in.server_unc);
20033                         if (length_server_unc_1 > size_server_unc_1) {
20034                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_unc_1, length_server_unc_1);
20035                         }
20036                         NDR_CHECK(ndr_check_string_terminator(ndr, length_server_unc_1, sizeof(uint16_t)));
20037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, length_server_unc_1, sizeof(uint16_t), CH_UTF16));
20038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);
20039                 }
20040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_emulated_server_unc));
20041                 if (_ptr_emulated_server_unc) {
20042                         NDR_PULL_ALLOC(ndr, r->in.emulated_server_unc);
20043                 } else {
20044                         r->in.emulated_server_unc = NULL;
20045                 }
20046                 if (r->in.emulated_server_unc) {
20047                         _mem_save_emulated_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);
20048                         NDR_PULL_SET_MEM_CTX(ndr, r->in.emulated_server_unc, 0);
20049                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.emulated_server_unc));
20050                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.emulated_server_unc));
20051                         size_emulated_server_unc_1 = ndr_get_array_size(ndr, &r->in.emulated_server_unc);
20052                         length_emulated_server_unc_1 = ndr_get_array_length(ndr, &r->in.emulated_server_unc);
20053                         if (length_emulated_server_unc_1 > size_emulated_server_unc_1) {
20054                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_emulated_server_unc_1, length_emulated_server_unc_1);
20055                         }
20056                         NDR_CHECK(ndr_check_string_terminator(ndr, length_emulated_server_unc_1, sizeof(uint16_t)));
20057                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.emulated_server_unc, length_emulated_server_unc_1, sizeof(uint16_t), CH_UTF16));
20058                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_emulated_server_unc_0, 0);
20059                 }
20060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));
20061                 if (_ptr_transport) {
20062                         NDR_PULL_ALLOC(ndr, r->in.transport);
20063                 } else {
20064                         r->in.transport = NULL;
20065                 }
20066                 if (r->in.transport) {
20067                         _mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);
20068                         NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);
20069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));
20070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));
20071                         size_transport_1 = ndr_get_array_size(ndr, &r->in.transport);
20072                         length_transport_1 = ndr_get_array_length(ndr, &r->in.transport);
20073                         if (length_transport_1 > size_transport_1) {
20074                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_transport_1, length_transport_1);
20075                         }
20076                         NDR_CHECK(ndr_check_string_terminator(ndr, length_transport_1, sizeof(uint16_t)));
20077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, length_transport_1, sizeof(uint16_t), CH_UTF16));
20078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);
20079                 }
20080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebitsofinterest));
20081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));
20082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));
20083         }
20084         if (flags & NDR_OUT) {
20085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20086         }
20087         return NDR_ERR_SUCCESS;
20088 }
20089
20090 _PUBLIC_ void ndr_print_srvsvc_NetServerSetServiceBitsEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)
20091 {
20092         ndr_print_struct(ndr, name, "srvsvc_NetServerSetServiceBitsEx");
20093         if (r == NULL) { ndr_print_null(ndr); return; }
20094         ndr->depth++;
20095         if (flags & NDR_SET_VALUES) {
20096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20097         }
20098         if (flags & NDR_IN) {
20099                 ndr_print_struct(ndr, "in", "srvsvc_NetServerSetServiceBitsEx");
20100                 ndr->depth++;
20101                 ndr_print_ptr(ndr, "server_unc", r->in.server_unc);
20102                 ndr->depth++;
20103                 if (r->in.server_unc) {
20104                         ndr_print_string(ndr, "server_unc", r->in.server_unc);
20105                 }
20106                 ndr->depth--;
20107                 ndr_print_ptr(ndr, "emulated_server_unc", r->in.emulated_server_unc);
20108                 ndr->depth++;
20109                 if (r->in.emulated_server_unc) {
20110                         ndr_print_string(ndr, "emulated_server_unc", r->in.emulated_server_unc);
20111                 }
20112                 ndr->depth--;
20113                 ndr_print_ptr(ndr, "transport", r->in.transport);
20114                 ndr->depth++;
20115                 if (r->in.transport) {
20116                         ndr_print_string(ndr, "transport", r->in.transport);
20117                 }
20118                 ndr->depth--;
20119                 ndr_print_uint32(ndr, "servicebitsofinterest", r->in.servicebitsofinterest);
20120                 ndr_print_uint32(ndr, "servicebits", r->in.servicebits);
20121                 ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);
20122                 ndr->depth--;
20123         }
20124         if (flags & NDR_OUT) {
20125                 ndr_print_struct(ndr, "out", "srvsvc_NetServerSetServiceBitsEx");
20126                 ndr->depth++;
20127                 ndr_print_WERROR(ndr, "result", r->out.result);
20128                 ndr->depth--;
20129         }
20130         ndr->depth--;
20131 }
20132
20133 static enum ndr_err_code ndr_push_srvsvc_NETRDFSGETVERSION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
20134 {
20135         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20136         if (flags & NDR_IN) {
20137         }
20138         if (flags & NDR_OUT) {
20139                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20140         }
20141         return NDR_ERR_SUCCESS;
20142 }
20143
20144 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSGETVERSION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSGETVERSION *r)
20145 {
20146         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20147         if (flags & NDR_IN) {
20148         }
20149         if (flags & NDR_OUT) {
20150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20151         }
20152         return NDR_ERR_SUCCESS;
20153 }
20154
20155 _PUBLIC_ void ndr_print_srvsvc_NETRDFSGETVERSION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSGETVERSION *r)
20156 {
20157         ndr_print_struct(ndr, name, "srvsvc_NETRDFSGETVERSION");
20158         if (r == NULL) { ndr_print_null(ndr); return; }
20159         ndr->depth++;
20160         if (flags & NDR_SET_VALUES) {
20161                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20162         }
20163         if (flags & NDR_IN) {
20164                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSGETVERSION");
20165                 ndr->depth++;
20166                 ndr->depth--;
20167         }
20168         if (flags & NDR_OUT) {
20169                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSGETVERSION");
20170                 ndr->depth++;
20171                 ndr_print_WERROR(ndr, "result", r->out.result);
20172                 ndr->depth--;
20173         }
20174         ndr->depth--;
20175 }
20176
20177 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
20178 {
20179         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20180         if (flags & NDR_IN) {
20181         }
20182         if (flags & NDR_OUT) {
20183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20184         }
20185         return NDR_ERR_SUCCESS;
20186 }
20187
20188 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
20189 {
20190         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20191         if (flags & NDR_IN) {
20192         }
20193         if (flags & NDR_OUT) {
20194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20195         }
20196         return NDR_ERR_SUCCESS;
20197 }
20198
20199 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
20200 {
20201         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATELOCALPARTITION");
20202         if (r == NULL) { ndr_print_null(ndr); return; }
20203         ndr->depth++;
20204         if (flags & NDR_SET_VALUES) {
20205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20206         }
20207         if (flags & NDR_IN) {
20208                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATELOCALPARTITION");
20209                 ndr->depth++;
20210                 ndr->depth--;
20211         }
20212         if (flags & NDR_OUT) {
20213                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATELOCALPARTITION");
20214                 ndr->depth++;
20215                 ndr_print_WERROR(ndr, "result", r->out.result);
20216                 ndr->depth--;
20217         }
20218         ndr->depth--;
20219 }
20220
20221 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
20222 {
20223         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20224         if (flags & NDR_IN) {
20225         }
20226         if (flags & NDR_OUT) {
20227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20228         }
20229         return NDR_ERR_SUCCESS;
20230 }
20231
20232 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
20233 {
20234         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20235         if (flags & NDR_IN) {
20236         }
20237         if (flags & NDR_OUT) {
20238                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20239         }
20240         return NDR_ERR_SUCCESS;
20241 }
20242
20243 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
20244 {
20245         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETELOCALPARTITION");
20246         if (r == NULL) { ndr_print_null(ndr); return; }
20247         ndr->depth++;
20248         if (flags & NDR_SET_VALUES) {
20249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20250         }
20251         if (flags & NDR_IN) {
20252                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETELOCALPARTITION");
20253                 ndr->depth++;
20254                 ndr->depth--;
20255         }
20256         if (flags & NDR_OUT) {
20257                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETELOCALPARTITION");
20258                 ndr->depth++;
20259                 ndr_print_WERROR(ndr, "result", r->out.result);
20260                 ndr->depth--;
20261         }
20262         ndr->depth--;
20263 }
20264
20265 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
20266 {
20267         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20268         if (flags & NDR_IN) {
20269         }
20270         if (flags & NDR_OUT) {
20271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20272         }
20273         return NDR_ERR_SUCCESS;
20274 }
20275
20276 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
20277 {
20278         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20279         if (flags & NDR_IN) {
20280         }
20281         if (flags & NDR_OUT) {
20282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20283         }
20284         return NDR_ERR_SUCCESS;
20285 }
20286
20287 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
20288 {
20289         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
20290         if (r == NULL) { ndr_print_null(ndr); return; }
20291         ndr->depth++;
20292         if (flags & NDR_SET_VALUES) {
20293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20294         }
20295         if (flags & NDR_IN) {
20296                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
20297                 ndr->depth++;
20298                 ndr->depth--;
20299         }
20300         if (flags & NDR_OUT) {
20301                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");
20302                 ndr->depth++;
20303                 ndr_print_WERROR(ndr, "result", r->out.result);
20304                 ndr->depth--;
20305         }
20306         ndr->depth--;
20307 }
20308
20309 static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETSERVERINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
20310 {
20311         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20312         if (flags & NDR_IN) {
20313         }
20314         if (flags & NDR_OUT) {
20315                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20316         }
20317         return NDR_ERR_SUCCESS;
20318 }
20319
20320 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETSERVERINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETSERVERINFO *r)
20321 {
20322         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20323         if (flags & NDR_IN) {
20324         }
20325         if (flags & NDR_OUT) {
20326                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20327         }
20328         return NDR_ERR_SUCCESS;
20329 }
20330
20331 _PUBLIC_ void ndr_print_srvsvc_NETRDFSSETSERVERINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)
20332 {
20333         ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETSERVERINFO");
20334         if (r == NULL) { ndr_print_null(ndr); return; }
20335         ndr->depth++;
20336         if (flags & NDR_SET_VALUES) {
20337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20338         }
20339         if (flags & NDR_IN) {
20340                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETSERVERINFO");
20341                 ndr->depth++;
20342                 ndr->depth--;
20343         }
20344         if (flags & NDR_OUT) {
20345                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETSERVERINFO");
20346                 ndr->depth++;
20347                 ndr_print_WERROR(ndr, "result", r->out.result);
20348                 ndr->depth--;
20349         }
20350         ndr->depth--;
20351 }
20352
20353 static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
20354 {
20355         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20356         if (flags & NDR_IN) {
20357         }
20358         if (flags & NDR_OUT) {
20359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20360         }
20361         return NDR_ERR_SUCCESS;
20362 }
20363
20364 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
20365 {
20366         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20367         if (flags & NDR_IN) {
20368         }
20369         if (flags & NDR_OUT) {
20370                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20371         }
20372         return NDR_ERR_SUCCESS;
20373 }
20374
20375 _PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)
20376 {
20377         ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATEEXITPOINT");
20378         if (r == NULL) { ndr_print_null(ndr); return; }
20379         ndr->depth++;
20380         if (flags & NDR_SET_VALUES) {
20381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20382         }
20383         if (flags & NDR_IN) {
20384                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATEEXITPOINT");
20385                 ndr->depth++;
20386                 ndr->depth--;
20387         }
20388         if (flags & NDR_OUT) {
20389                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATEEXITPOINT");
20390                 ndr->depth++;
20391                 ndr_print_WERROR(ndr, "result", r->out.result);
20392                 ndr->depth--;
20393         }
20394         ndr->depth--;
20395 }
20396
20397 static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
20398 {
20399         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20400         if (flags & NDR_IN) {
20401         }
20402         if (flags & NDR_OUT) {
20403                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20404         }
20405         return NDR_ERR_SUCCESS;
20406 }
20407
20408 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
20409 {
20410         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20411         if (flags & NDR_IN) {
20412         }
20413         if (flags & NDR_OUT) {
20414                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20415         }
20416         return NDR_ERR_SUCCESS;
20417 }
20418
20419 _PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)
20420 {
20421         ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETEEXITPOINT");
20422         if (r == NULL) { ndr_print_null(ndr); return; }
20423         ndr->depth++;
20424         if (flags & NDR_SET_VALUES) {
20425                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20426         }
20427         if (flags & NDR_IN) {
20428                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETEEXITPOINT");
20429                 ndr->depth++;
20430                 ndr->depth--;
20431         }
20432         if (flags & NDR_OUT) {
20433                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETEEXITPOINT");
20434                 ndr->depth++;
20435                 ndr_print_WERROR(ndr, "result", r->out.result);
20436                 ndr->depth--;
20437         }
20438         ndr->depth--;
20439 }
20440
20441 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
20442 {
20443         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20444         if (flags & NDR_IN) {
20445         }
20446         if (flags & NDR_OUT) {
20447                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20448         }
20449         return NDR_ERR_SUCCESS;
20450 }
20451
20452 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMODIFYPREFIX *r)
20453 {
20454         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20455         if (flags & NDR_IN) {
20456         }
20457         if (flags & NDR_OUT) {
20458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20459         }
20460         return NDR_ERR_SUCCESS;
20461 }
20462
20463 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)
20464 {
20465         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMODIFYPREFIX");
20466         if (r == NULL) { ndr_print_null(ndr); return; }
20467         ndr->depth++;
20468         if (flags & NDR_SET_VALUES) {
20469                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20470         }
20471         if (flags & NDR_IN) {
20472                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMODIFYPREFIX");
20473                 ndr->depth++;
20474                 ndr->depth--;
20475         }
20476         if (flags & NDR_OUT) {
20477                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMODIFYPREFIX");
20478                 ndr->depth++;
20479                 ndr_print_WERROR(ndr, "result", r->out.result);
20480                 ndr->depth--;
20481         }
20482         ndr->depth--;
20483 }
20484
20485 static enum ndr_err_code ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
20486 {
20487         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20488         if (flags & NDR_IN) {
20489         }
20490         if (flags & NDR_OUT) {
20491                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20492         }
20493         return NDR_ERR_SUCCESS;
20494 }
20495
20496 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
20497 {
20498         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20499         if (flags & NDR_IN) {
20500         }
20501         if (flags & NDR_OUT) {
20502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20503         }
20504         return NDR_ERR_SUCCESS;
20505 }
20506
20507 _PUBLIC_ void ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
20508 {
20509         ndr_print_struct(ndr, name, "srvsvc_NETRDFSFIXLOCALVOLUME");
20510         if (r == NULL) { ndr_print_null(ndr); return; }
20511         ndr->depth++;
20512         if (flags & NDR_SET_VALUES) {
20513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20514         }
20515         if (flags & NDR_IN) {
20516                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSFIXLOCALVOLUME");
20517                 ndr->depth++;
20518                 ndr->depth--;
20519         }
20520         if (flags & NDR_OUT) {
20521                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSFIXLOCALVOLUME");
20522                 ndr->depth++;
20523                 ndr_print_WERROR(ndr, "result", r->out.result);
20524                 ndr->depth--;
20525         }
20526         ndr->depth--;
20527 }
20528
20529 static enum ndr_err_code ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
20530 {
20531         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20532         if (flags & NDR_IN) {
20533         }
20534         if (flags & NDR_OUT) {
20535                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20536         }
20537         return NDR_ERR_SUCCESS;
20538 }
20539
20540 static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
20541 {
20542         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20543         if (flags & NDR_IN) {
20544         }
20545         if (flags & NDR_OUT) {
20546                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 _PUBLIC_ void ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
20552 {
20553         ndr_print_struct(ndr, name, "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
20554         if (r == NULL) { ndr_print_null(ndr); return; }
20555         ndr->depth++;
20556         if (flags & NDR_SET_VALUES) {
20557                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20558         }
20559         if (flags & NDR_IN) {
20560                 ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
20561                 ndr->depth++;
20562                 ndr->depth--;
20563         }
20564         if (flags & NDR_OUT) {
20565                 ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");
20566                 ndr->depth++;
20567                 ndr_print_WERROR(ndr, "result", r->out.result);
20568                 ndr->depth--;
20569         }
20570         ndr->depth--;
20571 }
20572
20573 static enum ndr_err_code ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
20574 {
20575         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
20576         if (flags & NDR_IN) {
20577         }
20578         if (flags & NDR_OUT) {
20579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20580         }
20581         return NDR_ERR_SUCCESS;
20582 }
20583
20584 static enum ndr_err_code ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
20585 {
20586         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
20587         if (flags & NDR_IN) {
20588         }
20589         if (flags & NDR_OUT) {
20590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20591         }
20592         return NDR_ERR_SUCCESS;
20593 }
20594
20595 _PUBLIC_ void ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
20596 {
20597         ndr_print_struct(ndr, name, "srvsvc_NETRSERVERTRANSPORTDELEX");
20598         if (r == NULL) { ndr_print_null(ndr); return; }
20599         ndr->depth++;
20600         if (flags & NDR_SET_VALUES) {
20601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20602         }
20603         if (flags & NDR_IN) {
20604                 ndr_print_struct(ndr, "in", "srvsvc_NETRSERVERTRANSPORTDELEX");
20605                 ndr->depth++;
20606                 ndr->depth--;
20607         }
20608         if (flags & NDR_OUT) {
20609                 ndr_print_struct(ndr, "out", "srvsvc_NETRSERVERTRANSPORTDELEX");
20610                 ndr->depth++;
20611                 ndr_print_WERROR(ndr, "result", r->out.result);
20612                 ndr->depth--;
20613         }
20614         ndr->depth--;
20615 }
20616
20617 static const struct ndr_interface_call srvsvc_calls[] = {
20618         {
20619                 "srvsvc_NetCharDevEnum",
20620                 sizeof(struct srvsvc_NetCharDevEnum),
20621                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevEnum,
20622                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevEnum,
20623                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevEnum,
20624                 { 0, NULL },
20625                 { 0, NULL },
20626         },
20627         {
20628                 "srvsvc_NetCharDevGetInfo",
20629                 sizeof(struct srvsvc_NetCharDevGetInfo),
20630                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevGetInfo,
20631                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevGetInfo,
20632                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevGetInfo,
20633                 { 0, NULL },
20634                 { 0, NULL },
20635         },
20636         {
20637                 "srvsvc_NetCharDevControl",
20638                 sizeof(struct srvsvc_NetCharDevControl),
20639                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevControl,
20640                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevControl,
20641                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevControl,
20642                 { 0, NULL },
20643                 { 0, NULL },
20644         },
20645         {
20646                 "srvsvc_NetCharDevQEnum",
20647                 sizeof(struct srvsvc_NetCharDevQEnum),
20648                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQEnum,
20649                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQEnum,
20650                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQEnum,
20651                 { 0, NULL },
20652                 { 0, NULL },
20653         },
20654         {
20655                 "srvsvc_NetCharDevQGetInfo",
20656                 sizeof(struct srvsvc_NetCharDevQGetInfo),
20657                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQGetInfo,
20658                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQGetInfo,
20659                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQGetInfo,
20660                 { 0, NULL },
20661                 { 0, NULL },
20662         },
20663         {
20664                 "srvsvc_NetCharDevQSetInfo",
20665                 sizeof(struct srvsvc_NetCharDevQSetInfo),
20666                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQSetInfo,
20667                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQSetInfo,
20668                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQSetInfo,
20669                 { 0, NULL },
20670                 { 0, NULL },
20671         },
20672         {
20673                 "srvsvc_NetCharDevQPurge",
20674                 sizeof(struct srvsvc_NetCharDevQPurge),
20675                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurge,
20676                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurge,
20677                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurge,
20678                 { 0, NULL },
20679                 { 0, NULL },
20680         },
20681         {
20682                 "srvsvc_NetCharDevQPurgeSelf",
20683                 sizeof(struct srvsvc_NetCharDevQPurgeSelf),
20684                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurgeSelf,
20685                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurgeSelf,
20686                 (ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurgeSelf,
20687                 { 0, NULL },
20688                 { 0, NULL },
20689         },
20690         {
20691                 "srvsvc_NetConnEnum",
20692                 sizeof(struct srvsvc_NetConnEnum),
20693                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetConnEnum,
20694                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetConnEnum,
20695                 (ndr_print_function_t) ndr_print_srvsvc_NetConnEnum,
20696                 { 0, NULL },
20697                 { 0, NULL },
20698         },
20699         {
20700                 "srvsvc_NetFileEnum",
20701                 sizeof(struct srvsvc_NetFileEnum),
20702                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileEnum,
20703                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileEnum,
20704                 (ndr_print_function_t) ndr_print_srvsvc_NetFileEnum,
20705                 { 0, NULL },
20706                 { 0, NULL },
20707         },
20708         {
20709                 "srvsvc_NetFileGetInfo",
20710                 sizeof(struct srvsvc_NetFileGetInfo),
20711                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileGetInfo,
20712                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileGetInfo,
20713                 (ndr_print_function_t) ndr_print_srvsvc_NetFileGetInfo,
20714                 { 0, NULL },
20715                 { 0, NULL },
20716         },
20717         {
20718                 "srvsvc_NetFileClose",
20719                 sizeof(struct srvsvc_NetFileClose),
20720                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileClose,
20721                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileClose,
20722                 (ndr_print_function_t) ndr_print_srvsvc_NetFileClose,
20723                 { 0, NULL },
20724                 { 0, NULL },
20725         },
20726         {
20727                 "srvsvc_NetSessEnum",
20728                 sizeof(struct srvsvc_NetSessEnum),
20729                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessEnum,
20730                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessEnum,
20731                 (ndr_print_function_t) ndr_print_srvsvc_NetSessEnum,
20732                 { 0, NULL },
20733                 { 0, NULL },
20734         },
20735         {
20736                 "srvsvc_NetSessDel",
20737                 sizeof(struct srvsvc_NetSessDel),
20738                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessDel,
20739                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessDel,
20740                 (ndr_print_function_t) ndr_print_srvsvc_NetSessDel,
20741                 { 0, NULL },
20742                 { 0, NULL },
20743         },
20744         {
20745                 "srvsvc_NetShareAdd",
20746                 sizeof(struct srvsvc_NetShareAdd),
20747                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareAdd,
20748                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareAdd,
20749                 (ndr_print_function_t) ndr_print_srvsvc_NetShareAdd,
20750                 { 0, NULL },
20751                 { 0, NULL },
20752         },
20753         {
20754                 "srvsvc_NetShareEnumAll",
20755                 sizeof(struct srvsvc_NetShareEnumAll),
20756                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnumAll,
20757                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnumAll,
20758                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnumAll,
20759                 { 0, NULL },
20760                 { 0, NULL },
20761         },
20762         {
20763                 "srvsvc_NetShareGetInfo",
20764                 sizeof(struct srvsvc_NetShareGetInfo),
20765                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareGetInfo,
20766                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareGetInfo,
20767                 (ndr_print_function_t) ndr_print_srvsvc_NetShareGetInfo,
20768                 { 0, NULL },
20769                 { 0, NULL },
20770         },
20771         {
20772                 "srvsvc_NetShareSetInfo",
20773                 sizeof(struct srvsvc_NetShareSetInfo),
20774                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareSetInfo,
20775                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareSetInfo,
20776                 (ndr_print_function_t) ndr_print_srvsvc_NetShareSetInfo,
20777                 { 0, NULL },
20778                 { 0, NULL },
20779         },
20780         {
20781                 "srvsvc_NetShareDel",
20782                 sizeof(struct srvsvc_NetShareDel),
20783                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDel,
20784                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDel,
20785                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDel,
20786                 { 0, NULL },
20787                 { 0, NULL },
20788         },
20789         {
20790                 "srvsvc_NetShareDelSticky",
20791                 sizeof(struct srvsvc_NetShareDelSticky),
20792                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelSticky,
20793                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelSticky,
20794                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelSticky,
20795                 { 0, NULL },
20796                 { 0, NULL },
20797         },
20798         {
20799                 "srvsvc_NetShareCheck",
20800                 sizeof(struct srvsvc_NetShareCheck),
20801                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareCheck,
20802                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareCheck,
20803                 (ndr_print_function_t) ndr_print_srvsvc_NetShareCheck,
20804                 { 0, NULL },
20805                 { 0, NULL },
20806         },
20807         {
20808                 "srvsvc_NetSrvGetInfo",
20809                 sizeof(struct srvsvc_NetSrvGetInfo),
20810                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvGetInfo,
20811                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvGetInfo,
20812                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvGetInfo,
20813                 { 0, NULL },
20814                 { 0, NULL },
20815         },
20816         {
20817                 "srvsvc_NetSrvSetInfo",
20818                 sizeof(struct srvsvc_NetSrvSetInfo),
20819                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvSetInfo,
20820                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvSetInfo,
20821                 (ndr_print_function_t) ndr_print_srvsvc_NetSrvSetInfo,
20822                 { 0, NULL },
20823                 { 0, NULL },
20824         },
20825         {
20826                 "srvsvc_NetDiskEnum",
20827                 sizeof(struct srvsvc_NetDiskEnum),
20828                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetDiskEnum,
20829                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetDiskEnum,
20830                 (ndr_print_function_t) ndr_print_srvsvc_NetDiskEnum,
20831                 { 0, NULL },
20832                 { 0, NULL },
20833         },
20834         {
20835                 "srvsvc_NetServerStatisticsGet",
20836                 sizeof(struct srvsvc_NetServerStatisticsGet),
20837                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerStatisticsGet,
20838                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerStatisticsGet,
20839                 (ndr_print_function_t) ndr_print_srvsvc_NetServerStatisticsGet,
20840                 { 0, NULL },
20841                 { 0, NULL },
20842         },
20843         {
20844                 "srvsvc_NetTransportAdd",
20845                 sizeof(struct srvsvc_NetTransportAdd),
20846                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportAdd,
20847                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportAdd,
20848                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportAdd,
20849                 { 0, NULL },
20850                 { 0, NULL },
20851         },
20852         {
20853                 "srvsvc_NetTransportEnum",
20854                 sizeof(struct srvsvc_NetTransportEnum),
20855                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportEnum,
20856                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportEnum,
20857                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportEnum,
20858                 { 0, NULL },
20859                 { 0, NULL },
20860         },
20861         {
20862                 "srvsvc_NetTransportDel",
20863                 sizeof(struct srvsvc_NetTransportDel),
20864                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportDel,
20865                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportDel,
20866                 (ndr_print_function_t) ndr_print_srvsvc_NetTransportDel,
20867                 { 0, NULL },
20868                 { 0, NULL },
20869         },
20870         {
20871                 "srvsvc_NetRemoteTOD",
20872                 sizeof(struct srvsvc_NetRemoteTOD),
20873                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetRemoteTOD,
20874                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetRemoteTOD,
20875                 (ndr_print_function_t) ndr_print_srvsvc_NetRemoteTOD,
20876                 { 0, NULL },
20877                 { 0, NULL },
20878         },
20879         {
20880                 "srvsvc_NetSetServiceBits",
20881                 sizeof(struct srvsvc_NetSetServiceBits),
20882                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetServiceBits,
20883                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetServiceBits,
20884                 (ndr_print_function_t) ndr_print_srvsvc_NetSetServiceBits,
20885                 { 0, NULL },
20886                 { 0, NULL },
20887         },
20888         {
20889                 "srvsvc_NetPathType",
20890                 sizeof(struct srvsvc_NetPathType),
20891                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathType,
20892                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathType,
20893                 (ndr_print_function_t) ndr_print_srvsvc_NetPathType,
20894                 { 0, NULL },
20895                 { 0, NULL },
20896         },
20897         {
20898                 "srvsvc_NetPathCanonicalize",
20899                 sizeof(struct srvsvc_NetPathCanonicalize),
20900                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCanonicalize,
20901                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCanonicalize,
20902                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCanonicalize,
20903                 { 0, NULL },
20904                 { 0, NULL },
20905         },
20906         {
20907                 "srvsvc_NetPathCompare",
20908                 sizeof(struct srvsvc_NetPathCompare),
20909                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCompare,
20910                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCompare,
20911                 (ndr_print_function_t) ndr_print_srvsvc_NetPathCompare,
20912                 { 0, NULL },
20913                 { 0, NULL },
20914         },
20915         {
20916                 "srvsvc_NetNameValidate",
20917                 sizeof(struct srvsvc_NetNameValidate),
20918                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetNameValidate,
20919                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetNameValidate,
20920                 (ndr_print_function_t) ndr_print_srvsvc_NetNameValidate,
20921                 { 0, NULL },
20922                 { 0, NULL },
20923         },
20924         {
20925                 "srvsvc_NETRPRNAMECANONICALIZE",
20926                 sizeof(struct srvsvc_NETRPRNAMECANONICALIZE),
20927                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRPRNAMECANONICALIZE,
20928                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRPRNAMECANONICALIZE,
20929                 (ndr_print_function_t) ndr_print_srvsvc_NETRPRNAMECANONICALIZE,
20930                 { 0, NULL },
20931                 { 0, NULL },
20932         },
20933         {
20934                 "srvsvc_NetPRNameCompare",
20935                 sizeof(struct srvsvc_NetPRNameCompare),
20936                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetPRNameCompare,
20937                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPRNameCompare,
20938                 (ndr_print_function_t) ndr_print_srvsvc_NetPRNameCompare,
20939                 { 0, NULL },
20940                 { 0, NULL },
20941         },
20942         {
20943                 "srvsvc_NetShareEnum",
20944                 sizeof(struct srvsvc_NetShareEnum),
20945                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnum,
20946                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnum,
20947                 (ndr_print_function_t) ndr_print_srvsvc_NetShareEnum,
20948                 { 0, NULL },
20949                 { 0, NULL },
20950         },
20951         {
20952                 "srvsvc_NetShareDelStart",
20953                 sizeof(struct srvsvc_NetShareDelStart),
20954                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelStart,
20955                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelStart,
20956                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelStart,
20957                 { 0, NULL },
20958                 { 0, NULL },
20959         },
20960         {
20961                 "srvsvc_NetShareDelCommit",
20962                 sizeof(struct srvsvc_NetShareDelCommit),
20963                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelCommit,
20964                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelCommit,
20965                 (ndr_print_function_t) ndr_print_srvsvc_NetShareDelCommit,
20966                 { 0, NULL },
20967                 { 0, NULL },
20968         },
20969         {
20970                 "srvsvc_NetGetFileSecurity",
20971                 sizeof(struct srvsvc_NetGetFileSecurity),
20972                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetGetFileSecurity,
20973                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetGetFileSecurity,
20974                 (ndr_print_function_t) ndr_print_srvsvc_NetGetFileSecurity,
20975                 { 0, NULL },
20976                 { 0, NULL },
20977         },
20978         {
20979                 "srvsvc_NetSetFileSecurity",
20980                 sizeof(struct srvsvc_NetSetFileSecurity),
20981                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetFileSecurity,
20982                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetFileSecurity,
20983                 (ndr_print_function_t) ndr_print_srvsvc_NetSetFileSecurity,
20984                 { 0, NULL },
20985                 { 0, NULL },
20986         },
20987         {
20988                 "srvsvc_NetServerTransportAddEx",
20989                 sizeof(struct srvsvc_NetServerTransportAddEx),
20990                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerTransportAddEx,
20991                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerTransportAddEx,
20992                 (ndr_print_function_t) ndr_print_srvsvc_NetServerTransportAddEx,
20993                 { 0, NULL },
20994                 { 0, NULL },
20995         },
20996         {
20997                 "srvsvc_NetServerSetServiceBitsEx",
20998                 sizeof(struct srvsvc_NetServerSetServiceBitsEx),
20999                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerSetServiceBitsEx,
21000                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerSetServiceBitsEx,
21001                 (ndr_print_function_t) ndr_print_srvsvc_NetServerSetServiceBitsEx,
21002                 { 0, NULL },
21003                 { 0, NULL },
21004         },
21005         {
21006                 "srvsvc_NETRDFSGETVERSION",
21007                 sizeof(struct srvsvc_NETRDFSGETVERSION),
21008                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSGETVERSION,
21009                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSGETVERSION,
21010                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSGETVERSION,
21011                 { 0, NULL },
21012                 { 0, NULL },
21013         },
21014         {
21015                 "srvsvc_NETRDFSCREATELOCALPARTITION",
21016                 sizeof(struct srvsvc_NETRDFSCREATELOCALPARTITION),
21017                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION,
21018                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION,
21019                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION,
21020                 { 0, NULL },
21021                 { 0, NULL },
21022         },
21023         {
21024                 "srvsvc_NETRDFSDELETELOCALPARTITION",
21025                 sizeof(struct srvsvc_NETRDFSDELETELOCALPARTITION),
21026                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION,
21027                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION,
21028                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION,
21029                 { 0, NULL },
21030                 { 0, NULL },
21031         },
21032         {
21033                 "srvsvc_NETRDFSSETLOCALVOLUMESTATE",
21034                 sizeof(struct srvsvc_NETRDFSSETLOCALVOLUMESTATE),
21035                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
21036                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
21037                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE,
21038                 { 0, NULL },
21039                 { 0, NULL },
21040         },
21041         {
21042                 "srvsvc_NETRDFSSETSERVERINFO",
21043                 sizeof(struct srvsvc_NETRDFSSETSERVERINFO),
21044                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETSERVERINFO,
21045                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETSERVERINFO,
21046                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETSERVERINFO,
21047                 { 0, NULL },
21048                 { 0, NULL },
21049         },
21050         {
21051                 "srvsvc_NETRDFSCREATEEXITPOINT",
21052                 sizeof(struct srvsvc_NETRDFSCREATEEXITPOINT),
21053                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATEEXITPOINT,
21054                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT,
21055                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATEEXITPOINT,
21056                 { 0, NULL },
21057                 { 0, NULL },
21058         },
21059         {
21060                 "srvsvc_NETRDFSDELETEEXITPOINT",
21061                 sizeof(struct srvsvc_NETRDFSDELETEEXITPOINT),
21062                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETEEXITPOINT,
21063                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT,
21064                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETEEXITPOINT,
21065                 { 0, NULL },
21066                 { 0, NULL },
21067         },
21068         {
21069                 "srvsvc_NETRDFSMODIFYPREFIX",
21070                 sizeof(struct srvsvc_NETRDFSMODIFYPREFIX),
21071                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMODIFYPREFIX,
21072                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMODIFYPREFIX,
21073                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMODIFYPREFIX,
21074                 { 0, NULL },
21075                 { 0, NULL },
21076         },
21077         {
21078                 "srvsvc_NETRDFSFIXLOCALVOLUME",
21079                 sizeof(struct srvsvc_NETRDFSFIXLOCALVOLUME),
21080                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME,
21081                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME,
21082                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME,
21083                 { 0, NULL },
21084                 { 0, NULL },
21085         },
21086         {
21087                 "srvsvc_NETRDFSMANAGERREPORTSITEINFO",
21088                 sizeof(struct srvsvc_NETRDFSMANAGERREPORTSITEINFO),
21089                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
21090                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
21091                 (ndr_print_function_t) ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO,
21092                 { 0, NULL },
21093                 { 0, NULL },
21094         },
21095         {
21096                 "srvsvc_NETRSERVERTRANSPORTDELEX",
21097                 sizeof(struct srvsvc_NETRSERVERTRANSPORTDELEX),
21098                 (ndr_push_flags_fn_t) ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX,
21099                 (ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX,
21100                 (ndr_print_function_t) ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX,
21101                 { 0, NULL },
21102                 { 0, NULL },
21103         },
21104         { NULL, 0, NULL, NULL, NULL }
21105 };
21106
21107 static const char * const srvsvc_endpoint_strings[] = {
21108         "ncacn_np:[\\pipe\\srvsvc]",
21109         "ncacn_ip_tcp:",
21110         "ncalrpc:",
21111 };
21112
21113 static const struct ndr_interface_string_array srvsvc_endpoints = {
21114         .count  = 3,
21115         .names  = srvsvc_endpoint_strings
21116 };
21117
21118 static const char * const srvsvc_authservice_strings[] = {
21119         "host",
21120 };
21121
21122 static const struct ndr_interface_string_array srvsvc_authservices = {
21123         .count  = 1,
21124         .names  = srvsvc_authservice_strings
21125 };
21126
21127
21128 const struct ndr_interface_table ndr_table_srvsvc = {
21129         .name           = "srvsvc",
21130         .syntax_id      = {
21131                 {0x4b324fc8,0x1670,0x01d3,{0x12,0x78},{0x5a,0x47,0xbf,0x6e,0xe1,0x88}},
21132                 NDR_SRVSVC_VERSION
21133         },
21134         .helpstring     = NDR_SRVSVC_HELPSTRING,
21135         .num_calls      = 54,
21136         .calls          = srvsvc_calls,
21137         .endpoints      = &srvsvc_endpoints,
21138         .authservices   = &srvsvc_authservices
21139 };
21140