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 <[email protected]>
   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_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. */
  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         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
 129 out:
 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
 136 out_drop_lock:
 137         fh_unlock(fh);
 138         fh_drop_write(fh);
 139 out_errno:
 140         resp->status = nfserrno(error);
 141         goto out;
 142 }
 143
 144 /*
 145  * Check file attributes
 146  */
 147 static __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);
 159 out:
 160         return rpc_success;
 161 }
 162
 163 /*
 164  * Check file access
 165  */
 166 static __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);
 181 out:
 182         return rpc_success;
 183 }
 184
 185 /*
 186  * XDR decode functions
 187  */
 188 static int nfsaclsvc_decode_voidarg(struct svc_rqst *rqstp, __be32 *p)
 189 {
 190         return 1;
 191 }
 192
 193 static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
 194 {
 195         struct nfsd3_getaclargs *argp = rqstp->rq_argp;
 196
 197         p = nfs2svc_decode_fh(p, &argp->fh);
 198         if (!p)
 199                 return 0;
 200         argp->mask = ntohl(*p); p++;
 201
 202         return xdr_argsize_check(rqstp, p);
 203 }
 204
 205
 206 static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
 207 {
 208         struct nfsd3_setaclargs *argp = rqstp->rq_argp;
 209         struct kvec *head = rqstp->rq_arg.head;
 210         unsigned int base;
 211         int n;
 212
 213         p = nfs2svc_decode_fh(p, &argp->fh);
 214         if (!p)
 215                 return 0;
 216         argp->mask = ntohl(*p++);
 217         if (argp->mask & ~NFS_ACL_MASK ||
 218             !xdr_argsize_check(rqstp, p))
 219                 return 0;
 220
 221         base = (char *)p - (char *)head->iov_base;
 222         n = nfsacl_decode(&rqstp->rq_arg, base, NULL,
 223                           (argp->mask & NFS_ACL) ?
 224                           &argp->acl_access : NULL);
 225         if (n > 0)
 226                 n = nfsacl_decode(&rqstp->rq_arg, base + n, NULL,
 227                                   (argp->mask & NFS_DFACL) ?
 228                                   &argp->acl_default : NULL);
 229         return (n > 0);
 230 }
 231
 232 static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p)
 233 {
 234         struct nfsd_fhandle *argp = rqstp->rq_argp;
 235
 236         p = nfs2svc_decode_fh(p, &argp->fh);
 237         if (!p)
 238                 return 0;
 239         return xdr_argsize_check(rqstp, p);
 240 }
 241
 242 static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
 243 {
 244         struct nfsd3_accessargs *argp = rqstp->rq_argp;
 245
 246         p = nfs2svc_decode_fh(p, &argp->fh);
 247         if (!p)
 248                 return 0;
 249         argp->access = ntohl(*p++);
 250
 251         return xdr_argsize_check(rqstp, p);
 252 }
 253
 254 /*
 255  * XDR encode functions
 256  */
 257
 258 /*
 259  * There must be an encoding function for void results so svc_process
 260  * will work properly.
 261  */
 262 static int nfsaclsvc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
 263 {
 264         return xdr_ressize_check(rqstp, p);
 265 }
 266
 267 /* GETACL */
 268 static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
 269 {
 270         struct nfsd3_getaclres *resp = rqstp->rq_resp;
 271         struct dentry *dentry = resp->fh.fh_dentry;
 272         struct inode *inode;
 273         struct kvec *head = rqstp->rq_res.head;
 274         unsigned int base;
 275         int n;
 276         int w;
 277
 278         *p++ = resp->status;
 279         if (resp->status != nfs_ok)
 280                 return xdr_ressize_check(rqstp, p);
 281
 282         /*
 283          * Since this is version 2, the check for nfserr in
 284          * nfsd_dispatch actually ensures the following cannot happen.
 285          * However, it seems fragile to depend on that.
 286          */
 287         if (dentry == NULL || d_really_is_negative(dentry))
 288                 return 0;
 289         inode = d_inode(dentry);
 290
 291         p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 292         *p++ = htonl(resp->mask);
 293         if (!xdr_ressize_check(rqstp, p))
 294                 return 0;
 295         base = (char *)p - (char *)head->iov_base;
 296
 297         rqstp->rq_res.page_len = w = nfsacl_size(
 298                 (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
 299                 (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
 300         while (w > 0) {
 301                 if (!*(rqstp->rq_next_page++))
 302                         return 0;
 303                 w -= PAGE_SIZE;
 304         }
 305
 306         n = nfsacl_encode(&rqstp->rq_res, base, inode,
 307                           resp->acl_access,
 308                           resp->mask & NFS_ACL, 0);
 309         if (n > 0)
 310                 n = nfsacl_encode(&rqstp->rq_res, base + n, inode,
 311                                   resp->acl_default,
 312                                   resp->mask & NFS_DFACL,
 313                                   NFS_ACL_DEFAULT);
 314         return (n > 0);
 315 }
 316
 317 static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p)
 318 {
 319         struct nfsd_attrstat *resp = rqstp->rq_resp;
 320
 321         *p++ = resp->status;
 322         if (resp->status != nfs_ok)
 323                 goto out;
 324
 325         p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 326 out:
 327         return xdr_ressize_check(rqstp, p);
 328 }
 329
 330 /* ACCESS */
 331 static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
 332 {
 333         struct nfsd3_accessres *resp = rqstp->rq_resp;
 334
 335         *p++ = resp->status;
 336         if (resp->status != nfs_ok)
 337                 goto out;
 338
 339         p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
 340         *p++ = htonl(resp->access);
 341 out:
 342         return xdr_ressize_check(rqstp, p);
 343 }
 344
 345 /*
 346  * XDR release functions
 347  */
 348 static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
 349 {
 350         struct nfsd3_getaclres *resp = rqstp->rq_resp;
 351
 352         fh_put(&resp->fh);
 353         posix_acl_release(resp->acl_access);
 354         posix_acl_release(resp->acl_default);
 355 }
 356
 357 static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
 358 {
 359         struct nfsd_attrstat *resp = rqstp->rq_resp;
 360
 361         fh_put(&resp->fh);
 362 }
 363
 364 static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
 365 {
 366         struct nfsd3_accessres *resp = rqstp->rq_resp;
 367
 368         fh_put(&resp->fh);
 369 }
 370
 371 struct nfsd3_voidargs { int dummy; };
 372
 373 #define ST 1            /* status*/
 374 #define AT 21           /* attributes */
 375 #define pAT (1+AT)      /* post attributes - conditional */
 376 #define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */
 377
 378 static const struct svc_procedure nfsd_acl_procedures2[5] = {
 379         [ACLPROC2_NULL] = {
 380                 .pc_func = nfsacld_proc_null,
 381                 .pc_decode = nfsaclsvc_decode_voidarg,
 382                 .pc_encode = nfsaclsvc_encode_voidres,
 383                 .pc_argsize = sizeof(struct nfsd3_voidargs),
 384                 .pc_ressize = sizeof(struct nfsd3_voidargs),
 385                 .pc_cachetype = RC_NOCACHE,
 386                 .pc_xdrressize = ST,
 387         },
 388         [ACLPROC2_GETACL] = {
 389                 .pc_func = nfsacld_proc_getacl,
 390                 .pc_decode = nfsaclsvc_decode_getaclargs,
 391                 .pc_encode = nfsaclsvc_encode_getaclres,
 392                 .pc_release = nfsaclsvc_release_getacl,
 393                 .pc_argsize = sizeof(struct nfsd3_getaclargs),
 394                 .pc_ressize = sizeof(struct nfsd3_getaclres),
 395                 .pc_cachetype = RC_NOCACHE,
 396                 .pc_xdrressize = ST+1+2*(1+ACL),
 397         },
 398         [ACLPROC2_SETACL] = {
 399                 .pc_func = nfsacld_proc_setacl,
 400                 .pc_decode = nfsaclsvc_decode_setaclargs,
 401                 .pc_encode = nfsaclsvc_encode_attrstatres,
 402                 .pc_release = nfsaclsvc_release_attrstat,
 403                 .pc_argsize = sizeof(struct nfsd3_setaclargs),
 404                 .pc_ressize = sizeof(struct nfsd_attrstat),
 405                 .pc_cachetype = RC_NOCACHE,
 406                 .pc_xdrressize = ST+AT,
 407         },
 408         [ACLPROC2_GETATTR] = {
 409                 .pc_func = nfsacld_proc_getattr,
 410                 .pc_decode = nfsaclsvc_decode_fhandleargs,
 411                 .pc_encode = nfsaclsvc_encode_attrstatres,
 412                 .pc_release = nfsaclsvc_release_attrstat,
 413                 .pc_argsize = sizeof(struct nfsd_fhandle),
 414                 .pc_ressize = sizeof(struct nfsd_attrstat),
 415                 .pc_cachetype = RC_NOCACHE,
 416                 .pc_xdrressize = ST+AT,
 417         },
 418         [ACLPROC2_ACCESS] = {
 419                 .pc_func = nfsacld_proc_access,
 420                 .pc_decode = nfsaclsvc_decode_accessargs,
 421                 .pc_encode = nfsaclsvc_encode_accessres,
 422                 .pc_release = nfsaclsvc_release_access,
 423                 .pc_argsize = sizeof(struct nfsd3_accessargs),
 424                 .pc_ressize = sizeof(struct nfsd3_accessres),
 425                 .pc_cachetype = RC_NOCACHE,
 426                 .pc_xdrressize = ST+AT+1,
 427         },
 428 };
 429
 430 static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
 431 const struct svc_version nfsd_acl_version2 = {
 432         .vs_vers        = 2,
 433         .vs_nproc       = 5,
 434         .vs_proc        = nfsd_acl_procedures2,
 435         .vs_count       = nfsd_acl_count2,
 436         .vs_dispatch    = nfsd_dispatch,
 437         .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 438 };