Partitioned friend-request transport from the onion transport.

1 files changed, 69 insertions, 3 deletions

diff --git a/src/Network/Tox/Onion/Transport.hs b/src/Network/Tox/Onion/Transport.hs
index 989b06fd..3e3596a6 100644
--- a/src/Network/Tox/Onion/Transport.hs
+++ b/src/Network/Tox/Onion/Transport.hs
@@ -17,9 +17,12 @@
 module Network.Tox.Onion.Transport
     ( parseOnionAddr
     , encodeOnionAddr
+    , parseDataToRoute
+    , encodeDataToRoute
     , forwardOnions
     , OnionDestination(..)
     , OnionMessage(..)
+    , Rendezvous(..)
     , DataToRoute(..)
     , AnnounceResponse(..)
     , AnnounceRequest(..)
@@ -44,7 +47,7 @@ import Network.QueryResponse
 import Crypto.Tox hiding (encrypt,decrypt)
 import Network.Tox.NodeId
 import qualified Crypto.Tox as ToxCrypto
-import Network.Tox.DHT.Transport (NodeInfo(..),NodeId(..),SendNodes(..),nodeInfo,DHTPublicKey,asymNodeInfo)
+import Network.Tox.DHT.Transport (NodeInfo(..),NodeId(..),SendNodes(..),nodeInfo,DHTPublicKey,FriendRequest,asymNodeInfo)
 
 import Debug.Trace
 import Control.Arrow
@@ -561,13 +564,39 @@ instance Serialize DataToRoute where
     get = DataToRoute <$> getPublicKey <*> get
     put (DataToRoute k dta) = putPublicKey k >> put dta
 
-data OnionData = OnionDHTPublicKey DHTPublicKey -- 0x9c
+data OnionData
+  = -- | type 0x9c
+    --
+    -- We send this packet every 30 seconds if there is more than one peer (in
+    -- the 8) that says they our friend is announced on them. This packet can
+    -- also be sent through the DHT module as a DHT request packet (see DHT) if
+    -- we know the DHT public key of the friend and are looking for them in the
+    -- DHT but have not connected to them yet. 30 second is a reasonable
+    -- timeout to not flood the network with too many packets while making sure
+    -- the other will eventually receive the packet. Since packets are sent
+    -- through every peer that knows the friend, resending it right away
+    -- without waiting has a high likelihood of failure as the chances of
+    -- packet loss happening to all (up to to 8) packets sent is low.
+    --
+    -- If a friend is online and connected to us, the onion will stop all of
+    -- its actions for that friend. If the peer goes offline it will restart
+    -- searching for the friend as if toxcore was just started.
+    OnionDHTPublicKey DHTPublicKey
+  | -- | type 0x20
+    --
+    --
+    OnionFriendRequest FriendRequest -- 0x20
 
 instance Sized OnionData where
-    size = VarSize $ \(OnionDHTPublicKey dhtpk) -> case size of
+    size = VarSize $ \case
+        OnionDHTPublicKey dhtpk -> case size of
             ConstSize n -> n -- Override because OnionData probably
                              -- should be treated as variable sized.
             VarSize f   -> f dhtpk
+        -- FIXME: inconsitantly, we have to add in the tag byte for this case.
+        OnionFriendRequest req -> 1 + case size of
+            ConstSize n -> n
+            VarSize f   -> f req
 
 encrypt :: TransportCrypto -> OnionMessage Identity -> OnionDestination r -> (OnionMessage Encrypted, OnionDestination r)
 encrypt crypto msg rpath = ( transcode ( (. (runIdentity . either id assymData))
@@ -625,12 +654,14 @@ sequenceMessage (OnionAnnounce a)        = fmap OnionAnnounce $ sequenceA $ fmap
 sequenceMessage (OnionAnnounceResponse n8 n24 dta) = OnionAnnounceResponse n8 n24 <$> uncomposed dta
 sequenceMessage (OnionToRoute pub a)     = pure $ OnionToRoute pub a
 sequenceMessage (OnionToRouteResponse a) = pure $ OnionToRouteResponse a
+-- sequenceMessage (OnionToRouteResponse a) = fmap OnionToRouteResponse $ sequenceA $ fmap uncomposed a
 
 transcode :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Assym (f a)) -> g a) -> OnionMessage f -> OnionMessage g
 transcode f (OnionAnnounce a)        = OnionAnnounce $ a { assymData = f (assymNonce a) (Right a) }
 transcode f (OnionAnnounceResponse n8 n24 dta) = OnionAnnounceResponse n8 n24 $ f n24 $ Left dta
 transcode f (OnionToRoute pub a)     = OnionToRoute pub     a
 transcode f (OnionToRouteResponse a) = OnionToRouteResponse a
+-- transcode f (OnionToRouteResponse a) = OnionToRouteResponse $ a { assymData = f (assymNonce a) (Right a) }
 
 
 data OnionRoute = OnionRoute
@@ -673,3 +704,38 @@ wrapOnion :: Serialize (Forwarding n msg) =>
            -> Forwarding (S n) msg
 wrapOnion skey nonce destkey saddr fwd =
     Forwarding (toPublic skey) $ encryptMessage skey destkey nonce (Addressed saddr fwd)
+
+
+-- TODO
+-- Two types of packets may be sent to Rendezvous via OnionToRoute requests.
+--
+--  (1) DHT public key packet (0x9c)
+--
+--  (2) Friend request
+data Rendezvous = Rendezvous
+    { rendezvousKey :: PublicKey
+    , rendezvousNode :: NodeInfo
+    }
+ deriving Eq
+
+instance Show Rendezvous where
+    show (Rendezvous k ni) = concat [show $ key2id k, ":", show ni]
+
+
+
+parseDataToRoute
+    :: TransportCrypto
+         -> (OnionMessage Encrypted,OnionDestination r)
+         -> Either (Assym (Encrypted DataToRoute),Rendezvous) (OnionMessage Encrypted, OnionDestination r)
+parseDataToRoute crypto (OnionToRouteResponse dta, od)
+                            = Left ( dta
+                                   , Rendezvous (onionAliasPublic crypto) $ onionNodeInfo od )
+parseDataToRoute _      msg = Right msg
+
+encodeDataToRoute :: TransportCrypto
+                     -> (Assym (Encrypted DataToRoute),Rendezvous)
+                     -> Maybe (OnionMessage Encrypted,OnionDestination r)
+encodeDataToRoute crypto (dta, Rendezvous pub ni)
+    = Just ( OnionToRoute pub -- Public key of destination node
+                          dta
+           , OnionDestination ni Nothing )