Store return paths for announced keys.

2 files changed, 18 insertions, 16 deletions

diff --git a/Tox.hs b/Tox.hs
index 4459a08f..d8bf11bc 100644
--- a/Tox.hs
+++ b/Tox.hs
@@ -703,7 +703,9 @@ newClient addr = do
             , tableMethods = tbl
             }
 
-        handler typ f = Just $ MethodHandler (S.decode . msgData) (encodePayload typ) f
+        handler typ f = Just $ MethodHandler (S.decode . msgData) (encodePayload typ) (f . (\(ToxPath ni _)->ni))
+
+        handler' typ f = Just $ MethodHandler (S.decode . msgData) (encodePayload typ) f
 
         -- (decryptAssymetric secret) (encryptAssymetric secret . cryptoNonce) f
 
@@ -713,7 +715,7 @@ newClient addr = do
         handlers :: Tox.PacketKind -> Maybe Handler
         handlers PingType       = handler PongType pingH
         handlers GetNodesType   = handler SendNodesType $ getNodesH routing
-        handlers AnnounceType   = handler AnnounceResponseType $ announceH routing toks keydb
+        handlers AnnounceType   = handler' AnnounceResponseType $ announceH routing toks keydb
         {-
         handlers var OnionRequest0  = noreply OnionRequest0
                                       $ onionSend0H (symmetricCipher (return symkey)
@@ -750,7 +752,7 @@ newClient addr = do
                     -> ToxClient
         mkclient (tbl,var) handlers = Client
             { clientNet           = net
-            , clientDispatcher    = dispatch tbl var (fmap (contramapAddr (\(ToxPath ni _) -> ni)) . handlers)
+            , clientDispatcher    = dispatch tbl var handlers -- (fmap (contramapAddr (\(ToxPath ni _) -> ni)) . handlers)
             , clientErrorReporter = (printErrors stderr) { reportTimeout = reportTimeout ignoreErrors }
             , clientPending       = var
             , clientAddress       = \maddr -> atomically $ do
@@ -875,7 +877,7 @@ decodePayload :: S.Serialize a => Message ByteString -> Either String a
 decodePayload msg = S.decode $ dropEnd8 $ msgPayload msg
 -}
 
-type Handler = MethodHandler String TransactionId NodeInfo Msg
+type Handler = MethodHandler String TransactionId ToxPath Msg
 
 {-
 noreply :: Tox.PacketKind
@@ -1160,8 +1162,8 @@ getNodesH routing addr (GetNodes nid) = do
 -- The reason for this 20 second timeout in toxcore is that it gives a reasonable
 -- time (20 to 40 seconds) for a peer to announce himself while taking in count
 -- all the possible delays with some extra seconds.
-announceH :: Routing -> TVar SessionTokens -> TVar AnnouncedKeys -> NodeInfo -> AnnounceRequest -> IO AnnounceResponse
-announceH routing toks keydb naddr req = do
+announceH :: Routing -> TVar SessionTokens -> TVar AnnouncedKeys -> ToxPath -> AnnounceRequest -> IO AnnounceResponse
+announceH routing toks keydb (ToxPath naddr retpath) req = do
     case () of
         _ | announcePingId req == zeros32
           -> go False
@@ -1177,22 +1179,22 @@ announceH routing toks keydb naddr req = do
         let storing = (nodeId naddr == announceSeeking req)
         record <- atomically $ do
             when (withTok && storing) $ do
-                let ni = Tox.Aliased (naddr { nodeId = announceKey req })
+                let toxpath = ToxPath naddr{ nodeId = announceKey req } retpath
                     -- Note: The following distance calculation assumes that
                     -- our nodeid doesn't change and is the same for both
                     -- routing4 and routing6.
                     d = xor (nodeId (tentativeId routing))
                             (announceSeeking req)
-                modifyTVar' keydb (insertKey tm (announceSeeking req) ni d)
+                modifyTVar' keydb (insertKey tm (announceSeeking req) toxpath d)
             ks <- readTVar keydb
             return $ snd <$> MinMaxPSQ.lookup' (announceSeeking req) (keyAssoc ks)
         newtok <- if storing
                     then Nonce32 . toPaddedByteString 32 <$> grantToken toks naddr
                     else return $ zeros32
         let k = case record of
-                Nothing                         -> NotStored newtok
-                Just (Tox.Aliased ni) | storing -> Acknowledged newtok
-                Just (Tox.Aliased ni)           -> SendBackKey (nodeId ni)
+                Nothing                     -> NotStored newtok
+                Just (ToxPath {}) | storing -> Acknowledged newtok
+                Just (ToxPath ni _)         -> SendBackKey (nodeId ni)
         return $ AnnounceResponse k ns
 
 {-
@@ -1330,11 +1332,11 @@ type NodeDistance = Tox.PubKey
 
 data AnnouncedKeys = AnnouncedKeys
     { keyByAge :: PSQ NodeId (Down POSIXTime) -- timeout of 300 seconds
-    , keyAssoc :: MinMaxPSQ' Tox.PubKey NodeDistance (Tox.Aliased NodeInfo)
+    , keyAssoc :: MinMaxPSQ' Tox.PubKey NodeDistance ToxPath
     }
 
-insertKey :: POSIXTime -> Tox.PubKey -> Tox.Aliased NodeInfo -> NodeDistance -> AnnouncedKeys -> AnnouncedKeys
-insertKey tm pub ni d keydb = AnnouncedKeys
+insertKey :: POSIXTime -> Tox.PubKey -> ToxPath -> NodeDistance -> AnnouncedKeys -> AnnouncedKeys
+insertKey tm pub toxpath d keydb = AnnouncedKeys
     { keyByAge = PSQ.insert pub (Down tm) (keyByAge keydb)
-    , keyAssoc = MinMaxPSQ.insert' pub ni d (keyAssoc keydb)
+    , keyAssoc = MinMaxPSQ.insert' pub toxpath d (keyAssoc keydb)
     }
diff --git a/ToxMessage.hs b/ToxMessage.hs
index 06026b49..56758e48 100644
--- a/ToxMessage.hs
+++ b/ToxMessage.hs
@@ -210,7 +210,7 @@ data Packet where
 
     DHTRequest :: PubKey -> Assymetric -> Packet -- 0x20 -- Sometimes Assymetric query
 
-    DataToRoute :: PubKey -> Aliased Assymetric -> Packet
+    DataToRoute :: PubKey -> Aliased Assymetric -> ReturnPath 3 -> Packet
     DataToRouteResponse :: Aliased Assymetric -> Packet
 
     LanDiscovery :: PubKey -> Packet  -- 0x21