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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
  10 }
  11
  12 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
  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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
  63 }
  64
  65 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
  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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
  90 }
  91
  92 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 117 }
 118
 119 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 145 }
 146
 147 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 175 }
 176
 177 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 205 }
 206
 207 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 235 }
 236
 237 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 265 }
 266
 267 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 300 }
 301
 302 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 334 }
 335
 336 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 367 }
 368
 369 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 407 }
 408
 409 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 447 }
 448
 449 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 481 }
 482
 483 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 508 }
 509
 510 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 535 }
 536
 537 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 563 }
 564
 565 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 598 }
 599
 600 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 632 }
 633
 634 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 660 }
 661
 662 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 689 }
 690
 691 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 716 }
 717
 718 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 743 }
 744
 745 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 771 }
 772
 773 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 801 }
 802
 803 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 836 }
 837
 838 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
 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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
1074 }
1075
1076 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
1427 }
1428
1429 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
1476 }
1477
1478 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
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 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
1529 }
1530
1531 static enum ndr_err_code 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 NDR_ERR_SUCCESS;
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", (int)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                         if (asprintf(&idx_0, "[%d]", cntr_floors_0) != -1) {
1570                                 ndr_print_epm_floor(ndr, "floors", &r->floors[cntr_floors_0]);
1571                                 free(idx_0);
1572                         }
1573                 }
1574                 ndr->depth--;
1575                 ndr->depth--;
1576                 ndr->flags = _flags_save_STRUCT;
1577         }
1578 }
1579
1580 static size_t ndr_size_epm_tower(const struct epm_tower *r, int flags)
1581 {
1582         flags |= LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN;
1583         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_epm_tower);
1584 }
1585
1586 static enum ndr_err_code ndr_push_epm_twr_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_t *r)
1587 {
1588         if (ndr_flags & NDR_SCALARS) {
1589                 NDR_CHECK(ndr_push_align(ndr, 4));
1590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_epm_tower(&r->tower, ndr->flags)));
1591                 {
1592                         struct ndr_push *_ndr_tower;
1593                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_tower, 4, -1));
1594                         NDR_CHECK(ndr_push_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1595                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_tower, 4, -1));
1596                 }
1597         }
1598         if (ndr_flags & NDR_BUFFERS) {
1599         }
1600         return NDR_ERR_SUCCESS;
1601 }
1602
1603 static enum ndr_err_code ndr_pull_epm_twr_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_t *r)
1604 {
1605         if (ndr_flags & NDR_SCALARS) {
1606                 NDR_CHECK(ndr_pull_align(ndr, 4));
1607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tower_length));
1608                 {
1609                         struct ndr_pull *_ndr_tower;
1610                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_tower, 4, -1));
1611                         NDR_CHECK(ndr_pull_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1612                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_tower, 4, -1));
1613                 }
1614         }
1615         if (ndr_flags & NDR_BUFFERS) {
1616         }
1617         return NDR_ERR_SUCCESS;
1618 }
1619
1620 _PUBLIC_ void ndr_print_epm_twr_t(struct ndr_print *ndr, const char *name, const struct epm_twr_t *r)
1621 {
1622         ndr_print_struct(ndr, name, "epm_twr_t");
1623         ndr->depth++;
1624         ndr_print_uint32(ndr, "tower_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_epm_tower(&r->tower, ndr->flags):r->tower_length);
1625         ndr_print_epm_tower(ndr, "tower", &r->tower);
1626         ndr->depth--;
1627 }
1628
1629 static enum ndr_err_code ndr_push_epm_entry_t(struct ndr_push *ndr, int ndr_flags, const struct epm_entry_t *r)
1630 {
1631         if (ndr_flags & NDR_SCALARS) {
1632                 NDR_CHECK(ndr_push_align(ndr, 4));
1633                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
1634                 NDR_CHECK(ndr_push_full_ptr(ndr, r->tower));
1635                 {
1636                         uint32_t _flags_save_string = ndr->flags;
1637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4);
1638                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->annotation));
1639                         ndr->flags = _flags_save_string;
1640                 }
1641         }
1642         if (ndr_flags & NDR_BUFFERS) {
1643                 if (r->tower) {
1644                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1645                 }
1646         }
1647         return NDR_ERR_SUCCESS;
1648 }
1649
1650 static enum ndr_err_code ndr_pull_epm_entry_t(struct ndr_pull *ndr, int ndr_flags, struct epm_entry_t *r)
1651 {
1652         uint32_t _ptr_tower;
1653         TALLOC_CTX *_mem_save_tower_0;
1654         if (ndr_flags & NDR_SCALARS) {
1655                 NDR_CHECK(ndr_pull_align(ndr, 4));
1656                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
1657                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
1658                 if (_ptr_tower) {
1659                         NDR_PULL_ALLOC(ndr, r->tower);
1660                 } else {
1661                         r->tower = NULL;
1662                 }
1663                 {
1664                         uint32_t _flags_save_string = ndr->flags;
1665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4);
1666                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->annotation));
1667                         ndr->flags = _flags_save_string;
1668                 }
1669         }
1670         if (ndr_flags & NDR_BUFFERS) {
1671                 if (r->tower) {
1672                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
1673                         NDR_PULL_SET_MEM_CTX(ndr, r->tower, 0);
1674                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
1676                 }
1677         }
1678         return NDR_ERR_SUCCESS;
1679 }
1680
1681 _PUBLIC_ void ndr_print_epm_entry_t(struct ndr_print *ndr, const char *name, const struct epm_entry_t *r)
1682 {
1683         ndr_print_struct(ndr, name, "epm_entry_t");
1684         ndr->depth++;
1685         ndr_print_GUID(ndr, "object", &r->object);
1686         ndr_print_ptr(ndr, "tower", r->tower);
1687         ndr->depth++;
1688         if (r->tower) {
1689                 ndr_print_epm_twr_t(ndr, "tower", r->tower);
1690         }
1691         ndr->depth--;
1692         ndr_print_string(ndr, "annotation", r->annotation);
1693         ndr->depth--;
1694 }
1695
1696 static enum ndr_err_code ndr_push_rpc_if_id_t(struct ndr_push *ndr, int ndr_flags, const struct rpc_if_id_t *r)
1697 {
1698         if (ndr_flags & NDR_SCALARS) {
1699                 NDR_CHECK(ndr_push_align(ndr, 4));
1700                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
1701                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_major));
1702                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_minor));
1703         }
1704         if (ndr_flags & NDR_BUFFERS) {
1705         }
1706         return NDR_ERR_SUCCESS;
1707 }
1708
1709 static enum ndr_err_code ndr_pull_rpc_if_id_t(struct ndr_pull *ndr, int ndr_flags, struct rpc_if_id_t *r)
1710 {
1711         if (ndr_flags & NDR_SCALARS) {
1712                 NDR_CHECK(ndr_pull_align(ndr, 4));
1713                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
1714                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_major));
1715                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_minor));
1716         }
1717         if (ndr_flags & NDR_BUFFERS) {
1718         }
1719         return NDR_ERR_SUCCESS;
1720 }
1721
1722 _PUBLIC_ void ndr_print_rpc_if_id_t(struct ndr_print *ndr, const char *name, const struct rpc_if_id_t *r)
1723 {
1724         ndr_print_struct(ndr, name, "rpc_if_id_t");
1725         ndr->depth++;
1726         ndr_print_GUID(ndr, "uuid", &r->uuid);
1727         ndr_print_uint16(ndr, "vers_major", r->vers_major);
1728         ndr_print_uint16(ndr, "vers_minor", r->vers_minor);
1729         ndr->depth--;
1730 }
1731
1732 static enum ndr_err_code ndr_push_epm_twr_p_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_p_t *r)
1733 {
1734         if (ndr_flags & NDR_SCALARS) {
1735                 NDR_CHECK(ndr_push_align(ndr, 4));
1736                 NDR_CHECK(ndr_push_full_ptr(ndr, r->twr));
1737         }
1738         if (ndr_flags & NDR_BUFFERS) {
1739                 if (r->twr) {
1740                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1741                 }
1742         }
1743         return NDR_ERR_SUCCESS;
1744 }
1745
1746 static enum ndr_err_code ndr_pull_epm_twr_p_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_p_t *r)
1747 {
1748         uint32_t _ptr_twr;
1749         TALLOC_CTX *_mem_save_twr_0;
1750         if (ndr_flags & NDR_SCALARS) {
1751                 NDR_CHECK(ndr_pull_align(ndr, 4));
1752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_twr));
1753                 if (_ptr_twr) {
1754                         NDR_PULL_ALLOC(ndr, r->twr);
1755                 } else {
1756                         r->twr = NULL;
1757                 }
1758         }
1759         if (ndr_flags & NDR_BUFFERS) {
1760                 if (r->twr) {
1761                         _mem_save_twr_0 = NDR_PULL_GET_MEM_CTX(ndr);
1762                         NDR_PULL_SET_MEM_CTX(ndr, r->twr, 0);
1763                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_twr_0, 0);
1765                 }
1766         }
1767         return NDR_ERR_SUCCESS;
1768 }
1769
1770 _PUBLIC_ void ndr_print_epm_twr_p_t(struct ndr_print *ndr, const char *name, const struct epm_twr_p_t *r)
1771 {
1772         ndr_print_struct(ndr, name, "epm_twr_p_t");
1773         ndr->depth++;
1774         ndr_print_ptr(ndr, "twr", r->twr);
1775         ndr->depth++;
1776         if (r->twr) {
1777                 ndr_print_epm_twr_t(ndr, "twr", r->twr);
1778         }
1779         ndr->depth--;
1780         ndr->depth--;
1781 }
1782
1783 static enum ndr_err_code ndr_push_epm_Insert(struct ndr_push *ndr, int flags, const struct epm_Insert *r)
1784 {
1785         uint32_t cntr_entries_0;
1786         if (flags & NDR_IN) {
1787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1789                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1790                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1791                 }
1792                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1793                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1794                 }
1795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.replace));
1796         }
1797         if (flags & NDR_OUT) {
1798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1799         }
1800         return NDR_ERR_SUCCESS;
1801 }
1802
1803 static enum ndr_err_code ndr_pull_epm_Insert(struct ndr_pull *ndr, int flags, struct epm_Insert *r)
1804 {
1805         uint32_t cntr_entries_0;
1806         TALLOC_CTX *_mem_save_entries_0;
1807         if (flags & NDR_IN) {
1808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1810                 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1811                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1813                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1814                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1815                 }
1816                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1817                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1818                 }
1819                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.replace));
1821                 if (r->in.entries) {
1822                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1823                 }
1824         }
1825         if (flags & NDR_OUT) {
1826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1827         }
1828         return NDR_ERR_SUCCESS;
1829 }
1830
1831 _PUBLIC_ void ndr_print_epm_Insert(struct ndr_print *ndr, const char *name, int flags, const struct epm_Insert *r)
1832 {
1833         uint32_t cntr_entries_0;
1834         ndr_print_struct(ndr, name, "epm_Insert");
1835         ndr->depth++;
1836         if (flags & NDR_SET_VALUES) {
1837                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1838         }
1839         if (flags & NDR_IN) {
1840                 ndr_print_struct(ndr, "in", "epm_Insert");
1841                 ndr->depth++;
1842                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1843                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
1844                 ndr->depth++;
1845                 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1846                         char *idx_0=NULL;
1847                         if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1848                                 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1849                                 free(idx_0);
1850                         }
1851                 }
1852                 ndr->depth--;
1853                 ndr_print_uint32(ndr, "replace", r->in.replace);
1854                 ndr->depth--;
1855         }
1856         if (flags & NDR_OUT) {
1857                 ndr_print_struct(ndr, "out", "epm_Insert");
1858                 ndr->depth++;
1859                 ndr_print_uint32(ndr, "result", r->out.result);
1860                 ndr->depth--;
1861         }
1862         ndr->depth--;
1863 }
1864
1865 static enum ndr_err_code ndr_push_epm_Delete(struct ndr_push *ndr, int flags, const struct epm_Delete *r)
1866 {
1867         uint32_t cntr_entries_0;
1868         if (flags & NDR_IN) {
1869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1871                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1872                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1873                 }
1874                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1875                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1876                 }
1877         }
1878         if (flags & NDR_OUT) {
1879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1880         }
1881         return NDR_ERR_SUCCESS;
1882 }
1883
1884 static enum ndr_err_code ndr_pull_epm_Delete(struct ndr_pull *ndr, int flags, struct epm_Delete *r)
1885 {
1886         uint32_t cntr_entries_0;
1887         TALLOC_CTX *_mem_save_entries_0;
1888         if (flags & NDR_IN) {
1889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1890                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1891                 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1892                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1893                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1894                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1895                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1896                 }
1897                 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1898                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1899                 }
1900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1901                 if (r->in.entries) {
1902                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1903                 }
1904         }
1905         if (flags & NDR_OUT) {
1906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1907         }
1908         return NDR_ERR_SUCCESS;
1909 }
1910
1911 _PUBLIC_ void ndr_print_epm_Delete(struct ndr_print *ndr, const char *name, int flags, const struct epm_Delete *r)
1912 {
1913         uint32_t cntr_entries_0;
1914         ndr_print_struct(ndr, name, "epm_Delete");
1915         ndr->depth++;
1916         if (flags & NDR_SET_VALUES) {
1917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1918         }
1919         if (flags & NDR_IN) {
1920                 ndr_print_struct(ndr, "in", "epm_Delete");
1921                 ndr->depth++;
1922                 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1923                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
1924                 ndr->depth++;
1925                 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1926                         char *idx_0=NULL;
1927                         if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1928                                 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1929                                 free(idx_0);
1930                         }
1931                 }
1932                 ndr->depth--;
1933                 ndr->depth--;
1934         }
1935         if (flags & NDR_OUT) {
1936                 ndr_print_struct(ndr, "out", "epm_Delete");
1937                 ndr->depth++;
1938                 ndr_print_uint32(ndr, "result", r->out.result);
1939                 ndr->depth--;
1940         }
1941         ndr->depth--;
1942 }
1943
1944 static enum ndr_err_code ndr_push_epm_Lookup(struct ndr_push *ndr, int flags, const struct epm_Lookup *r)
1945 {
1946         uint32_t cntr_entries_0;
1947         if (flags & NDR_IN) {
1948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.inquiry_type));
1949                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
1950                 if (r->in.object) {
1951                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
1952                 }
1953                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.interface_id));
1954                 if (r->in.interface_id) {
1955                         NDR_CHECK(ndr_push_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
1956                 }
1957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.vers_option));
1958                 if (r->in.entry_handle == NULL) {
1959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1960                 }
1961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
1962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
1963         }
1964         if (flags & NDR_OUT) {
1965                 if (r->out.entry_handle == NULL) {
1966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1967                 }
1968                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
1969                 if (r->out.num_ents == NULL) {
1970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1971                 }
1972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
1973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
1974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
1976                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1977                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
1978                 }
1979                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1980                         NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
1981                 }
1982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1983         }
1984         return NDR_ERR_SUCCESS;
1985 }
1986
1987 static enum ndr_err_code ndr_pull_epm_Lookup(struct ndr_pull *ndr, int flags, struct epm_Lookup *r)
1988 {
1989         uint32_t _ptr_object;
1990         uint32_t _ptr_interface_id;
1991         uint32_t cntr_entries_0;
1992         TALLOC_CTX *_mem_save_object_0;
1993         TALLOC_CTX *_mem_save_interface_id_0;
1994         TALLOC_CTX *_mem_save_entry_handle_0;
1995         TALLOC_CTX *_mem_save_num_ents_0;
1996         TALLOC_CTX *_mem_save_entries_0;
1997         if (flags & NDR_IN) {
1998                 ZERO_STRUCT(r->out);
1999
2000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.inquiry_type));
2001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2002                 if (_ptr_object) {
2003                         NDR_PULL_ALLOC(ndr, r->in.object);
2004                 } else {
2005                         r->in.object = NULL;
2006                 }
2007                 if (r->in.object) {
2008                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2009                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2010                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2012                 }
2013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_interface_id));
2014                 if (_ptr_interface_id) {
2015                         NDR_PULL_ALLOC(ndr, r->in.interface_id);
2016                 } else {
2017                         r->in.interface_id = NULL;
2018                 }
2019                 if (r->in.interface_id) {
2020                         _mem_save_interface_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2021                         NDR_PULL_SET_MEM_CTX(ndr, r->in.interface_id, 0);
2022                         NDR_CHECK(ndr_pull_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
2023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_interface_id_0, 0);
2024                 }
2025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.vers_option));
2026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2027                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2028                 }
2029                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2030                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_ents));
2034                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2035                 *r->out.entry_handle = *r->in.entry_handle;
2036                 NDR_PULL_ALLOC(ndr, r->out.num_ents);
2037                 ZERO_STRUCTP(r->out.num_ents);
2038         }
2039         if (flags & NDR_OUT) {
2040                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2041                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2042                 }
2043                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2044                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2045                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2046                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2047                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2048                         NDR_PULL_ALLOC(ndr, r->out.num_ents);
2049                 }
2050                 _mem_save_num_ents_0 = NDR_PULL_GET_MEM_CTX(ndr);
2051                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ents, LIBNDR_FLAG_REF_ALLOC);
2052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ents));
2053                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ents_0, LIBNDR_FLAG_REF_ALLOC);
2054                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.entries));
2055                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.entries));
2056                 if (ndr_get_array_length(ndr, &r->out.entries) > ndr_get_array_size(ndr, &r->out.entries)) {
2057                         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));
2058                 }
2059                 NDR_PULL_ALLOC_N(ndr, r->out.entries, ndr_get_array_size(ndr, &r->out.entries));
2060                 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries, 0);
2062                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
2063                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
2064                 }
2065                 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
2066                         NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
2067                 }
2068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
2069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2070                 if (r->out.entries) {
2071                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.entries, r->in.max_ents));
2072                 }
2073                 if (r->out.entries) {
2074                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.entries, *r->out.num_ents));
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_epm_Lookup(struct ndr_print *ndr, const char *name, int flags, const struct epm_Lookup *r)
2081 {
2082         uint32_t cntr_entries_0;
2083         ndr_print_struct(ndr, name, "epm_Lookup");
2084         ndr->depth++;
2085         if (flags & NDR_SET_VALUES) {
2086                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2087         }
2088         if (flags & NDR_IN) {
2089                 ndr_print_struct(ndr, "in", "epm_Lookup");
2090                 ndr->depth++;
2091                 ndr_print_uint32(ndr, "inquiry_type", r->in.inquiry_type);
2092                 ndr_print_ptr(ndr, "object", r->in.object);
2093                 ndr->depth++;
2094                 if (r->in.object) {
2095                         ndr_print_GUID(ndr, "object", r->in.object);
2096                 }
2097                 ndr->depth--;
2098                 ndr_print_ptr(ndr, "interface_id", r->in.interface_id);
2099                 ndr->depth++;
2100                 if (r->in.interface_id) {
2101                         ndr_print_rpc_if_id_t(ndr, "interface_id", r->in.interface_id);
2102                 }
2103                 ndr->depth--;
2104                 ndr_print_uint32(ndr, "vers_option", r->in.vers_option);
2105                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2106                 ndr->depth++;
2107                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2108                 ndr->depth--;
2109                 ndr_print_uint32(ndr, "max_ents", r->in.max_ents);
2110                 ndr->depth--;
2111         }
2112         if (flags & NDR_OUT) {
2113                 ndr_print_struct(ndr, "out", "epm_Lookup");
2114                 ndr->depth++;
2115                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2116                 ndr->depth++;
2117                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2118                 ndr->depth--;
2119                 ndr_print_ptr(ndr, "num_ents", r->out.num_ents);
2120                 ndr->depth++;
2121                 ndr_print_uint32(ndr, "num_ents", *r->out.num_ents);
2122                 ndr->depth--;
2123                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)*r->out.num_ents);
2124                 ndr->depth++;
2125                 for (cntr_entries_0=0;cntr_entries_0<*r->out.num_ents;cntr_entries_0++) {
2126                         char *idx_0=NULL;
2127                         if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
2128                                 ndr_print_epm_entry_t(ndr, "entries", &r->out.entries[cntr_entries_0]);
2129                                 free(idx_0);
2130                         }
2131                 }
2132                 ndr->depth--;
2133                 ndr_print_uint32(ndr, "result", r->out.result);
2134                 ndr->depth--;
2135         }
2136         ndr->depth--;
2137 }
2138
2139 _PUBLIC_ enum ndr_err_code ndr_push_epm_Map(struct ndr_push *ndr, int flags, const struct epm_Map *r)
2140 {
2141         uint32_t cntr_towers_0;
2142         if (flags & NDR_IN) {
2143                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2144                 if (r->in.object) {
2145                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
2146                 }
2147                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.map_tower));
2148                 if (r->in.map_tower) {
2149                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2150                 }
2151                 if (r->in.entry_handle == NULL) {
2152                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2153                 }
2154                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, 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) {
2159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2160                 }
2161                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2162                 if (r->out.num_towers == NULL) {
2163                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2164                 }
2165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
2166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_towers));
2167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
2169                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2170                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2171                 }
2172                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2173                         NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2174                 }
2175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2176         }
2177         return NDR_ERR_SUCCESS;
2178 }
2179
2180 _PUBLIC_ enum ndr_err_code ndr_pull_epm_Map(struct ndr_pull *ndr, int flags, struct epm_Map *r)
2181 {
2182         uint32_t _ptr_object;
2183         uint32_t _ptr_map_tower;
2184         uint32_t cntr_towers_0;
2185         TALLOC_CTX *_mem_save_object_0;
2186         TALLOC_CTX *_mem_save_map_tower_0;
2187         TALLOC_CTX *_mem_save_entry_handle_0;
2188         TALLOC_CTX *_mem_save_num_towers_0;
2189         TALLOC_CTX *_mem_save_towers_0;
2190         if (flags & NDR_IN) {
2191                 ZERO_STRUCT(r->out);
2192
2193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2194                 if (_ptr_object) {
2195                         NDR_PULL_ALLOC(ndr, r->in.object);
2196                 } else {
2197                         r->in.object = NULL;
2198                 }
2199                 if (r->in.object) {
2200                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2201                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2202                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2204                 }
2205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_map_tower));
2206                 if (_ptr_map_tower) {
2207                         NDR_PULL_ALLOC(ndr, r->in.map_tower);
2208                 } else {
2209                         r->in.map_tower = NULL;
2210                 }
2211                 if (r->in.map_tower) {
2212                         _mem_save_map_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2213                         NDR_PULL_SET_MEM_CTX(ndr, r->in.map_tower, 0);
2214                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_map_tower_0, 0);
2216                 }
2217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2218                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2219                 }
2220                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2222                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_towers));
2225                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2226                 *r->out.entry_handle = *r->in.entry_handle;
2227                 NDR_PULL_ALLOC(ndr, r->out.num_towers);
2228                 ZERO_STRUCTP(r->out.num_towers);
2229         }
2230         if (flags & NDR_OUT) {
2231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2232                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2233                 }
2234                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2236                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2238                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2239                         NDR_PULL_ALLOC(ndr, r->out.num_towers);
2240                 }
2241                 _mem_save_num_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2242                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_towers, LIBNDR_FLAG_REF_ALLOC);
2243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_towers));
2244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_towers_0, LIBNDR_FLAG_REF_ALLOC);
2245                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.towers));
2246                 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.towers));
2247                 if (ndr_get_array_length(ndr, &r->out.towers) > ndr_get_array_size(ndr, &r->out.towers)) {
2248                         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));
2249                 }
2250                 NDR_PULL_ALLOC_N(ndr, r->out.towers, ndr_get_array_size(ndr, &r->out.towers));
2251                 _mem_save_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2252                 NDR_PULL_SET_MEM_CTX(ndr, r->out.towers, 0);
2253                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2254                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2255                 }
2256                 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2257                         NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2258                 }
2259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_towers_0, 0);
2260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2261                 if (r->out.towers) {
2262                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.towers, r->in.max_towers));
2263                 }
2264                 if (r->out.towers) {
2265                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.towers, *r->out.num_towers));
2266                 }
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_epm_Map(struct ndr_print *ndr, const char *name, int flags, const struct epm_Map *r)
2272 {
2273         uint32_t cntr_towers_0;
2274         ndr_print_struct(ndr, name, "epm_Map");
2275         ndr->depth++;
2276         if (flags & NDR_SET_VALUES) {
2277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2278         }
2279         if (flags & NDR_IN) {
2280                 ndr_print_struct(ndr, "in", "epm_Map");
2281                 ndr->depth++;
2282                 ndr_print_ptr(ndr, "object", r->in.object);
2283                 ndr->depth++;
2284                 if (r->in.object) {
2285                         ndr_print_GUID(ndr, "object", r->in.object);
2286                 }
2287                 ndr->depth--;
2288                 ndr_print_ptr(ndr, "map_tower", r->in.map_tower);
2289                 ndr->depth++;
2290                 if (r->in.map_tower) {
2291                         ndr_print_epm_twr_t(ndr, "map_tower", r->in.map_tower);
2292                 }
2293                 ndr->depth--;
2294                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2295                 ndr->depth++;
2296                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2297                 ndr->depth--;
2298                 ndr_print_uint32(ndr, "max_towers", r->in.max_towers);
2299                 ndr->depth--;
2300         }
2301         if (flags & NDR_OUT) {
2302                 ndr_print_struct(ndr, "out", "epm_Map");
2303                 ndr->depth++;
2304                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2305                 ndr->depth++;
2306                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2307                 ndr->depth--;
2308                 ndr_print_ptr(ndr, "num_towers", r->out.num_towers);
2309                 ndr->depth++;
2310                 ndr_print_uint32(ndr, "num_towers", *r->out.num_towers);
2311                 ndr->depth--;
2312                 ndr->print(ndr, "%s: ARRAY(%d)", "towers", (int)*r->out.num_towers);
2313                 ndr->depth++;
2314                 for (cntr_towers_0=0;cntr_towers_0<*r->out.num_towers;cntr_towers_0++) {
2315                         char *idx_0=NULL;
2316                         if (asprintf(&idx_0, "[%d]", cntr_towers_0) != -1) {
2317                                 ndr_print_epm_twr_p_t(ndr, "towers", &r->out.towers[cntr_towers_0]);
2318                                 free(idx_0);
2319                         }
2320                 }
2321                 ndr->depth--;
2322                 ndr_print_uint32(ndr, "result", r->out.result);
2323                 ndr->depth--;
2324         }
2325         ndr->depth--;
2326 }
2327
2328 static enum ndr_err_code ndr_push_epm_LookupHandleFree(struct ndr_push *ndr, int flags, const struct epm_LookupHandleFree *r)
2329 {
2330         if (flags & NDR_IN) {
2331                 if (r->in.entry_handle == NULL) {
2332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2333                 }
2334                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2335         }
2336         if (flags & NDR_OUT) {
2337                 if (r->out.entry_handle == NULL) {
2338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2339                 }
2340                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2342         }
2343         return NDR_ERR_SUCCESS;
2344 }
2345
2346 static enum ndr_err_code ndr_pull_epm_LookupHandleFree(struct ndr_pull *ndr, int flags, struct epm_LookupHandleFree *r)
2347 {
2348         TALLOC_CTX *_mem_save_entry_handle_0;
2349         if (flags & NDR_IN) {
2350                 ZERO_STRUCT(r->out);
2351
2352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2353                         NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2354                 }
2355                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2356                 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2357                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2359                 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2360                 *r->out.entry_handle = *r->in.entry_handle;
2361         }
2362         if (flags & NDR_OUT) {
2363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2364                         NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2365                 }
2366                 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2367                 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2371         }
2372         return NDR_ERR_SUCCESS;
2373 }
2374
2375 _PUBLIC_ void ndr_print_epm_LookupHandleFree(struct ndr_print *ndr, const char *name, int flags, const struct epm_LookupHandleFree *r)
2376 {
2377         ndr_print_struct(ndr, name, "epm_LookupHandleFree");
2378         ndr->depth++;
2379         if (flags & NDR_SET_VALUES) {
2380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2381         }
2382         if (flags & NDR_IN) {
2383                 ndr_print_struct(ndr, "in", "epm_LookupHandleFree");
2384                 ndr->depth++;
2385                 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2386                 ndr->depth++;
2387                 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2388                 ndr->depth--;
2389                 ndr->depth--;
2390         }
2391         if (flags & NDR_OUT) {
2392                 ndr_print_struct(ndr, "out", "epm_LookupHandleFree");
2393                 ndr->depth++;
2394                 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2395                 ndr->depth++;
2396                 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2397                 ndr->depth--;
2398                 ndr_print_uint32(ndr, "result", r->out.result);
2399                 ndr->depth--;
2400         }
2401         ndr->depth--;
2402 }
2403
2404 static enum ndr_err_code ndr_push_epm_InqObject(struct ndr_push *ndr, int flags, const struct epm_InqObject *r)
2405 {
2406         if (flags & NDR_IN) {
2407                 if (r->in.epm_object == NULL) {
2408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2409                 }
2410                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.epm_object));
2411         }
2412         if (flags & NDR_OUT) {
2413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2414         }
2415         return NDR_ERR_SUCCESS;
2416 }
2417
2418 static enum ndr_err_code ndr_pull_epm_InqObject(struct ndr_pull *ndr, int flags, struct epm_InqObject *r)
2419 {
2420         TALLOC_CTX *_mem_save_epm_object_0;
2421         if (flags & NDR_IN) {
2422                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2423                         NDR_PULL_ALLOC(ndr, r->in.epm_object);
2424                 }
2425                 _mem_save_epm_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2426                 NDR_PULL_SET_MEM_CTX(ndr, r->in.epm_object, LIBNDR_FLAG_REF_ALLOC);
2427                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.epm_object));
2428                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epm_object_0, LIBNDR_FLAG_REF_ALLOC);
2429         }
2430         if (flags & NDR_OUT) {
2431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2432         }
2433         return NDR_ERR_SUCCESS;
2434 }
2435
2436 _PUBLIC_ void ndr_print_epm_InqObject(struct ndr_print *ndr, const char *name, int flags, const struct epm_InqObject *r)
2437 {
2438         ndr_print_struct(ndr, name, "epm_InqObject");
2439         ndr->depth++;
2440         if (flags & NDR_SET_VALUES) {
2441                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2442         }
2443         if (flags & NDR_IN) {
2444                 ndr_print_struct(ndr, "in", "epm_InqObject");
2445                 ndr->depth++;
2446                 ndr_print_ptr(ndr, "epm_object", r->in.epm_object);
2447                 ndr->depth++;
2448                 ndr_print_GUID(ndr, "epm_object", r->in.epm_object);
2449                 ndr->depth--;
2450                 ndr->depth--;
2451         }
2452         if (flags & NDR_OUT) {
2453                 ndr_print_struct(ndr, "out", "epm_InqObject");
2454                 ndr->depth++;
2455                 ndr_print_uint32(ndr, "result", r->out.result);
2456                 ndr->depth--;
2457         }
2458         ndr->depth--;
2459 }
2460
2461 static enum ndr_err_code ndr_push_epm_MgmtDelete(struct ndr_push *ndr, int flags, const struct epm_MgmtDelete *r)
2462 {
2463         if (flags & NDR_IN) {
2464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.object_speced));
2465                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2466                 if (r->in.object) {
2467                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
2468                 }
2469                 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.tower));
2470                 if (r->in.tower) {
2471                         NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2472                 }
2473         }
2474         if (flags & NDR_OUT) {
2475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2476         }
2477         return NDR_ERR_SUCCESS;
2478 }
2479
2480 static enum ndr_err_code ndr_pull_epm_MgmtDelete(struct ndr_pull *ndr, int flags, struct epm_MgmtDelete *r)
2481 {
2482         uint32_t _ptr_object;
2483         uint32_t _ptr_tower;
2484         TALLOC_CTX *_mem_save_object_0;
2485         TALLOC_CTX *_mem_save_tower_0;
2486         if (flags & NDR_IN) {
2487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.object_speced));
2488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2489                 if (_ptr_object) {
2490                         NDR_PULL_ALLOC(ndr, r->in.object);
2491                 } else {
2492                         r->in.object = NULL;
2493                 }
2494                 if (r->in.object) {
2495                         _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496                         NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2497                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2499                 }
2500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
2501                 if (_ptr_tower) {
2502                         NDR_PULL_ALLOC(ndr, r->in.tower);
2503                 } else {
2504                         r->in.tower = NULL;
2505                 }
2506                 if (r->in.tower) {
2507                         _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                         NDR_PULL_SET_MEM_CTX(ndr, r->in.tower, 0);
2509                         NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
2511                 }
2512         }
2513         if (flags & NDR_OUT) {
2514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2515         }
2516         return NDR_ERR_SUCCESS;
2517 }
2518
2519 _PUBLIC_ void ndr_print_epm_MgmtDelete(struct ndr_print *ndr, const char *name, int flags, const struct epm_MgmtDelete *r)
2520 {
2521         ndr_print_struct(ndr, name, "epm_MgmtDelete");
2522         ndr->depth++;
2523         if (flags & NDR_SET_VALUES) {
2524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2525         }
2526         if (flags & NDR_IN) {
2527                 ndr_print_struct(ndr, "in", "epm_MgmtDelete");
2528                 ndr->depth++;
2529                 ndr_print_uint32(ndr, "object_speced", r->in.object_speced);
2530                 ndr_print_ptr(ndr, "object", r->in.object);
2531                 ndr->depth++;
2532                 if (r->in.object) {
2533                         ndr_print_GUID(ndr, "object", r->in.object);
2534                 }
2535                 ndr->depth--;
2536                 ndr_print_ptr(ndr, "tower", r->in.tower);
2537                 ndr->depth++;
2538                 if (r->in.tower) {
2539                         ndr_print_epm_twr_t(ndr, "tower", r->in.tower);
2540                 }
2541                 ndr->depth--;
2542                 ndr->depth--;
2543         }
2544         if (flags & NDR_OUT) {
2545                 ndr_print_struct(ndr, "out", "epm_MgmtDelete");
2546                 ndr->depth++;
2547                 ndr_print_uint32(ndr, "result", r->out.result);
2548                 ndr->depth--;
2549         }
2550         ndr->depth--;
2551 }
2552
2553 static enum ndr_err_code ndr_push_epm_MapAuth(struct ndr_push *ndr, int flags, const struct epm_MapAuth *r)
2554 {
2555         if (flags & NDR_IN) {
2556         }
2557         if (flags & NDR_OUT) {
2558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2559         }
2560         return NDR_ERR_SUCCESS;
2561 }
2562
2563 static enum ndr_err_code ndr_pull_epm_MapAuth(struct ndr_pull *ndr, int flags, struct epm_MapAuth *r)
2564 {
2565         if (flags & NDR_IN) {
2566         }
2567         if (flags & NDR_OUT) {
2568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2569         }
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 _PUBLIC_ void ndr_print_epm_MapAuth(struct ndr_print *ndr, const char *name, int flags, const struct epm_MapAuth *r)
2574 {
2575         ndr_print_struct(ndr, name, "epm_MapAuth");
2576         ndr->depth++;
2577         if (flags & NDR_SET_VALUES) {
2578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2579         }
2580         if (flags & NDR_IN) {
2581                 ndr_print_struct(ndr, "in", "epm_MapAuth");
2582                 ndr->depth++;
2583                 ndr->depth--;
2584         }
2585         if (flags & NDR_OUT) {
2586                 ndr_print_struct(ndr, "out", "epm_MapAuth");
2587                 ndr->depth++;
2588                 ndr_print_uint32(ndr, "result", r->out.result);
2589                 ndr->depth--;
2590         }
2591         ndr->depth--;
2592 }
2593
2594 static const struct ndr_interface_call epmapper_calls[] = {
2595         {
2596                 "epm_Insert",
2597                 sizeof(struct epm_Insert),
2598                 (ndr_push_flags_fn_t) ndr_push_epm_Insert,
2599                 (ndr_pull_flags_fn_t) ndr_pull_epm_Insert,
2600                 (ndr_print_function_t) ndr_print_epm_Insert,
2601                 false,
2602         },
2603         {
2604                 "epm_Delete",
2605                 sizeof(struct epm_Delete),
2606                 (ndr_push_flags_fn_t) ndr_push_epm_Delete,
2607                 (ndr_pull_flags_fn_t) ndr_pull_epm_Delete,
2608                 (ndr_print_function_t) ndr_print_epm_Delete,
2609                 false,
2610         },
2611         {
2612                 "epm_Lookup",
2613                 sizeof(struct epm_Lookup),
2614                 (ndr_push_flags_fn_t) ndr_push_epm_Lookup,
2615                 (ndr_pull_flags_fn_t) ndr_pull_epm_Lookup,
2616                 (ndr_print_function_t) ndr_print_epm_Lookup,
2617                 false,
2618         },
2619         {
2620                 "epm_Map",
2621                 sizeof(struct epm_Map),
2622                 (ndr_push_flags_fn_t) ndr_push_epm_Map,
2623                 (ndr_pull_flags_fn_t) ndr_pull_epm_Map,
2624                 (ndr_print_function_t) ndr_print_epm_Map,
2625                 false,
2626         },
2627         {
2628                 "epm_LookupHandleFree",
2629                 sizeof(struct epm_LookupHandleFree),
2630                 (ndr_push_flags_fn_t) ndr_push_epm_LookupHandleFree,
2631                 (ndr_pull_flags_fn_t) ndr_pull_epm_LookupHandleFree,
2632                 (ndr_print_function_t) ndr_print_epm_LookupHandleFree,
2633                 false,
2634         },
2635         {
2636                 "epm_InqObject",
2637                 sizeof(struct epm_InqObject),
2638                 (ndr_push_flags_fn_t) ndr_push_epm_InqObject,
2639                 (ndr_pull_flags_fn_t) ndr_pull_epm_InqObject,
2640                 (ndr_print_function_t) ndr_print_epm_InqObject,
2641                 false,
2642         },
2643         {
2644                 "epm_MgmtDelete",
2645                 sizeof(struct epm_MgmtDelete),
2646                 (ndr_push_flags_fn_t) ndr_push_epm_MgmtDelete,
2647                 (ndr_pull_flags_fn_t) ndr_pull_epm_MgmtDelete,
2648                 (ndr_print_function_t) ndr_print_epm_MgmtDelete,
2649                 false,
2650         },
2651         {
2652                 "epm_MapAuth",
2653                 sizeof(struct epm_MapAuth),
2654                 (ndr_push_flags_fn_t) ndr_push_epm_MapAuth,
2655                 (ndr_pull_flags_fn_t) ndr_pull_epm_MapAuth,
2656                 (ndr_print_function_t) ndr_print_epm_MapAuth,
2657                 false,
2658         },
2659         { NULL, 0, NULL, NULL, NULL, false }
2660 };
2661
2662 static const char * const epmapper_endpoint_strings[] = {
2663         "ncacn_np:[\\pipe\\epmapper]",
2664         "ncacn_ip_tcp:[135]",
2665         "ncalrpc:[EPMAPPER]",
2666 };
2667
2668 static const struct ndr_interface_string_array epmapper_endpoints = {
2669         .count  = 3,
2670         .names  = epmapper_endpoint_strings
2671 };
2672
2673 static const char * const epmapper_authservice_strings[] = {
2674         "host",
2675 };
2676
2677 static const struct ndr_interface_string_array epmapper_authservices = {
2678         .count  = 1,
2679         .names  = epmapper_authservice_strings
2680 };
2681
2682
2683 const struct ndr_interface_table ndr_table_epmapper = {
2684         .name           = "epmapper",
2685         .syntax_id      = {
2686                 {0xe1af8308,0x5d1f,0x11c9,{0x91,0xa4},{0x08,0x00,0x2b,0x14,0xa0,0xfa}},
2687                 NDR_EPMAPPER_VERSION
2688         },
2689         .helpstring     = NDR_EPMAPPER_HELPSTRING,
2690         .num_calls      = 8,
2691         .calls          = epmapper_calls,
2692         .endpoints      = &epmapper_endpoints,
2693         .authservices   = &epmapper_authservices
2694 };
2695