464 lines
12 KiB
C#
464 lines
12 KiB
C#
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
|
|
namespace CPF.Mac.Foundation
|
|
{
|
|
[Register("NSURLProtectionSpace", true)]
|
|
public class NSUrlProtectionSpace : NSObject
|
|
{
|
|
private static readonly IntPtr selRealmHandle = Selector.GetHandle("realm");
|
|
|
|
private static readonly IntPtr selReceivesCredentialSecurelyHandle = Selector.GetHandle("receivesCredentialSecurely");
|
|
|
|
private static readonly IntPtr selIsProxyHandle = Selector.GetHandle("isProxy");
|
|
|
|
private static readonly IntPtr selHostHandle = Selector.GetHandle("host");
|
|
|
|
private static readonly IntPtr selPortHandle = Selector.GetHandle("port");
|
|
|
|
private static readonly IntPtr selProxyTypeHandle = Selector.GetHandle("proxyType");
|
|
|
|
private static readonly IntPtr selProtocolHandle = Selector.GetHandle("protocol");
|
|
|
|
private static readonly IntPtr selAuthenticationMethodHandle = Selector.GetHandle("authenticationMethod");
|
|
|
|
private static readonly IntPtr selDistinguishedNamesHandle = Selector.GetHandle("distinguishedNames");
|
|
|
|
private static readonly IntPtr selServerTrustHandle = Selector.GetHandle("serverTrust");
|
|
|
|
private static readonly IntPtr selInitWithHostPortProtocolRealmAuthenticationMethod_Handle = Selector.GetHandle("initWithHost:port:protocol:realm:authenticationMethod:");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSURLProtectionSpace");
|
|
|
|
private object __mt_DistinguishedNames_var;
|
|
|
|
private static NSString _HTTP;
|
|
|
|
private static NSString _HTTPS;
|
|
|
|
private static NSString _FTP;
|
|
|
|
private static NSString _HTTPProxy;
|
|
|
|
private static NSString _HTTPSProxy;
|
|
|
|
private static NSString _FTPProxy;
|
|
|
|
private static NSString _SOCKSProxy;
|
|
|
|
private static NSString _AuthenticationMethodDefault;
|
|
|
|
private static NSString _AuthenticationMethodHTTPBasic;
|
|
|
|
private static NSString _AuthenticationMethodHTTPDigest;
|
|
|
|
private static NSString _AuthenticationMethodHTMLForm;
|
|
|
|
private static NSString _AuthenticationMethodNTL;
|
|
|
|
private static NSString _AuthenticationMethodNegotiat;
|
|
|
|
private static NSString _AuthenticationMethodClientCertificate;
|
|
|
|
private static NSString _AuthenticationMethodServerTrus;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public virtual string Realm
|
|
{
|
|
[Export("realm")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selRealmHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selRealmHandle));
|
|
}
|
|
}
|
|
|
|
public virtual bool ReceivesCredentialSecurely
|
|
{
|
|
[Export("receivesCredentialSecurely")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selReceivesCredentialSecurelyHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selReceivesCredentialSecurelyHandle);
|
|
}
|
|
}
|
|
|
|
public virtual bool IsProxy
|
|
{
|
|
[Export("isProxy")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selIsProxyHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selIsProxyHandle);
|
|
}
|
|
}
|
|
|
|
public virtual string Host
|
|
{
|
|
[Export("host")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selHostHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selHostHandle));
|
|
}
|
|
}
|
|
|
|
public virtual long Port
|
|
{
|
|
[Export("port")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.Int64_objc_msgSend(base.Handle, selPortHandle);
|
|
}
|
|
return Messaging.Int64_objc_msgSendSuper(base.SuperHandle, selPortHandle);
|
|
}
|
|
}
|
|
|
|
public virtual string ProxyType
|
|
{
|
|
[Export("proxyType")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selProxyTypeHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selProxyTypeHandle));
|
|
}
|
|
}
|
|
|
|
public virtual string Protocol
|
|
{
|
|
[Export("protocol")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selProtocolHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selProtocolHandle));
|
|
}
|
|
}
|
|
|
|
public virtual string AuthenticationMethod
|
|
{
|
|
[Export("authenticationMethod")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSend(base.Handle, selAuthenticationMethodHandle));
|
|
}
|
|
return NSString.FromHandle(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selAuthenticationMethodHandle));
|
|
}
|
|
}
|
|
|
|
public virtual NSData[] DistinguishedNames
|
|
{
|
|
[Export("distinguishedNames")]
|
|
get
|
|
{
|
|
return (NSData[])(__mt_DistinguishedNames_var = ((!IsDirectBinding) ? NSArray.ArrayFromHandle<NSData>(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selDistinguishedNamesHandle)) : NSArray.ArrayFromHandle<NSData>(Messaging.IntPtr_objc_msgSend(base.Handle, selDistinguishedNamesHandle))));
|
|
}
|
|
}
|
|
|
|
public virtual IntPtr ServerTrust
|
|
{
|
|
[Export("serverTrust")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.IntPtr_objc_msgSend(base.Handle, selServerTrustHandle);
|
|
}
|
|
return Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selServerTrustHandle);
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceHTTP", "Foundation")]
|
|
public static NSString HTTP
|
|
{
|
|
get
|
|
{
|
|
if (_HTTP == null)
|
|
{
|
|
_HTTP = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceHTTP");
|
|
}
|
|
return _HTTP;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceHTTPS", "Foundation")]
|
|
public static NSString HTTPS
|
|
{
|
|
get
|
|
{
|
|
if (_HTTPS == null)
|
|
{
|
|
_HTTPS = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceHTTPS");
|
|
}
|
|
return _HTTPS;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceFTP", "Foundation")]
|
|
public static NSString FTP
|
|
{
|
|
get
|
|
{
|
|
if (_FTP == null)
|
|
{
|
|
_FTP = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceFTP");
|
|
}
|
|
return _FTP;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceHTTPProxy", "Foundation")]
|
|
public static NSString HTTPProxy
|
|
{
|
|
get
|
|
{
|
|
if (_HTTPProxy == null)
|
|
{
|
|
_HTTPProxy = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceHTTPProxy");
|
|
}
|
|
return _HTTPProxy;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceHTTPSProxy", "Foundation")]
|
|
public static NSString HTTPSProxy
|
|
{
|
|
get
|
|
{
|
|
if (_HTTPSProxy == null)
|
|
{
|
|
_HTTPSProxy = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceHTTPSProxy");
|
|
}
|
|
return _HTTPSProxy;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceFTPProxy", "Foundation")]
|
|
public static NSString FTPProxy
|
|
{
|
|
get
|
|
{
|
|
if (_FTPProxy == null)
|
|
{
|
|
_FTPProxy = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceFTPProxy");
|
|
}
|
|
return _FTPProxy;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLProtectionSpaceSOCKSProxy", "Foundation")]
|
|
public static NSString SOCKSProxy
|
|
{
|
|
get
|
|
{
|
|
if (_SOCKSProxy == null)
|
|
{
|
|
_SOCKSProxy = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLProtectionSpaceSOCKSProxy");
|
|
}
|
|
return _SOCKSProxy;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodDefault", "Foundation")]
|
|
public static NSString AuthenticationMethodDefault
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodDefault == null)
|
|
{
|
|
_AuthenticationMethodDefault = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodDefault");
|
|
}
|
|
return _AuthenticationMethodDefault;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodHTTPBasic", "Foundation")]
|
|
public static NSString AuthenticationMethodHTTPBasic
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodHTTPBasic == null)
|
|
{
|
|
_AuthenticationMethodHTTPBasic = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodHTTPBasic");
|
|
}
|
|
return _AuthenticationMethodHTTPBasic;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodHTTPDigest", "Foundation")]
|
|
public static NSString AuthenticationMethodHTTPDigest
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodHTTPDigest == null)
|
|
{
|
|
_AuthenticationMethodHTTPDigest = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodHTTPDigest");
|
|
}
|
|
return _AuthenticationMethodHTTPDigest;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodHTMLForm", "Foundation")]
|
|
public static NSString AuthenticationMethodHTMLForm
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodHTMLForm == null)
|
|
{
|
|
_AuthenticationMethodHTMLForm = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodHTMLForm");
|
|
}
|
|
return _AuthenticationMethodHTMLForm;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodNTLM", "Foundation")]
|
|
public static NSString AuthenticationMethodNTL
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodNTL == null)
|
|
{
|
|
_AuthenticationMethodNTL = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodNTLM");
|
|
}
|
|
return _AuthenticationMethodNTL;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodNegotiate", "Foundation")]
|
|
public static NSString AuthenticationMethodNegotiat
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodNegotiat == null)
|
|
{
|
|
_AuthenticationMethodNegotiat = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodNegotiate");
|
|
}
|
|
return _AuthenticationMethodNegotiat;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodClientCertificate", "Foundation")]
|
|
public static NSString AuthenticationMethodClientCertificate
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodClientCertificate == null)
|
|
{
|
|
_AuthenticationMethodClientCertificate = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodClientCertificate");
|
|
}
|
|
return _AuthenticationMethodClientCertificate;
|
|
}
|
|
}
|
|
|
|
[Field("NSURLAuthenticationMethodServerTrust", "Foundation")]
|
|
public static NSString AuthenticationMethodServerTrus
|
|
{
|
|
get
|
|
{
|
|
if (_AuthenticationMethodServerTrus == null)
|
|
{
|
|
_AuthenticationMethodServerTrus = Dlfcn.GetStringConstant(Libraries.Foundation.Handle, "NSURLAuthenticationMethodServerTrust");
|
|
}
|
|
return _AuthenticationMethodServerTrus;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSUrlProtectionSpace(NSCoder coder)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSUrlProtectionSpace(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSUrlProtectionSpace(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("initWithHost:port:protocol:realm:authenticationMethod:")]
|
|
public NSUrlProtectionSpace(string host, long port, string protocol, string realm, string authenticationMethod)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (host == null)
|
|
{
|
|
throw new ArgumentNullException("host");
|
|
}
|
|
if (protocol == null)
|
|
{
|
|
throw new ArgumentNullException("protocol");
|
|
}
|
|
if (realm == null)
|
|
{
|
|
throw new ArgumentNullException("realm");
|
|
}
|
|
if (authenticationMethod == null)
|
|
{
|
|
throw new ArgumentNullException("authenticationMethod");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(host);
|
|
IntPtr intPtr2 = NSString.CreateNative(protocol);
|
|
IntPtr intPtr3 = NSString.CreateNative(realm);
|
|
IntPtr intPtr4 = NSString.CreateNative(authenticationMethod);
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr_Int64_IntPtr_IntPtr_IntPtr(base.Handle, selInitWithHostPortProtocolRealmAuthenticationMethod_Handle, intPtr, port, intPtr2, intPtr3, intPtr4);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr_Int64_IntPtr_IntPtr_IntPtr(base.SuperHandle, selInitWithHostPortProtocolRealmAuthenticationMethod_Handle, intPtr, port, intPtr2, intPtr3, intPtr4);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
NSString.ReleaseNative(intPtr2);
|
|
NSString.ReleaseNative(intPtr3);
|
|
NSString.ReleaseNative(intPtr4);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (base.Handle == IntPtr.Zero)
|
|
{
|
|
__mt_DistinguishedNames_var = null;
|
|
}
|
|
}
|
|
}
|
|
}
|