<<>>
    <<NetworkNameSunYPImpl.mesa>>
        <<Copyright Ó 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Demers, November 6, 1990 3:06 pm PST>>
        <<>>
        <<NOTE: There ought to be a generic bounded-size/timed-out/LRU cache mechanism this guy can use ...>>
        <<Willie-s, November 7, 1990 12:13 pm PST>>

    DIRECTORY
        Arpa,
        Convert,
        NetworkName,
        Rope,
        SunYPAgent
        ;

    NetworkNameSunYPImpl: CEDAR PROGRAM
        IMPORTS Convert, NetworkName, Rope, SunYPAgent
        ~ {
        OPEN NN: NetworkName;
    <<Types>>
        ROPE: TYPE ~ Rope.ROPE;
    <<Parameters>>
        hostsByName: ROPE Ź "hosts.byname";
        hostsByAddr: ROPE Ź "hosts.byaddr";

        servicesByName: ROPE Ź "services.byname";

        myFamily: ATOM Ź $ARPA;
        myFlavor: ATOM Ź $SunYP;
    <<Port Name Stuff>>
        PortNameMapEntry: TYPE ~ RECORD [
            portName: ROPE,
            port: ROPE
            ];

        portNameMapUDP: LIST OF PortNameMapEntry Ź NIL;
        portNameMapTCP: LIST OF PortNameMapEntry Ź NIL;

        InitPortNameMaps: PROC ~ {
            h: SunYPAgent.Handle Ź NIL;
            errorCode: ATOM Ź NIL;
            newMapUDP: LIST OF PortNameMapEntry Ź NIL;
            newMapTCP: LIST OF PortNameMapEntry Ź NIL;
            Insert: PROC [pn: ROPE, p: ROPE, proto: ROPE] ~ {
                SELECT TRUE FROM
                    Rope.Equal[proto, "TCP", FALSE] =>
                        newMapTCP Ź CONS[ PortNameMapEntry[pn, p], newMapTCP];
                    Rope.Equal[proto, "UDP", FALSE] =>
                        newMapUDP Ź CONS[ PortNameMapEntry[pn, p], newMapUDP];
                    ENDCASE => NULL;
                };
            {
                ENABLE SunYPAgent.Error => { errorCode Ź code; CONTINUE };
                key: ROPE;
                val, txt: REF TEXT;
                r, port, proto: ROPE;
                pos: INT;
                seq: SunYPAgent.TextSeq;
                ok: BOOL;

                h Ź SunYPAgent.ObtainHandle[];
                key Ź NIL;
                DO
                    {
                        ENABLE SunYPAgent.Error => IF code = $noMoreEntries THEN EXIT;
                        IF key = NIL
                            THEN [key, val] Ź SunYPAgent.First[h, servicesByName]
                            ELSE [key, val] Ź SunYPAgent.Next[h, servicesByName, key];
                        };
                    seq Ź SunYPAgent.Tokenize[val];
                    IF seq.length < 2 THEN LOOP;
                    txt Ź seq.refText[0];
                    IF (txt.length > 0) AND (txt[0] = '#) THEN LOOP;
                    txt Ź seq.refText[1];
                    IF (txt.length > 0) AND (txt[0] = '#) THEN LOOP;
                    r Ź Rope.FromRefText[txt];
                    pos Ź Rope.Find[r, "/"];
                    IF pos < 0 THEN LOOP;
                    proto Ź Rope.Substr[r, pos+1];
                    port Ź Rope.Substr[r, 0, pos];
                    [ok, port] Ź ConvertPortLiteral[port];
                    IF NOT ok THEN LOOP; 
                    Insert[Rope.FromRefText[seq.refText[0]], port, proto];
                    FOR i: INT IN [2 .. seq.length) DO
                        txt Ź seq.refText[i];
                        IF (txt.length > 0) AND (txt[0] = '#) THEN EXIT;
                        Insert[Rope.FromRefText[txt], port, proto];
                        ENDLOOP; 
                    ENDLOOP;
                };
            IF h # NIL THEN SunYPAgent.ReleaseHandle[h ! SunYPAgent.Error => CONTINUE];
            IF errorCode # NIL THEN ERROR NN.Error[ LIST[$serviceError, errorCode], "SunYPAgent Error" ];
            portNameMapTCP Ź newMapTCP;
            portNameMapUDP Ź newMapUDP;
            };

        LookupPortName: PROC [portName: ROPE] RETURNS [port: ROPE Ź NIL] ~ {
            IF (portNameMapUDP = NIL) AND (portNameMapTCP = NIL) THEN InitPortNameMaps[];
            FOR p: LIST OF PortNameMapEntry Ź portNameMapTCP, p.rest WHILE p # NIL DO
                IF Rope.Equal[portName, p.first.portName, FALSE] THEN RETURN [p.first.port];
                ENDLOOP;
            FOR p: LIST OF PortNameMapEntry Ź portNameMapUDP, p.rest WHILE p # NIL DO
                IF Rope.Equal[portName, p.first.portName, FALSE] THEN RETURN [p.first.port];
                ENDLOOP;
            ERROR NN.Error[ LIST[$notFound], "port name not found"];
            };

        LookupPort: PROC [port: ROPE] RETURNS [portName: ROPE] ~ {
            ok: BOOL;
            [ok, port] Ź ConvertPortLiteral[port];
            IF ok THEN {
                IF (portNameMapUDP = NIL) AND (portNameMapTCP = NIL) THEN InitPortNameMaps[];
                FOR p: LIST OF PortNameMapEntry Ź portNameMapTCP, p.rest WHILE p # NIL DO
                    IF Rope.Equal[port, p.first.port, FALSE] THEN RETURN [p.first.portName];
                    ENDLOOP;
                FOR p: LIST OF PortNameMapEntry Ź portNameMapUDP, p.rest WHILE p # NIL DO
                    IF Rope.Equal[port, p.first.port, FALSE] THEN RETURN [p.first.portName];
                    ENDLOOP;
                };
            ERROR NN.Error[ LIST[$notFound], "port name not found"];
            };
    <<Procs>>
        SplitNameOrAddress: PROC [name: ROPE] RETURNS [hostPart: ROPE Ź NIL, portPart: ROPE Ź NIL] ~ {
            portPos, hostLen: INT;
            pos: INT Ź 0;
            IF Rope.IsEmpty[name] THEN RETURN;
            SELECT TRUE FROM
                (pos Ź Rope.FindBackward[name, ":"]) >= 0 => {
                    portPos Ź pos+1;
                    hostLen Ź pos;
                    };
                (pos Ź Rope.FindBackward[name, "]"]) >= 0 => {
                    portPos Ź pos+1;
                    hostLen Ź pos+1;
                    };
                ENDCASE => {
                    portPos Ź Rope.Length[name];
                    hostLen Ź portPos;
                    };
            portPart Ź Rope.Substr[name, portPos];
            hostPart Ź Rope.Substr[name, 0, hostLen];
            IF (hostLen >= 2) AND (Rope.Fetch[hostPart, 0] = '[) AND (Rope.Fetch[hostPart, hostLen-1] = ']) THEN hostPart Ź 
            Rope.Substr[hostPart, 1, hostLen-2];
            };

        ConvertHostLiteral: PROC [literal: ROPE] RETURNS [ok: BOOL Ź FALSE, host: ROPE Ź NIL] ~ {
            ENABLE Convert.Error => CONTINUE;
            len: INT;
            host Ź Convert.RopeFromArpaAddress[
                IF Rope.IsEmpty[literal]
                THEN Arpa.nullAddress
                ELSE Convert.ArpaAddressFromRope[literal]
                ];
            len Ź Rope.Length[host];
            IF (len >= 2) AND (Rope.Fetch[host, 0] = '[)
                THEN host Ź Rope.Substr[host, 1, len-2];
            ok Ź TRUE;
            };

        LookupHostName: PROC [name: ROPE] RETURNS [addr: ROPE Ź NIL] ~ {
            h: SunYPAgent.Handle Ź NIL;
            errorCodes: LIST OF ATOM Ź NIL;
            matchedVal: REF TEXT Ź NIL;
            seq: SunYPAgent.TextSeq Ź NIL;
            {
                ENABLE SunYPAgent.Error => { errorCodes Ź LIST[$serviceError, code]; GOTO Out };
                h Ź SunYPAgent.ObtainHandle[];
                matchedVal Ź SunYPAgent.Match[h, hostsByName, name
                    ! SunYPAgent.Error => IF code = $keyNotFound THEN { errorCodes Ź LIST[$notFound]; GOTO Out }];
                seq Ź SunYPAgent.Tokenize[matchedVal];
                IF (seq # NIL) AND (seq.length > 0) THEN {
                    addr Ź Rope.FromRefText[seq.refText[0]];
                    };
                EXITS
                    Out => NULL;
                };
            IF h # NIL THEN SunYPAgent.ReleaseHandle[h ! SunYPAgent.Error => CONTINUE];
            IF errorCodes # NIL THEN ERROR NN.Error[ errorCodes, "SunYP lookup error" ];
            };

        ConvertPortLiteral: PROC [portLiteral: ROPE] RETURNS [ok: BOOL Ź FALSE, port: ROPE Ź NIL] ~ {
            ENABLE Convert.Error => CONTINUE;
            n: CARD;
            n Ź IF Rope.IsEmpty[portLiteral] THEN 0 ELSE Convert.CardFromRope[portLiteral];
            port Ź Convert.RopeFromCard[n];
            ok Ź TRUE;
            };

        AddressFromName: NN.AddressFromNameProc -- [r, name, portHint, components] RETURNS [addr] -- ~ {
            host, port, hostName, portName: ROPE Ź NIL;
            ok: BOOL;
            addr Ź NIL;
            [hostName, portName] Ź SplitNameOrAddress[name];
            SELECT components FROM
                host, hostAndPort => {
                    [ok, host] Ź ConvertHostLiteral[hostName];
                    IF NOT ok THEN host Ź LookupHostName[hostName]; -- ! NN.Error
                    };
                ENDCASE;
            SELECT components FROM
                port, hostAndPort => {
                    IF Rope.IsEmpty[portName] THEN portName Ź portHint;
                    [ok, port] Ź ConvertPortLiteral[portName];
                    IF NOT ok THEN port Ź LookupPortName[portName]; -- ! NN.Error
                    };
                ENDCASE;
            addr Ź host;
            IF NOT Rope.IsEmpty[portName] THEN addr Ź Rope.Cat[addr, ":", port];
            };

        LookupHost: PROC [host: ROPE] RETURNS [hostName: ROPE Ź NIL] ~ {
            h: SunYPAgent.Handle Ź NIL;
            errorCodes: LIST OF ATOM Ź NIL;
            matchedVal: REF TEXT Ź NIL;
            seq: SunYPAgent.TextSeq Ź NIL;
            ok: BOOL;
            {
                ENABLE SunYPAgent.Error => { errorCodes Ź LIST[$serviceError, code]; GOTO Out };
                h Ź SunYPAgent.ObtainHandle[];
                [ok, host] Ź ConvertHostLiteral[host];
                IF NOT ok THEN { errorCodes Ź LIST[$syntax]; GOTO Out };
                matchedVal Ź SunYPAgent.Match[h, hostsByAddr, host
                    ! SunYPAgent.Error => IF code = $keyNotFound THEN { errorCodes Ź LIST[$notFound]; GOTO Out }];
                seq Ź SunYPAgent.Tokenize[matchedVal];
                IF (seq # NIL) AND (seq.length > 1) THEN {
                    hostName Ź Rope.FromRefText[seq.refText[1]];
                    };
                EXITS
                    Out => NULL;
                };
            IF h # NIL THEN SunYPAgent.ReleaseHandle[h ! SunYPAgent.Error => CONTINUE];
            IF errorCodes # NIL THEN ERROR NN.Error[ errorCodes, "SunYP lookup error" ];
            };

        NameFromAddress: NN.NameFromAddressProc -- [r, addr, components] RETURNS [name] -- ~ {
            host, port, hostName, portName: ROPE Ź NIL;
            ok: BOOL;
            name Ź NIL;
            [host, port] Ź SplitNameOrAddress[addr];
            SELECT components FROM
                host, hostAndPort => {
                    IF NOT Rope.IsEmpty[host] THEN {
                        [ok, host] Ź ConvertHostLiteral[host];
                        IF NOT ok THEN ERROR NN.Error[ LIST[$syntax], "host address syntax"];
                        hostName Ź LookupHost[host]; -- ! NN.Error
                        };
                    };
                ENDCASE;
            SELECT components FROM
                port, hostAndPort => {
                    IF NOT Rope.IsEmpty[port] THEN {
                        [ok, port] Ź ConvertPortLiteral[port];
                        IF NOT ok THEN ERROR NN.Error[ LIST[$syntax], "port number syntax"];
                        {
                            ENABLE NN.Error => {
                                IF (codes # NIL) AND (codes.first = $notFound) AND (components = hostAndPort) THEN { portName Ź port; CONTINUE };
                                };
                            portName Ź LookupPort[port]; -- ! NN.Error
                            };
                        };
                    };
                ENDCASE;
            SELECT components FROM
                host => RETURN [hostName];
                port => RETURN [portName];
                hostAndPort => RETURN [Rope.Cat[hostName, ":", portName]];
                ENDCASE => ERROR;
            };

        RegisterSelf: PROC ~ {
            r: NN.Registration;
            RegistrationCallback: NN.RegistrationCallbackProc -- [oldRegistration] RETURNS [action, newRegistration] -- ~ {
                RETURN [insert, r];
                };
            r Ź NEW[NN.RegistrationObject Ź [
                family~myFamily,
                flavor~myFlavor,
                addressFromName~AddressFromName,
                nameFromAddress~NameFromAddress
                ]];
            NN.Register[myFamily, RegistrationCallback];
            };

        RegisterSelf[];
        }.