Renamed Assym -> Asymm (short for asymmetric).

1 files changed, 37 insertions, 37 deletions

diff --git a/src/Network/Tox/Onion/Transport.hs b/src/Network/Tox/Onion/Transport.hs
index 82f2c8a7..203d7dc7 100644
--- a/src/Network/Tox/Onion/Transport.hs
+++ b/src/Network/Tox/Onion/Transport.hs
@@ -78,17 +78,17 @@ type HandleLo a = Maybe (Either String (ByteString, SockAddr)) -> IO a
 type UDPTransport = Transport String SockAddr ByteString
 
 
-getOnionAssym :: Get (Assym (Encrypted DataToRoute))
-getOnionAssym = getAliasedAssym
+getOnionAsymm :: Get (Asymm (Encrypted DataToRoute))
+getOnionAsymm = getAliasedAsymm
 
-putOnionAssym :: Serialize a => Word8 -> Put -> Assym a -> Put
-putOnionAssym typ p a = put typ >> p >> putAliasedAssym a
+putOnionAsymm :: Serialize a => Word8 -> Put -> Asymm a -> Put
+putOnionAsymm typ p a = put typ >> p >> putAliasedAsymm a
 
 data OnionMessage (f :: * -> *)
-    = OnionAnnounce (Assym (f (AnnounceRequest,Nonce8)))
+    = OnionAnnounce (Asymm (f (AnnounceRequest,Nonce8)))
     | OnionAnnounceResponse Nonce8 Nonce24 (f AnnounceResponse)
-    | OnionToRoute PublicKey (Assym (Encrypted DataToRoute)) -- destination key, aliased Assym
-    | OnionToRouteResponse (Assym (Encrypted DataToRoute))
+    | OnionToRoute PublicKey (Asymm (Encrypted DataToRoute)) -- destination key, aliased Asymm
+    | OnionToRouteResponse (Asymm (Encrypted DataToRoute))
 
 deriving instance ( Show (f (AnnounceRequest, Nonce8))
                   , Show (f AnnounceResponse)
@@ -96,10 +96,10 @@ deriving instance ( Show (f (AnnounceRequest, Nonce8))
                   ) => Show (OnionMessage f)
 
 msgNonce :: OnionMessage f -> Nonce24
-msgNonce (OnionAnnounce a)               = assymNonce a
+msgNonce (OnionAnnounce a)               = asymmNonce a
 msgNonce (OnionAnnounceResponse _ n24 _) = n24
-msgNonce (OnionToRoute _ a)              = assymNonce a
-msgNonce (OnionToRouteResponse a)        = assymNonce a
+msgNonce (OnionToRoute _ a)              = asymmNonce a
+msgNonce (OnionToRouteResponse a)        = asymmNonce a
 
 data AliasSelector = SearchingAlias | AnnouncingAlias SecretKey PublicKey
     deriving (Eq,Show)
@@ -138,18 +138,18 @@ instance Serialize (OnionMessage Encrypted) where
     get = do
         typ <- get
         case typ :: Word8 of
-            0x83 -> OnionAnnounce <$> getAliasedAssym
-            0x85 -> OnionToRoute <$> getPublicKey <*> getAliasedAssym
+            0x83 -> OnionAnnounce <$> getAliasedAsymm
+            0x85 -> OnionToRoute <$> getPublicKey <*> getAliasedAsymm
             t    -> fail ("Unknown onion payload: " ++ show t)
                     `fromMaybe` getOnionReply t
-    put (OnionAnnounce a)                = putWord8 0x83 >> putAliasedAssym a
-    put (OnionToRoute k a)               = putWord8 0x85 >> putPublicKey k >> putAliasedAssym a
+    put (OnionAnnounce a)                = putWord8 0x83 >> putAliasedAsymm a
+    put (OnionToRoute k a)               = putWord8 0x85 >> putPublicKey k >> putAliasedAsymm a
     put (OnionAnnounceResponse n8 n24 x) = putWord8 0x84 >> put n8 >> put n24 >> put x
-    put (OnionToRouteResponse a)         = putWord8 0x86 >> putAliasedAssym a
+    put (OnionToRouteResponse a)         = putWord8 0x86 >> putAliasedAsymm a
 
-onionToOwner :: Assym a -> ReturnPath N3 -> SockAddr -> Either String (OnionDestination r)
-onionToOwner assym ret3 saddr = do
-    ni <- nodeInfo (key2id $ senderKey assym) saddr
+onionToOwner :: Asymm a -> ReturnPath N3 -> SockAddr -> Either String (OnionDestination r)
+onionToOwner asymm ret3 saddr = do
+    ni <- nodeInfo (key2id $ senderKey asymm) saddr
     return $ OnionToOwner ni ret3
 -- data CookieAddress = WithoutCookie NodeInfo | CookieAddress Cookie SockAddr
 
@@ -157,11 +157,11 @@ onionToOwner assym ret3 saddr = do
 onion :: Sized msg =>
                ByteString
                -> SockAddr
-               -> Get (Assym (Encrypted msg) -> t)
+               -> Get (Asymm (Encrypted msg) -> t)
                -> Either String (t, OnionDestination r)
-onion bs saddr getf = do (f,(assym,ret3)) <- runGet ((,) <$> getf <*> getOnionRequest) bs
-                         oaddr <- onionToOwner assym ret3 saddr
-                         return (f assym, oaddr)
+onion bs saddr getf = do (f,(asymm,ret3)) <- runGet ((,) <$> getf <*> getOnionRequest) bs
+                         oaddr <- onionToOwner asymm ret3 saddr
+                         return (f asymm, oaddr)
 
 parseOnionAddr :: (SockAddr -> Nonce8 -> IO (Maybe (OnionDestination r)))
                   -> (ByteString, SockAddr)
@@ -187,14 +187,14 @@ parseOnionAddr lookupSender (msg,saddr)
 
 getOnionReply :: Word8 -> Maybe (Get (OnionMessage Encrypted))
 getOnionReply 0x84 = Just $ OnionAnnounceResponse <$> get <*> get <*> get
-getOnionReply 0x86 = Just $ OnionToRouteResponse <$> getOnionAssym
+getOnionReply 0x86 = Just $ OnionToRouteResponse <$> getOnionAsymm
 getOnionReply _    = Nothing
 
 putOnionMsg :: OnionMessage Encrypted -> Put
-putOnionMsg (OnionAnnounce                a) = putOnionAssym 0x83 (return ()) a
-putOnionMsg (OnionToRoute pubkey          a) = putOnionAssym 0x85 (putPublicKey pubkey) a
+putOnionMsg (OnionAnnounce                a) = putOnionAsymm 0x83 (return ()) a
+putOnionMsg (OnionToRoute pubkey          a) = putOnionAsymm 0x85 (putPublicKey pubkey) a
 putOnionMsg (OnionAnnounceResponse n8 n24 x) = put (0x84 :: Word8) >> put n8 >> put n24 >> put x
-putOnionMsg (OnionToRouteResponse         a) = putOnionAssym 0x86 (return ()) a
+putOnionMsg (OnionToRouteResponse         a) = putOnionAsymm 0x86 (return ()) a
 
 encodeOnionAddr :: (NodeInfo -> r -> IO (Maybe OnionRoute))
                    -> (OnionMessage Encrypted,OnionDestination r)
@@ -470,7 +470,7 @@ peelOnion :: Serialize (Addressed (Forwarding n t))
               -> Forwarding (S n) t
               -> Either String (Addressed (Forwarding n t))
 peelOnion crypto nonce (Forwarding k fwd) =
-    fmap runIdentity $ uncomposed $ decryptMessage (dhtKey crypto) nonce (Right $ Assym k nonce fwd)
+    fmap runIdentity $ uncomposed $ decryptMessage (dhtKey crypto) nonce (Right $ Asymm k nonce fwd)
 
 handleOnionResponse :: (KnownPeanoNat n, Sized (ReturnPath n), Serialize (ReturnPath n)) => proxy (S n) -> TransportCrypto -> SockAddr -> UDPTransport -> IO a -> OnionResponse (S n) -> IO a
 handleOnionResponse proxy crypto saddr udp kont (OnionResponse path msg) = do
@@ -499,13 +499,13 @@ instance S.Serialize AnnounceRequest where
     get = AnnounceRequest <$> S.get <*> S.get <*> S.get
     put (AnnounceRequest p s k) = S.put (p,s,k)
 
-getOnionRequest :: Sized msg => Get (Assym (Encrypted msg), ReturnPath N3)
+getOnionRequest :: Sized msg => Get (Asymm (Encrypted msg), ReturnPath N3)
 getOnionRequest = do
     -- Assumes return path is constant size so that we can isolate
     -- the variable-sized prefix.
     cnt <- remaining
     a <- isolate (case size :: Size (ReturnPath N3) of ConstSize n -> cnt - n)
-                 getAliasedAssym
+                 getAliasedAsymm
     path <- get
     return (a,path)
 
@@ -619,7 +619,7 @@ encrypt :: TransportCrypto -> OnionMessage Identity -> OnionDestination r -> IO
 encrypt crypto msg rpath = do
     (skey,pkey) <- selectKey crypto msg rpath -- source key
     let okey = onionKey rpath                 -- destination key
-    return ( transcode ( (. (runIdentity . either id assymData))
+    return ( transcode ( (. (runIdentity . either id asymmData))
                                          . encryptMessage skey okey)
                                        msg
            , rpath)
@@ -652,12 +652,12 @@ decryptMessage :: Serialize x =>
                   (SecretKey,PublicKey)
                   -> Nonce24
                   -> Either (PublicKey, Encrypted x)
-                            (Assym (Encrypted x))
+                            (Asymm (Encrypted x))
                   -> (Either String ∘ Identity) x
 decryptMessage crypto n arg = plain $ ToxCrypto.decrypt secret e
  where
     secret     = computeSharedSecret (fst crypto) sender n
-    (sender,e) = either id (senderKey &&& assymData) arg
+    (sender,e) = either id (senderKey &&& asymmData) arg
     plain      = Composed . fmap Identity . (>>= decodePlain)
 
 
@@ -668,12 +668,12 @@ 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 :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Asymm (f a)) -> g a) -> OnionMessage f -> OnionMessage g
+transcode f (OnionAnnounce a)        = OnionAnnounce $ a { asymmData = f (asymmNonce 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) }
+-- transcode f (OnionToRouteResponse a) = OnionToRouteResponse $ a { asymmData = f (asymmNonce a) (Right a) }
 
 
 data OnionRoute = OnionRoute
@@ -738,14 +738,14 @@ instance Show Rendezvous where
 parseDataToRoute
     :: TransportCrypto
          -> (OnionMessage Encrypted,OnionDestination r)
-         -> Either (Assym (Encrypted DataToRoute),Rendezvous) (OnionMessage Encrypted, OnionDestination r)
+         -> Either (Asymm (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)
+                     -> (Asymm (Encrypted DataToRoute),Rendezvous)
                      -> Maybe (OnionMessage Encrypted,OnionDestination r)
 encodeDataToRoute crypto (dta, Rendezvous pub ni)
     = Just ( OnionToRoute pub -- Public key of destination node