source/lib/sysacls.c

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