{
long code;
- code = buf_CleanVnode(scp, userp, reqp);
+ code = cm_FSync(scp, userp, reqp, FALSE);
if (!code) {
lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange();
+ cm_noteLocalMountPointChange(FALSE);
return 0;
}
#endif
code = buf_FlushCleanPages(scp, userp, reqp);
+ if (scp->fileType == CM_SCACHETYPE_DIRECTORY)
+ lock_ObtainWrite(&scp->dirlock);
lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
- if (scp->fileType == CM_SCACHETYPE_DIRECTORY)
- cm_ResetSCacheDirectory(scp);
+ if (scp->fileType == CM_SCACHETYPE_DIRECTORY) {
+ cm_ResetSCacheDirectory(scp, 1);
+ lock_ReleaseWrite(&scp->dirlock);
+ }
lock_ReleaseWrite(&scp->rw);
osi_Log2(afsd_logp,"cm_FlushFile scp 0x%x returns error: [%x]",scp, code);
{
afs_int32 code = 0;
cm_scache_t *scp;
- int i;
+ unsigned int i;
#ifdef AFS_FREELANCE_CLIENT
if ( cell == AFS_FAKE_ROOT_CELL_ID && volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange();
+ cm_noteLocalMountPointChange(FALSE);
return 0;
}
#endif
}
/*
- * Utility function. Used within this file.
- * Invalidate ACL info for a user that has just obtained or lost tokens.
- */
-void
-cm_ResetACLCache(cm_user_t *userp)
-{
- cm_scache_t *scp;
- int hash;
-
- lock_ObtainWrite(&cm_scacheLock);
- for (hash=0; hash < cm_data.scacheHashTableSize; hash++) {
- for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {
- cm_HoldSCacheNoLock(scp);
- lock_ReleaseWrite(&cm_scacheLock);
- lock_ObtainWrite(&scp->rw);
- cm_InvalidateACLUser(scp, userp);
- lock_ReleaseWrite(&scp->rw);
- lock_ObtainWrite(&cm_scacheLock);
- cm_ReleaseSCacheNoLock(scp);
- }
- }
- lock_ReleaseWrite(&cm_scacheLock);
-}
-
-/*
* TranslateExtendedChars - This is a fix for TR 54482.
*
* If an extended character (80 - FF) is entered into a file
if ((ioctlp->flags & CM_IOCTLFLAG_USEUTF8) == CM_IOCTLFLAG_USEUTF8) {
cchout = cm_ClientStringToUtf8(cstr, cchlen, outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp));
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)));
} else {
if (smb_StoreAnsiFilenames) {
cchout = WideCharToMultiByte(CP_ACP, 0, cstr, cchlen,
outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)),
NULL, NULL);
} else {
cchout = WideCharToMultiByte(CP_OEMCP, 0, cstr, cchlen,
outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)),
NULL, NULL);
}
}
cm_ioctlQueryOptions_t *
cm_IoctlGetQueryOptions(struct cm_ioctl *ioctlp, struct cm_user *userp)
{
- afs_uint32 pathlen = strlen(ioctlp->inDatap) + 1;
+ afs_uint32 pathlen = (afs_uint32) strlen(ioctlp->inDatap) + 1;
char *p = ioctlp->inDatap + pathlen;
cm_ioctlQueryOptions_t * optionsp = NULL;
if (!cm_ClientStrCmpNI(inpathp, cm_mountRootC, cm_mountRootCLen))
cm_ClientStrCpy(outpathp, cchlen, inpathp);
else if (!cm_ClientStrCmpNI(inpathp, bslash_mountRoot,
- cm_ClientStrLen(bslash_mountRoot)))
+ (int)cm_ClientStrLen(bslash_mountRoot)))
cm_ClientStrCpy(outpathp, cchlen, inpathp);
else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
cm_ClientStrPrintfN(outpathp, cchlen, _C("%s%s"), cm_mountRootC, inpathp);
outpathp[strlen(outpathp)-1] = 0;
}
- if (!strcmpi (outpathp, cm_mountRoot)) {
+ if (!_stricmp (outpathp, cm_mountRoot)) {
StringCbCopy(outpathp, outlen, cm_mountRoot);
}
}
int tlen;
struct rx_connection * rxconnp;
+ memset(&volSync, 0, sizeof(volSync));
+
/* now make the get acl call */
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
clientchar_t * cellname;
cellname = cm_FsStringToClientStringAlloc(cellp->name, -1, NULL);
- cm_UnparseIoctlString(ioctlp, NULL, cellname, -1);
- free(cellname);
- code = 0;
+ if (cellname == NULL) {
+ code = CM_ERROR_NOSUCHCELL;
+ } else {
+ cm_UnparseIoctlString(ioctlp, NULL, cellname, -1);
+ free(cellname);
+ code = 0;
+ }
} else
code = CM_ERROR_NOSUCHCELL;
}
AFSFid fid;
struct rx_connection * rxconnp;
+ memset(&volSync, 0, sizeof(volSync));
+
#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;
{
afs_int32 code;
cm_scache_t *scp;
- int i;
+ unsigned int i;
lock_ObtainWrite(&cm_scacheLock);
for (i=0; i<cm_data.scacheHashTableSize; i++) {
/*
+ * VIOC_SETOWNER internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped
+ * and that cm_ioctlQueryOptions_t have been parsed and skipped.
+ *
+ * scp is held but not locked.
+ *
+ */
+afs_int32
+cm_IoctlSetOwner(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
+{
+ afs_int32 code = 0;
+ char *cp;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&scp->rw);
+
+ if (code == 0) {
+ afs_uint32 owner;
+ cm_attr_t attr;
+
+ memset(&attr, 0, sizeof(attr));
+
+ cp = ioctlp->inDatap;
+ memcpy((char *)&owner, cp, sizeof(afs_uint32));
+
+ attr.mask = CM_ATTRMASK_OWNER;
+ attr.owner = owner;
+
+ code = cm_SetAttr(scp, &attr, userp, reqp);
+ }
+ return code;
+}
+
+
+/*
+ * VIOC_SETGROUP internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped
+ * and that cm_ioctlQueryOptions_t have been parsed and skipped.
+ *
+ */
+afs_int32
+cm_IoctlSetGroup(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
+{
+ afs_int32 code = 0;
+ char *cp;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&scp->rw);
+
+ if (code == 0) {
+ afs_uint32 group;
+ cm_attr_t attr;
+
+ memset(&attr, 0, sizeof(attr));
+
+ cp = ioctlp->inDatap;
+ memcpy((char *)&group, cp, sizeof(afs_uint32));
+
+ attr.mask = CM_ATTRMASK_GROUP;
+ attr.group = group;
+
+ code = cm_SetAttr(scp, &attr, userp, reqp);
+ }
+ return code;
+}
+
+
+/*
* VIOCWHEREIS internals.
*
* Assumes that pioctl path has been parsed or skipped.
ioctlp->outDatap = basep + max * sizeof(afs_int32);
cellnamep = cm_FsStringToClientStringAlloc(tcellp->name, -1, NULL);
- cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
- free(cellnamep);
+ if (cellnamep) {
+ cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
+ free(cellnamep);
+ } else {
+ tcellp = NULL;
+ }
}
if (tcellp)
rock.cellp = cp;
rock.flags = 0;
- code = cm_SearchCellFile(cp->name, cp->name, cm_AddCellProc, &rock);
-#ifdef AFS_AFSDB_ENV
+ code = cm_SearchCellRegistry(1, cp->name, cp->name, cp->linkedName, cm_AddCellProc, &rock);
+ if (code && code != CM_ERROR_FORCE_DNS_LOOKUP)
+ code = cm_SearchCellFileEx(cp->name, cp->name, cp->linkedName, cm_AddCellProc, &rock);
if (code) {
if (cm_dnsEnabled) {
int ttl;
cp->flags &= ~CM_CELLFLAG_DNS;
lock_ReleaseMutex(&cp->mx);
}
-#endif /* AFS_AFSDB_ENV */
if (code) {
lock_ObtainMutex(&cp->mx);
cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
} else if (cm_data.rootCellp) {
clientchar_t * cellnamep = cm_FsStringToClientStringAlloc(cm_data.rootCellp->name, -1, NULL);
/* return the default cellname to the caller */
- cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
- free(cellnamep);
+ if (cellnamep) {
+ cm_UnparseIoctlString(ioctlp, NULL, cellnamep, -1);
+ free(cellnamep);
+ } else {
+ code = CM_ERROR_NOSUCHCELL;
+ }
} else {
/* if we don't know our default cell, return failure */
code = CM_ERROR_NOSUCHCELL;
afs_uint32 setSysName;
char *cp, *cp2;
clientchar_t *inname = NULL;
- int t, count;
+ int t;
+ unsigned int count;
memcpy(&setSysName, ioctlp->inDatap, sizeof(afs_uint32));
ioctlp->inDatap += sizeof(afs_uint32);
}
cm_sysNameCount = setSysName;
} else {
- afs_int32 i32;
+ afs_uint32 i32;
/* return the sysname to the caller */
i32 = cm_sysNameCount;
srvin = &(spin->servers[i]);
rank = srvin->rank + (rand() & 0x000f);
tmp.sin_addr = srvin->host;
+ switch (type) {
+ case CM_SERVER_VLDB:
+ tmp.sin_port = htons(7003);
+ break;
+ case CM_SERVER_FILE:
+ tmp.sin_port = htons(7000);
+ break;
+ }
tmp.sin_family = AF_INET;
tsp = cm_FindServer(&tmp, type);
if ( tsp ) /* an existing server - ref count increased */
{
- tsp->ipRank = rank; /* no need to protect by mutex*/
-
- if (type == CM_SERVER_FILE)
- { /* fileserver */
- /* find volumes which might have RO copy
- /* on server and change the ordering of
+ lock_ObtainMutex(&tsp->mx);
+ tsp->ipRank = rank;
+ tsp->flags |= CM_SERVERFLAG_PREF_SET;
+ tsp->adminRank = tsp->ipRank;
+ lock_ReleaseMutex(&tsp->mx);
+
+ switch (type) {
+ case CM_SERVER_FILE:
+ /*
+ * find volumes which might have RO copy
+ * on server and change the ordering of
* their RO list
*/
cm_ChangeRankVolume(tsp);
- }
- else
- {
+ break;
+ case CM_SERVER_VLDB:
/* set preferences for an existing vlserver */
cm_ChangeRankCellVLServer(tsp);
+ break;
}
}
else /* add a new server without a cell */
{
- tsp = cm_NewServer(&tmp, type, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
+ tsp = cm_NewServer(&tmp, type, NULL, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
+ lock_ObtainMutex(&tsp->mx);
+ tsp->ipRank = rank;
+ tsp->flags |= CM_SERVERFLAG_PREF_SET;
+ tsp->adminRank = tsp->ipRank;
+ lock_ReleaseMutex(&tsp->mx);
tsp->ipRank = rank;
}
- lock_ObtainMutex(&tsp->mx);
- tsp->flags |= CM_SERVERFLAG_PREF_SET;
- lock_ReleaseMutex(&tsp->mx);
cm_PutServer(tsp); /* decrease refcount */
}
return 0;
continue; /* catch up to where we left off */
}
- if ( vlonly && (tsp->type == CM_SERVER_FILE) )
+ if ( vlonly && (tsp->type != CM_SERVER_VLDB) )
continue; /* ignore fileserver for -vlserver option*/
- if ( !vlonly && (tsp->type == CM_SERVER_VLDB) )
+ if ( !vlonly && (tsp->type != CM_SERVER_FILE) )
continue; /* ignore vlservers */
srvout->host = tsp->addr.sin_addr;
int i;
char * p, * r;
+ memset(&info, 0, sizeof(info));
tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
code = afsconf_GetCellInfo(tdir, ucellp->cellp->name, "afsprot", &info);
afsconf_Close(tdir);
code = ubik_ClientInit(serverconns, &pruclient);
if (code) {
+ if (info.linkedCell)
+ free(info.linkedCell);
return code;
}
pruclient = NULL;
}
+ if (info.linkedCell)
+ free(info.linkedCell);
return 0;
}
#endif /* QUERY_AFSID */
ioctlp->flags |= CM_IOCTLFLAG_LOGON;
}
- cm_ResetACLCache(userp);
+ cm_ResetACLCache(cellp, userp);
if (release_userp)
cm_ReleaseUser(userp);
lock_ReleaseMutex(&userp->mx);
- cm_ResetACLCache(userp);
+ cm_ResetACLCache(cellp, userp);
return 0;
}
lock_ReleaseMutex(&userp->mx);
- cm_ResetACLCache(userp);
+ cm_ResetACLCache(NULL, userp);
return 0;
}
cm_DumpVolumes(hLogFile, cookie, 1);
cm_DumpSCache(hLogFile, cookie, 1);
cm_DumpBufHashTable(hLogFile, cookie, 1);
+ cm_DumpServers(hLogFile, cookie, 1);
smb_DumpVCP(hLogFile, cookie, 1);
rx_DumpCalls(hLogFile, cookie);
rx_DumpPackets(hLogFile, cookie);
git://git.openafs.org / openafs.git / blobdiff