summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Attach.hs2
-rw-r--r--src/Contact.hs4
-rw-r--r--src/Main.hs56
-rw-r--r--src/Message.hs4
-rw-r--r--src/Network.hs825
-rw-r--r--src/Pairing.hs6
-rw-r--r--src/Storage/Internal.hs3
7 files changed, 461 insertions, 439 deletions
diff --git a/src/Attach.hs b/src/Attach.hs
index 5acc608..4df7e5f 100644
--- a/src/Attach.hs
+++ b/src/Attach.hs
@@ -97,7 +97,7 @@ attachAccept printMsg h peer = do
PeerRequestConfirm -> do
liftIO $ printMsg $ "Accepted new attached device, seding updated identity"
owner <- liftIO $ mergeSharedIdentity h
- PeerIdentityFull pid <- return $ peerIdentity peer
+ PeerIdentityFull pid <- peerIdentity peer
Just secret <- liftIO $ loadKey $ idKeyIdentity owner
liftIO $ do
identity <- wrappedStore st =<< sign secret =<< wrappedStore st (emptyIdentityData $ idKeyIdentity pid)
diff --git a/src/Contact.hs b/src/Contact.hs
index 814e324..fefcd1f 100644
--- a/src/Contact.hs
+++ b/src/Contact.hs
@@ -121,7 +121,7 @@ contactAccept printMsg h peer = do
liftIO $ printMsg $ "Contact accepted, waiting for peer confirmation"
return (Nothing, OurRequestReady)
OurRequestConfirm (Just ContactAccepted) -> do
- PeerIdentityFull pid <- return $ peerIdentity peer
+ PeerIdentityFull pid <- peerIdentity peer
liftIO $ do
printMsg $ "Contact accepted"
updateLocalState_ h $ finalizeContact pid
@@ -129,7 +129,7 @@ contactAccept printMsg h peer = do
OurRequestReady -> throwError $ "alredy accepted, waiting for peer"
PeerRequest {} -> throwError $ "waiting for peer"
PeerRequestConfirm -> do
- PeerIdentityFull pid <- return $ peerIdentity peer
+ PeerIdentityFull pid <- peerIdentity peer
liftIO $ do
printMsg $ "Contact accepted"
updateLocalState_ h $ finalizeContact pid
diff --git a/src/Main.hs b/src/Main.hs
index 0e8970f..a847bd1 100644
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -109,16 +109,16 @@ interactiveLoop st bhost = runInputT defaultSettings $ do
peers <- liftIO $ newMVar []
void $ liftIO $ forkIO $ void $ forever $ do
- peer <- readChan $ serverChanPeer server
- if | PeerIdentityFull pid <- peerIdentity peer -> do
- let update [] = ([peer], Nothing)
- update (p:ps) | PeerIdentityFull pid' <- peerIdentity p
- , pid' `sameIdentity` pid = (peer : ps, Just p)
- | otherwise = first (p:) $ update ps
- op <- modifyMVar peers (return . update)
- let shown = showPeer peer
- when (Just shown /= (showPeer <$> op)) $ extPrint shown
- | otherwise -> return ()
+ peer <- getNextPeerChange server
+ peerIdentity peer >>= \case
+ pid@(PeerIdentityFull _) -> do
+ let shown = showPeer pid $ peerAddress peer
+ let update [] = ([(peer, shown)], Nothing)
+ update ((p,s):ps) | p == peer = ((peer, shown) : ps, Just s)
+ | otherwise = first ((p,s):) $ update ps
+ op <- modifyMVar peers (return . update)
+ when (Just shown /= op) $ extPrint shown
+ _ -> return ()
let getInputLines prompt = do
Just input <- lift $ getInputLine prompt
@@ -129,12 +129,12 @@ interactiveLoop st bhost = runInputT defaultSettings $ do
let process :: CommandState -> MaybeT (InputT IO) CommandState
process cstate = do
- let pname = case csPeer cstate of
- Nothing -> ""
- Just peer -> case peerIdentity peer of
- PeerIdentityFull pid -> maybe "<unnamed>" T.unpack $ idName $ finalOwner pid
- PeerIdentityRef wref -> "<" ++ BC.unpack (showRefDigest $ wrDigest wref) ++ ">"
- PeerIdentityUnknown -> "<unknown>"
+ pname <- case csPeer cstate of
+ Nothing -> return ""
+ Just peer -> peerIdentity peer >>= return . \case
+ PeerIdentityFull pid -> maybe "<unnamed>" T.unpack $ idName $ finalOwner pid
+ PeerIdentityRef wref _ -> "<" ++ BC.unpack (showRefDigest $ wrDigest wref) ++ ">"
+ PeerIdentityUnknown _ -> "<unknown>"
input <- getInputLines $ pname ++ "> "
let (CommandM cmd, line) = case input of
'/':rest -> let (scmd, args) = dropWhile isSpace <$> span (\c -> isAlphaNum c || c == '-') rest
@@ -171,7 +171,7 @@ data CommandInput = CommandInput
, ciServer :: Server
, ciLine :: String
, ciPrint :: String -> IO ()
- , ciPeers :: CommandM [Peer]
+ , ciPeers :: CommandM [(Peer, String)]
}
data CommandState = CommandState
@@ -214,21 +214,21 @@ cmdUnknown cmd = liftIO $ putStrLn $ "Unknown command: " ++ cmd
cmdPeers :: Command
cmdPeers = do
peers <- join $ asks ciPeers
- forM_ (zip [1..] peers) $ \(i :: Int, p) -> do
- liftIO $ putStrLn $ show i ++ ": " ++ showPeer p
+ forM_ (zip [1..] peers) $ \(i :: Int, (_, name)) -> do
+ liftIO $ putStrLn $ show i ++ ": " ++ name
-showPeer :: Peer -> String
-showPeer peer =
- let name = case peerIdentity peer of
- PeerIdentityUnknown -> "<noid>"
- PeerIdentityRef wref -> "<" ++ BC.unpack (showRefDigest $ wrDigest wref) ++ ">"
- PeerIdentityFull pid -> T.unpack $ displayIdentity pid
- in name ++ " [" ++ show (peerAddress peer) ++ "]"
+showPeer :: PeerIdentity -> PeerAddress -> String
+showPeer pidentity paddr =
+ let name = case pidentity of
+ PeerIdentityUnknown _ -> "<noid>"
+ PeerIdentityRef wref _ -> "<" ++ BC.unpack (showRefDigest $ wrDigest wref) ++ ">"
+ PeerIdentityFull pid -> T.unpack $ displayIdentity pid
+ in name ++ " [" ++ show paddr ++ "]"
cmdSetPeer :: Int -> Command
cmdSetPeer n | n < 1 = liftIO $ putStrLn "Invalid peer index"
| otherwise = do peers <- join $ asks ciPeers
- modify $ \s -> s { csPeer = listToMaybe $ drop (n - 1) peers }
+ modify $ \s -> s { csPeer = fmap fst $ listToMaybe $ drop (n - 1) peers }
cmdSend :: Command
cmdSend = void $ do
@@ -243,7 +243,7 @@ cmdHistory :: Command
cmdHistory = void $ do
ehead <- asks ciHead
Just peer <- gets csPeer
- PeerIdentityFull pid <- return $ peerIdentity peer
+ PeerIdentityFull pid <- peerIdentity peer
let powner = finalOwner pid
Just thread <- return $ find (sameIdentity powner . msgPeer) $
diff --git a/src/Message.hs b/src/Message.hs
index 874e375..2d00de2 100644
--- a/src/Message.hs
+++ b/src/Message.hs
@@ -115,8 +115,8 @@ findMsgProperty pid sel mss = concat $ flip findProperty mss $ \x -> do
sendDirectMessage :: (MonadIO m, MonadError String m) => Head LocalState -> Peer -> Text -> m (Stored DirectMessage)
sendDirectMessage h peer text = do
- pid <- case peerIdentity peer of PeerIdentityFull pid -> return pid
- _ -> throwError "incomplete peer identity"
+ pid <- peerIdentity peer >>= \case PeerIdentityFull pid -> return pid
+ _ -> throwError "incomplete peer identity"
let st = refStorage $ headRef h
self = headLocalIdentity h
powner = finalOwner pid
diff --git a/src/Network.hs b/src/Network.hs
index cbc68b6..52d83bb 100644
--- a/src/Network.hs
+++ b/src/Network.hs
@@ -1,11 +1,11 @@
module Network (
Server,
startServer,
- serverChanPeer,
+ getNextPeerChange,
- Peer(..),
- PeerAddress(..),
- PeerIdentity(..),
+ Peer,
+ PeerAddress(..), peerAddress,
+ PeerIdentity(..), peerIdentity,
PeerChannel(..),
WaitingRef, wrDigest,
Service(..),
@@ -16,6 +16,7 @@ module Network (
) where
import Control.Concurrent
+import Control.Concurrent.STM
import Control.Exception
import Control.Monad
import Control.Monad.Except
@@ -23,13 +24,15 @@ import Control.Monad.State
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lazy as BL
-import Data.Either
+import Data.Function
import Data.List
import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe
import Data.Typeable
+import GHC.Conc.Sync (unsafeIOToSTM)
+
import Network.Socket
import qualified Network.Socket.ByteString as S
@@ -55,27 +58,33 @@ data Server = Server
, serverIdentity :: MVar UnifiedIdentity
, serverSocket :: MVar Socket
, serverChanPacket :: Chan (PeerAddress, BC.ByteString)
+ , serverOutQueue :: TQueue (Peer, Bool, TransportPacket)
+ , serverDataResponse :: TQueue (Peer, Maybe PartialRef)
+ , serverIOActions :: TQueue (ExceptT String IO ())
, serverPeers :: MVar (Map PeerAddress Peer)
- , serverChanPeer' :: Chan Peer
+ , serverChanPeer :: TChan Peer
+ , serverErrorLog :: TQueue String
}
-serverChanPeer :: Server -> Chan Peer
-serverChanPeer = serverChanPeer'
+getNextPeerChange :: Server -> IO Peer
+getNextPeerChange = atomically . readTChan . serverChanPeer
data Peer = Peer
{ peerAddress :: PeerAddress
- , peerIdentity :: PeerIdentity
- , peerIdentityUpdate :: [WaitingRef]
- , peerChannel :: PeerChannel
+ , peerServer :: Server
+ , peerIdentityVar :: TVar PeerIdentity
+ , peerChannel :: TVar PeerChannel
, peerStorage :: Storage
, peerInStorage :: PartialStorage
- , peerServiceState :: MVar (M.Map ServiceID SomeServiceState)
- , peerServiceInQueue :: [(ServiceID, WaitingRef)]
- , peerServiceOutQueue :: MVar [TransportPacket]
- , peerWaitingRefs :: [WaitingRef]
+ , peerServiceState :: TMVar (M.Map ServiceID SomeServiceState)
+ , peerServiceOutQueue :: TVar [TransportPacket]
+ , peerWaitingRefs :: TMVar [WaitingRef]
}
+instance Eq Peer where
+ (==) = (==) `on` peerIdentityVar
+
data PeerAddress = DatagramAddress Socket SockAddr
| PeerIceSession IceSession
@@ -95,8 +104,8 @@ instance Ord PeerAddress where
compare (PeerIceSession ice ) (PeerIceSession ice') = compare ice ice'
-data PeerIdentity = PeerIdentityUnknown
- | PeerIdentityRef WaitingRef
+data PeerIdentity = PeerIdentityUnknown (TVar [UnifiedIdentity -> ExceptT String IO ()])
+ | PeerIdentityRef WaitingRef (TVar [UnifiedIdentity -> ExceptT String IO ()])
| PeerIdentityFull UnifiedIdentity
data PeerChannel = ChannelWait
@@ -105,6 +114,9 @@ data PeerChannel = ChannelWait
| ChannelOurAccept (Stored ChannelAccept) (Stored Channel)
| ChannelEstablished Channel
+peerIdentity :: MonadIO m => Peer -> m PeerIdentity
+peerIdentity = liftIO . atomically . readTVar . peerIdentityVar
+
data TransportPacket = TransportPacket TransportHeader [Ref]
@@ -162,53 +174,65 @@ lookupServiceType (_ : hs) = lookupServiceType hs
lookupServiceType [] = Nothing
-data WaitingRef = WaitingRef Storage PartialRef (MVar [RefDigest])
+data WaitingRef = WaitingRef
+ { wrefStorage :: Storage
+ , wrefPartial :: PartialRef
+ , wrefAction :: Ref -> WaitingRefCallback
+ , wrefStatus :: TVar (Either [RefDigest] Ref)
+ }
+
+type WaitingRefCallback = ExceptT String IO ()
wrDigest :: WaitingRef -> RefDigest
-wrDigest (WaitingRef _ pref _) = refDigest pref
+wrDigest = refDigest . wrefPartial
-newWaitingRef :: Storage -> PartialRef -> PacketHandler WaitingRef
-newWaitingRef st pref = do
- wref <- WaitingRef st pref <$> liftIO (newMVar [])
- updatePeer $ \p -> p { peerWaitingRefs = wref : peerWaitingRefs p }
+newWaitingRef :: PartialRef -> (Ref -> WaitingRefCallback) -> PacketHandler WaitingRef
+newWaitingRef pref act = do
+ peer <- gets phPeer
+ wref <- WaitingRef (peerStorage peer) pref act <$> liftSTM (newTVar (Left []))
+ modifyTMVarP (peerWaitingRefs peer) (wref:)
+ liftSTM $ writeTQueue (serverDataResponse $ peerServer peer) (peer, Nothing)
return wref
-copyOrRequestRef :: Storage -> PartialRef -> PacketHandler (Either WaitingRef Ref)
-copyOrRequestRef st pref = copyRef st pref >>= \case
- Right ref -> return $ Right ref
- Left dgst -> do
- addHeader $ DataRequest $ partialRefFromDigest (refStorage pref) dgst
- wref <- WaitingRef st pref <$> liftIO (newMVar [dgst])
- updatePeer $ \p -> p { peerWaitingRefs = wref : peerWaitingRefs p }
- return $ Left wref
-
-checkWaitingRef :: WaitingRef -> PacketHandler (Maybe Ref)
-checkWaitingRef (WaitingRef st pref mvar) = do
- liftIO (readMVar mvar) >>= \case
- [] -> copyRef st pref >>= \case
- Right ref -> return $ Just ref
- Left dgst -> do liftIO $ modifyMVar_ mvar $ return . (dgst:)
- addHeader $ DataRequest $ partialRefFromDigest (refStorage pref) dgst
- return Nothing
- _ -> return Nothing
-
-receivedWaitingRef :: PartialRef -> WaitingRef -> PacketHandler (Maybe Ref)
-receivedWaitingRef nref wr@(WaitingRef _ _ mvar) = do
- liftIO $ modifyMVar_ mvar $ return . filter (/= refDigest nref)
- checkWaitingRef wr
-
startServer :: Head LocalState -> (String -> IO ()) -> String -> [SomeService] -> IO Server
-startServer origHead logd bhost services = do
+startServer origHead logd' bhost services = do
let storage = refStorage $ headRef origHead
chanPacket <- newChan
- chanPeer <- newChan
- chanSvc <- newChan
- svcStates <- newMVar M.empty
+ outQueue <- newTQueueIO
+ dataResponse <- newTQueueIO
+ ioActions <- newTQueueIO
+ chanPeer <- newTChanIO
+ chanSvc <- newTQueueIO
+ svcStates <- newTMVarIO M.empty
peers <- newMVar M.empty
midentity <- newMVar $ headLocalIdentity origHead
mshared <- newMVar $ lsShared $ load $ headRef origHead
ssocket <- newEmptyMVar
+ errlog <- newTQueueIO
+
+ let server = Server
+ { serverStorage = storage
+ , serverIdentity = midentity
+ , serverSocket = ssocket
+ , serverChanPacket = chanPacket
+ , serverOutQueue = outQueue
+ , serverDataResponse = dataResponse
+ , serverIOActions = ioActions
+ , serverPeers = peers
+ , serverChanPeer = chanPeer
+ , serverErrorLog = errlog
+ }
+
+ let logd = writeTQueue errlog
+ void $ forkIO $ forever $ do
+ logd' =<< atomically (readTQueue errlog)
+
+ void $ forkIO $ sendWorker server
+ void $ forkIO $ dataResponseWorker server
+ void $ forkIO $ forever $ do
+ either (atomically . logd) return =<< runExceptT =<<
+ atomically (readTQueue $ serverIOActions server)
let open addr = do
sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
@@ -229,27 +253,26 @@ startServer origHead logd bhost services = do
let announceUpdate identity = do
st <- derivePartialStorage storage
- let plaintext = BL.toStrict $ serializeObject $ transportToObject $ TransportHeader $
- (AnnounceSelf $ partialRef st $ storedRef $ idData identity) :
+ let hitems = (AnnounceSelf $ partialRef st $ storedRef $ idData identity) :
map (AnnounceUpdate . partialRef st . storedRef) (idUpdates identity)
+ let packet = TransportPacket (TransportHeader hitems) []
ps <- readMVar peers
- forM_ ps $ \case
- peer
- | PeerIdentityFull _ <- peerIdentity peer
- , ChannelEstablished ch <- peerChannel peer
- -> runExceptT (channelEncrypt ch plaintext) >>= \case
- Right ctext -> void $ sendTo peer ctext
- Left err -> logd $ "Failed to encrypt data: " ++ err
- | otherwise -> return ()
-
- let shareState self shared peer
- | PeerIdentityFull pid <- peerIdentity peer
- , finalOwner pid `sameIdentity` finalOwner self = do
- forM_ shared $ \s -> runExceptT (sendToPeer self peer $ SyncPacket s) >>= \case
- Left err -> logd $ "failed to sync state with peer: " ++ show err
- Right () -> return ()
- | otherwise = return ()
+ forM_ ps $ \peer -> atomically $ do
+ ((,) <$> readTVar (peerIdentityVar peer) <*> readTVar (peerChannel peer)) >>= \case
+ (PeerIdentityFull _, ChannelEstablished _) ->
+ writeTQueue outQueue (peer, True, packet)
+ _ -> return ()
+
+ let shareState self shared peer = do
+ let hitems = (ServiceType $ serviceID @SyncService Proxy) :
+ map (ServiceRef . partialRef (peerInStorage peer) . storedRef) shared
+ packet = TransportPacket (TransportHeader hitems) $
+ map storedRef shared
+ atomically $ readTVar (peerIdentityVar peer) >>= \case
+ PeerIdentityFull pid | finalOwner pid `sameIdentity` finalOwner self -> do
+ sendToPeerS peer packet
+ _ -> return ()
watchHead origHead $ \h -> do
let idt = headLocalIdentity h
@@ -269,42 +292,40 @@ startServer origHead logd bhost services = do
forever $ do
(paddr, msg) <- readChan chanPacket
- modifyMVar_ peers $ \pvalue -> do
- let mbpeer = M.lookup paddr pvalue
- (peer, content, secure) <- if
- | Just peer <- mbpeer
- , Just ch <- case peerChannel peer of
- ChannelEstablished ch -> Just ch
- ChannelOurAccept _ sch -> Just $ fromStored sch
- _ -> Nothing
- , Right plain <- runExcept $ channelDecrypt ch msg
- -> return (peer, plain, True)
-
- | Just peer <- mbpeer
- -> return (peer, msg, False)
-
- | otherwise
- -> (, msg, False) <$> mkPeer storage paddr
-
- case runExcept $ deserializeObjects (peerInStorage peer) $ BL.fromStrict content of
- Right (obj:objs)
- | Just header <- transportFromObject obj -> do
- forM_ objs $ storeObject $ peerInStorage peer
- identity <- readMVar midentity
- let svcs = map someServiceID services
- handlePacket logd origHead identity secure peer chanSvc svcs header >>= \case
- Just peer' -> do
- writeChan chanPeer peer'
- return $ M.insert paddr peer' pvalue
- Nothing -> return pvalue
-
- | otherwise -> do
- logd $ show paddr ++ ": invalid objects"
- logd $ show objs
- return pvalue
-
- _ -> do logd $ show paddr ++ ": invalid objects"
- return pvalue
+ (peer, content, secure) <- modifyMVar peers $ \pvalue -> do
+ case M.lookup paddr pvalue of
+ Just peer -> do
+ mbch <- atomically (readTVar (peerChannel peer)) >>= return . \case
+ ChannelEstablished ch -> Just ch
+ ChannelOurAccept _ sch -> Just $ fromStored sch
+ _ -> Nothing
+
+ if | Just ch <- mbch
+ , Right plain <- runExcept $ channelDecrypt ch msg
+ -> return (pvalue, (peer, plain, True))
+
+ | otherwise
+ -> return (pvalue, (peer, msg, False))
+
+ Nothing -> do
+ peer <- mkPeer server paddr
+ return (M.insert paddr peer pvalue, (peer, msg, False))
+
+ case runExcept $ deserializeObjects (peerInStorage peer) $ BL.fromStrict content of
+ Right (obj:objs)
+ | Just header <- transportFromObject obj -> do
+ prefs <- forM objs $ storeObject $ peerInStorage peer
+ identity <- readMVar midentity
+ let svcs = map someServiceID services
+ handlePacket origHead identity secure peer chanSvc svcs header prefs >>= \case
+ Just peer' -> atomically $ writeTChan chanPeer peer'
+ Nothing -> return ()
+
+ | otherwise -> atomically $ do
+ logd $ show paddr ++ ": invalid objects"
+ logd $ show objs
+
+ _ -> do atomically $ logd $ show paddr ++ ": invalid objects"
void $ forkIO $ withSocketsDo $ do
let hints = defaultHints
@@ -314,49 +335,123 @@ startServer origHead logd bhost services = do
addr:_ <- getAddrInfo (Just hints) Nothing (Just discoveryPort)
bracket (open addr) close loop
- void $ forkIO $ forever $ readChan chanSvc >>= \case
- (peer, svc, ref)
- | PeerIdentityFull peerId <- peerIdentity peer
- -> modifyMVar_ svcStates $ \global ->
- modifyMVar (peerServiceState peer) $ \svcs ->
- case (maybe (someServiceEmptyState <$> find ((svc ==) . someServiceID) services) Just $ M.lookup svc svcs,
- maybe (someServiceEmptyGlobalState <$> find ((svc ==) . someServiceID) services) Just $ M.lookup svc global) of
- (Just (SomeServiceState (proxy :: Proxy s) s),
- Just (SomeServiceGlobalState (_ :: Proxy gs) gs))
- | Just (Refl :: s :~: gs) <- eqT -> do
- let inp = ServiceInput
- { svcPeer = peerId
- , svcPrintOp = logd
- }
- reloadHead origHead >>= \case
- Nothing -> do
- logd $ "current head deleted"
- return (svcs, global)
- Just h -> do
- (rsp, (s', gs')) <- handleServicePacket h inp s gs (wrappedLoad ref :: Stored s)
- identity <- readMVar midentity
- runExceptT (sendToPeerList identity peer rsp) >>= \case
- Left err -> logd $ "failed to send response to peer: " ++ show err
- Right () -> return ()
- return (M.insert svc (SomeServiceState proxy s') svcs,
- M.insert svc (SomeServiceGlobalState proxy gs') global)
- _ -> do
- logd $ "unhandled service '" ++ show (toUUID svc) ++ "'"
- return (svcs, global)
-
- | otherwise -> do
- logd $ "service packet from peer with incomplete identity " ++ show (peerAddress peer)
-
- return Server
- { serverStorage = storage
- , serverIdentity = midentity
- , serverSocket = ssocket
- , serverChanPacket = chanPacket
- , serverPeers = peers
- , serverChanPeer' = chanPeer
- }
-
-type PacketHandler a = StateT PacketHandlerState (ExceptT String IO) a
+ void $ forkIO $ forever $ do
+ (peer, svc, ref) <- atomically $ readTQueue chanSvc
+ atomically (readTVar (peerIdentityVar peer)) >>= \case
+ PeerIdentityFull peerId -> do
+ (global, svcs) <- atomically $ (,)
+ <$> takeTMVar svcStates
+ <*> takeTMVar (peerServiceState peer)
+ case (maybe (someServiceEmptyState <$> find ((svc ==) . someServiceID) services) Just $ M.lookup svc svcs,
+ maybe (someServiceEmptyGlobalState <$> find ((svc ==) . someServiceID) services) Just $ M.lookup svc global) of
+ (Just (SomeServiceState (proxy :: Proxy s) s),
+ Just (SomeServiceGlobalState (_ :: Proxy gs) gs))
+ | Just (Refl :: s :~: gs) <- eqT -> do
+ let inp = ServiceInput
+ { svcPeer = peerId
+ , svcPrintOp = atomically . logd
+ }
+ reloadHead origHead >>= \case
+ Nothing -> atomically $ do
+ logd $ "current head deleted"
+ putTMVar (peerServiceState peer) svcs
+ putTMVar svcStates global
+ Just h -> do
+ (rsp, (s', gs')) <- handleServicePacket h inp s gs (wrappedLoad ref :: Stored s)
+ identity <- readMVar midentity
+ sendToPeerList identity peer rsp
+ atomically $ do
+ putTMVar (peerServiceState peer) $ M.insert svc (SomeServiceState proxy s') svcs
+ putTMVar svcStates $ M.insert svc (SomeServiceGlobalState proxy gs') global
+ _ -> atomically $ do
+ logd $ "unhandled service '" ++ show (toUUID svc) ++ "'"
+ putTMVar (peerServiceState peer) svcs
+ putTMVar svcStates global
+
+ _ -> do
+ atomically $ logd $ "service packet from peer with incomplete identity " ++ show (peerAddress peer)
+
+ return server
+
+sendWorker :: Server -> IO ()
+sendWorker server = forever $ do
+ (peer, secure, packet@(TransportPacket header content)) <-
+ atomically (readTQueue $ serverOutQueue server)
+
+ let logd = atomically . writeTQueue (serverErrorLog $ peerServer peer)
+ let plain = BL.toStrict $ BL.concat $
+ (serializeObject $ transportToObject header)
+ : map lazyLoadBytes content
+ mbs <- do
+ mbch <- atomically $ do
+ readTVar (peerChannel peer) >>= \case
+ ChannelEstablished ch -> return (Just ch)
+ _ -> do when secure $ modifyTVar' (peerServiceOutQueue peer) (packet:)
+ return Nothing
+
+ case mbch of
+ Just ch -> do
+ runExceptT (channelEncrypt ch plain) >>= \case
+ Right ctext -> return $ Just ctext
+ Left err -> do logd $ "Failed to encrypt data: " ++ err
+ return Nothing
+ Nothing | secure -> return Nothing
+ | otherwise -> return $ Just plain
+
+ case mbs of
+ Just bs -> case peerAddress peer of
+ DatagramAddress sock addr -> void $ S.sendTo sock bs addr
+ PeerIceSession ice -> iceSend ice bs
+ Nothing -> return ()
+
+dataResponseWorker :: Server -> IO ()
+dataResponseWorker server = forever $ do
+ (peer, npref) <- atomically (readTQueue $ serverDataResponse server)
+
+ wait <- atomically $ takeTMVar (peerWaitingRefs peer)
+ list <- forM wait $ \wr@WaitingRef { wrefStatus = tvar } ->
+ atomically (readTVar tvar) >>= \case
+ Left ds -> case maybe id (filter . (/=) . refDigest) npref $ ds of
+ [] -> copyRef (wrefStorage wr) (wrefPartial wr) >>= \case
+ Right ref -> do
+ atomically (writeTVar tvar $ Right ref)
+ void $ forkIO $ runExceptT (wrefAction wr ref) >>= \case
+ Left err -> atomically $ writeTQueue (serverErrorLog server) err
+ Right () -> return ()
+
+ return (Nothing, [])
+ Left dgst -> do
+ atomically (writeTVar tvar $ Left [dgst])
+ return (Just wr, [partialRefFromDigest (refStorage $ wrefPartial wr) dgst])
+ ds' -> do
+ atomically (writeTVar tvar $ Left ds')
+ return (Just wr, [])
+ Right _ -> return (Nothing, [])
+ atomically $ putTMVar (peerWaitingRefs peer) $ catMaybes $ map fst list
+
+ let reqs = concat $ map snd list
+ when (not $ null reqs) $ do
+ let packet = TransportPacket (TransportHeader $ map DataRequest reqs) []
+ atomically $ sendToPeerPlain peer packet
+
+
+newtype PacketHandler a = PacketHandler { unPacketHandler :: StateT PacketHandlerState (ExceptT String STM) a }
+ deriving (Functor, Applicative, Monad, MonadState PacketHandlerState, MonadError String)
+
+instance MonadFail PacketHandler where
+ fail = throwError
+
+liftSTM :: STM a -> PacketHandler a
+liftSTM = PacketHandler . lift . lift
+
+readTVarP :: TVar a -> PacketHandler a
+readTVarP = liftSTM . readTVar
+
+writeTVarP :: TVar a -> a -> PacketHandler ()
+writeTVarP v = liftSTM . writeTVar v
+
+modifyTMVarP :: TMVar a -> (a -> a) -> PacketHandler ()
+modifyTMVarP v f = liftSTM $ putTMVar v . f =<< takeTMVar v
data PacketHandlerState = PacketHandlerState
{ phPeer :: Peer
@@ -365,9 +460,6 @@ data PacketHandlerState = PacketHandlerState
, phBody :: [Ref]
}
-updatePeer :: (Peer -> Peer) -> PacketHandler ()
-updatePeer f = modify $ \ph -> ph { phPeer = f (phPeer ph), phPeerChanged = True }
-
addHeader :: TransportHeaderItem -> PacketHandler ()
addHeader h = modify $ \ph -> ph { phHead = h `appendDistinct` phHead ph }
@@ -379,85 +471,74 @@ appendDistinct x (y:ys) | x == y = y : ys
| otherwise = y : appendDistinct x ys
appendDistinct x [] = [x]
-handlePacket :: (String -> IO ()) -> Head LocalState -> UnifiedIdentity -> Bool
- -> Peer -> Chan (Peer, ServiceID, Ref) -> [ServiceID]
- -> TransportHeader -> IO (Maybe Peer)
-handlePacket logd origHead identity secure opeer chanSvc svcs (TransportHeader headers) = do
+handlePacket :: Head LocalState -> UnifiedIdentity -> Bool
+ -> Peer -> TQueue (Peer, ServiceID, Ref) -> [ServiceID]
+ -> TransportHeader -> [PartialRef] -> IO (Maybe Peer)
+handlePacket origHead identity secure peer chanSvc svcs (TransportHeader headers) prefs = atomically $ do
+ let server = peerServer peer
+ ochannel <- readTVar $ peerChannel peer
let sidentity = idData identity
plaintextRefs = map (refDigest . storedRef) $ concatMap (collectStoredObjects . wrappedLoad) $ concat
[ [ storedRef sidentity ]
, map storedRef $ idUpdates identity
- , case peerChannel opeer of
+ , case ochannel of
ChannelOurRequest req -> [ storedRef req ]
ChannelOurAccept acc _ -> [ storedRef acc ]
_ -> []
]
- res <- runExceptT $ flip execStateT (PacketHandlerState opeer False [] []) $ do
+ res <- runExceptT $ flip execStateT (PacketHandlerState peer False [] []) $ unPacketHandler $ do
+ let logd = liftSTM . writeTQueue (serverErrorLog server)
forM_ headers $ \case
Acknowledged ref -> do
- gets (peerChannel . phPeer) >>= \case
+ readTVarP (peerChannel peer) >>= \case
ChannelOurAccept acc ch | refDigest (storedRef acc) == refDigest ref -> do
- updatePeer $ \p -> p { peerChannel = ChannelEstablished (fromStored ch) }
- finalizedChannel origHead identity
+ writeTVarP (peerChannel peer) $ ChannelEstablished (fromStored ch)
+ liftSTM $ finalizedChannel peer origHead identity
_ -> return ()
- Rejected _ -> return ()
+ Rejected ref -> do
+ logd $ "rejected by peer: " ++ show (refDigest ref)
DataRequest ref
| secure || refDigest ref `elem` plaintextRefs -> do
- Right mref <- copyRef (storedStorage sidentity) ref
+ Right mref <- liftSTM $ unsafeIOToSTM $ copyRef (storedStorage sidentity) ref
addHeader $ DataResponse ref
addBody $ mref
| otherwise -> do
- liftIO $ logd $ "unauthorized data request for " ++ show ref
+ logd $ "unauthorized data request for " ++ show ref
addHeader $ Rejected ref
- DataResponse ref -> do
- liftIO (ioLoadBytes ref) >>= \case
- Right _ -> do
- addHeader $ Acknowledged ref
- wait <- gets $ peerWaitingRefs . phPeer
- wait' <- flip filterM wait $ receivedWaitingRef ref >=> \case
- Just _ -> return False
- Nothing -> return True
- updatePeer $ \p -> p { peerWaitingRefs = wait' }
- Left _ -> throwError $ "mismatched data response " ++ show ref
-
- AnnounceSelf ref -> do
- peer <- gets phPeer
- if | PeerIdentityRef wref <- peerIdentity peer, wrDigest wref == refDigest ref -> return ()
- | PeerIdentityFull pid <- peerIdentity peer, refDigest ref == (refDigest $ storedRef $ idData pid) -> return ()
- | refDigest ref == refDigest (storedRef sidentity) -> return ()
- | otherwise -> do
- copyOrRequestRef (peerStorage peer) ref >>= \case
- Right pref
- | Just idt <- validateIdentity $ wrappedLoad pref ->
- case peerIdentity peer of
- PeerIdentityFull prev | not (prev `sameIdentity` idt) ->
- throwError $ "peer identity does not follow"
- _ -> updatePeer $ \p -> p { peerIdentity = PeerIdentityFull idt }
- | otherwise -> throwError $ "broken identity " ++ show pref
- Left wref -> do
- addHeader $ AnnounceSelf $ partialRef (peerInStorage peer) $ storedRef $ idData identity
- updatePeer $ \p -> p { peerIdentity = PeerIdentityRef wref }
+ DataResponse ref -> if
+ | ref `elem` prefs -> do
+ addHeader $ Acknowledged ref
+ liftSTM $ writeTQueue (serverDataResponse server) (peer, Just ref)
+ | otherwise -> throwError $ "mismatched data response " ++ show ref
+
+ AnnounceSelf pref
+ | refDigest pref == refDigest (storedRef sidentity) -> return ()
+ | otherwise -> readTVarP (peerIdentityVar peer) >>= \case
+ PeerIdentityUnknown idwait -> do
+ wref <- newWaitingRef pref $ handleIdentityAnnounce identity peer
+ addHeader $ AnnounceSelf $ partialRef (peerInStorage peer) $ storedRef $ idData identity
+ writeTVarP (peerIdentityVar peer) $ PeerIdentityRef wref idwait
+ modify $ \ph -> ph { phPeerChanged = True }
+ _ -> return ()
AnnounceUpdate ref -> do
- peer <- gets phPeer
- case peerIdentity peer of
- PeerIdentityFull pid -> copyOrRequestRef (peerStorage peer) ref >>= \case
- Right upd -> updatePeer $ \p -> p { peerIdentity = PeerIdentityFull $ updateOwners [wrappedLoad upd] pid }
- Left wref -> updatePeer $ \p -> p { peerIdentityUpdate = wref : peerIdentityUpdate p }
- _ -> return ()
+ readTVarP (peerIdentityVar peer) >>= \case
+ PeerIdentityFull _ -> do
+ void $ newWaitingRef ref $ handleIdentityUpdate peer
+ _ -> return ()
TrChannelRequest reqref -> do
- pst <- gets $ peerStorage . phPeer
let process = do
addHeader $ Acknowledged reqref
- handleChannelRequest identity =<< newWaitingRef pst reqref
+ wref <- newWaitingRef reqref $ handleChannelRequest peer identity
+ writeTVarP (peerChannel peer) $ ChannelPeerRequest wref
reject = addHeader $ Rejected reqref
- gets (peerChannel . phPeer) >>= \case
+ readTVarP (peerChannel peer) >>= \case
ChannelWait {} -> process
ChannelOurRequest our | refDigest reqref < refDigest (storedRef our) -> process
| otherwise -> reject
@@ -467,9 +548,8 @@ handlePacket logd origHead identity secure opeer chanSvc svcs (TransportHeader h
TrChannelAccept accref -> do
let process = do
- addHeader $ Acknowledged accref
handleChannelAccept origHead identity accref
- gets (peerChannel . phPeer) >>= \case
+ readTVarP (peerChannel peer) >>= \case
ChannelWait {} -> process
ChannelOurRequest {} -> process
ChannelPeerRequest {} -> process
@@ -482,207 +562,150 @@ handlePacket logd origHead identity secure opeer chanSvc svcs (TransportHeader h
| not secure -> throwError $ "service packet without secure channel"
| Just svc <- lookupServiceType headers -> if
| svc `elem` svcs -> do
- liftIO (ioLoadBytes pref) >>= \case
- Right _ -> do
+ if pref `elem` prefs || True {- TODO: used by Message service to confirm receive -}
+ then do
addHeader $ Acknowledged pref
- pst <- gets $ peerStorage . phPeer
- wref <- newWaitingRef pst pref
- updatePeer $ \p -> p { peerServiceInQueue = (svc, wref) : peerServiceInQueue p }
- Left _ -> throwError $ "missing service object " ++ show pref
+ void $ newWaitingRef pref $ \ref ->
+ liftIO $ atomically $ writeTQueue chanSvc (peer, svc, ref)
+ else throwError $ "missing service object " ++ show pref
| otherwise -> addHeader $ Rejected pref
| otherwise -> throwError $ "service ref without type"
-
- setupChannel identity
- handleIdentityUpdate
- handleServices chanSvc
+ let logd = writeTQueue (serverErrorLog server)
case res of
Left err -> do
- logd $ "Error in handling packet from " ++ show (peerAddress opeer) ++ ": " ++ err
+ logd $ "Error in handling packet from " ++ show (peerAddress peer) ++ ": " ++ err
return Nothing
Right ph -> do
when (not $ null $ phHead ph) $ do
- let plain = BL.toStrict $ BL.concat
- [ serializeObject $ transportToObject $ TransportHeader $ phHead ph
- , BL.concat $ map lazyLoadBytes $ phBody ph
- ]
- case peerChannel $ phPeer ph of
- ChannelEstablished ch -> do
- x <- runExceptT (channelEncrypt ch plain)
- case x of Right ctext -> void $ sendTo (phPeer ph) ctext
- Left err -> logd $ "Failed to encrypt data: " ++ err
- _ -> void $ sendTo (phPeer ph) plain
+ let packet = TransportPacket (TransportHeader $ phHead ph) (phBody ph)
+ writeTQueue (serverOutQueue server) (peer, secure, packet)
return $ if phPeerChanged ph then Just $ phPeer ph
else Nothing
-getOrRequestIdentity :: PeerIdentity -> PacketHandler (Maybe UnifiedIdentity)
-getOrRequestIdentity = \case
- PeerIdentityUnknown -> return Nothing
- PeerIdentityRef wref -> checkWaitingRef wref >>= \case
- Just ref -> case validateIdentity (wrappedLoad ref) of
- Nothing -> throwError $ "broken identity"
- Just idt -> return $ Just idt
- Nothing -> return Nothing
- PeerIdentityFull idt -> return $ Just idt
-
-
-setupChannel :: UnifiedIdentity -> PacketHandler ()
-setupChannel identity = gets phPeer >>= \case
- peer@Peer { peerChannel = ChannelWait } -> do
- getOrRequestIdentity (peerIdentity peer) >>= \case
- Just pid | Just upid <- toUnifiedIdentity pid -> do
- let ist = peerInStorage peer
- req <- createChannelRequest (peerStorage peer) identity upid
- updatePeer $ \p -> p { peerChannel = ChannelOurRequest req }
- addHeader $ TrChannelRequest $ partialRef ist $ storedRef req
- addHeader $ AnnounceSelf $ partialRef ist $ storedRef $ idData identity
- addBody $ storedRef req
+withPeerIdentity :: MonadIO m => Peer -> (UnifiedIdentity -> ExceptT String IO ()) -> m ()
+withPeerIdentity peer act = liftIO $ atomically $ readTVar (peerIdentityVar peer) >>= \case
+ PeerIdentityUnknown tvar -> modifyTVar' tvar (act:)
+ PeerIdentityRef _ tvar -> modifyTVar' tvar (act:)
+ PeerIdentityFull idt -> writeTQueue (serverIOActions $ peerServer peer) (act idt)
+
+
+setupChannel :: UnifiedIdentity -> Peer -> UnifiedIdentity -> WaitingRefCallback
+setupChannel identity peer upid = do
+ req <- createChannelRequest (peerStorage peer) identity upid
+ let ist = peerInStorage peer
+ let hitems =
+ [ TrChannelRequest $ partialRef ist $ storedRef req
+ , AnnounceSelf $ partialRef ist $ storedRef $ idData identity
+ ]
+ liftIO $ atomically $ do
+ readTVar (peerChannel peer) >>= \case
+ ChannelWait -> do
+ sendToPeerPlain peer $ TransportPacket (TransportHeader hitems) [storedRef req]
+ writeTVar (peerChannel peer) $ ChannelOurRequest req
_ -> return ()
- Peer { peerChannel = ChannelPeerRequest wref } -> do
- handleChannelRequest identity wref
-
- _ -> return ()
-
-handleChannelRequest :: UnifiedIdentity -> WaitingRef -> PacketHandler ()
-handleChannelRequest identity reqref = do
- ist <- gets $ peerInStorage . phPeer
- checkWaitingRef reqref >>= \case
- Just req -> do
- pid <- gets (peerIdentity . phPeer) >>= \case
- PeerIdentityFull pid -> return pid
- PeerIdentityRef wref -> do
- Just idref <- checkWaitingRef wref
- Just pid <- return $ validateIdentity $ wrappedLoad idref
- return pid
- PeerIdentityUnknown -> throwError $ "unknown peer identity"
-
- (acc, ch) <- case toUnifiedIdentity pid of
- Just upid -> acceptChannelRequest identity upid (wrappedLoad req)
- Nothing -> throwError $ "non-unified peer identity"
- updatePeer $ \p -> p
- { peerIdentity = PeerIdentityFull pid
- , peerChannel = ChannelOurAccept acc ch
- }
- addHeader $ TrChannelAccept (partialRef ist $ storedRef acc)
- mapM_ addBody $ concat
- [ [ storedRef $ acc ]
- , [ storedRef $ signedData $ fromStored acc ]
- , [ storedRef $ caKey $ fromStored $ signedData $ fromStored acc ]
- , map storedRef $ signedSignature $ fromStored acc
- ]
- Nothing -> do
- updatePeer $ \p -> p { peerChannel = ChannelPeerRequest reqref }
+handleChannelRequest :: Peer -> UnifiedIdentity -> Ref -> WaitingRefCallback
+handleChannelRequest peer identity req = do
+ withPeerIdentity peer $ \upid -> do
+ (acc, ch) <- acceptChannelRequest identity upid (wrappedLoad req)
+ liftIO $ atomically $ do
+ readTVar (peerChannel peer) >>= \case
+ ChannelPeerRequest wr | wrDigest wr == refDigest req -> do
+ writeTVar (peerChannel peer) $ ChannelOurAccept acc ch
+ let header = TrChannelAccept (partialRef (peerInStorage peer) $ storedRef acc)
+ sendToPeerPlain peer $ TransportPacket (TransportHeader [header]) $ concat
+ [ [ storedRef $ acc ]
+ , [ storedRef $ signedData $ fromStored acc ]
+ , [ storedRef $ caKey $ fromStored $ signedData $ fromStored acc ]
+ , map storedRef $ signedSignature $ fromStored acc
+ ]
+ _ -> writeTQueue (serverErrorLog $ peerServer peer) $ "unexpected channel request"
handleChannelAccept :: Head LocalState -> UnifiedIdentity -> PartialRef -> PacketHandler ()
handleChannelAccept oh identity accref = do
- pst <- gets $ peerStorage . phPeer
- copyRef pst accref >>= \case
- Right acc -> do
- pid <- gets (peerIdentity . phPeer) >>= \case
- PeerIdentityFull pid -> return pid
- PeerIdentityRef wref -> do
- Just idref <- checkWaitingRef wref
- Just pid <- return $ validateIdentity $ wrappedLoad idref
- return pid
- PeerIdentityUnknown -> throwError $ "unknown peer identity"
-
- ch <- case toUnifiedIdentity pid of
- Just upid -> acceptedChannel identity upid (wrappedLoad acc)
- Nothing -> throwError $ "non-unified peer identity"
- updatePeer $ \p -> p
- { peerIdentity = PeerIdentityFull pid
- , peerChannel = ChannelEstablished $ fromStored ch
- }
- finalizedChannel oh identity
- Left dgst -> throwError $ "missing accept data " ++ BC.unpack (showRefDigest dgst)
-
-
-finalizedChannel :: Head LocalState -> UnifiedIdentity -> PacketHandler ()
-finalizedChannel oh self = do
- -- Identity update
- ist <- gets $ peerInStorage . phPeer
- addHeader $ AnnounceSelf $ partialRef ist $ storedRef $ idData $ self
- mapM_ addHeader . map (AnnounceUpdate . partialRef ist . storedRef) . idUpdates $ self
+ peer <- gets phPeer
+ liftSTM $ writeTQueue (serverIOActions $ peerServer peer) $ do
+ withPeerIdentity peer $ \upid -> do
+ copyRef (peerStorage peer) accref >>= \case
+ Right acc -> do
+ ch <- acceptedChannel identity upid (wrappedLoad acc)
+ liftIO $ atomically $ do
+ sendToPeerS peer $ TransportPacket (TransportHeader [Acknowledged accref]) []
+ writeTVar (peerChannel peer) $ ChannelEstablished $ fromStored ch
+ finalizedChannel peer oh identity
- -- Shared state
- gets phPeer >>= \case
- peer | PeerIdentityFull pid <- peerIdentity peer
- , finalOwner pid `sameIdentity` finalOwner self -> do
- Just h <- liftIO $ reloadHead oh
- let shared = lsShared $ headObject h
- addHeader $ ServiceType $ serviceID @SyncService Proxy
- mapM_ (addHeader . ServiceRef . partialRef ist . storedRef) shared
- mapM_ (addBody . storedRef) shared
- | otherwise -> return ()
+ Left dgst -> throwError $ "missing accept data " ++ BC.unpack (showRefDigest dgst)
- -- Outstanding service packets
- gets phPeer >>= \case
- peer@Peer
- { peerChannel = ChannelEstablished ch
- , peerServiceOutQueue = oqueue
- } -> do
- ps <- liftIO $ modifyMVar oqueue $ return . ([],)
- forM_ ps $ sendPacket peer ch
- _ -> return ()
+finalizedChannel :: Peer -> Head LocalState -> UnifiedIdentity -> STM ()
+finalizedChannel peer oh self = do
+ -- Identity update
+ let ist = peerInStorage peer
+ sendToPeerS peer $ flip TransportPacket [] $ TransportHeader $
+ ( AnnounceSelf $ partialRef ist $ storedRef $ idData $ self ) :
+ ( map (AnnounceUpdate . partialRef ist . storedRef) $ idUpdates $ self )
-handleIdentityUpdate :: PacketHandler ()
-handleIdentityUpdate = do
- peer <- gets phPeer
- case (peerIdentity peer, peerIdentityUpdate peer) of
- (PeerIdentityRef wref, _) -> checkWaitingRef wref >>= \case
- Just ref | Just pid <- validateIdentity $ wrappedLoad ref -> do
- updatePeer $ \p -> p { peerIdentity = PeerIdentityFull pid }
- handleIdentityUpdate
- _ -> return ()
+ -- Shared state
+ readTVar (peerIdentityVar peer) >>= \case
+ PeerIdentityFull pid | finalOwner pid `sameIdentity` finalOwner self -> do
+ writeTQueue (serverIOActions $ peerServer peer) $ do
+ Just h <- liftIO $ reloadHead oh
+ let shared = lsShared $ headObject h
+ let hitems = (ServiceType $ serviceID @SyncService Proxy) :
+ map (ServiceRef . partialRef ist . storedRef) shared
+ liftIO $ atomically $ sendToPeerS peer $
+ TransportPacket (TransportHeader hitems) $ map storedRef shared
+ _ -> return ()
- (PeerIdentityFull pid, wrefs@(_:_)) -> do
- (wrefs', upds) <- fmap partitionEithers $ forM wrefs $ \wref -> checkWaitingRef wref >>= \case
- Just upd -> return $ Right $ wrappedLoad upd
- Nothing -> return $ Left wref
- updatePeer $ \p -> p
- { peerIdentity = PeerIdentityFull $ updateOwners upds pid
- , peerIdentityUpdate = wrefs'
- }
-
- _ -> return ()
-
-
-handleServices :: Chan (Peer, ServiceID, Ref) -> PacketHandler ()
-handleServices chan = gets (peerServiceInQueue . phPeer) >>= \case
- [] -> return ()
- queue -> do
- queue' <- flip filterM queue $ \case
- (svc, wref) -> checkWaitingRef wref >>= \case
- Just ref -> do
- peer <- gets phPeer
- liftIO $ writeChan chan (peer, svc, ref)
- return False
- Nothing -> return True
- updatePeer $ \p -> p { peerServiceInQueue = queue' }
-
-
-mkPeer :: Storage -> PeerAddress -> IO Peer
-mkPeer st paddr = do
- pst <- deriveEphemeralStorage st
- ist <- derivePartialStorage pst
- svcs <- newMVar M.empty
- oqueue <- newMVar []
- return $ Peer
- { peerAddress = paddr
- , peerIdentity = PeerIdentityUnknown
- , peerIdentityUpdate = []
- , peerChannel = ChannelWait
- , peerStorage = pst
- , peerInStorage = ist
- , peerServiceState = svcs
- , peerServiceInQueue = []
- , peerServiceOutQueue = oqueue
- , peerWaitingRefs = []
- }
+ -- Outstanding service packets
+ mapM_ (sendToPeerS peer) =<< swapTVar (peerServiceOutQueue peer) []
+
+
+handleIdentityAnnounce :: UnifiedIdentity -> Peer -> Ref -> WaitingRefCallback
+handleIdentityAnnounce self peer ref = liftIO $ atomically $ do
+ pidentity <- readTVar (peerIdentityVar peer)
+ if | PeerIdentityRef wref wact <- pidentity
+ , wrDigest wref == refDigest ref
+ -> case validateIdentity $ wrappedLoad ref of
+ Just pid -> do
+ writeTVar (peerIdentityVar peer) $ PeerIdentityFull pid
+ writeTChan (serverChanPeer $ peerServer peer) peer
+ mapM_ (writeTQueue (serverIOActions $ peerServer peer) . ($pid)) .
+ reverse =<< readTVar wact
+ writeTQueue (serverIOActions $ peerServer peer) $ do
+ setupChannel self peer pid
+ Nothing -> return ()
+
+ | otherwise -> return ()
+
+handleIdentityUpdate :: Peer -> Ref -> WaitingRefCallback
+handleIdentityUpdate peer ref = liftIO $ atomically $ do
+ pidentity <- readTVar (peerIdentityVar peer)
+ if | PeerIdentityFull pid <- pidentity
+ -> do
+ writeTVar (peerIdentityVar peer) $ PeerIdentityFull $
+ updateOwners [wrappedLoad ref] pid
+ writeTChan (serverChanPeer $ peerServer peer) peer
+
+ | otherwise -> return ()
+
+
+mkPeer :: Server -> PeerAddress -> IO Peer
+mkPeer server paddr = do
+ pst <- deriveEphemeralStorage $ serverStorage server
+ Peer
+ <$> pure paddr
+ <*> pure server
+ <*> (newTVarIO . PeerIdentityUnknown =<< newTVarIO [])
+ <*> newTVarIO ChannelWait
+ <*> pure pst
+ <*> derivePartialStorage pst
+ <*> newTMVarIO M.empty
+ <*> newTVarIO []
+ <*> newTMVarIO []
serverPeer :: Server -> SockAddr -> IO Peer
serverPeer server paddr = do
@@ -702,27 +725,24 @@ serverPeer' server paddr = do
case M.lookup paddr pvalue of
Just peer -> return (pvalue, (peer, False))
Nothing -> do
- peer <- mkPeer (serverStorage server) paddr
+ peer <- mkPeer server paddr
return (M.insert paddr peer pvalue, (peer, True))
when hello $ do
identity <- readMVar (serverIdentity server)
- void $ sendTo peer $
- BL.toStrict $ serializeObject $ transportToObject $ TransportHeader
- [ AnnounceSelf $ partialRef (peerInStorage peer) $ storedRef $ idData identity ]
+ atomically $ writeTQueue (serverOutQueue server) $ (peer, False,) $
+ TransportPacket
+ (TransportHeader [ AnnounceSelf $ partialRef (peerInStorage peer) $ storedRef $ idData identity ])
+ []
return peer
-sendTo :: Peer -> BC.ByteString -> IO ()
-sendTo Peer { peerAddress = DatagramAddress sock addr } msg = void $ S.sendTo sock msg addr
-sendTo Peer { peerAddress = PeerIceSession ice } msg = iceSend ice msg
-
-sendToPeer :: (Service s, MonadIO m, MonadError String m) => UnifiedIdentity -> Peer -> s -> m ()
+sendToPeer :: (Service s, MonadIO m) => UnifiedIdentity -> Peer -> s -> m ()
sendToPeer self peer packet = sendToPeerList self peer [ServiceReply (Left packet) True]
-sendToPeerStored :: (Service s, MonadIO m, MonadError String m) => UnifiedIdentity -> Peer -> Stored s -> m ()
+sendToPeerStored :: (Service s, MonadIO m) => UnifiedIdentity -> Peer -> Stored s -> m ()
sendToPeerStored self peer spacket = sendToPeerList self peer [ServiceReply (Right spacket) True]
-sendToPeerList :: (Service s, MonadIO m, MonadError String m) => UnifiedIdentity -> Peer -> [ServiceReply s] -> m ()
+sendToPeerList :: (Service s, MonadIO m) => UnifiedIdentity -> Peer -> [ServiceReply s] -> m ()
sendToPeerList _ peer parts = do
let st = peerStorage peer
pst = peerInStorage peer
@@ -732,27 +752,26 @@ sendToPeerList _ peer parts = do
let content = map snd $ filter (\(ServiceReply _ use, _) -> use) (zip parts srefs)
header = TransportHeader (ServiceType (serviceID $ head parts) : map ServiceRef prefs)
packet = TransportPacket header content
- case peerChannel peer of
- ChannelEstablished ch -> do
- sendPacket peer ch packet
- _ -> liftIO $ modifyMVar_ (peerServiceOutQueue peer) $ return . (packet:)
+ liftIO $ atomically $ sendToPeerS peer packet
-sendPacket :: (MonadIO m, MonadError String m) => Peer -> Channel -> TransportPacket -> m ()
-sendPacket peer ch (TransportPacket header content) = do
- let plain = BL.toStrict $ BL.concat $
- (serializeObject $ transportToObject header)
- : map lazyLoadBytes content
- ctext <- channelEncrypt ch plain
- void $ liftIO $ sendTo peer ctext
+sendToPeerS :: Peer -> TransportPacket -> STM ()
+sendToPeerS peer packet = writeTQueue (serverOutQueue $ peerServer peer) (peer, True, packet)
+
+sendToPeerPlain :: Peer -> TransportPacket -> STM ()
+sendToPeerPlain peer packet = writeTQueue (serverOutQueue $ peerServer peer) (peer, False, packet)
sendToPeerWith :: forall s m. (Service s, MonadIO m, MonadError String m) => UnifiedIdentity -> Peer -> (ServiceState s -> ExceptT String IO (Maybe s, ServiceState s)) -> m ()
sendToPeerWith identity peer fobj = do
let sproxy = Proxy @s
sid = serviceID sproxy
- res <- liftIO $ modifyMVar (peerServiceState peer) $ \svcs -> do
- runExceptT (fobj $ fromMaybe (emptyServiceState sproxy) $ fromServiceState sproxy =<< M.lookup sid svcs) >>= \case
+ res <- liftIO $ do
+ svcs <- atomically $ takeTMVar (peerServiceState peer)
+ (svcs', res) <- runExceptT (fobj $ fromMaybe (emptyServiceState sproxy) $ fromServiceState sproxy =<< M.lookup sid svcs) >>= \case
Right (obj, s') -> return $ (M.insert sid (SomeServiceState sproxy s') svcs, Right obj)
Left err -> return $ (svcs, Left err)
+ atomically $ putTMVar (peerServiceState peer) svcs'
+ return res
+
case res of
Right (Just obj) -> sendToPeer identity peer obj
Right Nothing -> return ()
diff --git a/src/Pairing.hs b/src/Pairing.hs
index a0a19b3..9af33c7 100644
--- a/src/Pairing.hs
+++ b/src/Pairing.hs
@@ -155,9 +155,9 @@ confirmationNumber dgst = let (a:b:c:d:_) = map fromIntegral $ BA.unpack dgst ::
pairingRequest :: forall a m proxy. (PairingResult a, MonadIO m, MonadError String m) => proxy a -> UnifiedIdentity -> Peer -> m ()
pairingRequest _ self peer = do
nonce <- liftIO $ getRandomBytes 32
- pid <- case peerIdentity peer of
- PeerIdentityFull pid -> return pid
- _ -> throwError "incomplete peer identity"
+ pid <- peerIdentity peer >>= \case
+ PeerIdentityFull pid -> return pid
+ _ -> throwError "incomplete peer identity"
sendToPeerWith @(PairingService a) self peer $ \case
NoPairing -> return (Just $ PairingRequest (nonceDigest self pid nonce BA.empty), OurRequest nonce)
_ -> throwError "alredy in progress"
diff --git a/src/Storage/Internal.hs b/src/Storage/Internal.hs
index e4e4f00..a625efb 100644
--- a/src/Storage/Internal.hs
+++ b/src/Storage/Internal.hs
@@ -71,6 +71,9 @@ data StorageBacking c
newtype RefDigest = RefDigest (Digest Blake2b_256)
deriving (Eq, Ord, NFData, ByteArrayAccess)
+instance Show RefDigest where
+ show = BC.unpack . showRefDigest
+
data Ref' c = Ref (Storage' c) RefDigest
deriving (Eq)