LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_xattr.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 535 974 54.9 %
Date: 2021-09-23 10:06:22 Functions: 35 67 52.2 %

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

Generated by: LCOV version 1.13