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
|
{-# LANGUAGE StandaloneDeriving #-}
module SybilLimit where
import Data.List
import Data.IntMap.Strict ( IntMap, (!) )
import qualified Data.IntMap.Strict as IntMap
import Data.Traversable
import Control.Applicative
-- import System.Random
import Stochastic
import Data.Map.Strict ( Map )
import qualified Data.Map as Map
data NodeId
deriving instance Ord NodeId
deriving instance Eq NodeId
data ThisNode = ThisNode
{ selfId :: NodeId
, friends :: IntMap FriendNode
, friendById :: Map NodeId Int
, routeTails :: IntMap (NodeId,NodeId)
-- ^ Terminal edge by instance number.
, routeCount :: Int
}
data FriendNode = FriendNode
{ friendId :: NodeId
, routesTo :: IntMap Int
-- ^ Forward random-route hop by instance number.
, routesFrom :: IntMap Int
-- ^ Backward random-route hop by instance number.
, registeredTerminal :: Maybe NodeId
-- ^ Currently registered terminal edge.
-- The NodeId indicates the source vertex, friendId is the destination vertex.
}
data PeerMessage
= ForwardRRMessage { rrRoute :: Int
, rrCount :: Int
, rrSuspect :: NodeId }
| BackwardRRMessage { rrRoute :: Int
, rrCount :: Int
, rrTail :: (NodeId,NodeId) }
friendNode :: NodeId -> FriendNode
friendNode nid = FriendNode nid IntMap.empty IntMap.empty Nothing
friendCount :: ThisNode -> Int
friendCount me = IntMap.size $ friends me
todo :: a
todo = error "unimplemented"
-- | @ addFriend @ adds a friend and updates the random route instances.
--
-- Arguments:
--
-- [@them@] The 'NodeId' of the friend being added.
--
-- [@me@] 'ThisNode' prior to the friend being added.
--
-- Returns the altered 'ThisNode' and the list of friend numbers
-- for which we should send notifications about the change.
--
addFriend :: NodeId -> ThisNode -> Stochastic ( ThisNode, [Int] )
addFriend them me = fmap (\ks -> (addFriend' ks them me,ks)) mks
where
d = friendCount me
mks = sequenceA $ replicate (routeCount me) $ random 0 d
addFriend' :: [Int] -> NodeId -> ThisNode -> ThisNode
addFriend' ks them me = me { friends = fs, friendById = ids }
where
d = friendCount me
fs0 = IntMap.insert d (friendNode them) $ friends me
ids = Map.insert them d (friendById me)
fs = foldl' (flip $ uncurry updateRoute) fs0 edges
where edges = zip [0..] (map mkEdge ks)
mkEdge k = if k==d then (d,d) else (k,d)
-- | @ updateRoute @ updates one of the random routes used by SybilLimit.
--
-- [@i@] The random route instance number.
--
-- [@(k,j)@] A pair of friend numbers. The routes inbound from friend @k@
-- will be routed out to friend @j@ for the s-direction (forwards)
-- and vice versa for the v-direction (backwards).
--
-- [@fs@] The current friend map prior to changed route.
--
-- Returns: The friend map with changes applied.
--
updateRoute :: Int -> (Int,Int) -> IntMap FriendNode -> IntMap FriendNode
updateRoute i (k,j) fs = jfromk $ ktoj fs
where
ktoj fs = IntMap.insert k (setTo i j (fs!k)) fs
jfromk fs = IntMap.insert j (setFrom i k (fs!j)) fs
setTo i x f = f { routesTo = IntMap.insert i x (routesTo f)}
setFrom i x f = f { routesFrom = IntMap.insert i x (routesFrom f)}
forwardMessage me next (srcId,msg) = msg'
where msg' = ( dest, msg { rrCount = rrCount msg + 1 } )
srcno = friendById me Map.! srcId
destno = next (friends me ! srcno) ! rrRoute msg
dest = friendId (friends me ! destno)
reactToMessage :: Int -> (NodeId,PeerMessage) -> ThisNode -> (ThisNode, [(NodeId,PeerMessage)])
reactToMessage w (srcId, msg) me =
if rrCount msg == w then terminate else (me, [forwardMessage me next (srcId,msg)])
where
(terminate,next) = case msg of
ForwardRRMessage {} -> ( terminateForward, routesTo )
BackwardRRMessage {} -> ( terminateBackward, routesFrom )
terminateForward = ( me { friends = friends' }, [pong] )
where pong =( srcId, BackwardRRMessage { rrCount = 1
, rrRoute = rrRoute msg
, rrTail = (srcId, selfId me)
} )
friends' = IntMap.adjust adj suspectNo $ friends me
suspectNo = friendById me Map.! rrSuspect msg
adj f = f { registeredTerminal = Just $ rrSuspect msg }
terminateBackward = ( me', [])
where me' = me { routeTails =
IntMap.insert (rrRoute msg) (rrTail msg)
$ routeTails me
}
|
