WIP changing Tox packets.

1 files changed, 201 insertions, 87 deletions

diff --git a/Tox.hs b/Tox.hs
index bd5ebbc2..8ee065d6 100644
--- a/Tox.hs
+++ b/Tox.hs
@@ -70,10 +70,17 @@ import Network.BitTorrent.DHT.Search          (Search (..))
 import Text.Printf
 import qualified Crypto.Cipher.ChaChaPoly1305 as Symmetric
 import Data.Bitraversable (bisequence)
+import ToxMessage (quoted,bin2hex)
+import qualified ToxMessage as Tox
 
+{-
 newtype NodeId = NodeId ByteString
  deriving (Eq,Ord,ByteArrayAccess, Bits, Hashable)
+-}
+
+type NodeId = Tox.PubKey
 
+{-
 instance Show NodeId where
     show (NodeId bs) = C8.unpack $ Base16.encode bs
 
@@ -90,9 +97,10 @@ instance Read NodeId where
         , B.length bs == 32
                     = [ (NodeId bs, drop 64 str) ]
         | otherwise = []
+-}
 
 zeroID :: NodeId
-zeroID = NodeId $ B.replicate 32 0
+zeroID = Tox.PubKey $ B.replicate 32 0
 
 data NodeInfo = NodeInfo
   { nodeId   :: NodeId
@@ -128,7 +136,7 @@ instance FromJSON NodeInfo where
               <|> maybe empty (return . IPv4) (ip4str >>= readMaybe)
         let (bs,_) = Base16.decode (C8.pack nidstr)
         guard (B.length bs == 32)
-        return $ NodeInfo (NodeId bs) ip (fromIntegral (portnum :: Word16))
+        return $ NodeInfo (Tox.PubKey bs) ip (fromIntegral (portnum :: Word16))
 
 getIP :: Word8 -> S.Get IP
 getIP 0x02 = IPv4 <$> S.get
@@ -173,7 +181,7 @@ instance Read NodeInfo where
                       RP.char '@' RP.+++ RP.satisfy isSpace
                       addrstr <- parseAddr
                       nid <- case Base16.decode $ C8.pack hexhash of
-                              (bs,_) | B.length bs==32 -> return (NodeId bs)
+                              (bs,_) | B.length bs==32 -> return (Tox.PubKey bs)
                               _                        -> fail "Bad node id."
                       return (nid,addrstr)
     (nid,addrstr) <- ( nodeidAt RP.+++ ( (zeroID,) <$> parseAddr) )
@@ -217,40 +225,35 @@ nodeInfo nid saddr
 
 data TransactionId = TransactionId
  { transactionKey :: Nonce8  -- ^ Used to lookup pending query.
- , cryptoNonce    :: Nonce24 -- ^ Used during the encryption layer.
+ , cryptoNonce    :: Tox.Nonce24 -- ^ Used during the encryption layer.
  }
 
--- https://toktok.ltd/spec#packet-kind
---  calls this "Packet Kind"
-newtype Method = MessageType Word8
- deriving (Eq, Ord, S.Serialize)
-
-pattern PingType      = MessageType 0 -- 0x00     Ping Request
-pattern PongType      = MessageType 1 -- 0x01     Ping Response
-pattern GetNodesType  = MessageType 2 -- 0x02     Nodes Request
-pattern SendNodesType = MessageType 4 -- 0x04     Nodes Response
+pattern PingType      = Tox.PacketKind 0 -- 0x00     Ping Request
+pattern PongType      = Tox.PacketKind 1 -- 0x01     Ping Response
+pattern GetNodesType  = Tox.PacketKind 2 -- 0x02     Nodes Request
+pattern SendNodesType = Tox.PacketKind 4 -- 0x04     Nodes Response
 -- 0x18     Cookie Request
 -- 0x19     Cookie Response
 -- 0x1a     Crypto Handshake
 -- 0x1b     Crypto Data
 
 -- TODO: Auth fail:
-pattern DHTRequestType = MessageType 32 -- 0x20     DHT Request
+pattern DHTRequestType = Tox.PacketKind 32 -- 0x20     DHT Request
 
 -- 0x21     LAN Discovery
 
 -- TODO: Auth fail:
-pattern OnionRequest0 = MessageType 128 -- 0x80     Onion Request 0
-pattern OnionRequest1 = MessageType 129 -- 0x81     Onion Request 1
-pattern OnionRequest2 = MessageType 130 -- 0x82     Onion Request 2
-pattern AnnounceType  = MessageType 131 -- 0x83     Announce Request
+pattern OnionRequest0 = Tox.PacketKind 128 -- 0x80     Onion Request 0
+pattern OnionRequest1 = Tox.PacketKind 129 -- 0x81     Onion Request 1
+pattern OnionRequest2 = Tox.PacketKind 130 -- 0x82     Onion Request 2
+pattern AnnounceType  = Tox.PacketKind 131 -- 0x83     Announce Request
 
 -- 0x84     Announce Response
 -- 0x85     Onion Data Request (data to route request packet)
 -- 0x86     Onion Data Response (data to route response packet)
 -- 0x8c     Onion Response 3
 -- 0x8d     Onion Response 2
-pattern OnionResponse1 = MessageType 142 -- 0x8e     Onion Response 1
+pattern OnionResponse1 = Tox.PacketKind 142 -- 0x8e     Onion Response 1
 -- 0xf0     Bootstrap Info
 
 --  TODO Fix these fails...
@@ -262,7 +265,7 @@ pattern OnionResponse1 = MessageType 142 -- 0x8e     Onion Response 1
 --  MessageType 32 decipherAndAuth: auth fail
 
 
-instance Show Method where
+instance Show Tox.PacketKind where
     showsPrec d PingType        = mappend "PingType"
     showsPrec d PongType        = mappend "PongType"
     showsPrec d GetNodesType    = mappend "GetNodesType"
@@ -271,10 +274,10 @@ instance Show Method where
     showsPrec d OnionRequest0   = mappend "OnionRequest0"
     showsPrec d OnionResponse1  = mappend "OnionResponse1"
     showsPrec d AnnounceType    = mappend "AnnounceType"
-    showsPrec d (MessageType x) = mappend "MessageType " . showsPrec (d+1) x
+    showsPrec d (Tox.PacketKind x) = mappend "PacketKind " . showsPrec (d+1) x
 
 newtype Nonce8 = Nonce8 Word64
- deriving (Eq, Ord)
+ deriving (Eq, Ord, S.Serialize)
 
 instance ByteArrayAccess Nonce8 where
     length _ = 8
@@ -286,43 +289,52 @@ instance ByteArrayAccess Nonce8 where
 instance Show Nonce8 where
     showsPrec d nonce = quoted (mappend $ bin2hex nonce)
 
-newtype Nonce24 = Nonce24 ByteString
+{-
+newtype Tox.Nonce24 = Tox.Nonce24 ByteString
  deriving (Eq, Ord, ByteArrayAccess)
 
-instance Show Nonce24 where
-    showsPrec d nonce = quoted (mappend $ bin2hex nonce)
-
-instance S.Serialize Nonce24 where
-    get = Nonce24 <$> S.getBytes 24
-    put (Nonce24 bs) = S.putByteString bs
-
-quoted :: ShowS -> ShowS
-quoted shows s = '"':shows ('"':s)
+instance show tox.nonce24 where
+    showsprec d nonce = quoted (mappend $ bin2hex nonce)
 
-bin2hex :: ByteArrayAccess bs => bs -> String
-bin2hex = C8.unpack . Base16.encode . BA.convert
+instance S.Serialize Tox.Nonce24 where
+    get = Tox.Nonce24 <$> S.getBytes 24
+    put (Tox.Nonce24 bs) = S.putByteString bs
+-}
 
 newtype SymmetricCiphered = SymmetricCiphered ByteString
     deriving (Eq,Show)
 
+{-
 data Message a = Message
     { msgType       :: Method
     , msgOrigin     :: NodeId
-    , msgNonce      :: Nonce24 -- cryptoNonce of TransactionId
-    , msgReturnPath :: Maybe SymmetricCiphered
+    , msgNonce      :: Tox.Nonce24 -- cryptoNonce of TransactionId
+    , msgReturnPath :: Maybe (Tox.Nonce24,SymmetricCiphered)
     , msgPayload    :: a
     }
  deriving (Eq, Show, Generic, Functor, Foldable, Traversable)
+-}
+
+data Msg = Msg
+    { msgType     :: Tox.PacketKind
+    , msgNonce    :: Tox.Nonce24
+    , msgData     :: ByteString
+    , msgSendBack :: Nonce8
+    }
+ deriving Show
+
 
 typeHasEncryptedPayload OnionResponse1 = False
 typeHasEncryptedPayload _              = True
 
+{-
 msgDHTKey Message{ msgOrigin, msgType = PingType      } = Just msgOrigin
 msgDHTKey Message{ msgOrigin, msgType = PongType      } = Just msgOrigin
 msgDHTKey Message{ msgOrigin, msgType = GetNodesType  } = Just msgOrigin
 msgDHTKey Message{ msgOrigin, msgType = SendNodesType } = Just msgOrigin
 msgDHTKey Message{ msgOrigin, msgType = OnionRequest0 } = Just msgOrigin
 msgDHTKey _                                             = Nothing
+-}
 
 data Ciphered = Ciphered { cipheredMAC   :: Poly1305.Auth
                          , cipheredBytes :: ByteString }
@@ -334,6 +346,7 @@ instance S.Serialize OnionPayload where
     get = OnionPayload <$> (S.remaining >>= S.getBytes)
     put (OnionPayload bs) = S.putByteString bs
 
+{-
 getMessage :: S.Get (Message (Either OnionPayload Ciphered))
 getMessage = do
         typ <- S.get
@@ -377,10 +390,13 @@ putMessage (Message {..}) = do
             AnnounceType   -> S.put msgNonce  >> S.put msgOrigin
             _              -> S.put msgOrigin >> S.put msgNonce
         let putPayload    = either putOnionPayload putCiphered msgPayload
-            putReturnPath = forM_ msgReturnPath $ \(SymmetricCiphered bs) -> S.putByteString bs
+            putReturnPath = forM_ msgReturnPath
+                              $ \(nonce,SymmetricCiphered bs) -> do S.put nonce
+                                                                    S.putByteString bs
         case msgType of
             OnionResponse1 -> putReturnPath >> putPayload
             _              -> putPayload >> putReturnPath
+-}
 
 {-
 data Plain a = Plain
@@ -425,7 +441,7 @@ hsalsa20 k n = a <> b
     (b, _ ) = BA.splitAt 16 bs
 
 
-computeSharedSecret :: SecretKey -> NodeId -> Nonce24 -> (Poly1305.State, XSalsa.State)
+computeSharedSecret :: SecretKey -> NodeId -> Tox.Nonce24 -> (Poly1305.State, XSalsa.State)
 computeSharedSecret sk recipient nonce = (hash, crypt)
  where
     -- diffie helman
@@ -440,16 +456,40 @@ computeSharedSecret sk recipient nonce = (hash, crypt)
     Cryptonite.CryptoPassed hash = Poly1305.initialize rs
 
 
+{-
 encryptMessage :: SecretKey -> SecretsCache -> NodeId -> Message ByteString -> Message (Either OnionPayload Ciphered)
 encryptMessage sk _ recipient plaintext
     = if typeHasEncryptedPayload (msgType plaintext)
         then Right . withSecret encipherAndHash sk recipient (msgNonce plaintext) <$> plaintext
         else Left . OnionPayload <$> plaintext
+-}
 
+encryptAssymetric :: SecretKey -> NodeId -> NodeId -> Msg -> (Tox.PacketKind, Tox.Assymetric)
+encryptAssymetric sk pk recipient (Msg typ nonce plaintext sendback)
+    = ( typ
+      , Tox.Assymetric
+          { senderKey = pk
+          , sent = Tox.UnclaimedAssymetric
+                   { assymetricNonce = nonce
+                   , assymetricData  = withSecret encipherAndHash sk recipient nonce (plaintext <> S.encode sendback)
+                   }
+          } )
 
+{-
 decryptMessage :: SecretKey -> SecretsCache -> Message Ciphered -> Either String (Message ByteString)
 decryptMessage sk _ ciphertext
     = mapM (withSecret decipherAndAuth sk (msgOrigin ciphertext) (msgNonce ciphertext)) ciphertext
+-}
+
+decryptAssymetric :: SecretKey -> (Tox.PacketKind, Tox.Assymetric) -> Either String Msg
+decryptAssymetric sk (typ,assym)
+    = f <$> withSecret decipherAndAuth sk
+                                       (Tox.senderKey assym)
+                                       nonce
+                                       (Tox.assymetricData . Tox.sent $ assym)
+ where
+    nonce = Tox.assymetricNonce . Tox.sent $ assym
+    f bs = uncurry (Msg typ nonce) . second (either (const (Nonce8 0)) id . S.decode) $ B.splitAt (B.length bs - 8) bs
 
 withSecret f sk recipient nonce x = f hash crypt x
  where
@@ -458,14 +498,14 @@ withSecret f sk recipient nonce x = f hash crypt x
 
 -- Encrypt-then-Mac:  Encrypt the cleartext, then compute the MAC on the
 -- ciphertext, and prepend it to the ciphertext
-encipherAndHash :: Poly1305.State -> XSalsa.State -> ByteString -> Ciphered
-encipherAndHash hash crypt m = Ciphered a c
+encipherAndHash :: Poly1305.State -> XSalsa.State -> ByteString -> Tox.ImplicitAssymetric
+encipherAndHash hash crypt m = Tox.ImplicitAssymetric (Tox.Auth a) c
   where
     c = fst . XSalsa.combine crypt $ m
     a = Poly1305.finalize . Poly1305.update hash $ c
 
-decipherAndAuth :: Poly1305.State -> XSalsa.State -> Ciphered -> Either String ByteString
-decipherAndAuth hash crypt (Ciphered mac c)
+decipherAndAuth :: Poly1305.State -> XSalsa.State -> Tox.ImplicitAssymetric -> Either String ByteString
+decipherAndAuth hash crypt (Tox.ImplicitAssymetric (Tox.Auth mac) c)
     | (a == mac) = Right m
     | otherwise  = Left "decipherAndAuth: auth fail"
   where
@@ -483,6 +523,7 @@ xxd offset bs             = printf "%03x: %s" offset ds : xxd (offset + B.length
                  $ B.unpack xs
     (xs,bs') = B.splitAt 16 bs
 
+{-
 showPayloadError ciphered naddr flow err = unlines (map (prefix ++) xs)
  where
     xs = unwords [show (msgType ciphered), err]
@@ -492,7 +533,6 @@ showPayloadError ciphered naddr flow err = unlines (map (prefix ++) xs)
 
     prefix = show naddr <> flow
 
-
 showParseError bs addr err = unlines $
         concat [ either show show (either4or6 addr), " --> ", err ]
         : xxd 0 bs
@@ -521,7 +561,30 @@ parsePacket sk cache bs addr = left (showParseError bs addr) $ do
 encodePacket :: SecretKey -> SecretsCache -> Message ByteString -> NodeInfo -> (ByteString, SockAddr)
 encodePacket sk cache msg ni = ( S.runPut . putMessage $ encryptMessage sk cache (nodeId ni) msg
                                , nodeAddr ni )
+-}
+
+msgLayer :: SecretKey
+            -> NodeId
+            -> Transport String NodeInfo (Tox.PacketKind,Tox.Assymetric)
+            -> Transport String NodeInfo Msg
+msgLayer sk pk = layerTransport parse serialize
+ where
+    parse x addr = fmap (,addr) $ decryptAssymetric sk x
+    serialize x addr = (encryptAssymetric sk pk (nodeId addr) x, addr)
+
+asymLayer :: Transport String SockAddr Tox.Packet -> Transport String NodeInfo (Tox.PacketKind,Tox.Assymetric)
+asymLayer = layerTransport parse serialize
+ where
+    parse x addr = case Tox.pktClass (Tox.pktKind x) of
+                    Tox.AssymetricClass top fromp -> fmap ((Tox.pktKind x,y),) $ nodeInfo (Tox.senderKey y) addr where y = fromp x
 
+    serialize (typ,assym) addr = (x,nodeAddr addr)
+        where x = case Tox.pktClass typ of
+                    Tox.AssymetricClass top _ -> top assym
+
+toxLayer :: Transport String SockAddr ByteString -> Transport String SockAddr Tox.Packet
+toxLayer = layerTransport (\x addr -> (,addr) <$> S.decode x)
+                          (\x addr -> (S.encode x, addr))
 
 data Routing = Routing
     { tentativeId :: NodeInfo
@@ -533,13 +596,27 @@ data Routing = Routing
     , committee6  :: TriadCommittee NodeId SockAddr
     }
 
-type ToxClient = Client String Method TransactionId NodeInfo (Message ByteString)
+type ToxClient = Client String Tox.PacketKind TransactionId NodeInfo Msg
+
+encodePayload :: S.Serialize b => Tox.PacketKind -> TransactionId -> addr -> addr -> b -> Msg
+encodePayload typ (TransactionId nonce8 nonce24) _ _ b = Msg typ nonce24 (S.encode b) nonce8
+
+trimPackets :: SockAddr -> ByteString -> IO (Maybe (ByteString -> ByteString))
+trimPackets addr bs = do
+    hPutStrLn stderr $ "GOT " ++ show (Tox.PacketKind (B.head bs))
+    return $ case Tox.PacketKind (B.head bs) of
+                        PingType      -> Just id
+                        PongType      -> Just id
+                        SendNodesType -> Just id
+                        GetNodesType  -> Just id
+                        _             -> Nothing
 
 newClient :: SockAddr -> IO (ToxClient, Routing)
 newClient addr = do
     udp <- udpTransport addr
     secret <- generateSecretKey
     let pubkey = key2id $ toPublic secret
+    hPutStrLn stderr $ "pubkey = " ++ show pubkey
     cache <- newEmptyCache
     (symkey, drg) <- do
         drg0 <- getSystemDRG
@@ -587,17 +664,14 @@ newClient addr = do
             let mapT = transactionMethods (contramapT nonceKey mapMethods) gen
             map_var <- atomically $ newTVar (drg, mempty)
             return $ Left (mapT,map_var)
-    let net = onInbound (updateRouting outgoingClient routing)
+    let net = addHandler (handleMessage client)
               $ addVerbosity
-              $ layerTransport (parsePacket secret cache)
-                               (encodePacket secret cache)
-              $ udp
-
-        -- Paranoid: It's safe to define /net/ and /client/ to be mutually
-        -- recursive since 'updateRouting' does not invoke 'awaitMessage' which
-        -- which was modified by 'onInbound'.  However, I'm going to avoid the
-        -- mutual reference just to be safe.
-        outgoingClient = client { clientNet = net { awaitMessage = ($ Nothing) } }
+              $ msgLayer secret pubkey
+              $ onInbound (updateRouting client routing)
+              $ asymLayer
+              $ toxLayer
+              $ addVerbosity2
+              $ addHandler trimPackets udp
 
         dispatch tbl var = DispatchMethods
             { classifyInbound = classify
@@ -605,6 +679,11 @@ newClient addr = do
             , tableMethods = tbl
             }
 
+        handler typ f = Just $ MethodHandler (S.decode . msgData) (encodePayload typ) f
+
+        -- (decryptAssymetric secret) (encryptAssymetric secret . cryptoNonce) f
+
+
         -- handlers :: TVar -> Method -> Maybe Handler
         handlers var PingType       = handler PongType pingH
         handlers var GetNodesType   = handler SendNodesType $ getNodesH routing
@@ -627,15 +706,15 @@ newClient addr = do
             (g,pending) <- readTVar var
             let (bs, g') = randomBytesGenerate 24 g
             writeTVar var (g',pending)
-            return $ TransactionId nonce8 (Nonce24 bs)
+            return $ TransactionId nonce8 (Tox.Nonce24 bs)
 
         client = either mkclient mkclient tblvar
 
         mkclient :: DRG g =>
-                    ( TransactionMethods (g,t (MVar (Message ByteString)))
+                    ( TransactionMethods (g,t (MVar Msg))
                                          TransactionId
-                                         (Message ByteString)
-                    , TVar (g, t (MVar (Message ByteString)))
+                                         Msg
+                    , TVar (g, t (MVar Msg))
                     ) -> ToxClient
         mkclient (tbl,var) = Client
             { clientNet           = net
@@ -676,6 +755,7 @@ toxSpace = R.KademliaSpace
     }
 
 
+{-
 last8 :: ByteString -> Nonce8
 last8 bs
     | let len = B.length bs
@@ -688,6 +768,16 @@ last8 bs
 
 dropEnd8 :: ByteString -> ByteString
 dropEnd8 bs = B.take (B.length bs - 8) bs
+-}
+
+data Payload a = Payload
+    { payload :: a
+    , sendback :: Nonce8
+    }
+
+instance S.Serialize a => S.Serialize (Payload a) where
+    get = Payload <$> S.get <*> S.get
+    put (Payload a nonce) = S.put a >> S.put nonce
 
 
 -- Add detailed printouts for every packet.
@@ -699,14 +789,29 @@ addVerbosity tr =
             kont m
        , sendMessage = \addr msg -> do
             hPutStrLn stderr ( (show addr)
-                                ++ " <-- " ++ show (msgType msg))
+                                ++ " <-- " ++ show msg ) -- (msgType msg))
             sendMessage tr addr msg
        }
 
-classify :: Message ByteString -> MessageClass String Method TransactionId
-classify (Message { msgType    = typ
-                  , msgPayload = bs
-                  , msgNonce   = nonce24 }) = go $ TransactionId (last8 bs) nonce24
+addVerbosity2 tr =
+    tr { awaitMessage = \kont -> awaitMessage tr $ \m -> do
+            forM_ m $ mapM_ $ \(msg,addr) -> do
+                hPutStrLn stderr ( (show addr)
+                                    ++ " -2-> " ++ show (Tox.PacketKind $ B.head msg))
+            kont m
+       , sendMessage = \addr msg -> do
+            hPutStrLn stderr ( (show addr)
+                                ++ " <-2- " ++ show (Tox.PacketKind $ B.head msg))
+            forM_ (xxd 0 msg) (hPutStrLn stderr)
+            sendMessage tr addr msg
+       }
+
+
+classify :: Msg -> MessageClass String Tox.PacketKind TransactionId
+classify (Msg { msgType     = typ
+              , msgData     = bs
+              , msgSendBack = nonce8
+              , msgNonce    = nonce24 }) = go $ TransactionId nonce8 nonce24
  where
     go = case typ of
             PingType       -> IsQuery typ
@@ -720,6 +825,7 @@ classify (Message { msgType    = typ
             AnnounceType   -> IsQuery typ
             _              -> const $ IsUnknown ("Unknown message type: "++show typ)
 
+{-
 encodePayload typ (TransactionId (Nonce8 tid) nonce) self dest b
     = Message { msgType       = typ
               , msgOrigin     = nodeId self
@@ -730,18 +836,18 @@ encodePayload typ (TransactionId (Nonce8 tid) nonce) self dest b
 
 decodePayload :: S.Serialize a => Message ByteString -> Either String a
 decodePayload msg = S.decode $ dropEnd8 $ msgPayload msg
+-}
 
-type Handler = MethodHandler String TransactionId NodeInfo (Message ByteString)
-
-handler typ f = Just $ MethodHandler decodePayload (encodePayload typ) f
+type Handler = MethodHandler String TransactionId NodeInfo Msg
 
-noreply :: S.Serialize b =>
-           Method
-           -> (addr -> Message b -> IO ())
-           -> Maybe (MethodHandler String tid addr (Message ByteString))
+{-
+noreply :: Tox.PacketKind
+           -> (addr -> Msg -> IO ())
+           -> Maybe (MethodHandler String tid addr Msg)
 noreply typ f = Just $ NoReply (mapM deserialize) f
  where
     deserialize = S.decode . bool id dropEnd8 (typeHasEncryptedPayload typ)
+-}
 
 transitionCommittee :: TriadCommittee NodeId SockAddr -> RoutingTransition NodeInfo -> STM (IO ())
 transitionCommittee committee (RoutingTransition ni Stranger) = do
@@ -750,13 +856,12 @@ transitionCommittee committee (RoutingTransition ni Stranger) = do
         hPutStrLn stderr $ "delVote "++show (nodeId ni)
 transitionCommittee committee _ = return $ return ()
 
-updateRouting :: ToxClient -> Routing -> NodeInfo -> Message ByteString -> IO ()
-updateRouting client routing addr msg = do
-    forM_ (msgDHTKey msg) $ \nid -> do
-        let naddr = addr { nodeId = nid }
-        case prefer4or6 naddr Nothing of
-            Want_IP4 -> updateTable client naddr (routing4 routing) (committee4 routing) (sched4 routing)
-            Want_IP6 -> updateTable client naddr (routing6 routing) (committee6 routing) (sched6 routing)
+updateRouting :: ToxClient -> Routing -> NodeInfo -> (Tox.PacketKind, Tox.Assymetric) -> IO ()
+updateRouting client routing naddr (typ,msg) = do
+    hPutStrLn stderr $ "updateRouting "++show typ
+    case prefer4or6 naddr Nothing of
+        Want_IP4 -> updateTable client naddr (routing4 routing) (committee4 routing) (sched4 routing)
+        Want_IP6 -> updateTable client naddr (routing6 routing) (committee6 routing) (sched6 routing)
 
 updateTable client naddr tbl committee sched = do
         self <- atomically $ R.thisNode <$> readTVar tbl
@@ -971,7 +1076,8 @@ getNodesH routing addr (GetNodes nid) = do
     k = 4
 
 
-symmetricCipher :: DRG g => STM ByteString -> STM g -> (g -> STM ()) -> ByteString -> IO SymmetricCiphered
+{-
+symmetricCipher :: DRG g => STM ByteString -> STM g -> (g -> STM ()) -> ByteString -> IO (Tox.Nonce24, SymmetricCiphered)
 symmetricCipher currentSymmetricKey readG writeG bs = (>>= \e -> hPutStrLn stderr (show e) >> Cryptonite.throwCryptoErrorIO e) $ atomically $ do
     g <- readG
     let (sym_nonce_bytes, g') = randomBytesGenerate 12 g
@@ -985,9 +1091,12 @@ symmetricCipher currentSymmetricKey readG writeG bs = (>>= \e -> hPutStrLn stder
             -- For a single SockAddr, bs will be 19 bytes which gives
             -- 12 + 16 + 19 = 47 bytes.
             -- We need 12 more make 59 bytes, so we'll include the nonce twice.
-        return $ SymmetricCiphered (sym_nonce_bytes <> sym_nonce_bytes <> BA.convert auth <> rpath_bs)
+            nonce24 = Tox.Nonce24 $ sym_nonce <> sym_nonce
+        return ( nonce24
+               , SymmetricCiphered (BA.convert auth <> rpath_bs)
+               )
 
-symmetricDecipher currentSymmetricKey (Nonce24 nonce24) (SymmetricCiphered bs) = atomically $ do
+symmetricDecipher currentSymmetricKey (Tox.Nonce24 nonce24) (SymmetricCiphered bs) = atomically $ do
     symmkey <- currentSymmetricKey
     return $ do
         let sym_nonce_bytes = B.drop 12 nonce24
@@ -1000,11 +1109,12 @@ symmetricDecipher currentSymmetricKey (Nonce24 nonce24) (SymmetricCiphered bs) =
         if BA.convert auth /= mac
             then Left "symmetricDecipher: Auth fail."
             else return $ ds
+-}
 
-
+{-
 
 -- OnionRequest0
-onionSend0H :: (ByteString -> IO SymmetricCiphered)
+onionSend0H :: (ByteString -> IO (Tox.Nonce24,SymmetricCiphered))
             -> Transport err SockAddr ByteString
             -> NodeInfo
             -> Message (OnionWrap Ciphered)
@@ -1012,12 +1122,12 @@ onionSend0H :: (ByteString -> IO SymmetricCiphered)
 onionSend0H symcipher udp addr Message{ msgNonce
                                       , msgPayload = OnionWrap forward alias ciphered } = do
     hPutStrLn stderr $ "onionSend0H( " ++ show addr ++ " --> " ++ either show show (either4or6 forward) ++ ")"
-    rpath <- symcipher (S.runPut $ putForwardAddr forward)
+    (nonce,rpath) <- symcipher (S.runPut $ putForwardAddr forward)
     sendMessage udp forward $ S.runPut $ putMessage
         Message { msgType       = OnionRequest1
                 , msgOrigin     = alias
                 , msgNonce      = msgNonce
-                , msgReturnPath = Just rpath
+                , msgReturnPath = Just (nonce,rpath)
                 , msgPayload    = Right ciphered
                 }
     hPutStrLn stderr $ "onionSend0H SENT ( " ++ show addr ++ " --> " ++ either show show (either4or6 forward) ++ ")"
@@ -1026,7 +1136,7 @@ onionSend0H symcipher udp addr Message{ msgNonce
 --
 -- No public-key decryption here.
 onionResponse1H ::
-            (Nonce24 -> SymmetricCiphered -> IO (Either String ByteString))
+            (Tox.Nonce24 -> SymmetricCiphered -> IO (Either String ByteString))
             -> Transport err SockAddr ByteString
             -> NodeInfo
             -> Message OnionPayload
@@ -1044,6 +1154,8 @@ onionResponse1H symdecipher udp addr Message{ msgNonce
                 sendMessage udp forward (unpackOnionPayload msgPayload)
             either (hPutStrLn stderr . mappend "onionResponse1H decipher ERROR ") (\x -> go x >> hPutStrLn stderr "onionResponse1H SENT") eaddr
 
+-}
+
 intKey :: TransactionId -> Int
 intKey (TransactionId (Nonce8 w) _) = fromIntegral w
 
@@ -1056,7 +1168,8 @@ gen :: forall gen. DRG gen => gen -> (TransactionId, gen)
 gen g = let (bs, g')  = randomBytesGenerate 24 g
             (ws, g'') = randomBytesGenerate 8 g'
             Right w   = S.runGet S.getWord64be ws
-        in ( TransactionId (Nonce8 w) (Nonce24 bs), g'' )
+        in ( TransactionId (Nonce8 w) (Tox.Nonce24 bs), g'' )
+
 
 
 toxSend meth unwrap msg client nid addr = do
@@ -1072,7 +1185,7 @@ toxSend meth unwrap msg client nid addr = do
         -- wrapQuery :: tid -> addr -> addr -> a -> x
         , wrapQuery      = encodePayload meth
         -- unwrapResponse :: x -> b
-        , unwrapResponse = fmap unwrap . decodePayload
+        , unwrapResponse = fmap unwrap . S.decode . msgData
         }
 
 ping :: ToxClient -> NodeInfo -> IO Bool
@@ -1092,3 +1205,4 @@ toxSearch qry = Search
     }
 
 nodeSearch client = toxSearch (getNodes client)
+