
    <<SunRPCAuthImpl.mesa>>
        <<Demers, September 15, 1987 10:22:12 pm PDT>>

    DIRECTORY
        BasicTime USING [earliestGMT, GMT, Now, Period],
        Booting USING [RegisterProcs, RollbackProc],
        Process USING [Detach, PauseMsec],
        RefText USING [New],
        Rope USING [ROPE],
        SunRPCAuth USING [AuthenticateProc, AuthenticateResult, CheckReplyVerifierProc, ConversationObject, Flavor, 
        GetCredentialsAndNextVerifierProc, InitiateProc, NoShortcutProc, nullFlavor, ProcsObject, SweepProc, TerminateProc]
        ;

    SunRPCAuthImpl: CEDAR MONITOR
        IMPORTS BasicTime, Booting, Process, RefText
        EXPORTS SunRPCAuth
        ~ {

    <<Types>>
        ROPE: TYPE ~ Rope.ROPE;

        Flavor: TYPE ~ SunRPCAuth.Flavor;
        nullFlavor: Flavor ~ SunRPCAuth.nullFlavor;

        OpaqueValue: TYPE ~ REF TEXT;
        nullOpaqueValue: OpaqueValue _ RefText.New[0];

        Conversation: TYPE ~ REF ConversationObject;
        ConversationObject: TYPE ~ SunRPCAuth.ConversationObject;

        Procs: TYPE ~ REF ProcsObject;
        ProcsObject: TYPE ~ SunRPCAuth.ProcsObject;

        GetCredentialsAndNextVerifierProc: TYPE ~ SunRPCAuth.GetCredentialsAndNextVerifierProc;
        CheckReplyVerifierProc: TYPE ~ SunRPCAuth.CheckReplyVerifierProc;
        NoShortcutProc: TYPE ~ SunRPCAuth.NoShortcutProc;
        TerminateProc: TYPE ~ SunRPCAuth.TerminateProc;

        InitiateProc: TYPE ~ SunRPCAuth.InitiateProc;
        AuthenticateProc: TYPE ~ SunRPCAuth.AuthenticateProc;
        SweepProc: TYPE ~ SunRPCAuth.SweepProc;

        AuthenticateResult: TYPE ~ SunRPCAuth.AuthenticateResult;

        Error: PUBLIC ERROR [code: ATOM] ~ CODE;
    <<Parameters>>
        numFlavors: CARDINAL ~ 5;
        msecBetweenSweeps: CARD _ 30*1000;
    <<Registration>>
        Registrations: TYPE ~ ARRAY [0..numFlavors) OF Registration;
        Registration: TYPE ~ REF RegistrationObject;
        RegistrationObject: TYPE ~ RECORD [
            initiateProc: InitiateProc,
            authenticateProc: AuthenticateProc,
            sweepProc: SweepProc, 
            data: REF
            ];

        registrations: REF Registrations _ NEW[Registrations];

        Register: PUBLIC PROC [flavor: Flavor, initiate: InitiateProc, authenticate: AuthenticateProc, sweep: SweepProc, registrationData: 
        REF] ~ {
            flavorIndex: CARD _ flavor;
            registration: Registration _ NIL;
            IF flavorIndex >= numFlavors THEN ERROR Error[$flavorOutOfRange];
            IF (initiate # NIL) AND (authenticate # NIL) THEN {
                registration _ NEW[RegistrationObject];
                registration.initiateProc _ initiate;
                registration.authenticateProc _ authenticate;
                registration.sweepProc _ sweep;
                registration.data _ registrationData;
                };
            registrations[flavorIndex] _ registration;
            };
    <<Daemon>>
        Daemon: PROC ~ {
            DO
                Process.PauseMsec[msecBetweenSweeps];
            DoSweeps[];
                ENDLOOP;
            };

        lastSweepTime: BasicTime.GMT _ BasicTime.earliestGMT;

        DoSweeps: ENTRY PROC [rollingBack: BOOL _ FALSE] ~ {
            now: BasicTime.GMT;
            secondsSinceLastSweep: CARD;

            now _ BasicTime.Now[];
            secondsSinceLastSweep _ BasicTime.Period[
                from~IF rollingBack THEN BasicTime.earliestGMT ELSE lastSweepTime,
                to~now];
            FOR i: CARDINAL IN [0 .. numFlavors) DO
                r: Registration ~ registrations[i];
                IF (r # NIL) AND (r.sweepProc # NIL) THEN r.sweepProc[r.data, secondsSinceLastSweep];
                ENDLOOP;
            lastSweepTime _ now;
            };

        Rollback: Booting.RollbackProc ~ {
            DoSweeps[rollingBack~TRUE];
            };
    <<Servers>>
        Authenticate: PUBLIC PROC [cFlavor: Flavor, credentials: OpaqueValue, vFlavor: Flavor, verifier: OpaqueValue]
            RETURNS [result: AuthenticateResult, replyFlavor: Flavor, replyVerifier: OpaqueValue, c: Conversation]
            ~ {
            flavorIndex: CARD;
            registration: Registration;
            IF ((flavorIndex _ cFlavor) >= numFlavors)
            OR ((registration _ registrations[flavorIndex]) = NIL)
                THEN RETURN [result~badCredentials, replyFlavor~nullFlavor, replyVerifier~NIL, c~NIL];
            [result, replyFlavor, replyVerifier, c] _ registration.authenticateProc[cFlavor, credentials, vFlavor, verifier, registration.data];
            };
    <<Clients>>
        Initiate: PUBLIC PROC [flavor: Flavor, myName, myPassword: ROPE, hisName: ROPE]
            RETURNS [c: Conversation] ~ {
            flavorIndex: CARD;
            registration: Registration;
            IF (flavorIndex _ flavor) >= numFlavors THEN ERROR Error[$flavorOutOfRange];
            IF (registration _ registrations[flavorIndex]) = NIL THEN ERROR Error[$flavorNotRegistered];
            c _ registration.initiateProc[flavor, myName, myPassword, hisName, registration.data];
            };

    <<Null Flavor>>
        nullClientConversation: Conversation;
        nullClientProcs: Procs;
        nullServerConversation: Conversation;

        NullInitiate: InitiateProc ~ { RETURN[nullClientConversation] };

        NullNoShortcut: NoShortcutProc ~ { RETURN [FALSE] };

        NullTerminate: TerminateProc ~ { NULL };

        NullGetCredentialsAndNextVerifier: GetCredentialsAndNextVerifierProc ~ {
            cFlavor _ vFlavor _ nullFlavor;
            credentials _ nullOpaqueValue;
            verifier _ nullOpaqueValue;
            };

        NullCheckReplyVerifier: CheckReplyVerifierProc ~ { RETURN[ok] };

        NullAuthenticate: AuthenticateProc ~ {
            RETURN [result~ok, replyFlavor~nullFlavor, replyVerifier~nullOpaqueValue, c~nullServerConversation];
            };

        RegisterNull: PROC ~ {
            nullClientProcs _ NEW[ProcsObject _ [NullGetCredentialsAndNextVerifier, NullCheckReplyVerifier, NullNoShortcut, NullTerminate]];
            nullClientConversation _ NEW[ConversationObject _ [nullFlavor, nullClientProcs, NIL]];
            nullServerConversation _ NEW[ConversationObject _ [nullFlavor, NIL, NIL]];

            Register[nullFlavor, NullInitiate, NullAuthenticate, NIL, NIL];
            };
    <<Initialization>>
        RegisterNull[];
        TRUSTED { Process.Detach[ FORK Daemon[] ] };
        Booting.RegisterProcs[r: Rollback];

        }...