{-# LANGUAGE ScopedTypeVariables #-}

-- |
-- Module      : Data.X509.Validation.Internal
-- License     : BSD-style
-- Stability   : experimental
-- Portability : unknown
--
-- Guards against exceptions thrown from pure code on malformed input.
module Data.X509.Validation.Internal (
    tryPure,
    safeCharacterToString,
) where

import Control.Exception (
    SomeAsyncException,
    SomeException,
    evaluate,
    fromException,
    throwIO,
    try,
 )
import Data.ASN1.Types (ASN1CharacterString, asn1CharacterToString)
import qualified Data.List as L
import System.IO.Unsafe (unsafeDupablePerformIO)

-- | Run a forcing function and turn synchronous exceptions into 'Left'.
tryPure :: (a -> ()) -> a -> Either String a
tryPure :: forall a. (a -> ()) -> a -> Either String a
tryPure a -> ()
force a
x = IO (Either String a) -> Either String a
forall a. IO a -> a
unsafeDupablePerformIO (IO (Either String a) -> Either String a)
-> IO (Either String a) -> Either String a
forall a b. (a -> b) -> a -> b
$ do
    res <- IO () -> IO (Either SomeException ())
forall e a. Exception e => IO a -> IO (Either e a)
try (IO () -> IO (Either SomeException ()))
-> IO () -> IO (Either SomeException ())
forall a b. (a -> b) -> a -> b
$ () -> IO ()
forall a. a -> IO a
evaluate (() -> IO ()) -> () -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> ()
force a
x
    case res of
        Right () -> Either String a -> IO (Either String a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String a -> IO (Either String a))
-> Either String a -> IO (Either String a)
forall a b. (a -> b) -> a -> b
$ a -> Either String a
forall a b. b -> Either a b
Right a
x
        Left (SomeException
e :: SomeException)
            | Just (SomeAsyncException
_ :: SomeAsyncException) <- SomeException -> Maybe SomeAsyncException
forall e. Exception e => SomeException -> Maybe e
fromException SomeException
e -> SomeException -> IO (Either String a)
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO SomeException
e
            | Bool
otherwise -> Either String a -> IO (Either String a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String a -> IO (Either String a))
-> Either String a -> IO (Either String a)
forall a b. (a -> b) -> a -> b
$ String -> Either String a
forall a b. a -> Either a b
Left (SomeException -> String
forall a. Show a => a -> String
show SomeException
e)
{-# NOINLINE tryPure #-}

-- | Like 'asn1CharacterToString' but 'Nothing' on invalid encoding.
safeCharacterToString :: ASN1CharacterString -> Maybe String
safeCharacterToString :: ASN1CharacterString -> Maybe String
safeCharacterToString ASN1CharacterString
cs =
    ASN1CharacterString -> Maybe String
asn1CharacterToString ASN1CharacterString
cs Maybe String -> (String -> Maybe String) -> Maybe String
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (String -> Maybe String)
-> (String -> Maybe String) -> Either String String -> Maybe String
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe String -> String -> Maybe String
forall a b. a -> b -> a
const Maybe String
forall a. Maybe a
Nothing) String -> Maybe String
forall a. a -> Maybe a
Just (Either String String -> Maybe String)
-> (String -> Either String String) -> String -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> ()) -> String -> Either String String
forall a. (a -> ()) -> a -> Either String a
tryPure String -> ()
forall {a}. [a] -> ()
force
  where
    force :: [a] -> ()
force = (() -> a -> ()) -> () -> [a] -> ()
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
L.foldl' ((a -> () -> ()) -> () -> a -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> () -> ()
forall a b. a -> b -> b
seq) ()