{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Soup.Objects.AuthManager ( -- * Exported types AuthManager(..) , IsAuthManager , toAuthManager , noAuthManager , -- * Methods -- ** clearCachedCredentials #method:clearCachedCredentials# #if ENABLE_OVERLOADING AuthManagerClearCachedCredentialsMethodInfo, #endif authManagerClearCachedCredentials , -- ** useAuth #method:useAuth# #if ENABLE_OVERLOADING AuthManagerUseAuthMethodInfo , #endif authManagerUseAuth , -- * Signals -- ** authenticate #signal:authenticate# AuthManagerAuthenticateCallback , #if ENABLE_OVERLOADING AuthManagerAuthenticateSignalInfo , #endif C_AuthManagerAuthenticateCallback , afterAuthManagerAuthenticate , genClosure_AuthManagerAuthenticate , mk_AuthManagerAuthenticateCallback , noAuthManagerAuthenticateCallback , onAuthManagerAuthenticate , wrap_AuthManagerAuthenticateCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature import {-# SOURCE #-} qualified GI.Soup.Objects.Auth as Soup.Auth import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI -- | Memory-managed wrapper type. newtype AuthManager = AuthManager (ManagedPtr AuthManager) foreign import ccall "soup_auth_manager_get_type" c_soup_auth_manager_get_type :: IO GType instance GObject AuthManager where gobjectType = c_soup_auth_manager_get_type -- | Type class for types which can be safely cast to `AuthManager`, for instance with `toAuthManager`. class (GObject o, O.IsDescendantOf AuthManager o) => IsAuthManager o instance (GObject o, O.IsDescendantOf AuthManager o) => IsAuthManager o instance O.HasParentTypes AuthManager type instance O.ParentTypes AuthManager = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature] -- | Cast to `AuthManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toAuthManager :: (MonadIO m, IsAuthManager o) => o -> m AuthManager toAuthManager = liftIO . unsafeCastTo AuthManager -- | A convenience alias for `Nothing` :: `Maybe` `AuthManager`. noAuthManager :: Maybe AuthManager noAuthManager = Nothing #if ENABLE_OVERLOADING type family ResolveAuthManagerMethod (t :: Symbol) (o :: *) :: * where ResolveAuthManagerMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo ResolveAuthManagerMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo ResolveAuthManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveAuthManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveAuthManagerMethod "clearCachedCredentials" o = AuthManagerClearCachedCredentialsMethodInfo ResolveAuthManagerMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo ResolveAuthManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveAuthManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveAuthManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveAuthManagerMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo ResolveAuthManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveAuthManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveAuthManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveAuthManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveAuthManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveAuthManagerMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo ResolveAuthManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveAuthManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveAuthManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveAuthManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveAuthManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveAuthManagerMethod "useAuth" o = AuthManagerUseAuthMethodInfo ResolveAuthManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveAuthManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveAuthManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveAuthManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveAuthManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveAuthManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveAuthManagerMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveAuthManagerMethod t AuthManager, O.MethodInfo info AuthManager p) => OL.IsLabel t (AuthManager -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal AuthManager::authenticate {- | Emitted when the manager requires the application to provide authentication credentials. 'GI.Soup.Objects.Session.Session' connects to this signal and emits its own 'GI.Soup.Objects.Session.Session'::@/authenticate/@ signal when it is emitted, so you shouldn\'t need to use this signal directly. -} type AuthManagerAuthenticateCallback = Soup.Message.Message {- ^ /@msg@/: the 'GI.Soup.Objects.Message.Message' being sent -} -> Soup.Auth.Auth {- ^ /@auth@/: the 'GI.Soup.Objects.Auth.Auth' to authenticate -} -> Bool {- ^ /@retrying@/: 'True' if this is the second (or later) attempt -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `AuthManagerAuthenticateCallback`@. noAuthManagerAuthenticateCallback :: Maybe AuthManagerAuthenticateCallback noAuthManagerAuthenticateCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_AuthManagerAuthenticateCallback = Ptr () -> -- object Ptr Soup.Message.Message -> Ptr Soup.Auth.Auth -> CInt -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_AuthManagerAuthenticateCallback`. foreign import ccall "wrapper" mk_AuthManagerAuthenticateCallback :: C_AuthManagerAuthenticateCallback -> IO (FunPtr C_AuthManagerAuthenticateCallback) -- | Wrap the callback into a `GClosure`. genClosure_AuthManagerAuthenticate :: MonadIO m => AuthManagerAuthenticateCallback -> m (GClosure C_AuthManagerAuthenticateCallback) genClosure_AuthManagerAuthenticate cb = liftIO $ do let cb' = wrap_AuthManagerAuthenticateCallback cb mk_AuthManagerAuthenticateCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `AuthManagerAuthenticateCallback` into a `C_AuthManagerAuthenticateCallback`. wrap_AuthManagerAuthenticateCallback :: AuthManagerAuthenticateCallback -> C_AuthManagerAuthenticateCallback wrap_AuthManagerAuthenticateCallback _cb _ msg auth retrying _ = do msg' <- (newObject Soup.Message.Message) msg auth' <- (newObject Soup.Auth.Auth) auth let retrying' = (/= 0) retrying _cb msg' auth' retrying' {- | Connect a signal handler for the “@authenticate@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' authManager #authenticate callback @ -} onAuthManagerAuthenticate :: (IsAuthManager a, MonadIO m) => a -> AuthManagerAuthenticateCallback -> m SignalHandlerId onAuthManagerAuthenticate obj cb = liftIO $ do let cb' = wrap_AuthManagerAuthenticateCallback cb cb'' <- mk_AuthManagerAuthenticateCallback cb' connectSignalFunPtr obj "authenticate" cb'' SignalConnectBefore {- | Connect a signal handler for the “@authenticate@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' authManager #authenticate callback @ -} afterAuthManagerAuthenticate :: (IsAuthManager a, MonadIO m) => a -> AuthManagerAuthenticateCallback -> m SignalHandlerId afterAuthManagerAuthenticate obj cb = liftIO $ do let cb' = wrap_AuthManagerAuthenticateCallback cb cb'' <- mk_AuthManagerAuthenticateCallback cb' connectSignalFunPtr obj "authenticate" cb'' SignalConnectAfter #if ENABLE_OVERLOADING instance O.HasAttributeList AuthManager type instance O.AttributeList AuthManager = AuthManagerAttributeList type AuthManagerAttributeList = ('[ ] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING data AuthManagerAuthenticateSignalInfo instance SignalInfo AuthManagerAuthenticateSignalInfo where type HaskellCallbackType AuthManagerAuthenticateSignalInfo = AuthManagerAuthenticateCallback connectSignal _ obj cb connectMode = do let cb' = wrap_AuthManagerAuthenticateCallback cb cb'' <- mk_AuthManagerAuthenticateCallback cb' connectSignalFunPtr obj "authenticate" cb'' connectMode type instance O.SignalList AuthManager = AuthManagerSignalList type AuthManagerSignalList = ('[ '("authenticate", AuthManagerAuthenticateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method AuthManager::clear_cached_credentials -- method type : OrdinaryMethod -- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "Soup", name = "AuthManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_manager_clear_cached_credentials" soup_auth_manager_clear_cached_credentials :: Ptr AuthManager -> -- manager : TInterface (Name {namespace = "Soup", name = "AuthManager"}) IO () {- | Clear all credentials cached by /@manager@/ /Since: 2.58/ -} authManagerClearCachedCredentials :: (B.CallStack.HasCallStack, MonadIO m, IsAuthManager a) => a {- ^ /@manager@/: a 'GI.Soup.Objects.AuthManager.AuthManager' -} -> m () authManagerClearCachedCredentials manager = liftIO $ do manager' <- unsafeManagedPtrCastPtr manager soup_auth_manager_clear_cached_credentials manager' touchManagedPtr manager return () #if ENABLE_OVERLOADING data AuthManagerClearCachedCredentialsMethodInfo instance (signature ~ (m ()), MonadIO m, IsAuthManager a) => O.MethodInfo AuthManagerClearCachedCredentialsMethodInfo a signature where overloadedMethod _ = authManagerClearCachedCredentials #endif -- method AuthManager::use_auth -- method type : OrdinaryMethod -- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "Soup", name = "AuthManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupURI under which @auth is to be used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auth", argType = TInterface (Name {namespace = "Soup", name = "Auth"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupAuth to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_manager_use_auth" soup_auth_manager_use_auth :: Ptr AuthManager -> -- manager : TInterface (Name {namespace = "Soup", name = "AuthManager"}) Ptr Soup.URI.URI -> -- uri : TInterface (Name {namespace = "Soup", name = "URI"}) Ptr Soup.Auth.Auth -> -- auth : TInterface (Name {namespace = "Soup", name = "Auth"}) IO () {- | Records that /@auth@/ is to be used under /@uri@/, as though a WWW-Authenticate header had been received at that URI. This can be used to \"preload\" /@manager@/\'s auth cache, to avoid an extra HTTP round trip in the case where you know ahead of time that a 401 response will be returned. This is only useful for authentication types where the initial Authorization header does not depend on any additional information from the server. (Eg, Basic or NTLM, but not Digest.) /Since: 2.42/ -} authManagerUseAuth :: (B.CallStack.HasCallStack, MonadIO m, IsAuthManager a, Soup.Auth.IsAuth b) => a {- ^ /@manager@/: a 'GI.Soup.Objects.AuthManager.AuthManager' -} -> Soup.URI.URI {- ^ /@uri@/: the 'GI.Soup.Structs.URI.URI' under which /@auth@/ is to be used -} -> b {- ^ /@auth@/: the 'GI.Soup.Objects.Auth.Auth' to use -} -> m () authManagerUseAuth manager uri auth = liftIO $ do manager' <- unsafeManagedPtrCastPtr manager uri' <- unsafeManagedPtrGetPtr uri auth' <- unsafeManagedPtrCastPtr auth soup_auth_manager_use_auth manager' uri' auth' touchManagedPtr manager touchManagedPtr uri touchManagedPtr auth return () #if ENABLE_OVERLOADING data AuthManagerUseAuthMethodInfo instance (signature ~ (Soup.URI.URI -> b -> m ()), MonadIO m, IsAuthManager a, Soup.Auth.IsAuth b) => O.MethodInfo AuthManagerUseAuthMethodInfo a signature where overloadedMethod _ = authManagerUseAuth #endif