1 files changed, 8 insertions, 127 deletions

diff --git a/lib/Transforms.hs b/lib/Transforms.hs
index 0a3a9a6..edc18bb 100644
--- a/lib/Transforms.hs
+++ b/lib/Transforms.hs
@@ -22,7 +22,6 @@ import FunctorToMaybe
 import GnuPGAgent ( key_nbits )
 import PacketTranscoder
 import TimeUtil
-import qualified Data.Traversable as Traversable
 import qualified Data.ByteString      as S
 import qualified Data.ByteString.Lazy as L
 import qualified Data.ByteString.Lazy.Char8 as Char8
@@ -120,25 +119,6 @@ data UserIDRecord = UserIDRecord {
 }
  deriving Show
 
-data PGPKeyFlags =
-    Special
-    | Vouch                  -- 0001 C -- Signkey
-    | Sign                   -- 0010 S
-    | VouchSign              -- 0011
-    | Communication          -- 0100 E
-    | VouchCommunication     -- 0101
-    | SignCommunication      -- 0110
-    | VouchSignCommunication -- 0111
-    | Storage                -- 1000 E
-    | VouchStorage           -- 1001
-    | SignStorage            -- 1010
-    | VouchSignStorage       -- 1011
-    | Encrypt                -- 1100 E
-    | VouchEncrypt           -- 1101
-    | SignEncrypt            -- 1110
-    | VouchSignEncrypt       -- 1111
- deriving (Eq,Show,Read,Enum)
-
 
 
 -- Functions
@@ -235,18 +215,6 @@ mkUsage tag = NotationDataPacket
                 }
 
 
-unk :: Bool -> MappedPacket -> MappedPacket
-unk isPublic = if isPublic then toPacket secretToPublic else id
-                where toPacket f mp@(MappedPacket {packet=p}) = mp {packet=(f p)}
-
-
-unsig :: FilePath -> Bool -> SigAndTrust -> [MappedPacket]
-unsig fname isPublic (sig,trustmap) =
-    sig : map (asMapped (-1)) ( take 1 . Map.elems $ Map.filterWithKey f trustmap)
-  where
-    f n _ = n==fname -- && trace ("fname=n="++show n) True
-    asMapped n p = let m = mappedPacket fname p
-                   in m { locations = fmap (\x->x {originalNum=n}) (locations m) }
 
 smallpr :: Packet -> [Char]
 smallpr k = drop 24 $ fingerprint k
@@ -360,34 +328,6 @@ accBindings bs = as
             (bc,_,bkind,bhashed,bclaimaints)
         = (ac .|. bc,p,akind++bkind,ahashed++bhashed,aclaimaints++bclaimaints)
 
-sortByHint :: FilePath -> (a -> MappedPacket) -> [a] -> [a]
-sortByHint fname f = sortBy (comparing gethint)
-  where
-    gethint = maybe defnum originalNum . Map.lookup fname . locations . f
-    defnum = -1
-
-concatSort ::
-  FilePath -> ([a] -> MappedPacket) -> (b -> [a]) -> [b] -> [a]
-concatSort fname getp f = concat . sortByHint fname getp . map f
-
-flattenUid :: FilePath -> Bool -> (String,([SigAndTrust],OriginMap)) -> [MappedPacket]
-flattenUid fname ispub (str,(sigs,om)) =
-    (mappedPacket "" $ UserIDPacket str) {locations=om} : concatSort fname head (unsig fname ispub) sigs
-
-flattenSub :: FilePath -> Bool -> SubKey -> [MappedPacket]
-flattenSub fname ispub (SubKey key sigs) = unk ispub key: concatSort fname head (unsig fname ispub) sigs
-
-flattenAllUids :: FilePath -> Bool -> Map.Map String ([SigAndTrust],OriginMap) -> [MappedPacket]
-flattenAllUids fname ispub uids =
-    concatSort fname head (flattenUid fname ispub) (Map.assocs uids)
-
-flattenTop :: FilePath -> Bool -> KeyData -> [MappedPacket]
-flattenTop fname ispub (KeyData key sigs uids subkeys) =
-    unk ispub key :
-            ( flattenAllUids fname ispub uids
-             ++ concatSort fname head (flattenSub fname ispub) (Map.elems subkeys))
-
-
 sigpackets ::
   Monad m =>
   Word8 -> [SignatureSubpacket] -> [SignatureSubpacket] -> m Packet
@@ -407,72 +347,11 @@ sigpackets typ hashed unhashed = return $
 keyFlags :: t -> [Packet] -> [SignatureSubpacket]
 keyFlags  wkun uids = keyFlags0 wkun (filter isSignaturePacket uids)
 
--- XXX keyFlags and keyflags are different functions.
-keyflags :: SignatureSubpacket -> Maybe PGPKeyFlags
-keyflags flgs@(KeyFlagsPacket {}) =
-    Just . toEnum $
-        (   bit 0x1 certify_keys
-        .|. bit 0x2 sign_data
-        .|. bit 0x4 encrypt_communication
-        .|. bit 0x8 encrypt_storage )     :: Maybe PGPKeyFlags
-    -- other flags:
-    --  split_key
-    --  authentication (ssh-client)
-    --  group_key
- where
-    bit v f = if f flgs then v else 0
-keyflags _ = Nothing
-
-
-
-secretToPublic :: Packet -> Packet
-secretToPublic pkt@(SecretKeyPacket {}) =
-    PublicKeyPacket { version = version pkt
-                    , timestamp = timestamp pkt
-                    , key_algorithm = key_algorithm pkt
-                    -- , ecc_curve = ecc_curve pkt
-                    , key = let seckey = key pkt
-                                pubs = public_key_fields (key_algorithm pkt)
-                            in filter (\(k,v) -> k `elem` pubs) seckey
-                    , is_subkey = is_subkey pkt
-                    , v3_days_of_validity = Nothing
-                    }
-secretToPublic pkt = pkt
-
-
-
-uidkey :: Packet -> String
-uidkey (UserIDPacket str) = str
-
-usageString :: PGPKeyFlags -> String
-usageString flgs =
- case flgs of
-    Special                -> "special"
-    Vouch                  -> "vouch" -- signkey
-    Sign                   -> "sign"
-    VouchSign              -> "vouch-sign"
-    Communication          -> "communication"
-    VouchCommunication     -> "vouch-communication"
-    SignCommunication      -> "sign-communication"
-    VouchSignCommunication -> "vouch-sign-communication"
-    Storage                -> "storage"
-    VouchStorage           -> "vouch-storage"
-    SignStorage            -> "sign-storage"
-    VouchSignStorage       -> "vouch-sign-storage"
-    Encrypt                -> "encrypt"
-    VouchEncrypt           -> "vouch-encrypt"
-    SignEncrypt            -> "sign-encrypt"
-    VouchSignEncrypt       -> "vouch-sign-encrypt"
-
-
-
-usage :: SignatureSubpacket -> Maybe String
-usage (NotationDataPacket
-        { human_readable = True
-        , notation_name  = "usage@"
-        , notation_value = u
-        }) = Just u
-usage _    = Nothing
+
+
+
+
+
 
 
 ifSecret :: Packet -> t -> t -> t
@@ -487,7 +366,7 @@ showPacket p | isKey p   = (if is_subkey p
                            ++ " "++fingerprint p
                            ++ " "++show (key_algorithm p)
                            ++ case key_nbits p of { 0 -> ""; n -> "("++show n++")" }
-             | isUserID p          = showPacket0 p ++ " " ++ show (uidkey p)
+             | Just uid <- isUserID p  = showPacket0 p ++ " " ++ show uid
              --  isSignaturePacket p = showPacket0 p ++ maybe "" ((++) (" ^ signed"++sigusage p++": ")) (signature_issuer p)
              | isSignaturePacket p = showPacket0 p ++ maybe "" (" ^ signed: "++) (signature_issuer p) ++ sigusage p
              | otherwise           = showPacket0 p
@@ -721,8 +600,10 @@ makeSig doDecrypt top fname subkey_p tags mbsig = do
         (es,qs) = partition isExpiration ps
         stamp = listToMaybe . sortBy (comparing Down) $
                  map unwrap cs where unwrap (SignatureCreationTimePacket x) = x
+                                     unwrap _ = error "isCreation fail"
         exp = listToMaybe $ sort $
                  map unwrap es where unwrap (SignatureExpirationTimePacket x) = x
+                                     unwrap _ = error "isExpiration fail"
         expires = liftA2 (+) stamp exp
     timestamp <- now
     if fmap ( (< timestamp) . fromIntegral) expires == Just True then