2015-05-05 11:32:59 +03:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
2000-12-06 05:32:48 +03:00
Samba system utilities for ACL support .
Copyright ( C ) Jeremy Allison 2000.
2006-07-21 19:51:34 +04:00
Copyright ( C ) Volker Lendecke 2006
2008-01-08 03:54:19 +03:00
Copyright ( C ) Michael Adam 2006 , 2008
2015-05-05 11:32:59 +03:00
2000-12-06 05:32:48 +03:00
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
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
2000-12-06 05:32:48 +03:00
( at your option ) any later version .
2015-05-05 11:32:59 +03:00
2000-12-06 05:32:48 +03:00
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 .
2015-05-05 11:32:59 +03:00
2000-12-06 05:32:48 +03:00
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
2000-12-06 05:32:48 +03:00
*/
# include "includes.h"
2011-02-25 19:14:22 +03:00
# include "system/passwd.h"
2000-12-06 05:32:48 +03:00
2011-04-14 01:48:33 +04:00
# if defined(HAVE_POSIX_ACLS)
# include "modules/vfs_posixacl.h"
# endif
# if defined(HAVE_TRU64_ACLS)
# include "modules/vfs_tru64acl.h"
# endif
2014-03-05 06:06:02 +04:00
# if defined(HAVE_SOLARIS_UNIXWARE_ACLS)
2011-04-14 01:48:33 +04:00
# include "modules/vfs_solarisacl.h"
# endif
# if defined(HAVE_HPUX_ACLS)
# include "modules/vfs_hpuxacl.h"
# endif
2005-03-14 23:03:32 +03:00
# undef DBGC_CLASS
# define DBGC_CLASS DBGC_ACLS
2001-04-06 00:52:02 +04:00
/*
* 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 ( )
*/
2001-02-15 22:56:10 +03:00
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 )
{
2006-07-21 19:51:34 +04:00
if ( entry_d - > a_type = = SMB_ACL_USER ) {
2012-09-07 09:49:47 +04:00
return & entry_d - > info . user . uid ;
2015-05-05 11:34:11 +03:00
}
2001-02-15 22:56:10 +03:00
2006-07-21 19:51:34 +04:00
if ( entry_d - > a_type = = SMB_ACL_GROUP ) {
2012-09-07 09:49:47 +04:00
return & entry_d - > info . group . gid ;
2001-02-15 22:56:10 +03:00
}
2006-07-21 19:51:34 +04:00
errno = EINVAL ;
2015-05-05 11:34:11 +03:00
return NULL ;
2001-02-15 22:56:10 +03:00
}
int sys_acl_clear_perms ( SMB_ACL_PERMSET_T permset_d )
{
* permset_d = 0 ;
2006-07-21 19:51:34 +04:00
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 ;
2015-05-05 11:34:11 +03:00
}
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
if ( permset_d = = NULL ) {
errno = EINVAL ;
return - 1 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
* permset_d | = perm ;
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
return 0 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_get_perm ( SMB_ACL_PERMSET_T permset_d , SMB_ACL_PERM_T perm )
2001-04-17 09:41:07 +04:00
{
2006-07-21 19:51:34 +04:00
return * permset_d & perm ;
2001-04-17 09:41:07 +04:00
}
2012-05-08 08:11:27 +04:00
char * sys_acl_to_text ( const struct smb_acl_t * acl_d , ssize_t * len_p )
2001-04-17 09:41:07 +04:00
{
2006-07-21 19:51:34 +04:00
int i ;
int len , maxlen ;
char * text ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
/*
* 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 ;
2006-07-31 08:30:55 +04:00
if ( ( text = ( char * ) SMB_MALLOC ( maxlen ) ) = = NULL ) {
2006-07-21 19:51:34 +04:00
errno = ENOMEM ;
return NULL ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
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 ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
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 ;
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
case SMB_ACL_USER :
2012-09-07 09:49:47 +04:00
id = uidtoname ( ap - > info . user . uid ) ;
2012-12-18 19:33:14 +04:00
/* FALL TROUGH */
2006-07-21 19:51:34 +04:00
case SMB_ACL_USER_OBJ :
tag = " user " ;
break ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
case SMB_ACL_GROUP :
2012-09-07 09:49:47 +04:00
if ( ( gr = getgrgid ( ap - > info . group . gid ) ) = = NULL ) {
2006-07-21 19:51:34 +04:00
slprintf ( idbuf , sizeof ( idbuf ) - 1 , " %ld " ,
2012-09-07 09:49:47 +04:00
( long ) ap - > info . group . gid ) ;
2006-07-21 19:51:34 +04:00
id = idbuf ;
} else {
id = gr - > gr_name ;
2007-03-24 00:50:44 +03:00
}
2012-12-18 19:33:14 +04:00
/* FALL TROUGH */
2006-07-21 19:51:34 +04:00
case SMB_ACL_GROUP_OBJ :
tag = " group " ;
break ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
case SMB_ACL_OTHER :
tag = " other " ;
break ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
case SMB_ACL_MASK :
tag = " mask " ;
break ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
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 ' ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
/* <tag> : <qualifier> : rwx \n \0 */
nbytes = strlen ( tag ) + 1 + strlen ( id ) + 1 + 3 + 1 + 1 ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
/*
* 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 ) ;
2006-07-31 08:30:55 +04:00
if ( ( text = ( char * ) SMB_REALLOC ( text , maxlen ) ) = = NULL ) {
2012-05-08 08:02:07 +04:00
errno = ENOMEM ;
2006-07-21 19:51:34 +04:00
return NULL ;
2012-05-08 08:02:07 +04:00
}
2001-04-17 09:41:07 +04:00
}
2012-05-08 17:39:35 +04:00
slprintf ( & text [ len ] , nbytes , " %s:%s:%s \n " , tag , id , perms ) ;
len + = ( nbytes - 1 ) ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
if ( len_p )
* len_p = len ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
return text ;
2001-04-17 09:41:07 +04:00
}
2012-10-10 03:18:32 +04:00
SMB_ACL_T sys_acl_init ( TALLOC_CTX * mem_ctx )
2001-04-17 09:41:07 +04:00
{
2006-07-21 19:51:34 +04:00
SMB_ACL_T a ;
2001-04-17 09:41:07 +04:00
2012-10-10 03:18:32 +04:00
if ( ( a = talloc ( mem_ctx , struct smb_acl_t ) ) = = NULL ) {
2006-07-21 19:51:34 +04:00
errno = ENOMEM ;
return NULL ;
}
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
a - > count = 0 ;
a - > next = - 1 ;
2001-04-17 09:41:07 +04:00
2012-09-07 11:44:24 +04:00
a - > acl = talloc_array ( a , struct smb_acl_entry , 0 ) ;
2012-08-12 14:41:35 +04:00
if ( ! a - > acl ) {
TALLOC_FREE ( a ) ;
errno = ENOMEM ;
return NULL ;
}
2006-07-21 19:51:34 +04:00
return a ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_create_entry ( SMB_ACL_T * acl_p , SMB_ACL_ENTRY_T * entry_p )
2001-04-17 09:41:07 +04:00
{
2006-07-21 19:51:34 +04:00
SMB_ACL_T acl_d ;
SMB_ACL_ENTRY_T entry_d ;
2012-09-07 11:44:24 +04:00
struct smb_acl_entry * acl ;
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
if ( acl_p = = NULL | | entry_p = = NULL | | ( acl_d = * acl_p ) = = NULL ) {
errno = EINVAL ;
return - 1 ;
2001-04-17 09:41:07 +04:00
}
2012-09-07 11:44:24 +04:00
acl = talloc_realloc ( acl_d , acl_d - > acl , struct smb_acl_entry , acl_d - > count + 1 ) ;
if ( ! acl ) {
errno = ENOMEM ;
2006-07-21 19:51:34 +04:00
return - 1 ;
}
2012-09-07 11:44:24 +04:00
acl_d - > acl = acl ;
entry_d = & acl_d - > acl [ acl_d - > count ] ;
2006-08-24 23:56:20 +04:00
entry_d - > a_type = SMB_ACL_TAG_INVALID ;
2006-07-21 19:51:34 +04:00
entry_d - > a_perm = 0 ;
* entry_p = entry_d ;
2001-04-17 09:41:07 +04:00
2012-09-07 11:44:24 +04:00
acl_d - > count + + ;
2006-07-21 19:51:34 +04:00
return 0 ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
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 :
2001-04-17 09:41:07 +04:00
case SMB_ACL_USER_OBJ :
2006-07-21 19:51:34 +04:00
case SMB_ACL_GROUP :
2001-04-17 09:41:07 +04:00
case SMB_ACL_GROUP_OBJ :
case SMB_ACL_OTHER :
case SMB_ACL_MASK :
2006-07-21 19:51:34 +04:00
entry_d - > a_type = tag_type ;
break ;
default :
errno = EINVAL ;
return - 1 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
return 0 ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
int sys_acl_set_qualifier ( SMB_ACL_ENTRY_T entry_d , void * qual_p )
{
if ( entry_d - > a_type = = SMB_ACL_USER ) {
2012-09-07 09:49:47 +04:00
entry_d - > info . user . uid = * ( ( uid_t * ) qual_p ) ;
2006-07-21 19:51:34 +04:00
return 0 ;
2015-05-05 11:34:11 +03:00
}
2006-07-21 19:51:34 +04:00
if ( entry_d - > a_type = = SMB_ACL_GROUP ) {
2012-09-07 09:49:47 +04:00
entry_d - > info . group . gid = * ( ( gid_t * ) qual_p ) ;
2006-07-21 19:51:34 +04:00
return 0 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
errno = EINVAL ;
return - 1 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_permset ( SMB_ACL_ENTRY_T entry_d , SMB_ACL_PERMSET_T permset_d )
2001-04-17 09:41:07 +04:00
{
2006-07-21 19:51:34 +04:00
if ( * permset_d & ~ ( SMB_ACL_READ | SMB_ACL_WRITE | SMB_ACL_EXECUTE ) ) {
errno = EINVAL ;
return - 1 ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
entry_d - > a_perm = * permset_d ;
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
return 0 ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
int sys_acl_free_text ( char * text )
{
SAFE_FREE ( text ) ;
return 0 ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
int sys_acl_valid ( SMB_ACL_T acl_d )
{
errno = EINVAL ;
return - 1 ;
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
/*
* 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 .
*/
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
# if defined(HAVE_POSIX_ACLS)
2015-05-05 11:32:59 +03:00
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2006-07-21 19:51:34 +04:00
{
2017-05-24 03:11:18 +03:00
return posixacl_sys_acl_get_file ( handle , smb_fname , type , mem_ctx ) ;
2006-07-21 19:51:34 +04:00
}
2015-05-05 11:32:59 +03:00
2012-10-10 03:18:32 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp , TALLOC_CTX * mem_ctx )
2006-07-21 19:51:34 +04:00
{
2012-10-10 03:18:32 +04:00
return posixacl_sys_acl_get_fd ( handle , fsp , mem_ctx ) ;
2006-07-21 19:51:34 +04:00
}
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2006-07-21 19:51:34 +04:00
{
2017-05-24 20:47:46 +03:00
return posixacl_sys_acl_set_file ( handle , smb_fname , type , acl_d ) ;
2006-07-21 19:51:34 +04:00
}
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2006-07-21 19:51:34 +04:00
{
2008-01-08 03:54:19 +03:00
return posixacl_sys_acl_set_fd ( handle , fsp , acl_d ) ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2001-06-08 23:56:15 +04:00
{
2017-05-24 01:33:31 +03:00
return posixacl_sys_acl_delete_def_file ( handle , smb_fname ) ;
2001-06-08 23:56:15 +04:00
}
2006-07-21 19:51:34 +04:00
# elif defined(HAVE_AIX_ACLS)
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2001-04-17 09:41:07 +04:00
{
2017-05-24 03:11:18 +03:00
return aixacl_sys_acl_get_file ( handle , smb_fname , type , mem_ctx ) ;
2001-04-17 09:41:07 +04:00
}
2012-10-11 07:42:39 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2006-07-21 19:51:34 +04:00
{
2012-10-11 07:42:39 +04:00
return aixacl_sys_acl_get_fd ( handle , fsp , mem_ctx ) ;
2006-07-21 19:51:34 +04:00
}
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2001-04-17 09:41:07 +04:00
{
2017-05-24 20:47:46 +03:00
return aixacl_sys_acl_set_file ( handle , smb_fname , type , acl_d ) ;
2001-04-17 09:41:07 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2001-04-17 09:41:07 +04:00
{
2008-01-08 03:54:19 +03:00
return aixacl_sys_acl_set_fd ( handle , fsp , acl_d ) ;
2006-07-21 19:51:34 +04:00
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2006-07-21 19:51:34 +04:00
{
2017-05-24 01:33:31 +03:00
return aixacl_sys_acl_delete_def_file ( handle , smb_fname ) ;
2006-07-21 19:51:34 +04:00
}
2001-04-17 09:41:07 +04:00
2006-07-21 19:51:34 +04:00
# elif defined(HAVE_TRU64_ACLS)
2015-05-05 11:32:59 +03:00
2006-07-21 19:51:34 +04:00
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2006-07-21 19:51:34 +04:00
{
2017-05-24 03:11:18 +03:00
return tru64acl_sys_acl_get_file ( handle , smb_fname , type ,
2012-10-11 07:42:39 +04:00
mem_ctx ) ;
2001-04-17 09:41:07 +04:00
}
2012-10-11 07:42:39 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2001-04-17 09:41:07 +04:00
{
2012-10-11 07:42:39 +04:00
return tru64acl_sys_acl_get_fd ( handle , fsp , mem_ctx ) ;
2001-04-14 01:11:57 +04:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2006-07-21 19:51:34 +04:00
{
2017-05-24 20:47:46 +03:00
return tru64acl_sys_acl_set_file ( handle , smb_fname , type , acl_d ) ;
2006-07-21 19:51:34 +04:00
}
2000-12-07 02:24:31 +03:00
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2000-12-06 05:32:48 +03:00
{
2008-01-08 03:54:19 +03:00
return tru64acl_sys_acl_set_fd ( handle , fsp , acl_d ) ;
2000-12-06 05:32:48 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2000-12-06 05:32:48 +03:00
{
2017-05-24 01:33:31 +03:00
return tru64acl_sys_acl_delete_def_file ( handle , smb_fname ) ;
2000-12-06 05:32:48 +03:00
}
2014-03-05 06:06:02 +04:00
# elif defined(HAVE_SOLARIS_UNIXWARE_ACLS)
2006-07-21 19:51:34 +04:00
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2000-12-06 05:32:48 +03:00
{
2017-05-24 03:11:18 +03:00
return solarisacl_sys_acl_get_file ( handle , smb_fname , type ,
2012-10-11 07:42:39 +04:00
mem_ctx ) ;
2000-12-06 05:32:48 +03:00
}
2012-10-11 07:42:39 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2000-12-06 05:32:48 +03:00
{
2012-10-11 07:42:39 +04:00
return solarisacl_sys_acl_get_fd ( handle , fsp ,
mem_ctx ) ;
2000-12-06 05:32:48 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2000-12-06 05:32:48 +03:00
{
2017-05-24 20:47:46 +03:00
return solarisacl_sys_acl_set_file ( handle , smb_fname , type , acl_d ) ;
2000-12-07 02:24:31 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2000-12-07 02:24:31 +03:00
{
2008-01-08 03:54:19 +03:00
return solarisacl_sys_acl_set_fd ( handle , fsp , acl_d ) ;
2000-12-06 05:32:48 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2000-12-07 08:38:01 +03:00
{
2017-05-24 01:33:31 +03:00
return solarisacl_sys_acl_delete_def_file ( handle , smb_fname ) ;
2000-12-07 08:38:01 +03:00
}
2006-07-21 19:51:34 +04:00
# elif defined(HAVE_HPUX_ACLS)
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2000-12-07 08:38:01 +03:00
{
2017-05-24 03:11:18 +03:00
return hpuxacl_sys_acl_get_file ( handle , smb_fname , type , mem_ctx ) ;
2000-12-07 08:38:01 +03:00
}
2012-10-11 07:42:39 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2000-12-07 08:38:01 +03:00
{
2012-10-11 07:42:39 +04:00
return hpuxacl_sys_acl_get_fd ( handle , fsp , mem_ctx ) ;
2000-12-07 08:38:01 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2000-12-07 08:38:01 +03:00
{
2017-05-24 20:47:46 +03:00
return hpuxacl_sys_acl_set_file ( handle , smb_fname , type , acl_d ) ;
2000-12-07 08:38:01 +03:00
}
2000-12-19 21:41:51 +03:00
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2000-12-19 21:41:51 +03:00
{
2008-01-08 03:54:19 +03:00
return hpuxacl_sys_acl_set_fd ( handle , fsp , acl_d ) ;
2000-12-19 21:41:51 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2001-01-12 01:37:59 +03:00
{
2017-05-24 01:33:31 +03:00
return hpuxacl_sys_acl_delete_def_file ( handle , smb_fname ) ;
2001-01-12 01:37:59 +03:00
}
2006-07-21 19:51:34 +04:00
# else /* No ACLs. */
SMB_ACL_T sys_acl_get_file ( vfs_handle_struct * handle ,
2017-05-24 03:11:18 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
TALLOC_CTX * mem_ctx )
2001-01-12 01:37:59 +03:00
{
2006-09-03 12:16:25 +04:00
# ifdef ENOTSUP
2006-07-21 19:51:34 +04:00
errno = ENOTSUP ;
2006-09-03 12:16:25 +04:00
# else
errno = ENOSYS ;
# endif
2006-07-21 19:51:34 +04:00
return NULL ;
2001-01-12 01:37:59 +03:00
}
2012-10-11 07:42:39 +04:00
SMB_ACL_T sys_acl_get_fd ( vfs_handle_struct * handle , files_struct * fsp ,
TALLOC_CTX * mem_ctx )
2001-01-12 01:37:59 +03:00
{
2006-09-03 12:16:25 +04:00
# ifdef ENOTSUP
2006-07-21 19:51:34 +04:00
errno = ENOTSUP ;
2006-09-03 12:16:25 +04:00
# else
errno = ENOSYS ;
# endif
2006-07-21 19:51:34 +04:00
return NULL ;
2001-01-12 01:37:59 +03:00
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_file ( vfs_handle_struct * handle ,
2017-05-24 20:47:46 +03:00
const struct smb_filename * smb_fname ,
SMB_ACL_TYPE_T type ,
SMB_ACL_T acl_d )
2001-06-08 23:29:57 +04:00
{
2006-09-03 12:16:25 +04:00
# ifdef ENOTSUP
2006-07-21 19:51:34 +04:00
errno = ENOTSUP ;
2006-09-03 12:16:25 +04:00
# else
errno = ENOSYS ;
# endif
2001-06-08 23:29:57 +04:00
return - 1 ;
}
2006-07-21 19:51:34 +04:00
int sys_acl_set_fd ( vfs_handle_struct * handle , files_struct * fsp ,
2008-01-08 03:54:19 +03:00
SMB_ACL_T acl_d )
2000-12-19 21:41:51 +03:00
{
2006-09-03 12:16:25 +04:00
# ifdef ENOTSUP
2006-07-21 19:51:34 +04:00
errno = ENOTSUP ;
2006-09-03 12:16:25 +04:00
# else
errno = ENOSYS ;
# endif
2000-12-19 21:41:51 +03:00
return - 1 ;
}
2001-04-14 01:11:57 +04:00
2006-07-21 19:51:34 +04:00
int sys_acl_delete_def_file ( vfs_handle_struct * handle ,
2017-05-24 01:33:31 +03:00
const struct smb_filename * smb_fname )
2001-04-14 01:11:57 +04:00
{
2006-09-03 12:16:25 +04:00
# ifdef ENOTSUP
2006-07-21 19:51:34 +04:00
errno = ENOTSUP ;
2006-09-03 12:16:25 +04:00
# else
errno = ENOSYS ;
# endif
2001-04-14 01:11:57 +04:00
return - 1 ;
}
2006-07-21 19:51:34 +04:00
# endif
2004-11-12 05:16:00 +03:00
/************************************************************************
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 ;
}