{-# LANGUAGE CPP #-}
module Network.HTTP.Proxy
( Proxy(..)
, noProxy
, fetchProxy
, parseProxy
) where
import Control.Monad ( when, mplus, join, liftM2 )
#if defined(WIN32)
import Network.HTTP.Base ( catchIO )
import Control.Monad ( liftM )
import Data.List ( isPrefixOf )
#endif
import Network.HTTP.Utils ( dropWhileTail, chopAtDelim )
import Network.HTTP.Auth
import Network.URI
( URI(..), URIAuth(..), parseAbsoluteURI, unEscapeString )
import System.IO ( hPutStrLn, stderr )
import System.Environment
#if defined(WIN32)
import System.Win32.Types ( DWORD, HKEY )
import System.Win32.Registry( hKEY_CURRENT_USER, regOpenKey, regCloseKey, regQueryValueEx )
import Control.Exception ( bracket )
import Foreign ( toBool, Storable(peek, sizeOf), castPtr, alloca )
#if MIN_VERSION_Win32(2,8,0)
import System.Win32.Registry( regQueryDefaultValue )
#else
import System.Win32.Registry( regQueryValue )
#endif
#endif
data Proxy
= NoProxy
| Proxy String
(Maybe Authority)
noProxy :: Proxy
noProxy :: Proxy
noProxy = Proxy
NoProxy
envProxyString :: IO (Maybe String)
envProxyString :: IO (Maybe [Char])
envProxyString = do
env <- IO [([Char], [Char])]
getEnvironment
return (lookup "http_proxy" env `mplus` lookup "HTTP_PROXY" env)
proxyString :: IO (Maybe String)
proxyString :: IO (Maybe [Char])
proxyString = (Maybe [Char] -> Maybe [Char] -> Maybe [Char])
-> IO (Maybe [Char]) -> IO (Maybe [Char]) -> IO (Maybe [Char])
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe [Char] -> Maybe [Char] -> Maybe [Char]
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus IO (Maybe [Char])
envProxyString IO (Maybe [Char])
windowsProxyString
windowsProxyString :: IO (Maybe String)
#if !defined(WIN32)
windowsProxyString :: IO (Maybe [Char])
windowsProxyString = Maybe [Char] -> IO (Maybe [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Char]
forall a. Maybe a
Nothing
#else
windowsProxyString = liftM (>>= parseWindowsProxy) registryProxyString
registryProxyLoc :: (HKEY,String)
registryProxyLoc = (hive, path)
where
hive = hKEY_CURRENT_USER
path = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"
registryProxyString :: IO (Maybe String)
registryProxyString = catchIO
(bracket (uncurry regOpenKey registryProxyLoc) regCloseKey $ \hkey -> do
enable <- fmap toBool $ regQueryValueDWORD hkey "ProxyEnable"
if enable
#if MIN_VERSION_Win32(2,8,0)
then fmap Just $ regQueryDefaultValue hkey "ProxyServer"
#elif MIN_VERSION_Win32(2,6,0)
then fmap Just $ regQueryValue hkey "ProxyServer"
#else
then fmap Just $ regQueryValue hkey (Just "ProxyServer")
#endif
else return Nothing)
(\_ -> return Nothing)
parseWindowsProxy :: String -> Maybe String
parseWindowsProxy s =
case proxies of
x:_ -> Just x
_ -> Nothing
where
parts = split ';' s
pr x = case break (== '=') x of
(p, []) -> p
(p, u) -> p ++ "://" ++ drop 1 u
proxies = filter (isPrefixOf "http://") . map pr $ parts
split :: Eq a => a -> [a] -> [[a]]
split _ [] = []
split a xs = case break (a ==) xs of
(ys, []) -> [ys]
(ys, _:zs) -> ys:split a zs
#endif
fetchProxy :: Bool -> IO Proxy
fetchProxy :: Bool -> IO Proxy
fetchProxy Bool
warnIfIllformed = do
mstr <- IO (Maybe [Char])
proxyString
case mstr of
Maybe [Char]
Nothing -> Proxy -> IO Proxy
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Proxy
NoProxy
Just [Char]
str -> case [Char] -> Maybe Proxy
parseProxy [Char]
str of
Just Proxy
p -> Proxy -> IO Proxy
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Proxy
p
Maybe Proxy
Nothing -> do
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
warnIfIllformed (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ Handle -> [Char] -> IO ()
System.IO.hPutStrLn Handle
System.IO.stderr ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
[ [Char]
"invalid http proxy uri: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
str
, [Char]
"proxy uri must be http with a hostname"
, [Char]
"ignoring http proxy, trying a direct connection"
]
Proxy -> IO Proxy
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Proxy
NoProxy
parseProxy :: String -> Maybe Proxy
parseProxy :: [Char] -> Maybe Proxy
parseProxy [Char]
"" = Maybe Proxy
forall a. Maybe a
Nothing
parseProxy [Char]
str = Maybe (Maybe Proxy) -> Maybe Proxy
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join
(Maybe (Maybe Proxy) -> Maybe Proxy)
-> (Maybe URI -> Maybe (Maybe Proxy)) -> Maybe URI -> Maybe Proxy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (URI -> Maybe Proxy) -> Maybe URI -> Maybe (Maybe Proxy)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap URI -> Maybe Proxy
uri2proxy
(Maybe URI -> Maybe Proxy) -> Maybe URI -> Maybe Proxy
forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe URI
parseHttpURI [Char]
str
Maybe URI -> Maybe URI -> Maybe URI
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` [Char] -> Maybe URI
parseHttpURI ([Char]
"http://" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
str)
where
parseHttpURI :: [Char] -> Maybe URI
parseHttpURI [Char]
str' =
case [Char] -> Maybe URI
parseAbsoluteURI [Char]
str' of
Just uri :: URI
uri@URI{uriAuthority :: URI -> Maybe URIAuth
uriAuthority = Just{}} -> URI -> Maybe URI
forall a. a -> Maybe a
Just (URI -> URI
fixUserInfo URI
uri)
Maybe URI
_ -> Maybe URI
forall a. Maybe a
Nothing
fixUserInfo :: URI -> URI
fixUserInfo :: URI -> URI
fixUserInfo URI
uri = URI
uri{ uriAuthority = f `fmap` uriAuthority uri }
where
f :: URIAuth -> URIAuth
f a :: URIAuth
a@URIAuth{uriUserInfo :: URIAuth -> [Char]
uriUserInfo=[Char]
s} = URIAuth
a{uriUserInfo=dropWhileTail (=='@') s}
uri2proxy :: URI -> Maybe Proxy
uri2proxy :: URI -> Maybe Proxy
uri2proxy uri :: URI
uri@URI{ uriScheme :: URI -> [Char]
uriScheme = [Char]
"http:"
, uriAuthority :: URI -> Maybe URIAuth
uriAuthority = Just (URIAuth [Char]
auth' [Char]
hst [Char]
prt)
} =
Proxy -> Maybe Proxy
forall a. a -> Maybe a
Just ([Char] -> Maybe Authority -> Proxy
Proxy ([Char]
hst [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
prt) Maybe Authority
auth)
where
auth :: Maybe Authority
auth =
case [Char]
auth' of
[] -> Maybe Authority
forall a. Maybe a
Nothing
[Char]
as -> Authority -> Maybe Authority
forall a. a -> Maybe a
Just ([Char] -> [Char] -> [Char] -> URI -> Authority
AuthBasic [Char]
"" ([Char] -> [Char]
unEscapeString [Char]
usr) ([Char] -> [Char]
unEscapeString [Char]
pwd) URI
uri)
where
([Char]
usr,[Char]
pwd) = Char -> [Char] -> ([Char], [Char])
forall a. Eq a => a -> [a] -> ([a], [a])
chopAtDelim Char
':' [Char]
as
uri2proxy URI
_ = Maybe Proxy
forall a. Maybe a
Nothing
#if defined(WIN32)
regQueryValueDWORD :: HKEY -> String -> IO DWORD
regQueryValueDWORD hkey name = alloca $ \ptr -> do
_ <- regQueryValueEx hkey name (castPtr ptr) (sizeOf (undefined :: DWORD))
peek ptr
#endif