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