lib/sysacls.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * Based on the Samba ACL support code.
   4  * Copyright (C) Jeremy Allison 2000.
   5  *
   6  * The permission functions have been changed to get/set all bits via
   7  * one call.  Some functions that rsync doesn't need were also removed.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * with this program; if not, visit the http://fsf.org website.
  21  */
  22
  23 #include "rsync.h"
  24 #include "sysacls.h"
  25
  26 #ifdef SUPPORT_ACLS
  27
  28 #ifdef DEBUG
  29 #undef DEBUG
  30 #endif
  31 #define DEBUG(x,y)
  32
  33 void SAFE_FREE(void *mem)
  34 {
  35         if (mem)
  36                 free(mem);
  37 }
  38
  39 /*
  40  This file wraps all differing system ACL interfaces into a consistent
  41  one based on the POSIX interface. It also returns the correct errors
  42  for older UNIX systems that don't support ACLs.
  43
  44  The interfaces that each ACL implementation must support are as follows :
  45
  46  int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
  47  int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
  48  int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
  49  SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
  50  SMB_ACL_T sys_acl_get_fd(int fd)
  51  SMB_ACL_T sys_acl_init( int count)
  52  int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
  53  int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
  54  int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
  55  int sys_acl_valid( SMB_ACL_T theacl )
  56  int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
  57  int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
  58  int sys_acl_delete_def_file(const char *path)
  59  int sys_acl_free_acl(SMB_ACL_T posix_acl)
  60
  61 */
  62
  63 #if defined(HAVE_POSIX_ACLS) /*--------------------------------------------*/
  64
  65 /* Identity mapping - easy. */
  66
  67 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
  68 {
  69         return acl_get_entry( the_acl, entry_id, entry_p);
  70 }
  71
  72 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
  73 {
  74         return acl_get_tag_type( entry_d, tag_type_p);
  75 }
  76
  77 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
  78 {
  79         return acl_get_file( path_p, type);
  80 }
  81
  82 #if 0
  83 SMB_ACL_T sys_acl_get_fd(int fd)
  84 {
  85         return acl_get_fd(fd);
  86 }
  87 #endif
  88
  89 #if defined(HAVE_ACL_GET_PERM_NP)
  90 #define acl_get_perm(p, b) acl_get_perm_np(p, b)
  91 #endif
  92
  93 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
  94 {
  95         acl_permset_t permset;
  96
  97         if (acl_get_tag_type(entry, tag_type_p) != 0
  98          || acl_get_permset(entry, &permset) != 0)
  99                 return -1;
 100
 101         *bits_p = (acl_get_perm(permset, ACL_READ) ? 4 : 0)
 102                 | (acl_get_perm(permset, ACL_WRITE) ? 2 : 0)
 103                 | (acl_get_perm(permset, ACL_EXECUTE) ? 1 : 0);
 104
 105         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP) {
 106                 void *qual;
 107                 if ((qual = acl_get_qualifier(entry)) == NULL)
 108                         return -1;
 109                 *u_g_id_p = *(id_t*)qual;
 110                 acl_free(qual);
 111         }
 112
 113         return 0;
 114 }
 115
 116 SMB_ACL_T sys_acl_init( int count)
 117 {
 118         return acl_init(count);
 119 }
 120
 121 int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 122 {
 123         return acl_create_entry(pacl, pentry);
 124 }
 125
 126 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
 127 {
 128         if (acl_set_tag_type(entry, tag_type) != 0)
 129                 return -1;
 130
 131         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP) {
 132                 if (acl_set_qualifier(entry, (void*)&u_g_id) != 0)
 133                         return -1;
 134         }
 135
 136         return sys_acl_set_access_bits(entry, bits);
 137 }
 138
 139 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
 140 {
 141         acl_permset_t permset;
 142         int rc;
 143         if ((rc = acl_get_permset(entry, &permset)) != 0)
 144                 return rc;
 145         acl_clear_perms(permset);
 146         if (bits & 4)
 147                 acl_add_perm(permset, ACL_READ);
 148         if (bits & 2)
 149                 acl_add_perm(permset, ACL_WRITE);
 150         if (bits & 1)
 151                 acl_add_perm(permset, ACL_EXECUTE);
 152         return acl_set_permset(entry, permset);
 153 }
 154
 155 int sys_acl_valid( SMB_ACL_T theacl )
 156 {
 157         return acl_valid(theacl);
 158 }
 159
 160 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 161 {
 162         return acl_set_file(name, acltype, theacl);
 163 }
 164
 165 #if 0
 166 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
 167 {
 168         return acl_set_fd(fd, theacl);
 169 }
 170 #endif
 171
 172 int sys_acl_delete_def_file(const char *name)
 173 {
 174         return acl_delete_def_file(name);
 175 }
 176
 177 int sys_acl_free_acl(SMB_ACL_T the_acl)
 178 {
 179         return acl_free(the_acl);
 180 }
 181
 182 #elif defined(HAVE_TRU64_ACLS) /*--------------------------------------------*/
 183 /*
 184  * The interface to DEC/Compaq Tru64 UNIX ACLs
 185  * is based on Draft 13 of the POSIX spec which is
 186  * slightly different from the Draft 16 interface.
 187  *
 188  * Also, some of the permset manipulation functions
 189  * such as acl_clear_perm() and acl_add_perm() appear
 190  * to be broken on Tru64 so we have to manipulate
 191  * the permission bits in the permset directly.
 192  */
 193 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 194 {
 195         SMB_ACL_ENTRY_T entry;
 196
 197         if (entry_id == SMB_ACL_FIRST_ENTRY && acl_first_entry(the_acl) != 0) {
 198                 return -1;
 199         }
 200
 201         errno = 0;
 202         if ((entry = acl_get_entry(the_acl)) != NULL) {
 203                 *entry_p = entry;
 204                 return 1;
 205         }
 206
 207         return errno ? -1 : 0;
 208 }
 209
 210 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
 211 {
 212         return acl_get_tag_type( entry_d, tag_type_p);
 213 }
 214
 215 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
 216 {
 217         return acl_get_file((char *)path_p, type);
 218 }
 219
 220 #if 0
 221 SMB_ACL_T sys_acl_get_fd(int fd)
 222 {
 223         return acl_get_fd(fd, ACL_TYPE_ACCESS);
 224 }
 225 #endif
 226
 227 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
 228 {
 229         acl_permset_t permset;
 230
 231         if (acl_get_tag_type(entry, tag_type_p) != 0
 232          || acl_get_permset(entry, &permset) != 0)
 233                 return -1;
 234
 235         *bits_p = *permset & 7; /* Tru64 doesn't have acl_get_perm() */
 236
 237         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP) {
 238                 void *qual;
 239                 if ((qual = acl_get_qualifier(entry)) == NULL)
 240                         return -1;
 241                 *u_g_id_p = *(id_t*)qual;
 242                 acl_free_qualifier(qual, *tag_type_p);
 243         }
 244
 245         return 0;
 246 }
 247
 248 SMB_ACL_T sys_acl_init( int count)
 249 {
 250         return acl_init(count);
 251 }
 252
 253 int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 254 {
 255         SMB_ACL_ENTRY_T entry;
 256
 257         if ((entry = acl_create_entry(pacl)) == NULL) {
 258                 return -1;
 259         }
 260
 261         *pentry = entry;
 262         return 0;
 263 }
 264
 265 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
 266 {
 267         if (acl_set_tag_type(entry, tag_type) != 0)
 268                 return -1;
 269
 270         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP) {
 271                 if (acl_set_qualifier(entry, (void*)&u_g_id) != 0)
 272                         return -1;
 273         }
 274
 275         return sys_acl_set_access_bits(entry, bits);
 276 }
 277
 278 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
 279 {
 280         acl_permset_t permset;
 281         int rc;
 282         if ((rc = acl_get_permset(entry, &permset)) != 0)
 283                 return rc;
 284         *permset = bits & 7;
 285         return acl_set_permset(entry, permset);
 286 }
 287
 288 int sys_acl_valid( SMB_ACL_T theacl )
 289 {
 290         acl_entry_t     entry;
 291
 292         return acl_valid(theacl, &entry);
 293 }
 294
 295 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 296 {
 297         return acl_set_file((char *)name, acltype, theacl);
 298 }
 299
 300 #if 0
 301 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
 302 {
 303         return acl_set_fd(fd, ACL_TYPE_ACCESS, theacl);
 304 }
 305 #endif
 306
 307 int sys_acl_delete_def_file(const char *name)
 308 {
 309         return acl_delete_def_file((char *)name);
 310 }
 311
 312 int sys_acl_free_acl(SMB_ACL_T the_acl)
 313 {
 314         return acl_free(the_acl);
 315 }
 316
 317 #elif defined(HAVE_UNIXWARE_ACLS) || defined(HAVE_SOLARIS_ACLS) /*-----------*/
 318
 319 /*
 320  * Donated by Michael Davidson <md@sco.COM> for UnixWare / OpenUNIX.
 321  * Modified by Toomas Soome <tsoome@ut.ee> for Solaris.
 322  */
 323
 324 /*
 325  * Note that while this code implements sufficient functionality
 326  * to support the sys_acl_* interfaces it does not provide all
 327  * of the semantics of the POSIX ACL interfaces.
 328  *
 329  * In particular, an ACL entry descriptor (SMB_ACL_ENTRY_T) returned
 330  * from a call to sys_acl_get_entry() should not be assumed to be
 331  * valid after calling any of the following functions, which may
 332  * reorder the entries in the ACL.
 333  *
 334  *      sys_acl_valid()
 335  *      sys_acl_set_file()
 336  *      sys_acl_set_fd()
 337  */
 338
 339 /*
 340  * The only difference between Solaris and UnixWare / OpenUNIX is
 341  * that the #defines for the ACL operations have different names
 342  */
 343 #if defined(HAVE_UNIXWARE_ACLS)
 344
 345 #define SETACL          ACL_SET
 346 #define GETACL          ACL_GET
 347 #define GETACLCNT       ACL_CNT
 348
 349 #endif
 350
 351
 352 int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 353 {
 354         if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
 355                 errno = EINVAL;
 356                 return -1;
 357         }
 358
 359         if (entry_p == NULL) {
 360                 errno = EINVAL;
 361                 return -1;
 362         }
 363
 364         if (entry_id == SMB_ACL_FIRST_ENTRY) {
 365                 acl_d->next = 0;
 366         }
 367
 368         if (acl_d->next < 0) {
 369                 errno = EINVAL;
 370                 return -1;
 371         }
 372
 373         if (acl_d->next >= acl_d->count) {
 374                 return 0;
 375         }
 376
 377         *entry_p = &acl_d->acl[acl_d->next++];
 378
 379         return 1;
 380 }
 381
 382 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
 383 {
 384         *type_p = entry_d->a_type;
 385
 386         return 0;
 387 }
 388
 389 /*
 390  * There is no way of knowing what size the ACL returned by
 391  * GETACL will be unless you first call GETACLCNT which means
 392  * making an additional system call.
 393  *
 394  * In the hope of avoiding the cost of the additional system
 395  * call in most cases, we initially allocate enough space for
 396  * an ACL with INITIAL_ACL_SIZE entries. If this turns out to
 397  * be too small then we use GETACLCNT to find out the actual
 398  * size, reallocate the ACL buffer, and then call GETACL again.
 399  */
 400
 401 #define INITIAL_ACL_SIZE        16
 402
 403 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
 404 {
 405         SMB_ACL_T       acl_d;
 406         int             count;          /* # of ACL entries allocated   */
 407         int             naccess;        /* # of access ACL entries      */
 408         int             ndefault;       /* # of default ACL entries     */
 409
 410         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
 411                 errno = EINVAL;
 412                 return NULL;
 413         }
 414
 415         count = INITIAL_ACL_SIZE;
 416         if ((acl_d = sys_acl_init(count)) == NULL) {
 417                 return NULL;
 418         }
 419
 420         /*
 421          * If there isn't enough space for the ACL entries we use
 422          * GETACLCNT to determine the actual number of ACL entries
 423          * reallocate and try again. This is in a loop because it
 424          * is possible that someone else could modify the ACL and
 425          * increase the number of entries between the call to
 426          * GETACLCNT and the call to GETACL.
 427          */
 428         while ((count = acl(path_p, GETACL, count, &acl_d->acl[0])) < 0
 429             && errno == ENOSPC) {
 430
 431                 sys_acl_free_acl(acl_d);
 432
 433                 if ((count = acl(path_p, GETACLCNT, 0, NULL)) < 0) {
 434                         return NULL;
 435                 }
 436
 437                 if ((acl_d = sys_acl_init(count)) == NULL) {
 438                         return NULL;
 439                 }
 440         }
 441
 442         if (count < 0) {
 443                 sys_acl_free_acl(acl_d);
 444                 return NULL;
 445         }
 446
 447         /*
 448          * calculate the number of access and default ACL entries
 449          *
 450          * Note: we assume that the acl() system call returned a
 451          * well formed ACL which is sorted so that all of the
 452          * access ACL entries preceed any default ACL entries
 453          */
 454         for (naccess = 0; naccess < count; naccess++) {
 455                 if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
 456                         break;
 457         }
 458         ndefault = count - naccess;
 459
 460         /*
 461          * if the caller wants the default ACL we have to copy
 462          * the entries down to the start of the acl[] buffer
 463          * and mask out the ACL_DEFAULT flag from the type field
 464          */
 465         if (type == SMB_ACL_TYPE_DEFAULT) {
 466                 int     i, j;
 467
 468                 for (i = 0, j = naccess; i < ndefault; i++, j++) {
 469                         acl_d->acl[i] = acl_d->acl[j];
 470                         acl_d->acl[i].a_type &= ~ACL_DEFAULT;
 471                 }
 472
 473                 acl_d->count = ndefault;
 474         } else {
 475                 acl_d->count = naccess;
 476         }
 477
 478         return acl_d;
 479 }
 480
 481 #if 0
 482 SMB_ACL_T sys_acl_get_fd(int fd)
 483 {
 484         SMB_ACL_T       acl_d;
 485         int             count;          /* # of ACL entries allocated   */
 486         int             naccess;        /* # of access ACL entries      */
 487
 488         count = INITIAL_ACL_SIZE;
 489         if ((acl_d = sys_acl_init(count)) == NULL) {
 490                 return NULL;
 491         }
 492
 493         while ((count = facl(fd, GETACL, count, &acl_d->acl[0])) < 0
 494             && errno == ENOSPC) {
 495
 496                 sys_acl_free_acl(acl_d);
 497
 498                 if ((count = facl(fd, GETACLCNT, 0, NULL)) < 0) {
 499                         return NULL;
 500                 }
 501
 502                 if ((acl_d = sys_acl_init(count)) == NULL) {
 503                         return NULL;
 504                 }
 505         }
 506
 507         if (count < 0) {
 508                 sys_acl_free_acl(acl_d);
 509                 return NULL;
 510         }
 511
 512         /*
 513          * calculate the number of access ACL entries
 514          */
 515         for (naccess = 0; naccess < count; naccess++) {
 516                 if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
 517                         break;
 518         }
 519
 520         acl_d->count = naccess;
 521
 522         return acl_d;
 523 }
 524 #endif
 525
 526 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
 527 {
 528         *tag_type_p = entry->a_type;
 529
 530         *bits_p = entry->a_perm;
 531
 532         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP)
 533                 *u_g_id_p = entry->a_id;
 534
 535         return 0;
 536 }
 537
 538 SMB_ACL_T sys_acl_init(int count)
 539 {
 540         SMB_ACL_T       a;
 541
 542         if (count < 0) {
 543                 errno = EINVAL;
 544                 return NULL;
 545         }
 546
 547         /*
 548          * note that since the definition of the structure pointed
 549          * to by the SMB_ACL_T includes the first element of the
 550          * acl[] array, this actually allocates an ACL with room
 551          * for (count+1) entries
 552          */
 553         if ((a = (SMB_ACL_T)SMB_MALLOC(sizeof(struct SMB_ACL_T) + count * sizeof(struct acl))) == NULL) {
 554                 errno = ENOMEM;
 555                 return NULL;
 556         }
 557
 558         a->size = count + 1;
 559         a->count = 0;
 560         a->next = -1;
 561
 562         return a;
 563 }
 564
 565
 566 int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
 567 {
 568         SMB_ACL_T       acl_d;
 569         SMB_ACL_ENTRY_T entry_d;
 570
 571         if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
 572                 errno = EINVAL;
 573                 return -1;
 574         }
 575
 576         if (acl_d->count >= acl_d->size) {
 577                 errno = ENOSPC;
 578                 return -1;
 579         }
 580
 581         entry_d         = &acl_d->acl[acl_d->count++];
 582         entry_d->a_type = 0;
 583         entry_d->a_id   = -1;
 584         entry_d->a_perm = 0;
 585         *entry_p        = entry_d;
 586
 587         return 0;
 588 }
 589
 590 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
 591 {
 592         entry->a_type = tag_type;
 593
 594         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP)
 595                 entry->a_id = u_g_id;
 596
 597         entry->a_perm = bits;
 598
 599         return 0;
 600 }
 601
 602 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry_d, uint32 bits)
 603 {
 604         entry_d->a_perm = bits;
 605         return 0;
 606 }
 607
 608 /*
 609  * sort the ACL and check it for validity
 610  *
 611  * if it's a minimal ACL with only 4 entries then we
 612  * need to recalculate the mask permissions to make
 613  * sure that they are the same as the GROUP_OBJ
 614  * permissions as required by the UnixWare acl() system call.
 615  *
 616  * (note: since POSIX allows minimal ACLs which only contain
 617  * 3 entries - ie there is no mask entry - we should, in theory,
 618  * check for this and add a mask entry if necessary - however
 619  * we "know" that the caller of this interface always specifies
 620  * a mask so, in practice "this never happens" (tm) - if it *does*
 621  * happen aclsort() will fail and return an error and someone will
 622  * have to fix it ...)
 623  */
 624
 625 static int acl_sort(SMB_ACL_T acl_d)
 626 {
 627         int     fixmask = (acl_d->count <= 4);
 628
 629         if (aclsort(acl_d->count, fixmask, acl_d->acl) != 0) {
 630                 errno = EINVAL;
 631                 return -1;
 632         }
 633         return 0;
 634 }
 635
 636 int sys_acl_valid(SMB_ACL_T acl_d)
 637 {
 638         return acl_sort(acl_d);
 639 }
 640
 641 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 642 {
 643         struct stat     s;
 644         struct acl      *acl_p;
 645         int             acl_count;
 646         struct acl      *acl_buf        = NULL;
 647         int             ret;
 648
 649         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
 650                 errno = EINVAL;
 651                 return -1;
 652         }
 653
 654         if (acl_sort(acl_d) != 0) {
 655                 return -1;
 656         }
 657
 658         acl_p           = &acl_d->acl[0];
 659         acl_count       = acl_d->count;
 660
 661         /*
 662          * if it's a directory there is extra work to do
 663          * since the acl() system call will replace both
 664          * the access ACLs and the default ACLs (if any)
 665          */
 666         if (stat(name, &s) != 0) {
 667                 return -1;
 668         }
 669         if (S_ISDIR(s.st_mode)) {
 670                 SMB_ACL_T       acc_acl;
 671                 SMB_ACL_T       def_acl;
 672                 SMB_ACL_T       tmp_acl;
 673                 int             i;
 674
 675                 if (type == SMB_ACL_TYPE_ACCESS) {
 676                         acc_acl = acl_d;
 677                         def_acl = tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_DEFAULT);
 678
 679                 } else {
 680                         def_acl = acl_d;
 681                         acc_acl = tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_ACCESS);
 682                 }
 683
 684                 if (tmp_acl == NULL) {
 685                         return -1;
 686                 }
 687
 688                 /*
 689                  * allocate a temporary buffer for the complete ACL
 690                  */
 691                 acl_count = acc_acl->count + def_acl->count;
 692                 acl_p = acl_buf = SMB_MALLOC_ARRAY(struct acl, acl_count);
 693
 694                 if (acl_buf == NULL) {
 695                         sys_acl_free_acl(tmp_acl);
 696                         errno = ENOMEM;
 697                         return -1;
 698                 }
 699
 700                 /*
 701                  * copy the access control and default entries into the buffer
 702                  */
 703                 memcpy(&acl_buf[0], &acc_acl->acl[0],
 704                         acc_acl->count * sizeof(acl_buf[0]));
 705
 706                 memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],
 707                         def_acl->count * sizeof(acl_buf[0]));
 708
 709                 /*
 710                  * set the ACL_DEFAULT flag on the default entries
 711                  */
 712                 for (i = acc_acl->count; i < acl_count; i++) {
 713                         acl_buf[i].a_type |= ACL_DEFAULT;
 714                 }
 715
 716                 sys_acl_free_acl(tmp_acl);
 717
 718         } else if (type != SMB_ACL_TYPE_ACCESS) {
 719                 errno = EINVAL;
 720                 return -1;
 721         }
 722
 723         ret = acl(name, SETACL, acl_count, acl_p);
 724
 725         SAFE_FREE(acl_buf);
 726
 727         return ret;
 728 }
 729
 730 #if 0
 731 int sys_acl_set_fd(int fd, SMB_ACL_T acl_d)
 732 {
 733         if (acl_sort(acl_d) != 0) {
 734                 return -1;
 735         }
 736
 737         return facl(fd, SETACL, acl_d->count, &acl_d->acl[0]);
 738 }
 739 #endif
 740
 741 int sys_acl_delete_def_file(const char *path)
 742 {
 743         SMB_ACL_T       acl_d;
 744         int             ret;
 745
 746         /*
 747          * fetching the access ACL and rewriting it has
 748          * the effect of deleting the default ACL
 749          */
 750         if ((acl_d = sys_acl_get_file(path, SMB_ACL_TYPE_ACCESS)) == NULL) {
 751                 return -1;
 752         }
 753
 754         ret = acl(path, SETACL, acl_d->count, acl_d->acl);
 755
 756         sys_acl_free_acl(acl_d);
 757
 758         return ret;
 759 }
 760
 761 int sys_acl_free_acl(SMB_ACL_T acl_d)
 762 {
 763         SAFE_FREE(acl_d);
 764         return 0;
 765 }
 766
 767 #elif defined(HAVE_HPUX_ACLS) /*---------------------------------------------*/
 768
 769 #include <dl.h>
 770
 771 /*
 772  * Based on the Solaris/SCO code - with modifications.
 773  */
 774
 775 /*
 776  * Note that while this code implements sufficient functionality
 777  * to support the sys_acl_* interfaces it does not provide all
 778  * of the semantics of the POSIX ACL interfaces.
 779  *
 780  * In particular, an ACL entry descriptor (SMB_ACL_ENTRY_T) returned
 781  * from a call to sys_acl_get_entry() should not be assumed to be
 782  * valid after calling any of the following functions, which may
 783  * reorder the entries in the ACL.
 784  *
 785  *      sys_acl_valid()
 786  *      sys_acl_set_file()
 787  *      sys_acl_set_fd()
 788  */
 789
 790 /* This checks if the POSIX ACL system call is defined */
 791 /* which basically corresponds to whether JFS 3.3 or   */
 792 /* higher is installed. If acl() was called when it    */
 793 /* isn't defined, it causes the process to core dump   */
 794 /* so it is important to check this and avoid acl()    */
 795 /* calls if it isn't there.                            */
 796
 797 static BOOL hpux_acl_call_presence(void)
 798 {
 799
 800         shl_t handle = NULL;
 801         void *value;
 802         int ret_val=0;
 803         static BOOL already_checked=0;
 804
 805         if(already_checked)
 806                 return True;
 807
 808
 809         ret_val = shl_findsym(&handle, "acl", TYPE_PROCEDURE, &value);
 810
 811         if(ret_val != 0) {
 812                 DEBUG(5, ("hpux_acl_call_presence: shl_findsym() returned %d, errno = %d, error %s\n",
 813                         ret_val, errno, strerror(errno)));
 814                 DEBUG(5,("hpux_acl_call_presence: acl() system call is not present. Check if you have JFS 3.3 and above?\n"));
 815                 return False;
 816         }
 817
 818         DEBUG(10,("hpux_acl_call_presence: acl() system call is present. We have JFS 3.3 or above \n"));
 819
 820         already_checked = True;
 821         return True;
 822 }
 823
 824 int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 825 {
 826         if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
 827                 errno = EINVAL;
 828                 return -1;
 829         }
 830
 831         if (entry_p == NULL) {
 832                 errno = EINVAL;
 833                 return -1;
 834         }
 835
 836         if (entry_id == SMB_ACL_FIRST_ENTRY) {
 837                 acl_d->next = 0;
 838         }
 839
 840         if (acl_d->next < 0) {
 841                 errno = EINVAL;
 842                 return -1;
 843         }
 844
 845         if (acl_d->next >= acl_d->count) {
 846                 return 0;
 847         }
 848
 849         *entry_p = &acl_d->acl[acl_d->next++];
 850
 851         return 1;
 852 }
 853
 854 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
 855 {
 856         *type_p = entry_d->a_type;
 857
 858         return 0;
 859 }
 860
 861 /*
 862  * There is no way of knowing what size the ACL returned by
 863  * ACL_GET will be unless you first call ACL_CNT which means
 864  * making an additional system call.
 865  *
 866  * In the hope of avoiding the cost of the additional system
 867  * call in most cases, we initially allocate enough space for
 868  * an ACL with INITIAL_ACL_SIZE entries. If this turns out to
 869  * be too small then we use ACL_CNT to find out the actual
 870  * size, reallocate the ACL buffer, and then call ACL_GET again.
 871  */
 872
 873 #define INITIAL_ACL_SIZE        16
 874
 875 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
 876 {
 877         SMB_ACL_T       acl_d;
 878         int             count;          /* # of ACL entries allocated   */
 879         int             naccess;        /* # of access ACL entries      */
 880         int             ndefault;       /* # of default ACL entries     */
 881
 882         if(hpux_acl_call_presence() == False) {
 883                 /* Looks like we don't have the acl() system call on HPUX.
 884                  * May be the system doesn't have the latest version of JFS.
 885                  */
 886                 return NULL;
 887         }
 888
 889         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
 890                 errno = EINVAL;
 891                 return NULL;
 892         }
 893
 894         count = INITIAL_ACL_SIZE;
 895         if ((acl_d = sys_acl_init(count)) == NULL) {
 896                 return NULL;
 897         }
 898
 899         /*
 900          * If there isn't enough space for the ACL entries we use
 901          * ACL_CNT to determine the actual number of ACL entries
 902          * reallocate and try again. This is in a loop because it
 903          * is possible that someone else could modify the ACL and
 904          * increase the number of entries between the call to
 905          * ACL_CNT and the call to ACL_GET.
 906          */
 907         while ((count = acl(path_p, ACL_GET, count, &acl_d->acl[0])) < 0 && errno == ENOSPC) {
 908
 909                 sys_acl_free_acl(acl_d);
 910
 911                 if ((count = acl(path_p, ACL_CNT, 0, NULL)) < 0) {
 912                         return NULL;
 913                 }
 914
 915                 if ((acl_d = sys_acl_init(count)) == NULL) {
 916                         return NULL;
 917                 }
 918         }
 919
 920         if (count < 0) {
 921                 sys_acl_free_acl(acl_d);
 922                 return NULL;
 923         }
 924
 925         /*
 926          * calculate the number of access and default ACL entries
 927          *
 928          * Note: we assume that the acl() system call returned a
 929          * well formed ACL which is sorted so that all of the
 930          * access ACL entries preceed any default ACL entries
 931          */
 932         for (naccess = 0; naccess < count; naccess++) {
 933                 if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
 934                         break;
 935         }
 936         ndefault = count - naccess;
 937
 938         /*
 939          * if the caller wants the default ACL we have to copy
 940          * the entries down to the start of the acl[] buffer
 941          * and mask out the ACL_DEFAULT flag from the type field
 942          */
 943         if (type == SMB_ACL_TYPE_DEFAULT) {
 944                 int     i, j;
 945
 946                 for (i = 0, j = naccess; i < ndefault; i++, j++) {
 947                         acl_d->acl[i] = acl_d->acl[j];
 948                         acl_d->acl[i].a_type &= ~ACL_DEFAULT;
 949                 }
 950
 951                 acl_d->count = ndefault;
 952         } else {
 953                 acl_d->count = naccess;
 954         }
 955
 956         return acl_d;
 957 }
 958
 959 #if 0
 960 SMB_ACL_T sys_acl_get_fd(int fd)
 961 {
 962         /*
 963          * HPUX doesn't have the facl call. Fake it using the path.... JRA.
 964          */
 965
 966         files_struct *fsp = file_find_fd(fd);
 967
 968         if (fsp == NULL) {
 969                 errno = EBADF;
 970                 return NULL;
 971         }
 972
 973         /*
 974          * We know we're in the same conn context. So we
 975          * can use the relative path.
 976          */
 977
 978         return sys_acl_get_file(fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
 979 }
 980 #endif
 981
 982 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
 983 {
 984         *tag_type_p = entry->a_type;
 985
 986         *bits_p = entry->a_perm;
 987
 988         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP)
 989                 *u_g_id_p = entry->a_id;
 990
 991         return 0;
 992 }
 993
 994 SMB_ACL_T sys_acl_init(int count)
 995 {
 996         SMB_ACL_T       a;
 997
 998         if (count < 0) {
 999                 errno = EINVAL;
1000                 return NULL;
1001         }
1002
1003         /*
1004          * note that since the definition of the structure pointed
1005          * to by the SMB_ACL_T includes the first element of the
1006          * acl[] array, this actually allocates an ACL with room
1007          * for (count+1) entries
1008          */
1009         if ((a = SMB_MALLOC(sizeof(struct SMB_ACL_T) + count * sizeof(struct acl))) == NULL) {
1010                 errno = ENOMEM;
1011                 return NULL;
1012         }
1013
1014         a->size = count + 1;
1015         a->count = 0;
1016         a->next = -1;
1017
1018         return a;
1019 }
1020
1021
1022 int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
1023 {
1024         SMB_ACL_T       acl_d;
1025         SMB_ACL_ENTRY_T entry_d;
1026
1027         if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
1028                 errno = EINVAL;
1029                 return -1;
1030         }
1031
1032         if (acl_d->count >= acl_d->size) {
1033                 errno = ENOSPC;
1034                 return -1;
1035         }
1036
1037         entry_d         = &acl_d->acl[acl_d->count++];
1038         entry_d->a_type = 0;
1039         entry_d->a_id   = -1;
1040         entry_d->a_perm = 0;
1041         *entry_p        = entry_d;
1042
1043         return 0;
1044 }
1045
1046 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
1047 {
1048         entry->a_type = tag_type;
1049
1050         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP)
1051                 entry->a_id = u_g_id;
1052
1053         entry->a_perm = bits;
1054
1055         return 0;
1056 }
1057
1058 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry_d, uint32 bits)
1059 {
1060         entry_d->a_perm = bits;
1061
1062         return 0;
1063 }
1064
1065 /* Structure to capture the count for each type of ACE. */
1066
1067 struct hpux_acl_types {
1068         int n_user;
1069         int n_def_user;
1070         int n_user_obj;
1071         int n_def_user_obj;
1072
1073         int n_group;
1074         int n_def_group;
1075         int n_group_obj;
1076         int n_def_group_obj;
1077
1078         int n_other;
1079         int n_other_obj;
1080         int n_def_other_obj;
1081
1082         int n_class_obj;
1083         int n_def_class_obj;
1084
1085         int n_illegal_obj;
1086 };
1087
1088 /* count_obj:
1089  * Counts the different number of objects in a given array of ACL
1090  * structures.
1091  * Inputs:
1092  *
1093  * acl_count      - Count of ACLs in the array of ACL strucutres.
1094  * aclp           - Array of ACL structures.
1095  * acl_type_count - Pointer to acl_types structure. Should already be
1096  *                  allocated.
1097  * Output:
1098  *
1099  * acl_type_count - This structure is filled up with counts of various
1100  *                  acl types.
1101  */
1102
1103 static void hpux_count_obj(int acl_count, struct acl *aclp, struct hpux_acl_types *acl_type_count)
1104 {
1105         int i;
1106
1107         memset(acl_type_count, 0, sizeof(struct hpux_acl_types));
1108
1109         for(i=0;i<acl_count;i++) {
1110                 switch(aclp[i].a_type) {
1111                 case USER:
1112                         acl_type_count->n_user++;
1113                         break;
1114                 case USER_OBJ:
1115                         acl_type_count->n_user_obj++;
1116                         break;
1117                 case DEF_USER_OBJ:
1118                         acl_type_count->n_def_user_obj++;
1119                         break;
1120                 case GROUP:
1121                         acl_type_count->n_group++;
1122                         break;
1123                 case GROUP_OBJ:
1124                         acl_type_count->n_group_obj++;
1125                         break;
1126                 case DEF_GROUP_OBJ:
1127                         acl_type_count->n_def_group_obj++;
1128                         break;
1129                 case OTHER_OBJ:
1130                         acl_type_count->n_other_obj++;
1131                         break;
1132                 case DEF_OTHER_OBJ:
1133                         acl_type_count->n_def_other_obj++;
1134                         break;
1135                 case CLASS_OBJ:
1136                         acl_type_count->n_class_obj++;
1137                         break;
1138                 case DEF_CLASS_OBJ:
1139                         acl_type_count->n_def_class_obj++;
1140                         break;
1141                 case DEF_USER:
1142                         acl_type_count->n_def_user++;
1143                         break;
1144                 case DEF_GROUP:
1145                         acl_type_count->n_def_group++;
1146                         break;
1147                 default:
1148                         acl_type_count->n_illegal_obj++;
1149                         break;
1150                 }
1151         }
1152 }
1153
1154 /* swap_acl_entries:  Swaps two ACL entries.
1155  *
1156  * Inputs: aclp0, aclp1 - ACL entries to be swapped.
1157  */
1158
1159 static void hpux_swap_acl_entries(struct acl *aclp0, struct acl *aclp1)
1160 {
1161         struct acl temp_acl;
1162
1163         temp_acl.a_type = aclp0->a_type;
1164         temp_acl.a_id = aclp0->a_id;
1165         temp_acl.a_perm = aclp0->a_perm;
1166
1167         aclp0->a_type = aclp1->a_type;
1168         aclp0->a_id = aclp1->a_id;
1169         aclp0->a_perm = aclp1->a_perm;
1170
1171         aclp1->a_type = temp_acl.a_type;
1172         aclp1->a_id = temp_acl.a_id;
1173         aclp1->a_perm = temp_acl.a_perm;
1174 }
1175
1176 /* prohibited_duplicate_type
1177  * Identifies if given ACL type can have duplicate entries or
1178  * not.
1179  *
1180  * Inputs: acl_type - ACL Type.
1181  *
1182  * Outputs:
1183  *
1184  * Return..
1185  *
1186  * True - If the ACL type matches any of the prohibited types.
1187  * False - If the ACL type doesn't match any of the prohibited types.
1188  */
1189
1190 static BOOL hpux_prohibited_duplicate_type(int acl_type)
1191 {
1192         switch(acl_type) {
1193                 case USER:
1194                 case GROUP:
1195                 case DEF_USER:
1196                 case DEF_GROUP:
1197                         return True;
1198                 default:
1199                         return False;
1200         }
1201 }
1202
1203 /* get_needed_class_perm
1204  * Returns the permissions of a ACL structure only if the ACL
1205  * type matches one of the pre-determined types for computing
1206  * CLASS_OBJ permissions.
1207  *
1208  * Inputs: aclp - Pointer to ACL structure.
1209  */
1210
1211 static int hpux_get_needed_class_perm(struct acl *aclp)
1212 {
1213         switch(aclp->a_type) {
1214                 case USER:
1215                 case GROUP_OBJ:
1216                 case GROUP:
1217                 case DEF_USER_OBJ:
1218                 case DEF_USER:
1219                 case DEF_GROUP_OBJ:
1220                 case DEF_GROUP:
1221                 case DEF_CLASS_OBJ:
1222                 case DEF_OTHER_OBJ:
1223                         return aclp->a_perm;
1224                 default:
1225                         return 0;
1226         }
1227 }
1228
1229 /* acl_sort for HPUX.
1230  * Sorts the array of ACL structures as per the description in
1231  * aclsort man page. Refer to aclsort man page for more details
1232  *
1233  * Inputs:
1234  *
1235  * acl_count - Count of ACLs in the array of ACL structures.
1236  * calclass  - If this is not zero, then we compute the CLASS_OBJ
1237  *             permissions.
1238  * aclp      - Array of ACL structures.
1239  *
1240  * Outputs:
1241  *
1242  * aclp     - Sorted array of ACL structures.
1243  *
1244  * Outputs:
1245  *
1246  * Returns 0 for success -1 for failure. Prints a message to the Samba
1247  * debug log in case of failure.
1248  */
1249
1250 static int hpux_acl_sort(int acl_count, int calclass, struct acl *aclp)
1251 {
1252 #if !defined(HAVE_HPUX_ACLSORT)
1253         /*
1254          * The aclsort() system call is availabe on the latest HPUX General
1255          * Patch Bundles. So for HPUX, we developed our version of acl_sort
1256          * function. Because, we don't want to update to a new
1257          * HPUX GR bundle just for aclsort() call.
1258          */
1259
1260         struct hpux_acl_types acl_obj_count;
1261         int n_class_obj_perm = 0;
1262         int i, j;
1263
1264         if(!acl_count) {
1265                 DEBUG(10,("Zero acl count passed. Returning Success\n"));
1266                 return 0;
1267         }
1268
1269         if(aclp == NULL) {
1270                 DEBUG(0,("Null ACL pointer in hpux_acl_sort. Returning Failure. \n"));
1271                 return -1;
1272         }
1273
1274         /* Count different types of ACLs in the ACLs array */
1275
1276         hpux_count_obj(acl_count, aclp, &acl_obj_count);
1277
1278         /* There should be only one entry each of type USER_OBJ, GROUP_OBJ,
1279          * CLASS_OBJ and OTHER_OBJ
1280          */
1281
1282         if( (acl_obj_count.n_user_obj  != 1) ||
1283                 (acl_obj_count.n_group_obj != 1) ||
1284                 (acl_obj_count.n_class_obj != 1) ||
1285                 (acl_obj_count.n_other_obj != 1)
1286         ) {
1287                 DEBUG(0,("hpux_acl_sort: More than one entry or no entries for \
1288 USER OBJ or GROUP_OBJ or OTHER_OBJ or CLASS_OBJ\n"));
1289                 return -1;
1290         }
1291
1292         /* If any of the default objects are present, there should be only
1293          * one of them each.
1294          */
1295
1296         if( (acl_obj_count.n_def_user_obj  > 1) || (acl_obj_count.n_def_group_obj > 1) ||
1297                         (acl_obj_count.n_def_other_obj > 1) || (acl_obj_count.n_def_class_obj > 1) ) {
1298                 DEBUG(0,("hpux_acl_sort: More than one entry for DEF_CLASS_OBJ \
1299 or DEF_USER_OBJ or DEF_GROUP_OBJ or DEF_OTHER_OBJ\n"));
1300                 return -1;
1301         }
1302
1303         /* We now have proper number of OBJ and DEF_OBJ entries. Now sort the acl
1304          * structures.
1305          *
1306          * Sorting crieteria - First sort by ACL type. If there are multiple entries of
1307          * same ACL type, sort by ACL id.
1308          *
1309          * I am using the trival kind of sorting method here because, performance isn't
1310          * really effected by the ACLs feature. More over there aren't going to be more
1311          * than 17 entries on HPUX.
1312          */
1313
1314         for(i=0; i<acl_count;i++) {
1315                 for (j=i+1; j<acl_count; j++) {
1316                         if( aclp[i].a_type > aclp[j].a_type ) {
1317                                 /* ACL entries out of order, swap them */
1318
1319                                 hpux_swap_acl_entries((aclp+i), (aclp+j));
1320
1321                         } else if ( aclp[i].a_type == aclp[j].a_type ) {
1322
1323                                 /* ACL entries of same type, sort by id */
1324
1325                                 if(aclp[i].a_id > aclp[j].a_id) {
1326                                         hpux_swap_acl_entries((aclp+i), (aclp+j));
1327                                 } else if (aclp[i].a_id == aclp[j].a_id) {
1328                                         /* We have a duplicate entry. */
1329                                         if(hpux_prohibited_duplicate_type(aclp[i].a_type)) {
1330                                                 DEBUG(0, ("hpux_acl_sort: Duplicate entry: Type(hex): %x Id: %d\n",
1331                                                         aclp[i].a_type, aclp[i].a_id));
1332                                                 return -1;
1333                                         }
1334                                 }
1335
1336                         }
1337                 }
1338         }
1339
1340         /* set the class obj permissions to the computed one. */
1341         if(calclass) {
1342                 int n_class_obj_index = -1;
1343
1344                 for(i=0;i<acl_count;i++) {
1345                         n_class_obj_perm |= hpux_get_needed_class_perm((aclp+i));
1346
1347                         if(aclp[i].a_type == CLASS_OBJ)
1348                                 n_class_obj_index = i;
1349                 }
1350                 aclp[n_class_obj_index].a_perm = n_class_obj_perm;
1351         }
1352
1353         return 0;
1354 #else
1355         return aclsort(acl_count, calclass, aclp);
1356 #endif
1357 }
1358
1359 /*
1360  * sort the ACL and check it for validity
1361  *
1362  * if it's a minimal ACL with only 4 entries then we
1363  * need to recalculate the mask permissions to make
1364  * sure that they are the same as the GROUP_OBJ
1365  * permissions as required by the UnixWare acl() system call.
1366  *
1367  * (note: since POSIX allows minimal ACLs which only contain
1368  * 3 entries - ie there is no mask entry - we should, in theory,
1369  * check for this and add a mask entry if necessary - however
1370  * we "know" that the caller of this interface always specifies
1371  * a mask so, in practice "this never happens" (tm) - if it *does*
1372  * happen aclsort() will fail and return an error and someone will
1373  * have to fix it ...)
1374  */
1375
1376 static int acl_sort(SMB_ACL_T acl_d)
1377 {
1378         int fixmask = (acl_d->count <= 4);
1379
1380         if (hpux_acl_sort(acl_d->count, fixmask, acl_d->acl) != 0) {
1381                 errno = EINVAL;
1382                 return -1;
1383         }
1384         return 0;
1385 }
1386
1387 int sys_acl_valid(SMB_ACL_T acl_d)
1388 {
1389         return acl_sort(acl_d);
1390 }
1391
1392 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
1393 {
1394         struct stat     s;
1395         struct acl      *acl_p;
1396         int             acl_count;
1397         struct acl      *acl_buf        = NULL;
1398         int             ret;
1399
1400         if(hpux_acl_call_presence() == False) {
1401                 /* Looks like we don't have the acl() system call on HPUX.
1402                  * May be the system doesn't have the latest version of JFS.
1403                  */
1404                 errno=ENOSYS;
1405                 return -1;
1406         }
1407
1408         if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) {
1409                 errno = EINVAL;
1410                 return -1;
1411         }
1412
1413         if (acl_sort(acl_d) != 0) {
1414                 return -1;
1415         }
1416
1417         acl_p           = &acl_d->acl[0];
1418         acl_count       = acl_d->count;
1419
1420         /*
1421          * if it's a directory there is extra work to do
1422          * since the acl() system call will replace both
1423          * the access ACLs and the default ACLs (if any)
1424          */
1425         if (stat(name, &s) != 0) {
1426                 return -1;
1427         }
1428         if (S_ISDIR(s.st_mode)) {
1429                 SMB_ACL_T       acc_acl;
1430                 SMB_ACL_T       def_acl;
1431                 SMB_ACL_T       tmp_acl;
1432                 int             i;
1433
1434                 if (type == SMB_ACL_TYPE_ACCESS) {
1435                         acc_acl = acl_d;
1436                         def_acl = tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_DEFAULT);
1437
1438                 } else {
1439                         def_acl = acl_d;
1440                         acc_acl = tmp_acl = sys_acl_get_file(name, SMB_ACL_TYPE_ACCESS);
1441                 }
1442
1443                 if (tmp_acl == NULL) {
1444                         return -1;
1445                 }
1446
1447                 /*
1448                  * allocate a temporary buffer for the complete ACL
1449                  */
1450                 acl_count = acc_acl->count + def_acl->count;
1451                 acl_p = acl_buf = SMB_MALLOC_ARRAY(struct acl, acl_count);
1452
1453                 if (acl_buf == NULL) {
1454                         sys_acl_free_acl(tmp_acl);
1455                         errno = ENOMEM;
1456                         return -1;
1457                 }
1458
1459                 /*
1460                  * copy the access control and default entries into the buffer
1461                  */
1462                 memcpy(&acl_buf[0], &acc_acl->acl[0],
1463                         acc_acl->count * sizeof(acl_buf[0]));
1464
1465                 memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],
1466                         def_acl->count * sizeof(acl_buf[0]));
1467
1468                 /*
1469                  * set the ACL_DEFAULT flag on the default entries
1470                  */
1471                 for (i = acc_acl->count; i < acl_count; i++) {
1472                         acl_buf[i].a_type |= ACL_DEFAULT;
1473                 }
1474
1475                 sys_acl_free_acl(tmp_acl);
1476
1477         } else if (type != SMB_ACL_TYPE_ACCESS) {
1478                 errno = EINVAL;
1479                 return -1;
1480         }
1481
1482         ret = acl(name, ACL_SET, acl_count, acl_p);
1483
1484         if (acl_buf) {
1485                 free(acl_buf);
1486         }
1487
1488         return ret;
1489 }
1490
1491 #if 0
1492 int sys_acl_set_fd(int fd, SMB_ACL_T acl_d)
1493 {
1494         /*
1495          * HPUX doesn't have the facl call. Fake it using the path.... JRA.
1496          */
1497
1498         files_struct *fsp = file_find_fd(fd);
1499
1500         if (fsp == NULL) {
1501                 errno = EBADF;
1502                 return NULL;
1503         }
1504
1505         if (acl_sort(acl_d) != 0) {
1506                 return -1;
1507         }
1508
1509         /*
1510          * We know we're in the same conn context. So we
1511          * can use the relative path.
1512          */
1513
1514         return sys_acl_set_file(fsp->fsp_name, SMB_ACL_TYPE_ACCESS, acl_d);
1515 }
1516 #endif
1517
1518 int sys_acl_delete_def_file(const char *path)
1519 {
1520         SMB_ACL_T       acl_d;
1521         int             ret;
1522
1523         /*
1524          * fetching the access ACL and rewriting it has
1525          * the effect of deleting the default ACL
1526          */
1527         if ((acl_d = sys_acl_get_file(path, SMB_ACL_TYPE_ACCESS)) == NULL) {
1528                 return -1;
1529         }
1530
1531         ret = acl(path, ACL_SET, acl_d->count, acl_d->acl);
1532
1533         sys_acl_free_acl(acl_d);
1534
1535         return ret;
1536 }
1537
1538 int sys_acl_free_acl(SMB_ACL_T acl_d)
1539 {
1540         free(acl_d);
1541         return 0;
1542 }
1543
1544 #elif defined(HAVE_IRIX_ACLS) /*---------------------------------------------*/
1545
1546 int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1547 {
1548         if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
1549                 errno = EINVAL;
1550                 return -1;
1551         }
1552
1553         if (entry_p == NULL) {
1554                 errno = EINVAL;
1555                 return -1;
1556         }
1557
1558         if (entry_id == SMB_ACL_FIRST_ENTRY) {
1559                 acl_d->next = 0;
1560         }
1561
1562         if (acl_d->next < 0) {
1563                 errno = EINVAL;
1564                 return -1;
1565         }
1566
1567         if (acl_d->next >= acl_d->aclp->acl_cnt) {
1568                 return 0;
1569         }
1570
1571         *entry_p = &acl_d->aclp->acl_entry[acl_d->next++];
1572
1573         return 1;
1574 }
1575
1576 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
1577 {
1578         *type_p = entry_d->ae_tag;
1579
1580         return 0;
1581 }
1582
1583 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
1584 {
1585         SMB_ACL_T       a;
1586
1587         if ((a = SMB_MALLOC_P(struct SMB_ACL_T)) == NULL) {
1588                 errno = ENOMEM;
1589                 return NULL;
1590         }
1591         if ((a->aclp = acl_get_file(path_p, type)) == NULL) {
1592                 SAFE_FREE(a);
1593                 return NULL;
1594         }
1595         a->next = -1;
1596         a->freeaclp = True;
1597         return a;
1598 }
1599
1600 #if 0
1601 SMB_ACL_T sys_acl_get_fd(int fd)
1602 {
1603         SMB_ACL_T       a;
1604
1605         if ((a = SMB_MALLOC_P(struct SMB_ACL_T)) == NULL) {
1606                 errno = ENOMEM;
1607                 return NULL;
1608         }
1609         if ((a->aclp = acl_get_fd(fd)) == NULL) {
1610                 SAFE_FREE(a);
1611                 return NULL;
1612         }
1613         a->next = -1;
1614         a->freeaclp = True;
1615         return a;
1616 }
1617 #endif
1618
1619 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
1620 {
1621         *tag_type_p = entry->ae_tag;
1622
1623         *bits_p = entry->ae_perm;
1624
1625         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP)
1626                 *u_g_id_p = entry->ae_id;
1627
1628         return 0;
1629 }
1630
1631 SMB_ACL_T sys_acl_init(int count)
1632 {
1633         SMB_ACL_T       a;
1634
1635         if (count < 0) {
1636                 errno = EINVAL;
1637                 return NULL;
1638         }
1639
1640         if ((a = SMB_MALLOC(sizeof(struct SMB_ACL_T) + sizeof(struct acl))) == NULL) {
1641                 errno = ENOMEM;
1642                 return NULL;
1643         }
1644
1645         a->next = -1;
1646         a->freeaclp = False;
1647         a->aclp = (struct acl *)(&a->aclp + sizeof(struct acl *));
1648         a->aclp->acl_cnt = 0;
1649
1650         return a;
1651 }
1652
1653
1654 int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
1655 {
1656         SMB_ACL_T       acl_d;
1657         SMB_ACL_ENTRY_T entry_d;
1658
1659         if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
1660                 errno = EINVAL;
1661                 return -1;
1662         }
1663
1664         if (acl_d->aclp->acl_cnt >= ACL_MAX_ENTRIES) {
1665                 errno = ENOSPC;
1666                 return -1;
1667         }
1668
1669         entry_d         = &acl_d->aclp->acl_entry[acl_d->aclp->acl_cnt++];
1670         entry_d->ae_tag = 0;
1671         entry_d->ae_id  = 0;
1672         entry_d->ae_perm        = 0;
1673         *entry_p        = entry_d;
1674
1675         return 0;
1676 }
1677
1678 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
1679 {
1680         entry->ae_tag = tag_type;
1681
1682         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP)
1683                 entry->ae_id = u_g_id;
1684
1685         entry->ae_perm = bits;
1686
1687         return 0;
1688 }
1689
1690 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry_d, uint32 bits)
1691 {
1692         entry_d->ae_perm = bits;
1693
1694         return 0;
1695 }
1696
1697 int sys_acl_valid(SMB_ACL_T acl_d)
1698 {
1699         return acl_valid(acl_d->aclp);
1700 }
1701
1702 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
1703 {
1704         return acl_set_file(name, type, acl_d->aclp);
1705 }
1706
1707 #if 0
1708 int sys_acl_set_fd(int fd, SMB_ACL_T acl_d)
1709 {
1710         return acl_set_fd(fd, acl_d->aclp);
1711 }
1712 #endif
1713
1714 int sys_acl_delete_def_file(const char *name)
1715 {
1716         return acl_delete_def_file(name);
1717 }
1718
1719 int sys_acl_free_acl(SMB_ACL_T acl_d)
1720 {
1721         if (acl_d->freeaclp) {
1722                 acl_free(acl_d->aclp);
1723         }
1724         acl_free(acl_d);
1725         return 0;
1726 }
1727
1728 #elif defined(HAVE_AIX_ACLS) /*----------------------------------------------*/
1729
1730 /* Donated by Medha Date, mdate@austin.ibm.com, for IBM */
1731
1732 int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1733 {
1734         struct acl_entry_link *link;
1735         struct new_acl_entry *entry;
1736         int keep_going;
1737
1738         DEBUG(10,("This is the count: %d\n",theacl->count));
1739
1740         /* Check if count was previously set to -1. *
1741          * If it was, that means we reached the end *
1742          * of the acl last time.                    */
1743         if(theacl->count == -1)
1744                 return(0);
1745
1746         link = theacl;
1747         /* To get to the next acl, traverse linked list until index *
1748          * of acl matches the count we are keeping.  This count is  *
1749          * incremented each time we return an acl entry.            */
1750
1751         for(keep_going = 0; keep_going < theacl->count; keep_going++)
1752                 link = link->nextp;
1753
1754         entry = *entry_p =  link->entryp;
1755
1756         DEBUG(10,("*entry_p is %d\n",entry_p));
1757         DEBUG(10,("*entry_p->ace_access is %d\n",entry->ace_access));
1758
1759         /* Increment count */
1760         theacl->count++;
1761         if(link->nextp == NULL)
1762                 theacl->count = -1;
1763
1764         return(1);
1765 }
1766
1767 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
1768 {
1769         /* Initialize tag type */
1770
1771         *tag_type_p = -1;
1772         DEBUG(10,("the tagtype is %d\n",entry_d->ace_id->id_type));
1773
1774         /* Depending on what type of entry we have, *
1775          * return tag type.                         */
1776         switch(entry_d->ace_id->id_type) {
1777         case ACEID_USER:
1778                 *tag_type_p = SMB_ACL_USER;
1779                 break;
1780         case ACEID_GROUP:
1781                 *tag_type_p = SMB_ACL_GROUP;
1782                 break;
1783
1784         case SMB_ACL_USER_OBJ:
1785         case SMB_ACL_GROUP_OBJ:
1786         case SMB_ACL_OTHER:
1787                 *tag_type_p = entry_d->ace_id->id_type;
1788                 break;
1789
1790         default:
1791                 return(-1);
1792         }
1793
1794         return(0);
1795 }
1796
1797 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)
1798 {
1799         struct acl *file_acl = (struct acl *)NULL;
1800         struct acl_entry *acl_entry;
1801         struct new_acl_entry *new_acl_entry;
1802         struct ace_id *idp;
1803         struct acl_entry_link *acl_entry_link;
1804         struct acl_entry_link *acl_entry_link_head;
1805         int i;
1806         int rc = 0;
1807         uid_t user_id;
1808
1809         /* AIX has no DEFAULT */
1810         if  ( type == SMB_ACL_TYPE_DEFAULT ) {
1811                 errno = ENOTSUP;
1812                 return NULL;
1813         }
1814
1815         /* Get the acl using statacl */
1816
1817         DEBUG(10,("Entering sys_acl_get_file\n"));
1818         DEBUG(10,("path_p is %s\n",path_p));
1819
1820         file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);
1821
1822         if(file_acl == NULL) {
1823                 errno=ENOMEM;
1824                 DEBUG(0,("Error in AIX sys_acl_get_file: %d\n",errno));
1825                 return(NULL);
1826         }
1827
1828         memset(file_acl,0,BUFSIZ);
1829
1830         rc = statacl((char *)path_p,0,file_acl,BUFSIZ);
1831         if(rc == -1) {
1832                 DEBUG(0,("statacl returned %d with errno %d\n",rc,errno));
1833                 SAFE_FREE(file_acl);
1834                 return(NULL);
1835         }
1836
1837         DEBUG(10,("Got facl and returned it\n"));
1838
1839         /* Point to the first acl entry in the acl */
1840         acl_entry =  file_acl->acl_ext;
1841
1842         /* Begin setting up the head of the linked list *
1843          * that will be used for the storing the acl    *
1844          * in a way that is useful for the posix_acls.c *
1845          * code.                                          */
1846
1847         acl_entry_link_head = acl_entry_link = sys_acl_init(0);
1848         if(acl_entry_link_head == NULL)
1849                 return(NULL);
1850
1851         acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
1852         if(acl_entry_link->entryp == NULL) {
1853                 SAFE_FREE(file_acl);
1854                 errno = ENOMEM;
1855                 DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
1856                 return(NULL);
1857         }
1858
1859         DEBUG(10,("acl_entry is %d\n",acl_entry));
1860         DEBUG(10,("acl_last(file_acl) id %d\n",acl_last(file_acl)));
1861
1862         /* Check if the extended acl bit is on.   *
1863          * If it isn't, do not show the           *
1864          * contents of the acl since AIX intends *
1865          * the extended info to remain unused     */
1866
1867         if(file_acl->acl_mode & S_IXACL){
1868                 /* while we are not pointing to the very end */
1869                 while(acl_entry < acl_last(file_acl)) {
1870                         /* before we malloc anything, make sure this is  */
1871                         /* a valid acl entry and one that we want to map */
1872                         idp = id_nxt(acl_entry->ace_id);
1873                         if((acl_entry->ace_type == ACC_SPECIFY ||
1874                                 (acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) {
1875                                         acl_entry = acl_nxt(acl_entry);
1876                                         continue;
1877                         }
1878
1879                         idp = acl_entry->ace_id;
1880
1881                         /* Check if this is the first entry in the linked list. *
1882                          * The first entry needs to keep prevp pointing to NULL *
1883                          * and already has entryp allocated.                  */
1884
1885                         if(acl_entry_link_head->count != 0) {
1886                                 acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
1887
1888                                 if(acl_entry_link->nextp == NULL) {
1889                                         SAFE_FREE(file_acl);
1890                                         errno = ENOMEM;
1891                                         DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
1892                                         return(NULL);
1893                                 }
1894
1895                                 acl_entry_link->nextp->prevp = acl_entry_link;
1896                                 acl_entry_link = acl_entry_link->nextp;
1897                                 acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
1898                                 if(acl_entry_link->entryp == NULL) {
1899                                         SAFE_FREE(file_acl);
1900                                         errno = ENOMEM;
1901                                         DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
1902                                         return(NULL);
1903                                 }
1904                                 acl_entry_link->nextp = NULL;
1905                         }
1906
1907                         acl_entry_link->entryp->ace_len = acl_entry->ace_len;
1908
1909                         /* Don't really need this since all types are going *
1910                          * to be specified but, it's better than leaving it 0 */
1911
1912                         acl_entry_link->entryp->ace_type = acl_entry->ace_type;
1913
1914                         acl_entry_link->entryp->ace_access = acl_entry->ace_access;
1915
1916                         memcpy(acl_entry_link->entryp->ace_id,idp,sizeof(struct ace_id));
1917
1918                         /* The access in the acl entries must be left shifted by *
1919                          * three bites, because they will ultimately be compared *
1920                          * to S_IRUSR, S_IWUSR, and S_IXUSR.                  */
1921
1922                         switch(acl_entry->ace_type){
1923                         case ACC_PERMIT:
1924                         case ACC_SPECIFY:
1925                                 acl_entry_link->entryp->ace_access = acl_entry->ace_access;
1926                                 acl_entry_link->entryp->ace_access <<= 6;
1927                                 acl_entry_link_head->count++;
1928                                 break;
1929                         case ACC_DENY:
1930                                 /* Since there is no way to return a DENY acl entry *
1931                                  * change to PERMIT and then shift.                 */
1932                                 DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access));
1933                                 acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;
1934                                 DEBUG(10,("acl_entry_link->entryp->ace_access is %d\n",acl_entry_link->entryp->ace_access));
1935                                 acl_entry_link->entryp->ace_access <<= 6;
1936                                 acl_entry_link_head->count++;
1937                                 break;
1938                         default:
1939                                 return(0);
1940                         }
1941
1942                         DEBUG(10,("acl_entry = %d\n",acl_entry));
1943                         DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type));
1944
1945                         acl_entry = acl_nxt(acl_entry);
1946                 }
1947         } /* end of if enabled */
1948
1949         /* Since owner, group, other acl entries are not *
1950          * part of the acl entries in an acl, they must  *
1951          * be dummied up to become part of the list.     */
1952
1953         for( i = 1; i < 4; i++) {
1954                 DEBUG(10,("i is %d\n",i));
1955                 if(acl_entry_link_head->count != 0) {
1956                         acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
1957                         if(acl_entry_link->nextp == NULL) {
1958                                 SAFE_FREE(file_acl);
1959                                 errno = ENOMEM;
1960                                 DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
1961                                 return(NULL);
1962                         }
1963
1964                         acl_entry_link->nextp->prevp = acl_entry_link;
1965                         acl_entry_link = acl_entry_link->nextp;
1966                         acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
1967                         if(acl_entry_link->entryp == NULL) {
1968                                 SAFE_FREE(file_acl);
1969                                 errno = ENOMEM;
1970                                 DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
1971                                 return(NULL);
1972                         }
1973                 }
1974
1975                 acl_entry_link->nextp = NULL;
1976
1977                 new_acl_entry = acl_entry_link->entryp;
1978                 idp = new_acl_entry->ace_id;
1979
1980                 new_acl_entry->ace_len = sizeof(struct acl_entry);
1981                 new_acl_entry->ace_type = ACC_PERMIT;
1982                 idp->id_len = sizeof(struct ace_id);
1983                 DEBUG(10,("idp->id_len = %d\n",idp->id_len));
1984                 memset(idp->id_data,0,sizeof(uid_t));
1985
1986                 switch(i) {
1987                 case 2:
1988                         new_acl_entry->ace_access = file_acl->g_access << 6;
1989                         idp->id_type = SMB_ACL_GROUP_OBJ;
1990                         break;
1991
1992                 case 3:
1993                         new_acl_entry->ace_access = file_acl->o_access << 6;
1994                         idp->id_type = SMB_ACL_OTHER;
1995                         break;
1996
1997                 case 1:
1998                         new_acl_entry->ace_access = file_acl->u_access << 6;
1999                         idp->id_type = SMB_ACL_USER_OBJ;
2000                         break;
2001
2002                 default:
2003                         return(NULL);
2004
2005                 }
2006
2007                 acl_entry_link_head->count++;
2008                 DEBUG(10,("new_acl_entry->ace_access = %d\n",new_acl_entry->ace_access));
2009         }
2010
2011         acl_entry_link_head->count = 0;
2012         SAFE_FREE(file_acl);
2013
2014         return(acl_entry_link_head);
2015 }
2016
2017 #if 0
2018 SMB_ACL_T sys_acl_get_fd(int fd)
2019 {
2020         struct acl *file_acl = (struct acl *)NULL;
2021         struct acl_entry *acl_entry;
2022         struct new_acl_entry *new_acl_entry;
2023         struct ace_id *idp;
2024         struct acl_entry_link *acl_entry_link;
2025         struct acl_entry_link *acl_entry_link_head;
2026         int i;
2027         int rc = 0;
2028         uid_t user_id;
2029
2030         /* Get the acl using fstatacl */
2031
2032         DEBUG(10,("Entering sys_acl_get_fd\n"));
2033         DEBUG(10,("fd is %d\n",fd));
2034         file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);
2035
2036         if(file_acl == NULL) {
2037                 errno=ENOMEM;
2038                 DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2039                 return(NULL);
2040         }
2041
2042         memset(file_acl,0,BUFSIZ);
2043
2044         rc = fstatacl(fd,0,file_acl,BUFSIZ);
2045         if(rc == -1) {
2046                 DEBUG(0,("The fstatacl call returned %d with errno %d\n",rc,errno));
2047                 SAFE_FREE(file_acl);
2048                 return(NULL);
2049         }
2050
2051         DEBUG(10,("Got facl and returned it\n"));
2052
2053         /* Point to the first acl entry in the acl */
2054
2055         acl_entry =  file_acl->acl_ext;
2056         /* Begin setting up the head of the linked list *
2057          * that will be used for the storing the acl    *
2058          * in a way that is useful for the posix_acls.c *
2059          * code.                                        */
2060
2061         acl_entry_link_head = acl_entry_link = sys_acl_init(0);
2062         if(acl_entry_link_head == NULL){
2063                 SAFE_FREE(file_acl);
2064                 return(NULL);
2065         }
2066
2067         acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
2068
2069         if(acl_entry_link->entryp == NULL) {
2070                 errno = ENOMEM;
2071                 DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2072                 SAFE_FREE(file_acl);
2073                 return(NULL);
2074         }
2075
2076         DEBUG(10,("acl_entry is %d\n",acl_entry));
2077         DEBUG(10,("acl_last(file_acl) id %d\n",acl_last(file_acl)));
2078
2079         /* Check if the extended acl bit is on.   *
2080          * If it isn't, do not show the           *
2081          * contents of the acl since AIX intends  *
2082          * the extended info to remain unused     */
2083
2084         if(file_acl->acl_mode & S_IXACL){
2085                 /* while we are not pointing to the very end */
2086                 while(acl_entry < acl_last(file_acl)) {
2087                         /* before we malloc anything, make sure this is  */
2088                         /* a valid acl entry and one that we want to map */
2089
2090                         idp = id_nxt(acl_entry->ace_id);
2091                         if((acl_entry->ace_type == ACC_SPECIFY ||
2092                                 (acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) {
2093                                         acl_entry = acl_nxt(acl_entry);
2094                                         continue;
2095                         }
2096
2097                         idp = acl_entry->ace_id;
2098
2099                         /* Check if this is the first entry in the linked list. *
2100                          * The first entry needs to keep prevp pointing to NULL *
2101                          * and already has entryp allocated.                 */
2102
2103                         if(acl_entry_link_head->count != 0) {
2104                                 acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
2105                                 if(acl_entry_link->nextp == NULL) {
2106                                         errno = ENOMEM;
2107                                         DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2108                                         SAFE_FREE(file_acl);
2109                                         return(NULL);
2110                                 }
2111                                 acl_entry_link->nextp->prevp = acl_entry_link;
2112                                 acl_entry_link = acl_entry_link->nextp;
2113                                 acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
2114                                 if(acl_entry_link->entryp == NULL) {
2115                                         errno = ENOMEM;
2116                                         DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2117                                         SAFE_FREE(file_acl);
2118                                         return(NULL);
2119                                 }
2120
2121                                 acl_entry_link->nextp = NULL;
2122                         }
2123
2124                         acl_entry_link->entryp->ace_len = acl_entry->ace_len;
2125
2126                         /* Don't really need this since all types are going *
2127                          * to be specified but, it's better than leaving it 0 */
2128
2129                         acl_entry_link->entryp->ace_type = acl_entry->ace_type;
2130                         acl_entry_link->entryp->ace_access = acl_entry->ace_access;
2131
2132                         memcpy(acl_entry_link->entryp->ace_id, idp, sizeof(struct ace_id));
2133
2134                         /* The access in the acl entries must be left shifted by *
2135                          * three bites, because they will ultimately be compared *
2136                          * to S_IRUSR, S_IWUSR, and S_IXUSR.                  */
2137
2138                         switch(acl_entry->ace_type){
2139                         case ACC_PERMIT:
2140                         case ACC_SPECIFY:
2141                                 acl_entry_link->entryp->ace_access = acl_entry->ace_access;
2142                                 acl_entry_link->entryp->ace_access <<= 6;
2143                                 acl_entry_link_head->count++;
2144                                 break;
2145                         case ACC_DENY:
2146                                 /* Since there is no way to return a DENY acl entry *
2147                                  * change to PERMIT and then shift.                 */
2148                                 DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access));
2149                                 acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;
2150                                 DEBUG(10,("acl_entry_link->entryp->ace_access is %d\n",acl_entry_link->entryp->ace_access));
2151                                 acl_entry_link->entryp->ace_access <<= 6;
2152                                 acl_entry_link_head->count++;
2153                                 break;
2154                         default:
2155                                 return(0);
2156                         }
2157
2158                         DEBUG(10,("acl_entry = %d\n",acl_entry));
2159                         DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type));
2160
2161                         acl_entry = acl_nxt(acl_entry);
2162                 }
2163         } /* end of if enabled */
2164
2165         /* Since owner, group, other acl entries are not *
2166          * part of the acl entries in an acl, they must  *
2167          * be dummied up to become part of the list.     */
2168
2169         for( i = 1; i < 4; i++) {
2170                 DEBUG(10,("i is %d\n",i));
2171                 if(acl_entry_link_head->count != 0){
2172                         acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
2173                         if(acl_entry_link->nextp == NULL) {
2174                                 errno = ENOMEM;
2175                                 DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2176                                 SAFE_FREE(file_acl);
2177                                 return(NULL);
2178                         }
2179
2180                         acl_entry_link->nextp->prevp = acl_entry_link;
2181                         acl_entry_link = acl_entry_link->nextp;
2182                         acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
2183
2184                         if(acl_entry_link->entryp == NULL) {
2185                                 SAFE_FREE(file_acl);
2186                                 errno = ENOMEM;
2187                                 DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));
2188                                 return(NULL);
2189                         }
2190                 }
2191
2192                 acl_entry_link->nextp = NULL;
2193
2194                 new_acl_entry = acl_entry_link->entryp;
2195                 idp = new_acl_entry->ace_id;
2196
2197                 new_acl_entry->ace_len = sizeof(struct acl_entry);
2198                 new_acl_entry->ace_type = ACC_PERMIT;
2199                 idp->id_len = sizeof(struct ace_id);
2200                 DEBUG(10,("idp->id_len = %d\n",idp->id_len));
2201                 memset(idp->id_data,0,sizeof(uid_t));
2202
2203                 switch(i) {
2204                 case 2:
2205                         new_acl_entry->ace_access = file_acl->g_access << 6;
2206                         idp->id_type = SMB_ACL_GROUP_OBJ;
2207                         break;
2208
2209                 case 3:
2210                         new_acl_entry->ace_access = file_acl->o_access << 6;
2211                         idp->id_type = SMB_ACL_OTHER;
2212                         break;
2213
2214                 case 1:
2215                         new_acl_entry->ace_access = file_acl->u_access << 6;
2216                         idp->id_type = SMB_ACL_USER_OBJ;
2217                         break;
2218
2219                 default:
2220                         return(NULL);
2221                 }
2222
2223                 acl_entry_link_head->count++;
2224                 DEBUG(10,("new_acl_entry->ace_access = %d\n",new_acl_entry->ace_access));
2225         }
2226
2227         acl_entry_link_head->count = 0;
2228         SAFE_FREE(file_acl);
2229
2230         return(acl_entry_link_head);
2231 }
2232 #endif
2233
2234 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
2235 {
2236         uint *permset;
2237
2238         if (sys_acl_get_tag_type(entry, tag_type_p) != 0)
2239                 return -1;
2240
2241         if (*tag_type_p == SMB_ACL_USER || *tag_type_p == SMB_ACL_GROUP)
2242                 memcpy(u_g_id_p, entry->ace_id->id_data, sizeof (id_t));
2243
2244         permset = &entry->ace_access;
2245
2246         DEBUG(10,("*permset is %d\n",*permset));
2247         *bits_p = (*permset & S_IRUSR ? 4 : 0)
2248                 | (*permset & S_IWUSR ? 2 : 0)
2249                 | (*permset & S_IXUSR ? 1 : 0);
2250
2251         return 0;
2252 }
2253
2254 SMB_ACL_T sys_acl_init( int count)
2255 {
2256         struct acl_entry_link *theacl = NULL;
2257
2258         DEBUG(10,("Entering sys_acl_init\n"));
2259
2260         theacl = SMB_MALLOC_P(struct acl_entry_link);
2261         if(theacl == NULL) {
2262                 errno = ENOMEM;
2263                 DEBUG(0,("Error in sys_acl_init is %d\n",errno));
2264                 return(NULL);
2265         }
2266
2267         theacl->count = 0;
2268         theacl->nextp = NULL;
2269         theacl->prevp = NULL;
2270         theacl->entryp = NULL;
2271         DEBUG(10,("Exiting sys_acl_init\n"));
2272         return(theacl);
2273 }
2274
2275 int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
2276 {
2277         struct acl_entry_link *theacl;
2278         struct acl_entry_link *acl_entryp;
2279         struct acl_entry_link *temp_entry;
2280         int counting;
2281
2282         DEBUG(10,("Entering the sys_acl_create_entry\n"));
2283
2284         theacl = acl_entryp = *pacl;
2285
2286         /* Get to the end of the acl before adding entry */
2287
2288         for(counting=0; counting < theacl->count; counting++){
2289                 DEBUG(10,("The acl_entryp is %d\n",acl_entryp));
2290                 temp_entry = acl_entryp;
2291                 acl_entryp = acl_entryp->nextp;
2292         }
2293
2294         if(theacl->count != 0){
2295                 temp_entry->nextp = acl_entryp = SMB_MALLOC_P(struct acl_entry_link);
2296                 if(acl_entryp == NULL) {
2297                         errno = ENOMEM;
2298                         DEBUG(0,("Error in sys_acl_create_entry is %d\n",errno));
2299                         return(-1);
2300                 }
2301
2302                 DEBUG(10,("The acl_entryp is %d\n",acl_entryp));
2303                 acl_entryp->prevp = temp_entry;
2304                 DEBUG(10,("The acl_entryp->prevp is %d\n",acl_entryp->prevp));
2305         }
2306
2307         *pentry = acl_entryp->entryp = SMB_MALLOC_P(struct new_acl_entry);
2308         if(*pentry == NULL) {
2309                 errno = ENOMEM;
2310                 DEBUG(0,("Error in sys_acl_create_entry is %d\n",errno));
2311                 return(-1);
2312         }
2313
2314         memset(*pentry,0,sizeof(struct new_acl_entry));
2315         acl_entryp->entryp->ace_len = sizeof(struct acl_entry);
2316         acl_entryp->entryp->ace_type = ACC_PERMIT;
2317         acl_entryp->entryp->ace_id->id_len = sizeof(struct ace_id);
2318         acl_entryp->nextp = NULL;
2319         theacl->count++;
2320         DEBUG(10,("Exiting sys_acl_create_entry\n"));
2321         return(0);
2322 }
2323
2324 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
2325 {
2326         entry->ace_id->id_type = tag_type;
2327         DEBUG(10,("The tag type is %d\n",entry->ace_id->id_type));
2328
2329         if (tag_type == SMB_ACL_USER || tag_type == SMB_ACL_GROUP)
2330                 memcpy(entry->ace_id->id_data, &u_g_id, sizeof (id_t));
2331
2332         entry->ace_access = bits;
2333         DEBUG(10,("entry->ace_access = %d\n",entry->ace_access));
2334
2335         return 0;
2336 }
2337
2338 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
2339 {
2340         DEBUG(10,("Starting AIX sys_acl_set_permset\n"));
2341         entry->ace_access = bits;
2342         DEBUG(10,("entry->ace_access = %d\n",entry->ace_access));
2343         DEBUG(10,("Ending AIX sys_acl_set_permset\n"));
2344         return(0);
2345 }
2346
2347 int sys_acl_valid( SMB_ACL_T theacl )
2348 {
2349         int user_obj = 0;
2350         int group_obj = 0;
2351         int other_obj = 0;
2352         struct acl_entry_link *acl_entry;
2353
2354         for(acl_entry=theacl; acl_entry != NULL; acl_entry = acl_entry->nextp) {
2355                 user_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_USER_OBJ);
2356                 group_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_GROUP_OBJ);
2357                 other_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_OTHER);
2358         }
2359
2360         DEBUG(10,("user_obj=%d, group_obj=%d, other_obj=%d\n",user_obj,group_obj,other_obj));
2361
2362         if(user_obj != 1 || group_obj != 1 || other_obj != 1)
2363                 return(-1);
2364
2365         return(0);
2366 }
2367
2368 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
2369 {
2370         struct acl_entry_link *acl_entry_link = NULL;
2371         struct acl *file_acl = NULL;
2372         struct acl *file_acl_temp = NULL;
2373         struct acl_entry *acl_entry = NULL;
2374         struct ace_id *ace_id = NULL;
2375         uint id_type;
2376         uint ace_access;
2377         uint user_id;
2378         uint acl_length;
2379         uint rc;
2380
2381         DEBUG(10,("Entering sys_acl_set_file\n"));
2382         DEBUG(10,("File name is %s\n",name));
2383
2384         /* AIX has no default ACL */
2385         if(acltype == SMB_ACL_TYPE_DEFAULT)
2386                 return(0);
2387
2388         acl_length = BUFSIZ;
2389         file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);
2390
2391         if(file_acl == NULL) {
2392                 errno = ENOMEM;
2393                 DEBUG(0,("Error in sys_acl_set_file is %d\n",errno));
2394                 return(-1);
2395         }
2396
2397         memset(file_acl,0,BUFSIZ);
2398
2399         file_acl->acl_len = ACL_SIZ;
2400         file_acl->acl_mode = S_IXACL;
2401
2402         for(acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {
2403                 acl_entry_link->entryp->ace_access >>= 6;
2404                 id_type = acl_entry_link->entryp->ace_id->id_type;
2405
2406                 switch(id_type) {
2407                 case SMB_ACL_USER_OBJ:
2408                         file_acl->u_access = acl_entry_link->entryp->ace_access;
2409                         continue;
2410                 case SMB_ACL_GROUP_OBJ:
2411                         file_acl->g_access = acl_entry_link->entryp->ace_access;
2412                         continue;
2413                 case SMB_ACL_OTHER:
2414                         file_acl->o_access = acl_entry_link->entryp->ace_access;
2415                         continue;
2416                 case SMB_ACL_MASK:
2417                         continue;
2418                 }
2419
2420                 if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) {
2421                         acl_length += sizeof(struct acl_entry);
2422                         file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);
2423                         if(file_acl_temp == NULL) {
2424                                 SAFE_FREE(file_acl);
2425                                 errno = ENOMEM;
2426                                 DEBUG(0,("Error in sys_acl_set_file is %d\n",errno));
2427                                 return(-1);
2428                         }
2429
2430                         memcpy(file_acl_temp,file_acl,file_acl->acl_len);
2431                         SAFE_FREE(file_acl);
2432                         file_acl = file_acl_temp;
2433                 }
2434
2435                 acl_entry = (struct acl_entry *)((char *)file_acl + file_acl->acl_len);
2436                 file_acl->acl_len += sizeof(struct acl_entry);
2437                 acl_entry->ace_len = acl_entry_link->entryp->ace_len;
2438                 acl_entry->ace_access = acl_entry_link->entryp->ace_access;
2439
2440                 /* In order to use this, we'll need to wait until we can get denies */
2441                 /* if(!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)
2442                 acl_entry->ace_type = ACC_SPECIFY; */
2443
2444                 acl_entry->ace_type = ACC_SPECIFY;
2445
2446                 ace_id = acl_entry->ace_id;
2447
2448                 ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;
2449                 DEBUG(10,("The id type is %d\n",ace_id->id_type));
2450                 ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;
2451                 memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof(uid_t));
2452                 memcpy(acl_entry->ace_id->id_data, &user_id, sizeof(uid_t));
2453         }
2454
2455         rc = chacl((char*)name,file_acl,file_acl->acl_len);
2456         DEBUG(10,("errno is %d\n",errno));
2457         DEBUG(10,("return code is %d\n",rc));
2458         SAFE_FREE(file_acl);
2459         DEBUG(10,("Exiting the sys_acl_set_file\n"));
2460         return(rc);
2461 }
2462
2463 #if 0
2464 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
2465 {
2466         struct acl_entry_link *acl_entry_link = NULL;
2467         struct acl *file_acl = NULL;
2468         struct acl *file_acl_temp = NULL;
2469         struct acl_entry *acl_entry = NULL;
2470         struct ace_id *ace_id = NULL;
2471         uint id_type;
2472         uint user_id;
2473         uint acl_length;
2474         uint rc;
2475
2476         DEBUG(10,("Entering sys_acl_set_fd\n"));
2477         acl_length = BUFSIZ;
2478         file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);
2479
2480         if(file_acl == NULL) {
2481                 errno = ENOMEM;
2482                 DEBUG(0,("Error in sys_acl_set_fd is %d\n",errno));
2483                 return(-1);
2484         }
2485
2486         memset(file_acl,0,BUFSIZ);
2487
2488         file_acl->acl_len = ACL_SIZ;
2489         file_acl->acl_mode = S_IXACL;
2490
2491         for(acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {
2492                 acl_entry_link->entryp->ace_access >>= 6;
2493                 id_type = acl_entry_link->entryp->ace_id->id_type;
2494                 DEBUG(10,("The id_type is %d\n",id_type));
2495
2496                 switch(id_type) {
2497                 case SMB_ACL_USER_OBJ:
2498                         file_acl->u_access = acl_entry_link->entryp->ace_access;
2499                         continue;
2500                 case SMB_ACL_GROUP_OBJ:
2501                         file_acl->g_access = acl_entry_link->entryp->ace_access;
2502                         continue;
2503                 case SMB_ACL_OTHER:
2504                         file_acl->o_access = acl_entry_link->entryp->ace_access;
2505                         continue;
2506                 case SMB_ACL_MASK:
2507                         continue;
2508                 }
2509
2510                 if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) {
2511                         acl_length += sizeof(struct acl_entry);
2512                         file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);
2513                         if(file_acl_temp == NULL) {
2514                                 SAFE_FREE(file_acl);
2515                                 errno = ENOMEM;
2516                                 DEBUG(0,("Error in sys_acl_set_fd is %d\n",errno));
2517                                 return(-1);
2518                         }
2519
2520                         memcpy(file_acl_temp,file_acl,file_acl->acl_len);
2521                         SAFE_FREE(file_acl);
2522                         file_acl = file_acl_temp;
2523                 }
2524
2525                 acl_entry = (struct acl_entry *)((char *)file_acl + file_acl->acl_len);
2526                 file_acl->acl_len += sizeof(struct acl_entry);
2527                 acl_entry->ace_len = acl_entry_link->entryp->ace_len;
2528                 acl_entry->ace_access = acl_entry_link->entryp->ace_access;
2529
2530                 /* In order to use this, we'll need to wait until we can get denies */
2531                 /* if(!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)
2532                         acl_entry->ace_type = ACC_SPECIFY; */
2533
2534                 acl_entry->ace_type = ACC_SPECIFY;
2535
2536                 ace_id = acl_entry->ace_id;
2537
2538                 ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;
2539                 DEBUG(10,("The id type is %d\n",ace_id->id_type));
2540                 ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;
2541                 memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof(uid_t));
2542                 memcpy(ace_id->id_data, &user_id, sizeof(uid_t));
2543         }
2544
2545         rc = fchacl(fd,file_acl,file_acl->acl_len);
2546         DEBUG(10,("errno is %d\n",errno));
2547         DEBUG(10,("return code is %d\n",rc));
2548         SAFE_FREE(file_acl);
2549         DEBUG(10,("Exiting sys_acl_set_fd\n"));
2550         return(rc);
2551 }
2552 #endif
2553
2554 int sys_acl_delete_def_file(const char *name)
2555 {
2556         /* AIX has no default ACL */
2557         return 0;
2558 }
2559
2560 int sys_acl_free_acl(SMB_ACL_T posix_acl)
2561 {
2562         struct acl_entry_link *acl_entry_link;
2563
2564         for(acl_entry_link = posix_acl->nextp; acl_entry_link->nextp != NULL; acl_entry_link = acl_entry_link->nextp) {
2565                 SAFE_FREE(acl_entry_link->prevp->entryp);
2566                 SAFE_FREE(acl_entry_link->prevp);
2567         }
2568
2569         SAFE_FREE(acl_entry_link->prevp->entryp);
2570         SAFE_FREE(acl_entry_link->prevp);
2571         SAFE_FREE(acl_entry_link->entryp);
2572         SAFE_FREE(acl_entry_link);
2573
2574         return(0);
2575 }
2576
2577 #elif defined(HAVE_OSX_ACLS) /*----------------------------------------------*/
2578
2579 #define OSX_BROKEN_GETENTRY /* returns 0 instead of 1 */
2580
2581 #include <membership.h>
2582
2583 int sys_acl_get_entry(SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
2584 {
2585         int ret = acl_get_entry(the_acl, entry_id, entry_p);
2586 #ifdef OSX_BROKEN_GETENTRY
2587         if (ret == 0)
2588                 ret = 1;
2589         else if (ret == -1 && errno == 22)
2590                 ret = 0;
2591 #endif
2592         return ret;
2593 }
2594
2595 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
2596 {
2597         if (type == ACL_TYPE_DEFAULT) {
2598                 errno = ENOTSUP;
2599                 return NULL;
2600         }
2601         errno = 0;
2602         return acl_get_file(path_p, type);
2603 }
2604
2605 #if 0
2606 SMB_ACL_T sys_acl_get_fd(int fd)
2607 {
2608         return acl_get_fd(fd);
2609 }
2610 #endif
2611
2612 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T *tag_type_p, uint32 *bits_p, id_t *u_g_id_p)
2613 {
2614         uuid_t *uup;
2615         acl_tag_t tag;
2616         acl_flagset_t flagset;
2617         acl_permset_t permset;
2618         uint32 bits, fb, bb, pb;
2619         int id_type = -1;
2620         int rc;
2621
2622         if (acl_get_tag_type(entry, &tag) != 0
2623          || acl_get_flagset_np(entry, &flagset) != 0
2624          || acl_get_permset(entry, &permset) != 0
2625          || (uup = acl_get_qualifier(entry)) == NULL)
2626                 return -1;
2627
2628         rc = mbr_uuid_to_id(*uup, u_g_id_p, &id_type);
2629         acl_free(uup);
2630         if (rc != 0)
2631                 return rc;
2632
2633         if (id_type == ID_TYPE_UID)
2634                 *tag_type_p = SMB_ACL_USER;
2635         else
2636                 *tag_type_p = SMB_ACL_GROUP;
2637
2638         bits = tag == ACL_EXTENDED_ALLOW ? 1 : 0;
2639
2640         for (fb = (1u<<4), bb = (1u<<1); bb < (1u<<12); fb *= 2, bb *= 2) {
2641                 if (acl_get_flag_np(flagset, fb) == 1)
2642                         bits |= bb;
2643         }
2644
2645         for (pb = (1u<<1), bb = (1u<<12); bb < (1u<<25); pb *= 2, bb *= 2) {
2646                 if (acl_get_perm_np(permset, pb) == 1)
2647                         bits |= bb;
2648         }
2649
2650         *bits_p = bits;
2651
2652         return 0;
2653 }
2654
2655 SMB_ACL_T sys_acl_init(int count)
2656 {
2657         return acl_init(count);
2658 }
2659
2660 int sys_acl_create_entry(SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
2661 {
2662         return acl_create_entry(pacl, pentry);
2663 }
2664
2665 int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
2666 {
2667         acl_flagset_t flagset;
2668         acl_permset_t permset;
2669         uint32 fb, bb, pb;
2670         int is_user = tag_type == SMB_ACL_USER;
2671         uuid_t uu;
2672         int rc;
2673
2674         tag_type = bits & 1 ? ACL_EXTENDED_ALLOW : ACL_EXTENDED_DENY;
2675
2676         if (acl_get_flagset_np(entry, &flagset) != 0
2677          || acl_get_permset(entry, &permset) != 0)
2678                 return -1;
2679
2680         acl_clear_flags_np(flagset);
2681         acl_clear_perms(permset);
2682
2683         for (fb = (1u<<4), bb = (1u<<1); bb < (1u<<12); fb *= 2, bb *= 2) {
2684                 if (bits & bb)
2685                         acl_add_flag_np(flagset, fb);
2686         }
2687
2688         for (pb = (1u<<1), bb = (1u<<12); bb < (1u<<25); pb *= 2, bb *= 2) {
2689                 if (bits & bb)
2690                         acl_add_perm(permset, pb);
2691         }
2692
2693         if (is_user)
2694                 rc = mbr_uid_to_uuid(u_g_id, uu);
2695         else
2696                 rc = mbr_gid_to_uuid(u_g_id, uu);
2697
2698         if (acl_set_tag_type(entry, tag_type) != 0
2699          || acl_set_qualifier(entry, &uu) != 0
2700          || acl_set_permset(entry, permset) != 0
2701          || acl_set_flagset_np(entry, flagset) != 0)
2702                 return -1;
2703
2704         return 0;
2705 }
2706
2707 #if 0
2708 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
2709 {
2710         return -1; /* Not needed for OS X. */
2711 }
2712 #endif
2713
2714 int sys_acl_valid(SMB_ACL_T theacl)
2715 {
2716         return acl_valid(theacl);
2717 }
2718
2719 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
2720 {
2721         return acl_set_file(name, acltype, theacl);
2722 }
2723
2724 #if 0
2725 int sys_acl_set_fd(int fd, SMB_ACL_T theacl)
2726 {
2727         return acl_set_fd(fd, theacl);
2728 }
2729 #endif
2730
2731 int sys_acl_delete_def_file(const char *name)
2732 {
2733         return acl_delete_def_file(name);
2734 }
2735
2736 int sys_acl_free_acl(SMB_ACL_T the_acl)
2737 {
2738         return acl_free(the_acl);
2739 }
2740
2741 #else /* No ACLs. */
2742
2743 #error No ACL functions defined for this platform!
2744
2745 #endif
2746
2747 /************************************************************************
2748  Deliberately outside the ACL defines. Return 1 if this is a "no acls"
2749  errno, 0 if not.
2750 ************************************************************************/
2751
2752 int no_acl_syscall_error(int err)
2753 {
2754 #ifdef HAVE_OSX_ACLS
2755         if (err == ENOENT)
2756                 return 1; /* Weird problem with directory ACLs. */
2757 #endif
2758 #if defined(ENOSYS)
2759         if (err == ENOSYS) {
2760                 return 1;
2761         }
2762 #endif
2763 #if defined(ENOTSUP)
2764         if (err == ENOTSUP) {
2765                 return 1;
2766         }
2767 #endif
2768         return 0;
2769 }
2770
2771 #endif /* SUPPORT_ACLS */