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 master 2b515b7d Lines: 519 1056 49.1 %
Date: 2024-02-28 12:06:22 Functions: 32 70 45.7 %

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

Generated by: LCOV version 1.14