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_BytePipe_chunk(struct ndr_push *ndr, int ndr_flags, const struct echo_BytePipe_chunk *r)
 695 {
 696         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 697         if (ndr_flags & NDR_SCALARS) {
 698                 NDR_CHECK(ndr_push_align(ndr, 5));
 699                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 700                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->array, r->count));
 701                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 702         }
 703         if (ndr_flags & NDR_BUFFERS) {
 704         }
 705
 706         NDR_CHECK(ndr_push_pipe_chunk_trailer(ndr, ndr_flags, r->count));
 707
 708         return NDR_ERR_SUCCESS;
 709 }
 710
 711 static enum ndr_err_code ndr_pull_echo_BytePipe_chunk(struct ndr_pull *ndr, int ndr_flags, struct echo_BytePipe_chunk *r)
 712 {
 713         uint32_t size_array_0 = 0;
 714         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 715         if (ndr_flags & NDR_SCALARS) {
 716                 NDR_CHECK(ndr_pull_align(ndr, 5));
 717                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->count));
 718                 size_array_0 = r->count;
 719                 NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
 720                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->array, size_array_0));
 721                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 722         }
 723         if (ndr_flags & NDR_BUFFERS) {
 724         }
 725
 726         NDR_CHECK(ndr_check_pipe_chunk_trailer(ndr, ndr_flags, r->count));
 727
 728         return NDR_ERR_SUCCESS;
 729 }
 730
 731 _PUBLIC_ void ndr_print_echo_BytePipe_chunk(struct ndr_print *ndr, const char *name, const struct echo_BytePipe_chunk *r)
 732 {
 733         ndr_print_struct(ndr, name, "echo_BytePipe_chunk");
 734         if (r == NULL) { ndr_print_null(ndr); return; }
 735         ndr->depth++;
 736         ndr_print_uint3264(ndr, "count", r->count);
 737         ndr_print_array_uint8(ndr, "array", r->array, r->count);
 738         ndr->depth--;
 739 }
 740
 741 static enum ndr_err_code ndr_push_echo_AddOne(struct ndr_push *ndr, int flags, const struct echo_AddOne *r)
 742 {
 743         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 744         if (flags & NDR_IN) {
 745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data));
 746         }
 747         if (flags & NDR_OUT) {
 748                 if (r->out.out_data == NULL) {
 749                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 750                 }
 751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.out_data));
 752         }
 753         return NDR_ERR_SUCCESS;
 754 }
 755
 756 static enum ndr_err_code ndr_pull_echo_AddOne(struct ndr_pull *ndr, int flags, struct echo_AddOne *r)
 757 {
 758         TALLOC_CTX *_mem_save_out_data_0;
 759         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 760         if (flags & NDR_IN) {
 761                 ZERO_STRUCT(r->out);
 762
 763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.in_data));
 764                 NDR_PULL_ALLOC(ndr, r->out.out_data);
 765                 ZERO_STRUCTP(r->out.out_data);
 766         }
 767         if (flags & NDR_OUT) {
 768                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 769                         NDR_PULL_ALLOC(ndr, r->out.out_data);
 770                 }
 771                 _mem_save_out_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
 772                 NDR_PULL_SET_MEM_CTX(ndr, r->out.out_data, LIBNDR_FLAG_REF_ALLOC);
 773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.out_data));
 774                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_out_data_0, LIBNDR_FLAG_REF_ALLOC);
 775         }
 776         return NDR_ERR_SUCCESS;
 777 }
 778
 779 _PUBLIC_ void ndr_print_echo_AddOne(struct ndr_print *ndr, const char *name, int flags, const struct echo_AddOne *r)
 780 {
 781         ndr_print_struct(ndr, name, "echo_AddOne");
 782         if (r == NULL) { ndr_print_null(ndr); return; }
 783         ndr->depth++;
 784         if (flags & NDR_SET_VALUES) {
 785                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 786         }
 787         if (flags & NDR_IN) {
 788                 ndr_print_struct(ndr, "in", "echo_AddOne");
 789                 ndr->depth++;
 790                 ndr_print_uint32(ndr, "in_data", r->in.in_data);
 791                 ndr->depth--;
 792         }
 793         if (flags & NDR_OUT) {
 794                 ndr_print_struct(ndr, "out", "echo_AddOne");
 795                 ndr->depth++;
 796                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
 797                 ndr->depth++;
 798                 ndr_print_uint32(ndr, "out_data", *r->out.out_data);
 799                 ndr->depth--;
 800                 ndr->depth--;
 801         }
 802         ndr->depth--;
 803 }
 804
 805 static enum ndr_err_code ndr_push_echo_EchoData(struct ndr_push *ndr, int flags, const struct echo_EchoData *r)
 806 {
 807         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 808         if (flags & NDR_IN) {
 809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 810                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 811                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.in_data, r->in.len));
 812         }
 813         if (flags & NDR_OUT) {
 814                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 815                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.len));
 816         }
 817         return NDR_ERR_SUCCESS;
 818 }
 819
 820 static enum ndr_err_code ndr_pull_echo_EchoData(struct ndr_pull *ndr, int flags, struct echo_EchoData *r)
 821 {
 822         uint32_t size_in_data_0 = 0;
 823         uint32_t size_out_data_0 = 0;
 824         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 825         if (flags & NDR_IN) {
 826                 ZERO_STRUCT(r->out);
 827
 828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 829                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.in_data));
 830                 size_in_data_0 = ndr_get_array_size(ndr, &r->in.in_data);
 831                 NDR_PULL_ALLOC_N(ndr, r->in.in_data, size_in_data_0);
 832                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.in_data, size_in_data_0));
 833                 if (r->in.in_data) {
 834                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.in_data, r->in.len));
 835                 }
 836         }
 837         if (flags & NDR_OUT) {
 838                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
 839                 size_out_data_0 = ndr_get_array_size(ndr, &r->out.out_data);
 840                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, size_out_data_0);
 841                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, size_out_data_0));
 842                 if (r->out.out_data) {
 843                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.len));
 844                 }
 845         }
 846         return NDR_ERR_SUCCESS;
 847 }
 848
 849 _PUBLIC_ void ndr_print_echo_EchoData(struct ndr_print *ndr, const char *name, int flags, const struct echo_EchoData *r)
 850 {
 851         ndr_print_struct(ndr, name, "echo_EchoData");
 852         if (r == NULL) { ndr_print_null(ndr); return; }
 853         ndr->depth++;
 854         if (flags & NDR_SET_VALUES) {
 855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 856         }
 857         if (flags & NDR_IN) {
 858                 ndr_print_struct(ndr, "in", "echo_EchoData");
 859                 ndr->depth++;
 860                 ndr_print_uint32(ndr, "len", r->in.len);
 861                 ndr_print_array_uint8(ndr, "in_data", r->in.in_data, r->in.len);
 862                 ndr->depth--;
 863         }
 864         if (flags & NDR_OUT) {
 865                 ndr_print_struct(ndr, "out", "echo_EchoData");
 866                 ndr->depth++;
 867                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.len);
 868                 ndr->depth--;
 869         }
 870         ndr->depth--;
 871 }
 872
 873 static enum ndr_err_code ndr_push_echo_SinkData(struct ndr_push *ndr, int flags, const struct echo_SinkData *r)
 874 {
 875         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 876         if (flags & NDR_IN) {
 877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 878                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 879                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.len));
 880         }
 881         if (flags & NDR_OUT) {
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_echo_SinkData(struct ndr_pull *ndr, int flags, struct echo_SinkData *r)
 887 {
 888         uint32_t size_data_0 = 0;
 889         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 890         if (flags & NDR_IN) {
 891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 892                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
 893                 size_data_0 = ndr_get_array_size(ndr, &r->in.data);
 894                 NDR_PULL_ALLOC_N(ndr, r->in.data, size_data_0);
 895                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, size_data_0));
 896                 if (r->in.data) {
 897                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.len));
 898                 }
 899         }
 900         if (flags & NDR_OUT) {
 901         }
 902         return NDR_ERR_SUCCESS;
 903 }
 904
 905 _PUBLIC_ void ndr_print_echo_SinkData(struct ndr_print *ndr, const char *name, int flags, const struct echo_SinkData *r)
 906 {
 907         ndr_print_struct(ndr, name, "echo_SinkData");
 908         if (r == NULL) { ndr_print_null(ndr); return; }
 909         ndr->depth++;
 910         if (flags & NDR_SET_VALUES) {
 911                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 912         }
 913         if (flags & NDR_IN) {
 914                 ndr_print_struct(ndr, "in", "echo_SinkData");
 915                 ndr->depth++;
 916                 ndr_print_uint32(ndr, "len", r->in.len);
 917                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.len);
 918                 ndr->depth--;
 919         }
 920         if (flags & NDR_OUT) {
 921                 ndr_print_struct(ndr, "out", "echo_SinkData");
 922                 ndr->depth++;
 923                 ndr->depth--;
 924         }
 925         ndr->depth--;
 926 }
 927
 928 static enum ndr_err_code ndr_push_echo_SourceData(struct ndr_push *ndr, int flags, const struct echo_SourceData *r)
 929 {
 930         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 931         if (flags & NDR_IN) {
 932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.len));
 933         }
 934         if (flags & NDR_OUT) {
 935                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.len));
 936                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.len));
 937         }
 938         return NDR_ERR_SUCCESS;
 939 }
 940
 941 static enum ndr_err_code ndr_pull_echo_SourceData(struct ndr_pull *ndr, int flags, struct echo_SourceData *r)
 942 {
 943         uint32_t size_data_0 = 0;
 944         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
 945         if (flags & NDR_IN) {
 946                 ZERO_STRUCT(r->out);
 947
 948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.len));
 949         }
 950         if (flags & NDR_OUT) {
 951                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
 952                 size_data_0 = ndr_get_array_size(ndr, &r->out.data);
 953                 NDR_PULL_ALLOC_N(ndr, r->out.data, size_data_0);
 954                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, size_data_0));
 955                 if (r->out.data) {
 956                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.len));
 957                 }
 958         }
 959         return NDR_ERR_SUCCESS;
 960 }
 961
 962 _PUBLIC_ void ndr_print_echo_SourceData(struct ndr_print *ndr, const char *name, int flags, const struct echo_SourceData *r)
 963 {
 964         ndr_print_struct(ndr, name, "echo_SourceData");
 965         if (r == NULL) { ndr_print_null(ndr); return; }
 966         ndr->depth++;
 967         if (flags & NDR_SET_VALUES) {
 968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 969         }
 970         if (flags & NDR_IN) {
 971                 ndr_print_struct(ndr, "in", "echo_SourceData");
 972                 ndr->depth++;
 973                 ndr_print_uint32(ndr, "len", r->in.len);
 974                 ndr->depth--;
 975         }
 976         if (flags & NDR_OUT) {
 977                 ndr_print_struct(ndr, "out", "echo_SourceData");
 978                 ndr->depth++;
 979                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.len);
 980                 ndr->depth--;
 981         }
 982         ndr->depth--;
 983 }
 984
 985 static enum ndr_err_code ndr_push_echo_TestCall(struct ndr_push *ndr, int flags, const struct echo_TestCall *r)
 986 {
 987         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
 988         if (flags & NDR_IN) {
 989                 if (r->in.s1 == NULL) {
 990                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 991                 }
 992                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.s1, CH_UTF16)));
 993                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 994                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.s1, CH_UTF16)));
 995                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.s1, ndr_charset_length(r->in.s1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 996         }
 997         if (flags & NDR_OUT) {
 998                 if (r->out.s2 == NULL) {
 999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1000                 }
1001                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.s2));
1002                 if (*r->out.s2) {
1003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.s2, CH_UTF16)));
1004                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1005                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.s2, CH_UTF16)));
1006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.s2, ndr_charset_length(*r->out.s2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1007                 }
1008         }
1009         return NDR_ERR_SUCCESS;
1010 }
1011
1012 static enum ndr_err_code ndr_pull_echo_TestCall(struct ndr_pull *ndr, int flags, struct echo_TestCall *r)
1013 {
1014         uint32_t size_s1_1 = 0;
1015         uint32_t length_s1_1 = 0;
1016         uint32_t _ptr_s2;
1017         uint32_t size_s2_2 = 0;
1018         uint32_t length_s2_2 = 0;
1019         TALLOC_CTX *_mem_save_s2_0;
1020         TALLOC_CTX *_mem_save_s2_1;
1021         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1022         if (flags & NDR_IN) {
1023                 ZERO_STRUCT(r->out);
1024
1025                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.s1));
1026                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.s1));
1027                 size_s1_1 = ndr_get_array_size(ndr, &r->in.s1);
1028                 length_s1_1 = ndr_get_array_length(ndr, &r->in.s1);
1029                 if (length_s1_1 > size_s1_1) {
1030                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_s1_1, length_s1_1);
1031                 }
1032                 NDR_CHECK(ndr_check_string_terminator(ndr, length_s1_1, sizeof(uint16_t)));
1033                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.s1, length_s1_1, sizeof(uint16_t), CH_UTF16));
1034                 NDR_PULL_ALLOC(ndr, r->out.s2);
1035                 ZERO_STRUCTP(r->out.s2);
1036         }
1037         if (flags & NDR_OUT) {
1038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1039                         NDR_PULL_ALLOC(ndr, r->out.s2);
1040                 }
1041                 _mem_save_s2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1042                 NDR_PULL_SET_MEM_CTX(ndr, r->out.s2, LIBNDR_FLAG_REF_ALLOC);
1043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_s2));
1044                 if (_ptr_s2) {
1045                         NDR_PULL_ALLOC(ndr, *r->out.s2);
1046                 } else {
1047                         *r->out.s2 = NULL;
1048                 }
1049                 if (*r->out.s2) {
1050                         _mem_save_s2_1 = NDR_PULL_GET_MEM_CTX(ndr);
1051                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.s2, 0);
1052                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.s2));
1053                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.s2));
1054                         size_s2_2 = ndr_get_array_size(ndr, r->out.s2);
1055                         length_s2_2 = ndr_get_array_length(ndr, r->out.s2);
1056                         if (length_s2_2 > size_s2_2) {
1057                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_s2_2, length_s2_2);
1058                         }
1059                         NDR_CHECK(ndr_check_string_terminator(ndr, length_s2_2, sizeof(uint16_t)));
1060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.s2, length_s2_2, sizeof(uint16_t), CH_UTF16));
1061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s2_1, 0);
1062                 }
1063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_s2_0, LIBNDR_FLAG_REF_ALLOC);
1064         }
1065         return NDR_ERR_SUCCESS;
1066 }
1067
1068 _PUBLIC_ void ndr_print_echo_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestCall *r)
1069 {
1070         ndr_print_struct(ndr, name, "echo_TestCall");
1071         if (r == NULL) { ndr_print_null(ndr); return; }
1072         ndr->depth++;
1073         if (flags & NDR_SET_VALUES) {
1074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1075         }
1076         if (flags & NDR_IN) {
1077                 ndr_print_struct(ndr, "in", "echo_TestCall");
1078                 ndr->depth++;
1079                 ndr_print_ptr(ndr, "s1", r->in.s1);
1080                 ndr->depth++;
1081                 ndr_print_string(ndr, "s1", r->in.s1);
1082                 ndr->depth--;
1083                 ndr->depth--;
1084         }
1085         if (flags & NDR_OUT) {
1086                 ndr_print_struct(ndr, "out", "echo_TestCall");
1087                 ndr->depth++;
1088                 ndr_print_ptr(ndr, "s2", r->out.s2);
1089                 ndr->depth++;
1090                 ndr_print_ptr(ndr, "s2", *r->out.s2);
1091                 ndr->depth++;
1092                 if (*r->out.s2) {
1093                         ndr_print_string(ndr, "s2", *r->out.s2);
1094                 }
1095                 ndr->depth--;
1096                 ndr->depth--;
1097                 ndr->depth--;
1098         }
1099         ndr->depth--;
1100 }
1101
1102 static enum ndr_err_code ndr_push_echo_TestCall2(struct ndr_push *ndr, int flags, const struct echo_TestCall2 *r)
1103 {
1104         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1105         if (flags & NDR_IN) {
1106                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
1107         }
1108         if (flags & NDR_OUT) {
1109                 if (r->out.info == NULL) {
1110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1111                 }
1112                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
1113                 NDR_CHECK(ndr_push_echo_Info(ndr, NDR_SCALARS, r->out.info));
1114                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1115         }
1116         return NDR_ERR_SUCCESS;
1117 }
1118
1119 static enum ndr_err_code ndr_pull_echo_TestCall2(struct ndr_pull *ndr, int flags, struct echo_TestCall2 *r)
1120 {
1121         TALLOC_CTX *_mem_save_info_0;
1122         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1123         if (flags & NDR_IN) {
1124                 ZERO_STRUCT(r->out);
1125
1126                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
1127                 NDR_PULL_ALLOC(ndr, r->out.info);
1128                 ZERO_STRUCTP(r->out.info);
1129         }
1130         if (flags & NDR_OUT) {
1131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1132                         NDR_PULL_ALLOC(ndr, r->out.info);
1133                 }
1134                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
1136                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
1137                 NDR_CHECK(ndr_pull_echo_Info(ndr, NDR_SCALARS, r->out.info));
1138                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
1139                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1140         }
1141         return NDR_ERR_SUCCESS;
1142 }
1143
1144 _PUBLIC_ void ndr_print_echo_TestCall2(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestCall2 *r)
1145 {
1146         ndr_print_struct(ndr, name, "echo_TestCall2");
1147         if (r == NULL) { ndr_print_null(ndr); return; }
1148         ndr->depth++;
1149         if (flags & NDR_SET_VALUES) {
1150                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1151         }
1152         if (flags & NDR_IN) {
1153                 ndr_print_struct(ndr, "in", "echo_TestCall2");
1154                 ndr->depth++;
1155                 ndr_print_uint16(ndr, "level", r->in.level);
1156                 ndr->depth--;
1157         }
1158         if (flags & NDR_OUT) {
1159                 ndr_print_struct(ndr, "out", "echo_TestCall2");
1160                 ndr->depth++;
1161                 ndr_print_ptr(ndr, "info", r->out.info);
1162                 ndr->depth++;
1163                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
1164                 ndr_print_echo_Info(ndr, "info", r->out.info);
1165                 ndr->depth--;
1166                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
1167                 ndr->depth--;
1168         }
1169         ndr->depth--;
1170 }
1171
1172 static enum ndr_err_code ndr_push_echo_TestSleep(struct ndr_push *ndr, int flags, const struct echo_TestSleep *r)
1173 {
1174         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1175         if (flags & NDR_IN) {
1176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.seconds));
1177         }
1178         if (flags & NDR_OUT) {
1179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1180         }
1181         return NDR_ERR_SUCCESS;
1182 }
1183
1184 static enum ndr_err_code ndr_pull_echo_TestSleep(struct ndr_pull *ndr, int flags, struct echo_TestSleep *r)
1185 {
1186         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1187         if (flags & NDR_IN) {
1188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.seconds));
1189         }
1190         if (flags & NDR_OUT) {
1191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1192         }
1193         return NDR_ERR_SUCCESS;
1194 }
1195
1196 _PUBLIC_ void ndr_print_echo_TestSleep(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestSleep *r)
1197 {
1198         ndr_print_struct(ndr, name, "echo_TestSleep");
1199         if (r == NULL) { ndr_print_null(ndr); return; }
1200         ndr->depth++;
1201         if (flags & NDR_SET_VALUES) {
1202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1203         }
1204         if (flags & NDR_IN) {
1205                 ndr_print_struct(ndr, "in", "echo_TestSleep");
1206                 ndr->depth++;
1207                 ndr_print_uint32(ndr, "seconds", r->in.seconds);
1208                 ndr->depth--;
1209         }
1210         if (flags & NDR_OUT) {
1211                 ndr_print_struct(ndr, "out", "echo_TestSleep");
1212                 ndr->depth++;
1213                 ndr_print_uint32(ndr, "result", r->out.result);
1214                 ndr->depth--;
1215         }
1216         ndr->depth--;
1217 }
1218
1219 static enum ndr_err_code ndr_push_echo_TestEnum(struct ndr_push *ndr, int flags, const struct echo_TestEnum *r)
1220 {
1221         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1222         if (flags & NDR_IN) {
1223                 if (r->in.foo1 == NULL) {
1224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1225                 }
1226                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, *r->in.foo1));
1227                 if (r->in.foo2 == NULL) {
1228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1229                 }
1230                 NDR_CHECK(ndr_push_echo_Enum2(ndr, NDR_SCALARS, r->in.foo2));
1231                 if (r->in.foo3 == NULL) {
1232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1233                 }
1234                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.foo3, *r->in.foo1));
1235                 NDR_CHECK(ndr_push_echo_Enum3(ndr, NDR_SCALARS, r->in.foo3));
1236         }
1237         if (flags & NDR_OUT) {
1238                 if (r->out.foo1 == NULL) {
1239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1240                 }
1241                 NDR_CHECK(ndr_push_echo_Enum1(ndr, NDR_SCALARS, *r->out.foo1));
1242                 if (r->out.foo2 == NULL) {
1243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1244                 }
1245                 NDR_CHECK(ndr_push_echo_Enum2(ndr, NDR_SCALARS, r->out.foo2));
1246                 if (r->out.foo3 == NULL) {
1247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1248                 }
1249                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.foo3, *r->out.foo1));
1250                 NDR_CHECK(ndr_push_echo_Enum3(ndr, NDR_SCALARS, r->out.foo3));
1251         }
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 static enum ndr_err_code ndr_pull_echo_TestEnum(struct ndr_pull *ndr, int flags, struct echo_TestEnum *r)
1256 {
1257         TALLOC_CTX *_mem_save_foo1_0;
1258         TALLOC_CTX *_mem_save_foo2_0;
1259         TALLOC_CTX *_mem_save_foo3_0;
1260         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1261         if (flags & NDR_IN) {
1262                 ZERO_STRUCT(r->out);
1263
1264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1265                         NDR_PULL_ALLOC(ndr, r->in.foo1);
1266                 }
1267                 _mem_save_foo1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1268                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo1, LIBNDR_FLAG_REF_ALLOC);
1269                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, r->in.foo1));
1270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo1_0, LIBNDR_FLAG_REF_ALLOC);
1271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1272                         NDR_PULL_ALLOC(ndr, r->in.foo2);
1273                 }
1274                 _mem_save_foo2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo2, LIBNDR_FLAG_REF_ALLOC);
1276                 NDR_CHECK(ndr_pull_echo_Enum2(ndr, NDR_SCALARS, r->in.foo2));
1277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo2_0, LIBNDR_FLAG_REF_ALLOC);
1278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1279                         NDR_PULL_ALLOC(ndr, r->in.foo3);
1280                 }
1281                 _mem_save_foo3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1282                 NDR_PULL_SET_MEM_CTX(ndr, r->in.foo3, LIBNDR_FLAG_REF_ALLOC);
1283                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.foo3, *r->in.foo1));
1284                 NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_SCALARS, r->in.foo3));
1285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo3_0, LIBNDR_FLAG_REF_ALLOC);
1286                 NDR_PULL_ALLOC(ndr, r->out.foo1);
1287                 *r->out.foo1 = *r->in.foo1;
1288                 NDR_PULL_ALLOC(ndr, r->out.foo2);
1289                 *r->out.foo2 = *r->in.foo2;
1290                 NDR_PULL_ALLOC(ndr, r->out.foo3);
1291                 *r->out.foo3 = *r->in.foo3;
1292         }
1293         if (flags & NDR_OUT) {
1294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1295                         NDR_PULL_ALLOC(ndr, r->out.foo1);
1296                 }
1297                 _mem_save_foo1_0 = NDR_PULL_GET_MEM_CTX(ndr);
1298                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo1, LIBNDR_FLAG_REF_ALLOC);
1299                 NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, r->out.foo1));
1300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo1_0, LIBNDR_FLAG_REF_ALLOC);
1301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1302                         NDR_PULL_ALLOC(ndr, r->out.foo2);
1303                 }
1304                 _mem_save_foo2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1305                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo2, LIBNDR_FLAG_REF_ALLOC);
1306                 NDR_CHECK(ndr_pull_echo_Enum2(ndr, NDR_SCALARS, r->out.foo2));
1307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo2_0, LIBNDR_FLAG_REF_ALLOC);
1308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1309                         NDR_PULL_ALLOC(ndr, r->out.foo3);
1310                 }
1311                 _mem_save_foo3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.foo3, LIBNDR_FLAG_REF_ALLOC);
1313                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.foo3, *r->out.foo1));
1314                 NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_SCALARS, r->out.foo3));
1315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_foo3_0, LIBNDR_FLAG_REF_ALLOC);
1316         }
1317         return NDR_ERR_SUCCESS;
1318 }
1319
1320 _PUBLIC_ void ndr_print_echo_TestEnum(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestEnum *r)
1321 {
1322         ndr_print_struct(ndr, name, "echo_TestEnum");
1323         if (r == NULL) { ndr_print_null(ndr); return; }
1324         ndr->depth++;
1325         if (flags & NDR_SET_VALUES) {
1326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1327         }
1328         if (flags & NDR_IN) {
1329                 ndr_print_struct(ndr, "in", "echo_TestEnum");
1330                 ndr->depth++;
1331                 ndr_print_ptr(ndr, "foo1", r->in.foo1);
1332                 ndr->depth++;
1333                 ndr_print_echo_Enum1(ndr, "foo1", *r->in.foo1);
1334                 ndr->depth--;
1335                 ndr_print_ptr(ndr, "foo2", r->in.foo2);
1336                 ndr->depth++;
1337                 ndr_print_echo_Enum2(ndr, "foo2", r->in.foo2);
1338                 ndr->depth--;
1339                 ndr_print_ptr(ndr, "foo3", r->in.foo3);
1340                 ndr->depth++;
1341                 ndr_print_set_switch_value(ndr, r->in.foo3, *r->in.foo1);
1342                 ndr_print_echo_Enum3(ndr, "foo3", r->in.foo3);
1343                 ndr->depth--;
1344                 ndr->depth--;
1345         }
1346         if (flags & NDR_OUT) {
1347                 ndr_print_struct(ndr, "out", "echo_TestEnum");
1348                 ndr->depth++;
1349                 ndr_print_ptr(ndr, "foo1", r->out.foo1);
1350                 ndr->depth++;
1351                 ndr_print_echo_Enum1(ndr, "foo1", *r->out.foo1);
1352                 ndr->depth--;
1353                 ndr_print_ptr(ndr, "foo2", r->out.foo2);
1354                 ndr->depth++;
1355                 ndr_print_echo_Enum2(ndr, "foo2", r->out.foo2);
1356                 ndr->depth--;
1357                 ndr_print_ptr(ndr, "foo3", r->out.foo3);
1358                 ndr->depth++;
1359                 ndr_print_set_switch_value(ndr, r->out.foo3, *r->out.foo1);
1360                 ndr_print_echo_Enum3(ndr, "foo3", r->out.foo3);
1361                 ndr->depth--;
1362                 ndr->depth--;
1363         }
1364         ndr->depth--;
1365 }
1366
1367 static enum ndr_err_code ndr_push_echo_TestSurrounding(struct ndr_push *ndr, int flags, const struct echo_TestSurrounding *r)
1368 {
1369         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1370         if (flags & NDR_IN) {
1371                 if (r->in.data == NULL) {
1372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1373                 }
1374                 NDR_CHECK(ndr_push_echo_Surrounding(ndr, NDR_SCALARS, r->in.data));
1375         }
1376         if (flags & NDR_OUT) {
1377                 if (r->out.data == NULL) {
1378                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1379                 }
1380                 NDR_CHECK(ndr_push_echo_Surrounding(ndr, NDR_SCALARS, r->out.data));
1381         }
1382         return NDR_ERR_SUCCESS;
1383 }
1384
1385 static enum ndr_err_code ndr_pull_echo_TestSurrounding(struct ndr_pull *ndr, int flags, struct echo_TestSurrounding *r)
1386 {
1387         TALLOC_CTX *_mem_save_data_0;
1388         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1389         if (flags & NDR_IN) {
1390                 ZERO_STRUCT(r->out);
1391
1392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1393                         NDR_PULL_ALLOC(ndr, r->in.data);
1394                 }
1395                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1396                 NDR_PULL_SET_MEM_CTX(ndr, r->in.data, LIBNDR_FLAG_REF_ALLOC);
1397                 NDR_CHECK(ndr_pull_echo_Surrounding(ndr, NDR_SCALARS, r->in.data));
1398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1399                 NDR_PULL_ALLOC(ndr, r->out.data);
1400                 *r->out.data = *r->in.data;
1401         }
1402         if (flags & NDR_OUT) {
1403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1404                         NDR_PULL_ALLOC(ndr, r->out.data);
1405                 }
1406                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1407                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
1408                 NDR_CHECK(ndr_pull_echo_Surrounding(ndr, NDR_SCALARS, r->out.data));
1409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1410         }
1411         return NDR_ERR_SUCCESS;
1412 }
1413
1414 _PUBLIC_ void ndr_print_echo_TestSurrounding(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestSurrounding *r)
1415 {
1416         ndr_print_struct(ndr, name, "echo_TestSurrounding");
1417         if (r == NULL) { ndr_print_null(ndr); return; }
1418         ndr->depth++;
1419         if (flags & NDR_SET_VALUES) {
1420                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1421         }
1422         if (flags & NDR_IN) {
1423                 ndr_print_struct(ndr, "in", "echo_TestSurrounding");
1424                 ndr->depth++;
1425                 ndr_print_ptr(ndr, "data", r->in.data);
1426                 ndr->depth++;
1427                 ndr_print_echo_Surrounding(ndr, "data", r->in.data);
1428                 ndr->depth--;
1429                 ndr->depth--;
1430         }
1431         if (flags & NDR_OUT) {
1432                 ndr_print_struct(ndr, "out", "echo_TestSurrounding");
1433                 ndr->depth++;
1434                 ndr_print_ptr(ndr, "data", r->out.data);
1435                 ndr->depth++;
1436                 ndr_print_echo_Surrounding(ndr, "data", r->out.data);
1437                 ndr->depth--;
1438                 ndr->depth--;
1439         }
1440         ndr->depth--;
1441 }
1442
1443 static enum ndr_err_code ndr_push_echo_TestDoublePointer(struct ndr_push *ndr, int flags, const struct echo_TestDoublePointer *r)
1444 {
1445         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1446         if (flags & NDR_IN) {
1447                 if (r->in.data == NULL) {
1448                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1449                 }
1450                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.data));
1451                 if (*r->in.data) {
1452                         NDR_CHECK(ndr_push_unique_ptr(ndr, **r->in.data));
1453                         if (**r->in.data) {
1454                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ***r->in.data));
1455                         }
1456                 }
1457         }
1458         if (flags & NDR_OUT) {
1459                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.result));
1460         }
1461         return NDR_ERR_SUCCESS;
1462 }
1463
1464 static enum ndr_err_code ndr_pull_echo_TestDoublePointer(struct ndr_pull *ndr, int flags, struct echo_TestDoublePointer *r)
1465 {
1466         uint32_t _ptr_data;
1467         TALLOC_CTX *_mem_save_data_0;
1468         TALLOC_CTX *_mem_save_data_1;
1469         TALLOC_CTX *_mem_save_data_2;
1470         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1471         if (flags & NDR_IN) {
1472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1473                         NDR_PULL_ALLOC(ndr, r->in.data);
1474                 }
1475                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.data, LIBNDR_FLAG_REF_ALLOC);
1477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1478                 if (_ptr_data) {
1479                         NDR_PULL_ALLOC(ndr, *r->in.data);
1480                 } else {
1481                         *r->in.data = NULL;
1482                 }
1483                 if (*r->in.data) {
1484                         _mem_save_data_1 = NDR_PULL_GET_MEM_CTX(ndr);
1485                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.data, 0);
1486                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1487                         if (_ptr_data) {
1488                                 NDR_PULL_ALLOC(ndr, **r->in.data);
1489                         } else {
1490                                 **r->in.data = NULL;
1491                         }
1492                         if (**r->in.data) {
1493                                 _mem_save_data_2 = NDR_PULL_GET_MEM_CTX(ndr);
1494                                 NDR_PULL_SET_MEM_CTX(ndr, **r->in.data, 0);
1495                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, **r->in.data));
1496                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_2, 0);
1497                         }
1498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_1, 0);
1499                 }
1500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
1501         }
1502         if (flags & NDR_OUT) {
1503                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.result));
1504         }
1505         return NDR_ERR_SUCCESS;
1506 }
1507
1508 _PUBLIC_ void ndr_print_echo_TestDoublePointer(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestDoublePointer *r)
1509 {
1510         ndr_print_struct(ndr, name, "echo_TestDoublePointer");
1511         if (r == NULL) { ndr_print_null(ndr); return; }
1512         ndr->depth++;
1513         if (flags & NDR_SET_VALUES) {
1514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1515         }
1516         if (flags & NDR_IN) {
1517                 ndr_print_struct(ndr, "in", "echo_TestDoublePointer");
1518                 ndr->depth++;
1519                 ndr_print_ptr(ndr, "data", r->in.data);
1520                 ndr->depth++;
1521                 ndr_print_ptr(ndr, "data", *r->in.data);
1522                 ndr->depth++;
1523                 if (*r->in.data) {
1524                         ndr_print_ptr(ndr, "data", **r->in.data);
1525                         ndr->depth++;
1526                         if (**r->in.data) {
1527                                 ndr_print_uint16(ndr, "data", ***r->in.data);
1528                         }
1529                         ndr->depth--;
1530                 }
1531                 ndr->depth--;
1532                 ndr->depth--;
1533                 ndr->depth--;
1534         }
1535         if (flags & NDR_OUT) {
1536                 ndr_print_struct(ndr, "out", "echo_TestDoublePointer");
1537                 ndr->depth++;
1538                 ndr_print_uint16(ndr, "result", r->out.result);
1539                 ndr->depth--;
1540         }
1541         ndr->depth--;
1542 }
1543
1544 static enum ndr_err_code ndr_push_echo_TestBytePipeIn(struct ndr_push *ndr, int flags, const struct echo_TestBytePipeIn *r)
1545 {
1546         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1547         if (flags & NDR_IN) {
1548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_chunks));
1549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.chunk_size));
1550         }
1551         if (flags & NDR_OUT) {
1552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1553         }
1554         return NDR_ERR_SUCCESS;
1555 }
1556
1557 static enum ndr_err_code ndr_pull_echo_TestBytePipeIn(struct ndr_pull *ndr, int flags, struct echo_TestBytePipeIn *r)
1558 {
1559         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1560         if (flags & NDR_IN) {
1561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_chunks));
1562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.chunk_size));
1563         }
1564         if (flags & NDR_OUT) {
1565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1566         }
1567         return NDR_ERR_SUCCESS;
1568 }
1569
1570 _PUBLIC_ void ndr_print_echo_TestBytePipeIn(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestBytePipeIn *r)
1571 {
1572         ndr_print_struct(ndr, name, "echo_TestBytePipeIn");
1573         if (r == NULL) { ndr_print_null(ndr); return; }
1574         ndr->depth++;
1575         if (flags & NDR_SET_VALUES) {
1576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1577         }
1578         if (flags & NDR_IN) {
1579                 ndr_print_struct(ndr, "in", "echo_TestBytePipeIn");
1580                 ndr->depth++;
1581                 ndr_print_uint32(ndr, "num_chunks", r->in.num_chunks);
1582                 ndr_print_uint32(ndr, "chunk_size", r->in.chunk_size);
1583                 ndr_print_ptr(ndr, "in_pipe", r->in.in_pipe);
1584                 ndr->depth++;
1585                 ndr->depth--;
1586                 ndr->depth--;
1587         }
1588         if (flags & NDR_OUT) {
1589                 ndr_print_struct(ndr, "out", "echo_TestBytePipeIn");
1590                 ndr->depth++;
1591                 ndr_print_uint32(ndr, "result", r->out.result);
1592                 ndr->depth--;
1593         }
1594         ndr->depth--;
1595 }
1596
1597 static enum ndr_err_code ndr_push_echo_TestBytePipeOut(struct ndr_push *ndr, int flags, const struct echo_TestBytePipeOut *r)
1598 {
1599         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1600         if (flags & NDR_IN) {
1601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_chunks));
1602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.chunk_size));
1603         }
1604         if (flags & NDR_OUT) {
1605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1606         }
1607         return NDR_ERR_SUCCESS;
1608 }
1609
1610 static enum ndr_err_code ndr_pull_echo_TestBytePipeOut(struct ndr_pull *ndr, int flags, struct echo_TestBytePipeOut *r)
1611 {
1612         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1613         if (flags & NDR_IN) {
1614                 ZERO_STRUCT(r->out);
1615
1616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_chunks));
1617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.chunk_size));
1618         }
1619         if (flags & NDR_OUT) {
1620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1621         }
1622         return NDR_ERR_SUCCESS;
1623 }
1624
1625 _PUBLIC_ void ndr_print_echo_TestBytePipeOut(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestBytePipeOut *r)
1626 {
1627         ndr_print_struct(ndr, name, "echo_TestBytePipeOut");
1628         if (r == NULL) { ndr_print_null(ndr); return; }
1629         ndr->depth++;
1630         if (flags & NDR_SET_VALUES) {
1631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1632         }
1633         if (flags & NDR_IN) {
1634                 ndr_print_struct(ndr, "in", "echo_TestBytePipeOut");
1635                 ndr->depth++;
1636                 ndr_print_uint32(ndr, "num_chunks", r->in.num_chunks);
1637                 ndr_print_uint32(ndr, "chunk_size", r->in.chunk_size);
1638                 ndr->depth--;
1639         }
1640         if (flags & NDR_OUT) {
1641                 ndr_print_struct(ndr, "out", "echo_TestBytePipeOut");
1642                 ndr->depth++;
1643                 ndr_print_ptr(ndr, "out_pipe", r->out.out_pipe);
1644                 ndr->depth++;
1645                 ndr->depth--;
1646                 ndr_print_uint32(ndr, "result", r->out.result);
1647                 ndr->depth--;
1648         }
1649         ndr->depth--;
1650 }
1651
1652 static enum ndr_err_code ndr_push_echo_TestBytePipeInOut(struct ndr_push *ndr, int flags, const struct echo_TestBytePipeInOut *r)
1653 {
1654         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1655         if (flags & NDR_IN) {
1656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_chunks));
1657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.chunk_size));
1658         }
1659         if (flags & NDR_OUT) {
1660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1661         }
1662         return NDR_ERR_SUCCESS;
1663 }
1664
1665 static enum ndr_err_code ndr_pull_echo_TestBytePipeInOut(struct ndr_pull *ndr, int flags, struct echo_TestBytePipeInOut *r)
1666 {
1667         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1668         if (flags & NDR_IN) {
1669                 ZERO_STRUCT(r->out);
1670
1671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_chunks));
1672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.chunk_size));
1673         }
1674         if (flags & NDR_OUT) {
1675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1676         }
1677         return NDR_ERR_SUCCESS;
1678 }
1679
1680 _PUBLIC_ void ndr_print_echo_TestBytePipeInOut(struct ndr_print *ndr, const char *name, int flags, const struct echo_TestBytePipeInOut *r)
1681 {
1682         ndr_print_struct(ndr, name, "echo_TestBytePipeInOut");
1683         if (r == NULL) { ndr_print_null(ndr); return; }
1684         ndr->depth++;
1685         if (flags & NDR_SET_VALUES) {
1686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1687         }
1688         if (flags & NDR_IN) {
1689                 ndr_print_struct(ndr, "in", "echo_TestBytePipeInOut");
1690                 ndr->depth++;
1691                 ndr_print_uint32(ndr, "num_chunks", r->in.num_chunks);
1692                 ndr_print_uint32(ndr, "chunk_size", r->in.chunk_size);
1693                 ndr_print_ptr(ndr, "out_pipe", r->in.out_pipe);
1694                 ndr->depth++;
1695                 ndr->depth--;
1696                 ndr->depth--;
1697         }
1698         if (flags & NDR_OUT) {
1699                 ndr_print_struct(ndr, "out", "echo_TestBytePipeInOut");
1700                 ndr->depth++;
1701                 ndr_print_ptr(ndr, "out_pipe", r->out.out_pipe);
1702                 ndr->depth++;
1703                 ndr->depth--;
1704                 ndr_print_uint32(ndr, "result", r->out.result);
1705                 ndr->depth--;
1706         }
1707         ndr->depth--;
1708 }
1709
1710 static const struct ndr_interface_call_pipe echo_TestBytePipeIn_in_pipes[] = {
1711         {
1712                 "in.in_pipe",
1713                 "echo_BytePipe_chunk",
1714                 sizeof(struct echo_BytePipe_chunk),
1715                 (ndr_push_flags_fn_t) ndr_push_echo_BytePipe_chunk,
1716                 (ndr_pull_flags_fn_t) ndr_pull_echo_BytePipe_chunk,
1717                 (ndr_print_fn_t) ndr_print_echo_BytePipe_chunk,
1718         },
1719         { NULL, NULL, 0, NULL, NULL, NULL }
1720 };
1721
1722 static const struct ndr_interface_call_pipe echo_TestBytePipeOut_out_pipes[] = {
1723         {
1724                 "out.out_pipe",
1725                 "echo_BytePipe_chunk",
1726                 sizeof(struct echo_BytePipe_chunk),
1727                 (ndr_push_flags_fn_t) ndr_push_echo_BytePipe_chunk,
1728                 (ndr_pull_flags_fn_t) ndr_pull_echo_BytePipe_chunk,
1729                 (ndr_print_fn_t) ndr_print_echo_BytePipe_chunk,
1730         },
1731         { NULL, NULL, 0, NULL, NULL, NULL }
1732 };
1733
1734 static const struct ndr_interface_call_pipe echo_TestBytePipeInOut_in_pipes[] = {
1735         {
1736                 "in.out_pipe",
1737                 "echo_BytePipe_chunk",
1738                 sizeof(struct echo_BytePipe_chunk),
1739                 (ndr_push_flags_fn_t) ndr_push_echo_BytePipe_chunk,
1740                 (ndr_pull_flags_fn_t) ndr_pull_echo_BytePipe_chunk,
1741                 (ndr_print_fn_t) ndr_print_echo_BytePipe_chunk,
1742         },
1743         { NULL, NULL, 0, NULL, NULL, NULL }
1744 };
1745
1746 static const struct ndr_interface_call_pipe echo_TestBytePipeInOut_out_pipes[] = {
1747         {
1748                 "out.out_pipe",
1749                 "echo_BytePipe_chunk",
1750                 sizeof(struct echo_BytePipe_chunk),
1751                 (ndr_push_flags_fn_t) ndr_push_echo_BytePipe_chunk,
1752                 (ndr_pull_flags_fn_t) ndr_pull_echo_BytePipe_chunk,
1753                 (ndr_print_fn_t) ndr_print_echo_BytePipe_chunk,
1754         },
1755         { NULL, NULL, 0, NULL, NULL, NULL }
1756 };
1757
1758 static const struct ndr_interface_call rpcecho_calls[] = {
1759         {
1760                 "echo_AddOne",
1761                 sizeof(struct echo_AddOne),
1762                 (ndr_push_flags_fn_t) ndr_push_echo_AddOne,
1763                 (ndr_pull_flags_fn_t) ndr_pull_echo_AddOne,
1764                 (ndr_print_function_t) ndr_print_echo_AddOne,
1765                 { 0, NULL },
1766                 { 0, NULL },
1767         },
1768         {
1769                 "echo_EchoData",
1770                 sizeof(struct echo_EchoData),
1771                 (ndr_push_flags_fn_t) ndr_push_echo_EchoData,
1772                 (ndr_pull_flags_fn_t) ndr_pull_echo_EchoData,
1773                 (ndr_print_function_t) ndr_print_echo_EchoData,
1774                 { 0, NULL },
1775                 { 0, NULL },
1776         },
1777         {
1778                 "echo_SinkData",
1779                 sizeof(struct echo_SinkData),
1780                 (ndr_push_flags_fn_t) ndr_push_echo_SinkData,
1781                 (ndr_pull_flags_fn_t) ndr_pull_echo_SinkData,
1782                 (ndr_print_function_t) ndr_print_echo_SinkData,
1783                 { 0, NULL },
1784                 { 0, NULL },
1785         },
1786         {
1787                 "echo_SourceData",
1788                 sizeof(struct echo_SourceData),
1789                 (ndr_push_flags_fn_t) ndr_push_echo_SourceData,
1790                 (ndr_pull_flags_fn_t) ndr_pull_echo_SourceData,
1791                 (ndr_print_function_t) ndr_print_echo_SourceData,
1792                 { 0, NULL },
1793                 { 0, NULL },
1794         },
1795         {
1796                 "echo_TestCall",
1797                 sizeof(struct echo_TestCall),
1798                 (ndr_push_flags_fn_t) ndr_push_echo_TestCall,
1799                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestCall,
1800                 (ndr_print_function_t) ndr_print_echo_TestCall,
1801                 { 0, NULL },
1802                 { 0, NULL },
1803         },
1804         {
1805                 "echo_TestCall2",
1806                 sizeof(struct echo_TestCall2),
1807                 (ndr_push_flags_fn_t) ndr_push_echo_TestCall2,
1808                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestCall2,
1809                 (ndr_print_function_t) ndr_print_echo_TestCall2,
1810                 { 0, NULL },
1811                 { 0, NULL },
1812         },
1813         {
1814                 "echo_TestSleep",
1815                 sizeof(struct echo_TestSleep),
1816                 (ndr_push_flags_fn_t) ndr_push_echo_TestSleep,
1817                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestSleep,
1818                 (ndr_print_function_t) ndr_print_echo_TestSleep,
1819                 { 0, NULL },
1820                 { 0, NULL },
1821         },
1822         {
1823                 "echo_TestEnum",
1824                 sizeof(struct echo_TestEnum),
1825                 (ndr_push_flags_fn_t) ndr_push_echo_TestEnum,
1826                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestEnum,
1827                 (ndr_print_function_t) ndr_print_echo_TestEnum,
1828                 { 0, NULL },
1829                 { 0, NULL },
1830         },
1831         {
1832                 "echo_TestSurrounding",
1833                 sizeof(struct echo_TestSurrounding),
1834                 (ndr_push_flags_fn_t) ndr_push_echo_TestSurrounding,
1835                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestSurrounding,
1836                 (ndr_print_function_t) ndr_print_echo_TestSurrounding,
1837                 { 0, NULL },
1838                 { 0, NULL },
1839         },
1840         {
1841                 "echo_TestDoublePointer",
1842                 sizeof(struct echo_TestDoublePointer),
1843                 (ndr_push_flags_fn_t) ndr_push_echo_TestDoublePointer,
1844                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestDoublePointer,
1845                 (ndr_print_function_t) ndr_print_echo_TestDoublePointer,
1846                 { 0, NULL },
1847                 { 0, NULL },
1848         },
1849         {
1850                 "echo_TestBytePipeIn",
1851                 sizeof(struct echo_TestBytePipeIn),
1852                 (ndr_push_flags_fn_t) ndr_push_echo_TestBytePipeIn,
1853                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestBytePipeIn,
1854                 (ndr_print_function_t) ndr_print_echo_TestBytePipeIn,
1855                 { 1, echo_TestBytePipeIn_in_pipes },
1856                 { 0, NULL },
1857         },
1858         {
1859                 "echo_TestBytePipeOut",
1860                 sizeof(struct echo_TestBytePipeOut),
1861                 (ndr_push_flags_fn_t) ndr_push_echo_TestBytePipeOut,
1862                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestBytePipeOut,
1863                 (ndr_print_function_t) ndr_print_echo_TestBytePipeOut,
1864                 { 0, NULL },
1865                 { 1, echo_TestBytePipeOut_out_pipes },
1866         },
1867         {
1868                 "echo_TestBytePipeInOut",
1869                 sizeof(struct echo_TestBytePipeInOut),
1870                 (ndr_push_flags_fn_t) ndr_push_echo_TestBytePipeInOut,
1871                 (ndr_pull_flags_fn_t) ndr_pull_echo_TestBytePipeInOut,
1872                 (ndr_print_function_t) ndr_print_echo_TestBytePipeInOut,
1873                 { 1, echo_TestBytePipeInOut_in_pipes },
1874                 { 1, echo_TestBytePipeInOut_out_pipes },
1875         },
1876         { NULL, 0, NULL, NULL, NULL }
1877 };
1878
1879 static const char * const rpcecho_endpoint_strings[] = {
1880         "ncacn_np:[\\pipe\\rpcecho]",
1881         "ncacn_ip_tcp:",
1882         "ncalrpc:",
1883 };
1884
1885 static const struct ndr_interface_string_array rpcecho_endpoints = {
1886         .count  = 3,
1887         .names  = rpcecho_endpoint_strings
1888 };
1889
1890 static const char * const rpcecho_authservice_strings[] = {
1891         "host",
1892 };
1893
1894 static const struct ndr_interface_string_array rpcecho_authservices = {
1895         .count  = 1,
1896         .names  = rpcecho_authservice_strings
1897 };
1898
1899
1900 const struct ndr_interface_table ndr_table_rpcecho = {
1901         .name           = "rpcecho",
1902         .syntax_id      = {
1903                 {0x60a15ec5,0x4de8,0x11d7,{0xa6,0x37},{0x00,0x50,0x56,0xa2,0x01,0x82}},
1904                 NDR_RPCECHO_VERSION
1905         },
1906         .helpstring     = NDR_RPCECHO_HELPSTRING,
1907         .num_calls      = 13,
1908         .calls          = rpcecho_calls,
1909         .endpoints      = &rpcecho_endpoints,
1910         .authservices   = &rpcecho_authservices
1911 };
1912