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  */
  21 static __be32
  22 nfsacld_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  */
  30 static __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_inode_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_inode_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. */
  81 out:
  82         return rpc_success;
  83
  84 fail:
  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  */
  93 static __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         inode_lock(inode);
 115
 116         error = set_posix_acl(&nop_mnt_idmap, fh->fh_dentry, ACL_TYPE_ACCESS,
 117                               argp->acl_access);
 118         if (error)
 119                 goto out_drop_lock;
 120         error = set_posix_acl(&nop_mnt_idmap, fh->fh_dentry, ACL_TYPE_DEFAULT,
 121                               argp->acl_default);
 122         if (error)
 123                 goto out_drop_lock;
 124
 125         inode_unlock(inode);
 126
 127         fh_drop_write(fh);
 128
 129         resp->status = fh_getattr(fh, &resp->stat);
 130
 131 out:
 132         /* argp->acl_{access,default} may have been allocated in
 133            nfssvc_decode_setaclargs. */
 134         posix_acl_release(argp->acl_access);
 135         posix_acl_release(argp->acl_default);
 136         return rpc_success;
 137
 138 out_drop_lock:
 139         inode_unlock(inode);
 140         fh_drop_write(fh);
 141 out_errno:
 142         resp->status = nfserrno(error);
 143         goto out;
 144 }
 145
 146 /*
 147  * Check file attributes
 148  */
 149 static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
 150 {
 151         struct nfsd_fhandle *argp = rqstp->rq_argp;
 152         struct nfsd_attrstat *resp = rqstp->rq_resp;
 153
 154         dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 155
 156         fh_copy(&resp->fh, &argp->fh);
 157         resp->status = fh_verify(rqstp, &resp->fh, 0, NFSD_MAY_NOP);
 158         if (resp->status != nfs_ok)
 159                 goto out;
 160         resp->status = fh_getattr(&resp->fh, &resp->stat);
 161 out:
 162         return rpc_success;
 163 }
 164
 165 /*
 166  * Check file access
 167  */
 168 static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
 169 {
 170         struct nfsd3_accessargs *argp = rqstp->rq_argp;
 171         struct nfsd3_accessres *resp = rqstp->rq_resp;
 172
 173         dprintk("nfsd: ACCESS(2acl)   %s 0x%x\n",
 174                         SVCFH_fmt(&argp->fh),
 175                         argp->access);
 176
 177         fh_copy(&resp->fh, &argp->fh);
 178         resp->access = argp->access;
 179         resp->status = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
 180         if (resp->status != nfs_ok)
 181                 goto out;
 182         resp->status = fh_getattr(&resp->fh, &resp->stat);
 183 out:
 184         return rpc_success;
 185 }
 186
 187 /*
 188  * XDR decode functions
 189  */
 190
 191 static bool
 192 nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 193 {
 194         struct nfsd3_getaclargs *argp = rqstp->rq_argp;
 195
 196         if (!svcxdr_decode_fhandle(xdr, &argp->fh))
 197                 return false;
 198         if (xdr_stream_decode_u32(xdr, &argp->mask) < 0)
 199                 return false;
 200
 201         return true;
 202 }
 203
 204 static bool
 205 nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 206 {
 207         struct nfsd3_setaclargs *argp = rqstp->rq_argp;
 208
 209         if (!svcxdr_decode_fhandle(xdr, &argp->fh))
 210                 return false;
 211         if (xdr_stream_decode_u32(xdr, &argp->mask) < 0)
 212                 return false;
 213         if (argp->mask & ~NFS_ACL_MASK)
 214                 return false;
 215         if (!nfs_stream_decode_acl(xdr, NULL, (argp->mask & NFS_ACL) ?
 216                                    &argp->acl_access : NULL))
 217                 return false;
 218         if (!nfs_stream_decode_acl(xdr, NULL, (argp->mask & NFS_DFACL) ?
 219                                    &argp->acl_default : NULL))
 220                 return false;
 221
 222         return true;
 223 }
 224
 225 static bool
 226 nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 227 {
 228         struct nfsd3_accessargs *args = rqstp->rq_argp;
 229
 230         if (!svcxdr_decode_fhandle(xdr, &args->fh))
 231                 return false;
 232         if (xdr_stream_decode_u32(xdr, &args->access) < 0)
 233                 return false;
 234
 235         return true;
 236 }
 237
 238 /*
 239  * XDR encode functions
 240  */
 241
 242 /* GETACL */
 243 static bool
 244 nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 245 {
 246         struct nfsd3_getaclres *resp = rqstp->rq_resp;
 247         struct dentry *dentry = resp->fh.fh_dentry;
 248         struct inode *inode;
 249
 250         if (!svcxdr_encode_stat(xdr, resp->status))
 251                 return false;
 252
 253         if (dentry == NULL || d_really_is_negative(dentry))
 254                 return true;
 255         inode = d_inode(dentry);
 256
 257         if (!svcxdr_encode_fattr(rqstp, xdr, &resp->fh, &resp->stat))
 258                 return false;
 259         if (xdr_stream_encode_u32(xdr, resp->mask) < 0)
 260                 return false;
 261
 262         if (!nfs_stream_encode_acl(xdr, inode, resp->acl_access,
 263                                    resp->mask & NFS_ACL, 0))
 264                 return false;
 265         if (!nfs_stream_encode_acl(xdr, inode, resp->acl_default,
 266                                    resp->mask & NFS_DFACL, NFS_ACL_DEFAULT))
 267                 return false;
 268
 269         return true;
 270 }
 271
 272 /* ACCESS */
 273 static bool
 274 nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
 275 {
 276         struct nfsd3_accessres *resp = rqstp->rq_resp;
 277
 278         if (!svcxdr_encode_stat(xdr, resp->status))
 279                 return false;
 280         switch (resp->status) {
 281         case nfs_ok:
 282                 if (!svcxdr_encode_fattr(rqstp, xdr, &resp->fh, &resp->stat))
 283                         return false;
 284                 if (xdr_stream_encode_u32(xdr, resp->access) < 0)
 285                         return false;
 286                 break;
 287         }
 288
 289         return true;
 290 }
 291
 292 /*
 293  * XDR release functions
 294  */
 295 static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
 296 {
 297         struct nfsd3_getaclres *resp = rqstp->rq_resp;
 298
 299         fh_put(&resp->fh);
 300         posix_acl_release(resp->acl_access);
 301         posix_acl_release(resp->acl_default);
 302 }
 303
 304 static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
 305 {
 306         struct nfsd3_accessres *resp = rqstp->rq_resp;
 307
 308         fh_put(&resp->fh);
 309 }
 310
 311 #define ST 1            /* status*/
 312 #define AT 21           /* attributes */
 313 #define pAT (1+AT)      /* post attributes - conditional */
 314 #define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */
 315
 316 static const struct svc_procedure nfsd_acl_procedures2[5] = {
 317         [ACLPROC2_NULL] = {
 318                 .pc_func = nfsacld_proc_null,
 319                 .pc_decode = nfssvc_decode_voidarg,
 320                 .pc_encode = nfssvc_encode_voidres,
 321                 .pc_argsize = sizeof(struct nfsd_voidargs),
 322                 .pc_argzero = sizeof(struct nfsd_voidargs),
 323                 .pc_ressize = sizeof(struct nfsd_voidres),
 324                 .pc_cachetype = RC_NOCACHE,
 325                 .pc_xdrressize = ST,
 326                 .pc_name = "NULL",
 327         },
 328         [ACLPROC2_GETACL] = {
 329                 .pc_func = nfsacld_proc_getacl,
 330                 .pc_decode = nfsaclsvc_decode_getaclargs,
 331                 .pc_encode = nfsaclsvc_encode_getaclres,
 332                 .pc_release = nfsaclsvc_release_getacl,
 333                 .pc_argsize = sizeof(struct nfsd3_getaclargs),
 334                 .pc_argzero = sizeof(struct nfsd3_getaclargs),
 335                 .pc_ressize = sizeof(struct nfsd3_getaclres),
 336                 .pc_cachetype = RC_NOCACHE,
 337                 .pc_xdrressize = ST+1+2*(1+ACL),
 338                 .pc_name = "GETACL",
 339         },
 340         [ACLPROC2_SETACL] = {
 341                 .pc_func = nfsacld_proc_setacl,
 342                 .pc_decode = nfsaclsvc_decode_setaclargs,
 343                 .pc_encode = nfssvc_encode_attrstatres,
 344                 .pc_release = nfssvc_release_attrstat,
 345                 .pc_argsize = sizeof(struct nfsd3_setaclargs),
 346                 .pc_argzero = sizeof(struct nfsd3_setaclargs),
 347                 .pc_ressize = sizeof(struct nfsd_attrstat),
 348                 .pc_cachetype = RC_NOCACHE,
 349                 .pc_xdrressize = ST+AT,
 350                 .pc_name = "SETACL",
 351         },
 352         [ACLPROC2_GETATTR] = {
 353                 .pc_func = nfsacld_proc_getattr,
 354                 .pc_decode = nfssvc_decode_fhandleargs,
 355                 .pc_encode = nfssvc_encode_attrstatres,
 356                 .pc_release = nfssvc_release_attrstat,
 357                 .pc_argsize = sizeof(struct nfsd_fhandle),
 358                 .pc_argzero = sizeof(struct nfsd_fhandle),
 359                 .pc_ressize = sizeof(struct nfsd_attrstat),
 360                 .pc_cachetype = RC_NOCACHE,
 361                 .pc_xdrressize = ST+AT,
 362                 .pc_name = "GETATTR",
 363         },
 364         [ACLPROC2_ACCESS] = {
 365                 .pc_func = nfsacld_proc_access,
 366                 .pc_decode = nfsaclsvc_decode_accessargs,
 367                 .pc_encode = nfsaclsvc_encode_accessres,
 368                 .pc_release = nfsaclsvc_release_access,
 369                 .pc_argsize = sizeof(struct nfsd3_accessargs),
 370                 .pc_argzero = sizeof(struct nfsd3_accessargs),
 371                 .pc_ressize = sizeof(struct nfsd3_accessres),
 372                 .pc_cachetype = RC_NOCACHE,
 373                 .pc_xdrressize = ST+AT+1,
 374                 .pc_name = "SETATTR",
 375         },
 376 };
 377
 378 static DEFINE_PER_CPU_ALIGNED(unsigned long,
 379                               nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)]);
 380 const struct svc_version nfsd_acl_version2 = {
 381         .vs_vers        = 2,
 382         .vs_nproc       = ARRAY_SIZE(nfsd_acl_procedures2),
 383         .vs_proc        = nfsd_acl_procedures2,
 384         .vs_count       = nfsd_acl_count2,
 385         .vs_dispatch    = nfsd_dispatch,
 386         .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 387 };