use a type for the return value of getHostnames

4 files changed, 30 insertions, 16 deletions

diff --git a/kiki.hs b/kiki.hs
index 47462a7..cd0f516 100644
--- a/kiki.hs
+++ b/kiki.hs
@@ -1665,7 +1665,7 @@ tarContent rt spec pubpem knownhosts secpem = ipsecs ++ sshs ++ secrets "root"
     ipsecs = do
         (kk,ipsec,sigs) <- selectPublicKeyAndSigs (KeyUidMatch "",Just "ipsec") (rtKeyDB rt)
         let kd = (rtKeyDB rt Map.! kk)
-            (addr,(onames,ns)) = getHostnames kd
+            Hostnames addr onames ns _ = getHostnames kd
         oname <- onames
         return ("etc/ipsec.d/certs/" ++ Char8.unpack oname ++ ".pem", pubpem ns addr ipsec sigs)
 
@@ -1698,10 +1698,15 @@ tarContent rt spec pubpem knownhosts secpem = ipsecs ++ sshs ++ secrets "root"
             sshsvr = spem (dir "etc/ssh/ssh_host_rsa_key") <$> lookupSecret "ssh-host" kd
             ipseckey = do
                 k <- lookupSecret "ipsec" kd
-                oname <- fst . snd $ getHostnames kd
-                return $ spem (dir $ "etc/ipsec.d/private/"++Char8.unpack oname++".pem") k
+                keyName <- ipsecKeyNames (getHostnames kd)
+                return $ spem (dir $ keyName) k
         torkey ++ sshcli ++ sshsvr ++ ipseckey
 
+ipsecKeyNames :: Hostnames -> [String]
+ipsecKeyNames (Hostnames _ onames _ _) = do
+  oname <- Char8.unpack <$> onames
+  return $ "etc/ipsec.d/private/"++oname++".pem"
+
 tarT :: ([[String]],Map.Map String [String]) -> IO ()
 tarT (sargs,margs) = do
     KikiResult rt report <- runKeyRing $ minimalOp $ parseCommonArgs margs
@@ -1747,7 +1752,7 @@ tarC (sargs,margs) = do
         knownhost (kk,hostkey,sigs) = Char8.intercalate "," ns <> " " <> Char8.pack (sshblobFromPacket hostkey)
          where
             ns = onames ++ others
-            (_,(onames,others)) = getHostnames $ rtKeyDB rt Map.! kk
+            Hostnames _ onames others _ = getHostnames $ rtKeyDB rt Map.! kk
 
     build_secret :: Num t => KeyRingRuntime  -> Packet -> (t, Either (IO (Maybe Char8.ByteString)) b)
     build_secret rt k = ( fromIntegral $ timestamp k
diff --git a/lib/KeyRing.hs b/lib/KeyRing.hs
index 5cdb30c..8b041f1 100644
--- a/lib/KeyRing.hs
+++ b/lib/KeyRing.hs
@@ -582,7 +582,7 @@ writeHostsFiles
      -> ([Hosts.Hosts],
          [Hosts.Hosts],
          Hosts.Hosts,
-         [(SockAddr, (t1, [Char8.ByteString]))],
+         [Hostnames],
          [SockAddr])
      -> IO [(FilePath, KikiReportAction)]
 writeHostsFiles krd ctx (hostdbs0,hostdbs,u1,gpgnames,outgoing_names) = do
@@ -598,7 +598,7 @@ writeHostsFiles krd ctx (hostdbs0,hostdbs,u1,gpgnames,outgoing_names) = do
     -- 3. add hostnames from gpg for addresses not in U
     let u = foldl' f u1 ans
         ans = reverse $ do
-            (addr,(_,ns)) <- gpgnames
+            Hostnames addr _ ns _ <- gpgnames
             guard $ addr `elem` outgoing_names -- . null $ Hosts.namesForAddress addr u0
             n <- ns
             return (addr,n)
diff --git a/lib/KeyRing/BuildKeyDB.hs b/lib/KeyRing/BuildKeyDB.hs
index 9a806a3..f90f638 100644
--- a/lib/KeyRing/BuildKeyDB.hs
+++ b/lib/KeyRing/BuildKeyDB.hs
@@ -132,7 +132,7 @@ buildKeyDB :: InputFileContext -> Maybe String -> KeyRingOperation
                                     ,{- hs        -} ({- hostdbs0 -}[Hosts.Hosts],
                                                       {- hostdbs  -}[Hosts.Hosts],
                                                       {- u1       -}Hosts.Hosts,
-                                                      {- gpgnames -}[(SockAddr, ([ByteString],[ByteString]))],
+                                                      {- gpgnames -}[Hostnames],
                                                       {- outgoing_names -}[SockAddr])
                                     ,{- accs      -} Map.Map InputFile Access
                                     ,{- transcode -} PacketTranscoder
@@ -564,7 +564,7 @@ mergeHostFiles :: KeyRingOperation -> KeyDB -> InputFileContext
                , ( [Hosts.Hosts]
                  , [Hosts.Hosts]
                  , Hosts.Hosts
-                 , [(SockAddr, ([Char8.ByteString], [Char8.ByteString]))]
+                 , [Hostnames]
                  , [SockAddr]))
              , [(FilePath,KikiReportAction)]))
 mergeHostFiles krd db ctx = do
@@ -586,14 +586,14 @@ mergeHostFiles krd db ctx = do
 
     let gpgnames = map getHostnames $ Map.elems db
         os = do
-            (addr,(ns,_)) <- gpgnames
+            Hostnames addr ns _ _ <- gpgnames
             n <- ns
             return (addr,n)
         setOnions hosts = foldl' (flip $ uncurry Hosts.assignName) hosts os
         -- we ensure .onion names are set properly
         hostdbs = map setOnions hostdbs0
         outgoing_names = do
-            (addr,(_,gns)) <- gpgnames
+            Hostnames addr _ gns _ <- gpgnames
             guard . not $ null gns
             guard $ all (null . Hosts.namesForAddress addr) hostdbs0
             return addr
@@ -902,13 +902,20 @@ generateSubkey transcode kd' (genparam,StreamInfo { spill = KF_Match tag }) = do
         return $ KikiSuccess (kd,report0)
 generateSubkey _ kd _ = return kd
 
+data Hostnames = Hostnames {
+  gpgipv6addr :: SockAddr,
+  verifiedOnionNames :: [L.ByteString],
+  notationPacketNames :: [L.ByteString],
+  cryptonomicName :: Maybe L.ByteString
+}
+
 -- |
 -- Returns (ip6 fingerprint address,(onion names,other host names))
 --
 -- Requires a validly cross-signed tor key for each onion name returned.
 -- (Signature checks are performed.)
-getHostnames :: KeyData -> (SockAddr, ([L.ByteString],[L.ByteString]))
-getHostnames (KeyData topmp _ uids subs) = (addr,(onames,othernames))
+getHostnames :: KeyData -> Hostnames
+getHostnames (KeyData topmp _ uids subs) = Hostnames addr onames othernames Nothing
  where
     othernames = do
         mp <- flattenAllUids "" True uids
@@ -966,7 +973,9 @@ setHostnames pred hosts kd@(KeyData topmp topsigs uids subs) =
     addr = fingerdress topk
     names :: [Char8.ByteString]
     names                          = Hosts.namesForAddress addr hosts
-    (_, (gotOnions, gotNonOnions)) = getHostnames kd
+
+    Hostnames _ gotOnions gotNonOnions cryptonomic = getHostnames kd
+
     namesWithoutGotOnions          = names \\ gotOnions
     notations                      = map (NotationDataPacket True "hostname@" . Char8.unpack) namesWithoutGotOnions
     isName (NotationDataPacket True "hostname@" _) = True
diff --git a/lib/Kiki.hs b/lib/Kiki.hs
index ca6e80f..8ceda99 100644
--- a/lib/Kiki.hs
+++ b/lib/Kiki.hs
@@ -431,7 +431,7 @@ generateHostsFile mkpath rt = do
     KikiResult _ report <- runKeyRing op
     outputReport report
 
-names :: KeyRingRuntime -> Maybe (SockAddr, ([Char8.ByteString], [Char8.ByteString]))
+names :: KeyRingRuntime -> Maybe Hostnames
 names rt = do wk <- rtWorkingKey rt
               -- XXX unnecessary signature check
               return $ getHostnames (rtKeyDB rt Map.! keykey wk)
@@ -478,7 +478,7 @@ refreshCache rt rootdir = do
     (mkpath, commit) <- getMkPathAndCommit (fromMaybe "" rootdir ++ "/var/cache/kiki/config")
     generateHostsFile mkpath rt
     fromMaybe (error "No working key.") $ do
-    (wkaddr,(onames,_)) <- names rt
+    Hostnames wkaddr onames _ _ <- names rt
     Just $ do
     let oname = Char8.concat $ take 1 onames
         bUnprivileged = False -- TODO
@@ -535,7 +535,7 @@ writePublicKeyFiles rt mkpath grip oname wkaddr commit = do
         namedContact kd = do
             -- The getHostnames command requires a valid cross-signed tor key
             -- for each onion name returned in (_,(ns,_)).
-            let (addr,(ns,_)) = getHostnames kd
+            let Hostnames addr ns _ _ = getHostnames kd
             fmap (\n -> (n,addr, kd)) $ listToMaybe ns -- only first onion name.
 
         known_hosts = L.concat $ map getssh onionkeys