{-# LANGUAGE DeriveDataTypeable, CPP #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Signal
-- Copyright   :  (c) Andrea Rosatto
--             :  (c) Jose A. Ortega Ruiz
--             :  (c) Jochen Keil
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Jose A. Ortega Ruiz <jao@gnu.org>
-- Stability   :  unstable
-- Portability :  unportable
--
-- Signal handling, including DBUS when available
--
-----------------------------------------------------------------------------

module Xmobar.System.Signal where

import Data.Foldable (for_)
import Data.Typeable (Typeable)
import Control.Concurrent
import Control.Concurrent.STM
import Control.Exception
import System.Posix.Signals
import Graphics.X11.Types (Button)
import Graphics.X11.Xlib.Types (Position)
import System.IO

#ifdef DBUS
import DBus (IsVariant(..))
import Control.Monad ((>=>))
#endif

safeHead :: [a] -> Maybe a
safeHead :: [a] -> Maybe a
safeHead    [] = Maybe a
forall a. Maybe a
Nothing
safeHead (a
x:[a]
_) = a -> Maybe a
forall a. a -> Maybe a
Just a
x

data WakeUp = WakeUp deriving (Int -> WakeUp -> ShowS
[WakeUp] -> ShowS
WakeUp -> String
(Int -> WakeUp -> ShowS)
-> (WakeUp -> String) -> ([WakeUp] -> ShowS) -> Show WakeUp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WakeUp] -> ShowS
$cshowList :: [WakeUp] -> ShowS
show :: WakeUp -> String
$cshow :: WakeUp -> String
showsPrec :: Int -> WakeUp -> ShowS
$cshowsPrec :: Int -> WakeUp -> ShowS
Show,Typeable)
instance Exception WakeUp

data SignalType = Wakeup
                | Reposition
                | ChangeScreen
                | Hide   Int
                | Reveal Int
                | Toggle Int
                | TogglePersistent
                | Action Button Position
    deriving (ReadPrec [SignalType]
ReadPrec SignalType
Int -> ReadS SignalType
ReadS [SignalType]
(Int -> ReadS SignalType)
-> ReadS [SignalType]
-> ReadPrec SignalType
-> ReadPrec [SignalType]
-> Read SignalType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SignalType]
$creadListPrec :: ReadPrec [SignalType]
readPrec :: ReadPrec SignalType
$creadPrec :: ReadPrec SignalType
readList :: ReadS [SignalType]
$creadList :: ReadS [SignalType]
readsPrec :: Int -> ReadS SignalType
$creadsPrec :: Int -> ReadS SignalType
Read, Int -> SignalType -> ShowS
[SignalType] -> ShowS
SignalType -> String
(Int -> SignalType -> ShowS)
-> (SignalType -> String)
-> ([SignalType] -> ShowS)
-> Show SignalType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SignalType] -> ShowS
$cshowList :: [SignalType] -> ShowS
show :: SignalType -> String
$cshow :: SignalType -> String
showsPrec :: Int -> SignalType -> ShowS
$cshowsPrec :: Int -> SignalType -> ShowS
Show)

#ifdef DBUS
instance IsVariant SignalType where
    toVariant   = toVariant . show
    fromVariant = fromVariant >=> parseSignalType
#endif

parseSignalType :: String -> Maybe SignalType
parseSignalType :: String -> Maybe SignalType
parseSignalType = ((SignalType, String) -> SignalType)
-> Maybe (SignalType, String) -> Maybe SignalType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (SignalType, String) -> SignalType
forall a b. (a, b) -> a
fst (Maybe (SignalType, String) -> Maybe SignalType)
-> (String -> Maybe (SignalType, String))
-> String
-> Maybe SignalType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(SignalType, String)] -> Maybe (SignalType, String)
forall a. [a] -> Maybe a
safeHead ([(SignalType, String)] -> Maybe (SignalType, String))
-> ReadS SignalType -> String -> Maybe (SignalType, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS SignalType
forall a. Read a => ReadS a
reads

-- | Signal handling
setupSignalHandler :: TMVar SignalType -> IO ()
setupSignalHandler :: TMVar SignalType -> IO ()
setupSignalHandler TMVar SignalType
tid = do
   Signal -> Handler -> Maybe SignalSet -> IO Handler
installHandler Signal
sigUSR2 (IO () -> Handler
Catch (IO () -> Handler) -> IO () -> Handler
forall a b. (a -> b) -> a -> b
$ TMVar SignalType -> IO ()
updatePosHandler TMVar SignalType
tid) Maybe SignalSet
forall a. Maybe a
Nothing
   Signal -> Handler -> Maybe SignalSet -> IO Handler
installHandler Signal
sigUSR1 (IO () -> Handler
Catch (IO () -> Handler) -> IO () -> Handler
forall a b. (a -> b) -> a -> b
$ TMVar SignalType -> IO ()
changeScreenHandler TMVar SignalType
tid) Maybe SignalSet
forall a. Maybe a
Nothing
   () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

updatePosHandler :: TMVar SignalType -> IO ()
updatePosHandler :: TMVar SignalType -> IO ()
updatePosHandler TMVar SignalType
sig = do
   STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ()) -> STM () -> IO ()
forall a b. (a -> b) -> a -> b
$ TMVar SignalType -> SignalType -> STM ()
forall a. TMVar a -> a -> STM ()
putTMVar TMVar SignalType
sig SignalType
Reposition
   () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

changeScreenHandler :: TMVar SignalType -> IO ()
changeScreenHandler :: TMVar SignalType -> IO ()
changeScreenHandler TMVar SignalType
sig = do
   STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ()) -> STM () -> IO ()
forall a b. (a -> b) -> a -> b
$ TMVar SignalType -> SignalType -> STM ()
forall a. TMVar a -> a -> STM ()
putTMVar TMVar SignalType
sig SignalType
ChangeScreen
   () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- | Ensures that the given IO action runs its cleanup actions ('bracket' etc.),
-- even if a signal is caught.
--
-- An exception will be thrown on the thread that called this function when a
-- signal is caught.
withDeferSignals :: IO a -> IO a
withDeferSignals :: IO a -> IO a
withDeferSignals IO a
thing = do
  ThreadId
threadId <- IO ThreadId
myThreadId
  MVar Signal
caughtSignal <- IO (MVar Signal)
forall a. IO (MVar a)
newEmptyMVar

  let signals :: [Signal]
signals =
        (Signal -> Bool) -> [Signal] -> [Signal]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Signal -> Bool) -> Signal -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Signal -> SignalSet -> Bool) -> SignalSet -> Signal -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Signal -> SignalSet -> Bool
inSignalSet SignalSet
reservedSignals)
          [ Signal
sigQUIT
          , Signal
sigTERM
          --, sigINT -- Handler already installed by GHC
          --, sigPIPE -- Handler already installed by GHC
          --, sigUSR1 -- Handled by setupSignalHandler
          --, sigUSR2 -- Handled by setupSignalHandler

          -- One of the following appears to cause instability, see #360
          --, sigHUP
          --, sigILL
          --, sigABRT
          --, sigFPE
          --, sigSEGV
          --, sigALRM
          --, sigBUS
          --, sigPOLL
          --, sigPROF
          --, sigSYS
          --, sigTRAP
          --, sigVTALRM
          --, sigXCPU
          --, sigXFSZ
          ]

  [Signal] -> (Signal -> IO Handler) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Signal]
signals ((Signal -> IO Handler) -> IO ())
-> (Signal -> IO Handler) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Signal
s ->

      Signal -> Handler -> Maybe SignalSet -> IO Handler
installHandler Signal
s
        (IO () -> Handler
Catch (IO () -> Handler) -> IO () -> Handler
forall a b. (a -> b) -> a -> b
$ do
          MVar Signal -> Signal -> IO Bool
forall a. MVar a -> a -> IO Bool
tryPutMVar MVar Signal
caughtSignal Signal
s
          Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"xmobar: Caught signal "String -> ShowS
forall a. [a] -> [a] -> [a]
++Signal -> String
forall a. Show a => a -> String
show Signal
sString -> ShowS
forall a. [a] -> [a] -> [a]
++String
"; exiting...")
          ThreadId -> AsyncException -> IO ()
forall e. Exception e => ThreadId -> e -> IO ()
throwTo ThreadId
threadId AsyncException
ThreadKilled)
        Maybe SignalSet
forall a. Maybe a
Nothing

  IO a
thing IO a -> IO () -> IO a
forall a b. IO a -> IO b -> IO a
`finally` do
        Maybe Signal
s0 <- MVar Signal -> IO (Maybe Signal)
forall a. MVar a -> IO (Maybe a)
tryReadMVar MVar Signal
caughtSignal
        case Maybe Signal
s0 of
          Maybe Signal
Nothing -> () -> IO ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
          Just Signal
s -> do
            -- Run the default handler for the signal
            -- hPutStrLn stderr ("xmobar: Running default handler for signal "++show s)
            Signal -> Handler -> Maybe SignalSet -> IO Handler
installHandler Signal
s Handler
Default Maybe SignalSet
forall a. Maybe a
Nothing
            Signal -> IO ()
raiseSignal Signal
s