LXR linux/fs/nfsd/nfs2acl.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Process version 2 NFSACL requests.
   4 *
   5 * Copyright (C) 2002-2003 Andreas Gruenbacher <agruen@suse.de>
   6 */
   7
   8#include "nfsd.h"
   9/* FIXME: nfsacl.h is a broken header */
  10#include <linux/nfsacl.h>
  11#include <linux/gfp.h>
  12#include "cache.h"
  13#include "xdr3.h"
  14#include "vfs.h"
  15
  16#define NFSDDBG_FACILITY                NFSDDBG_PROC
  17
  18/*
  19 * NULL call.
  20 */
  21static __be32
  22nfsacld_proc_null(struct svc_rqst *rqstp)
  23{
  24        return rpc_success;
  25}
  26
  27/*
  28 * Get the Access and/or Default ACL of a file.
  29 */
  30static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
  31{
  32        struct nfsd3_getaclargs *argp = rqstp->rq_argp;
  33        struct nfsd3_getaclres *resp = rqstp->rq_resp;
  34        struct posix_acl *acl;
  35        struct inode *inode;
  36        svc_fh *fh;
  37
  38        dprintk("nfsd: GETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));
  39
  40        fh = fh_copy(&resp->fh, &argp->fh);
  41        resp->status = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
  42        if (resp->status != nfs_ok)
  43                goto out;
  44
  45        inode = d_inode(fh->fh_dentry);
  46
  47        if (argp->mask & ~NFS_ACL_MASK) {
  48                resp->status = nfserr_inval;
  49                goto out;
  50        }
  51        resp->mask = argp->mask;
  52
  53        resp->status = fh_getattr(fh, &resp->stat);
  54        if (resp->status != nfs_ok)
  55                goto out;
  56
  57        if (resp->mask & (NFS_ACL|NFS_ACLCNT)) {
  58                acl = get_acl(inode, ACL_TYPE_ACCESS);
  59                if (acl == NULL) {
  60                        /* Solaris returns the inode's minimum ACL. */
  61                        acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
  62                }
  63                if (IS_ERR(acl)) {
  64                        resp->status = nfserrno(PTR_ERR(acl));
  65                        goto fail;
  66                }
  67                resp->acl_access = acl;
  68        }
  69        if (resp->mask & (NFS_DFACL|NFS_DFACLCNT)) {
  70                /* Check how Solaris handles requests for the Default ACL
  71                   of a non-directory! */
  72                acl = get_acl(inode, ACL_TYPE_DEFAULT);
  73                if (IS_ERR(acl)) {
  74                        resp->status = nfserrno(PTR_ERR(acl));
  75                        goto fail;
  76                }
  77                resp->acl_default = acl;
  78        }
  79
  80        /* resp->acl_{access,default} are released in nfssvc_release_getacl. */
  81out:
  82        return rpc_success;
  83
  84fail:
  85        posix_acl_release(resp->acl_access);
  86        posix_acl_release(resp->acl_default);
  87        goto out;
  88}
  89
  90/*
  91 * Set the Access and/or Default ACL of a file.
  92 */
  93static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
  94{
  95        struct nfsd3_setaclargs *argp = rqstp->rq_argp;
  96        struct nfsd_attrstat *resp = rqstp->rq_resp;
  97        struct inode *inode;
  98        svc_fh *fh;
  99        int error;
 100
 101        dprintk("nfsd: SETACL(2acl)   %s\n", SVCFH_fmt(&argp->fh));
 102
 103        fh = fh_copy(&resp->fh, &argp->fh);
 104        resp->status = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_SATTR);
 105        if (resp->status != nfs_ok)
 106                goto out;
 107
 108        inode = d_inode(fh->fh_dentry);
 109
 110        error = fh_want_write(fh);
 111        if (error)
 112                goto out_errno;
 113
 114        fh_lock(fh);
 115
 116        error = set_posix_acl(inode, ACL_TYPE_ACCESS, argp->acl_access);
 117        if (error)
 118                goto out_drop_lock;
 119        error = set_posix_acl(inode, ACL_TYPE_DEFAULT, argp->acl_default);
 120        if (error)
 121                goto out_drop_lock;
 122
 123        fh_unlock(fh);
 124
 125        fh_drop_write(fh);
 126
 127        resp->status = fh_getattr(fh, &resp->stat);
 128
 129out:
 130        /* argp->acl_{access,default} may have been allocated in
 131           nfssvc_decode_setaclargs. */
 132        posix_acl_release(argp->acl_access);
 133        posix_acl_release(argp->acl_default);
 134        return rpc_success;
 135
 136out_drop_lock:
 137        fh_unlock(fh);
 138        fh_drop_write(fh);
 139out_errno:
 140        resp->status = nfserrno(error);
 141        goto out;
 142}
 143
 144/*
 145 * Check file attributes
 146 */
 147static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
 148{
 149        struct nfsd_fhandle *argp = rqstp->rq_argp;
 150        struct nfsd_attrstat *resp = rqstp->rq_resp;
 151
 152        dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 153
 154        fh_copy(&resp->fh, &argp->fh);
 155        resp->status = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
 156        if (resp->status != nfs_ok)
 157                goto out;
 158        resp->status = fh_getattr(&resp->fh, &resp->stat);
 159out:
 160        return rpc_success;
 161}
 162
 163/*
 164 * Check file access
 165 */
 166static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
 167{
 168        struct nfsd3_accessargs *argp = rqstp->rq_argp;
 169        struct nfsd3_accessres *resp = rqstp->rq_resp;
 170
 171        dprintk("nfsd: ACCESS(2acl)   %s 0x%x\n",
 172                        SVCFH_fmt(&argp->fh),
 173                        argp->access);
 174
 175        fh_copy(&resp->fh, &argp->fh);
 176        resp->access = argp->access;
 177        resp->status = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
 178        if (resp->status != nfs_ok)
 179                goto out;
 180        resp->status = fh_getattr(&resp->fh, &resp->stat);
 181out:
 182        return rpc_success;
 183}
 184
 185/*
 186 * XDR decode functions
 187 */
 188
 189static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
 190{
 191        struct nfsd3_getaclargs *argp = rqstp->rq_argp;
 192
 193        p = nfs2svc_decode_fh(p, &argp->fh);
 194        if (!p)
 195                return 0;
 196        argp->mask = ntohl(*p); p++;
 197
 198        return xdr_argsize_check(rqstp, p);
 199}
 200
 201
 202static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
 203{
 204        struct nfsd3_setaclargs *argp = rqstp->rq_argp;
 205        struct kvec *head = rqstp->rq_arg.head;
 206        unsigned int base;
 207        int n;
 208
 209        p = nfs2svc_decode_fh(p, &argp->fh);
 210        if (!p)
 211                return 0;
 212        argp->mask = ntohl(*p++);
 213        if (argp->mask & ~NFS_ACL_MASK ||
 214            !xdr_argsize_check(rqstp, p))
 215                return 0;
 216
 217        base = (char *)p - (char *)head->iov_base;
 218        n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
 219                          (argp->mask & NFS_ACL) ?
 220                          &argp->acl_access : NULL);
 221        if (n > 0)
 222                n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
 223                                  (argp->mask & NFS_DFACL) ?
 224                                  &argp->acl_default : NULL);
 225        return (n > 0);
 226}
 227
 228static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p)
 229{
 230        struct nfsd_fhandle *argp = rqstp->rq_argp;
 231
 232        p = nfs2svc_decode_fh(p, &argp->fh);
 233        if (!p)
 234                return 0;
 235        return xdr_argsize_check(rqstp, p);
 236}
 237
 238static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
 239{
 240        struct nfsd3_accessargs *argp = rqstp->rq_argp;
 241
 242        p = nfs2svc_decode_fh(p, &argp->fh);
 243        if (!p)
 244                return 0;
 245        argp->access = ntohl(*p++);
 246
 247        return xdr_argsize_check(rqstp, p);
 248}
 249
 250/*
 251 * XDR encode functions
 252 */
 253
 254/* GETACL */
 255static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
 256{
 257        struct nfsd3_getaclres *resp = rqstp->rq_resp;
 258        struct dentry *dentry = resp->fh.fh_dentry;
 259        struct inode *inode;
 260        struct kvec *head = rqstp->rq_res.head;
 261        unsigned int base;
 262        int n;
 263        int w;
 264
 265        *p++ = resp->status;
 266        if (resp->status != nfs_ok)
 267                return xdr_ressize_check(rqstp, p);
 268
 269        /*
 270         * Since this is version 2, the check for nfserr in
 271         * nfsd_dispatch actually ensures the following cannot happen.
 272         * However, it seems fragile to depend on that.
 273         */
 274        if (dentry == NULL || d_really_is_negative(dentry))
 275                return 0;
 276        inode = d_inode(dentry);
 277
 278        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 279        *p++ = htonl(resp->mask);
 280        if (!xdr_ressize_check(rqstp, p))
 281                return 0;
 282        base = (char *)p - (char *)head->iov_base;
 283
 284        rqstp->rq_res.page_len = w = nfsacl_size(
 285                (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
 286                (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
 287        while (w > 0) {
 288                if (!*(rqstp->rq_next_page++))
 289                        return 0;
 290                w -= PAGE_SIZE;
 291        }
 292
 293        n = nfsacl_encode(&rqstp->rq_res, base, inode,
 294                          resp->acl_access,
 295                          resp->mask & NFS_ACL, 0);
 296        if (n > 0)
 297                n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
 298                                  resp->acl_default,
 299                                  resp->mask & NFS_DFACL,
 300                                  NFS_ACL_DEFAULT);
 301        return (n > 0);
 302}
 303
 304static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p)
 305{
 306        struct nfsd_attrstat *resp = rqstp->rq_resp;
 307
 308        *p++ = resp->status;
 309        if (resp->status != nfs_ok)
 310                goto out;
 311
 312        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 313out:
 314        return xdr_ressize_check(rqstp, p);
 315}
 316
 317/* ACCESS */
 318static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
 319{
 320        struct nfsd3_accessres *resp = rqstp->rq_resp;
 321
 322        *p++ = resp->status;
 323        if (resp->status != nfs_ok)
 324                goto out;
 325
 326        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 327        *p++ = htonl(resp->access);
 328out:
 329        return xdr_ressize_check(rqstp, p);
 330}
 331
 332/*
 333 * XDR release functions
 334 */
 335static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
 336{
 337        struct nfsd3_getaclres *resp = rqstp->rq_resp;
 338
 339        fh_put(&resp->fh);
 340        posix_acl_release(resp->acl_access);
 341        posix_acl_release(resp->acl_default);
 342}
 343
 344static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
 345{
 346        struct nfsd_attrstat *resp = rqstp->rq_resp;
 347
 348        fh_put(&resp->fh);
 349}
 350
 351static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
 352{
 353        struct nfsd3_accessres *resp = rqstp->rq_resp;
 354
 355        fh_put(&resp->fh);
 356}
 357
 358struct nfsd3_voidargs { int dummy; };
 359
 360#define ST 1            /* status*/
 361#define AT 21           /* attributes */
 362#define pAT (1+AT)      /* post attributes - conditional */
 363#define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */
 364
 365static const struct svc_procedure nfsd_acl_procedures2[5] = {
 366        [ACLPROC2_NULL] = {
 367                .pc_func = nfsacld_proc_null,
 368                .pc_decode = nfssvc_decode_voidarg,
 369                .pc_encode = nfssvc_encode_voidres,
 370                .pc_argsize = sizeof(struct nfsd_voidargs),
 371                .pc_ressize = sizeof(struct nfsd_voidres),
 372                .pc_cachetype = RC_NOCACHE,
 373                .pc_xdrressize = ST,
 374        },
 375        [ACLPROC2_GETACL] = {
 376                .pc_func = nfsacld_proc_getacl,
 377                .pc_decode = nfsaclsvc_decode_getaclargs,
 378                .pc_encode = nfsaclsvc_encode_getaclres,
 379                .pc_release = nfsaclsvc_release_getacl,
 380                .pc_argsize = sizeof(struct nfsd3_getaclargs),
 381                .pc_ressize = sizeof(struct nfsd3_getaclres),
 382                .pc_cachetype = RC_NOCACHE,
 383                .pc_xdrressize = ST+1+2*(1+ACL),
 384        },
 385        [ACLPROC2_SETACL] = {
 386                .pc_func = nfsacld_proc_setacl,
 387                .pc_decode = nfsaclsvc_decode_setaclargs,
 388                .pc_encode = nfsaclsvc_encode_attrstatres,
 389                .pc_release = nfsaclsvc_release_attrstat,
 390                .pc_argsize = sizeof(struct nfsd3_setaclargs),
 391                .pc_ressize = sizeof(struct nfsd_attrstat),
 392                .pc_cachetype = RC_NOCACHE,
 393                .pc_xdrressize = ST+AT,
 394        },
 395        [ACLPROC2_GETATTR] = {
 396                .pc_func = nfsacld_proc_getattr,
 397                .pc_decode = nfsaclsvc_decode_fhandleargs,
 398                .pc_encode = nfsaclsvc_encode_attrstatres,
 399                .pc_release = nfsaclsvc_release_attrstat,
 400                .pc_argsize = sizeof(struct nfsd_fhandle),
 401                .pc_ressize = sizeof(struct nfsd_attrstat),
 402                .pc_cachetype = RC_NOCACHE,
 403                .pc_xdrressize = ST+AT,
 404        },
 405        [ACLPROC2_ACCESS] = {
 406                .pc_func = nfsacld_proc_access,
 407                .pc_decode = nfsaclsvc_decode_accessargs,
 408                .pc_encode = nfsaclsvc_encode_accessres,
 409                .pc_release = nfsaclsvc_release_access,
 410                .pc_argsize = sizeof(struct nfsd3_accessargs),
 411                .pc_ressize = sizeof(struct nfsd3_accessres),
 412                .pc_cachetype = RC_NOCACHE,
 413                .pc_xdrressize = ST+AT+1,
 414        },
 415};
 416
 417static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
 418const struct svc_version nfsd_acl_version2 = {
 419        .vs_vers        = 2,
 420        .vs_nproc       = 5,
 421        .vs_proc        = nfsd_acl_procedures2,
 422        .vs_count       = nfsd_acl_count2,
 423        .vs_dispatch    = nfsd_dispatch,
 424        .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 425};
 426