source3/librpc/gen_ndr/ndr_echo.c

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