bin/default/librpc/gen_ndr/ndr_orpc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_orpc.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_COMVERSION(struct ndr_push *ndr, int ndr_flags, const struct COMVERSION *r)
   8 {
   9         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 2));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->MajorVersion));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->MinorVersion));
  14                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  15         }
  16         if (ndr_flags & NDR_BUFFERS) {
  17         }
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _PUBLIC_ enum ndr_err_code ndr_pull_COMVERSION(struct ndr_pull *ndr, int ndr_flags, struct COMVERSION *r)
  22 {
  23         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  24         if (ndr_flags & NDR_SCALARS) {
  25                 NDR_CHECK(ndr_pull_align(ndr, 2));
  26                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->MajorVersion));
  27                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->MinorVersion));
  28                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  29         }
  30         if (ndr_flags & NDR_BUFFERS) {
  31         }
  32         return NDR_ERR_SUCCESS;
  33 }
  34
  35 _PUBLIC_ void ndr_print_COMVERSION(struct ndr_print *ndr, const char *name, const struct COMVERSION *r)
  36 {
  37         ndr_print_struct(ndr, name, "COMVERSION");
  38         if (r == NULL) { ndr_print_null(ndr); return; }
  39         ndr->depth++;
  40         ndr_print_uint16(ndr, "MajorVersion", r->MajorVersion);
  41         ndr_print_uint16(ndr, "MinorVersion", r->MinorVersion);
  42         ndr->depth--;
  43 }
  44
  45 _PUBLIC_ enum ndr_err_code ndr_push_ORPC_EXTENT(struct ndr_push *ndr, int ndr_flags, const struct ORPC_EXTENT *r)
  46 {
  47         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  48         if (ndr_flags & NDR_SCALARS) {
  49                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ((r->size + 7) & ~7)));
  50                 NDR_CHECK(ndr_push_align(ndr, 4));
  51                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->id));
  52                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
  53                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, ((r->size + 7) & ~7)));
  54                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  55         }
  56         if (ndr_flags & NDR_BUFFERS) {
  57         }
  58         return NDR_ERR_SUCCESS;
  59 }
  60
  61 _PUBLIC_ enum ndr_err_code ndr_pull_ORPC_EXTENT(struct ndr_pull *ndr, int ndr_flags, struct ORPC_EXTENT *r)
  62 {
  63         uint32_t size_data_0 = 0;
  64         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  65         if (ndr_flags & NDR_SCALARS) {
  66                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
  67                 NDR_CHECK(ndr_pull_align(ndr, 4));
  68                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->id));
  69                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  70                 size_data_0 = ndr_get_array_size(ndr, &r->data);
  71                 NDR_PULL_ALLOC_N(ndr, r->data, size_data_0);
  72                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_0));
  73                 if (r->data) {
  74                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, ((r->size + 7) & ~7)));
  75                 }
  76                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  77         }
  78         if (ndr_flags & NDR_BUFFERS) {
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 _PUBLIC_ void ndr_print_ORPC_EXTENT(struct ndr_print *ndr, const char *name, const struct ORPC_EXTENT *r)
  84 {
  85         ndr_print_struct(ndr, name, "ORPC_EXTENT");
  86         if (r == NULL) { ndr_print_null(ndr); return; }
  87         ndr->depth++;
  88         ndr_print_GUID(ndr, "id", &r->id);
  89         ndr_print_uint32(ndr, "size", r->size);
  90         ndr_print_array_uint8(ndr, "data", r->data, ((r->size + 7) & ~7));
  91         ndr->depth--;
  92 }
  93
  94 static enum ndr_err_code ndr_push_ORPC_EXTENT_ARRAY(struct ndr_push *ndr, int ndr_flags, const struct ORPC_EXTENT_ARRAY *r)
  95 {
  96         uint32_t cntr_extent_1;
  97         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  98         if (ndr_flags & NDR_SCALARS) {
  99                 NDR_CHECK(ndr_push_align(ndr, 5));
 100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
 102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->extent));
 103                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 104         }
 105         if (ndr_flags & NDR_BUFFERS) {
 106                 if (r->extent) {
 107                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ((r->size + 1) & ~1)));
 108                         for (cntr_extent_1 = 0; cntr_extent_1 < (((r->size + 1) & ~1)); cntr_extent_1++) {
 109                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->extent[cntr_extent_1]));
 110                         }
 111                         for (cntr_extent_1 = 0; cntr_extent_1 < (((r->size + 1) & ~1)); cntr_extent_1++) {
 112                                 if (r->extent[cntr_extent_1]) {
 113                                         NDR_CHECK(ndr_push_ORPC_EXTENT(ndr, NDR_SCALARS, r->extent[cntr_extent_1]));
 114                                 }
 115                         }
 116                 }
 117         }
 118         return NDR_ERR_SUCCESS;
 119 }
 120
 121 static enum ndr_err_code ndr_pull_ORPC_EXTENT_ARRAY(struct ndr_pull *ndr, int ndr_flags, struct ORPC_EXTENT_ARRAY *r)
 122 {
 123         uint32_t _ptr_extent;
 124         uint32_t size_extent_1 = 0;
 125         uint32_t cntr_extent_1;
 126         TALLOC_CTX *_mem_save_extent_0 = NULL;
 127         TALLOC_CTX *_mem_save_extent_1 = NULL;
 128         TALLOC_CTX *_mem_save_extent_2 = NULL;
 129         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 130         if (ndr_flags & NDR_SCALARS) {
 131                 NDR_CHECK(ndr_pull_align(ndr, 5));
 132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
 134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_extent));
 135                 if (_ptr_extent) {
 136                         NDR_PULL_ALLOC(ndr, r->extent);
 137                 } else {
 138                         r->extent = NULL;
 139                 }
 140                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 141         }
 142         if (ndr_flags & NDR_BUFFERS) {
 143                 if (r->extent) {
 144                         _mem_save_extent_0 = NDR_PULL_GET_MEM_CTX(ndr);
 145                         NDR_PULL_SET_MEM_CTX(ndr, r->extent, 0);
 146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->extent));
 147                         size_extent_1 = ndr_get_array_size(ndr, &r->extent);
 148                         NDR_PULL_ALLOC_N(ndr, r->extent, size_extent_1);
 149                         _mem_save_extent_1 = NDR_PULL_GET_MEM_CTX(ndr);
 150                         NDR_PULL_SET_MEM_CTX(ndr, r->extent, 0);
 151                         for (cntr_extent_1 = 0; cntr_extent_1 < (size_extent_1); cntr_extent_1++) {
 152                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_extent));
 153                                 if (_ptr_extent) {
 154                                         NDR_PULL_ALLOC(ndr, r->extent[cntr_extent_1]);
 155                                 } else {
 156                                         r->extent[cntr_extent_1] = NULL;
 157                                 }
 158                         }
 159                         for (cntr_extent_1 = 0; cntr_extent_1 < (size_extent_1); cntr_extent_1++) {
 160                                 if (r->extent[cntr_extent_1]) {
 161                                         _mem_save_extent_2 = NDR_PULL_GET_MEM_CTX(ndr);
 162                                         NDR_PULL_SET_MEM_CTX(ndr, r->extent[cntr_extent_1], 0);
 163                                         NDR_CHECK(ndr_pull_ORPC_EXTENT(ndr, NDR_SCALARS, r->extent[cntr_extent_1]));
 164                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_extent_2, 0);
 165                                 }
 166                         }
 167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_extent_1, 0);
 168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_extent_0, 0);
 169                 }
 170                 if (r->extent) {
 171                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->extent, ((r->size + 1) & ~1)));
 172                 }
 173         }
 174         return NDR_ERR_SUCCESS;
 175 }
 176
 177 _PUBLIC_ void ndr_print_ORPC_EXTENT_ARRAY(struct ndr_print *ndr, const char *name, const struct ORPC_EXTENT_ARRAY *r)
 178 {
 179         uint32_t cntr_extent_1;
 180         ndr_print_struct(ndr, name, "ORPC_EXTENT_ARRAY");
 181         if (r == NULL) { ndr_print_null(ndr); return; }
 182         ndr->depth++;
 183         ndr_print_uint32(ndr, "size", r->size);
 184         ndr_print_uint32(ndr, "reserved", r->reserved);
 185         ndr_print_ptr(ndr, "extent", r->extent);
 186         ndr->depth++;
 187         if (r->extent) {
 188                 ndr->print(ndr, "%s: ARRAY(%d)", "extent", (int)((r->size + 1) & ~1));
 189                 ndr->depth++;
 190                 for (cntr_extent_1 = 0; cntr_extent_1 < (((r->size + 1) & ~1)); cntr_extent_1++) {
 191                         ndr_print_ptr(ndr, "extent", r->extent[cntr_extent_1]);
 192                         ndr->depth++;
 193                         if (r->extent[cntr_extent_1]) {
 194                                 ndr_print_ORPC_EXTENT(ndr, "extent", r->extent[cntr_extent_1]);
 195                         }
 196                         ndr->depth--;
 197                 }
 198                 ndr->depth--;
 199         }
 200         ndr->depth--;
 201         ndr->depth--;
 202 }
 203
 204 _PUBLIC_ enum ndr_err_code ndr_push_ORPCTHIS(struct ndr_push *ndr, int ndr_flags, const struct ORPCTHIS *r)
 205 {
 206         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 207         if (ndr_flags & NDR_SCALARS) {
 208                 NDR_CHECK(ndr_push_align(ndr, 5));
 209                 NDR_CHECK(ndr_push_COMVERSION(ndr, NDR_SCALARS, &r->version));
 210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 212                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->cid));
 213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->extensions));
 214                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 215         }
 216         if (ndr_flags & NDR_BUFFERS) {
 217                 if (r->extensions) {
 218                         NDR_CHECK(ndr_push_ORPC_EXTENT_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->extensions));
 219                 }
 220         }
 221         return NDR_ERR_SUCCESS;
 222 }
 223
 224 _PUBLIC_ enum ndr_err_code ndr_pull_ORPCTHIS(struct ndr_pull *ndr, int ndr_flags, struct ORPCTHIS *r)
 225 {
 226         uint32_t _ptr_extensions;
 227         TALLOC_CTX *_mem_save_extensions_0 = NULL;
 228         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_pull_align(ndr, 5));
 231                 NDR_CHECK(ndr_pull_COMVERSION(ndr, NDR_SCALARS, &r->version));
 232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 234                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->cid));
 235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_extensions));
 236                 if (_ptr_extensions) {
 237                         NDR_PULL_ALLOC(ndr, r->extensions);
 238                 } else {
 239                         r->extensions = NULL;
 240                 }
 241                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 242         }
 243         if (ndr_flags & NDR_BUFFERS) {
 244                 if (r->extensions) {
 245                         _mem_save_extensions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 246                         NDR_PULL_SET_MEM_CTX(ndr, r->extensions, 0);
 247                         NDR_CHECK(ndr_pull_ORPC_EXTENT_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->extensions));
 248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_extensions_0, 0);
 249                 }
 250         }
 251         return NDR_ERR_SUCCESS;
 252 }
 253
 254 _PUBLIC_ void ndr_print_ORPCTHIS(struct ndr_print *ndr, const char *name, const struct ORPCTHIS *r)
 255 {
 256         ndr_print_struct(ndr, name, "ORPCTHIS");
 257         if (r == NULL) { ndr_print_null(ndr); return; }
 258         ndr->depth++;
 259         ndr_print_COMVERSION(ndr, "version", &r->version);
 260         ndr_print_uint32(ndr, "flags", r->flags);
 261         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 262         ndr_print_GUID(ndr, "cid", &r->cid);
 263         ndr_print_ptr(ndr, "extensions", r->extensions);
 264         ndr->depth++;
 265         if (r->extensions) {
 266                 ndr_print_ORPC_EXTENT_ARRAY(ndr, "extensions", r->extensions);
 267         }
 268         ndr->depth--;
 269         ndr->depth--;
 270 }
 271
 272 _PUBLIC_ enum ndr_err_code ndr_push_ORPCTHAT(struct ndr_push *ndr, int ndr_flags, const struct ORPCTHAT *r)
 273 {
 274         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 275         if (ndr_flags & NDR_SCALARS) {
 276                 NDR_CHECK(ndr_push_align(ndr, 5));
 277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->extensions));
 279                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 280         }
 281         if (ndr_flags & NDR_BUFFERS) {
 282                 if (r->extensions) {
 283                         NDR_CHECK(ndr_push_ORPC_EXTENT_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->extensions));
 284                 }
 285         }
 286         return NDR_ERR_SUCCESS;
 287 }
 288
 289 _PUBLIC_ enum ndr_err_code ndr_pull_ORPCTHAT(struct ndr_pull *ndr, int ndr_flags, struct ORPCTHAT *r)
 290 {
 291         uint32_t _ptr_extensions;
 292         TALLOC_CTX *_mem_save_extensions_0 = NULL;
 293         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 294         if (ndr_flags & NDR_SCALARS) {
 295                 NDR_CHECK(ndr_pull_align(ndr, 5));
 296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_extensions));
 298                 if (_ptr_extensions) {
 299                         NDR_PULL_ALLOC(ndr, r->extensions);
 300                 } else {
 301                         r->extensions = NULL;
 302                 }
 303                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 304         }
 305         if (ndr_flags & NDR_BUFFERS) {
 306                 if (r->extensions) {
 307                         _mem_save_extensions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 308                         NDR_PULL_SET_MEM_CTX(ndr, r->extensions, 0);
 309                         NDR_CHECK(ndr_pull_ORPC_EXTENT_ARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->extensions));
 310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_extensions_0, 0);
 311                 }
 312         }
 313         return NDR_ERR_SUCCESS;
 314 }
 315
 316 _PUBLIC_ void ndr_print_ORPCTHAT(struct ndr_print *ndr, const char *name, const struct ORPCTHAT *r)
 317 {
 318         ndr_print_struct(ndr, name, "ORPCTHAT");
 319         if (r == NULL) { ndr_print_null(ndr); return; }
 320         ndr->depth++;
 321         ndr_print_uint32(ndr, "flags", r->flags);
 322         ndr_print_ptr(ndr, "extensions", r->extensions);
 323         ndr->depth++;
 324         if (r->extensions) {
 325                 ndr_print_ORPC_EXTENT_ARRAY(ndr, "extensions", r->extensions);
 326         }
 327         ndr->depth--;
 328         ndr->depth--;
 329 }
 330
 331 _PUBLIC_ enum ndr_err_code ndr_push_STRINGBINDING(struct ndr_push *ndr, int ndr_flags, const struct STRINGBINDING *r)
 332 {
 333         {
 334                 uint32_t _flags_save_STRUCT = ndr->flags;
 335                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 336                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 337                 if (ndr_flags & NDR_SCALARS) {
 338                         NDR_CHECK(ndr_push_align(ndr, 4));
 339                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wTowerId));
 340                         {
 341                                 uint32_t _flags_save_string = ndr->flags;
 342                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 343                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->NetworkAddr));
 344                                 ndr->flags = _flags_save_string;
 345                         }
 346                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 347                 }
 348                 if (ndr_flags & NDR_BUFFERS) {
 349                 }
 350                 ndr->flags = _flags_save_STRUCT;
 351         }
 352         return NDR_ERR_SUCCESS;
 353 }
 354
 355 _PUBLIC_ enum ndr_err_code ndr_pull_STRINGBINDING(struct ndr_pull *ndr, int ndr_flags, struct STRINGBINDING *r)
 356 {
 357         {
 358                 uint32_t _flags_save_STRUCT = ndr->flags;
 359                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 360                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 361                 if (ndr_flags & NDR_SCALARS) {
 362                         NDR_CHECK(ndr_pull_align(ndr, 4));
 363                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wTowerId));
 364                         {
 365                                 uint32_t _flags_save_string = ndr->flags;
 366                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->NetworkAddr));
 368                                 ndr->flags = _flags_save_string;
 369                         }
 370                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 371                 }
 372                 if (ndr_flags & NDR_BUFFERS) {
 373                 }
 374                 ndr->flags = _flags_save_STRUCT;
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ void ndr_print_STRINGBINDING(struct ndr_print *ndr, const char *name, const struct STRINGBINDING *r)
 380 {
 381         ndr_print_struct(ndr, name, "STRINGBINDING");
 382         if (r == NULL) { ndr_print_null(ndr); return; }
 383         {
 384                 uint32_t _flags_save_STRUCT = ndr->flags;
 385                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 386                 ndr->depth++;
 387                 ndr_print_uint16(ndr, "wTowerId", r->wTowerId);
 388                 ndr_print_string(ndr, "NetworkAddr", r->NetworkAddr);
 389                 ndr->depth--;
 390                 ndr->flags = _flags_save_STRUCT;
 391         }
 392 }
 393
 394 _PUBLIC_ enum ndr_err_code ndr_push_SECURITYBINDING(struct ndr_push *ndr, int ndr_flags, const struct SECURITYBINDING *r)
 395 {
 396         {
 397                 uint32_t _flags_save_STRUCT = ndr->flags;
 398                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 399                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 400                 if (ndr_flags & NDR_SCALARS) {
 401                         NDR_CHECK(ndr_push_align(ndr, 4));
 402                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wAuthnSvc));
 403                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wAuthzSvc));
 404                         {
 405                                 uint32_t _flags_save_string = ndr->flags;
 406                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->PrincName));
 408                                 ndr->flags = _flags_save_string;
 409                         }
 410                         NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 411                 }
 412                 if (ndr_flags & NDR_BUFFERS) {
 413                 }
 414                 ndr->flags = _flags_save_STRUCT;
 415         }
 416         return NDR_ERR_SUCCESS;
 417 }
 418
 419 _PUBLIC_ enum ndr_err_code ndr_pull_SECURITYBINDING(struct ndr_pull *ndr, int ndr_flags, struct SECURITYBINDING *r)
 420 {
 421         {
 422                 uint32_t _flags_save_STRUCT = ndr->flags;
 423                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 424                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 425                 if (ndr_flags & NDR_SCALARS) {
 426                         NDR_CHECK(ndr_pull_align(ndr, 4));
 427                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wAuthnSvc));
 428                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wAuthzSvc));
 429                         {
 430                                 uint32_t _flags_save_string = ndr->flags;
 431                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->PrincName));
 433                                 ndr->flags = _flags_save_string;
 434                         }
 435                         NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 436                 }
 437                 if (ndr_flags & NDR_BUFFERS) {
 438                 }
 439                 ndr->flags = _flags_save_STRUCT;
 440         }
 441         return NDR_ERR_SUCCESS;
 442 }
 443
 444 _PUBLIC_ void ndr_print_SECURITYBINDING(struct ndr_print *ndr, const char *name, const struct SECURITYBINDING *r)
 445 {
 446         ndr_print_struct(ndr, name, "SECURITYBINDING");
 447         if (r == NULL) { ndr_print_null(ndr); return; }
 448         {
 449                 uint32_t _flags_save_STRUCT = ndr->flags;
 450                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
 451                 ndr->depth++;
 452                 ndr_print_uint16(ndr, "wAuthnSvc", r->wAuthnSvc);
 453                 ndr_print_uint16(ndr, "wAuthzSvc", r->wAuthzSvc);
 454                 ndr_print_string(ndr, "PrincName", r->PrincName);
 455                 ndr->depth--;
 456                 ndr->flags = _flags_save_STRUCT;
 457         }
 458 }
 459
 460 _PUBLIC_ enum ndr_err_code ndr_push_STDOBJREF(struct ndr_push *ndr, int ndr_flags, const struct STDOBJREF *r)
 461 {
 462         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 463         if (ndr_flags & NDR_SCALARS) {
 464                 NDR_CHECK(ndr_push_align(ndr, 8));
 465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cPublicRefs));
 467                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->oxid));
 468                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->oid));
 469                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ipid));
 470                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 471         }
 472         if (ndr_flags & NDR_BUFFERS) {
 473         }
 474         return NDR_ERR_SUCCESS;
 475 }
 476
 477 _PUBLIC_ enum ndr_err_code ndr_pull_STDOBJREF(struct ndr_pull *ndr, int ndr_flags, struct STDOBJREF *r)
 478 {
 479         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 480         if (ndr_flags & NDR_SCALARS) {
 481                 NDR_CHECK(ndr_pull_align(ndr, 8));
 482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cPublicRefs));
 484                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->oxid));
 485                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->oid));
 486                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ipid));
 487                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 488         }
 489         if (ndr_flags & NDR_BUFFERS) {
 490         }
 491         return NDR_ERR_SUCCESS;
 492 }
 493
 494 _PUBLIC_ void ndr_print_STDOBJREF(struct ndr_print *ndr, const char *name, const struct STDOBJREF *r)
 495 {
 496         ndr_print_struct(ndr, name, "STDOBJREF");
 497         if (r == NULL) { ndr_print_null(ndr); return; }
 498         ndr->depth++;
 499         ndr_print_uint32(ndr, "flags", r->flags);
 500         ndr_print_uint32(ndr, "cPublicRefs", r->cPublicRefs);
 501         ndr_print_hyper(ndr, "oxid", r->oxid);
 502         ndr_print_hyper(ndr, "oid", r->oid);
 503         ndr_print_GUID(ndr, "ipid", &r->ipid);
 504         ndr->depth--;
 505 }
 506
 507 static enum ndr_err_code ndr_push_u_standard(struct ndr_push *ndr, int ndr_flags, const struct u_standard *r)
 508 {
 509         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 510         if (ndr_flags & NDR_SCALARS) {
 511                 NDR_CHECK(ndr_push_align(ndr, 8));
 512                 NDR_CHECK(ndr_push_STDOBJREF(ndr, NDR_SCALARS, &r->std));
 513                 NDR_CHECK(ndr_push_STRINGARRAY(ndr, NDR_SCALARS, &r->saResAddr));
 514                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 515         }
 516         if (ndr_flags & NDR_BUFFERS) {
 517                 NDR_CHECK(ndr_push_STRINGARRAY(ndr, NDR_BUFFERS, &r->saResAddr));
 518         }
 519         return NDR_ERR_SUCCESS;
 520 }
 521
 522 static enum ndr_err_code ndr_pull_u_standard(struct ndr_pull *ndr, int ndr_flags, struct u_standard *r)
 523 {
 524         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 525         if (ndr_flags & NDR_SCALARS) {
 526                 NDR_CHECK(ndr_pull_align(ndr, 8));
 527                 NDR_CHECK(ndr_pull_STDOBJREF(ndr, NDR_SCALARS, &r->std));
 528                 NDR_CHECK(ndr_pull_STRINGARRAY(ndr, NDR_SCALARS, &r->saResAddr));
 529                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 530         }
 531         if (ndr_flags & NDR_BUFFERS) {
 532                 NDR_CHECK(ndr_pull_STRINGARRAY(ndr, NDR_BUFFERS, &r->saResAddr));
 533         }
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 _PUBLIC_ void ndr_print_u_standard(struct ndr_print *ndr, const char *name, const struct u_standard *r)
 538 {
 539         ndr_print_struct(ndr, name, "u_standard");
 540         if (r == NULL) { ndr_print_null(ndr); return; }
 541         ndr->depth++;
 542         ndr_print_STDOBJREF(ndr, "std", &r->std);
 543         ndr_print_STRINGARRAY(ndr, "saResAddr", &r->saResAddr);
 544         ndr->depth--;
 545 }
 546
 547 static enum ndr_err_code ndr_push_u_handler(struct ndr_push *ndr, int ndr_flags, const struct u_handler *r)
 548 {
 549         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 550         if (ndr_flags & NDR_SCALARS) {
 551                 NDR_CHECK(ndr_push_align(ndr, 8));
 552                 NDR_CHECK(ndr_push_STDOBJREF(ndr, NDR_SCALARS, &r->std));
 553                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->clsid));
 554                 NDR_CHECK(ndr_push_STRINGARRAY(ndr, NDR_SCALARS, &r->saResAddr));
 555                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 556         }
 557         if (ndr_flags & NDR_BUFFERS) {
 558                 NDR_CHECK(ndr_push_STRINGARRAY(ndr, NDR_BUFFERS, &r->saResAddr));
 559         }
 560         return NDR_ERR_SUCCESS;
 561 }
 562
 563 static enum ndr_err_code ndr_pull_u_handler(struct ndr_pull *ndr, int ndr_flags, struct u_handler *r)
 564 {
 565         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_pull_align(ndr, 8));
 568                 NDR_CHECK(ndr_pull_STDOBJREF(ndr, NDR_SCALARS, &r->std));
 569                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->clsid));
 570                 NDR_CHECK(ndr_pull_STRINGARRAY(ndr, NDR_SCALARS, &r->saResAddr));
 571                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 572         }
 573         if (ndr_flags & NDR_BUFFERS) {
 574                 NDR_CHECK(ndr_pull_STRINGARRAY(ndr, NDR_BUFFERS, &r->saResAddr));
 575         }
 576         return NDR_ERR_SUCCESS;
 577 }
 578
 579 _PUBLIC_ void ndr_print_u_handler(struct ndr_print *ndr, const char *name, const struct u_handler *r)
 580 {
 581         ndr_print_struct(ndr, name, "u_handler");
 582         if (r == NULL) { ndr_print_null(ndr); return; }
 583         ndr->depth++;
 584         ndr_print_STDOBJREF(ndr, "std", &r->std);
 585         ndr_print_GUID(ndr, "clsid", &r->clsid);
 586         ndr_print_STRINGARRAY(ndr, "saResAddr", &r->saResAddr);
 587         ndr->depth--;
 588 }
 589
 590 static enum ndr_err_code ndr_push_u_custom(struct ndr_push *ndr, int ndr_flags, const struct u_custom *r)
 591 {
 592         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 593         if (ndr_flags & NDR_SCALARS) {
 594                 NDR_CHECK(ndr_push_align(ndr, 4));
 595                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->clsid));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cbExtension));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 598                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->pData, r->size));
 599                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 600         }
 601         if (ndr_flags & NDR_BUFFERS) {
 602         }
 603         return NDR_ERR_SUCCESS;
 604 }
 605
 606 static enum ndr_err_code ndr_pull_u_custom(struct ndr_pull *ndr, int ndr_flags, struct u_custom *r)
 607 {
 608         uint32_t size_pData_0 = 0;
 609         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 610         if (ndr_flags & NDR_SCALARS) {
 611                 NDR_CHECK(ndr_pull_align(ndr, 4));
 612                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->clsid));
 613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cbExtension));
 614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 615                 size_pData_0 = r->size;
 616                 NDR_PULL_ALLOC_N(ndr, r->pData, size_pData_0);
 617                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->pData, size_pData_0));
 618                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 619         }
 620         if (ndr_flags & NDR_BUFFERS) {
 621         }
 622         return NDR_ERR_SUCCESS;
 623 }
 624
 625 _PUBLIC_ void ndr_print_u_custom(struct ndr_print *ndr, const char *name, const struct u_custom *r)
 626 {
 627         ndr_print_struct(ndr, name, "u_custom");
 628         if (r == NULL) { ndr_print_null(ndr); return; }
 629         ndr->depth++;
 630         ndr_print_GUID(ndr, "clsid", &r->clsid);
 631         ndr_print_uint32(ndr, "cbExtension", r->cbExtension);
 632         ndr_print_uint32(ndr, "size", r->size);
 633         ndr_print_array_uint8(ndr, "pData", r->pData, r->size);
 634         ndr->depth--;
 635 }
 636
 637 static enum ndr_err_code ndr_push_u_null(struct ndr_push *ndr, int ndr_flags, const struct u_null *r)
 638 {
 639         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 640         if (ndr_flags & NDR_SCALARS) {
 641                 NDR_CHECK(ndr_push_align(ndr, 1));
 642                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 643         }
 644         if (ndr_flags & NDR_BUFFERS) {
 645         }
 646         return NDR_ERR_SUCCESS;
 647 }
 648
 649 static enum ndr_err_code ndr_pull_u_null(struct ndr_pull *ndr, int ndr_flags, struct u_null *r)
 650 {
 651         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 652         if (ndr_flags & NDR_SCALARS) {
 653                 NDR_CHECK(ndr_pull_align(ndr, 1));
 654                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 655         }
 656         if (ndr_flags & NDR_BUFFERS) {
 657         }
 658         return NDR_ERR_SUCCESS;
 659 }
 660
 661 _PUBLIC_ void ndr_print_u_null(struct ndr_print *ndr, const char *name, const struct u_null *r)
 662 {
 663         ndr_print_struct(ndr, name, "u_null");
 664         if (r == NULL) { ndr_print_null(ndr); return; }
 665         ndr->depth++;
 666         ndr->depth--;
 667 }
 668
 669 static enum ndr_err_code ndr_push_OBJREF_Types(struct ndr_push *ndr, int ndr_flags, const union OBJREF_Types *r)
 670 {
 671         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 672         if (ndr_flags & NDR_SCALARS) {
 673                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 674                 NDR_CHECK(ndr_push_union_align(ndr, 8));
 675                 switch (level) {
 676                         case OBJREF_NULL: {
 677                                 NDR_CHECK(ndr_push_u_null(ndr, NDR_SCALARS, &r->u_null));
 678                         break; }
 679
 680                         case OBJREF_STANDARD: {
 681                                 NDR_CHECK(ndr_push_u_standard(ndr, NDR_SCALARS, &r->u_standard));
 682                         break; }
 683
 684                         case OBJREF_HANDLER: {
 685                                 NDR_CHECK(ndr_push_u_handler(ndr, NDR_SCALARS, &r->u_handler));
 686                         break; }
 687
 688                         case OBJREF_CUSTOM: {
 689                                 NDR_CHECK(ndr_push_u_custom(ndr, NDR_SCALARS, &r->u_custom));
 690                         break; }
 691
 692                         default:
 693                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 694                 }
 695         }
 696         if (ndr_flags & NDR_BUFFERS) {
 697                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 698                 switch (level) {
 699                         case OBJREF_NULL:
 700                         break;
 701
 702                         case OBJREF_STANDARD:
 703                                 NDR_CHECK(ndr_push_u_standard(ndr, NDR_BUFFERS, &r->u_standard));
 704                         break;
 705
 706                         case OBJREF_HANDLER:
 707                                 NDR_CHECK(ndr_push_u_handler(ndr, NDR_BUFFERS, &r->u_handler));
 708                         break;
 709
 710                         case OBJREF_CUSTOM:
 711                         break;
 712
 713                         default:
 714                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 715                 }
 716         }
 717         return NDR_ERR_SUCCESS;
 718 }
 719
 720 static enum ndr_err_code ndr_pull_OBJREF_Types(struct ndr_pull *ndr, int ndr_flags, union OBJREF_Types *r)
 721 {
 722         uint32_t level;
 723         level = ndr_pull_get_switch_value(ndr, r);
 724         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 725         if (ndr_flags & NDR_SCALARS) {
 726                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
 727                 switch (level) {
 728                         case OBJREF_NULL: {
 729                                 NDR_CHECK(ndr_pull_u_null(ndr, NDR_SCALARS, &r->u_null));
 730                         break; }
 731
 732                         case OBJREF_STANDARD: {
 733                                 NDR_CHECK(ndr_pull_u_standard(ndr, NDR_SCALARS, &r->u_standard));
 734                         break; }
 735
 736                         case OBJREF_HANDLER: {
 737                                 NDR_CHECK(ndr_pull_u_handler(ndr, NDR_SCALARS, &r->u_handler));
 738                         break; }
 739
 740                         case OBJREF_CUSTOM: {
 741                                 NDR_CHECK(ndr_pull_u_custom(ndr, NDR_SCALARS, &r->u_custom));
 742                         break; }
 743
 744                         default:
 745                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 746                 }
 747         }
 748         if (ndr_flags & NDR_BUFFERS) {
 749                 switch (level) {
 750                         case OBJREF_NULL:
 751                         break;
 752
 753                         case OBJREF_STANDARD:
 754                                 NDR_CHECK(ndr_pull_u_standard(ndr, NDR_BUFFERS, &r->u_standard));
 755                         break;
 756
 757                         case OBJREF_HANDLER:
 758                                 NDR_CHECK(ndr_pull_u_handler(ndr, NDR_BUFFERS, &r->u_handler));
 759                         break;
 760
 761                         case OBJREF_CUSTOM:
 762                         break;
 763
 764                         default:
 765                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 766                 }
 767         }
 768         return NDR_ERR_SUCCESS;
 769 }
 770
 771 _PUBLIC_ void ndr_print_OBJREF_Types(struct ndr_print *ndr, const char *name, const union OBJREF_Types *r)
 772 {
 773         uint32_t level;
 774         level = ndr_print_get_switch_value(ndr, r);
 775         ndr_print_union(ndr, name, level, "OBJREF_Types");
 776         switch (level) {
 777                 case OBJREF_NULL:
 778                         ndr_print_u_null(ndr, "u_null", &r->u_null);
 779                 break;
 780
 781                 case OBJREF_STANDARD:
 782                         ndr_print_u_standard(ndr, "u_standard", &r->u_standard);
 783                 break;
 784
 785                 case OBJREF_HANDLER:
 786                         ndr_print_u_handler(ndr, "u_handler", &r->u_handler);
 787                 break;
 788
 789                 case OBJREF_CUSTOM:
 790                         ndr_print_u_custom(ndr, "u_custom", &r->u_custom);
 791                 break;
 792
 793                 default:
 794                         ndr_print_bad_level(ndr, name, level);
 795         }
 796 }
 797
 798 _PUBLIC_ enum ndr_err_code ndr_push_OBJREF(struct ndr_push *ndr, int ndr_flags, const struct OBJREF *r)
 799 {
 800         {
 801                 uint32_t _flags_save_STRUCT = ndr->flags;
 802                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 803                 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 804                 if (ndr_flags & NDR_SCALARS) {
 805                         NDR_CHECK(ndr_push_align(ndr, 8));
 806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->signature));
 807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 808                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iid));
 809                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u_objref, r->flags));
 810                         NDR_CHECK(ndr_push_OBJREF_Types(ndr, NDR_SCALARS, &r->u_objref));
 811                         NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 812                 }
 813                 if (ndr_flags & NDR_BUFFERS) {
 814                         NDR_CHECK(ndr_push_OBJREF_Types(ndr, NDR_BUFFERS, &r->u_objref));
 815                 }
 816                 ndr->flags = _flags_save_STRUCT;
 817         }
 818         return NDR_ERR_SUCCESS;
 819 }
 820
 821 _PUBLIC_ enum ndr_err_code ndr_pull_OBJREF(struct ndr_pull *ndr, int ndr_flags, struct OBJREF *r)
 822 {
 823         {
 824                 uint32_t _flags_save_STRUCT = ndr->flags;
 825                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 826                 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 827                 if (ndr_flags & NDR_SCALARS) {
 828                         NDR_CHECK(ndr_pull_align(ndr, 8));
 829                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->signature));
 830                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 831                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iid));
 832                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u_objref, r->flags));
 833                         NDR_CHECK(ndr_pull_OBJREF_Types(ndr, NDR_SCALARS, &r->u_objref));
 834                         NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 835                 }
 836                 if (ndr_flags & NDR_BUFFERS) {
 837                         NDR_CHECK(ndr_pull_OBJREF_Types(ndr, NDR_BUFFERS, &r->u_objref));
 838                 }
 839                 ndr->flags = _flags_save_STRUCT;
 840         }
 841         return NDR_ERR_SUCCESS;
 842 }
 843
 844 _PUBLIC_ void ndr_print_OBJREF(struct ndr_print *ndr, const char *name, const struct OBJREF *r)
 845 {
 846         ndr_print_struct(ndr, name, "OBJREF");
 847         if (r == NULL) { ndr_print_null(ndr); return; }
 848         {
 849                 uint32_t _flags_save_STRUCT = ndr->flags;
 850                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 851                 ndr->depth++;
 852                 ndr_print_uint32(ndr, "signature", r->signature);
 853                 ndr_print_uint32(ndr, "flags", r->flags);
 854                 ndr_print_GUID(ndr, "iid", &r->iid);
 855                 ndr_print_set_switch_value(ndr, &r->u_objref, r->flags);
 856                 ndr_print_OBJREF_Types(ndr, "u_objref", &r->u_objref);
 857                 ndr->depth--;
 858                 ndr->flags = _flags_save_STRUCT;
 859         }
 860 }
 861
 862 _PUBLIC_ enum ndr_err_code ndr_push_MInterfacePointer(struct ndr_push *ndr, int ndr_flags, const struct MInterfacePointer *r)
 863 {
 864         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 865         if (ndr_flags & NDR_SCALARS) {
 866                 NDR_CHECK(ndr_push_align(ndr, 4));
 867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
 868                 {
 869                         struct ndr_push *_ndr_obj;
 870                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_obj, 4, -1));
 871                         NDR_CHECK(ndr_push_OBJREF(_ndr_obj, NDR_SCALARS|NDR_BUFFERS, &r->obj));
 872                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_obj, 4, -1));
 873                 }
 874                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 875         }
 876         if (ndr_flags & NDR_BUFFERS) {
 877         }
 878         return NDR_ERR_SUCCESS;
 879 }
 880
 881 _PUBLIC_ enum ndr_err_code ndr_pull_MInterfacePointer(struct ndr_pull *ndr, int ndr_flags, struct MInterfacePointer *r)
 882 {
 883         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 884         if (ndr_flags & NDR_SCALARS) {
 885                 NDR_CHECK(ndr_pull_align(ndr, 4));
 886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
 887                 {
 888                         struct ndr_pull *_ndr_obj;
 889                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_obj, 4, -1));
 890                         NDR_CHECK(ndr_pull_OBJREF(_ndr_obj, NDR_SCALARS|NDR_BUFFERS, &r->obj));
 891                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_obj, 4, -1));
 892                 }
 893                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 894         }
 895         if (ndr_flags & NDR_BUFFERS) {
 896         }
 897         return NDR_ERR_SUCCESS;
 898 }
 899
 900 _PUBLIC_ void ndr_print_MInterfacePointer(struct ndr_print *ndr, const char *name, const struct MInterfacePointer *r)
 901 {
 902         ndr_print_struct(ndr, name, "MInterfacePointer");
 903         if (r == NULL) { ndr_print_null(ndr); return; }
 904         ndr->depth++;
 905         ndr_print_uint32(ndr, "size", r->size);
 906         ndr_print_OBJREF(ndr, "obj", &r->obj);
 907         ndr->depth--;
 908 }
 909
 910 _PUBLIC_ enum ndr_err_code ndr_push_COMRESULT(struct ndr_push *ndr, int ndr_flags, enum COMRESULT r)
 911 {
 912         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 913         return NDR_ERR_SUCCESS;
 914 }
 915
 916 _PUBLIC_ enum ndr_err_code ndr_pull_COMRESULT(struct ndr_pull *ndr, int ndr_flags, enum COMRESULT *r)
 917 {
 918         uint32_t v;
 919         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 920         *r = v;
 921         return NDR_ERR_SUCCESS;
 922 }
 923
 924 _PUBLIC_ void ndr_print_COMRESULT(struct ndr_print *ndr, const char *name, enum COMRESULT r)
 925 {
 926         const char *val = NULL;
 927
 928         switch (r) {
 929                 case COM_OK: val = "COM_OK"; break;
 930                 case COM_OUTOFMEMORY: val = "COM_OUTOFMEMORY"; break;
 931                 case COM_INVALIDARG: val = "COM_INVALIDARG"; break;
 932                 case COM_NOINTERFACE: val = "COM_NOINTERFACE"; break;
 933                 case COM_ACCESSDENIED: val = "COM_ACCESSDENIED"; break;
 934                 case COM_INVALID_OXID: val = "COM_INVALID_OXID"; break;
 935                 case COM_INVALID_OID: val = "COM_INVALID_OID"; break;
 936                 case COM_INVALID_SET: val = "COM_INVALID_SET"; break;
 937                 case COM_UNEXPECTED: val = "COM_UNEXPECTED"; break;
 938                 case COM_CLSNOTFOUND: val = "COM_CLSNOTFOUND"; break;
 939         }
 940         ndr_print_enum(ndr, name, "ENUM", val, r);
 941 }
 942