bin.gen_ndr/default/librpc/gen_ndr/ndr_xattr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_xattr.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 static enum ndr_err_code ndr_push_xattr_DosInfoFFFFCompat(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfoFFFFCompat *r)
   8 {
   9         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
  13                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16         }
  17         return NDR_ERR_SUCCESS;
  18 }
  19
  20 static enum ndr_err_code ndr_pull_xattr_DosInfoFFFFCompat(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfoFFFFCompat *r)
  21 {
  22         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  23         if (ndr_flags & NDR_SCALARS) {
  24                 NDR_CHECK(ndr_pull_align(ndr, 4));
  25                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
  26                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  27         }
  28         if (ndr_flags & NDR_BUFFERS) {
  29         }
  30         return NDR_ERR_SUCCESS;
  31 }
  32
  33 _PUBLIC_ void ndr_print_xattr_DosInfoFFFFCompat(struct ndr_print *ndr, const char *name, const struct xattr_DosInfoFFFFCompat *r)
  34 {
  35         ndr_print_struct(ndr, name, "xattr_DosInfoFFFFCompat");
  36         if (r == NULL) { ndr_print_null(ndr); return; }
  37         ndr->depth++;
  38         ndr_print_uint32(ndr, "attrib", r->attrib);
  39         ndr->depth--;
  40 }
  41
  42 static enum ndr_err_code ndr_push_xattr_DosInfo1(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo1 *r)
  43 {
  44         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  45         if (ndr_flags & NDR_SCALARS) {
  46                 NDR_CHECK(ndr_push_align(ndr, 4));
  47                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
  48                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
  49                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
  50                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
  51                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
  52                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
  53                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  54         }
  55         if (ndr_flags & NDR_BUFFERS) {
  56         }
  57         return NDR_ERR_SUCCESS;
  58 }
  59
  60 static enum ndr_err_code ndr_pull_xattr_DosInfo1(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo1 *r)
  61 {
  62         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  63         if (ndr_flags & NDR_SCALARS) {
  64                 NDR_CHECK(ndr_pull_align(ndr, 4));
  65                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
  66                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
  67                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
  68                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
  69                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
  70                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
  71                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  72         }
  73         if (ndr_flags & NDR_BUFFERS) {
  74         }
  75         return NDR_ERR_SUCCESS;
  76 }
  77
  78 _PUBLIC_ void ndr_print_xattr_DosInfo1(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo1 *r)
  79 {
  80         ndr_print_struct(ndr, name, "xattr_DosInfo1");
  81         if (r == NULL) { ndr_print_null(ndr); return; }
  82         ndr->depth++;
  83         ndr_print_uint32(ndr, "attrib", r->attrib);
  84         ndr_print_uint32(ndr, "ea_size", r->ea_size);
  85         ndr_print_udlong(ndr, "size", r->size);
  86         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
  87         ndr_print_NTTIME(ndr, "create_time", r->create_time);
  88         ndr_print_NTTIME(ndr, "change_time", r->change_time);
  89         ndr->depth--;
  90 }
  91
  92 static enum ndr_err_code ndr_push_xattr_DosInfo2Old(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo2Old *r)
  93 {
  94         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  95         if (ndr_flags & NDR_SCALARS) {
  96                 NDR_CHECK(ndr_push_align(ndr, 4));
  97                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
  98                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
  99                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
 100                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 101                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 102                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
 103                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
 104                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->write_time));
 105                 {
 106                         uint32_t _flags_save_string = ndr->flags;
 107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 108                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 109                         ndr->flags = _flags_save_string;
 110                 }
 111                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 112         }
 113         if (ndr_flags & NDR_BUFFERS) {
 114         }
 115         return NDR_ERR_SUCCESS;
 116 }
 117
 118 static enum ndr_err_code ndr_pull_xattr_DosInfo2Old(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo2Old *r)
 119 {
 120         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 121         if (ndr_flags & NDR_SCALARS) {
 122                 NDR_CHECK(ndr_pull_align(ndr, 4));
 123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
 125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
 126                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 127                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 128                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
 129                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
 130                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->write_time));
 131                 {
 132                         uint32_t _flags_save_string = ndr->flags;
 133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 134                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 135                         ndr->flags = _flags_save_string;
 136                 }
 137                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 138         }
 139         if (ndr_flags & NDR_BUFFERS) {
 140         }
 141         return NDR_ERR_SUCCESS;
 142 }
 143
 144 _PUBLIC_ void ndr_print_xattr_DosInfo2Old(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo2Old *r)
 145 {
 146         ndr_print_struct(ndr, name, "xattr_DosInfo2Old");
 147         if (r == NULL) { ndr_print_null(ndr); return; }
 148         ndr->depth++;
 149         ndr_print_uint32(ndr, "flags", r->flags);
 150         ndr_print_uint32(ndr, "attrib", r->attrib);
 151         ndr_print_uint32(ndr, "ea_size", r->ea_size);
 152         ndr_print_udlong(ndr, "size", r->size);
 153         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 154         ndr_print_NTTIME(ndr, "create_time", r->create_time);
 155         ndr_print_NTTIME(ndr, "change_time", r->change_time);
 156         ndr_print_NTTIME(ndr, "write_time", r->write_time);
 157         ndr_print_string(ndr, "name", r->name);
 158         ndr->depth--;
 159 }
 160
 161 static enum ndr_err_code ndr_push_xattr_DosInfoValidFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 162 {
 163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 static enum ndr_err_code ndr_pull_xattr_DosInfoValidFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 168 {
 169         uint32_t v;
 170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 171         *r = v;
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_xattr_DosInfoValidFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 176 {
 177         ndr_print_uint32(ndr, name, r);
 178         ndr->depth++;
 179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_ATTRIB", XATTR_DOSINFO_ATTRIB, r);
 180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_EA_SIZE", XATTR_DOSINFO_EA_SIZE, r);
 181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_SIZE", XATTR_DOSINFO_SIZE, r);
 182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_ALLOC_SIZE", XATTR_DOSINFO_ALLOC_SIZE, r);
 183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_CREATE_TIME", XATTR_DOSINFO_CREATE_TIME, r);
 184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "XATTR_DOSINFO_CHANGE_TIME", XATTR_DOSINFO_CHANGE_TIME, r);
 185         ndr->depth--;
 186 }
 187
 188 static enum ndr_err_code ndr_push_xattr_DosInfo3(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo3 *r)
 189 {
 190         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 191         if (ndr_flags & NDR_SCALARS) {
 192                 NDR_CHECK(ndr_push_align(ndr, 4));
 193                 NDR_CHECK(ndr_push_xattr_DosInfoValidFlags(ndr, NDR_SCALARS, r->valid_flags));
 194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
 195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
 196                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 197                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 198                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
 199                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
 200                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 201         }
 202         if (ndr_flags & NDR_BUFFERS) {
 203         }
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 static enum ndr_err_code ndr_pull_xattr_DosInfo3(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo3 *r)
 208 {
 209         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 210         if (ndr_flags & NDR_SCALARS) {
 211                 NDR_CHECK(ndr_pull_align(ndr, 4));
 212                 NDR_CHECK(ndr_pull_xattr_DosInfoValidFlags(ndr, NDR_SCALARS, &r->valid_flags));
 213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
 214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
 215                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 216                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 217                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
 218                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
 219                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 220         }
 221         if (ndr_flags & NDR_BUFFERS) {
 222         }
 223         return NDR_ERR_SUCCESS;
 224 }
 225
 226 _PUBLIC_ void ndr_print_xattr_DosInfo3(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo3 *r)
 227 {
 228         ndr_print_struct(ndr, name, "xattr_DosInfo3");
 229         if (r == NULL) { ndr_print_null(ndr); return; }
 230         ndr->depth++;
 231         ndr_print_xattr_DosInfoValidFlags(ndr, "valid_flags", r->valid_flags);
 232         ndr_print_uint32(ndr, "attrib", r->attrib);
 233         ndr_print_uint32(ndr, "ea_size", r->ea_size);
 234         ndr_print_udlong(ndr, "size", r->size);
 235         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 236         ndr_print_NTTIME(ndr, "create_time", r->create_time);
 237         ndr_print_NTTIME(ndr, "change_time", r->change_time);
 238         ndr->depth--;
 239 }
 240
 241 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosInfo(struct ndr_push *ndr, int ndr_flags, const union xattr_DosInfo *r)
 242 {
 243         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 244         if (ndr_flags & NDR_SCALARS) {
 245                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 246                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 247                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 248                 NDR_CHECK(ndr_push_union_align(ndr, 4));
 249                 switch (level) {
 250                         case 0xFFFF: {
 251                                 NDR_CHECK(ndr_push_xattr_DosInfoFFFFCompat(ndr, NDR_SCALARS, &r->compatinfoFFFF));
 252                         break; }
 253
 254                         case 1: {
 255                                 NDR_CHECK(ndr_push_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 256                         break; }
 257
 258                         case 2: {
 259                                 NDR_CHECK(ndr_push_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 260                         break; }
 261
 262                         case 3: {
 263                                 NDR_CHECK(ndr_push_xattr_DosInfo3(ndr, NDR_SCALARS, &r->info3));
 264                         break; }
 265
 266                         default:
 267                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 268                 }
 269         }
 270         if (ndr_flags & NDR_BUFFERS) {
 271                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 272                 switch (level) {
 273                         case 0xFFFF:
 274                         break;
 275
 276                         case 1:
 277                         break;
 278
 279                         case 2:
 280                         break;
 281
 282                         case 3:
 283                         break;
 284
 285                         default:
 286                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 287                 }
 288         }
 289         return NDR_ERR_SUCCESS;
 290 }
 291
 292 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosInfo(struct ndr_pull *ndr, int ndr_flags, union xattr_DosInfo *r)
 293 {
 294         uint32_t level;
 295         uint16_t _level;
 296         level = ndr_pull_get_switch_value(ndr, r);
 297         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 298         if (ndr_flags & NDR_SCALARS) {
 299                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 300                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 301                 if (_level != level) {
 302                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 303                 }
 304                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
 305                 switch (level) {
 306                         case 0xFFFF: {
 307                                 NDR_CHECK(ndr_pull_xattr_DosInfoFFFFCompat(ndr, NDR_SCALARS, &r->compatinfoFFFF));
 308                         break; }
 309
 310                         case 1: {
 311                                 NDR_CHECK(ndr_pull_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 312                         break; }
 313
 314                         case 2: {
 315                                 NDR_CHECK(ndr_pull_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 316                         break; }
 317
 318                         case 3: {
 319                                 NDR_CHECK(ndr_pull_xattr_DosInfo3(ndr, NDR_SCALARS, &r->info3));
 320                         break; }
 321
 322                         default:
 323                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 324                 }
 325         }
 326         if (ndr_flags & NDR_BUFFERS) {
 327                 switch (level) {
 328                         case 0xFFFF:
 329                         break;
 330
 331                         case 1:
 332                         break;
 333
 334                         case 2:
 335                         break;
 336
 337                         case 3:
 338                         break;
 339
 340                         default:
 341                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 342                 }
 343         }
 344         return NDR_ERR_SUCCESS;
 345 }
 346
 347 _PUBLIC_ void ndr_print_xattr_DosInfo(struct ndr_print *ndr, const char *name, const union xattr_DosInfo *r)
 348 {
 349         uint32_t level;
 350         level = ndr_print_get_switch_value(ndr, r);
 351         ndr_print_union(ndr, name, level, "xattr_DosInfo");
 352         switch (level) {
 353                 case 0xFFFF:
 354                         ndr_print_xattr_DosInfoFFFFCompat(ndr, "compatinfoFFFF", &r->compatinfoFFFF);
 355                 break;
 356
 357                 case 1:
 358                         ndr_print_xattr_DosInfo1(ndr, "info1", &r->info1);
 359                 break;
 360
 361                 case 2:
 362                         ndr_print_xattr_DosInfo2Old(ndr, "oldinfo2", &r->oldinfo2);
 363                 break;
 364
 365                 case 3:
 366                         ndr_print_xattr_DosInfo3(ndr, "info3", &r->info3);
 367                 break;
 368
 369                 default:
 370                         ndr_print_bad_level(ndr, name, level);
 371         }
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosAttrib(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosAttrib *r)
 375 {
 376         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 377         if (ndr_flags & NDR_SCALARS) {
 378                 NDR_CHECK(ndr_push_align(ndr, 4));
 379                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 380                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 381                 NDR_CHECK(ndr_push_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 382                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 383         }
 384         if (ndr_flags & NDR_BUFFERS) {
 385         }
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosAttrib(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosAttrib *r)
 390 {
 391         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 392         if (ndr_flags & NDR_SCALARS) {
 393                 NDR_CHECK(ndr_pull_align(ndr, 4));
 394                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 395                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 396                 NDR_CHECK(ndr_pull_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 397                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 398         }
 399         if (ndr_flags & NDR_BUFFERS) {
 400         }
 401         return NDR_ERR_SUCCESS;
 402 }
 403
 404 _PUBLIC_ void ndr_print_xattr_DosAttrib(struct ndr_print *ndr, const char *name, const struct xattr_DosAttrib *r)
 405 {
 406         ndr_print_struct(ndr, name, "xattr_DosAttrib");
 407         if (r == NULL) { ndr_print_null(ndr); return; }
 408         ndr->depth++;
 409         ndr_print_uint16(ndr, "version", r->version);
 410         ndr_print_set_switch_value(ndr, &r->info, r->version);
 411         ndr_print_xattr_DosInfo(ndr, "info", &r->info);
 412         ndr->depth--;
 413 }
 414
 415 static enum ndr_err_code ndr_push_xattr_EA(struct ndr_push *ndr, int ndr_flags, const struct xattr_EA *r)
 416 {
 417         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 418         if (ndr_flags & NDR_SCALARS) {
 419                 NDR_CHECK(ndr_push_align(ndr, 4));
 420                 {
 421                         uint32_t _flags_save_string = ndr->flags;
 422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 423                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 424                         ndr->flags = _flags_save_string;
 425                 }
 426                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
 427                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 428         }
 429         if (ndr_flags & NDR_BUFFERS) {
 430         }
 431         return NDR_ERR_SUCCESS;
 432 }
 433
 434 static enum ndr_err_code ndr_pull_xattr_EA(struct ndr_pull *ndr, int ndr_flags, struct xattr_EA *r)
 435 {
 436         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 437         if (ndr_flags & NDR_SCALARS) {
 438                 NDR_CHECK(ndr_pull_align(ndr, 4));
 439                 {
 440                         uint32_t _flags_save_string = ndr->flags;
 441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 442                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 443                         ndr->flags = _flags_save_string;
 444                 }
 445                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
 446                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 447         }
 448         if (ndr_flags & NDR_BUFFERS) {
 449         }
 450         return NDR_ERR_SUCCESS;
 451 }
 452
 453 _PUBLIC_ void ndr_print_xattr_EA(struct ndr_print *ndr, const char *name, const struct xattr_EA *r)
 454 {
 455         ndr_print_struct(ndr, name, "xattr_EA");
 456         if (r == NULL) { ndr_print_null(ndr); return; }
 457         ndr->depth++;
 458         ndr_print_string(ndr, "name", r->name);
 459         ndr_print_DATA_BLOB(ndr, "value", r->value);
 460         ndr->depth--;
 461 }
 462
 463 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosEAs(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosEAs *r)
 464 {
 465         uint32_t cntr_eas_1;
 466         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 467         if (ndr_flags & NDR_SCALARS) {
 468                 NDR_CHECK(ndr_push_align(ndr, 5));
 469                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_eas));
 470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->eas));
 471                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 472         }
 473         if (ndr_flags & NDR_BUFFERS) {
 474                 if (r->eas) {
 475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_eas));
 476                         for (cntr_eas_1 = 0; cntr_eas_1 < r->num_eas; cntr_eas_1++) {
 477                                 NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 478                         }
 479                 }
 480         }
 481         return NDR_ERR_SUCCESS;
 482 }
 483
 484 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosEAs(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosEAs *r)
 485 {
 486         uint32_t _ptr_eas;
 487         uint32_t size_eas_1 = 0;
 488         uint32_t cntr_eas_1;
 489         TALLOC_CTX *_mem_save_eas_0;
 490         TALLOC_CTX *_mem_save_eas_1;
 491         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 492         if (ndr_flags & NDR_SCALARS) {
 493                 NDR_CHECK(ndr_pull_align(ndr, 5));
 494                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_eas));
 495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eas));
 496                 if (_ptr_eas) {
 497                         NDR_PULL_ALLOC(ndr, r->eas);
 498                 } else {
 499                         r->eas = NULL;
 500                 }
 501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 502         }
 503         if (ndr_flags & NDR_BUFFERS) {
 504                 if (r->eas) {
 505                         _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 506                         NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 507                         NDR_CHECK(ndr_pull_array_size(ndr, &r->eas));
 508                         size_eas_1 = ndr_get_array_size(ndr, &r->eas);
 509                         NDR_PULL_ALLOC_N(ndr, r->eas, size_eas_1);
 510                         _mem_save_eas_1 = NDR_PULL_GET_MEM_CTX(ndr);
 511                         NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 512                         for (cntr_eas_1 = 0; cntr_eas_1 < size_eas_1; cntr_eas_1++) {
 513                                 NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 514                         }
 515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_1, 0);
 516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 517                 }
 518                 if (r->eas) {
 519                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->eas, r->num_eas));
 520                 }
 521         }
 522         return NDR_ERR_SUCCESS;
 523 }
 524
 525 _PUBLIC_ void ndr_print_xattr_DosEAs(struct ndr_print *ndr, const char *name, const struct xattr_DosEAs *r)
 526 {
 527         uint32_t cntr_eas_1;
 528         ndr_print_struct(ndr, name, "xattr_DosEAs");
 529         if (r == NULL) { ndr_print_null(ndr); return; }
 530         ndr->depth++;
 531         ndr_print_uint16(ndr, "num_eas", r->num_eas);
 532         ndr_print_ptr(ndr, "eas", r->eas);
 533         ndr->depth++;
 534         if (r->eas) {
 535                 ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 536                 ndr->depth++;
 537                 for (cntr_eas_1=0;cntr_eas_1<r->num_eas;cntr_eas_1++) {
 538                         ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_1]);
 539                 }
 540                 ndr->depth--;
 541         }
 542         ndr->depth--;
 543         ndr->depth--;
 544 }
 545
 546 _PUBLIC_ enum ndr_err_code ndr_push_tdb_xattrs(struct ndr_push *ndr, int ndr_flags, const struct tdb_xattrs *r)
 547 {
 548         uint32_t cntr_eas_0;
 549         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 550         if (ndr_flags & NDR_SCALARS) {
 551                 NDR_CHECK(ndr_push_align(ndr, 4));
 552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_eas));
 553                 for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
 554                         NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 555                 }
 556                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 557         }
 558         if (ndr_flags & NDR_BUFFERS) {
 559         }
 560         return NDR_ERR_SUCCESS;
 561 }
 562
 563 _PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattrs(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattrs *r)
 564 {
 565         uint32_t size_eas_0 = 0;
 566         uint32_t cntr_eas_0;
 567         TALLOC_CTX *_mem_save_eas_0;
 568         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 569         if (ndr_flags & NDR_SCALARS) {
 570                 NDR_CHECK(ndr_pull_align(ndr, 4));
 571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_eas));
 572                 size_eas_0 = r->num_eas;
 573                 NDR_PULL_ALLOC_N(ndr, r->eas, size_eas_0);
 574                 _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 575                 NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 576                 for (cntr_eas_0 = 0; cntr_eas_0 < size_eas_0; cntr_eas_0++) {
 577                         NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 578                 }
 579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 580                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 581         }
 582         if (ndr_flags & NDR_BUFFERS) {
 583         }
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 _PUBLIC_ void ndr_print_tdb_xattrs(struct ndr_print *ndr, const char *name, const struct tdb_xattrs *r)
 588 {
 589         uint32_t cntr_eas_0;
 590         ndr_print_struct(ndr, name, "tdb_xattrs");
 591         if (r == NULL) { ndr_print_null(ndr); return; }
 592         ndr->depth++;
 593         ndr_print_uint32(ndr, "num_eas", r->num_eas);
 594         ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 595         ndr->depth++;
 596         for (cntr_eas_0=0;cntr_eas_0<r->num_eas;cntr_eas_0++) {
 597                 ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_0]);
 598         }
 599         ndr->depth--;
 600         ndr->depth--;
 601 }
 602
 603 static enum ndr_err_code ndr_push_xattr_DosStream(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStream *r)
 604 {
 605         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 606         if (ndr_flags & NDR_SCALARS) {
 607                 NDR_CHECK(ndr_push_align(ndr, 4));
 608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 609                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 610                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 611                 {
 612                         uint32_t _flags_save_string = ndr->flags;
 613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 614                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 615                         ndr->flags = _flags_save_string;
 616                 }
 617                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 static enum ndr_err_code ndr_pull_xattr_DosStream(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStream *r)
 625 {
 626         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 627         if (ndr_flags & NDR_SCALARS) {
 628                 NDR_CHECK(ndr_pull_align(ndr, 4));
 629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 630                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 631                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 632                 {
 633                         uint32_t _flags_save_string = ndr->flags;
 634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 635                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 636                         ndr->flags = _flags_save_string;
 637                 }
 638                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 639         }
 640         if (ndr_flags & NDR_BUFFERS) {
 641         }
 642         return NDR_ERR_SUCCESS;
 643 }
 644
 645 _PUBLIC_ void ndr_print_xattr_DosStream(struct ndr_print *ndr, const char *name, const struct xattr_DosStream *r)
 646 {
 647         ndr_print_struct(ndr, name, "xattr_DosStream");
 648         if (r == NULL) { ndr_print_null(ndr); return; }
 649         ndr->depth++;
 650         ndr_print_uint32(ndr, "flags", r->flags);
 651         ndr_print_udlong(ndr, "size", r->size);
 652         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 653         ndr_print_string(ndr, "name", r->name);
 654         ndr->depth--;
 655 }
 656
 657 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosStreams(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStreams *r)
 658 {
 659         uint32_t cntr_streams_1;
 660         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 661         if (ndr_flags & NDR_SCALARS) {
 662                 NDR_CHECK(ndr_push_align(ndr, 5));
 663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
 664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->streams));
 665                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 666         }
 667         if (ndr_flags & NDR_BUFFERS) {
 668                 if (r->streams) {
 669                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_streams));
 670                         for (cntr_streams_1 = 0; cntr_streams_1 < r->num_streams; cntr_streams_1++) {
 671                                 NDR_CHECK(ndr_push_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 672                         }
 673                 }
 674         }
 675         return NDR_ERR_SUCCESS;
 676 }
 677
 678 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosStreams(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStreams *r)
 679 {
 680         uint32_t _ptr_streams;
 681         uint32_t size_streams_1 = 0;
 682         uint32_t cntr_streams_1;
 683         TALLOC_CTX *_mem_save_streams_0;
 684         TALLOC_CTX *_mem_save_streams_1;
 685         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 686         if (ndr_flags & NDR_SCALARS) {
 687                 NDR_CHECK(ndr_pull_align(ndr, 5));
 688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_streams));
 689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_streams));
 690                 if (_ptr_streams) {
 691                         NDR_PULL_ALLOC(ndr, r->streams);
 692                 } else {
 693                         r->streams = NULL;
 694                 }
 695                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 696         }
 697         if (ndr_flags & NDR_BUFFERS) {
 698                 if (r->streams) {
 699                         _mem_save_streams_0 = NDR_PULL_GET_MEM_CTX(ndr);
 700                         NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->streams));
 702                         size_streams_1 = ndr_get_array_size(ndr, &r->streams);
 703                         NDR_PULL_ALLOC_N(ndr, r->streams, size_streams_1);
 704                         _mem_save_streams_1 = NDR_PULL_GET_MEM_CTX(ndr);
 705                         NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 706                         for (cntr_streams_1 = 0; cntr_streams_1 < size_streams_1; cntr_streams_1++) {
 707                                 NDR_CHECK(ndr_pull_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 708                         }
 709                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_1, 0);
 710                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_0, 0);
 711                 }
 712                 if (r->streams) {
 713                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->streams, r->num_streams));
 714                 }
 715         }
 716         return NDR_ERR_SUCCESS;
 717 }
 718
 719 _PUBLIC_ void ndr_print_xattr_DosStreams(struct ndr_print *ndr, const char *name, const struct xattr_DosStreams *r)
 720 {
 721         uint32_t cntr_streams_1;
 722         ndr_print_struct(ndr, name, "xattr_DosStreams");
 723         if (r == NULL) { ndr_print_null(ndr); return; }
 724         ndr->depth++;
 725         ndr_print_uint32(ndr, "num_streams", r->num_streams);
 726         ndr_print_ptr(ndr, "streams", r->streams);
 727         ndr->depth++;
 728         if (r->streams) {
 729                 ndr->print(ndr, "%s: ARRAY(%d)", "streams", (int)r->num_streams);
 730                 ndr->depth++;
 731                 for (cntr_streams_1=0;cntr_streams_1<r->num_streams;cntr_streams_1++) {
 732                         ndr_print_xattr_DosStream(ndr, "streams", &r->streams[cntr_streams_1]);
 733                 }
 734                 ndr->depth--;
 735         }
 736         ndr->depth--;
 737         ndr->depth--;
 738 }
 739
 740 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v2(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash_v2 *r)
 741 {
 742         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 743         if (ndr_flags & NDR_SCALARS) {
 744                 NDR_CHECK(ndr_push_align(ndr, 5));
 745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 746                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 747                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 748         }
 749         if (ndr_flags & NDR_BUFFERS) {
 750                 if (r->sd) {
 751                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 752                 }
 753         }
 754         return NDR_ERR_SUCCESS;
 755 }
 756
 757 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v2(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash_v2 *r)
 758 {
 759         uint32_t _ptr_sd;
 760         TALLOC_CTX *_mem_save_sd_0;
 761         uint32_t size_hash_0 = 0;
 762         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_pull_align(ndr, 5));
 765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 766                 if (_ptr_sd) {
 767                         NDR_PULL_ALLOC(ndr, r->sd);
 768                 } else {
 769                         r->sd = NULL;
 770                 }
 771                 size_hash_0 = 16;
 772                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
 773                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 774         }
 775         if (ndr_flags & NDR_BUFFERS) {
 776                 if (r->sd) {
 777                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 778                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 779                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 781                 }
 782         }
 783         return NDR_ERR_SUCCESS;
 784 }
 785
 786 _PUBLIC_ void ndr_print_security_descriptor_hash_v2(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash_v2 *r)
 787 {
 788         ndr_print_struct(ndr, name, "security_descriptor_hash_v2");
 789         if (r == NULL) { ndr_print_null(ndr); return; }
 790         ndr->depth++;
 791         ndr_print_ptr(ndr, "sd", r->sd);
 792         ndr->depth++;
 793         if (r->sd) {
 794                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 795         }
 796         ndr->depth--;
 797         ndr_print_array_uint8(ndr, "hash", r->hash, 16);
 798         ndr->depth--;
 799 }
 800
 801 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v3(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash_v3 *r)
 802 {
 803         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 804         if (ndr_flags & NDR_SCALARS) {
 805                 NDR_CHECK(ndr_push_align(ndr, 5));
 806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 807                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hash_type));
 808                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
 809                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 810         }
 811         if (ndr_flags & NDR_BUFFERS) {
 812                 if (r->sd) {
 813                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 814                 }
 815         }
 816         return NDR_ERR_SUCCESS;
 817 }
 818
 819 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v3(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash_v3 *r)
 820 {
 821         uint32_t _ptr_sd;
 822         TALLOC_CTX *_mem_save_sd_0;
 823         uint32_t size_hash_0 = 0;
 824         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 5));
 827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 828                 if (_ptr_sd) {
 829                         NDR_PULL_ALLOC(ndr, r->sd);
 830                 } else {
 831                         r->sd = NULL;
 832                 }
 833                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hash_type));
 834                 size_hash_0 = 64;
 835                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
 836                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 837         }
 838         if (ndr_flags & NDR_BUFFERS) {
 839                 if (r->sd) {
 840                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 841                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 842                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 844                 }
 845         }
 846         return NDR_ERR_SUCCESS;
 847 }
 848
 849 _PUBLIC_ void ndr_print_security_descriptor_hash_v3(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash_v3 *r)
 850 {
 851         ndr_print_struct(ndr, name, "security_descriptor_hash_v3");
 852         if (r == NULL) { ndr_print_null(ndr); return; }
 853         ndr->depth++;
 854         ndr_print_ptr(ndr, "sd", r->sd);
 855         ndr->depth++;
 856         if (r->sd) {
 857                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 858         }
 859         ndr->depth--;
 860         ndr_print_uint16(ndr, "hash_type", r->hash_type);
 861         ndr_print_array_uint8(ndr, "hash", r->hash, 64);
 862         ndr->depth--;
 863 }
 864
 865 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v4(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash_v4 *r)
 866 {
 867         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 868         if (ndr_flags & NDR_SCALARS) {
 869                 NDR_CHECK(ndr_push_align(ndr, 5));
 870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 871                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hash_type));
 872                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
 873                 {
 874                         uint32_t _flags_save_string = ndr->flags;
 875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 876                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 877                         ndr->flags = _flags_save_string;
 878                 }
 879                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
 880                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->sys_acl_hash, 64));
 881                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 882         }
 883         if (ndr_flags & NDR_BUFFERS) {
 884                 if (r->sd) {
 885                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 886                 }
 887         }
 888         return NDR_ERR_SUCCESS;
 889 }
 890
 891 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v4(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash_v4 *r)
 892 {
 893         uint32_t _ptr_sd;
 894         TALLOC_CTX *_mem_save_sd_0;
 895         uint32_t size_hash_0 = 0;
 896         uint32_t size_sys_acl_hash_0 = 0;
 897         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 898         if (ndr_flags & NDR_SCALARS) {
 899                 NDR_CHECK(ndr_pull_align(ndr, 5));
 900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 901                 if (_ptr_sd) {
 902                         NDR_PULL_ALLOC(ndr, r->sd);
 903                 } else {
 904                         r->sd = NULL;
 905                 }
 906                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hash_type));
 907                 size_hash_0 = 64;
 908                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, size_hash_0));
 909                 {
 910                         uint32_t _flags_save_string = ndr->flags;
 911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 912                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 913                         ndr->flags = _flags_save_string;
 914                 }
 915                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
 916                 size_sys_acl_hash_0 = 64;
 917                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->sys_acl_hash, size_sys_acl_hash_0));
 918                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 919         }
 920         if (ndr_flags & NDR_BUFFERS) {
 921                 if (r->sd) {
 922                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 923                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 924                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 926                 }
 927         }
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 _PUBLIC_ void ndr_print_security_descriptor_hash_v4(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash_v4 *r)
 932 {
 933         ndr_print_struct(ndr, name, "security_descriptor_hash_v4");
 934         if (r == NULL) { ndr_print_null(ndr); return; }
 935         ndr->depth++;
 936         ndr_print_ptr(ndr, "sd", r->sd);
 937         ndr->depth++;
 938         if (r->sd) {
 939                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 940         }
 941         ndr->depth--;
 942         ndr_print_uint16(ndr, "hash_type", r->hash_type);
 943         ndr_print_array_uint8(ndr, "hash", r->hash, 64);
 944         ndr_print_string(ndr, "description", r->description);
 945         ndr_print_NTTIME(ndr, "time", r->time);
 946         ndr_print_array_uint8(ndr, "sys_acl_hash", r->sys_acl_hash, 64);
 947         ndr->depth--;
 948 }
 949
 950 static enum ndr_err_code ndr_push_xattr_NTACL_Info(struct ndr_push *ndr, int ndr_flags, const union xattr_NTACL_Info *r)
 951 {
 952         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 953         if (ndr_flags & NDR_SCALARS) {
 954                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 955                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 956                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 957                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 958                 switch (level) {
 959                         case 1: {
 960                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 961                         break; }
 962
 963                         case 2: {
 964                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs2));
 965                         break; }
 966
 967                         case 3: {
 968                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs3));
 969                         break; }
 970
 971                         case 4: {
 972                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs4));
 973                         break; }
 974
 975                         default:
 976                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 977                 }
 978         }
 979         if (ndr_flags & NDR_BUFFERS) {
 980                 uint32_t level = ndr_push_get_switch_value(ndr, r);
 981                 switch (level) {
 982                         case 1:
 983                                 if (r->sd) {
 984                                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 985                                 }
 986                         break;
 987
 988                         case 2:
 989                                 if (r->sd_hs2) {
 990                                         NDR_CHECK(ndr_push_security_descriptor_hash_v2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs2));
 991                                 }
 992                         break;
 993
 994                         case 3:
 995                                 if (r->sd_hs3) {
 996                                         NDR_CHECK(ndr_push_security_descriptor_hash_v3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs3));
 997                                 }
 998                         break;
 999
1000                         case 4:
1001                                 if (r->sd_hs4) {
1002                                         NDR_CHECK(ndr_push_security_descriptor_hash_v4(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs4));
1003                                 }
1004                         break;
1005
1006                         default:
1007                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1008                 }
1009         }
1010         return NDR_ERR_SUCCESS;
1011 }
1012
1013 static enum ndr_err_code ndr_pull_xattr_NTACL_Info(struct ndr_pull *ndr, int ndr_flags, union xattr_NTACL_Info *r)
1014 {
1015         uint32_t level;
1016         uint16_t _level;
1017         TALLOC_CTX *_mem_save_sd_0;
1018         uint32_t _ptr_sd;
1019         TALLOC_CTX *_mem_save_sd_hs2_0;
1020         uint32_t _ptr_sd_hs2;
1021         TALLOC_CTX *_mem_save_sd_hs3_0;
1022         uint32_t _ptr_sd_hs3;
1023         TALLOC_CTX *_mem_save_sd_hs4_0;
1024         uint32_t _ptr_sd_hs4;
1025         level = ndr_pull_get_switch_value(ndr, r);
1026         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1027         if (ndr_flags & NDR_SCALARS) {
1028                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1029                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1030                 if (_level != level) {
1031                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1032                 }
1033                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
1034                 switch (level) {
1035                         case 1: {
1036                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
1037                                 if (_ptr_sd) {
1038                                         NDR_PULL_ALLOC(ndr, r->sd);
1039                                 } else {
1040                                         r->sd = NULL;
1041                                 }
1042                         break; }
1043
1044                         case 2: {
1045                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs2));
1046                                 if (_ptr_sd_hs2) {
1047                                         NDR_PULL_ALLOC(ndr, r->sd_hs2);
1048                                 } else {
1049                                         r->sd_hs2 = NULL;
1050                                 }
1051                         break; }
1052
1053                         case 3: {
1054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs3));
1055                                 if (_ptr_sd_hs3) {
1056                                         NDR_PULL_ALLOC(ndr, r->sd_hs3);
1057                                 } else {
1058                                         r->sd_hs3 = NULL;
1059                                 }
1060                         break; }
1061
1062                         case 4: {
1063                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs4));
1064                                 if (_ptr_sd_hs4) {
1065                                         NDR_PULL_ALLOC(ndr, r->sd_hs4);
1066                                 } else {
1067                                         r->sd_hs4 = NULL;
1068                                 }
1069                         break; }
1070
1071                         default:
1072                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1073                 }
1074         }
1075         if (ndr_flags & NDR_BUFFERS) {
1076                 switch (level) {
1077                         case 1:
1078                                 if (r->sd) {
1079                                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
1080                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
1081                                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
1082                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
1083                                 }
1084                         break;
1085
1086                         case 2:
1087                                 if (r->sd_hs2) {
1088                                         _mem_save_sd_hs2_0 = NDR_PULL_GET_MEM_CTX(ndr);
1089                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs2, 0);
1090                                         NDR_CHECK(ndr_pull_security_descriptor_hash_v2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs2));
1091                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs2_0, 0);
1092                                 }
1093                         break;
1094
1095                         case 3:
1096                                 if (r->sd_hs3) {
1097                                         _mem_save_sd_hs3_0 = NDR_PULL_GET_MEM_CTX(ndr);
1098                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs3, 0);
1099                                         NDR_CHECK(ndr_pull_security_descriptor_hash_v3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs3));
1100                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs3_0, 0);
1101                                 }
1102                         break;
1103
1104                         case 4:
1105                                 if (r->sd_hs4) {
1106                                         _mem_save_sd_hs4_0 = NDR_PULL_GET_MEM_CTX(ndr);
1107                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs4, 0);
1108                                         NDR_CHECK(ndr_pull_security_descriptor_hash_v4(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs4));
1109                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs4_0, 0);
1110                                 }
1111                         break;
1112
1113                         default:
1114                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1115                 }
1116         }
1117         return NDR_ERR_SUCCESS;
1118 }
1119
1120 _PUBLIC_ void ndr_print_xattr_NTACL_Info(struct ndr_print *ndr, const char *name, const union xattr_NTACL_Info *r)
1121 {
1122         uint32_t level;
1123         level = ndr_print_get_switch_value(ndr, r);
1124         ndr_print_union(ndr, name, level, "xattr_NTACL_Info");
1125         switch (level) {
1126                 case 1:
1127                         ndr_print_ptr(ndr, "sd", r->sd);
1128                         ndr->depth++;
1129                         if (r->sd) {
1130                                 ndr_print_security_descriptor(ndr, "sd", r->sd);
1131                         }
1132                         ndr->depth--;
1133                 break;
1134
1135                 case 2:
1136                         ndr_print_ptr(ndr, "sd_hs2", r->sd_hs2);
1137                         ndr->depth++;
1138                         if (r->sd_hs2) {
1139                                 ndr_print_security_descriptor_hash_v2(ndr, "sd_hs2", r->sd_hs2);
1140                         }
1141                         ndr->depth--;
1142                 break;
1143
1144                 case 3:
1145                         ndr_print_ptr(ndr, "sd_hs3", r->sd_hs3);
1146                         ndr->depth++;
1147                         if (r->sd_hs3) {
1148                                 ndr_print_security_descriptor_hash_v3(ndr, "sd_hs3", r->sd_hs3);
1149                         }
1150                         ndr->depth--;
1151                 break;
1152
1153                 case 4:
1154                         ndr_print_ptr(ndr, "sd_hs4", r->sd_hs4);
1155                         ndr->depth++;
1156                         if (r->sd_hs4) {
1157                                 ndr_print_security_descriptor_hash_v4(ndr, "sd_hs4", r->sd_hs4);
1158                         }
1159                         ndr->depth--;
1160                 break;
1161
1162                 default:
1163                         ndr_print_bad_level(ndr, name, level);
1164         }
1165 }
1166
1167 _PUBLIC_ enum ndr_err_code ndr_push_xattr_NTACL(struct ndr_push *ndr, int ndr_flags, const struct xattr_NTACL *r)
1168 {
1169         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1170         if (ndr_flags & NDR_SCALARS) {
1171                 NDR_CHECK(ndr_push_align(ndr, 5));
1172                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
1173                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
1174                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
1175                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1176         }
1177         if (ndr_flags & NDR_BUFFERS) {
1178                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
1179         }
1180         return NDR_ERR_SUCCESS;
1181 }
1182
1183 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_NTACL(struct ndr_pull *ndr, int ndr_flags, struct xattr_NTACL *r)
1184 {
1185         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1186         if (ndr_flags & NDR_SCALARS) {
1187                 NDR_CHECK(ndr_pull_align(ndr, 5));
1188                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
1189                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
1190                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
1191                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1192         }
1193         if (ndr_flags & NDR_BUFFERS) {
1194                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
1195         }
1196         return NDR_ERR_SUCCESS;
1197 }
1198
1199 _PUBLIC_ void ndr_print_xattr_NTACL(struct ndr_print *ndr, const char *name, const struct xattr_NTACL *r)
1200 {
1201         ndr_print_struct(ndr, name, "xattr_NTACL");
1202         if (r == NULL) { ndr_print_null(ndr); return; }
1203         ndr->depth++;
1204         ndr_print_uint16(ndr, "version", r->version);
1205         ndr_print_set_switch_value(ndr, &r->info, r->version);
1206         ndr_print_xattr_NTACL_Info(ndr, "info", &r->info);
1207         ndr->depth--;
1208 }
1209
1210 _PUBLIC_ enum ndr_err_code ndr_push_xattr_sys_acl_hash_wrapper(struct ndr_push *ndr, int ndr_flags, const struct xattr_sys_acl_hash_wrapper *r)
1211 {
1212         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1213         if (ndr_flags & NDR_SCALARS) {
1214                 NDR_CHECK(ndr_push_align(ndr, 8));
1215                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->acl_as_blob));
1216                 NDR_CHECK(ndr_push_uid_t(ndr, NDR_SCALARS, r->owner));
1217                 NDR_CHECK(ndr_push_gid_t(ndr, NDR_SCALARS, r->group));
1218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mode));
1219                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1220         }
1221         if (ndr_flags & NDR_BUFFERS) {
1222         }
1223         return NDR_ERR_SUCCESS;
1224 }
1225
1226 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_sys_acl_hash_wrapper(struct ndr_pull *ndr, int ndr_flags, struct xattr_sys_acl_hash_wrapper *r)
1227 {
1228         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1229         if (ndr_flags & NDR_SCALARS) {
1230                 NDR_CHECK(ndr_pull_align(ndr, 8));
1231                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->acl_as_blob));
1232                 NDR_CHECK(ndr_pull_uid_t(ndr, NDR_SCALARS, &r->owner));
1233                 NDR_CHECK(ndr_pull_gid_t(ndr, NDR_SCALARS, &r->group));
1234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mode));
1235                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1236         }
1237         if (ndr_flags & NDR_BUFFERS) {
1238         }
1239         return NDR_ERR_SUCCESS;
1240 }
1241
1242 _PUBLIC_ void ndr_print_xattr_sys_acl_hash_wrapper(struct ndr_print *ndr, const char *name, const struct xattr_sys_acl_hash_wrapper *r)
1243 {
1244         ndr_print_struct(ndr, name, "xattr_sys_acl_hash_wrapper");
1245         if (r == NULL) { ndr_print_null(ndr); return; }
1246         ndr->depth++;
1247         ndr_print_DATA_BLOB(ndr, "acl_as_blob", r->acl_as_blob);
1248         ndr_print_uid_t(ndr, "owner", r->owner);
1249         ndr_print_gid_t(ndr, "group", r->group);
1250         ndr_print_uint32(ndr, "mode", r->mode);
1251         ndr->depth--;
1252 }
1253
1254 static enum ndr_err_code ndr_push_xattr_parse_DOSATTRIB(struct ndr_push *ndr, int flags, const struct xattr_parse_DOSATTRIB *r)
1255 {
1256         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1257         if (flags & NDR_IN) {
1258                 NDR_CHECK(ndr_push_xattr_DOSATTRIB(ndr, NDR_SCALARS, &r->in.x));
1259         }
1260         if (flags & NDR_OUT) {
1261         }
1262         return NDR_ERR_SUCCESS;
1263 }
1264
1265 static enum ndr_err_code ndr_pull_xattr_parse_DOSATTRIB(struct ndr_pull *ndr, int flags, struct xattr_parse_DOSATTRIB *r)
1266 {
1267         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1268         if (flags & NDR_IN) {
1269                 NDR_CHECK(ndr_pull_xattr_DOSATTRIB(ndr, NDR_SCALARS, &r->in.x));
1270         }
1271         if (flags & NDR_OUT) {
1272         }
1273         return NDR_ERR_SUCCESS;
1274 }
1275
1276 _PUBLIC_ void ndr_print_xattr_parse_DOSATTRIB(struct ndr_print *ndr, const char *name, int flags, const struct xattr_parse_DOSATTRIB *r)
1277 {
1278         ndr_print_struct(ndr, name, "xattr_parse_DOSATTRIB");
1279         if (r == NULL) { ndr_print_null(ndr); return; }
1280         ndr->depth++;
1281         if (flags & NDR_SET_VALUES) {
1282                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1283         }
1284         if (flags & NDR_IN) {
1285                 ndr_print_struct(ndr, "in", "xattr_parse_DOSATTRIB");
1286                 ndr->depth++;
1287                 ndr_print_xattr_DOSATTRIB(ndr, "x", &r->in.x);
1288                 ndr->depth--;
1289         }
1290         if (flags & NDR_OUT) {
1291                 ndr_print_struct(ndr, "out", "xattr_parse_DOSATTRIB");
1292                 ndr->depth++;
1293                 ndr->depth--;
1294         }
1295         ndr->depth--;
1296 }
1297
1298 static const struct ndr_interface_call xattr_calls[] = {
1299         {
1300                 "xattr_parse_DOSATTRIB",
1301                 sizeof(struct xattr_parse_DOSATTRIB),
1302                 (ndr_push_flags_fn_t) ndr_push_xattr_parse_DOSATTRIB,
1303                 (ndr_pull_flags_fn_t) ndr_pull_xattr_parse_DOSATTRIB,
1304                 (ndr_print_function_t) ndr_print_xattr_parse_DOSATTRIB,
1305                 { 0, NULL },
1306                 { 0, NULL },
1307         },
1308         { NULL, 0, NULL, NULL, NULL }
1309 };
1310
1311 static const char * const xattr_endpoint_strings[] = {
1312         "ncacn_np:[\\pipe\\xattr]",
1313 };
1314
1315 static const struct ndr_interface_string_array xattr_endpoints = {
1316         .count  = 1,
1317         .names  = xattr_endpoint_strings
1318 };
1319
1320 static const char * const xattr_authservice_strings[] = {
1321         "host",
1322 };
1323
1324 static const struct ndr_interface_string_array xattr_authservices = {
1325         .count  = 1,
1326         .names  = xattr_authservice_strings
1327 };
1328
1329
1330 const struct ndr_interface_table ndr_table_xattr = {
1331         .name           = "xattr",
1332         .syntax_id      = {
1333                 {0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x02}},
1334                 NDR_XATTR_VERSION
1335         },
1336         .helpstring     = NDR_XATTR_HELPSTRING,
1337         .num_calls      = 1,
1338         .calls          = xattr_calls,
1339         .endpoints      = &xattr_endpoints,
1340         .authservices   = &xattr_authservices
1341 };
1342