src/afs/VNOPS/afs_vnop_access.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * afs_vnop_access.c - access vop ccess mode bit support for vnode operations.
  12  *
  13  * Implements:
  14  * afs_GetAccessBits
  15  * afs_AccessOK
  16  * afs_access
  17  *
  18  * Local:
  19  * fileModeMap (table)
  20  */
  21
  22 #include <afsconfig.h>
  23 #include "afs/param.h"
  24
  25
  26 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  27 #include "afsincludes.h"        /* Afs-based standard headers */
  28 #include "afs/afs_stats.h"      /* statistics */
  29 #include "afs/afs_cbqueue.h"
  30 #include "afs/nfsclient.h"
  31 #include "afs/afs_osidnlc.h"
  32
  33 #ifndef ANONYMOUSID
  34 #define ANONYMOUSID     32766   /* make sure this is same as in ptserver.h */
  35 #endif
  36
  37
  38
  39
  40 /* access bits to turn off for various owner Unix mode values */
  41 static char fileModeMap[8] = {
  42     PRSFS_READ | PRSFS_WRITE,
  43     PRSFS_READ | PRSFS_WRITE,
  44     PRSFS_READ,
  45     PRSFS_READ,
  46     PRSFS_WRITE,
  47     PRSFS_WRITE,
  48     0,
  49     0
  50 };
  51
  52 /* avc must be held.  Returns bit map of mode bits.  Ignores file mode bits */
  53 afs_int32
  54 afs_GetAccessBits(struct vcache *avc, afs_int32 arights,
  55                   struct vrequest *areq)
  56 {
  57     AFS_STATCNT(afs_GetAccessBits);
  58     /* see if anyuser has the required access bits */
  59     if ((arights & avc->f.anyAccess) == arights) {
  60         return arights;
  61     }
  62
  63     /* look in per-pag cache */
  64     if (avc->Access) {          /* not beautiful, but Sun's cc will tolerate it */
  65         struct axscache *ac;
  66
  67         ac = afs_FindAxs(avc->Access, areq->uid);
  68         if (ac) {
  69             return (arights & ac->axess);
  70         }
  71     }
  72
  73     if (!(avc->f.states & CForeign)) {
  74         /* If there aren't any bits cached for this user (but the vnode
  75          * _is_ cached, obviously), make sure this user has valid tokens
  76          * before bothering with the RPC.  */
  77         struct unixuser *tu;
  78         tu = afs_FindUser(areq->uid, avc->f.fid.Cell, READ_LOCK);
  79         if (!tu) {
  80             return (arights & avc->f.anyAccess);
  81         }
  82         if (!(tu->states & UHasTokens) || (tu->states & UTokensBad)) {
  83             afs_PutUser(tu, READ_LOCK);
  84             return (arights & avc->f.anyAccess);
  85         } else {
  86             afs_PutUser(tu, READ_LOCK);
  87         }
  88     }
  89
  90     if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
  91         /* If we get this far, we have to ask the network. But we can't, so
  92          * they're out of luck... */
  93         return 0;
  94     } else
  95     {                           /* Ok, user has valid tokens, go ask the server. */
  96         struct AFSFetchStatus OutStatus;
  97         afs_int32 code;
  98
  99         code = afs_FetchStatus(avc, &avc->f.fid, areq, &OutStatus);
 100         return (code ? 0 : OutStatus.CallerAccess & arights);
 101     }
 102 }
 103
 104
 105 /* the new access ok function.  AVC must be held but not locked. if avc is a
 106  * file, its parent need not be held, and should not be locked. */
 107
 108 int
 109 afs_AccessOK(struct vcache *avc, afs_int32 arights, struct vrequest *areq,
 110              afs_int32 check_mode_bits)
 111 {
 112     struct vcache *tvc;
 113     struct VenusFid dirFid;
 114     afs_int32 mask;
 115     afs_int32 dirBits;
 116     afs_int32 fileBits;
 117
 118     AFS_STATCNT(afs_AccessOK);
 119
 120     if ((vType(avc) == VDIR) || (avc->f.states & CForeign)) {
 121         /* rights are just those from acl */
 122         if (afs_InReadDir(avc)) {
 123             /* if we are already in readdir, then they may have read and
 124              * lookup, and nothing else, and nevermind the real ACL.
 125              * Otherwise we might end up with problems trying to call
 126              * FetchStatus on the vnode readdir is working on, and that
 127              * would be a real mess.
 128              */
 129             dirBits = PRSFS_LOOKUP | PRSFS_READ;
 130             return (arights == (dirBits & arights));
 131         }
 132         return (arights == afs_GetAccessBits(avc, arights, areq));
 133     } else {
 134         /* some rights come from dir and some from file.  Specifically, you
 135          * have "a" rights to a file if you are its owner, which comes
 136          * back as "a" rights to the file. You have other rights just
 137          * from dir, but all are restricted by the file mode bit. Now,
 138          * if you have I and A rights to a file, we throw in R and W
 139          * rights for free. These rights will then be restricted by
 140          * the access mask. */
 141         dirBits = 0;
 142         if (avc->f.parent.vnode) {
 143             dirFid.Cell = avc->f.fid.Cell;
 144             dirFid.Fid.Volume = avc->f.fid.Fid.Volume;
 145             dirFid.Fid.Vnode = avc->f.parent.vnode;
 146             dirFid.Fid.Unique = avc->f.parent.unique;
 147             /* Avoid this GetVCache call */
 148             tvc = afs_GetVCache(&dirFid, areq, NULL, NULL);
 149             if (tvc) {
 150                 dirBits = afs_GetAccessBits(tvc, arights, areq);
 151                 afs_PutVCache(tvc);
 152             }
 153         } else
 154             dirBits = 0xffffffff;       /* assume OK; this is a race condition */
 155         if (arights & PRSFS_ADMINISTER)
 156             fileBits = afs_GetAccessBits(avc, arights, areq);
 157         else
 158             fileBits = 0;       /* don't make call if results don't matter */
 159
 160         /* compute basic rights in fileBits, taking A from file bits */
 161         fileBits =
 162             (fileBits & PRSFS_ADMINISTER) | (dirBits & ~PRSFS_ADMINISTER);
 163
 164         /* for files, throw in R and W if have I and A (owner).  This makes
 165          * insert-only dirs work properly */
 166         if (vType(avc) != VDIR
 167             && (fileBits & (PRSFS_ADMINISTER | PRSFS_INSERT)) ==
 168             (PRSFS_ADMINISTER | PRSFS_INSERT))
 169             fileBits |= (PRSFS_READ | PRSFS_WRITE);
 170
 171         if (check_mode_bits & CHECK_MODE_BITS) {
 172             /* owner mode bits are further restrictions on the access mode
 173              * The mode bits are mapped to protection bits through the
 174              * fileModeMap. If CMB_ALLOW_EXEC_AS_READ is set, it's from the
 175              * NFS translator and we don't know if it's a read or execute
 176              * on the NFS client, but both need to read the data.
 177              */
 178             mask = (avc->f.m.Mode & 0700) >> 6; /* file restrictions to use */
 179             fileBits &= ~fileModeMap[mask];
 180             if (check_mode_bits & CMB_ALLOW_EXEC_AS_READ) {
 181                 if (avc->f.m.Mode & 0100)
 182                     fileBits |= PRSFS_READ;
 183             }
 184         }
 185         return ((fileBits & arights) == arights);       /* true if all rights bits are on */
 186     }
 187 }
 188
 189
 190 #if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
 191 int
 192 afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
 193            afs_ucred_t *acred)
 194 #else
 195 int
 196 afs_access(OSI_VC_DECL(avc), afs_int32 amode,
 197            afs_ucred_t *acred)
 198 #endif
 199 {
 200     afs_int32 code;
 201     struct vrequest treq;
 202     struct afs_fakestat_state fakestate;
 203     OSI_VC_CONVERT(avc);
 204
 205     AFS_STATCNT(afs_access);
 206     afs_Trace3(afs_iclSetp, CM_TRACE_ACCESS, ICL_TYPE_POINTER, avc,
 207                ICL_TYPE_INT32, amode, ICL_TYPE_OFFSET,
 208                ICL_HANDLE_OFFSET(avc->f.m.Length));
 209     afs_InitFakeStat(&fakestate);
 210     if ((code = afs_InitReq(&treq, acred)))
 211         return code;
 212
 213     AFS_DISCON_LOCK();
 214
 215     if (afs_fakestat_enable && avc->mvstat == 1) {
 216         code = afs_TryEvalFakeStat(&avc, &fakestate, &treq);
 217         if (code == 0 && avc->mvstat == 1) {
 218             afs_PutFakeStat(&fakestate);
 219             AFS_DISCON_UNLOCK();
 220             return 0;
 221         }
 222     } else {
 223         code = afs_EvalFakeStat(&avc, &fakestate, &treq);
 224     }
 225
 226     if (code) {
 227         afs_PutFakeStat(&fakestate);
 228         AFS_DISCON_UNLOCK();
 229         return code;
 230     }
 231
 232     if (vType(avc) != VDIR || !afs_InReadDir(avc)) {
 233         code = afs_VerifyVCache(avc, &treq);
 234         if (code) {
 235             afs_PutFakeStat(&fakestate);
 236             AFS_DISCON_UNLOCK();
 237             code = afs_CheckCode(code, &treq, 16);
 238             return code;
 239         }
 240     }
 241
 242     /* if we're looking for write access and we have a read-only file system, report it */
 243     if ((amode & VWRITE) && (avc->f.states & CRO)) {
 244         afs_PutFakeStat(&fakestate);
 245         AFS_DISCON_UNLOCK();
 246         return EROFS;
 247     }
 248
 249     /* If we're looking for write access, and we're disconnected without logging, forget it */
 250     if ((amode & VWRITE) && (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW)) {
 251         afs_PutFakeStat(&fakestate);
 252         AFS_DISCON_UNLOCK();
 253         /* printf("Network is down in afs_vnop_access\n"); */
 254         return ENETDOWN;
 255     }
 256
 257     code = 1;                   /* Default from here on in is access ok. */
 258     if (avc->f.states & CForeign) {
 259         /* In the dfs xlator the EXEC bit is mapped to LOOKUP */
 260         if (amode & VEXEC)
 261             code = afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
 262         if (code && (amode & VWRITE)) {
 263             code = afs_AccessOK(avc, PRSFS_WRITE, &treq, CHECK_MODE_BITS);
 264             if (code && (vType(avc) == VDIR)) {
 265                 if (code)
 266                     code =
 267                         afs_AccessOK(avc, PRSFS_INSERT, &treq,
 268                                      CHECK_MODE_BITS);
 269                 if (!code)
 270                     code =
 271                         afs_AccessOK(avc, PRSFS_DELETE, &treq,
 272                                      CHECK_MODE_BITS);
 273             }
 274         }
 275         if (code && (amode & VREAD))
 276             code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
 277     } else {
 278         if (vType(avc) == VDIR) {
 279             if (amode & VEXEC)
 280                 code =
 281                     afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
 282             if (code && (amode & VWRITE)) {
 283                 code =
 284                     afs_AccessOK(avc, PRSFS_INSERT, &treq, CHECK_MODE_BITS);
 285                 if (!code)
 286                     code =
 287                         afs_AccessOK(avc, PRSFS_DELETE, &treq,
 288                                      CHECK_MODE_BITS);
 289             }
 290             if (code && (amode & VREAD))
 291                 code =
 292                     afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
 293         } else {
 294             if (amode & VEXEC) {
 295                 code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
 296                 if (code) {
 297                         if ((avc->f.m.Mode & 0100) == 0)
 298                             code = 0;
 299                 } else if (avc->f.m.Mode & 0100)
 300                     code = 1;
 301             }
 302             if (code && (amode & VWRITE)) {
 303                 code = afs_AccessOK(avc, PRSFS_WRITE, &treq, CHECK_MODE_BITS);
 304
 305                 /* The above call fails when the NFS translator tries to copy
 306                  ** a file with r--r--r-- permissions into a directory which
 307                  ** has system:anyuser acl. This is because the destination file
 308                  ** file is first created with r--r--r-- permissions through an
 309                  ** unauthenticated connectin.  hence, the above afs_AccessOK
 310                  ** call returns failure. hence, we retry without any file
 311                  ** mode bit checking */
 312                 if (!code && AFS_NFSXLATORREQ(acred)
 313                     && avc->f.m.Owner == ANONYMOUSID)
 314                     code =
 315                         afs_AccessOK(avc, PRSFS_WRITE, &treq,
 316                                      DONT_CHECK_MODE_BITS);
 317             }
 318             if (code && (amode & VREAD))
 319                 code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
 320         }
 321     }
 322     afs_PutFakeStat(&fakestate);
 323
 324     AFS_DISCON_UNLOCK();
 325
 326     if (code) {
 327         return 0;               /* if access is ok */
 328     } else {
 329         code = afs_CheckCode(EACCES, &treq, 17);        /* failure code */
 330         return code;
 331     }
 332 }
 333
 334 #if defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS)
 335 /*
 336  * afs_getRights
 337  * This function is just an interface to afs_GetAccessBits
 338  */
 339 int
 340 afs_getRights(OSI_VC_DECL(avc), afs_int32 arights,
 341               afs_ucred_t *acred)
 342 {
 343     afs_int32 code;
 344     struct vrequest treq;
 345     OSI_VC_CONVERT(avc);
 346
 347     if ((code = afs_InitReq(&treq, acred)))
 348         return code;
 349
 350     code = afs_VerifyVCache(avc, &treq);
 351     if (code) {
 352         code = afs_CheckCode(code, &treq, 16);
 353         return code;
 354     }
 355
 356     return afs_GetAccessBits(avc, arights, &treq);
 357 }
 358 #endif /* defined(UKERNEL) && defined(AFS_WEB_ENHANCEMENTS) */