source: branches/samba-3.3.x/source/modules/nfs4_acls.c@ 482

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

static SMB_ACL4_INT_T *get_validated_aclint(SMB4ACL_T *theacl)
{
        SMB_ACL4_INT_T *aclint = (SMB_ACL4_INT_T *)theacl;
        if (theacl==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  *theacl = (SMB_ACL4_INT_T *)TALLOC_ZERO_SIZE(mem_ctx, sizeof(SMB_ACL4_INT_T));
        if (theacl==NULL)
        {
                DEBUG(0, ("TALLOC_SIZE failed\n"));
                errno = ENOMEM;
                return NULL;
        }
        theacl->magic = SMB_ACL4_INT_MAGIC;
        /* theacl->first, last = NULL not needed */
        return (SMB4ACL_T *)theacl;
}

SMB4ACE_T *smb_add_ace4(SMB4ACL_T *theacl, SMB_ACE4PROP_T *prop)
{
        SMB_ACL4_INT_T *aclint = get_validated_aclint(theacl);
        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;
}