source3/lib/sysacls.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba system utilities for ACL support.
   4    Copyright (C) Jeremy Allison 2000.
   5    Copyright (C) Volker Lendecke 2006
   6    Copyright (C) Michael Adam 2006,2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/passwd.h"
  24
  25 #if defined(HAVE_POSIX_ACLS)
  26 #include "modules/vfs_posixacl.h"
  27 #endif
  28
  29 #if defined(HAVE_TRU64_ACLS)
  30 #include "modules/vfs_tru64acl.h"
  31 #endif
  32
  33 #if defined(HAVE_SOLARIS_ACLS) || defined(HAVE_UNIXWARE_ACLS)
  34 #include "modules/vfs_solarisacl.h"
  35 #endif
  36
  37 #if defined(HAVE_HPUX_ACLS)
  38 #include "modules/vfs_hpuxacl.h"
  39 #endif
  40
  41 #if defined(HAVE_IRIX_ACLS)
  42 #include "modules/vfs_irixacl.h"
  43 #endif
  44
  45 #undef  DBGC_CLASS
  46 #define DBGC_CLASS DBGC_ACLS
  47
  48 /*
  49  * Note that while this code implements sufficient functionality
  50  * to support the sys_acl_* interfaces it does not provide all
  51  * of the semantics of the POSIX ACL interfaces.
  52  *
  53  * In particular, an ACL entry descriptor (SMB_ACL_ENTRY_T) returned
  54  * from a call to sys_acl_get_entry() should not be assumed to be
  55  * valid after calling any of the following functions, which may
  56  * reorder the entries in the ACL.
  57  *
  58  *      sys_acl_valid()
  59  *      sys_acl_set_file()
  60  *      sys_acl_set_fd()
  61  */
  62
  63 int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
  64 {
  65         if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
  66                 errno = EINVAL;
  67                 return -1;
  68         }
  69
  70         if (entry_p == NULL) {
  71                 errno = EINVAL;
  72                 return -1;
  73         }
  74
  75         if (entry_id == SMB_ACL_FIRST_ENTRY) {
  76                 acl_d->next = 0;
  77         }
  78
  79         if (acl_d->next < 0) {
  80                 errno = EINVAL;
  81                 return -1;
  82         }
  83
  84         if (acl_d->next >= acl_d->count) {
  85                 return 0;
  86         }
  87
  88         *entry_p = &acl_d->acl[acl_d->next++];
  89
  90         return 1;
  91 }
  92
  93 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
  94 {
  95         *type_p = entry_d->a_type;
  96
  97         return 0;
  98 }
  99
 100 int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 101 {
 102         *permset_p = &entry_d->a_perm;
 103
 104         return 0;
 105 }
 106
 107 void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d)
 108 {
 109         if (entry_d->a_type == SMB_ACL_USER) {
 110                 return &entry_d->uid;
 111                 }
 112
 113         if (entry_d->a_type == SMB_ACL_GROUP) {
 114                 return &entry_d->gid;
 115         }
 116
 117         errno = EINVAL;
 118                 return NULL;
 119 }
 120
 121 int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d)
 122 {
 123         *permset_d = 0;
 124
 125         return 0;
 126 }
 127
 128 int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
 129 {
 130         if (perm != SMB_ACL_READ && perm != SMB_ACL_WRITE
 131             && perm != SMB_ACL_EXECUTE) {
 132                 errno = EINVAL;
 133                 return -1;
 134                 }
 135
 136         if (permset_d == NULL) {
 137                 errno = EINVAL;
 138                 return -1;
 139         }
 140
 141         *permset_d |= perm;
 142
 143         return 0;
 144 }
 145
 146 int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
 147 {
 148         return *permset_d & perm;
 149 }
 150
 151 char *sys_acl_to_text(const struct smb_acl_t *acl_d, ssize_t *len_p)
 152 {
 153         int     i;
 154         int     len, maxlen;
 155         char    *text;
 156
 157         /*
 158          * use an initial estimate of 20 bytes per ACL entry
 159          * when allocating memory for the text representation
 160          * of the ACL
 161          */
 162         len     = 0;
 163         maxlen  = 20 * acl_d->count;
 164         if ((text = (char *)SMB_MALLOC(maxlen)) == NULL) {
 165                 errno = ENOMEM;
 166                 return NULL;
 167         }
 168
 169         for (i = 0; i < acl_d->count; i++) {
 170                 struct smb_acl_entry *ap = &acl_d->acl[i];
 171                 struct group    *gr;
 172                 char            tagbuf[12];
 173                 char            idbuf[12];
 174                 const char      *tag;
 175                 const char      *id     = "";
 176                 char            perms[4];
 177                 int             nbytes;
 178
 179                 switch (ap->a_type) {
 180                         /*
 181                          * for debugging purposes it's probably more
 182                          * useful to dump unknown tag types rather
 183                          * than just returning an error
 184                          */
 185                         default:
 186                                 slprintf(tagbuf, sizeof(tagbuf)-1, "0x%x",
 187                                          ap->a_type);
 188                                 tag = tagbuf;
 189                                 break;
 190
 191                         case SMB_ACL_USER:
 192                                 id = uidtoname(ap->uid);
 193                         case SMB_ACL_USER_OBJ:
 194                                 tag = "user";
 195                                 break;
 196
 197                         case SMB_ACL_GROUP:
 198                                 if ((gr = getgrgid(ap->gid)) == NULL) {
 199                                         slprintf(idbuf, sizeof(idbuf)-1, "%ld",
 200                                                 (long)ap->gid);
 201                                         id = idbuf;
 202                                 } else {
 203                                         id = gr->gr_name;
 204                                 }
 205                         case SMB_ACL_GROUP_OBJ:
 206                                 tag = "group";
 207                                 break;
 208
 209                         case SMB_ACL_OTHER:
 210                                 tag = "other";
 211                                 break;
 212
 213                         case SMB_ACL_MASK:
 214                                 tag = "mask";
 215                                 break;
 216
 217                 }
 218
 219                 perms[0] = (ap->a_perm & SMB_ACL_READ) ? 'r' : '-';
 220                 perms[1] = (ap->a_perm & SMB_ACL_WRITE) ? 'w' : '-';
 221                 perms[2] = (ap->a_perm & SMB_ACL_EXECUTE) ? 'x' : '-';
 222                 perms[3] = '\0';
 223
 224                 /*          <tag>      :  <qualifier>   :  rwx \n  \0 */
 225                 nbytes = strlen(tag) + 1 + strlen(id) + 1 + 3 + 1 + 1;
 226
 227                 /*
 228                  * If this entry would overflow the buffer
 229                  * allocate enough additional memory for this
 230                  * entry and an estimate of another 20 bytes
 231                  * for each entry still to be processed
 232                  */
 233                 if ((len + nbytes) > maxlen) {
 234                         maxlen += nbytes + 20 * (acl_d->count - i);
 235                         if ((text = (char *)SMB_REALLOC(text, maxlen)) == NULL) {
 236                                 errno = ENOMEM;
 237                                 return NULL;
 238                         }
 239                 }
 240
 241
 242                 slprintf(&text[len], nbytes, "%s:%s:%s\n", tag, id, perms);
 243                 len += (nbytes - 1);
 244         }
 245
 246         if (len_p)
 247                 *len_p = len;
 248
 249         return text;
 250 }
 251
 252 SMB_ACL_T sys_acl_init(int count)
 253 {
 254         SMB_ACL_T       a;
 255
 256         if (count < 0) {
 257                 errno = EINVAL;
 258                 return NULL;
 259         }
 260
 261         /*
 262          * note that since the definition of the structure pointed
 263          * to by the SMB_ACL_T includes the first element of the
 264          * acl[] array, this actually allocates an ACL with room
 265          * for (count+1) entries
 266          */
 267         if ((a = (struct smb_acl_t *)SMB_MALLOC(
 268                      sizeof(struct smb_acl_t) +
 269                      count * sizeof(struct smb_acl_entry))) == NULL) {
 270                 errno = ENOMEM;
 271                 return NULL;
 272         }
 273
 274         a->size = count + 1;
 275         a->count = 0;
 276         a->next = -1;
 277
 278         return a;
 279 }
 280
 281 int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
 282 {
 283         SMB_ACL_T       acl_d;
 284         SMB_ACL_ENTRY_T entry_d;
 285
 286         if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
 287                 errno = EINVAL;
 288                 return -1;
 289         }
 290
 291         if (acl_d->count >= acl_d->size) {
 292                 errno = ENOSPC;
 293                 return -1;
 294         }
 295
 296         entry_d         = &acl_d->acl[acl_d->count++];
 297         entry_d->a_type = SMB_ACL_TAG_INVALID;
 298         entry_d->uid    = -1;
 299         entry_d->gid    = -1;
 300         entry_d->a_perm = 0;
 301         *entry_p        = entry_d;
 302
 303         return 0;
 304 }
 305
 306 int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type)
 307 {
 308         switch (tag_type) {
 309                 case SMB_ACL_USER:
 310                 case SMB_ACL_USER_OBJ:
 311                 case SMB_ACL_GROUP:
 312                 case SMB_ACL_GROUP_OBJ:
 313                 case SMB_ACL_OTHER:
 314                 case SMB_ACL_MASK:
 315                         entry_d->a_type = tag_type;
 316                         break;
 317                 default:
 318                         errno = EINVAL;
 319                         return -1;
 320                 }
 321
 322         return 0;
 323 }
 324
 325 int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p)
 326 {
 327         if (entry_d->a_type == SMB_ACL_USER) {
 328                 entry_d->uid = *((uid_t *)qual_p);
 329                 return 0;
 330                 }
 331         if (entry_d->a_type == SMB_ACL_GROUP) {
 332                 entry_d->gid = *((gid_t *)qual_p);
 333                 return 0;
 334         }
 335
 336         errno = EINVAL;
 337         return -1;
 338 }
 339
 340 int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d)
 341 {
 342         if (*permset_d & ~(SMB_ACL_READ|SMB_ACL_WRITE|SMB_ACL_EXECUTE)) {
 343                 errno = EINVAL;
 344                 return -1;
 345         }
 346
 347         entry_d->a_perm = *permset_d;
 348
 349         return 0;
 350 }
 351
 352 int sys_acl_free_text(char *text)
 353 {
 354         SAFE_FREE(text);
 355         return 0;
 356 }
 357
 358 int sys_acl_free_acl(SMB_ACL_T acl_d)
 359 {
 360         SAFE_FREE(acl_d);
 361         return 0;
 362 }
 363
 364 int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype)
 365 {
 366         return 0;
 367 }
 368
 369 int sys_acl_valid(SMB_ACL_T acl_d)
 370 {
 371         errno = EINVAL;
 372         return -1;
 373 }
 374
 375 /*
 376  * acl_get_file, acl_get_fd, acl_set_file, acl_set_fd and
 377  * sys_acl_delete_def_file are to be redirected to the default
 378  * statically-bound acl vfs module, but they are replacable.
 379  */
 380
 381 #if defined(HAVE_POSIX_ACLS)
 382
 383 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 384                            const char *path_p, SMB_ACL_TYPE_T type)
 385 {
 386         return posixacl_sys_acl_get_file(handle, path_p, type);
 387 }
 388
 389 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 390 {
 391         return posixacl_sys_acl_get_fd(handle, fsp);
 392 }
 393
 394 int sys_acl_set_file(vfs_handle_struct *handle,
 395                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 396 {
 397         return posixacl_sys_acl_set_file(handle, name, type, acl_d);
 398 }
 399
 400 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 401                    SMB_ACL_T acl_d)
 402 {
 403         return posixacl_sys_acl_set_fd(handle, fsp, acl_d);
 404 }
 405
 406 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 407                             const char *path)
 408 {
 409         return posixacl_sys_acl_delete_def_file(handle, path);
 410 }
 411
 412 #elif defined(HAVE_AIX_ACLS)
 413
 414 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 415                            const char *path_p, SMB_ACL_TYPE_T type)
 416 {
 417         return aixacl_sys_acl_get_file(handle, path_p, type);
 418 }
 419
 420 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 421 {
 422         return aixacl_sys_acl_get_fd(handle, fsp);
 423 }
 424
 425 int sys_acl_set_file(vfs_handle_struct *handle,
 426                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 427 {
 428         return aixacl_sys_acl_set_file(handle, name, type, acl_d);
 429 }
 430
 431 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 432                    SMB_ACL_T acl_d)
 433 {
 434         return aixacl_sys_acl_set_fd(handle, fsp, acl_d);
 435 }
 436
 437 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 438                             const char *path)
 439 {
 440         return aixacl_sys_acl_delete_def_file(handle, path);
 441 }
 442
 443 #elif defined(HAVE_TRU64_ACLS)
 444
 445 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 446                            const char *path_p, SMB_ACL_TYPE_T type)
 447 {
 448         return tru64acl_sys_acl_get_file(handle, path_p, type);
 449 }
 450
 451 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 452 {
 453         return tru64acl_sys_acl_get_fd(handle, fsp);
 454 }
 455
 456 int sys_acl_set_file(vfs_handle_struct *handle,
 457                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 458 {
 459         return tru64acl_sys_acl_set_file(handle, name, type, acl_d);
 460 }
 461
 462 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 463                    SMB_ACL_T acl_d)
 464 {
 465         return tru64acl_sys_acl_set_fd(handle, fsp, acl_d);
 466 }
 467
 468 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 469                             const char *path)
 470 {
 471         return tru64acl_sys_acl_delete_def_file(handle, path);
 472 }
 473
 474 #elif defined(HAVE_SOLARIS_ACLS) || defined(HAVE_UNIXWARE_ACLS)
 475
 476 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 477                            const char *path_p, SMB_ACL_TYPE_T type)
 478 {
 479         return solarisacl_sys_acl_get_file(handle, path_p, type);
 480 }
 481
 482 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 483 {
 484         return solarisacl_sys_acl_get_fd(handle, fsp);
 485 }
 486
 487 int sys_acl_set_file(vfs_handle_struct *handle,
 488                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 489 {
 490         return solarisacl_sys_acl_set_file(handle, name, type, acl_d);
 491 }
 492
 493 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 494                    SMB_ACL_T acl_d)
 495 {
 496         return solarisacl_sys_acl_set_fd(handle, fsp, acl_d);
 497 }
 498
 499 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 500                             const char *path)
 501 {
 502         return solarisacl_sys_acl_delete_def_file(handle, path);
 503 }
 504
 505 #elif defined(HAVE_HPUX_ACLS)
 506
 507 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 508                            const char *path_p, SMB_ACL_TYPE_T type)
 509 {
 510         return hpuxacl_sys_acl_get_file(handle, path_p, type);
 511 }
 512
 513 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 514 {
 515         return hpuxacl_sys_acl_get_fd(handle, fsp);
 516 }
 517
 518 int sys_acl_set_file(vfs_handle_struct *handle,
 519                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 520 {
 521         return hpuxacl_sys_acl_set_file(handle, name, type, acl_d);
 522 }
 523
 524 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 525                    SMB_ACL_T acl_d)
 526 {
 527         return hpuxacl_sys_acl_set_fd(handle, fsp, acl_d);
 528 }
 529
 530 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 531                             const char *path)
 532 {
 533         return hpuxacl_sys_acl_delete_def_file(handle, path);
 534 }
 535
 536 #elif defined(HAVE_IRIX_ACLS)
 537
 538 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 539                            const char *path_p, SMB_ACL_TYPE_T type)
 540 {
 541         return irixacl_sys_acl_get_file(handle, path_p, type);
 542 }
 543
 544 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 545 {
 546         return irixacl_sys_acl_get_fd(handle, fsp);
 547 }
 548
 549 int sys_acl_set_file(vfs_handle_struct *handle,
 550                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 551 {
 552         return irixacl_sys_acl_set_file(handle, name, type, acl_d);
 553 }
 554
 555 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 556                    SMB_ACL_T acl_d)
 557 {
 558         return irixacl_sys_acl_set_fd(handle, fsp, acl_d);
 559 }
 560
 561 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 562                             const char *path)
 563 {
 564         return irixacl_sys_acl_delete_def_file(handle, path);
 565 }
 566
 567 #else /* No ACLs. */
 568
 569 SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
 570                            const char *path_p, SMB_ACL_TYPE_T type)
 571 {
 572 #ifdef ENOTSUP
 573         errno = ENOTSUP;
 574 #else
 575         errno = ENOSYS;
 576 #endif
 577         return NULL;
 578 }
 579
 580 SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 581 {
 582 #ifdef ENOTSUP
 583         errno = ENOTSUP;
 584 #else
 585         errno = ENOSYS;
 586 #endif
 587         return NULL;
 588 }
 589
 590 int sys_acl_set_file(vfs_handle_struct *handle,
 591                      const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d)
 592 {
 593 #ifdef ENOTSUP
 594         errno = ENOTSUP;
 595 #else
 596         errno = ENOSYS;
 597 #endif
 598         return -1;
 599 }
 600
 601 int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 602                    SMB_ACL_T acl_d)
 603 {
 604 #ifdef ENOTSUP
 605         errno = ENOTSUP;
 606 #else
 607         errno = ENOSYS;
 608 #endif
 609         return -1;
 610 }
 611
 612 int sys_acl_delete_def_file(vfs_handle_struct *handle,
 613                             const char *path)
 614 {
 615 #ifdef ENOTSUP
 616         errno = ENOTSUP;
 617 #else
 618         errno = ENOSYS;
 619 #endif
 620         return -1;
 621 }
 622
 623 #endif
 624
 625 /************************************************************************
 626  Deliberately outside the ACL defines. Return 1 if this is a "no acls"
 627  errno, 0 if not.
 628 ************************************************************************/
 629
 630 int no_acl_syscall_error(int err)
 631 {
 632 #if defined(ENOSYS)
 633         if (err == ENOSYS) {
 634                 return 1;
 635         }
 636 #endif
 637 #if defined(ENOTSUP)
 638         if (err == ENOTSUP) {
 639                 return 1;
 640         }
 641 #endif
 642         return 0;
 643 }