#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange(FALSE);
- return 0;
+ return CM_ERROR_NOACCESS;
}
#endif
lock_ObtainWrite(&scp->dirlock);
lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
+ if (scp->fileType == CM_SCACHETYPE_MOUNTPOINT ||
+ scp->fileType == CM_SCACHETYPE_SYMLINK) {
+ scp->mpDataVersion = CM_SCACHE_VERSION_BAD;
+ scp->mountPointStringp[0] = '\0';
+ }
if (scp->fileType == CM_SCACHETYPE_DIRECTORY) {
cm_ResetSCacheDirectory(scp, 1);
lock_ReleaseWrite(&scp->dirlock);
#ifdef AFS_FREELANCE_CLIENT
if ( cell == AFS_FAKE_ROOT_CELL_ID && volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange(FALSE);
- return 0;
+ return CM_ERROR_NOACCESS;
}
#endif
}
lock_ReleaseWrite(&cm_scacheLock);
- return code;
+ return 0;
}
/*
code = RXAFS_FetchACL(rxconnp, &afid, &acl, &fileStatus, &volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, 0, &volSync, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, 0, &fileStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
code = RXAFS_StoreACL(rxconnp, &fid, &acl, &fileStatus, &volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, 1, &fileStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
/* invalidate cache info, since we just trashed the ACL cache */
}
lock_ReleaseWrite(&cm_scacheLock);
- return code;
+#ifdef AFS_FREELANCE_CLIENT
+ cm_noteLocalMountPointChange(FALSE);
+#endif
+
+ return 0;
}
/*
afs_int32
cm_IoctlFlushVolume(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
{
- afs_int32 code;
- afs_uint32 volume;
- afs_uint32 cell;
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
- code = CM_ERROR_NOACCESS;
- } else
-#endif
- {
- volume = scp->fid.volume;
- cell = scp->fid.cell;
- code = cm_FlushVolume(userp, reqp, cell, volume);
+ cm_noteLocalMountPointChange(FALSE);
+ return 0;
}
- return code;
+#endif
+
+ return cm_FlushVolume(userp, reqp, scp->fid.cell, scp->fid.volume);
}
/*
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
- code = CM_ERROR_NOACCESS;
- } else
-#endif
- {
- cm_FlushFile(scp, userp, reqp);
+ return CM_ERROR_NOACCESS;
}
- return 0;
+#endif
+
+ return cm_FlushFile(scp, userp, reqp);
}
&storeStat, volName, offLineMsg, motd);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(tcp, userp, reqp, &scp->fid, NULL, 1, NULL, NULL, NULL, code));
+ } while (cm_Analyze(tcp, userp, reqp, &scp->fid, NULL, 1, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
}
if (code)
return code;
- lock_ObtainWrite(&vscp->rw);
- code = cm_SyncOp(vscp, NULL, userp, reqp, PRSFS_READ,
- CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseWrite(&vscp->rw);
- if (code)
- return code;
-
Name = volName;
OfflineMsg = offLineMsg;
MOTD = motd;
&volStat, &Name, &OfflineMsg, &MOTD);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &vfid, NULL, 0, NULL, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &vfid, NULL, 0, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
- lock_ObtainWrite(&vscp->rw);
- cm_SyncOpDone(vscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- lock_ReleaseWrite(&vscp->rw);
cm_ReleaseSCache(vscp);
}
cp = ioctlp->outDatap;
- tsrpp = cm_GetVolServers(tvp, volume, userp, reqp);
+ tsrpp = cm_GetVolServers(tvp, volume, userp, reqp, NULL);
if (tsrpp == NULL) {
code = CM_ERROR_NOSUCHVOLUME;
} else {
cp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
code = cm_Lookup(dscp, cp[0] ? cp : L".", CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
- if (code)
+ if (code && code != CM_ERROR_INEXACT_MATCH)
goto done_2;
lock_ObtainWrite(&scp->rw);
code = cm_Lookup(dscp, cp[0] ? cp : L".", CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
/* if something went wrong, bail out now */
- if (code)
+ if (code && code != CM_ERROR_INEXACT_MATCH)
goto done3;
lock_ObtainWrite(&scp->rw);
/* now return the current down server list */
cp = ioctlp->outDatap;
lock_ObtainRead(&cm_serverLock);
- for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
+ for (tsp = cm_serversAllFirstp;
+ tsp;
+ tsp = (cm_server_t *)osi_QNext(&tsp->allq)) {
if (cellp && tsp->cellp != cellp)
continue; /* cell spec'd and wrong */
if (tsp->flags & CM_SERVERFLAG_DOWN) {
* is up, do not report the server as down.
*/
if (tsp->type == CM_SERVER_FILE) {
- for (csp = cm_allServersp; csp; csp=csp->allNextp) {
+ for (csp = cm_serversAllFirstp;
+ csp;
+ csp = (cm_server_t *)osi_QNext(&csp->allq)) {
if (csp->type == CM_SERVER_FILE &&
!(csp->flags & CM_SERVERFLAG_DOWN) &&
afs_uuid_equal(&tsp->uuid, &csp->uuid)) {
* so we report the entire cache in use since reporting 0 in use disturbs
* many users.
*/
- parms.parms[1] = cm_data.buf_nbuffers * (cm_data.buf_blockSize / 1024);
+ parms.parms[1] = cm_data.buf_usedCount * (cm_data.buf_blockSize / 1024);
memcpy(ioctlp->outDatap, &parms, sizeof(parms));
ioctlp->outDatap += sizeof(parms);
if ( tsp ) /* an existing server - ref count increased */
{
lock_ObtainMutex(&tsp->mx);
- tsp->ipRank = rank;
+ tsp->adminRank = rank;
_InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
- tsp->adminRank = tsp->ipRank;
+ cm_RankServer(tsp);
lock_ReleaseMutex(&tsp->mx);
switch (type) {
{
tsp = cm_NewServer(&tmp, type, NULL, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
lock_ObtainMutex(&tsp->mx);
- tsp->ipRank = rank;
+ tsp->adminRank = rank;
_InterlockedOr(&tsp->flags, CM_SERVERFLAG_PREF_SET);
- tsp->adminRank = tsp->ipRank;
lock_ReleaseMutex(&tsp->mx);
- tsp->ipRank = rank;
}
cm_PutServer(tsp); /* decrease refcount */
}
lock_ObtainRead(&cm_serverLock); /* get server lock */
- for (tsp=cm_allServersp, i=0; tsp && noServers; tsp=tsp->allNextp,i++){
+ for (tsp = cm_serversAllFirstp, i=0;
+ tsp && noServers;
+ tsp = (cm_server_t *)osi_QNext(&tsp->allq),i++){
if (spin->offset > i) {
continue; /* catch up to where we left off */
}
continue; /* ignore vlservers */
srvout->host = tsp->addr.sin_addr;
- srvout->rank = tsp->ipRank;
+ srvout->rank = tsp->activeRank;
srvout++;
spout->num_servers++;
noServers--;
/* Extract the possibly partial cell name */
mpp = cm_ParseIoctlStringAlloc(ioctlp, NULL);
+
+ len = cm_ClientStrLen(mpp);
+ if (len <= 1 || mpp[len-1] != L'.') {
+ code = CM_ERROR_INVAL;
+ goto done;
+ }
+
cell = cm_ClientCharNext(mpp);
if (cp = cm_ClientStrChr(cell, ':')) {
goto done;
}
- StringCbPrintfA(mpInfo, sizeof(mpInfo), "%c%s:%s.", (char) *mpp,
+ /* fsvolume includes the trailing dot */
+ StringCbPrintfA(mpInfo, sizeof(mpInfo), "%c%s:%s", (char) *mpp,
fullCell, fsvolume);
} else {
cellp = cm_FindCellByID(dscp->fid.cell, CM_FLAG_NOPROBE);
}
- /* remove the trailing dot if it is present */
+ /* remove the trailing dot */
len = strlen(fsvolume);
- if (len > 1 && fsvolume[len-1] == '.')
- fsvolume[len-1] = '\0';
+ fsvolume[len-1] = '\0';
/* validate the target info */
if (cm_VolNameIsID(fsvolume)) {
clientp = cm_Utf8ToClientStringAlloc(cp, -1, NULL);
code = cm_Lookup(dscp, clientp[0] ? clientp : L".", CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
free(clientp);
- if (code)
+ if (code && code != CM_ERROR_INEXACT_MATCH)
return code;
/* Check that it's a real symlink */
clientp = cm_Utf8ToClientStringAlloc(cp, -1, NULL);
code = cm_Lookup(dscp, clientp[0] ? clientp : L".", CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
free(clientp);
- if (code)
+ if (code && code != CM_ERROR_INEXACT_MATCH)
return code;
/* Check that it's a real symlink */
code = cm_Lookup(dscp, clientp[0] ? clientp : L".", CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
/* if something went wrong, bail out now */
- if (code)
+ if (code && code != CM_ERROR_INEXACT_MATCH)
goto done3;
lock_ObtainWrite(&scp->rw);
return 0;
}
+/*
+ * VIOC_GETCALLERACCESS internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped.
+ */
+
+afs_int32
+cm_IoctlGetCallerAccess(cm_ioctl_t *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
+{
+ afs_int32 code;
+ afs_uint32 rights = 0;
+ int haveRights = 0;
+ char *cp;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0) {
+ haveRights = cm_HaveAccessRights(scp, userp, reqp, 0xFF0000FF, &rights);
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ }
+ lock_ReleaseWrite(&scp->rw);
+
+ cp = ioctlp->outDatap;
+ /* Copy all this junk into msg->im_data, keeping track of the lengths. */
+ if (haveRights)
+ memcpy(cp, (char *)&rights, sizeof(afs_uint32));
+ else
+ memcpy(cp, (char *)&scp->anyAccess, sizeof(afs_uint32));
+ cp += sizeof(afs_uint32);
+ memcpy(cp, (char *)&scp->anyAccess, sizeof(afs_uint32));
+ cp += sizeof(afs_uint32);
+
+ /* return new size */
+ ioctlp->outDatap = cp;
+
+ return code;
+}
git://git.openafs.org / openafs.git / blobdiff