source3/librpc/gen_ndr/ndr_epmapper.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_epmapper.h"
   5
   6 NTSTATUS ndr_push_epm_protocol(struct ndr_push *ndr, int ndr_flags, enum epm_protocol r)
   7 {
   8         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
   9         return NT_STATUS_OK;
  10 }
  11
  12 NTSTATUS ndr_pull_epm_protocol(struct ndr_pull *ndr, int ndr_flags, enum epm_protocol *r)
  13 {
  14         uint8_t v;
  15         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
  16         *r = v;
  17         return NT_STATUS_OK;
  18 }
  19
  20 _PUBLIC_ void ndr_print_epm_protocol(struct ndr_print *ndr, const char *name, enum epm_protocol r)
  21 {
  22         const char *val = NULL;
  23
  24         switch (r) {
  25                 case EPM_PROTOCOL_DNET_NSP: val = "EPM_PROTOCOL_DNET_NSP"; break;
  26                 case EPM_PROTOCOL_OSI_TP4: val = "EPM_PROTOCOL_OSI_TP4"; break;
  27                 case EPM_PROTOCOL_OSI_CLNS: val = "EPM_PROTOCOL_OSI_CLNS"; break;
  28                 case EPM_PROTOCOL_TCP: val = "EPM_PROTOCOL_TCP"; break;
  29                 case EPM_PROTOCOL_UDP: val = "EPM_PROTOCOL_UDP"; break;
  30                 case EPM_PROTOCOL_IP: val = "EPM_PROTOCOL_IP"; break;
  31                 case EPM_PROTOCOL_NCADG: val = "EPM_PROTOCOL_NCADG"; break;
  32                 case EPM_PROTOCOL_NCACN: val = "EPM_PROTOCOL_NCACN"; break;
  33                 case EPM_PROTOCOL_NCALRPC: val = "EPM_PROTOCOL_NCALRPC"; break;
  34                 case EPM_PROTOCOL_UUID: val = "EPM_PROTOCOL_UUID"; break;
  35                 case EPM_PROTOCOL_IPX: val = "EPM_PROTOCOL_IPX"; break;
  36                 case EPM_PROTOCOL_SMB: val = "EPM_PROTOCOL_SMB"; break;
  37                 case EPM_PROTOCOL_PIPE: val = "EPM_PROTOCOL_PIPE"; break;
  38                 case EPM_PROTOCOL_NETBIOS: val = "EPM_PROTOCOL_NETBIOS"; break;
  39                 case EPM_PROTOCOL_NETBEUI: val = "EPM_PROTOCOL_NETBEUI"; break;
  40                 case EPM_PROTOCOL_SPX: val = "EPM_PROTOCOL_SPX"; break;
  41                 case EPM_PROTOCOL_NB_IPX: val = "EPM_PROTOCOL_NB_IPX"; break;
  42                 case EPM_PROTOCOL_DSP: val = "EPM_PROTOCOL_DSP"; break;
  43                 case EPM_PROTOCOL_DDP: val = "EPM_PROTOCOL_DDP"; break;
  44                 case EPM_PROTOCOL_APPLETALK: val = "EPM_PROTOCOL_APPLETALK"; break;
  45                 case EPM_PROTOCOL_VINES_SPP: val = "EPM_PROTOCOL_VINES_SPP"; break;
  46                 case EPM_PROTOCOL_VINES_IPC: val = "EPM_PROTOCOL_VINES_IPC"; break;
  47                 case EPM_PROTOCOL_STREETTALK: val = "EPM_PROTOCOL_STREETTALK"; break;
  48                 case EPM_PROTOCOL_HTTP: val = "EPM_PROTOCOL_HTTP"; break;
  49                 case EPM_PROTOCOL_UNIX_DS: val = "EPM_PROTOCOL_UNIX_DS"; break;
  50                 case EPM_PROTOCOL_NULL: val = "EPM_PROTOCOL_NULL"; break;
  51         }
  52         ndr_print_enum(ndr, name, "ENUM", val, r);
  53 }
  54
  55 NTSTATUS ndr_push_epm_rhs_dnet_nsp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_dnet_nsp *r)
  56 {
  57         if (ndr_flags & NDR_SCALARS) {
  58                 NDR_CHECK(ndr_push_align(ndr, 1));
  59         }
  60         if (ndr_flags & NDR_BUFFERS) {
  61         }
  62         return NT_STATUS_OK;
  63 }
  64
  65 NTSTATUS ndr_pull_epm_rhs_dnet_nsp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_dnet_nsp *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_pull_align(ndr, 1));
  69         }
  70         if (ndr_flags & NDR_BUFFERS) {
  71         }
  72         return NT_STATUS_OK;
  73 }
  74
  75 _PUBLIC_ void ndr_print_epm_rhs_dnet_nsp(struct ndr_print *ndr, const char *name, const struct epm_rhs_dnet_nsp *r)
  76 {
  77         ndr_print_struct(ndr, name, "epm_rhs_dnet_nsp");
  78         ndr->depth++;
  79         ndr->depth--;
  80 }
  81
  82 NTSTATUS ndr_push_epm_rhs_osi_tp4(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_tp4 *r)
  83 {
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_push_align(ndr, 1));
  86         }
  87         if (ndr_flags & NDR_BUFFERS) {
  88         }
  89         return NT_STATUS_OK;
  90 }
  91
  92 NTSTATUS ndr_pull_epm_rhs_osi_tp4(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_tp4 *r)
  93 {
  94         if (ndr_flags & NDR_SCALARS) {
  95                 NDR_CHECK(ndr_pull_align(ndr, 1));
  96         }
  97         if (ndr_flags & NDR_BUFFERS) {
  98         }
  99         return NT_STATUS_OK;
 100 }
 101
 102 _PUBLIC_ void ndr_print_epm_rhs_osi_tp4(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_tp4 *r)
 103 {
 104         ndr_print_struct(ndr, name, "epm_rhs_osi_tp4");
 105         ndr->depth++;
 106         ndr->depth--;
 107 }
 108
 109 NTSTATUS ndr_push_epm_rhs_osi_clns(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_clns *r)
 110 {
 111         if (ndr_flags & NDR_SCALARS) {
 112                 NDR_CHECK(ndr_push_align(ndr, 1));
 113         }
 114         if (ndr_flags & NDR_BUFFERS) {
 115         }
 116         return NT_STATUS_OK;
 117 }
 118
 119 NTSTATUS ndr_pull_epm_rhs_osi_clns(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_clns *r)
 120 {
 121         if (ndr_flags & NDR_SCALARS) {
 122                 NDR_CHECK(ndr_pull_align(ndr, 1));
 123         }
 124         if (ndr_flags & NDR_BUFFERS) {
 125         }
 126         return NT_STATUS_OK;
 127 }
 128
 129 _PUBLIC_ void ndr_print_epm_rhs_osi_clns(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_clns *r)
 130 {
 131         ndr_print_struct(ndr, name, "epm_rhs_osi_clns");
 132         ndr->depth++;
 133         ndr->depth--;
 134 }
 135
 136 NTSTATUS ndr_push_epm_rhs_udp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_udp *r)
 137 {
 138         if (ndr_flags & NDR_SCALARS) {
 139                 NDR_CHECK(ndr_push_align(ndr, 2));
 140                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 141         }
 142         if (ndr_flags & NDR_BUFFERS) {
 143         }
 144         return NT_STATUS_OK;
 145 }
 146
 147 NTSTATUS ndr_pull_epm_rhs_udp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_udp *r)
 148 {
 149         if (ndr_flags & NDR_SCALARS) {
 150                 NDR_CHECK(ndr_pull_align(ndr, 2));
 151                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 152         }
 153         if (ndr_flags & NDR_BUFFERS) {
 154         }
 155         return NT_STATUS_OK;
 156 }
 157
 158 _PUBLIC_ void ndr_print_epm_rhs_udp(struct ndr_print *ndr, const char *name, const struct epm_rhs_udp *r)
 159 {
 160         ndr_print_struct(ndr, name, "epm_rhs_udp");
 161         ndr->depth++;
 162         ndr_print_uint16(ndr, "port", r->port);
 163         ndr->depth--;
 164 }
 165
 166 NTSTATUS ndr_push_epm_rhs_tcp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_tcp *r)
 167 {
 168         if (ndr_flags & NDR_SCALARS) {
 169                 NDR_CHECK(ndr_push_align(ndr, 2));
 170                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 171         }
 172         if (ndr_flags & NDR_BUFFERS) {
 173         }
 174         return NT_STATUS_OK;
 175 }
 176
 177 NTSTATUS ndr_pull_epm_rhs_tcp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_tcp *r)
 178 {
 179         if (ndr_flags & NDR_SCALARS) {
 180                 NDR_CHECK(ndr_pull_align(ndr, 2));
 181                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 182         }
 183         if (ndr_flags & NDR_BUFFERS) {
 184         }
 185         return NT_STATUS_OK;
 186 }
 187
 188 _PUBLIC_ void ndr_print_epm_rhs_tcp(struct ndr_print *ndr, const char *name, const struct epm_rhs_tcp *r)
 189 {
 190         ndr_print_struct(ndr, name, "epm_rhs_tcp");
 191         ndr->depth++;
 192         ndr_print_uint16(ndr, "port", r->port);
 193         ndr->depth--;
 194 }
 195
 196 NTSTATUS ndr_push_epm_rhs_ip(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ip *r)
 197 {
 198         if (ndr_flags & NDR_SCALARS) {
 199                 NDR_CHECK(ndr_push_align(ndr, 4));
 200                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
 201         }
 202         if (ndr_flags & NDR_BUFFERS) {
 203         }
 204         return NT_STATUS_OK;
 205 }
 206
 207 NTSTATUS ndr_pull_epm_rhs_ip(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ip *r)
 208 {
 209         if (ndr_flags & NDR_SCALARS) {
 210                 NDR_CHECK(ndr_pull_align(ndr, 4));
 211                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
 212         }
 213         if (ndr_flags & NDR_BUFFERS) {
 214         }
 215         return NT_STATUS_OK;
 216 }
 217
 218 _PUBLIC_ void ndr_print_epm_rhs_ip(struct ndr_print *ndr, const char *name, const struct epm_rhs_ip *r)
 219 {
 220         ndr_print_struct(ndr, name, "epm_rhs_ip");
 221         ndr->depth++;
 222         ndr_print_ipv4address(ndr, "ipaddr", r->ipaddr);
 223         ndr->depth--;
 224 }
 225
 226 NTSTATUS ndr_push_epm_rhs_ncadg(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncadg *r)
 227 {
 228         if (ndr_flags & NDR_SCALARS) {
 229                 NDR_CHECK(ndr_push_align(ndr, 2));
 230                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
 231         }
 232         if (ndr_flags & NDR_BUFFERS) {
 233         }
 234         return NT_STATUS_OK;
 235 }
 236
 237 NTSTATUS ndr_pull_epm_rhs_ncadg(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncadg *r)
 238 {
 239         if (ndr_flags & NDR_SCALARS) {
 240                 NDR_CHECK(ndr_pull_align(ndr, 2));
 241                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
 242         }
 243         if (ndr_flags & NDR_BUFFERS) {
 244         }
 245         return NT_STATUS_OK;
 246 }
 247
 248 _PUBLIC_ void ndr_print_epm_rhs_ncadg(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncadg *r)
 249 {
 250         ndr_print_struct(ndr, name, "epm_rhs_ncadg");
 251         ndr->depth++;
 252         ndr_print_uint16(ndr, "minor_version", r->minor_version);
 253         ndr->depth--;
 254 }
 255
 256 NTSTATUS ndr_push_epm_rhs_ncacn(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncacn *r)
 257 {
 258         if (ndr_flags & NDR_SCALARS) {
 259                 NDR_CHECK(ndr_push_align(ndr, 2));
 260                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
 261         }
 262         if (ndr_flags & NDR_BUFFERS) {
 263         }
 264         return NT_STATUS_OK;
 265 }
 266
 267 NTSTATUS ndr_pull_epm_rhs_ncacn(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncacn *r)
 268 {
 269         if (ndr_flags & NDR_SCALARS) {
 270                 NDR_CHECK(ndr_pull_align(ndr, 2));
 271                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
 272         }
 273         if (ndr_flags & NDR_BUFFERS) {
 274         }
 275         return NT_STATUS_OK;
 276 }
 277
 278 _PUBLIC_ void ndr_print_epm_rhs_ncacn(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncacn *r)
 279 {
 280         ndr_print_struct(ndr, name, "epm_rhs_ncacn");
 281         ndr->depth++;
 282         ndr_print_uint16(ndr, "minor_version", r->minor_version);
 283         ndr->depth--;
 284 }
 285
 286 NTSTATUS ndr_push_epm_rhs_uuid(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_uuid *r)
 287 {
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_push_align(ndr, 4));
 290                 {
 291                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 293                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
 294                         ndr->flags = _flags_save_DATA_BLOB;
 295                 }
 296         }
 297         if (ndr_flags & NDR_BUFFERS) {
 298         }
 299         return NT_STATUS_OK;
 300 }
 301
 302 NTSTATUS ndr_pull_epm_rhs_uuid(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_uuid *r)
 303 {
 304         if (ndr_flags & NDR_SCALARS) {
 305                 NDR_CHECK(ndr_pull_align(ndr, 4));
 306                 {
 307                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 309                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
 310                         ndr->flags = _flags_save_DATA_BLOB;
 311                 }
 312         }
 313         if (ndr_flags & NDR_BUFFERS) {
 314         }
 315         return NT_STATUS_OK;
 316 }
 317
 318 _PUBLIC_ void ndr_print_epm_rhs_uuid(struct ndr_print *ndr, const char *name, const struct epm_rhs_uuid *r)
 319 {
 320         ndr_print_struct(ndr, name, "epm_rhs_uuid");
 321         ndr->depth++;
 322         ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
 323         ndr->depth--;
 324 }
 325
 326 NTSTATUS ndr_push_epm_rhs_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ipx *r)
 327 {
 328         if (ndr_flags & NDR_SCALARS) {
 329                 NDR_CHECK(ndr_push_align(ndr, 1));
 330         }
 331         if (ndr_flags & NDR_BUFFERS) {
 332         }
 333         return NT_STATUS_OK;
 334 }
 335
 336 NTSTATUS ndr_pull_epm_rhs_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ipx *r)
 337 {
 338         if (ndr_flags & NDR_SCALARS) {
 339                 NDR_CHECK(ndr_pull_align(ndr, 1));
 340         }
 341         if (ndr_flags & NDR_BUFFERS) {
 342         }
 343         return NT_STATUS_OK;
 344 }
 345
 346 _PUBLIC_ void ndr_print_epm_rhs_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_ipx *r)
 347 {
 348         ndr_print_struct(ndr, name, "epm_rhs_ipx");
 349         ndr->depth++;
 350         ndr->depth--;
 351 }
 352
 353 NTSTATUS ndr_push_epm_rhs_smb(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_smb *r)
 354 {
 355         if (ndr_flags & NDR_SCALARS) {
 356                 NDR_CHECK(ndr_push_align(ndr, 4));
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 360                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unc));
 361                         ndr->flags = _flags_save_string;
 362                 }
 363         }
 364         if (ndr_flags & NDR_BUFFERS) {
 365         }
 366         return NT_STATUS_OK;
 367 }
 368
 369 NTSTATUS ndr_pull_epm_rhs_smb(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_smb *r)
 370 {
 371         if (ndr_flags & NDR_SCALARS) {
 372                 NDR_CHECK(ndr_pull_align(ndr, 4));
 373                 {
 374                         uint32_t _flags_save_string = ndr->flags;
 375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 376                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unc));
 377                         ndr->flags = _flags_save_string;
 378                 }
 379         }
 380         if (ndr_flags & NDR_BUFFERS) {
 381         }
 382         return NT_STATUS_OK;
 383 }
 384
 385 _PUBLIC_ void ndr_print_epm_rhs_smb(struct ndr_print *ndr, const char *name, const struct epm_rhs_smb *r)
 386 {
 387         ndr_print_struct(ndr, name, "epm_rhs_smb");
 388         ndr->depth++;
 389         ndr_print_string(ndr, "unc", r->unc);
 390         ndr->depth--;
 391 }
 392
 393 NTSTATUS ndr_push_epm_rhs_pipe(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_pipe *r)
 394 {
 395         if (ndr_flags & NDR_SCALARS) {
 396                 NDR_CHECK(ndr_push_align(ndr, 4));
 397                 {
 398                         uint32_t _flags_save_string = ndr->flags;
 399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 400                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
 401                         ndr->flags = _flags_save_string;
 402                 }
 403         }
 404         if (ndr_flags & NDR_BUFFERS) {
 405         }
 406         return NT_STATUS_OK;
 407 }
 408
 409 NTSTATUS ndr_pull_epm_rhs_pipe(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_pipe *r)
 410 {
 411         if (ndr_flags & NDR_SCALARS) {
 412                 NDR_CHECK(ndr_pull_align(ndr, 4));
 413                 {
 414                         uint32_t _flags_save_string = ndr->flags;
 415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 416                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
 417                         ndr->flags = _flags_save_string;
 418                 }
 419         }
 420         if (ndr_flags & NDR_BUFFERS) {
 421         }
 422         return NT_STATUS_OK;
 423 }
 424
 425 _PUBLIC_ void ndr_print_epm_rhs_pipe(struct ndr_print *ndr, const char *name, const struct epm_rhs_pipe *r)
 426 {
 427         ndr_print_struct(ndr, name, "epm_rhs_pipe");
 428         ndr->depth++;
 429         ndr_print_string(ndr, "path", r->path);
 430         ndr->depth--;
 431 }
 432
 433 NTSTATUS ndr_push_epm_rhs_netbios(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbios *r)
 434 {
 435         if (ndr_flags & NDR_SCALARS) {
 436                 NDR_CHECK(ndr_push_align(ndr, 4));
 437                 {
 438                         uint32_t _flags_save_string = ndr->flags;
 439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 440                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 441                         ndr->flags = _flags_save_string;
 442                 }
 443         }
 444         if (ndr_flags & NDR_BUFFERS) {
 445         }
 446         return NT_STATUS_OK;
 447 }
 448
 449 NTSTATUS ndr_pull_epm_rhs_netbios(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbios *r)
 450 {
 451         if (ndr_flags & NDR_SCALARS) {
 452                 NDR_CHECK(ndr_pull_align(ndr, 4));
 453                 {
 454                         uint32_t _flags_save_string = ndr->flags;
 455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 456                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 457                         ndr->flags = _flags_save_string;
 458                 }
 459         }
 460         if (ndr_flags & NDR_BUFFERS) {
 461         }
 462         return NT_STATUS_OK;
 463 }
 464
 465 _PUBLIC_ void ndr_print_epm_rhs_netbios(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbios *r)
 466 {
 467         ndr_print_struct(ndr, name, "epm_rhs_netbios");
 468         ndr->depth++;
 469         ndr_print_string(ndr, "name", r->name);
 470         ndr->depth--;
 471 }
 472
 473 NTSTATUS ndr_push_epm_rhs_netbeui(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbeui *r)
 474 {
 475         if (ndr_flags & NDR_SCALARS) {
 476                 NDR_CHECK(ndr_push_align(ndr, 1));
 477         }
 478         if (ndr_flags & NDR_BUFFERS) {
 479         }
 480         return NT_STATUS_OK;
 481 }
 482
 483 NTSTATUS ndr_pull_epm_rhs_netbeui(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbeui *r)
 484 {
 485         if (ndr_flags & NDR_SCALARS) {
 486                 NDR_CHECK(ndr_pull_align(ndr, 1));
 487         }
 488         if (ndr_flags & NDR_BUFFERS) {
 489         }
 490         return NT_STATUS_OK;
 491 }
 492
 493 _PUBLIC_ void ndr_print_epm_rhs_netbeui(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbeui *r)
 494 {
 495         ndr_print_struct(ndr, name, "epm_rhs_netbeui");
 496         ndr->depth++;
 497         ndr->depth--;
 498 }
 499
 500 NTSTATUS ndr_push_epm_rhs_spx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_spx *r)
 501 {
 502         if (ndr_flags & NDR_SCALARS) {
 503                 NDR_CHECK(ndr_push_align(ndr, 1));
 504         }
 505         if (ndr_flags & NDR_BUFFERS) {
 506         }
 507         return NT_STATUS_OK;
 508 }
 509
 510 NTSTATUS ndr_pull_epm_rhs_spx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_spx *r)
 511 {
 512         if (ndr_flags & NDR_SCALARS) {
 513                 NDR_CHECK(ndr_pull_align(ndr, 1));
 514         }
 515         if (ndr_flags & NDR_BUFFERS) {
 516         }
 517         return NT_STATUS_OK;
 518 }
 519
 520 _PUBLIC_ void ndr_print_epm_rhs_spx(struct ndr_print *ndr, const char *name, const struct epm_rhs_spx *r)
 521 {
 522         ndr_print_struct(ndr, name, "epm_rhs_spx");
 523         ndr->depth++;
 524         ndr->depth--;
 525 }
 526
 527 NTSTATUS ndr_push_epm_rhs_nb_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_nb_ipx *r)
 528 {
 529         if (ndr_flags & NDR_SCALARS) {
 530                 NDR_CHECK(ndr_push_align(ndr, 1));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533         }
 534         return NT_STATUS_OK;
 535 }
 536
 537 NTSTATUS ndr_pull_epm_rhs_nb_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_nb_ipx *r)
 538 {
 539         if (ndr_flags & NDR_SCALARS) {
 540                 NDR_CHECK(ndr_pull_align(ndr, 1));
 541         }
 542         if (ndr_flags & NDR_BUFFERS) {
 543         }
 544         return NT_STATUS_OK;
 545 }
 546
 547 _PUBLIC_ void ndr_print_epm_rhs_nb_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_nb_ipx *r)
 548 {
 549         ndr_print_struct(ndr, name, "epm_rhs_nb_ipx");
 550         ndr->depth++;
 551         ndr->depth--;
 552 }
 553
 554 NTSTATUS ndr_push_epm_rhs_http(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_http *r)
 555 {
 556         if (ndr_flags & NDR_SCALARS) {
 557                 NDR_CHECK(ndr_push_align(ndr, 2));
 558                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 559         }
 560         if (ndr_flags & NDR_BUFFERS) {
 561         }
 562         return NT_STATUS_OK;
 563 }
 564
 565 NTSTATUS ndr_pull_epm_rhs_http(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_http *r)
 566 {
 567         if (ndr_flags & NDR_SCALARS) {
 568                 NDR_CHECK(ndr_pull_align(ndr, 2));
 569                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 570         }
 571         if (ndr_flags & NDR_BUFFERS) {
 572         }
 573         return NT_STATUS_OK;
 574 }
 575
 576 _PUBLIC_ void ndr_print_epm_rhs_http(struct ndr_print *ndr, const char *name, const struct epm_rhs_http *r)
 577 {
 578         ndr_print_struct(ndr, name, "epm_rhs_http");
 579         ndr->depth++;
 580         ndr_print_uint16(ndr, "port", r->port);
 581         ndr->depth--;
 582 }
 583
 584 NTSTATUS ndr_push_epm_rhs_unix_ds(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_unix_ds *r)
 585 {
 586         if (ndr_flags & NDR_SCALARS) {
 587                 NDR_CHECK(ndr_push_align(ndr, 4));
 588                 {
 589                         uint32_t _flags_save_string = ndr->flags;
 590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 591                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
 592                         ndr->flags = _flags_save_string;
 593                 }
 594         }
 595         if (ndr_flags & NDR_BUFFERS) {
 596         }
 597         return NT_STATUS_OK;
 598 }
 599
 600 NTSTATUS ndr_pull_epm_rhs_unix_ds(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_unix_ds *r)
 601 {
 602         if (ndr_flags & NDR_SCALARS) {
 603                 NDR_CHECK(ndr_pull_align(ndr, 4));
 604                 {
 605                         uint32_t _flags_save_string = ndr->flags;
 606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 607                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
 608                         ndr->flags = _flags_save_string;
 609                 }
 610         }
 611         if (ndr_flags & NDR_BUFFERS) {
 612         }
 613         return NT_STATUS_OK;
 614 }
 615
 616 _PUBLIC_ void ndr_print_epm_rhs_unix_ds(struct ndr_print *ndr, const char *name, const struct epm_rhs_unix_ds *r)
 617 {
 618         ndr_print_struct(ndr, name, "epm_rhs_unix_ds");
 619         ndr->depth++;
 620         ndr_print_string(ndr, "path", r->path);
 621         ndr->depth--;
 622 }
 623
 624 NTSTATUS ndr_push_epm_rhs_null(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_null *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_push_align(ndr, 1));
 628         }
 629         if (ndr_flags & NDR_BUFFERS) {
 630         }
 631         return NT_STATUS_OK;
 632 }
 633
 634 NTSTATUS ndr_pull_epm_rhs_null(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_null *r)
 635 {
 636         if (ndr_flags & NDR_SCALARS) {
 637                 NDR_CHECK(ndr_pull_align(ndr, 1));
 638         }
 639         if (ndr_flags & NDR_BUFFERS) {
 640         }
 641         return NT_STATUS_OK;
 642 }
 643
 644 _PUBLIC_ void ndr_print_epm_rhs_null(struct ndr_print *ndr, const char *name, const struct epm_rhs_null *r)
 645 {
 646         ndr_print_struct(ndr, name, "epm_rhs_null");
 647         ndr->depth++;
 648         ndr->depth--;
 649 }
 650
 651 NTSTATUS ndr_push_epm_rhs_ncalrpc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncalrpc *r)
 652 {
 653         if (ndr_flags & NDR_SCALARS) {
 654                 NDR_CHECK(ndr_push_align(ndr, 2));
 655                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658         }
 659         return NT_STATUS_OK;
 660 }
 661
 662 NTSTATUS ndr_pull_epm_rhs_ncalrpc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncalrpc *r)
 663 {
 664         if (ndr_flags & NDR_SCALARS) {
 665                 NDR_CHECK(ndr_pull_align(ndr, 2));
 666                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
 667         }
 668         if (ndr_flags & NDR_BUFFERS) {
 669         }
 670         return NT_STATUS_OK;
 671 }
 672
 673 _PUBLIC_ void ndr_print_epm_rhs_ncalrpc(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncalrpc *r)
 674 {
 675         ndr_print_struct(ndr, name, "epm_rhs_ncalrpc");
 676         ndr->depth++;
 677         ndr_print_uint16(ndr, "minor_version", r->minor_version);
 678         ndr->depth--;
 679 }
 680
 681 NTSTATUS ndr_push_epm_rhs_appletalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_appletalk *r)
 682 {
 683         if (ndr_flags & NDR_SCALARS) {
 684                 NDR_CHECK(ndr_push_align(ndr, 1));
 685         }
 686         if (ndr_flags & NDR_BUFFERS) {
 687         }
 688         return NT_STATUS_OK;
 689 }
 690
 691 NTSTATUS ndr_pull_epm_rhs_appletalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_appletalk *r)
 692 {
 693         if (ndr_flags & NDR_SCALARS) {
 694                 NDR_CHECK(ndr_pull_align(ndr, 1));
 695         }
 696         if (ndr_flags & NDR_BUFFERS) {
 697         }
 698         return NT_STATUS_OK;
 699 }
 700
 701 _PUBLIC_ void ndr_print_epm_rhs_appletalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_appletalk *r)
 702 {
 703         ndr_print_struct(ndr, name, "epm_rhs_appletalk");
 704         ndr->depth++;
 705         ndr->depth--;
 706 }
 707
 708 NTSTATUS ndr_push_epm_rhs_atalk_stream(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_stream *r)
 709 {
 710         if (ndr_flags & NDR_SCALARS) {
 711                 NDR_CHECK(ndr_push_align(ndr, 1));
 712         }
 713         if (ndr_flags & NDR_BUFFERS) {
 714         }
 715         return NT_STATUS_OK;
 716 }
 717
 718 NTSTATUS ndr_pull_epm_rhs_atalk_stream(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_stream *r)
 719 {
 720         if (ndr_flags & NDR_SCALARS) {
 721                 NDR_CHECK(ndr_pull_align(ndr, 1));
 722         }
 723         if (ndr_flags & NDR_BUFFERS) {
 724         }
 725         return NT_STATUS_OK;
 726 }
 727
 728 _PUBLIC_ void ndr_print_epm_rhs_atalk_stream(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_stream *r)
 729 {
 730         ndr_print_struct(ndr, name, "epm_rhs_atalk_stream");
 731         ndr->depth++;
 732         ndr->depth--;
 733 }
 734
 735 NTSTATUS ndr_push_epm_rhs_atalk_datagram(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_datagram *r)
 736 {
 737         if (ndr_flags & NDR_SCALARS) {
 738                 NDR_CHECK(ndr_push_align(ndr, 1));
 739         }
 740         if (ndr_flags & NDR_BUFFERS) {
 741         }
 742         return NT_STATUS_OK;
 743 }
 744
 745 NTSTATUS ndr_pull_epm_rhs_atalk_datagram(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_datagram *r)
 746 {
 747         if (ndr_flags & NDR_SCALARS) {
 748                 NDR_CHECK(ndr_pull_align(ndr, 1));
 749         }
 750         if (ndr_flags & NDR_BUFFERS) {
 751         }
 752         return NT_STATUS_OK;
 753 }
 754
 755 _PUBLIC_ void ndr_print_epm_rhs_atalk_datagram(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_datagram *r)
 756 {
 757         ndr_print_struct(ndr, name, "epm_rhs_atalk_datagram");
 758         ndr->depth++;
 759         ndr->depth--;
 760 }
 761
 762 NTSTATUS ndr_push_epm_rhs_vines_spp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_spp *r)
 763 {
 764         if (ndr_flags & NDR_SCALARS) {
 765                 NDR_CHECK(ndr_push_align(ndr, 2));
 766                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 767         }
 768         if (ndr_flags & NDR_BUFFERS) {
 769         }
 770         return NT_STATUS_OK;
 771 }
 772
 773 NTSTATUS ndr_pull_epm_rhs_vines_spp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_spp *r)
 774 {
 775         if (ndr_flags & NDR_SCALARS) {
 776                 NDR_CHECK(ndr_pull_align(ndr, 2));
 777                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 778         }
 779         if (ndr_flags & NDR_BUFFERS) {
 780         }
 781         return NT_STATUS_OK;
 782 }
 783
 784 _PUBLIC_ void ndr_print_epm_rhs_vines_spp(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_spp *r)
 785 {
 786         ndr_print_struct(ndr, name, "epm_rhs_vines_spp");
 787         ndr->depth++;
 788         ndr_print_uint16(ndr, "port", r->port);
 789         ndr->depth--;
 790 }
 791
 792 NTSTATUS ndr_push_epm_rhs_vines_ipc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_ipc *r)
 793 {
 794         if (ndr_flags & NDR_SCALARS) {
 795                 NDR_CHECK(ndr_push_align(ndr, 2));
 796                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 797         }
 798         if (ndr_flags & NDR_BUFFERS) {
 799         }
 800         return NT_STATUS_OK;
 801 }
 802
 803 NTSTATUS ndr_pull_epm_rhs_vines_ipc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_ipc *r)
 804 {
 805         if (ndr_flags & NDR_SCALARS) {
 806                 NDR_CHECK(ndr_pull_align(ndr, 2));
 807                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 808         }
 809         if (ndr_flags & NDR_BUFFERS) {
 810         }
 811         return NT_STATUS_OK;
 812 }
 813
 814 _PUBLIC_ void ndr_print_epm_rhs_vines_ipc(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_ipc *r)
 815 {
 816         ndr_print_struct(ndr, name, "epm_rhs_vines_ipc");
 817         ndr->depth++;
 818         ndr_print_uint16(ndr, "port", r->port);
 819         ndr->depth--;
 820 }
 821
 822 NTSTATUS ndr_push_epm_rhs_streettalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_streettalk *r)
 823 {
 824         if (ndr_flags & NDR_SCALARS) {
 825                 NDR_CHECK(ndr_push_align(ndr, 4));
 826                 {
 827                         uint32_t _flags_save_string = ndr->flags;
 828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 829                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->streettalk));
 830                         ndr->flags = _flags_save_string;
 831                 }
 832         }
 833         if (ndr_flags & NDR_BUFFERS) {
 834         }
 835         return NT_STATUS_OK;
 836 }
 837
 838 NTSTATUS ndr_pull_epm_rhs_streettalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_streettalk *r)
 839 {
 840         if (ndr_flags & NDR_SCALARS) {
 841                 NDR_CHECK(ndr_pull_align(ndr, 4));
 842                 {
 843                         uint32_t _flags_save_string = ndr->flags;
 844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 845                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->streettalk));
 846                         ndr->flags = _flags_save_string;
 847                 }
 848         }
 849         if (ndr_flags & NDR_BUFFERS) {
 850         }
 851         return NT_STATUS_OK;
 852 }
 853
 854 _PUBLIC_ void ndr_print_epm_rhs_streettalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_streettalk *r)
 855 {
 856         ndr_print_struct(ndr, name, "epm_rhs_streettalk");
 857         ndr->depth++;
 858         ndr_print_string(ndr, "streettalk", r->streettalk);
 859         ndr->depth--;
 860 }
 861
 862 NTSTATUS ndr_push_epm_rhs(struct ndr_push *ndr, int ndr_flags, const union epm_rhs *r)
 863 {
 864         {
 865                 uint32_t _flags_save_UNION = ndr->flags;
 866                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 867                 if (ndr_flags & NDR_SCALARS) {
 868                         int level = ndr_push_get_switch_value(ndr, r);
 869                         switch (level) {
 870                                 case EPM_PROTOCOL_DNET_NSP:
 871                                         NDR_CHECK(ndr_push_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
 872                                 break;
 873
 874                                 case EPM_PROTOCOL_OSI_TP4:
 875                                         NDR_CHECK(ndr_push_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
 876                                 break;
 877
 878                                 case EPM_PROTOCOL_OSI_CLNS:
 879                                         NDR_CHECK(ndr_push_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
 880                                 break;
 881
 882                                 case EPM_PROTOCOL_TCP:
 883                                         NDR_CHECK(ndr_push_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
 884                                 break;
 885
 886                                 case EPM_PROTOCOL_UDP:
 887                                         NDR_CHECK(ndr_push_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
 888                                 break;
 889
 890                                 case EPM_PROTOCOL_IP:
 891                                         NDR_CHECK(ndr_push_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
 892                                 break;
 893
 894                                 case EPM_PROTOCOL_NCADG:
 895                                         NDR_CHECK(ndr_push_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
 896                                 break;
 897
 898                                 case EPM_PROTOCOL_NCACN:
 899                                         NDR_CHECK(ndr_push_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
 900                                 break;
 901
 902                                 case EPM_PROTOCOL_NCALRPC:
 903                                         NDR_CHECK(ndr_push_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
 904                                 break;
 905
 906                                 case EPM_PROTOCOL_UUID:
 907                                         NDR_CHECK(ndr_push_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
 908                                 break;
 909
 910                                 case EPM_PROTOCOL_IPX:
 911                                         NDR_CHECK(ndr_push_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
 912                                 break;
 913
 914                                 case EPM_PROTOCOL_SMB:
 915                                         NDR_CHECK(ndr_push_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
 916                                 break;
 917
 918                                 case EPM_PROTOCOL_PIPE:
 919                                         NDR_CHECK(ndr_push_epm_rhs_pipe(ndr, NDR_SCALARS, &r->pipe));
 920                                 break;
 921
 922                                 case EPM_PROTOCOL_NETBIOS:
 923                                         NDR_CHECK(ndr_push_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
 924                                 break;
 925
 926                                 case EPM_PROTOCOL_NETBEUI:
 927                                         NDR_CHECK(ndr_push_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
 928                                 break;
 929
 930                                 case EPM_PROTOCOL_SPX:
 931                                         NDR_CHECK(ndr_push_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
 932                                 break;
 933
 934                                 case EPM_PROTOCOL_NB_IPX:
 935                                         NDR_CHECK(ndr_push_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
 936                                 break;
 937
 938                                 case EPM_PROTOCOL_DSP:
 939                                         NDR_CHECK(ndr_push_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
 940                                 break;
 941
 942                                 case EPM_PROTOCOL_DDP:
 943                                         NDR_CHECK(ndr_push_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
 944                                 break;
 945
 946                                 case EPM_PROTOCOL_APPLETALK:
 947                                         NDR_CHECK(ndr_push_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
 948                                 break;
 949
 950                                 case EPM_PROTOCOL_VINES_SPP:
 951                                         NDR_CHECK(ndr_push_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
 952                                 break;
 953
 954                                 case EPM_PROTOCOL_VINES_IPC:
 955                                         NDR_CHECK(ndr_push_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
 956                                 break;
 957
 958                                 case EPM_PROTOCOL_STREETTALK:
 959                                         NDR_CHECK(ndr_push_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
 960                                 break;
 961
 962                                 case EPM_PROTOCOL_HTTP:
 963                                         NDR_CHECK(ndr_push_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
 964                                 break;
 965
 966                                 case EPM_PROTOCOL_UNIX_DS:
 967                                         NDR_CHECK(ndr_push_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
 968                                 break;
 969
 970                                 case EPM_PROTOCOL_NULL:
 971                                         NDR_CHECK(ndr_push_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
 972                                 break;
 973
 974                                 default:
 975                                         {
 976                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 977                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 978                                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
 979                                                 ndr->flags = _flags_save_DATA_BLOB;
 980                                         }
 981                                 break;
 982
 983                         }
 984                 }
 985                 if (ndr_flags & NDR_BUFFERS) {
 986                         int level = ndr_push_get_switch_value(ndr, r);
 987                         switch (level) {
 988                                 case EPM_PROTOCOL_DNET_NSP:
 989                                 break;
 990
 991                                 case EPM_PROTOCOL_OSI_TP4:
 992                                 break;
 993
 994                                 case EPM_PROTOCOL_OSI_CLNS:
 995                                 break;
 996
 997                                 case EPM_PROTOCOL_TCP:
 998                                 break;
 999
1000                                 case EPM_PROTOCOL_UDP:
1001                                 break;
1002
1003                                 case EPM_PROTOCOL_IP:
1004                                 break;
1005
1006                                 case EPM_PROTOCOL_NCADG:
1007                                 break;
1008
1009                                 case EPM_PROTOCOL_NCACN:
1010                                 break;
1011
1012                                 case EPM_PROTOCOL_NCALRPC:
1013                                 break;
1014
1015                                 case EPM_PROTOCOL_UUID:
1016                                 break;
1017
1018                                 case EPM_PROTOCOL_IPX:
1019                                 break;
1020
1021                                 case EPM_PROTOCOL_SMB:
1022                                 break;
1023
1024                                 case EPM_PROTOCOL_PIPE:
1025                                 break;
1026
1027                                 case EPM_PROTOCOL_NETBIOS:
1028                                 break;
1029
1030                                 case EPM_PROTOCOL_NETBEUI:
1031                                 break;
1032
1033                                 case EPM_PROTOCOL_SPX:
1034                                 break;
1035
1036                                 case EPM_PROTOCOL_NB_IPX:
1037                                 break;
1038
1039                                 case EPM_PROTOCOL_DSP:
1040                                 break;
1041
1042                                 case EPM_PROTOCOL_DDP:
1043                                 break;
1044
1045                                 case EPM_PROTOCOL_APPLETALK:
1046                                 break;
1047
1048                                 case EPM_PROTOCOL_VINES_SPP:
1049                                 break;
1050
1051                                 case EPM_PROTOCOL_VINES_IPC:
1052                                 break;
1053
1054                                 case EPM_PROTOCOL_STREETTALK:
1055                                 break;
1056
1057                                 case EPM_PROTOCOL_HTTP:
1058                                 break;
1059
1060                                 case EPM_PROTOCOL_UNIX_DS:
1061                                 break;
1062
1063                                 case EPM_PROTOCOL_NULL:
1064                                 break;
1065
1066                                 default:
1067                                 break;
1068
1069                         }
1070                 }
1071                 ndr->flags = _flags_save_UNION;
1072         }
1073         return NT_STATUS_OK;
1074 }
1075
1076 NTSTATUS ndr_pull_epm_rhs(struct ndr_pull *ndr, int ndr_flags, union epm_rhs *r)
1077 {
1078         int level;
1079         {
1080                 uint32_t _flags_save_UNION = ndr->flags;
1081                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1082                 level = ndr_pull_get_switch_value(ndr, r);
1083                 if (ndr_flags & NDR_SCALARS) {
1084                         switch (level) {
1085                                 case EPM_PROTOCOL_DNET_NSP: {
1086                                         NDR_CHECK(ndr_pull_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
1087                                 break; }
1088
1089                                 case EPM_PROTOCOL_OSI_TP4: {
1090                                         NDR_CHECK(ndr_pull_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
1091                                 break; }
1092
1093                                 case EPM_PROTOCOL_OSI_CLNS: {
1094                                         NDR_CHECK(ndr_pull_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
1095                                 break; }
1096
1097                                 case EPM_PROTOCOL_TCP: {
1098                                         NDR_CHECK(ndr_pull_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
1099                                 break; }
1100
1101                                 case EPM_PROTOCOL_UDP: {
1102                                         NDR_CHECK(ndr_pull_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
1103                                 break; }
1104
1105                                 case EPM_PROTOCOL_IP: {
1106                                         NDR_CHECK(ndr_pull_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
1107                                 break; }
1108
1109                                 case EPM_PROTOCOL_NCADG: {
1110                                         NDR_CHECK(ndr_pull_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
1111                                 break; }
1112
1113                                 case EPM_PROTOCOL_NCACN: {
1114                                         NDR_CHECK(ndr_pull_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
1115                                 break; }
1116
1117                                 case EPM_PROTOCOL_NCALRPC: {
1118                                         NDR_CHECK(ndr_pull_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
1119                                 break; }
1120
1121                                 case EPM_PROTOCOL_UUID: {
1122                                         NDR_CHECK(ndr_pull_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
1123                                 break; }
1124
1125                                 case EPM_PROTOCOL_IPX: {
1126                                         NDR_CHECK(ndr_pull_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
1127                                 break; }
1128
1129                                 case EPM_PROTOCOL_SMB: {
1130                                         NDR_CHECK(ndr_pull_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
1131                                 break; }
1132
1133                                 case EPM_PROTOCOL_PIPE: {
1134                                         NDR_CHECK(ndr_pull_epm_rhs_pipe(ndr, NDR_SCALARS, &r->pipe));
1135                                 break; }
1136
1137                                 case EPM_PROTOCOL_NETBIOS: {
1138                                         NDR_CHECK(ndr_pull_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
1139                                 break; }
1140
1141                                 case EPM_PROTOCOL_NETBEUI: {
1142                                         NDR_CHECK(ndr_pull_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
1143                                 break; }
1144
1145                                 case EPM_PROTOCOL_SPX: {
1146                                         NDR_CHECK(ndr_pull_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
1147                                 break; }
1148
1149                                 case EPM_PROTOCOL_NB_IPX: {
1150                                         NDR_CHECK(ndr_pull_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
1151                                 break; }
1152
1153                                 case EPM_PROTOCOL_DSP: {
1154                                         NDR_CHECK(ndr_pull_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
1155                                 break; }
1156
1157                                 case EPM_PROTOCOL_DDP: {
1158                                         NDR_CHECK(ndr_pull_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
1159                                 break; }
1160
1161                                 case EPM_PROTOCOL_APPLETALK: {
1162                                         NDR_CHECK(ndr_pull_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
1163                                 break; }
1164
1165                                 case EPM_PROTOCOL_VINES_SPP: {
1166                                         NDR_CHECK(ndr_pull_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
1167                                 break; }
1168
1169                                 case EPM_PROTOCOL_VINES_IPC: {
1170                                         NDR_CHECK(ndr_pull_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
1171                                 break; }
1172
1173                                 case EPM_PROTOCOL_STREETTALK: {
1174                                         NDR_CHECK(ndr_pull_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
1175                                 break; }
1176
1177                                 case EPM_PROTOCOL_HTTP: {
1178                                         NDR_CHECK(ndr_pull_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
1179                                 break; }
1180
1181                                 case EPM_PROTOCOL_UNIX_DS: {
1182                                         NDR_CHECK(ndr_pull_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
1183                                 break; }
1184
1185                                 case EPM_PROTOCOL_NULL: {
1186                                         NDR_CHECK(ndr_pull_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
1187                                 break; }
1188
1189                                 default: {
1190                                         {
1191                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
1192                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1193                                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
1194                                                 ndr->flags = _flags_save_DATA_BLOB;
1195                                         }
1196                                 break; }
1197
1198                         }
1199                 }
1200                 if (ndr_flags & NDR_BUFFERS) {
1201                         switch (level) {
1202                                 case EPM_PROTOCOL_DNET_NSP:
1203                                 break;
1204
1205                                 case EPM_PROTOCOL_OSI_TP4:
1206                                 break;
1207
1208                                 case EPM_PROTOCOL_OSI_CLNS:
1209                                 break;
1210
1211                                 case EPM_PROTOCOL_TCP:
1212                                 break;
1213
1214                                 case EPM_PROTOCOL_UDP:
1215                                 break;
1216
1217                                 case EPM_PROTOCOL_IP:
1218                                 break;
1219
1220                                 case EPM_PROTOCOL_NCADG:
1221                                 break;
1222
1223                                 case EPM_PROTOCOL_NCACN:
1224                                 break;
1225
1226                                 case EPM_PROTOCOL_NCALRPC:
1227                                 break;
1228
1229                                 case EPM_PROTOCOL_UUID:
1230                                 break;
1231
1232                                 case EPM_PROTOCOL_IPX:
1233                                 break;
1234
1235                                 case EPM_PROTOCOL_SMB:
1236                                 break;
1237
1238                                 case EPM_PROTOCOL_PIPE:
1239                                 break;
1240
1241                                 case EPM_PROTOCOL_NETBIOS:
1242                                 break;
1243
1244                                 case EPM_PROTOCOL_NETBEUI:
1245                                 break;
1246
1247                                 case EPM_PROTOCOL_SPX:
1248                                 break;
1249
1250                                 case EPM_PROTOCOL_NB_IPX:
1251                                 break;
1252
1253                                 case EPM_PROTOCOL_DSP:
1254                                 break;
1255
1256                                 case EPM_PROTOCOL_DDP:
1257                                 break;
1258
1259                                 case EPM_PROTOCOL_APPLETALK:
1260                                 break;
1261
1262                                 case EPM_PROTOCOL_VINES_SPP:
1263                                 break;
1264
1265                                 case EPM_PROTOCOL_VINES_IPC:
1266                                 break;
1267
1268                                 case EPM_PROTOCOL_STREETTALK:
1269                                 break;
1270
1271                                 case EPM_PROTOCOL_HTTP:
1272                                 break;
1273
1274                                 case EPM_PROTOCOL_UNIX_DS:
1275                                 break;
1276
1277                                 case EPM_PROTOCOL_NULL:
1278                                 break;
1279
1280                                 default:
1281                                 break;
1282
1283                         }
1284                 }
1285                 ndr->flags = _flags_save_UNION;
1286         }
1287         return NT_STATUS_OK;
1288 }
1289
1290 _PUBLIC_ void ndr_print_epm_rhs(struct ndr_print *ndr, const char *name, const union epm_rhs *r)
1291 {
1292         int level;
1293         {
1294                 uint32_t _flags_save_UNION = ndr->flags;
1295                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1296                 level = ndr_print_get_switch_value(ndr, r);
1297                 ndr_print_union(ndr, name, level, "epm_rhs");
1298                 switch (level) {
1299                         case EPM_PROTOCOL_DNET_NSP:
1300                                 ndr_print_epm_rhs_dnet_nsp(ndr, "dnet_nsp", &r->dnet_nsp);
1301                         break;
1302
1303                         case EPM_PROTOCOL_OSI_TP4:
1304                                 ndr_print_epm_rhs_osi_tp4(ndr, "osi_tp4", &r->osi_tp4);
1305                         break;
1306
1307                         case EPM_PROTOCOL_OSI_CLNS:
1308                                 ndr_print_epm_rhs_osi_clns(ndr, "osi_clns", &r->osi_clns);
1309                         break;
1310
1311                         case EPM_PROTOCOL_TCP:
1312                                 ndr_print_epm_rhs_tcp(ndr, "tcp", &r->tcp);
1313                         break;
1314
1315                         case EPM_PROTOCOL_UDP:
1316                                 ndr_print_epm_rhs_udp(ndr, "udp", &r->udp);
1317                         break;
1318
1319                         case EPM_PROTOCOL_IP:
1320                                 ndr_print_epm_rhs_ip(ndr, "ip", &r->ip);
1321                         break;
1322
1323                         case EPM_PROTOCOL_NCADG:
1324                                 ndr_print_epm_rhs_ncadg(ndr, "ncadg", &r->ncadg);
1325                         break;
1326
1327                         case EPM_PROTOCOL_NCACN:
1328                                 ndr_print_epm_rhs_ncacn(ndr, "ncacn", &r->ncacn);
1329                         break;
1330
1331                         case EPM_PROTOCOL_NCALRPC:
1332                                 ndr_print_epm_rhs_ncalrpc(ndr, "ncalrpc", &r->ncalrpc);
1333                         break;
1334
1335                         case EPM_PROTOCOL_UUID:
1336                                 ndr_print_epm_rhs_uuid(ndr, "uuid", &r->uuid);
1337                         break;
1338
1339                         case EPM_PROTOCOL_IPX:
1340                                 ndr_print_epm_rhs_ipx(ndr, "ipx", &r->ipx);
1341                         break;
1342
1343                         case EPM_PROTOCOL_SMB:
1344                                 ndr_print_epm_rhs_smb(ndr, "smb", &r->smb);
1345                         break;
1346
1347                         case EPM_PROTOCOL_PIPE:
1348                                 ndr_print_epm_rhs_pipe(ndr, "pipe", &r->pipe);
1349                         break;
1350
1351                         case EPM_PROTOCOL_NETBIOS:
1352                                 ndr_print_epm_rhs_netbios(ndr, "netbios", &r->netbios);
1353                         break;
1354
1355                         case EPM_PROTOCOL_NETBEUI:
1356                                 ndr_print_epm_rhs_netbeui(ndr, "netbeui", &r->netbeui);
1357                         break;
1358
1359                         case EPM_PROTOCOL_SPX:
1360                                 ndr_print_epm_rhs_spx(ndr, "spx", &r->spx);
1361                         break;
1362
1363                         case EPM_PROTOCOL_NB_IPX:
1364                                 ndr_print_epm_rhs_nb_ipx(ndr, "nb_ipx", &r->nb_ipx);
1365                         break;
1366
1367                         case EPM_PROTOCOL_DSP:
1368                                 ndr_print_epm_rhs_atalk_stream(ndr, "atalk_stream", &r->atalk_stream);
1369                         break;
1370
1371                         case EPM_PROTOCOL_DDP:
1372                                 ndr_print_epm_rhs_atalk_datagram(ndr, "atalk_datagram", &r->atalk_datagram);
1373                         break;
1374
1375                         case EPM_PROTOCOL_APPLETALK:
1376                                 ndr_print_epm_rhs_appletalk(ndr, "appletalk", &r->appletalk);
1377                         break;
1378
1379                         case EPM_PROTOCOL_VINES_SPP:
1380                                 ndr_print_epm_rhs_vines_spp(ndr, "vines_spp", &r->vines_spp);
1381                         break;
1382
1383                         case EPM_PROTOCOL_VINES_IPC:
1384                                 ndr_print_epm_rhs_vines_ipc(ndr, "vines_ipc", &r->vines_ipc);
1385                         break;
1386
1387                         case EPM_PROTOCOL_STREETTALK:
1388                                 ndr_print_epm_rhs_streettalk(ndr, "streettalk", &r->streettalk);
1389                         break;
1390
1391                         case EPM_PROTOCOL_HTTP:
1392                                 ndr_print_epm_rhs_http(ndr, "http", &r->http);
1393                         break;
1394
1395                         case EPM_PROTOCOL_UNIX_DS:
1396                                 ndr_print_epm_rhs_unix_ds(ndr, "unix_ds", &r->unix_ds);
1397                         break;
1398
1399                         case EPM_PROTOCOL_NULL:
1400                                 ndr_print_epm_rhs_null(ndr, "null", &r->null);
1401                         break;
1402
1403                         default:
1404                                 ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
1405                         break;
1406
1407                 }
1408                 ndr->flags = _flags_save_UNION;
1409         }
1410 }
1411
1412 NTSTATUS ndr_push_epm_lhs(struct ndr_push *ndr, int ndr_flags, const struct epm_lhs *r)
1413 {
1414         if (ndr_flags & NDR_SCALARS) {
1415                 NDR_CHECK(ndr_push_align(ndr, 4));
1416                 NDR_CHECK(ndr_push_epm_protocol(ndr, NDR_SCALARS, r->protocol));
1417                 {
1418                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1419                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1420                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lhs_data));
1421                         ndr->flags = _flags_save_DATA_BLOB;
1422                 }
1423         }
1424         if (ndr_flags & NDR_BUFFERS) {
1425         }
1426         return NT_STATUS_OK;
1427 }
1428
1429 NTSTATUS ndr_pull_epm_lhs(struct ndr_pull *ndr, int ndr_flags, struct epm_lhs *r)
1430 {
1431         if (ndr_flags & NDR_SCALARS) {
1432                 NDR_CHECK(ndr_pull_align(ndr, 4));
1433                 NDR_CHECK(ndr_pull_epm_protocol(ndr, NDR_SCALARS, &r->protocol));
1434                 {
1435                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1437                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lhs_data));
1438                         ndr->flags = _flags_save_DATA_BLOB;
1439                 }
1440         }
1441         if (ndr_flags & NDR_BUFFERS) {
1442         }
1443         return NT_STATUS_OK;
1444 }
1445
1446 _PUBLIC_ void ndr_print_epm_lhs(struct ndr_print *ndr, const char *name, const struct epm_lhs *r)
1447 {
1448         ndr_print_struct(ndr, name, "epm_lhs");
1449         ndr->depth++;
1450         ndr_print_epm_protocol(ndr, "protocol", r->protocol);
1451         ndr_print_DATA_BLOB(ndr, "lhs_data", r->lhs_data);
1452         ndr->depth--;
1453 }
1454
1455 NTSTATUS ndr_push_epm_floor(struct ndr_push *ndr, int ndr_flags, const struct epm_floor *r)
1456 {
1457         if (ndr_flags & NDR_SCALARS) {
1458                 NDR_CHECK(ndr_push_align(ndr, 1));
1459                 {
1460                         struct ndr_push *_ndr_lhs;
1461                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_lhs, 2, -1));
1462                         NDR_CHECK(ndr_push_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
1463                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_lhs, 2, -1));
1464                 }
1465                 {
1466                         struct ndr_push *_ndr_rhs;
1467                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_rhs, 2, -1));
1468                         NDR_CHECK(ndr_push_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
1469                         NDR_CHECK(ndr_push_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
1470                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_rhs, 2, -1));
1471                 }
1472         }
1473         if (ndr_flags & NDR_BUFFERS) {
1474         }
1475         return NT_STATUS_OK;
1476 }
1477
1478 NTSTATUS ndr_pull_epm_floor(struct ndr_pull *ndr, int ndr_flags, struct epm_floor *r)
1479 {
1480         if (ndr_flags & NDR_SCALARS) {
1481                 NDR_CHECK(ndr_pull_align(ndr, 1));
1482                 {
1483                         struct ndr_pull *_ndr_lhs;
1484                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_lhs, 2, -1));
1485                         NDR_CHECK(ndr_pull_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
1486                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_lhs, 2, -1));
1487                 }
1488                 {
1489                         struct ndr_pull *_ndr_rhs;
1490                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_rhs, 2, -1));
1491                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
1492                         NDR_CHECK(ndr_pull_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
1493                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_rhs, 2, -1));
1494                 }
1495         }
1496         if (ndr_flags & NDR_BUFFERS) {
1497         }
1498         return NT_STATUS_OK;
1499 }
1500
1501 _PUBLIC_ void ndr_print_epm_floor(struct ndr_print *ndr, const char *name, const struct epm_floor *r)
1502 {
1503         ndr_print_struct(ndr, name, "epm_floor");
1504         ndr->depth++;
1505         ndr_print_epm_lhs(ndr, "lhs", &r->lhs);
1506         ndr_print_set_switch_value(ndr, &r->rhs, r->lhs.protocol);
1507         ndr_print_epm_rhs(ndr, "rhs", &r->rhs);
1508         ndr->depth--;
1509 }
1510
1511 NTSTATUS ndr_push_epm_tower(struct ndr_push *ndr, int ndr_flags, const struct epm_tower *r)
1512 {
1513         uint32_t cntr_floors_0;
1514         {
1515                 uint32_t _flags_save_STRUCT = ndr->flags;
1516                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1517                 if (ndr_flags & NDR_SCALARS) {
1518                         NDR_CHECK(ndr_push_align(ndr, 2));
1519                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_floors));
1520                         for (cntr_floors_0 = 0; cntr_floors_0 < r->num_floors; cntr_floors_0++) {
1521                                 NDR_CHECK(ndr_push_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
1522                         }
1523                 }
1524                 if (ndr_flags & NDR_BUFFERS) {
1525                 }
1526                 ndr->flags = _flags_save_STRUCT;
1527         }
1528         return NT_STATUS_OK;
1529 }
1530
1531 NTSTATUS ndr_pull_epm_tower(struct ndr_pull *ndr, int ndr_flags, struct epm_tower *r)
1532 {
1533         uint32_t cntr_floors_0;
1534         TALLOC_CTX *_mem_save_floors_0;
1535         {
1536                 uint32_t _flags_save_STRUCT = ndr->flags;
1537                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1538                 if (ndr_flags & NDR_SCALARS) {
1539                         NDR_CHECK(ndr_pull_align(ndr, 2));
1540                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_floors));
1541                         NDR_PULL_ALLOC_N(ndr, r->floors, r->num_floors);
1542                         _mem_save_floors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1543                         NDR_PULL_SET_MEM_CTX(ndr, r->floors, 0);
1544                         for (cntr_floors_0 = 0; cntr_floors_0 < r->num_floors; cntr_floors_0++) {
1545                                 NDR_CHECK(ndr_pull_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
1546                         }
1547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_floors_0, 0);
1548                 }
1549                 if (ndr_flags & NDR_BUFFERS) {
1550                 }
1551                 ndr->flags = _flags_save_STRUCT;
1552         }
1553         return NT_STATUS_OK;
1554 }
1555
1556 _PUBLIC_ void ndr_print_epm_tower(struct ndr_print *ndr, const char *name, const struct epm_tower *r)
1557 {
1558         uint32_t cntr_floors_0;
1559         ndr_print_struct(ndr, name, "epm_tower");
1560         {
1561                 uint32_t _flags_save_STRUCT = ndr->flags;
1562                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1563                 ndr->depth++;
1564                 ndr_print_uint16(ndr, "num_floors", r->num_floors);
1565                 ndr->print(ndr, "%s: ARRAY(%d)", "floors", r->num_floors);
1566                 ndr->depth++;
1567                 for (cntr_floors_0=0;cntr_floors_0<r->num_floors;cntr_floors_0++) {
1568                         char *idx_0=NULL;
1569                         asprintf(&idx_0, "[%d]", cntr_floors_0);
1570                         if (idx_0) {
1571                                 ndr_print_epm_floor(ndr, "floors", &r->floors[cntr_floors_0]);
1572                                 free(idx_0);
1573                         }
1574                 }
1575                 ndr->depth--;
1576                 ndr->depth--;
1577                 ndr->flags = _flags_save_STRUCT;
1578         }
1579 }
1580
1581 size_t ndr_size_epm_tower(const struct epm_tower *r, int flags)
1582 {
1583         flags |= LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN;
1584         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_epm_tower);
1585 }
1586
1587 NTSTATUS ndr_push_epm_twr_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_t *r)
1588 {
1589         if (ndr_flags & NDR_SCALARS) {
1590                 NDR_CHECK(ndr_push_align(ndr, 4));
1591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_epm_tower(&r->tower, ndr->flags)));
1592                 {
1593                         struct ndr_push *_ndr_tower;
1594                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_tower, 4, -1));
1595                         NDR_CHECK(ndr_push_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1596                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_tower, 4, -1));
1597                 }
1598         }
1599         if (ndr_flags & NDR_BUFFERS) {
1600         }
1601         return NT_STATUS_OK;
1602 }
1603
1604 NTSTATUS ndr_pull_epm_twr_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_t *r)
1605 {
1606         if (ndr_flags & NDR_SCALARS) {
1607                 NDR_CHECK(ndr_pull_align(ndr, 4));
1608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tower_length));
1609                 {
1610                         struct ndr_pull *_ndr_tower;
1611                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_tower, 4, -1));
1612                         NDR_CHECK(ndr_pull_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1613                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_tower, 4, -1));
1614                 }
1615         }
1616         if (ndr_flags & NDR_BUFFERS) {
1617         }
1618         return NT_STATUS_OK;
1619 }
1620
1621 _PUBLIC_ void ndr_print_epm_twr_t(struct ndr_print *ndr, const char *name, const struct epm_twr_t *r)
1622 {
1623         ndr_print_struct(ndr, name, "epm_twr_t");
1624         ndr->depth++;
1625         ndr_print_uint32(ndr, "tower_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_epm_tower(&r->tower, ndr->flags):r->tower_length);
1626         ndr_print_epm_tower(ndr, "tower", &r->tower);
1627         ndr->depth--;
1628 }
1629
1630 NTSTATUS ndr_push_epm_entry_t(struct ndr_push *ndr, int ndr_flags, const struct epm_entry_t *r)
1631 {
1632         if (ndr_flags & NDR_SCALARS) {
1633                 NDR_CHECK(ndr_push_align(ndr, 4));
1634                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
1635                 NDR_CHECK(ndr_push_full_ptr(ndr, r->tower));
1636                 {
1637                         uint32_t _flags_save_string = ndr->flags;
1638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4);
1639                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->annotation));
1640                         ndr->flags = _flags_save_string;
1641                 }
1642         }
1643         if (ndr_flags & NDR_BUFFERS) {
1644                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->object));
1645                 if (r->tower) {
1646                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1647                 }
1648         }
1649         return NT_STATUS_OK;
1650 }
1651
1652 NTSTATUS ndr_pull_epm_entry_t(struct ndr_pull *ndr, int ndr_flags, struct epm_entry_t *r)
1653 {
1654         uint32_t _ptr_tower;
1655         TALLOC_CTX *_mem_save_tower_0;
1656         if (ndr_flags & NDR_SCALARS) {
1657                 NDR_CHECK(ndr_pull_align(ndr, 4));
1658                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
1659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
1660                 if (_ptr_tower) {
1661                         NDR_PULL_ALLOC(ndr, r->tower);
1662                 } else {
1663                         r->tower = NULL;
1664                 }
1665                 {
1666                         uint32_t _flags_save_string = ndr->flags;
1667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4);
1668                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->annotation));
1669                         ndr->flags = _flags_save_string;
1670                 }
1671         }
1672         if (ndr_flags & NDR_BUFFERS) {
1673                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->object));
1674                 if (r->tower) {
1675                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
1676                         NDR_PULL_SET_MEM_CTX(ndr, r->tower, 0);
1677                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
1679                 }
1680         }
1681         return NT_STATUS_OK;
1682 }
1683
1684 _PUBLIC_ void ndr_print_epm_entry_t(struct ndr_print *ndr, const char *name, const struct epm_entry_t *r)
1685 {
1686         ndr_print_struct(ndr, name, "epm_entry_t");
1687         ndr->depth++;
1688         ndr_print_GUID(ndr, "object", &r->object);
1689         ndr_print_ptr(ndr, "tower", r->tower);
1690         ndr->depth++;
1691         if (r->tower) {
1692                 ndr_print_epm_twr_t(ndr, "tower", r->tower);
1693         }
1694         ndr->depth--;
1695         ndr_print_string(ndr, "annotation", r->annotation);
1696         ndr->depth--;
1697 }
1698
1699 NTSTATUS ndr_push_rpc_if_id_t(struct ndr_push *ndr, int ndr_flags, const struct rpc_if_id_t *r)
1700 {
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_push_align(ndr, 4));
1703                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
1704                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_major));
1705                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_minor));
1706         }
1707         if (ndr_flags & NDR_BUFFERS) {
1708                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->uuid));
1709         }
1710         return NT_STATUS_OK;
1711 }
1712
1713 NTSTATUS ndr_pull_rpc_if_id_t(struct ndr_pull *ndr, int ndr_flags, struct rpc_if_id_t *r)
1714 {
1715         if (ndr_flags & NDR_SCALARS) {
1716                 NDR_CHECK(ndr_pull_align(ndr, 4));
1717                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
1718                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_major));
1719                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_minor));
1720         }
1721         if (ndr_flags & NDR_BUFFERS) {
1722                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->uuid));
1723         }
1724         return NT_STATUS_OK;
1725 }
1726
1727 _PUBLIC_ void ndr_print_rpc_if_id_t(struct ndr_print *ndr, const char *name, const struct rpc_if_id_t *r)
1728 {
1729         ndr_print_struct(ndr, name, "rpc_if_id_t");
1730         ndr->depth++;
1731         ndr_print_GUID(ndr, "uuid", &r->uuid);
1732         ndr_print_uint16(ndr, "vers_major", r->vers_major);
1733         ndr_print_uint16(ndr, "vers_minor", r->vers_minor);
1734         ndr->depth--;
1735 }
1736
1737 NTSTATUS ndr_push_epm_twr_p_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_p_t *r)
1738 {
1739         if (ndr_flags & NDR_SCALARS) {
1740                 NDR_CHECK(ndr_push_align(ndr, 4));
1741                 NDR_CHECK(ndr_push_full_ptr(ndr, r->twr));
1742         }
1743         if (ndr_flags & NDR_BUFFERS) {
1744                 if (r->twr) {
1745                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1746                 }
1747         }
1748         return NT_STATUS_OK;
1749 }
1750
1751 NTSTATUS ndr_pull_epm_twr_p_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_p_t *r)
1752 {
1753         uint32_t _ptr_twr;
1754         TALLOC_CTX *_mem_save_twr_0;
1755         if (ndr_flags & NDR_SCALARS) {
1756                 NDR_CHECK(ndr_pull_align(ndr, 4));
1757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_twr));
1758                 if (_ptr_twr) {
1759                         NDR_PULL_ALLOC(ndr, r->twr);
1760                 } else {
1761                         r->twr = NULL;
1762                 }
1763         }
1764         if (ndr_flags & NDR_BUFFERS) {
1765                 if (r->twr) {
1766                         _mem_save_twr_0 = NDR_PULL_GET_MEM_CTX(ndr);
1767                         NDR_PULL_SET_MEM_CTX(ndr, r->twr, 0);
1768                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_twr_0, 0);
1770                 }
1771         }
1772         return NT_STATUS_OK;
1773 }
1774
1775 _PUBLIC_ void ndr_print_epm_twr_p_t(struct ndr_print *ndr, const char *name, const struct epm_twr_p_t *r)
1776 {
1777         ndr_print_struct(ndr, name, "epm_twr_p_t");
1778         ndr->depth++;
1779         ndr_print_ptr(ndr, "twr", r->twr);
1780         ndr->depth++;
1781         if (r->twr) {
1782                 ndr_print_epm_twr_t(ndr, "twr", r->twr);
1783         }
1784         ndr->depth--;
1785         ndr->depth--;
1786 }
1787
1788 NTSTATUS ndr_push_epm_Insert(struct ndr_push *ndr, int flags, const struct epm_Insert *r)
1789 {
1790         uint32_t cntr_entries_0;
1791         if (flags & NDR_IN) {
1792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1794                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1795                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1796                 }
1797                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1798                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1799                 }
1800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.replace));
1801         }
1802         if (flags & NDR_OUT) {
1803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1804         }
1805         return NT_STATUS_OK;
1806 }
1807
1808 NTSTATUS ndr_pull_epm_Insert(struct ndr_pull *ndr, int flags, struct epm_Insert *r)
1809 {
1810         uint32_t cntr_entries_0;
1811         TALLOC_CTX *_mem_save_entries_0;
1812         if (flags & NDR_IN) {
1813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1814                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1815                 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1816                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1817                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1818                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1819                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1820                 }
1821                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1822                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1823                 }
1824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.replace));
1826                 if (r->in.entries) {
1827                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1828                 }
1829         }
1830         if (flags & NDR_OUT) {
1831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1832         }
1833         return NT_STATUS_OK;
1834 }
1835
1836 _PUBLIC_ void ndr_print_epm_Insert(struct ndr_print *ndr, const char *name, int flags, const struct epm_Insert *r)
1837 {
1838         uint32_t cntr_entries_0;
1839         ndr_print_struct(ndr, name, "epm_Insert");
1840         ndr->depth++;
1841         if (flags & NDR_SET_VALUES) {
1842                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1843         }
1844         if (flags & NDR_IN) {
1845                 ndr_print_struct(ndr, "in", "epm_Insert");
1846                 ndr->depth++;
1847                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1848                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", r->in.num_ents);
1849                 ndr->depth++;
1850                 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1851                         char *idx_0=NULL;
1852                         asprintf(&idx_0, "[%d]", cntr_entries_0);
1853                         if (idx_0) {
1854                                 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1855                                 free(idx_0);
1856                         }
1857                 }
1858                 ndr->depth--;
1859                 ndr_print_uint32(ndr, "replace", r->in.replace);
1860                 ndr->depth--;
1861         }
1862         if (flags & NDR_OUT) {
1863                 ndr_print_struct(ndr, "out", "epm_Insert");
1864                 ndr->depth++;
1865                 ndr_print_uint32(ndr, "result", r->out.result);
1866                 ndr->depth--;
1867         }
1868         ndr->depth--;
1869 }
1870
1871 NTSTATUS ndr_push_epm_Delete(struct ndr_push *ndr, int flags, const struct epm_Delete *r)
1872 {
1873         uint32_t cntr_entries_0;
1874         if (flags & NDR_IN) {
1875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1877                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1878                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1879                 }
1880                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1881                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1882                 }
1883         }
1884         if (flags & NDR_OUT) {
1885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1886         }
1887         return NT_STATUS_OK;
1888 }
1889
1890 NTSTATUS ndr_pull_epm_Delete(struct ndr_pull *ndr, int flags, struct epm_Delete *r)
1891 {
1892         uint32_t cntr_entries_0;
1893         TALLOC_CTX *_mem_save_entries_0;
1894         if (flags & NDR_IN) {
1895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1896                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1897                 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1898                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1900                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1901                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1902                 }
1903                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1904                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1905                 }
1906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1907                 if (r->in.entries) {
1908                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1909                 }
1910         }
1911         if (flags & NDR_OUT) {
1912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1913         }
1914         return NT_STATUS_OK;
1915 }
1916
1917 _PUBLIC_ void ndr_print_epm_Delete(struct ndr_print *ndr, const char *name, int flags, const struct epm_Delete *r)
1918 {
1919         uint32_t cntr_entries_0;
1920         ndr_print_struct(ndr, name, "epm_Delete");
1921         ndr->depth++;
1922         if (flags & NDR_SET_VALUES) {
1923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1924         }
1925         if (flags & NDR_IN) {
1926                 ndr_print_struct(ndr, "in", "epm_Delete");
1927                 ndr->depth++;
1928                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1929                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", r->in.num_ents);
1930                 ndr->depth++;
1931                 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1932                         char *idx_0=NULL;
1933                         asprintf(&idx_0, "[%d]", cntr_entries_0);
1934                         if (idx_0) {
1935                                 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1936                                 free(idx_0);
1937                         }
1938                 }
1939                 ndr->depth--;
1940                 ndr->depth--;
1941         }
1942         if (flags & NDR_OUT) {
1943                 ndr_print_struct(ndr, "out", "epm_Delete");
1944                 ndr->depth++;
1945                 ndr_print_uint32(ndr, "result", r->out.result);
1946                 ndr->depth--;
1947         }
1948         ndr->depth--;
1949 }
1950
1951 NTSTATUS ndr_push_epm_Lookup(struct ndr_push *ndr, int flags, const struct epm_Lookup *r)
1952 {
1953         uint32_t cntr_entries_0;
1954         if (flags & NDR_IN) {
1955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.inquiry_type));
1956                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
1957                 if (r->in.object) {
1958                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
1959                 }
1960                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.interface_id));
1961                 if (r->in.interface_id) {
1962                         NDR_CHECK(ndr_push_rpc_if_id_t(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.interface_id));
1963                 }
1964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.vers_option));
1965                 if (r->in.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
1967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
1968         }
1969         if (flags & NDR_OUT) {
1970                 if (r->out.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1971                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
1972                 if (r->out.num_ents == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
1974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
1975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
1977                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1978                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
1979                 }
1980                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1981                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
1982                 }
1983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1984         }
1985         return NT_STATUS_OK;
1986 }
1987
1988 NTSTATUS ndr_pull_epm_Lookup(struct ndr_pull *ndr, int flags, struct epm_Lookup *r)
1989 {
1990         uint32_t _ptr_object;
1991         uint32_t _ptr_interface_id;
1992         uint32_t cntr_entries_0;
1993         TALLOC_CTX *_mem_save_object_0;
1994         TALLOC_CTX *_mem_save_interface_id_0;
1995         TALLOC_CTX *_mem_save_entry_handle_0;
1996         TALLOC_CTX *_mem_save_num_ents_0;
1997         TALLOC_CTX *_mem_save_entries_0;
1998         if (flags & NDR_IN) {
1999                 ZERO_STRUCT(r->out);
2000
2001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.inquiry_type));
2002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2003                 if (_ptr_object) {
2004                         NDR_PULL_ALLOC(ndr, r->in.object);
2005                 } else {
2006                         r->in.object = NULL;
2007                 }
2008                 if (r->in.object) {
2009                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2010                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2011                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
2012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2013                 }
2014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_interface_id));
2015                 if (_ptr_interface_id) {
2016                         NDR_PULL_ALLOC(ndr, r->in.interface_id);
2017                 } else {
2018                         r->in.interface_id = NULL;
2019                 }
2020                 if (r->in.interface_id) {
2021                         _mem_save_interface_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                         NDR_PULL_SET_MEM_CTX(ndr, r->in.interface_id, 0);
2023                         NDR_CHECK(ndr_pull_rpc_if_id_t(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.interface_id));
2024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_interface_id_0, 0);
2025                 }
2026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.vers_option));
2027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2028                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2029                 }
2030                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2031                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2032                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
2033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_ents));
2035                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2036                 *r->out.entry_handle = *r->in.entry_handle;
2037                 NDR_PULL_ALLOC(ndr, r->out.num_ents);
2038                 ZERO_STRUCTP(r->out.num_ents);
2039         }
2040         if (flags & NDR_OUT) {
2041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2042                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2043                 }
2044                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2045                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
2047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2049                         NDR_PULL_ALLOC(ndr, r->out.num_ents);
2050                 }
2051                 _mem_save_num_ents_0 = NDR_PULL_GET_MEM_CTX(ndr);
2052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ents, LIBNDR_FLAG_REF_ALLOC);
2053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ents));
2054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ents_0, LIBNDR_FLAG_REF_ALLOC);
2055                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.entries));
2056                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.entries));
2057                 if (ndr_get_array_length(ndr, &r->out.entries) > ndr_get_array_size(ndr, &r->out.entries)) {
2058                         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.entries), ndr_get_array_length(ndr, &r->out.entries));
2059                 }
2060                 NDR_PULL_ALLOC_N(ndr, r->out.entries, ndr_get_array_size(ndr, &r->out.entries));
2061                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2062                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries, 0);
2063                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
2064                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
2065                 }
2066                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
2067                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
2068                 }
2069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
2070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2071                 if (r->out.entries) {
2072                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.entries, r->in.max_ents));
2073                 }
2074                 if (r->out.entries) {
2075                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.entries, *r->out.num_ents));
2076                 }
2077         }
2078         return NT_STATUS_OK;
2079 }
2080
2081 _PUBLIC_ void ndr_print_epm_Lookup(struct ndr_print *ndr, const char *name, int flags, const struct epm_Lookup *r)
2082 {
2083         uint32_t cntr_entries_0;
2084         ndr_print_struct(ndr, name, "epm_Lookup");
2085         ndr->depth++;
2086         if (flags & NDR_SET_VALUES) {
2087                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2088         }
2089         if (flags & NDR_IN) {
2090                 ndr_print_struct(ndr, "in", "epm_Lookup");
2091                 ndr->depth++;
2092                 ndr_print_uint32(ndr, "inquiry_type", r->in.inquiry_type);
2093                 ndr_print_ptr(ndr, "object", r->in.object);
2094                 ndr->depth++;
2095                 if (r->in.object) {
2096                         ndr_print_GUID(ndr, "object", r->in.object);
2097                 }
2098                 ndr->depth--;
2099                 ndr_print_ptr(ndr, "interface_id", r->in.interface_id);
2100                 ndr->depth++;
2101                 if (r->in.interface_id) {
2102                         ndr_print_rpc_if_id_t(ndr, "interface_id", r->in.interface_id);
2103                 }
2104                 ndr->depth--;
2105                 ndr_print_uint32(ndr, "vers_option", r->in.vers_option);
2106                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2107                 ndr->depth++;
2108                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2109                 ndr->depth--;
2110                 ndr_print_uint32(ndr, "max_ents", r->in.max_ents);
2111                 ndr->depth--;
2112         }
2113         if (flags & NDR_OUT) {
2114                 ndr_print_struct(ndr, "out", "epm_Lookup");
2115                 ndr->depth++;
2116                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2117                 ndr->depth++;
2118                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2119                 ndr->depth--;
2120                 ndr_print_ptr(ndr, "num_ents", r->out.num_ents);
2121                 ndr->depth++;
2122                 ndr_print_uint32(ndr, "num_ents", *r->out.num_ents);
2123                 ndr->depth--;
2124                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", *r->out.num_ents);
2125                 ndr->depth++;
2126                 for (cntr_entries_0=0;cntr_entries_0<*r->out.num_ents;cntr_entries_0++) {
2127                         char *idx_0=NULL;
2128                         asprintf(&idx_0, "[%d]", cntr_entries_0);
2129                         if (idx_0) {
2130                                 ndr_print_epm_entry_t(ndr, "entries", &r->out.entries[cntr_entries_0]);
2131                                 free(idx_0);
2132                         }
2133                 }
2134                 ndr->depth--;
2135                 ndr_print_uint32(ndr, "result", r->out.result);
2136                 ndr->depth--;
2137         }
2138         ndr->depth--;
2139 }
2140
2141 _PUBLIC_ NTSTATUS ndr_push_epm_Map(struct ndr_push *ndr, int flags, const struct epm_Map *r)
2142 {
2143         uint32_t cntr_towers_0;
2144         if (flags & NDR_IN) {
2145                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2146                 if (r->in.object) {
2147                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
2148                 }
2149                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.map_tower));
2150                 if (r->in.map_tower) {
2151                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2152                 }
2153                 if (r->in.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2154                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
2155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_towers));
2156         }
2157         if (flags & NDR_OUT) {
2158                 if (r->out.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2159                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
2160                 if (r->out.num_towers == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
2162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_towers));
2163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
2165                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2166                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2167                 }
2168                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2169                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2170                 }
2171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2172         }
2173         return NT_STATUS_OK;
2174 }
2175
2176 _PUBLIC_ NTSTATUS ndr_pull_epm_Map(struct ndr_pull *ndr, int flags, struct epm_Map *r)
2177 {
2178         uint32_t _ptr_object;
2179         uint32_t _ptr_map_tower;
2180         uint32_t cntr_towers_0;
2181         TALLOC_CTX *_mem_save_object_0;
2182         TALLOC_CTX *_mem_save_map_tower_0;
2183         TALLOC_CTX *_mem_save_entry_handle_0;
2184         TALLOC_CTX *_mem_save_num_towers_0;
2185         TALLOC_CTX *_mem_save_towers_0;
2186         if (flags & NDR_IN) {
2187                 ZERO_STRUCT(r->out);
2188
2189                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2190                 if (_ptr_object) {
2191                         NDR_PULL_ALLOC(ndr, r->in.object);
2192                 } else {
2193                         r->in.object = NULL;
2194                 }
2195                 if (r->in.object) {
2196                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2197                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2198                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
2199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2200                 }
2201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_map_tower));
2202                 if (_ptr_map_tower) {
2203                         NDR_PULL_ALLOC(ndr, r->in.map_tower);
2204                 } else {
2205                         r->in.map_tower = NULL;
2206                 }
2207                 if (r->in.map_tower) {
2208                         _mem_save_map_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2209                         NDR_PULL_SET_MEM_CTX(ndr, r->in.map_tower, 0);
2210                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_map_tower_0, 0);
2212                 }
2213                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2214                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2215                 }
2216                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2217                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2218                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
2219                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_towers));
2221                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2222                 *r->out.entry_handle = *r->in.entry_handle;
2223                 NDR_PULL_ALLOC(ndr, r->out.num_towers);
2224                 ZERO_STRUCTP(r->out.num_towers);
2225         }
2226         if (flags & NDR_OUT) {
2227                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2228                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2229                 }
2230                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2231                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2232                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
2233                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2235                         NDR_PULL_ALLOC(ndr, r->out.num_towers);
2236                 }
2237                 _mem_save_num_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2238                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_towers, LIBNDR_FLAG_REF_ALLOC);
2239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_towers));
2240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_towers_0, LIBNDR_FLAG_REF_ALLOC);
2241                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.towers));
2242                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.towers));
2243                 if (ndr_get_array_length(ndr, &r->out.towers) > ndr_get_array_size(ndr, &r->out.towers)) {
2244                         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.towers), ndr_get_array_length(ndr, &r->out.towers));
2245                 }
2246                 NDR_PULL_ALLOC_N(ndr, r->out.towers, ndr_get_array_size(ndr, &r->out.towers));
2247                 _mem_save_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2248                 NDR_PULL_SET_MEM_CTX(ndr, r->out.towers, 0);
2249                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2250                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2251                 }
2252                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2253                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2254                 }
2255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_towers_0, 0);
2256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2257                 if (r->out.towers) {
2258                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.towers, r->in.max_towers));
2259                 }
2260                 if (r->out.towers) {
2261                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.towers, *r->out.num_towers));
2262                 }
2263         }
2264         return NT_STATUS_OK;
2265 }
2266
2267 _PUBLIC_ void ndr_print_epm_Map(struct ndr_print *ndr, const char *name, int flags, const struct epm_Map *r)
2268 {
2269         uint32_t cntr_towers_0;
2270         ndr_print_struct(ndr, name, "epm_Map");
2271         ndr->depth++;
2272         if (flags & NDR_SET_VALUES) {
2273                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2274         }
2275         if (flags & NDR_IN) {
2276                 ndr_print_struct(ndr, "in", "epm_Map");
2277                 ndr->depth++;
2278                 ndr_print_ptr(ndr, "object", r->in.object);
2279                 ndr->depth++;
2280                 if (r->in.object) {
2281                         ndr_print_GUID(ndr, "object", r->in.object);
2282                 }
2283                 ndr->depth--;
2284                 ndr_print_ptr(ndr, "map_tower", r->in.map_tower);
2285                 ndr->depth++;
2286                 if (r->in.map_tower) {
2287                         ndr_print_epm_twr_t(ndr, "map_tower", r->in.map_tower);
2288                 }
2289                 ndr->depth--;
2290                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2291                 ndr->depth++;
2292                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2293                 ndr->depth--;
2294                 ndr_print_uint32(ndr, "max_towers", r->in.max_towers);
2295                 ndr->depth--;
2296         }
2297         if (flags & NDR_OUT) {
2298                 ndr_print_struct(ndr, "out", "epm_Map");
2299                 ndr->depth++;
2300                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2301                 ndr->depth++;
2302                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2303                 ndr->depth--;
2304                 ndr_print_ptr(ndr, "num_towers", r->out.num_towers);
2305                 ndr->depth++;
2306                 ndr_print_uint32(ndr, "num_towers", *r->out.num_towers);
2307                 ndr->depth--;
2308                 ndr->print(ndr, "%s: ARRAY(%d)", "towers", *r->out.num_towers);
2309                 ndr->depth++;
2310                 for (cntr_towers_0=0;cntr_towers_0<*r->out.num_towers;cntr_towers_0++) {
2311                         char *idx_0=NULL;
2312                         asprintf(&idx_0, "[%d]", cntr_towers_0);
2313                         if (idx_0) {
2314                                 ndr_print_epm_twr_p_t(ndr, "towers", &r->out.towers[cntr_towers_0]);
2315                                 free(idx_0);
2316                         }
2317                 }
2318                 ndr->depth--;
2319                 ndr_print_uint32(ndr, "result", r->out.result);
2320                 ndr->depth--;
2321         }
2322         ndr->depth--;
2323 }
2324
2325 NTSTATUS ndr_push_epm_LookupHandleFree(struct ndr_push *ndr, int flags, const struct epm_LookupHandleFree *r)
2326 {
2327         if (flags & NDR_IN) {
2328                 if (r->in.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2329                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
2330         }
2331         if (flags & NDR_OUT) {
2332                 if (r->out.entry_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
2334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2335         }
2336         return NT_STATUS_OK;
2337 }
2338
2339 NTSTATUS ndr_pull_epm_LookupHandleFree(struct ndr_pull *ndr, int flags, struct epm_LookupHandleFree *r)
2340 {
2341         TALLOC_CTX *_mem_save_entry_handle_0;
2342         if (flags & NDR_IN) {
2343                 ZERO_STRUCT(r->out);
2344
2345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2346                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2347                 }
2348                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2349                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.entry_handle));
2351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2352                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2353                 *r->out.entry_handle = *r->in.entry_handle;
2354         }
2355         if (flags & NDR_OUT) {
2356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2357                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2358                 }
2359                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.entry_handle));
2362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2364         }
2365         return NT_STATUS_OK;
2366 }
2367
2368 _PUBLIC_ void ndr_print_epm_LookupHandleFree(struct ndr_print *ndr, const char *name, int flags, const struct epm_LookupHandleFree *r)
2369 {
2370         ndr_print_struct(ndr, name, "epm_LookupHandleFree");
2371         ndr->depth++;
2372         if (flags & NDR_SET_VALUES) {
2373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2374         }
2375         if (flags & NDR_IN) {
2376                 ndr_print_struct(ndr, "in", "epm_LookupHandleFree");
2377                 ndr->depth++;
2378                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2379                 ndr->depth++;
2380                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2381                 ndr->depth--;
2382                 ndr->depth--;
2383         }
2384         if (flags & NDR_OUT) {
2385                 ndr_print_struct(ndr, "out", "epm_LookupHandleFree");
2386                 ndr->depth++;
2387                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2388                 ndr->depth++;
2389                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2390                 ndr->depth--;
2391                 ndr_print_uint32(ndr, "result", r->out.result);
2392                 ndr->depth--;
2393         }
2394         ndr->depth--;
2395 }
2396
2397 NTSTATUS ndr_push_epm_InqObject(struct ndr_push *ndr, int flags, const struct epm_InqObject *r)
2398 {
2399         if (flags & NDR_IN) {
2400                 if (r->in.epm_object == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2401                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.epm_object));
2402         }
2403         if (flags & NDR_OUT) {
2404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2405         }
2406         return NT_STATUS_OK;
2407 }
2408
2409 NTSTATUS ndr_pull_epm_InqObject(struct ndr_pull *ndr, int flags, struct epm_InqObject *r)
2410 {
2411         TALLOC_CTX *_mem_save_epm_object_0;
2412         if (flags & NDR_IN) {
2413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2414                         NDR_PULL_ALLOC(ndr, r->in.epm_object);
2415                 }
2416                 _mem_save_epm_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.epm_object, LIBNDR_FLAG_REF_ALLOC);
2418                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.epm_object));
2419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epm_object_0, LIBNDR_FLAG_REF_ALLOC);
2420         }
2421         if (flags & NDR_OUT) {
2422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2423         }
2424         return NT_STATUS_OK;
2425 }
2426
2427 _PUBLIC_ void ndr_print_epm_InqObject(struct ndr_print *ndr, const char *name, int flags, const struct epm_InqObject *r)
2428 {
2429         ndr_print_struct(ndr, name, "epm_InqObject");
2430         ndr->depth++;
2431         if (flags & NDR_SET_VALUES) {
2432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2433         }
2434         if (flags & NDR_IN) {
2435                 ndr_print_struct(ndr, "in", "epm_InqObject");
2436                 ndr->depth++;
2437                 ndr_print_ptr(ndr, "epm_object", r->in.epm_object);
2438                 ndr->depth++;
2439                 ndr_print_GUID(ndr, "epm_object", r->in.epm_object);
2440                 ndr->depth--;
2441                 ndr->depth--;
2442         }
2443         if (flags & NDR_OUT) {
2444                 ndr_print_struct(ndr, "out", "epm_InqObject");
2445                 ndr->depth++;
2446                 ndr_print_uint32(ndr, "result", r->out.result);
2447                 ndr->depth--;
2448         }
2449         ndr->depth--;
2450 }
2451
2452 NTSTATUS ndr_push_epm_MgmtDelete(struct ndr_push *ndr, int flags, const struct epm_MgmtDelete *r)
2453 {
2454         if (flags & NDR_IN) {
2455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.object_speced));
2456                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2457                 if (r->in.object) {
2458                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
2459                 }
2460                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.tower));
2461                 if (r->in.tower) {
2462                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2463                 }
2464         }
2465         if (flags & NDR_OUT) {
2466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2467         }
2468         return NT_STATUS_OK;
2469 }
2470
2471 NTSTATUS ndr_pull_epm_MgmtDelete(struct ndr_pull *ndr, int flags, struct epm_MgmtDelete *r)
2472 {
2473         uint32_t _ptr_object;
2474         uint32_t _ptr_tower;
2475         TALLOC_CTX *_mem_save_object_0;
2476         TALLOC_CTX *_mem_save_tower_0;
2477         if (flags & NDR_IN) {
2478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.object_speced));
2479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2480                 if (_ptr_object) {
2481                         NDR_PULL_ALLOC(ndr, r->in.object);
2482                 } else {
2483                         r->in.object = NULL;
2484                 }
2485                 if (r->in.object) {
2486                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2488                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.object));
2489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2490                 }
2491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
2492                 if (_ptr_tower) {
2493                         NDR_PULL_ALLOC(ndr, r->in.tower);
2494                 } else {
2495                         r->in.tower = NULL;
2496                 }
2497                 if (r->in.tower) {
2498                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2499                         NDR_PULL_SET_MEM_CTX(ndr, r->in.tower, 0);
2500                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
2502                 }
2503         }
2504         if (flags & NDR_OUT) {
2505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2506         }
2507         return NT_STATUS_OK;
2508 }
2509
2510 _PUBLIC_ void ndr_print_epm_MgmtDelete(struct ndr_print *ndr, const char *name, int flags, const struct epm_MgmtDelete *r)
2511 {
2512         ndr_print_struct(ndr, name, "epm_MgmtDelete");
2513         ndr->depth++;
2514         if (flags & NDR_SET_VALUES) {
2515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2516         }
2517         if (flags & NDR_IN) {
2518                 ndr_print_struct(ndr, "in", "epm_MgmtDelete");
2519                 ndr->depth++;
2520                 ndr_print_uint32(ndr, "object_speced", r->in.object_speced);
2521                 ndr_print_ptr(ndr, "object", r->in.object);
2522                 ndr->depth++;
2523                 if (r->in.object) {
2524                         ndr_print_GUID(ndr, "object", r->in.object);
2525                 }
2526                 ndr->depth--;
2527                 ndr_print_ptr(ndr, "tower", r->in.tower);
2528                 ndr->depth++;
2529                 if (r->in.tower) {
2530                         ndr_print_epm_twr_t(ndr, "tower", r->in.tower);
2531                 }
2532                 ndr->depth--;
2533                 ndr->depth--;
2534         }
2535         if (flags & NDR_OUT) {
2536                 ndr_print_struct(ndr, "out", "epm_MgmtDelete");
2537                 ndr->depth++;
2538                 ndr_print_uint32(ndr, "result", r->out.result);
2539                 ndr->depth--;
2540         }
2541         ndr->depth--;
2542 }
2543
2544 NTSTATUS ndr_push_epm_MapAuth(struct ndr_push *ndr, int flags, const struct epm_MapAuth *r)
2545 {
2546         if (flags & NDR_IN) {
2547         }
2548         if (flags & NDR_OUT) {
2549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2550         }
2551         return NT_STATUS_OK;
2552 }
2553
2554 NTSTATUS ndr_pull_epm_MapAuth(struct ndr_pull *ndr, int flags, struct epm_MapAuth *r)
2555 {
2556         if (flags & NDR_IN) {
2557         }
2558         if (flags & NDR_OUT) {
2559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2560         }
2561         return NT_STATUS_OK;
2562 }
2563
2564 _PUBLIC_ void ndr_print_epm_MapAuth(struct ndr_print *ndr, const char *name, int flags, const struct epm_MapAuth *r)
2565 {
2566         ndr_print_struct(ndr, name, "epm_MapAuth");
2567         ndr->depth++;
2568         if (flags & NDR_SET_VALUES) {
2569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2570         }
2571         if (flags & NDR_IN) {
2572                 ndr_print_struct(ndr, "in", "epm_MapAuth");
2573                 ndr->depth++;
2574                 ndr->depth--;
2575         }
2576         if (flags & NDR_OUT) {
2577                 ndr_print_struct(ndr, "out", "epm_MapAuth");
2578                 ndr->depth++;
2579                 ndr_print_uint32(ndr, "result", r->out.result);
2580                 ndr->depth--;
2581         }
2582         ndr->depth--;
2583 }
2584
2585 const struct ndr_interface_call epmapper_calls[] = {
2586         {
2587                 "epm_Insert",
2588                 sizeof(struct epm_Insert),
2589                 (ndr_push_flags_fn_t) ndr_push_epm_Insert,
2590                 (ndr_pull_flags_fn_t) ndr_pull_epm_Insert,
2591                 (ndr_print_function_t) ndr_print_epm_Insert,
2592                 False,
2593         },
2594         {
2595                 "epm_Delete",
2596                 sizeof(struct epm_Delete),
2597                 (ndr_push_flags_fn_t) ndr_push_epm_Delete,
2598                 (ndr_pull_flags_fn_t) ndr_pull_epm_Delete,
2599                 (ndr_print_function_t) ndr_print_epm_Delete,
2600                 False,
2601         },
2602         {
2603                 "epm_Lookup",
2604                 sizeof(struct epm_Lookup),
2605                 (ndr_push_flags_fn_t) ndr_push_epm_Lookup,
2606                 (ndr_pull_flags_fn_t) ndr_pull_epm_Lookup,
2607                 (ndr_print_function_t) ndr_print_epm_Lookup,
2608                 False,
2609         },
2610         {
2611                 "epm_Map",
2612                 sizeof(struct epm_Map),
2613                 (ndr_push_flags_fn_t) ndr_push_epm_Map,
2614                 (ndr_pull_flags_fn_t) ndr_pull_epm_Map,
2615                 (ndr_print_function_t) ndr_print_epm_Map,
2616                 False,
2617         },
2618         {
2619                 "epm_LookupHandleFree",
2620                 sizeof(struct epm_LookupHandleFree),
2621                 (ndr_push_flags_fn_t) ndr_push_epm_LookupHandleFree,
2622                 (ndr_pull_flags_fn_t) ndr_pull_epm_LookupHandleFree,
2623                 (ndr_print_function_t) ndr_print_epm_LookupHandleFree,
2624                 False,
2625         },
2626         {
2627                 "epm_InqObject",
2628                 sizeof(struct epm_InqObject),
2629                 (ndr_push_flags_fn_t) ndr_push_epm_InqObject,
2630                 (ndr_pull_flags_fn_t) ndr_pull_epm_InqObject,
2631                 (ndr_print_function_t) ndr_print_epm_InqObject,
2632                 False,
2633         },
2634         {
2635                 "epm_MgmtDelete",
2636                 sizeof(struct epm_MgmtDelete),
2637                 (ndr_push_flags_fn_t) ndr_push_epm_MgmtDelete,
2638                 (ndr_pull_flags_fn_t) ndr_pull_epm_MgmtDelete,
2639                 (ndr_print_function_t) ndr_print_epm_MgmtDelete,
2640                 False,
2641         },
2642         {
2643                 "epm_MapAuth",
2644                 sizeof(struct epm_MapAuth),
2645                 (ndr_push_flags_fn_t) ndr_push_epm_MapAuth,
2646                 (ndr_pull_flags_fn_t) ndr_pull_epm_MapAuth,
2647                 (ndr_print_function_t) ndr_print_epm_MapAuth,
2648                 False,
2649         },
2650         { NULL, 0, NULL, NULL, NULL, False }
2651 };
2652
2653 const char * const epmapper_endpoint_strings[] = {
2654         "ncacn_np:[\\pipe\\epmapper]",
2655         "ncacn_ip_tcp:[135]",
2656         "ncalrpc:[EPMAPPER]",
2657 };
2658
2659 const struct ndr_interface_string_array epmapper_endpoints = {
2660         .count  = 3,
2661         .names  = epmapper_endpoint_strings
2662 };
2663
2664 const char * const epmapper_authservice_strings[] = {
2665         "host",
2666 };
2667
2668 const struct ndr_interface_string_array epmapper_authservices = {
2669         .count  = 3,
2670         .names  = epmapper_authservice_strings
2671 };
2672
2673
2674 const struct dcerpc_interface_table dcerpc_table_epmapper = {
2675         .name           = "epmapper",
2676         .syntax_id      = {
2677                 {0xe1af8308,0x5d1f,0x11c9,{0x91,0xa4},{0x08,0x00,0x2b,0x14,0xa0,0xfa}},
2678                 DCERPC_EPMAPPER_VERSION
2679         },
2680         .helpstring     = DCERPC_EPMAPPER_HELPSTRING,
2681         .num_calls      = 8,
2682         .calls          = epmapper_calls,
2683         .endpoints      = &epmapper_endpoints,
2684         .authservices   = &epmapper_authservices
2685 };
2686