/// <summary> /// Adds the headers necessary to trigger HMAC signing if we don't already have an Authentication header. /// </summary> /// <param name="client"></param> /// <param name="headers"></param> public static void AddHmacClientHeaders(this IHmacClient client, HttpRequestHeaders headers) { var auth = headers.Authorization; if (auth != null) { return; } // Only bother if we don't have an authentication header? var clientId = client.ClientId; if (!string.IsNullOrEmpty(clientId)) { // Mark it so we know to sign the message headers.Add(HmacAuthentication.ClientIdHeader, clientId); // See if we have any custom headers var customHeaders = client.AddCustomHeaders(headers); if (!string.IsNullOrEmpty(customHeaders)) { // Ok, mark it so the signer knows to include them in the signature. headers.Add(HmacAuthentication.CustomHeaders, customHeaders.Trim()); } } }
public void CopyToMovesDataIntoArray() { IDictionary <string, StringValues> headers = new HttpRequestHeaders(); headers.Add("host", new[] { "localhost" }); headers.Add("Content-Length", new[] { "0" }); headers.Add("custom", new[] { "value" }); var entries = new KeyValuePair <string, StringValues> [5]; headers.CopyTo(entries, 1); Assert.Null(entries[0].Key); Assert.Equal(new StringValues(), entries[0].Value); Assert.Equal("Host", entries[1].Key); Assert.Equal(new[] { "localhost" }, entries[1].Value); Assert.Equal("Content-Length", entries[2].Key); Assert.Equal(new[] { "0" }, entries[2].Value); Assert.Equal("custom", entries[3].Key); Assert.Equal(new[] { "value" }, entries[3].Value); Assert.Null(entries[4].Key); Assert.Equal(new StringValues(), entries[4].Value); }
private static void InjectContext(HttpRequestHeaders headers, string traceId, string spanId, string samplingPriority, string origin) { headers.Add(HttpHeaderNames.TraceId, traceId); headers.Add(HttpHeaderNames.ParentId, spanId); headers.Add(HttpHeaderNames.SamplingPriority, samplingPriority); headers.Add(HttpHeaderNames.Origin, origin); }
/// <summary> /// Set <see cref="HttpRequestHeaders"/> using the <see cref="ApiHeaders"/>. This initially clears <paramref name="headers"/> /// </summary> /// <param name="headers">The <see cref="HttpRequestHeaders"/> to set</param> /// <param name="instanceId">The <see cref="Models.Instance.Id"/> for the request</param> public void SetRequestHeaders(HttpRequestHeaders headers, long?instanceId = null) { if (headers == null) { throw new ArgumentNullException(nameof(headers)); } if (instanceId.HasValue && InstanceId.HasValue && instanceId != InstanceId) { throw new InvalidOperationException("Specified instance ID in constructor and SetRequestHeaders!"); } headers.Clear(); headers.Accept.Add(new MediaTypeWithQualityHeaderValue(ApplicationJson)); if (IsTokenAuthentication) { headers.Authorization = new AuthenticationHeaderValue(JwtAuthenticationScheme, Token); } else { headers.Authorization = new AuthenticationHeaderValue(PasswordAuthenticationScheme, Password); headers.Add(UsernameHeader, Username); } headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent)); headers.Add(ApiVersionHeader, new ProductHeaderValue(AssemblyName.Name, ApiVersion.ToString()).ToString()); instanceId = instanceId ?? InstanceId; if (instanceId.HasValue) { headers.Add(InstanceIdHeader, instanceId.ToString()); } }
public void has_positive() { headers.Add("a", new string[] { "1", "2" }); request.HasHeader("a").ShouldBeTrue(); request.HasHeader("A").ShouldBeTrue(); }
/// <summary> /// Applies X-Forwarded.* headers to the outgoing header collection /// with an additional PathBase parameter. /// </summary> /// <param name="outgoingHeaders">The outgoing HTTP request /// headers.</param> /// <param name="for">The client IP address.</param> /// <param name="host">The host of the request.</param> /// <param name="proto">The protocol of the incoming request.</param> /// <param name="pathBase">The base path of the incoming /// request.</param> public static void ApplyXForwardedHeaders( this HttpRequestHeaders outgoingHeaders, IPAddress @for, HostString host, string proto, PathString pathBase) { if (@for != null) { var forString = @for.AddressFamily == AddressFamily.InterNetworkV6 ? $"\"[{@for}]\"" : @for.ToString(); outgoingHeaders.Add(XForwardedFor, forString); } if (host.HasValue) { outgoingHeaders.Add(XForwardedHost, host.Value); } if (!string.IsNullOrWhiteSpace(proto)) { outgoingHeaders.Add(XForwardedProto, proto); } if (!string.IsNullOrWhiteSpace(pathBase)) { outgoingHeaders.Add(XForwardedPathBase, pathBase); } }
public static void SetHeaderValue(this HttpRequestHeaders Headers, string code) { Headers.Add("sobeyhive-http-system", "INGESTSERVER"); Headers.Add("sobeyhive-http-site", "S1"); Headers.Add("sobeyhive-http-tool", "INGESTSERVER"); Headers.Add("sobeyhive-http-secret", RSAHelper.RSAstr()); Headers.Add("current-user-code", code); }
/// <summary> /// SetHikSecurityHeaders /// </summary> /// <param name="headers">headers</param> /// <param name="body">body</param> /// <param name="url">url</param> /// <param name="data">data</param> /// <param name="method">method</param> /// <returns></returns> public static HttpRequestHeaders SetHikSecurityHeaders(this HttpRequestHeaders headers, string body, string url, object data, string method) { var formData = new Dictionary <string, string>(); if (data != null) { Type t = data.GetType(); PropertyInfo[] pi = t.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo p in pi) { MethodInfo mi = p.GetGetMethod(); if (mi != null && mi.IsPublic) { formData.Add(p.Name, mi.Invoke(data, new Object[] { })?.ToString()); } } } headers.Date = DateTimeOffset.Now; var securityHeaders = GetHikSecurityHeaders(headers, method, url, formData); var allHeaders = new Dictionary <string, string>(); foreach (var header in headers) { if (header.Value?.Count() > 0) { if (header.Key.Equals("url")) { continue; } allHeaders.Add(header.Key, header.Value?.FirstOrDefault() ?? ""); } } var sign = BuildStringToSign(securityHeaders, allHeaders); headers.Add("X-Ca-Signature", HmacSha256(sign)); if (securityHeaders.Count > 0) { string secheaders = ""; foreach (var securityHeader in securityHeaders) { secheaders += $@"{securityHeader.Key}:{securityHeader.Value} ,"; } headers.Add("X-Ca-Signature-Headers", secheaders.TrimEnd(',')); } headers.Add("appKey", new List <string>() { HikSecurityContext.ArtemisAppKey }); headers.Add("appSecret", new List <string>() { HikSecurityContext.ArtemisAppSecret }); return(headers); }
protected virtual void AddCommonHeaders(HttpRequestHeaders headers, AccessToken accessToken) { if (!string.IsNullOrWhiteSpace(accessToken?.Token)) { headers.Add("X-Acrolinx-Auth", accessToken.Token); } headers.Add("X-Acrolinx-Base-Url", this.acrolinxUrl); headers.Add("X-Acrolinx-Client-Locale", this.clientLocale); headers.Add("X-Acrolinx-Client", this.clientSignature + "; " + this.clientVersion); headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
public static void SetAvailabilityTestRequestHeaders(this HttpClient httpClient, string testInfoDescriptor, string testInvocationInstanceDescriptor) { Validate.NotNull(httpClient, nameof(httpClient)); Validate.NotNullOrWhitespace(testInfoDescriptor, nameof(testInfoDescriptor)); Validate.NotNullOrWhitespace(testInvocationInstanceDescriptor, nameof(testInvocationInstanceDescriptor)); HttpRequestHeaders headers = httpClient.DefaultRequestHeaders; headers.Add(Format.AvailabilityTest.HttpHeaderNames.TestInfoDescriptor, Format.SpellIfNull(testInfoDescriptor)); headers.Add(Format.AvailabilityTest.HttpHeaderNames.TestInvocationInstanceDescriptor, Format.SpellIfNull(testInvocationInstanceDescriptor)); }
/// <summary> /// An internal method, used for preparing http headers for get and post request. /// </summary> protected void PrepareHeader(HttpRequestHeaders header) { header.Add( "user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.90 Safari/537.36" ); header.Add( "accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3" ); }
public async Task <bool> FollowUser(string githubAccessToken, string userName) { using (HttpClient client = new HttpClient()) { HttpRequestHeaders headers = client.DefaultRequestHeaders; headers.Add("Authorization", string.Format("token {0}", githubAccessToken)); headers.Add("User-Agent", "PrimarySchool"); HttpResponseMessage response = await client.PutAsync($"https://api.github.com/user/following/{userName}", new StringContent(string.Empty)); return(response.StatusCode == System.Net.HttpStatusCode.NoContent); } }
public static void SetRequestProperties(HttpRequestHeaders headers, UnleashConfig config) { headers.Add(UNLEASH_APP_NAME_HEADER, config.AppName); headers.Add(UNLEASH_INSTANCE_ID_HEADER, config.InstanceId); headers.Add("User-Agent", config.AppName); config .CustomHttpHeaders .Keys .ToList() .ForEach(key => headers.Add(key, config.CustomHttpHeaders[key])); }
private void SetHeaders(HttpRequestHeaders headers, Dictionary <string, string> newHeaders) { if (newHeaders != null) { foreach (var header in newHeaders) { headers.Add(header.Key, header.Value); } } headers.Add("sino", "nacos"); }
public static void add(this HttpRequestHeaders headers, string name, string value) { if (!headers.Contains(name)) { headers.Add(name, value); } else { headers.Remove(name); headers.Add(name, value); } }
private void AddCommonAuthHeaders(HttpRequestHeaders headers, string referrer) { headers.Add("Accept-Language", "en-US,en;q=0.5"); headers.Add("Connection", "keep-alive"); headers.Add("Pragma", "no-cache"); headers.Add("Cache-Control", "no-cache"); headers.Host = "account.sonnen.de"; if (!string.IsNullOrWhiteSpace(referrer)) { headers.Referrer = new Uri(referrer); } headers.TryAddWithoutValidation("User-Agent", _userAgent); }
private void SetRequestHeaders(HttpRequestHeaders httpRequestHeaders, string userAgent, string authorizationToken, string etag) { httpRequestHeaders.Accept.Clear(); httpRequestHeaders.Add("User-agent", userAgent); httpRequestHeaders.Add("Authorization", string.Format("Token {0}", authorizationToken)); if (!string.IsNullOrEmpty(etag)) { httpRequestHeaders.Add("If-None-Match", string.Format(@"{0}", etag)); } httpRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
private static void InjectW3CHeaders(Activity currentActivity, HttpRequestHeaders requestHeaders) { if (!requestHeaders.Contains(W3C.W3CConstants.TraceParentHeader)) { requestHeaders.Add(W3C.W3CConstants.TraceParentHeader, currentActivity.Id); } if (!requestHeaders.Contains(W3C.W3CConstants.TraceStateHeader) && currentActivity.TraceStateString != null) { requestHeaders.Add(W3C.W3CConstants.TraceStateHeader, currentActivity.TraceStateString); } }
private async Task <HttpResponseMessage> GetServiceConnectionAsync(string urlFragment, string method, string?body, UnidentifiedAccess?unidentifiedAccess, CancellationToken?token = null) { if (token == null) { token = CancellationToken.None; } try { SignalUrl signalUrl = GetRandom(SignalConnectionInformation.SignalServiceUrls); string url = signalUrl.Url; string? hostHeader = signalUrl.HostHeader; Uri uri = new Uri(string.Format("{0}{1}", url, urlFragment)); HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), uri); if (body != null) { request.Content = new StringContent(body, Encoding.UTF8, "application/json"); } HttpRequestHeaders headers = request.Headers; if (unidentifiedAccess != null) { headers.Add("Unidentified-Access-Key", Base64.EncodeBytes(unidentifiedAccess.UnidentifiedAccessKey)); } if (CredentialsProvider.Password != null) { string authHeader = GetAuthorizationHeader(CredentialsProvider); headers.Add("Authorization", authHeader); } if (UserAgent != null) { headers.Add("X-Signal-Agent", UserAgent); } if (hostHeader != null) { headers.Host = hostHeader; } return(await httpClient.SendAsync(request, token.Value)); } catch (Exception e) { Logger.LogError("GetServiceConnectionAsync() failed: {0}\n{1}", e.Message, e.StackTrace); throw new PushNetworkException(e); } }
void AddNpmHeaders(IActivityMonitor m, HttpRequestHeaders headers) { if (NpmInCi) { headers.Add("npm-in-ci", NpmInCi.ToString().ToLower()); //json type are lowercase m.Info("Detected that we are running in CI. Sending to the registry an header indicating it."); } headers.Add("npm-session", _session); headers.Add("user-agent", _userAgent); if (_authHeader != null) { headers.Authorization = _authHeader; } }
private static void Add(this HttpRequestHeaders requestHeaders, string name, string value, Dictionary <string, List <string> > headers) { List <string> values; if (headers != null && headers.TryGetValue(name, out values)) { requestHeaders.Add(name, values); headers.Remove(name); } else { requestHeaders.Add(name, value); } }
public static void SetSecPolicy(this HttpRequestHeaders headers, string?mode = "cors", string?site = "same-site", string?dest = "empty") { if (!string.IsNullOrEmpty(mode)) { headers.Add("Sec-Fetch-Mode", mode); } if (!string.IsNullOrEmpty(site)) { headers.Add("Sec-Fetch-Site", site); } if (!string.IsNullOrEmpty(dest)) { headers.Add("Sec-Fetch-Dest", dest); } }
static void Main(string[] args) { //REAd configuration file into string string filecontent = ReadConfigurationFile("E:/c#/weatherProgram/world/cities.json"); //parse filecontent CityConfig[] cityConfigArray = new JavaScriptSerializer().Deserialize <CityConfig[]>(filecontent); Weather weather = new Weather(); Console.WriteLine(weather.str); foreach (CityConfig cityConfig in cityConfigArray) { Console.WriteLine(cityConfig.city); float tempkdp = weather.GetCurrentTemperature(cityConfig.city, cityConfig.countrycode); Console.WriteLine("temperature : " + tempkdp); //body // HttpClient post HttpClient httpClient = new HttpClient(); // (httpClient.DefaultRequestHeaders).Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpRequestHeaders httpRequestHeaders = httpClient.DefaultRequestHeaders; // HttpHeaderValueCollection<MediaTypeWithQualityHeaderValue> httpHeaderValueCollection = httpRequestHeaders.Accept; // MediaTypeWithQualityHeaderValue mediaTypeWithQualityHeaderValue = new MediaTypeWithQualityHeaderValue("application/json"); // httpHeaderValueCollection.Add(mediaTypeWithQualityHeaderValue); httpRequestHeaders.Add("X-Insert-Key", "jzsjmfl5Qmntrkfrn28XL5VOTVkYU3ju"); // httpRequestHeaders.Add("Content-Type", "application/json"); httpRequestHeaders.Add("xyz", "abc"); StringContent content = new StringContent("[{\"city\":\"" + cityConfig.city + "\", \"countryCode\":\"" + cityConfig.countrycode + "\" , \"eventType\":\"Temperature\" , \"temperature\":" + tempkdp + "}]", Encoding.UTF8, "application/json"); Console.WriteLine(content.ReadAsStringAsync().Result); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var result = httpClient.PostAsync("https://insights-collector.newrelic.com/v1/accounts/1245525/events", content).Result; if (result.IsSuccessStatusCode) { Console.WriteLine("SUCCESSFULLY POSTED DATA TO NEWRELIC"); } else { Console.WriteLine("FAILED TO SNED"); Console.WriteLine(result.ReasonPhrase); } } Console.ReadKey(); }
protected void FillRequestHeadersWithCommonHeaders(HttpRequestHeaders headers) { foreach (var item in _options.CommonHeaders) { headers.Add(item.Key, item.Value); } }
// Generates a random expected response content length and adds it to the request headers public int SetExpectedResponseContentLengthHeader(HttpRequestHeaders headers, int minLength = 0) { int expectedResponseContentLength = _random.Next(minLength, Math.Max(minLength, MaxContentLength)); headers.Add(StressServer.ExpectedResponseContentLength, expectedResponseContentLength.ToString()); return(expectedResponseContentLength); }
/// <summary> /// Sets test mode header. /// </summary> /// <param name="headers">The http request header.</param> /// <param name="value">The header value.</param> public static void SetTestMode(this HttpRequestHeaders headers, string value) { if (!string.IsNullOrWhiteSpace(value)) { headers.Add("x-bz-test-mode", value); } }
/// <summary> /// Sets part number header. /// </summary> /// <param name="headers">The http request header.</param> /// <param name="value">The header value.</param> public static void SetPartNumber(this HttpRequestHeaders headers, int value) { if (value != 0) { headers.Add("x-bz-part-number", value.ToString()); } }
public void Headers_Response() { HttpRequestMessage message = new HttpRequestMessage(); HttpRequestHeaders headers = message.Headers; headers.Add("Age", "vv"); Assert.AreEqual("vv", headers.GetValues("Age").First(), "#1"); headers.Clear(); headers.TryAddWithoutValidation("Age", "vv"); Assert.AreEqual("vv", headers.GetValues("Age").First(), "#2"); // .NET encloses the "Age: vv" with two whitespaces. var normalized = Regex.Replace(message.ToString(), @"\s", ""); #if !__WATCHOS__ if (HttpClientTestHelpers.UsingSocketsHandler) #endif Assert.AreEqual("Method:GET,RequestUri:'<null>',Version:2.0,Content:<null>,Headers:{Age:vv}", normalized, "#3"); #if !__WATCHOS__ else { Assert.AreEqual("Method:GET,RequestUri:'<null>',Version:1.1,Content:<null>,Headers:{Age:vv}", normalized, "#3"); } #endif }
public static void AddIdempotencyHeader(this HttpRequestHeaders @this, string idempotencyToken) { @this.ThrowIfNull(typeof(HttpRequestHeaders).Name.ToLower()); idempotencyToken.ThrowIfNullOrWhiteSpace(nameof(idempotencyToken)); @this.Add(IdempotencyHeader, idempotencyToken); }
private void CopyHeaders(string prefix, IHeaderDictionary sourceHeaders, HttpRequestHeaders destinationHeaders) { foreach (var sourceHeader in sourceHeaders) { if (ShouldAddHeader(sourceHeader.Key) && !destinationHeaders.Contains(sourceHeader.Key)) { var sourceHeaderValues = sourceHeader.Value.First().Split(';'); var cookieValues = new List <string>(); foreach (var sourceHeaderValue in sourceHeaderValues) { var sourceHeaderValueTrimmed = sourceHeaderValue.Trim(); if (ShouldAddCookie(prefix, sourceHeaderValueTrimmed)) { var cookieKey = GetCookieKey(prefix, sourceHeaderValueTrimmed); var cookieValue = GetCookieValue(sourceHeaderValueTrimmed); cookieValue = Uri.UnescapeDataString(cookieValue); cookieValue = $"{cookieKey}={cookieValue}"; cookieValues.Add(cookieValue); } } if (cookieValues.Any()) { destinationHeaders.Add(HeaderNames.Cookie, cookieValues); } } } }