1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/source3/lib/sysacls.c
Jeremy Allison aada94885d s3: VFS: Change SMB_VFS_SYS_ACL_SET_FILE to use const struct smb_filename * instead of const char *.
We need to migrate all pathname based VFS calls to use a struct
to finish modernising the VFS with extra timestamp and flags parameters.

Signed-off-by: Jeremy Allison <jra@samba.org>
Reviewed-by: Ralph Boehme <slow@samba.org>
2017-05-31 22:50:22 +02:00

626 lines
13 KiB
C

/*
Unix SMB/CIFS implementation.
Samba system utilities for ACL support.
Copyright (C) Jeremy Allison 2000.
Copyright (C) Volker Lendecke 2006
Copyright (C) Michael Adam 2006,2008
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "system/passwd.h"
#if defined(HAVE_POSIX_ACLS)
#include "modules/vfs_posixacl.h"
#endif
#if defined(HAVE_TRU64_ACLS)
#include "modules/vfs_tru64acl.h"
#endif
#if defined(HAVE_SOLARIS_UNIXWARE_ACLS)
#include "modules/vfs_solarisacl.h"
#endif
#if defined(HAVE_HPUX_ACLS)
#include "modules/vfs_hpuxacl.h"
#endif
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_ACLS
/*
* Note that while this code implements sufficient functionality
* to support the sys_acl_* interfaces it does not provide all
* of the semantics of the POSIX ACL interfaces.
*
* In particular, an ACL entry descriptor (SMB_ACL_ENTRY_T) returned
* from a call to sys_acl_get_entry() should not be assumed to be
* valid after calling any of the following functions, which may
* reorder the entries in the ACL.
*
* sys_acl_valid()
* sys_acl_set_file()
* sys_acl_set_fd()
*/
int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p)
{
if (entry_id != SMB_ACL_FIRST_ENTRY && entry_id != SMB_ACL_NEXT_ENTRY) {
errno = EINVAL;
return -1;
}
if (entry_p == NULL) {
errno = EINVAL;
return -1;
}
if (entry_id == SMB_ACL_FIRST_ENTRY) {
acl_d->next = 0;
}
if (acl_d->next < 0) {
errno = EINVAL;
return -1;
}
if (acl_d->next >= acl_d->count) {
return 0;
}
*entry_p = &acl_d->acl[acl_d->next++];
return 1;
}
int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p)
{
*type_p = entry_d->a_type;
return 0;
}
int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
{
*permset_p = &entry_d->a_perm;
return 0;
}
void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d)
{
if (entry_d->a_type == SMB_ACL_USER) {
return &entry_d->info.user.uid;
}
if (entry_d->a_type == SMB_ACL_GROUP) {
return &entry_d->info.group.gid;
}
errno = EINVAL;
return NULL;
}
int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d)
{
*permset_d = 0;
return 0;
}
int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
{
if (perm != SMB_ACL_READ && perm != SMB_ACL_WRITE
&& perm != SMB_ACL_EXECUTE) {
errno = EINVAL;
return -1;
}
if (permset_d == NULL) {
errno = EINVAL;
return -1;
}
*permset_d |= perm;
return 0;
}
int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm)
{
return *permset_d & perm;
}
char *sys_acl_to_text(const struct smb_acl_t *acl_d, ssize_t *len_p)
{
int i;
int len, maxlen;
char *text;
/*
* use an initial estimate of 20 bytes per ACL entry
* when allocating memory for the text representation
* of the ACL
*/
len = 0;
maxlen = 20 * acl_d->count;
if ((text = (char *)SMB_MALLOC(maxlen)) == NULL) {
errno = ENOMEM;
return NULL;
}
for (i = 0; i < acl_d->count; i++) {
struct smb_acl_entry *ap = &acl_d->acl[i];
struct group *gr;
char tagbuf[12];
char idbuf[12];
const char *tag;
const char *id = "";
char perms[4];
int nbytes;
switch (ap->a_type) {
/*
* for debugging purposes it's probably more
* useful to dump unknown tag types rather
* than just returning an error
*/
default:
slprintf(tagbuf, sizeof(tagbuf)-1, "0x%x",
ap->a_type);
tag = tagbuf;
break;
case SMB_ACL_USER:
id = uidtoname(ap->info.user.uid);
/* FALL TROUGH */
case SMB_ACL_USER_OBJ:
tag = "user";
break;
case SMB_ACL_GROUP:
if ((gr = getgrgid(ap->info.group.gid)) == NULL) {
slprintf(idbuf, sizeof(idbuf)-1, "%ld",
(long)ap->info.group.gid);
id = idbuf;
} else {
id = gr->gr_name;
}
/* FALL TROUGH */
case SMB_ACL_GROUP_OBJ:
tag = "group";
break;
case SMB_ACL_OTHER:
tag = "other";
break;
case SMB_ACL_MASK:
tag = "mask";
break;
}
perms[0] = (ap->a_perm & SMB_ACL_READ) ? 'r' : '-';
perms[1] = (ap->a_perm & SMB_ACL_WRITE) ? 'w' : '-';
perms[2] = (ap->a_perm & SMB_ACL_EXECUTE) ? 'x' : '-';
perms[3] = '\0';
/* <tag> : <qualifier> : rwx \n \0 */
nbytes = strlen(tag) + 1 + strlen(id) + 1 + 3 + 1 + 1;
/*
* If this entry would overflow the buffer
* allocate enough additional memory for this
* entry and an estimate of another 20 bytes
* for each entry still to be processed
*/
if ((len + nbytes) > maxlen) {
maxlen += nbytes + 20 * (acl_d->count - i);
if ((text = (char *)SMB_REALLOC(text, maxlen)) == NULL) {
errno = ENOMEM;
return NULL;
}
}
slprintf(&text[len], nbytes, "%s:%s:%s\n", tag, id, perms);
len += (nbytes - 1);
}
if (len_p)
*len_p = len;
return text;
}
SMB_ACL_T sys_acl_init(TALLOC_CTX *mem_ctx)
{
SMB_ACL_T a;
if ((a = talloc(mem_ctx, struct smb_acl_t)) == NULL) {
errno = ENOMEM;
return NULL;
}
a->count = 0;
a->next = -1;
a->acl = talloc_array(a, struct smb_acl_entry, 0);
if (!a->acl) {
TALLOC_FREE(a);
errno = ENOMEM;
return NULL;
}
return a;
}
int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p)
{
SMB_ACL_T acl_d;
SMB_ACL_ENTRY_T entry_d;
struct smb_acl_entry *acl;
if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) {
errno = EINVAL;
return -1;
}
acl = talloc_realloc(acl_d, acl_d->acl, struct smb_acl_entry, acl_d->count+1);
if (!acl) {
errno = ENOMEM;
return -1;
}
acl_d->acl = acl;
entry_d = &acl_d->acl[acl_d->count];
entry_d->a_type = SMB_ACL_TAG_INVALID;
entry_d->a_perm = 0;
*entry_p = entry_d;
acl_d->count++;
return 0;
}
int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type)
{
switch (tag_type) {
case SMB_ACL_USER:
case SMB_ACL_USER_OBJ:
case SMB_ACL_GROUP:
case SMB_ACL_GROUP_OBJ:
case SMB_ACL_OTHER:
case SMB_ACL_MASK:
entry_d->a_type = tag_type;
break;
default:
errno = EINVAL;
return -1;
}
return 0;
}
int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p)
{
if (entry_d->a_type == SMB_ACL_USER) {
entry_d->info.user.uid = *((uid_t *)qual_p);
return 0;
}
if (entry_d->a_type == SMB_ACL_GROUP) {
entry_d->info.group.gid = *((gid_t *)qual_p);
return 0;
}
errno = EINVAL;
return -1;
}
int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d)
{
if (*permset_d & ~(SMB_ACL_READ|SMB_ACL_WRITE|SMB_ACL_EXECUTE)) {
errno = EINVAL;
return -1;
}
entry_d->a_perm = *permset_d;
return 0;
}
int sys_acl_free_text(char *text)
{
SAFE_FREE(text);
return 0;
}
int sys_acl_valid(SMB_ACL_T acl_d)
{
errno = EINVAL;
return -1;
}
/*
* acl_get_file, acl_get_fd, acl_set_file, acl_set_fd and
* sys_acl_delete_def_file are to be redirected to the default
* statically-bound acl vfs module, but they are replacable.
*/
#if defined(HAVE_POSIX_ACLS)
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
return posixacl_sys_acl_get_file(handle, smb_fname, type, mem_ctx);
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, TALLOC_CTX *mem_ctx)
{
return posixacl_sys_acl_get_fd(handle, fsp, mem_ctx);
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
return posixacl_sys_acl_set_file(handle, smb_fname, type, acl_d);
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
return posixacl_sys_acl_set_fd(handle, fsp, acl_d);
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
return posixacl_sys_acl_delete_def_file(handle, smb_fname);
}
#elif defined(HAVE_AIX_ACLS)
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
return aixacl_sys_acl_get_file(handle, smb_fname, type, mem_ctx);
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp,
TALLOC_CTX *mem_ctx)
{
return aixacl_sys_acl_get_fd(handle, fsp, mem_ctx);
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
return aixacl_sys_acl_set_file(handle, smb_fname, type, acl_d);
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
return aixacl_sys_acl_set_fd(handle, fsp, acl_d);
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
return aixacl_sys_acl_delete_def_file(handle, smb_fname);
}
#elif defined(HAVE_TRU64_ACLS)
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
return tru64acl_sys_acl_get_file(handle, smb_fname, type,
mem_ctx);
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp,
TALLOC_CTX *mem_ctx)
{
return tru64acl_sys_acl_get_fd(handle, fsp, mem_ctx);
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
return tru64acl_sys_acl_set_file(handle, smb_fname, type, acl_d);
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
return tru64acl_sys_acl_set_fd(handle, fsp, acl_d);
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
return tru64acl_sys_acl_delete_def_file(handle, smb_fname);
}
#elif defined(HAVE_SOLARIS_UNIXWARE_ACLS)
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
return solarisacl_sys_acl_get_file(handle, smb_fname, type,
mem_ctx);
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp,
TALLOC_CTX *mem_ctx)
{
return solarisacl_sys_acl_get_fd(handle, fsp,
mem_ctx);
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
return solarisacl_sys_acl_set_file(handle, smb_fname, type, acl_d);
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
return solarisacl_sys_acl_set_fd(handle, fsp, acl_d);
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
return solarisacl_sys_acl_delete_def_file(handle, smb_fname);
}
#elif defined(HAVE_HPUX_ACLS)
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
return hpuxacl_sys_acl_get_file(handle, smb_fname, type, mem_ctx);
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp,
TALLOC_CTX *mem_ctx)
{
return hpuxacl_sys_acl_get_fd(handle, fsp, mem_ctx);
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
return hpuxacl_sys_acl_set_file(handle, smb_fname, type, acl_d);
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
return hpuxacl_sys_acl_set_fd(handle, fsp, acl_d);
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
return hpuxacl_sys_acl_delete_def_file(handle, smb_fname);
}
#else /* No ACLs. */
SMB_ACL_T sys_acl_get_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
#ifdef ENOTSUP
errno = ENOTSUP;
#else
errno = ENOSYS;
#endif
return NULL;
}
SMB_ACL_T sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp,
TALLOC_CTX *mem_ctx)
{
#ifdef ENOTSUP
errno = ENOTSUP;
#else
errno = ENOSYS;
#endif
return NULL;
}
int sys_acl_set_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
SMB_ACL_TYPE_T type,
SMB_ACL_T acl_d)
{
#ifdef ENOTSUP
errno = ENOTSUP;
#else
errno = ENOSYS;
#endif
return -1;
}
int sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
SMB_ACL_T acl_d)
{
#ifdef ENOTSUP
errno = ENOTSUP;
#else
errno = ENOSYS;
#endif
return -1;
}
int sys_acl_delete_def_file(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
#ifdef ENOTSUP
errno = ENOTSUP;
#else
errno = ENOSYS;
#endif
return -1;
}
#endif
/************************************************************************
Deliberately outside the ACL defines. Return 1 if this is a "no acls"
errno, 0 if not.
************************************************************************/
int no_acl_syscall_error(int err)
{
#if defined(ENOSYS)
if (err == ENOSYS) {
return 1;
}
#endif
#if defined(ENOTSUP)
if (err == ENOTSUP) {
return 1;
}
#endif
return 0;
}