bin.gen_ndr/default/librpc/gen_ndr/ndr_dnsp.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_dnsp.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_dns_record_type(struct ndr_push *ndr, int ndr_flags, enum dns_record_type r)
   8 {
   9         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
  10         return NDR_ERR_SUCCESS;
  11 }
  12
  13 _PUBLIC_ enum ndr_err_code ndr_pull_dns_record_type(struct ndr_pull *ndr, int ndr_flags, enum dns_record_type *r)
  14 {
  15         uint16_t v;
  16         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
  17         *r = v;
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _PUBLIC_ void ndr_print_dns_record_type(struct ndr_print *ndr, const char *name, enum dns_record_type r)
  22 {
  23         const char *val = NULL;
  24
  25         switch (r) {
  26                 case DNS_TYPE_TOMBSTONE: val = "DNS_TYPE_TOMBSTONE"; break;
  27                 case DNS_TYPE_A: val = "DNS_TYPE_A"; break;
  28                 case DNS_TYPE_NS: val = "DNS_TYPE_NS"; break;
  29                 case DNS_TYPE_MD: val = "DNS_TYPE_MD"; break;
  30                 case DNS_TYPE_MF: val = "DNS_TYPE_MF"; break;
  31                 case DNS_TYPE_CNAME: val = "DNS_TYPE_CNAME"; break;
  32                 case DNS_TYPE_SOA: val = "DNS_TYPE_SOA"; break;
  33                 case DNS_TYPE_MB: val = "DNS_TYPE_MB"; break;
  34                 case DNS_TYPE_MG: val = "DNS_TYPE_MG"; break;
  35                 case DNS_TYPE_MR: val = "DNS_TYPE_MR"; break;
  36                 case DNS_TYPE_NULL: val = "DNS_TYPE_NULL"; break;
  37                 case DNS_TYPE_WKS: val = "DNS_TYPE_WKS"; break;
  38                 case DNS_TYPE_PTR: val = "DNS_TYPE_PTR"; break;
  39                 case DNS_TYPE_HINFO: val = "DNS_TYPE_HINFO"; break;
  40                 case DNS_TYPE_MINFO: val = "DNS_TYPE_MINFO"; break;
  41                 case DNS_TYPE_MX: val = "DNS_TYPE_MX"; break;
  42                 case DNS_TYPE_TXT: val = "DNS_TYPE_TXT"; break;
  43                 case DNS_TYPE_RP: val = "DNS_TYPE_RP"; break;
  44                 case DNS_TYPE_AFSDB: val = "DNS_TYPE_AFSDB"; break;
  45                 case DNS_TYPE_X25: val = "DNS_TYPE_X25"; break;
  46                 case DNS_TYPE_ISDN: val = "DNS_TYPE_ISDN"; break;
  47                 case DNS_TYPE_RT: val = "DNS_TYPE_RT"; break;
  48                 case DNS_TYPE_SIG: val = "DNS_TYPE_SIG"; break;
  49                 case DNS_TYPE_KEY: val = "DNS_TYPE_KEY"; break;
  50                 case DNS_TYPE_AAAA: val = "DNS_TYPE_AAAA"; break;
  51                 case DNS_TYPE_LOC: val = "DNS_TYPE_LOC"; break;
  52                 case DNS_TYPE_NXT: val = "DNS_TYPE_NXT"; break;
  53                 case DNS_TYPE_SRV: val = "DNS_TYPE_SRV"; break;
  54                 case DNS_TYPE_ATMA: val = "DNS_TYPE_ATMA"; break;
  55                 case DNS_TYPE_NAPTR: val = "DNS_TYPE_NAPTR"; break;
  56                 case DNS_TYPE_DNAME: val = "DNS_TYPE_DNAME"; break;
  57                 case DNS_TYPE_DS: val = "DNS_TYPE_DS"; break;
  58                 case DNS_TYPE_RRSIG: val = "DNS_TYPE_RRSIG"; break;
  59                 case DNS_TYPE_NSEC: val = "DNS_TYPE_NSEC"; break;
  60                 case DNS_TYPE_DNSKEY: val = "DNS_TYPE_DNSKEY"; break;
  61                 case DNS_TYPE_DHCID: val = "DNS_TYPE_DHCID"; break;
  62                 case DNS_TYPE_ALL: val = "DNS_TYPE_ALL"; break;
  63                 case DNS_TYPE_WINS: val = "DNS_TYPE_WINS"; break;
  64                 case DNS_TYPE_WINSR: val = "DNS_TYPE_WINSR"; break;
  65         }
  66         ndr_print_enum(ndr, name, "ENUM", val, r);
  67 }
  68
  69 static enum ndr_err_code ndr_push_dns_rpc_node_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  70 {
  71         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  72         return NDR_ERR_SUCCESS;
  73 }
  74
  75 static enum ndr_err_code ndr_pull_dns_rpc_node_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  76 {
  77         uint32_t v;
  78         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  79         *r = v;
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 _PUBLIC_ void ndr_print_dns_rpc_node_flags(struct ndr_print *ndr, const char *name, uint32_t r)
  84 {
  85         ndr_print_uint32(ndr, name, r);
  86         ndr->depth++;
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_SUPPRESS_NOTIFY", DNS_RPC_FLAG_SUPPRESS_NOTIFY, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_AGING_ON", DNS_RPC_FLAG_AGING_ON, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_OPEN_ACL", DNS_RPC_FLAG_OPEN_ACL, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_NODE_COMPLETE", DNS_RPC_FLAG_NODE_COMPLETE, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_NODE_STICKY", DNS_RPC_FLAG_NODE_STICKY, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_RECORD_CREATE_PTR", DNS_RPC_FLAG_RECORD_CREATE_PTR, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_RECORD_TTL_CHANGE", DNS_RPC_FLAG_RECORD_TTL_CHANGE, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_RECORD_DEFAULT_TTL", DNS_RPC_FLAG_RECORD_DEFAULT_TTL, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_ZONE_DELEGATION", DNS_RPC_FLAG_ZONE_DELEGATION, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_AUTH_ZONE_ROOT", DNS_RPC_FLAG_AUTH_ZONE_ROOT, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_ZONE_ROOT", DNS_RPC_FLAG_ZONE_ROOT, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DNS_RPC_FLAG_CACHE_DATA", DNS_RPC_FLAG_CACHE_DATA, r);
  99         ndr->depth--;
 100 }
 101
 102 static enum ndr_err_code ndr_push_dns_record_rank(struct ndr_push *ndr, int ndr_flags, enum dns_record_rank r)
 103 {
 104         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 105         return NDR_ERR_SUCCESS;
 106 }
 107
 108 static enum ndr_err_code ndr_pull_dns_record_rank(struct ndr_pull *ndr, int ndr_flags, enum dns_record_rank *r)
 109 {
 110         uint8_t v;
 111         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 112         *r = v;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 _PUBLIC_ void ndr_print_dns_record_rank(struct ndr_print *ndr, const char *name, enum dns_record_rank r)
 117 {
 118         const char *val = NULL;
 119
 120         switch (r) {
 121                 case DNS_RANK_NONE: val = "DNS_RANK_NONE"; break;
 122                 case DNS_RANK_CACHE_BIT: val = "DNS_RANK_CACHE_BIT"; break;
 123                 case DNS_RANK_ROOT_HINT: val = "DNS_RANK_ROOT_HINT"; break;
 124                 case DNS_RANK_OUTSIDE_GLUE: val = "DNS_RANK_OUTSIDE_GLUE"; break;
 125                 case DNS_RANK_CACHE_NA_ADDITIONAL: val = "DNS_RANK_CACHE_NA_ADDITIONAL"; break;
 126                 case DNS_RANK_CACHE_NA_AUTHORITY: val = "DNS_RANK_CACHE_NA_AUTHORITY"; break;
 127                 case DNS_RANK_CACHE_A_ADDITIONAL: val = "DNS_RANK_CACHE_A_ADDITIONAL"; break;
 128                 case DNS_RANK_CACHE_NA_ANSWER: val = "DNS_RANK_CACHE_NA_ANSWER"; break;
 129                 case DNS_RANK_CACHE_A_AUTHORITY: val = "DNS_RANK_CACHE_A_AUTHORITY"; break;
 130                 case DNS_RANK_GLUE: val = "DNS_RANK_GLUE"; break;
 131                 case DNS_RANK_NS_GLUE: val = "DNS_RANK_NS_GLUE"; break;
 132                 case DNS_RANK_CACHE_A_ANSWER: val = "DNS_RANK_CACHE_A_ANSWER"; break;
 133                 case DNS_RANK_ZONE: val = "DNS_RANK_ZONE"; break;
 134         }
 135         ndr_print_enum(ndr, name, "ENUM", val, r);
 136 }
 137
 138 static enum ndr_err_code ndr_push_dns_zone_type(struct ndr_push *ndr, int ndr_flags, enum dns_zone_type r)
 139 {
 140         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 static enum ndr_err_code ndr_pull_dns_zone_type(struct ndr_pull *ndr, int ndr_flags, enum dns_zone_type *r)
 145 {
 146         uint32_t v;
 147         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 148         *r = v;
 149         return NDR_ERR_SUCCESS;
 150 }
 151
 152 _PUBLIC_ void ndr_print_dns_zone_type(struct ndr_print *ndr, const char *name, enum dns_zone_type r)
 153 {
 154         const char *val = NULL;
 155
 156         switch (r) {
 157                 case DNS_ZONE_TYPE_CACHE: val = "DNS_ZONE_TYPE_CACHE"; break;
 158                 case DNS_ZONE_TYPE_PRIMARY: val = "DNS_ZONE_TYPE_PRIMARY"; break;
 159                 case DNS_ZONE_TYPE_SECONDARY: val = "DNS_ZONE_TYPE_SECONDARY"; break;
 160                 case DNS_ZONE_TYPE_STUB: val = "DNS_ZONE_TYPE_STUB"; break;
 161                 case DNS_ZONE_TYPE_FORWARDER: val = "DNS_ZONE_TYPE_FORWARDER"; break;
 162                 case DNS_ZONE_TYPE_SECONDARY_CACHE: val = "DNS_ZONE_TYPE_SECONDARY_CACHE"; break;
 163         }
 164         ndr_print_enum(ndr, name, "ENUM", val, r);
 165 }
 166
 167 _PUBLIC_ enum ndr_err_code ndr_push_dns_zone_update(struct ndr_push *ndr, int ndr_flags, enum dns_zone_update r)
 168 {
 169         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 170         return NDR_ERR_SUCCESS;
 171 }
 172
 173 _PUBLIC_ enum ndr_err_code ndr_pull_dns_zone_update(struct ndr_pull *ndr, int ndr_flags, enum dns_zone_update *r)
 174 {
 175         uint8_t v;
 176         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 177         *r = v;
 178         return NDR_ERR_SUCCESS;
 179 }
 180
 181 _PUBLIC_ void ndr_print_dns_zone_update(struct ndr_print *ndr, const char *name, enum dns_zone_update r)
 182 {
 183         const char *val = NULL;
 184
 185         switch (r) {
 186                 case DNS_ZONE_UPDATE_OFF: val = "DNS_ZONE_UPDATE_OFF"; break;
 187                 case DNS_ZONE_UPDATE_UNSECURE: val = "DNS_ZONE_UPDATE_UNSECURE"; break;
 188                 case DNS_ZONE_UPDATE_SECURE: val = "DNS_ZONE_UPDATE_SECURE"; break;
 189         }
 190         ndr_print_enum(ndr, name, "ENUM", val, r);
 191 }
 192
 193 static enum ndr_err_code ndr_push_dns_property_id(struct ndr_push *ndr, int ndr_flags, enum dns_property_id r)
 194 {
 195         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 196         return NDR_ERR_SUCCESS;
 197 }
 198
 199 static enum ndr_err_code ndr_pull_dns_property_id(struct ndr_pull *ndr, int ndr_flags, enum dns_property_id *r)
 200 {
 201         uint32_t v;
 202         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 203         *r = v;
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_dns_property_id(struct ndr_print *ndr, const char *name, enum dns_property_id r)
 208 {
 209         const char *val = NULL;
 210
 211         switch (r) {
 212                 case DSPROPERTY_ZONE_EMPTY: val = "DSPROPERTY_ZONE_EMPTY"; break;
 213                 case DSPROPERTY_ZONE_TYPE: val = "DSPROPERTY_ZONE_TYPE"; break;
 214                 case DSPROPERTY_ZONE_ALLOW_UPDATE: val = "DSPROPERTY_ZONE_ALLOW_UPDATE"; break;
 215                 case DSPROPERTY_ZONE_SECURE_TIME: val = "DSPROPERTY_ZONE_SECURE_TIME"; break;
 216                 case DSPROPERTY_ZONE_NOREFRESH_INTERVAL: val = "DSPROPERTY_ZONE_NOREFRESH_INTERVAL"; break;
 217                 case DSPROPERTY_ZONE_SCAVENGING_SERVERS: val = "DSPROPERTY_ZONE_SCAVENGING_SERVERS"; break;
 218                 case DSPROPERTY_ZONE_AGING_ENABLED_TIME: val = "DSPROPERTY_ZONE_AGING_ENABLED_TIME"; break;
 219                 case DSPROPERTY_ZONE_REFRESH_INTERVAL: val = "DSPROPERTY_ZONE_REFRESH_INTERVAL"; break;
 220                 case DSPROPERTY_ZONE_AGING_STATE: val = "DSPROPERTY_ZONE_AGING_STATE"; break;
 221                 case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME: val = "DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME"; break;
 222                 case DSPROPERTY_ZONE_MASTER_SERVERS: val = "DSPROPERTY_ZONE_MASTER_SERVERS"; break;
 223                 case DSPROPERTY_ZONE_AUTO_NS_SERVERS: val = "DSPROPERTY_ZONE_AUTO_NS_SERVERS"; break;
 224                 case DSPROPERTY_ZONE_DCPROMO_CONVERT: val = "DSPROPERTY_ZONE_DCPROMO_CONVERT"; break;
 225                 case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA: val = "DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA"; break;
 226                 case DSPROPERTY_ZONE_MASTER_SERVERS_DA: val = "DSPROPERTY_ZONE_MASTER_SERVERS_DA"; break;
 227                 case DSPROPERTY_ZONE_NS_SERVERS_DA: val = "DSPROPERTY_ZONE_NS_SERVERS_DA"; break;
 228                 case DSPROPERTY_ZONE_NODE_DBFLAGS: val = "DSPROPERTY_ZONE_NODE_DBFLAGS"; break;
 229         }
 230         ndr_print_enum(ndr, name, "ENUM", val, r);
 231 }
 232
 233 static enum ndr_err_code ndr_push_dns_dcpromo_flag(struct ndr_push *ndr, int ndr_flags, enum dns_dcpromo_flag r)
 234 {
 235         NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 236         return NDR_ERR_SUCCESS;
 237 }
 238
 239 static enum ndr_err_code ndr_pull_dns_dcpromo_flag(struct ndr_pull *ndr, int ndr_flags, enum dns_dcpromo_flag *r)
 240 {
 241         uint8_t v;
 242         NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 243         *r = v;
 244         return NDR_ERR_SUCCESS;
 245 }
 246
 247 _PUBLIC_ void ndr_print_dns_dcpromo_flag(struct ndr_print *ndr, const char *name, enum dns_dcpromo_flag r)
 248 {
 249         const char *val = NULL;
 250
 251         switch (r) {
 252                 case DCPROMO_CONVERT_NONE: val = "DCPROMO_CONVERT_NONE"; break;
 253                 case DCPROMO_CONVERT_DOMAIN: val = "DCPROMO_CONVERT_DOMAIN"; break;
 254                 case DCPROMO_CONVERT_FOREST: val = "DCPROMO_CONVERT_FOREST"; break;
 255         }
 256         ndr_print_enum(ndr, name, "ENUM", val, r);
 257 }
 258
 259 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_soa(struct ndr_push *ndr, int ndr_flags, const struct dnsp_soa *r)
 260 {
 261         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 262         if (ndr_flags & NDR_SCALARS) {
 263                 NDR_CHECK(ndr_push_align(ndr, 4));
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial));
 265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->refresh));
 266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->retry));
 267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->expire));
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minimum));
 269                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->mname));
 270                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->rname));
 271                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 272         }
 273         if (ndr_flags & NDR_BUFFERS) {
 274         }
 275         return NDR_ERR_SUCCESS;
 276 }
 277
 278 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_soa(struct ndr_pull *ndr, int ndr_flags, struct dnsp_soa *r)
 279 {
 280         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 281         if (ndr_flags & NDR_SCALARS) {
 282                 NDR_CHECK(ndr_pull_align(ndr, 4));
 283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial));
 284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->refresh));
 285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->retry));
 286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->expire));
 287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minimum));
 288                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->mname));
 289                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->rname));
 290                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 291         }
 292         if (ndr_flags & NDR_BUFFERS) {
 293         }
 294         return NDR_ERR_SUCCESS;
 295 }
 296
 297 _PUBLIC_ void ndr_print_dnsp_soa(struct ndr_print *ndr, const char *name, const struct dnsp_soa *r)
 298 {
 299         ndr_print_struct(ndr, name, "dnsp_soa");
 300         if (r == NULL) { ndr_print_null(ndr); return; }
 301         ndr->depth++;
 302         ndr_print_uint32(ndr, "serial", r->serial);
 303         ndr_print_uint32(ndr, "refresh", r->refresh);
 304         ndr_print_uint32(ndr, "retry", r->retry);
 305         ndr_print_uint32(ndr, "expire", r->expire);
 306         ndr_print_uint32(ndr, "minimum", r->minimum);
 307         ndr_print_dnsp_name(ndr, "mname", r->mname);
 308         ndr_print_dnsp_name(ndr, "rname", r->rname);
 309         ndr->depth--;
 310 }
 311
 312 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_mx(struct ndr_push *ndr, int ndr_flags, const struct dnsp_mx *r)
 313 {
 314         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 315         if (ndr_flags & NDR_SCALARS) {
 316                 NDR_CHECK(ndr_push_align(ndr, 2));
 317                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wPriority));
 318                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->nameTarget));
 319                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
 320         }
 321         if (ndr_flags & NDR_BUFFERS) {
 322         }
 323         return NDR_ERR_SUCCESS;
 324 }
 325
 326 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_mx(struct ndr_pull *ndr, int ndr_flags, struct dnsp_mx *r)
 327 {
 328         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 329         if (ndr_flags & NDR_SCALARS) {
 330                 NDR_CHECK(ndr_pull_align(ndr, 2));
 331                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wPriority));
 332                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->nameTarget));
 333                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
 334         }
 335         if (ndr_flags & NDR_BUFFERS) {
 336         }
 337         return NDR_ERR_SUCCESS;
 338 }
 339
 340 _PUBLIC_ void ndr_print_dnsp_mx(struct ndr_print *ndr, const char *name, const struct dnsp_mx *r)
 341 {
 342         ndr_print_struct(ndr, name, "dnsp_mx");
 343         if (r == NULL) { ndr_print_null(ndr); return; }
 344         ndr->depth++;
 345         ndr_print_uint16(ndr, "wPriority", r->wPriority);
 346         ndr_print_dnsp_name(ndr, "nameTarget", r->nameTarget);
 347         ndr->depth--;
 348 }
 349
 350 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_hinfo(struct ndr_push *ndr, int ndr_flags, const struct dnsp_hinfo *r)
 351 {
 352         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 353         if (ndr_flags & NDR_SCALARS) {
 354                 NDR_CHECK(ndr_push_align(ndr, 1));
 355                 NDR_CHECK(ndr_push_dnsp_string(ndr, NDR_SCALARS, r->cpu));
 356                 NDR_CHECK(ndr_push_dnsp_string(ndr, NDR_SCALARS, r->os));
 357                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 358         }
 359         if (ndr_flags & NDR_BUFFERS) {
 360         }
 361         return NDR_ERR_SUCCESS;
 362 }
 363
 364 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_hinfo(struct ndr_pull *ndr, int ndr_flags, struct dnsp_hinfo *r)
 365 {
 366         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 367         if (ndr_flags & NDR_SCALARS) {
 368                 NDR_CHECK(ndr_pull_align(ndr, 1));
 369                 NDR_CHECK(ndr_pull_dnsp_string(ndr, NDR_SCALARS, &r->cpu));
 370                 NDR_CHECK(ndr_pull_dnsp_string(ndr, NDR_SCALARS, &r->os));
 371                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 372         }
 373         if (ndr_flags & NDR_BUFFERS) {
 374         }
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 _PUBLIC_ void ndr_print_dnsp_hinfo(struct ndr_print *ndr, const char *name, const struct dnsp_hinfo *r)
 379 {
 380         ndr_print_struct(ndr, name, "dnsp_hinfo");
 381         if (r == NULL) { ndr_print_null(ndr); return; }
 382         ndr->depth++;
 383         ndr_print_dnsp_string(ndr, "cpu", r->cpu);
 384         ndr_print_dnsp_string(ndr, "os", r->os);
 385         ndr->depth--;
 386 }
 387
 388 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_srv(struct ndr_push *ndr, int ndr_flags, const struct dnsp_srv *r)
 389 {
 390         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 391         if (ndr_flags & NDR_SCALARS) {
 392                 NDR_CHECK(ndr_push_align(ndr, 2));
 393                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wPriority));
 394                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wWeight));
 395                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wPort));
 396                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->nameTarget));
 397                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
 398         }
 399         if (ndr_flags & NDR_BUFFERS) {
 400         }
 401         return NDR_ERR_SUCCESS;
 402 }
 403
 404 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_srv(struct ndr_pull *ndr, int ndr_flags, struct dnsp_srv *r)
 405 {
 406         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 407         if (ndr_flags & NDR_SCALARS) {
 408                 NDR_CHECK(ndr_pull_align(ndr, 2));
 409                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wPriority));
 410                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wWeight));
 411                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wPort));
 412                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->nameTarget));
 413                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
 414         }
 415         if (ndr_flags & NDR_BUFFERS) {
 416         }
 417         return NDR_ERR_SUCCESS;
 418 }
 419
 420 _PUBLIC_ void ndr_print_dnsp_srv(struct ndr_print *ndr, const char *name, const struct dnsp_srv *r)
 421 {
 422         ndr_print_struct(ndr, name, "dnsp_srv");
 423         if (r == NULL) { ndr_print_null(ndr); return; }
 424         ndr->depth++;
 425         ndr_print_uint16(ndr, "wPriority", r->wPriority);
 426         ndr_print_uint16(ndr, "wWeight", r->wWeight);
 427         ndr_print_uint16(ndr, "wPort", r->wPort);
 428         ndr_print_dnsp_name(ndr, "nameTarget", r->nameTarget);
 429         ndr->depth--;
 430 }
 431
 432 static enum ndr_err_code ndr_push_dnsp_ip4_array(struct ndr_push *ndr, int ndr_flags, const struct dnsp_ip4_array *r)
 433 {
 434         uint32_t cntr_addr_1;
 435         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 436         if (ndr_flags & NDR_SCALARS) {
 437                 NDR_CHECK(ndr_push_align(ndr, 5));
 438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addrCount));
 439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));
 440                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 441         }
 442         if (ndr_flags & NDR_BUFFERS) {
 443                 if (r->addr) {
 444                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->addrCount));
 445                         for (cntr_addr_1 = 0; cntr_addr_1 < r->addrCount; cntr_addr_1++) {
 446                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr[cntr_addr_1]));
 447                         }
 448                 }
 449         }
 450         return NDR_ERR_SUCCESS;
 451 }
 452
 453 static enum ndr_err_code ndr_pull_dnsp_ip4_array(struct ndr_pull *ndr, int ndr_flags, struct dnsp_ip4_array *r)
 454 {
 455         uint32_t _ptr_addr;
 456         uint32_t size_addr_1 = 0;
 457         uint32_t cntr_addr_1;
 458         TALLOC_CTX *_mem_save_addr_0;
 459         TALLOC_CTX *_mem_save_addr_1;
 460         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 461         if (ndr_flags & NDR_SCALARS) {
 462                 NDR_CHECK(ndr_pull_align(ndr, 5));
 463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addrCount));
 464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));
 465                 if (_ptr_addr) {
 466                         NDR_PULL_ALLOC(ndr, r->addr);
 467                 } else {
 468                         r->addr = NULL;
 469                 }
 470                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 471         }
 472         if (ndr_flags & NDR_BUFFERS) {
 473                 if (r->addr) {
 474                         _mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);
 475                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
 476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));
 477                         size_addr_1 = ndr_get_array_size(ndr, &r->addr);
 478                         NDR_PULL_ALLOC_N(ndr, r->addr, size_addr_1);
 479                         _mem_save_addr_1 = NDR_PULL_GET_MEM_CTX(ndr);
 480                         NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);
 481                         for (cntr_addr_1 = 0; cntr_addr_1 < size_addr_1; cntr_addr_1++) {
 482                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr[cntr_addr_1]));
 483                         }
 484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_1, 0);
 485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);
 486                 }
 487                 if (r->addr) {
 488                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addrCount));
 489                 }
 490         }
 491         return NDR_ERR_SUCCESS;
 492 }
 493
 494 _PUBLIC_ void ndr_print_dnsp_ip4_array(struct ndr_print *ndr, const char *name, const struct dnsp_ip4_array *r)
 495 {
 496         uint32_t cntr_addr_1;
 497         ndr_print_struct(ndr, name, "dnsp_ip4_array");
 498         if (r == NULL) { ndr_print_null(ndr); return; }
 499         ndr->depth++;
 500         ndr_print_uint32(ndr, "addrCount", r->addrCount);
 501         ndr_print_ptr(ndr, "addr", r->addr);
 502         ndr->depth++;
 503         if (r->addr) {
 504                 ndr->print(ndr, "%s: ARRAY(%d)", "addr", (int)r->addrCount);
 505                 ndr->depth++;
 506                 for (cntr_addr_1=0;cntr_addr_1<r->addrCount;cntr_addr_1++) {
 507                         ndr_print_uint32(ndr, "addr", r->addr[cntr_addr_1]);
 508                 }
 509                 ndr->depth--;
 510         }
 511         ndr->depth--;
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_dnsp_dns_addr(struct ndr_push *ndr, int ndr_flags, const struct dnsp_dns_addr *r)
 516 {
 517         uint32_t cntr_unused_0;
 518         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 519         if (ndr_flags & NDR_SCALARS) {
 520                 NDR_CHECK(ndr_push_align(ndr, 4));
 521                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->family));
 522                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
 523                 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipv4));
 524                 NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ipv6));
 525                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pad, 8));
 526                 for (cntr_unused_0 = 0; cntr_unused_0 < 8; cntr_unused_0++) {
 527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unused[cntr_unused_0]));
 528                 }
 529                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 530         }
 531         if (ndr_flags & NDR_BUFFERS) {
 532         }
 533         return NDR_ERR_SUCCESS;
 534 }
 535
 536 static enum ndr_err_code ndr_pull_dnsp_dns_addr(struct ndr_pull *ndr, int ndr_flags, struct dnsp_dns_addr *r)
 537 {
 538         uint32_t size_pad_0 = 0;
 539         uint32_t size_unused_0 = 0;
 540         uint32_t cntr_unused_0;
 541         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 542         if (ndr_flags & NDR_SCALARS) {
 543                 NDR_CHECK(ndr_pull_align(ndr, 4));
 544                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->family));
 545                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
 546                 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipv4));
 547                 NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ipv6));
 548                 size_pad_0 = 8;
 549                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pad, size_pad_0));
 550                 size_unused_0 = 8;
 551                 for (cntr_unused_0 = 0; cntr_unused_0 < size_unused_0; cntr_unused_0++) {
 552                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unused[cntr_unused_0]));
 553                 }
 554                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 555         }
 556         if (ndr_flags & NDR_BUFFERS) {
 557         }
 558         return NDR_ERR_SUCCESS;
 559 }
 560
 561 _PUBLIC_ void ndr_print_dnsp_dns_addr(struct ndr_print *ndr, const char *name, const struct dnsp_dns_addr *r)
 562 {
 563         uint32_t cntr_unused_0;
 564         ndr_print_struct(ndr, name, "dnsp_dns_addr");
 565         if (r == NULL) { ndr_print_null(ndr); return; }
 566         ndr->depth++;
 567         ndr_print_uint16(ndr, "family", r->family);
 568         ndr_print_uint16(ndr, "port", r->port);
 569         ndr_print_ipv4address(ndr, "ipv4", r->ipv4);
 570         ndr_print_ipv6address(ndr, "ipv6", r->ipv6);
 571         ndr_print_array_uint8(ndr, "pad", r->pad, 8);
 572         ndr->print(ndr, "%s: ARRAY(%d)", "unused", (int)8);
 573         ndr->depth++;
 574         for (cntr_unused_0=0;cntr_unused_0<8;cntr_unused_0++) {
 575                 ndr_print_uint32(ndr, "unused", r->unused[cntr_unused_0]);
 576         }
 577         ndr->depth--;
 578         ndr->depth--;
 579 }
 580
 581 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_dns_addr_array(struct ndr_push *ndr, int ndr_flags, const struct dnsp_dns_addr_array *r)
 582 {
 583         uint32_t cntr_AddrArray_0;
 584         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 585         if (ndr_flags & NDR_SCALARS) {
 586                 NDR_CHECK(ndr_push_align(ndr, 4));
 587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MaxCount));
 588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->AddrCount));
 589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Tag));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Family));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->Reserved0));
 592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MatchFlag));
 593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Reserved1));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Reserved2));
 595                 for (cntr_AddrArray_0 = 0; cntr_AddrArray_0 < r->AddrCount; cntr_AddrArray_0++) {
 596                         NDR_CHECK(ndr_push_dnsp_dns_addr(ndr, NDR_SCALARS, &r->AddrArray[cntr_AddrArray_0]));
 597                 }
 598                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 599         }
 600         if (ndr_flags & NDR_BUFFERS) {
 601         }
 602         return NDR_ERR_SUCCESS;
 603 }
 604
 605 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_dns_addr_array(struct ndr_pull *ndr, int ndr_flags, struct dnsp_dns_addr_array *r)
 606 {
 607         uint32_t size_AddrArray_0 = 0;
 608         uint32_t cntr_AddrArray_0;
 609         TALLOC_CTX *_mem_save_AddrArray_0;
 610         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 611         if (ndr_flags & NDR_SCALARS) {
 612                 NDR_CHECK(ndr_pull_align(ndr, 4));
 613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MaxCount));
 614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->AddrCount));
 615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Tag));
 616                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Family));
 617                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->Reserved0));
 618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MatchFlag));
 619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Reserved1));
 620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Reserved2));
 621                 size_AddrArray_0 = r->AddrCount;
 622                 NDR_PULL_ALLOC_N(ndr, r->AddrArray, size_AddrArray_0);
 623                 _mem_save_AddrArray_0 = NDR_PULL_GET_MEM_CTX(ndr);
 624                 NDR_PULL_SET_MEM_CTX(ndr, r->AddrArray, 0);
 625                 for (cntr_AddrArray_0 = 0; cntr_AddrArray_0 < size_AddrArray_0; cntr_AddrArray_0++) {
 626                         NDR_CHECK(ndr_pull_dnsp_dns_addr(ndr, NDR_SCALARS, &r->AddrArray[cntr_AddrArray_0]));
 627                 }
 628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AddrArray_0, 0);
 629                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 630         }
 631         if (ndr_flags & NDR_BUFFERS) {
 632         }
 633         return NDR_ERR_SUCCESS;
 634 }
 635
 636 _PUBLIC_ void ndr_print_dnsp_dns_addr_array(struct ndr_print *ndr, const char *name, const struct dnsp_dns_addr_array *r)
 637 {
 638         uint32_t cntr_AddrArray_0;
 639         ndr_print_struct(ndr, name, "dnsp_dns_addr_array");
 640         if (r == NULL) { ndr_print_null(ndr); return; }
 641         ndr->depth++;
 642         ndr_print_uint32(ndr, "MaxCount", r->MaxCount);
 643         ndr_print_uint32(ndr, "AddrCount", r->AddrCount);
 644         ndr_print_uint32(ndr, "Tag", r->Tag);
 645         ndr_print_uint16(ndr, "Family", r->Family);
 646         ndr_print_uint16(ndr, "Reserved0", r->Reserved0);
 647         ndr_print_uint32(ndr, "MatchFlag", r->MatchFlag);
 648         ndr_print_uint32(ndr, "Reserved1", r->Reserved1);
 649         ndr_print_uint32(ndr, "Reserved2", r->Reserved2);
 650         ndr->print(ndr, "%s: ARRAY(%d)", "AddrArray", (int)r->AddrCount);
 651         ndr->depth++;
 652         for (cntr_AddrArray_0=0;cntr_AddrArray_0<r->AddrCount;cntr_AddrArray_0++) {
 653                 ndr_print_dnsp_dns_addr(ndr, "AddrArray", &r->AddrArray[cntr_AddrArray_0]);
 654         }
 655         ndr->depth--;
 656         ndr->depth--;
 657 }
 658
 659 _PUBLIC_ size_t ndr_size_dnsp_string_list(const struct dnsp_string_list *r, int flags)
 660 {
 661         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_dnsp_string_list);
 662 }
 663
 664 static enum ndr_err_code ndr_push_dnsRecordData(struct ndr_push *ndr, int ndr_flags, const union dnsRecordData *r)
 665 {
 666         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 667         if (ndr_flags & NDR_SCALARS) {
 668                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 669                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 670                 switch (level) {
 671                         case DNS_TYPE_TOMBSTONE: {
 672                                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
 673                         break; }
 674
 675                         case DNS_TYPE_A: {
 676                                 {
 677                                         uint32_t _flags_save_ipv4address = ndr->flags;
 678                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 679                                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipv4));
 680                                         ndr->flags = _flags_save_ipv4address;
 681                                 }
 682                         break; }
 683
 684                         case DNS_TYPE_NS: {
 685                                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->ns));
 686                         break; }
 687
 688                         case DNS_TYPE_CNAME: {
 689                                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->cname));
 690                         break; }
 691
 692                         case DNS_TYPE_SOA: {
 693                                 {
 694                                         uint32_t _flags_save_dnsp_soa = ndr->flags;
 695                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 696                                         NDR_CHECK(ndr_push_dnsp_soa(ndr, NDR_SCALARS, &r->soa));
 697                                         ndr->flags = _flags_save_dnsp_soa;
 698                                 }
 699                         break; }
 700
 701                         case DNS_TYPE_MX: {
 702                                 {
 703                                         uint32_t _flags_save_dnsp_mx = ndr->flags;
 704                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 705                                         NDR_CHECK(ndr_push_dnsp_mx(ndr, NDR_SCALARS, &r->mx));
 706                                         ndr->flags = _flags_save_dnsp_mx;
 707                                 }
 708                         break; }
 709
 710                         case DNS_TYPE_TXT: {
 711                                 NDR_CHECK(ndr_push_dnsp_string_list(ndr, NDR_SCALARS, &r->txt));
 712                         break; }
 713
 714                         case DNS_TYPE_PTR: {
 715                                 NDR_CHECK(ndr_push_dnsp_name(ndr, NDR_SCALARS, r->ptr));
 716                         break; }
 717
 718                         case DNS_TYPE_HINFO: {
 719                                 NDR_CHECK(ndr_push_dnsp_hinfo(ndr, NDR_SCALARS, &r->hinfo));
 720                         break; }
 721
 722                         case DNS_TYPE_AAAA: {
 723                                 NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ipv6));
 724                         break; }
 725
 726                         case DNS_TYPE_SRV: {
 727                                 {
 728                                         uint32_t _flags_save_dnsp_srv = ndr->flags;
 729                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 730                                         NDR_CHECK(ndr_push_dnsp_srv(ndr, NDR_SCALARS, &r->srv));
 731                                         ndr->flags = _flags_save_dnsp_srv;
 732                                 }
 733                         break; }
 734
 735                         default: {
 736                                 {
 737                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 738                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 739                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 740                                         ndr->flags = _flags_save_DATA_BLOB;
 741                                 }
 742                         break; }
 743
 744                 }
 745         }
 746         if (ndr_flags & NDR_BUFFERS) {
 747                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 748                 switch (level) {
 749                         case DNS_TYPE_TOMBSTONE:
 750                         break;
 751
 752                         case DNS_TYPE_A:
 753                         break;
 754
 755                         case DNS_TYPE_NS:
 756                         break;
 757
 758                         case DNS_TYPE_CNAME:
 759                         break;
 760
 761                         case DNS_TYPE_SOA:
 762                         break;
 763
 764                         case DNS_TYPE_MX:
 765                         break;
 766
 767                         case DNS_TYPE_TXT:
 768                         break;
 769
 770                         case DNS_TYPE_PTR:
 771                         break;
 772
 773                         case DNS_TYPE_HINFO:
 774                         break;
 775
 776                         case DNS_TYPE_AAAA:
 777                         break;
 778
 779                         case DNS_TYPE_SRV:
 780                         break;
 781
 782                         default:
 783                         break;
 784
 785                 }
 786         }
 787         return NDR_ERR_SUCCESS;
 788 }
 789
 790 static enum ndr_err_code ndr_pull_dnsRecordData(struct ndr_pull *ndr, int ndr_flags, union dnsRecordData *r)
 791 {
 792         uint32_t level;
 793         level = ndr_pull_get_switch_value(ndr, r);
 794         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 795         if (ndr_flags & NDR_SCALARS) {
 796                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 797                 switch (level) {
 798                         case DNS_TYPE_TOMBSTONE: {
 799                                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
 800                         break; }
 801
 802                         case DNS_TYPE_A: {
 803                                 {
 804                                         uint32_t _flags_save_ipv4address = ndr->flags;
 805                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 806                                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipv4));
 807                                         ndr->flags = _flags_save_ipv4address;
 808                                 }
 809                         break; }
 810
 811                         case DNS_TYPE_NS: {
 812                                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->ns));
 813                         break; }
 814
 815                         case DNS_TYPE_CNAME: {
 816                                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->cname));
 817                         break; }
 818
 819                         case DNS_TYPE_SOA: {
 820                                 {
 821                                         uint32_t _flags_save_dnsp_soa = ndr->flags;
 822                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 823                                         NDR_CHECK(ndr_pull_dnsp_soa(ndr, NDR_SCALARS, &r->soa));
 824                                         ndr->flags = _flags_save_dnsp_soa;
 825                                 }
 826                         break; }
 827
 828                         case DNS_TYPE_MX: {
 829                                 {
 830                                         uint32_t _flags_save_dnsp_mx = ndr->flags;
 831                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 832                                         NDR_CHECK(ndr_pull_dnsp_mx(ndr, NDR_SCALARS, &r->mx));
 833                                         ndr->flags = _flags_save_dnsp_mx;
 834                                 }
 835                         break; }
 836
 837                         case DNS_TYPE_TXT: {
 838                                 NDR_CHECK(ndr_pull_dnsp_string_list(ndr, NDR_SCALARS, &r->txt));
 839                         break; }
 840
 841                         case DNS_TYPE_PTR: {
 842                                 NDR_CHECK(ndr_pull_dnsp_name(ndr, NDR_SCALARS, &r->ptr));
 843                         break; }
 844
 845                         case DNS_TYPE_HINFO: {
 846                                 NDR_CHECK(ndr_pull_dnsp_hinfo(ndr, NDR_SCALARS, &r->hinfo));
 847                         break; }
 848
 849                         case DNS_TYPE_AAAA: {
 850                                 NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ipv6));
 851                         break; }
 852
 853                         case DNS_TYPE_SRV: {
 854                                 {
 855                                         uint32_t _flags_save_dnsp_srv = ndr->flags;
 856                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 857                                         NDR_CHECK(ndr_pull_dnsp_srv(ndr, NDR_SCALARS, &r->srv));
 858                                         ndr->flags = _flags_save_dnsp_srv;
 859                                 }
 860                         break; }
 861
 862                         default: {
 863                                 {
 864                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 865                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 866                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 867                                         ndr->flags = _flags_save_DATA_BLOB;
 868                                 }
 869                         break; }
 870
 871                 }
 872         }
 873         if (ndr_flags & NDR_BUFFERS) {
 874                 switch (level) {
 875                         case DNS_TYPE_TOMBSTONE:
 876                         break;
 877
 878                         case DNS_TYPE_A:
 879                         break;
 880
 881                         case DNS_TYPE_NS:
 882                         break;
 883
 884                         case DNS_TYPE_CNAME:
 885                         break;
 886
 887                         case DNS_TYPE_SOA:
 888                         break;
 889
 890                         case DNS_TYPE_MX:
 891                         break;
 892
 893                         case DNS_TYPE_TXT:
 894                         break;
 895
 896                         case DNS_TYPE_PTR:
 897                         break;
 898
 899                         case DNS_TYPE_HINFO:
 900                         break;
 901
 902                         case DNS_TYPE_AAAA:
 903                         break;
 904
 905                         case DNS_TYPE_SRV:
 906                         break;
 907
 908                         default:
 909                         break;
 910
 911                 }
 912         }
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ void ndr_print_dnsRecordData(struct ndr_print *ndr, const char *name, const union dnsRecordData *r)
 917 {
 918         uint32_t level;
 919         level = ndr_print_get_switch_value(ndr, r);
 920         ndr_print_union(ndr, name, level, "dnsRecordData");
 921         switch (level) {
 922                 case DNS_TYPE_TOMBSTONE:
 923                         ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
 924                 break;
 925
 926                 case DNS_TYPE_A:
 927                         ndr_print_ipv4address(ndr, "ipv4", r->ipv4);
 928                 break;
 929
 930                 case DNS_TYPE_NS:
 931                         ndr_print_dnsp_name(ndr, "ns", r->ns);
 932                 break;
 933
 934                 case DNS_TYPE_CNAME:
 935                         ndr_print_dnsp_name(ndr, "cname", r->cname);
 936                 break;
 937
 938                 case DNS_TYPE_SOA:
 939                         ndr_print_dnsp_soa(ndr, "soa", &r->soa);
 940                 break;
 941
 942                 case DNS_TYPE_MX:
 943                         ndr_print_dnsp_mx(ndr, "mx", &r->mx);
 944                 break;
 945
 946                 case DNS_TYPE_TXT:
 947                         ndr_print_dnsp_string_list(ndr, "txt", &r->txt);
 948                 break;
 949
 950                 case DNS_TYPE_PTR:
 951                         ndr_print_dnsp_name(ndr, "ptr", r->ptr);
 952                 break;
 953
 954                 case DNS_TYPE_HINFO:
 955                         ndr_print_dnsp_hinfo(ndr, "hinfo", &r->hinfo);
 956                 break;
 957
 958                 case DNS_TYPE_AAAA:
 959                         ndr_print_ipv6address(ndr, "ipv6", r->ipv6);
 960                 break;
 961
 962                 case DNS_TYPE_SRV:
 963                         ndr_print_dnsp_srv(ndr, "srv", &r->srv);
 964                 break;
 965
 966                 default:
 967                         ndr_print_DATA_BLOB(ndr, "data", r->data);
 968                 break;
 969
 970         }
 971 }
 972
 973 static size_t ndr_size_dnsRecordData(const union dnsRecordData *r, uint32_t level, int flags)
 974 {
 975         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_dnsRecordData);
 976 }
 977
 978 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_DnssrvRpcRecord(struct ndr_push *ndr, int ndr_flags, const struct dnsp_DnssrvRpcRecord *r)
 979 {
 980         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 981         if (ndr_flags & NDR_SCALARS) {
 982                 NDR_CHECK(ndr_push_align(ndr, 4));
 983                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_dnsRecordData(&r->data, r->wType, ndr->flags)));
 984                 NDR_CHECK(ndr_push_dns_record_type(ndr, NDR_SCALARS, r->wType));
 985                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 5));
 986                 NDR_CHECK(ndr_push_dns_record_rank(ndr, NDR_SCALARS, r->rank));
 987                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->flags));
 988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwSerial));
 989                 {
 990                         uint32_t _flags_save_uint32 = ndr->flags;
 991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwTtlSeconds));
 993                         ndr->flags = _flags_save_uint32;
 994                 }
 995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwReserved));
 996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwTimeStamp));
 997                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->wType));
 998                 NDR_CHECK(ndr_push_dnsRecordData(ndr, NDR_SCALARS, &r->data));
 999                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002         }
1003         return NDR_ERR_SUCCESS;
1004 }
1005
1006 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_DnssrvRpcRecord(struct ndr_pull *ndr, int ndr_flags, struct dnsp_DnssrvRpcRecord *r)
1007 {
1008         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1009         if (ndr_flags & NDR_SCALARS) {
1010                 NDR_CHECK(ndr_pull_align(ndr, 4));
1011                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wDataLength));
1012                 NDR_CHECK(ndr_pull_dns_record_type(ndr, NDR_SCALARS, &r->wType));
1013                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->version));
1014                 NDR_CHECK(ndr_pull_dns_record_rank(ndr, NDR_SCALARS, &r->rank));
1015                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
1016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwSerial));
1017                 {
1018                         uint32_t _flags_save_uint32 = ndr->flags;
1019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1020                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwTtlSeconds));
1021                         ndr->flags = _flags_save_uint32;
1022                 }
1023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwReserved));
1024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwTimeStamp));
1025                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->wType));
1026                 NDR_CHECK(ndr_pull_dnsRecordData(ndr, NDR_SCALARS, &r->data));
1027                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1028         }
1029         if (ndr_flags & NDR_BUFFERS) {
1030         }
1031         return NDR_ERR_SUCCESS;
1032 }
1033
1034 _PUBLIC_ void ndr_print_dnsp_DnssrvRpcRecord(struct ndr_print *ndr, const char *name, const struct dnsp_DnssrvRpcRecord *r)
1035 {
1036         ndr_print_struct(ndr, name, "dnsp_DnssrvRpcRecord");
1037         if (r == NULL) { ndr_print_null(ndr); return; }
1038         ndr->depth++;
1039         ndr_print_uint16(ndr, "wDataLength", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dnsRecordData(&r->data, r->wType, ndr->flags):r->wDataLength);
1040         ndr_print_dns_record_type(ndr, "wType", r->wType);
1041         ndr_print_uint8(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?5:r->version);
1042         ndr_print_dns_record_rank(ndr, "rank", r->rank);
1043         ndr_print_uint16(ndr, "flags", r->flags);
1044         ndr_print_uint32(ndr, "dwSerial", r->dwSerial);
1045         ndr_print_uint32(ndr, "dwTtlSeconds", r->dwTtlSeconds);
1046         ndr_print_uint32(ndr, "dwReserved", r->dwReserved);
1047         ndr_print_uint32(ndr, "dwTimeStamp", r->dwTimeStamp);
1048         ndr_print_set_switch_value(ndr, &r->data, r->wType);
1049         ndr_print_dnsRecordData(ndr, "data", &r->data);
1050         ndr->depth--;
1051 }
1052
1053 static enum ndr_err_code ndr_push_dnsPropertyData(struct ndr_push *ndr, int ndr_flags, const union dnsPropertyData *r)
1054 {
1055         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1056         if (ndr_flags & NDR_SCALARS) {
1057                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1058                 NDR_CHECK(ndr_push_union_align(ndr, 5));
1059                 switch (level) {
1060                         case DSPROPERTY_ZONE_EMPTY: {
1061                         break; }
1062
1063                         case DSPROPERTY_ZONE_TYPE: {
1064                                 NDR_CHECK(ndr_push_dns_zone_type(ndr, NDR_SCALARS, r->zone_type));
1065                         break; }
1066
1067                         case DSPROPERTY_ZONE_ALLOW_UPDATE: {
1068                                 NDR_CHECK(ndr_push_dns_zone_update(ndr, NDR_SCALARS, r->allow_update_flag));
1069                         break; }
1070
1071                         case DSPROPERTY_ZONE_SECURE_TIME: {
1072                                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->zone_secure_time));
1073                         break; }
1074
1075                         case DSPROPERTY_ZONE_NOREFRESH_INTERVAL: {
1076                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->norefresh_hours));
1077                         break; }
1078
1079                         case DSPROPERTY_ZONE_REFRESH_INTERVAL: {
1080                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->refresh_hours));
1081                         break; }
1082
1083                         case DSPROPERTY_ZONE_AGING_STATE: {
1084                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->aging_enabled));
1085                         break; }
1086
1087                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS: {
1088                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_SCALARS, &r->servers));
1089                         break; }
1090
1091                         case DSPROPERTY_ZONE_AGING_ENABLED_TIME: {
1092                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_scavenging_cycle_hours));
1093                         break; }
1094
1095                         case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME: {
1096                                 {
1097                                         uint32_t _flags_save_string = ndr->flags;
1098                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
1099                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->deleted_by_hostname));
1100                                         ndr->flags = _flags_save_string;
1101                                 }
1102                         break; }
1103
1104                         case DSPROPERTY_ZONE_MASTER_SERVERS: {
1105                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_SCALARS, &r->master_servers));
1106                         break; }
1107
1108                         case DSPROPERTY_ZONE_AUTO_NS_SERVERS: {
1109                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_SCALARS, &r->ns_servers));
1110                         break; }
1111
1112                         case DSPROPERTY_ZONE_DCPROMO_CONVERT: {
1113                                 NDR_CHECK(ndr_push_dns_dcpromo_flag(ndr, NDR_SCALARS, r->dcpromo_flag));
1114                         break; }
1115
1116                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA: {
1117                                 NDR_CHECK(ndr_push_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->s_ns_servers));
1118                         break; }
1119
1120                         case DSPROPERTY_ZONE_MASTER_SERVERS_DA: {
1121                                 NDR_CHECK(ndr_push_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->z_master_servers));
1122                         break; }
1123
1124                         case DSPROPERTY_ZONE_NS_SERVERS_DA: {
1125                                 NDR_CHECK(ndr_push_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->d_ns_servers));
1126                         break; }
1127
1128                         case DSPROPERTY_ZONE_NODE_DBFLAGS: {
1129                                 NDR_CHECK(ndr_push_dns_rpc_node_flags(ndr, NDR_SCALARS, r->flags));
1130                         break; }
1131
1132                         default:
1133                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1134                 }
1135         }
1136         if (ndr_flags & NDR_BUFFERS) {
1137                 uint32_t level = ndr_push_get_switch_value(ndr, r);
1138                 switch (level) {
1139                         case DSPROPERTY_ZONE_EMPTY:
1140                         break;
1141
1142                         case DSPROPERTY_ZONE_TYPE:
1143                         break;
1144
1145                         case DSPROPERTY_ZONE_ALLOW_UPDATE:
1146                         break;
1147
1148                         case DSPROPERTY_ZONE_SECURE_TIME:
1149                         break;
1150
1151                         case DSPROPERTY_ZONE_NOREFRESH_INTERVAL:
1152                         break;
1153
1154                         case DSPROPERTY_ZONE_REFRESH_INTERVAL:
1155                         break;
1156
1157                         case DSPROPERTY_ZONE_AGING_STATE:
1158                         break;
1159
1160                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS:
1161                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->servers));
1162                         break;
1163
1164                         case DSPROPERTY_ZONE_AGING_ENABLED_TIME:
1165                         break;
1166
1167                         case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME:
1168                         break;
1169
1170                         case DSPROPERTY_ZONE_MASTER_SERVERS:
1171                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->master_servers));
1172                         break;
1173
1174                         case DSPROPERTY_ZONE_AUTO_NS_SERVERS:
1175                                 NDR_CHECK(ndr_push_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->ns_servers));
1176                         break;
1177
1178                         case DSPROPERTY_ZONE_DCPROMO_CONVERT:
1179                         break;
1180
1181                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA:
1182                         break;
1183
1184                         case DSPROPERTY_ZONE_MASTER_SERVERS_DA:
1185                         break;
1186
1187                         case DSPROPERTY_ZONE_NS_SERVERS_DA:
1188                         break;
1189
1190                         case DSPROPERTY_ZONE_NODE_DBFLAGS:
1191                         break;
1192
1193                         default:
1194                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1195                 }
1196         }
1197         return NDR_ERR_SUCCESS;
1198 }
1199
1200 static enum ndr_err_code ndr_pull_dnsPropertyData(struct ndr_pull *ndr, int ndr_flags, union dnsPropertyData *r)
1201 {
1202         uint32_t level;
1203         level = ndr_pull_get_switch_value(ndr, r);
1204         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1205         if (ndr_flags & NDR_SCALARS) {
1206                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1207                 switch (level) {
1208                         case DSPROPERTY_ZONE_EMPTY: {
1209                         break; }
1210
1211                         case DSPROPERTY_ZONE_TYPE: {
1212                                 NDR_CHECK(ndr_pull_dns_zone_type(ndr, NDR_SCALARS, &r->zone_type));
1213                         break; }
1214
1215                         case DSPROPERTY_ZONE_ALLOW_UPDATE: {
1216                                 NDR_CHECK(ndr_pull_dns_zone_update(ndr, NDR_SCALARS, &r->allow_update_flag));
1217                         break; }
1218
1219                         case DSPROPERTY_ZONE_SECURE_TIME: {
1220                                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->zone_secure_time));
1221                         break; }
1222
1223                         case DSPROPERTY_ZONE_NOREFRESH_INTERVAL: {
1224                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->norefresh_hours));
1225                         break; }
1226
1227                         case DSPROPERTY_ZONE_REFRESH_INTERVAL: {
1228                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->refresh_hours));
1229                         break; }
1230
1231                         case DSPROPERTY_ZONE_AGING_STATE: {
1232                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->aging_enabled));
1233                         break; }
1234
1235                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS: {
1236                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_SCALARS, &r->servers));
1237                         break; }
1238
1239                         case DSPROPERTY_ZONE_AGING_ENABLED_TIME: {
1240                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_scavenging_cycle_hours));
1241                         break; }
1242
1243                         case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME: {
1244                                 {
1245                                         uint32_t _flags_save_string = ndr->flags;
1246                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
1247                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->deleted_by_hostname));
1248                                         ndr->flags = _flags_save_string;
1249                                 }
1250                         break; }
1251
1252                         case DSPROPERTY_ZONE_MASTER_SERVERS: {
1253                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_SCALARS, &r->master_servers));
1254                         break; }
1255
1256                         case DSPROPERTY_ZONE_AUTO_NS_SERVERS: {
1257                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_SCALARS, &r->ns_servers));
1258                         break; }
1259
1260                         case DSPROPERTY_ZONE_DCPROMO_CONVERT: {
1261                                 NDR_CHECK(ndr_pull_dns_dcpromo_flag(ndr, NDR_SCALARS, &r->dcpromo_flag));
1262                         break; }
1263
1264                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA: {
1265                                 NDR_CHECK(ndr_pull_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->s_ns_servers));
1266                         break; }
1267
1268                         case DSPROPERTY_ZONE_MASTER_SERVERS_DA: {
1269                                 NDR_CHECK(ndr_pull_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->z_master_servers));
1270                         break; }
1271
1272                         case DSPROPERTY_ZONE_NS_SERVERS_DA: {
1273                                 NDR_CHECK(ndr_pull_dnsp_dns_addr_array(ndr, NDR_SCALARS, &r->d_ns_servers));
1274                         break; }
1275
1276                         case DSPROPERTY_ZONE_NODE_DBFLAGS: {
1277                                 NDR_CHECK(ndr_pull_dns_rpc_node_flags(ndr, NDR_SCALARS, &r->flags));
1278                         break; }
1279
1280                         default:
1281                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1282                 }
1283         }
1284         if (ndr_flags & NDR_BUFFERS) {
1285                 switch (level) {
1286                         case DSPROPERTY_ZONE_EMPTY:
1287                         break;
1288
1289                         case DSPROPERTY_ZONE_TYPE:
1290                         break;
1291
1292                         case DSPROPERTY_ZONE_ALLOW_UPDATE:
1293                         break;
1294
1295                         case DSPROPERTY_ZONE_SECURE_TIME:
1296                         break;
1297
1298                         case DSPROPERTY_ZONE_NOREFRESH_INTERVAL:
1299                         break;
1300
1301                         case DSPROPERTY_ZONE_REFRESH_INTERVAL:
1302                         break;
1303
1304                         case DSPROPERTY_ZONE_AGING_STATE:
1305                         break;
1306
1307                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS:
1308                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->servers));
1309                         break;
1310
1311                         case DSPROPERTY_ZONE_AGING_ENABLED_TIME:
1312                         break;
1313
1314                         case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME:
1315                         break;
1316
1317                         case DSPROPERTY_ZONE_MASTER_SERVERS:
1318                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->master_servers));
1319                         break;
1320
1321                         case DSPROPERTY_ZONE_AUTO_NS_SERVERS:
1322                                 NDR_CHECK(ndr_pull_dnsp_ip4_array(ndr, NDR_BUFFERS, &r->ns_servers));
1323                         break;
1324
1325                         case DSPROPERTY_ZONE_DCPROMO_CONVERT:
1326                         break;
1327
1328                         case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA:
1329                         break;
1330
1331                         case DSPROPERTY_ZONE_MASTER_SERVERS_DA:
1332                         break;
1333
1334                         case DSPROPERTY_ZONE_NS_SERVERS_DA:
1335                         break;
1336
1337                         case DSPROPERTY_ZONE_NODE_DBFLAGS:
1338                         break;
1339
1340                         default:
1341                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1342                 }
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_dnsPropertyData(struct ndr_print *ndr, const char *name, const union dnsPropertyData *r)
1348 {
1349         uint32_t level;
1350         level = ndr_print_get_switch_value(ndr, r);
1351         ndr_print_union(ndr, name, level, "dnsPropertyData");
1352         switch (level) {
1353                 case DSPROPERTY_ZONE_EMPTY:
1354                 break;
1355
1356                 case DSPROPERTY_ZONE_TYPE:
1357                         ndr_print_dns_zone_type(ndr, "zone_type", r->zone_type);
1358                 break;
1359
1360                 case DSPROPERTY_ZONE_ALLOW_UPDATE:
1361                         ndr_print_dns_zone_update(ndr, "allow_update_flag", r->allow_update_flag);
1362                 break;
1363
1364                 case DSPROPERTY_ZONE_SECURE_TIME:
1365                         ndr_print_NTTIME(ndr, "zone_secure_time", r->zone_secure_time);
1366                 break;
1367
1368                 case DSPROPERTY_ZONE_NOREFRESH_INTERVAL:
1369                         ndr_print_uint32(ndr, "norefresh_hours", r->norefresh_hours);
1370                 break;
1371
1372                 case DSPROPERTY_ZONE_REFRESH_INTERVAL:
1373                         ndr_print_uint32(ndr, "refresh_hours", r->refresh_hours);
1374                 break;
1375
1376                 case DSPROPERTY_ZONE_AGING_STATE:
1377                         ndr_print_uint32(ndr, "aging_enabled", r->aging_enabled);
1378                 break;
1379
1380                 case DSPROPERTY_ZONE_SCAVENGING_SERVERS:
1381                         ndr_print_dnsp_ip4_array(ndr, "servers", &r->servers);
1382                 break;
1383
1384                 case DSPROPERTY_ZONE_AGING_ENABLED_TIME:
1385                         ndr_print_uint32(ndr, "next_scavenging_cycle_hours", r->next_scavenging_cycle_hours);
1386                 break;
1387
1388                 case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME:
1389                         ndr_print_string(ndr, "deleted_by_hostname", r->deleted_by_hostname);
1390                 break;
1391
1392                 case DSPROPERTY_ZONE_MASTER_SERVERS:
1393                         ndr_print_dnsp_ip4_array(ndr, "master_servers", &r->master_servers);
1394                 break;
1395
1396                 case DSPROPERTY_ZONE_AUTO_NS_SERVERS:
1397                         ndr_print_dnsp_ip4_array(ndr, "ns_servers", &r->ns_servers);
1398                 break;
1399
1400                 case DSPROPERTY_ZONE_DCPROMO_CONVERT:
1401                         ndr_print_dns_dcpromo_flag(ndr, "dcpromo_flag", r->dcpromo_flag);
1402                 break;
1403
1404                 case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA:
1405                         ndr_print_dnsp_dns_addr_array(ndr, "s_ns_servers", &r->s_ns_servers);
1406                 break;
1407
1408                 case DSPROPERTY_ZONE_MASTER_SERVERS_DA:
1409                         ndr_print_dnsp_dns_addr_array(ndr, "z_master_servers", &r->z_master_servers);
1410                 break;
1411
1412                 case DSPROPERTY_ZONE_NS_SERVERS_DA:
1413                         ndr_print_dnsp_dns_addr_array(ndr, "d_ns_servers", &r->d_ns_servers);
1414                 break;
1415
1416                 case DSPROPERTY_ZONE_NODE_DBFLAGS:
1417                         ndr_print_dns_rpc_node_flags(ndr, "flags", r->flags);
1418                 break;
1419
1420                 default:
1421                         ndr_print_bad_level(ndr, name, level);
1422         }
1423 }
1424
1425 static size_t ndr_size_dnsPropertyData(const union dnsPropertyData *r, uint32_t level, int flags)
1426 {
1427         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_dnsPropertyData);
1428 }
1429
1430 _PUBLIC_ enum ndr_err_code ndr_push_dnsp_DnsProperty(struct ndr_push *ndr, int ndr_flags, const struct dnsp_DnsProperty *r)
1431 {
1432         {
1433                 uint32_t _flags_save_STRUCT = ndr->flags;
1434                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1435                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1436                 if (ndr_flags & NDR_SCALARS) {
1437                         NDR_CHECK(ndr_push_align(ndr, 5));
1438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dnsPropertyData(&r->data, r->id, ndr->flags)));
1439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->namelength));
1440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1442                         NDR_CHECK(ndr_push_dns_property_id(ndr, NDR_SCALARS, r->id));
1443                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, ndr_size_dnsPropertyData(&r->data, r->id, ndr->flags)?r->id:DSPROPERTY_ZONE_EMPTY));
1444                         NDR_CHECK(ndr_push_dnsPropertyData(ndr, NDR_SCALARS, &r->data));
1445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->name));
1446                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1447                 }
1448                 if (ndr_flags & NDR_BUFFERS) {
1449                         NDR_CHECK(ndr_push_dnsPropertyData(ndr, NDR_BUFFERS, &r->data));
1450                 }
1451                 ndr->flags = _flags_save_STRUCT;
1452         }
1453         return NDR_ERR_SUCCESS;
1454 }
1455
1456 _PUBLIC_ enum ndr_err_code ndr_pull_dnsp_DnsProperty(struct ndr_pull *ndr, int ndr_flags, struct dnsp_DnsProperty *r)
1457 {
1458         {
1459                 uint32_t _flags_save_STRUCT = ndr->flags;
1460                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1461                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1462                 if (ndr_flags & NDR_SCALARS) {
1463                         NDR_CHECK(ndr_pull_align(ndr, 5));
1464                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wDataLength));
1465                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->namelength));
1466                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flag));
1467                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1468                         NDR_CHECK(ndr_pull_dns_property_id(ndr, NDR_SCALARS, &r->id));
1469                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->wDataLength?r->id:DSPROPERTY_ZONE_EMPTY));
1470                         NDR_CHECK(ndr_pull_dnsPropertyData(ndr, NDR_SCALARS, &r->data));
1471                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->name));
1472                         NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1473                 }
1474                 if (ndr_flags & NDR_BUFFERS) {
1475                         NDR_CHECK(ndr_pull_dnsPropertyData(ndr, NDR_BUFFERS, &r->data));
1476                 }
1477                 ndr->flags = _flags_save_STRUCT;
1478         }
1479         return NDR_ERR_SUCCESS;
1480 }
1481
1482 _PUBLIC_ void ndr_print_dnsp_DnsProperty(struct ndr_print *ndr, const char *name, const struct dnsp_DnsProperty *r)
1483 {
1484         ndr_print_struct(ndr, name, "dnsp_DnsProperty");
1485         if (r == NULL) { ndr_print_null(ndr); return; }
1486         {
1487                 uint32_t _flags_save_STRUCT = ndr->flags;
1488                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1489                 ndr->depth++;
1490                 ndr_print_uint32(ndr, "wDataLength", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dnsPropertyData(&r->data, r->id, ndr->flags):r->wDataLength);
1491                 ndr_print_uint32(ndr, "namelength", r->namelength);
1492                 ndr_print_uint32(ndr, "flag", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flag);
1493                 ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1494                 ndr_print_dns_property_id(ndr, "id", r->id);
1495                 ndr_print_set_switch_value(ndr, &r->data, r->wDataLength?r->id:DSPROPERTY_ZONE_EMPTY);
1496                 ndr_print_dnsPropertyData(ndr, "data", &r->data);
1497                 ndr_print_uint32(ndr, "name", r->name);
1498                 ndr->depth--;
1499                 ndr->flags = _flags_save_STRUCT;
1500         }
1501 }
1502
1503 static enum ndr_err_code ndr_push_decode_DnssrvRpcRecord(struct ndr_push *ndr, int flags, const struct decode_DnssrvRpcRecord *r)
1504 {
1505         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1506         if (flags & NDR_IN) {
1507                 NDR_CHECK(ndr_push_dnsp_DnssrvRpcRecord(ndr, NDR_SCALARS, &r->in.blob));
1508         }
1509         if (flags & NDR_OUT) {
1510         }
1511         return NDR_ERR_SUCCESS;
1512 }
1513
1514 static enum ndr_err_code ndr_pull_decode_DnssrvRpcRecord(struct ndr_pull *ndr, int flags, struct decode_DnssrvRpcRecord *r)
1515 {
1516         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1517         if (flags & NDR_IN) {
1518                 NDR_CHECK(ndr_pull_dnsp_DnssrvRpcRecord(ndr, NDR_SCALARS, &r->in.blob));
1519         }
1520         if (flags & NDR_OUT) {
1521         }
1522         return NDR_ERR_SUCCESS;
1523 }
1524
1525 _PUBLIC_ void ndr_print_decode_DnssrvRpcRecord(struct ndr_print *ndr, const char *name, int flags, const struct decode_DnssrvRpcRecord *r)
1526 {
1527         ndr_print_struct(ndr, name, "decode_DnssrvRpcRecord");
1528         if (r == NULL) { ndr_print_null(ndr); return; }
1529         ndr->depth++;
1530         if (flags & NDR_SET_VALUES) {
1531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1532         }
1533         if (flags & NDR_IN) {
1534                 ndr_print_struct(ndr, "in", "decode_DnssrvRpcRecord");
1535                 ndr->depth++;
1536                 ndr_print_dnsp_DnssrvRpcRecord(ndr, "blob", &r->in.blob);
1537                 ndr->depth--;
1538         }
1539         if (flags & NDR_OUT) {
1540                 ndr_print_struct(ndr, "out", "decode_DnssrvRpcRecord");
1541                 ndr->depth++;
1542                 ndr->depth--;
1543         }
1544         ndr->depth--;
1545 }
1546
1547 static enum ndr_err_code ndr_push_decode_DnsProperty(struct ndr_push *ndr, int flags, const struct decode_DnsProperty *r)
1548 {
1549         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1550         if (flags & NDR_IN) {
1551                 NDR_CHECK(ndr_push_dnsp_DnsProperty(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
1552         }
1553         if (flags & NDR_OUT) {
1554         }
1555         return NDR_ERR_SUCCESS;
1556 }
1557
1558 static enum ndr_err_code ndr_pull_decode_DnsProperty(struct ndr_pull *ndr, int flags, struct decode_DnsProperty *r)
1559 {
1560         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1561         if (flags & NDR_IN) {
1562                 NDR_CHECK(ndr_pull_dnsp_DnsProperty(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
1563         }
1564         if (flags & NDR_OUT) {
1565         }
1566         return NDR_ERR_SUCCESS;
1567 }
1568
1569 _PUBLIC_ void ndr_print_decode_DnsProperty(struct ndr_print *ndr, const char *name, int flags, const struct decode_DnsProperty *r)
1570 {
1571         ndr_print_struct(ndr, name, "decode_DnsProperty");
1572         if (r == NULL) { ndr_print_null(ndr); return; }
1573         ndr->depth++;
1574         if (flags & NDR_SET_VALUES) {
1575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1576         }
1577         if (flags & NDR_IN) {
1578                 ndr_print_struct(ndr, "in", "decode_DnsProperty");
1579                 ndr->depth++;
1580                 ndr_print_dnsp_DnsProperty(ndr, "blob", &r->in.blob);
1581                 ndr->depth--;
1582         }
1583         if (flags & NDR_OUT) {
1584                 ndr_print_struct(ndr, "out", "decode_DnsProperty");
1585                 ndr->depth++;
1586                 ndr->depth--;
1587         }
1588         ndr->depth--;
1589 }
1590
1591 static const struct ndr_interface_call dnsp_calls[] = {
1592         {
1593                 "decode_DnssrvRpcRecord",
1594                 sizeof(struct decode_DnssrvRpcRecord),
1595                 (ndr_push_flags_fn_t) ndr_push_decode_DnssrvRpcRecord,
1596                 (ndr_pull_flags_fn_t) ndr_pull_decode_DnssrvRpcRecord,
1597                 (ndr_print_function_t) ndr_print_decode_DnssrvRpcRecord,
1598                 { 0, NULL },
1599                 { 0, NULL },
1600         },
1601         {
1602                 "decode_DnsProperty",
1603                 sizeof(struct decode_DnsProperty),
1604                 (ndr_push_flags_fn_t) ndr_push_decode_DnsProperty,
1605                 (ndr_pull_flags_fn_t) ndr_pull_decode_DnsProperty,
1606                 (ndr_print_function_t) ndr_print_decode_DnsProperty,
1607                 { 0, NULL },
1608                 { 0, NULL },
1609         },
1610         { NULL, 0, NULL, NULL, NULL }
1611 };
1612
1613 static const char * const dnsp_endpoint_strings[] = {
1614         "ncacn_np:[\\pipe\\dnsp]",
1615 };
1616
1617 static const struct ndr_interface_string_array dnsp_endpoints = {
1618         .count  = 1,
1619         .names  = dnsp_endpoint_strings
1620 };
1621
1622 static const char * const dnsp_authservice_strings[] = {
1623         "host",
1624 };
1625
1626 static const struct ndr_interface_string_array dnsp_authservices = {
1627         .count  = 1,
1628         .names  = dnsp_authservice_strings
1629 };
1630
1631
1632 const struct ndr_interface_table ndr_table_dnsp = {
1633         .name           = "dnsp",
1634         .syntax_id      = {
1635                 {0xbdd66e9e,0xd45f,0x4202,{0x85,0xc0},{0x61,0x32,0xed,0xc4,0xf3,0x0a}},
1636                 NDR_DNSP_VERSION
1637         },
1638         .helpstring     = NDR_DNSP_HELPSTRING,
1639         .num_calls      = 2,
1640         .calls          = dnsp_calls,
1641         .endpoints      = &dnsp_endpoints,
1642         .authservices   = &dnsp_authservices
1643 };
1644