Credential exchange is no user initiated. We also do some nudging to send it when an appropriate encounter was created.

Author: thsc42

libs/ASAPJava.jar

@@ -15,13 +15,14 @@ public MessageReceivedListener(SharkMessengerApp sharkMessengerApp) {
     public void sharkMessagesReceived(CharSequence uri) {
         try {
             SharkMessageList messages = this.sharkMessengerApp.getSharkMessengerComponent().getChannel(uri).getMessages();
-            System.out.println("TODO in MessageReceivedListener: show messages");
-            //cliModel.observer.displayMessages(messages);
+            StringBuilder sb = new StringBuilder();
+            sb.append(messages.size());
+            sb.append("messages received in channel ");
+            sb.append(uri);
+            this.sharkMessengerApp.tellUI(sb.toString());
 
         } catch (SharkMessengerException | IOException e) {
-            System.out.println("TODO: exception in MessageReceivedListener:" + e.getLocalizedMessage());
-
-//            cliModel.observer.onChannelDisappeared(uri.toString());
+            this.sharkMessengerApp.tellUIError("exception when receiving messages:" + e.getLocalizedMessage());
         }
     }
 }

libs/SharkPKI.jar

@@ -123,7 +123,7 @@ public static void main(String[] args) throws SharkException, IOException {
         // TCP connection management
         smUI.addCommand(new UICommandOpenTCP(sharkMessengerApp, smUI, "openTCP", false));
         smUI.addCommand(new UICommandConnectTCP(sharkMessengerApp, smUI, "connectTCP", false));
-        smUI.addCommand(new UICommandCloseTCP(sharkMessengerApp, smUI, "closeTCPPort", false));
+        smUI.addCommand(new UICommandCloseTCP(sharkMessengerApp, smUI, "closeTCP", false));
         smUI.addCommand(new UICommandShowOpenTCPPorts(sharkMessengerApp, smUI, "showOpenTCPPorts", false));
 
         // encounter control
@@ -133,6 +133,7 @@ public static void main(String[] args) throws SharkException, IOException {
         smUI.addCommand(new UICommandShowCertificatesByIssuer(sharkMessengerApp, smUI, "certByIssuer", true));
         smUI.addCommand(new UICommandShowCertificatesBySubject(sharkMessengerApp, smUI, "certBySubject", true));
         smUI.addCommand(new UICommandShowPendingCredentials(sharkMessengerApp, smUI, "showCredentials", true));
+        smUI.addCommand(new UICommandSendCredentialMessage(sharkMessengerApp, smUI, "sendCredential", true));
         smUI.addCommand(new UICommandAcceptCredential(sharkMessengerApp, smUI, "acceptCredential", true));
         smUI.addCommand(new UICommandRefuseCredential(sharkMessengerApp, smUI, "refuseCredential", true));
 

libs/SharkPeer.jar

@@ -2,9 +2,12 @@
 
 import net.sharksystem.SharkException;
 import net.sharksystem.SharkPeer;
+import net.sharksystem.SharkPeerEncounterChangedListener;
 import net.sharksystem.SharkPeerFS;
 import net.sharksystem.asap.*;
 import net.sharksystem.asap.apps.TCPServerSocketAcceptor;
+import net.sharksystem.asap.pki.ASAPCertificate;
+import net.sharksystem.asap.utils.DateTimeHelper;
 import net.sharksystem.fs.ExtraData;
 import net.sharksystem.fs.FSUtils;
 import net.sharksystem.hub.HubConnectionManager;
@@ -27,7 +30,7 @@
  * Proposed and suggested pattern for Shark app. Implement a central entity (could even be a singleton)
  * that provides access to any component that is part of this application
  */
-public class SharkMessengerApp {
+public class SharkMessengerApp implements SharkPeerEncounterChangedListener {
     private final SharkPeerFS sharkPeerFS;
 
     //private static final CharSequence ROOTFOLDER = "sharkMessengerDataStorage";
@@ -79,9 +82,13 @@ public SharkMessengerApp(String peerName, ExtraData settings) throws SharkExcept
         //System.out.println("Fill PKI with example data - for testing purposes");
         //HelperPKITests.fillWithExampleData(this.pkiComponent);
 
+        // get informed about encounter changes
+        this.sharkPeerFS.addSharkPeerEncounterChangedListener(this);
+
         //////////////////////// setup hub connection management
         // TODO: that's still a design flaw. We need something that extracts a connection handler from a peer. Do we?
         ASAPPeer asapPeer = this.sharkPeerFS.getASAPPeer();
+
         ASAPConnectionHandler asapHandler = (ASAPConnectionHandler) asapPeer;
         // this code runs on service side - this peer should be a connection handler
         if (asapPeer instanceof ASAPConnectionHandler) { // TODO: aaaaargs
@@ -262,6 +269,46 @@ public void acceptPendingCredentialMessageOnIndex(int index) throws ASAPSecurity
         this.actionOnPendingCredentialMessageOnIndex(index, true);
     }
 
+    /////////////////////////////////////////////////////////////////////////////////////////////
+    //                                 environment changed handling                            //
+    /////////////////////////////////////////////////////////////////////////////////////////////
+
+    @Override
+    public void encounterStarted(CharSequence peerID) {
+        this.tellUI("\nnew encounter: " + peerID);
+
+        // check if better ask for a (fresh) certificate?
+        try {
+            try {
+                ASAPCertificate certificateByIssuerAndSubject =
+                        this.getSharkPKIComponent().
+                                getCertificateByIssuerAndSubject(peerID, this.getSharkPeer().getPeerID());
+
+                ;
+                StringBuilder sb = new StringBuilder();
+                sb.append("\nYou have an encounter with peer ");
+                sb.append(peerID);
+                sb.append(". It issued a certificate for you that runs out ");
+                sb.append(DateTimeHelper.
+                        long2DateString(certificateByIssuerAndSubject.getValidUntil().getTimeInMillis()));
+                this.tellUI(sb.toString());
+            }
+            catch(ASAPSecurityException ase) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("\nPeer ");
+                sb.append(peerID);
+                sb.append(" has not yet issued a certificate for you. You are connected now. A good time to ask for one?");
+                this.tellUI(sb.toString());
+            }
+        } catch (SharkException e) {
+            this.tellUIError("unexpected problems when dealing with present certificates: " + e.getLocalizedMessage());
+        }
+    }
+
+    @Override
+    public void encounterTerminated(CharSequence peerID) {
+        this.tellUI("\nterminated encounter: " + peerID);
+    }
     /////////////////////////////////////////////////////////////////////////////////////////////
     //                                    communicate with UI                                  //
     /////////////////////////////////////////////////////////////////////////////////////////////
@@ -278,4 +325,5 @@ public void tellUI(String message) {
     public void tellUIError(String message) {
         this.errStream.println(message);
     }
+
 }

src/net/sharksystem/cmdline/sharkmessengerUI/MessageReceivedListener.java

@@ -3,32 +3,20 @@
 import net.sharksystem.asap.ASAPEncounterManagerAdmin;
 import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerApp;
 import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerUI;
-import net.sharksystem.cmdline.sharkmessengerUI.UICommand;
-import net.sharksystem.cmdline.sharkmessengerUI.commandarguments.UICommandQuestionnaire;
+import net.sharksystem.cmdline.sharkmessengerUI.commands.helper.AbstractCommandNoParameter;
 
 import java.util.Iterator;
 import java.util.List;
 
-public class UICommandShowEncounter extends UICommand {
+public class UICommandShowEncounter extends AbstractCommandNoParameter {
     public UICommandShowEncounter(SharkMessengerApp sharkMessengerApp, SharkMessengerUI sharkMessengerUI,
                                   String identifier, boolean rememberCommand) {
         super(sharkMessengerApp, sharkMessengerUI, identifier, rememberCommand);
     }
 
-    @Override
-    protected boolean handleArguments(List<String> arguments) {
-        return true;
-    }
-
-    @Override
-    protected UICommandQuestionnaire specifyCommandStructure() {
-        return null;
-    }
-
     @Override
     protected void execute() throws Exception {
         ASAPEncounterManagerAdmin encounterManagerAdmin = this.getSharkMessengerApp().getEncounterManagerAdmin();
-
         Iterator<CharSequence> connectPeersIter = encounterManagerAdmin.getConnectedPeerIDs().iterator();
 
         if(connectPeersIter == null || !connectPeersIter.hasNext()) {

src/net/sharksystem/cmdline/sharkmessengerUI/ProductionUI.java

@@ -0,0 +1,45 @@
+package net.sharksystem.cmdline.sharkmessengerUI.commands.helper;
+
+import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerApp;
+import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerUI;
+import net.sharksystem.cmdline.sharkmessengerUI.UICommand;
+import net.sharksystem.cmdline.sharkmessengerUI.commandarguments.UICommandIntegerArgument;
+import net.sharksystem.cmdline.sharkmessengerUI.commandarguments.UICommandQuestionnaire;
+import net.sharksystem.cmdline.sharkmessengerUI.commandarguments.UICommandStringArgument;
+
+import java.util.List;
+
+public abstract class AbstractCommandWithSingleString extends UICommand {
+    private UICommandStringArgument stringArgument;
+
+    public AbstractCommandWithSingleString(SharkMessengerApp sharkMessengerApp, SharkMessengerUI sharkMessengerUI,
+                                           String identifier, boolean rememberCommand) {
+        super(sharkMessengerApp, sharkMessengerUI, identifier, rememberCommand);
+
+        this.stringArgument = new UICommandStringArgument(sharkMessengerApp);
+    }
+
+    @Override
+    protected boolean handleArguments(List<String> arguments) {
+        if (arguments.size() < 1) {
+            this.getSharkMessengerApp().tellUI("string argument required");
+            return false;
+        } else {
+            boolean isParsable = this.stringArgument.tryParse(arguments.get(0));
+            if (!isParsable) {
+                System.err.println("failed to parse string value" + arguments.get(0));
+            }
+            return isParsable;
+        }
+    }
+
+    protected String getStringArgument() {
+        return this.stringArgument.getValue();
+    }
+
+    @Override
+    protected UICommandQuestionnaire specifyCommandStructure() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'specifyCommandStructure'");
+    }
+}

src/net/sharksystem/cmdline/sharkmessengerUI/SharkMessengerApp.java

@@ -0,0 +1,26 @@
+package net.sharksystem.cmdline.sharkmessengerUI.commands.pki;
+
+import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerApp;
+import net.sharksystem.cmdline.sharkmessengerUI.SharkMessengerUI;
+import net.sharksystem.cmdline.sharkmessengerUI.commands.helper.AbstractCommandWithSingleString;
+
+public class UICommandSendCredentialMessage extends AbstractCommandWithSingleString {
+    public UICommandSendCredentialMessage(SharkMessengerApp sharkMessengerApp, SharkMessengerUI sharkMessengerUI,
+                                          String identifier, boolean rememberCommand) {
+        super(sharkMessengerApp, sharkMessengerUI, identifier, rememberCommand);
+    }
+
+    @Override
+    protected void execute() throws Exception {
+        String peerID = this.getStringArgument();
+        this.getSharkMessengerApp().tellUI("going to send credential message to peer " + peerID);
+        this.getSharkMessengerApp().getSharkPKIComponent().sendOnlineCredentialMessage(peerID);
+    }
+
+    @Override
+    public String getDescription() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Send a credential message to a specific peer to ask for a certificate.");
+        return sb.toString();
+    }
+}