private static async Task<IValueProvider> CreateValueProviderAsync(HttpRequest request)
{
return new FormValueProvider(
BindingSource.Form,
await request.ReadFormAsync(),
CultureInfo.CurrentCulture);
}
private static bool TryGetApiKey(HttpRequest request, out string apiKey)
{
StringValues headerValue;
if (request.Headers.TryGetValue("Authorization", out headerValue))
{
AuthenticationHeaderValue authHeaderValue;
if (AuthenticationHeaderValue.TryParse(headerValue, out authHeaderValue))
{
apiKey = authHeaderValue.Parameter;
return true;
}
}
if (request.Headers.TryGetValue("X-Octopus-ApiKey", out headerValue))
{
apiKey = headerValue;
return true;
}
if (request.Headers.TryGetValue("X-NuGet-ApiKey", out headerValue))
{
apiKey = headerValue;
return true;
}
if (request.Query.ContainsKey("apikey"))
{
apiKey = request.Query["apikey"];
return true;
}
apiKey = null;
return false;
}
private static bool ParseAuthenticationHeader(MgHttpRequestParam param, HttpRequest request)
{
//This method decodes and extracts the username and password from the http authentication
//header (if it exists) and packs the values into the MgHttpRequestParam object if they
//exist
String auth = request.Headers["authorization"];
if (auth != null && auth.Length > 6)
{
auth = auth.Substring(6);
byte[] decoded = Convert.FromBase64String(auth);
String decodedStr = Encoding.UTF8.GetString(decoded);
String[] decodedTokens = decodedStr.Split(':');
if (decodedTokens.Length == 1 || decodedTokens.Length == 2)
{
String username = decodedTokens[0];
String password = "";
if (decodedTokens.Length == 2)
password = decodedTokens[1];
param.AddParameter("USERNAME", username);
param.AddParameter("PASSWORD", password);
return true;
}
}
return false;
}
public StaticFileContext(HttpContext context, StaticFileOptions options, PathString matchUrl, ILogger logger)
{
_context = context;
_options = options;
_matchUrl = matchUrl;
_request = context.Request;
_response = context.Response;
_logger = logger;
_requestHeaders = _request.GetTypedHeaders();
_responseHeaders = _response.GetTypedHeaders();
_method = null;
_isGet = false;
_isHead = false;
_subPath = PathString.Empty;
_contentType = null;
_fileInfo = null;
_length = 0;
_lastModified = new DateTimeOffset();
_etag = null;
_ifMatchState = PreconditionState.Unspecified;
_ifNoneMatchState = PreconditionState.Unspecified;
_ifModifiedSinceState = PreconditionState.Unspecified;
_ifUnmodifiedSinceState = PreconditionState.Unspecified;
_ranges = null;
}
public static string Combine(HttpRequest request, string path, params Descriptor[] descriptors)
{
StringBuilder result = new StringBuilder();
foreach (Descriptor descriptor in descriptors)
{
if (!descriptor.Skip)
{
string value = descriptor.TakeFromUrl ? request.Query[descriptor.Name] : descriptor.Value;
if (!string.IsNullOrEmpty(value))
result.AppendFormat("{0}{1}={2}", result.Length == 0 ? '?' : '&', descriptor.Name, value);
}
}
foreach (KeyValuePair<string, string[]> keyValuePair in request.Query)
{
if (!descriptors.Any(d => d.Name == keyValuePair.Key))
{
string value = request.Query[keyValuePair.Key];
if (!string.IsNullOrEmpty(value))
result.AppendFormat("{0}{1}={2}", result.Length == 0 ? '?' : '&', keyValuePair.Key, value);
}
}
result.Insert(0, string.IsNullOrEmpty(path) ? request.Path.ToString() : path);
return result.ToString();
}
private static async Task<IValueProvider> CreateValueProviderAsync(HttpRequest request)
{
return new JQueryFormValueProvider(
BindingSource.Form,
await GetValueCollectionAsync(request),
CultureInfo.CurrentCulture);
}
/*
* Very simple logger that logs to the VS Debug output window. Requires the debugger to be attached to work!
*/
public void Log(HttpRequest request, Exception ex)
{
/*
* Simplification due to time restrictions.
*/
Log(ex);
}
protected override async Task OnReceived(HttpRequest request, string connectionId, string data) {
var identity = request.HttpContext.User.Identity;
var status = identity.IsAuthenticated ? "authenticated" : "unauthenticated";
var name = identity.IsAuthenticated ? identity.Name : "client";
await Connection.Send(connectionId, $"Received an {status} message from {name}: {data}");
}
private bool RequestingSwaggerUi(HttpRequest request)
{
if (request.Method != "GET") return false;
var routeValues = _requestMatcher.Match(request.Path.ToUriComponent().Trim('/'));
return (routeValues != null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from
/// the <see cref="ODataQueryContext"/>.
/// </summary>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information.</param>
/// <param name="request">The incoming request message.</param>
public ODataQueryOptions(ODataQueryContext context, HttpRequest request)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
_assemblyProvider = request.AssemblyProvider();
Context = context;
Request = request;
RawValues = new ODataRawQueryOptions();
var queryOptionDict = request.Query.ToDictionary(p => p.Key, p => p.Value.FirstOrDefault());
_queryOptionParser = new ODataQueryOptionParser(
context.Model,
context.ElementType,
context.NavigationSource,
queryOptionDict);
BuildQueryOptions(queryOptionDict);
}
public virtual object ApplyQueryOptions(object value, HttpRequest request, ActionDescriptor descriptor)
{
var elementClrType = TypeHelper.GetImplementedIEnumerableType(value.GetType());
var model = request.ODataProperties().Model;
if (model == null)
{
throw Error.InvalidOperation(SRResources.QueryGetModelMustNotReturnNull);
}
var queryContext = new ODataQueryContext(
model,
elementClrType,
request.ODataProperties().Path);
var queryOptions = new ODataQueryOptions(queryContext, request);
var enumerable = value as IEnumerable;
if (enumerable == null)
{
// response is single entity.
return value;
}
// response is a collection.
var query = (value as IQueryable) ?? enumerable.AsQueryable();
return queryOptions.ApplyTo(query,
new ODataQuerySettings
{
HandleNullPropagation = HandleNullPropagationOption.True
});
}
private bool RequestingSwaggerUi(HttpRequest request)
{
if (request.Method != "GET") return false;
var routeValues = _requestMatcher.Match(request.Path);
return (routeValues != null);
}
public BasicAuthIdentity GetBasicAuth(HttpRequest request)
{
BasicAuthIdentity identity = null;
var headerValue = request.Headers["Authorization"];
if (!String.IsNullOrEmpty(headerValue))
{
var headerValues = headerValue.Split(' ');
var scheme = headerValues[0];
if (string.Compare(scheme, "Basic", true) == 0)
{
var encodedUsernameAndPassword = headerValues[1];
var usernameAndPassword = Encoding.UTF8.GetString(Convert.FromBase64String(encodedUsernameAndPassword));
if (usernameAndPassword != null && usernameAndPassword != ":")
{
var tokens = usernameAndPassword.Split(':');
switch (tokens.Length)
{
case 2:
identity = new BasicAuthIdentity(tokens[0], tokens[1]);
break;
case 1:
identity = new BasicAuthIdentity(tokens[0], null);
break;
default:
identity = null;
break;
}
}
}
}
return identity;
}
protected override Task OnDisconnected(HttpRequest request, string connectionId, bool stopCalled)
{
string ignored;
_users.TryRemove(connectionId, out ignored);
string suffix = stopCalled ? "cleanly" : "uncleanly";
return Connection.Broadcast(DateTime.Now + ": " + GetUser(connectionId) + " disconnected " + suffix);
}
internal static bool RequestPrefersReturnNoContent(HttpRequest request)
{
string[] preferences = null;
if (request.Headers.TryGetValue(PreferHeaderName, out preferences))
{
return preferences.Contains(ReturnNoContentHeaderValue);
}
return false;
}
public OrderedFileSet(IEnumerable<IWebFile> files,
FileSystemHelper fileSystemHelper,
HttpRequest request,
PreProcessPipeline defaultPipeline)
{
_files = files;
_defaultPipeline = defaultPipeline;
_fileSystemHelper = fileSystemHelper;
_request = request;
}
/// <summary>
/// Get a redirect uri using standard options
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private static string GetStandardRedirectUri(HttpRequest request)
{
var uri = new UriBuilder();
uri.Scheme = "https";
uri.Host = RemovePort.Replace(request.Host.Value, String.Empty);
uri.Path = request.Path.Value;
uri.Query = request.QueryString.Value;
return uri.ToString();
}
private IStreamDiscovery CreateStreamDiscovery(HttpRequest request)
{
var streams = request.Query["streams"];
if( streams.FirstOrDefault() != null)
{
return new StaticStreamDiscovery(streams.Select(uri=>uri.Trim()));
}
var cluster = request.Query["cluster"].FirstOrDefault();
return new EtcdStreamDiscovery(cluster);
}
public static string GetHeaderInformation(HttpRequest request)
{
var sb = new StringBuilder();
IHeaderDictionary headers = request.Headers;
foreach (var header in request.Headers)
{
sb.Append(GetDiv(header.Key, string.Join("; ", header.Value)));
}
return sb.ToString();
}
public static IObservable<IDictionary<string, object>> ReceiveSse(string address, HttpRequest origin, CancellationTokenSource token, IObservable<StreamAction> streamRemoved)
{
return Observable.Create<IDictionary<string, object>>((Func<IObserver<IDictionary<string, object>>, Task>)(async (IObserver<IDictionary<string, object>> observer) =>
{
var subscription = streamRemoved.Where(a => a.Uri == address).Subscribe(o => {
token.Cancel();
});
var client = new HttpClient();
var builder = new UriBuilder(address);
if(!String.IsNullOrWhiteSpace( origin.QueryString.Value))
builder.Query = origin.QueryString.Value.Substring(1);
var uri = builder.Uri;
await Task.Delay(TimeSpan.FromSeconds(1));
while (true)
{
try
{
//Console.WriteLine("Get info for " + address);
using (var response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, token.Token).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
var stream = new StreamReader(await response.Content.ReadAsStreamAsync());
while (!token.IsCancellationRequested)
{
var line = await stream.ReadLineAsync();
if (line.Length > 0 && line.StartsWith("data: "))
{
var data = DeserializeData(line.Substring("data: ".Length));
data["instanceId"] = uri.Authority.ToString();
//Console.WriteLine($"{uri.Authority} -> {data["requestCount"]}");
observer.OnNext(data);
}
await Task.Yield();
}
}
}
catch(Exception ex)
{
if (IsSocketException(ex) || token.IsCancellationRequested) break;
//Console.WriteLine("Error waiting 10 sec for " + address);
await Task.Delay(TimeSpan.FromSeconds(10));
}
}
//Console.WriteLine("Completed for " + address);
observer.OnCompleted();
}));
}
private bool RequestingSwaggerDocs(HttpRequest request, out string apiVersion)
{
apiVersion = null;
if (request.Method != "GET") return false;
var routeValues = _requestMatcher.Match(request.Path.ToUriComponent().Trim('/'));
if (routeValues == null || !routeValues.ContainsKey("apiVersion")) return false;
apiVersion = routeValues["apiVersion"].ToString();
return true;
}
internal static string GetRequestPreferHeader(HttpRequest request)
{
string[] values;
if (request.Headers.TryGetValue(PreferHeaderName, out values))
{
// If there are many "Prefer" headers, pick up the first one.
return values.FirstOrDefault();
}
return null;
}
protected override async Task OnConnected(HttpRequest request, string connectionId) {
var identity = request.HttpContext.User.Identity;
var status = identity.IsAuthenticated ? "Authenticated" : "Unauthenticated";
Logger.LogInformation($"{status} connection {connectionId} has just connected.");
await Connection.Send(connectionId, $"Connection is {status}");
if (identity.IsAuthenticated) {
await Connection.Send(connectionId, $"Authenticated username: {identity.Name}");
}
}
private static async Task<IDictionary<string, StringValues>> GetValueCollectionAsync(HttpRequest request)
{
var formCollection = await request.ReadFormAsync();
var dictionary = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
foreach (var entry in formCollection)
{
var key = NormalizeJQueryToMvc(entry.Key);
dictionary[key] = entry.Value;
}
return dictionary;
}
/// <summary>
/// Creates a new instance of the <see cref="HttpClient"/> class.
/// </summary>
/// <param name="request"><see cref="HttpRequest"/> instance.</param>
/// <param name="handler"><see cref="HttpMessageHandler"/> instance.</param>
/// <returns>Returns the <see cref="HttpClient"/> instance created.</returns>
public HttpClient CreateHttpClient(HttpRequest request, HttpMessageHandler handler = null)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var url = string.Join("://", request.IsHttps ? "https" : "http", request.Host.Value);
var baseAddressUri = new Uri(url);
var client = handler == null ? new HttpClient() : new HttpClient(handler, true);
client.BaseAddress = baseAddressUri;
return client;
}
/// <summary>
/// Creates a SharePointContext instance with the specified HTTP request.
/// </summary>
/// <param name="httpRequest">The HTTP request.</param>
/// <returns>The SharePointContext instance. Returns <c>null</c> if errors occur.</returns>
public SharePointContext CreateSharePointContext(HttpRequest httpRequest)
{
if (httpRequest == null)
{
throw new ArgumentNullException(nameof(httpRequest));
}
// SPHostUrl
Uri spHostUrl = SharePointContext.GetUriFromQueryStringParameter(httpRequest, SharePointContext.SPHostUrlKey);
if (spHostUrl == null)
{
return(null);
}
// SPAppWebUrl
Uri spAppWebUrl = SharePointContext.GetUriFromQueryStringParameter(httpRequest, SharePointContext.SPAppWebUrlKey);
if (spAppWebUrl == null)
{
spAppWebUrl = null;
}
// SPLanguage
string spLanguage = httpRequest.Query[SharePointContext.SPLanguageKey];
if (string.IsNullOrEmpty(spLanguage))
{
return(null);
}
// SPClientTag
string spClientTag = httpRequest.Query[SharePointContext.SPClientTagKey];
if (string.IsNullOrEmpty(spClientTag))
{
return(null);
}
// SPProductNumber
string spProductNumber = httpRequest.Query[SharePointContext.SPProductNumberKey];
if (string.IsNullOrEmpty(spProductNumber))
{
return(null);
}
return(CreateSharePointContext(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber, httpRequest));
}
/// <summary>
/// Determines whether client is authorized to connect to <see cref="IHub"/>.
/// </summary>
/// <param name="hubDescriptor">Description of the hub client is attempting to connect to.</param>
/// <param name="request">The (re)connect request from the client.</param>
/// <returns>true if the caller is authorized to connect to the hub; otherwise, false.</returns>
public virtual bool AuthorizeHubConnection(HubDescriptor hubDescriptor, HttpRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
// If RequireOutgoing is explicitly set to false, authorize all connections.
if (_requireOutgoing.HasValue && !_requireOutgoing.Value)
{
return true;
}
return UserAuthorized(request.HttpContext.User);
}
/// <summary>
/// Gets the SharePoint host url from QueryString of the specified HTTP request.
/// </summary>
/// <param name="httpRequest">The specified HTTP request.</param>
/// <returns>The SharePoint host url. Returns <c>null</c> if the HTTP request doesn't contain the SharePoint host url.</returns>
public static Uri GetUriFromQueryStringParameter(HttpRequest httpRequest, string queryStringParameter)
{
if (httpRequest == null) { throw new ArgumentNullException(nameof(httpRequest)); }
string parameterValue = TokenHandler.EnsureTrailingSlash(httpRequest.Query[queryStringParameter]);
Uri uriValue;
if (Uri.TryCreate(parameterValue, UriKind.Absolute, out uriValue) &&
(uriValue.Scheme == Uri.UriSchemeHttp || uriValue.Scheme == Uri.UriSchemeHttps))
{
return uriValue;
}
return null;
}
public static string GetRequestInformation(HttpRequest request)
{
var sb = new StringBuilder();
sb.Append(GetDiv("scheme", request.Scheme));
sb.Append(GetDiv("host", request.Host.HasValue ? request.Host.Value :
"no host"));
sb.Append(GetDiv("path", request.Path));
sb.Append(GetDiv("query string", request.QueryString.HasValue ?
request.QueryString.Value : "no query string"));
sb.Append(GetDiv("method", request.Method));
sb.Append(GetDiv("protocol", request.Protocol));
return sb.ToString();
}
public string GetUserId(HttpRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
var user = request.HttpContext.User;
if (user != null && user.Identity != null)
{
return user.Identity.Name;
}
return null;
}
/// <summary>
/// Returns the ordered collection of files for the bundle
/// </summary>
/// <param name="bundleName"></param>
/// <param name="request"></param>
/// <returns></returns>
public IEnumerable<IWebFile> GetFiles(string bundleName, HttpRequest request)
{
BundleFileCollection collection;
if (!_bundles.TryGetValue(bundleName, out collection)) return null;
//the file type in the bundle will always be the same
var first = collection.Files.FirstOrDefault();
if (first == null) return Enumerable.Empty<IWebFile>();
var orderedSet = new OrderedFileSet(collection.Files, _fileSystemHelper, request,
_processorFactory.GetDefault(first.DependencyType));
var ordered = orderedSet.GetOrderedFileSet();
//call the registered callback if any is set
return collection.OrderingCallback == null ? ordered : collection.OrderingCallback(ordered);
}
/// <summary>
/// Gets the SharePoint host url from QueryString of the specified HTTP request.
/// </summary>
/// <param name="httpRequest">The specified HTTP request.</param>
/// <returns>The SharePoint host url. Returns <c>null</c> if the HTTP request doesn't contain the SharePoint host url.</returns>
public static Uri GetUriFromQueryStringParameter(HttpRequest httpRequest, string queryStringParameter)
{
if (httpRequest == null)
{
throw new ArgumentNullException(nameof(httpRequest));
}
string parameterValue = TokenHandler.EnsureTrailingSlash(httpRequest.Query[queryStringParameter]);
Uri uriValue;
if (Uri.TryCreate(parameterValue, UriKind.Absolute, out uriValue) &&
(uriValue.Scheme == Uri.UriSchemeHttp || uriValue.Scheme == Uri.UriSchemeHttps))
{
return(uriValue);
}
return(null);
}
public HttpRequest(Microsoft.AspNet.Http.HttpRequest request, Microsoft.AspNet.Http.Features.IHttpConnectionFeature connectionFeature)
{
_request = request;
_connectionFeature = connectionFeature;
}
protected override SharePointContext CreateSharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, HttpRequest httpRequest)
{
string contextTokenString = TokenHandler.GetContextTokenFromRequest(httpRequest);
if (string.IsNullOrEmpty(contextTokenString))
{
return(null);
}
SharePointContextToken contextToken = null;
try
{
contextToken = TokenHandler.ReadAndValidateContextToken(contextTokenString, httpRequest.Host.Value);
}
catch (WebException)
{
return(null);
}
catch (AudienceUriValidationFailedException)
{
return(null);
}
return(new SharePointAcsContext(spHostUrl, spAppWebUrl, spLanguage, spClientTag, spProductNumber, contextTokenString, contextToken, Configuration));
}
public Uploader(IHostingEnvironment _env, Microsoft.AspNet.Http.HttpRequest request)
{
this._env = _env;
this._request = request;
}
/// <summary> /// Creates a SharePointContext instance. /// </summary> /// <param name="spHostUrl">The SharePoint host url.</param> /// <param name="spAppWebUrl">The SharePoint app web url.</param> /// <param name="spLanguage">The SharePoint language.</param> /// <param name="spClientTag">The SharePoint client tag.</param> /// <param name="spProductNumber">The SharePoint product number.</param> /// <param name="httpRequest">The HTTP request.</param> /// <returns>The SharePointContext instance. Returns <c>null</c> if errors occur.</returns> protected abstract SharePointContext CreateSharePointContext(Uri spHostUrl, Uri spAppWebUrl, string spLanguage, string spClientTag, string spProductNumber, HttpRequest httpRequest);
