modules/vfs_aixacl.c

ソースコードを見る。

関数
SMB_ACL_T	aixacl_to_smbacl (struct acl *file_acl)
acl *	aixacl_smb_to_aixacl (SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
SMB_ACL_T	aixacl_sys_acl_get_file (vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
SMB_ACL_T	aixacl_sys_acl_get_fd (vfs_handle_struct *handle, files_struct *fsp, int fd)
int	aixacl_sys_acl_set_file (vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T type, SMB_ACL_T theacl)
int	aixacl_sys_acl_set_fd (vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
int	aixacl_sys_acl_delete_def_file (vfs_handle_struct *handle, const char *path)
NTSTATUS	vfs_aixacl_init (void)
変数
static vfs_op_tuple	aixacl_op_tuples []

---

関数

SMB_ACL_T aixacl_to_smbacl

(

struct acl *

file_acl

)

vfs_aixacl_util.c の 23 行で定義されています。

参照元 aixacl_sys_acl_get_fd()・aixacl_sys_acl_get_file()・aixjfs2_get_posix_acl().

{
        struct acl_entry *acl_entry;
        struct ace_id *idp;
        
        struct smb_acl_t *result = SMB_MALLOC_P(struct smb_acl_t);
        struct smb_acl_entry *ace;
        int i;
        
        if (result == NULL) {
                return NULL;
        }
        ZERO_STRUCTP(result);
        
        /* Point to the first acl entry in the acl */
        acl_entry =  file_acl->acl_ext;


        
        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){
                /* while we are not pointing to the very end */
                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;
                        }

                        idp = acl_entry->ace_id;
                        DEBUG(10,("idp->id_data is %d\n",idp->id_data[0]));
                        
                        result = SMB_REALLOC(result, sizeof(struct smb_acl_t) +
                                     (sizeof(struct smb_acl_entry) *
                                      (result->count+1)));
                        if (result == NULL) {
                                DEBUG(0, ("SMB_REALLOC failed\n"));
                                errno = ENOMEM;
                                return NULL;
                        }
                        

                        DEBUG(10,("idp->id_type is %d\n",idp->id_type));
                        ace = &result->acl[result->count];
                        
                        ace->a_type = idp->id_type;
                                                        
                        switch(ace->a_type) {
                        case ACEID_USER: {
                        ace->uid = idp->id_data[0];
                        DEBUG(10,("case ACEID_USER ace->uid is %d\n",ace->uid));
                        ace->a_type = SMB_ACL_USER;
                        break;
                        }
                
                        case ACEID_GROUP: {
                        ace->gid = idp->id_data[0];
                        DEBUG(10,("case ACEID_GROUP ace->gid is %d\n",ace->gid));
                        ace->a_type = SMB_ACL_GROUP;
                        break;
                        }
                        default:
                                break;
                        }
                        /* 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){
                        case ACC_PERMIT:
                        case ACC_SPECIFY:
                                ace->a_perm = acl_entry->ace_access;
                                ace->a_perm <<= 6;
                                DEBUG(10,("ace->a_perm is %d\n",ace->a_perm));
                                break;
                        case ACC_DENY:
                                /* 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));
                                ace->a_perm = ~acl_entry->ace_access & 7;
                                DEBUG(10,("ace->a_perm is %d\n",ace->a_perm));
                                ace->a_perm <<= 6;
                                break;
                        default:
                                DEBUG(0, ("unknown ace->type\n"));
                                SAFE_FREE(result);
                                return(0);
                        }
                
                        result->count++;
                        ace->a_perm |= (ace->a_perm & S_IRUSR) ? SMB_ACL_READ : 0;
                        ace->a_perm |= (ace->a_perm & S_IWUSR) ? SMB_ACL_WRITE : 0;
                        ace->a_perm |= (ace->a_perm & S_IXUSR) ? SMB_ACL_EXECUTE : 0;
                        DEBUG(10,("ace->a_perm is %d\n",ace->a_perm));
                        
                        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.     */

        for( i = 1; i < 4; i++) {
                DEBUG(10,("i is %d\n",i));

                        result = SMB_REALLOC(result, sizeof(struct smb_acl_t) +
                                     (sizeof(struct smb_acl_entry) *
                                      (result->count+1)));
                        if (result == NULL) {
                                DEBUG(0, ("SMB_REALLOC failed\n"));
                                errno = ENOMEM;
                                DEBUG(0,("Error in AIX sys_acl_get_file is %d\n",errno));
                                return NULL;
                        }
                        
                ace = &result->acl[result->count];
                
                ace->uid = 0;
                ace->gid = 0;
                DEBUG(10,("ace->uid = %d\n",ace->uid));
                
                switch(i) {
                case 2:
                        ace->a_perm = file_acl->g_access << 6;
                        ace->a_type = SMB_ACL_GROUP_OBJ;
                        break;

                case 3:
                        ace->a_perm = file_acl->o_access << 6;
                        ace->a_type = SMB_ACL_OTHER;
                        break;
 
                case 1:
                        ace->a_perm = file_acl->u_access << 6;
                        ace->a_type = SMB_ACL_USER_OBJ;
                        break;
 
                default:
                        return(NULL);

                }
                ace->a_perm |= ((ace->a_perm & S_IRUSR) ? SMB_ACL_READ : 0);
                ace->a_perm |= ((ace->a_perm & S_IWUSR) ? SMB_ACL_WRITE : 0);
                ace->a_perm |= ((ace->a_perm & S_IXUSR) ? SMB_ACL_EXECUTE : 0);
                
                memcpy(&result->acl[result->count],ace,sizeof(struct smb_acl_entry));
                result->count++;
                DEBUG(10,("ace->a_perm = %d\n",ace->a_perm));
                DEBUG(10,("ace->a_type = %d\n",ace->a_type));
        }


        return result;


}

struct acl* aixacl_smb_to_aixacl	(	SMB_ACL_TYPE_T	acltype,
		SMB_ACL_T	theacl
	)

vfs_aixacl_util.c の 206 行で定義されています。

参照元 aixacl_sys_acl_set_fd()・aixacl_sys_acl_set_file()・aixjfs2_sys_acl_set_fd()・aixjfs2_sys_acl_set_file().

{
        struct smb_acl_entry *smb_entry = NULL;
        struct acl *file_acl = NULL;
        struct acl *file_acl_temp = NULL;
        struct acl_entry *acl_entry = NULL;
        struct ace_id *ace_id = NULL;
        uint id_type;
        uint user_id;
        uint acl_length;
        int     i;
 
        DEBUG(10,("Entering aixacl_smb_to_aixacl\n"));
        /* AIX has no default ACL */
        if(acltype == SMB_ACL_TYPE_DEFAULT)
                return NULL;

        acl_length = BUFSIZ;
        file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);
        if(file_acl == NULL) {
                errno = ENOMEM;
                DEBUG(0,("Error in aixacl_smb_to_aixacl is %d\n",errno));
                return NULL;
        }

        memset(file_acl,0,BUFSIZ);
 
        file_acl->acl_len = ACL_SIZ;
        file_acl->acl_mode = S_IXACL;

        for(i=0; i<theacl->count; i++ ) {
                smb_entry = &(theacl->acl[i]);
                id_type = smb_entry->a_type;
                DEBUG(10,("The id_type is %d\n",id_type));

                switch(id_type) {
                        case SMB_ACL_USER_OBJ:
                                file_acl->u_access = aixacl_smb_to_aixperm(smb_entry->a_perm);
                                continue;
                        case SMB_ACL_GROUP_OBJ:
                                file_acl->g_access = aixacl_smb_to_aixperm(smb_entry->a_perm);
                                continue;
                        case SMB_ACL_OTHER:
                                file_acl->o_access = aixacl_smb_to_aixperm(smb_entry->a_perm);
                                continue;
                        case SMB_ACL_MASK:
                                continue;
                        case SMB_ACL_GROUP:
                                break; /* process this */
                        case SMB_ACL_USER:
                                break; /* process this */
                        default: /* abnormal case */
                                DEBUG(10,("The id_type is unknown !\n"));
                                continue;
                }

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

                        memcpy(file_acl_temp,file_acl,file_acl->acl_len);
                        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);
                acl_entry->ace_len = sizeof(struct acl_entry); /* contains 1 ace_id */
                acl_entry->ace_access = aixacl_smb_to_aixperm(smb_entry->a_perm);

                /* 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; */

                acl_entry->ace_type = ACC_SPECIFY;

                ace_id = acl_entry->ace_id;

                ace_id->id_type = (smb_entry->a_type==SMB_ACL_GROUP) ? ACEID_GROUP : ACEID_USER;
                DEBUG(10,("The id type is %d\n",ace_id->id_type));
                ace_id->id_len = sizeof(struct ace_id); /* contains 1 id_data */
                ace_id->id_data[0] = (smb_entry->a_type==SMB_ACL_GROUP) ? smb_entry->gid : smb_entry->uid;
        }

        return file_acl;
}

SMB_ACL_T aixacl_sys_acl_get_file	(	vfs_handle_struct *	handle,
		const char *	path_p,
		SMB_ACL_TYPE_T	type
	)

vfs_aixacl.c の 26 行で定義されています。

参照先 aixacl_to_smbacl()・errno・result.

{
        struct acl *file_acl = (struct acl *)NULL;
        struct smb_acl_t *result = (struct smb_acl_t *)NULL;
        
        int rc = 0;
        uid_t user_id;

        /* AIX has no DEFAULT */
        if  ( type == SMB_ACL_TYPE_DEFAULT )
                return NULL;

        /* Get the acl using statacl */
 
        DEBUG(10,("Entering AIX sys_acl_get_file\n"));
        DEBUG(10,("path_p is %s\n",path_p));

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

        memset(file_acl,0,BUFSIZ);

        rc = statacl((char *)path_p,0,file_acl,BUFSIZ);
        if( (rc == -1) && (errno == ENOSPC)) {
                struct acl *new_acl = SMB_MALLOC(file_acl->acl_len + sizeof(struct acl));
                if( new_acl == NULL) {
                        SAFE_FREE(file_acl);
                        errno = ENOMEM;
                        return NULL;
                }
                file_acl = new_acl;
                rc = statacl((char *)path_p,0,file_acl,file_acl->acl_len+sizeof(struct acl));
                if( rc == -1) {
                        DEBUG(0,("statacl returned %d with errno %d\n",rc,errno));
                        SAFE_FREE(file_acl);
                        return(NULL);
                }
        }

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

        
        result = aixacl_to_smbacl(file_acl);
        SAFE_FREE(file_acl);
        return result;
        
        /*errno = ENOTSUP;
        return NULL;*/
}

SMB_ACL_T aixacl_sys_acl_get_fd	(	vfs_handle_struct *	handle,
		files_struct *	fsp,
		int	fd
	)

vfs_aixacl.c の 83 行で定義されています。

参照先 aixacl_to_smbacl()・errno・result.

{

        struct acl *file_acl = (struct acl *)NULL;
        struct smb_acl_t *result = (struct smb_acl_t *)NULL;
        
        int rc = 0;
        uid_t user_id;

        /* Get the acl using fstatacl */
   
        DEBUG(10,("Entering AIX sys_acl_get_fd\n"));
        DEBUG(10,("fd is %d\n",fd));
        file_acl = (struct acl *)SMB_MALLOC(BUFSIZ);

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

        memset(file_acl,0,BUFSIZ);

        rc = fstatacl(fd,0,file_acl,BUFSIZ);
        if( (rc == -1) && (errno == ENOSPC)) {
                struct acl *new_acl = SMB_MALLOC(file_acl->acl_len + sizeof(struct acl));
                if( new_acl == NULL) {
                        SAFE_FREE(file_acl);
                        errno = ENOMEM;
                        return NULL;
                }
                file_acl = new_acl;
                rc = fstatacl(fd,0,file_acl,file_acl->acl_len + sizeof(struct acl));
                if( rc == -1) {
                        DEBUG(0,("fstatacl returned %d with errno %d\n",rc,errno));
                        SAFE_FREE(file_acl);
                        return(NULL);
                }
        }

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

        result = aixacl_to_smbacl(file_acl);
        SAFE_FREE(file_acl);
        return result;
        
        /*errno = ENOTSUP;
        return NULL;*/
}

int aixacl_sys_acl_set_file	(	vfs_handle_struct *	handle,
		const char *	name,
		SMB_ACL_TYPE_T	type,
		SMB_ACL_T	theacl
	)

vfs_aixacl.c の 135 行で定義されています。

参照先 aixacl_smb_to_aixacl()・errno.

{
        struct acl *file_acl = NULL;
        uint rc;
        
        file_acl = aixacl_smb_to_aixacl(type, theacl);
        if (!file_acl)
                return -1;

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

        return rc;
}

int aixacl_sys_acl_set_fd	(	vfs_handle_struct *	handle,
		files_struct *	fsp,
		int	fd,
		SMB_ACL_T	theacl
	)

vfs_aixacl.c の 156 行で定義されています。

参照先 aixacl_smb_to_aixacl()・errno.

{
        struct acl *file_acl = NULL;
        uint rc;

        file_acl = aixacl_smb_to_aixacl(SMB_ACL_TYPE_ACCESS, theacl);
        if (!file_acl)
                return -1;

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

        return rc;
}

int aixacl_sys_acl_delete_def_file	(	vfs_handle_struct *	handle,
		const char *	path
	)

vfs_aixacl.c の 176 行で定義されています。

{
        return 0; /* otherwise you can't set acl at upper level */
}

NTSTATUS vfs_aixacl_init

(

void

)

vfs_aixacl.c の 212 行で定義されています。

参照先 aixacl_op_tuples・smb_register_vfs().

{
        return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "aixacl",
                                aixacl_op_tuples);
}

---

変数

vfs_op_tuple aixacl_op_tuples[] [static]

初期値:

 {
        
  {SMB_VFS_OP(aixacl_sys_acl_get_file),
   SMB_VFS_OP_SYS_ACL_GET_FILE,
   SMB_VFS_LAYER_TRANSPARENT},

  {SMB_VFS_OP(aixacl_sys_acl_get_fd),
   SMB_VFS_OP_SYS_ACL_GET_FD,
   SMB_VFS_LAYER_TRANSPARENT},

  {SMB_VFS_OP(aixacl_sys_acl_set_file),
   SMB_VFS_OP_SYS_ACL_SET_FILE,
   SMB_VFS_LAYER_TRANSPARENT},

  {SMB_VFS_OP(aixacl_sys_acl_set_fd),
   SMB_VFS_OP_SYS_ACL_SET_FD,
   SMB_VFS_LAYER_TRANSPARENT},

  {SMB_VFS_OP(aixacl_sys_acl_delete_def_file),
   SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
   SMB_VFS_LAYER_TRANSPARENT},

  {SMB_VFS_OP(NULL),
   SMB_VFS_OP_NOOP,
   SMB_VFS_LAYER_NOOP}
}

vfs_aixacl.c の 184 行で定義されています。

参照元 vfs_aixacl_init().

---