From 0f6733d8b5d54f6fd7cb07a0abccef233a075787 Mon Sep 17 00:00:00 2001 From: Wayne Davison Date: Wed, 20 Oct 2004 08:11:50 +0000 Subject: [PATCH] - Put sysacls.c into lib because it is taken from samba and because it interferes with the generation of proto.h in the main dir. - Synchronized sysacls.c with the lastest samba version from CVS. - Created lib/sysacls.h to provide prototypes to acls.c, and also to define Realloc() for lib/sysacls.c. --- acls.diff | 2668 ++++++++++++++++++++++++++++------------------------- 1 file changed, 1392 insertions(+), 1276 deletions(-) diff --git a/acls.diff b/acls.diff index fee9707..01be4c7 100644 --- a/acls.diff +++ b/acls.diff @@ -11,29 +11,31 @@ from a disk that doesn't support ACLs. This should be changed to silently notice that no ACLs are available to copy. Of course, trying to write out ACLs to a non-ACL-supporting disk should complain. ---- orig/Makefile.in 2004-10-08 20:16:26 -+++ Makefile.in 2004-07-03 20:11:58 -@@ -25,7 +25,7 @@ VERSION=@VERSION@ +--- orig/Makefile.in 2004-10-14 17:11:40 ++++ Makefile.in 2004-10-20 06:32:26 +@@ -25,16 +25,16 @@ VERSION=@VERSION@ .SUFFIXES: .SUFFIXES: .c .o -HEADERS=byteorder.h config.h errcode.h proto.h rsync.h lib/pool_alloc.h +HEADERS=byteorder.h config.h errcode.h proto.h rsync.h smb_acls.h lib/pool_alloc.h LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o \ - lib/permstring.o lib/pool_alloc.o @LIBOBJS@ +- lib/permstring.o lib/pool_alloc.o @LIBOBJS@ ++ lib/permstring.o lib/pool_alloc.o lib/sysacls.o @LIBOBJS@ ZLIBOBJ=zlib/deflate.o zlib/infblock.o zlib/infcodes.o zlib/inffast.o \ -@@ -34,7 +34,7 @@ ZLIBOBJ=zlib/deflate.o zlib/infblock.o z + zlib/inflate.o zlib/inftrees.o zlib/infutil.o zlib/trees.o \ + zlib/zutil.o zlib/adler32.o OBJS1=rsync.o generator.o receiver.o cleanup.o sender.o exclude.o util.o \ main.o checksum.o match.o syscall.o log.o backup.o OBJS2=options.o flist.o io.o compat.o hlink.o token.o uidlist.o socket.o \ - fileio.o batch.o clientname.o -+ fileio.o batch.o clientname.o sysacls.o acls.o ++ fileio.o batch.o clientname.o acls.o OBJS3=progress.o pipe.o DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o popt_OBJS=popt/findme.o popt/popt.o popt/poptconfig.o \ ---- orig/acls.c 2004-09-08 06:09:30 -+++ acls.c 2004-09-08 06:09:30 -@@ -0,0 +1,1144 @@ +--- orig/acls.c 2004-10-20 06:36:04 ++++ acls.c 2004-10-20 06:36:04 +@@ -0,0 +1,1130 @@ +/* -*- c-file-style: "linux" -*- + Copyright (C) Andrew Tridgell 1996 + Copyright (C) Paul Mackerras 1996 @@ -56,6 +58,7 @@ ACLs to a non-ACL-supporting disk should complain. +/* handle passing ACLs between systems */ + +#include "rsync.h" ++#include "lib/sysacls.h" + +#if SUPPORT_ACLS + @@ -82,21 +85,17 @@ ACLs to a non-ACL-supporting disk should complain. + /* first time through, 0 <= 0, so list is expanded: + * diabolical, rsync guys! */ + if (racl->malloced <= racl->count) { -+ void *new_ptr; -+ size_t new_size; -+ racl->malloced += 10; -+ new_size = racl->malloced * sizeof racl->races[0]; -+ if (racl->races) -+ new_ptr = realloc(racl->races, new_size); -+ else -+ new_ptr = malloc(new_size); ++ rsync_ace *new_ptr; ++ size_t new_size = racl->malloced + 10; ++ new_ptr = realloc_array(racl->races, rsync_ace, new_size); + if (verbose >= 4) { + rprintf(FINFO, "expand rsync_acl to %.0f bytes, did%s move\n", -+ (double) new_size, ++ (double) new_size * sizeof racl->races[0], + racl->races ? "" : " not"); + } + -+ racl->races = (rsync_ace *) new_ptr; ++ racl->races = new_ptr; ++ racl->malloced = new_size; + + if (!racl->races) + out_of_memory("expand_rsync_acl"); @@ -251,24 +250,21 @@ ACLs to a non-ACL-supporting disk should complain. + /* first time through, 0 <= 0, so list is expanded: + * diabolical, rsync guys! */ + if (racl_list->malloced <= racl_list->count) { -+ void *new_ptr; ++ rsync_acl *new_ptr; + size_t new_size; + if (racl_list->malloced < 1000) -+ racl_list->malloced += 1000; ++ new_size = racl_list->malloced + 1000; + else -+ racl_list->malloced *= 2; -+ new_size = racl_list->malloced * sizeof racl_list->racls[0]; -+ if (racl_list->racls) -+ new_ptr = realloc(racl_list->racls, new_size); -+ else -+ new_ptr = malloc(new_size); ++ new_size = racl_list->malloced * 2; ++ new_ptr = realloc_array(racl_list->racls, rsync_acl, new_size); + if (verbose >= 3) { + rprintf(FINFO, "expand_rsync_acl_list to %.0f bytes, did%s move\n", -+ (double) new_size, ++ (double) new_size * sizeof racl_list->racls[0], + racl_list->racls ? "" : " not"); + } + -+ racl_list->racls = (rsync_acl *) new_ptr; ++ racl_list->racls = new_ptr; ++ racl_list->malloced = new_size; + + if (!racl_list->racls) + out_of_memory("expand_rsync_acl_list"); @@ -474,25 +470,21 @@ ACLs to a non-ACL-supporting disk should complain. + /* first time through, 0 <= 0, so list is expanded: + * diabolical, rsync guys! */ + if (fileaclidx_list->malloced <= fileaclidx_list->count) { -+ void *new_ptr; ++ file_acl_index *new_ptr; + size_t new_size; + if (fileaclidx_list->malloced < 1000) -+ fileaclidx_list->malloced += 1000; -+ else -+ fileaclidx_list->malloced *= 2; -+ new_size = fileaclidx_list->malloced -+ * sizeof fileaclidx_list->fileaclidxs[0]; -+ if (fileaclidx_list->fileaclidxs) -+ new_ptr = realloc(fileaclidx_list->fileaclidxs, new_size); ++ new_size = fileaclidx_list->malloced + 1000; + else -+ new_ptr = malloc(new_size); ++ new_size = fileaclidx_list->malloced * 2; ++ new_ptr = realloc_array(fileaclidx_list->fileaclidxs, file_acl_index, new_size); + if (verbose >= 3) { + rprintf(FINFO, "expand_file_acl_index_list to %.0f bytes, did%s move\n", -+ (double) new_size, ++ (double) new_size * sizeof fileaclidx_list->fileaclidxs[0], + fileaclidx_list->fileaclidxs ? "" : " not"); + } + -+ fileaclidx_list->fileaclidxs = (file_acl_index *) new_ptr; ++ fileaclidx_list->fileaclidxs = new_ptr; ++ fileaclidx_list->malloced = new_size; + + if (!fileaclidx_list->fileaclidxs) + out_of_memory("expand_file_acl_index_list"); @@ -532,25 +524,21 @@ ACLs to a non-ACL-supporting disk should complain. + /* first time through, 0 <= 0, so list is expanded: + * diabolical, rsync guys! */ + if (sacl_list->malloced <= sacl_list->count) { -+ void *new_ptr; ++ SMB_ACL_T *new_ptr; + size_t new_size; + if (sacl_list->malloced < 1000) -+ sacl_list->malloced += 1000; ++ new_size = sacl_list->malloced + 1000; + else -+ sacl_list->malloced *= 2; -+ new_size = sacl_list->malloced -+ * sizeof sacl_list->sacls[0]; -+ if (sacl_list->sacls) -+ new_ptr = realloc(sacl_list->sacls, new_size); -+ else -+ new_ptr = malloc(new_size); ++ new_size = sacl_list->malloced * 2; ++ new_ptr = realloc_array(sacl_list->sacls, SMB_ACL_T, new_size); + if (verbose >= 3) { + rprintf(FINFO, "expand_smb_acl_list to %.0f bytes, did%s move\n", -+ (double) new_size, ++ (double) new_size * sizeof sacl_list->sacls[0], + sacl_list->sacls ? "" : " not"); + } + -+ sacl_list->sacls = (SMB_ACL_T *) new_ptr; ++ sacl_list->sacls = new_ptr; ++ sacl_list->malloced = new_size; + + if (!sacl_list->sacls) + out_of_memory("expand_smb_acl_list"); @@ -1350,198 +1338,14 @@ ACLs to a non-ACL-supporting disk should complain. return; } ---- orig/mkproto.awk 2004-01-01 21:10:50 -+++ mkproto.awk 2004-06-30 00:04:06 -@@ -58,7 +58,7 @@ BEGIN { - next; - } - --!/^OFF_T|^size_t|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^const/ { -+!/^OFF_T|^size_t|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^const|^SMB_ACL_T|^id_t/ { - next; - } - ---- orig/options.c 2004-10-08 20:16:26 -+++ options.c 2004-08-19 17:38:57 -@@ -43,6 +43,7 @@ int keep_dirlinks = 0; - int copy_links = 0; - int preserve_links = 0; - int preserve_hard_links = 0; -+int preserve_acls = 0; - int preserve_perms = 0; - int preserve_devices = 0; - int preserve_uid = 0; -@@ -152,6 +153,7 @@ static void print_rsync_version(enum log - char const *got_socketpair = "no "; - char const *have_inplace = "no "; - char const *hardlinks = "no "; -+ char const *acls = "no "; - char const *links = "no "; - char const *ipv6 = "no "; - STRUCT_STAT *dumstat; -@@ -168,6 +170,10 @@ static void print_rsync_version(enum log - hardlinks = ""; - #endif - -+#if SUPPORT_ACLS -+ acls = ""; -+#endif -+ - #if SUPPORT_LINKS - links = ""; - #endif -@@ -182,9 +188,9 @@ static void print_rsync_version(enum log - "Copyright (C) 1996-2004 by Andrew Tridgell and others\n"); - rprintf(f, "\n"); - rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, " -- "%shard links, %ssymlinks, batchfiles, \n", -+ "%shard links, %sACLs, %ssymlinks, batchfiles, \n", - (int) (sizeof (OFF_T) * 8), -- got_socketpair, hardlinks, links); -+ got_socketpair, hardlinks, acls, links); - - /* Note that this field may not have type ino_t. It depends - * on the complicated interaction between largefile feature -@@ -249,6 +255,7 @@ void usage(enum logcode F) - rprintf(F," --safe-links ignore \"unsafe\" symlinks\n"); - rprintf(F," -H, --hard-links preserve hard links\n"); - rprintf(F," -p, --perms preserve permissions\n"); -+ rprintf(F," -A, --acls preserve ACLs (implies --perms)\n"); - rprintf(F," -o, --owner preserve owner (root only)\n"); - rprintf(F," -g, --group preserve group\n"); - rprintf(F," -D, --devices preserve devices (root only)\n"); -@@ -358,6 +365,7 @@ static struct poptOption long_options[] - {"no-whole-file", 0, POPT_ARG_VAL, &whole_file, 0, 0, 0 }, - {"copy-unsafe-links", 0, POPT_ARG_NONE, ©_unsafe_links, 0, 0, 0 }, - {"perms", 'p', POPT_ARG_NONE, &preserve_perms, 0, 0, 0 }, -+ {"acls", 'A', POPT_ARG_NONE, 0, 'A', 0, 0 }, - {"owner", 'o', POPT_ARG_NONE, &preserve_uid, 0, 0, 0 }, - {"group", 'g', POPT_ARG_NONE, &preserve_gid, 0, 0, 0 }, - {"devices", 'D', POPT_ARG_NONE, &preserve_devices, 0, 0, 0 }, -@@ -616,6 +624,24 @@ int parse_arguments(int *argc, const cha - return 0; - #endif - -+ case 'A': -+#if SUPPORT_ACLS -+ preserve_acls = 1; -+ preserve_perms = 1; -+#else -+ /* FIXME: this should probably be ignored with a -+ * warning and then countermeasures taken to -+ * restrict group and other access in the presence -+ * of any more restrictive ACLs, but this is safe -+ * for now */ -+ snprintf(err_buf,sizeof(err_buf), -+ "ACLs are not supported on this %s\n", -+ am_server ? "server" : "client"); -+ return 0; -+#endif /* SUPPORT_ACLS */ -+ break; -+ -+ - default: - /* A large opt value means that set_refuse_options() - * turned this option off (opt-BASE is its index). */ -@@ -942,6 +968,8 @@ void server_options(char **args,int *arg - - if (preserve_hard_links) - argstr[x++] = 'H'; -+ if (preserve_acls) -+ argstr[x++] = 'A'; - if (preserve_uid) - argstr[x++] = 'o'; - if (preserve_gid) ---- orig/rsync.c 2004-09-07 21:45:30 -+++ rsync.c 2004-07-03 20:11:58 -@@ -207,6 +207,14 @@ int set_perms(char *fname,struct file_st - } - #endif - -+ /* If this is a directory, SET_ACL() will be called on the cleanup -+ * receive_generator() pass--if we called it here, we might clobber -+ * writability on the directory. everything else is OK to do now. */ -+ if (!S_ISDIR(st->st_mode)) { -+ if (SET_ACL(fname, file) == 0) -+ updated = 1; -+ } -+ - if (verbose > 1 && flags & PERMS_REPORT) { - if (updated) - rprintf(FINFO,"%s\n",fname); ---- orig/rsync.h 2004-10-09 03:21:56 -+++ rsync.h 2004-07-03 20:11:58 -@@ -545,6 +545,40 @@ static inline int flist_up(struct file_l - #include "lib/permstring.h" - #include "lib/addrinfo.h" - -+#define SUPPORT_ACLS HAVE_POSIX_ACLS|HAVE_UNIXWARE_ACLS|HAVE_SOLARIS_ACLS|\ -+ HAVE_HPUX_ACLS|HAVE_IRIX_ACLS|HAVE_AIX_ACLS|HAVE_TRU64_ACLS -+ -+#define ACLS_NEED_MASK HAVE_UNIXWARE_ACLS|HAVE_SOLARIS_ACLS|HAVE_HPUX_ACLS -+ -+#if SUPPORT_ACLS -+#ifdef HAVE_SYS_ACL_H -+#include -+#endif -+#define MAKE_ACL(file, fname) make_acl(file, fname) -+#define SEND_ACL(file, f) send_acl(file, f) -+#define RECEIVE_ACL(file, f) receive_acl(file, f) -+#define SORT_FILE_ACL_INDEX_LISTS() sort_file_acl_index_lists() -+#define SET_ACL(fname, file) set_acl(fname, file) -+#define NEXT_ACL_UID() next_acl_uid() -+#define ACL_UID_MAP(uid) acl_uid_map(uid) -+#define PUSH_KEEP_BACKUP_ACL(file, orig, dest) \ -+ push_keep_backup_acl(file, orig, dest) -+#define CLEANUP_KEEP_BACKUP_ACL() cleanup_keep_backup_acl() -+#define DUP_ACL(orig, dest, mode) dup_acl(orig, dest, mode) -+#else /* SUPPORT_ACLS */ -+#define MAKE_ACL(file, fname) 1 /* checked return value */ -+#define SEND_ACL(file, f) -+#define RECEIVE_ACL(file, f) -+#define SORT_FILE_ACL_INDEX_LISTS() -+#define SET_ACL(fname, file) 0 /* checked return value */ -+#define NEXT_ACL_UID() -+#define ACL_UID_MAP(uid) -+#define PUSH_KEEP_BACKUP_ACL(file, orig, dest) -+#define CLEANUP_KEEP_BACKUP_ACL() -+#define DUP_ACL(src, orig, mode) 0 /* checked return value */ -+#endif /* SUPPORT_ACLS */ -+#include "smb_acls.h" -+ - #include "proto.h" - - /* We have replacement versions of these if they're missing. */ ---- orig/rsync.yo 2004-10-06 00:12:16 -+++ rsync.yo 2004-07-03 20:11:58 -@@ -326,6 +326,7 @@ verb( - --safe-links ignore "unsafe" symlinks - -H, --hard-links preserve hard links - -p, --perms preserve permissions -+ -A, --acls preserve ACLs (implies -p) [local option] - -o, --owner preserve owner (root only) - -g, --group preserve group - -D, --devices preserve devices (root only) -@@ -585,6 +586,11 @@ source file's permissions and the umask - other files (including updated files) retain their existing permissions - (which is the same behavior as other file-copy utilities, such as cp). - -+dit(bf(-A, --acls)) This option causes rsync to update the remote -+ACLs to be the same as the local ACLs. This will work only if the -+remote machine's rsync supports this option also. This is a non-standard -+option. -+ - dit(bf(-o, --owner)) This option causes rsync to set the owner of the - destination file to be the same as the source file. On most systems, - only the super-user can set file ownership. By default, the preservation ---- orig/smb_acls.h 2004-06-30 00:04:07 -+++ smb_acls.h 2004-06-30 00:04:07 -@@ -0,0 +1,277 @@ +--- orig/lib/sysacls.c 2004-10-20 08:06:39 ++++ lib/sysacls.c 2004-10-20 08:06:39 +@@ -0,0 +1,3218 @@ +/* + Unix SMB/Netbios implementation. -+ Version 2.2.x -+ Portable SMB ACL interface -+ Copyright (C) Jeremy Allison 2000 ++ Version 2.2. ++ Samba system utilities for ACL support. ++ Copyright (C) Jeremy Allison 2000. + + 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 @@ -1558,360 +1362,87 @@ ACLs to a non-ACL-supporting disk should complain. + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + -+#ifndef _SMB_ACLS_H -+#define _SMB_ACLS_H -+ -+#if defined(HAVE_POSIX_ACLS) ++#include "rsync.h" ++#include "sysacls.h" + -+/* This is an identity mapping (just remove the SMB_). */ ++void SAFE_FREE(void *mem) ++{ ++ if (mem) ++ free(mem); ++} + -+#define SMB_ACL_TAG_T acl_tag_t -+#define SMB_ACL_TYPE_T acl_type_t -+#define SMB_ACL_PERMSET_T acl_permset_t -+#define SMB_ACL_PERM_T acl_perm_t -+#define SMB_ACL_READ ACL_READ -+#define SMB_ACL_WRITE ACL_WRITE -+#define SMB_ACL_EXECUTE ACL_EXECUTE ++/* ++ This file wraps all differing system ACL interfaces into a consistent ++ one based on the POSIX interface. It also returns the correct errors ++ for older UNIX systems that don't support ACLs. + -+/* Types of ACLs. */ -+#define SMB_ACL_USER ACL_USER -+#define SMB_ACL_USER_OBJ ACL_USER_OBJ -+#define SMB_ACL_GROUP ACL_GROUP -+#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ -+#define SMB_ACL_OTHER ACL_OTHER -+#define SMB_ACL_MASK ACL_MASK ++ The interfaces that each ACL implementation must support are as follows : + -+#define SMB_ACL_T acl_t ++ 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_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p ++ void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d) ++ 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) ++ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset); ++ int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); ++ char *sys_acl_to_text( SMB_ACL_T theacl, ssize_t *plen) ++ 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_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) ++ int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual) ++ int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) ++ 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_fd( int fd, SMB_ACL_T theacl) ++ int sys_acl_delete_def_file(const char *path) + -+#define SMB_ACL_ENTRY_T acl_entry_t ++ This next one is not POSIX complient - but we *have* to have it ! ++ More POSIX braindamage. + -+#define SMB_ACL_FIRST_ENTRY ACL_FIRST_ENTRY -+#define SMB_ACL_NEXT_ENTRY ACL_NEXT_ENTRY ++ int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) + -+#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS -+#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT ++ The generic POSIX free is the following call. We split this into ++ several different free functions as we may need to add tag info ++ to structures when emulating the POSIX interface. + -+#elif defined(HAVE_TRU64_ACLS) ++ int sys_acl_free( void *obj_p) + -+/* This is for DEC/Compaq Tru64 UNIX */ ++ The calls we actually use are : + -+#define SMB_ACL_TAG_T acl_tag_t -+#define SMB_ACL_TYPE_T acl_type_t -+#define SMB_ACL_PERMSET_T acl_permset_t -+#define SMB_ACL_PERM_T acl_perm_t -+#define SMB_ACL_READ ACL_READ -+#define SMB_ACL_WRITE ACL_WRITE -+#define SMB_ACL_EXECUTE ACL_EXECUTE ++ int sys_acl_free_text(char *text) - free acl_to_text ++ int sys_acl_free_acl(SMB_ACL_T posix_acl) ++ int sys_acl_free_qualifier(void *qualifier, SMB_ACL_TAG_T tagtype) + -+/* Types of ACLs. */ -+#define SMB_ACL_USER ACL_USER -+#define SMB_ACL_USER_OBJ ACL_USER_OBJ -+#define SMB_ACL_GROUP ACL_GROUP -+#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ -+#define SMB_ACL_OTHER ACL_OTHER -+#define SMB_ACL_MASK ACL_MASK ++*/ + -+#define SMB_ACL_T acl_t ++#if defined(HAVE_POSIX_ACLS) + -+#define SMB_ACL_ENTRY_T acl_entry_t ++/* Identity mapping - easy. */ + -+#define SMB_ACL_FIRST_ENTRY 0 -+#define SMB_ACL_NEXT_ENTRY 1 -+ -+#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS -+#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT -+ -+#elif defined(HAVE_UNIXWARE_ACLS) || defined(HAVE_SOLARIS_ACLS) -+/* -+ * Donated by Michael Davidson for UnixWare / OpenUNIX. -+ * Modified by Toomas Soome for Solaris. -+ */ -+ -+/* SVR4.2 ES/MP ACLs */ -+typedef int SMB_ACL_TAG_T; -+typedef int SMB_ACL_TYPE_T; -+typedef ushort *SMB_ACL_PERMSET_T; -+typedef ushort SMB_ACL_PERM_T; -+#define SMB_ACL_READ 4 -+#define SMB_ACL_WRITE 2 -+#define SMB_ACL_EXECUTE 1 -+ -+/* Types of ACLs. */ -+#define SMB_ACL_USER USER -+#define SMB_ACL_USER_OBJ USER_OBJ -+#define SMB_ACL_GROUP GROUP -+#define SMB_ACL_GROUP_OBJ GROUP_OBJ -+#define SMB_ACL_OTHER OTHER_OBJ -+#define SMB_ACL_MASK CLASS_OBJ -+ -+typedef struct SMB_ACL_T { -+ int size; -+ int count; -+ int next; -+ struct acl acl[1]; -+} *SMB_ACL_T; -+ -+typedef struct acl *SMB_ACL_ENTRY_T; -+ -+#define SMB_ACL_FIRST_ENTRY 0 -+#define SMB_ACL_NEXT_ENTRY 1 -+ -+#define SMB_ACL_TYPE_ACCESS 0 -+#define SMB_ACL_TYPE_DEFAULT 1 -+ -+#elif defined(HAVE_HPUX_ACLS) -+ -+/* -+ * Based on the Solaris & UnixWare code. -+ */ -+ -+#undef GROUP -+#include -+ -+/* SVR4.2 ES/MP ACLs */ -+typedef int SMB_ACL_TAG_T; -+typedef int SMB_ACL_TYPE_T; -+typedef ushort *SMB_ACL_PERMSET_T; -+typedef ushort SMB_ACL_PERM_T; -+#define SMB_ACL_READ 4 -+#define SMB_ACL_WRITE 2 -+#define SMB_ACL_EXECUTE 1 -+ -+/* Types of ACLs. */ -+#define SMB_ACL_USER USER -+#define SMB_ACL_USER_OBJ USER_OBJ -+#define SMB_ACL_GROUP GROUP -+#define SMB_ACL_GROUP_OBJ GROUP_OBJ -+#define SMB_ACL_OTHER OTHER_OBJ -+#define SMB_ACL_MASK CLASS_OBJ -+ -+typedef struct SMB_ACL_T { -+ int size; -+ int count; -+ int next; -+ struct acl acl[1]; -+} *SMB_ACL_T; -+ -+typedef struct acl *SMB_ACL_ENTRY_T; -+ -+#define SMB_ACL_FIRST_ENTRY 0 -+#define SMB_ACL_NEXT_ENTRY 1 -+ -+#define SMB_ACL_TYPE_ACCESS 0 -+#define SMB_ACL_TYPE_DEFAULT 1 -+ -+#elif defined(HAVE_IRIX_ACLS) -+ -+#define SMB_ACL_TAG_T acl_tag_t -+#define SMB_ACL_TYPE_T acl_type_t -+#define SMB_ACL_PERMSET_T acl_permset_t -+#define SMB_ACL_PERM_T acl_perm_t -+#define SMB_ACL_READ ACL_READ -+#define SMB_ACL_WRITE ACL_WRITE -+#define SMB_ACL_EXECUTE ACL_EXECUTE -+ -+/* Types of ACLs. */ -+#define SMB_ACL_USER ACL_USER -+#define SMB_ACL_USER_OBJ ACL_USER_OBJ -+#define SMB_ACL_GROUP ACL_GROUP -+#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ -+#define SMB_ACL_OTHER ACL_OTHER_OBJ -+#define SMB_ACL_MASK ACL_MASK -+ -+typedef struct SMB_ACL_T { -+ int next; -+ BOOL freeaclp; -+ struct acl *aclp; -+} *SMB_ACL_T; -+ -+#define SMB_ACL_ENTRY_T acl_entry_t -+ -+#define SMB_ACL_FIRST_ENTRY 0 -+#define SMB_ACL_NEXT_ENTRY 1 -+ -+#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS -+#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT -+ -+#elif defined(HAVE_AIX_ACLS) -+ -+/* Donated by Medha Date, mdate@austin.ibm.com, for IBM */ -+ -+#include "/usr/include/acl.h" -+ -+typedef uint *SMB_ACL_PERMSET_T; -+ -+struct acl_entry_link{ -+ struct acl_entry_link *prevp; -+ struct new_acl_entry *entryp; -+ struct acl_entry_link *nextp; -+ int count; -+}; -+ -+struct new_acl_entry{ -+ unsigned short ace_len; -+ unsigned short ace_type; -+ unsigned int ace_access; -+ struct ace_id ace_id[1]; -+}; -+ -+#define SMB_ACL_ENTRY_T struct new_acl_entry* -+#define SMB_ACL_T struct acl_entry_link* -+ -+#define SMB_ACL_TAG_T unsigned short -+#define SMB_ACL_TYPE_T int -+#define SMB_ACL_PERM_T uint -+#define SMB_ACL_READ S_IRUSR -+#define SMB_ACL_WRITE S_IWUSR -+#define SMB_ACL_EXECUTE S_IXUSR -+ -+/* Types of ACLs. */ -+#define SMB_ACL_USER ACEID_USER -+#define SMB_ACL_USER_OBJ 3 -+#define SMB_ACL_GROUP ACEID_GROUP -+#define SMB_ACL_GROUP_OBJ 4 -+#define SMB_ACL_OTHER 5 -+#define SMB_ACL_MASK 6 -+ -+ -+#define SMB_ACL_FIRST_ENTRY 1 -+#define SMB_ACL_NEXT_ENTRY 2 -+ -+#define SMB_ACL_TYPE_ACCESS 0 -+#define SMB_ACL_TYPE_DEFAULT 1 -+ -+#else /* No ACLs. */ -+ -+/* No ACLS - fake it. */ -+#define SMB_ACL_TAG_T int -+#define SMB_ACL_TYPE_T int -+#define SMB_ACL_PERMSET_T mode_t -+#define SMB_ACL_PERM_T mode_t -+#define SMB_ACL_READ S_IRUSR -+#define SMB_ACL_WRITE S_IWUSR -+#define SMB_ACL_EXECUTE S_IXUSR -+ -+/* Types of ACLs. */ -+#define SMB_ACL_USER 0 -+#define SMB_ACL_USER_OBJ 1 -+#define SMB_ACL_GROUP 2 -+#define SMB_ACL_GROUP_OBJ 3 -+#define SMB_ACL_OTHER 4 -+#define SMB_ACL_MASK 5 -+ -+typedef struct SMB_ACL_T { -+ int dummy; -+} *SMB_ACL_T; -+ -+typedef struct SMB_ACL_ENTRY_T { -+ int dummy; -+} *SMB_ACL_ENTRY_T; -+ -+#define SMB_ACL_FIRST_ENTRY 0 -+#define SMB_ACL_NEXT_ENTRY 1 -+ -+#define SMB_ACL_TYPE_ACCESS 0 -+#define SMB_ACL_TYPE_DEFAULT 1 -+ -+#endif /* No ACLs. */ -+#endif /* _SMB_ACLS_H */ ---- orig/sysacls.c 2004-08-19 17:38:21 -+++ sysacls.c 2004-08-19 17:38:21 -@@ -0,0 +1,3117 @@ -+/* -+ Unix SMB/Netbios implementation. -+ Version 2.2. -+ Samba system utilities for ACL support. -+ Copyright (C) Jeremy Allison 2000. -+ -+ 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 2 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, write to the Free Software -+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -+*/ -+ -+#include "rsync.h" -+ -+/* -+ This file wraps all differing system ACL interfaces into a consistent -+ one based on the POSIX interface. It also returns the correct errors -+ for older UNIX systems that don't support ACLs. -+ -+ 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_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p) -+ int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p -+ void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) -+ 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) -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset); -+ int sys_acl_add_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); -+ char *sys_acl_to_text(SMB_ACL_T theacl, ssize_t *plen) -+ 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_set_tag_type(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry, void *qual) -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) -+ 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_fd(int fd, SMB_ACL_T theacl) -+ int sys_acl_delete_def_file(const char *path) -+ -+ This next one is not POSIX complient - but we *have* to have it ! -+ More POSIX braindamage. -+ -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) -+ -+ The generic POSIX free is the following call. We split this into -+ several different free functions as we may need to add tag info -+ to structures when emulating the POSIX interface. -+ -+ int sys_acl_free(void *obj_p) -+ -+ The calls we actually use are: -+ -+ int sys_acl_free_text(char *text) - free acl_to_text -+ int sys_acl_free_acl(SMB_ACL_T posix_acl) -+ int sys_acl_free_qualifier(void *qualifier, SMB_ACL_TAG_T tagtype) -+ -+*/ -+ -+#if defined(HAVE_POSIX_ACLS) -+ -+/* 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); +} + -+int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) ++int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) +{ -+ return acl_get_permset(entry_d, permset_p); ++ return acl_get_permset( entry_d, permset_p); +} + -+void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) ++void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d) +{ -+ return acl_get_qualifier(entry_d); ++ return acl_get_qualifier( entry_d); +} + -+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); +} + +SMB_ACL_T sys_acl_get_fd(int fd) @@ -1924,54 +1455,56 @@ ACLs to a non-ACL-supporting disk should complain. + return acl_clear_perms(permset); +} + -+int sys_acl_add_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ + return acl_add_perm(permset, perm); +} + -+int sys_acl_get_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ +#if defined(HAVE_ACL_GET_PERM_NP) -+ /* Required for TrustedBSD-based ACL implementations where ++ /* ++ * Required for TrustedBSD-based ACL implementations where + * non-POSIX.1e functions are denoted by a _np (non-portable) -+ * suffix. */ ++ * suffix. ++ */ + return acl_get_perm_np(permset, perm); +#else + return acl_get_perm(permset, perm); +#endif +} + -+char *sys_acl_to_text(SMB_ACL_T the_acl, ssize_t *plen) ++char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen) +{ -+ return acl_to_text(the_acl, plen); ++ return acl_to_text( the_acl, plen); +} + -+SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init( int 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); +} + -+int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) ++int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) +{ + return acl_set_tag_type(entry, tagtype); +} + -+int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry, void *qual) ++int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual) +{ + return acl_set_qualifier(entry, qual); +} + -+int sys_acl_set_permset(SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) ++int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T 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); +} @@ -1981,7 +1514,7 @@ ACLs to a non-ACL-supporting disk should complain. + return acl_set_file(name, acltype, theacl); +} + -+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); +} @@ -1996,7 +1529,7 @@ ACLs to a non-ACL-supporting disk should complain. + return acl_free(text); +} + -+int sys_acl_free_acl(SMB_ACL_T the_acl) ++int sys_acl_free_acl(SMB_ACL_T the_acl) +{ + return acl_free(the_acl); +} @@ -2007,17 +1540,19 @@ ACLs to a non-ACL-supporting disk should complain. +} + +#elif defined(HAVE_TRU64_ACLS) -+/* The interface to DEC/Compaq Tru64 UNIX ACLs ++/* ++ * The interface to DEC/Compaq Tru64 UNIX ACLs + * is based on Draft 13 of the POSIX spec which is + * slightly different from the Draft 16 interface. -+ * ++ * + * Also, some of the permset manipulation functions + * such as acl_clear_perm() and acl_add_perm() appear + * to be broken on Tru64 so we have to manipulate -+ * 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) ++ * 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) +{ -+ SMB_ACL_ENTRY_T entry; ++ SMB_ACL_ENTRY_T entry; + + if (entry_id == SMB_ACL_FIRST_ENTRY && acl_first_entry(the_acl) != 0) { + return -1; @@ -2032,66 +1567,66 @@ ACLs to a non-ACL-supporting disk should complain. + 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); +} + -+ int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) ++int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) +{ -+ return acl_get_permset(entry_d, permset_p); ++ return acl_get_permset( entry_d, permset_p); +} + -+ void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) ++void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d) +{ -+ return acl_get_qualifier(entry_d); ++ return acl_get_qualifier( entry_d); +} + -+ 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); +} + -+ SMB_ACL_T sys_acl_get_fd(int fd) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ + return acl_get_fd(fd, ACL_TYPE_ACCESS); +} + -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset) ++int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset) +{ -+ *permset = 0; /* acl_clear_perm() is broken on Tru64 */ ++ *permset = 0; /* acl_clear_perm() is broken on Tru64 */ + + return 0; +} + -+ int sys_acl_add_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ + if (perm & ~(SMB_ACL_READ | SMB_ACL_WRITE | SMB_ACL_EXECUTE)) { + errno = EINVAL; + return -1; + } + -+ *permset |= perm; /* acl_add_perm() is broken on Tru64 */ ++ *permset |= perm; /* acl_add_perm() is broken on Tru64 */ + + return 0; +} + -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ + return *permset & perm; /* Tru64 doesn't have acl_get_perm() */ +} + -+ char *sys_acl_to_text(SMB_ACL_T the_acl, ssize_t *plen) ++char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen) +{ -+ return acl_to_text(the_acl, plen); ++ return acl_to_text( the_acl, plen); +} + -+ SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init( int 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; + @@ -2103,67 +1638,72 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) ++int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) +{ + return acl_set_tag_type(entry, tagtype); +} + -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry, void *qual) ++int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual) +{ + return acl_set_qualifier(entry, qual); +} + -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) ++int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T 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); +} + -+ 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); +} + -+ 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); +} + -+ int sys_acl_delete_def_file(const char *name) ++int sys_acl_delete_def_file(const char *name) +{ + return acl_delete_def_file((char *)name); +} + -+ int sys_acl_free_text(char *text) ++int sys_acl_free_text(char *text) +{ -+ /* (void) cast and explicit return 0 are for DEC UNIX -+ * which just #defines acl_free_text() to be free(). */ ++ /* ++ * (void) cast and explicit return 0 are for DEC UNIX ++ * which just #defines acl_free_text() to be free() ++ */ + (void) acl_free_text(text); + return 0; +} + -+ int sys_acl_free_acl(SMB_ACL_T the_acl) ++int sys_acl_free_acl(SMB_ACL_T the_acl) +{ + return acl_free(the_acl); +} + -+ int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ + return acl_free_qualifier(qual, tagtype); +} + +#elif defined(HAVE_UNIXWARE_ACLS) || defined(HAVE_SOLARIS_ACLS) + -+/* Donated by Michael Davidson for UnixWare / OpenUNIX. -+ * Modified by Toomas Soome for Solaris. */ ++/* ++ * Donated by Michael Davidson for UnixWare / OpenUNIX. ++ * Modified by Toomas Soome for Solaris. ++ */ + -+/* Note that while this code implements sufficient functionality ++/* ++ * 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. + * @@ -2177,18 +1717,20 @@ ACLs to a non-ACL-supporting disk should complain. + * sys_acl_set_fd() + */ + -+/* The only difference between Solaris and UnixWare / OpenUNIX is -+ * that the #defines for the ACL operations have different names. */ ++/* ++ * The only difference between Solaris and UnixWare / OpenUNIX is ++ * that the #defines for the ACL operations have different names ++ */ +#if defined(HAVE_UNIXWARE_ACLS) + -+#define SETACL ACL_SET -+#define GETACL ACL_GET -+#define GETACLCNT ACL_CNT ++#define SETACL ACL_SET ++#define GETACL ACL_GET ++#define GETACLCNT ACL_CNT + +#endif + + -+ int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p) ++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; @@ -2218,21 +1760,21 @@ ACLs to a non-ACL-supporting disk should complain. + return 1; +} + -+ int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p) ++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) ++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) ++void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) +{ + if (entry_d->a_type != SMB_ACL_USER + && entry_d->a_type != SMB_ACL_GROUP) { @@ -2243,7 +1785,8 @@ ACLs to a non-ACL-supporting disk should complain. + return &entry_d->a_id; +} + -+/* There is no way of knowing what size the ACL returned by ++/* ++ * There is no way of knowing what size the ACL returned by + * GETACL will be unless you first call GETACLCNT which means + * making an additional system call. + * @@ -2251,16 +1794,17 @@ ACLs to a non-ACL-supporting disk should complain. + * call in most cases, we initially allocate enough space for + * an ACL with INITIAL_ACL_SIZE entries. If this turns out to + * be too small then we use GETACLCNT to find out the actual -+ * size, reallocate the ACL buffer, and then call GETACL again. */ ++ * size, reallocate the ACL buffer, and then call GETACL again. ++ */ + -+#define INITIAL_ACL_SIZE 16 ++#define INITIAL_ACL_SIZE 16 + -+ 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; -+ int count; /* # of ACL entries allocated */ -+ int naccess; /* # of access ACL entries */ -+ int ndefault; /* # of default ACL entries */ ++ SMB_ACL_T acl_d; ++ int count; /* # of ACL entries allocated */ ++ int naccess; /* # of access ACL entries */ ++ int ndefault; /* # of default ACL entries */ + + if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) { + errno = EINVAL; @@ -2272,12 +1816,14 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* If there isn't enough space for the ACL entries we use ++ /* ++ * If there isn't enough space for the ACL entries we use + * GETACLCNT to determine the actual number of ACL entries + * reallocate and try again. This is in a loop because it + * is possible that someone else could modify the ACL and + * increase the number of entries between the call to -+ * GETACLCNT and the call to GETACL. */ ++ * GETACLCNT and the call to GETACL. ++ */ + while ((count = acl(path_p, GETACL, count, &acl_d->acl[0])) < 0 + && errno == ENOSPC) { + @@ -2297,22 +1843,26 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* Calculate the number of access and default ACL entries. ++ /* ++ * calculate the number of access and default ACL entries + * + * Note: we assume that the acl() system call returned a + * well formed ACL which is sorted so that all of the -+ * access ACL entries preceed any default ACL entries. */ ++ * access ACL entries preceed any default ACL entries ++ */ + for (naccess = 0; naccess < count; naccess++) { + if (acl_d->acl[naccess].a_type & ACL_DEFAULT) + break; + } + ndefault = count - naccess; -+ -+ /* If the caller wants the default ACL we have to copy ++ ++ /* ++ * if the caller wants the default ACL we have to copy + * the entries down to the start of the acl[] buffer -+ * and mask out the ACL_DEFAULT flag from the type field. */ ++ * and mask out the ACL_DEFAULT flag from the type field ++ */ + if (type == SMB_ACL_TYPE_DEFAULT) { -+ int i, j; ++ int i, j; + + for (i = 0, j = naccess; i < ndefault; i++, j++) { + acl_d->acl[i] = acl_d->acl[j]; @@ -2327,11 +1877,11 @@ ACLs to a non-ACL-supporting disk should complain. + return acl_d; +} + -+ SMB_ACL_T sys_acl_get_fd(int fd) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ -+ SMB_ACL_T acl_d; -+ int count; /* # of ACL entries allocated */ -+ int naccess; /* # of access ACL entries */ ++ SMB_ACL_T acl_d; ++ int count; /* # of ACL entries allocated */ ++ int naccess; /* # of access ACL entries */ + + count = INITIAL_ACL_SIZE; + if ((acl_d = sys_acl_init(count)) == NULL) { @@ -2357,25 +1907,27 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* Calculate the number of access ACL entries. */ ++ /* ++ * calculate the number of access ACL entries ++ */ + for (naccess = 0; naccess < count; naccess++) { + if (acl_d->acl[naccess].a_type & ACL_DEFAULT) + break; + } -+ ++ + acl_d->count = naccess; + + return acl_d; +} + -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d) ++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) ++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) { @@ -2393,54 +1945,58 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm) ++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(SMB_ACL_T acl_d, ssize_t *len_p) ++char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p) +{ -+ int i; -+ int len, maxlen; -+ char *text; ++ int i; ++ int len, maxlen; ++ char *text; + -+ /* Use an initial estimate of 20 bytes per ACL entry ++ /* ++ * 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; ++ * of the ACL ++ */ ++ len = 0; ++ maxlen = 20 * acl_d->count; + if ((text = malloc(maxlen)) == NULL) { + errno = ENOMEM; + return NULL; + } + + for (i = 0; i < acl_d->count; i++) { -+ struct acl *ap = &acl_d->acl[i]; -+ struct passwd *pw; -+ struct group *gr; -+ char tagbuf[12]; -+ char idbuf[12]; -+ char *tag; -+ char *id = ""; -+ char perms[4]; -+ int nbytes; ++ struct acl *ap = &acl_d->acl[i]; ++ struct passwd *pw; ++ struct group *gr; ++ char tagbuf[12]; ++ char idbuf[12]; ++ char *tag; ++ char *id = ""; ++ char perms[4]; ++ int nbytes; + + switch (ap->a_type) { -+ /* For debugging purposes it's probably more ++ /* ++ * for debugging purposes it's probably more + * useful to dump unknown tag types rather -+ * than just returning an error. */ ++ * than just returning an error ++ */ + default: -+ snprintf(tagbuf, sizeof tagbuf - 1, "0x%x", ++ slprintf(tagbuf, sizeof(tagbuf)-1, "0x%x", + ap->a_type); + tag = tagbuf; -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ slprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + break; + + case SMB_ACL_USER: + if ((pw = getpwuid(ap->a_id)) == NULL) { -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ snprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + } else { @@ -2452,7 +2008,7 @@ ACLs to a non-ACL-supporting disk should complain. + + case SMB_ACL_GROUP: + if ((gr = getgrgid(ap->a_id)) == NULL) { -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ slprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + } else { @@ -2480,23 +2036,25 @@ ACLs to a non-ACL-supporting disk should complain. + /* : : rwx \n \0 */ + nbytes = strlen(tag) + 1 + strlen(id) + 1 + 3 + 1 + 1; + -+ /* If this entry would overflow the buffer ++ /* ++ * 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. */ ++ * for each entry still to be processed ++ */ + if ((len + nbytes) > maxlen) { + char *oldtext = text; + + maxlen += nbytes + 20 * (acl_d->count - i); + + if ((text = Realloc(oldtext, maxlen)) == NULL) { -+ free(oldtext); ++ SAFE_FREE(oldtext); + errno = ENOMEM; + return NULL; + } + } + -+ snprintf(&text[len], nbytes-1, "%s:%s:%s\n", tag, id, perms); ++ slprintf(&text[len], nbytes-1, "%s:%s:%s\n", tag, id, perms); + len += nbytes - 1; + } + @@ -2506,20 +2064,22 @@ ACLs to a non-ACL-supporting disk should complain. + return text; +} + -+ SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init(int count) +{ -+ SMB_ACL_T a; ++ SMB_ACL_T a; + + if (count < 0) { + errno = EINVAL; + return NULL; + } + -+ /* Note that since the definition of the structure pointed ++ /* ++ * note that since the definition of the structure pointed + * to by the SMB_ACL_T includes the first element of the + * acl[] array, this actually allocates an ACL with room -+ * for (count+1) entries. */ -+ if ((a = malloc(sizeof a[0] + count * sizeof (struct acl))) == NULL) { ++ * for (count+1) entries ++ */ ++ if ((a = malloc(sizeof(*a) + count * sizeof(struct acl))) == NULL) { + errno = ENOMEM; + return NULL; + } @@ -2532,10 +2092,10 @@ ACLs to a non-ACL-supporting disk should complain. +} + + -+ int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p) ++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; ++ SMB_ACL_T acl_d; ++ SMB_ACL_ENTRY_T entry_d; + + if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) { + errno = EINVAL; @@ -2547,16 +2107,16 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ entry_d = &acl_d->acl[acl_d->count++]; -+ entry_d->a_type = 0; -+ entry_d->a_id = -1; -+ entry_d->a_perm = 0; -+ *entry_p = entry_d; ++ entry_d = &acl_d->acl[acl_d->count++]; ++ entry_d->a_type = 0; ++ entry_d->a_id = -1; ++ entry_d->a_perm = 0; ++ *entry_p = entry_d; + + return 0; +} + -+ int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type) ++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: @@ -2575,7 +2135,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) ++int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) +{ + if (entry_d->a_type != SMB_ACL_GROUP + && entry_d->a_type != SMB_ACL_USER) { @@ -2588,7 +2148,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d) ++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)) { + return EINVAL; @@ -2599,20 +2159,22 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+/* Sort the ACL and check it for validity. ++/* ++ * sort the ACL and check it for validity + * -+ * If it's a minimal ACL with only 4 entries then we ++ * if it's a minimal ACL with only 4 entries then we + * need to recalculate the mask permissions to make + * sure that they are the same as the GROUP_OBJ + * permissions as required by the UnixWare acl() system call. + * -+ * (Note: since POSIX allows minimal ACLs which only contain ++ * (note: since POSIX allows minimal ACLs which only contain + * 3 entries - ie there is no mask entry - we should, in theory, + * check for this and add a mask entry if necessary - however + * we "know" that the caller of this interface always specifies + * a mask so, in practice "this never happens" (tm) - if it *does* + * happen aclsort() will fail and return an error and someone will -+ * have to fix it ...) */ ++ * have to fix it ...) ++ */ + +static int acl_sort(SMB_ACL_T acl_d) +{ @@ -2624,19 +2186,19 @@ ACLs to a non-ACL-supporting disk should complain. + } + return 0; +} -+ -+ int sys_acl_valid(SMB_ACL_T acl_d) ++ ++int sys_acl_valid(SMB_ACL_T acl_d) +{ + return acl_sort(acl_d); +} + -+ int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d) ++int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d) +{ -+ struct stat s; -+ struct acl *acl_p; -+ int acl_count; -+ struct acl *acl_buf = NULL; -+ int ret; ++ struct stat s; ++ struct acl *acl_p; ++ int acl_count; ++ struct acl *acl_buf = NULL; ++ int ret; + + if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) { + errno = EINVAL; @@ -2647,20 +2209,22 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ acl_p = &acl_d->acl[0]; -+ acl_count = acl_d->count; ++ acl_p = &acl_d->acl[0]; ++ acl_count = acl_d->count; + -+ /* If it's a directory there is extra work to do since the acl() -+ * system call will replace both the access ACLs and the default -+ * ACLs (if any). */ ++ /* ++ * if it's a directory there is extra work to do ++ * since the acl() system call will replace both ++ * the access ACLs and the default ACLs (if any) ++ */ + if (stat(name, &s) != 0) { + return -1; + } + if (S_ISDIR(s.st_mode)) { -+ SMB_ACL_T acc_acl; -+ SMB_ACL_T def_acl; -+ SMB_ACL_T tmp_acl; -+ int i; ++ SMB_ACL_T acc_acl; ++ SMB_ACL_T def_acl; ++ SMB_ACL_T tmp_acl; ++ int i; + + if (type == SMB_ACL_TYPE_ACCESS) { + acc_acl = acl_d; @@ -2675,9 +2239,11 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ /* Allocate a temporary buffer for the complete ACL. */ ++ /* ++ * allocate a temporary buffer for the complete ACL ++ */ + acl_count = acc_acl->count + def_acl->count; -+ acl_p = acl_buf = malloc(acl_count * sizeof acl_buf[0]); ++ acl_p = acl_buf = malloc(acl_count * sizeof(acl_buf[0])); + + if (acl_buf == NULL) { + sys_acl_free_acl(tmp_acl); @@ -2685,14 +2251,18 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ /* 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], -+ acc_acl->count * sizeof acl_buf[0]); ++ acc_acl->count * sizeof(acl_buf[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 ++ */ + for (i = acc_acl->count; i < acl_count; i++) { + acl_buf[i].a_type |= ACL_DEFAULT; + } @@ -2706,12 +2276,12 @@ ACLs to a non-ACL-supporting disk should complain. + + ret = acl(name, SETACL, acl_count, acl_p); + -+ free(acl_buf); ++ SAFE_FREE(acl_buf); + + return ret; +} + -+ int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) ++int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) +{ + if (acl_sort(acl_d) != 0) { + return -1; @@ -2720,13 +2290,15 @@ ACLs to a non-ACL-supporting disk should complain. + return facl(fd, SETACL, acl_d->count, &acl_d->acl[0]); +} + -+ int sys_acl_delete_def_file(const char *path) ++int sys_acl_delete_def_file(const char *path) +{ -+ SMB_ACL_T acl_d; -+ int ret; ++ SMB_ACL_T acl_d; ++ int ret; + -+ /* Fetching the access ACL and rewriting it has the effect of -+ * deleting the default ACL. */ ++ /* ++ * fetching the access ACL and rewriting it has ++ * the effect of deleting the default ACL ++ */ + if ((acl_d = sys_acl_get_file(path, SMB_ACL_TYPE_ACCESS)) == NULL) { + return -1; + } @@ -2734,23 +2306,23 @@ ACLs to a non-ACL-supporting disk should complain. + ret = acl(path, SETACL, acl_d->count, acl_d->acl); + + sys_acl_free_acl(acl_d); -+ ++ + return ret; +} + -+ int sys_acl_free_text(char *text) ++int sys_acl_free_text(char *text) +{ -+ free(text); ++ SAFE_FREE(text); + return 0; +} + -+ int sys_acl_free_acl(SMB_ACL_T acl_d) ++int sys_acl_free_acl(SMB_ACL_T acl_d) +{ -+ free(acl_d); ++ SAFE_FREE(acl_d); + return 0; +} + -+ int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ + return 0; +} @@ -2758,9 +2330,12 @@ ACLs to a non-ACL-supporting disk should complain. +#elif defined(HAVE_HPUX_ACLS) +#include + -+/* Based on the Solaris/SCO code - with modifications. */ ++/* ++ * Based on the Solaris/SCO code - with modifications. ++ */ + -+/* Note that while this code implements sufficient functionality ++/* ++ * 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. + * @@ -2774,11 +2349,12 @@ ACLs to a non-ACL-supporting disk should complain. + * sys_acl_set_fd() + */ + -+/* This checks if the POSIX ACL system call is defined which basically -+ * corresponds to whether JFS 3.3 or higher is installed. If acl() was -+ * called when it isn't defined, it causes the process to core dump so -+ * it is important to check this and avoid acl() calls if it isn't -+ * there. */ ++/* This checks if the POSIX ACL system call is defined */ ++/* which basically corresponds to whether JFS 3.3 or */ ++/* higher is installed. If acl() was called when it */ ++/* isn't defined, it causes the process to core dump */ ++/* so it is important to check this and avoid acl() */ ++/* calls if it isn't there. */ + +static BOOL hpux_acl_call_presence(void) +{ @@ -2788,13 +2364,13 @@ ACLs to a non-ACL-supporting disk should complain. + int ret_val=0; + static BOOL already_checked=0; + -+ if (already_checked) ++ if(already_checked) + return True; + + + 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", + 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")); @@ -2807,7 +2383,7 @@ ACLs to a non-ACL-supporting disk should complain. + return True; +} + -+ int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p) ++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; @@ -2837,21 +2413,21 @@ ACLs to a non-ACL-supporting disk should complain. + return 1; +} + -+ int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p) ++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) ++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) ++void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) +{ + if (entry_d->a_type != SMB_ACL_USER + && entry_d->a_type != SMB_ACL_GROUP) { @@ -2862,7 +2438,8 @@ ACLs to a non-ACL-supporting disk should complain. + return &entry_d->a_id; +} + -+/* There is no way of knowing what size the ACL returned by ++/* ++ * There is no way of knowing what size the ACL returned by + * ACL_GET will be unless you first call ACL_CNT which means + * making an additional system call. + * @@ -2873,19 +2450,20 @@ ACLs to a non-ACL-supporting disk should complain. + * size, reallocate the ACL buffer, and then call ACL_GET again. + */ + -+#define INITIAL_ACL_SIZE 16 ++#define INITIAL_ACL_SIZE 16 + -+ 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; -+ int count; /* # of ACL entries allocated */ -+ int naccess; /* # of access ACL entries */ -+ int ndefault; /* # of default ACL entries */ ++ SMB_ACL_T acl_d; ++ int count; /* # of ACL entries allocated */ ++ int naccess; /* # of access ACL entries */ ++ int ndefault; /* # of default ACL entries */ + -+ if (hpux_acl_call_presence() == False) { -+ /* Looks like we don't have the acl() system call on HPUX. -+ * May be the system doesn't have the latest version of JFS. */ -+ return NULL; ++ if(hpux_acl_call_presence() == False) { ++ /* Looks like we don't have the acl() system call on HPUX. ++ * May be the system doesn't have the latest version of JFS. ++ */ ++ return NULL; + } + + if (type != SMB_ACL_TYPE_ACCESS && type != SMB_ACL_TYPE_DEFAULT) { @@ -2898,12 +2476,14 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* If there isn't enough space for the ACL entries we use ++ /* ++ * If there isn't enough space for the ACL entries we use + * ACL_CNT to determine the actual number of ACL entries + * reallocate and try again. This is in a loop because it + * is possible that someone else could modify the ACL and + * increase the number of entries between the call to -+ * ACL_CNT and the call to ACL_GET. */ ++ * ACL_CNT and the call to ACL_GET. ++ */ + while ((count = acl(path_p, ACL_GET, count, &acl_d->acl[0])) < 0 && errno == ENOSPC) { + + sys_acl_free_acl(acl_d); @@ -2922,22 +2502,26 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* Calculate the number of access and default ACL entries. ++ /* ++ * calculate the number of access and default ACL entries + * + * Note: we assume that the acl() system call returned a + * well formed ACL which is sorted so that all of the -+ * access ACL entries preceed any default ACL entries. */ ++ * access ACL entries preceed any default ACL entries ++ */ + for (naccess = 0; naccess < count; naccess++) { + if (acl_d->acl[naccess].a_type & ACL_DEFAULT) + break; + } + ndefault = count - naccess; -+ -+ /* If the caller wants the default ACL we have to copy ++ ++ /* ++ * if the caller wants the default ACL we have to copy + * the entries down to the start of the acl[] buffer -+ * and mask out the ACL_DEFAULT flag from the type field. */ ++ * and mask out the ACL_DEFAULT flag from the type field ++ */ + if (type == SMB_ACL_TYPE_DEFAULT) { -+ int i, j; ++ int i, j; + + for (i = 0, j = naccess; i < ndefault; i++, j++) { + acl_d->acl[i] = acl_d->acl[j]; @@ -2952,9 +2536,11 @@ ACLs to a non-ACL-supporting disk should complain. + return acl_d; +} + -+ SMB_ACL_T sys_acl_get_fd(int fd) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ -+ /* HPUX doesn't have the facl call. Fake it using the path.... JRA. */ ++ /* ++ * HPUX doesn't have the facl call. Fake it using the path.... JRA. ++ */ + + files_struct *fsp = file_find_fd(fd); + @@ -2963,20 +2549,22 @@ ACLs to a non-ACL-supporting disk should complain. + return NULL; + } + -+ /* We know we're in the same conn context. So we can use the -+ * relative path. */ ++ /* ++ * We know we're in the same conn context. So we ++ * can use the relative path. ++ */ + + return sys_acl_get_file(dos_to_unix_static(fsp->fsp_name), SMB_ACL_TYPE_ACCESS); +} + -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d) ++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) ++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) { @@ -2994,53 +2582,58 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm) ++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(SMB_ACL_T acl_d, ssize_t *len_p) ++char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p) +{ -+ int i; -+ int len, maxlen; -+ char *text; ++ 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; ++ /* ++ * 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 = malloc(maxlen)) == NULL) { + errno = ENOMEM; + return NULL; + } + + for (i = 0; i < acl_d->count; i++) { -+ struct acl *ap = &acl_d->acl[i]; -+ struct passwd *pw; -+ struct group *gr; -+ char tagbuf[12]; -+ char idbuf[12]; -+ char *tag; -+ char *id = ""; -+ char perms[4]; -+ int nbytes; ++ struct acl *ap = &acl_d->acl[i]; ++ struct passwd *pw; ++ struct group *gr; ++ char tagbuf[12]; ++ char idbuf[12]; ++ char *tag; ++ char *id = ""; ++ char perms[4]; ++ int nbytes; + + switch (ap->a_type) { -+ /* For debugging purposes it's probably more ++ /* ++ * for debugging purposes it's probably more + * useful to dump unknown tag types rather -+ * than just returning an error. */ ++ * than just returning an error ++ */ + default: -+ snprintf(tagbuf, sizeof tagbuf - 1, "0x%x", ++ slprintf(tagbuf, sizeof(tagbuf)-1, "0x%x", + ap->a_type); + tag = tagbuf; -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ slprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + break; + + case SMB_ACL_USER: + if ((pw = getpwuid(ap->a_id)) == NULL) { -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ snprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + } else { @@ -3052,7 +2645,7 @@ ACLs to a non-ACL-supporting disk should complain. + + case SMB_ACL_GROUP: + if ((gr = getgrgid(ap->a_id)) == NULL) { -+ snprintf(idbuf, sizeof idbuf - 1, "%ld", ++ slprintf(idbuf, sizeof(idbuf)-1, "%ld", + (long)ap->a_id); + id = idbuf; + } else { @@ -3080,10 +2673,12 @@ ACLs to a non-ACL-supporting disk should complain. + /* : : rwx \n \0 */ + nbytes = strlen(tag) + 1 + strlen(id) + 1 + 3 + 1 + 1; + -+ /* If this entry would overflow the buffer ++ /* ++ * 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. */ ++ * for each entry still to be processed ++ */ + if ((len + nbytes) > maxlen) { + char *oldtext = text; + @@ -3096,7 +2691,7 @@ ACLs to a non-ACL-supporting disk should complain. + } + } + -+ snprintf(&text[len], nbytes-1, "%s:%s:%s\n", tag, id, perms); ++ slprintf(&text[len], nbytes-1, "%s:%s:%s\n", tag, id, perms); + len += nbytes - 1; + } + @@ -3106,20 +2701,22 @@ ACLs to a non-ACL-supporting disk should complain. + return text; +} + -+ SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init(int count) +{ -+ SMB_ACL_T a; ++ SMB_ACL_T a; + + if (count < 0) { + errno = EINVAL; + return NULL; + } + -+ /* Note that since the definition of the structure pointed ++ /* ++ * note that since the definition of the structure pointed + * to by the SMB_ACL_T includes the first element of the + * acl[] array, this actually allocates an ACL with room -+ * for (count+1) entries. */ -+ if ((a = malloc(sizeof a[0] + count * sizeof (struct acl))) == NULL) { ++ * for (count+1) entries ++ */ ++ if ((a = malloc(sizeof(*a) + count * sizeof(struct acl))) == NULL) { + errno = ENOMEM; + return NULL; + } @@ -3132,10 +2729,10 @@ ACLs to a non-ACL-supporting disk should complain. +} + + -+ int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p) ++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; ++ SMB_ACL_T acl_d; ++ SMB_ACL_ENTRY_T entry_d; + + if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) { + errno = EINVAL; @@ -3147,16 +2744,16 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ entry_d = &acl_d->acl[acl_d->count++]; -+ entry_d->a_type = 0; -+ entry_d->a_id = -1; -+ entry_d->a_perm = 0; -+ *entry_p = entry_d; ++ entry_d = &acl_d->acl[acl_d->count++]; ++ entry_d->a_type = 0; ++ entry_d->a_id = -1; ++ entry_d->a_perm = 0; ++ *entry_p = entry_d; + + return 0; +} + -+ int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type) ++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: @@ -3175,7 +2772,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) ++int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) +{ + if (entry_d->a_type != SMB_ACL_GROUP + && entry_d->a_type != SMB_ACL_USER) { @@ -3188,7 +2785,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d) ++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)) { + return EINVAL; @@ -3231,9 +2828,9 @@ ACLs to a non-ACL-supporting disk should complain. + * aclp - Array of ACL structures. + * acl_type_count - Pointer to acl_types structure. Should already be + * allocated. -+ * Output: ++ * Output: + * -+ * acl_type_count - This structure is filled up with counts of various ++ * acl_type_count - This structure is filled up with counts of various + * acl types. + */ + @@ -3241,32 +2838,32 @@ ACLs to a non-ACL-supporting disk should complain. +{ + 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;in_user++; + break; -+ case USER_OBJ: ++ case USER_OBJ: + acl_type_count->n_user_obj++; + break; -+ case DEF_USER_OBJ: ++ case DEF_USER_OBJ: + acl_type_count->n_def_user_obj++; + break; -+ case GROUP: ++ case GROUP: + acl_type_count->n_group++; + break; -+ case GROUP_OBJ: ++ case GROUP_OBJ: + acl_type_count->n_group_obj++; + break; -+ case DEF_GROUP_OBJ: ++ case DEF_GROUP_OBJ: + acl_type_count->n_def_group_obj++; + break; -+ case OTHER_OBJ: ++ case OTHER_OBJ: + acl_type_count->n_other_obj++; + break; -+ case DEF_OTHER_OBJ: ++ case DEF_OTHER_OBJ: + acl_type_count->n_def_other_obj++; + break; + case CLASS_OBJ: @@ -3281,14 +2878,14 @@ ACLs to a non-ACL-supporting disk should complain. + case DEF_GROUP: + acl_type_count->n_def_group++; + break; -+ default: ++ default: + acl_type_count->n_illegal_obj++; + break; + } + } +} + -+/* swap_acl_entries: Swaps two ACL entries. ++/* swap_acl_entries: Swaps two ACL entries. + * + * Inputs: aclp0, aclp1 - ACL entries to be swapped. + */ @@ -3311,34 +2908,35 @@ ACLs to a non-ACL-supporting disk should complain. +} + +/* prohibited_duplicate_type -+ * Identifies if given ACL type can have duplicate entries or ++ * Identifies if given ACL type can have duplicate entries or + * not. + * + * Inputs: acl_type - ACL Type. + * -+ * Outputs: ++ * Outputs: + * -+ * Return.. ++ * Return.. + * + * True - If the ACL type matches any of the prohibited types. + * False - If the ACL type doesn't match any of the prohibited types. -+ */ ++ */ + +static BOOL hpux_prohibited_duplicate_type(int acl_type) +{ -+ switch (acl_type) { ++ switch(acl_type) { + case USER: + case GROUP: -+ case DEF_USER: ++ case DEF_USER: + case DEF_GROUP: + return True; ++ default: ++ return False; + } -+ return False; +} + +/* get_needed_class_perm + * Returns the permissions of a ACL structure only if the ACL -+ * type matches one of the pre-determined types for computing ++ * type matches one of the pre-determined types for computing + * CLASS_OBJ permissions. + * + * Inputs: aclp - Pointer to ACL structure. @@ -3346,18 +2944,18 @@ ACLs to a non-ACL-supporting disk should complain. + +static int hpux_get_needed_class_perm(struct acl *aclp) +{ -+ switch (aclp->a_type) { -+ case USER: -+ case GROUP_OBJ: -+ case GROUP: -+ case DEF_USER_OBJ: ++ switch(aclp->a_type) { ++ case USER: ++ case GROUP_OBJ: ++ case GROUP: ++ case DEF_USER_OBJ: + case DEF_USER: -+ case DEF_GROUP_OBJ: ++ case DEF_GROUP_OBJ: + case DEF_GROUP: + case DEF_CLASS_OBJ: -+ case DEF_OTHER_OBJ: ++ case DEF_OTHER_OBJ: + return aclp->a_perm; -+ default: ++ default: + return 0; + } +} @@ -3386,21 +2984,23 @@ ACLs to a non-ACL-supporting disk should complain. +static int hpux_acl_sort(int acl_count, int calclass, struct acl *aclp) +{ +#if !defined(HAVE_HPUX_ACLSORT) -+ /* The aclsort() system call is availabe on the latest HPUX General -+ * Patch Bundles. So for HPUX, we developed our version of acl_sort -+ * function. Because, we don't want to update to a new -+ * HPUX GR bundle just for aclsort() call. */ ++ /* ++ * The aclsort() system call is availabe on the latest HPUX General ++ * Patch Bundles. So for HPUX, we developed our version of acl_sort ++ * function. Because, we don't want to update to a new ++ * HPUX GR bundle just for aclsort() call. ++ */ + + struct hpux_acl_types acl_obj_count; + int n_class_obj_perm = 0; + int i, j; -+ -+ if (!acl_count) { ++ ++ if(!acl_count) { + DEBUG(10,("Zero acl count passed. Returning Success\n")); + return 0; + } + -+ if (aclp == NULL) { ++ if(aclp == NULL) { + DEBUG(0,("Null ACL pointer in hpux_acl_sort. Returning Failure. \n")); + return -1; + } @@ -3409,14 +3009,15 @@ ACLs to a non-ACL-supporting disk should complain. + + hpux_count_obj(acl_count, aclp, &acl_obj_count); + -+ /* There should be only one entry each of type USER_OBJ, GROUP_OBJ, -+ * CLASS_OBJ and OTHER_OBJ ++ /* There should be only one entry each of type USER_OBJ, GROUP_OBJ, ++ * CLASS_OBJ and OTHER_OBJ + */ + -+ if (acl_obj_count.n_user_obj != 1 -+ || acl_obj_count.n_group_obj != 1 -+ || acl_obj_count.n_class_obj != 1 -+ || acl_obj_count.n_other_obj != 1) { ++ if( (acl_obj_count.n_user_obj != 1) || ++ (acl_obj_count.n_group_obj != 1) || ++ (acl_obj_count.n_class_obj != 1) || ++ (acl_obj_count.n_other_obj != 1) ++ ) { + 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")); + return -1; @@ -3426,40 +3027,40 @@ ACLs to a non-ACL-supporting disk should complain. + * one of them each. + */ + -+ 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) { ++ 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) ) { + 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")); + return -1; + } + -+ /* We now have proper number of OBJ and DEF_OBJ entries. Now sort the acl -+ * structures. ++ /* We now have proper number of OBJ and DEF_OBJ entries. Now sort the acl ++ * structures. + * + * Sorting crieteria - First sort by ACL type. If there are multiple entries of + * 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 trival kind of sorting method here because, performance isn't + * 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 aclp[j].a_type) { ++ if( aclp[i].a_type > aclp[j].a_type ) { + /* ACL entries out of order, swap them */ + + 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 */ + -+ 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)); + } else if (aclp[i].a_id == aclp[j].a_id) { + /* 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", + aclp[i].a_type, aclp[i].a_id)); + return -1; @@ -3471,13 +3072,13 @@ ACLs to a non-ACL-supporting disk should complain. + } + + /* set the class obj permissions to the computed one. */ -+ if (calclass) { ++ if(calclass) { + int n_class_obj_index = -1; + -+ for (i=0;iacl[0]; -+ acl_count = acl_d->count; ++ acl_p = &acl_d->acl[0]; ++ acl_count = acl_d->count; + -+ /* If it's a directory there is extra work to do since the acl() -+ * system call will replace both the access ACLs and the default -+ * ACLs (if any). */ ++ /* ++ * if it's a directory there is extra work to do ++ * since the acl() system call will replace both ++ * the access ACLs and the default ACLs (if any) ++ */ + if (stat(name, &s) != 0) { + return -1; + } + if (S_ISDIR(s.st_mode)) { -+ SMB_ACL_T acc_acl; -+ SMB_ACL_T def_acl; -+ SMB_ACL_T tmp_acl; -+ int i; ++ SMB_ACL_T acc_acl; ++ SMB_ACL_T def_acl; ++ SMB_ACL_T tmp_acl; ++ int i; + + if (type == SMB_ACL_TYPE_ACCESS) { + acc_acl = acl_d; @@ -3572,9 +3178,11 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ /* Allocate a temporary buffer for the complete ACL. */ ++ /* ++ * allocate a temporary buffer for the complete ACL ++ */ + acl_count = acc_acl->count + def_acl->count; -+ acl_p = acl_buf = malloc(acl_count * sizeof acl_buf[0]); ++ acl_p = acl_buf = malloc(acl_count * sizeof(acl_buf[0])); + + if (acl_buf == NULL) { + sys_acl_free_acl(tmp_acl); @@ -3582,14 +3190,18 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ /* 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], -+ acc_acl->count * sizeof acl_buf[0]); ++ acc_acl->count * sizeof(acl_buf[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 ++ */ + for (i = acc_acl->count; i < acl_count; i++) { + acl_buf[i].a_type |= ACL_DEFAULT; + } @@ -3603,14 +3215,18 @@ ACLs to a non-ACL-supporting disk should complain. + + ret = acl(name, ACL_SET, acl_count, acl_p); + -+ free(acl_buf); ++ if (acl_buf) { ++ free(acl_buf); ++ } + + return ret; +} + -+ int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) ++int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) +{ -+ /* HPUX doesn't have the facl call. Fake it using the path.... JRA. */ ++ /* ++ * HPUX doesn't have the facl call. Fake it using the path.... JRA. ++ */ + + files_struct *fsp = file_find_fd(fd); + @@ -3623,19 +3239,23 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ /* We know we're in the same conn context. So we can use the -+ * relative path. */ ++ /* ++ * We know we're in the same conn context. So we ++ * can use the relative path. ++ */ + + return sys_acl_set_file(dos_to_unix_static(fsp->fsp_name), SMB_ACL_TYPE_ACCESS, acl_d); +} + -+ int sys_acl_delete_def_file(const char *path) ++int sys_acl_delete_def_file(const char *path) +{ -+ SMB_ACL_T acl_d; -+ int ret; ++ SMB_ACL_T acl_d; ++ int ret; + -+ /* Fetching the access ACL and rewriting it has the effect of -+ * deleting the default ACL. */ ++ /* ++ * fetching the access ACL and rewriting it has ++ * the effect of deleting the default ACL ++ */ + if ((acl_d = sys_acl_get_file(path, SMB_ACL_TYPE_ACCESS)) == NULL) { + return -1; + } @@ -3643,30 +3263,30 @@ ACLs to a non-ACL-supporting disk should complain. + ret = acl(path, ACL_SET, acl_d->count, acl_d->acl); + + sys_acl_free_acl(acl_d); -+ ++ + return ret; +} + -+ int sys_acl_free_text(char *text) ++int sys_acl_free_text(char *text) +{ + free(text); + return 0; +} + -+ int sys_acl_free_acl(SMB_ACL_T acl_d) ++int sys_acl_free_acl(SMB_ACL_T acl_d) +{ + free(acl_d); + return 0; +} + -+ int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ + return 0; +} + +#elif defined(HAVE_IRIX_ACLS) + -+ int sys_acl_get_entry(SMB_ACL_T acl_d, int entry_id, SMB_ACL_ENTRY_T *entry_p) ++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; @@ -3696,21 +3316,21 @@ ACLs to a non-ACL-supporting disk should complain. + return 1; +} + -+ int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p) ++int sys_acl_get_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *type_p) +{ + *type_p = entry_d->ae_tag; + + return 0; +} + -+ int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) ++int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) +{ + *permset_p = entry_d; + + return 0; +} + -+ void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) ++void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) +{ + if (entry_d->ae_tag != SMB_ACL_USER + && entry_d->ae_tag != SMB_ACL_GROUP) { @@ -3721,16 +3341,16 @@ ACLs to a non-ACL-supporting disk should complain. + return &entry_d->ae_id; +} + -+ 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 a; ++ SMB_ACL_T a; + -+ if ((a = malloc(sizeof a[0])) == NULL) { ++ if ((a = malloc(sizeof(*a))) == NULL) { + errno = ENOMEM; + return NULL; + } + if ((a->aclp = acl_get_file(path_p, type)) == NULL) { -+ free(a); ++ SAFE_FREE(a); + return NULL; + } + a->next = -1; @@ -3738,16 +3358,16 @@ ACLs to a non-ACL-supporting disk should complain. + return a; +} + -+ SMB_ACL_T sys_acl_get_fd(int fd) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ -+ SMB_ACL_T a; ++ SMB_ACL_T a; + -+ if ((a = malloc(sizeof a[0])) == NULL) { ++ if ((a = malloc(sizeof(*a))) == NULL) { + errno = ENOMEM; + return NULL; + } + if ((a->aclp = acl_get_fd(fd)) == NULL) { -+ free(a); ++ SAFE_FREE(a); + return NULL; + } + a->next = -1; @@ -3755,14 +3375,14 @@ ACLs to a non-ACL-supporting disk should complain. + return a; +} + -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d) ++int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset_d) +{ + permset_d->ae_perm = 0; + + return 0; +} + -+ int sys_acl_add_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm) ++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) { @@ -3780,43 +3400,43 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm) ++int sys_acl_get_perm(SMB_ACL_PERMSET_T permset_d, SMB_ACL_PERM_T perm) +{ + return permset_d->ae_perm & perm; +} + -+ char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p) ++char *sys_acl_to_text(SMB_ACL_T acl_d, ssize_t *len_p) +{ + return acl_to_text(acl_d->aclp, len_p); +} + -+ SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init(int count) +{ -+ SMB_ACL_T a; ++ SMB_ACL_T a; + + if (count < 0) { + errno = EINVAL; + return NULL; + } + -+ if ((a = malloc(sizeof a[0] + sizeof (struct acl))) == NULL) { ++ if ((a = malloc(sizeof(*a) + sizeof(struct acl))) == NULL) { + errno = ENOMEM; + return NULL; + } + + a->next = -1; + a->freeaclp = False; -+ a->aclp = (struct acl *)(&a->aclp + sizeof (struct acl *)); ++ a->aclp = (struct acl *)(&a->aclp + sizeof(struct acl *)); + a->aclp->acl_cnt = 0; + + return a; +} + + -+ int sys_acl_create_entry(SMB_ACL_T *acl_p, SMB_ACL_ENTRY_T *entry_p) ++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; ++ SMB_ACL_T acl_d; ++ SMB_ACL_ENTRY_T entry_d; + + if (acl_p == NULL || entry_p == NULL || (acl_d = *acl_p) == NULL) { + errno = EINVAL; @@ -3828,16 +3448,16 @@ ACLs to a non-ACL-supporting disk should complain. + return -1; + } + -+ entry_d = &acl_d->aclp->acl_entry[acl_d->aclp->acl_cnt++]; -+ entry_d->ae_tag = 0; -+ entry_d->ae_id = 0; -+ entry_d->ae_perm = 0; -+ *entry_p = entry_d; ++ entry_d = &acl_d->aclp->acl_entry[acl_d->aclp->acl_cnt++]; ++ entry_d->ae_tag = 0; ++ entry_d->ae_id = 0; ++ entry_d->ae_perm = 0; ++ *entry_p = entry_d; + + return 0; +} + -+ int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T tag_type) ++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: @@ -3856,7 +3476,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) ++int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry_d, void *qual_p) +{ + if (entry_d->ae_tag != SMB_ACL_GROUP + && entry_d->ae_tag != SMB_ACL_USER) { @@ -3869,7 +3489,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d) ++int sys_acl_set_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T permset_d) +{ + if (permset_d->ae_perm & ~(SMB_ACL_READ|SMB_ACL_WRITE|SMB_ACL_EXECUTE)) { + return EINVAL; @@ -3880,32 +3500,32 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_valid(SMB_ACL_T acl_d) ++int sys_acl_valid(SMB_ACL_T acl_d) +{ + return acl_valid(acl_d->aclp); +} + -+ int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d) ++int sys_acl_set_file(const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T acl_d) +{ + return acl_set_file(name, type, acl_d->aclp); +} + -+ int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) ++int sys_acl_set_fd(int fd, SMB_ACL_T acl_d) +{ + return acl_set_fd(fd, acl_d->aclp); +} + -+ int sys_acl_delete_def_file(const char *name) ++int sys_acl_delete_def_file(const char *name) +{ + return acl_delete_def_file(name); +} + -+ int sys_acl_free_text(char *text) ++int sys_acl_free_text(char *text) +{ + return acl_free(text); +} + -+ int sys_acl_free_acl(SMB_ACL_T acl_d) ++int sys_acl_free_acl(SMB_ACL_T acl_d) +{ + if (acl_d->freeaclp) { + acl_free(acl_d->aclp); @@ -3914,7 +3534,7 @@ ACLs to a non-ACL-supporting disk should complain. + return 0; +} + -+ int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ + return 0; +} @@ -3923,7 +3543,7 @@ ACLs to a non-ACL-supporting disk should complain. + +/* 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 new_acl_entry *entry; @@ -3931,17 +3551,18 @@ ACLs to a non-ACL-supporting disk should complain. + + DEBUG(10,("This is the count: %d\n",theacl->count)); + -+ /* Check if count was previously set to -1. If it was, that -+ * means we reached the end of the acl last time. */ -+ if (theacl->count == -1) -+ return 0; ++ /* Check if count was previously set to -1. * ++ * If it was, that means we reached the end * ++ * of the acl last time. */ ++ if(theacl->count == -1) ++ return(0); + + link = theacl; -+ /* To get to the next acl, traverse linked list until index of -+ * acl matches the count we are keeping. This count is -+ * incremented each time we return an acl entry. */ ++ /* To get to the next acl, traverse linked list until index * ++ * of acl matches the count we are keeping. This count is * ++ * 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; + + entry = *entry_p = link->entryp; @@ -3951,21 +3572,22 @@ ACLs to a non-ACL-supporting disk should complain. + + /* Increment count */ + theacl->count++; -+ if (link->nextp == NULL) ++ if(link->nextp == NULL) + 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 */ + + *tag_type_p = -1; + DEBUG(10,("the tagtype is %d\n",entry_d->ace_id->id_type)); + -+ /* Depending on what type of entry we have, return tag type. */ -+ switch (entry_d->ace_id->id_type) { ++ /* Depending on what type of entry we have, * ++ * return tag type. */ ++ switch(entry_d->ace_id->id_type) { + case ACEID_USER: + *tag_type_p = SMB_ACL_USER; + break; @@ -3978,35 +3600,35 @@ ACLs to a non-ACL-supporting disk should complain. + case SMB_ACL_OTHER: + *tag_type_p = entry_d->ace_id->id_type; + break; -+ ++ + default: -+ return -1; ++ return(-1); + } + -+ return 0; ++ return(0); +} + -+ int sys_acl_get_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) ++int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) +{ + DEBUG(10,("Starting AIX sys_acl_get_permset\n")); + *permset_p = &entry_d->ace_access; + DEBUG(10,("**permset_p is %d\n",**permset_p)); -+ if (!(**permset_p & S_IXUSR) -+ && !(**permset_p & S_IWUSR) -+ && !(**permset_p & S_IRUSR) -+ && **permset_p != 0) -+ return -1; ++ if(!(**permset_p & S_IXUSR) && ++ !(**permset_p & S_IWUSR) && ++ !(**permset_p & S_IRUSR) && ++ (**permset_p != 0)) ++ return(-1); + + DEBUG(10,("Ending AIX sys_acl_get_permset\n")); -+ return 0; ++ return(0); +} + -+ void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d) ++void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d) +{ -+ return entry_d->ace_id->id_data; ++ return(entry_d->ace_id->id_data); +} + -+ 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_entry *acl_entry; @@ -4019,25 +3641,25 @@ ACLs to a non-ACL-supporting disk should complain. + uid_t user_id; + + /* Get the acl using statacl */ -+ ++ + DEBUG(10,("Entering sys_acl_get_file\n")); + DEBUG(10,("path_p is %s\n",path_p)); + + file_acl = (struct acl *)malloc(BUFSIZ); -+ -+ if (file_acl == NULL) { ++ ++ if(file_acl == NULL) { + errno=ENOMEM; + DEBUG(0,("Error in AIX sys_acl_get_file: %d\n",errno)); -+ return NULL; ++ return(NULL); + } + + memset(file_acl,0,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)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + + DEBUG(10,("Got facl and returned it\n")); @@ -4045,86 +3667,88 @@ ACLs to a non-ACL-supporting disk should complain. + /* Point to the first acl entry in the acl */ + acl_entry = file_acl->acl_ext; + -+ /* Begin setting up the head of the linked list that will be -+ * used for the storing the acl in a way that is useful for the -+ * posix_acls.c code. */ ++ /* Begin setting up the head of the linked list * ++ * that will be used for the storing the acl * ++ * in a way that is useful for the posix_acls.c * ++ * code. */ + + acl_entry_link_head = acl_entry_link = sys_acl_init(0); -+ if (acl_entry_link_head == NULL) -+ return NULL; ++ if(acl_entry_link_head == NULL) ++ return(NULL); + -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); -+ if (acl_entry_link->entryp == NULL) { -+ free(file_acl); ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); ++ if(acl_entry_link->entryp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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_last(file_acl) id %d\n",acl_last(file_acl))); + -+ /* Check if the extended acl bit is on. If it isn't, do not -+ * show the contents of the acl since AIX intends the extended -+ * info to remain unused. */ ++ /* Check if the extended acl bit is on. * ++ * If it isn't, do not show the * ++ * contents of the acl since AIX intends * ++ * 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 (acl_entry < acl_last(file_acl)) { ++ while(acl_entry < acl_last(file_acl)) { + /* before we malloc anything, make sure this is */ + /* a valid acl entry and one that we want to map */ + idp = id_nxt(acl_entry->ace_id); -+ if ((acl_entry->ace_type == ACC_SPECIFY -+ || acl_entry->ace_type == ACC_PERMIT) -+ && idp != id_last(acl_entry)) { -+ acl_entry = acl_nxt(acl_entry); -+ continue; ++ if((acl_entry->ace_type == ACC_SPECIFY || ++ (acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) { ++ acl_entry = acl_nxt(acl_entry); ++ continue; + } + + idp = acl_entry->ace_id; + -+ /* Check if this is the first entry in the linked list. -+ * The first entry needs to keep prevp pointing to NULL -+ * and already has entryp allocated. */ ++ /* Check if this is the first entry in the linked list. * ++ * The first entry needs to keep prevp pointing to NULL * ++ * and already has entryp allocated. */ + -+ if (acl_entry_link_head->count != 0) { -+ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); ++ if(acl_entry_link_head->count != 0) { ++ acl_entry_link->nextp = (struct acl_entry_link *) ++ malloc(sizeof(struct acl_entry_link)); + -+ if (acl_entry_link->nextp == NULL) { -+ free(file_acl); ++ if(acl_entry_link->nextp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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 = acl_entry_link->nextp; -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); -+ if (acl_entry_link->entryp == NULL) { -+ free(file_acl); ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); ++ if(acl_entry_link->entryp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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->entryp->ace_len = acl_entry->ace_len; + -+ /* Don't really need this since all types are going -+ * to be specified but, it's better than leaving it 0. */ ++ /* Don't really need this since all types are going * ++ * to be specified but, it's better than leaving it 0 */ + + acl_entry_link->entryp->ace_type = acl_entry->ace_type; -+ ++ + 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 -+ * three bites, because they will ultimately be compared -+ * to S_IRUSR, S_IWUSR, and S_IXUSR. */ ++ /* The access in the acl entries must be left shifted by * ++ * three bites, because they will ultimately be compared * ++ * to S_IRUSR, S_IWUSR, and S_IXUSR. */ + -+ switch (acl_entry->ace_type){ ++ switch(acl_entry->ace_type){ + case ACC_PERMIT: + case ACC_SPECIFY: + acl_entry_link->entryp->ace_access = acl_entry->ace_access; @@ -4132,8 +3756,8 @@ ACLs to a non-ACL-supporting disk should complain. + acl_entry_link_head->count++; + break; + case ACC_DENY: -+ /* Since there is no way to return a DENY acl entry -+ * change to PERMIT and then shift. */ ++ /* Since there is no way to return a DENY acl entry * ++ * change to PERMIT and then shift. */ + DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access)); + 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)); @@ -4141,39 +3765,39 @@ ACLs to a non-ACL-supporting disk should complain. + acl_entry_link_head->count++; + break; + default: -+ return 0; ++ return(0); + } + + DEBUG(10,("acl_entry = %d\n",acl_entry)); + DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type)); -+ ++ + acl_entry = acl_nxt(acl_entry); + } + } /* end of if enabled */ + -+ /* Since owner, group, other acl entries are not part of the acl -+ * entries in an acl, they must be dummied up to become part of -+ * the list. */ ++ /* Since owner, group, other acl entries are not * ++ * part of the acl entries in an acl, they must * ++ * 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)); -+ if (acl_entry_link_head->count != 0) { -+ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); -+ if (acl_entry_link->nextp == NULL) { -+ free(file_acl); ++ if(acl_entry_link_head->count != 0) { ++ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof(struct acl_entry_link)); ++ if(acl_entry_link->nextp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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 = acl_entry_link->nextp; -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); -+ if (acl_entry_link->entryp == NULL) { -+ free(file_acl); ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); ++ if(acl_entry_link->entryp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno)); -+ return NULL; ++ return(NULL); + } + } + @@ -4182,13 +3806,13 @@ ACLs to a non-ACL-supporting disk should complain. + new_acl_entry = acl_entry_link->entryp; + 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; -+ idp->id_len = sizeof (struct ace_id); ++ idp->id_len = sizeof(struct ace_id); + 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: + new_acl_entry->ace_access = file_acl->g_access << 6; + idp->id_type = SMB_ACL_GROUP_OBJ; @@ -4198,14 +3822,14 @@ ACLs to a non-ACL-supporting disk should complain. + new_acl_entry->ace_access = file_acl->o_access << 6; + idp->id_type = SMB_ACL_OTHER; + break; -+ ++ + case 1: + new_acl_entry->ace_access = file_acl->u_access << 6; + idp->id_type = SMB_ACL_USER_OBJ; + break; -+ ++ + default: -+ return NULL; ++ return(NULL); + + } + @@ -4214,12 +3838,12 @@ ACLs to a non-ACL-supporting disk should complain. + } + + acl_entry_link_head->count = 0; -+ free(file_acl); ++ SAFE_FREE(file_acl); + -+ return acl_entry_link_head; ++ return(acl_entry_link_head); +} + -+ SMB_ACL_T sys_acl_get_fd(int fd) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ + struct acl *file_acl = (struct acl *)NULL; + struct acl_entry *acl_entry; @@ -4232,24 +3856,24 @@ ACLs to a non-ACL-supporting disk should complain. + uid_t user_id; + + /* Get the acl using fstatacl */ -+ ++ + DEBUG(10,("Entering sys_acl_get_fd\n")); + DEBUG(10,("fd is %d\n",fd)); + file_acl = (struct acl *)malloc(BUFSIZ); + -+ if (file_acl == NULL) { ++ if(file_acl == NULL) { + errno=ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ return NULL; ++ return(NULL); + } + + memset(file_acl,0,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)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + + DEBUG(10,("Got facl and returned it\n")); @@ -4257,69 +3881,69 @@ ACLs to a non-ACL-supporting disk should complain. + /* Point to the first acl entry in the acl */ + + acl_entry = file_acl->acl_ext; -+ -+ /* Begin setting up the head of the linked list that will be -+ * used for the storing the acl in a way that is useful for the -+ * posix_acls.c code. */ ++ /* Begin setting up the head of the linked list * ++ * that will be used for the storing the acl * ++ * in a way that is useful for the posix_acls.c * ++ * code. */ + + acl_entry_link_head = acl_entry_link = sys_acl_init(0); -+ if (acl_entry_link_head == NULL){ -+ free(file_acl); -+ return NULL; ++ if(acl_entry_link_head == NULL){ ++ SAFE_FREE(file_acl); ++ return(NULL); + } + -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); + -+ if (acl_entry_link->entryp == NULL) { ++ if(acl_entry_link->entryp == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + + DEBUG(10,("acl_entry is %d\n",acl_entry)); + DEBUG(10,("acl_last(file_acl) id %d\n",acl_last(file_acl))); -+ -+ /* Check if the extended acl bit is on. If it isn't, do not -+ * show the contents of the acl since AIX intends the extended -+ * info to remain unused. */ -+ -+ if (file_acl->acl_mode & S_IXACL){ ++ ++ /* Check if the extended acl bit is on. * ++ * If it isn't, do not show the * ++ * contents of the acl since AIX intends * ++ * the extended info to remain unused */ ++ ++ if(file_acl->acl_mode & S_IXACL){ + /* 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 */ + /* a valid acl entry and one that we want to map */ + + idp = id_nxt(acl_entry->ace_id); -+ if ((acl_entry->ace_type == ACC_SPECIFY -+ || acl_entry->ace_type == ACC_PERMIT) -+ && (idp != id_last(acl_entry))) { -+ acl_entry = acl_nxt(acl_entry); -+ continue; ++ if((acl_entry->ace_type == ACC_SPECIFY || ++ (acl_entry->ace_type == ACC_PERMIT)) && (idp != id_last(acl_entry))) { ++ acl_entry = acl_nxt(acl_entry); ++ continue; + } + + idp = acl_entry->ace_id; ++ ++ /* Check if this is the first entry in the linked list. * ++ * The first entry needs to keep prevp pointing to NULL * ++ * and already has entryp allocated. */ + -+ /* Check if this is the first entry in the linked list. -+ * The first entry needs to keep prevp pointing to NULL -+ * and already has entryp allocated. */ -+ -+ if (acl_entry_link_head->count != 0) { -+ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); -+ if (acl_entry_link->nextp == NULL) { ++ if(acl_entry_link_head->count != 0) { ++ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof(struct acl_entry_link)); ++ if(acl_entry_link->nextp == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + acl_entry_link->nextp->prevp = acl_entry_link; + acl_entry_link = acl_entry_link->nextp; -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); -+ if (acl_entry_link->entryp == NULL) { ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); ++ if(acl_entry_link->entryp == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + + acl_entry_link->nextp = NULL; @@ -4327,19 +3951,19 @@ ACLs to a non-ACL-supporting disk should complain. + + acl_entry_link->entryp->ace_len = acl_entry->ace_len; + -+ /* Don't really need this since all types are going -+ * to be specified but, it's better than leaving it 0. */ ++ /* Don't really need this since all types are going * ++ * to be specified but, it's better than leaving it 0 */ + + acl_entry_link->entryp->ace_type = acl_entry->ace_type; + 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 -+ * three bites, because they will ultimately be compared -+ * to S_IRUSR, S_IWUSR, and S_IXUSR. */ ++ /* The access in the acl entries must be left shifted by * ++ * three bites, because they will ultimately be compared * ++ * to S_IRUSR, S_IWUSR, and S_IXUSR. */ + -+ switch (acl_entry->ace_type){ ++ switch(acl_entry->ace_type){ + case ACC_PERMIT: + case ACC_SPECIFY: + acl_entry_link->entryp->ace_access = acl_entry->ace_access; @@ -4347,8 +3971,8 @@ ACLs to a non-ACL-supporting disk should complain. + acl_entry_link_head->count++; + break; + case ACC_DENY: -+ /* Since there is no way to return a DENY acl entry -+ * change to PERMIT and then shift. */ ++ /* Since there is no way to return a DENY acl entry * ++ * change to PERMIT and then shift. */ + DEBUG(10,("acl_entry->ace_access is %d\n",acl_entry->ace_access)); + 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)); @@ -4356,116 +3980,117 @@ ACLs to a non-ACL-supporting disk should complain. + acl_entry_link_head->count++; + break; + default: -+ return 0; ++ return(0); + } + + DEBUG(10,("acl_entry = %d\n",acl_entry)); + DEBUG(10,("The ace_type is %d\n",acl_entry->ace_type)); -+ ++ + acl_entry = acl_nxt(acl_entry); + } + } /* end of if enabled */ + -+ /* Since owner, group, other acl entries are not -+ * part of the acl entries in an acl, they must -+ * be dummied up to become part of the list. */ ++ /* Since owner, group, other acl entries are not * ++ * part of the acl entries in an acl, they must * ++ * 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)); -+ if (acl_entry_link_head->count != 0){ -+ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); -+ if (acl_entry_link->nextp == NULL) { ++ if(acl_entry_link_head->count != 0){ ++ acl_entry_link->nextp = (struct acl_entry_link *)malloc(sizeof(struct acl_entry_link)); ++ if(acl_entry_link->nextp == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ free(file_acl); -+ return NULL; ++ SAFE_FREE(file_acl); ++ return(NULL); + } + + acl_entry_link->nextp->prevp = acl_entry_link; + acl_entry_link = acl_entry_link->nextp; -+ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); ++ acl_entry_link->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); + -+ if (acl_entry_link->entryp == NULL) { -+ free(file_acl); ++ if(acl_entry_link->entryp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_get_fd is %d\n",errno)); -+ return NULL; ++ return(NULL); + } + } + + acl_entry_link->nextp = NULL; -+ ++ + new_acl_entry = acl_entry_link->entryp; + 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; -+ idp->id_len = sizeof (struct ace_id); ++ idp->id_len = sizeof(struct ace_id); + DEBUG(10,("idp->id_len = %d\n",idp->id_len)); -+ memset(idp->id_data,0,sizeof (uid_t)); -+ -+ switch (i) { ++ memset(idp->id_data,0,sizeof(uid_t)); ++ ++ switch(i) { + case 2: + new_acl_entry->ace_access = file_acl->g_access << 6; + idp->id_type = SMB_ACL_GROUP_OBJ; + break; -+ ++ + case 3: + new_acl_entry->ace_access = file_acl->o_access << 6; + idp->id_type = SMB_ACL_OTHER; + break; -+ ++ + case 1: + new_acl_entry->ace_access = file_acl->u_access << 6; + idp->id_type = SMB_ACL_USER_OBJ; + break; -+ ++ + default: -+ return NULL; ++ return(NULL); + } -+ ++ + acl_entry_link_head->count++; + DEBUG(10,("new_acl_entry->ace_access = %d\n",new_acl_entry->ace_access)); + } + + acl_entry_link_head->count = 0; -+ free(file_acl); -+ -+ return acl_entry_link_head; ++ SAFE_FREE(file_acl); ++ ++ return(acl_entry_link_head); +} + -+ int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset) ++int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset) +{ + *permset = *permset & ~0777; -+ return 0; ++ return(0); +} + -+ int sys_acl_add_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ -+ if (perm != 0 && (perm & (S_IXUSR | S_IWUSR | S_IRUSR)) == 0) -+ return -1; ++ if((perm != 0) && ++ (perm & (S_IXUSR | S_IWUSR | S_IRUSR)) == 0) ++ return(-1); + + *permset |= perm; + DEBUG(10,("This is the permset now: %d\n",*permset)); -+ return 0; ++ return(0); +} + -+ char *sys_acl_to_text(SMB_ACL_T theacl, ssize_t *plen) ++char *sys_acl_to_text( SMB_ACL_T theacl, ssize_t *plen) +{ -+ return NULL; ++ return(NULL); +} + -+ SMB_ACL_T sys_acl_init(int count) ++SMB_ACL_T sys_acl_init( int count) +{ + struct acl_entry_link *theacl = NULL; -+ ++ + DEBUG(10,("Entering sys_acl_init\n")); + -+ theacl = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); -+ if (theacl == NULL) { ++ theacl = (struct acl_entry_link *)malloc(sizeof(struct acl_entry_link)); ++ if(theacl == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_init is %d\n",errno)); -+ return NULL; ++ return(NULL); + } + + theacl->count = 0; @@ -4473,10 +4098,10 @@ ACLs to a non-ACL-supporting disk should complain. + theacl->prevp = NULL; + theacl->entryp = NULL; + 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 *acl_entryp; @@ -4489,18 +4114,18 @@ ACLs to a non-ACL-supporting disk should complain. + + /* 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)); + temp_entry = acl_entryp; + acl_entryp = acl_entryp->nextp; + } + -+ if (theacl->count != 0){ -+ temp_entry->nextp = acl_entryp = (struct acl_entry_link *)malloc(sizeof (struct acl_entry_link)); -+ if (acl_entryp == NULL) { ++ if(theacl->count != 0){ ++ temp_entry->nextp = acl_entryp = (struct acl_entry_link *)malloc(sizeof(struct acl_entry_link)); ++ if(acl_entryp == NULL) { + errno = ENOMEM; + 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)); @@ -4508,24 +4133,24 @@ ACLs to a non-ACL-supporting disk should complain. + DEBUG(10,("The acl_entryp->prevp is %d\n",acl_entryp->prevp)); + } + -+ *pentry = acl_entryp->entryp = (struct new_acl_entry *)malloc(sizeof (struct new_acl_entry)); -+ if (*pentry == NULL) { ++ *pentry = acl_entryp->entryp = (struct new_acl_entry *)malloc(sizeof(struct new_acl_entry)); ++ if(*pentry == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_create_entry is %d\n",errno)); -+ return -1; ++ return(-1); + } + -+ memset(*pentry,0,sizeof (struct new_acl_entry)); -+ acl_entryp->entryp->ace_len = sizeof (struct acl_entry); ++ memset(*pentry,0,sizeof(struct new_acl_entry)); ++ acl_entryp->entryp->ace_len = sizeof(struct acl_entry); + 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; + theacl->count++; + DEBUG(10,("Exiting sys_acl_create_entry\n")); -+ return 0; ++ return(0); +} + -+ int sys_acl_set_tag_type(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) ++int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) +{ + DEBUG(10,("Starting AIX sys_acl_set_tag_type\n")); + entry->ace_id->id_type = tagtype; @@ -4533,51 +4158,51 @@ ACLs to a non-ACL-supporting disk should complain. + DEBUG(10,("Ending AIX sys_acl_set_tag_type\n")); +} + -+ int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry, void *qual) ++int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual) +{ + DEBUG(10,("Starting AIX sys_acl_set_qualifier\n")); -+ memcpy(entry->ace_id->id_data,qual,sizeof (uid_t)); ++ memcpy(entry->ace_id->id_data,qual,sizeof(uid_t)); + DEBUG(10,("Ending AIX sys_acl_set_qualifier\n")); -+ return 0; ++ return(0); +} + -+ int sys_acl_set_permset(SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) ++int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) +{ + DEBUG(10,("Starting AIX sys_acl_set_permset\n")); -+ if (!(*permset & S_IXUSR) -+ && !(*permset & S_IWUSR) -+ && !(*permset & S_IRUSR) -+ && *permset != 0) -+ return -1; ++ if(!(*permset & S_IXUSR) && ++ !(*permset & S_IWUSR) && ++ !(*permset & S_IRUSR) && ++ (*permset != 0)) ++ return(-1); + + entry->ace_access = *permset; + DEBUG(10,("entry->ace_access = %d\n",entry->ace_access)); + 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 group_obj = 0; + int other_obj = 0; + 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); + 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); + } + + 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) ++ return(-1); + -+ if (user_obj != 1 || group_obj != 1 || other_obj != 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 *file_acl = NULL; @@ -4592,18 +4217,18 @@ ACLs to a non-ACL-supporting disk should complain. + + DEBUG(10,("Entering sys_acl_set_file\n")); + DEBUG(10,("File name is %s\n",name)); -+ ++ + /* AIX has no default ACL */ -+ if (acltype == SMB_ACL_TYPE_DEFAULT) -+ return 0; ++ if(acltype == SMB_ACL_TYPE_DEFAULT) ++ return(0); + + acl_length = BUFSIZ; + file_acl = (struct acl *)malloc(BUFSIZ); + -+ if (file_acl == NULL) { ++ if(file_acl == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_set_file is %d\n",errno)); -+ return -1; ++ return(-1); + } + + memset(file_acl,0,BUFSIZ); @@ -4611,11 +4236,11 @@ ACLs to a non-ACL-supporting disk should complain. + file_acl->acl_len = ACL_SIZ; + 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; + id_type = acl_entry_link->entryp->ace_id->id_type; + -+ switch (id_type) { ++ switch(id_type) { + case SMB_ACL_USER_OBJ: + file_acl->u_access = acl_entry_link->entryp->ace_access; + continue; @@ -4629,50 +4254,50 @@ ACLs to a non-ACL-supporting disk should complain. + continue; + } + -+ if ((file_acl->acl_len + sizeof (struct acl_entry)) > acl_length) { -+ acl_length += sizeof (struct acl_entry); ++ if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) { ++ acl_length += sizeof(struct acl_entry); + file_acl_temp = (struct acl *)malloc(acl_length); -+ if (file_acl_temp == NULL) { -+ free(file_acl); ++ if(file_acl_temp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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); -+ free(file_acl); ++ SAFE_FREE(file_acl); + file_acl = file_acl_temp; + } + + 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_access = acl_entry_link->entryp->ace_access; -+ ++ + /* 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) -+ acl_entry->ace_type = ACC_SPECIFY; */ ++ /* if(!acl_entry->ace_access && acl_entry->ace_type == ACC_PERMIT) ++ acl_entry->ace_type = ACC_SPECIFY; */ + + acl_entry->ace_type = ACC_SPECIFY; -+ ++ + ace_id = acl_entry->ace_id; -+ ++ + ace_id->id_type = acl_entry_link->entryp->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; -+ 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(&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)); + } + -+ rc = chacl((char *)name,file_acl,file_acl->acl_len); ++ rc = chacl(name,file_acl,file_acl->acl_len); + DEBUG(10,("errno is %d\n",errno)); + DEBUG(10,("return code is %d\n",rc)); -+ free(file_acl); ++ SAFE_FREE(file_acl); + DEBUG(10,("Exiting the sys_acl_set_file\n")); -+ return rc; ++ return(rc); +} + -+ 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 *file_acl = NULL; @@ -4683,28 +4308,28 @@ ACLs to a non-ACL-supporting disk should complain. + uint user_id; + uint acl_length; + uint rc; -+ ++ + DEBUG(10,("Entering sys_acl_set_fd\n")); + acl_length = BUFSIZ; + file_acl = (struct acl *)malloc(BUFSIZ); + -+ if (file_acl == NULL) { ++ if(file_acl == NULL) { + errno = ENOMEM; + DEBUG(0,("Error in sys_acl_set_fd is %d\n",errno)); -+ return -1; ++ return(-1); + } + + memset(file_acl,0,BUFSIZ); -+ ++ + file_acl->acl_len = ACL_SIZ; + 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; + id_type = acl_entry_link->entryp->ace_id->id_type; + DEBUG(10,("The id_type is %d\n",id_type)); + -+ switch (id_type) { ++ switch(id_type) { + case SMB_ACL_USER_OBJ: + file_acl->u_access = acl_entry_link->entryp->ace_access; + continue; @@ -4718,222 +4343,713 @@ ACLs to a non-ACL-supporting disk should complain. + continue; + } + -+ if ((file_acl->acl_len + sizeof (struct acl_entry)) > acl_length) { -+ acl_length += sizeof (struct acl_entry); ++ if((file_acl->acl_len + sizeof(struct acl_entry)) > acl_length) { ++ acl_length += sizeof(struct acl_entry); + file_acl_temp = (struct acl *)malloc(acl_length); -+ if (file_acl_temp == NULL) { -+ free(file_acl); ++ if(file_acl_temp == NULL) { ++ SAFE_FREE(file_acl); + errno = ENOMEM; + 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); -+ free(file_acl); ++ SAFE_FREE(file_acl); + file_acl = file_acl_temp; + } + + 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_access = acl_entry_link->entryp->ace_access; -+ ++ + /* 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; -+ ++ + ace_id = acl_entry->ace_id; -+ ++ + ace_id->id_type = acl_entry_link->entryp->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; -+ 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(&user_id, acl_entry_link->entryp->ace_id->id_data, sizeof(uid_t)); ++ memcpy(ace_id->id_data, &user_id, sizeof(uid_t)); + } -+ ++ + rc = fchacl(fd,file_acl,file_acl->acl_len); + DEBUG(10,("errno is %d\n",errno)); + DEBUG(10,("return code is %d\n",rc)); -+ free(file_acl); ++ SAFE_FREE(file_acl); + DEBUG(10,("Exiting sys_acl_set_fd\n")); -+ return rc; ++ return(rc); +} + -+ int sys_acl_delete_def_file(const char *name) ++int sys_acl_delete_def_file(const char *name) +{ + /* AIX has no default ACL */ + return 0; +} + -+ int sys_acl_get_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) ++int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ -+ return *permset & perm; ++ return(*permset & perm); +} + -+ int sys_acl_free_text(char *text) ++int sys_acl_free_text(char *text) +{ -+ return 0; ++ return(0); +} + -+ int sys_acl_free_acl(SMB_ACL_T posix_acl) ++int sys_acl_free_acl(SMB_ACL_T posix_acl) +{ + 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) { -+ free(acl_entry_link->prevp->entryp); -+ free(acl_entry_link->prevp); ++ 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); + } + -+ free(acl_entry_link->prevp->entryp); -+ free(acl_entry_link->prevp); -+ free(acl_entry_link->entryp); -+ free(acl_entry_link); -+ -+ return 0; ++ SAFE_FREE(acl_entry_link->prevp->entryp); ++ SAFE_FREE(acl_entry_link->prevp); ++ SAFE_FREE(acl_entry_link->entryp); ++ SAFE_FREE(acl_entry_link); ++ ++ return(0); +} + -+ int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ -+ return 0; ++ return(0); +} + +#else /* No ACLs. */ + -+ int sys_acl_get_entry(UNUSED(SMB_ACL_T the_acl), UNUSED(int entry_id), UNUSED(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) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_get_tag_type(UNUSED(SMB_ACL_ENTRY_T entry_d), UNUSED(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) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_get_permset(UNUSED(SMB_ACL_ENTRY_T entry_d), UNUSED(SMB_ACL_PERMSET_T *permset_p)) ++int sys_acl_get_permset( SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p) +{ + errno = ENOSYS; + return -1; +} + -+ void *sys_acl_get_qualifier(UNUSED(SMB_ACL_ENTRY_T entry_d)) ++void *sys_acl_get_qualifier( SMB_ACL_ENTRY_T entry_d) +{ + errno = ENOSYS; + return NULL; +} + -+ SMB_ACL_T sys_acl_get_file(UNUSED(const char *path_p), UNUSED(SMB_ACL_TYPE_T type)) ++SMB_ACL_T sys_acl_get_file( const char *path_p, SMB_ACL_TYPE_T type) +{ + errno = ENOSYS; + return 0; +} + -+ SMB_ACL_T sys_acl_get_fd(UNUSED(int fd)) ++SMB_ACL_T sys_acl_get_fd(int fd) +{ + errno = ENOSYS; + return 0; +} + -+ int sys_acl_clear_perms(UNUSED(SMB_ACL_PERMSET_T permset)) ++int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_add_perm(UNUSED(SMB_ACL_PERMSET_T permset), UNUSED(SMB_ACL_PERM_T perm)) ++int sys_acl_add_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_get_perm(UNUSED(SMB_ACL_PERMSET_T permset), UNUSED(SMB_ACL_PERM_T perm)) ++int sys_acl_get_perm( SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm) +{ + errno = ENOSYS; -+ return permset & perm ? 1 : 0; ++ return (permset & perm) ? 1 : 0; +} + -+ char *sys_acl_to_text(UNUSED(SMB_ACL_T the_acl), UNUSED(ssize_t *plen)) ++char *sys_acl_to_text( SMB_ACL_T the_acl, ssize_t *plen) +{ + errno = ENOSYS; + return NULL; +} + -+ int sys_acl_free_text(UNUSED(char *text)) ++int sys_acl_free_text(char *text) +{ + errno = ENOSYS; + return -1; +} + -+ SMB_ACL_T sys_acl_init(UNUSED(int count)) ++SMB_ACL_T sys_acl_init( int count) +{ + errno = ENOSYS; + return NULL; +} + -+ int sys_acl_create_entry(UNUSED(SMB_ACL_T *pacl), UNUSED(SMB_ACL_ENTRY_T *pentry)) ++int sys_acl_create_entry( SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_set_tag_type(UNUSED(SMB_ACL_ENTRY_T entry), UNUSED(SMB_ACL_TAG_T tagtype)) ++int sys_acl_set_tag_type( SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_set_qualifier(UNUSED(SMB_ACL_ENTRY_T entry), UNUSED(void *qual)) ++int sys_acl_set_qualifier( SMB_ACL_ENTRY_T entry, void *qual) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_set_permset(UNUSED(SMB_ACL_ENTRY_T entry), UNUSED(SMB_ACL_PERMSET_T permset)) ++int sys_acl_set_permset( SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_valid(UNUSED(SMB_ACL_T theacl)) ++int sys_acl_valid( SMB_ACL_T theacl ) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_set_file(UNUSED(const char *name), UNUSED(SMB_ACL_TYPE_T acltype), UNUSED(SMB_ACL_T theacl)) ++int sys_acl_set_file( const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_set_fd(UNUSED(int fd), UNUSED(SMB_ACL_T theacl)) ++int sys_acl_set_fd( int fd, SMB_ACL_T theacl) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_delete_def_file(UNUSED(const char *name)) ++int sys_acl_delete_def_file(const char *name) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_free_acl(UNUSED(SMB_ACL_T the_acl)) ++int sys_acl_free_acl(SMB_ACL_T the_acl) +{ + errno = ENOSYS; + return -1; +} + -+ int sys_acl_free_qualifier(UNUSED(void *qual), UNUSED(SMB_ACL_TAG_T tagtype)) ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype) +{ + errno = ENOSYS; + return -1; +} + +#endif /* No ACLs. */ +--- orig/lib/sysacls.h 2004-10-20 08:06:45 ++++ lib/sysacls.h 2004-10-20 08:06:45 +@@ -0,0 +1,24 @@ ++#define Realloc(mem, cnt) realloc_array((mem), char, (cnt)) ++ ++int sys_acl_get_entry(SMB_ACL_T the_acl, 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_permset(SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p); ++void *sys_acl_get_qualifier(SMB_ACL_ENTRY_T entry_d); ++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); ++int sys_acl_clear_perms(SMB_ACL_PERMSET_T permset); ++int sys_acl_add_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); ++int sys_acl_get_perm(SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm); ++char *sys_acl_to_text(SMB_ACL_T the_acl, ssize_t *plen); ++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_set_tag_type(SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype); ++int sys_acl_set_qualifier(SMB_ACL_ENTRY_T entry, void *qual); ++int sys_acl_set_permset(SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset); ++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_fd(int fd, SMB_ACL_T theacl); ++int sys_acl_delete_def_file(const char *name); ++int sys_acl_free_text(char *text); ++int sys_acl_free_acl(SMB_ACL_T the_acl); ++int sys_acl_free_qualifier(void *qual, SMB_ACL_TAG_T tagtype); +--- orig/mkproto.awk 2004-01-01 21:10:50 ++++ mkproto.awk 2004-10-20 08:03:05 +@@ -58,7 +58,7 @@ BEGIN { + next; + } + +-!/^OFF_T|^size_t|^off_t|^pid_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^const/ { ++!/^OFF_T|^size_t|^off_t|^pid_t|id_t|^unsigned|^mode_t|^DIR|^user|^int|^char|^uint|^struct|^BOOL|^void|^time|^const/ { + next; + } + +--- orig/options.c 2004-10-14 17:11:40 ++++ options.c 2004-08-19 17:38:57 +@@ -43,6 +43,7 @@ int keep_dirlinks = 0; + int copy_links = 0; + int preserve_links = 0; + int preserve_hard_links = 0; ++int preserve_acls = 0; + int preserve_perms = 0; + int preserve_devices = 0; + int preserve_uid = 0; +@@ -152,6 +153,7 @@ static void print_rsync_version(enum log + char const *got_socketpair = "no "; + char const *have_inplace = "no "; + char const *hardlinks = "no "; ++ char const *acls = "no "; + char const *links = "no "; + char const *ipv6 = "no "; + STRUCT_STAT *dumstat; +@@ -168,6 +170,10 @@ static void print_rsync_version(enum log + hardlinks = ""; + #endif + ++#if SUPPORT_ACLS ++ acls = ""; ++#endif ++ + #if SUPPORT_LINKS + links = ""; + #endif +@@ -182,9 +188,9 @@ static void print_rsync_version(enum log + "Copyright (C) 1996-2004 by Andrew Tridgell and others\n"); + rprintf(f, "\n"); + rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, " +- "%shard links, %ssymlinks, batchfiles, \n", ++ "%shard links, %sACLs, %ssymlinks, batchfiles, \n", + (int) (sizeof (OFF_T) * 8), +- got_socketpair, hardlinks, links); ++ got_socketpair, hardlinks, acls, links); + + /* Note that this field may not have type ino_t. It depends + * on the complicated interaction between largefile feature +@@ -249,6 +255,7 @@ void usage(enum logcode F) + rprintf(F," --safe-links ignore \"unsafe\" symlinks\n"); + rprintf(F," -H, --hard-links preserve hard links\n"); + rprintf(F," -p, --perms preserve permissions\n"); ++ rprintf(F," -A, --acls preserve ACLs (implies --perms)\n"); + rprintf(F," -o, --owner preserve owner (root only)\n"); + rprintf(F," -g, --group preserve group\n"); + rprintf(F," -D, --devices preserve devices (root only)\n"); +@@ -351,6 +358,7 @@ static struct poptOption long_options[] + {"no-whole-file", 0, POPT_ARG_VAL, &whole_file, 0, 0, 0 }, + {"copy-unsafe-links", 0, POPT_ARG_NONE, ©_unsafe_links, 0, 0, 0 }, + {"perms", 'p', POPT_ARG_NONE, &preserve_perms, 0, 0, 0 }, ++ {"acls", 'A', POPT_ARG_NONE, 0, 'A', 0, 0 }, + {"owner", 'o', POPT_ARG_NONE, &preserve_uid, 0, 0, 0 }, + {"group", 'g', POPT_ARG_NONE, &preserve_gid, 0, 0, 0 }, + {"devices", 'D', POPT_ARG_NONE, &preserve_devices, 0, 0, 0 }, +@@ -683,6 +691,24 @@ int parse_arguments(int *argc, const cha + return 0; + #endif + ++ case 'A': ++#if SUPPORT_ACLS ++ preserve_acls = 1; ++ preserve_perms = 1; ++#else ++ /* FIXME: this should probably be ignored with a ++ * warning and then countermeasures taken to ++ * restrict group and other access in the presence ++ * of any more restrictive ACLs, but this is safe ++ * for now */ ++ snprintf(err_buf,sizeof(err_buf), ++ "ACLs are not supported on this %s\n", ++ am_server ? "server" : "client"); ++ return 0; ++#endif /* SUPPORT_ACLS */ ++ break; ++ ++ + default: + /* A large opt value means that set_refuse_options() + * turned this option off (opt-BASE is its index). */ +@@ -999,6 +1025,8 @@ void server_options(char **args,int *arg + + if (preserve_hard_links) + argstr[x++] = 'H'; ++ if (preserve_acls) ++ argstr[x++] = 'A'; + if (preserve_uid) + argstr[x++] = 'o'; + if (preserve_gid) +--- orig/rsync.c 2004-09-07 21:45:30 ++++ rsync.c 2004-07-03 20:11:58 +@@ -207,6 +207,14 @@ int set_perms(char *fname,struct file_st + } + #endif + ++ /* If this is a directory, SET_ACL() will be called on the cleanup ++ * receive_generator() pass--if we called it here, we might clobber ++ * writability on the directory. everything else is OK to do now. */ ++ if (!S_ISDIR(st->st_mode)) { ++ if (SET_ACL(fname, file) == 0) ++ updated = 1; ++ } ++ + if (verbose > 1 && flags & PERMS_REPORT) { + if (updated) + rprintf(FINFO,"%s\n",fname); +--- orig/rsync.h 2004-10-09 03:21:56 ++++ rsync.h 2004-07-03 20:11:58 +@@ -545,6 +545,40 @@ static inline int flist_up(struct file_l + #include "lib/permstring.h" + #include "lib/addrinfo.h" + ++#define SUPPORT_ACLS HAVE_POSIX_ACLS|HAVE_UNIXWARE_ACLS|HAVE_SOLARIS_ACLS|\ ++ HAVE_HPUX_ACLS|HAVE_IRIX_ACLS|HAVE_AIX_ACLS|HAVE_TRU64_ACLS ++ ++#define ACLS_NEED_MASK HAVE_UNIXWARE_ACLS|HAVE_SOLARIS_ACLS|HAVE_HPUX_ACLS ++ ++#if SUPPORT_ACLS ++#ifdef HAVE_SYS_ACL_H ++#include ++#endif ++#define MAKE_ACL(file, fname) make_acl(file, fname) ++#define SEND_ACL(file, f) send_acl(file, f) ++#define RECEIVE_ACL(file, f) receive_acl(file, f) ++#define SORT_FILE_ACL_INDEX_LISTS() sort_file_acl_index_lists() ++#define SET_ACL(fname, file) set_acl(fname, file) ++#define NEXT_ACL_UID() next_acl_uid() ++#define ACL_UID_MAP(uid) acl_uid_map(uid) ++#define PUSH_KEEP_BACKUP_ACL(file, orig, dest) \ ++ push_keep_backup_acl(file, orig, dest) ++#define CLEANUP_KEEP_BACKUP_ACL() cleanup_keep_backup_acl() ++#define DUP_ACL(orig, dest, mode) dup_acl(orig, dest, mode) ++#else /* SUPPORT_ACLS */ ++#define MAKE_ACL(file, fname) 1 /* checked return value */ ++#define SEND_ACL(file, f) ++#define RECEIVE_ACL(file, f) ++#define SORT_FILE_ACL_INDEX_LISTS() ++#define SET_ACL(fname, file) 0 /* checked return value */ ++#define NEXT_ACL_UID() ++#define ACL_UID_MAP(uid) ++#define PUSH_KEEP_BACKUP_ACL(file, orig, dest) ++#define CLEANUP_KEEP_BACKUP_ACL() ++#define DUP_ACL(src, orig, mode) 0 /* checked return value */ ++#endif /* SUPPORT_ACLS */ ++#include "smb_acls.h" ++ + #include "proto.h" + + /* We have replacement versions of these if they're missing. */ +--- orig/rsync.yo 2004-10-06 00:12:16 ++++ rsync.yo 2004-07-03 20:11:58 +@@ -326,6 +326,7 @@ verb( + --safe-links ignore "unsafe" symlinks + -H, --hard-links preserve hard links + -p, --perms preserve permissions ++ -A, --acls preserve ACLs (implies -p) [local option] + -o, --owner preserve owner (root only) + -g, --group preserve group + -D, --devices preserve devices (root only) +@@ -585,6 +586,11 @@ source file's permissions and the umask + other files (including updated files) retain their existing permissions + (which is the same behavior as other file-copy utilities, such as cp). + ++dit(bf(-A, --acls)) This option causes rsync to update the remote ++ACLs to be the same as the local ACLs. This will work only if the ++remote machine's rsync supports this option also. This is a non-standard ++option. ++ + dit(bf(-o, --owner)) This option causes rsync to set the owner of the + destination file to be the same as the source file. On most systems, + only the super-user can set file ownership. By default, the preservation +--- orig/smb_acls.h 2004-06-30 00:04:07 ++++ smb_acls.h 2004-06-30 00:04:07 +@@ -0,0 +1,277 @@ ++/* ++ Unix SMB/Netbios implementation. ++ Version 2.2.x ++ Portable SMB ACL interface ++ Copyright (C) Jeremy Allison 2000 ++ ++ 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 2 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, write to the Free Software ++ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++*/ ++ ++#ifndef _SMB_ACLS_H ++#define _SMB_ACLS_H ++ ++#if defined(HAVE_POSIX_ACLS) ++ ++/* This is an identity mapping (just remove the SMB_). */ ++ ++#define SMB_ACL_TAG_T acl_tag_t ++#define SMB_ACL_TYPE_T acl_type_t ++#define SMB_ACL_PERMSET_T acl_permset_t ++#define SMB_ACL_PERM_T acl_perm_t ++#define SMB_ACL_READ ACL_READ ++#define SMB_ACL_WRITE ACL_WRITE ++#define SMB_ACL_EXECUTE ACL_EXECUTE ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER ACL_USER ++#define SMB_ACL_USER_OBJ ACL_USER_OBJ ++#define SMB_ACL_GROUP ACL_GROUP ++#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ ++#define SMB_ACL_OTHER ACL_OTHER ++#define SMB_ACL_MASK ACL_MASK ++ ++#define SMB_ACL_T acl_t ++ ++#define SMB_ACL_ENTRY_T acl_entry_t ++ ++#define SMB_ACL_FIRST_ENTRY ACL_FIRST_ENTRY ++#define SMB_ACL_NEXT_ENTRY ACL_NEXT_ENTRY ++ ++#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS ++#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT ++ ++#elif defined(HAVE_TRU64_ACLS) ++ ++/* This is for DEC/Compaq Tru64 UNIX */ ++ ++#define SMB_ACL_TAG_T acl_tag_t ++#define SMB_ACL_TYPE_T acl_type_t ++#define SMB_ACL_PERMSET_T acl_permset_t ++#define SMB_ACL_PERM_T acl_perm_t ++#define SMB_ACL_READ ACL_READ ++#define SMB_ACL_WRITE ACL_WRITE ++#define SMB_ACL_EXECUTE ACL_EXECUTE ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER ACL_USER ++#define SMB_ACL_USER_OBJ ACL_USER_OBJ ++#define SMB_ACL_GROUP ACL_GROUP ++#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ ++#define SMB_ACL_OTHER ACL_OTHER ++#define SMB_ACL_MASK ACL_MASK ++ ++#define SMB_ACL_T acl_t ++ ++#define SMB_ACL_ENTRY_T acl_entry_t ++ ++#define SMB_ACL_FIRST_ENTRY 0 ++#define SMB_ACL_NEXT_ENTRY 1 ++ ++#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS ++#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT ++ ++#elif defined(HAVE_UNIXWARE_ACLS) || defined(HAVE_SOLARIS_ACLS) ++/* ++ * Donated by Michael Davidson for UnixWare / OpenUNIX. ++ * Modified by Toomas Soome for Solaris. ++ */ ++ ++/* SVR4.2 ES/MP ACLs */ ++typedef int SMB_ACL_TAG_T; ++typedef int SMB_ACL_TYPE_T; ++typedef ushort *SMB_ACL_PERMSET_T; ++typedef ushort SMB_ACL_PERM_T; ++#define SMB_ACL_READ 4 ++#define SMB_ACL_WRITE 2 ++#define SMB_ACL_EXECUTE 1 ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER USER ++#define SMB_ACL_USER_OBJ USER_OBJ ++#define SMB_ACL_GROUP GROUP ++#define SMB_ACL_GROUP_OBJ GROUP_OBJ ++#define SMB_ACL_OTHER OTHER_OBJ ++#define SMB_ACL_MASK CLASS_OBJ ++ ++typedef struct SMB_ACL_T { ++ int size; ++ int count; ++ int next; ++ struct acl acl[1]; ++} *SMB_ACL_T; ++ ++typedef struct acl *SMB_ACL_ENTRY_T; ++ ++#define SMB_ACL_FIRST_ENTRY 0 ++#define SMB_ACL_NEXT_ENTRY 1 ++ ++#define SMB_ACL_TYPE_ACCESS 0 ++#define SMB_ACL_TYPE_DEFAULT 1 ++ ++#elif defined(HAVE_HPUX_ACLS) ++ ++/* ++ * Based on the Solaris & UnixWare code. ++ */ ++ ++#undef GROUP ++#include ++ ++/* SVR4.2 ES/MP ACLs */ ++typedef int SMB_ACL_TAG_T; ++typedef int SMB_ACL_TYPE_T; ++typedef ushort *SMB_ACL_PERMSET_T; ++typedef ushort SMB_ACL_PERM_T; ++#define SMB_ACL_READ 4 ++#define SMB_ACL_WRITE 2 ++#define SMB_ACL_EXECUTE 1 ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER USER ++#define SMB_ACL_USER_OBJ USER_OBJ ++#define SMB_ACL_GROUP GROUP ++#define SMB_ACL_GROUP_OBJ GROUP_OBJ ++#define SMB_ACL_OTHER OTHER_OBJ ++#define SMB_ACL_MASK CLASS_OBJ ++ ++typedef struct SMB_ACL_T { ++ int size; ++ int count; ++ int next; ++ struct acl acl[1]; ++} *SMB_ACL_T; ++ ++typedef struct acl *SMB_ACL_ENTRY_T; ++ ++#define SMB_ACL_FIRST_ENTRY 0 ++#define SMB_ACL_NEXT_ENTRY 1 ++ ++#define SMB_ACL_TYPE_ACCESS 0 ++#define SMB_ACL_TYPE_DEFAULT 1 ++ ++#elif defined(HAVE_IRIX_ACLS) ++ ++#define SMB_ACL_TAG_T acl_tag_t ++#define SMB_ACL_TYPE_T acl_type_t ++#define SMB_ACL_PERMSET_T acl_permset_t ++#define SMB_ACL_PERM_T acl_perm_t ++#define SMB_ACL_READ ACL_READ ++#define SMB_ACL_WRITE ACL_WRITE ++#define SMB_ACL_EXECUTE ACL_EXECUTE ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER ACL_USER ++#define SMB_ACL_USER_OBJ ACL_USER_OBJ ++#define SMB_ACL_GROUP ACL_GROUP ++#define SMB_ACL_GROUP_OBJ ACL_GROUP_OBJ ++#define SMB_ACL_OTHER ACL_OTHER_OBJ ++#define SMB_ACL_MASK ACL_MASK ++ ++typedef struct SMB_ACL_T { ++ int next; ++ BOOL freeaclp; ++ struct acl *aclp; ++} *SMB_ACL_T; ++ ++#define SMB_ACL_ENTRY_T acl_entry_t ++ ++#define SMB_ACL_FIRST_ENTRY 0 ++#define SMB_ACL_NEXT_ENTRY 1 ++ ++#define SMB_ACL_TYPE_ACCESS ACL_TYPE_ACCESS ++#define SMB_ACL_TYPE_DEFAULT ACL_TYPE_DEFAULT ++ ++#elif defined(HAVE_AIX_ACLS) ++ ++/* Donated by Medha Date, mdate@austin.ibm.com, for IBM */ ++ ++#include "/usr/include/acl.h" ++ ++typedef uint *SMB_ACL_PERMSET_T; ++ ++struct acl_entry_link{ ++ struct acl_entry_link *prevp; ++ struct new_acl_entry *entryp; ++ struct acl_entry_link *nextp; ++ int count; ++}; ++ ++struct new_acl_entry{ ++ unsigned short ace_len; ++ unsigned short ace_type; ++ unsigned int ace_access; ++ struct ace_id ace_id[1]; ++}; ++ ++#define SMB_ACL_ENTRY_T struct new_acl_entry* ++#define SMB_ACL_T struct acl_entry_link* ++ ++#define SMB_ACL_TAG_T unsigned short ++#define SMB_ACL_TYPE_T int ++#define SMB_ACL_PERM_T uint ++#define SMB_ACL_READ S_IRUSR ++#define SMB_ACL_WRITE S_IWUSR ++#define SMB_ACL_EXECUTE S_IXUSR ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER ACEID_USER ++#define SMB_ACL_USER_OBJ 3 ++#define SMB_ACL_GROUP ACEID_GROUP ++#define SMB_ACL_GROUP_OBJ 4 ++#define SMB_ACL_OTHER 5 ++#define SMB_ACL_MASK 6 ++ ++ ++#define SMB_ACL_FIRST_ENTRY 1 ++#define SMB_ACL_NEXT_ENTRY 2 ++ ++#define SMB_ACL_TYPE_ACCESS 0 ++#define SMB_ACL_TYPE_DEFAULT 1 ++ ++#else /* No ACLs. */ ++ ++/* No ACLS - fake it. */ ++#define SMB_ACL_TAG_T int ++#define SMB_ACL_TYPE_T int ++#define SMB_ACL_PERMSET_T mode_t ++#define SMB_ACL_PERM_T mode_t ++#define SMB_ACL_READ S_IRUSR ++#define SMB_ACL_WRITE S_IWUSR ++#define SMB_ACL_EXECUTE S_IXUSR ++ ++/* Types of ACLs. */ ++#define SMB_ACL_USER 0 ++#define SMB_ACL_USER_OBJ 1 ++#define SMB_ACL_GROUP 2 ++#define SMB_ACL_GROUP_OBJ 3 ++#define SMB_ACL_OTHER 4 ++#define SMB_ACL_MASK 5 ++ ++typedef struct SMB_ACL_T { ++ int dummy; ++} *SMB_ACL_T; ++ ++typedef struct SMB_ACL_ENTRY_T { ++ int dummy; ++} *SMB_ACL_ENTRY_T; ++ ++#define SMB_ACL_FIRST_ENTRY 0 ++#define SMB_ACL_NEXT_ENTRY 1 ++ ++#define SMB_ACL_TYPE_ACCESS 0 ++#define SMB_ACL_TYPE_DEFAULT 1 ++ ++#endif /* No ACLs. */ ++#endif /* _SMB_ACLS_H */ --- orig/uidlist.c 2004-04-29 19:37:25 +++ uidlist.c 2004-07-03 20:11:58 @@ -34,6 +34,7 @@ -- 2.34.1