librpc/gen_ndr/ndr_security.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_security.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_security_ace_flags(struct ndr_push *ndr, int ndr_flags, uint8_t r)
   8 {
   9         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
  10         return NDR_ERR_SUCCESS;
  11 }
  12
  13 _PUBLIC_ enum ndr_err_code ndr_pull_security_ace_flags(struct ndr_pull *ndr, int ndr_flags, uint8_t *r)
  14 {
  15         uint8_t v;
  16         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
  17         *r = v;
  18         return NDR_ERR_SUCCESS;
  19 }
  20
  21 _PUBLIC_ void ndr_print_security_ace_flags(struct ndr_print *ndr, const char *name, uint8_t r)
  22 {
  23         ndr_print_uint8(ndr, name, r);
  24         ndr->depth++;
  25         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_OBJECT_INHERIT", SEC_ACE_FLAG_OBJECT_INHERIT, r);
  26         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_CONTAINER_INHERIT", SEC_ACE_FLAG_CONTAINER_INHERIT, r);
  27         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_NO_PROPAGATE_INHERIT", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT, r);
  28         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERIT_ONLY", SEC_ACE_FLAG_INHERIT_ONLY, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERITED_ACE", SEC_ACE_FLAG_INHERITED_ACE, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_VALID_INHERIT", SEC_ACE_FLAG_VALID_INHERIT, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_SUCCESSFUL_ACCESS", SEC_ACE_FLAG_SUCCESSFUL_ACCESS, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_FAILED_ACCESS", SEC_ACE_FLAG_FAILED_ACCESS, r);
  33         ndr->depth--;
  34 }
  35
  36 _PUBLIC_ enum ndr_err_code ndr_push_security_ace_type(struct ndr_push *ndr, int ndr_flags, enum security_ace_type r)
  37 {
  38         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
  39         return NDR_ERR_SUCCESS;
  40 }
  41
  42 _PUBLIC_ enum ndr_err_code ndr_pull_security_ace_type(struct ndr_pull *ndr, int ndr_flags, enum security_ace_type *r)
  43 {
  44         uint8_t v;
  45         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
  46         *r = v;
  47         return NDR_ERR_SUCCESS;
  48 }
  49
  50 _PUBLIC_ void ndr_print_security_ace_type(struct ndr_print *ndr, const char *name, enum security_ace_type r)
  51 {
  52         const char *val = NULL;
  53
  54         switch (r) {
  55                 case SEC_ACE_TYPE_ACCESS_ALLOWED: val = "SEC_ACE_TYPE_ACCESS_ALLOWED"; break;
  56                 case SEC_ACE_TYPE_ACCESS_DENIED: val = "SEC_ACE_TYPE_ACCESS_DENIED"; break;
  57                 case SEC_ACE_TYPE_SYSTEM_AUDIT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT"; break;
  58                 case SEC_ACE_TYPE_SYSTEM_ALARM: val = "SEC_ACE_TYPE_SYSTEM_ALARM"; break;
  59                 case SEC_ACE_TYPE_ALLOWED_COMPOUND: val = "SEC_ACE_TYPE_ALLOWED_COMPOUND"; break;
  60                 case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT"; break;
  61                 case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_DENIED_OBJECT"; break;
  62                 case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT"; break;
  63                 case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT"; break;
  64         }
  65         ndr_print_enum(ndr, name, "ENUM", val, r);
  66 }
  67
  68 static enum ndr_err_code ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  69 {
  70         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  71         return NDR_ERR_SUCCESS;
  72 }
  73
  74 static enum ndr_err_code ndr_pull_security_ace_object_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  75 {
  76         uint32_t v;
  77         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  78         *r = v;
  79         return NDR_ERR_SUCCESS;
  80 }
  81
  82 _PUBLIC_ void ndr_print_security_ace_object_flags(struct ndr_print *ndr, const char *name, uint32_t r)
  83 {
  84         ndr_print_uint32(ndr, name, r);
  85         ndr->depth++;
  86         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_OBJECT_TYPE_PRESENT", SEC_ACE_OBJECT_TYPE_PRESENT, r);
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT", SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT, r);
  88         ndr->depth--;
  89 }
  90
  91 static enum ndr_err_code ndr_push_security_ace_object_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_type *r)
  92 {
  93         if (ndr_flags & NDR_SCALARS) {
  94                 int level = ndr_push_get_switch_value(ndr, r);
  95                 switch (level) {
  96                         case SEC_ACE_OBJECT_TYPE_PRESENT: {
  97                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->type));
  98                         break; }
  99
 100                         default: {
 101                         break; }
 102
 103                 }
 104         }
 105         if (ndr_flags & NDR_BUFFERS) {
 106                 int level = ndr_push_get_switch_value(ndr, r);
 107                 switch (level) {
 108                         case SEC_ACE_OBJECT_TYPE_PRESENT:
 109                         break;
 110
 111                         default:
 112                         break;
 113
 114                 }
 115         }
 116         return NDR_ERR_SUCCESS;
 117 }
 118
 119 static enum ndr_err_code ndr_pull_security_ace_object_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_type *r)
 120 {
 121         int level;
 122         level = ndr_pull_get_switch_value(ndr, r);
 123         if (ndr_flags & NDR_SCALARS) {
 124                 switch (level) {
 125                         case SEC_ACE_OBJECT_TYPE_PRESENT: {
 126                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->type));
 127                         break; }
 128
 129                         default: {
 130                         break; }
 131
 132                 }
 133         }
 134         if (ndr_flags & NDR_BUFFERS) {
 135                 switch (level) {
 136                         case SEC_ACE_OBJECT_TYPE_PRESENT:
 137                         break;
 138
 139                         default:
 140                         break;
 141
 142                 }
 143         }
 144         return NDR_ERR_SUCCESS;
 145 }
 146
 147 _PUBLIC_ void ndr_print_security_ace_object_type(struct ndr_print *ndr, const char *name, const union security_ace_object_type *r)
 148 {
 149         int level;
 150         level = ndr_print_get_switch_value(ndr, r);
 151         ndr_print_union(ndr, name, level, "security_ace_object_type");
 152         switch (level) {
 153                 case SEC_ACE_OBJECT_TYPE_PRESENT:
 154                         ndr_print_GUID(ndr, "type", &r->type);
 155                 break;
 156
 157                 default:
 158                 break;
 159
 160         }
 161 }
 162
 163 static enum ndr_err_code ndr_push_security_ace_object_inherited_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_inherited_type *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 int level = ndr_push_get_switch_value(ndr, r);
 167                 switch (level) {
 168                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
 169                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 170                         break; }
 171
 172                         default: {
 173                         break; }
 174
 175                 }
 176         }
 177         if (ndr_flags & NDR_BUFFERS) {
 178                 int level = ndr_push_get_switch_value(ndr, r);
 179                 switch (level) {
 180                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 181                         break;
 182
 183                         default:
 184                         break;
 185
 186                 }
 187         }
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 static enum ndr_err_code ndr_pull_security_ace_object_inherited_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_inherited_type *r)
 192 {
 193         int level;
 194         level = ndr_pull_get_switch_value(ndr, r);
 195         if (ndr_flags & NDR_SCALARS) {
 196                 switch (level) {
 197                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
 198                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 199                         break; }
 200
 201                         default: {
 202                         break; }
 203
 204                 }
 205         }
 206         if (ndr_flags & NDR_BUFFERS) {
 207                 switch (level) {
 208                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 209                         break;
 210
 211                         default:
 212                         break;
 213
 214                 }
 215         }
 216         return NDR_ERR_SUCCESS;
 217 }
 218
 219 _PUBLIC_ void ndr_print_security_ace_object_inherited_type(struct ndr_print *ndr, const char *name, const union security_ace_object_inherited_type *r)
 220 {
 221         int level;
 222         level = ndr_print_get_switch_value(ndr, r);
 223         ndr_print_union(ndr, name, level, "security_ace_object_inherited_type");
 224         switch (level) {
 225                 case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 226                         ndr_print_GUID(ndr, "inherited_type", &r->inherited_type);
 227                 break;
 228
 229                 default:
 230                 break;
 231
 232         }
 233 }
 234
 235 static enum ndr_err_code ndr_push_security_ace_object(struct ndr_push *ndr, int ndr_flags, const struct security_ace_object *r)
 236 {
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_push_align(ndr, 4));
 239                 NDR_CHECK(ndr_push_security_ace_object_flags(ndr, NDR_SCALARS, r->flags));
 240                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT));
 241                 NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 242                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 243                 NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 244         }
 245         if (ndr_flags & NDR_BUFFERS) {
 246                 NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 247                 NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 248         }
 249         return NDR_ERR_SUCCESS;
 250 }
 251
 252 static enum ndr_err_code ndr_pull_security_ace_object(struct ndr_pull *ndr, int ndr_flags, struct security_ace_object *r)
 253 {
 254         if (ndr_flags & NDR_SCALARS) {
 255                 NDR_CHECK(ndr_pull_align(ndr, 4));
 256                 NDR_CHECK(ndr_pull_security_ace_object_flags(ndr, NDR_SCALARS, &r->flags));
 257                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT));
 258                 NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 259                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 260                 NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 261         }
 262         if (ndr_flags & NDR_BUFFERS) {
 263                 NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 264                 NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 265         }
 266         return NDR_ERR_SUCCESS;
 267 }
 268
 269 _PUBLIC_ void ndr_print_security_ace_object(struct ndr_print *ndr, const char *name, const struct security_ace_object *r)
 270 {
 271         ndr_print_struct(ndr, name, "security_ace_object");
 272         ndr->depth++;
 273         ndr_print_security_ace_object_flags(ndr, "flags", r->flags);
 274         ndr_print_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT);
 275         ndr_print_security_ace_object_type(ndr, "type", &r->type);
 276         ndr_print_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT);
 277         ndr_print_security_ace_object_inherited_type(ndr, "inherited_type", &r->inherited_type);
 278         ndr->depth--;
 279 }
 280
 281 _PUBLIC_ enum ndr_err_code ndr_push_security_ace_object_ctr(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_ctr *r)
 282 {
 283         if (ndr_flags & NDR_SCALARS) {
 284                 int level = ndr_push_get_switch_value(ndr, r);
 285                 switch (level) {
 286                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
 287                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 288                         break; }
 289
 290                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
 291                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 292                         break; }
 293
 294                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
 295                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 296                         break; }
 297
 298                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
 299                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 300                         break; }
 301
 302                         default: {
 303                         break; }
 304
 305                 }
 306         }
 307         if (ndr_flags & NDR_BUFFERS) {
 308                 int level = ndr_push_get_switch_value(ndr, r);
 309                 switch (level) {
 310                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 311                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 312                         break;
 313
 314                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 315                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 316                         break;
 317
 318                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 319                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 320                         break;
 321
 322                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 323                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 324                         break;
 325
 326                         default:
 327                         break;
 328
 329                 }
 330         }
 331         return NDR_ERR_SUCCESS;
 332 }
 333
 334 _PUBLIC_ enum ndr_err_code ndr_pull_security_ace_object_ctr(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_ctr *r)
 335 {
 336         int level;
 337         level = ndr_pull_get_switch_value(ndr, r);
 338         if (ndr_flags & NDR_SCALARS) {
 339                 switch (level) {
 340                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
 341                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 342                         break; }
 343
 344                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
 345                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 346                         break; }
 347
 348                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
 349                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 350                         break; }
 351
 352                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
 353                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 354                         break; }
 355
 356                         default: {
 357                         break; }
 358
 359                 }
 360         }
 361         if (ndr_flags & NDR_BUFFERS) {
 362                 switch (level) {
 363                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 364                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 365                         break;
 366
 367                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 368                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 369                         break;
 370
 371                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 372                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 373                         break;
 374
 375                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 376                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 377                         break;
 378
 379                         default:
 380                         break;
 381
 382                 }
 383         }
 384         return NDR_ERR_SUCCESS;
 385 }
 386
 387 _PUBLIC_ void ndr_print_security_ace_object_ctr(struct ndr_print *ndr, const char *name, const union security_ace_object_ctr *r)
 388 {
 389         int level;
 390         level = ndr_print_get_switch_value(ndr, r);
 391         ndr_print_union(ndr, name, level, "security_ace_object_ctr");
 392         switch (level) {
 393                 case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 394                         ndr_print_security_ace_object(ndr, "object", &r->object);
 395                 break;
 396
 397                 case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 398                         ndr_print_security_ace_object(ndr, "object", &r->object);
 399                 break;
 400
 401                 case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 402                         ndr_print_security_ace_object(ndr, "object", &r->object);
 403                 break;
 404
 405                 case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 406                         ndr_print_security_ace_object(ndr, "object", &r->object);
 407                 break;
 408
 409                 default:
 410                 break;
 411
 412         }
 413 }
 414
 415 _PUBLIC_ enum ndr_err_code ndr_push_security_ace(struct ndr_push *ndr, int ndr_flags, const struct security_ace *r)
 416 {
 417         if (ndr_flags & NDR_SCALARS) {
 418                 NDR_CHECK(ndr_push_align(ndr, 4));
 419                 NDR_CHECK(ndr_push_security_ace_type(ndr, NDR_SCALARS, r->type));
 420                 NDR_CHECK(ndr_push_security_ace_flags(ndr, NDR_SCALARS, r->flags));
 421                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_ace(r, ndr->iconv_convenience, ndr->flags)));
 422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->access_mask));
 423                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->type));
 424                 NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
 425                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->trustee));
 426         }
 427         if (ndr_flags & NDR_BUFFERS) {
 428                 NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
 429         }
 430         return NDR_ERR_SUCCESS;
 431 }
 432
 433 _PUBLIC_ void ndr_print_security_ace(struct ndr_print *ndr, const char *name, const struct security_ace *r)
 434 {
 435         ndr_print_struct(ndr, name, "security_ace");
 436         ndr->depth++;
 437         ndr_print_security_ace_type(ndr, "type", r->type);
 438         ndr_print_security_ace_flags(ndr, "flags", r->flags);
 439         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_ace(r, ndr->iconv_convenience, ndr->flags):r->size);
 440         ndr_print_uint32(ndr, "access_mask", r->access_mask);
 441         ndr_print_set_switch_value(ndr, &r->object, r->type);
 442         ndr_print_security_ace_object_ctr(ndr, "object", &r->object);
 443         ndr_print_dom_sid(ndr, "trustee", &r->trustee);
 444         ndr->depth--;
 445 }
 446
 447 static enum ndr_err_code ndr_push_security_acl_revision(struct ndr_push *ndr, int ndr_flags, enum security_acl_revision r)
 448 {
 449         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 450         return NDR_ERR_SUCCESS;
 451 }
 452
 453 static enum ndr_err_code ndr_pull_security_acl_revision(struct ndr_pull *ndr, int ndr_flags, enum security_acl_revision *r)
 454 {
 455         uint16_t v;
 456         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 457         *r = v;
 458         return NDR_ERR_SUCCESS;
 459 }
 460
 461 _PUBLIC_ void ndr_print_security_acl_revision(struct ndr_print *ndr, const char *name, enum security_acl_revision r)
 462 {
 463         const char *val = NULL;
 464
 465         switch (r) {
 466                 case SECURITY_ACL_REVISION_NT4: val = "SECURITY_ACL_REVISION_NT4"; break;
 467                 case SECURITY_ACL_REVISION_ADS: val = "SECURITY_ACL_REVISION_ADS"; break;
 468         }
 469         ndr_print_enum(ndr, name, "ENUM", val, r);
 470 }
 471
 472 _PUBLIC_ enum ndr_err_code ndr_push_security_acl(struct ndr_push *ndr, int ndr_flags, const struct security_acl *r)
 473 {
 474         uint32_t cntr_aces_0;
 475         if (ndr_flags & NDR_SCALARS) {
 476                 NDR_CHECK(ndr_push_align(ndr, 4));
 477                 NDR_CHECK(ndr_push_security_acl_revision(ndr, NDR_SCALARS, r->revision));
 478                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_acl(r, ndr->iconv_convenience, ndr->flags)));
 479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aces));
 480                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 481                         NDR_CHECK(ndr_push_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 482                 }
 483         }
 484         if (ndr_flags & NDR_BUFFERS) {
 485                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 486                         NDR_CHECK(ndr_push_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 487                 }
 488         }
 489         return NDR_ERR_SUCCESS;
 490 }
 491
 492 _PUBLIC_ enum ndr_err_code ndr_pull_security_acl(struct ndr_pull *ndr, int ndr_flags, struct security_acl *r)
 493 {
 494         uint32_t cntr_aces_0;
 495         TALLOC_CTX *_mem_save_aces_0;
 496         if (ndr_flags & NDR_SCALARS) {
 497                 NDR_CHECK(ndr_pull_align(ndr, 4));
 498                 NDR_CHECK(ndr_pull_security_acl_revision(ndr, NDR_SCALARS, &r->revision));
 499                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aces));
 501                 if (r->num_aces > 1000) {
 502                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 503                 }
 504                 NDR_PULL_ALLOC_N(ndr, r->aces, r->num_aces);
 505                 _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 506                 NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 507                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 508                         NDR_CHECK(ndr_pull_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 509                 }
 510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 511         }
 512         if (ndr_flags & NDR_BUFFERS) {
 513                 _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 514                 NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 515                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 516                         NDR_CHECK(ndr_pull_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 517                 }
 518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 519         }
 520         return NDR_ERR_SUCCESS;
 521 }
 522
 523 _PUBLIC_ void ndr_print_security_acl(struct ndr_print *ndr, const char *name, const struct security_acl *r)
 524 {
 525         uint32_t cntr_aces_0;
 526         ndr_print_struct(ndr, name, "security_acl");
 527         ndr->depth++;
 528         ndr_print_security_acl_revision(ndr, "revision", r->revision);
 529         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_acl(r, ndr->iconv_convenience, ndr->flags):r->size);
 530         ndr_print_uint32(ndr, "num_aces", r->num_aces);
 531         ndr->print(ndr, "%s: ARRAY(%d)", "aces", (int)r->num_aces);
 532         ndr->depth++;
 533         for (cntr_aces_0=0;cntr_aces_0<r->num_aces;cntr_aces_0++) {
 534                 char *idx_0=NULL;
 535                 if (asprintf(&idx_0, "[%d]", cntr_aces_0) != -1) {
 536                         ndr_print_security_ace(ndr, "aces", &r->aces[cntr_aces_0]);
 537                         free(idx_0);
 538                 }
 539         }
 540         ndr->depth--;
 541         ndr->depth--;
 542 }
 543
 544 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_revision(struct ndr_push *ndr, int ndr_flags, enum security_descriptor_revision r)
 545 {
 546         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 547         return NDR_ERR_SUCCESS;
 548 }
 549
 550 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_revision(struct ndr_pull *ndr, int ndr_flags, enum security_descriptor_revision *r)
 551 {
 552         uint8_t v;
 553         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 554         *r = v;
 555         return NDR_ERR_SUCCESS;
 556 }
 557
 558 _PUBLIC_ void ndr_print_security_descriptor_revision(struct ndr_print *ndr, const char *name, enum security_descriptor_revision r)
 559 {
 560         const char *val = NULL;
 561
 562         switch (r) {
 563                 case SECURITY_DESCRIPTOR_REVISION_1: val = "SECURITY_DESCRIPTOR_REVISION_1"; break;
 564         }
 565         ndr_print_enum(ndr, name, "ENUM", val, r);
 566 }
 567
 568 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_type(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 569 {
 570         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_type(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 575 {
 576         uint16_t v;
 577         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 578         *r = v;
 579         return NDR_ERR_SUCCESS;
 580 }
 581
 582 _PUBLIC_ void ndr_print_security_descriptor_type(struct ndr_print *ndr, const char *name, uint16_t r)
 583 {
 584         ndr_print_uint16(ndr, name, r);
 585         ndr->depth++;
 586         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_OWNER_DEFAULTED", SEC_DESC_OWNER_DEFAULTED, r);
 587         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_GROUP_DEFAULTED", SEC_DESC_GROUP_DEFAULTED, r);
 588         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PRESENT", SEC_DESC_DACL_PRESENT, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_DEFAULTED", SEC_DESC_DACL_DEFAULTED, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PRESENT", SEC_DESC_SACL_PRESENT, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_DEFAULTED", SEC_DESC_SACL_DEFAULTED, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_TRUSTED", SEC_DESC_DACL_TRUSTED, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SERVER_SECURITY", SEC_DESC_SERVER_SECURITY, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERIT_REQ", SEC_DESC_DACL_AUTO_INHERIT_REQ, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERIT_REQ", SEC_DESC_SACL_AUTO_INHERIT_REQ, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERITED", SEC_DESC_DACL_AUTO_INHERITED, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERITED", SEC_DESC_SACL_AUTO_INHERITED, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PROTECTED", SEC_DESC_DACL_PROTECTED, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PROTECTED", SEC_DESC_SACL_PROTECTED, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_RM_CONTROL_VALID", SEC_DESC_RM_CONTROL_VALID, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SELF_RELATIVE", SEC_DESC_SELF_RELATIVE, r);
 602         ndr->depth--;
 603 }
 604
 605 _PUBLIC_ enum ndr_err_code ndr_push_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
 606 {
 607         {
 608                 uint32_t _flags_save_STRUCT = ndr->flags;
 609                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 610                 if (ndr_flags & NDR_SCALARS) {
 611                         NDR_CHECK(ndr_push_align(ndr, 4));
 612                         NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
 613                         NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
 614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
 615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
 616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
 617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
 618                 }
 619                 if (ndr_flags & NDR_BUFFERS) {
 620                         if (r->owner_sid) {
 621                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->owner_sid));
 622                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 623                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->owner_sid));
 624                         }
 625                         if (r->group_sid) {
 626                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->group_sid));
 627                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 628                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->group_sid));
 629                         }
 630                         if (r->sacl) {
 631                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sacl));
 632                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 633                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sacl));
 634                         }
 635                         if (r->dacl) {
 636                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dacl));
 637                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 638                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dacl));
 639                         }
 640                 }
 641                 ndr->flags = _flags_save_STRUCT;
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
 647 {
 648         uint32_t _ptr_owner_sid;
 649         TALLOC_CTX *_mem_save_owner_sid_0;
 650         uint32_t _ptr_group_sid;
 651         TALLOC_CTX *_mem_save_group_sid_0;
 652         uint32_t _ptr_sacl;
 653         TALLOC_CTX *_mem_save_sacl_0;
 654         uint32_t _ptr_dacl;
 655         TALLOC_CTX *_mem_save_dacl_0;
 656         {
 657                 uint32_t _flags_save_STRUCT = ndr->flags;
 658                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 659                 if (ndr_flags & NDR_SCALARS) {
 660                         NDR_CHECK(ndr_pull_align(ndr, 4));
 661                         NDR_CHECK(ndr_pull_security_descriptor_revision(ndr, NDR_SCALARS, &r->revision));
 662                         NDR_CHECK(ndr_pull_security_descriptor_type(ndr, NDR_SCALARS, &r->type));
 663                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_owner_sid));
 664                         if (_ptr_owner_sid) {
 665                                 NDR_PULL_ALLOC(ndr, r->owner_sid);
 666                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->owner_sid, _ptr_owner_sid));
 667                         } else {
 668                                 r->owner_sid = NULL;
 669                         }
 670                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
 671                         if (_ptr_group_sid) {
 672                                 NDR_PULL_ALLOC(ndr, r->group_sid);
 673                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->group_sid, _ptr_group_sid));
 674                         } else {
 675                                 r->group_sid = NULL;
 676                         }
 677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sacl));
 678                         if (_ptr_sacl) {
 679                                 NDR_PULL_ALLOC(ndr, r->sacl);
 680                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sacl, _ptr_sacl));
 681                         } else {
 682                                 r->sacl = NULL;
 683                         }
 684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dacl));
 685                         if (_ptr_dacl) {
 686                                 NDR_PULL_ALLOC(ndr, r->dacl);
 687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dacl, _ptr_dacl));
 688                         } else {
 689                                 r->dacl = NULL;
 690                         }
 691                 }
 692                 if (ndr_flags & NDR_BUFFERS) {
 693                         if (r->owner_sid) {
 694                                 uint32_t _relative_save_offset;
 695                                 _relative_save_offset = ndr->offset;
 696                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->owner_sid));
 697                                 _mem_save_owner_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 698                                 NDR_PULL_SET_MEM_CTX(ndr, r->owner_sid, 0);
 699                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 700                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_owner_sid_0, 0);
 701                                 ndr->offset = _relative_save_offset;
 702                         }
 703                         if (r->group_sid) {
 704                                 uint32_t _relative_save_offset;
 705                                 _relative_save_offset = ndr->offset;
 706                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->group_sid));
 707                                 _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 708                                 NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
 709                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 710                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
 711                                 ndr->offset = _relative_save_offset;
 712                         }
 713                         if (r->sacl) {
 714                                 uint32_t _relative_save_offset;
 715                                 _relative_save_offset = ndr->offset;
 716                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sacl));
 717                                 _mem_save_sacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 718                                 NDR_PULL_SET_MEM_CTX(ndr, r->sacl, 0);
 719                                 NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 720                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sacl_0, 0);
 721                                 ndr->offset = _relative_save_offset;
 722                         }
 723                         if (r->dacl) {
 724                                 uint32_t _relative_save_offset;
 725                                 _relative_save_offset = ndr->offset;
 726                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dacl));
 727                                 _mem_save_dacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 728                                 NDR_PULL_SET_MEM_CTX(ndr, r->dacl, 0);
 729                                 NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 730                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dacl_0, 0);
 731                                 ndr->offset = _relative_save_offset;
 732                         }
 733                 }
 734                 ndr->flags = _flags_save_STRUCT;
 735         }
 736         return NDR_ERR_SUCCESS;
 737 }
 738
 739 _PUBLIC_ void ndr_print_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
 740 {
 741         ndr_print_struct(ndr, name, "security_descriptor");
 742         {
 743                 uint32_t _flags_save_STRUCT = ndr->flags;
 744                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 745                 ndr->depth++;
 746                 ndr_print_security_descriptor_revision(ndr, "revision", r->revision);
 747                 ndr_print_security_descriptor_type(ndr, "type", r->type);
 748                 ndr_print_ptr(ndr, "owner_sid", r->owner_sid);
 749                 ndr->depth++;
 750                 if (r->owner_sid) {
 751                         ndr_print_dom_sid(ndr, "owner_sid", r->owner_sid);
 752                 }
 753                 ndr->depth--;
 754                 ndr_print_ptr(ndr, "group_sid", r->group_sid);
 755                 ndr->depth++;
 756                 if (r->group_sid) {
 757                         ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
 758                 }
 759                 ndr->depth--;
 760                 ndr_print_ptr(ndr, "sacl", r->sacl);
 761                 ndr->depth++;
 762                 if (r->sacl) {
 763                         ndr_print_security_acl(ndr, "sacl", r->sacl);
 764                 }
 765                 ndr->depth--;
 766                 ndr_print_ptr(ndr, "dacl", r->dacl);
 767                 ndr->depth++;
 768                 if (r->dacl) {
 769                         ndr_print_security_acl(ndr, "dacl", r->dacl);
 770                 }
 771                 ndr->depth--;
 772                 ndr->depth--;
 773                 ndr->flags = _flags_save_STRUCT;
 774         }
 775 }
 776
 777 _PUBLIC_ enum ndr_err_code ndr_push_sec_desc_buf(struct ndr_push *ndr, int ndr_flags, const struct sec_desc_buf *r)
 778 {
 779         if (ndr_flags & NDR_SCALARS) {
 780                 NDR_CHECK(ndr_push_align(ndr, 4));
 781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_security_descriptor(r->sd, ndr->iconv_convenience, ndr->flags)));
 782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 783         }
 784         if (ndr_flags & NDR_BUFFERS) {
 785                 if (r->sd) {
 786                         {
 787                                 struct ndr_push *_ndr_sd;
 788                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sd, 4, -1));
 789                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
 790                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sd, 4, -1));
 791                         }
 792                 }
 793         }
 794         return NDR_ERR_SUCCESS;
 795 }
 796
 797 _PUBLIC_ enum ndr_err_code ndr_pull_sec_desc_buf(struct ndr_pull *ndr, int ndr_flags, struct sec_desc_buf *r)
 798 {
 799         uint32_t _ptr_sd;
 800         TALLOC_CTX *_mem_save_sd_0;
 801         if (ndr_flags & NDR_SCALARS) {
 802                 NDR_CHECK(ndr_pull_align(ndr, 4));
 803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sd_size));
 804                 if (r->sd_size > 0x40000) {
 805                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 806                 }
 807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 808                 if (_ptr_sd) {
 809                         NDR_PULL_ALLOC(ndr, r->sd);
 810                 } else {
 811                         r->sd = NULL;
 812                 }
 813         }
 814         if (ndr_flags & NDR_BUFFERS) {
 815                 if (r->sd) {
 816                         _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 817                         NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 818                         {
 819                                 struct ndr_pull *_ndr_sd;
 820                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sd, 4, -1));
 821                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
 822                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sd, 4, -1));
 823                         }
 824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 825                 }
 826         }
 827         return NDR_ERR_SUCCESS;
 828 }
 829
 830 _PUBLIC_ void ndr_print_sec_desc_buf(struct ndr_print *ndr, const char *name, const struct sec_desc_buf *r)
 831 {
 832         ndr_print_struct(ndr, name, "sec_desc_buf");
 833         ndr->depth++;
 834         ndr_print_uint32(ndr, "sd_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_descriptor(r->sd, ndr->iconv_convenience, ndr->flags):r->sd_size);
 835         ndr_print_ptr(ndr, "sd", r->sd);
 836         ndr->depth++;
 837         if (r->sd) {
 838                 ndr_print_security_descriptor(ndr, "sd", r->sd);
 839         }
 840         ndr->depth--;
 841         ndr->depth--;
 842 }
 843
 844 _PUBLIC_ enum ndr_err_code ndr_push_security_token(struct ndr_push *ndr, int ndr_flags, const struct security_token *r)
 845 {
 846         uint32_t cntr_sids_0;
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_push_align(ndr, 4));
 849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_sid));
 850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_sid));
 851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 853                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 854                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_0]));
 855                 }
 856                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->privilege_mask));
 857         }
 858         if (ndr_flags & NDR_BUFFERS) {
 859                 if (r->user_sid) {
 860                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->user_sid));
 861                 }
 862                 if (r->group_sid) {
 863                         NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 864                 }
 865                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 866                         if (r->sids[cntr_sids_0]) {
 867                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->sids[cntr_sids_0]));
 868                         }
 869                 }
 870         }
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ enum ndr_err_code ndr_pull_security_token(struct ndr_pull *ndr, int ndr_flags, struct security_token *r)
 875 {
 876         uint32_t _ptr_user_sid;
 877         TALLOC_CTX *_mem_save_user_sid_0;
 878         uint32_t _ptr_group_sid;
 879         TALLOC_CTX *_mem_save_group_sid_0;
 880         uint32_t _ptr_sids;
 881         uint32_t cntr_sids_0;
 882         TALLOC_CTX *_mem_save_sids_0;
 883         TALLOC_CTX *_mem_save_sids_1;
 884         if (ndr_flags & NDR_SCALARS) {
 885                 NDR_CHECK(ndr_pull_align(ndr, 4));
 886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
 887                 if (_ptr_user_sid) {
 888                         NDR_PULL_ALLOC(ndr, r->user_sid);
 889                 } else {
 890                         r->user_sid = NULL;
 891                 }
 892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
 893                 if (_ptr_group_sid) {
 894                         NDR_PULL_ALLOC(ndr, r->group_sid);
 895                 } else {
 896                         r->group_sid = NULL;
 897                 }
 898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
 899                 NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
 900                 NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
 901                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 902                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 903                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
 905                         if (_ptr_sids) {
 906                                 NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_0]);
 907                         } else {
 908                                 r->sids[cntr_sids_0] = NULL;
 909                         }
 910                 }
 911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 912                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->privilege_mask));
 913                 if (r->sids) {
 914                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
 915                 }
 916         }
 917         if (ndr_flags & NDR_BUFFERS) {
 918                 if (r->user_sid) {
 919                         _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 920                         NDR_PULL_SET_MEM_CTX(ndr, r->user_sid, 0);
 921                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->user_sid));
 922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
 923                 }
 924                 if (r->group_sid) {
 925                         _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 926                         NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
 927                         NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
 929                 }
 930                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 931                 NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 932                 for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 933                         if (r->sids[cntr_sids_0]) {
 934                                 _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 935                                 NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_0], 0);
 936                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->sids[cntr_sids_0]));
 937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
 938                         }
 939                 }
 940                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 941         }
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 _PUBLIC_ void ndr_print_security_token(struct ndr_print *ndr, const char *name, const struct security_token *r)
 946 {
 947         uint32_t cntr_sids_0;
 948         ndr_print_struct(ndr, name, "security_token");
 949         ndr->depth++;
 950         ndr_print_ptr(ndr, "user_sid", r->user_sid);
 951         ndr->depth++;
 952         if (r->user_sid) {
 953                 ndr_print_dom_sid(ndr, "user_sid", r->user_sid);
 954         }
 955         ndr->depth--;
 956         ndr_print_ptr(ndr, "group_sid", r->group_sid);
 957         ndr->depth++;
 958         if (r->group_sid) {
 959                 ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
 960         }
 961         ndr->depth--;
 962         ndr_print_uint32(ndr, "num_sids", r->num_sids);
 963         ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
 964         ndr->depth++;
 965         for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
 966                 char *idx_0=NULL;
 967                 if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
 968                         ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_0]);
 969                         ndr->depth++;
 970                         if (r->sids[cntr_sids_0]) {
 971                                 ndr_print_dom_sid(ndr, "sids", r->sids[cntr_sids_0]);
 972                         }
 973                         ndr->depth--;
 974                         free(idx_0);
 975                 }
 976         }
 977         ndr->depth--;
 978         ndr_print_udlong(ndr, "privilege_mask", r->privilege_mask);
 979         ndr->depth--;
 980 }
 981
 982 _PUBLIC_ enum ndr_err_code ndr_push_security_secinfo(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 983 {
 984         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 985         return NDR_ERR_SUCCESS;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_pull_security_secinfo(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 989 {
 990         uint32_t v;
 991         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 992         *r = v;
 993         return NDR_ERR_SUCCESS;
 994 }
 995
 996 _PUBLIC_ void ndr_print_security_secinfo(struct ndr_print *ndr, const char *name, uint32_t r)
 997 {
 998         ndr_print_uint32(ndr, name, r);
 999         ndr->depth++;
1000         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_OWNER", SECINFO_OWNER, r);
1001         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_GROUP", SECINFO_GROUP, r);
1002         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_DACL", SECINFO_DACL, r);
1003         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_SACL", SECINFO_SACL, r);
1004         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_UNPROTECTED_SACL", SECINFO_UNPROTECTED_SACL, r);
1005         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_UNPROTECTED_DACL", SECINFO_UNPROTECTED_DACL, r);
1006         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_PROTECTED_SACL", SECINFO_PROTECTED_SACL, r);
1007         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_PROTECTED_DACL", SECINFO_PROTECTED_DACL, r);
1008         ndr->depth--;
1009 }
1010
1011 _PUBLIC_ enum ndr_err_code ndr_push_kerb_EncTypes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1012 {
1013         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 _PUBLIC_ enum ndr_err_code ndr_pull_kerb_EncTypes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1018 {
1019         uint32_t v;
1020         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1021         *r = v;
1022         return NDR_ERR_SUCCESS;
1023 }
1024
1025 _PUBLIC_ void ndr_print_kerb_EncTypes(struct ndr_print *ndr, const char *name, uint32_t r)
1026 {
1027         ndr_print_uint32(ndr, name, r);
1028         ndr->depth++;
1029         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_DES_CBC_CRC", KERB_ENCTYPE_DES_CBC_CRC, r);
1030         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_DES_CBC_MD5", KERB_ENCTYPE_DES_CBC_MD5, r);
1031         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_RC4_HMAC_MD5", KERB_ENCTYPE_RC4_HMAC_MD5, r);
1032         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_AES128_CTS_HMAC_SHA1_96", KERB_ENCTYPE_AES128_CTS_HMAC_SHA1_96, r);
1033         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96", KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96, r);
1034         ndr->depth--;
1035 }
1036