mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 12:31:30 -10:00
617 lines
15 KiB
C#
617 lines
15 KiB
C#
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Configuration;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Runtime;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.Serialization;
|
|
using System.Security;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Net;
|
|
|
|
namespace System.Net
|
|
{
|
|
[Serializable]
|
|
public class HttpWebRequest : WebRequest
|
|
{
|
|
#region Fields
|
|
|
|
|
|
private static readonly int DEFAULT_MAX_RESP_HEADER_LEN = 64;
|
|
|
|
private static int _defaultMaxResponseHeadersLength = DEFAULT_MAX_RESP_HEADER_LEN;
|
|
|
|
|
|
private HttpProvider _provider;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
internal HttpWebRequest(Uri uri)
|
|
{
|
|
_provider = HttpProvider.GetHttpProvider(uri);
|
|
// Console.WriteLine("uri to string: " + uri.ToString());
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
|
|
public string Accept
|
|
{
|
|
get{return Headers["Accept"];}
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted ())
|
|
throw new InvalidOperationException ("request started");
|
|
_provider.Headers.RemoveAndAdd ("Accept", value);
|
|
}
|
|
}
|
|
|
|
public Uri Address
|
|
{
|
|
get{return _provider.GetAddress();}
|
|
}
|
|
|
|
public bool AllowAutoRedirect
|
|
{
|
|
get{return _provider.AllowAutoRedirect;}
|
|
set{_provider.AllowAutoRedirect = value;}
|
|
}
|
|
|
|
public bool AllowWriteStreamBuffering
|
|
{
|
|
get{return _provider.AllowWriteStreamBuffering;}
|
|
set{_provider.AllowWriteStreamBuffering = value;}
|
|
}
|
|
|
|
[MonoTODO] //documentation related
|
|
public X509CertificateCollection ClientCertificates
|
|
{
|
|
[MonoTODO]
|
|
get{return _provider.GetX509Certificates();}
|
|
[MonoNotSupported("")]
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
public string Connection
|
|
{
|
|
get { return Headers["Connection"]; }
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted())
|
|
throw new InvalidOperationException ("request started");
|
|
|
|
string val = value;
|
|
if (val != null)
|
|
val = val.Trim ().ToLower (CultureInfo.InvariantCulture);
|
|
|
|
if (val == null || val.Length == 0)
|
|
{
|
|
Headers.RemoveInternal ("Connection");
|
|
return;
|
|
}
|
|
|
|
if (val == "keep-alive" || val == "close")
|
|
throw new ArgumentException ("Keep-Alive and Close may not be set with this property");
|
|
|
|
// if (this.KeepAlive && val.IndexOf ("keep-alive") == -1)
|
|
// value = value + ", Keep-Alive";
|
|
|
|
Headers.RemoveAndAdd ("Connection", value);
|
|
}
|
|
}
|
|
|
|
public override string ConnectionGroupName
|
|
{
|
|
get{return _provider.ConnectionGroupName;}
|
|
set{_provider.ConnectionGroupName = value;}
|
|
}
|
|
|
|
public override long ContentLength
|
|
{
|
|
get{return _provider.ContentLength;}
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted())
|
|
throw new InvalidOperationException("Connection already opened");
|
|
_provider.ContentLength = value;
|
|
}
|
|
}
|
|
|
|
public override string ContentType
|
|
{
|
|
get { return Headers["Content-Type"]; }
|
|
set
|
|
{
|
|
if (value == null || value.Trim().Length == 0)
|
|
{
|
|
Headers.RemoveInternal ("Content-Type");
|
|
return;
|
|
}
|
|
Headers.RemoveAndAdd ("Content-Type", value);
|
|
}
|
|
}
|
|
[MonoTODO] //needed for automatic documentation tools,
|
|
//since currently we don't support this feature
|
|
public HttpContinueDelegate ContinueDelegate
|
|
{
|
|
[MonoTODO]
|
|
get{return _provider.ContinueDelegate;}
|
|
[MonoTODO]
|
|
set{_provider.ContinueDelegate = value;}
|
|
}
|
|
|
|
public CookieContainer CookieContainer
|
|
{
|
|
get{return _provider.CookieContainer;}
|
|
set{_provider.CookieContainer = value;}
|
|
}
|
|
|
|
public override ICredentials Credentials
|
|
{
|
|
get{return _provider.Credentials;}
|
|
set{_provider.Credentials = value;}
|
|
}
|
|
|
|
public static int DefaultMaximumResponseHeadersLength
|
|
{
|
|
get{return HttpProvider.DefaultMaxResponseHeadersLength;}
|
|
set{HttpProvider.DefaultMaxResponseHeadersLength = value;}
|
|
}
|
|
|
|
public string Expect
|
|
{
|
|
get{return Headers["Expect"];}
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted ())
|
|
throw new InvalidOperationException("Connection already opened");
|
|
string val = value;
|
|
if (val != null)
|
|
val = val.Trim ().ToLower (CultureInfo.InvariantCulture);
|
|
|
|
if (val == null || val.Length == 0)
|
|
{
|
|
Headers.RemoveInternal ("Expect");
|
|
return;
|
|
}
|
|
|
|
if (val == "100-continue")
|
|
throw new ArgumentException ("100-Continue cannot be set with this property.",
|
|
"value");
|
|
Headers.RemoveAndAdd ("Expect", value);
|
|
}
|
|
}
|
|
|
|
public bool HaveResponse
|
|
{
|
|
get{return _provider.IsHaveResponse();}
|
|
}
|
|
|
|
public override WebHeaderCollection Headers
|
|
{
|
|
get{return _provider.Headers;}
|
|
set{_provider.Headers = value;}
|
|
}
|
|
|
|
public DateTime IfModifiedSince
|
|
{
|
|
get
|
|
{
|
|
string str = Headers["If-Modified-Since"];
|
|
if (str == null)
|
|
return DateTime.Now;
|
|
try
|
|
{
|
|
return MonoHttpDate.Parse (str);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return DateTime.Now;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted ())
|
|
throw new InvalidOperationException("Connection already started");
|
|
// rfc-1123 pattern
|
|
Headers.SetInternal ("If-Modified-Since",
|
|
value.ToUniversalTime ().ToString ("r", null));
|
|
// TODO: check last param when using different locale
|
|
}
|
|
}
|
|
|
|
public bool KeepAlive
|
|
{
|
|
get{return _provider.KeepAlive;}
|
|
set{_provider.KeepAlive = value;}
|
|
}
|
|
|
|
public int MaximumAutomaticRedirections
|
|
{
|
|
get{return _provider.MaxAutoRedirections;}
|
|
set{_provider.MaxAutoRedirections = value;}
|
|
}
|
|
|
|
[MonoTODO] //documentation
|
|
public int MaximumResponseHeadersLength
|
|
{
|
|
[MonoTODO]
|
|
get{return _provider.MaximumResponseHeadersLength;}
|
|
[MonoTODO]
|
|
set{_provider.MaximumResponseHeadersLength = value;}
|
|
}
|
|
|
|
public string MediaType
|
|
{
|
|
get{return _provider.MediaType;}
|
|
set{_provider.MediaType = value;}
|
|
}
|
|
|
|
public override string Method
|
|
{
|
|
get{return _provider.MethodName;}
|
|
set{_provider.MethodName = value;}
|
|
}
|
|
[MonoTODO] //for documentation related - limited.
|
|
public bool Pipelined
|
|
{
|
|
[MonoTODO]
|
|
get{return _provider.Pipelined;}
|
|
[MonoTODO]
|
|
set{_provider.Pipelined = value;}
|
|
}
|
|
|
|
public override bool PreAuthenticate
|
|
{
|
|
get{return _provider.PreAuthenticate;}
|
|
set{_provider.PreAuthenticate = value;}
|
|
}
|
|
|
|
public Version ProtocolVersion
|
|
{
|
|
get{return _provider.ProtocolVersion;}
|
|
set{_provider.ProtocolVersion = value;}
|
|
}
|
|
|
|
public override IWebProxy Proxy
|
|
{
|
|
get{return _provider.Proxy;}
|
|
set{_provider.Proxy = value;}
|
|
}
|
|
|
|
public int ReadWriteTimeout
|
|
{
|
|
get{return _provider.ReadWriteTimeout;}
|
|
set{_provider.ReadWriteTimeout = value;}
|
|
}
|
|
|
|
public string Referer
|
|
{
|
|
get {return Headers["Referer"];}
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted ())
|
|
throw new InvalidOperationException("Connection already opened");
|
|
if (value == null || value.Trim().Length == 0)
|
|
{
|
|
Headers.RemoveInternal ("Referer");
|
|
return;
|
|
}
|
|
Headers.SetInternal ("Referer", value);
|
|
}
|
|
}
|
|
internal Uri AuthUri
|
|
{
|
|
get { return RequestUri; }
|
|
}
|
|
public override Uri RequestUri
|
|
{
|
|
get{return _provider.GetOriginalAddress();}
|
|
}
|
|
|
|
public bool SendChunked
|
|
{
|
|
get{return _provider.SendChunked;}
|
|
set{_provider.SendChunked = value;}
|
|
}
|
|
|
|
public ServicePoint ServicePoint
|
|
{
|
|
get{return _provider.ServicePoint;}
|
|
}
|
|
[MonoTODO] //once again - needed since our impl. still
|
|
//doesn't support this feature we need document it..
|
|
public override int Timeout
|
|
{
|
|
[MonoTODO]
|
|
get{return _provider.Timeout;}
|
|
[MonoTODO]
|
|
set{_provider.Timeout = value;}
|
|
}
|
|
|
|
|
|
public string TransferEncoding
|
|
{
|
|
get { return Headers ["Transfer-Encoding"]; }
|
|
set
|
|
{
|
|
if(_provider.IsRequestStarted ())
|
|
{
|
|
throw new InvalidOperationException("Connection has been already opened");
|
|
}
|
|
string val = value;
|
|
if (val != null)
|
|
val = val.Trim ().ToLower (CultureInfo.InvariantCulture);
|
|
|
|
if (val == null || val.Length == 0)
|
|
{
|
|
Headers.RemoveInternal ("Transfer-Encoding");
|
|
return;
|
|
}
|
|
|
|
if (val == "chunked")
|
|
throw new ArgumentException ("Chunked encoding must be set with the SendChunked property");
|
|
|
|
if (!this.SendChunked)
|
|
throw new InvalidOperationException ("SendChunked must be True");
|
|
|
|
Headers.RemoveAndAdd ("Transfer-Encoding", value);
|
|
}
|
|
}
|
|
|
|
|
|
public bool UnsafeAuthenticatedConnectionSharing
|
|
{
|
|
get { throw new NotImplementedException (); }
|
|
set { throw new NotImplementedException (); }
|
|
}
|
|
|
|
public string UserAgent
|
|
{
|
|
get { return Headers ["User-Agent"]; }
|
|
set { Headers.SetInternal ("User-Agent", value); }
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
//todo
|
|
public override void Abort()
|
|
{
|
|
_provider.Abort();
|
|
// _connection.disconnect();
|
|
// _haveResponse = true;
|
|
// //aborted = true;
|
|
// if (_asyncWrite != null)
|
|
// {
|
|
// GHWebAsyncResult r = _asyncWrite;
|
|
// WebException wexc = new WebException ("Aborted.", WebExceptionStatus.RequestCanceled);
|
|
// r.SetCompleted (false, wexc);
|
|
// r.DoCallback ();
|
|
// _asyncWrite = null;
|
|
// }
|
|
//
|
|
// if (_asyncRead != null)
|
|
// {
|
|
// GHWebAsyncResult r = _asyncRead;
|
|
// WebException wexc = new WebException ("Aborted.", WebExceptionStatus.RequestCanceled);
|
|
// r.SetCompleted (false, wexc);
|
|
// r.DoCallback ();
|
|
// _asyncRead = null;
|
|
// }
|
|
//
|
|
//// if (abortHandler != null)
|
|
//// {
|
|
//// try
|
|
//// {
|
|
//// abortHandler (this, EventArgs.Empty);
|
|
//// }
|
|
//// catch {}
|
|
//// abortHandler = null;
|
|
//// }
|
|
//
|
|
// if (_writeStream != null)
|
|
// {
|
|
// try
|
|
// {
|
|
// _writeStream.Close ();
|
|
// _writeStream = null;
|
|
// }
|
|
// catch {}
|
|
// }
|
|
//
|
|
// if (_response != null)
|
|
// {
|
|
// try
|
|
// {
|
|
// _response.Close ();
|
|
// _response = null;
|
|
// }
|
|
// catch {}
|
|
// }
|
|
}
|
|
|
|
public void AddRange (int range)
|
|
{
|
|
AddRange ("bytes", range);
|
|
}
|
|
|
|
public void AddRange (int from, int to)
|
|
{
|
|
AddRange ("bytes", from, to);
|
|
}
|
|
|
|
public void AddRange (string rangeSpecifier, int range)
|
|
{
|
|
if (rangeSpecifier == null)
|
|
throw new ArgumentNullException ("rangeSpecifier");
|
|
string value = Headers ["Range"];
|
|
if (value == null || value.Length == 0)
|
|
value = rangeSpecifier + "=";
|
|
else if (value.StartsWith (rangeSpecifier.ToLower () + "=", StringComparison.InvariantCultureIgnoreCase))
|
|
value += ",";
|
|
else
|
|
throw new InvalidOperationException ("rangeSpecifier");
|
|
Headers.RemoveAndAdd ("Range", value + range + "-");
|
|
}
|
|
|
|
public void AddRange (string rangeSpecifier, int from, int to)
|
|
{
|
|
if (rangeSpecifier == null)
|
|
throw new ArgumentNullException ("rangeSpecifier");
|
|
if (from < 0 || to < 0 || from > to)
|
|
throw new ArgumentOutOfRangeException ();
|
|
string value = Headers ["Range"];
|
|
if (value == null || value.Length == 0)
|
|
value = rangeSpecifier + "=";
|
|
else if (value.StartsWith (rangeSpecifier.ToLower () + "=", StringComparison.InvariantCultureIgnoreCase))
|
|
value += ",";
|
|
else
|
|
throw new InvalidOperationException ("rangeSpecifier");
|
|
Headers.RemoveAndAdd ("Range", value + from + "-" + to);
|
|
}
|
|
|
|
public override Stream GetRequestStream()
|
|
{
|
|
return _provider.GetRequestStream();
|
|
// lock(this)
|
|
// {
|
|
// Type t = Type.GetType("System.IO.ConsoleWriteStream", true);
|
|
// _connection.setDoOutput(true);
|
|
//
|
|
//
|
|
//// Console.WriteLine("Request is sent with following headers:");
|
|
//// java.util.Map map = _connection.getRequestProperties();
|
|
//// for(java.util.Iterator iter = map.keySet().iterator(); iter.hasNext();)
|
|
//// {
|
|
//// string key = (string) iter.next();
|
|
//// Console.WriteLine(key + ": " + map.get(key));
|
|
//// }
|
|
//
|
|
// foreach(string k in Headers)
|
|
// {
|
|
// string val = Headers[k];
|
|
// val = (val == null) ? "" : val;
|
|
// _connection.setRequestProperty(k, val);
|
|
// }
|
|
//
|
|
// _writeStream = (Stream) Activator.CreateInstance(t, new object[]{_connection.getOutputStream()});
|
|
// _haveRequest = true;
|
|
// return _writeStream;
|
|
// }
|
|
}
|
|
|
|
public override WebResponse GetResponse()
|
|
{
|
|
return _provider.GetResponse();
|
|
}
|
|
/*
|
|
private void CommonChecks (bool putpost)
|
|
{
|
|
string method = _connection.getRequestMethod();
|
|
|
|
if (method == null)
|
|
throw new ProtocolViolationException ("Method is null.");
|
|
|
|
bool keepAlive = _headers["Keep-Alive"] == null;
|
|
bool allowBuffering = true;
|
|
bool sendChunked = true;
|
|
long contentLength = _connection.getContentLength();
|
|
|
|
if (putpost && ((!keepAlive || (contentLength == -1 && !sendChunked)) && !allowBuffering))
|
|
throw new ProtocolViolationException ("Content-Length not set");
|
|
|
|
string transferEncoding = TransferEncoding;
|
|
if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "")
|
|
throw new ProtocolViolationException ("SendChunked should be true.");
|
|
}
|
|
*/
|
|
|
|
public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
|
|
{
|
|
return _provider.BeginGetRequestStream(callback, state);
|
|
}
|
|
|
|
public override Stream EndGetRequestStream(IAsyncResult asyncResult)
|
|
{
|
|
return _provider.EndGetRequestStream(asyncResult);
|
|
}
|
|
|
|
public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
|
|
{
|
|
//todo check input, http headers etc.
|
|
|
|
return _provider.BeginGetResponse(callback, state);
|
|
}
|
|
|
|
public override WebResponse EndGetResponse(IAsyncResult asyncResult)
|
|
{
|
|
return _provider.EndGetResponse(asyncResult);
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region Inner Classes
|
|
|
|
// #region JavaHeaders class
|
|
// [Serializable]
|
|
// internal sealed class JavaHeaders : WebHeaderCollection
|
|
// {
|
|
// private java.net.HttpURLConnection _connection;
|
|
//
|
|
// internal JavaHeaders(java.net.HttpURLConnection con)
|
|
// {
|
|
// _connection = con;
|
|
// }
|
|
//
|
|
// public string this[string key]
|
|
// {
|
|
// get
|
|
// {
|
|
// return _connection.getHeaderField(key);
|
|
// }
|
|
// set
|
|
// {
|
|
// _connection.addRequestProperty(key, value);
|
|
// }
|
|
// }
|
|
// }
|
|
// #endregion
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
#if NET_2_0
|
|
public DecompressionMethods AutomaticDecompression
|
|
{
|
|
get {
|
|
throw new NotSupportedException ();
|
|
}
|
|
set {
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|