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