module Crypto.Gpgme.Types where

import Bindings.Gpgme
import qualified Data.ByteString as BS
import Data.Maybe (mapMaybe)
import Foreign
import qualified Foreign.Concurrent as FC
import Foreign.C.String (peekCString)
import System.IO.Unsafe (unsafePerformIO)
import Control.Exception (SomeException, Exception)

-- | the protocol to be used in the crypto engine
data Protocol =
      CMS
    | GPGCONF
    | OpenPGP
    | UNKNOWN
    deriving (Int -> Protocol -> ShowS
[Protocol] -> ShowS
Protocol -> String
(Int -> Protocol -> ShowS)
-> (Protocol -> String) -> ([Protocol] -> ShowS) -> Show Protocol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Protocol] -> ShowS
$cshowList :: [Protocol] -> ShowS
show :: Protocol -> String
$cshow :: Protocol -> String
showsPrec :: Int -> Protocol -> ShowS
$cshowsPrec :: Int -> Protocol -> ShowS
Show, Protocol -> Protocol -> Bool
(Protocol -> Protocol -> Bool)
-> (Protocol -> Protocol -> Bool) -> Eq Protocol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Protocol -> Protocol -> Bool
$c/= :: Protocol -> Protocol -> Bool
== :: Protocol -> Protocol -> Bool
$c== :: Protocol -> Protocol -> Bool
Eq, Eq Protocol
Eq Protocol
-> (Protocol -> Protocol -> Ordering)
-> (Protocol -> Protocol -> Bool)
-> (Protocol -> Protocol -> Bool)
-> (Protocol -> Protocol -> Bool)
-> (Protocol -> Protocol -> Bool)
-> (Protocol -> Protocol -> Protocol)
-> (Protocol -> Protocol -> Protocol)
-> Ord Protocol
Protocol -> Protocol -> Bool
Protocol -> Protocol -> Ordering
Protocol -> Protocol -> Protocol
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Protocol -> Protocol -> Protocol
$cmin :: Protocol -> Protocol -> Protocol
max :: Protocol -> Protocol -> Protocol
$cmax :: Protocol -> Protocol -> Protocol
>= :: Protocol -> Protocol -> Bool
$c>= :: Protocol -> Protocol -> Bool
> :: Protocol -> Protocol -> Bool
$c> :: Protocol -> Protocol -> Bool
<= :: Protocol -> Protocol -> Bool
$c<= :: Protocol -> Protocol -> Bool
< :: Protocol -> Protocol -> Bool
$c< :: Protocol -> Protocol -> Bool
compare :: Protocol -> Protocol -> Ordering
$ccompare :: Protocol -> Protocol -> Ordering
$cp1Ord :: Eq Protocol
Ord)

-- | Context to be passed around with operations. Use 'newCtx' or
--   'withCtx' in order to obtain an instance.
data Ctx = Ctx {
      Ctx -> Ptr C'gpgme_ctx_t
_ctx             :: Ptr C'gpgme_ctx_t -- ^ context
    , Ctx -> String
_version         :: String            -- ^ GPGME version
    , Ctx -> Protocol
_protocol        :: Protocol          -- ^ context protocol
    , Ctx -> String
_engineVersion   :: String            -- ^ engine version
}

-- | Modes for key listings
data KeyListingMode
    = KeyListingLocal
    | KeyListingExtern
    | KeyListingSigs
    | KeyListingSigNotations
    | KeyListingValidate

-- | Modes for signing with GPG
data SignMode = Normal | Detach | Clear deriving Int -> SignMode -> ShowS
[SignMode] -> ShowS
SignMode -> String
(Int -> SignMode -> ShowS)
-> (SignMode -> String) -> ([SignMode] -> ShowS) -> Show SignMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SignMode] -> ShowS
$cshowList :: [SignMode] -> ShowS
show :: SignMode -> String
$cshow :: SignMode -> String
showsPrec :: Int -> SignMode -> ShowS
$cshowsPrec :: Int -> SignMode -> ShowS
Show

-- | a fingerprint
type Fpr = BS.ByteString

-- | a plaintext
type Plain = BS.ByteString

-- | an ciphertext
type Encrypted = BS.ByteString

-- | a signature
type Signature = BS.ByteString

-- | the summary of a signature status
data SignatureSummary =
      BadPolicy                        -- ^ A policy requirement was not met
    | CrlMissing                       -- ^ The CRL is not available
    | CrlTooOld                        -- ^ Available CRL is too old
    | Green                            -- ^ The signature is good but one might want to display some extra information
    | KeyExpired                       -- ^ The key or one of the certificates has expired
    | KeyMissing                       -- ^ Can’t verify due to a missing key or certificate
    | KeyRevoked                       -- ^ The key or at least one certificate has been revoked
    | Red                              -- ^ The signature is bad
    | SigExpired                       -- ^ The signature has expired
    | SysError                         -- ^ A system error occured
    | UnknownSummary C'gpgme_sigsum_t  -- ^ The summary is something else
    | Valid                            -- ^ The signature is fully valid
    deriving (Int -> SignatureSummary -> ShowS
[SignatureSummary] -> ShowS
SignatureSummary -> String
(Int -> SignatureSummary -> ShowS)
-> (SignatureSummary -> String)
-> ([SignatureSummary] -> ShowS)
-> Show SignatureSummary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SignatureSummary] -> ShowS
$cshowList :: [SignatureSummary] -> ShowS
show :: SignatureSummary -> String
$cshow :: SignatureSummary -> String
showsPrec :: Int -> SignatureSummary -> ShowS
$cshowsPrec :: Int -> SignatureSummary -> ShowS
Show, SignatureSummary -> SignatureSummary -> Bool
(SignatureSummary -> SignatureSummary -> Bool)
-> (SignatureSummary -> SignatureSummary -> Bool)
-> Eq SignatureSummary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SignatureSummary -> SignatureSummary -> Bool
$c/= :: SignatureSummary -> SignatureSummary -> Bool
== :: SignatureSummary -> SignatureSummary -> Bool
$c== :: SignatureSummary -> SignatureSummary -> Bool
Eq, Eq SignatureSummary
Eq SignatureSummary
-> (SignatureSummary -> SignatureSummary -> Ordering)
-> (SignatureSummary -> SignatureSummary -> Bool)
-> (SignatureSummary -> SignatureSummary -> Bool)
-> (SignatureSummary -> SignatureSummary -> Bool)
-> (SignatureSummary -> SignatureSummary -> Bool)
-> (SignatureSummary -> SignatureSummary -> SignatureSummary)
-> (SignatureSummary -> SignatureSummary -> SignatureSummary)
-> Ord SignatureSummary
SignatureSummary -> SignatureSummary -> Bool
SignatureSummary -> SignatureSummary -> Ordering
SignatureSummary -> SignatureSummary -> SignatureSummary
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SignatureSummary -> SignatureSummary -> SignatureSummary
$cmin :: SignatureSummary -> SignatureSummary -> SignatureSummary
max :: SignatureSummary -> SignatureSummary -> SignatureSummary
$cmax :: SignatureSummary -> SignatureSummary -> SignatureSummary
>= :: SignatureSummary -> SignatureSummary -> Bool
$c>= :: SignatureSummary -> SignatureSummary -> Bool
> :: SignatureSummary -> SignatureSummary -> Bool
$c> :: SignatureSummary -> SignatureSummary -> Bool
<= :: SignatureSummary -> SignatureSummary -> Bool
$c<= :: SignatureSummary -> SignatureSummary -> Bool
< :: SignatureSummary -> SignatureSummary -> Bool
$c< :: SignatureSummary -> SignatureSummary -> Bool
compare :: SignatureSummary -> SignatureSummary -> Ordering
$ccompare :: SignatureSummary -> SignatureSummary -> Ordering
$cp1Ord :: Eq SignatureSummary
Ord)

-- | Translate the gpgme_sigsum_t bit vector to a list of SignatureSummary
toSignatureSummaries :: C'gpgme_sigsum_t -> [SignatureSummary]
toSignatureSummaries :: C'gpgme_sigsum_t -> [SignatureSummary]
toSignatureSummaries C'gpgme_sigsum_t
x = ((C'gpgme_sigsum_t, SignatureSummary) -> Maybe SignatureSummary)
-> [(C'gpgme_sigsum_t, SignatureSummary)] -> [SignatureSummary]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (\(C'gpgme_sigsum_t
mask, SignatureSummary
val) -> if C'gpgme_sigsum_t
mask C'gpgme_sigsum_t -> C'gpgme_sigsum_t -> C'gpgme_sigsum_t
forall a. Bits a => a -> a -> a
.&. C'gpgme_sigsum_t
x C'gpgme_sigsum_t -> C'gpgme_sigsum_t -> Bool
forall a. Eq a => a -> a -> Bool
== C'gpgme_sigsum_t
0 then Maybe SignatureSummary
forall a. Maybe a
Nothing else SignatureSummary -> Maybe SignatureSummary
forall a. a -> Maybe a
Just SignatureSummary
val)
    [ (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_BAD_POLICY , SignatureSummary
BadPolicy)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_CRL_MISSING, SignatureSummary
CrlMissing)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_CRL_TOO_OLD, SignatureSummary
CrlTooOld)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_GREEN      , SignatureSummary
Green)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_KEY_EXPIRED, SignatureSummary
KeyExpired)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_KEY_MISSING, SignatureSummary
KeyMissing)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_KEY_REVOKED, SignatureSummary
KeyRevoked)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_RED        , SignatureSummary
Red)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_SIG_EXPIRED, SignatureSummary
SigExpired)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_SYS_ERROR  , SignatureSummary
SysError)
    , (C'gpgme_sigsum_t
forall a. Num a => a
c'GPGME_SIGSUM_VALID      , SignatureSummary
Valid)
    ]

type VerificationResult = [(GpgmeError, [SignatureSummary], Fpr)]

-- | The fingerprint and an error code
type InvalidKey = (String, Int)
-- TODO map intot better error code

-- | A key from the context
newtype Key = Key { Key -> ForeignPtr C'gpgme_key_t
unKey :: ForeignPtr C'gpgme_key_t }

-- | Allocate a key
allocKey :: IO Key
allocKey :: IO Key
allocKey = do
    Ptr C'gpgme_key_t
keyPtr <- IO (Ptr C'gpgme_key_t)
forall a. Storable a => IO (Ptr a)
malloc
    let finalize :: IO ()
finalize = do
            Ptr C'gpgme_key_t -> IO C'gpgme_key_t
forall a. Storable a => Ptr a -> IO a
peek Ptr C'gpgme_key_t
keyPtr IO C'gpgme_key_t -> (C'gpgme_key_t -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= C'gpgme_key_t -> IO ()
c'gpgme_key_unref
            Ptr C'gpgme_key_t -> IO ()
forall a. Ptr a -> IO ()
free Ptr C'gpgme_key_t
keyPtr
    ForeignPtr C'gpgme_key_t -> Key
Key (ForeignPtr C'gpgme_key_t -> Key)
-> IO (ForeignPtr C'gpgme_key_t) -> IO Key
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Ptr C'gpgme_key_t -> IO () -> IO (ForeignPtr C'gpgme_key_t)
forall a. Ptr a -> IO () -> IO (ForeignPtr a)
FC.newForeignPtr Ptr C'gpgme_key_t
keyPtr IO ()
finalize

-- | Perform an action with the pointer to a 'Key'
withKeyPtr :: Key -> (Ptr C'gpgme_key_t -> IO a) -> IO a
withKeyPtr :: Key -> (Ptr C'gpgme_key_t -> IO a) -> IO a
withKeyPtr (Key ForeignPtr C'gpgme_key_t
fPtr) = ForeignPtr C'gpgme_key_t -> (Ptr C'gpgme_key_t -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr C'gpgme_key_t
fPtr

-- | Whether to include secret keys when searching
data IncludeSecret =
      WithSecret -- ^ do not include secret keys
    | NoSecret   -- ^ include secret keys
    deriving (Int -> IncludeSecret -> ShowS
[IncludeSecret] -> ShowS
IncludeSecret -> String
(Int -> IncludeSecret -> ShowS)
-> (IncludeSecret -> String)
-> ([IncludeSecret] -> ShowS)
-> Show IncludeSecret
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IncludeSecret] -> ShowS
$cshowList :: [IncludeSecret] -> ShowS
show :: IncludeSecret -> String
$cshow :: IncludeSecret -> String
showsPrec :: Int -> IncludeSecret -> ShowS
$cshowsPrec :: Int -> IncludeSecret -> ShowS
Show, IncludeSecret -> IncludeSecret -> Bool
(IncludeSecret -> IncludeSecret -> Bool)
-> (IncludeSecret -> IncludeSecret -> Bool) -> Eq IncludeSecret
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IncludeSecret -> IncludeSecret -> Bool
$c/= :: IncludeSecret -> IncludeSecret -> Bool
== :: IncludeSecret -> IncludeSecret -> Bool
$c== :: IncludeSecret -> IncludeSecret -> Bool
Eq, Eq IncludeSecret
Eq IncludeSecret
-> (IncludeSecret -> IncludeSecret -> Ordering)
-> (IncludeSecret -> IncludeSecret -> Bool)
-> (IncludeSecret -> IncludeSecret -> Bool)
-> (IncludeSecret -> IncludeSecret -> Bool)
-> (IncludeSecret -> IncludeSecret -> Bool)
-> (IncludeSecret -> IncludeSecret -> IncludeSecret)
-> (IncludeSecret -> IncludeSecret -> IncludeSecret)
-> Ord IncludeSecret
IncludeSecret -> IncludeSecret -> Bool
IncludeSecret -> IncludeSecret -> Ordering
IncludeSecret -> IncludeSecret -> IncludeSecret
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: IncludeSecret -> IncludeSecret -> IncludeSecret
$cmin :: IncludeSecret -> IncludeSecret -> IncludeSecret
max :: IncludeSecret -> IncludeSecret -> IncludeSecret
$cmax :: IncludeSecret -> IncludeSecret -> IncludeSecret
>= :: IncludeSecret -> IncludeSecret -> Bool
$c>= :: IncludeSecret -> IncludeSecret -> Bool
> :: IncludeSecret -> IncludeSecret -> Bool
$c> :: IncludeSecret -> IncludeSecret -> Bool
<= :: IncludeSecret -> IncludeSecret -> Bool
$c<= :: IncludeSecret -> IncludeSecret -> Bool
< :: IncludeSecret -> IncludeSecret -> Bool
$c< :: IncludeSecret -> IncludeSecret -> Bool
compare :: IncludeSecret -> IncludeSecret -> Ordering
$ccompare :: IncludeSecret -> IncludeSecret -> Ordering
$cp1Ord :: Eq IncludeSecret
Ord)

data Flag =
      AlwaysTrust
    | NoFlag
    deriving (Int -> Flag -> ShowS
[Flag] -> ShowS
Flag -> String
(Int -> Flag -> ShowS)
-> (Flag -> String) -> ([Flag] -> ShowS) -> Show Flag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flag] -> ShowS
$cshowList :: [Flag] -> ShowS
show :: Flag -> String
$cshow :: Flag -> String
showsPrec :: Int -> Flag -> ShowS
$cshowsPrec :: Int -> Flag -> ShowS
Show, Flag -> Flag -> Bool
(Flag -> Flag -> Bool) -> (Flag -> Flag -> Bool) -> Eq Flag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flag -> Flag -> Bool
$c/= :: Flag -> Flag -> Bool
== :: Flag -> Flag -> Bool
$c== :: Flag -> Flag -> Bool
Eq, Eq Flag
Eq Flag
-> (Flag -> Flag -> Ordering)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Flag)
-> (Flag -> Flag -> Flag)
-> Ord Flag
Flag -> Flag -> Bool
Flag -> Flag -> Ordering
Flag -> Flag -> Flag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Flag -> Flag -> Flag
$cmin :: Flag -> Flag -> Flag
max :: Flag -> Flag -> Flag
$cmax :: Flag -> Flag -> Flag
>= :: Flag -> Flag -> Bool
$c>= :: Flag -> Flag -> Bool
> :: Flag -> Flag -> Bool
$c> :: Flag -> Flag -> Bool
<= :: Flag -> Flag -> Bool
$c<= :: Flag -> Flag -> Bool
< :: Flag -> Flag -> Bool
$c< :: Flag -> Flag -> Bool
compare :: Flag -> Flag -> Ordering
$ccompare :: Flag -> Flag -> Ordering
$cp1Ord :: Eq Flag
Ord)

-- | A GPGME error.
--
-- Errors in GPGME consist of two parts: a code indicating the nature of the fault,
-- and a source indicating from which subsystem the error originated.
newtype GpgmeError = GpgmeError C'gpgme_error_t
                   deriving (Int -> GpgmeError -> ShowS
[GpgmeError] -> ShowS
GpgmeError -> String
(Int -> GpgmeError -> ShowS)
-> (GpgmeError -> String)
-> ([GpgmeError] -> ShowS)
-> Show GpgmeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GpgmeError] -> ShowS
$cshowList :: [GpgmeError] -> ShowS
show :: GpgmeError -> String
$cshow :: GpgmeError -> String
showsPrec :: Int -> GpgmeError -> ShowS
$cshowsPrec :: Int -> GpgmeError -> ShowS
Show, Eq GpgmeError
Eq GpgmeError
-> (GpgmeError -> GpgmeError -> Ordering)
-> (GpgmeError -> GpgmeError -> Bool)
-> (GpgmeError -> GpgmeError -> Bool)
-> (GpgmeError -> GpgmeError -> Bool)
-> (GpgmeError -> GpgmeError -> Bool)
-> (GpgmeError -> GpgmeError -> GpgmeError)
-> (GpgmeError -> GpgmeError -> GpgmeError)
-> Ord GpgmeError
GpgmeError -> GpgmeError -> Bool
GpgmeError -> GpgmeError -> Ordering
GpgmeError -> GpgmeError -> GpgmeError
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GpgmeError -> GpgmeError -> GpgmeError
$cmin :: GpgmeError -> GpgmeError -> GpgmeError
max :: GpgmeError -> GpgmeError -> GpgmeError
$cmax :: GpgmeError -> GpgmeError -> GpgmeError
>= :: GpgmeError -> GpgmeError -> Bool
$c>= :: GpgmeError -> GpgmeError -> Bool
> :: GpgmeError -> GpgmeError -> Bool
$c> :: GpgmeError -> GpgmeError -> Bool
<= :: GpgmeError -> GpgmeError -> Bool
$c<= :: GpgmeError -> GpgmeError -> Bool
< :: GpgmeError -> GpgmeError -> Bool
$c< :: GpgmeError -> GpgmeError -> Bool
compare :: GpgmeError -> GpgmeError -> Ordering
$ccompare :: GpgmeError -> GpgmeError -> Ordering
$cp1Ord :: Eq GpgmeError
Ord, GpgmeError -> GpgmeError -> Bool
(GpgmeError -> GpgmeError -> Bool)
-> (GpgmeError -> GpgmeError -> Bool) -> Eq GpgmeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GpgmeError -> GpgmeError -> Bool
$c/= :: GpgmeError -> GpgmeError -> Bool
== :: GpgmeError -> GpgmeError -> Bool
$c== :: GpgmeError -> GpgmeError -> Bool
Eq)

-- | An explanatory string for a GPGME error.
errorString :: GpgmeError -> String
errorString :: GpgmeError -> String
errorString (GpgmeError C'gpgme_sigsum_t
n) =
    IO String -> String
forall a. IO a -> a
unsafePerformIO (IO String -> String) -> IO String -> String
forall a b. (a -> b) -> a -> b
$ C'gpgme_sigsum_t -> IO CString
c'gpgme_strerror C'gpgme_sigsum_t
n IO CString -> (CString -> IO String) -> IO String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CString -> IO String
peekCString

-- | An explanatory string describing the source of a GPGME error
sourceString :: GpgmeError -> String
sourceString :: GpgmeError -> String
sourceString (GpgmeError C'gpgme_sigsum_t
n) =
    IO String -> String
forall a. IO a -> a
unsafePerformIO (IO String -> String) -> IO String -> String
forall a b. (a -> b) -> a -> b
$ C'gpgme_sigsum_t -> IO CString
c'gpgme_strsource C'gpgme_sigsum_t
n IO CString -> (CString -> IO String) -> IO String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CString -> IO String
peekCString

-- | error indicating what went wrong in decryption
data DecryptError =
      NoData              -- ^ no data to decrypt
    | Failed              -- ^ not a valid cipher
    | BadPass             -- ^ passphrase for secret was wrong
    | Unknown GpgmeError  -- ^ something else went wrong
    deriving (Int -> DecryptError -> ShowS
[DecryptError] -> ShowS
DecryptError -> String
(Int -> DecryptError -> ShowS)
-> (DecryptError -> String)
-> ([DecryptError] -> ShowS)
-> Show DecryptError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DecryptError] -> ShowS
$cshowList :: [DecryptError] -> ShowS
show :: DecryptError -> String
$cshow :: DecryptError -> String
showsPrec :: Int -> DecryptError -> ShowS
$cshowsPrec :: Int -> DecryptError -> ShowS
Show, DecryptError -> DecryptError -> Bool
(DecryptError -> DecryptError -> Bool)
-> (DecryptError -> DecryptError -> Bool) -> Eq DecryptError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DecryptError -> DecryptError -> Bool
$c/= :: DecryptError -> DecryptError -> Bool
== :: DecryptError -> DecryptError -> Bool
$c== :: DecryptError -> DecryptError -> Bool
Eq, Eq DecryptError
Eq DecryptError
-> (DecryptError -> DecryptError -> Ordering)
-> (DecryptError -> DecryptError -> Bool)
-> (DecryptError -> DecryptError -> Bool)
-> (DecryptError -> DecryptError -> Bool)
-> (DecryptError -> DecryptError -> Bool)
-> (DecryptError -> DecryptError -> DecryptError)
-> (DecryptError -> DecryptError -> DecryptError)
-> Ord DecryptError
DecryptError -> DecryptError -> Bool
DecryptError -> DecryptError -> Ordering
DecryptError -> DecryptError -> DecryptError
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DecryptError -> DecryptError -> DecryptError
$cmin :: DecryptError -> DecryptError -> DecryptError
max :: DecryptError -> DecryptError -> DecryptError
$cmax :: DecryptError -> DecryptError -> DecryptError
>= :: DecryptError -> DecryptError -> Bool
$c>= :: DecryptError -> DecryptError -> Bool
> :: DecryptError -> DecryptError -> Bool
$c> :: DecryptError -> DecryptError -> Bool
<= :: DecryptError -> DecryptError -> Bool
$c<= :: DecryptError -> DecryptError -> Bool
< :: DecryptError -> DecryptError -> Bool
$c< :: DecryptError -> DecryptError -> Bool
compare :: DecryptError -> DecryptError -> Ordering
$ccompare :: DecryptError -> DecryptError -> Ordering
$cp1Ord :: Eq DecryptError
Ord)

toDecryptError :: C'gpgme_error_t -> DecryptError
toDecryptError :: C'gpgme_sigsum_t -> DecryptError
toDecryptError C'gpgme_sigsum_t
n =
    case IO C'gpgme_sigsum_t -> C'gpgme_sigsum_t
forall a. IO a -> a
unsafePerformIO (IO C'gpgme_sigsum_t -> C'gpgme_sigsum_t)
-> IO C'gpgme_sigsum_t -> C'gpgme_sigsum_t
forall a b. (a -> b) -> a -> b
$ C'gpgme_sigsum_t -> IO C'gpgme_sigsum_t
c'gpgme_err_code C'gpgme_sigsum_t
n of
        C'gpgme_sigsum_t
58   -> DecryptError
NoData
        C'gpgme_sigsum_t
152  -> DecryptError
Failed
        C'gpgme_sigsum_t
11   -> DecryptError
BadPass
        C'gpgme_sigsum_t
x    -> GpgmeError -> DecryptError
Unknown (C'gpgme_sigsum_t -> GpgmeError
GpgmeError C'gpgme_sigsum_t
x)

-- | The validity of a user identity
data Validity =
      ValidityUnknown
    | ValidityUndefined
    | ValidityNever
    | ValidityMarginal
    | ValidityFull
    | ValidityUltimate
    deriving (Int -> Validity -> ShowS
[Validity] -> ShowS
Validity -> String
(Int -> Validity -> ShowS)
-> (Validity -> String) -> ([Validity] -> ShowS) -> Show Validity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Validity] -> ShowS
$cshowList :: [Validity] -> ShowS
show :: Validity -> String
$cshow :: Validity -> String
showsPrec :: Int -> Validity -> ShowS
$cshowsPrec :: Int -> Validity -> ShowS
Show, Eq Validity
Eq Validity
-> (Validity -> Validity -> Ordering)
-> (Validity -> Validity -> Bool)
-> (Validity -> Validity -> Bool)
-> (Validity -> Validity -> Bool)
-> (Validity -> Validity -> Bool)
-> (Validity -> Validity -> Validity)
-> (Validity -> Validity -> Validity)
-> Ord Validity
Validity -> Validity -> Bool
Validity -> Validity -> Ordering
Validity -> Validity -> Validity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Validity -> Validity -> Validity
$cmin :: Validity -> Validity -> Validity
max :: Validity -> Validity -> Validity
$cmax :: Validity -> Validity -> Validity
>= :: Validity -> Validity -> Bool
$c>= :: Validity -> Validity -> Bool
> :: Validity -> Validity -> Bool
$c> :: Validity -> Validity -> Bool
<= :: Validity -> Validity -> Bool
$c<= :: Validity -> Validity -> Bool
< :: Validity -> Validity -> Bool
$c< :: Validity -> Validity -> Bool
compare :: Validity -> Validity -> Ordering
$ccompare :: Validity -> Validity -> Ordering
$cp1Ord :: Eq Validity
Ord, Validity -> Validity -> Bool
(Validity -> Validity -> Bool)
-> (Validity -> Validity -> Bool) -> Eq Validity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Validity -> Validity -> Bool
$c/= :: Validity -> Validity -> Bool
== :: Validity -> Validity -> Bool
$c== :: Validity -> Validity -> Bool
Eq)

-- | A public-key encryption algorithm
data PubKeyAlgo =
      Rsa
    | RsaE
    | RsaS
    | ElgE
    | Dsa
    | Elg
    deriving (Int -> PubKeyAlgo -> ShowS
[PubKeyAlgo] -> ShowS
PubKeyAlgo -> String
(Int -> PubKeyAlgo -> ShowS)
-> (PubKeyAlgo -> String)
-> ([PubKeyAlgo] -> ShowS)
-> Show PubKeyAlgo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PubKeyAlgo] -> ShowS
$cshowList :: [PubKeyAlgo] -> ShowS
show :: PubKeyAlgo -> String
$cshow :: PubKeyAlgo -> String
showsPrec :: Int -> PubKeyAlgo -> ShowS
$cshowsPrec :: Int -> PubKeyAlgo -> ShowS
Show, Eq PubKeyAlgo
Eq PubKeyAlgo
-> (PubKeyAlgo -> PubKeyAlgo -> Ordering)
-> (PubKeyAlgo -> PubKeyAlgo -> Bool)
-> (PubKeyAlgo -> PubKeyAlgo -> Bool)
-> (PubKeyAlgo -> PubKeyAlgo -> Bool)
-> (PubKeyAlgo -> PubKeyAlgo -> Bool)
-> (PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo)
-> (PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo)
-> Ord PubKeyAlgo
PubKeyAlgo -> PubKeyAlgo -> Bool
PubKeyAlgo -> PubKeyAlgo -> Ordering
PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo
$cmin :: PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo
max :: PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo
$cmax :: PubKeyAlgo -> PubKeyAlgo -> PubKeyAlgo
>= :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c>= :: PubKeyAlgo -> PubKeyAlgo -> Bool
> :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c> :: PubKeyAlgo -> PubKeyAlgo -> Bool
<= :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c<= :: PubKeyAlgo -> PubKeyAlgo -> Bool
< :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c< :: PubKeyAlgo -> PubKeyAlgo -> Bool
compare :: PubKeyAlgo -> PubKeyAlgo -> Ordering
$ccompare :: PubKeyAlgo -> PubKeyAlgo -> Ordering
$cp1Ord :: Eq PubKeyAlgo
Ord, PubKeyAlgo -> PubKeyAlgo -> Bool
(PubKeyAlgo -> PubKeyAlgo -> Bool)
-> (PubKeyAlgo -> PubKeyAlgo -> Bool) -> Eq PubKeyAlgo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c/= :: PubKeyAlgo -> PubKeyAlgo -> Bool
== :: PubKeyAlgo -> PubKeyAlgo -> Bool
$c== :: PubKeyAlgo -> PubKeyAlgo -> Bool
Eq)

-- | h-gpgme exception for wrapping exception which occur outside of the control of h-gpgme
newtype HgpgmeException = HgpgmeException SomeException deriving (Int -> HgpgmeException -> ShowS
[HgpgmeException] -> ShowS
HgpgmeException -> String
(Int -> HgpgmeException -> ShowS)
-> (HgpgmeException -> String)
-> ([HgpgmeException] -> ShowS)
-> Show HgpgmeException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HgpgmeException] -> ShowS
$cshowList :: [HgpgmeException] -> ShowS
show :: HgpgmeException -> String
$cshow :: HgpgmeException -> String
showsPrec :: Int -> HgpgmeException -> ShowS
$cshowsPrec :: Int -> HgpgmeException -> ShowS
Show)
instance Exception HgpgmeException

-- | Flags for removeKey function
data RemoveKeyFlags = RemoveKeyFlags {
      RemoveKeyFlags -> Bool
allowSecret :: Bool -- ^ if False, only public keys are removed, otherwise secret keys are removed as well
    , RemoveKeyFlags -> Bool
force       :: Bool -- ^ if True, don't ask for confirmation
    } deriving (Int -> RemoveKeyFlags -> ShowS
[RemoveKeyFlags] -> ShowS
RemoveKeyFlags -> String
(Int -> RemoveKeyFlags -> ShowS)
-> (RemoveKeyFlags -> String)
-> ([RemoveKeyFlags] -> ShowS)
-> Show RemoveKeyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoveKeyFlags] -> ShowS
$cshowList :: [RemoveKeyFlags] -> ShowS
show :: RemoveKeyFlags -> String
$cshow :: RemoveKeyFlags -> String
showsPrec :: Int -> RemoveKeyFlags -> ShowS
$cshowsPrec :: Int -> RemoveKeyFlags -> ShowS
Show, RemoveKeyFlags -> RemoveKeyFlags -> Bool
(RemoveKeyFlags -> RemoveKeyFlags -> Bool)
-> (RemoveKeyFlags -> RemoveKeyFlags -> Bool) -> Eq RemoveKeyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c/= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
== :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c== :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
Eq, Eq RemoveKeyFlags
Eq RemoveKeyFlags
-> (RemoveKeyFlags -> RemoveKeyFlags -> Ordering)
-> (RemoveKeyFlags -> RemoveKeyFlags -> Bool)
-> (RemoveKeyFlags -> RemoveKeyFlags -> Bool)
-> (RemoveKeyFlags -> RemoveKeyFlags -> Bool)
-> (RemoveKeyFlags -> RemoveKeyFlags -> Bool)
-> (RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags)
-> (RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags)
-> Ord RemoveKeyFlags
RemoveKeyFlags -> RemoveKeyFlags -> Bool
RemoveKeyFlags -> RemoveKeyFlags -> Ordering
RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags
$cmin :: RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags
max :: RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags
$cmax :: RemoveKeyFlags -> RemoveKeyFlags -> RemoveKeyFlags
>= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c>= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
> :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c> :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
<= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c<= :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
< :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
$c< :: RemoveKeyFlags -> RemoveKeyFlags -> Bool
compare :: RemoveKeyFlags -> RemoveKeyFlags -> Ordering
$ccompare :: RemoveKeyFlags -> RemoveKeyFlags -> Ordering
$cp1Ord :: Eq RemoveKeyFlags
Ord)