3 files changed, 66 insertions, 15 deletions

diff --git a/src/Network/Tox.hs b/src/Network/Tox.hs
index 69975c0a..149905d2 100644
--- a/src/Network/Tox.hs
+++ b/src/Network/Tox.hs
@@ -97,7 +97,7 @@ import Crypto.Tox
 import Data.Word64Map                        (fitsInInt)
 import qualified Data.Word64Map              (empty)
 import Network.Kademlia.Bootstrap            (forkPollForRefresh, bootstrap)
-import Network.Tox.Crypto.Transport          (NetCrypto, CryptoMessage)
+import Network.Tox.Crypto.Transport          (NetCrypto(..), CryptoMessage, HandshakeData(..), Handshake(..))
 import Network.Tox.Crypto.Handlers
 import qualified Network.Tox.DHT.Handlers    as DHT
 import qualified Network.Tox.DHT.Transport   as DHT
@@ -111,6 +111,7 @@ import Text.XXD
 import qualified Data.HashMap.Strict as HashMap
 import Data.HashMap.Strict (HashMap)
 import qualified Data.Map.Strict as Map
+import Control.Concurrent (threadDelay)
 
 
 newCrypto :: IO TransportCrypto
@@ -266,10 +267,22 @@ netCrypto tox myseckey theirpubkey = do
             hPutStrLn stderr ("netCrypto: (" ++ show mykeyAsId ++") friend not found (" ++ show theirkeyAsId ++ ").")
             return []
          Just contact@(Contact { contactKeyPacket     = mbKeyPkt
-                               , contactLastSeenAddr  = mbSAddr
+                               , contactLastSeenAddr  = Nothing
                                , contactFriendRequest = mbFR
                                , contactPolicy        = mbPolicy
                                }) -> do
+            hPutStrLn stderr ("netCrypto: (" ++ show mykeyAsId ++") no SockAddr for friend (" ++ show theirkeyAsId ++ "). TODO: search their node?")
+            return []
+         Just contact@(Contact { contactKeyPacket     = Nothing
+                               }) -> do
+            hPutStrLn stderr ("netCrypto: (" ++ show mykeyAsId ++") no DHT-key for friend (" ++ show theirkeyAsId ++ "). TODO: what?")
+            return []
+         Just contact@(Contact { contactKeyPacket     = Just keyPkt
+                               , contactLastSeenAddr  = Just saddr
+                               , contactFriendRequest = mbFR
+                               , contactPolicy        = mbPolicy
+                               }) | theirDhtKey <- DHT.dhtpk keyPkt -> do
+            -- Do we already have an active session with this user?
             sessionsMap <- atomically $ readTVar (netCryptoSessionsByKey (toxCryptoSessions tox) )
             let sessionUsesIdentity key session = key == ncMyPublicKey session
             case Map.lookup theirpubkey sessionsMap of
@@ -280,12 +293,45 @@ netCrypto tox myseckey theirpubkey = do
                 hPutStrLn stderr ("netCrypto: Already have a session for " ++ show mykeyAsId ++ "<-->" ++ show theirkeyAsId)
                 return matchedSessions
             -- if not, send handshake, this is separate session
-              Nothing -> error "netCrypto: todo"
+              Nothing -> do
                 -- if no session:
-                -- 1) send dht key, actually maybe send dht-key regardless
-                -- 2) if no IP, search for their node(dht-key)
-                -- 3) if no dht-key, output error message return empty
-                -- 4) send handshakes to last seen ip's, if any
+                -- Convert to NodeInfo, so we can send cookieRequest
+                let crypto = toxCryptoKeys tox
+                    client = toxDHT tox
+                case nodeInfo (key2id theirDhtKey) saddr of
+                   Left e   -> hPutStrLn stderr ("netCrypto: nodeInfo fail... " ++ e) >> return []
+                   Right ni -> do
+                    mbCookie <- DHT.cookieRequest crypto client (toPublic myseckey) ni
+                    case mbCookie of
+                      Nothing -> do
+                        hPutStrLn stderr ("netCrypto: (" ++ show mykeyAsId ++") <--> (" ++ show theirkeyAsId ++ ").")
+                        hPutStrLn stderr ("netCrypto: CookieRequest failed. TODO: dhtpkNodes thingy")
+                        return []
+                      Just cookie -> do
+                        let hp = HParam { hpOtherCookie = cookie
+                                        , hpMySecretKey = myseckey
+                                        , hpCookieRemotePubkey = theirpubkey
+                                        , hpCookieRemoteDhtkey = theirDhtKey
+                                        , hpTheirBaseNonce = error "netCrypto: Unreachable! hpTheirBaseNonce"
+                                        , hpTheirSessionKeyPublic = error "netCrypto: Unreachable! hpTheirSessionKeyPublic"
+                                        }
+                        n24' <- atomically $ transportNewNonce crypto
+                        state <- lookupSharedSecret crypto myseckey theirDhtKey n24'
+                        newBaseNonce <- atomically $ transportNewNonce crypto
+                        mbMyhandshakeData <- newHandShakeData crypto newBaseNonce hp saddr
+                        let encodeHandshake myhandshakeData = let plain = encodePlain myhandshakeData
+                                                                  encrypted = encrypt state plain
+                                                                  in Handshake { handshakeCookie = cookie
+                                                                               , handshakeNonce = n24'
+                                                                               , handshakeData = encrypted
+                                                                               }
+                        let myhandshake = encodeHandshake <$> mbMyhandshakeData
+                        case myhandshake of
+                            Nothing -> hPutStrLn stderr "netCrypto: failed to create HandshakeData." >> return []
+                            Just handshake -> do
+                                sendMessage (toxCrypto tox) saddr (NetHandshake handshake)
+                                threadDelay 1000000 -- delay 1 second
+                                netCrypto tox myseckey theirpubkey -- hopefully it will find an active session this time.
 
 getContactInfo :: Tox -> IO DHT.DHTPublicKey
 getContactInfo Tox{toxCryptoKeys,toxRouting} = join $ atomically $ do
diff --git a/src/Network/Tox/Crypto/Handlers.hs b/src/Network/Tox/Crypto/Handlers.hs
index bffb4280..0e349196 100644
--- a/src/Network/Tox/Crypto/Handlers.hs
+++ b/src/Network/Tox/Crypto/Handlers.hs
@@ -7,7 +7,7 @@ import Network.QueryResponse
 import Network.Tox.NodeId
 import Network.Tox.Crypto.Transport
 import Network.Tox.DHT.Transport (Cookie(..),CookieData(..), CookieRequest(..), NoSpam(..))
-import Network.Tox.DHT.Handlers (Client, cookieRequest, cookieRequestH )
+import Network.Tox.DHT.Handlers (Client, cookieRequest, createCookie )
 import Crypto.Tox
 import Control.Concurrent.STM
 import Network.Address
@@ -212,7 +212,7 @@ newHandShakeData crypto basenonce (HParam {hpOtherCookie,hpMySecretKey,hpCookieR
     = do
     freshCookie
       <- case  nodeInfo (key2id hpCookieRemoteDhtkey) addr  of
-            Right nodeinfo -> Just <$> cookieRequestH crypto nodeinfo (CookieRequest hpCookieRemotePubkey)
+            Right nodeinfo -> Just <$> createCookie crypto nodeinfo hpCookieRemotePubkey
             Left er        -> return Nothing
     let hinit                = hashInit
         Cookie n24 encrypted = hpOtherCookie
diff --git a/src/Network/Tox/DHT/Handlers.hs b/src/Network/Tox/DHT/Handlers.hs
index 9faee69a..327659a9 100644
--- a/src/Network/Tox/DHT/Handlers.hs
+++ b/src/Network/Tox/DHT/Handlers.hs
@@ -217,11 +217,8 @@ getNodesH routing addr (GetNodes nid) = do
 
     k = 4
 
-cookieRequestH :: TransportCrypto -> NodeInfo -> CookieRequest -> IO Cookie
-cookieRequestH crypto ni (CookieRequest remoteUserKey) = do
-    hPutStrLn stderr $ unlines
-        [ "CookieRequest! remoteUserKey=" ++ show (key2id remoteUserKey)
-        , "                      sender=" ++ show ni ]
+createCookie :: TransportCrypto -> NodeInfo -> PublicKey -> IO Cookie
+createCookie crypto ni remoteUserKey = do
     (n24,sym,us) <- atomically $ do
         n24 <- transportNewNonce crypto
         sym <- transportSymmetric crypto
@@ -234,9 +231,17 @@ cookieRequestH crypto ni (CookieRequest remoteUserKey) = do
             , dhtKey      = transportPublic crypto
             }
         edta = encryptSymmetric sym n24 dta
-    hPutStrLn stderr $ "CookieRequest! responding to " ++ show (key2id remoteUserKey)
     return $ Cookie n24 edta
 
+cookieRequestH :: TransportCrypto -> NodeInfo -> CookieRequest -> IO Cookie
+cookieRequestH crypto ni (CookieRequest remoteUserKey) = do
+    hPutStrLn stderr $ unlines
+        [ "CookieRequest! remoteUserKey=" ++ show (key2id remoteUserKey)
+        , "                      sender=" ++ show ni ]
+    x <- createCookie crypto ni remoteUserKey
+    hPutStrLn stderr $ "CookieRequest! responding to " ++ show (key2id remoteUserKey)
+    return x
+
 lanDiscoveryH :: Client -> NodeInfo -> NodeInfo -> IO (Maybe (Message -> Message))
 lanDiscoveryH client _ ni = do
     forkIO $ do