source: branches/samba-3.2.x/source/modules/nfs4_acls.c@ 579

/*
 * NFS4 ACL handling
 *
 * Copyright (C) Jim McDonough, 2006
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "includes.h"
#include "nfs4_acls.h"

#undef DBGC_CLASS
#define DBGC_CLASS DBGC_ACLS

#define SMBACL4_PARAM_TYPE_NAME "nfs4"

extern const struct generic_mapping file_generic_mapping;

#define SMB_ACE4_INT_MAGIC 0x76F8A967
typedef struct _SMB_ACE4_INT_T
{
        uint32  magic;
        SMB_ACE4PROP_T  prop;
        void    *next;
} SMB_ACE4_INT_T;

#define SMB_ACL4_INT_MAGIC 0x29A3E792
typedef struct _SMB_ACL4_INT_T
{
        uint32  magic;
        uint32  naces;
        SMB_ACE4_INT_T  *first;
        SMB_ACE4_INT_T  *last;
} SMB_ACL4_INT_T;

extern struct current_user current_user;
extern int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_t gid);
extern NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp,
        uint32 security_info_sent, SEC_DESC *psd);

static SMB_ACL4_INT_T *get_validated_aclint(SMB4ACL_T *acl)
{
        SMB_ACL4_INT_T *aclint = (SMB_ACL4_INT_T *)acl;
        if (acl==NULL)
        {
                DEBUG(2, ("acl is NULL\n"));
                errno = EINVAL;
                return NULL;
        }
        if (aclint->magic!=SMB_ACL4_INT_MAGIC)
        {
                DEBUG(2, ("aclint bad magic 0x%x\n", aclint->magic));
                errno = EINVAL;
                return NULL;
        }
        return aclint;
}

static SMB_ACE4_INT_T *get_validated_aceint(SMB4ACE_T *ace)
{
        SMB_ACE4_INT_T *aceint = (SMB_ACE4_INT_T *)ace;
        if (ace==NULL)
        {
                DEBUG(2, ("ace is NULL\n"));
                errno = EINVAL;
                return NULL;
        }
        if (aceint->magic!=SMB_ACE4_INT_MAGIC)
        {
                DEBUG(2, ("aceint bad magic 0x%x\n", aceint->magic));
                errno = EINVAL;
                return NULL;
        }
        return aceint;
}

SMB4ACL_T *smb_create_smb4acl(void)
{
        TALLOC_CTX *mem_ctx = talloc_tos();
        SMB_ACL4_INT_T  *acl = (SMB_ACL4_INT_T *)TALLOC_ZERO_SIZE(mem_ctx, sizeof(SMB_ACL4_INT_T));
        if (acl==NULL)
        {
                DEBUG(0, ("TALLOC_SIZE failed\n"));
                errno = ENOMEM;
                return NULL;
        }
        acl->magic = SMB_ACL4_INT_MAGIC;
        /* acl->first, last = NULL not needed */
        return (SMB4ACL_T *)acl;
}

SMB4ACE_T *smb_add_ace4(SMB4ACL_T *acl, SMB_ACE4PROP_T *prop)
{
        SMB_ACL4_INT_T *aclint = get_validated_aclint(acl);
        TALLOC_CTX *mem_ctx = talloc_tos();
        SMB_ACE4_INT_T *ace;

        ace = (SMB_ACE4_INT_T *)TALLOC_ZERO_SIZE(mem_ctx, sizeof(SMB_ACE4_INT_T));
        if (ace==NULL)
        {
                DEBUG(0, ("TALLOC_SIZE failed\n"));
                errno = ENOMEM;
                return NULL;
        }
        ace->magic = SMB_ACE4_INT_MAGIC;
        /* ace->next = NULL not needed */
        memcpy(&ace->prop, prop, sizeof(SMB_ACE4PROP_T));

        if (aclint->first==NULL)
        {
                aclint->first = ace;
                aclint->last = ace;
        } else {
                aclint->last->next = (void *)ace;
                aclint->last = ace;
        }
        aclint->naces++;

        return (SMB4ACE_T *)ace;
}

SMB_ACE4PROP_T *smb_get_ace4(SMB4ACE_T *ace)
{
        SMB_ACE4_INT_T *aceint = get_validated_aceint(ace);
        if (aceint==NULL)
                return NULL;

        return &aceint->prop;
}

SMB4ACE_T *smb_next_ace4(SMB4ACE_T *ace)
{
        SMB_ACE4_INT_T *aceint = get_validated_aceint(ace);
        if (aceint==NULL)
                return NULL;

        return (SMB4ACE_T *)aceint->next;
}

SMB4ACE_T *smb_first_ace4(SMB4ACL_T *acl)
{
        SMB_ACL4_INT_T *aclint = get_validated_aclint(acl);
        if (aclint==NULL)
                return NULL;

        return (SMB4ACE_T *)aclint->first;
}

uint32 smb_get_naces(SMB4ACL_T *acl)
{
        SMB_ACL4_INT_T *aclint = get_validated_aclint(acl);
        if (aclint==NULL)
                return 0;

        return aclint->naces;
}

static int smbacl4_GetFileOwner(struct connection_struct *conn,
                                const char *filename,
                                SMB_STRUCT_STAT *psbuf)
{
        memset(psbuf, 0, sizeof(SMB_STRUCT_STAT));

        /* Get the stat struct for the owner info. */
        if (SMB_VFS_STAT(conn, filename, psbuf) != 0)
        {
                DEBUG(8, ("SMB_VFS_STAT failed with error %s\n",
                        strerror(errno)));
                return -1;
        }

        return 0;