embedaddon/rsync/lib/sysacls.c - diff

Return to sysacls.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / lib

Diff for /embedaddon/rsync/lib/sysacls.c between versions 1.1 and 1.1.1.3

version 1.1, 2012/02/17 15:09:30	version 1.1.1.3, 2021/03/17 00:32:36
Line 2	Line 2
* Unix SMB/CIFS implementation.	* Unix SMB/CIFS implementation.
* Based on the Samba ACL support code.	* Based on the Samba ACL support code.
* Copyright (C) Jeremy Allison 2000.	* Copyright (C) Jeremy Allison 2000.
* Copyright (C) 2007-2008 Wayne Davison	* Copyright (C) 2007-2020 Wayne Davison
*	*
* The permission functions have been changed to get/set all bits via	* The permission functions have been changed to get/set all bits via
* one call. Some functions that rsync doesn't need were also removed.	* one call. Some functions that rsync doesn't need were also removed.
Line 29	Line 29
#ifdef DEBUG	#ifdef DEBUG
#undef DEBUG	#undef DEBUG
#endif	#endif
#define DEBUG(x,y)	#define DEBUG(x, y)

void SAFE_FREE(void *mem)	void SAFE_FREE(void *mem)
{	{
Line 44 void SAFE_FREE(void *mem)	Line 44 void SAFE_FREE(void *mem)

The interfaces that each ACL implementation must support are as follows :	The interfaces that each ACL implementation must support are as follows :

int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)	int sys_acl_get_entry(SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)	int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type_p, uint32 bits_p, id_t *u_g_id_p)	int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type_p, uint32 bits_p, id_t *u_g_id_p)
SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)	SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
SMB_ACL_T sys_acl_get_fd(int fd)	SMB_ACL_T sys_acl_get_fd(int fd)
SMB_ACL_T sys_acl_init( int count)	SMB_ACL_T sys_acl_init(int count)
int sys_acl_create_entry( SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)	int sys_acl_create_entry(SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)
int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)	int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)	int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
int sys_acl_valid( SMB_ACL_T theacl )	int sys_acl_valid(SMB_ACL_T theacl)
int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)	int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	int sys_acl_set_fd(int fd, SMB_ACL_T theacl)
int sys_acl_delete_def_file(const char *path)	int sys_acl_delete_def_file(const char *path)
int sys_acl_free_acl(SMB_ACL_T posix_acl)	int sys_acl_free_acl(SMB_ACL_T posix_acl)

Line 65 void SAFE_FREE(void *mem)	Line 65 void SAFE_FREE(void *mem)

/* Identity mapping - easy. */	/* Identity mapping - easy. */

int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)	int sys_acl_get_entry(SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
{	{
return acl_get_entry( the_acl, entry_id, entry_p);	return acl_get_entry(the_acl, entry_id, entry_p);
}	}

int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)	int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
{	{
return acl_get_tag_type( entry_d, tag_type_p);	return acl_get_tag_type(entry_d, tag_type_p);
}	}

SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)	SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
{	{
return acl_get_file( path_p, type);	return acl_get_file(path_p, type);
}	}

#if 0	#if 0
Line 114 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA	Line 114 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA
return 0;	return 0;
}	}

SMB_ACL_T sys_acl_init( int count)	SMB_ACL_T sys_acl_init(int count)
{	{
return acl_init(count);	return acl_init(count);
}	}

int sys_acl_create_entry( SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)	int sys_acl_create_entry(SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)
{	{
return acl_create_entry(pacl, pentry);	return acl_create_entry(pacl, pentry);
}	}
Line 153 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uin	Line 153 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uin
return acl_set_permset(entry, permset);	return acl_set_permset(entry, permset);
}	}

int sys_acl_valid( SMB_ACL_T theacl )	int sys_acl_valid(SMB_ACL_T theacl)
{	{
return acl_valid(theacl);	return acl_valid(theacl);
}	}
Line 164 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T	Line 164 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T
}	}

#if 0	#if 0
int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	int sys_acl_set_fd(int fd, SMB_ACL_T theacl)
{	{
return acl_set_fd(fd, theacl);	return acl_set_fd(fd, theacl);
}	}
Line 191 int sys_acl_free_acl(SMB_ACL_T the_acl)	Line 191 int sys_acl_free_acl(SMB_ACL_T the_acl)
* to be broken on Tru64 so we have to manipulate	* to be broken on Tru64 so we have to manipulate
* the permission bits in the permset directly.	* the permission bits in the permset directly.
*/	*/
int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)	int sys_acl_get_entry(SMB_ACL_T the_acl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
{	{
SMB_ACL_ENTRY_T entry;	SMB_ACL_ENTRY_T entry;

Line 208 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id	Line 208 int sys_acl_get_entry( SMB_ACL_T the_acl, int entry_id
return errno ? -1 : 0;	return errno ? -1 : 0;
}	}

int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)	int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
{	{
return acl_get_tag_type( entry_d, tag_type_p);	return acl_get_tag_type(entry_d, tag_type_p);
}	}

SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)	SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
{	{
return acl_get_file((char *)path_p, type);	return acl_get_file((char *)path_p, type);
}	}
Line 246 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA	Line 246 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA
return 0;	return 0;
}	}

SMB_ACL_T sys_acl_init( int count)	SMB_ACL_T sys_acl_init(int count)
{	{
return acl_init(count);	return acl_init(count);
}	}

int sys_acl_create_entry( SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)	int sys_acl_create_entry(SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)
{	{
SMB_ACL_ENTRY_T entry;	SMB_ACL_ENTRY_T entry;

Line 286 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uin	Line 286 int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uin
return acl_set_permset(entry, permset);	return acl_set_permset(entry, permset);
}	}

int sys_acl_valid( SMB_ACL_T theacl )	int sys_acl_valid(SMB_ACL_T theacl)
{	{
acl_entry_t entry;	acl_entry_t entry;

return acl_valid(theacl, &entry);	return acl_valid(theacl, &entry);
}	}

int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)	int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
{	{
return acl_set_file((char *)name, acltype, theacl);	return acl_set_file((char *)name, acltype, theacl);
}	}

#if 0	#if 0
int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	int sys_acl_set_fd(int fd, SMB_ACL_T theacl)
{	{
return acl_set_fd(fd, ACL_TYPE_ACCESS, theacl);	return acl_set_fd(fd, ACL_TYPE_ACCESS, theacl);
}	}
Line 450 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL	Line 450 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL
*	*
* Note: we assume that the acl() system call returned a	* Note: we assume that the acl() system call returned a
* well formed ACL which is sorted so that all of the	* well formed ACL which is sorted so that all of the
* access ACL entries preceed any default ACL entries	* access ACL entries precede any default ACL entries
*/	*/
for (naccess = 0; naccess < count; naccess++) {	for (naccess = 0; naccess < count; naccess++) {
if (acl_d->acl[naccess].a_type & ACL_DEFAULT)	if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
Line 702 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T	Line 702 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T
* copy the access control and default entries into the buffer	* copy the access control and default entries into the buffer
*/	*/
memcpy(&acl_buf[0], &acc_acl->acl[0],	memcpy(&acl_buf[0], &acc_acl->acl[0],
acc_acl->count * sizeof(acl_buf[0]));	acc_acl->count * sizeof acl_buf[0]);

memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],	memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],
def_acl->count * sizeof(acl_buf[0]));	def_acl->count * sizeof acl_buf[0]);

/*	/*
* set the ACL_DEFAULT flag on the default entries	* set the ACL_DEFAULT flag on the default entries
Line 767 int sys_acl_free_acl(SMB_ACL_T acl_d)	Line 767 int sys_acl_free_acl(SMB_ACL_T acl_d)

#elif defined(HAVE_HPUX_ACLS) /---------------------------------------------/	#elif defined(HAVE_HPUX_ACLS) /---------------------------------------------/

	#ifdef HAVE_DL_H
#include <dl.h>	#include <dl.h>
	#endif

/*	/*
* Based on the Solaris/SCO code - with modifications.	* Based on the Solaris/SCO code - with modifications.
Line 795 int sys_acl_free_acl(SMB_ACL_T acl_d)	Line 797 int sys_acl_free_acl(SMB_ACL_T acl_d)
/* so it is important to check this and avoid acl() */	/* so it is important to check this and avoid acl() */
/* calls if it isn't there. */	/* calls if it isn't there. */

static BOOL hpux_acl_call_presence(void)	#ifdef __TANDEM
	inline int do_acl(const char path_p, int cmd, int nentries, struct acl aclbufp)
{	{
	return acl((char*)path_p, cmd, nentries, aclbufp);
	}
	#define acl(p,c,n,a) do_acl(p,c,n,a)
	#endif

	static BOOL hpux_acl_call_presence(void)
	{
	#ifndef __TANDEM
shl_t handle = NULL;	shl_t handle = NULL;
void *value;	void *value;
int ret_val=0;	int ret_val=0;
static BOOL already_checked=0;	static BOOL already_checked=0;

if(already_checked)	if (already_checked)
return True;	return True;


ret_val = shl_findsym(&handle, "acl", TYPE_PROCEDURE, &value);	ret_val = shl_findsym(&handle, "acl", TYPE_PROCEDURE, &value);

if(ret_val != 0) {	if (ret_val != 0) {
DEBUG(5, ("hpux_acl_call_presence: shl_findsym() returned %d, errno = %d, error %s\n",	DEBUG(5, ("hpux_acl_call_presence: shl_findsym() returned %d, errno = %d, error %s\n",
ret_val, errno, strerror(errno)));	ret_val, errno, strerror(errno)));
DEBUG(5,("hpux_acl_call_presence: acl() system call is not present. Check if you have JFS 3.3 and above?\n"));	DEBUG(5, ("hpux_acl_call_presence: acl() system call is not present. Check if you have JFS 3.3 and above?\n"));
return False;	return False;
}	}

DEBUG(10,("hpux_acl_call_presence: acl() system call is present. We have JFS 3.3 or above \n"));	DEBUG(10, ("hpux_acl_call_presence: acl() system call is present. We have JFS 3.3 or above \n"));

already_checked = True;	already_checked = True;
	#endif
return True;	return True;
}	}

Line 873 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_	Line 883 int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_

#define INITIAL_ACL_SIZE 16	#define INITIAL_ACL_SIZE 16

	#ifndef NACLENTRIES
	#define NACLENTRIES 0
	#endif

SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)	SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
{	{
SMB_ACL_T acl_d;	SMB_ACL_T acl_d;
Line 880 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL	Line 894 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL
int naccess; /* # of access ACL entries */	int naccess; /* # of access ACL entries */
int ndefault; /* # of default ACL entries */	int ndefault; /* # of default ACL entries */

if(hpux_acl_call_presence() == False) {	if (hpux_acl_call_presence() == False) {
/* Looks like we don't have the acl() system call on HPUX.	/* Looks like we don't have the acl() system call on HPUX.
* May be the system doesn't have the latest version of JFS.	* May be the system doesn't have the latest version of JFS.
*/	*/
Line 909 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL	Line 923 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL

sys_acl_free_acl(acl_d);	sys_acl_free_acl(acl_d);

if ((count = acl(path_p, ACL_CNT, 0, NULL)) < 0) {	if ((count = acl(path_p, ACL_CNT, NACLENTRIES, NULL)) < 0) {
return NULL;	return NULL;
}	}

Line 928 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL	Line 942 SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL
*	*
* Note: we assume that the acl() system call returned a	* Note: we assume that the acl() system call returned a
* well formed ACL which is sorted so that all of the	* well formed ACL which is sorted so that all of the
* access ACL entries preceed any default ACL entries	* access ACL entries precede any default ACL entries
*/	*/
for (naccess = 0; naccess < count; naccess++) {	for (naccess = 0; naccess < count; naccess++) {
if (acl_d->acl[naccess].a_type & ACL_DEFAULT)	if (acl_d->acl[naccess].a_type & ACL_DEFAULT)
Line 1007 SMB_ACL_T sys_acl_init(int count)	Line 1021 SMB_ACL_T sys_acl_init(int count)
* acl[] array, this actually allocates an ACL with room	* acl[] array, this actually allocates an ACL with room
* for (count+1) entries	* for (count+1) entries
*/	*/
if ((a = (SMB_ACL_T)SMB_MALLOC(sizeof a[0] + count * sizeof(struct acl))) == NULL) {	if ((a = (SMB_ACL_T)SMB_MALLOC(sizeof a[0] + count * sizeof (struct acl))) == NULL) {
errno = ENOMEM;	errno = ENOMEM;
return NULL;	return NULL;
}	}
Line 1091 struct hpux_acl_types {	Line 1105 struct hpux_acl_types {
* structures.	* structures.
* Inputs:	* Inputs:
*	*
* acl_count - Count of ACLs in the array of ACL strucutres.	* acl_count - Count of ACLs in the array of ACL structures.
* aclp - Array of ACL structures.	* aclp - Array of ACL structures.
* acl_type_count - Pointer to acl_types structure. Should already be	* acl_type_count - Pointer to acl_types structure. Should already be
* allocated.	* allocated.
Line 1105 static void hpux_count_obj(int acl_count, struct acl *	Line 1119 static void hpux_count_obj(int acl_count, struct acl *
{	{
int i;	int i;

memset(acl_type_count, 0, sizeof(struct hpux_acl_types));	memset(acl_type_count, 0, sizeof (struct hpux_acl_types));

for(i=0;i<acl_count;i++) {	for (i = 0; i < acl_count; i++) {
switch(aclp[i].a_type) {	switch (aclp[i].a_type) {
case USER:	case USER:
acl_type_count->n_user++;	acl_type_count->n_user++;
break;	break;
Line 1190 static void hpux_swap_acl_entries(struct acl *aclp0, s	Line 1204 static void hpux_swap_acl_entries(struct acl *aclp0, s

static BOOL hpux_prohibited_duplicate_type(int acl_type)	static BOOL hpux_prohibited_duplicate_type(int acl_type)
{	{
switch(acl_type) {	switch (acl_type) {
case USER:	case USER:
case GROUP:	case GROUP:
case DEF_USER:	case DEF_USER:
case DEF_GROUP:	case DEF_GROUP:
return True;	return True;
default:	default:
return False;	return False;
}	}
}	}

Line 1211 static BOOL hpux_prohibited_duplicate_type(int acl_typ	Line 1225 static BOOL hpux_prohibited_duplicate_type(int acl_typ

static int hpux_get_needed_class_perm(struct acl *aclp)	static int hpux_get_needed_class_perm(struct acl *aclp)
{	{
switch(aclp->a_type) {	switch (aclp->a_type) {
case USER:	case USER:
case GROUP_OBJ:	case GROUP_OBJ:
case GROUP:	case GROUP:
case DEF_USER_OBJ:	case DEF_USER_OBJ:
case DEF_USER:	case DEF_USER:
case DEF_GROUP_OBJ:	case DEF_GROUP_OBJ:
case DEF_GROUP:	case DEF_GROUP:
case DEF_CLASS_OBJ:	case DEF_CLASS_OBJ:
case DEF_OTHER_OBJ:	case DEF_OTHER_OBJ:
return aclp->a_perm;	return aclp->a_perm;
default:	default:
return 0;	return 0;
}	}
}	}

Line 1252 static int hpux_acl_sort(int acl_count, int calclass,	Line 1266 static int hpux_acl_sort(int acl_count, int calclass,
{	{
#if !defined(HAVE_HPUX_ACLSORT)	#if !defined(HAVE_HPUX_ACLSORT)
/*	/*
* The aclsort() system call is availabe on the latest HPUX General	* The aclsort() system call is available on the latest HPUX General
* Patch Bundles. So for HPUX, we developed our version of acl_sort	* Patch Bundles. So for HPUX, we developed our version of acl_sort
* function. Because, we don't want to update to a new	* function. Because, we don't want to update to a new
* HPUX GR bundle just for aclsort() call.	* HPUX GR bundle just for aclsort() call.
Line 1262 static int hpux_acl_sort(int acl_count, int calclass,	Line 1276 static int hpux_acl_sort(int acl_count, int calclass,
int n_class_obj_perm = 0;	int n_class_obj_perm = 0;
int i, j;	int i, j;

if(!acl_count) {	if (!acl_count) {
DEBUG(10,("Zero acl count passed. Returning Success\n"));	DEBUG(10, ("Zero acl count passed. Returning Success\n"));
return 0;	return 0;
}	}

if(aclp == NULL) {	if (aclp == NULL) {
DEBUG(0,("Null ACL pointer in hpux_acl_sort. Returning Failure. \n"));	DEBUG(0, ("Null ACL pointer in hpux_acl_sort. Returning Failure. \n"));
return -1;	return -1;
}	}

Line 1280 static int hpux_acl_sort(int acl_count, int calclass,	Line 1294 static int hpux_acl_sort(int acl_count, int calclass,
* CLASS_OBJ and OTHER_OBJ	* CLASS_OBJ and OTHER_OBJ
*/	*/

if( (acl_obj_count.n_user_obj != 1) \|\|	if (acl_obj_count.n_user_obj != 1
(acl_obj_count.n_group_obj != 1) \|\|	\|\| acl_obj_count.n_group_obj != 1
(acl_obj_count.n_class_obj != 1) \|\|	\|\| acl_obj_count.n_class_obj != 1
(acl_obj_count.n_other_obj != 1)	\|\| acl_obj_count.n_other_obj != 1) {
) {	DEBUG(0, ("hpux_acl_sort: More than one entry or no entries for \
DEBUG(0,("hpux_acl_sort: More than one entry or no entries for \
USER OBJ or GROUP_OBJ or OTHER_OBJ or CLASS_OBJ\n"));	USER OBJ or GROUP_OBJ or OTHER_OBJ or CLASS_OBJ\n"));
return -1;	return -1;
}	}
Line 1293 USER OBJ or GROUP_OBJ or OTHER_OBJ or CLASS_OBJ\n"));	Line 1306 USER OBJ or GROUP_OBJ or OTHER_OBJ or CLASS_OBJ\n"));
/* If any of the default objects are present, there should be only	/* If any of the default objects are present, there should be only
* one of them each.	* one of them each.
*/	*/
	if (acl_obj_count.n_def_user_obj > 1 \|\| acl_obj_count.n_def_group_obj > 1
if( (acl_obj_count.n_def_user_obj > 1) \|\| (acl_obj_count.n_def_group_obj > 1) \|\|	\|\| acl_obj_count.n_def_other_obj > 1 \|\| acl_obj_count.n_def_class_obj > 1) {
(acl_obj_count.n_def_other_obj > 1) \|\| (acl_obj_count.n_def_class_obj > 1) ) {	DEBUG(0, ("hpux_acl_sort: More than one entry for DEF_CLASS_OBJ \
DEBUG(0,("hpux_acl_sort: More than one entry for DEF_CLASS_OBJ \
or DEF_USER_OBJ or DEF_GROUP_OBJ or DEF_OTHER_OBJ\n"));	or DEF_USER_OBJ or DEF_GROUP_OBJ or DEF_OTHER_OBJ\n"));
return -1;	return -1;
}	}
Line 1307 or DEF_USER_OBJ or DEF_GROUP_OBJ or DEF_OTHER_OBJ\n"))	Line 1319 or DEF_USER_OBJ or DEF_GROUP_OBJ or DEF_OTHER_OBJ\n"))
* Sorting crieteria - First sort by ACL type. If there are multiple entries of	* Sorting crieteria - First sort by ACL type. If there are multiple entries of
* same ACL type, sort by ACL id.	* same ACL type, sort by ACL id.
*	*
* I am using the trival kind of sorting method here because, performance isn't	* I am using the trivial kind of sorting method here because, performance isn't
* really effected by the ACLs feature. More over there aren't going to be more	* really effected by the ACLs feature. More over there aren't going to be more
* than 17 entries on HPUX.	* than 17 entries on HPUX.
*/	*/

for(i=0; i<acl_count;i++) {	for (i = 0; i < acl_count; i++) {
for (j=i+1; j<acl_count; j++) {	for (j = i+1; j < acl_count; j++) {
if( aclp[i].a_type > aclp[j].a_type ) {	if (aclp[i].a_type > aclp[j].a_type) {
/* ACL entries out of order, swap them */	/* ACL entries out of order, swap them */

hpux_swap_acl_entries((aclp+i), (aclp+j));	hpux_swap_acl_entries((aclp+i), (aclp+j));
	} else if (aclp[i].a_type == aclp[j].a_type) {
} else if ( aclp[i].a_type == aclp[j].a_type ) {

/* ACL entries of same type, sort by id */	/* ACL entries of same type, sort by id */
	if (aclp[i].a_id > aclp[j].a_id) {
if(aclp[i].a_id > aclp[j].a_id) {
hpux_swap_acl_entries((aclp+i), (aclp+j));	hpux_swap_acl_entries((aclp+i), (aclp+j));
} else if (aclp[i].a_id == aclp[j].a_id) {	} else if (aclp[i].a_id == aclp[j].a_id) {
/* We have a duplicate entry. */	/* We have a duplicate entry. */
if(hpux_prohibited_duplicate_type(aclp[i].a_type)) {	if (hpux_prohibited_duplicate_type(aclp[i].a_type)) {
DEBUG(0, ("hpux_acl_sort: Duplicate entry: Type(hex): %x Id: %d\n",	DEBUG(0, ("hpux_acl_sort: Duplicate entry: Type(hex): %x Id: %d\n",
aclp[i].a_type, aclp[i].a_id));	aclp[i].a_type, aclp[i].a_id));
return -1;	return -1;
}	}
}	}

}	}
}	}
}	}

/* set the class obj permissions to the computed one. */	/* set the class obj permissions to the computed one. */
if(calclass) {	if (calclass) {
int n_class_obj_index = -1;	int n_class_obj_index = -1;

for(i=0;i<acl_count;i++) {	for (i = 0;i < acl_count; i++) {
n_class_obj_perm \|= hpux_get_needed_class_perm((aclp+i));	n_class_obj_perm \|= hpux_get_needed_class_perm((aclp+i));
	if (aclp[i].a_type == CLASS_OBJ)
if(aclp[i].a_type == CLASS_OBJ)
n_class_obj_index = i;	n_class_obj_index = i;
}	}
aclp[n_class_obj_index].a_perm = n_class_obj_perm;	aclp[n_class_obj_index].a_perm = n_class_obj_perm;
Line 1398 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T	Line 1404 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T
struct acl *acl_buf = NULL;	struct acl *acl_buf = NULL;
int ret;	int ret;

if(hpux_acl_call_presence() == False) {	if (hpux_acl_call_presence() == False) {
/* Looks like we don't have the acl() system call on HPUX.	/* Looks like we don't have the acl() system call on HPUX.
* May be the system doesn't have the latest version of JFS.	* May be the system doesn't have the latest version of JFS.
*/	*/
Line 1461 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T	Line 1467 int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T
* copy the access control and default entries into the buffer	* copy the access control and default entries into the buffer
*/	*/
memcpy(&acl_buf[0], &acc_acl->acl[0],	memcpy(&acl_buf[0], &acc_acl->acl[0],
acc_acl->count * sizeof(acl_buf[0]));	acc_acl->count * sizeof acl_buf[0]);

memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],	memcpy(&acl_buf[acc_acl->count], &def_acl->acl[0],
def_acl->count * sizeof(acl_buf[0]));	def_acl->count * sizeof acl_buf[0]);

/*	/*
* set the ACL_DEFAULT flag on the default entries	* set the ACL_DEFAULT flag on the default entries
Line 1730 int sys_acl_free_acl(SMB_ACL_T acl_d)	Line 1736 int sys_acl_free_acl(SMB_ACL_T acl_d)

/* Donated by Medha Date, mdate@austin.ibm.com, for IBM */	/* Donated by Medha Date, mdate@austin.ibm.com, for IBM */

int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)	int sys_acl_get_entry(SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
{	{
struct acl_entry_link *link;	struct acl_entry_link *link;
struct new_acl_entry *entry;	struct new_acl_entry *entry;
Line 1743 int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id,	Line 1749 int sys_acl_get_entry( SMB_ACL_T theacl, int entry_id,
return -1;	return -1;
}	}

DEBUG(10,("This is the count: %d\n",theacl->count));	DEBUG(10, ("This is the count: %d\n", theacl->count));

/* Check if count was previously set to -1. *	/* Check if count was previously set to -1. *
* If it was, that means we reached the end *	* If it was, that means we reached the end *
* of the acl last time. */	* of the acl last time. */
if(theacl->count == -1)	if (theacl->count == -1)
return(0);	return 0;

link = theacl;	link = theacl;
/* To get to the next acl, traverse linked list until index *	/* To get to the next acl, traverse linked list until index *
* of acl matches the count we are keeping. This count is *	* of acl matches the count we are keeping. This count is *
* incremented each time we return an acl entry. */	* incremented each time we return an acl entry. */

for(keep_going = 0; keep_going < theacl->count; keep_going++)	for (keep_going = 0; keep_going < theacl->count; keep_going++)
link = link->nextp;	link = link->nextp;

entry = *entry_p = link->entryp;	entry = *entry_p = link->entryp;

DEBUG(10,("*entry_p is %d\n",entry_p));	DEBUG(10, ("*entry_p is %d\n", entry_p));
DEBUG(10,("*entry_p->ace_access is %d\n",entry->ace_access));	DEBUG(10, ("*entry_p->ace_access is %d\n", entry->ace_access));

/* Increment count */	/* Increment count */
theacl->count++;	theacl->count++;
if(link->nextp == NULL)	if (link->nextp == NULL)
theacl->count = -1;	theacl->count = -1;

return(1);	return 1;
}	}

int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)	int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
{	{
/* Initialize tag type */	/* Initialize tag type */

*tag_type_p = -1;	*tag_type_p = -1;
DEBUG(10,("the tagtype is %d\n",entry_d->ace_id->id_type));	DEBUG(10, ("the tagtype is %d\n", entry_d->ace_id->id_type));

/* Depending on what type of entry we have, *	/* Depending on what type of entry we have, *
* return tag type. */	* return tag type. */
switch(entry_d->ace_id->id_type) {	switch (entry_d->ace_id->id_type) {
case ACEID_USER:	case ACEID_USER:
*tag_type_p = SMB_ACL_USER;	*tag_type_p = SMB_ACL_USER;
break;	break;
Line 1796 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB	Line 1802 int sys_acl_get_tag_type( SMB_ACL_ENTRY_T entry_d, SMB
break;	break;

default:	default:
return(-1);	return -1;
}	}

return(0);	return 0;
}	}

SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type)	SMB_ACL_T sys_acl_get_file(const char *path_p, SMB_ACL_TYPE_T type)
{	{
struct acl file_acl = (struct acl )NULL;	struct acl file_acl = (struct acl )NULL;
struct acl_entry *acl_entry;	struct acl_entry *acl_entry;
Line 1814 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1820 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
int rc = 0;	int rc = 0;

/* AIX has no DEFAULT */	/* AIX has no DEFAULT */
if ( type == SMB_ACL_TYPE_DEFAULT ) {	if (type == SMB_ACL_TYPE_DEFAULT) {
#ifdef ENOTSUP	#ifdef ENOTSUP
errno = ENOTSUP;	errno = ENOTSUP;
#else	#else
Line 1825 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1831 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC

/* Get the acl using statacl */	/* Get the acl using statacl */

DEBUG(10,("Entering sys_acl_get_file\n"));	DEBUG(10, ("Entering sys_acl_get_file\n"));
DEBUG(10,("path_p is %s\n",path_p));	DEBUG(10, ("path_p is %s\n", path_p));

file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);	file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);

if(file_acl == NULL) {	if (file_acl == NULL) {
errno=ENOMEM;	errno=ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file: %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file: %d\n", errno));
return(NULL);	return NULL;
}	}

memset(file_acl,0,BUFSIZ);	memset(file_acl, 0, BUFSIZ);

rc = statacl((char *)path_p,0,file_acl,BUFSIZ);	rc = statacl((char *)path_p, 0, file_acl, BUFSIZ);
if(rc == -1) {	if (rc == -1) {
DEBUG(0,("statacl returned %d with errno %d\n",rc,errno));	DEBUG(0, ("statacl returned %d with errno %d\n", rc, errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

DEBUG(10,("Got facl and returned it\n"));	DEBUG(10, ("Got facl and returned it\n"));

/* Point to the first acl entry in the acl */	/* Point to the first acl entry in the acl */
acl_entry = file_acl->acl_ext;	acl_entry = file_acl->acl_ext;
Line 1856 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1862 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
* code. */	* code. */

acl_entry_link_head = acl_entry_link = sys_acl_init(0);	acl_entry_link_head = acl_entry_link = sys_acl_init(0);
if(acl_entry_link_head == NULL)	if (acl_entry_link_head == NULL)
return(NULL);	return NULL;

acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file is %d\n", errno));
return(NULL);	return NULL;
}	}

DEBUG(10,("acl_entry is %d\n",acl_entry));	DEBUG(10, ("acl_entry is %d\n", acl_entry));
DEBUG(10,("acl_last(file_acl) id %d\n",acl_last(file_acl)));	DEBUG(10, ("acl_last(file_acl) id %d\n", acl_last(file_acl)));

/* Check if the extended acl bit is on. *	/* Check if the extended acl bit is on. *
* If it isn't, do not show the *	* If it isn't, do not show the *
* contents of the acl since AIX intends *	* contents of the acl since AIX intends *
* the extended info to remain unused */	* the extended info to remain unused */

if(file_acl->acl_mode & S_IXACL){	if (file_acl->acl_mode & S_IXACL){
/* while we are not pointing to the very end */	/* while we are not pointing to the very end */
while(acl_entry < acl_last(file_acl)) {	while (acl_entry < acl_last(file_acl)) {
/* before we malloc anything, make sure this is */	/* before we malloc anything, make sure this is */
/* a valid acl entry and one that we want to map */	/* a valid acl entry and one that we want to map */
idp = id_nxt(acl_entry->ace_id);	idp = id_nxt(acl_entry->ace_id);
if((acl_entry->ace_type == ACC_SPECIFY \|\|	if ((acl_entry->ace_type == ACC_SPECIFY \|\| acl_entry->ace_type == ACC_PERMIT)
(acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) {	&& idp != id_last(acl_entry)) {
acl_entry = acl_nxt(acl_entry);	acl_entry = acl_nxt(acl_entry);
continue;	continue;
}	}

idp = acl_entry->ace_id;	idp = acl_entry->ace_id;
Line 1893 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1899 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
* The first entry needs to keep prevp pointing to NULL *	* The first entry needs to keep prevp pointing to NULL *
* and already has entryp allocated. */	* and already has entryp allocated. */

if(acl_entry_link_head->count != 0) {	if (acl_entry_link_head->count != 0) {
acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);	acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);

if(acl_entry_link->nextp == NULL) {	if (acl_entry_link->nextp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file is %d\n", errno));
return(NULL);	return NULL;
}	}

acl_entry_link->nextp->prevp = acl_entry_link;	acl_entry_link->nextp->prevp = acl_entry_link;
acl_entry_link = acl_entry_link->nextp;	acl_entry_link = acl_entry_link->nextp;
acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file is %d\n", errno));
return(NULL);	return NULL;
}	}
acl_entry_link->nextp = NULL;	acl_entry_link->nextp = NULL;
}	}
Line 1924 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1930 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC

acl_entry_link->entryp->ace_access = acl_entry->ace_access;	acl_entry_link->entryp->ace_access = acl_entry->ace_access;

memcpy(acl_entry_link->entryp->ace_id,idp,sizeof(struct ace_id));	memcpy(acl_entry_link->entryp->ace_id, idp, sizeof (struct ace_id));

/* The access in the acl entries must be left shifted by *	/* The access in the acl entries must be left shifted by *
* three bites, because they will ultimately be compared *	* three bites, because they will ultimately be compared *
* to S_IRUSR, S_IWUSR, and S_IXUSR. */	* to S_IRUSR, S_IWUSR, and S_IXUSR. */

switch(acl_entry->ace_type){	switch (acl_entry->ace_type){
case ACC_PERMIT:	case ACC_PERMIT:
case ACC_SPECIFY:	case ACC_SPECIFY:
acl_entry_link->entryp->ace_access = acl_entry->ace_access;	acl_entry_link->entryp->ace_access = acl_entry->ace_access;
Line 1940 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1946 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
case ACC_DENY:	case ACC_DENY:
/* Since there is no way to return a DENY acl entry *	/* Since there is no way to return a DENY acl entry *
* change to PERMIT and then shift. */	* change to PERMIT and then shift. */
DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access));	DEBUG(10, ("acl_entry->ace_access is %d\n", acl_entry->ace_access));
acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;	acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;
DEBUG(10,("acl_entry_link->entryp->ace_access is %d\n",acl_entry_link->entryp->ace_access));	DEBUG(10, ("acl_entry_link->entryp->ace_access is %d\n", acl_entry_link->entryp->ace_access));
acl_entry_link->entryp->ace_access <<= 6;	acl_entry_link->entryp->ace_access <<= 6;
acl_entry_link_head->count++;	acl_entry_link_head->count++;
break;	break;
default:	default:
return(0);	return 0;
}	}

DEBUG(10,("acl_entry = %d\n",acl_entry));	DEBUG(10, ("acl_entry = %d\n", acl_entry));
DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type));	DEBUG(10, ("The ace_type is %d\n", acl_entry->ace_type));

acl_entry = acl_nxt(acl_entry);	acl_entry = acl_nxt(acl_entry);
}	}
Line 1961 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1967 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
* part of the acl entries in an acl, they must *	* part of the acl entries in an acl, they must *
* be dummied up to become part of the list. */	* be dummied up to become part of the list. */

for( i = 1; i < 4; i++) {	for (i = 1; i < 4; i++) {
DEBUG(10,("i is %d\n",i));	DEBUG(10, ("i is %d\n", i));
if(acl_entry_link_head->count != 0) {	if (acl_entry_link_head->count != 0) {
acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);	acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
if(acl_entry_link->nextp == NULL) {	if (acl_entry_link->nextp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file is %d\n", errno));
return(NULL);	return NULL;
}	}

acl_entry_link->nextp->prevp = acl_entry_link;	acl_entry_link->nextp->prevp = acl_entry_link;
acl_entry_link = acl_entry_link->nextp;	acl_entry_link = acl_entry_link->nextp;
acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));	DEBUG(0, ("Error in AIX sys_acl_get_file is %d\n", errno));
return(NULL);	return NULL;
}	}
}	}

Line 1988 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 1994 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
new_acl_entry = acl_entry_link->entryp;	new_acl_entry = acl_entry_link->entryp;
idp = new_acl_entry->ace_id;	idp = new_acl_entry->ace_id;

new_acl_entry->ace_len = sizeof(struct acl_entry);	new_acl_entry->ace_len = sizeof (struct acl_entry);
new_acl_entry->ace_type = ACC_PERMIT;	new_acl_entry->ace_type = ACC_PERMIT;
idp->id_len = sizeof(struct ace_id);	idp->id_len = sizeof (struct ace_id);
DEBUG(10,("idp->id_len = %d\n",idp->id_len));	DEBUG(10, ("idp->id_len = %d\n", idp->id_len));
memset(idp->id_data,0,sizeof(uid_t));	memset(idp->id_data, 0, sizeof (uid_t));

switch(i) {	switch (i) {
case 2:	case 2:
new_acl_entry->ace_access = file_acl->g_access << 6;	new_acl_entry->ace_access = file_acl->g_access << 6;
idp->id_type = SMB_ACL_GROUP_OBJ;	idp->id_type = SMB_ACL_GROUP_OBJ;
Line 2011 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC	Line 2017 SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_AC
break;	break;

default:	default:
return(NULL);	return NULL;

}	}

acl_entry_link_head->count++;	acl_entry_link_head->count++;
DEBUG(10,("new_acl_entry->ace_access = %d\n",new_acl_entry->ace_access));	DEBUG(10, ("new_acl_entry->ace_access = %d\n", new_acl_entry->ace_access));
}	}

acl_entry_link_head->count = 0;	acl_entry_link_head->count = 0;
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);

return(acl_entry_link_head);	return acl_entry_link_head;
}	}

#if 0	#if 0
Line 2039 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2045 SMB_ACL_T sys_acl_get_fd(int fd)

/* Get the acl using fstatacl */	/* Get the acl using fstatacl */

DEBUG(10,("Entering sys_acl_get_fd\n"));	DEBUG(10, ("Entering sys_acl_get_fd\n"));
DEBUG(10,("fd is %d\n",fd));	DEBUG(10, ("fd is %d\n", fd));
file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);	file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);

if(file_acl == NULL) {	if (file_acl == NULL) {
errno=ENOMEM;	errno=ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
return(NULL);	return NULL;
}	}

memset(file_acl,0,BUFSIZ);	memset(file_acl, 0, BUFSIZ);

rc = fstatacl(fd,0,file_acl,BUFSIZ);	rc = fstatacl(fd, 0, file_acl, BUFSIZ);
if(rc == -1) {	if (rc == -1) {
DEBUG(0,("The fstatacl call returned %d with errno %d\n",rc,errno));	DEBUG(0, ("The fstatacl call returned %d with errno %d\n", rc, errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

DEBUG(10,("Got facl and returned it\n"));	DEBUG(10, ("Got facl and returned it\n"));

/* Point to the first acl entry in the acl */	/* Point to the first acl entry in the acl */

Line 2069 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2075 SMB_ACL_T sys_acl_get_fd(int fd)
* code. */	* code. */

acl_entry_link_head = acl_entry_link = sys_acl_init(0);	acl_entry_link_head = acl_entry_link = sys_acl_init(0);
if(acl_entry_link_head == NULL){	if (acl_entry_link_head == NULL){
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);

if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

DEBUG(10,("acl_entry is %d\n",acl_entry));	DEBUG(10, ("acl_entry is %d\n", acl_entry));
DEBUG(10,("acl_last(file_acl) id %d\n",acl_last(file_acl)));	DEBUG(10, ("acl_last(file_acl) id %d\n", acl_last(file_acl)));

/* Check if the extended acl bit is on. *	/* Check if the extended acl bit is on. *
* If it isn't, do not show the *	* If it isn't, do not show the *
* contents of the acl since AIX intends *	* contents of the acl since AIX intends *
* the extended info to remain unused */	* the extended info to remain unused */

if(file_acl->acl_mode & S_IXACL){	if (file_acl->acl_mode & S_IXACL){
/* while we are not pointing to the very end */	/* while we are not pointing to the very end */
while(acl_entry < acl_last(file_acl)) {	while (acl_entry < acl_last(file_acl)) {
/* before we malloc anything, make sure this is */	/* before we malloc anything, make sure this is */
/* a valid acl entry and one that we want to map */	/* a valid acl entry and one that we want to map */

idp = id_nxt(acl_entry->ace_id);	idp = id_nxt(acl_entry->ace_id);
if((acl_entry->ace_type == ACC_SPECIFY \|\|	if ((acl_entry->ace_type == ACC_SPECIFY \|\|
(acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) {	(acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) {
acl_entry = acl_nxt(acl_entry);	acl_entry = acl_nxt(acl_entry);
continue;	continue;
Line 2110 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2116 SMB_ACL_T sys_acl_get_fd(int fd)
* The first entry needs to keep prevp pointing to NULL *	* The first entry needs to keep prevp pointing to NULL *
* and already has entryp allocated. */	* and already has entryp allocated. */

if(acl_entry_link_head->count != 0) {	if (acl_entry_link_head->count != 0) {
acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);	acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
if(acl_entry_link->nextp == NULL) {	if (acl_entry_link->nextp == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}
acl_entry_link->nextp->prevp = acl_entry_link;	acl_entry_link->nextp->prevp = acl_entry_link;
acl_entry_link = acl_entry_link->nextp;	acl_entry_link = acl_entry_link->nextp;
acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);
if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

acl_entry_link->nextp = NULL;	acl_entry_link->nextp = NULL;
Line 2139 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2145 SMB_ACL_T sys_acl_get_fd(int fd)
acl_entry_link->entryp->ace_type = acl_entry->ace_type;	acl_entry_link->entryp->ace_type = acl_entry->ace_type;
acl_entry_link->entryp->ace_access = acl_entry->ace_access;	acl_entry_link->entryp->ace_access = acl_entry->ace_access;

memcpy(acl_entry_link->entryp->ace_id, idp, sizeof(struct ace_id));	memcpy(acl_entry_link->entryp->ace_id, idp, sizeof (struct ace_id));

/* The access in the acl entries must be left shifted by *	/* The access in the acl entries must be left shifted by *
* three bites, because they will ultimately be compared *	* three bites, because they will ultimately be compared *
* to S_IRUSR, S_IWUSR, and S_IXUSR. */	* to S_IRUSR, S_IWUSR, and S_IXUSR. */

switch(acl_entry->ace_type){	switch (acl_entry->ace_type){
case ACC_PERMIT:	case ACC_PERMIT:
case ACC_SPECIFY:	case ACC_SPECIFY:
acl_entry_link->entryp->ace_access = acl_entry->ace_access;	acl_entry_link->entryp->ace_access = acl_entry->ace_access;
Line 2155 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2161 SMB_ACL_T sys_acl_get_fd(int fd)
case ACC_DENY:	case ACC_DENY:
/* Since there is no way to return a DENY acl entry *	/* Since there is no way to return a DENY acl entry *
* change to PERMIT and then shift. */	* change to PERMIT and then shift. */
DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access));	DEBUG(10, ("acl_entry->ace_access is %d\n", acl_entry->ace_access));
acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;	acl_entry_link->entryp->ace_access = ~acl_entry->ace_access & 7;
DEBUG(10,("acl_entry_link->entryp->ace_access is %d\n",acl_entry_link->entryp->ace_access));	DEBUG(10, ("acl_entry_link->entryp->ace_access is %d\n", acl_entry_link->entryp->ace_access));
acl_entry_link->entryp->ace_access <<= 6;	acl_entry_link->entryp->ace_access <<= 6;
acl_entry_link_head->count++;	acl_entry_link_head->count++;
break;	break;
default:	default:
return(0);	return 0;
}	}

DEBUG(10,("acl_entry = %d\n",acl_entry));	DEBUG(10, ("acl_entry = %d\n", acl_entry));
DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type));	DEBUG(10, ("The ace_type is %d\n", acl_entry->ace_type));

acl_entry = acl_nxt(acl_entry);	acl_entry = acl_nxt(acl_entry);
}	}
Line 2176 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2182 SMB_ACL_T sys_acl_get_fd(int fd)
* part of the acl entries in an acl, they must *	* part of the acl entries in an acl, they must *
* be dummied up to become part of the list. */	* be dummied up to become part of the list. */

for( i = 1; i < 4; i++) {	for (i = 1; i < 4; i++) {
DEBUG(10,("i is %d\n",i));	DEBUG(10, ("i is %d\n", i));
if(acl_entry_link_head->count != 0){	if (acl_entry_link_head->count != 0){
acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);	acl_entry_link->nextp = SMB_MALLOC_P(struct acl_entry_link);
if(acl_entry_link->nextp == NULL) {	if (acl_entry_link->nextp == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
return(NULL);	return NULL;
}	}

acl_entry_link->nextp->prevp = acl_entry_link;	acl_entry_link->nextp->prevp = acl_entry_link;
acl_entry_link = acl_entry_link->nextp;	acl_entry_link = acl_entry_link->nextp;
acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);	acl_entry_link->entryp = SMB_MALLOC_P(struct new_acl_entry);

if(acl_entry_link->entryp == NULL) {	if (acl_entry_link->entryp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_get_fd is %d\n", errno));
return(NULL);	return NULL;
}	}
}	}

Line 2204 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2210 SMB_ACL_T sys_acl_get_fd(int fd)
new_acl_entry = acl_entry_link->entryp;	new_acl_entry = acl_entry_link->entryp;
idp = new_acl_entry->ace_id;	idp = new_acl_entry->ace_id;

new_acl_entry->ace_len = sizeof(struct acl_entry);	new_acl_entry->ace_len = sizeof (struct acl_entry);
new_acl_entry->ace_type = ACC_PERMIT;	new_acl_entry->ace_type = ACC_PERMIT;
idp->id_len = sizeof(struct ace_id);	idp->id_len = sizeof (struct ace_id);
DEBUG(10,("idp->id_len = %d\n",idp->id_len));	DEBUG(10, ("idp->id_len = %d\n", idp->id_len));
memset(idp->id_data,0,sizeof(uid_t));	memset(idp->id_data, 0, sizeof (uid_t));

switch(i) {	switch (i) {
case 2:	case 2:
new_acl_entry->ace_access = file_acl->g_access << 6;	new_acl_entry->ace_access = file_acl->g_access << 6;
idp->id_type = SMB_ACL_GROUP_OBJ;	idp->id_type = SMB_ACL_GROUP_OBJ;
Line 2227 SMB_ACL_T sys_acl_get_fd(int fd)	Line 2233 SMB_ACL_T sys_acl_get_fd(int fd)
break;	break;

default:	default:
return(NULL);	return NULL;
}	}

acl_entry_link_head->count++;	acl_entry_link_head->count++;
DEBUG(10,("new_acl_entry->ace_access = %d\n",new_acl_entry->ace_access));	DEBUG(10, ("new_acl_entry->ace_access = %d\n", new_acl_entry->ace_access));
}	}

acl_entry_link_head->count = 0;	acl_entry_link_head->count = 0;
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);

return(acl_entry_link_head);	return acl_entry_link_head;
}	}
#endif	#endif

Line 2253 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA	Line 2259 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA

permset = &entry->ace_access;	permset = &entry->ace_access;

DEBUG(10,("permset is %d\n",permset));	DEBUG(10, ("permset is %d\n", permset));
bits_p = (permset & S_IRUSR ? 4 : 0)	bits_p = (permset & S_IRUSR ? 4 : 0)
\| (*permset & S_IWUSR ? 2 : 0)	\| (*permset & S_IWUSR ? 2 : 0)
\| (*permset & S_IXUSR ? 1 : 0);	\| (*permset & S_IXUSR ? 1 : 0);
Line 2261 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA	Line 2267 int sys_acl_get_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TA
return 0;	return 0;
}	}

SMB_ACL_T sys_acl_init( int count)	SMB_ACL_T sys_acl_init(int count)
{	{
struct acl_entry_link *theacl = NULL;	struct acl_entry_link *theacl = NULL;

Line 2270 SMB_ACL_T sys_acl_init( int count)	Line 2276 SMB_ACL_T sys_acl_init( int count)
return NULL;	return NULL;
}	}

DEBUG(10,("Entering sys_acl_init\n"));	DEBUG(10, ("Entering sys_acl_init\n"));

theacl = SMB_MALLOC_P(struct acl_entry_link);	theacl = SMB_MALLOC_P(struct acl_entry_link);
if(theacl == NULL) {	if (theacl == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_init is %d\n",errno));	DEBUG(0, ("Error in sys_acl_init is %d\n", errno));
return(NULL);	return NULL;
}	}

theacl->count = 0;	theacl->count = 0;
theacl->nextp = NULL;	theacl->nextp = NULL;
theacl->prevp = NULL;	theacl->prevp = NULL;
theacl->entryp = NULL;	theacl->entryp = NULL;
DEBUG(10,("Exiting sys_acl_init\n"));	DEBUG(10, ("Exiting sys_acl_init\n"));
return(theacl);	return theacl;
}	}

int sys_acl_create_entry( SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)	int sys_acl_create_entry(SMB_ACL_T pacl, SMB_ACL_ENTRY_T pentry)
{	{
struct acl_entry_link *theacl;	struct acl_entry_link *theacl;
struct acl_entry_link *acl_entryp;	struct acl_entry_link *acl_entryp;
struct acl_entry_link *temp_entry;	struct acl_entry_link *temp_entry;
int counting;	int counting;

DEBUG(10,("Entering the sys_acl_create_entry\n"));	DEBUG(10, ("Entering the sys_acl_create_entry\n"));

theacl = acl_entryp = *pacl;	theacl = acl_entryp = *pacl;

/* Get to the end of the acl before adding entry */	/* Get to the end of the acl before adding entry */

for(counting=0; counting < theacl->count; counting++){	for (counting = 0; counting < theacl->count; counting++){
DEBUG(10,("The acl_entryp is %d\n",acl_entryp));	DEBUG(10, ("The acl_entryp is %d\n", acl_entryp));
temp_entry = acl_entryp;	temp_entry = acl_entryp;
acl_entryp = acl_entryp->nextp;	acl_entryp = acl_entryp->nextp;
}	}

if(theacl->count != 0){	if (theacl->count != 0){
temp_entry->nextp = acl_entryp = SMB_MALLOC_P(struct acl_entry_link);	temp_entry->nextp = acl_entryp = SMB_MALLOC_P(struct acl_entry_link);
if(acl_entryp == NULL) {	if (acl_entryp == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_create_entry is %d\n",errno));	DEBUG(0, ("Error in sys_acl_create_entry is %d\n", errno));
return(-1);	return -1;
}	}

DEBUG(10,("The acl_entryp is %d\n",acl_entryp));	DEBUG(10, ("The acl_entryp is %d\n", acl_entryp));
acl_entryp->prevp = temp_entry;	acl_entryp->prevp = temp_entry;
DEBUG(10,("The acl_entryp->prevp is %d\n",acl_entryp->prevp));	DEBUG(10, ("The acl_entryp->prevp is %d\n", acl_entryp->prevp));
}	}

*pentry = acl_entryp->entryp = SMB_MALLOC_P(struct new_acl_entry);	*pentry = acl_entryp->entryp = SMB_MALLOC_P(struct new_acl_entry);
if(*pentry == NULL) {	if (*pentry == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_create_entry is %d\n",errno));	DEBUG(0, ("Error in sys_acl_create_entry is %d\n", errno));
return(-1);	return -1;
}	}

memset(*pentry,0,sizeof(struct new_acl_entry));	memset(*pentry, 0, sizeof (struct new_acl_entry));
acl_entryp->entryp->ace_len = sizeof(struct acl_entry);	acl_entryp->entryp->ace_len = sizeof (struct acl_entry);
acl_entryp->entryp->ace_type = ACC_PERMIT;	acl_entryp->entryp->ace_type = ACC_PERMIT;
acl_entryp->entryp->ace_id->id_len = sizeof(struct ace_id);	acl_entryp->entryp->ace_id->id_len = sizeof (struct ace_id);
acl_entryp->nextp = NULL;	acl_entryp->nextp = NULL;
theacl->count++;	theacl->count++;
DEBUG(10,("Exiting sys_acl_create_entry\n"));	DEBUG(10, ("Exiting sys_acl_create_entry\n"));
return(0);	return 0;
}	}

int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)	int sys_acl_set_info(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tag_type, uint32 bits, id_t u_g_id)
{	{
entry->ace_id->id_type = tag_type;	entry->ace_id->id_type = tag_type;
DEBUG(10,("The tag type is %d\n",entry->ace_id->id_type));	DEBUG(10, ("The tag type is %d\n", entry->ace_id->id_type));

if (tag_type == SMB_ACL_USER \|\| tag_type == SMB_ACL_GROUP)	if (tag_type == SMB_ACL_USER \|\| tag_type == SMB_ACL_GROUP)
memcpy(entry->ace_id->id_data, &u_g_id, sizeof (id_t));	memcpy(entry->ace_id->id_data, &u_g_id, sizeof (id_t));

entry->ace_access = bits;	entry->ace_access = bits;
DEBUG(10,("entry->ace_access = %d\n",entry->ace_access));	DEBUG(10, ("entry->ace_access = %d\n", entry->ace_access));

return 0;	return 0;
}	}

int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)	int sys_acl_set_access_bits(SMB_ACL_ENTRY_T entry, uint32 bits)
{	{
DEBUG(10,("Starting AIX sys_acl_set_permset\n"));	DEBUG(10, ("Starting AIX sys_acl_set_permset\n"));
entry->ace_access = bits;	entry->ace_access = bits;
DEBUG(10,("entry->ace_access = %d\n",entry->ace_access));	DEBUG(10, ("entry->ace_access = %d\n", entry->ace_access));
DEBUG(10,("Ending AIX sys_acl_set_permset\n"));	DEBUG(10, ("Ending AIX sys_acl_set_permset\n"));
return(0);	return 0;
}	}

int sys_acl_valid( SMB_ACL_T theacl )	int sys_acl_valid(SMB_ACL_T theacl)
{	{
int user_obj = 0;	int user_obj = 0;
int group_obj = 0;	int group_obj = 0;
int other_obj = 0;	int other_obj = 0;
struct acl_entry_link *acl_entry;	struct acl_entry_link *acl_entry;

for(acl_entry=theacl; acl_entry != NULL; acl_entry = acl_entry->nextp) {	for (acl_entry=theacl; acl_entry != NULL; acl_entry = acl_entry->nextp) {
user_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_USER_OBJ);	user_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_USER_OBJ);
group_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_GROUP_OBJ);	group_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_GROUP_OBJ);
other_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_OTHER);	other_obj += (acl_entry->entryp->ace_id->id_type == SMB_ACL_OTHER);
}	}

DEBUG(10,("user_obj=%d, group_obj=%d, other_obj=%d\n",user_obj,group_obj,other_obj));	DEBUG(10, ("user_obj=%d, group_obj=%d, other_obj=%d\n", user_obj, group_obj, other_obj));

if(user_obj != 1 \|\| group_obj != 1 \|\| other_obj != 1)	if (user_obj != 1 \|\| group_obj != 1 \|\| other_obj != 1)
return(-1);	return -1;

return(0);	return 0;
}	}

int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)	int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
{	{
struct acl_entry_link *acl_entry_link = NULL;	struct acl_entry_link *acl_entry_link = NULL;
struct acl *file_acl = NULL;	struct acl *file_acl = NULL;
Line 2392 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T	Line 2398 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T
uint acl_length;	uint acl_length;
uint rc;	uint rc;

DEBUG(10,("Entering sys_acl_set_file\n"));	DEBUG(10, ("Entering sys_acl_set_file\n"));
DEBUG(10,("File name is %s\n",name));	DEBUG(10, ("File name is %s\n", name));

/* AIX has no default ACL */	/* AIX has no default ACL */
if(acltype == SMB_ACL_TYPE_DEFAULT)	if (acltype == SMB_ACL_TYPE_DEFAULT)
return(0);	return 0;

acl_length = BUFSIZ;	acl_length = BUFSIZ;
file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);	file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);

if(file_acl == NULL) {	if (file_acl == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_set_file is %d\n",errno));	DEBUG(0, ("Error in sys_acl_set_file is %d\n", errno));
return(-1);	return -1;
}	}

memset(file_acl,0,BUFSIZ);	memset(file_acl, 0, BUFSIZ);

file_acl->acl_len = ACL_SIZ;	file_acl->acl_len = ACL_SIZ;
file_acl->acl_mode = S_IXACL;	file_acl->acl_mode = S_IXACL;

for(acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {	for (acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {
acl_entry_link->entryp->ace_access >>= 6;	acl_entry_link->entryp->ace_access >>= 6;
id_type = acl_entry_link->entryp->ace_id->id_type;	id_type = acl_entry_link->entryp->ace_id->id_type;

switch(id_type) {	switch (id_type) {
case SMB_ACL_USER_OBJ:	case SMB_ACL_USER_OBJ:
file_acl->u_access = acl_entry_link->entryp->ace_access;	file_acl->u_access = acl_entry_link->entryp->ace_access;
continue;	continue;
Line 2431 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T	Line 2437 int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T
continue;	continue;
}	}

if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) {	if ((file_acl->acl_len + sizeof (struct acl_entry)) > acl_length) {
acl_length += sizeof(struct acl_entry);	acl_length += sizeof (struct acl_entry);
file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);	file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);
if(file_acl_temp == NULL) {	if (file_acl_temp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_set_file is %d\n",errno));	DEBUG(0, ("Error in sys_acl_set_file is %d\n", errno));
return(-1);	return -1;
}	}

memcpy(file_acl_temp,file_acl,file_acl->acl_len);	memcpy(file_acl_temp, file_acl, file_acl->acl_len);
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
file_acl = file_acl_temp;	file_acl = file_acl_temp;
}	}

acl_entry = (struct acl_entry )((char )file_acl + file_acl->acl_len);	acl_entry = (struct acl_entry )((char )file_acl + file_acl->acl_len);
file_acl->acl_len += sizeof(struct acl_entry);	file_acl->acl_len += sizeof (struct acl_entry);
acl_entry->ace_len = acl_entry_link->entryp->ace_len;	acl_entry->ace_len = acl_entry_link->entryp->ace_len;
acl_entry->ace_access = acl_entry_link->entryp->ace_access;	acl_entry->ace_access = acl_entry_link->entryp->ace_access;

/* In order to use this, we'll need to wait until we can get denies */	/* In order to use this, we'll need to wait until we can get denies */
/* if(!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)	/* if (!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)
acl_entry->ace_type = ACC_SPECIFY; */	acl_entry->ace_type = ACC_SPECIFY; */

acl_entry->ace_type = ACC_SPECIFY;	acl_entry->ace_type = ACC_SPECIFY;

ace_id = acl_entry->ace_id;	ace_id = acl_entry->ace_id;

ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;	ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;
DEBUG(10,("The id type is %d\n",ace_id->id_type));	DEBUG(10, ("The id type is %d\n", ace_id->id_type));
ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;	ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;
memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof(uid_t));	memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof (uid_t));
memcpy(acl_entry->ace_id->id_data, &user_id, sizeof(uid_t));	memcpy(acl_entry->ace_id->id_data, &user_id, sizeof (uid_t));
}	}

rc = chacl((char*)name,file_acl,file_acl->acl_len);	rc = chacl((char*)name, file_acl, file_acl->acl_len);
DEBUG(10,("errno is %d\n",errno));	DEBUG(10, ("errno is %d\n", errno));
DEBUG(10,("return code is %d\n",rc));	DEBUG(10, ("return code is %d\n", rc));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
DEBUG(10,("Exiting the sys_acl_set_file\n"));	DEBUG(10, ("Exiting the sys_acl_set_file\n"));
return(rc);	return rc;
}	}

#if 0	#if 0
int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	int sys_acl_set_fd(int fd, SMB_ACL_T theacl)
{	{
struct acl_entry_link *acl_entry_link = NULL;	struct acl_entry_link *acl_entry_link = NULL;
struct acl *file_acl = NULL;	struct acl *file_acl = NULL;
Line 2487 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	Line 2493 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
uint acl_length;	uint acl_length;
uint rc;	uint rc;

DEBUG(10,("Entering sys_acl_set_fd\n"));	DEBUG(10, ("Entering sys_acl_set_fd\n"));
acl_length = BUFSIZ;	acl_length = BUFSIZ;
file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);	file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);

if(file_acl == NULL) {	if (file_acl == NULL) {
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_set_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_set_fd is %d\n", errno));
return(-1);	return -1;
}	}

memset(file_acl,0,BUFSIZ);	memset(file_acl, 0, BUFSIZ);

file_acl->acl_len = ACL_SIZ;	file_acl->acl_len = ACL_SIZ;
file_acl->acl_mode = S_IXACL;	file_acl->acl_mode = S_IXACL;

for(acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {	for (acl_entry_link=theacl; acl_entry_link != NULL; acl_entry_link = acl_entry_link->nextp) {
acl_entry_link->entryp->ace_access >>= 6;	acl_entry_link->entryp->ace_access >>= 6;
id_type = acl_entry_link->entryp->ace_id->id_type;	id_type = acl_entry_link->entryp->ace_id->id_type;
DEBUG(10,("The id_type is %d\n",id_type));	DEBUG(10, ("The id_type is %d\n", id_type));

switch(id_type) {	switch (id_type) {
case SMB_ACL_USER_OBJ:	case SMB_ACL_USER_OBJ:
file_acl->u_access = acl_entry_link->entryp->ace_access;	file_acl->u_access = acl_entry_link->entryp->ace_access;
continue;	continue;
Line 2521 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	Line 2527 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
continue;	continue;
}	}

if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) {	if ((file_acl->acl_len + sizeof (struct acl_entry)) > acl_length) {
acl_length += sizeof(struct acl_entry);	acl_length += sizeof (struct acl_entry);
file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);	file_acl_temp = (struct acl *)SMB_MALLOC(acl_length);
if(file_acl_temp == NULL) {	if (file_acl_temp == NULL) {
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
errno = ENOMEM;	errno = ENOMEM;
DEBUG(0,("Error in sys_acl_set_fd is %d\n",errno));	DEBUG(0, ("Error in sys_acl_set_fd is %d\n", errno));
return(-1);	return -1;
}	}

memcpy(file_acl_temp,file_acl,file_acl->acl_len);	memcpy(file_acl_temp, file_acl, file_acl->acl_len);
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
file_acl = file_acl_temp;	file_acl = file_acl_temp;
}	}

acl_entry = (struct acl_entry )((char )file_acl + file_acl->acl_len);	acl_entry = (struct acl_entry )((char )file_acl + file_acl->acl_len);
file_acl->acl_len += sizeof(struct acl_entry);	file_acl->acl_len += sizeof (struct acl_entry);
acl_entry->ace_len = acl_entry_link->entryp->ace_len;	acl_entry->ace_len = acl_entry_link->entryp->ace_len;
acl_entry->ace_access = acl_entry_link->entryp->ace_access;	acl_entry->ace_access = acl_entry_link->entryp->ace_access;

/* In order to use this, we'll need to wait until we can get denies */	/* In order to use this, we'll need to wait until we can get denies */
/* if(!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)	/* if (!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT)
acl_entry->ace_type = ACC_SPECIFY; */	acl_entry->ace_type = ACC_SPECIFY; */

acl_entry->ace_type = ACC_SPECIFY;	acl_entry->ace_type = ACC_SPECIFY;
Line 2550 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)	Line 2556 int sys_acl_set_fd( int fd, SMB_ACL_T theacl)
ace_id = acl_entry->ace_id;	ace_id = acl_entry->ace_id;

ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;	ace_id->id_type = acl_entry_link->entryp->ace_id->id_type;
DEBUG(10,("The id type is %d\n",ace_id->id_type));	DEBUG(10, ("The id type is %d\n", ace_id->id_type));
ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;	ace_id->id_len = acl_entry_link->entryp->ace_id->id_len;
memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof(uid_t));	memcpy(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof (uid_t));
memcpy(ace_id->id_data, &user_id, sizeof(uid_t));	memcpy(ace_id->id_data, &user_id, sizeof (uid_t));
}	}

rc = fchacl(fd,file_acl,file_acl->acl_len);	rc = fchacl(fd, file_acl, file_acl->acl_len);
DEBUG(10,("errno is %d\n",errno));	DEBUG(10, ("errno is %d\n", errno));
DEBUG(10,("return code is %d\n",rc));	DEBUG(10, ("return code is %d\n", rc));
SAFE_FREE(file_acl);	SAFE_FREE(file_acl);
DEBUG(10,("Exiting sys_acl_set_fd\n"));	DEBUG(10, ("Exiting sys_acl_set_fd\n"));
return(rc);	return rc;
}	}
#endif	#endif

Line 2575 int sys_acl_free_acl(SMB_ACL_T posix_acl)	Line 2581 int sys_acl_free_acl(SMB_ACL_T posix_acl)
{	{
struct acl_entry_link *acl_entry_link;	struct acl_entry_link *acl_entry_link;

for(acl_entry_link = posix_acl->nextp; acl_entry_link->nextp != NULL; acl_entry_link = acl_entry_link->nextp) {	for (acl_entry_link = posix_acl->nextp; acl_entry_link->nextp != NULL; acl_entry_link = acl_entry_link->nextp) {
SAFE_FREE(acl_entry_link->prevp->entryp);	SAFE_FREE(acl_entry_link->prevp->entryp);
SAFE_FREE(acl_entry_link->prevp);	SAFE_FREE(acl_entry_link->prevp);
}	}
Line 2585 int sys_acl_free_acl(SMB_ACL_T posix_acl)	Line 2591 int sys_acl_free_acl(SMB_ACL_T posix_acl)
SAFE_FREE(acl_entry_link->entryp);	SAFE_FREE(acl_entry_link->entryp);
SAFE_FREE(acl_entry_link);	SAFE_FREE(acl_entry_link);

return(0);	return 0;
}	}

#elif defined(HAVE_OSX_ACLS) /----------------------------------------------/	#elif defined(HAVE_OSX_ACLS) /----------------------------------------------/

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.3