// IFsNameLookup.bcpl -- Network directory lookup routines.
// Adapted from PupNetDirLookup.bcpl, but making use of the IFS
// name server facilities
// Copyright Xerox Corporation 1979, 1980, 1981, 1983
// Last modified September 18, 1983 2:18 PM by Taft
get "Pup0.decl"
get "Pup1.decl"
get "IfsMisc.decl"
get "IfsName.decl"
external
[
// outgoing procedures
EnumeratePupAddresses; PrintPort
// incoming procedures
NameLookup; AddressLookup; PutTemplate
OpenLevel1Socket; CloseLevel1Socket; CompletePup
GetPBI; ReleasePBI; AppendStringToPup; LocateNet
SetTimer; TimerHasExpired; Block; Dismiss; Dequeue; Min
Wss; SetBlock; MoveBlock; Zero; DefaultArgs; Allocate; Free
// incoming statics
sysZone
]
manifest maxNPorts = 35 // maximum number of ports we'll consider in answer
//----------------------------------------------------------------------------
let EnumeratePupAddresses(name, filter, arg, dontCheckRT; numargs na) = valof
//----------------------------------------------------------------------------
// An exact replacement for the Pup package procedure of the same name.
// Evaluates name to one or more addresses. For each address, calls
// filter(port, arg), where port is that address and arg is the arg passed
// to EnumeratePupAddresses. If filter returns true, enumeration stops; if
// false, enumeration continues. Ordinarily the addresses are enumerated in
// order of increasing distance away from here (hop count), and inaccessible
// addresses are omitted; however, if dontCheckRT is supplied and true,
// the addresses are not sorted and are all returned.
// Filter defaults to TakeTheFirst, which treats arg as a pointer to a Port
// and copies the first Pup address to that port, discarding the rest.
// Returns zero if successful and an error code (from IfsName.decl)
// if unsuccessful.
[
DefaultArgs(lv na, -1, TakeTheFirst, 0, false)
let ports = Allocate(sysZone, maxNPorts*lenPort)
let result = valof
[
let nPorts = NameLookup(name, ports, maxNPorts*lenPort)
if nPorts ge ecNameFirst then
[ // failed, see why
unless nPorts eq ecNameServerDisabled resultis nPorts
// Reason for failure was that the local name server was locked.
// Try asking some other name server before giving up.
nPorts = ecNoServerResponded
let soc = vec lenPupSoc-1
// Default transient local socket, zero foreign socket
OpenLevel1Socket(soc, 0, 0, true)
soc>>PupSoc.frnPort.socket↑2 = socketMiscServices
for try = 1 to 20 do
[
let pbi = GetPBI(soc, true) // try to avoid pbi deadlock
if pbi ne 0 then
[
AppendStringToPup(pbi, 1, name)
pbi>>PBI.allNets = true // send on all directly connected nets
CompletePup(pbi, ptNameLookup)
]
let wait = nil; SetTimer(lv wait, 100) // 1 sec
[ // repeat
Block()
pbi = Dequeue(lv soc>>PupSoc.iQ)
if pbi ne 0 then
[
switchon pbi>>PBI.pup.type into
[
case ptNetDirError:
nPorts = ecNameNotFound
endcase
case ptNameReply:
nPorts = Min((pbi>>PBI.pup.length-pupOvBytes)/6,
maxNPorts)
MoveBlock(ports, lv pbi>>PBI.pup.words, nPorts*lenPort)
endcase
]
ReleasePBI(pbi)
if nPorts ne ecNoServerResponded break
]
] repeatuntil TimerHasExpired(lv wait)
if nPorts ne ecNoServerResponded break
]
CloseLevel1Socket(soc)
if nPorts ge ecNameFirst resultis nPorts
]
// EnumeratePupAddresses (cont'd)
// Obtain hop counts for sorting
let hopsVec = vec maxNPorts-1
SetBlock(hopsVec, (dontCheckRT? 0, maxHops+1), nPorts)
let nRoutesFound = 0
test dontCheckRT
ifso // Return all the ports that we got
nRoutesFound = nPorts
ifnot // Look up route for each port
for try = 0 to 20 do
[
// Even tries just look in the routing table; odd tries initiate probes.
// The purpose of this dance is to get all the information we can from the
// existing routing table before initiating probes that might displace
// useful entries already there. This can happen if the name we are looking
// up maps to more networks than there are entries in the routing cache.
let dontProbe = (try & 1) eq 0
for i = 0 to nPorts-1 do
if hopsVec!i gr maxHops then
[
let rte = LocateNet((ports+i*lenPort)>>Port.net, dontProbe)
if rte ne 0 then
[
hopsVec!i = rte>>RTE.hops
if hopsVec!i le maxHops then nRoutesFound = nRoutesFound+1
]
]
if nRoutesFound eq nPorts % (nRoutesFound gr 0 & try ge 4) break
unless dontProbe do Dismiss(100)
]
// Emit answers in increasing order of hop count, being careful to maintain
// the existing order of addresses at equal distances.
// This is effectively an n↑2 sort, but n is small, right?
let hops = 0
while hops le maxHops do
[
let nextHops = maxHops+1
for i = 0 to nPorts-1 do
[
if hopsVec!i eq hops & filter(ports+i*lenPort, arg) then
[ nextHops = maxHops+1; break ]
if hopsVec!i gr hops then nextHops = Min(nextHops, hopsVec!i)
]
hops = nextHops
]
resultis nRoutesFound eq 0? ecCantGetThere, 0
]
Free(sysZone, ports)
resultis result
]
//----------------------------------------------------------------------------
and TakeTheFirst(argPort, resultPort) = valof
//----------------------------------------------------------------------------
[
MoveBlock(resultPort, argPort, lenPort)
resultis true
]
//----------------------------------------------------------------------------
and PrintPort(stream, port) be
//----------------------------------------------------------------------------
// Prints a port as a name expression if possible, else as net#host#socket.
[
if AddressLookup(stream, port) ne 0 then
[
PutTemplate(stream, "$O#$O#", port>>Port.net, port>>Port.host)
if port>>Port.socket↑1 ne 0 % port>>Port.socket↑2 ne 0 then
PutTemplate(stream, "$UEO", lv port>>Port.socket)
]
]