source/librpc/ndr/ndr_sec_helper.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    fast routines for getting the wire size of security objects
   5
   6    Copyright (C) Andrew Tridgell 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24 #include "includes.h"
  25
  26 /*
  27   return the wire size of a dom_sid
  28 */
  29 size_t ndr_size_dom_sid(const struct dom_sid *sid, int flags)
  30 {
  31         if (!sid) return 0;
  32         return 8 + 4*sid->num_auths;
  33 }
  34
  35 /*
  36   return the wire size of a security_ace
  37 */
  38 size_t ndr_size_security_ace(const struct security_ace *ace, int flags)
  39 {
  40         if (!ace) return 0;
  41         return 8 + ndr_size_dom_sid(&ace->trustee, flags);
  42 }
  43
  44
  45 /*
  46   return the wire size of a security_acl
  47 */
  48 size_t ndr_size_security_acl(const struct security_acl *acl, int flags)
  49 {
  50         size_t ret;
  51         int i;
  52         if (!acl) return 0;
  53         ret = 8;
  54         for (i=0;i<acl->num_aces;i++) {
  55                 ret += ndr_size_security_ace(&acl->aces[i], flags);
  56         }
  57         return ret;
  58 }
  59
  60 /*
  61   return the wire size of a security descriptor
  62 */
  63 size_t ndr_size_security_descriptor(const struct security_descriptor *sd, int flags)
  64 {
  65         size_t ret;
  66         if (!sd) return 0;
  67
  68         ret = 20;
  69         ret += ndr_size_dom_sid(sd->owner_sid, flags);
  70         ret += ndr_size_dom_sid(sd->group_sid, flags);
  71         ret += ndr_size_security_acl(sd->dacl, flags);
  72         ret += ndr_size_security_acl(sd->sacl, flags);
  73         return ret;
  74 }
  75
  76 /*
  77   print a dom_sid
  78 */
  79 void ndr_print_dom_sid(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
  80 {
  81         ndr->print(ndr, "%-25s: %s", name, dom_sid_string(ndr, sid));
  82 }
  83
  84 void ndr_print_dom_sid2(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
  85 {
  86         ndr_print_dom_sid(ndr, name, sid);
  87 }
  88
  89 void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
  90 {
  91         ndr_print_dom_sid(ndr, name, sid);
  92 }
  93
  94 static NTSTATUS ndr_push_security_ace_flags(struct ndr_push *ndr, int ndr_flags, uint8_t r)
  95 {
  96         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
  97         return NT_STATUS_OK;
  98 }
  99
 100 static NTSTATUS ndr_pull_security_ace_flags(struct ndr_pull *ndr, int ndr_flags, uint8_t *r)
 101 {
 102         uint8_t v;
 103         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 104         *r = v;
 105         return NT_STATUS_OK;
 106 }
 107
 108 void ndr_print_security_ace_flags(struct ndr_print *ndr, const char *name, uint8_t r)
 109 {
 110         ndr_print_uint8(ndr, name, r);
 111         ndr->depth++;
 112         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_OBJECT_INHERIT", SEC_ACE_FLAG_OBJECT_INHERIT, r);
 113         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_CONTAINER_INHERIT", SEC_ACE_FLAG_CONTAINER_INHERIT, r);
 114         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_NO_PROPAGATE_INHERIT", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT, r);
 115         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERIT_ONLY", SEC_ACE_FLAG_INHERIT_ONLY, r);
 116         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERITED_ACE", SEC_ACE_FLAG_INHERITED_ACE, r);
 117         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_VALID_INHERIT", SEC_ACE_FLAG_VALID_INHERIT, r);
 118         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_SUCCESSFUL_ACCESS", SEC_ACE_FLAG_SUCCESSFUL_ACCESS, r);
 119         ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_FAILED_ACCESS", SEC_ACE_FLAG_FAILED_ACCESS, r);
 120         ndr->depth--;
 121 }
 122
 123 static NTSTATUS ndr_push_security_ace_type(struct ndr_push *ndr, int ndr_flags, enum security_ace_type r)
 124 {
 125         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 126         return NT_STATUS_OK;
 127 }
 128
 129 static NTSTATUS ndr_pull_security_ace_type(struct ndr_pull *ndr, int ndr_flags, enum security_ace_type *r)
 130 {
 131         uint8_t v;
 132         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 133         *r = (enum security_ace_type)v;
 134         return NT_STATUS_OK;
 135 }
 136
 137 void ndr_print_security_ace_type(struct ndr_print *ndr, const char *name, enum security_ace_type r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case SEC_ACE_TYPE_ACCESS_ALLOWED: val = "SEC_ACE_TYPE_ACCESS_ALLOWED"; break;
 143                 case SEC_ACE_TYPE_ACCESS_DENIED: val = "SEC_ACE_TYPE_ACCESS_DENIED"; break;
 144                 case SEC_ACE_TYPE_SYSTEM_AUDIT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT"; break;
 145                 case SEC_ACE_TYPE_SYSTEM_ALARM: val = "SEC_ACE_TYPE_SYSTEM_ALARM"; break;
 146                 case SEC_ACE_TYPE_ALLOWED_COMPOUND: val = "SEC_ACE_TYPE_ALLOWED_COMPOUND"; break;
 147                 case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT"; break;
 148                 case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_DENIED_OBJECT"; break;
 149                 case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT"; break;
 150                 case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT"; break;
 151         }
 152         ndr_print_enum(ndr, name, "ENUM", val, r);
 153 }
 154
 155 static NTSTATUS ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 156 {
 157         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 158         return NT_STATUS_OK;
 159 }
 160
 161 static NTSTATUS ndr_pull_security_ace_object_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 162 {
 163         uint32_t v;
 164         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 165         *r = v;
 166         return NT_STATUS_OK;
 167 }
 168
 169 void ndr_print_security_ace_object_flags(struct ndr_print *ndr, const char *name, uint32_t r)
 170 {
 171         ndr_print_uint32(ndr, name, r);
 172         ndr->depth++;
 173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_OBJECT_TYPE_PRESENT", SEC_ACE_OBJECT_TYPE_PRESENT, r);
 174         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT", SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT, r);
 175         ndr->depth--;
 176 }
 177
 178 static NTSTATUS ndr_push_security_ace_object_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_type *r)
 179 {
 180         int level;
 181         level = ndr_push_get_switch_value(ndr, r);
 182         if (ndr_flags & NDR_SCALARS) {
 183                 switch (level) {
 184                         case SEC_ACE_OBJECT_TYPE_PRESENT:
 185                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->type));
 186                         break;
 187
 188                         default:
 189                         break;
 190
 191                 }
 192         }
 193         if (ndr_flags & NDR_BUFFERS) {
 194                 switch (level) {
 195                         case SEC_ACE_OBJECT_TYPE_PRESENT:
 196                         break;
 197
 198                         default:
 199                         break;
 200
 201                 }
 202         }
 203         return NT_STATUS_OK;
 204 }
 205
 206 static NTSTATUS ndr_pull_security_ace_object_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_type *r)
 207 {
 208         int level;
 209         level = ndr_pull_get_switch_value(ndr, r);
 210         if (ndr_flags & NDR_SCALARS) {
 211                 switch (level) {
 212                         case SEC_ACE_OBJECT_TYPE_PRESENT: {
 213                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->type));
 214                         break; }
 215
 216                         default: {
 217                         break; }
 218
 219                 }
 220         }
 221         if (ndr_flags & NDR_BUFFERS) {
 222                 switch (level) {
 223                         case SEC_ACE_OBJECT_TYPE_PRESENT:
 224                         break;
 225
 226                         default:
 227                         break;
 228
 229                 }
 230         }
 231         return NT_STATUS_OK;
 232 }
 233
 234 void ndr_print_security_ace_object_type(struct ndr_print *ndr, const char *name, const union security_ace_object_type *r)
 235 {
 236         int level;
 237         level = ndr_print_get_switch_value(ndr, r);
 238         ndr_print_union(ndr, name, level, "security_ace_object_type");
 239         switch (level) {
 240                 case SEC_ACE_OBJECT_TYPE_PRESENT:
 241                         ndr_print_GUID(ndr, "type", &r->type);
 242                 break;
 243
 244                 default:
 245                 break;
 246
 247         }
 248 }
 249
 250 static NTSTATUS ndr_push_security_ace_object_inherited_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_inherited_type *r)
 251 {
 252         int level;
 253         level = ndr_push_get_switch_value(ndr, r);
 254         if (ndr_flags & NDR_SCALARS) {
 255                 switch (level) {
 256                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 257                                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 258                         break;
 259
 260                         default:
 261                         break;
 262
 263                 }
 264         }
 265         if (ndr_flags & NDR_BUFFERS) {
 266                 switch (level) {
 267                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 268                         break;
 269
 270                         default:
 271                         break;
 272
 273                 }
 274         }
 275         return NT_STATUS_OK;
 276 }
 277
 278 static NTSTATUS ndr_pull_security_ace_object_inherited_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_inherited_type *r)
 279 {
 280         int level;
 281         level = ndr_pull_get_switch_value(ndr, r);
 282         if (ndr_flags & NDR_SCALARS) {
 283                 switch (level) {
 284                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
 285                                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 286                         break; }
 287
 288                         default: {
 289                         break; }
 290
 291                 }
 292         }
 293         if (ndr_flags & NDR_BUFFERS) {
 294                 switch (level) {
 295                         case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 296                         break;
 297
 298                         default:
 299                         break;
 300
 301                 }
 302         }
 303         return NT_STATUS_OK;
 304 }
 305
 306 void ndr_print_security_ace_object_inherited_type(struct ndr_print *ndr, const char *name, const union security_ace_object_inherited_type *r)
 307 {
 308         int level;
 309         level = ndr_print_get_switch_value(ndr, r);
 310         ndr_print_union(ndr, name, level, "security_ace_object_inherited_type");
 311         switch (level) {
 312                 case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 313                         ndr_print_GUID(ndr, "inherited_type", &r->inherited_type);
 314                 break;
 315
 316                 default:
 317                 break;
 318
 319         }
 320 }
 321
 322 static NTSTATUS ndr_push_security_ace_object(struct ndr_push *ndr, int ndr_flags, const struct security_ace_object *r)
 323 {
 324         if (ndr_flags & NDR_SCALARS) {
 325                 NDR_CHECK(ndr_push_align(ndr, 4));
 326                 NDR_CHECK(ndr_push_security_ace_object_flags(ndr, NDR_SCALARS, r->flags));
 327                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT));
 328                 NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 329                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 330                 NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 331         }
 332         if (ndr_flags & NDR_BUFFERS) {
 333                 NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 334                 NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 335         }
 336         return NT_STATUS_OK;
 337 }
 338
 339 static NTSTATUS ndr_pull_security_ace_object(struct ndr_pull *ndr, int ndr_flags, struct security_ace_object *r)
 340 {
 341         if (ndr_flags & NDR_SCALARS) {
 342                 NDR_CHECK(ndr_pull_align(ndr, 4));
 343                 NDR_CHECK(ndr_pull_security_ace_object_flags(ndr, NDR_SCALARS, &r->flags));
 344                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT));
 345                 NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 346                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 347                 NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 348         }
 349         if (ndr_flags & NDR_BUFFERS) {
 350                 NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 351                 NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 352         }
 353         return NT_STATUS_OK;
 354 }
 355
 356 void ndr_print_security_ace_object(struct ndr_print *ndr, const char *name, const struct security_ace_object *r)
 357 {
 358         ndr_print_struct(ndr, name, "security_ace_object");
 359         ndr->depth++;
 360         ndr_print_security_ace_object_flags(ndr, "flags", r->flags);
 361         ndr_print_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT);
 362         ndr_print_security_ace_object_type(ndr, "type", &r->type);
 363         ndr_print_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT);
 364         ndr_print_security_ace_object_inherited_type(ndr, "inherited_type", &r->inherited_type);
 365         ndr->depth--;
 366 }
 367
 368 static NTSTATUS ndr_push_security_ace_object_ctr(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_ctr *r)
 369 {
 370         int level;
 371         level = ndr_push_get_switch_value(ndr, r);
 372         if (ndr_flags & NDR_SCALARS) {
 373                 switch (level) {
 374                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 375                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 376                         break;
 377
 378                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 379                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 380                         break;
 381
 382                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 383                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 384                         break;
 385
 386                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 387                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 388                         break;
 389
 390                         default:
 391                         break;
 392
 393                 }
 394         }
 395         if (ndr_flags & NDR_BUFFERS) {
 396                 switch (level) {
 397                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 398                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 399                         break;
 400
 401                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 402                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 403                         break;
 404
 405                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 406                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 407                         break;
 408
 409                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 410                                 NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 411                         break;
 412
 413                         default:
 414                         break;
 415
 416                 }
 417         }
 418         return NT_STATUS_OK;
 419 }
 420
 421 static NTSTATUS ndr_pull_security_ace_object_ctr(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_ctr *r)
 422 {
 423         int level;
 424         level = ndr_pull_get_switch_value(ndr, r);
 425         if (ndr_flags & NDR_SCALARS) {
 426                 switch (level) {
 427                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
 428                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 429                         break; }
 430
 431                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
 432                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 433                         break; }
 434
 435                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
 436                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 437                         break; }
 438
 439                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
 440                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 441                         break; }
 442
 443                         default: {
 444                         break; }
 445
 446                 }
 447         }
 448         if (ndr_flags & NDR_BUFFERS) {
 449                 switch (level) {
 450                         case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 451                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 452                         break;
 453
 454                         case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 455                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 456                         break;
 457
 458                         case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 459                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 460                         break;
 461
 462                         case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 463                                 NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 464                         break;
 465
 466                         default:
 467                         break;
 468
 469                 }
 470         }
 471         return NT_STATUS_OK;
 472 }
 473
 474 void ndr_print_security_ace_object_ctr(struct ndr_print *ndr, const char *name, const union security_ace_object_ctr *r)
 475 {
 476         int level;
 477         level = ndr_print_get_switch_value(ndr, r);
 478         ndr_print_union(ndr, name, level, "security_ace_object_ctr");
 479         switch (level) {
 480                 case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 481                         ndr_print_security_ace_object(ndr, "object", &r->object);
 482                 break;
 483
 484                 case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 485                         ndr_print_security_ace_object(ndr, "object", &r->object);
 486                 break;
 487
 488                 case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 489                         ndr_print_security_ace_object(ndr, "object", &r->object);
 490                 break;
 491
 492                 case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 493                         ndr_print_security_ace_object(ndr, "object", &r->object);
 494                 break;
 495
 496                 default:
 497                 break;
 498
 499         }
 500 }
 501
 502 NTSTATUS ndr_push_security_ace(struct ndr_push *ndr, int ndr_flags, const struct security_ace *r)
 503 {
 504         if (ndr_flags & NDR_SCALARS) {
 505                 NDR_CHECK(ndr_push_align(ndr, 4));
 506                 NDR_CHECK(ndr_push_security_ace_type(ndr, NDR_SCALARS, r->type));
 507                 NDR_CHECK(ndr_push_security_ace_flags(ndr, NDR_SCALARS, r->flags));
 508                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_ace(r,ndr->flags)));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->access_mask));
 510                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->type));
 511                 NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
 512                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->trustee));
 513         }
 514         if (ndr_flags & NDR_BUFFERS) {
 515                 NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
 516         }
 517         return NT_STATUS_OK;
 518 }
 519
 520 NTSTATUS ndr_pull_security_ace(struct ndr_pull *ndr, int ndr_flags, struct security_ace *r)
 521 {
 522         if (ndr_flags & NDR_SCALARS) {
 523                 NDR_CHECK(ndr_pull_align(ndr, 4));
 524                 NDR_CHECK(ndr_pull_security_ace_type(ndr, NDR_SCALARS, &r->type));
 525                 NDR_CHECK(ndr_pull_security_ace_flags(ndr, NDR_SCALARS, &r->flags));
 526                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->access_mask));
 528                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, r->type));
 529                 NDR_CHECK(ndr_pull_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
 530                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->trustee));
 531         }
 532         if (ndr_flags & NDR_BUFFERS) {
 533                 NDR_CHECK(ndr_pull_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
 534         }
 535         return NT_STATUS_OK;
 536 }
 537
 538 void ndr_print_security_ace(struct ndr_print *ndr, const char *name, const struct security_ace *r)
 539 {
 540         ndr_print_struct(ndr, name, "security_ace");
 541         ndr->depth++;
 542         ndr_print_security_ace_type(ndr, "type", r->type);
 543         ndr_print_security_ace_flags(ndr, "flags", r->flags);
 544         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_ace(r,ndr->flags):r->size);
 545         ndr_print_uint32(ndr, "access_mask", r->access_mask);
 546         ndr_print_set_switch_value(ndr, &r->object, r->type);
 547         ndr_print_security_ace_object_ctr(ndr, "object", &r->object);
 548         ndr_print_dom_sid(ndr, "trustee", &r->trustee);
 549         ndr->depth--;
 550 }
 551
 552 static NTSTATUS ndr_push_security_acl_revision(struct ndr_push *ndr, int ndr_flags, enum security_acl_revision r)
 553 {
 554         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 555         return NT_STATUS_OK;
 556 }
 557
 558 static NTSTATUS ndr_pull_security_acl_revision(struct ndr_pull *ndr, int ndr_flags, enum security_acl_revision *r)
 559 {
 560         uint16_t v;
 561         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 562         *r = (enum security_acl_revision)v;
 563         return NT_STATUS_OK;
 564 }
 565
 566 void ndr_print_security_acl_revision(struct ndr_print *ndr, const char *name, enum security_acl_revision r)
 567 {
 568         const char *val = NULL;
 569
 570         switch (r) {
 571                 case SECURITY_ACL_REVISION_NT4: val = "SECURITY_ACL_REVISION_NT4"; break;
 572                 case SECURITY_ACL_REVISION_ADS: val = "SECURITY_ACL_REVISION_ADS"; break;
 573         }
 574         ndr_print_enum(ndr, name, "ENUM", val, r);
 575 }
 576
 577 NTSTATUS ndr_push_security_acl(struct ndr_push *ndr, int ndr_flags, const struct security_acl *r)
 578 {
 579         uint32_t cntr_aces_0;
 580         if (ndr_flags & NDR_SCALARS) {
 581                 NDR_CHECK(ndr_push_align(ndr, 4));
 582                 NDR_CHECK(ndr_push_security_acl_revision(ndr, NDR_SCALARS, r->revision));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_acl(r,ndr->flags)));
 584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aces));
 585                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 586                         NDR_CHECK(ndr_push_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 587                 }
 588         }
 589         if (ndr_flags & NDR_BUFFERS) {
 590                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 591                         NDR_CHECK(ndr_push_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 592                 }
 593         }
 594         return NT_STATUS_OK;
 595 }
 596
 597 NTSTATUS ndr_pull_security_acl(struct ndr_pull *ndr, int ndr_flags, struct security_acl *r)
 598 {
 599         uint32_t cntr_aces_0;
 600         TALLOC_CTX *_mem_save_aces_0;
 601         if (ndr_flags & NDR_SCALARS) {
 602                 NDR_CHECK(ndr_pull_align(ndr, 4));
 603                 NDR_CHECK(ndr_pull_security_acl_revision(ndr, NDR_SCALARS, &r->revision));
 604                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aces));
 606                 if (r->num_aces > 1000) { /* num_aces is unsigned */
 607                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 608                 }
 609                 NDR_PULL_ALLOC_N(ndr, r->aces, r->num_aces);
 610                 _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 611                 NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 612                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 613                         NDR_CHECK(ndr_pull_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 614                 }
 615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 616         }
 617         if (ndr_flags & NDR_BUFFERS) {
 618                 _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 619                 NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 620                 for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 621                         NDR_CHECK(ndr_pull_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 622                 }
 623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 624         }
 625         return NT_STATUS_OK;
 626 }
 627
 628 void ndr_print_security_acl(struct ndr_print *ndr, const char *name, const struct security_acl *r)
 629 {
 630         uint32_t cntr_aces_0;
 631         ndr_print_struct(ndr, name, "security_acl");
 632         ndr->depth++;
 633         ndr_print_security_acl_revision(ndr, "revision", r->revision);
 634         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_acl(r,ndr->flags):r->size);
 635         ndr_print_uint32(ndr, "num_aces", r->num_aces);
 636         ndr->print(ndr, "%s: ARRAY(%d)", "aces", r->num_aces);
 637         ndr->depth++;
 638         for (cntr_aces_0=0;cntr_aces_0<r->num_aces;cntr_aces_0++) {
 639                 char *idx_0=NULL;
 640                 asprintf(&idx_0, "[%d]", cntr_aces_0);
 641                 if (idx_0) {
 642                         ndr_print_security_ace(ndr, "aces", &r->aces[cntr_aces_0]);
 643                         free(idx_0);
 644                 }
 645         }
 646         ndr->depth--;
 647         ndr->depth--;
 648 }
 649
 650 static NTSTATUS ndr_push_security_descriptor_revision(struct ndr_push *ndr, int ndr_flags, enum security_descriptor_revision r)
 651 {
 652         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 653         return NT_STATUS_OK;
 654 }
 655
 656 static NTSTATUS ndr_pull_security_descriptor_revision(struct ndr_pull *ndr, int ndr_flags, enum security_descriptor_revision *r)
 657 {
 658         uint8_t v;
 659         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 660         *r = (enum security_descriptor_revision)v;
 661         return NT_STATUS_OK;
 662 }
 663
 664 void ndr_print_security_descriptor_revision(struct ndr_print *ndr, const char *name, enum security_descriptor_revision r)
 665 {
 666         const char *val = NULL;
 667
 668         switch (r) {
 669                 case SECURITY_DESCRIPTOR_REVISION_1: val = "SECURITY_DESCRIPTOR_REVISION_1"; break;
 670         }
 671         ndr_print_enum(ndr, name, "ENUM", val, r);
 672 }
 673
 674 static NTSTATUS ndr_push_security_descriptor_type(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 675 {
 676         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 677         return NT_STATUS_OK;
 678 }
 679
 680 static NTSTATUS ndr_pull_security_descriptor_type(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 681 {
 682         uint16_t v;
 683         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 684         *r = v;
 685         return NT_STATUS_OK;
 686 }
 687
 688 void ndr_print_security_descriptor_type(struct ndr_print *ndr, const char *name, uint16_t r)
 689 {
 690         ndr_print_uint16(ndr, name, r);
 691         ndr->depth++;
 692         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_OWNER_DEFAULTED", SEC_DESC_OWNER_DEFAULTED, r);
 693         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_GROUP_DEFAULTED", SEC_DESC_GROUP_DEFAULTED, r);
 694         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PRESENT", SEC_DESC_DACL_PRESENT, r);
 695         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_DEFAULTED", SEC_DESC_DACL_DEFAULTED, r);
 696         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PRESENT", SEC_DESC_SACL_PRESENT, r);
 697         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_DEFAULTED", SEC_DESC_SACL_DEFAULTED, r);
 698         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_TRUSTED", SEC_DESC_DACL_TRUSTED, r);
 699         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SERVER_SECURITY", SEC_DESC_SERVER_SECURITY, r);
 700         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERIT_REQ", SEC_DESC_DACL_AUTO_INHERIT_REQ, r);
 701         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERIT_REQ", SEC_DESC_SACL_AUTO_INHERIT_REQ, r);
 702         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERITED", SEC_DESC_DACL_AUTO_INHERITED, r);
 703         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERITED", SEC_DESC_SACL_AUTO_INHERITED, r);
 704         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PROTECTED", SEC_DESC_DACL_PROTECTED, r);
 705         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PROTECTED", SEC_DESC_SACL_PROTECTED, r);
 706         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_RM_CONTROL_VALID", SEC_DESC_RM_CONTROL_VALID, r);
 707         ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SELF_RELATIVE", SEC_DESC_SELF_RELATIVE, r);
 708         ndr->depth--;
 709 }
 710
 711 NTSTATUS ndr_push_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
 712 {
 713         {
 714                 uint32_t _flags_save_STRUCT = ndr->flags;
 715                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 716                 if (ndr_flags & NDR_SCALARS) {
 717                         NDR_CHECK(ndr_push_align(ndr, 4));
 718                         NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
 719                         NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
 720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
 721                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
 722                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
 723                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
 724                 }
 725                 if (ndr_flags & NDR_BUFFERS) {
 726                         if (r->owner_sid) {
 727                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->owner_sid));
 728                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 729                         }
 730                         if (r->group_sid) {
 731                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->group_sid));
 732                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 733                         }
 734                         if (r->sacl) {
 735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sacl));
 736                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 737                         }
 738                         if (r->dacl) {
 739                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dacl));
 740                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 741                         }
 742                 }
 743                 ndr->flags = _flags_save_STRUCT;
 744         }
 745         return NT_STATUS_OK;
 746 }
 747
 748 NTSTATUS ndr_pull_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
 749 {
 750         uint32_t _ptr_owner_sid;
 751         TALLOC_CTX *_mem_save_owner_sid_0;
 752         uint32_t _ptr_group_sid;
 753         TALLOC_CTX *_mem_save_group_sid_0;
 754         uint32_t _ptr_sacl;
 755         TALLOC_CTX *_mem_save_sacl_0;
 756         uint32_t _ptr_dacl;
 757         TALLOC_CTX *_mem_save_dacl_0;
 758         {
 759                 uint32_t _flags_save_STRUCT = ndr->flags;
 760                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 761                 if (ndr_flags & NDR_SCALARS) {
 762                         NDR_CHECK(ndr_pull_align(ndr, 4));
 763                         NDR_CHECK(ndr_pull_security_descriptor_revision(ndr, NDR_SCALARS, &r->revision));
 764                         NDR_CHECK(ndr_pull_security_descriptor_type(ndr, NDR_SCALARS, &r->type));
 765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_owner_sid));
 766                         if (_ptr_owner_sid) {
 767                                 NDR_PULL_ALLOC(ndr, r->owner_sid);
 768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->owner_sid, _ptr_owner_sid));
 769                         } else {
 770                                 r->owner_sid = NULL;
 771                         }
 772                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
 773                         if (_ptr_group_sid) {
 774                                 NDR_PULL_ALLOC(ndr, r->group_sid);
 775                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->group_sid, _ptr_group_sid));
 776                         } else {
 777                                 r->group_sid = NULL;
 778                         }
 779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sacl));
 780                         if (_ptr_sacl) {
 781                                 NDR_PULL_ALLOC(ndr, r->sacl);
 782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sacl, _ptr_sacl));
 783                         } else {
 784                                 r->sacl = NULL;
 785                         }
 786                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dacl));
 787                         if (_ptr_dacl) {
 788                                 NDR_PULL_ALLOC(ndr, r->dacl);
 789                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dacl, _ptr_dacl));
 790                         } else {
 791                                 r->dacl = NULL;
 792                         }
 793                 }
 794                 if (ndr_flags & NDR_BUFFERS) {
 795                         if (r->owner_sid) {
 796                                 struct ndr_pull_save _relative_save;
 797                                 ndr_pull_save(ndr, &_relative_save);
 798                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->owner_sid));
 799                                 _mem_save_owner_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 800                                 NDR_PULL_SET_MEM_CTX(ndr, r->owner_sid, 0);
 801                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 802                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_owner_sid_0, 0);
 803                                 ndr_pull_restore(ndr, &_relative_save);
 804                         }
 805                         if (r->group_sid) {
 806                                 struct ndr_pull_save _relative_save;
 807                                 ndr_pull_save(ndr, &_relative_save);
 808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->group_sid));
 809                                 _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 810                                 NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
 811                                 NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
 813                                 ndr_pull_restore(ndr, &_relative_save);
 814                         }
 815                         if (r->sacl) {
 816                                 struct ndr_pull_save _relative_save;
 817                                 ndr_pull_save(ndr, &_relative_save);
 818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sacl));
 819                                 _mem_save_sacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 820                                 NDR_PULL_SET_MEM_CTX(ndr, r->sacl, 0);
 821                                 NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sacl_0, 0);
 823                                 ndr_pull_restore(ndr, &_relative_save);
 824                         }
 825                         if (r->dacl) {
 826                                 struct ndr_pull_save _relative_save;
 827                                 ndr_pull_save(ndr, &_relative_save);
 828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dacl));
 829                                 _mem_save_dacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 830                                 NDR_PULL_SET_MEM_CTX(ndr, r->dacl, 0);
 831                                 NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dacl_0, 0);
 833                                 ndr_pull_restore(ndr, &_relative_save);
 834                         }
 835                 }
 836                 ndr->flags = _flags_save_STRUCT;
 837         }
 838         return NT_STATUS_OK;
 839 }
 840
 841 void ndr_print_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
 842 {
 843         ndr_print_struct(ndr, name, "security_descriptor");
 844         {
 845                 uint32_t _flags_save_STRUCT = ndr->flags;
 846                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 847                 ndr->depth++;
 848                 ndr_print_security_descriptor_revision(ndr, "revision", r->revision);
 849                 ndr_print_security_descriptor_type(ndr, "type", r->type);
 850                 ndr_print_ptr(ndr, "owner_sid", r->owner_sid);
 851                 ndr->depth++;
 852                 if (r->owner_sid) {
 853                         ndr_print_dom_sid(ndr, "owner_sid", r->owner_sid);
 854                 }
 855                 ndr->depth--;
 856                 ndr_print_ptr(ndr, "group_sid", r->group_sid);
 857                 ndr->depth++;
 858                 if (r->group_sid) {
 859                         ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
 860                 }
 861                 ndr->depth--;
 862                 ndr_print_ptr(ndr, "sacl", r->sacl);
 863                 ndr->depth++;
 864                 if (r->sacl) {
 865                         ndr_print_security_acl(ndr, "sacl", r->sacl);
 866                 }
 867                 ndr->depth--;
 868                 ndr_print_ptr(ndr, "dacl", r->dacl);
 869                 ndr->depth++;
 870                 if (r->dacl) {
 871                         ndr_print_security_acl(ndr, "dacl", r->dacl);
 872                 }
 873                 ndr->depth--;
 874                 ndr->depth--;
 875                 ndr->flags = _flags_save_STRUCT;
 876         }
 877 }
 878
 879 NTSTATUS ndr_push_security_secinfo(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 880 {
 881         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 882         return NT_STATUS_OK;
 883 }
 884
 885 NTSTATUS ndr_pull_security_secinfo(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 886 {
 887         uint32_t v;
 888         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 889         *r = v;
 890         return NT_STATUS_OK;
 891 }
 892
 893 void ndr_print_security_secinfo(struct ndr_print *ndr, const char *name, uint32_t r)
 894 {
 895         ndr_print_uint32(ndr, name, r);
 896         ndr->depth++;
 897         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_OWNER", SECINFO_OWNER, r);
 898         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_GROUP", SECINFO_GROUP, r);
 899         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_DACL", SECINFO_DACL, r);
 900         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_SACL", SECINFO_SACL, r);
 901         ndr->depth--;
 902 }
 903