// IfsLogConn.bcpl - authentication (Login and Connect)
// Copyright Xerox Corporation 1979, 1981, 1982
// Last modified April 11, 1982 3:01 PM by Taft
get "Ifs.decl"
get "IfsFiles.decl"
get "IfsDirs.decl"
get "Grapevine.decl"
external
[
// outgoing procedures
CreateUserInfo; DestroyUserInfo; Login; Connect; FindDIF
// incoming procedures
GetDIF; UpdateCachedDIF; CheckAccess; MakeQualifiedRName; WheelCall
IFSOpenFile; FilePos; ChangeFileAttributes; StreamsFD; PutTemplate; Closes
MakeKey; Authenticate
StringCompare; ExtractSubstring; RNamesEqual
Password; ReadCalendar; DoubleSubtract; DoubleUsc
SysAllocateZero; SysFree; Zero; MoveBlock; FreePointer; DefaultArgs
// outgoing statics
enablePasswordLog
// incoming statics
enableGrapevineAuth; enableGrapevineGroup
]
static
[
enablePasswordLog = false
]
// User name conventions:
// If Grapevine authentication is not enabled, user and connect names
// must exactly match the names of the DIFs to which access is being gained.
// If Grapevine authentication is enabled, user names not qualified by
// registry are assumed to belong to the default registry, except in the
// case where the qualified name does not exist in Grapevine but does exist
// (qualified or unqualified) as a local DIF.
// UserInfo.userName is always fully-qualified except in the latter case.
// With respect to presence or absence of qualification, UserInfo.connName
// always matches the name of the local DIF, and it is not possible to
// connect to a directory for which no DIF exists.
//---------------------------------------------------------------------------
let CreateUserInfo() = SysAllocateZero(lenUserInfo)
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
and DestroyUserInfo(ui) be
//---------------------------------------------------------------------------
[
FreePointer(lv ui>>UserInfo.userName, lv ui>>UserInfo.connName,
lv ui>>UserInfo.defaultDir, lv ui)
]
//---------------------------------------------------------------------------
and Login(name, password, ui, force; numargs na) = valof
//---------------------------------------------------------------------------
// Name may be qualified or unqualified; if unqualified, defaultRegistry
// is assumed. If force then suppress files-only and password check.
// Returns: 0 if ok, an error code otherwise.
// Updates UserInfo structure iff successful (changes only userName,
// connName, capabilities, and userGroups).
[
if na le 3 then force = false
if name eq 0 % name>>String.length eq 0 resultis ecNamePasswordRequired
let res = 0
if ui>>UserInfo.userName eq 0 % // currently not logged in?
not RNamesEqual(name, ui>>UserInfo.userName) then // different name?
[
let difName = 0
let dif = GetDIF(name, false, lv difName)
res = valof
[
if dif eq 0 then
[
// no local DIF found. We can now succeed only if Grapevine
// authenticates the name/password; and login cannot be forced.
if not enableGrapevineAuth % force resultis ecUserName
// set up a blank DIF that perhaps will be validated by Grapevine.
dif = SysAllocateZero(lenDIF)
dif>>DIF.nonexistentDIF = true
difName = MakeQualifiedRName(name)
]
unless force do
[
if dif>>DIF.filesOnly resultis ecFilesOnly
let ec = ValidateDIF(dif, difName, password)
if ec ne 0 resultis ec
]
// successful login. Update names in UserInfo block.
// userName is fully qualified except in the case of a name for
// which a local DIF exists but which Grapevine never heard of.
// connName always matches the local DIF (if there is one).
FreePointer(lv ui>>UserInfo.userName, lv ui>>UserInfo.connName,
lv ui>>UserInfo.defaultDir)
ui>>UserInfo.userName = dif>>DIF.validGrapevineRName?
MakeQualifiedRName(difName), ExtractSubstring(difName)
ui>>UserInfo.connName = difName
difName = 0
if enablePasswordLog & not force then
[ // Password logging hack
let s = WheelCall(IFSOpenFile, "<System>Ifs.test", 0, modeAppend)
if s ne 0 then
[
if FilePos(s) eq 0 then
WheelCall(ChangeFileAttributes, StreamsFD(s), ZeroAttr)
PutTemplate(s, "$S $S*n", ui>>UserInfo.userName, password)
Closes(s)
]
]
ui>>UserInfo.capabilities = dif>>DIF.capabilities
MoveBlock(lv ui>>UserInfo.userGroups, lv dif>>DIF.userGroups,
lenProtection)
resultis 0
]
FreePointer(lv difName, lv dif)
]
resultis res
]
//---------------------------------------------------------------------------
and Connect(name, password, ui) = valof
//---------------------------------------------------------------------------
// name = 0 or name.length = 0 means connect to the user's login directory.
// Returns: 0 if ok, an error code otherwise.
// Updates connName in UserInfo structure iff successful.
// Checks password only if something has changed.
[
if name eq 0 % name>>String.length eq 0 then name = ui>>UserInfo.userName
let res = 0
unless RNamesEqual(name, ui>>UserInfo.connName) do
[
let difName = 0
let dif = GetDIF(name, false, lv difName)
res = valof
[
if dif eq 0 % dif>>DIF.nonexistentDIF then
// permit connecting to nonexistent DIF only if Grapevine
// authentication is enabled and the connect name matches
// the login name.
unless RNamesEqual(difName, ui>>UserInfo.userName) do
resultis ecConnectName
// Permit connect to succeed if:
// (1) connecting to login directory;
// (2) user is owner of directory;
// (3) user is member of connect groups of directory; or
// (4) password is the correct one for the directory.
unless RNamesEqual(difName, ui>>UserInfo.userName) % // (1)
RNamesEqual(ui>>UserInfo.userName, lv dif>>DIF.owner) % // (2)
CheckAccess(lv dif>>DIF.connectProt, false) % // (3)
ValidateDIF(dif, difName, password) eq 0 do // (4)
resultis ecConnectPassword
// success. Install actual DIF name (if it exists) as connect name.
SysFree(ui>>UserInfo.connName)
ui>>UserInfo.connName = difName
difName = 0
resultis 0
]
FreePointer(lv dif, lv difName)
]
resultis res
]
//---------------------------------------------------------------------------
and ZeroAttr(fd, ld, nil) = valof
//---------------------------------------------------------------------------
[
Zero(lv ld>>ILD.fileProt, lenFileProt)
ld>>ILD.noBackup = true
resultis true
]
//---------------------------------------------------------------------------
and ValidateDIF(dif, name, password) = valof
//---------------------------------------------------------------------------
// Interacts with Grapevine, if appropriate, to verify that name and
// password are (still) authentic. If necessary, updates the DIF.
// To call ValidateDIF for a nonexistent local directory, the caller must
// construct a blank DIF -- a block of length lenDIF whose contents are all
// zero. A nonexistent DIF is recognizable by its nonexistentDIF bit
// being true. In this case, if validation is successful, the password is
// filled in and the DIF is inserted into the cache.
// Returns zero if successful, or an error code describing the outcome:
// ecUserName DIF is nonexistent and Grapevine never heard of name.
// ecUnknownUserName DIF is nonexistent and Grapevine is unresponsive.
// ecUserPassword Either Grapevine rejected the password, or Grapevine
// is unresponsive and the password does not match DIF.
[
if password eq 0 % password>>String.length eq 0 resultis ecUserPassword
let difPassword = lv dif>>DIF.password
let localPwdOk = difPassword!0 ne 0 & Password(password, difPassword, false)
if enableGrapevineAuth then
[
let time = vec 1; ReadCalendar(time)
DoubleSubtract(time, table [ 0; 124300B ]) // 12 hours
unless localPwdOk & DoubleUsc(lv dif>>DIF.timeLastValid, time) gr 0 do
[ // password wrong or DIF is stale -- time to ask Grapevine again
let key = vec lenPassword
MakeKey(password, key)
let rName = MakeQualifiedRName(name)
let ec = Authenticate(rName, key)
SysFree(rName)
switchon ec into
[
case ecIndividual:
// successfully authenticated -- update the DIF
Password(password, difPassword, true)
ReadCalendar(lv dif>>DIF.timeLastValid)
dif>>DIF.validGrapevineRName = true
if enableGrapevineGroup then
// forget user group membership -- require it to be
// determined afresh from Grapevine when needed.
Zero(lv dif>>DIF.userGroups, lenProtection)
UpdateCachedDIF(name, dif)
resultis 0
case ecBadPassword:
resultis ecUserPassword
case ecBadRName:
if localPwdOk then
[
// Grapevine doesn't know about this name, but we do and
// the password matches the local DIF.
ReadCalendar(lv dif>>DIF.timeLastValid)
dif>>DIF.validGrapevineRName = false
UpdateCachedDIF(name, dif)
]
endcase
// case ecAllDown:
default:
// depend on the information in the local DIF, but do not
// update its timeLastValid.
if difPassword!0 eq 0 resultis ecUnknownUserName
]
]
]
resultis localPwdOk? 0, difPassword!0 eq 0? ecUserName, ecUserPassword
]