-- Transport mechanism: Maintain:  raw communications

-- [Juniper]<Grapevine>Maintain>MaintainComm.mesa

-- Andrew Birrell  14-Jan-82  9:37:23

DIRECTORY
BodyDefs	USING[ Connect, oldestTime, Password, Remark, RName ],
LocateDefs	USING[ FindRegServer, FoundServerInfo ],
MaintainPrivate	USING[ Failed, Handle, TypeRC ],
ProtocolDefs,
PupDefs		USING[ AppendPupAddress, PupAddress ];

MaintainComm: PROGRAM
IMPORTS LocateDefs, MaintainPrivate, ProtocolDefs, PupDefs
EXPORTS MaintainPrivate =

BEGIN

OPEN MaintainPrivate;

-- Actual communication with the registration servers --

Update: PUBLIC PROC[handle: MaintainPrivate.Handle,
                    op: ProtocolDefs.RSOperation, name: BodyDefs.RName,
                    value: BodyDefs.RName _ NIL,
                    connect: BodyDefs.Connect _ NIL,
                    remark: BodyDefs.Remark _ NIL,
                    key: BodyDefs.Password _ [0,0,0,0],
                    sendRList: PROC[ProtocolDefs.Handle] _ NIL ] =
   BEGIN
   rc: ProtocolDefs.ReturnCode =
               Operate[handle, op, name, value, connect, remark, key];
   END;


Operate: PUBLIC PROC[handle: MaintainPrivate.Handle,
                    op: ProtocolDefs.RSOperation, name: BodyDefs.RName,
                    value: BodyDefs.RName _ NIL,
                    connect: BodyDefs.Connect _ NIL,
                    remark: BodyDefs.Remark _ NIL,
                    key: BodyDefs.Password _ [0,0,0,0],
                    sendRList: PROC[ProtocolDefs.Handle] _ NIL ]
        RETURNS[ rc: ProtocolDefs.ReturnCode ] =
   BEGIN
   OPEN ProtocolDefs;
   TryUpdate: PROC[str: ProtocolDefs.Handle] =
      BEGIN
      SendRSOperation[str, op];
      IF op # NoOp THEN SendRName[str, name];
      SELECT op FROM
        IN [Expand..ReadEntry] =>
          SendTimestamp[str, BodyDefs.oldestTime];
        IdentifyCaller =>
          SendPassword[str:str, pw: key, key: [0,0,0,0]];
        IN [AddMember..DeleteFriend], NewName,
        IN [IsMemberDirect..IsFriendClosure] =>
          { IF value = NIL THEN ERROR; SendRName[str, value] };
        Authenticate, CreateIndividual, ChangePassword =>
          SendPassword[str:str, pw: key, key: handle.callerKey];
        ChangeConnect =>
          { IF connect = NIL THEN ERROR; SendConnect[str, connect] };
        ChangeRemark =>
          { IF remark = NIL THEN ERROR; SendRemark[str, remark] };
        AddListOfMembers =>
          { IF sendRList = NIL THEN ERROR; sendRList[str] };
      ENDCASE => NULL;
      SendNow[str];
      IF op # NoOp THEN rc _ ReceiveRC[str];
      END;
   oldBad: BOOLEAN _ FALSE;
   Create: PROC =
      BEGIN
      serverSite: STRING = [21] --377#377#177777|177777--;
      PupDefs.AppendPupAddress[serverSite, handle.serverAddr];
      handle.glass.WriteString[serverSite];
      handle.glass.WriteString[" ... "L];
      handle.glass.SendNow[];
      handle.str _ ProtocolDefs.CreateStream[handle.serverAddr];
      IF handle.authenticated
      THEN BEGIN
           SendRSOperation[handle.str, IdentifyCaller];
           ProtocolDefs.SendRName[handle.str, handle.caller];
           ProtocolDefs.SendPassword[str:handle.str,
                                     pw: handle.callerKey,
                                     key:[0,0,0,0]];
           ProtocolDefs.SendNow[handle.str];
           rc _ ReceiveRC[handle.str];
           IF rc.code # done
           THEN BEGIN
                handle.authenticated _ FALSE;
                handle.glass.WriteString[
                       "your name/password is not valid! ... "L];
                END; 
           END;
      END;
   Destroy: PROC =
      BEGIN
      IF handle.str # NIL THEN DestroyStream[handle.str];
      handle.str _ NIL;
      END;
   Accept: PROC[addr: PupDefs.PupAddress]RETURNS[BOOLEAN] =
      BEGIN
      addr.socket _ RegServerEnquirySocket;
      IF handle.str # NIL AND handle.serverAddr # addr THEN Destroy[];
      IF handle.str = NIL
      THEN BEGIN
           handle.serverAddr _ addr;
           Create[ ! Failed => GOTO failed];
           handle.addrKnown _ TRUE;
           END;
      RETURN[TRUE];
      EXITS failed => RETURN[FALSE]
      END;
   handle.glass.WriteString[" ... "L]; handle.glass.SendNow[];
   SELECT op FROM
     NoOp, CheckStamp, Authenticate, IdentifyCaller =>
       NULL;
   ENDCASE =>
     IF NOT handle.authenticated
     THEN { handle.glass.WriteString["please login first"L];
            ERROR MaintainPrivate.Failed[] }; 
   BEGIN
      IF handle.str # NIL
      THEN BEGIN
           TryUpdate[ handle.str ! Failed => GOTO streamGone ];
           EXITS streamGone => Destroy[];
           END;
      IF handle.str = NIL
      THEN BEGIN
           IF handle.addrKnown
           THEN Create[ ! Failed => GOTO notThere]
           ELSE BEGIN
                [] _ LocateDefs.FindRegServer["x.GV"L, Accept];
                IF handle.str = NIL THEN GOTO notThere;
                END;
           TryUpdate[handle.str ! Failed => GOTO notThere];
           END;
      IF rc.code = WrongServer
      THEN oldBad _ TRUE
      ELSE oldBad _ FALSE;
   EXITS notThere => { Destroy[]; oldBad _ TRUE };
   END;
   IF oldBad
   THEN BEGIN -- need to find the correct R-Server --
        foundInfo: LocateDefs.FoundServerInfo;
        handle.glass.WriteString["Locating registration server ... "L];
        foundInfo _ LocateDefs.FindRegServer[name, Accept];
        WITH foundInfo SELECT FROM
          notFound => rc _ [BadRName, notFound];
          allDown => rc _ [AllDown, notFound];
          found =>
            BEGIN
            TryUpdate[ handle.str ! Failed => GOTO down ];
            EXITS down =>
              { Destroy[]; rc _ [AllDown, notFound] };
            END;
        ENDCASE => ERROR;
        END;
   IF rc.code = done
   THEN handle.glass.WriteString["done"L]
   ELSE MaintainPrivate.TypeRC[handle, op, rc, name, value];
   END;

END.