bin.gen_ndr/default/librpc/gen_ndr/ndr_echo.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_echo.h"
   5
   6 _PUBLIC_ enum ndr_err_code ndr_push_echo_info1(struct ndr_push *ndr, int ndr_flags, const struct echo_info1 *r)
   7 {
   8         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 1));
  11                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v));
  12                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
  13         }
  14         if (ndr_flags & NDR_BUFFERS) {
  15         }
  16         return NDR_ERR_SUCCESS;
  17 }
  18
  19 _PUBLIC_ enum ndr_err_code ndr_pull_echo_info1(struct ndr_pull *ndr, int ndr_flags, struct echo_info1 *r)
  20 {
  21         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  22         if (ndr_flags & NDR_SCALARS) {
  23                 NDR_CHECK(ndr_pull_align(ndr, 1));
  24                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v));
  25                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
  26         }
  27         if (ndr_flags & NDR_BUFFERS) {
  28         }
  29         return NDR_ERR_SUCCESS;
  30 }
  31
  32 _PUBLIC_ void ndr_print_echo_info1(struct ndr_print *ndr, const char *name, const struct echo_info1 *r)
  33 {
  34         ndr_print_struct(ndr, name, "echo_info1");
  35         if (r == NULL) { ndr_print_null(ndr); return; }
  36         ndr->depth++;
  37         ndr_print_uint8(ndr, "v", r->v);
  38         ndr->depth--;
  39 }
  40
  41 static enum ndr_err_code ndr_push_echo_info2(struct ndr_push *ndr, int ndr_flags, const struct echo_info2 *r)
  42 {
  43         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  44         if (ndr_flags & NDR_SCALARS) {
  45                 NDR_CHECK(ndr_push_align(ndr, 2));
  46                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->v));
  47                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  48         }
  49         if (ndr_flags & NDR_BUFFERS) {
  50         }
  51         return NDR_ERR_SUCCESS;
  52 }
  53
  54 static enum ndr_err_code ndr_pull_echo_info2(struct ndr_pull *ndr, int ndr_flags, struct echo_info2 *r)
  55 {
  56         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  57         if (ndr_flags & NDR_SCALARS) {
  58                 NDR_CHECK(ndr_pull_align(ndr, 2));
  59                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->v));
  60                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  61         }
  62         if (ndr_flags & NDR_BUFFERS) {
  63         }
  64         return NDR_ERR_SUCCESS;
  65 }
  66
  67 _PUBLIC_ void ndr_print_echo_info2(struct ndr_print *ndr, const char *name, const struct echo_info2 *r)
  68 {
  69         ndr_print_struct(ndr, name, "echo_info2");
  70         if (r == NULL) { ndr_print_null(ndr); return; }
  71         ndr->depth++;
  72         ndr_print_uint16(ndr, "v", r->v);
  73         ndr->depth--;
  74 }
  75
  76 static enum ndr_err_code ndr_push_echo_info3(struct ndr_push *ndr, int ndr_flags, const struct echo_info3 *r)
  77 {
  78         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  79         if (ndr_flags & NDR_SCALARS) {
  80                 NDR_CHECK(ndr_push_align(ndr, 4));
  81                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->v));
  82                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  83         }
  84         if (ndr_flags & NDR_BUFFERS) {
  85         }
  86         return NDR_ERR_SUCCESS;
  87 }
  88
  89 static enum ndr_err_code ndr_pull_echo_info3(struct ndr_pull *ndr, int ndr_flags, struct echo_info3 *r)
  90 {
  91         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  92         if (ndr_flags & NDR_SCALARS) {
  93                 NDR_CHECK(ndr_pull_align(ndr, 4));
  94                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->v));
  95                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  96         }
  97         if (ndr_flags & NDR_BUFFERS) {
  98         }
  99         return NDR_ERR_SUCCESS;
 100 }
 101
 102 _PUBLIC_ void ndr_print_echo_info3(struct ndr_print *ndr, const char *name, const struct echo_info3 *r)
 103 {
 104         ndr_print_struct(ndr, name, "echo_info3");
 105         if (r == NULL) { ndr_print_null(ndr); return; }
 106         ndr->depth++;
 107         ndr_print_uint32(ndr, "v", r->v);
 108         ndr->depth--;
 109 }
 110
 111 static enum ndr_err_code ndr_push_STRUCT_echo_info4(struct ndr_push *ndr, int ndr_flags, const struct echo_info4 *r)
 112 {
 113         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 114         if (ndr_flags & NDR_SCALARS) {
 115                 NDR_CHECK(ndr_push_align(ndr, 8));
 116                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->v));
 117                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 118         }
 119         if (ndr_flags & NDR_BUFFERS) {
 120         }
 121         return NDR_ERR_SUCCESS;
 122 }
 123
 124 static enum ndr_err_code ndr_pull_STRUCT_echo_info4(struct ndr_pull *ndr, int ndr_flags, struct echo_info4 *r)
 125 {
 126         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 127         if (ndr_flags & NDR_SCALARS) {
 128                 NDR_CHECK(ndr_pull_align(ndr, 8));
 129                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->v));
 130                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 131         }
 132         if (ndr_flags & NDR_BUFFERS) {
 133         }
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_STRUCT_echo_info4(struct ndr_print *ndr, const char *name, const struct echo_info4 *r)
 138 {
 139         ndr_print_struct(ndr, name, "echo_info4");
 140         if (r == NULL) { ndr_print_null(ndr); return; }
 141         ndr->depth++;
 142         ndr_print_hyper(ndr, "v", r->v);
 143         ndr->depth--;
 144 }
 145
 146 static enum ndr_err_code ndr_push_echo_info5(struct ndr_push *ndr, int ndr_flags, const struct echo_info5 *r)
 147 {
 148         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 149         if (ndr_flags & NDR_SCALARS) {
 150                 NDR_CHECK(ndr_push_align(ndr, 8));
 151                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
 152                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->v2));
 153                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 154         }
 155         if (ndr_flags & NDR_BUFFERS) {
 156         }
 157         return NDR_ERR_SUCCESS;
 158 }
 159
 160 static enum ndr_err_code ndr_pull_echo_info5(struct ndr_pull *ndr, int ndr_flags, struct echo_info5 *r)
 161 {
 162         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 163         if (ndr_flags & NDR_SCALARS) {
 164                 NDR_CHECK(ndr_pull_align(ndr, 8));
 165                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
 166                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->v2));
 167                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 168         }
 169         if (ndr_flags & NDR_BUFFERS) {
 170         }
 171         return NDR_ERR_SUCCESS;
 172 }
 173
 174 _PUBLIC_ void ndr_print_echo_info5(struct ndr_print *ndr, const char *name, const struct echo_info5 *r)
 175 {
 176         ndr_print_struct(ndr, name, "echo_info5");
 177         if (r == NULL) { ndr_print_null(ndr); return; }
 178         ndr->depth++;
 179         ndr_print_uint8(ndr, "v1", r->v1);
 180         ndr_print_hyper(ndr, "v2", r->v2);
 181         ndr->depth--;
 182 }
 183
 184 static enum ndr_err_code ndr_push_echo_info6(struct ndr_push *ndr, int ndr_flags, const struct echo_info6 *r)
 185 {
 186         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 187         if (ndr_flags & NDR_SCALARS) {
 188                 NDR_CHECK(ndr_push_align(ndr, 1));
 189                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
 190                 NDR_CHECK(ndr_push_echo_info1(ndr, NDR_SCALARS, &r->info1));
 191                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 192         }
 193         if (ndr_flags & NDR_BUFFERS) {
 194         }
 195         return NDR_ERR_SUCCESS;
 196 }
 197
 198 static enum ndr_err_code ndr_pull_echo_info6(struct ndr_pull *ndr, int ndr_flags, struct echo_info6 *r)
 199 {
 200         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 201         if (ndr_flags & NDR_SCALARS) {
 202                 NDR_CHECK(ndr_pull_align(ndr, 1));
 203                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
 204                 NDR_CHECK(ndr_pull_echo_info1(ndr, NDR_SCALARS, &r->info1));
 205                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 206         }
 207         if (ndr_flags & NDR_BUFFERS) {
 208         }
 209         return NDR_ERR_SUCCESS;
 210 }
 211
 212 _PUBLIC_ void ndr_print_echo_info6(struct ndr_print *ndr, const char *name, const struct echo_info6 *r)
 213 {
 214         ndr_print_struct(ndr, name, "echo_info6");
 215         if (r == NULL) { ndr_print_null(ndr); return; }
 216         ndr->depth++;
 217         ndr_print_uint8(ndr, "v1", r->v1);
 218         ndr_print_echo_info1(ndr, "info1", &r->info1);
 219         ndr->depth--;
 220 }
 221
 222 static enum ndr_err_code ndr_push_echo_info7(struct ndr_push *ndr, int ndr_flags, const struct echo_info7 *r)
 223 {
 224         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 225         if (ndr_flags & NDR_SCALARS) {
 226                 NDR_CHECK(ndr_push_align(ndr, 8));
 227                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->v1));
 228                 NDR_CHECK(ndr_push_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
 229                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 230         }
 231         if (ndr_flags & NDR_BUFFERS) {
 232         }
 233         return NDR_ERR_SUCCESS;
 234 }
 235
 236 static enum ndr_err_code ndr_pull_echo_info7(struct ndr_pull *ndr, int ndr_flags, struct echo_info7 *r)
 237 {
 238         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 239         if (ndr_flags & NDR_SCALARS) {
 240                 NDR_CHECK(ndr_pull_align(ndr, 8));
 241                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->v1));
 242                 NDR_CHECK(ndr_pull_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
 243                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 244         }
 245         if (ndr_flags & NDR_BUFFERS) {
 246         }
 247         return NDR_ERR_SUCCESS;
 248 }
 249
 250 _PUBLIC_ void ndr_print_echo_info7(struct ndr_print *ndr, const char *name, const struct echo_info7 *r)
 251 {
 252         ndr_print_struct(ndr, name, "echo_info7");
 253         if (r == NULL) { ndr_print_null(ndr); return; }
 254         ndr->depth++;
 255         ndr_print_uint8(ndr, "v1", r->v1);
 256         ndr_print_STRUCT_echo_info4(ndr, "info4", &r->info4);
 257         ndr->depth--;
 258 }
 259
 260 static enum ndr_err_code ndr_push_echo_Info(struct ndr_push *ndr, int ndr_flags, const union echo_Info *r)
 261 {
 262         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 263         if (ndr_flags & NDR_SCALARS) {
 264                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 265                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 266                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 267                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 268                 switch (level) {
 269                         case 1: {
 270                                 NDR_CHECK(ndr_push_echo_info1(ndr, NDR_SCALARS, &r->info1));
 271                         break; }
 272
 273                         case 2: {
 274                                 NDR_CHECK(ndr_push_echo_info2(ndr, NDR_SCALARS, &r->info2));
 275                         break; }
 276
 277                         case 3: {
 278                                 NDR_CHECK(ndr_push_echo_info3(ndr, NDR_SCALARS, &r->info3));
 279                         break; }
 280
 281                         case 4: {
 282                                 NDR_CHECK(ndr_push_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
 283                         break; }
 284
 285                         case 5: {
 286                                 NDR_CHECK(ndr_push_echo_info5(ndr, NDR_SCALARS, &r->info5));
 287                         break; }
 288
 289                         case 6: {
 290                                 NDR_CHECK(ndr_push_echo_info6(ndr, NDR_SCALARS, &r->info6));
 291                         break; }
 292
 293                         case 7: {
 294                                 NDR_CHECK(ndr_push_echo_info7(ndr, NDR_SCALARS, &r->info7));
 295                         break; }
 296
 297                         default:
 298                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 299                 }
 300         }
 301         if (ndr_flags & NDR_BUFFERS) {
 302                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 303                 switch (level) {
 304                         case 1:
 305                         break;
 306
 307                         case 2:
 308                         break;
 309
 310                         case 3:
 311                         break;
 312
 313                         case 4:
 314                         break;
 315
 316                         case 5:
 317                         break;
 318
 319                         case 6:
 320                         break;
 321
 322                         case 7:
 323                         break;
 324
 325                         default:
 326                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 327                 }
 328         }
 329         return NDR_ERR_SUCCESS;
 330 }
 331
 332 static enum ndr_err_code ndr_pull_echo_Info(struct ndr_pull *ndr, int ndr_flags, union echo_Info *r)
 333 {
 334         uint32_t level;
 335         uint16_t _level;
 336         level = ndr_pull_get_switch_value(ndr, r);
 337         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 338         if (ndr_flags & NDR_SCALARS) {
 339                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 340                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 341                 if (_level != level) {
 342                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 343                 }
 344                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 345                 switch (level) {
 346                         case 1: {
 347                                 NDR_CHECK(ndr_pull_echo_info1(ndr, NDR_SCALARS, &r->info1));
 348                         break; }
 349
 350                         case 2: {
 351                                 NDR_CHECK(ndr_pull_echo_info2(ndr, NDR_SCALARS, &r->info2));
 352                         break; }
 353
 354                         case 3: {
 355                                 NDR_CHECK(ndr_pull_echo_info3(ndr, NDR_SCALARS, &r->info3));
 356                         break; }
 357
 358                         case 4: {
 359                                 NDR_CHECK(ndr_pull_STRUCT_echo_info4(ndr, NDR_SCALARS, &r->info4));
 360                         break; }
 361
 362                         case 5: {
 363                                 NDR_CHECK(ndr_pull_echo_info5(ndr, NDR_SCALARS, &r->info5));
 364                         break; }
 365
 366                         case 6: {
 367                                 NDR_CHECK(ndr_pull_echo_info6(ndr, NDR_SCALARS, &r->info6));
 368                         break; }
 369
 370                         case 7: {
 371                                 NDR_CHECK(ndr_pull_echo_info7(ndr, NDR_SCALARS, &r->info7));
 372                         break; }
 373
 374                         default:
 375                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 376                 }
 377         }
 378         if (ndr_flags & NDR_BUFFERS) {
 379                 switch (level) {
 380                         case 1:
 381                         break;
 382
 383                         case 2:
 384                         break;
 385
 386                         case 3:
 387                         break;
 388
 389                         case 4:
 390                         break;
 391
 392                         case 5:
 393                         break;
 394
 395                         case 6:
 396                         break;
 397
 398                         case 7:
 399                         break;
 400
 401                         default:
 402                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 403                 }
 404         }
 405         return NDR_ERR_SUCCESS;
 406 }
 407
 408 _PUBLIC_ void ndr_print_echo_Info(struct ndr_print *ndr, const char *name, const union echo_Info *r)
 409 {
 410         uint32_t level;
 411         level = ndr_print_get_switch_value(ndr, r);
 412         ndr_print_union(ndr, name, level, "echo_Info");
 413         switch (level) {
 414                 case 1:
 415                         ndr_print_echo_info1(ndr, "info1", &r->info1);
 416                 break;
 417
 418                 case 2:
 419                         ndr_print_echo_info2(ndr, "info2", &r->info2);
 420                 break;
 421
 422                 case 3:
 423                         ndr_print_echo_info3(ndr, "info3", &r->info3);
 424                 break;
 425
 426                 case 4:
 427                         ndr_print_STRUCT_echo_info4(ndr, "info4", &r->info4);
 428                 break;
 429
 430                 case 5:
 431                         ndr_print_echo_info5(ndr, "info5", &r->info5);
 432                 break;
 433
 434                 case 6:
 435                         ndr_print_echo_info6(ndr, "info6", &r->info6);
 436                 break;
 437
 438                 case 7:
 439                         ndr_print_echo_info7(ndr, "info7", &r->info7);
 440                 break;
 441
 442                 default:
 443                         ndr_print_bad_level(ndr, name, level);
 444         }
 445 }
 446
 447 static enum ndr_err_code ndr_push_echo_Enum1(struct ndr_push *ndr, int ndr_flags, enum echo_Enum1 r)
 448 {
 449         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 450         return NDR_ERR_SUCCESS;
 451 }
 452
 453 static enum ndr_err_code ndr_pull_echo_Enum1(struct ndr_pull *ndr, int ndr_flags, enum echo_Enum1 *r)
 454 {
 455         uint16_t v;
 456         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 457         *r = v;
 458         return NDR_ERR_SUCCESS;
 459 }
 460
 461 _PUBLIC_ void ndr_print_echo_Enum1(struct ndr_print *ndr, const char *name, enum echo_Enum1 r)
 462 {
 463         const char *val = NULL;
 464
 465         switch (r) {
 466                 case ECHO_ENUM1: val = "ECHO_ENUM1"; break;
 467                 case ECHO_ENUM2: val = "ECHO_ENUM2"; break;
 468         }
 469         ndr_print_enum(ndr, name, "ENUM", val, r);
 470 }
 471
 472 static enum ndr_err_code ndr_push_echo_Enum1_32(struct ndr_push *ndr, int ndr_flags, enum echo_Enum1_32 r)
 473 {
 474         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 475         return NDR_ERR_SUCCESS;
 476 }
 477
 478 static enum ndr_err_code ndr_pull_echo_Enum1_32(struct ndr_pull *ndr, int ndr_flags, enum echo_Enum1_32 *r)
 479 {
 480         uint32_t v;
 481         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 482         *r = v;
 483         return NDR_ERR_SUCCESS;
 484 }
 485
 486 _PUBLIC_ void ndr_print_echo_Enum1_32(struct ndr_print *ndr, const char *name, enum echo_Enum1_32 r)
 487 {
 488         const char *val = NULL;
 489
 490         switch (r) {
 491                 case ECHO_ENUM1_32: val = "ECHO_ENUM1_32"; break;
 492                 case ECHO_ENUM2_32: val = "ECHO_ENUM2_32"; break;
 493         }
 494         ndr_print_enum(ndr, name, "ENUM", val, r);
 495 }
 496
 497 static enum ndr_err_code ndr_push_echo_Enum2(struct ndr_push *ndr, int ndr_flags, const struct echo_Enum2 *r)
 498 {
 499         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 500         if (ndr_flags & NDR_SCALARS) {
 501                 NDR_CHECK(ndr_push_align(ndr, 4));
 502                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, r->e1));
 503                 NDR_CHECK(ndr_push_echo_Enum1_32(ndr, NDR_SCALARS, r->e2));
 504                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 505         }
 506         if (ndr_flags & NDR_BUFFERS) {
 507         }
 508         return NDR_ERR_SUCCESS;
 509 }
 510
 511 static enum ndr_err_code ndr_pull_echo_Enum2(struct ndr_pull *ndr, int ndr_flags, struct echo_Enum2 *r)
 512 {
 513         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 514         if (ndr_flags & NDR_SCALARS) {
 515                 NDR_CHECK(ndr_pull_align(ndr, 4));
 516                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, &r->e1));
 517                 NDR_CHECK(ndr_pull_echo_Enum1_32(ndr, NDR_SCALARS, &r->e2));
 518                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 519         }
 520         if (ndr_flags & NDR_BUFFERS) {
 521         }
 522         return NDR_ERR_SUCCESS;
 523 }
 524
 525 _PUBLIC_ void ndr_print_echo_Enum2(struct ndr_print *ndr, const char *name, const struct echo_Enum2 *r)
 526 {
 527         ndr_print_struct(ndr, name, "echo_Enum2");
 528         if (r == NULL) { ndr_print_null(ndr); return; }
 529         ndr->depth++;
 530         ndr_print_echo_Enum1(ndr, "e1", r->e1);
 531         ndr_print_echo_Enum1_32(ndr, "e2", r->e2);
 532         ndr->depth--;
 533 }
 534
 535 static enum ndr_err_code ndr_push_echo_Enum3(struct ndr_push *ndr, int ndr_flags, const union echo_Enum3 *r)
 536 {
 537         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 538         if (ndr_flags & NDR_SCALARS) {
 539                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 540                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 541                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 542                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 543                 switch (level) {
 544                         case ECHO_ENUM1: {
 545                                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, r->e1));
 546                         break; }
 547
 548                         case ECHO_ENUM2: {
 549                                 NDR_CHECK(ndr_push_echo_Enum2(ndr, NDR_SCALARS, &r->e2));
 550                         break; }
 551
 552                         default:
 553                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 554                 }
 555         }
 556         if (ndr_flags & NDR_BUFFERS) {
 557                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 558                 switch (level) {
 559                         case ECHO_ENUM1:
 560                         break;
 561
 562                         case ECHO_ENUM2:
 563                         break;
 564
 565                         default:
 566                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 567                 }
 568         }
 569         return NDR_ERR_SUCCESS;
 570 }
 571
 572 static enum ndr_err_code ndr_pull_echo_Enum3(struct ndr_pull *ndr, int ndr_flags, union echo_Enum3 *r)
 573 {
 574         uint32_t level;
 575         uint16_t _level;
 576         level = ndr_pull_get_switch_value(ndr, r);
 577         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 578         if (ndr_flags & NDR_SCALARS) {
 579                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 580                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 581                 if (_level != level) {
 582                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 583                 }
 584                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 585                 switch (level) {
 586                         case ECHO_ENUM1: {
 587                                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, &r->e1));
 588                         break; }
 589
 590                         case ECHO_ENUM2: {
 591                                 NDR_CHECK(ndr_pull_echo_Enum2(ndr, NDR_SCALARS, &r->e2));
 592                         break; }
 593
 594                         default:
 595                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 596                 }
 597         }
 598         if (ndr_flags & NDR_BUFFERS) {
 599                 switch (level) {
 600                         case ECHO_ENUM1:
 601                         break;
 602
 603                         case ECHO_ENUM2:
 604                         break;
 605
 606                         default:
 607                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 608                 }
 609         }
 610         return NDR_ERR_SUCCESS;
 611 }
 612
 613 _PUBLIC_ void ndr_print_echo_Enum3(struct ndr_print *ndr, const char *name, const union echo_Enum3 *r)
 614 {
 615         uint32_t level;
 616         level = ndr_print_get_switch_value(ndr, r);
 617         ndr_print_union(ndr, name, level, "echo_Enum3");
 618         switch (level) {
 619                 case ECHO_ENUM1:
 620                         ndr_print_echo_Enum1(ndr, "e1", r->e1);
 621                 break;
 622
 623                 case ECHO_ENUM2:
 624                         ndr_print_echo_Enum2(ndr, "e2", &r->e2);
 625                 break;
 626
 627                 default:
 628                         ndr_print_bad_level(ndr, name, level);
 629         }
 630 }
 631
 632 static enum ndr_err_code ndr_push_echo_Surrounding(struct ndr_push *ndr, int ndr_flags, const struct echo_Surrounding *r)
 633 {
 634         uint32_t cntr_surrounding_0;
 635         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 636         if (ndr_flags & NDR_SCALARS) {
 637                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->x));
 638                 NDR_CHECK(ndr_push_align(ndr, 4));
 639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->x));
 640                 for (cntr_surrounding_0 = 0; cntr_surrounding_0 < r->x; cntr_surrounding_0++) {
 641                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->surrounding[cntr_surrounding_0]));
 642                 }
 643                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 644         }
 645         if (ndr_flags & NDR_BUFFERS) {
 646         }
 647         return NDR_ERR_SUCCESS;
 648 }
 649
 650 static enum ndr_err_code ndr_pull_echo_Surrounding(struct ndr_pull *ndr, int ndr_flags, struct echo_Surrounding *r)
 651 {
 652         uint32_t size_surrounding_0 = 0;
 653         uint32_t cntr_surrounding_0;
 654         TALLOC_CTX *_mem_save_surrounding_0;
 655         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 656         if (ndr_flags & NDR_SCALARS) {
 657                 NDR_CHECK(ndr_pull_array_size(ndr, &r->surrounding));
 658                 NDR_CHECK(ndr_pull_align(ndr, 4));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->x));
 660                 size_surrounding_0 = ndr_get_array_size(ndr, &r->surrounding);
 661                 NDR_PULL_ALLOC_N(ndr, r->surrounding, size_surrounding_0);
 662                 _mem_save_surrounding_0 = NDR_PULL_GET_MEM_CTX(ndr);
 663                 NDR_PULL_SET_MEM_CTX(ndr, r->surrounding, 0);
 664                 for (cntr_surrounding_0 = 0; cntr_surrounding_0 < size_surrounding_0; cntr_surrounding_0++) {
 665                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->surrounding[cntr_surrounding_0]));
 666                 }
 667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_surrounding_0, 0);
 668                 if (r->surrounding) {
 669                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->surrounding, r->x));
 670                 }
 671                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 672         }
 673         if (ndr_flags & NDR_BUFFERS) {
 674         }
 675         return NDR_ERR_SUCCESS;
 676 }
 677
 678 _PUBLIC_ void ndr_print_echo_Surrounding(struct ndr_print *ndr, const char *name, const struct echo_Surrounding *r)
 679 {
 680         uint32_t cntr_surrounding_0;
 681         ndr_print_struct(ndr, name, "echo_Surrounding");
 682         if (r == NULL) { ndr_print_null(ndr); return; }
 683         ndr->depth++;
 684         ndr_print_uint32(ndr, "x", r->x);
 685         ndr->print(ndr, "%s: ARRAY(%d)", "surrounding", (int)r->x);
 686         ndr->depth++;
 687         for (cntr_surrounding_0=0;cntr_surrounding_0<r->x;cntr_surrounding_0++) {
 688                 ndr_print_uint16(ndr, "surrounding", r->surrounding[cntr_surrounding_0]);
 689         }
 690         ndr->depth--;
 691         ndr->depth--;
 692 }
 693
 694 static enum ndr_err_code ndr_push_echo_AddOne(struct ndr_push *ndr, int flags, const struct echo_AddOne *r)
 695 {
 696         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 697         if (flags & NDR_IN) {
 698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data));
 699         }
 700         if (flags & NDR_OUT) {
 701                 if (r->out.out_data == NULL) {
 702                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 703                 }
 704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.out_data));
 705         }
 706         return NDR_ERR_SUCCESS;
 707 }
 708
 709 static enum ndr_err_code ndr_pull_echo_AddOne(struct ndr_pull *ndr, int flags, struct echo_AddOne *r)
 710 {
 711         TALLOC_CTX *_mem_save_out_data_0;
 712         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 713         if (flags & NDR_IN) {
 714                 ZERO_STRUCT(r->out);
 715
 716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.in_data));
 717                 NDR_PULL_ALLOC(ndr, r->out.out_data);
 718                 ZERO_STRUCTP(r->out.out_data);
 719         }
 720         if (flags & NDR_OUT) {
 721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 722                         NDR_PULL_ALLOC(ndr, r->out.out_data);
 723                 }
 724                 _mem_save_out_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 725                 NDR_PULL_SET_MEM_CTX(ndr, r->out.out_data, LIBNDR_FLAG_REF_ALLOC);
 726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.out_data));
 727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_out_data_0, LIBNDR_FLAG_REF_ALLOC);
 728         }
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ void ndr_print_echo_AddOne(struct ndr_print *ndr, const char *name, int flags, const struct echo_AddOne *r)
 733 {
 734         ndr_print_struct(ndr, name, "echo_AddOne");
 735         if (r == NULL) { ndr_print_null(ndr); return; }
 736         ndr->depth++;
 737         if (flags & NDR_SET_VALUES) {
 738                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 739         }
 740         if (flags & NDR_IN) {
 741                 ndr_print_struct(ndr, "in", "echo_AddOne");
 742                 ndr->depth++;
 743                 ndr_print_uint32(ndr, "in_data", r->in.in_data);
 744                 ndr->depth--;
 745         }
 746         if (flags & NDR_OUT) {
 747                 ndr_print_struct(ndr, "out", "echo_AddOne");
 748                 ndr->depth++;
 749                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
 750                 ndr->depth++;
 751                 ndr_print_uint32(ndr, "out_data", *r->out.out_data);
 752                 ndr->depth--;
 753                 ndr->depth--;
 754         }
 755         ndr->depth--;
 756 }
 757
 758 static enum ndr_err_code ndr_push_echo_EchoData(struct ndr_push *ndr, int flags, const struct echo_EchoData *r)
 759 {
 760         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 761         if (flags & NDR_IN) {
 762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 763                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 764                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.in_data, r->in.len));
 765         }
 766         if (flags & NDR_OUT) {
 767                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 768                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.len));
 769         }
 770         return NDR_ERR_SUCCESS;
 771 }
 772
 773 static enum ndr_err_code ndr_pull_echo_EchoData(struct ndr_pull *ndr, int flags, struct echo_EchoData *r)
 774 {
 775         uint32_t size_in_data_0 = 0;
 776         uint32_t size_out_data_0 = 0;
 777         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 778         if (flags & NDR_IN) {
 779                 ZERO_STRUCT(r->out);
 780
 781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 782                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.in_data));
 783                 size_in_data_0 = ndr_get_array_size(ndr, &r->in.in_data);
 784                 NDR_PULL_ALLOC_N(ndr, r->in.in_data, size_in_data_0);
 785                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.in_data, size_in_data_0));
 786                 if (r->in.in_data) {
 787                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.in_data, r->in.len));
 788                 }
 789         }
 790         if (flags & NDR_OUT) {
 791                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
 792                 size_out_data_0 = ndr_get_array_size(ndr, &r->out.out_data);
 793                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, size_out_data_0);
 794                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, size_out_data_0));
 795                 if (r->out.out_data) {
 796                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.len));
 797                 }
 798         }
 799         return NDR_ERR_SUCCESS;
 800 }
 801
 802 _PUBLIC_ void ndr_print_echo_EchoData(struct ndr_print *ndr, const char *name, int flags, const struct echo_EchoData *r)
 803 {
 804         ndr_print_struct(ndr, name, "echo_EchoData");
 805         if (r == NULL) { ndr_print_null(ndr); return; }
 806         ndr->depth++;
 807         if (flags & NDR_SET_VALUES) {
 808                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 809         }
 810         if (flags & NDR_IN) {
 811                 ndr_print_struct(ndr, "in", "echo_EchoData");
 812                 ndr->depth++;
 813                 ndr_print_uint32(ndr, "len", r->in.len);
 814                 ndr_print_array_uint8(ndr, "in_data", r->in.in_data, r->in.len);
 815                 ndr->depth--;
 816         }
 817         if (flags & NDR_OUT) {
 818                 ndr_print_struct(ndr, "out", "echo_EchoData");
 819                 ndr->depth++;
 820                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.len);
 821                 ndr->depth--;
 822         }
 823         ndr->depth--;
 824 }
 825
 826 static enum ndr_err_code ndr_push_echo_SinkData(struct ndr_push *ndr, int flags, const struct echo_SinkData *r)
 827 {
 828         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 829         if (flags & NDR_IN) {
 830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 831                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 832                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.len));
 833         }
 834         if (flags & NDR_OUT) {
 835         }
 836         return NDR_ERR_SUCCESS;
 837 }
 838
 839 static enum ndr_err_code ndr_pull_echo_SinkData(struct ndr_pull *ndr, int flags, struct echo_SinkData *r)
 840 {
 841         uint32_t size_data_0 = 0;
 842         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 843         if (flags & NDR_IN) {
 844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 845                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
 846                 size_data_0 = ndr_get_array_size(ndr, &r->in.data);
 847                 NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_0);
 848                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, size_data_0));
 849                 if (r->in.data) {
 850                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.len));
 851                 }
 852         }
 853         if (flags & NDR_OUT) {
 854         }
 855         return NDR_ERR_SUCCESS;
 856 }
 857
 858 _PUBLIC_ void ndr_print_echo_SinkData(struct ndr_print *ndr, const char *name, int flags, const struct echo_SinkData *r)
 859 {
 860         ndr_print_struct(ndr, name, "echo_SinkData");
 861         if (r == NULL) { ndr_print_null(ndr); return; }
 862         ndr->depth++;
 863         if (flags & NDR_SET_VALUES) {
 864                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 865         }
 866         if (flags & NDR_IN) {
 867                 ndr_print_struct(ndr, "in", "echo_SinkData");
 868                 ndr->depth++;
 869                 ndr_print_uint32(ndr, "len", r->in.len);
 870                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.len);
 871                 ndr->depth--;
 872         }
 873         if (flags & NDR_OUT) {
 874                 ndr_print_struct(ndr, "out", "echo_SinkData");
 875                 ndr->depth++;
 876                 ndr->depth--;
 877         }
 878         ndr->depth--;
 879 }
 880
 881 static enum ndr_err_code ndr_push_echo_SourceData(struct ndr_push *ndr, int flags, const struct echo_SourceData *r)
 882 {
 883         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 884         if (flags & NDR_IN) {
 885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 886         }
 887         if (flags & NDR_OUT) {
 888                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 889                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.len));
 890         }
 891         return NDR_ERR_SUCCESS;
 892 }
 893
 894 static enum ndr_err_code ndr_pull_echo_SourceData(struct ndr_pull *ndr, int flags, struct echo_SourceData *r)
 895 {
 896         uint32_t size_data_0 = 0;
 897         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 898         if (flags & NDR_IN) {
 899                 ZERO_STRUCT(r->out);
 900
 901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 902         }
 903         if (flags & NDR_OUT) {
 904                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
 905                 size_data_0 = ndr_get_array_size(ndr, &r->out.data);
 906                 NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_0);
 907                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_0));
 908                 if (r->out.data) {
 909                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.len));
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_echo_SourceData(struct ndr_print *ndr, const char *name, int flags, const struct echo_SourceData *r)
 916 {
 917         ndr_print_struct(ndr, name, "echo_SourceData");
 918         if (r == NULL) { ndr_print_null(ndr); return; }
 919         ndr->depth++;
 920         if (flags & NDR_SET_VALUES) {
 921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 922         }
 923         if (flags & NDR_IN) {
 924                 ndr_print_struct(ndr, "in", "echo_SourceData");
 925                 ndr->depth++;
 926                 ndr_print_uint32(ndr, "len", r->in.len);
 927                 ndr->depth--;
 928         }
 929         if (flags & NDR_OUT) {
 930                 ndr_print_struct(ndr, "out", "echo_SourceData");
 931                 ndr->depth++;
 932                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.len);
 933                 ndr->depth--;
 934         }
 935         ndr->depth--;
 936 }
 937
 938 static enum ndr_err_code ndr_push_echo_TestCall(struct ndr_push *ndr, int flags, const struct echo_TestCall *r)
 939 {
 940         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 941         if (flags & NDR_IN) {
 942                 if (r->in.s1 == NULL) {
 943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 944                 }
 945                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.s1, CH_UTF16)));
 946                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 947                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.s1, CH_UTF16)));
 948                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.s1, ndr_charset_length(r->in.s1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 949         }
 950         if (flags & NDR_OUT) {
 951                 if (r->out.s2 == NULL) {
 952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 953                 }
 954                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.s2));
 955                 if (*r->out.s2) {
 956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.s2, CH_UTF16)));
 957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.s2, CH_UTF16)));
 959                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.s2, ndr_charset_length(*r->out.s2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 960                 }
 961         }
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 static enum ndr_err_code ndr_pull_echo_TestCall(struct ndr_pull *ndr, int flags, struct echo_TestCall *r)
 966 {
 967         uint32_t size_s1_1 = 0;
 968         uint32_t length_s1_1 = 0;
 969         uint32_t _ptr_s2;
 970         uint32_t size_s2_2 = 0;
 971         uint32_t length_s2_2 = 0;
 972         TALLOC_CTX *_mem_save_s2_0;
 973         TALLOC_CTX *_mem_save_s2_1;
 974         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 975         if (flags & NDR_IN) {
 976                 ZERO_STRUCT(r->out);
 977
 978                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.s1));
 979                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.s1));
 980                 size_s1_1 = ndr_get_array_size(ndr, &r->in.s1);
 981                 length_s1_1 = ndr_get_array_length(ndr, &r->in.s1);
 982                 if (length_s1_1 > size_s1_1) {
 983                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_s1_1, length_s1_1);
 984                 }
 985                 NDR_CHECK(ndr_check_string_terminator(ndr, length_s1_1, sizeof(uint16_t)));
 986                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.s1, length_s1_1, sizeof(uint16_t), CH_UTF16));
 987                 NDR_PULL_ALLOC(ndr, r->out.s2);
 988                 ZERO_STRUCTP(r->out.s2);
 989         }
 990         if (flags & NDR_OUT) {
 991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 992                         NDR_PULL_ALLOC(ndr, r->out.s2);
 993                 }
 994                 _mem_save_s2_0 = NDR_PULL_GET_MEM_CTX(ndr);
 995                 NDR_PULL_SET_MEM_CTX(ndr, r->out.s2, LIBNDR_FLAG_REF_ALLOC);
 996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s2));
 997                 if (_ptr_s2) {
 998                         NDR_PULL_ALLOC(ndr, *r->out.s2);
 999                 } else {
1000                         *r->out.s2 = NULL;
1001                 }
1002                 if (*r->out.s2) {
1003                         _mem_save_s2_1 = NDR_PULL_GET_MEM_CTX(ndr);
1004                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.s2, 0);
1005                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.s2));
1006                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.s2));
1007                         size_s2_2 = ndr_get_array_size(ndr, r->out.s2);
1008                         length_s2_2 = ndr_get_array_length(ndr, r->out.s2);
1009                         if (length_s2_2 > size_s2_2) {
1010                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_s2_2, length_s2_2);
1011                         }
1012                         NDR_CHECK(ndr_check_string_terminator(ndr, length_s2_2, sizeof(uint16_t)));
1013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.s2, length_s2_2, sizeof(uint16_t), CH_UTF16));
1014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s2_1, 0);
1015                 }
1016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s2_0, LIBNDR_FLAG_REF_ALLOC);
1017         }
1018         return NDR_ERR_SUCCESS;
1019 }
1020
1021 _PUBLIC_ void ndr_print_echo_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestCall *r)
1022 {
1023         ndr_print_struct(ndr, name, "echo_TestCall");
1024         if (r == NULL) { ndr_print_null(ndr); return; }
1025         ndr->depth++;
1026         if (flags & NDR_SET_VALUES) {
1027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1028         }
1029         if (flags & NDR_IN) {
1030                 ndr_print_struct(ndr, "in", "echo_TestCall");
1031                 ndr->depth++;
1032                 ndr_print_ptr(ndr, "s1", r->in.s1);
1033                 ndr->depth++;
1034                 ndr_print_string(ndr, "s1", r->in.s1);
1035                 ndr->depth--;
1036                 ndr->depth--;
1037         }
1038         if (flags & NDR_OUT) {
1039                 ndr_print_struct(ndr, "out", "echo_TestCall");
1040                 ndr->depth++;
1041                 ndr_print_ptr(ndr, "s2", r->out.s2);
1042                 ndr->depth++;
1043                 ndr_print_ptr(ndr, "s2", *r->out.s2);
1044                 ndr->depth++;
1045                 if (*r->out.s2) {
1046                         ndr_print_string(ndr, "s2", *r->out.s2);
1047                 }
1048                 ndr->depth--;
1049                 ndr->depth--;
1050                 ndr->depth--;
1051         }
1052         ndr->depth--;
1053 }
1054
1055 static enum ndr_err_code ndr_push_echo_TestCall2(struct ndr_push *ndr, int flags, const struct echo_TestCall2 *r)
1056 {
1057         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1058         if (flags & NDR_IN) {
1059                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
1060         }
1061         if (flags & NDR_OUT) {
1062                 if (r->out.info == NULL) {
1063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1064                 }
1065                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
1066                 NDR_CHECK(ndr_push_echo_Info(ndr, NDR_SCALARS, r->out.info));
1067                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1068         }
1069         return NDR_ERR_SUCCESS;
1070 }
1071
1072 static enum ndr_err_code ndr_pull_echo_TestCall2(struct ndr_pull *ndr, int flags, struct echo_TestCall2 *r)
1073 {
1074         TALLOC_CTX *_mem_save_info_0;
1075         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1076         if (flags & NDR_IN) {
1077                 ZERO_STRUCT(r->out);
1078
1079                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
1080                 NDR_PULL_ALLOC(ndr, r->out.info);
1081                 ZERO_STRUCTP(r->out.info);
1082         }
1083         if (flags & NDR_OUT) {
1084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1085                         NDR_PULL_ALLOC(ndr, r->out.info);
1086                 }
1087                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1088                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
1089                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
1090                 NDR_CHECK(ndr_pull_echo_Info(ndr, NDR_SCALARS, r->out.info));
1091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
1092                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1093         }
1094         return NDR_ERR_SUCCESS;
1095 }
1096
1097 _PUBLIC_ void ndr_print_echo_TestCall2(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestCall2 *r)
1098 {
1099         ndr_print_struct(ndr, name, "echo_TestCall2");
1100         if (r == NULL) { ndr_print_null(ndr); return; }
1101         ndr->depth++;
1102         if (flags & NDR_SET_VALUES) {
1103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1104         }
1105         if (flags & NDR_IN) {
1106                 ndr_print_struct(ndr, "in", "echo_TestCall2");
1107                 ndr->depth++;
1108                 ndr_print_uint16(ndr, "level", r->in.level);
1109                 ndr->depth--;
1110         }
1111         if (flags & NDR_OUT) {
1112                 ndr_print_struct(ndr, "out", "echo_TestCall2");
1113                 ndr->depth++;
1114                 ndr_print_ptr(ndr, "info", r->out.info);
1115                 ndr->depth++;
1116                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
1117                 ndr_print_echo_Info(ndr, "info", r->out.info);
1118                 ndr->depth--;
1119                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1120                 ndr->depth--;
1121         }
1122         ndr->depth--;
1123 }
1124
1125 static enum ndr_err_code ndr_push_echo_TestSleep(struct ndr_push *ndr, int flags, const struct echo_TestSleep *r)
1126 {
1127         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1128         if (flags & NDR_IN) {
1129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.seconds));
1130         }
1131         if (flags & NDR_OUT) {
1132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1133         }
1134         return NDR_ERR_SUCCESS;
1135 }
1136
1137 static enum ndr_err_code ndr_pull_echo_TestSleep(struct ndr_pull *ndr, int flags, struct echo_TestSleep *r)
1138 {
1139         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1140         if (flags & NDR_IN) {
1141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.seconds));
1142         }
1143         if (flags & NDR_OUT) {
1144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1145         }
1146         return NDR_ERR_SUCCESS;
1147 }
1148
1149 _PUBLIC_ void ndr_print_echo_TestSleep(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestSleep *r)
1150 {
1151         ndr_print_struct(ndr, name, "echo_TestSleep");
1152         if (r == NULL) { ndr_print_null(ndr); return; }
1153         ndr->depth++;
1154         if (flags & NDR_SET_VALUES) {
1155                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1156         }
1157         if (flags & NDR_IN) {
1158                 ndr_print_struct(ndr, "in", "echo_TestSleep");
1159                 ndr->depth++;
1160                 ndr_print_uint32(ndr, "seconds", r->in.seconds);
1161                 ndr->depth--;
1162         }
1163         if (flags & NDR_OUT) {
1164                 ndr_print_struct(ndr, "out", "echo_TestSleep");
1165                 ndr->depth++;
1166                 ndr_print_uint32(ndr, "result", r->out.result);
1167                 ndr->depth--;
1168         }
1169         ndr->depth--;
1170 }
1171
1172 static enum ndr_err_code ndr_push_echo_TestEnum(struct ndr_push *ndr, int flags, const struct echo_TestEnum *r)
1173 {
1174         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1175         if (flags & NDR_IN) {
1176                 if (r->in.foo1 == NULL) {
1177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1178                 }
1179                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, *r->in.foo1));
1180                 if (r->in.foo2 == NULL) {
1181                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1182                 }
1183                 NDR_CHECK(ndr_push_echo_Enum2(ndr, NDR_SCALARS, r->in.foo2));
1184                 if (r->in.foo3 == NULL) {
1185                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1186                 }
1187                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.foo3, *r->in.foo1));
1188                 NDR_CHECK(ndr_push_echo_Enum3(ndr, NDR_SCALARS, r->in.foo3));
1189         }
1190         if (flags & NDR_OUT) {
1191                 if (r->out.foo1 == NULL) {
1192                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1193                 }
1194                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, *r->out.foo1));
1195                 if (r->out.foo2 == NULL) {
1196                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1197                 }
1198                 NDR_CHECK(ndr_push_echo_Enum2(ndr, NDR_SCALARS, r->out.foo2));
1199                 if (r->out.foo3 == NULL) {
1200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1201                 }
1202                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.foo3, *r->out.foo1));
1203                 NDR_CHECK(ndr_push_echo_Enum3(ndr, NDR_SCALARS, r->out.foo3));
1204         }
1205         return NDR_ERR_SUCCESS;
1206 }
1207
1208 static enum ndr_err_code ndr_pull_echo_TestEnum(struct ndr_pull *ndr, int flags, struct echo_TestEnum *r)
1209 {
1210         TALLOC_CTX *_mem_save_foo1_0;
1211         TALLOC_CTX *_mem_save_foo2_0;
1212         TALLOC_CTX *_mem_save_foo3_0;
1213         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1214         if (flags & NDR_IN) {
1215                 ZERO_STRUCT(r->out);
1216
1217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1218                         NDR_PULL_ALLOC(ndr, r->in.foo1);
1219                 }
1220                 _mem_save_foo1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo1, LIBNDR_FLAG_REF_ALLOC);
1222                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, r->in.foo1));
1223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo1_0, LIBNDR_FLAG_REF_ALLOC);
1224                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1225                         NDR_PULL_ALLOC(ndr, r->in.foo2);
1226                 }
1227                 _mem_save_foo2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1228                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo2, LIBNDR_FLAG_REF_ALLOC);
1229                 NDR_CHECK(ndr_pull_echo_Enum2(ndr, NDR_SCALARS, r->in.foo2));
1230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo2_0, LIBNDR_FLAG_REF_ALLOC);
1231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1232                         NDR_PULL_ALLOC(ndr, r->in.foo3);
1233                 }
1234                 _mem_save_foo3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1235                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo3, LIBNDR_FLAG_REF_ALLOC);
1236                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.foo3, *r->in.foo1));
1237                 NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_SCALARS, r->in.foo3));
1238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo3_0, LIBNDR_FLAG_REF_ALLOC);
1239                 NDR_PULL_ALLOC(ndr, r->out.foo1);
1240                 *r->out.foo1 = *r->in.foo1;
1241                 NDR_PULL_ALLOC(ndr, r->out.foo2);
1242                 *r->out.foo2 = *r->in.foo2;
1243                 NDR_PULL_ALLOC(ndr, r->out.foo3);
1244                 *r->out.foo3 = *r->in.foo3;
1245         }
1246         if (flags & NDR_OUT) {
1247                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1248                         NDR_PULL_ALLOC(ndr, r->out.foo1);
1249                 }
1250                 _mem_save_foo1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1251                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo1, LIBNDR_FLAG_REF_ALLOC);
1252                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, r->out.foo1));
1253                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo1_0, LIBNDR_FLAG_REF_ALLOC);
1254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1255                         NDR_PULL_ALLOC(ndr, r->out.foo2);
1256                 }
1257                 _mem_save_foo2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1258                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo2, LIBNDR_FLAG_REF_ALLOC);
1259                 NDR_CHECK(ndr_pull_echo_Enum2(ndr, NDR_SCALARS, r->out.foo2));
1260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo2_0, LIBNDR_FLAG_REF_ALLOC);
1261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1262                         NDR_PULL_ALLOC(ndr, r->out.foo3);
1263                 }
1264                 _mem_save_foo3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1265                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo3, LIBNDR_FLAG_REF_ALLOC);
1266                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.foo3, *r->out.foo1));
1267                 NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_SCALARS, r->out.foo3));
1268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo3_0, LIBNDR_FLAG_REF_ALLOC);
1269         }
1270         return NDR_ERR_SUCCESS;
1271 }
1272
1273 _PUBLIC_ void ndr_print_echo_TestEnum(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestEnum *r)
1274 {
1275         ndr_print_struct(ndr, name, "echo_TestEnum");
1276         if (r == NULL) { ndr_print_null(ndr); return; }
1277         ndr->depth++;
1278         if (flags & NDR_SET_VALUES) {
1279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1280         }
1281         if (flags & NDR_IN) {
1282                 ndr_print_struct(ndr, "in", "echo_TestEnum");
1283                 ndr->depth++;
1284                 ndr_print_ptr(ndr, "foo1", r->in.foo1);
1285                 ndr->depth++;
1286                 ndr_print_echo_Enum1(ndr, "foo1", *r->in.foo1);
1287                 ndr->depth--;
1288                 ndr_print_ptr(ndr, "foo2", r->in.foo2);
1289                 ndr->depth++;
1290                 ndr_print_echo_Enum2(ndr, "foo2", r->in.foo2);
1291                 ndr->depth--;
1292                 ndr_print_ptr(ndr, "foo3", r->in.foo3);
1293                 ndr->depth++;
1294                 ndr_print_set_switch_value(ndr, r->in.foo3, *r->in.foo1);
1295                 ndr_print_echo_Enum3(ndr, "foo3", r->in.foo3);
1296                 ndr->depth--;
1297                 ndr->depth--;
1298         }
1299         if (flags & NDR_OUT) {
1300                 ndr_print_struct(ndr, "out", "echo_TestEnum");
1301                 ndr->depth++;
1302                 ndr_print_ptr(ndr, "foo1", r->out.foo1);
1303                 ndr->depth++;
1304                 ndr_print_echo_Enum1(ndr, "foo1", *r->out.foo1);
1305                 ndr->depth--;
1306                 ndr_print_ptr(ndr, "foo2", r->out.foo2);
1307                 ndr->depth++;
1308                 ndr_print_echo_Enum2(ndr, "foo2", r->out.foo2);
1309                 ndr->depth--;
1310                 ndr_print_ptr(ndr, "foo3", r->out.foo3);
1311                 ndr->depth++;
1312                 ndr_print_set_switch_value(ndr, r->out.foo3, *r->out.foo1);
1313                 ndr_print_echo_Enum3(ndr, "foo3", r->out.foo3);
1314                 ndr->depth--;
1315                 ndr->depth--;
1316         }
1317         ndr->depth--;
1318 }
1319
1320 static enum ndr_err_code ndr_push_echo_TestSurrounding(struct ndr_push *ndr, int flags, const struct echo_TestSurrounding *r)
1321 {
1322         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1323         if (flags & NDR_IN) {
1324                 if (r->in.data == NULL) {
1325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1326                 }
1327                 NDR_CHECK(ndr_push_echo_Surrounding(ndr, NDR_SCALARS, r->in.data));
1328         }
1329         if (flags & NDR_OUT) {
1330                 if (r->out.data == NULL) {
1331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1332                 }
1333                 NDR_CHECK(ndr_push_echo_Surrounding(ndr, NDR_SCALARS, r->out.data));
1334         }
1335         return NDR_ERR_SUCCESS;
1336 }
1337
1338 static enum ndr_err_code ndr_pull_echo_TestSurrounding(struct ndr_pull *ndr, int flags, struct echo_TestSurrounding *r)
1339 {
1340         TALLOC_CTX *_mem_save_data_0;
1341         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1342         if (flags & NDR_IN) {
1343                 ZERO_STRUCT(r->out);
1344
1345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1346                         NDR_PULL_ALLOC(ndr, r->in.data);
1347                 }
1348                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1349                 NDR_PULL_SET_MEM_CTX(ndr, r->in.data, LIBNDR_FLAG_REF_ALLOC);
1350                 NDR_CHECK(ndr_pull_echo_Surrounding(ndr, NDR_SCALARS, r->in.data));
1351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1352                 NDR_PULL_ALLOC(ndr, r->out.data);
1353                 *r->out.data = *r->in.data;
1354         }
1355         if (flags & NDR_OUT) {
1356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1357                         NDR_PULL_ALLOC(ndr, r->out.data);
1358                 }
1359                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
1361                 NDR_CHECK(ndr_pull_echo_Surrounding(ndr, NDR_SCALARS, r->out.data));
1362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1363         }
1364         return NDR_ERR_SUCCESS;
1365 }
1366
1367 _PUBLIC_ void ndr_print_echo_TestSurrounding(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestSurrounding *r)
1368 {
1369         ndr_print_struct(ndr, name, "echo_TestSurrounding");
1370         if (r == NULL) { ndr_print_null(ndr); return; }
1371         ndr->depth++;
1372         if (flags & NDR_SET_VALUES) {
1373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1374         }
1375         if (flags & NDR_IN) {
1376                 ndr_print_struct(ndr, "in", "echo_TestSurrounding");
1377                 ndr->depth++;
1378                 ndr_print_ptr(ndr, "data", r->in.data);
1379                 ndr->depth++;
1380                 ndr_print_echo_Surrounding(ndr, "data", r->in.data);
1381                 ndr->depth--;
1382                 ndr->depth--;
1383         }
1384         if (flags & NDR_OUT) {
1385                 ndr_print_struct(ndr, "out", "echo_TestSurrounding");
1386                 ndr->depth++;
1387                 ndr_print_ptr(ndr, "data", r->out.data);
1388                 ndr->depth++;
1389                 ndr_print_echo_Surrounding(ndr, "data", r->out.data);
1390                 ndr->depth--;
1391                 ndr->depth--;
1392         }
1393         ndr->depth--;
1394 }
1395
1396 static enum ndr_err_code ndr_push_echo_TestDoublePointer(struct ndr_push *ndr, int flags, const struct echo_TestDoublePointer *r)
1397 {
1398         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1399         if (flags & NDR_IN) {
1400                 if (r->in.data == NULL) {
1401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1402                 }
1403                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.data));
1404                 if (*r->in.data) {
1405                         NDR_CHECK(ndr_push_unique_ptr(ndr, **r->in.data));
1406                         if (**r->in.data) {
1407                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ***r->in.data));
1408                         }
1409                 }
1410         }
1411         if (flags & NDR_OUT) {
1412                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.result));
1413         }
1414         return NDR_ERR_SUCCESS;
1415 }
1416
1417 static enum ndr_err_code ndr_pull_echo_TestDoublePointer(struct ndr_pull *ndr, int flags, struct echo_TestDoublePointer *r)
1418 {
1419         uint32_t _ptr_data;
1420         TALLOC_CTX *_mem_save_data_0;
1421         TALLOC_CTX *_mem_save_data_1;
1422         TALLOC_CTX *_mem_save_data_2;
1423         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1424         if (flags & NDR_IN) {
1425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1426                         NDR_PULL_ALLOC(ndr, r->in.data);
1427                 }
1428                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1429                 NDR_PULL_SET_MEM_CTX(ndr, r->in.data, LIBNDR_FLAG_REF_ALLOC);
1430                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1431                 if (_ptr_data) {
1432                         NDR_PULL_ALLOC(ndr, *r->in.data);
1433                 } else {
1434                         *r->in.data = NULL;
1435                 }
1436                 if (*r->in.data) {
1437                         _mem_save_data_1 = NDR_PULL_GET_MEM_CTX(ndr);
1438                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.data, 0);
1439                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1440                         if (_ptr_data) {
1441                                 NDR_PULL_ALLOC(ndr, **r->in.data);
1442                         } else {
1443                                 **r->in.data = NULL;
1444                         }
1445                         if (**r->in.data) {
1446                                 _mem_save_data_2 = NDR_PULL_GET_MEM_CTX(ndr);
1447                                 NDR_PULL_SET_MEM_CTX(ndr, **r->in.data, 0);
1448                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, **r->in.data));
1449                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_2, 0);
1450                         }
1451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_1, 0);
1452                 }
1453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1454         }
1455         if (flags & NDR_OUT) {
1456                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.result));
1457         }
1458         return NDR_ERR_SUCCESS;
1459 }
1460
1461 _PUBLIC_ void ndr_print_echo_TestDoublePointer(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestDoublePointer *r)
1462 {
1463         ndr_print_struct(ndr, name, "echo_TestDoublePointer");
1464         if (r == NULL) { ndr_print_null(ndr); return; }
1465         ndr->depth++;
1466         if (flags & NDR_SET_VALUES) {
1467                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1468         }
1469         if (flags & NDR_IN) {
1470                 ndr_print_struct(ndr, "in", "echo_TestDoublePointer");
1471                 ndr->depth++;
1472                 ndr_print_ptr(ndr, "data", r->in.data);
1473                 ndr->depth++;
1474                 ndr_print_ptr(ndr, "data", *r->in.data);
1475                 ndr->depth++;
1476                 if (*r->in.data) {
1477                         ndr_print_ptr(ndr, "data", **r->in.data);
1478                         ndr->depth++;
1479                         if (**r->in.data) {
1480                                 ndr_print_uint16(ndr, "data", ***r->in.data);
1481                         }
1482                         ndr->depth--;
1483                 }
1484                 ndr->depth--;
1485                 ndr->depth--;
1486                 ndr->depth--;
1487         }
1488         if (flags & NDR_OUT) {
1489                 ndr_print_struct(ndr, "out", "echo_TestDoublePointer");
1490                 ndr->depth++;
1491                 ndr_print_uint16(ndr, "result", r->out.result);
1492                 ndr->depth--;
1493         }
1494         ndr->depth--;
1495 }
1496
1497 static const struct ndr_interface_call rpcecho_calls[] = {
1498         {
1499                 "echo_AddOne",
1500                 sizeof(struct echo_AddOne),
1501                 (ndr_push_flags_fn_t) ndr_push_echo_AddOne,
1502                 (ndr_pull_flags_fn_t) ndr_pull_echo_AddOne,
1503                 (ndr_print_function_t) ndr_print_echo_AddOne,
1504                 { 0, NULL },
1505                 { 0, NULL },
1506         },
1507         {
1508                 "echo_EchoData",
1509                 sizeof(struct echo_EchoData),
1510                 (ndr_push_flags_fn_t) ndr_push_echo_EchoData,
1511                 (ndr_pull_flags_fn_t) ndr_pull_echo_EchoData,
1512                 (ndr_print_function_t) ndr_print_echo_EchoData,
1513                 { 0, NULL },
1514                 { 0, NULL },
1515         },
1516         {
1517                 "echo_SinkData",
1518                 sizeof(struct echo_SinkData),
1519                 (ndr_push_flags_fn_t) ndr_push_echo_SinkData,
1520                 (ndr_pull_flags_fn_t) ndr_pull_echo_SinkData,
1521                 (ndr_print_function_t) ndr_print_echo_SinkData,
1522                 { 0, NULL },
1523                 { 0, NULL },
1524         },
1525         {
1526                 "echo_SourceData",
1527                 sizeof(struct echo_SourceData),
1528                 (ndr_push_flags_fn_t) ndr_push_echo_SourceData,
1529                 (ndr_pull_flags_fn_t) ndr_pull_echo_SourceData,
1530                 (ndr_print_function_t) ndr_print_echo_SourceData,
1531                 { 0, NULL },
1532                 { 0, NULL },
1533         },
1534         {
1535                 "echo_TestCall",
1536                 sizeof(struct echo_TestCall),
1537                 (ndr_push_flags_fn_t) ndr_push_echo_TestCall,
1538                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestCall,
1539                 (ndr_print_function_t) ndr_print_echo_TestCall,
1540                 { 0, NULL },
1541                 { 0, NULL },
1542         },
1543         {
1544                 "echo_TestCall2",
1545                 sizeof(struct echo_TestCall2),
1546                 (ndr_push_flags_fn_t) ndr_push_echo_TestCall2,
1547                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestCall2,
1548                 (ndr_print_function_t) ndr_print_echo_TestCall2,
1549                 { 0, NULL },
1550                 { 0, NULL },
1551         },
1552         {
1553                 "echo_TestSleep",
1554                 sizeof(struct echo_TestSleep),
1555                 (ndr_push_flags_fn_t) ndr_push_echo_TestSleep,
1556                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestSleep,
1557                 (ndr_print_function_t) ndr_print_echo_TestSleep,
1558                 { 0, NULL },
1559                 { 0, NULL },
1560         },
1561         {
1562                 "echo_TestEnum",
1563                 sizeof(struct echo_TestEnum),
1564                 (ndr_push_flags_fn_t) ndr_push_echo_TestEnum,
1565                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestEnum,
1566                 (ndr_print_function_t) ndr_print_echo_TestEnum,
1567                 { 0, NULL },
1568                 { 0, NULL },
1569         },
1570         {
1571                 "echo_TestSurrounding",
1572                 sizeof(struct echo_TestSurrounding),
1573                 (ndr_push_flags_fn_t) ndr_push_echo_TestSurrounding,
1574                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestSurrounding,
1575                 (ndr_print_function_t) ndr_print_echo_TestSurrounding,
1576                 { 0, NULL },
1577                 { 0, NULL },
1578         },
1579         {
1580                 "echo_TestDoublePointer",
1581                 sizeof(struct echo_TestDoublePointer),
1582                 (ndr_push_flags_fn_t) ndr_push_echo_TestDoublePointer,
1583                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestDoublePointer,
1584                 (ndr_print_function_t) ndr_print_echo_TestDoublePointer,
1585                 { 0, NULL },
1586                 { 0, NULL },
1587         },
1588         { NULL, 0, NULL, NULL, NULL }
1589 };
1590
1591 static const char * const rpcecho_endpoint_strings[] = {
1592         "ncacn_np:[\\pipe\\rpcecho]",
1593         "ncacn_ip_tcp:",
1594         "ncalrpc:",
1595 };
1596
1597 static const struct ndr_interface_string_array rpcecho_endpoints = {
1598         .count  = 3,
1599         .names  = rpcecho_endpoint_strings
1600 };
1601
1602 static const char * const rpcecho_authservice_strings[] = {
1603         "host",
1604 };
1605
1606 static const struct ndr_interface_string_array rpcecho_authservices = {
1607         .count  = 1,
1608         .names  = rpcecho_authservice_strings
1609 };
1610
1611
1612 const struct ndr_interface_table ndr_table_rpcecho = {
1613         .name           = "rpcecho",
1614         .syntax_id      = {
1615                 {0x60a15ec5,0x4de8,0x11d7,{0xa6,0x37},{0x00,0x50,0x56,0xa2,0x01,0x82}},
1616                 NDR_RPCECHO_VERSION
1617         },
1618         .helpstring     = NDR_RPCECHO_HELPSTRING,
1619         .num_calls      = 10,
1620         .calls          = rpcecho_calls,
1621         .endpoints      = &rpcecho_endpoints,
1622         .authservices   = &rpcecho_authservices
1623 };
1624