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