source3/librpc/gen_ndr/ndr_xattr.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_xattr.h"
   5
   6 _PUBLIC_ enum ndr_err_code ndr_push_tdb_xattr(struct ndr_push *ndr, int ndr_flags, const struct tdb_xattr *r)
   7 {
   8         if (ndr_flags & NDR_SCALARS) {
   9                 NDR_CHECK(ndr_push_align(ndr, 4));
  10                 {
  11                         uint32_t _flags_save_string = ndr->flags;
  12                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
  13                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
  14                         ndr->flags = _flags_save_string;
  15                 }
  16                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19         }
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 _PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattr(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattr *r)
  24 {
  25         if (ndr_flags & NDR_SCALARS) {
  26                 NDR_CHECK(ndr_pull_align(ndr, 4));
  27                 {
  28                         uint32_t _flags_save_string = ndr->flags;
  29                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
  30                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
  31                         ndr->flags = _flags_save_string;
  32                 }
  33                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
  34         }
  35         if (ndr_flags & NDR_BUFFERS) {
  36         }
  37         return NDR_ERR_SUCCESS;
  38 }
  39
  40 _PUBLIC_ void ndr_print_tdb_xattr(struct ndr_print *ndr, const char *name, const struct tdb_xattr *r)
  41 {
  42         ndr_print_struct(ndr, name, "tdb_xattr");
  43         ndr->depth++;
  44         ndr_print_string(ndr, "name", r->name);
  45         ndr_print_DATA_BLOB(ndr, "value", r->value);
  46         ndr->depth--;
  47 }
  48
  49 _PUBLIC_ enum ndr_err_code ndr_push_tdb_xattrs(struct ndr_push *ndr, int ndr_flags, const struct tdb_xattrs *r)
  50 {
  51         uint32_t cntr_xattrs_0;
  52         if (ndr_flags & NDR_SCALARS) {
  53                 NDR_CHECK(ndr_push_align(ndr, 4));
  54                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_xattrs));
  55                 for (cntr_xattrs_0 = 0; cntr_xattrs_0 < r->num_xattrs; cntr_xattrs_0++) {
  56                         NDR_CHECK(ndr_push_tdb_xattr(ndr, NDR_SCALARS, &r->xattrs[cntr_xattrs_0]));
  57                 }
  58         }
  59         if (ndr_flags & NDR_BUFFERS) {
  60         }
  61         return NDR_ERR_SUCCESS;
  62 }
  63
  64 _PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattrs(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattrs *r)
  65 {
  66         uint32_t cntr_xattrs_0;
  67         TALLOC_CTX *_mem_save_xattrs_0;
  68         if (ndr_flags & NDR_SCALARS) {
  69                 NDR_CHECK(ndr_pull_align(ndr, 4));
  70                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_xattrs));
  71                 NDR_PULL_ALLOC_N(ndr, r->xattrs, r->num_xattrs);
  72                 _mem_save_xattrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
  73                 NDR_PULL_SET_MEM_CTX(ndr, r->xattrs, 0);
  74                 for (cntr_xattrs_0 = 0; cntr_xattrs_0 < r->num_xattrs; cntr_xattrs_0++) {
  75                         NDR_CHECK(ndr_pull_tdb_xattr(ndr, NDR_SCALARS, &r->xattrs[cntr_xattrs_0]));
  76                 }
  77                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_xattrs_0, 0);
  78         }
  79         if (ndr_flags & NDR_BUFFERS) {
  80         }
  81         return NDR_ERR_SUCCESS;
  82 }
  83
  84 _PUBLIC_ void ndr_print_tdb_xattrs(struct ndr_print *ndr, const char *name, const struct tdb_xattrs *r)
  85 {
  86         uint32_t cntr_xattrs_0;
  87         ndr_print_struct(ndr, name, "tdb_xattrs");
  88         ndr->depth++;
  89         ndr_print_uint32(ndr, "num_xattrs", r->num_xattrs);
  90         ndr->print(ndr, "%s: ARRAY(%d)", "xattrs", (int)r->num_xattrs);
  91         ndr->depth++;
  92         for (cntr_xattrs_0=0;cntr_xattrs_0<r->num_xattrs;cntr_xattrs_0++) {
  93                 char *idx_0=NULL;
  94                 if (asprintf(&idx_0, "[%d]", cntr_xattrs_0) != -1) {
  95                         ndr_print_tdb_xattr(ndr, "xattrs", &r->xattrs[cntr_xattrs_0]);
  96                         free(idx_0);
  97                 }
  98         }
  99         ndr->depth--;
 100         ndr->depth--;
 101 }
 102
 103 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_timestamp(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_timestamp *r)
 104 {
 105         if (ndr_flags & NDR_SCALARS) {
 106                 NDR_CHECK(ndr_push_align(ndr, 4));
 107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 108                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_changed));
 109         }
 110         if (ndr_flags & NDR_BUFFERS) {
 111                 if (r->sd) {
 112                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 113                 }
 114         }
 115         return NDR_ERR_SUCCESS;
 116 }
 117
 118 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_timestamp(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_timestamp *r)
 119 {
 120         uint32_t _ptr_sd;
 121         TALLOC_CTX *_mem_save_sd_0;
 122         if (ndr_flags & NDR_SCALARS) {
 123                 NDR_CHECK(ndr_pull_align(ndr, 4));
 124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 125                 if (_ptr_sd) {
 126                         NDR_PULL_ALLOC(ndr, r->sd);
 127                 } else {
 128                         r->sd = NULL;
 129                 }
 130                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_changed));
 131         }
 132         if (ndr_flags & NDR_BUFFERS) {
 133                 if (r->sd) {
 134                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 135                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 136                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 138                 }
 139         }
 140         return NDR_ERR_SUCCESS;
 141 }
 142
 143 _PUBLIC_ void ndr_print_security_descriptor_timestamp(struct ndr_print *ndr, const char *name, const struct security_descriptor_timestamp *r)
 144 {
 145         ndr_print_struct(ndr, name, "security_descriptor_timestamp");
 146         ndr->depth++;
 147         ndr_print_ptr(ndr, "sd", r->sd);
 148         ndr->depth++;
 149         if (r->sd) {
 150                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 151         }
 152         ndr->depth--;
 153         ndr_print_NTTIME(ndr, "last_changed", r->last_changed);
 154         ndr->depth--;
 155 }
 156
 157 static enum ndr_err_code ndr_push_xattr_NTACL_Info(struct ndr_push *ndr, int ndr_flags, const union xattr_NTACL_Info *r)
 158 {
 159         if (ndr_flags & NDR_SCALARS) {
 160                 int level = ndr_push_get_switch_value(ndr, r);
 161                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 162                 switch (level) {
 163                         case 1: {
 164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 165                         break; }
 166
 167                         case 2: {
 168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_ts));
 169                         break; }
 170
 171                         default:
 172                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 173                 }
 174         }
 175         if (ndr_flags & NDR_BUFFERS) {
 176                 int level = ndr_push_get_switch_value(ndr, r);
 177                 switch (level) {
 178                         case 1:
 179                                 if (r->sd) {
 180                                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 181                                 }
 182                         break;
 183
 184                         case 2:
 185                                 if (r->sd_ts) {
 186                                         NDR_CHECK(ndr_push_security_descriptor_timestamp(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_ts));
 187                                 }
 188                         break;
 189
 190                         default:
 191                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 192                 }
 193         }
 194         return NDR_ERR_SUCCESS;
 195 }
 196
 197 static enum ndr_err_code ndr_pull_xattr_NTACL_Info(struct ndr_pull *ndr, int ndr_flags, union xattr_NTACL_Info *r)
 198 {
 199         int level;
 200         uint16_t _level;
 201         TALLOC_CTX *_mem_save_sd_0;
 202         TALLOC_CTX *_mem_save_sd_ts_0;
 203         level = ndr_pull_get_switch_value(ndr, r);
 204         if (ndr_flags & NDR_SCALARS) {
 205                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 206                 if (_level != level) {
 207                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 208                 }
 209                 switch (level) {
 210                         case 1: {
 211                                 uint32_t _ptr_sd;
 212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 213                                 if (_ptr_sd) {
 214                                         NDR_PULL_ALLOC(ndr, r->sd);
 215                                 } else {
 216                                         r->sd = NULL;
 217                                 }
 218                         break; }
 219
 220                         case 2: {
 221                                 uint32_t _ptr_sd_ts;
 222                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_ts));
 223                                 if (_ptr_sd_ts) {
 224                                         NDR_PULL_ALLOC(ndr, r->sd_ts);
 225                                 } else {
 226                                         r->sd_ts = NULL;
 227                                 }
 228                         break; }
 229
 230                         default:
 231                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 232                 }
 233         }
 234         if (ndr_flags & NDR_BUFFERS) {
 235                 switch (level) {
 236                         case 1:
 237                                 if (r->sd) {
 238                                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 239                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 240                                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 241                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 242                                 }
 243                         break;
 244
 245                         case 2:
 246                                 if (r->sd_ts) {
 247                                         _mem_save_sd_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
 248                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_ts, 0);
 249                                         NDR_CHECK(ndr_pull_security_descriptor_timestamp(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_ts));
 250                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_ts_0, 0);
 251                                 }
 252                         break;
 253
 254                         default:
 255                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 256                 }
 257         }
 258         return NDR_ERR_SUCCESS;
 259 }
 260
 261 _PUBLIC_ void ndr_print_xattr_NTACL_Info(struct ndr_print *ndr, const char *name, const union xattr_NTACL_Info *r)
 262 {
 263         int level;
 264         level = ndr_print_get_switch_value(ndr, r);
 265         ndr_print_union(ndr, name, level, "xattr_NTACL_Info");
 266         switch (level) {
 267                 case 1:
 268                         ndr_print_ptr(ndr, "sd", r->sd);
 269                         ndr->depth++;
 270                         if (r->sd) {
 271                                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 272                         }
 273                         ndr->depth--;
 274                 break;
 275
 276                 case 2:
 277                         ndr_print_ptr(ndr, "sd_ts", r->sd_ts);
 278                         ndr->depth++;
 279                         if (r->sd_ts) {
 280                                 ndr_print_security_descriptor_timestamp(ndr, "sd_ts", r->sd_ts);
 281                         }
 282                         ndr->depth--;
 283                 break;
 284
 285                 default:
 286                         ndr_print_bad_level(ndr, name, level);
 287         }
 288 }
 289
 290 _PUBLIC_ enum ndr_err_code ndr_push_xattr_NTACL(struct ndr_push *ndr, int ndr_flags, const struct xattr_NTACL *r)
 291 {
 292         if (ndr_flags & NDR_SCALARS) {
 293                 NDR_CHECK(ndr_push_align(ndr, 4));
 294                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 295                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 296                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 297         }
 298         if (ndr_flags & NDR_BUFFERS) {
 299                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 300         }
 301         return NDR_ERR_SUCCESS;
 302 }
 303
 304 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_NTACL(struct ndr_pull *ndr, int ndr_flags, struct xattr_NTACL *r)
 305 {
 306         if (ndr_flags & NDR_SCALARS) {
 307                 NDR_CHECK(ndr_pull_align(ndr, 4));
 308                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 309                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 310                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 311         }
 312         if (ndr_flags & NDR_BUFFERS) {
 313                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 314         }
 315         return NDR_ERR_SUCCESS;
 316 }
 317
 318 _PUBLIC_ void ndr_print_xattr_NTACL(struct ndr_print *ndr, const char *name, const struct xattr_NTACL *r)
 319 {
 320         ndr_print_struct(ndr, name, "xattr_NTACL");
 321         ndr->depth++;
 322         ndr_print_uint16(ndr, "version", r->version);
 323         ndr_print_set_switch_value(ndr, &r->info, r->version);
 324         ndr_print_xattr_NTACL_Info(ndr, "info", &r->info);
 325         ndr->depth--;
 326 }
 327