bin.gen_ndr/default/librpc/gen_ndr/ndr_mgmt.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_mgmt.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 static enum ndr_err_code ndr_push_ndr_syntax_id_p(struct ndr_push *ndr, int ndr_flags, const struct ndr_syntax_id_p *r)
   8 {
   9         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 5));
  12                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
  13                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16                 if (r->id) {
  17                         NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, r->id));
  18                 }
  19         }
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 static enum ndr_err_code ndr_pull_ndr_syntax_id_p(struct ndr_pull *ndr, int ndr_flags, struct ndr_syntax_id_p *r)
  24 {
  25         uint32_t _ptr_id;
  26         TALLOC_CTX *_mem_save_id_0;
  27         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  28         if (ndr_flags & NDR_SCALARS) {
  29                 NDR_CHECK(ndr_pull_align(ndr, 5));
  30                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
  31                 if (_ptr_id) {
  32                         NDR_PULL_ALLOC(ndr, r->id);
  33                 } else {
  34                         r->id = NULL;
  35                 }
  36                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  37         }
  38         if (ndr_flags & NDR_BUFFERS) {
  39                 if (r->id) {
  40                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
  41                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
  42                         NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, r->id));
  43                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
  44                 }
  45         }
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 _PUBLIC_ void ndr_print_ndr_syntax_id_p(struct ndr_print *ndr, const char *name, const struct ndr_syntax_id_p *r)
  50 {
  51         ndr_print_struct(ndr, name, "ndr_syntax_id_p");
  52         if (r == NULL) { ndr_print_null(ndr); return; }
  53         ndr->depth++;
  54         ndr_print_ptr(ndr, "id", r->id);
  55         ndr->depth++;
  56         if (r->id) {
  57                 ndr_print_ndr_syntax_id(ndr, "id", r->id);
  58         }
  59         ndr->depth--;
  60         ndr->depth--;
  61 }
  62
  63 static enum ndr_err_code ndr_push_rpc_if_id_vector_t(struct ndr_push *ndr, int ndr_flags, const struct rpc_if_id_vector_t *r)
  64 {
  65         uint32_t cntr_if_id_0;
  66         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
  69                 NDR_CHECK(ndr_push_align(ndr, 5));
  70                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
  71                 for (cntr_if_id_0 = 0; cntr_if_id_0 < r->count; cntr_if_id_0++) {
  72                         NDR_CHECK(ndr_push_ndr_syntax_id_p(ndr, NDR_SCALARS, &r->if_id[cntr_if_id_0]));
  73                 }
  74                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  75         }
  76         if (ndr_flags & NDR_BUFFERS) {
  77                 for (cntr_if_id_0 = 0; cntr_if_id_0 < r->count; cntr_if_id_0++) {
  78                         NDR_CHECK(ndr_push_ndr_syntax_id_p(ndr, NDR_BUFFERS, &r->if_id[cntr_if_id_0]));
  79                 }
  80         }
  81         return NDR_ERR_SUCCESS;
  82 }
  83
  84 static enum ndr_err_code ndr_pull_rpc_if_id_vector_t(struct ndr_pull *ndr, int ndr_flags, struct rpc_if_id_vector_t *r)
  85 {
  86         uint32_t size_if_id_0 = 0;
  87         uint32_t cntr_if_id_0;
  88         TALLOC_CTX *_mem_save_if_id_0;
  89         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  90         if (ndr_flags & NDR_SCALARS) {
  91                 NDR_CHECK(ndr_pull_array_size(ndr, &r->if_id));
  92                 NDR_CHECK(ndr_pull_align(ndr, 5));
  93                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
  94                 size_if_id_0 = ndr_get_array_size(ndr, &r->if_id);
  95                 NDR_PULL_ALLOC_N(ndr, r->if_id, size_if_id_0);
  96                 _mem_save_if_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                 NDR_PULL_SET_MEM_CTX(ndr, r->if_id, 0);
  98                 for (cntr_if_id_0 = 0; cntr_if_id_0 < size_if_id_0; cntr_if_id_0++) {
  99                         NDR_CHECK(ndr_pull_ndr_syntax_id_p(ndr, NDR_SCALARS, &r->if_id[cntr_if_id_0]));
 100                 }
 101                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_if_id_0, 0);
 102                 if (r->if_id) {
 103                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->if_id, r->count));
 104                 }
 105                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 106         }
 107         if (ndr_flags & NDR_BUFFERS) {
 108                 size_if_id_0 = ndr_get_array_size(ndr, &r->if_id);
 109                 _mem_save_if_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
 110                 NDR_PULL_SET_MEM_CTX(ndr, r->if_id, 0);
 111                 for (cntr_if_id_0 = 0; cntr_if_id_0 < size_if_id_0; cntr_if_id_0++) {
 112                         NDR_CHECK(ndr_pull_ndr_syntax_id_p(ndr, NDR_BUFFERS, &r->if_id[cntr_if_id_0]));
 113                 }
 114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_if_id_0, 0);
 115         }
 116         return NDR_ERR_SUCCESS;
 117 }
 118
 119 _PUBLIC_ void ndr_print_rpc_if_id_vector_t(struct ndr_print *ndr, const char *name, const struct rpc_if_id_vector_t *r)
 120 {
 121         uint32_t cntr_if_id_0;
 122         ndr_print_struct(ndr, name, "rpc_if_id_vector_t");
 123         if (r == NULL) { ndr_print_null(ndr); return; }
 124         ndr->depth++;
 125         ndr_print_uint32(ndr, "count", r->count);
 126         ndr->print(ndr, "%s: ARRAY(%d)", "if_id", (int)r->count);
 127         ndr->depth++;
 128         for (cntr_if_id_0=0;cntr_if_id_0<r->count;cntr_if_id_0++) {
 129                 ndr_print_ndr_syntax_id_p(ndr, "if_id", &r->if_id[cntr_if_id_0]);
 130         }
 131         ndr->depth--;
 132         ndr->depth--;
 133 }
 134
 135 static enum ndr_err_code ndr_push_mgmt_statistics(struct ndr_push *ndr, int ndr_flags, const struct mgmt_statistics *r)
 136 {
 137         uint32_t cntr_statistics_0;
 138         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 139         if (ndr_flags & NDR_SCALARS) {
 140                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 141                 NDR_CHECK(ndr_push_align(ndr, 4));
 142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 143                 for (cntr_statistics_0 = 0; cntr_statistics_0 < r->count; cntr_statistics_0++) {
 144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->statistics[cntr_statistics_0]));
 145                 }
 146                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 147         }
 148         if (ndr_flags & NDR_BUFFERS) {
 149         }
 150         return NDR_ERR_SUCCESS;
 151 }
 152
 153 static enum ndr_err_code ndr_pull_mgmt_statistics(struct ndr_pull *ndr, int ndr_flags, struct mgmt_statistics *r)
 154 {
 155         uint32_t size_statistics_0 = 0;
 156         uint32_t cntr_statistics_0;
 157         TALLOC_CTX *_mem_save_statistics_0;
 158         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 159         if (ndr_flags & NDR_SCALARS) {
 160                 NDR_CHECK(ndr_pull_array_size(ndr, &r->statistics));
 161                 NDR_CHECK(ndr_pull_align(ndr, 4));
 162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 163                 size_statistics_0 = ndr_get_array_size(ndr, &r->statistics);
 164                 NDR_PULL_ALLOC_N(ndr, r->statistics, size_statistics_0);
 165                 _mem_save_statistics_0 = NDR_PULL_GET_MEM_CTX(ndr);
 166                 NDR_PULL_SET_MEM_CTX(ndr, r->statistics, 0);
 167                 for (cntr_statistics_0 = 0; cntr_statistics_0 < size_statistics_0; cntr_statistics_0++) {
 168                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->statistics[cntr_statistics_0]));
 169                 }
 170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_statistics_0, 0);
 171                 if (r->statistics) {
 172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->statistics, r->count));
 173                 }
 174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 175         }
 176         if (ndr_flags & NDR_BUFFERS) {
 177         }
 178         return NDR_ERR_SUCCESS;
 179 }
 180
 181 _PUBLIC_ void ndr_print_mgmt_statistics(struct ndr_print *ndr, const char *name, const struct mgmt_statistics *r)
 182 {
 183         uint32_t cntr_statistics_0;
 184         ndr_print_struct(ndr, name, "mgmt_statistics");
 185         if (r == NULL) { ndr_print_null(ndr); return; }
 186         ndr->depth++;
 187         ndr_print_uint32(ndr, "count", r->count);
 188         ndr->print(ndr, "%s: ARRAY(%d)", "statistics", (int)r->count);
 189         ndr->depth++;
 190         for (cntr_statistics_0=0;cntr_statistics_0<r->count;cntr_statistics_0++) {
 191                 ndr_print_uint32(ndr, "statistics", r->statistics[cntr_statistics_0]);
 192         }
 193         ndr->depth--;
 194         ndr->depth--;
 195 }
 196
 197 static enum ndr_err_code ndr_push_mgmt_inq_if_ids(struct ndr_push *ndr, int flags, const struct mgmt_inq_if_ids *r)
 198 {
 199         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 200         if (flags & NDR_IN) {
 201         }
 202         if (flags & NDR_OUT) {
 203                 if (r->out.if_id_vector == NULL) {
 204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 205                 }
 206                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.if_id_vector));
 207                 if (*r->out.if_id_vector) {
 208                         NDR_CHECK(ndr_push_rpc_if_id_vector_t(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.if_id_vector));
 209                 }
 210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 211         }
 212         return NDR_ERR_SUCCESS;
 213 }
 214
 215 static enum ndr_err_code ndr_pull_mgmt_inq_if_ids(struct ndr_pull *ndr, int flags, struct mgmt_inq_if_ids *r)
 216 {
 217         uint32_t _ptr_if_id_vector;
 218         TALLOC_CTX *_mem_save_if_id_vector_0;
 219         TALLOC_CTX *_mem_save_if_id_vector_1;
 220         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 221         if (flags & NDR_IN) {
 222                 ZERO_STRUCT(r->out);
 223
 224                 NDR_PULL_ALLOC(ndr, r->out.if_id_vector);
 225                 ZERO_STRUCTP(r->out.if_id_vector);
 226         }
 227         if (flags & NDR_OUT) {
 228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 229                         NDR_PULL_ALLOC(ndr, r->out.if_id_vector);
 230                 }
 231                 _mem_save_if_id_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
 232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.if_id_vector, LIBNDR_FLAG_REF_ALLOC);
 233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_if_id_vector));
 234                 if (_ptr_if_id_vector) {
 235                         NDR_PULL_ALLOC(ndr, *r->out.if_id_vector);
 236                 } else {
 237                         *r->out.if_id_vector = NULL;
 238                 }
 239                 if (*r->out.if_id_vector) {
 240                         _mem_save_if_id_vector_1 = NDR_PULL_GET_MEM_CTX(ndr);
 241                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.if_id_vector, 0);
 242                         NDR_CHECK(ndr_pull_rpc_if_id_vector_t(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.if_id_vector));
 243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_if_id_vector_1, 0);
 244                 }
 245                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_if_id_vector_0, LIBNDR_FLAG_REF_ALLOC);
 246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 247         }
 248         return NDR_ERR_SUCCESS;
 249 }
 250
 251 _PUBLIC_ void ndr_print_mgmt_inq_if_ids(struct ndr_print *ndr, const char *name, int flags, const struct mgmt_inq_if_ids *r)
 252 {
 253         ndr_print_struct(ndr, name, "mgmt_inq_if_ids");
 254         if (r == NULL) { ndr_print_null(ndr); return; }
 255         ndr->depth++;
 256         if (flags & NDR_SET_VALUES) {
 257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 258         }
 259         if (flags & NDR_IN) {
 260                 ndr_print_struct(ndr, "in", "mgmt_inq_if_ids");
 261                 ndr->depth++;
 262                 ndr->depth--;
 263         }
 264         if (flags & NDR_OUT) {
 265                 ndr_print_struct(ndr, "out", "mgmt_inq_if_ids");
 266                 ndr->depth++;
 267                 ndr_print_ptr(ndr, "if_id_vector", r->out.if_id_vector);
 268                 ndr->depth++;
 269                 ndr_print_ptr(ndr, "if_id_vector", *r->out.if_id_vector);
 270                 ndr->depth++;
 271                 if (*r->out.if_id_vector) {
 272                         ndr_print_rpc_if_id_vector_t(ndr, "if_id_vector", *r->out.if_id_vector);
 273                 }
 274                 ndr->depth--;
 275                 ndr->depth--;
 276                 ndr_print_WERROR(ndr, "result", r->out.result);
 277                 ndr->depth--;
 278         }
 279         ndr->depth--;
 280 }
 281
 282 static enum ndr_err_code ndr_push_mgmt_inq_stats(struct ndr_push *ndr, int flags, const struct mgmt_inq_stats *r)
 283 {
 284         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 285         if (flags & NDR_IN) {
 286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_count));
 287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
 288         }
 289         if (flags & NDR_OUT) {
 290                 if (r->out.statistics == NULL) {
 291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 292                 }
 293                 NDR_CHECK(ndr_push_mgmt_statistics(ndr, NDR_SCALARS, r->out.statistics));
 294                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 295         }
 296         return NDR_ERR_SUCCESS;
 297 }
 298
 299 static enum ndr_err_code ndr_pull_mgmt_inq_stats(struct ndr_pull *ndr, int flags, struct mgmt_inq_stats *r)
 300 {
 301         TALLOC_CTX *_mem_save_statistics_0;
 302         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 303         if (flags & NDR_IN) {
 304                 ZERO_STRUCT(r->out);
 305
 306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_count));
 307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
 308                 NDR_PULL_ALLOC(ndr, r->out.statistics);
 309                 ZERO_STRUCTP(r->out.statistics);
 310         }
 311         if (flags & NDR_OUT) {
 312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 313                         NDR_PULL_ALLOC(ndr, r->out.statistics);
 314                 }
 315                 _mem_save_statistics_0 = NDR_PULL_GET_MEM_CTX(ndr);
 316                 NDR_PULL_SET_MEM_CTX(ndr, r->out.statistics, LIBNDR_FLAG_REF_ALLOC);
 317                 NDR_CHECK(ndr_pull_mgmt_statistics(ndr, NDR_SCALARS, r->out.statistics));
 318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_statistics_0, LIBNDR_FLAG_REF_ALLOC);
 319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 320         }
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 _PUBLIC_ void ndr_print_mgmt_inq_stats(struct ndr_print *ndr, const char *name, int flags, const struct mgmt_inq_stats *r)
 325 {
 326         ndr_print_struct(ndr, name, "mgmt_inq_stats");
 327         if (r == NULL) { ndr_print_null(ndr); return; }
 328         ndr->depth++;
 329         if (flags & NDR_SET_VALUES) {
 330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 331         }
 332         if (flags & NDR_IN) {
 333                 ndr_print_struct(ndr, "in", "mgmt_inq_stats");
 334                 ndr->depth++;
 335                 ndr_print_uint32(ndr, "max_count", r->in.max_count);
 336                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
 337                 ndr->depth--;
 338         }
 339         if (flags & NDR_OUT) {
 340                 ndr_print_struct(ndr, "out", "mgmt_inq_stats");
 341                 ndr->depth++;
 342                 ndr_print_ptr(ndr, "statistics", r->out.statistics);
 343                 ndr->depth++;
 344                 ndr_print_mgmt_statistics(ndr, "statistics", r->out.statistics);
 345                 ndr->depth--;
 346                 ndr_print_WERROR(ndr, "result", r->out.result);
 347                 ndr->depth--;
 348         }
 349         ndr->depth--;
 350 }
 351
 352 static enum ndr_err_code ndr_push_mgmt_is_server_listening(struct ndr_push *ndr, int flags, const struct mgmt_is_server_listening *r)
 353 {
 354         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 355         if (flags & NDR_IN) {
 356         }
 357         if (flags & NDR_OUT) {
 358                 if (r->out.status == NULL) {
 359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 360                 }
 361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status));
 362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
 363         }
 364         return NDR_ERR_SUCCESS;
 365 }
 366
 367 static enum ndr_err_code ndr_pull_mgmt_is_server_listening(struct ndr_pull *ndr, int flags, struct mgmt_is_server_listening *r)
 368 {
 369         TALLOC_CTX *_mem_save_status_0;
 370         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 371         if (flags & NDR_IN) {
 372                 ZERO_STRUCT(r->out);
 373
 374                 NDR_PULL_ALLOC(ndr, r->out.status);
 375                 ZERO_STRUCTP(r->out.status);
 376         }
 377         if (flags & NDR_OUT) {
 378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 379                         NDR_PULL_ALLOC(ndr, r->out.status);
 380                 }
 381                 _mem_save_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
 382                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status, LIBNDR_FLAG_REF_ALLOC);
 383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status));
 384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_0, LIBNDR_FLAG_REF_ALLOC);
 385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
 386         }
 387         return NDR_ERR_SUCCESS;
 388 }
 389
 390 _PUBLIC_ void ndr_print_mgmt_is_server_listening(struct ndr_print *ndr, const char *name, int flags, const struct mgmt_is_server_listening *r)
 391 {
 392         ndr_print_struct(ndr, name, "mgmt_is_server_listening");
 393         if (r == NULL) { ndr_print_null(ndr); return; }
 394         ndr->depth++;
 395         if (flags & NDR_SET_VALUES) {
 396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 397         }
 398         if (flags & NDR_IN) {
 399                 ndr_print_struct(ndr, "in", "mgmt_is_server_listening");
 400                 ndr->depth++;
 401                 ndr->depth--;
 402         }
 403         if (flags & NDR_OUT) {
 404                 ndr_print_struct(ndr, "out", "mgmt_is_server_listening");
 405                 ndr->depth++;
 406                 ndr_print_ptr(ndr, "status", r->out.status);
 407                 ndr->depth++;
 408                 ndr_print_uint32(ndr, "status", *r->out.status);
 409                 ndr->depth--;
 410                 ndr_print_uint32(ndr, "result", r->out.result);
 411                 ndr->depth--;
 412         }
 413         ndr->depth--;
 414 }
 415
 416 static enum ndr_err_code ndr_push_mgmt_stop_server_listening(struct ndr_push *ndr, int flags, const struct mgmt_stop_server_listening *r)
 417 {
 418         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 419         if (flags & NDR_IN) {
 420         }
 421         if (flags & NDR_OUT) {
 422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 423         }
 424         return NDR_ERR_SUCCESS;
 425 }
 426
 427 static enum ndr_err_code ndr_pull_mgmt_stop_server_listening(struct ndr_pull *ndr, int flags, struct mgmt_stop_server_listening *r)
 428 {
 429         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 430         if (flags & NDR_IN) {
 431         }
 432         if (flags & NDR_OUT) {
 433                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 434         }
 435         return NDR_ERR_SUCCESS;
 436 }
 437
 438 _PUBLIC_ void ndr_print_mgmt_stop_server_listening(struct ndr_print *ndr, const char *name, int flags, const struct mgmt_stop_server_listening *r)
 439 {
 440         ndr_print_struct(ndr, name, "mgmt_stop_server_listening");
 441         if (r == NULL) { ndr_print_null(ndr); return; }
 442         ndr->depth++;
 443         if (flags & NDR_SET_VALUES) {
 444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 445         }
 446         if (flags & NDR_IN) {
 447                 ndr_print_struct(ndr, "in", "mgmt_stop_server_listening");
 448                 ndr->depth++;
 449                 ndr->depth--;
 450         }
 451         if (flags & NDR_OUT) {
 452                 ndr_print_struct(ndr, "out", "mgmt_stop_server_listening");
 453                 ndr->depth++;
 454                 ndr_print_WERROR(ndr, "result", r->out.result);
 455                 ndr->depth--;
 456         }
 457         ndr->depth--;
 458 }
 459
 460 static enum ndr_err_code ndr_push_mgmt_inq_princ_name(struct ndr_push *ndr, int flags, const struct mgmt_inq_princ_name *r)
 461 {
 462         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 463         if (flags & NDR_IN) {
 464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.authn_proto));
 465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.princ_name_size));
 466         }
 467         if (flags & NDR_OUT) {
 468                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.princ_name_size));
 469                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 470                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->out.princ_name, CH_DOS)));
 471                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.princ_name, ndr_charset_length(r->out.princ_name, CH_DOS), sizeof(uint8_t), CH_DOS));
 472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 473         }
 474         return NDR_ERR_SUCCESS;
 475 }
 476
 477 static enum ndr_err_code ndr_pull_mgmt_inq_princ_name(struct ndr_pull *ndr, int flags, struct mgmt_inq_princ_name *r)
 478 {
 479         uint32_t size_princ_name_0 = 0;
 480         uint32_t length_princ_name_0 = 0;
 481         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 482         if (flags & NDR_IN) {
 483                 ZERO_STRUCT(r->out);
 484
 485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.authn_proto));
 486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.princ_name_size));
 487         }
 488         if (flags & NDR_OUT) {
 489                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.princ_name));
 490                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.princ_name));
 491                 size_princ_name_0 = ndr_get_array_size(ndr, &r->out.princ_name);
 492                 length_princ_name_0 = ndr_get_array_length(ndr, &r->out.princ_name);
 493                 if (length_princ_name_0 > size_princ_name_0) {
 494                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_princ_name_0, length_princ_name_0);
 495                 }
 496                 NDR_CHECK(ndr_check_string_terminator(ndr, length_princ_name_0, sizeof(uint8_t)));
 497                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.princ_name, length_princ_name_0, sizeof(uint8_t), CH_DOS));
 498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 499                 if (r->out.princ_name) {
 500                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.princ_name, r->in.princ_name_size));
 501                 }
 502         }
 503         return NDR_ERR_SUCCESS;
 504 }
 505
 506 _PUBLIC_ void ndr_print_mgmt_inq_princ_name(struct ndr_print *ndr, const char *name, int flags, const struct mgmt_inq_princ_name *r)
 507 {
 508         ndr_print_struct(ndr, name, "mgmt_inq_princ_name");
 509         if (r == NULL) { ndr_print_null(ndr); return; }
 510         ndr->depth++;
 511         if (flags & NDR_SET_VALUES) {
 512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 513         }
 514         if (flags & NDR_IN) {
 515                 ndr_print_struct(ndr, "in", "mgmt_inq_princ_name");
 516                 ndr->depth++;
 517                 ndr_print_uint32(ndr, "authn_proto", r->in.authn_proto);
 518                 ndr_print_uint32(ndr, "princ_name_size", r->in.princ_name_size);
 519                 ndr->depth--;
 520         }
 521         if (flags & NDR_OUT) {
 522                 ndr_print_struct(ndr, "out", "mgmt_inq_princ_name");
 523                 ndr->depth++;
 524                 ndr_print_string(ndr, "princ_name", r->out.princ_name);
 525                 ndr_print_WERROR(ndr, "result", r->out.result);
 526                 ndr->depth--;
 527         }
 528         ndr->depth--;
 529 }
 530
 531 static const struct ndr_interface_call mgmt_calls[] = {
 532         {
 533                 "mgmt_inq_if_ids",
 534                 sizeof(struct mgmt_inq_if_ids),
 535                 (ndr_push_flags_fn_t) ndr_push_mgmt_inq_if_ids,
 536                 (ndr_pull_flags_fn_t) ndr_pull_mgmt_inq_if_ids,
 537                 (ndr_print_function_t) ndr_print_mgmt_inq_if_ids,
 538                 { 0, NULL },
 539                 { 0, NULL },
 540         },
 541         {
 542                 "mgmt_inq_stats",
 543                 sizeof(struct mgmt_inq_stats),
 544                 (ndr_push_flags_fn_t) ndr_push_mgmt_inq_stats,
 545                 (ndr_pull_flags_fn_t) ndr_pull_mgmt_inq_stats,
 546                 (ndr_print_function_t) ndr_print_mgmt_inq_stats,
 547                 { 0, NULL },
 548                 { 0, NULL },
 549         },
 550         {
 551                 "mgmt_is_server_listening",
 552                 sizeof(struct mgmt_is_server_listening),
 553                 (ndr_push_flags_fn_t) ndr_push_mgmt_is_server_listening,
 554                 (ndr_pull_flags_fn_t) ndr_pull_mgmt_is_server_listening,
 555                 (ndr_print_function_t) ndr_print_mgmt_is_server_listening,
 556                 { 0, NULL },
 557                 { 0, NULL },
 558         },
 559         {
 560                 "mgmt_stop_server_listening",
 561                 sizeof(struct mgmt_stop_server_listening),
 562                 (ndr_push_flags_fn_t) ndr_push_mgmt_stop_server_listening,
 563                 (ndr_pull_flags_fn_t) ndr_pull_mgmt_stop_server_listening,
 564                 (ndr_print_function_t) ndr_print_mgmt_stop_server_listening,
 565                 { 0, NULL },
 566                 { 0, NULL },
 567         },
 568         {
 569                 "mgmt_inq_princ_name",
 570                 sizeof(struct mgmt_inq_princ_name),
 571                 (ndr_push_flags_fn_t) ndr_push_mgmt_inq_princ_name,
 572                 (ndr_pull_flags_fn_t) ndr_pull_mgmt_inq_princ_name,
 573                 (ndr_print_function_t) ndr_print_mgmt_inq_princ_name,
 574                 { 0, NULL },
 575                 { 0, NULL },
 576         },
 577         { NULL, 0, NULL, NULL, NULL }
 578 };
 579
 580 static const char * const mgmt_endpoint_strings[] = {
 581         "ncacn_np:[\\pipe\\mgmt]",
 582 };
 583
 584 static const struct ndr_interface_string_array mgmt_endpoints = {
 585         .count  = 1,
 586         .names  = mgmt_endpoint_strings
 587 };
 588
 589 static const char * const mgmt_authservice_strings[] = {
 590         "host",
 591 };
 592
 593 static const struct ndr_interface_string_array mgmt_authservices = {
 594         .count  = 1,
 595         .names  = mgmt_authservice_strings
 596 };
 597
 598
 599 const struct ndr_interface_table ndr_table_mgmt = {
 600         .name           = "mgmt",
 601         .syntax_id      = {
 602                 {0xafa8bd80,0x7d8a,0x11c9,{0xbe,0xf4},{0x08,0x00,0x2b,0x10,0x29,0x89}},
 603                 NDR_MGMT_VERSION
 604         },
 605         .helpstring     = NDR_MGMT_HELPSTRING,
 606         .num_calls      = 5,
 607         .calls          = mgmt_calls,
 608         .endpoints      = &mgmt_endpoints,
 609         .authservices   = &mgmt_authservices
 610 };
 611