- tor-commits - lists.torproject.org

[tordnsel/master] Control.Concurrent: block/unblock -> mask/restore
by arlo＠torproject.org 16 Apr '16

16 Apr '16

commit 848228a5f1f043e5c10e55a0b9715e9c0d452535 Author: David Kaloper <david(a)numm.org> Date: Wed Aug 28 00:05:19 2013 +0200 Control.Concurrent: block/unblock -> mask/restore --- src/TorDNSEL/Control/Concurrent/Future.hs | 4 ++-- src/TorDNSEL/Control/Concurrent/Link/Internals.hs | 18 +++++++++++------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/TorDNSEL/Control/Concurrent/Future.hs b/src/TorDNSEL/Control/Concurrent/Future.hs index 4b5c6ac..8256477 100644 --- a/src/TorDNSEL/Control/Concurrent/Future.hs +++ b/src/TorDNSEL/Control/Concurrent/Future.hs @@ -34,8 +34,8 @@ spawn :: IO a -> IO (Future a) spawn io = do mv <- newEmptyMVar callingThread <- myThreadId - forkLinkIO . E.block $ do - r <- either (Left . extractReason) (Right . id) `fmap` E.try (E.unblock io) + forkLinkIO . E.mask $ \restore -> do + r <- either (Left . extractReason) (Right . id) `fmap` E.try (restore io) putMVar mv r unlinkThread callingThread either exit (const $ return ()) r diff --git a/src/TorDNSEL/Control/Concurrent/Link/Internals.hs b/src/TorDNSEL/Control/Concurrent/Link/Internals.hs index 7b614b9..5c3f8b2 100644 --- a/src/TorDNSEL/Control/Concurrent/Link/Internals.hs +++ b/src/TorDNSEL/Control/Concurrent/Link/Internals.hs @@ -32,6 +32,7 @@ import Control.Concurrent.MVar import GHC.Conc (setUncaughtExceptionHandler) import System.Exit (ExitCode) import Control.Monad (unless) +import Data.Functor import qualified Data.Foldable as F import qualified Data.Map as M import qualified Data.Set as S @@ -142,7 +143,7 @@ defaultSignal dst src e = E.throwTo dst $ ExitSignal src e withLinksDo :: IO a -> IO () withLinksDo io = E.mask $ \restore -> do setUncaughtExceptionHandler . const . return $ () - main <- C.myThreadId + main <- C.myThreadId mainId <- Tid `fmap` newUnique let initialState = ThreadState { ident = mainId @@ -158,7 +159,7 @@ withLinksDo io = E.mask $ \restore -> do , state = M.insert main initialState (state tm) } -- Don't bother propagating signals from the main thread -- since it's about to exit. - (restore io >> return ()) `E.catch` \(e :: E.SomeException) -> + (() <$ restore io) `E.catch` \(e :: E.SomeException) -> case extractReason e of NormalExit -> return () AbnormalExit (E.fromException -> Just e') -> @@ -178,8 +179,8 @@ forkLinkIO :: IO a -> IO ThreadId forkLinkIO = forkLinkIO' True forkLinkIO' :: Bool -> IO a -> IO ThreadId -forkLinkIO' shouldLink io = E.block $ do - parent <- C.myThreadId +forkLinkIO' shouldLink io = E.mask $ \restore -> do + parent <- C.myThreadId childId <- Tid `fmap` newUnique modifyMVar_ threadMap $ \tm -> do #ifdef DEBUG @@ -187,7 +188,9 @@ forkLinkIO' shouldLink io = E.block $ do #endif child <- forkHandler $ do child <- C.myThreadId - e <- either extractReason (const NormalExit) `fmap` E.try (E.unblock io) + e <- either (extractReason :: E.SomeException -> ExitReason) + (const NormalExit) + `fmap` E.try (restore io) -- modifyMVar is interruptible (a misfeature in this case), so an async -- exception could be delivered here. Forking an anonymous thread should -- avoid this race since nobody can throwTo it. @@ -234,9 +237,10 @@ forkLinkIO' shouldLink io = E.block $ do withMVar threadMap assertThreadMap #endif return childId + where - forkHandler = C.forkIO . ignore . (>> return ()) . E.block - ignore = E.handle $ \(e :: E.SomeException) -> return () + forkHandler io = E.mask_ . C.forkIO $ + (() <$ io) `E.catch` \(e :: E.SomeException) -> return () -- | Establish a bidirectional link between the calling thread and a given -- thread. If either thread terminates, an exit signal will be sent to the other

1 0

[tordnsel/master] stub hGetLine
by arlo＠torproject.org 16 Apr '16

16 Apr '16

commit d3976bd028ca1a476e24fea1d7d67acbd545592e Author: David Kaloper <david(a)numm.org> Date: Thu Aug 8 03:14:21 2013 +0200 stub hGetLine This function knows *way* too much about the IO manager. Go to sleep, Frankenstein. --- src/TorDNSEL/Util.hsc | 201 +++++++++++++++++++++++++------------------------- 1 file changed, 101 insertions(+), 100 deletions(-) diff --git a/src/TorDNSEL/Util.hsc b/src/TorDNSEL/Util.hsc index 57ada86..13303ac 100644 --- a/src/TorDNSEL/Util.hsc +++ b/src/TorDNSEL/Util.hsc @@ -363,106 +363,107 @@ foreign import ccall unsafe "ntohl" ntohl :: Word32 -> Word32 -- bytes. If EOF is encountered, return the bytes preceding it. The handle -- should be in 'LineBuffering' mode. hGetLine :: Handle -> ByteString -> Int -> IO ByteString -hGetLine h eol maxLen | B.null eol = B.hGet h maxLen -hGetLine h eol(a)(B.PS _ _ eolLen) maxLen - = wantReadableHandle "TorDNSEL.Util.hGetLine" h $ \handle_ -> do - case haBufferMode handle_ of - NoBuffering -> error "no buffering" - _other -> hGetLineBuffered handle_ - - where - hGetLineBuffered handle_ = do - let ref = haBuffer handle_ - buf <- readIORef ref - hGetLineBufferedLoop handle_ ref buf 0 0 [] - - hGetLineBufferedLoop handle_ ref - buf@Buffer{ bufRPtr=r, bufWPtr=w, bufBuf=raw } !len !eolIx xss = do - (new_eolIx,off) <- findEOL eolIx r w raw - let new_len = len + off - r - - if maxLen > 0 && new_len - new_eolIx > maxLen - -- If the line length exceeds maxLen, return a partial line. - then do - let maxOff = off - (new_len - maxLen) - writeIORef ref buf{ bufRPtr = maxOff } - mkBigPS . (:xss) =<< mkPS raw r maxOff - else if new_eolIx == eolLen - -- We have a complete line; strip the EOL sequence and return it. - then do - if w == off - then writeIORef ref buf{ bufRPtr=0, bufWPtr=0 } - else writeIORef ref buf{ bufRPtr = off } - if eolLen <= off - r - then mkBigPS . (:xss) =<< mkPS raw r (off - eolLen) - else fmap stripEOL . mkBigPS . (:xss) =<< mkPS raw r off - else do - xs <- mkPS raw r off - maybe_buf <- maybeFillReadBuffer (haFD handle_) True - (haIsStream handle_) buf{ bufWPtr=0, bufRPtr=0 } - case maybe_buf of - -- Nothing indicates we caught an EOF, and we may have a - -- partial line to return. - Nothing -> do - writeIORef ref buf{ bufRPtr=0, bufWPtr=0 } - if new_len > 0 - then mkBigPS (xs:xss) - else ioe_EOF - Just new_buf -> - hGetLineBufferedLoop handle_ ref new_buf new_len new_eolIx - (xs:xss) - - maybeFillReadBuffer fd is_line is_stream buf - = catch (Just `fmap` fillReadBuffer fd is_line is_stream buf) - (\e -> if isEOFError e then return Nothing else ioError e) - - findEOL eolIx - | eolLen == 1 = findEOLChar (B.w2c $ B.unsafeHead eol) - | otherwise = findEOLSeq eolIx - - findEOLChar eolChar r w raw - | r == w = return (0, r) - | otherwise = do - (!c,!r') <- readCharFromBuffer raw r - if c == eolChar - then return (1, r') - else findEOLChar eolChar r' w raw - - -- find the end-of-line sequence, if there is one - findEOLSeq !eolIx r w raw - | eolIx == eolLen || r == w = return (eolIx, r) - | otherwise = do - (!c,!r') <- readCharFromBuffer raw r - findEOLSeq (next c eolIx + 1) r' w raw - - -- get the next index into the EOL sequence we should match against - next !c !i = if i >= 0 && c /= eolIndex i then next c (table ! i) else i - - eolIndex = B.w2c . B.unsafeIndex eol - - -- build a match table for the Knuth-Morris-Pratt algorithm - table = runSTUArray (do - arr <- newArray_ (0, if eolLen == 1 then 1 else eolLen - 1) - zipWithM_ (writeArray arr) [0,1] [-1,0] - loop arr 2 0) - where - loop arr !t !p - | t >= eolLen = return arr - | eolIndex (t - 1) == eolIndex p - = let p' = p + 1 in writeArray arr t p' >> loop arr (t + 1) p' - | p > 0 = readArray arr p >>= loop arr t - | otherwise = writeArray arr t 0 >> loop arr (t + 1) p - - stripEOL (B.PS p s l) = E.assert (new_len >= 0) . B.copy $ B.PS p s new_len - where new_len = l - eolLen - - mkPS buf start end = B.create len $ \p -> do - B.memcpy_ptr_baoff p buf (fromIntegral start) (fromIntegral len) - return () - where len = end - start - - mkBigPS [ps] = return ps - mkBigPS pss = return $! B.concat (reverse pss) +hGetLine = error "hGetLine" -- XXX STUB +-- hGetLine h eol maxLen | B.null eol = B.hGet h maxLen +-- hGetLine h eol(a)(B.PS _ _ eolLen) maxLen +-- = wantReadableHandle "TorDNSEL.Util.hGetLine" h $ \handle_ -> do +-- case haBufferMode handle_ of +-- NoBuffering -> error "no buffering" +-- _other -> hGetLineBuffered handle_ +-- +-- where +-- hGetLineBuffered handle_ = do +-- let ref = haBuffer handle_ +-- buf <- readIORef ref +-- hGetLineBufferedLoop handle_ ref buf 0 0 [] +-- +-- hGetLineBufferedLoop handle_ ref +-- buf@Buffer{ bufRPtr=r, bufWPtr=w, bufBuf=raw } !len !eolIx xss = do +-- (new_eolIx,off) <- findEOL eolIx r w raw +-- let new_len = len + off - r +-- +-- if maxLen > 0 && new_len - new_eolIx > maxLen +-- -- If the line length exceeds maxLen, return a partial line. +-- then do +-- let maxOff = off - (new_len - maxLen) +-- writeIORef ref buf{ bufRPtr = maxOff } +-- mkBigPS . (:xss) =<< mkPS raw r maxOff +-- else if new_eolIx == eolLen +-- -- We have a complete line; strip the EOL sequence and return it. +-- then do +-- if w == off +-- then writeIORef ref buf{ bufRPtr=0, bufWPtr=0 } +-- else writeIORef ref buf{ bufRPtr = off } +-- if eolLen <= off - r +-- then mkBigPS . (:xss) =<< mkPS raw r (off - eolLen) +-- else fmap stripEOL . mkBigPS . (:xss) =<< mkPS raw r off +-- else do +-- xs <- mkPS raw r off +-- maybe_buf <- maybeFillReadBuffer (haFD handle_) True +-- (haIsStream handle_) buf{ bufWPtr=0, bufRPtr=0 } +-- case maybe_buf of +-- -- Nothing indicates we caught an EOF, and we may have a +-- -- partial line to return. +-- Nothing -> do +-- writeIORef ref buf{ bufRPtr=0, bufWPtr=0 } +-- if new_len > 0 +-- then mkBigPS (xs:xss) +-- else ioe_EOF +-- Just new_buf -> +-- hGetLineBufferedLoop handle_ ref new_buf new_len new_eolIx +-- (xs:xss) +-- +-- maybeFillReadBuffer fd is_line is_stream buf +-- = catch (Just `fmap` fillReadBuffer fd is_line is_stream buf) +-- (\e -> if isEOFError e then return Nothing else ioError e) +-- +-- findEOL eolIx +-- | eolLen == 1 = findEOLChar (B.w2c $ B.unsafeHead eol) +-- | otherwise = findEOLSeq eolIx +-- +-- findEOLChar eolChar r w raw +-- | r == w = return (0, r) +-- | otherwise = do +-- (!c,!r') <- readCharFromBuffer raw r +-- if c == eolChar +-- then return (1, r') +-- else findEOLChar eolChar r' w raw +-- +-- -- find the end-of-line sequence, if there is one +-- findEOLSeq !eolIx r w raw +-- | eolIx == eolLen || r == w = return (eolIx, r) +-- | otherwise = do +-- (!c,!r') <- readCharFromBuffer raw r +-- findEOLSeq (next c eolIx + 1) r' w raw +-- +-- -- get the next index into the EOL sequence we should match against +-- next !c !i = if i >= 0 && c /= eolIndex i then next c (table ! i) else i +-- +-- eolIndex = B.w2c . B.unsafeIndex eol +-- +-- -- build a match table for the Knuth-Morris-Pratt algorithm +-- table = runSTUArray (do +-- arr <- newArray_ (0, if eolLen == 1 then 1 else eolLen - 1) +-- zipWithM_ (writeArray arr) [0,1] [-1,0] +-- loop arr 2 0) +-- where +-- loop arr !t !p +-- | t >= eolLen = return arr +-- | eolIndex (t - 1) == eolIndex p +-- = let p' = p + 1 in writeArray arr t p' >> loop arr (t + 1) p' +-- | p > 0 = readArray arr p >>= loop arr t +-- | otherwise = writeArray arr t 0 >> loop arr (t + 1) p +-- +-- stripEOL (B.PS p s l) = E.assert (new_len >= 0) . B.copy $ B.PS p s new_len +-- where new_len = l - eolLen +-- +-- mkPS buf start end = B.create len $ \p -> do +-- B.memcpy_ptr_baoff p buf (fromIntegral start) (fromIntegral len) +-- return () +-- where len = end - start +-- +-- mkBigPS [ps] = return ps +-- mkBigPS pss = return $! B.concat (reverse pss) -- | Split @bs@ into pieces delimited by @delimiter@, consuming the delimiter. -- The result for overlapping delimiters is undefined.

1 0

[tordnsel/master] fix exceptions in TorDNSEL.Control.Concurrent
by arlo＠torproject.org 16 Apr '16

16 Apr '16

commit 7494d418a991eb60b4644169310026336068d634 Author: David Kaloper <david(a)numm.org> Date: Mon Aug 26 04:10:27 2013 +0200 fix exceptions in TorDNSEL.Control.Concurrent --- src/TorDNSEL/Control/Concurrent/Link.hs | 7 +- src/TorDNSEL/Control/Concurrent/Link/Internals.hs | 168 ++++++++++++---------- src/TorDNSEL/Control/Concurrent/Util.hs | 47 +++--- 3 files changed, 121 insertions(+), 101 deletions(-) diff --git a/src/TorDNSEL/Control/Concurrent/Link.hs b/src/TorDNSEL/Control/Concurrent/Link.hs index 98eda78..2c0a05f 100644 --- a/src/TorDNSEL/Control/Concurrent/Link.hs +++ b/src/TorDNSEL/Control/Concurrent/Link.hs @@ -30,15 +30,16 @@ module TorDNSEL.Control.Concurrent.Link ( , withMonitor , exit , throwTo - , throwDynTo , killThread , setTrapExit , unsetTrapExit - , ExitReason + , ExitReason(..) + , exitReason + , isAbnormal + , throwAbnormal , extractReason , fromExitSignal , LinkException(..) - , showLinkException ) where import TorDNSEL.Control.Concurrent.Link.Internals diff --git a/src/TorDNSEL/Control/Concurrent/Link/Internals.hs b/src/TorDNSEL/Control/Concurrent/Link/Internals.hs index cf83cba..7b614b9 100644 --- a/src/TorDNSEL/Control/Concurrent/Link/Internals.hs +++ b/src/TorDNSEL/Control/Concurrent/Link/Internals.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-ignore-asserts #-} ----------------------------------------------------------------------------- @@ -24,15 +25,18 @@ -- #not-home module TorDNSEL.Control.Concurrent.Link.Internals where +import qualified Control.Exception as E import qualified Control.Concurrent as C import Control.Concurrent.MVar (MVar, newMVar, withMVar, modifyMVar, modifyMVar_) -import qualified Control.Exception as E +import GHC.Conc (setUncaughtExceptionHandler) +import System.Exit (ExitCode) import Control.Monad (unless) import qualified Data.Foldable as F import qualified Data.Map as M import qualified Data.Set as S -import Data.Dynamic (Dynamic, fromDynamic, toDyn, Typeable) +-- import Data.Dynamic (Dynamic, fromDynamic, toDyn, Typeable) +import Data.Typeable (Typeable) import Data.List (nub) import Data.Unique (Unique, newUnique) import System.IO (hPutStrLn, hFlush, stderr) @@ -46,6 +50,9 @@ import TorDNSEL.Util newtype ThreadId = Tid Unique deriving (Eq, Ord) +-- ( Else an orphaned Show Unique... ) +instance Show ThreadId where show _ = "#<thread>" + -- | Return the 'ThreadId' of the calling thread. myThreadId :: IO ThreadId myThreadId = do @@ -74,11 +81,17 @@ threadMap :: MVar ThreadMap {-# NOINLINE threadMap #-} threadMap = unsafePerformIO . newMVar $ ThreadMap M.empty M.empty +-- | Erase 'threadMap', making it possible to re-run 'withLinksDo'. For +-- debugging only, as it loses track of threads. +unsafeResetThreadMap :: IO () +unsafeResetThreadMap = + modifyMVar_ threadMap $ const . return $ ThreadMap M.empty M.empty + -- | Assert various invariants of the global link and monitor state, printing a -- message to stdout if any assertions fail. assertThreadMap :: ThreadMap -> IO () assertThreadMap tm = - E.handleJust E.assertions (putStr . ("assertThreadMap: " ++)) $ + E.handle (\(E.AssertionFailed msg) -> putStrLn $ "assertThreadMap: " ++ msg) $ E.assert (M.size (ids tm) > 0) $ E.assert (M.size (ids tm) == M.size (state tm)) $ E.assert (M.elems (ids tm) == nub (M.elems (ids tm))) $ @@ -100,36 +113,35 @@ assertThreadMap tm = -- | An internal type used to transmit the originating 'ThreadId' in an -- asynchronous exception to a linked thread. data ExitSignal = ExitSignal !ThreadId !ExitReason - deriving Typeable - --- | Extract the 'ExitReason' from an 'ExitSignal' contained within a --- dynamically-typed exception. If the exception doesn't contain an --- 'ExitSignal', tag it with 'Just'. -extractReason :: E.Exception -> ExitReason -extractReason (E.DynException dyn) - | Just (ExitSignal _ e) <- fromDynamic dyn = e -extractReason e = Just e - --- | Extract an exit signal from an 'E.Exception' if it has the right type. -fromExitSignal :: Typeable a => E.Exception -> Maybe (ThreadId, a) -fromExitSignal (E.DynException d) - | Just (ExitSignal tid (Just (E.DynException d'))) <- fromDynamic d - = (,) tid `fmap` fromDynamic d' + deriving (Show, Typeable) + +instance E.Exception ExitSignal + +-- | Extract the 'ExitReason' from an 'ExitSignal' contained within an +-- exception. If the exception doesn't contain an 'ExitReason', it becomes the +-- exit reason itself. +extractReason :: E.SomeException -> ExitReason +extractReason (E.fromException -> Just (ExitSignal _ e)) = e +extractReason e = AbnormalExit e + +-- | Extract a particular exception type from an 'ExitSignal', if present. +fromExitSignal :: E.Exception e => ExitSignal -> Maybe (ThreadId, e) +fromExitSignal (ExitSignal tid (AbnormalExit e)) + | Just e' <- E.fromException e = Just (tid, e') fromExitSignal _ = Nothing -- | The default action used to signal a thread. Abnormal 'ExitReason's are -- sent to the thread and normal exits are ignored. defaultSignal :: C.ThreadId -> ThreadId -> ExitReason -> IO () -defaultSignal dst src e@(Just _) = E.throwDynTo dst $ ExitSignal src e -defaultSignal _ _ Nothing = return () - --- | Initialize the state supporting links and monitors. Use the given function --- to display an uncaught exception. It is an error to call this function --- outside the main thread, or to call any other functions in this module --- outside this function. -withLinksDo :: (E.Exception -> String) -> IO a -> IO () -withLinksDo showE io = E.block $ do - E.setUncaughtExceptionHandler . const . return $ () +defaultSignal dst src NormalExit = return () +defaultSignal dst src e = E.throwTo dst $ ExitSignal src e + +-- | Initialize the state supporting links and monitors. It is an error to call +-- this function outside the main thread, or to call any other functions in this +-- module outside this function. +withLinksDo :: IO a -> IO () +withLinksDo io = E.mask $ \restore -> do + setUncaughtExceptionHandler . const . return $ () main <- C.myThreadId mainId <- Tid `fmap` newUnique let initialState = ThreadState @@ -146,12 +158,13 @@ withLinksDo showE io = E.block $ do , state = M.insert main initialState (state tm) } -- Don't bother propagating signals from the main thread -- since it's about to exit. - (E.unblock io >> return ()) `E.catch` \e -> + (restore io >> return ()) `E.catch` \(e :: E.SomeException) -> case extractReason e of - Nothing -> return () - Just e'@(E.ExitException _) -> E.throwIO e' - Just e' -> do - hPutStrLn stderr ("*** Exception: " ++ showE e') + NormalExit -> return () + AbnormalExit (E.fromException -> Just e') -> + E.throwIO (e' :: ExitCode) + AbnormalExit e' -> do + hPutStrLn stderr ("*** Exception: " ++ show e') hFlush stderr E.throwIO e' @@ -169,15 +182,19 @@ forkLinkIO' shouldLink io = E.block $ do parent <- C.myThreadId childId <- Tid `fmap` newUnique modifyMVar_ threadMap $ \tm -> do - -- assertThreadMap tm +#ifdef DEBUG + assertThreadMap tm +#endif child <- forkHandler $ do child <- C.myThreadId - e <- either extractReason (const Nothing) `fmap` E.try (E.unblock io) + e <- either extractReason (const NormalExit) `fmap` E.try (E.unblock io) -- modifyMVar is interruptible (a misfeature in this case), so an async -- exception could be delivered here. Forking an anonymous thread should -- avoid this race since nobody can throwTo it. forkHandler $ do - -- withMVar threadMap assertThreadMap +#ifdef DEBUG + withMVar threadMap assertThreadMap +#endif (signalAll,notifyAll) <- modifyMVar threadMap $ \tm1 -> let s = state tm1 M.! child unlinkAll = flip (F.foldl' (flip (child `unlinkFrom`))) (links s) @@ -193,7 +210,9 @@ forkLinkIO' shouldLink io = E.block $ do notifyAll ex = F.mapM_ (forkHandler . ($ ex) . fst) (monitors s) tm1' = tm1 { ids = newIds, state = newState } in tm1' `seq` return (tm1', (signalAll, notifyAll)) - -- withMVar threadMap assertThreadMap +#ifdef DEBUG + withMVar threadMap assertThreadMap +#endif notifyAll e signalAll e @@ -211,11 +230,13 @@ forkLinkIO' shouldLink io = E.block $ do tm { ids = M.insert childId child $ ids tm , state = M.insert child initialState . linkToParent $ state tm } - -- withMVar threadMap assertThreadMap +#ifdef DEBUG + withMVar threadMap assertThreadMap +#endif return childId where forkHandler = C.forkIO . ignore . (>> return ()) . E.block - ignore = E.handle . const . return $ () + ignore = E.handle $ \(e :: E.SomeException) -> return () -- | Establish a bidirectional link between the calling thread and a given -- thread. If either thread terminates, an exit signal will be sent to the other @@ -225,16 +246,14 @@ forkLinkIO' shouldLink io = E.block $ do linkThread :: ThreadId -> IO () linkThread tid = do me <- C.myThreadId - mbSignalSelf <- modifyMVar threadMap $ \tm -> + mbSignalSelf <- modifyMVar threadMap $ \tm -> return $! case M.lookup tid (ids tm) of Just tid' - | tid' == me -> return (tm, Nothing) - | otherwise -> let tm' = tm { state = linkTogether me tid' $ state tm } - in tm' `seq` return (tm', Nothing) - Nothing -> - let s = state tm M.! me - in return (tm, Just . signal s tid . Just . E.DynException . - toDyn $ NonexistentThread) + | tid' == me -> (tm, Nothing) + | otherwise -> (tm', Nothing) + where !tm' = tm { state = linkTogether me tid' $ state tm } + Nothing -> (tm, Just . signal s tid $ exitReason NonexistentThread) + where s = state tm M.! me whenJust mbSignalSelf id where linkTogether x y = (x `linkTo` y) . (y `linkTo` x) @@ -258,9 +277,22 @@ linkTo, unlinkFrom :: C.ThreadId -> C.ThreadId -> StateModifier data Monitor = Monitor !ThreadId !Unique deriving (Eq, Ord) --- | The reason a thread was terminated. @Nothing@ means the thread exited --- normally. @Just exception@ contains the reason for an abnormal exit. -type ExitReason = Maybe E.Exception +-- | The reason a thread was terminated. +data ExitReason = NormalExit | AbnormalExit E.SomeException + deriving (Show) + +-- | Construct an 'ExitReason' from any 'E.Exception'. +exitReason :: E.Exception e => e -> ExitReason +exitReason = AbnormalExit . E.toException + +isAbnormal :: ExitReason -> Bool +isAbnormal (AbnormalExit _) = True +isAbnormal _ = False + +-- | Check the exit reason and re-throw it if it's an 'AbnormalExit'. +throwAbnormal :: ExitReason -> IO () +throwAbnormal NormalExit = return () +throwAbnormal (AbnormalExit e) = E.throwIO e -- | Start monitoring the given thread, invoking an 'IO' action with the -- 'ExitReason' when the thread dies. Return a handle to the monitor, which can @@ -271,20 +303,19 @@ monitorThread :: ThreadId -> (ExitReason -> IO ()) -> IO Monitor monitorThread tid notify = do me <- C.myThreadId mon@(Monitor _ monId) <- Monitor tid `fmap` newUnique - let cleanup tid' = adjust' (\ts -> - ts { ownedMons = S.delete (tid', monId) (ownedMons ts) }) me + let cleanup tid' = flip adjust' me $ \ts -> + ts { ownedMons = S.delete (tid', monId) (ownedMons ts) } addMon tid' ts = ts { monitors = M.insert monId (notify, cleanup tid') (monitors ts) } addOwned tid' ts = ts {ownedMons = S.insert (tid', monId) (ownedMons ts)} - exists <- modifyMVar threadMap $ \tm -> + exists <- modifyMVar threadMap $ \tm -> return $! case M.lookup tid (ids tm) of - Nothing -> return (tm, False) - Just tid' -> - let tm' = tm { state = adjust' (addMon tid') tid' . - adjust' (addOwned tid') me $ state tm } - in tm' `seq` return (tm', True) + Nothing -> (tm, False) + Just tid' -> (tm', True) + where !tm' = tm { state = adjust' (addMon tid') tid' . + adjust' (addOwned tid') me $ state tm } unless exists $ - notify . Just . E.DynException . toDyn $ NonexistentThread + notify $ exitReason NonexistentThread return mon -- | Cancel a monitor, if it is currently active. @@ -310,10 +341,10 @@ withMonitor tid notify = -- | Terminate the calling thread with the given 'ExitReason'. exit :: ExitReason -> IO a -exit e = E.throwDyn . flip ExitSignal e =<< myThreadId +exit e = E.throwIO . (`ExitSignal` e) =<< myThreadId -- | Send an exit signal with an 'ExitReason' to a thread. If the 'ExitReason' --- is 'Nothing', the signal will be ignored unless the target thread is trapping +-- is 'NormalExit', the signal will be ignored unless the target thread is trapping -- signals. Otherwise, the target thread will either exit with the same -- 'ExitReason' or be notified of the signal depending on whether it is trapping -- signals. If the target thread doesn't exist, do nothing. @@ -324,25 +355,20 @@ throwTo tid e = do let me' = ident (state tm M.! me) in if tid == me' -- special case: an exception thrown to oneself is untrappable - then E.throwDyn $ ExitSignal me' e + then E.throwIO $ ExitSignal me' e else return $ do tid' <- M.lookup tid (ids tm) return $ signal (state tm M.! tid') me' -- since signal can block, we don't want to hold a lock on threadMap whenJust mbSignal ($ e) --- | A variant of 'throwTo' for dynamically typed 'ExitReason's. -throwDynTo :: Typeable a => ThreadId -> a -> IO () -throwDynTo tid = throwTo tid . Just . E.DynException . toDyn - -- | Send an untrappable exit signal to a thread, if it exists. killThread :: ThreadId -> IO () killThread tid = do me <- C.myThreadId mbSignal <- withMVar threadMap $ \tm -> return $ do tid' <- M.lookup tid (ids tm) - return . - E.throwDynTo tid' $ ExitSignal (ident (state tm M.! me)) - (Just (E.AsyncException E.ThreadKilled)) + return . E.throwTo tid' $ ExitSignal (ident (state tm M.! me)) + (exitReason E.ThreadKilled) whenJust mbSignal id -- | Redirect exit signals destined for the calling thread to the given 'IO' @@ -367,6 +393,4 @@ data LinkException = NonexistentThread -- ^ instance Show LinkException where show NonexistentThread = "Attempt to link to nonexistent thread" --- | Boilerplate conversion of a dynamically typed 'LinkException' to a string. -showLinkException :: Dynamic -> Maybe String -showLinkException = fmap (show :: LinkException -> String) . fromDynamic +instance E.Exception LinkException diff --git a/src/TorDNSEL/Control/Concurrent/Util.hs b/src/TorDNSEL/Control/Concurrent/Util.hs index 1defc31..a7c2a65 100644 --- a/src/TorDNSEL/Control/Concurrent/Util.hs +++ b/src/TorDNSEL/Control/Concurrent/Util.hs @@ -13,7 +13,8 @@ module TorDNSEL.Control.Concurrent.Util where import qualified Control.Exception as E -import Control.Concurrent.MVar (newEmptyMVar, takeMVar, putMVar, tryPutMVar) +import Data.Functor ( (<$) ) +import Control.Concurrent.MVar (MVar, newEmptyMVar, takeMVar, putMVar, tryPutMVar) import Data.Dynamic (Dynamic) import Data.Maybe (isJust) import System.Timeout @@ -51,10 +52,9 @@ terminateThread mbWait tid terminate = do sendSyncMessage :: (IO () -> IO ()) -> ThreadId -> IO () sendSyncMessage sendMsg tid = do err <- newEmptyMVar - let putResponse = (>> return ()) . tryPutMVar err - withMonitor tid putResponse $ do - sendMsg $ putResponse Nothing - takeMVar err >>= flip whenJust E.throwIO + withMonitor tid (tryPutMVar_ err) $ do + sendMsg $ tryPutMVar_ err NormalExit + takeMVar err >>= throwAbnormal -- | Send a message parameterized by a reply action to @tid@, returning the -- response value. If the thread exits before responding to the message, throw @@ -62,19 +62,13 @@ sendSyncMessage sendMsg tid = do call :: ((a -> IO ()) -> IO ()) -> ThreadId -> IO a call sendMsg tid = do mv <- newEmptyMVar - let putResponse = (>> return ()) . tryPutMVar mv - withMonitor tid (putResponse . Left) $ do - sendMsg $ putResponse . Right + withMonitor tid (tryPutMVar_ mv . Left) $ do + sendMsg $ tryPutMVar_ mv . Right response <- takeMVar mv case response of - Left Nothing -> E.throwDyn NonexistentThread - Left (Just e) -> E.throwIO e - Right r -> return r - --- | A wrapper for using 'showException' with 'ExitReason's. -showExitReason :: [Dynamic -> Maybe String] -> ExitReason -> String -showExitReason _ Nothing = "Normal exit" -showExitReason fs (Just e) = showException (showLinkException:fs) e + Left NormalExit -> E.throwIO NonexistentThread + Left (AbnormalExit e) -> E.throwIO e + Right r -> return r -- | Invoke the given 'IO' action in a new thread, passing it an action to -- invoke when it has successfully started. Link the new thread to the calling @@ -83,14 +77,13 @@ showExitReason fs (Just e) = showException (showLinkException:fs) e startLink :: (IO () -> IO a) -> IO ThreadId startLink io = do sync <- newEmptyMVar - err <- newEmptyMVar - let putResponse = (>> return ()) . tryPutMVar err + err <- newEmptyMVar tid <- forkLinkIO $ do takeMVar sync - io (putResponse Nothing) - withMonitor tid putResponse $ do + io $ tryPutMVar_ err NormalExit + withMonitor tid (tryPutMVar_ err) $ do putMVar sync () - takeMVar err >>= flip whenJust E.throwIO + takeMVar err >>= throwAbnormal return tid -- | Invoke the given 'IO' action in a temporary thread (linked to the calling @@ -100,15 +93,17 @@ startLink io = do tryForkLinkIO :: Thread a => IO a -> IO (Either ExitReason a, ThreadId) tryForkLinkIO io = do sync <- newEmptyMVar - response <- newEmptyMVar - let putResponse = (>> return ()) . tryPutMVar response + resp <- newEmptyMVar intermediate <- forkLinkIO $ do takeMVar sync - io >>= putResponse . Right - r <- withMonitor intermediate (putResponse . Left) $ do + io >>= tryPutMVar_ resp . Right + r <- withMonitor intermediate (tryPutMVar_ resp . Left) $ do putMVar sync () E.block $ do - r <- takeMVar response + r <- takeMVar resp either (const $ return ()) (linkThread . threadId) r return r return (r, intermediate) + +tryPutMVar_ :: MVar a -> a -> IO () +tryPutMVar_ = ((() <$) .) . tryPutMVar

1 0

[tordnsel/master] precise parsing exceptions
by arlo＠torproject.org 16 Apr '16

16 Apr '16

commit 243f8660bae4c3cd30fe16ad0180e71b78070179 Author: David Kaloper <david(a)numm.org> Date: Sat Aug 24 03:40:24 2013 +0200 precise parsing exceptions --- src/TorDNSEL/DNS/Internals.hs | 9 ++++++--- src/TorDNSEL/Socks/Internals.hs | 10 ++++++---- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/TorDNSEL/DNS/Internals.hs b/src/TorDNSEL/DNS/Internals.hs index 0eed2be..91b2391 100644 --- a/src/TorDNSEL/DNS/Internals.hs +++ b/src/TorDNSEL/DNS/Internals.hs @@ -165,10 +165,13 @@ encodeMessage :: Message -> Packet encodeMessage = Packet . B.concat . L.toChunks . runPutMessage . putPacket -- | Decode a DNS message strictly, returning @'Just' _@ if parsing succeeded. +-- +-- XXX We just fight lazy decoding here -- we should replace `binary` with +-- `cereal`. ( See `Socks`. ) decodeMessage :: Packet -> IO (Maybe Message) -decodeMessage pkt = do - r <- E.tryJust syncExceptions (E.evaluate $!! unsafeDecodeMessage pkt) - return $ either (const Nothing) Just r +decodeMessage pkt = + ( E.evaluate $ Just $!! unsafeDecodeMessage pkt ) + `E.catch` \(E.ErrorCall _) -> return Nothing -- | Lazily decode a DNS message. If parsing fails, the result will contain an -- exceptional value at some level. diff --git a/src/TorDNSEL/Socks/Internals.hs b/src/TorDNSEL/Socks/Internals.hs index c5ce474..7999b91 100644 --- a/src/TorDNSEL/Socks/Internals.hs +++ b/src/TorDNSEL/Socks/Internals.hs @@ -142,11 +142,13 @@ encodeRequest = B.concat . L.toChunks . runPut . putRequest putWord8 0 -- | Decode a Socks4 response. +-- +-- XXX We just fight lazy decoding here -- we should replace `binary` with +-- `cereal`. ( See `DNS`. ) decodeResponse :: ByteString -> IO (Maybe Response) -decodeResponse resp = do - r <- E.tryJust syncExceptions - (E.evaluate $!! runGet getResponse (L.fromChunks [resp])) - return $ either (const Nothing) Just r +decodeResponse resp = + ( E.evaluate $ Just $!! runGet getResponse (L.fromChunks [resp]) ) + `E.catch` \(E.ErrorCall _) -> return Nothing where getResponse = do 0 <- getWord8

1 0

[tordnsel/master] start centralizing sync/async exn classification
by arlo＠torproject.org 16 Apr '16

16 Apr '16

commit a52e0fe72ae2f9a9f4c0ce0ec7b8092c5ad15d40 Author: David Kaloper <david(a)numm.org> Date: Wed Aug 21 02:55:54 2013 +0200 start centralizing sync/async exn classification For now, isolate the code that tries to catch-all-exceptions-except-asynchronous-ones into common combinators, to have it in one place. The problem with this idea is that mere classification of exceptions is not an indicator of how they were thrown, therefore such logic is not entirely correct. Code that relies on that should move to expecting specific exception types instead. See, for example, http://www.haskell.org/pipermail/haskell-cafe/2013-July/107694.html. Still, a workable band-aid to make it compile. --- src/TorDNSEL/NetworkState/Internals.hs | 11 +++--- src/TorDNSEL/TorControl/Internals.hs | 37 ++++++++---------- src/TorDNSEL/Util.hsc | 68 +++++++++++++++++++++++++++++----- 3 files changed, 79 insertions(+), 37 deletions(-) diff --git a/src/TorDNSEL/NetworkState/Internals.hs b/src/TorDNSEL/NetworkState/Internals.hs index c42cae7..cb3ae46 100644 --- a/src/TorDNSEL/NetworkState/Internals.hs +++ b/src/TorDNSEL/NetworkState/Internals.hs @@ -448,13 +448,12 @@ startTorController startTorController net conf mbDelay = liftIO $ do log Info "Starting Tor controller." (r,tid) <- tryForkLinkIO $ do - E.bracketOnError (socket AF_INET Stream tcpProtoNum) - (ignoreJust syncExceptions . sClose) $ \sock -> do + E.bracketOnError' (socket AF_INET Stream tcpProtoNum) sClose $ \sock -> do connect sock $ nsmcfTorControlAddr conf - E.bracketOnError - (do handle <- socketToHandle sock ReadWriteMode - openConnection handle $ nsmcfTorControlPasswd conf) - (ignoreJust syncExceptions . closeConnection) $ \conn -> do + E.bracketOnError' + ( socketToHandle sock ReadWriteMode >>= + (`openConnection` nsmcfTorControlPasswd conf) ) + closeConnection $ \conn -> do setConfWithRollback fetchUselessDescriptors (Just True) conn when (torVersion (protocolInfo conn) >= TorVersion 0 2 0 13 B.empty) $ setConfWithRollback fetchDirInfoEarly (Just True) conn diff --git a/src/TorDNSEL/TorControl/Internals.hs b/src/TorDNSEL/TorControl/Internals.hs index 95fbbd0..7c0e972 100644 --- a/src/TorDNSEL/TorControl/Internals.hs +++ b/src/TorDNSEL/TorControl/Internals.hs @@ -162,6 +162,7 @@ import TorDNSEL.Control.Concurrent.Util import TorDNSEL.Directory import TorDNSEL.Document import TorDNSEL.Util +improt qualified TorDNSEL.Util ( bracket', finally' ) -------------------------------------------------------------------------------- -- Connections @@ -193,15 +194,8 @@ data ConfSetting = forall a b. (ConfVal b, SameConfVal a b) => -- 'IO' action. If an exception interrupts execution, close the connection -- gracefully before re-throwing the exception. withConnection :: Handle -> Maybe ByteString -> (Connection -> IO a) -> IO a -withConnection handle mbPasswd io = - E.block $ do - conn <- openConnection handle mbPasswd - r <- E.catch (E.unblock $ io conn) $ \e -> do - -- so the original exception isn't lost - ignoreJust syncExceptions (closeConnection conn) - E.throwIO e - closeConnection conn - return r +withConnection handle mbPasswd = + bracket' (openConnection handle mbPasswd) closeConnection -- | Open a connection with a handle and an optional password. Throw a -- 'TorControlError' or 'IOError' if initializing the connection fails. @@ -211,19 +205,18 @@ openConnection handle mbPasswd = do conn@(tellIOManager,ioManagerTid) <- startIOManager handle confSettings <- newMVar [] - E.handle - (\e -> do ignoreJust syncExceptions (closeConnection' conn confSettings) - E.throwIO e) $ do - let protInfoCommand = Command (B.pack "protocolinfo") [B.pack "1"] [] - rs@(r:_) <- sendCommand' protInfoCommand False Nothing conn - throwIfNotPositive protInfoCommand r - protInfo <- either (protocolError protInfoCommand) return - (parseProtocolInfo rs) - - let conn' = Conn tellIOManager ioManagerTid protInfo confSettings - authenticate mbPasswd conn' - useFeature [VerboseNames] conn' - return conn' + ( do let protInfoCommand = Command (B.pack "protocolinfo") [B.pack "1"] [] + rs@(r:_) <- sendCommand' protInfoCommand False Nothing conn + throwIfNotPositive protInfoCommand r + protInfo <- either (protocolError protInfoCommand) return + (parseProtocolInfo rs) + + let conn' = Conn tellIOManager ioManagerTid protInfo confSettings + authenticate mbPasswd conn' + useFeature [VerboseNames] conn' + putStrLn "*X MRMLJ" + return conn' + ) `onException'` closeConnection' conn confSettings -- | Close a connection gracefully, blocking the current thread until the -- connection has terminated. diff --git a/src/TorDNSEL/Util.hsc b/src/TorDNSEL/Util.hsc index 13303ac..4329e68 100644 --- a/src/TorDNSEL/Util.hsc +++ b/src/TorDNSEL/Util.hsc @@ -51,13 +51,17 @@ module TorDNSEL.Util ( , split , ignoreJust , syncExceptions + , bracket' + , finally' + , bracketOnError' + , onException' , exitUsage + , trySync , inBoundsOf , htonl , ntohl , hGetLine , splitByDelimiter - , showException , showUTCTime -- * Network functions @@ -98,6 +102,7 @@ module TorDNSEL.Util ( ) where import Control.Arrow ((&&&), first, second) +import Control.Applicative import qualified Control.Exception as E import Control.Monad.Error (Error(..), MonadError(..), MonadTrans(..), MonadIO(..)) @@ -318,14 +323,59 @@ encodeBase16 = B.pack . concat . B.foldr ((:) . toBase16 . B.c2w) [] split :: Int -> ByteString -> [ByteString] split x = takeWhile (not . B.null) . map (B.take x) . iterate (B.drop x) + +-- | Try an action, catching -- roughly -- "synchronous" exceptions. +-- +-- XXX This is a remnant of the original code base; it's actually impossible to +-- determine if an exception was thrown synchronously just by its type. Usage of +-- this and derived combinators should be pruned in favour of only handling +-- per-use-site expected exceptions. +-- +trySync :: IO a -> IO (Either E.SomeException a) +trySync = E.tryJust $ \e -> + case E.fromException (e :: E.SomeException) of + Just (_ :: E.AsyncException) -> Nothing + _ -> Just e + +-- | Like 'E.bracket', but if cleanup re-throws while handling a throw, don't +-- eat the original exception. +bracket' :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c +bracket' before after act = + E.mask $ \restore -> do + a <- before + r <- restore (act a) `E.onException` trySync (after a) + _ <- after a + return r + +-- | Like 'E.finally', but if cleanup re-throws while handling a throw, don't +-- eat the original exception. +finally' :: IO a -> IO b -> IO a +finally' act after = bracket' (return ()) (const after) (const act) + +-- | Like 'E.bracketOnError', but if cleanup re-throws while handling a throw, +-- don't eat the original exception. +bracketOnError' :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c +bracketOnError' before after act = + E.mask $ \restore -> do + a <- before + restore (act a) `E.onException` trySync (after a) + +-- | Like 'E.onException' +onException' :: IO a -> IO b -> IO a +onException' io act = io `E.catch` \e -> + trySync act >> E.throwIO (e :: E.SomeException) + -- | Catch and discard exceptions matching the predicate. -ignoreJust :: (E.Exception -> Maybe a) -> IO () -> IO () +ignoreJust :: (E.Exception e) => (e -> Maybe a) -> IO () -> IO () ignoreJust p = E.handleJust p . const . return $ () -- | A predicate matching synchronous exceptions. -syncExceptions :: E.Exception -> Maybe E.Exception -syncExceptions (E.AsyncException _) = Nothing -syncExceptions e = Just e +-- XXX This is a bad idea. The exn itself conveys no info on how it was thrown. +syncExceptions :: E.SomeException -> Maybe E.SomeException +syncExceptions e + | show e == "<<timeout>>" = Nothing + | Just (_ :: E.AsyncException) <- E.fromException e = Nothing + | otherwise = Just e -- | Print a usage message to the given handle and exit with the given code. exitUsage :: Handle -> ExitCode -> IO a @@ -477,10 +527,10 @@ splitByDelimiter delimiter bs = subst (-len : B.findSubstrings delimiter bs) -- | Convert an exception to a string given a list of functions for displaying -- dynamically typed exceptions. -showException :: [Dynamic -> Maybe String] -> E.Exception -> String -showException fs (E.DynException dyn) - | str:_ <- mapMaybe ($ dyn) fs = str -showException _ e = show e +-- showException :: [Dynamic -> Maybe String] -> E.Exception -> String +-- showException fs (E.DynException dyn) +-- | str:_ <- mapMaybe ($ dyn) fs = str +-- showException _ e = show e -- | Convert a 'UTCTime' to a string in ISO 8601 format. showUTCTime :: UTCTime -> String

1 0

[translation/torbutton-torbuttondtd] Update translations for torbutton-torbuttondtd
by translation＠torproject.org 16 Apr '16

16 Apr '16

commit a262be46a628af775ccccd9eee12687c503a8f07 Author: Translation commit bot <translation(a)torproject.org> Date: Sat Apr 16 00:15:53 2016 +0000 Update translations for torbutton-torbuttondtd --- zh_HK/torbutton.dtd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zh_HK/torbutton.dtd b/zh_HK/torbutton.dtd index 40696a7..39570a8 100644 --- a/zh_HK/torbutton.dtd +++ b/zh_HK/torbutton.dtd @@ -86,7 +86,7 @@ <!ENTITY torbutton.prefs.non_tor "非Tor洋蔥路由"> <!ENTITY torbutton.prefs.restore_tor "啟動還原工作階段時，將Tor洋蔥路由狀態設定成："> <!ENTITY torbutton.prefs.startup_tor "啟動瀏覽器時，將Tor洋蔥路由狀態設定成："> -<!ENTITY torbutton.prefs.reload_crashed_jar "Firefox撞毁時重新載入Jar╱清理Cookies (建議)"> +<!ENTITY torbutton.prefs.reload_crashed_jar "Firefox程式崩塌時重新載入Jar╱清理Cookies (建議)"> <!ENTITY torbutton.prefs.dual_cookie_jars "將Tor洋蔥路由同非Tor洋蔥路由嘅Cookie同時存放喺受保護嘅Jar內(危險)"> <!ENTITY torbutton.prefs.clear_http_auth "清除http驗證工作階段(建議)"> <!ENTITY torbutton.prefs.block_js_history "隔離瀏覽歷程記錄嘅存取到Tor洋蔥路由狀態(重要)">

1 0

[webwml/master] unlink those two obsolete pages
by arma＠torproject.org 15 Apr '16

15 Apr '16

commit ae30bea6ac3219a8b07cddcefa141139787adbfd Author: Roger Dingledine <arma(a)torproject.org> Date: Fri Apr 15 17:33:48 2016 -0400 unlink those two obsolete pages also, link the corepeople page as a sub-bullet, because that's how it's done on the documentation pages. now there are two things you can click that get you to corepeople. this is not perfect, but it's better than the alternative where you don't even realize it's a thing you can click on. --- about/en/sidenav.wmi | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/about/en/sidenav.wmi b/about/en/sidenav.wmi index c8c6997..7d4e054 100644 --- a/about/en/sidenav.wmi +++ b/about/en/sidenav.wmi @@ -27,15 +27,12 @@ {'url' => 'about/corepeople', 'txt' => 'Tor People', 'subelements' => [ + {'url' => 'about/corepeople', + 'txt' => 'Core Tor People', + }, {'url' => 'about/board', 'txt' => 'Board of Directors', - }, - {'url' => 'about/translators', - 'txt' => 'Translators', - }, - {'url' => 'about/volunteers', - 'txt' => 'Volunteers', - }, + }, {'url' => 'about/contributors', 'txt' => 'Past Contributors', }]

1 0

[webwml/master] same with the obsolete translators page
by arma＠torproject.org 15 Apr '16

15 Apr '16

commit 4a161bab4dd5aae8f6de6e174ef4103d4a063054 Author: Roger Dingledine <arma(a)torproject.org> Date: Fri Apr 15 17:28:41 2016 -0400 same with the obsolete translators page --- about/en/translators.wml | 35 +++-------------------------------- 1 file changed, 3 insertions(+), 32 deletions(-) diff --git a/about/en/translators.wml b/about/en/translators.wml index 0c877e8..28b12ea 100644 --- a/about/en/translators.wml +++ b/about/en/translators.wml @@ -1,36 +1,7 @@ ## translation metadata # Revision: $Revision$ -# Translation-Priority: 3-low +# Status: obsolete + +#include "head.wmi" TITLE="Redirecting" REDIRECT="about/corepeople" -#include "head.wmi" TITLE="Tor Project: Translators" CHARSET="UTF-8" -<div id="content" class="clearfix"> - <div id="breadcrumbs"> - <a href="<page index>">Home » </a> - <a href="<page about/overview>">About » </a> - <a href="<page about/volunteers>">Translators</a> - </div> - <div id="maincol"> - <h1>Translators</h1> -<dl> -<dt>Bogdan Drozdowski</dt><dd>Polish</dd> -<dt>Tiago Faria</dt><dd>Portuguese.</dd> -<dt>fredzupy</dt><dd>French</dd> -<dt>Jens Kubieziel and Oliver Knapp</dt><dd>German</dd> -<dt>Pei Hanru and bridgefish</dt><dd>Simplified Chinese</dd> -<dt>Jan Reister</dt><dd>Italian</dd> -<dt>ygrek and an anonymous translator</dt><dd>Russian</dd> -<dt>Ghazal Teheri</dt><dd>Persian</dd> -<dt>Htaike Htaike Aung</dt><dd>Burmese</dd> -<dt>Osama Khalid</dt><dd>Arabic</dd> -<dt>Alexia Prichard</dt><dd>Spanish</dd> -</dl> - </div> -  - <div id = "sidecol"> -#include "side.wmi" -#include "info.wmi" - </div> -  -</div> - #include <foot.wmi>

1 0

[webwml/master] this page has had no love in years
by arma＠torproject.org 15 Apr '16

15 Apr '16

commit 43600056394413c352b3cdd98196d0ef5182de1d Author: Roger Dingledine <arma(a)torproject.org> Date: Fri Apr 15 17:27:31 2016 -0400 this page has had no love in years deprecate it in favor of corepeople --- about/en/volunteers.wml | 56 +++---------------------------------------------- 1 file changed, 3 insertions(+), 53 deletions(-) diff --git a/about/en/volunteers.wml b/about/en/volunteers.wml index 9561c47..28b12ea 100644 --- a/about/en/volunteers.wml +++ b/about/en/volunteers.wml @@ -1,57 +1,7 @@ ## translation metadata # Revision: $Revision$ -# Translation-Priority: 3-low -#include "head.wmi" TITLE="Tor Project: Volunteers" CHARSET="UTF-8" +# Status: obsolete + +#include "head.wmi" TITLE="Redirecting" REDIRECT="about/corepeople" -<div id="content" class="clearfix"> - <div id="breadcrumbs"> - <a href="<page index>">Home » </a> - <a href="<page about/overview>">About » </a> - <a href="<page about/volunteers>">Volunteers</a> - </div> - <div id="maincol"> - <h1>Volunteers</h1> - <dl> -<dt>Anonym, bertagaz, and intrigeri</dt><dd>Maintainers of <a -href="https://tails.boum.org/">The Amnesic Incognito Live System</a>.</dd> -<dt>Marco Bonetti</dt><dd>Focusing on MobileTor for the iPhone.</dd> -<dt>Kasimir Gabert</dt><dd>Maintains TorStatus.</dd> -<dt>Marcia Hofmann and Kevin Bankston</dt><dd>EFF lawyers who helped -write the <a href="<page eff/tor-legal-faq>">Tor Legal FAQ</a> and -tirelessly answers the phone when somebody in the world has a legal -question about Tor.</dd> -<dt>Andreas Jonsson</dt><dd>Works on OS X Tor Browser Bundle sandbox -technology.</dd> -<dt>Fabian Keil</dt><dd>One of the core Privoxy developers, and also a -Tor fan. He's the reason Tor and Privoxy still work well together.</dd> -<dt>Juha Nurmi</dt><dd>GSoC student in 2014 and researcher behind <a -href="https://blog.torproject.org/category/tags/ahmiafi">Ahmia</a>, a search -engine for hidden services.</dd> -<dt>Julius Mittenzwei</dt><dd>A lawyer with the CCC in -Germany. Coordinates the German Tor community with respect to legal -questions and concerns.</dd> -<dt>Shava Nerad</dt><dd>Our former Development Director. She still works -on PR and community relations.</dd> -<dt>Lasse Øverlier</dt><dd>Writes research papers on Tor: attacks, -defenses, and resource management, especially for hidden services.</dd> -<dt>Nart Villeneuve</dt><dd>Security researcher who works with -Jacob on Internet Censorship research.</dd> -<dt>Ethan Zuckerman</dt><dd>A blogger who has written some -<a href="http://www.ethanzuckerman.com/blog/?p=1019">interesting</a> -<a href="http://advocacy.globalvoicesonline.org/projects/guide/">tutorials</a> -for how, when, and whether to use Tor. He also teaches activists around -the world about Tor and related tools.</dd> -<dt>All our relay operators, people who write <a -href="http://freehaven.net/anonbib/">research papers</a> about Tor, -people who teach others about Tor, etc.</dt> -</dl> - </div> -  - <div id = "sidecol"> -#include "side.wmi" -#include "info.wmi" - </div> -  -</div> - #include <foot.wmi>

1 0

[tor-messenger-build/master] Switch tags to THUNDERBIRD_45_0_RELEASE
by arlo＠torproject.org 15 Apr '16

15 Apr '16

commit 6466b903e5c4ee930867c48766a03bc3c4cdf43d Author: Arlo Breault <arlolra(a)gmail.com> Date: Fri Apr 15 10:07:45 2016 -0700 Switch tags to THUNDERBIRD_45_0_RELEASE --- ChangeLog | 4 +++- projects/instantbird/config | 2 +- projects/mozilla/config | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ChangeLog b/ChangeLog index 4305ea4..cc19b93 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,7 @@ Tor Messenger 0.1.0b7 -- - * All Platforms +* All Platforms + * Use the THUNDERBIRD_45_0_RELEASE tag on mozilla-esr45 + * Use the THUNDERBIRD_45_0_RELEASE tag on comm-esr45 Tor Messenger 0.1.0b6 -- April 06, 2016 * All Platforms diff --git a/projects/instantbird/config b/projects/instantbird/config index eaa334c..b11e325 100644 --- a/projects/instantbird/config +++ b/projects/instantbird/config @@ -1,7 +1,7 @@ # vim: filetype=yaml sw=2 version: '[% c("abbrev") %]' hg_url: https://hg.mozilla.org/releases/comm-esr45/ -hg_hash: THUNDERBIRD_45_0b3_RELEASE +hg_hash: THUNDERBIRD_45_0_RELEASE filename: "[% project %]-[% c('version') %]-[% c('var/osname') %]-[% c('var/build_id') %].[% c('var/archive_suffix') %]" remote_docker: 1 var: diff --git a/projects/mozilla/config b/projects/mozilla/config index e062cfd..c4e81bc 100644 --- a/projects/mozilla/config +++ b/projects/mozilla/config @@ -1,7 +1,7 @@ # vim: filetype=yaml sw=2 version: '[% c("abbrev") %]' hg_url: https://hg.mozilla.org/releases/mozilla-esr45/ -hg_hash: THUNDERBIRD_45_0b3_RELEASE +hg_hash: THUNDERBIRD_45_0_RELEASE src: | #!/bin/sh set -e

1 0