Propagate StreamInfo information (untested.)

1 files changed, 22 insertions, 22 deletions

diff --git a/KeyRing.hs b/KeyRing.hs
index 0c1fc2a..b164527 100644
--- a/KeyRing.hs
+++ b/KeyRing.hs
@@ -278,7 +278,8 @@ data KeyFilter = KF_None -- ^ No keys will be imported.
   deriving (Eq,Ord,Show)
 
 -- | This type describes how 'runKeyRing' will treat a file.
-data StreamInfo = StreamInfo { access :: Access
+data StreamInfo = StreamInfo
+    { access :: Access
     -- ^ Indicates whether the file is allowed to contain secret information.
     , typ :: FileType
     -- ^ Indicates the format and content type of the file.
@@ -1290,7 +1291,7 @@ importSecretKey ::
   (MappedPacket -> IO (KikiCondition Packet))
   -> KikiCondition
        (Map.Map KeyKey KeyData, [(FilePath, KikiReportAction)])
-  -> (FilePath, Maybe [Char], [KeyKey], FileType, t)
+  -> (FilePath, Maybe [Char], [KeyKey], StreamInfo, t)
   -> IO (KikiCondition (Map.Map KeyKey KeyData, [(FilePath, KikiReportAction)]))
 importSecretKey doDecrypt db' tup = do
             try db' $ \(db',report0) -> do
@@ -1534,7 +1535,7 @@ buildKeyDB ctx grip0 keyring = do
             let (topspec,subspec) = parseSpec grip usage
                 ms = map fst $ filterMatches topspec (Map.toList db)
                 cmd = initializer stream
-            return (n,subspec,ms,typ stream, cmd)
+            return (n,subspec,ms,stream, cmd)
     imports <- filterM (\(n,_,_,_,_) -> doesFileExist n) pems
     db <- foldM (importSecretKey doDecrypt) (KikiSuccess (db,[])) imports
     try db $ \(db,reportPEMs) -> do
@@ -1769,9 +1770,9 @@ doImport
   :: Ord k =>
      (MappedPacket -> IO (KikiCondition Packet))
      -> Map.Map k KeyData
-     -> (FilePath, Maybe [Char], [k], FileType, t)
+     -> (FilePath, Maybe [Char], [k], StreamInfo, t)
      -> IO (KikiCondition (Map.Map k KeyData, [(FilePath,KikiReportAction)]))
-doImport doDecrypt db (fname,subspec,ms,typ,_) = do
+doImport doDecrypt db (fname,subspec,ms,typ -> typ,_) = do
     flip (maybe $ return CannotImportMasterKey)
          subspec $ \tag -> do
     (certs,keys) <- case typ of
@@ -2224,23 +2225,23 @@ writeKeyToFile False DNSPresentation fname packet = do
 
 writePEMKeys :: (MappedPacket -> IO (KikiCondition Packet))
                 -> KeyDB
-                -> [(FilePath,Maybe String,[MappedPacket],FileType,Maybe Initializer)]
+                -> [(FilePath,Maybe String,[MappedPacket],StreamInfo)]
                 -> IO (KikiCondition [(FilePath,KikiReportAction)])
 writePEMKeys doDecrypt db exports = do
     ds <- mapM decryptKeys exports
     let ds' = map functorToEither ds
     if null (lefts ds')
         then do
-            rs <- mapM (\(f,typ,p) -> writeKeyToFile False typ (ArgFile f) p)
+            rs <- mapM (\(f,stream,p) -> writeKeyToFile False (typ stream) (ArgFile f) p)
                        (rights ds')
             return $ KikiSuccess (map (first $ resolveForReport Nothing) $ concat rs)
         else do
             return (head $ lefts ds')
  where
-    decryptKeys (fname,subspec,[p],typ,_) = do
+    decryptKeys (fname,subspec,[p],stream) = do
         pun <- doDecrypt p
         try pun $ \pun -> do
-        return $ KikiSuccess (fname,typ,pun)
+        return $ KikiSuccess (fname,stream,pun)
 
 makeMemoizingDecrypter :: KeyRingOperation -> InputFileContext
                         -> Map.Map KeyKey MappedPacket
@@ -2392,8 +2393,7 @@ initializeMissingPEMFiles ::
       -> IO (KikiCondition ( (KeyDB,[( FilePath
                                      , Maybe String
                                      , [MappedPacket]
-                                     , FileType
-                                     , Maybe Initializer)])
+                                     , StreamInfo )])
                            , [(FilePath,KikiReportAction)]))
 initializeMissingPEMFiles operation ctx grip decrypt db = do
         nonexistents <-
@@ -2402,7 +2402,7 @@ initializeMissingPEMFiles operation ctx grip decrypt db = do
                     f <- resolveInputFile ctx f
                     return (f,t)
 
-        let (missing,notmissing) = partition (\(_,_,ns,_,_)->null (ns >>= snd)) $ do
+        let (missing,notmissing) = partition (\(_,_,ns,_)->null (ns >>= snd)) $ do
                 (fname,stream) <- nonexistents
                 guard $ isMutable stream
                 guard $ isSecretKeyFile (typ stream)
@@ -2415,12 +2415,12 @@ initializeMissingPEMFiles operation ctx grip decrypt db = do
                     ns = do
                        (kk,kd) <- filterMatches topspec $ Map.toList db
                        return (kk , subkeysForExport subspec kd)
-                return (fname,subspec,ns,(typ stream),initializer stream)
-            (exports0,ambiguous) = partition (\(_,_,ns,_,_)->null $ drop 1 $ (ns>>=snd))
+                return (fname,subspec,ns,stream)
+            (exports0,ambiguous) = partition (\(_,_,ns,_)->null $ drop 1 $ (ns>>=snd))
                                              notmissing
-            exports = map (\(f,subspec,ns,typ,cmd) -> (f,subspec,ns >>= snd,typ,cmd)) exports0
+            exports = map (\(f,subspec,ns,stream) -> (f,subspec,ns >>= snd,stream)) exports0
 
-            ambiguity (f,topspec,subspec,_,_) = do
+            ambiguity (f,topspec,subspec,_) = do
                return $ AmbiguousKeySpec f
 
             ifnotnull (x:xs) f g = f x
@@ -2432,10 +2432,10 @@ initializeMissingPEMFiles operation ctx grip decrypt db = do
         do
            let cmds = mapMaybe getcmd missing
                  where
-                   getcmd (fname,subspec,ms,typ,mcmd) = do
-                       cmd <- mcmd
-                       return (fname,subspec,ms,typ,cmd)
-           rs <- forM cmds $ \tup@(fname,subspec,ms,typ,cmd) -> do
+                   getcmd (fname,subspec,ms,stream) = do
+                       cmd <- initializer stream
+                       return (fname,subspec,ms,stream,cmd)
+           rs <- forM cmds $ \tup@(fname,subspec,ms,stream,cmd) -> do
                e <- systemEnv [ ("file",fname)
                               , ("usage",fromMaybe "" subspec) ]
                               cmd
@@ -2445,11 +2445,11 @@ initializeMissingPEMFiles operation ctx grip decrypt db = do
 
            v <- foldM (importSecretKey decrypt)
                       (KikiSuccess (db,[])) $ do
-                    ((f,subspec,ms,typ,cmd),r) <- rs
+                    ((f,subspec,ms,stream,cmd),r) <- rs
                     guard $ case r of
                        ExternallyGeneratedFile -> True
                        _ -> False
-                    return (f,subspec,map fst ms,typ,cmd)
+                    return (f,subspec,map fst ms,stream,cmd)
 
            try v $ \(db,import_rs) -> do
            return $ KikiSuccess ((db,exports), map (\((f,_,_,_,_),r)->(f,r)) rs