summaryrefslogtreecommitdiff
path: root/ToxToXMPP.hs
blob: c61764eff8320bf1b423b8456a24013eb8ace52a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
{-# LANGUAGE CPP            #-}
{-# LANGUAGE LambdaCase     #-}
{-# LANGUAGE NamedFieldPuns #-}
module ToxToXMPP where

import Data.Conduit                 as C
import qualified Data.Conduit.List  as CL
import Data.XML.Types               as XML
import Network.Tox.Crypto.Transport as Tox
import XMPPServer                   as XMPP
import EventUtil

import Announcer
import Announcer.Tox
import Connection
import Network.QueryResponse
-- import Control.Concurrent
import Control.Concurrent.STM
import Control.Monad
import Crypto.Tox
import qualified Data.HashMap.Strict         as HashMap
import Data.Maybe
import qualified Data.Set                    as Set
import qualified Data.Text                   as T
import Data.Time.Clock.POSIX
import Network.Address
import Network.Kademlia.Search
import qualified Network.Tox                 as Tox
import Network.Tox.ContactInfo               as Tox
import qualified Network.Tox.Crypto.Handlers as Tox
-- import qualified Network.Tox.DHT.Handlers    as Tox
import Announcer
import ClientState
import Control.Concurrent.STM
import Control.Monad
import Crypto.Tox
import Data.Bits
import Data.Function
import qualified Data.Map                    as Map
import qualified Data.Set                    as Set
import qualified Data.Text                   as T
         ;import Data.Text                   (Text)
import Data.Word
import qualified Network.Kademlia.Routing    as R
import Network.Tox
import Network.Tox.ContactInfo
import Network.Tox.DHT.Handlers
import qualified Network.Tox.DHT.Transport   as Tox
         ;import Network.Tox.DHT.Transport   (FriendRequest (..))
import Network.Tox.NodeId
import qualified Network.Tox.Onion.Handlers  as Tox
import qualified Network.Tox.Onion.Transport as Tox
         ;import Network.Tox.Onion.Transport (OnionData (..))
import Presence
import Presence
import System.IO
import Text.Read
import XMPPServer                            (ConnectionKey)
#ifdef THREAD_DEBUG
import Control.Concurrent.Lifted.Instrument
#else
import Control.Concurrent.Lifted
import GHC.Conc                  (labelThread)
#endif

xmppToTox :: Conduit XML.Event IO Tox.CryptoMessage
xmppToTox = do
    awaitForever (\_ -> return ())

toxToXmpp :: Monad m => Text -> Conduit Tox.CryptoMessage m XML.Event
toxToXmpp toxhost = do
    CL.sourceList $ XMPP.greet' "jabber:server" toxhost
    awaitForever $ \toxmsg -> do
        xmppInstantMessage "jabber:server" (Just toxhost) (T.pack $ show $ msgID toxmsg)

xmppInstantMessage :: Monad m => Text -> Maybe Text -> Text -> ConduitM i Event m ()
xmppInstantMessage namespace mfrom text = do
    let ns n = n { nameNamespace = Just namespace }
    C.yield $ EventBeginElement (ns "message")
               ((maybe id (\t->(attr "from" t:)) mfrom)
                 [attr "type" "normal" ])
    C.yield $   EventBeginElement (ns "body") []
    C.yield $     EventContent $ ContentText text
    C.yield $   EventEndElement (ns "body")
    C.yield $   EventBeginElement "{http://jabber.org/protocol/xhtml-im}html" []
    C.yield $     EventBeginElement "{http://www.w3.org/1999/xhtml}body" []
    C.yield $        EventBeginElement "{http://www.w3.org/1999/xhtml}p"
                       [ attr "style" "font-weight:bold; color:red" ]
    C.yield $          EventContent $ ContentText text
    C.yield $        EventEndElement "{http://www.w3.org/1999/xhtml}p"
    C.yield $     EventEndElement "{http://www.w3.org/1999/xhtml}body"
    C.yield $   EventEndElement "{http://jabber.org/protocol/xhtml-im}html"
    C.yield $ EventEndElement (ns "message")

key2jid :: Word32 -> PublicKey -> Text
key2jid nospam key = T.pack $ show $ NoSpamId nsp key
 where
    nsp = NoSpam nospam (Just sum)
    sum = nlo `xor` nhi `xor` xorsum key
    nlo = fromIntegral (0x0FFFF .&. nospam) :: Word16
    nhi = fromIntegral (0x0FFFF .&. (nospam `shiftR` 16)) :: Word16

data ToxToXMPP = ToxToXMPP
    { txAnnouncer :: Announcer
    , txAccount   :: Account
    , txPresence  :: PresenceState
    , txTox       :: Tox
    }

dispatch :: ToxToXMPP -> ContactEvent -> IO ()
dispatch tx (SessionEstablished theirKey) = stopConnecting tx theirKey
dispatch tx (SessionTerminated theirKey)  = startConnecting tx theirKey
dispatch tx (AddrChange   theirkey saddr)                    = return () -- todo
dispatch tx (PolicyChange theirkey TryingToConnect         ) = startConnecting tx theirkey
dispatch tx (PolicyChange theirkey policy                  ) = stopConnecting tx theirkey
dispatch tx (OnionRouted  theirkey (OnionDHTPublicKey pkey)) = return () -- todo
dispatch tx (OnionRouted  theirkey (OnionFriendRequest fr) ) = do
    let ToxToXMPP { txAnnouncer = acr
                  , txAccount   = acnt
                  , txPresence  = st } = tx
    k2c <- atomically $ do
        refs <- readTVar (clientRefs acnt)
        k2c <- Map.filterWithKey (\k _ -> k `Set.member` refs) <$> readTVar (keyToChan st)
        clients <- readTVar (clients st)
        return $ Map.intersectionWith (,) k2c clients
    -- TODO: Below we're using a hard coded default as their jabber user id.
    -- This isn't the right thing, but we don't know their user-id.  Perhaps
    -- there should be a way to parse it out of the friend request text.  Maybe
    -- after a zero-termination, or as visible text (nospam:...).
    let default_nospam = 0x6a7a27fc -- big-endian base64: anon/A==
        theirjid = key2jid default_nospam theirkey
    forM_ k2c $ \(conn,client) -> do
        self <- localJID (clientUser client) (clientProfile client) (clientResource client)
        ask <- presenceSolicitation theirjid self
        -- TODO Send friend-request text as an instant message or at least
        -- embed it in the stanza as a <status> element.
        sendModifiedStanzaToClient ask (connChan conn)

interweave :: [a] -> [a] -> [a]
interweave []     ys = ys
interweave (x:xs) ys = x : interweave ys xs

akeyDHTKeyShare announcer me them = atomically $ do
    packAnnounceKey announcer $ "dhtkey:" ++ (take 8 $ show me) ++ ":" ++ show (key2id them)
akeyConnect announcer me them = atomically $ do
    packAnnounceKey announcer $ "connect:" ++ (take 8 $ show me) ++ ":" ++ show (key2id them)

startConnecting0 :: ToxToXMPP -> PublicKey -> Contact -> IO ()
startConnecting0 tx them contact = do
        let ToxToXMPP { txTox       = tox
                      , txAnnouncer = announcer
                      , txAccount   = acnt     } = tx
        let nearNodes nid = do
                bkts4 <- readTVar $ routing4 $ toxRouting tox
                bkts6 <- readTVar $ routing6 $ toxRouting tox
                let nss = map (R.kclosest (searchSpace (toxQSearch tox)) searchK nid)
                              [bkts4,bkts6]
                return $ foldr interweave [] nss
        wanted <- atomically $ (==Just TryingToConnect) <$> readTVar (contactPolicy contact)
        when wanted $ do
            let pub = toPublic $ userSecret acnt
                me  = key2id pub
            akey <- akeyDHTKeyShare announcer me them
                    -- 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.
                    --
            -- TODO: Reschedule this as appropriate within 'dispatch' function.
            scheduleSearch announcer
                     akey
                     (SearchMethod   (toxQSearch tox)
                                     (\theirkey rendezvous -> do
                                        dkey <- Tox.getContactInfo tox
                                        sendMessage
                                            (Tox.toxToRoute tox)
                                            (Tox.AnnouncedRendezvous theirkey rendezvous)
                                            (pub,Tox.OnionDHTPublicKey dkey))
                                     nearNodes
                                     (key2id them)
                                     30) -- every 30 seconds
                     pub

startConnecting :: ToxToXMPP -> PublicKey -> IO ()
startConnecting tx them = do
    mc <- atomically $ HashMap.lookup (key2id them)
                        <$> readTVar (contacts $ txAccount tx)
    forM_ mc $ startConnecting0 tx them


stopConnecting :: ToxToXMPP -> PublicKey -> IO ()
stopConnecting ToxToXMPP{txAnnouncer=announcer,txAccount=acnt} them = do
    hPutStrLn stderr $ "STOP CONNECTING " ++ show (key2id them)
    let pub = toPublic $ userSecret acnt
        me  = key2id pub
    akey <- akeyDHTKeyShare announcer me them
    cancel announcer akey

forkAccountWatcher :: Account -> Tox -> PresenceState -> Announcer -> IO ThreadId
forkAccountWatcher acc tox st announcer = forkIO $ do
    myThreadId >>= flip labelThread ("tox-xmpp:"
                                      ++ show (key2id $ toPublic $ userSecret acc))
    (chan,cs) <- atomically $ do
                chan <- dupTChan $ eventChan acc -- duplicate broadcast channel for reading.
                contacts <- readTVar (contacts acc)
                return (chan,contacts)
    let tx = ToxToXMPP { txAnnouncer = announcer
                       , txAccount   = acc
                       , txPresence  = st
                       , txTox       = tox
                       }
    forM_ (HashMap.toList cs) $ \(them,c) -> do
        startConnecting0 tx (id2key them) c

    -- Loop endlessly until clientRefs is null.
    fix $ \loop -> do
    mev <- atomically $
            (Just <$> readTChan chan)
            `orElse` do
                refs <- readTVar $ clientRefs acc
                check $ Set.null refs
                return Nothing

    forM_ mev $ \ev -> dispatch tx ev >> loop

    cs <- atomically $ readTVar (contacts acc)
    forM_ (HashMap.toList cs) $ \(them,c) -> do
        stopConnecting tx (id2key them)


toxQSearch :: Tox.Tox -> Search Tox.NodeId (IP, PortNumber) Nonce32 Tox.NodeInfo Tox.Rendezvous
toxQSearch tox = Tox.toxidSearch (Tox.onionTimeout tox) (Tox.toxCryptoKeys tox) (Tox.toxOnion tox)

toxAnnounceInterval :: POSIXTime
toxAnnounceInterval = 15