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 #include "librpc/gen_ndr/ndr_security.h"
   7 static enum ndr_err_code ndr_push_xattr_DosInfo1(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo1 *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
  12                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
  13                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
  14                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
  15                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
  16                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19         }
  20         return NDR_ERR_SUCCESS;
  21 }
  22
  23 static enum ndr_err_code ndr_pull_xattr_DosInfo1(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo1 *r)
  24 {
  25         if (ndr_flags & NDR_SCALARS) {
  26                 NDR_CHECK(ndr_pull_align(ndr, 4));
  27                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
  28                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
  29                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
  30                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
  31                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
  32                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
  33         }
  34         if (ndr_flags & NDR_BUFFERS) {
  35         }
  36         return NDR_ERR_SUCCESS;
  37 }
  38
  39 _PUBLIC_ void ndr_print_xattr_DosInfo1(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo1 *r)
  40 {
  41         ndr_print_struct(ndr, name, "xattr_DosInfo1");
  42         ndr->depth++;
  43         ndr_print_uint32(ndr, "attrib", r->attrib);
  44         ndr_print_uint32(ndr, "ea_size", r->ea_size);
  45         ndr_print_udlong(ndr, "size", r->size);
  46         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
  47         ndr_print_NTTIME(ndr, "create_time", r->create_time);
  48         ndr_print_NTTIME(ndr, "change_time", r->change_time);
  49         ndr->depth--;
  50 }
  51
  52 static enum ndr_err_code ndr_push_xattr_DosInfo2Old(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo2Old *r)
  53 {
  54         if (ndr_flags & NDR_SCALARS) {
  55                 NDR_CHECK(ndr_push_align(ndr, 4));
  56                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
  57                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
  58                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
  59                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
  60                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
  61                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
  62                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
  63                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->write_time));
  64                 {
  65                         uint32_t _flags_save_string = ndr->flags;
  66                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
  67                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
  68                         ndr->flags = _flags_save_string;
  69                 }
  70         }
  71         if (ndr_flags & NDR_BUFFERS) {
  72         }
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 static enum ndr_err_code ndr_pull_xattr_DosInfo2Old(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo2Old *r)
  77 {
  78         if (ndr_flags & NDR_SCALARS) {
  79                 NDR_CHECK(ndr_pull_align(ndr, 4));
  80                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
  81                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
  82                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
  83                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
  84                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
  85                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
  86                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
  87                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->write_time));
  88                 {
  89                         uint32_t _flags_save_string = ndr->flags;
  90                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
  91                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
  92                         ndr->flags = _flags_save_string;
  93                 }
  94         }
  95         if (ndr_flags & NDR_BUFFERS) {
  96         }
  97         return NDR_ERR_SUCCESS;
  98 }
  99
 100 _PUBLIC_ void ndr_print_xattr_DosInfo2Old(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo2Old *r)
 101 {
 102         ndr_print_struct(ndr, name, "xattr_DosInfo2Old");
 103         ndr->depth++;
 104         ndr_print_uint32(ndr, "flags", r->flags);
 105         ndr_print_uint32(ndr, "attrib", r->attrib);
 106         ndr_print_uint32(ndr, "ea_size", r->ea_size);
 107         ndr_print_udlong(ndr, "size", r->size);
 108         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 109         ndr_print_NTTIME(ndr, "create_time", r->create_time);
 110         ndr_print_NTTIME(ndr, "change_time", r->change_time);
 111         ndr_print_NTTIME(ndr, "write_time", r->write_time);
 112         ndr_print_string(ndr, "name", r->name);
 113         ndr->depth--;
 114 }
 115
 116 static enum ndr_err_code ndr_push_xattr_DosInfo(struct ndr_push *ndr, int ndr_flags, const union xattr_DosInfo *r)
 117 {
 118         if (ndr_flags & NDR_SCALARS) {
 119                 int level = ndr_push_get_switch_value(ndr, r);
 120                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 121                 switch (level) {
 122                         case 1: {
 123                                 NDR_CHECK(ndr_push_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 124                         break; }
 125
 126                         case 2: {
 127                                 NDR_CHECK(ndr_push_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 128                         break; }
 129
 130                         default:
 131                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 132                 }
 133         }
 134         if (ndr_flags & NDR_BUFFERS) {
 135                 int level = ndr_push_get_switch_value(ndr, r);
 136                 switch (level) {
 137                         case 1:
 138                         break;
 139
 140                         case 2:
 141                         break;
 142
 143                         default:
 144                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 145                 }
 146         }
 147         return NDR_ERR_SUCCESS;
 148 }
 149
 150 static enum ndr_err_code ndr_pull_xattr_DosInfo(struct ndr_pull *ndr, int ndr_flags, union xattr_DosInfo *r)
 151 {
 152         int level;
 153         uint16_t _level;
 154         level = ndr_pull_get_switch_value(ndr, r);
 155         if (ndr_flags & NDR_SCALARS) {
 156                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 157                 if (_level != level) {
 158                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 159                 }
 160                 switch (level) {
 161                         case 1: {
 162                                 NDR_CHECK(ndr_pull_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 163                         break; }
 164
 165                         case 2: {
 166                                 NDR_CHECK(ndr_pull_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 167                         break; }
 168
 169                         default:
 170                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 171                 }
 172         }
 173         if (ndr_flags & NDR_BUFFERS) {
 174                 switch (level) {
 175                         case 1:
 176                         break;
 177
 178                         case 2:
 179                         break;
 180
 181                         default:
 182                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 183                 }
 184         }
 185         return NDR_ERR_SUCCESS;
 186 }
 187
 188 _PUBLIC_ void ndr_print_xattr_DosInfo(struct ndr_print *ndr, const char *name, const union xattr_DosInfo *r)
 189 {
 190         int level;
 191         level = ndr_print_get_switch_value(ndr, r);
 192         ndr_print_union(ndr, name, level, "xattr_DosInfo");
 193         switch (level) {
 194                 case 1:
 195                         ndr_print_xattr_DosInfo1(ndr, "info1", &r->info1);
 196                 break;
 197
 198                 case 2:
 199                         ndr_print_xattr_DosInfo2Old(ndr, "oldinfo2", &r->oldinfo2);
 200                 break;
 201
 202                 default:
 203                         ndr_print_bad_level(ndr, name, level);
 204         }
 205 }
 206
 207 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosAttrib(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosAttrib *r)
 208 {
 209         if (ndr_flags & NDR_SCALARS) {
 210                 NDR_CHECK(ndr_push_align(ndr, 4));
 211                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 212                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 213                 NDR_CHECK(ndr_push_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 214         }
 215         if (ndr_flags & NDR_BUFFERS) {
 216         }
 217         return NDR_ERR_SUCCESS;
 218 }
 219
 220 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosAttrib(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosAttrib *r)
 221 {
 222         if (ndr_flags & NDR_SCALARS) {
 223                 NDR_CHECK(ndr_pull_align(ndr, 4));
 224                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 225                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 226                 NDR_CHECK(ndr_pull_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 227         }
 228         if (ndr_flags & NDR_BUFFERS) {
 229         }
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 _PUBLIC_ void ndr_print_xattr_DosAttrib(struct ndr_print *ndr, const char *name, const struct xattr_DosAttrib *r)
 234 {
 235         ndr_print_struct(ndr, name, "xattr_DosAttrib");
 236         ndr->depth++;
 237         ndr_print_uint16(ndr, "version", r->version);
 238         ndr_print_set_switch_value(ndr, &r->info, r->version);
 239         ndr_print_xattr_DosInfo(ndr, "info", &r->info);
 240         ndr->depth--;
 241 }
 242
 243 static enum ndr_err_code ndr_push_xattr_EA(struct ndr_push *ndr, int ndr_flags, const struct xattr_EA *r)
 244 {
 245         if (ndr_flags & NDR_SCALARS) {
 246                 NDR_CHECK(ndr_push_align(ndr, 4));
 247                 {
 248                         uint32_t _flags_save_string = ndr->flags;
 249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 250                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 251                         ndr->flags = _flags_save_string;
 252                 }
 253                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
 254         }
 255         if (ndr_flags & NDR_BUFFERS) {
 256         }
 257         return NDR_ERR_SUCCESS;
 258 }
 259
 260 static enum ndr_err_code ndr_pull_xattr_EA(struct ndr_pull *ndr, int ndr_flags, struct xattr_EA *r)
 261 {
 262         if (ndr_flags & NDR_SCALARS) {
 263                 NDR_CHECK(ndr_pull_align(ndr, 4));
 264                 {
 265                         uint32_t _flags_save_string = ndr->flags;
 266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 267                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 268                         ndr->flags = _flags_save_string;
 269                 }
 270                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
 271         }
 272         if (ndr_flags & NDR_BUFFERS) {
 273         }
 274         return NDR_ERR_SUCCESS;
 275 }
 276
 277 _PUBLIC_ void ndr_print_xattr_EA(struct ndr_print *ndr, const char *name, const struct xattr_EA *r)
 278 {
 279         ndr_print_struct(ndr, name, "xattr_EA");
 280         ndr->depth++;
 281         ndr_print_string(ndr, "name", r->name);
 282         ndr_print_DATA_BLOB(ndr, "value", r->value);
 283         ndr->depth--;
 284 }
 285
 286 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosEAs(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosEAs *r)
 287 {
 288         uint32_t cntr_eas_1;
 289         if (ndr_flags & NDR_SCALARS) {
 290                 NDR_CHECK(ndr_push_align(ndr, 4));
 291                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_eas));
 292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->eas));
 293         }
 294         if (ndr_flags & NDR_BUFFERS) {
 295                 if (r->eas) {
 296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_eas));
 297                         for (cntr_eas_1 = 0; cntr_eas_1 < r->num_eas; cntr_eas_1++) {
 298                                 NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 299                         }
 300                 }
 301         }
 302         return NDR_ERR_SUCCESS;
 303 }
 304
 305 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosEAs(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosEAs *r)
 306 {
 307         uint32_t _ptr_eas;
 308         uint32_t cntr_eas_1;
 309         TALLOC_CTX *_mem_save_eas_0;
 310         TALLOC_CTX *_mem_save_eas_1;
 311         if (ndr_flags & NDR_SCALARS) {
 312                 NDR_CHECK(ndr_pull_align(ndr, 4));
 313                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_eas));
 314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eas));
 315                 if (_ptr_eas) {
 316                         NDR_PULL_ALLOC(ndr, r->eas);
 317                 } else {
 318                         r->eas = NULL;
 319                 }
 320         }
 321         if (ndr_flags & NDR_BUFFERS) {
 322                 if (r->eas) {
 323                         _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 324                         NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 325                         NDR_CHECK(ndr_pull_array_size(ndr, &r->eas));
 326                         NDR_PULL_ALLOC_N(ndr, r->eas, ndr_get_array_size(ndr, &r->eas));
 327                         _mem_save_eas_1 = NDR_PULL_GET_MEM_CTX(ndr);
 328                         NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 329                         for (cntr_eas_1 = 0; cntr_eas_1 < r->num_eas; cntr_eas_1++) {
 330                                 NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 331                         }
 332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_1, 0);
 333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 334                 }
 335                 if (r->eas) {
 336                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->eas, r->num_eas));
 337                 }
 338         }
 339         return NDR_ERR_SUCCESS;
 340 }
 341
 342 _PUBLIC_ void ndr_print_xattr_DosEAs(struct ndr_print *ndr, const char *name, const struct xattr_DosEAs *r)
 343 {
 344         uint32_t cntr_eas_1;
 345         ndr_print_struct(ndr, name, "xattr_DosEAs");
 346         ndr->depth++;
 347         ndr_print_uint16(ndr, "num_eas", r->num_eas);
 348         ndr_print_ptr(ndr, "eas", r->eas);
 349         ndr->depth++;
 350         if (r->eas) {
 351                 ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 352                 ndr->depth++;
 353                 for (cntr_eas_1=0;cntr_eas_1<r->num_eas;cntr_eas_1++) {
 354                         char *idx_1=NULL;
 355                         if (asprintf(&idx_1, "[%d]", cntr_eas_1) != -1) {
 356                                 ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_1]);
 357                                 free(idx_1);
 358                         }
 359                 }
 360                 ndr->depth--;
 361         }
 362         ndr->depth--;
 363         ndr->depth--;
 364 }
 365
 366 _PUBLIC_ enum ndr_err_code ndr_push_tdb_xattrs(struct ndr_push *ndr, int ndr_flags, const struct tdb_xattrs *r)
 367 {
 368         uint32_t cntr_eas_0;
 369         if (ndr_flags & NDR_SCALARS) {
 370                 NDR_CHECK(ndr_push_align(ndr, 4));
 371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_eas));
 372                 for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
 373                         NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 374                 }
 375         }
 376         if (ndr_flags & NDR_BUFFERS) {
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattrs(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattrs *r)
 382 {
 383         uint32_t cntr_eas_0;
 384         TALLOC_CTX *_mem_save_eas_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 4));
 387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_eas));
 388                 NDR_PULL_ALLOC_N(ndr, r->eas, r->num_eas);
 389                 _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 390                 NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 391                 for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
 392                         NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 393                 }
 394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 395         }
 396         if (ndr_flags & NDR_BUFFERS) {
 397         }
 398         return NDR_ERR_SUCCESS;
 399 }
 400
 401 _PUBLIC_ void ndr_print_tdb_xattrs(struct ndr_print *ndr, const char *name, const struct tdb_xattrs *r)
 402 {
 403         uint32_t cntr_eas_0;
 404         ndr_print_struct(ndr, name, "tdb_xattrs");
 405         ndr->depth++;
 406         ndr_print_uint32(ndr, "num_eas", r->num_eas);
 407         ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 408         ndr->depth++;
 409         for (cntr_eas_0=0;cntr_eas_0<r->num_eas;cntr_eas_0++) {
 410                 char *idx_0=NULL;
 411                 if (asprintf(&idx_0, "[%d]", cntr_eas_0) != -1) {
 412                         ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_0]);
 413                         free(idx_0);
 414                 }
 415         }
 416         ndr->depth--;
 417         ndr->depth--;
 418 }
 419
 420 static enum ndr_err_code ndr_push_xattr_DosStream(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStream *r)
 421 {
 422         if (ndr_flags & NDR_SCALARS) {
 423                 NDR_CHECK(ndr_push_align(ndr, 4));
 424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 425                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 426                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 427                 {
 428                         uint32_t _flags_save_string = ndr->flags;
 429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 430                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 431                         ndr->flags = _flags_save_string;
 432                 }
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435         }
 436         return NDR_ERR_SUCCESS;
 437 }
 438
 439 static enum ndr_err_code ndr_pull_xattr_DosStream(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStream *r)
 440 {
 441         if (ndr_flags & NDR_SCALARS) {
 442                 NDR_CHECK(ndr_pull_align(ndr, 4));
 443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 444                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 445                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 446                 {
 447                         uint32_t _flags_save_string = ndr->flags;
 448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 449                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 450                         ndr->flags = _flags_save_string;
 451                 }
 452         }
 453         if (ndr_flags & NDR_BUFFERS) {
 454         }
 455         return NDR_ERR_SUCCESS;
 456 }
 457
 458 _PUBLIC_ void ndr_print_xattr_DosStream(struct ndr_print *ndr, const char *name, const struct xattr_DosStream *r)
 459 {
 460         ndr_print_struct(ndr, name, "xattr_DosStream");
 461         ndr->depth++;
 462         ndr_print_uint32(ndr, "flags", r->flags);
 463         ndr_print_udlong(ndr, "size", r->size);
 464         ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 465         ndr_print_string(ndr, "name", r->name);
 466         ndr->depth--;
 467 }
 468
 469 _PUBLIC_ enum ndr_err_code ndr_push_xattr_DosStreams(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStreams *r)
 470 {
 471         uint32_t cntr_streams_1;
 472         if (ndr_flags & NDR_SCALARS) {
 473                 NDR_CHECK(ndr_push_align(ndr, 4));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
 475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->streams));
 476         }
 477         if (ndr_flags & NDR_BUFFERS) {
 478                 if (r->streams) {
 479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
 480                         for (cntr_streams_1 = 0; cntr_streams_1 < r->num_streams; cntr_streams_1++) {
 481                                 NDR_CHECK(ndr_push_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 482                         }
 483                 }
 484         }
 485         return NDR_ERR_SUCCESS;
 486 }
 487
 488 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosStreams(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStreams *r)
 489 {
 490         uint32_t _ptr_streams;
 491         uint32_t cntr_streams_1;
 492         TALLOC_CTX *_mem_save_streams_0;
 493         TALLOC_CTX *_mem_save_streams_1;
 494         if (ndr_flags & NDR_SCALARS) {
 495                 NDR_CHECK(ndr_pull_align(ndr, 4));
 496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_streams));
 497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_streams));
 498                 if (_ptr_streams) {
 499                         NDR_PULL_ALLOC(ndr, r->streams);
 500                 } else {
 501                         r->streams = NULL;
 502                 }
 503         }
 504         if (ndr_flags & NDR_BUFFERS) {
 505                 if (r->streams) {
 506                         _mem_save_streams_0 = NDR_PULL_GET_MEM_CTX(ndr);
 507                         NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 508                         NDR_CHECK(ndr_pull_array_size(ndr, &r->streams));
 509                         NDR_PULL_ALLOC_N(ndr, r->streams, ndr_get_array_size(ndr, &r->streams));
 510                         _mem_save_streams_1 = NDR_PULL_GET_MEM_CTX(ndr);
 511                         NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 512                         for (cntr_streams_1 = 0; cntr_streams_1 < r->num_streams; cntr_streams_1++) {
 513                                 NDR_CHECK(ndr_pull_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 514                         }
 515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_1, 0);
 516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_0, 0);
 517                 }
 518                 if (r->streams) {
 519                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->streams, r->num_streams));
 520                 }
 521         }
 522         return NDR_ERR_SUCCESS;
 523 }
 524
 525 _PUBLIC_ void ndr_print_xattr_DosStreams(struct ndr_print *ndr, const char *name, const struct xattr_DosStreams *r)
 526 {
 527         uint32_t cntr_streams_1;
 528         ndr_print_struct(ndr, name, "xattr_DosStreams");
 529         ndr->depth++;
 530         ndr_print_uint32(ndr, "num_streams", r->num_streams);
 531         ndr_print_ptr(ndr, "streams", r->streams);
 532         ndr->depth++;
 533         if (r->streams) {
 534                 ndr->print(ndr, "%s: ARRAY(%d)", "streams", (int)r->num_streams);
 535                 ndr->depth++;
 536                 for (cntr_streams_1=0;cntr_streams_1<r->num_streams;cntr_streams_1++) {
 537                         char *idx_1=NULL;
 538                         if (asprintf(&idx_1, "[%d]", cntr_streams_1) != -1) {
 539                                 ndr_print_xattr_DosStream(ndr, "streams", &r->streams[cntr_streams_1]);
 540                                 free(idx_1);
 541                         }
 542                 }
 543                 ndr->depth--;
 544         }
 545         ndr->depth--;
 546         ndr->depth--;
 547 }
 548
 549 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v2(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash_v2 *r)
 550 {
 551         if (ndr_flags & NDR_SCALARS) {
 552                 NDR_CHECK(ndr_push_align(ndr, 4));
 553                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 554                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 555         }
 556         if (ndr_flags & NDR_BUFFERS) {
 557                 if (r->sd) {
 558                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 559                 }
 560         }
 561         return NDR_ERR_SUCCESS;
 562 }
 563
 564 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v2(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash_v2 *r)
 565 {
 566         uint32_t _ptr_sd;
 567         TALLOC_CTX *_mem_save_sd_0;
 568         if (ndr_flags & NDR_SCALARS) {
 569                 NDR_CHECK(ndr_pull_align(ndr, 4));
 570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 571                 if (_ptr_sd) {
 572                         NDR_PULL_ALLOC(ndr, r->sd);
 573                 } else {
 574                         r->sd = NULL;
 575                 }
 576                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 577         }
 578         if (ndr_flags & NDR_BUFFERS) {
 579                 if (r->sd) {
 580                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 581                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 582                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 584                 }
 585         }
 586         return NDR_ERR_SUCCESS;
 587 }
 588
 589 _PUBLIC_ void ndr_print_security_descriptor_hash_v2(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash_v2 *r)
 590 {
 591         ndr_print_struct(ndr, name, "security_descriptor_hash_v2");
 592         ndr->depth++;
 593         ndr_print_ptr(ndr, "sd", r->sd);
 594         ndr->depth++;
 595         if (r->sd) {
 596                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 597         }
 598         ndr->depth--;
 599         ndr_print_array_uint8(ndr, "hash", r->hash, 16);
 600         ndr->depth--;
 601 }
 602
 603 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash_v3(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash_v3 *r)
 604 {
 605         if (ndr_flags & NDR_SCALARS) {
 606                 NDR_CHECK(ndr_push_align(ndr, 4));
 607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 608                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hash_type));
 609                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
 610         }
 611         if (ndr_flags & NDR_BUFFERS) {
 612                 if (r->sd) {
 613                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 614                 }
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash_v3(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash_v3 *r)
 620 {
 621         uint32_t _ptr_sd;
 622         TALLOC_CTX *_mem_save_sd_0;
 623         if (ndr_flags & NDR_SCALARS) {
 624                 NDR_CHECK(ndr_pull_align(ndr, 4));
 625                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 626                 if (_ptr_sd) {
 627                         NDR_PULL_ALLOC(ndr, r->sd);
 628                 } else {
 629                         r->sd = NULL;
 630                 }
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hash_type));
 632                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 64));
 633         }
 634         if (ndr_flags & NDR_BUFFERS) {
 635                 if (r->sd) {
 636                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 637                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 638                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 640                 }
 641         }
 642         return NDR_ERR_SUCCESS;
 643 }
 644
 645 _PUBLIC_ void ndr_print_security_descriptor_hash_v3(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash_v3 *r)
 646 {
 647         ndr_print_struct(ndr, name, "security_descriptor_hash_v3");
 648         ndr->depth++;
 649         ndr_print_ptr(ndr, "sd", r->sd);
 650         ndr->depth++;
 651         if (r->sd) {
 652                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 653         }
 654         ndr->depth--;
 655         ndr_print_uint16(ndr, "hash_type", r->hash_type);
 656         ndr_print_array_uint8(ndr, "hash", r->hash, 64);
 657         ndr->depth--;
 658 }
 659
 660 static enum ndr_err_code ndr_push_xattr_NTACL_Info(struct ndr_push *ndr, int ndr_flags, const union xattr_NTACL_Info *r)
 661 {
 662         if (ndr_flags & NDR_SCALARS) {
 663                 int level = ndr_push_get_switch_value(ndr, r);
 664                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 665                 switch (level) {
 666                         case 1: {
 667                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 668                         break; }
 669
 670                         case 2: {
 671                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs2));
 672                         break; }
 673
 674                         case 3: {
 675                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs3));
 676                         break; }
 677
 678                         default:
 679                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 680                 }
 681         }
 682         if (ndr_flags & NDR_BUFFERS) {
 683                 int level = ndr_push_get_switch_value(ndr, r);
 684                 switch (level) {
 685                         case 1:
 686                                 if (r->sd) {
 687                                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 688                                 }
 689                         break;
 690
 691                         case 2:
 692                                 if (r->sd_hs2) {
 693                                         NDR_CHECK(ndr_push_security_descriptor_hash_v2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs2));
 694                                 }
 695                         break;
 696
 697                         case 3:
 698                                 if (r->sd_hs3) {
 699                                         NDR_CHECK(ndr_push_security_descriptor_hash_v3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs3));
 700                                 }
 701                         break;
 702
 703                         default:
 704                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 705                 }
 706         }
 707         return NDR_ERR_SUCCESS;
 708 }
 709
 710 static enum ndr_err_code ndr_pull_xattr_NTACL_Info(struct ndr_pull *ndr, int ndr_flags, union xattr_NTACL_Info *r)
 711 {
 712         int level;
 713         uint16_t _level;
 714         TALLOC_CTX *_mem_save_sd_0;
 715         TALLOC_CTX *_mem_save_sd_hs2_0;
 716         TALLOC_CTX *_mem_save_sd_hs3_0;
 717         level = ndr_pull_get_switch_value(ndr, r);
 718         if (ndr_flags & NDR_SCALARS) {
 719                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 720                 if (_level != level) {
 721                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 722                 }
 723                 switch (level) {
 724                         case 1: {
 725                                 uint32_t _ptr_sd;
 726                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 727                                 if (_ptr_sd) {
 728                                         NDR_PULL_ALLOC(ndr, r->sd);
 729                                 } else {
 730                                         r->sd = NULL;
 731                                 }
 732                         break; }
 733
 734                         case 2: {
 735                                 uint32_t _ptr_sd_hs2;
 736                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs2));
 737                                 if (_ptr_sd_hs2) {
 738                                         NDR_PULL_ALLOC(ndr, r->sd_hs2);
 739                                 } else {
 740                                         r->sd_hs2 = NULL;
 741                                 }
 742                         break; }
 743
 744                         case 3: {
 745                                 uint32_t _ptr_sd_hs3;
 746                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs3));
 747                                 if (_ptr_sd_hs3) {
 748                                         NDR_PULL_ALLOC(ndr, r->sd_hs3);
 749                                 } else {
 750                                         r->sd_hs3 = NULL;
 751                                 }
 752                         break; }
 753
 754                         default:
 755                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 756                 }
 757         }
 758         if (ndr_flags & NDR_BUFFERS) {
 759                 switch (level) {
 760                         case 1:
 761                                 if (r->sd) {
 762                                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 763                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 764                                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 765                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 766                                 }
 767                         break;
 768
 769                         case 2:
 770                                 if (r->sd_hs2) {
 771                                         _mem_save_sd_hs2_0 = NDR_PULL_GET_MEM_CTX(ndr);
 772                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs2, 0);
 773                                         NDR_CHECK(ndr_pull_security_descriptor_hash_v2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs2));
 774                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs2_0, 0);
 775                                 }
 776                         break;
 777
 778                         case 3:
 779                                 if (r->sd_hs3) {
 780                                         _mem_save_sd_hs3_0 = NDR_PULL_GET_MEM_CTX(ndr);
 781                                         NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs3, 0);
 782                                         NDR_CHECK(ndr_pull_security_descriptor_hash_v3(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs3));
 783                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs3_0, 0);
 784                                 }
 785                         break;
 786
 787                         default:
 788                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 789                 }
 790         }
 791         return NDR_ERR_SUCCESS;
 792 }
 793
 794 _PUBLIC_ void ndr_print_xattr_NTACL_Info(struct ndr_print *ndr, const char *name, const union xattr_NTACL_Info *r)
 795 {
 796         int level;
 797         level = ndr_print_get_switch_value(ndr, r);
 798         ndr_print_union(ndr, name, level, "xattr_NTACL_Info");
 799         switch (level) {
 800                 case 1:
 801                         ndr_print_ptr(ndr, "sd", r->sd);
 802                         ndr->depth++;
 803                         if (r->sd) {
 804                                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 805                         }
 806                         ndr->depth--;
 807                 break;
 808
 809                 case 2:
 810                         ndr_print_ptr(ndr, "sd_hs2", r->sd_hs2);
 811                         ndr->depth++;
 812                         if (r->sd_hs2) {
 813                                 ndr_print_security_descriptor_hash_v2(ndr, "sd_hs2", r->sd_hs2);
 814                         }
 815                         ndr->depth--;
 816                 break;
 817
 818                 case 3:
 819                         ndr_print_ptr(ndr, "sd_hs3", r->sd_hs3);
 820                         ndr->depth++;
 821                         if (r->sd_hs3) {
 822                                 ndr_print_security_descriptor_hash_v3(ndr, "sd_hs3", r->sd_hs3);
 823                         }
 824                         ndr->depth--;
 825                 break;
 826
 827                 default:
 828                         ndr_print_bad_level(ndr, name, level);
 829         }
 830 }
 831
 832 _PUBLIC_ enum ndr_err_code ndr_push_xattr_NTACL(struct ndr_push *ndr, int ndr_flags, const struct xattr_NTACL *r)
 833 {
 834         if (ndr_flags & NDR_SCALARS) {
 835                 NDR_CHECK(ndr_push_align(ndr, 4));
 836                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 837                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 838                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 839         }
 840         if (ndr_flags & NDR_BUFFERS) {
 841                 NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 842         }
 843         return NDR_ERR_SUCCESS;
 844 }
 845
 846 _PUBLIC_ enum ndr_err_code ndr_pull_xattr_NTACL(struct ndr_pull *ndr, int ndr_flags, struct xattr_NTACL *r)
 847 {
 848         if (ndr_flags & NDR_SCALARS) {
 849                 NDR_CHECK(ndr_pull_align(ndr, 4));
 850                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 851                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 852                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 853         }
 854         if (ndr_flags & NDR_BUFFERS) {
 855                 NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 856         }
 857         return NDR_ERR_SUCCESS;
 858 }
 859
 860 _PUBLIC_ void ndr_print_xattr_NTACL(struct ndr_print *ndr, const char *name, const struct xattr_NTACL *r)
 861 {
 862         ndr_print_struct(ndr, name, "xattr_NTACL");
 863         ndr->depth++;
 864         ndr_print_uint16(ndr, "version", r->version);
 865         ndr_print_set_switch_value(ndr, &r->info, r->version);
 866         ndr_print_xattr_NTACL_Info(ndr, "info", &r->info);
 867         ndr->depth--;
 868 }
 869