#include <afs/param.h>
#include <afs/stds.h>
+#include <afs/cellconfig.h>
+#include <afs/ptserver.h>
+#include <ubik.h>
#ifndef DJGPP
#include <windows.h>
#include <strsafe.h>
#include <winioctl.h>
#include <..\afsrdr\kif.h>
+#include <rx\rx.h>
#ifdef _DEBUG
#include <crtdbg.h>
lock_InitializeMutex(&cm_Afsdsbmt_Lock, "AFSDSBMT.INI Access Lock");
}
+long cm_CleanFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
+{
+ long code;
+
+ lock_ObtainWrite(&scp->bufCreateLock);
+ code = buf_CleanVnode(scp, userp, reqp);
+
+ lock_ObtainMutex(&scp->mx);
+ cm_DiscardSCache(scp);
+ lock_ReleaseMutex(&scp->mx);
+
+ lock_ReleaseWrite(&scp->bufCreateLock);
+ osi_Log2(afsd_logp,"cm_CleanFile scp 0x%x returns error: [%x]",scp, code);
+ return code;
+}
+
long cm_FlushFile(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
{
long code;
code = buf_FlushCleanPages(scp, userp, reqp);
lock_ObtainMutex(&scp->mx);
- scp->cbServerp = NULL;
- scp->cbExpires = 0;
- cm_dnlcPurgedp(scp);
- cm_dnlcPurgevp(scp);
- cm_FreeAllACLEnts(scp);
+ cm_DiscardSCache(scp);
+
lock_ReleaseMutex(&scp->mx);
lock_ReleaseWrite(&scp->bufCreateLock);
- afsi_log("cm_FlushFile scp 0x%x returns error: [%x]",scp, code);
+ osi_Log2(afsd_logp,"cm_FlushFile scp 0x%x returns error: [%x]",scp, code);
+ return code;
+}
+
+long cm_FlushParent(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
+{
+ long code = 0;
+ cm_scache_t * pscp;
+
+ pscp = cm_FindSCacheParent(scp);
+
+ /* now flush the file */
+ code = cm_FlushFile(pscp, userp, reqp);
+ cm_ReleaseSCache(scp);
+
+ return code;
+}
+
+
+long cm_FlushVolume(cm_user_t *userp, cm_req_t *reqp, afs_uint32 cell, afs_uint32 volume)
+{
+ long code = 0;
+ cm_scache_t *scp;
+ int i;
+
+ lock_ObtainWrite(&cm_scacheLock);
+ for (i=0; i<cm_data.hashTableSize; i++) {
+ for (scp = cm_data.hashTablep[i]; scp; scp = scp->nextp) {
+ if (scp->fid.volume == volume && scp->fid.cell == cell) {
+ cm_HoldSCacheNoLock(scp);
+ lock_ReleaseWrite(&cm_scacheLock);
+
+ /* now flush the file */
+ code = cm_FlushFile(scp, userp, reqp);
+ lock_ObtainWrite(&cm_scacheLock);
+ cm_ReleaseSCacheNoLock(scp);
+ }
+ }
+ }
+ lock_ReleaseWrite(&cm_scacheLock);
+
return code;
}
userp, ioctlp->tidPathp, reqp, &substRootp);
if (code) return code;
- code = cm_NameI(substRootp, tbuffer, CM_FLAG_FOLLOW,
+ code = cm_NameI(substRootp, tbuffer, CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW,
userp, NULL, reqp, scpp);
if (code) return code;
}
scp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
scp->fid.volume==AFS_FAKE_ROOT_VOL_ID &&
scp->fid.vnode==0x1 && scp->fid.unique==0x1 ) {
- StringCbCopyA(ioctlp->outDatap, 999999, "Freelance.Local.Root");
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "Freelance.Local.Root");
ioctlp->outDatap += strlen(ioctlp->outDatap) + 1;
code = 0;
} else
{
cellp = cm_FindCellByID(scp->fid.cell);
if (cellp) {
- StringCbCopyA(ioctlp->outDatap, 999999, cellp->name);
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), cellp->name);
ioctlp->outDatap += strlen(ioctlp->outDatap) + 1;
code = 0;
}
return code;
}
+
+
long cm_IoctlFlushAllVolumes(struct smb_ioctl *ioctlp, struct cm_user *userp)
{
long code;
long code;
cm_scache_t *scp;
unsigned long volume;
- int i;
+ unsigned long cell;
cm_req_t req;
cm_InitReq(&req);
if (code) return code;
volume = scp->fid.volume;
+ cell = scp->fid.cell;
cm_ReleaseSCache(scp);
- lock_ObtainWrite(&cm_scacheLock);
- for (i=0; i<cm_data.hashTableSize; i++) {
- for (scp = cm_data.hashTablep[i]; scp; scp = scp->nextp) {
- if (scp->fid.volume == volume) {
- cm_HoldSCacheNoLock(scp);
- lock_ReleaseWrite(&cm_scacheLock);
-
- /* now flush the file */
- code = cm_FlushFile(scp, userp, &req);
- lock_ObtainWrite(&cm_scacheLock);
- cm_ReleaseSCacheNoLock(scp);
- }
- }
- }
- lock_ReleaseWrite(&cm_scacheLock);
+ code = cm_FlushVolume(userp, &req, cell, volume);
return code;
}
cp = ioctlp->outDatap;
memcpy(cp, (char *)&volStat, sizeof(VolumeStatus));
cp += sizeof(VolumeStatus);
- StringCbCopyA(cp, 999999, volName);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), volName);
cp += strlen(volName)+1;
- StringCbCopyA(cp, 999999, offLineMsg);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), offLineMsg);
cp += strlen(offLineMsg)+1;
- StringCbCopyA(cp, 999999, motd);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), motd);
cp += strlen(motd)+1;
/* now return updated return data pointer */
cp = ioctlp->outDatap;
memcpy(cp, (char *)&volStat, sizeof(AFSFetchVolumeStatus));
cp += sizeof(AFSFetchVolumeStatus);
- StringCbCopyA(cp, 999999, volName);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), volName);
cp += strlen(volName)+1;
- StringCbCopyA(cp, 999999, offLineMsg);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), offLineMsg);
cp += strlen(offLineMsg)+1;
- StringCbCopyA(cp, 999999, motd);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), motd);
cp += strlen(motd)+1;
/* return new size */
code = cm_ReadMountPoint(scp, userp, &req);
if (code == 0) {
cp = ioctlp->outDatap;
- StringCbCopyA(cp, 999999, scp->mountPointStringp);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), scp->mountPointStringp);
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
}
if ((inValue & 1) == 0) {
/* disable tracing */
osi_LogDisable(afsd_logp);
+ rx_DebugOnOff(FALSE);
}
else {
/* enable tracing */
osi_LogEnable(afsd_logp);
+ rx_DebugOnOff(TRUE);
}
}
}
lock_ReleaseRead(&cm_serverLock);
cp = basep + max * sizeof(afs_int32);
- StringCbCopyA(cp, 999999, tcellp->name);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), tcellp->name);
cp += strlen(tcellp->name)+1;
ioctlp->outDatap = cp;
}
for (cp = cm_data.allCellsp; cp; cp=cp->nextp)
{
long code;
+ lock_ObtainMutex(&cp->mx);
/* delete all previous server lists - cm_FreeServerList will ask for write on cm_ServerLock*/
cm_FreeServerList(&cp->vlServersp);
cp->vlServersp = NULL;
cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
cm_RandomizeServer(&cp->vlServersp);
}
+ lock_ReleaseMutex(&cp->mx);
}
lock_ReleaseWrite(&cm_cellLock);
if (cm_freelanceEnabled) {
if (cm_GetRootCellName(ioctlp->outDatap))
- StringCbCopyA(ioctlp->outDatap, 999999, "Freelance.Local.Root");
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "Freelance.Local.Root");
ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
} else if (cm_data.rootCellp) {
/* return the default cellname to the caller */
- StringCbCopyA(ioctlp->outDatap, 999999, cm_data.rootCellp->name);
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), cm_data.rootCellp->name);
ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
} else {
/* if we don't know our default cell, return failure */
memcpy(cp, (char *)&foundname, sizeof(afs_int32));
cp += sizeof(afs_int32); /* skip found flag */
if (foundname) {
- StringCbCopyA(cp, 999999, outname);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), outname);
cp += strlen(outname) + 1; /* skip name and terminating null char */
for ( count=1; count < foundname ; ++count) { /* ... or list */
if ( !(*sysnamelist)[count] )
if (t >= MAXSYSNAME)
osi_panic("cm_IoctlSysName: sysname entry garbled\n",
__FILE__, __LINE__);
- StringCbCopyA(cp, 999999, (*sysnamelist)[count]);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), (*sysnamelist)[count]);
cp += t + 1;
}
}
/* set preferences for an existing vlserver */
cm_ChangeRankCellVLServer(tsp);
}
- cm_PutServer(tsp); /* decrease refcount */
}
else /* add a new server without a cell */
{
tsp = cm_NewServer(&tmp, type, NULL); /* refcount = 1 */
tsp->ipRank = rank;
}
+ lock_ObtainMutex(&tsp->mx);
+ tsp->flags |= CM_SERVERFLAG_PREF_SET;
+ lock_ReleaseMutex(&tsp->mx);
+ cm_PutServer(tsp); /* decrease refcount */
}
return 0;
}
if (code == 0) {
cp = ioctlp->outDatap;
if (newRootScp != NULL) {
- StringCbCopyA(cp, 999999, cm_mountRoot);
- StringCbCatA(cp, 999999, "/");
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), cm_mountRoot);
+ StringCbCatA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), "/");
cp += strlen(cp);
}
- StringCbCopyA(cp, 999999, spacep->data);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), spacep->data);
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
cm_FreeSpace(spacep);
code == CM_ERROR_NOSUCHPATH &&
scp->fileType == CM_SCACHETYPE_INVALID) {
cp = ioctlp->outDatap;
- StringCbCopyA(cp, 999999, spacep->data);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), spacep->data);
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
cm_FreeSpace(spacep);
return code;
}
+long cm_UsernameToId(char *uname, cm_ucell_t * ucellp, afs_uint32* uid)
+{
+ afs_int32 code;
+ namelist lnames;
+ idlist lids;
+ static struct afsconf_cell info;
+ struct rx_connection *serverconns[MAXSERVERS];
+ struct rx_securityClass *sc[3];
+ afs_int32 scIndex = 2; /* authenticated - we have a token */
+ struct ubik_client *pruclient = NULL;
+ struct afsconf_dir *tdir;
+ int i;
+ char * p, * r;
+
+ tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH);
+ code = afsconf_GetCellInfo(tdir, ucellp->cellp->name, "afsprot", &info);
+ afsconf_Close(tdir);
+
+ sc[0] = 0;
+ sc[1] = 0;
+ sc[2] = 0;
+
+ /* we have the token that was given to us in the settoken
+ * call. we just have to use it.
+ */
+ scIndex = 2; /* kerberos ticket */
+ sc[2] = rxkad_NewClientSecurityObject(rxkad_clear, &ucellp->sessionKey,
+ ucellp->kvno, ucellp->ticketLen,
+ ucellp->ticketp);
+
+ memset(serverconns, 0, sizeof(serverconns)); /* terminate list!!! */
+ for (i = 0; i < info.numServers; i++)
+ serverconns[i] =
+ rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
+ info.hostAddr[i].sin_port, PRSRV, sc[scIndex],
+ scIndex);
+
+ code = ubik_ClientInit(serverconns, &pruclient);
+ if (code) {
+ return code;
+ }
+
+ code = rxs_Release(sc[scIndex]);
+
+ lids.idlist_len = 0;
+ lids.idlist_val = 0;
+ lnames.namelist_len = 1;
+ lnames.namelist_val = (prname *) malloc(PR_MAXNAMELEN);
+ strncpy(lnames.namelist_val[0], uname, PR_MAXNAMELEN);
+ lnames.namelist_val[0][PR_MAXNAMELEN-1] = '\0';
+ for ( p=lnames.namelist_val[0], r=NULL; *p; p++ ) {
+ if (isupper(*p))
+ *p = tolower(*p);
+ if (*p == '@')
+ r = p;
+ }
+ if (r && !stricmp(r+1,ucellp->cellp->name))
+ *r = '\0';
+
+ code = ubik_Call(PR_NameToID, pruclient, 0, &lnames, &lids);
+ if (lids.idlist_val) {
+ *uid = *lids.idlist_val;
+ free(lids.idlist_val);
+ }
+ if (lnames.namelist_val)
+ free(lnames.namelist_val);
+
+ if ( pruclient ) {
+ ubik_ClientDestroy(pruclient);
+ pruclient = NULL;
+ }
+
+ return 0;
+}
+
+
long cm_IoctlSetToken(struct smb_ioctl *ioctlp, struct cm_user *userp)
{
char *saveDataPtr;
int flags;
char sessionKey[8];
char *smbname;
+ int release_userp = 0;
+ char * wdir = NULL;
saveDataPtr = ioctlp->inDatap;
}
if (flags & PIOCTL_LOGON) {
- userp = smb_FindCMUserByName(smbname, ioctlp->fidp->vcp->rname);
+ userp = smb_FindCMUserByName(smbname, ioctlp->fidp->vcp->rname,
+ SMB_FLAG_CREATE|SMB_FLAG_AFSLOGON);
+ release_userp = 1;
}
/* store the token */
ucellp->kvno = ct.AuthHandle;
ucellp->expirationTime = ct.EndTimestamp;
ucellp->gen++;
- if (uname)
+ ucellp->uid = ANONYMOUSID;
+ if (uname) {
StringCbCopyA(ucellp->userName, MAXKTCNAMELEN, uname);
+
+ cm_UsernameToId(uname, ucellp, &ucellp->uid);
+ }
ucellp->flags |= CM_UCELLFLAG_RXKAD;
lock_ReleaseMutex(&userp->mx);
cm_ResetACLCache(userp);
+ if (release_userp)
+ cm_ReleaseUser(userp);
+
return 0;
}
cp += sizeof(temp);
/* cell name */
- StringCbCopyA(cp, 999999, ucellp->cellp->name);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->cellp->name);
cp += strlen(cp) + 1;
/* user name */
- StringCbCopyA(cp, 999999, ucellp->userName);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->userName);
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
cp += sizeof(temp);
/* cell name */
- StringCbCopyA(cp, 999999, ucellp->cellp->name);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->cellp->name);
cp += strlen(cp) + 1;
/* user name */
- StringCbCopyA(cp, 999999, ucellp->userName);
+ StringCbCopyA(cp, SMB_IOCTL_MAXDATA - (cp - ioctlp->outAllocp), ucellp->userName);
cp += strlen(cp) + 1;
ioctlp->outDatap = cp;
free(ucellp->ticketp);
ucellp->ticketp = NULL;
}
+ ucellp->ticketLen = 0;
+ memset(ucellp->sessionKey.data, 0, 8);
+ ucellp->kvno = 0;
+ ucellp->expirationTime = 0;
+ ucellp->userName[0] = '\0';
ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
ucellp->gen++;
for (ucellp = userp->cellInfop; ucellp; ucellp = ucellp->nextp) {
osi_Log1(smb_logp,"cm_IoctlDelAllToken ucellp %lx", ucellp);
+
+ if (ucellp->ticketp) {
+ free(ucellp->ticketp);
+ ucellp->ticketp = NULL;
+ }
+ ucellp->ticketLen = 0;
+ memset(ucellp->sessionKey.data, 0, 8);
+ ucellp->kvno = 0;
+ ucellp->expirationTime = 0;
+ ucellp->userName[0] = '\0';
ucellp->flags &= ~CM_UCELLFLAG_RXKAD;
ucellp->gen++;
}
(DWORD)strlen(&afspath[strlen(cm_mountRoot)])+1:2);
RegCloseKey( hkSubmounts );
- StringCbCopyA(ioctlp->outDatap, 999999, submountreqp);
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountreqp);
ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
return 0;
*/
cm_NormalizeAfsPath (submountPathNormalized, sizeof(submountPathNormalized), submountPath);
if (!strcmp (submountPathNormalized, afspath)) {
- StringCbCopyA(ioctlp->outDatap, 999999, submountreqp);
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountreqp);
ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
RegCloseKey( hkSubmounts );
lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
*/
cm_NormalizeAfsPath (submountPathNormalized, sizeof(submountPathNormalized), submountPath);
if (!strcmp (submountPathNormalized, afspath)) {
- StringCbCopyA(ioctlp->outDatap, 999999, submountName);
+ StringCbCopyA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), submountName);
ioctlp->outDatap += strlen(ioctlp->outDatap) +1;
RegCloseKey(hkSubmounts);
lock_ReleaseMutex(&cm_Afsdsbmt_Lock);
* when writing out the submount.
*/
- StringCbPrintfA(ioctlp->outDatap, 999999, "auto%ld", nextAutoSubmount);
+ StringCbPrintfA(ioctlp->outDatap, SMB_IOCTL_MAXDATA - (ioctlp->outDatap - ioctlp->outAllocp), "auto%ld", nextAutoSubmount);
RegSetValueEx( hkSubmounts,
ioctlp->outDatap,
long cm_IoctlSetRxkcrypt(smb_ioctl_t *ioctlp, cm_user_t *userp)
{
+ afs_int32 c = cryptall;
+
cm_SkipIoctlPath(ioctlp);
memcpy(&cryptall, ioctlp->inDatap, sizeof(cryptall));
+ if (c != cryptall) {
+ if (cryptall)
+ LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_ON);
+ else
+ LogEvent(EVENTLOG_INFORMATION_TYPE, MSG_CRYPT_OFF);
+ }
return 0;
}
git://git.openafs.org / openafs.git / blobdiff