public HttpProductInfoHeaderValue Create()
{
try
{
// What should we do? App names often have non-ASCII characters.
// These characters are turned into question marks by the
// time the header hits the wire. We do RFC 2047 encoding
// so that the server's log winds up with something decipherable.
// This can easily be changed by providing an alternate factory
// or an alternate IUserAgent implementation.
// (Note that only strings that need encoding are modified by
// ".Rfc2047Encode()".)
var productName = _userAgent.Name.Trim().Replace(' ', '-').Rfc2047Encode();
var userAgent = new HttpProductInfoHeaderValue(productName, _userAgent.Version);
return userAgent;
}
catch (FormatException ex)
{
Debug.WriteLine("HttpDefaults.DefaultUserAgentFactory({0}, {1}) unable to construct HttpProductInfoHeaderValue: {2}",
_userAgent.Name, _userAgent.Version, ex.Message);
return null;
}
}
public async Task <HttpResponseMessage> SendAsync(CancellationToken token = default(CancellationToken), Progress <HttpProgress> progressCallback = null)
{
using (var request = new HttpRequestMessage(_method, _requestUrl))
using (_contentStream)
{
request.Headers.Connection.Add(new HttpConnectionOptionHeaderValue("Keep-Alive"));
request.Headers.UserAgent.Add(HttpProductInfoHeaderValue.Parse("Mozilla/5.0"));
if (_customHeaders != null)
{
foreach (var header in _customHeaders)
{
request.Headers.Add(header);
}
}
if (_method.Method == "PROPFIND")
{
request.Content = new HttpStringContent(PropfindContent, UnicodeEncoding.Utf8);
}
else if (_contentStream != null)
{
request.Content = new HttpStreamContent(_contentStream.AsInputStream());
}
HttpResponseMessage response = await _httpClient.SendRequestAsync(request, HttpCompletionOption.ResponseHeadersRead).AsTask(token, progressCallback);
return(response);
}
}
public MyHttpClient(Client owner, HttpClient inner)
{
_Inner = inner;
_Owner = owner;
_Nocookie = new HttpClient(new HttpBaseProtocolFilter
{
CookieUsageBehavior = HttpCookieUsageBehavior.NoCookies,
});
var ua = new HttpProductInfoHeaderValue(Package.Current.Id.Name, Package.Current.Id.Version.ToVersion().ToString());
_Inner.DefaultRequestHeaders.UserAgent.Add(ua);
_Nocookie.DefaultRequestHeaders.UserAgent.Add(ua);
}
public WinRtHttpClientFactory(IWinRtHttpClientFactoryParameters parameters, IWebReaderManagerParameters webReaderManagerParameters, IHttpProductInfoHeaderValueFactory httpProductInfoFactory, Func<HttpBaseProtocolFilter> httpClientHandlerFactory)
{
if (null == parameters)
throw new ArgumentNullException(nameof(parameters));
if (null == webReaderManagerParameters)
throw new ArgumentNullException(nameof(webReaderManagerParameters));
if (null == httpProductInfoFactory)
throw new ArgumentNullException(nameof(httpProductInfoFactory));
if (null == httpClientHandlerFactory)
throw new ArgumentNullException(nameof(httpClientHandlerFactory));
_referrer = parameters.Referrer;
_userAgent = httpProductInfoFactory.Create();
_credentials = parameters.Credentials;
_webReaderManagerParameters = webReaderManagerParameters;
_httpClientHandlerFactory = httpClientHandlerFactory;
}
private IResponse Invoke(UrlBuilder url, HttpMethod method, System.Net.Http.HttpContent content, IBindingSession session,
long?offset, long?length, IDictionary <string, string> headers)
{
if (Logger.IsDebugEnabled)
{
Logger.Debug("HTTP: " + method.ToString() + " " + url.ToString());
}
IWindowsAuthenticationProvider authProvider = session.GetAuthenticationProvider() as IWindowsAuthenticationProvider;
HttpClient httpClient = session.GetValue(InvokerHttpClient) as HttpClient;
if (httpClient == null)
{
lock (invokerLock)
{
httpClient = session.GetValue(InvokerHttpClient) as HttpClient;
if (httpClient == null)
{
HttpBaseProtocolFilter httpClientFilter = new HttpBaseProtocolFilter();
// redirects
httpClientFilter.AllowAutoRedirect = false;
// compression
string compressionFlag = session.GetValue(SessionParameter.Compression) as string;
if (compressionFlag != null && compressionFlag.ToLowerInvariant().Equals("true"))
{
httpClientFilter.AutomaticDecompression = true;
}
// authentication
httpClientFilter.AllowUI = false;
// authentication provider
if (authProvider != null)
{
authProvider.PrepareHttpClientFilter(httpClientFilter);
}
// create HttpClient
httpClient = new HttpClient(httpClientFilter);
session.PutValue(InvokerHttpClient, httpClient);
}
}
}
HttpRequestMessage request = new HttpRequestMessage(method, new Uri(url.ToString()));
// set additional headers
string userAgent = session.GetValue(SessionParameter.UserAgent) as string;
request.Headers.UserAgent.Add(HttpProductInfoHeaderValue.Parse(userAgent ?? ClientVersion.UserAgent));
if (headers != null)
{
foreach (KeyValuePair <string, string> header in headers)
{
request.Headers.TryAppendWithoutValidation(header.Key, header.Value);
}
}
// range
if (offset != null && length != null)
{
long longOffset = offset.Value < 0 ? 0 : offset.Value;
if (length.Value > 0)
{
request.Headers.Add(new KeyValuePair <string, string>("Range", "bytes=" + longOffset + "-" + (longOffset + length.Value - 1)));
}
else
{
request.Headers.Add(new KeyValuePair <string, string>("Range", "bytes=" + longOffset + "-"));
}
}
else if (offset != null && offset.Value > 0)
{
request.Headers.Add(new KeyValuePair <string, string>("Range", "bytes=" + offset.Value + "-"));
}
// content
if (content != null)
{
request.Content = new ConvertedHttpContent(content);
if (request.Content.Headers.ContentLength == null)
{
request.Headers.TransferEncoding.TryParseAdd("chunked");
}
}
// authentication provider
if (authProvider != null)
{
authProvider.PrepareHttpRequestMessage(request);
}
// timeouts
int timeout = session.GetValue(SessionParameter.ConnectTimeout, -2);
WindowsResponse response;
try
{
Task <HttpResponseMessage> task = Send(httpClient, request, timeout);
if (task.IsFaulted)
{
throw task.Exception;
}
else
{
HttpResponseMessage httpResponseMessage = task.Result;
if (authProvider != null)
{
authProvider.HandleResponse(httpResponseMessage);
}
response = new WindowsResponse(httpResponseMessage);
}
}
catch (Exception e)
{
throw new CmisConnectionException("Cannot access " + url + ": " + e.Message, e);
}
return(response);
}
public async Task RequestUrl(WebMessage web)
{
var request = new HttpClient();
HttpResponseMessage response = null;
request.DefaultRequestHeaders.Accept.Add(HttpMediaTypeWithQualityHeaderValue.Parse("text/html"));
request.DefaultRequestHeaders.Accept.Add(HttpMediaTypeWithQualityHeaderValue.Parse("application/xhtml+xml"));
request.DefaultRequestHeaders.Accept.Add(HttpMediaTypeWithQualityHeaderValue.Parse("application/xml"));
request.DefaultRequestHeaders.Accept.Add(HttpMediaTypeWithQualityHeaderValue.Parse("application/json"));
request.DefaultRequestHeaders.Accept.Add(HttpMediaTypeWithQualityHeaderValue.Parse("*/*"));
request.DefaultRequestHeaders.UserAgent.Add(HttpProductInfoHeaderValue.Parse("Mozilla/5.0"));
try
{
if (web.Action != null)
{
switch (web.Action.ToUpperInvariant())
{
case "POST":
{
var content = new HttpStringContent(web.Data, UnicodeEncoding.Utf8, "application/json");
request.DefaultRequestHeaders.Accept.Add(
new HttpMediaTypeWithQualityHeaderValue("application/json"));
response = await request.PostAsync(new Uri(web.Url), content);
break;
}
case "GET":
{
request.DefaultRequestHeaders.Accept.Add(
new HttpMediaTypeWithQualityHeaderValue("application/json"));
response = await request.GetAsync(new Uri(web.Url));
break;
}
}
response?.EnsureSuccessStatusCode();
}
if (response != null)
{
var result = new ResultMessage(web)
{
ResultId = (int)response.StatusCode, Type = 'W'
};
if (!string.IsNullOrWhiteSpace(web.Parse) || web.Len > 0)
{
var temp = await response.Content.ReadAsStringAsync();
if (!string.IsNullOrWhiteSpace(web.Parse))
{
var parser = new Parser {
Content = temp, Instructions = web.Parse
};
if (parser.Parse())
{
if (parser.IsDictionary)
{
mainPage.mainDictionary[parser.Tablename] = parser.Dictionary;
temp = parser.Tablename;
result.ResultId = parser.Dictionary.Count();
}
else
{
temp = parser.Result;
}
}
}
result.Result = string.IsNullOrWhiteSpace(temp)
? string.Empty
: temp.Substring(0, Math.Min(temp.Length, web.Len == 0 ? 200 : web.Len));
}
await mainPage.SendResult(result);
}
}
catch (Exception e)
{
await mainPage.SendResult(new ResultMessage(web) { ResultId = e.HResult, Result = e.Message });
}
}