void SetAllowCredentials(IHttpResponse response)
{
if (this.config.IsCredentialsAllowed &&
!AsciiString.ContentEquals(response.Headers.Get(HttpHeaderNames.AccessControlAllowOrigin, null), AnyOrigin))
{
response.Headers.Set(HttpHeaderNames.AccessControlAllowCredentials, new AsciiString("true"));
}
}
private static void TestValueIteratorSingleValue(IHttp2Headers headers, ICharSequence name, ICharSequence value)
{
var itr = headers.GetAll(name).GetEnumerator();
Assert.True(itr.MoveNext());
Assert.True(AsciiString.ContentEqualsIgnoreCase(value, itr.Current));
Assert.False(itr.MoveNext());
}
public void PreflightRequestAllowCredentials()
{
var origin = new AsciiString("null");
CorsConfig config = CorsConfigBuilder.ForOrigin(origin).AllowCredentials().Build();
IHttpResponse response = PreflightRequest(config, origin.ToString(), "content-type, xheader1");
Assert.Equal("true", response.Headers.Get(HttpHeaderNames.AccessControlAllowCredentials, null));
}
public void SubStringHashCode()
{
var value1 = new AsciiString("123");
var value2 = new AsciiString("a123".Substring(1));
//two "123"s
Assert.Equal(AsciiString.GetHashCode(value1), AsciiString.GetHashCode(value2));
}
public void SimpleRequestWithOrigin()
{
var origin = new AsciiString("http://localhost:8888");
IHttpResponse response = SimpleRequest(CorsConfigBuilder.ForOrigin(origin).Build(), origin.ToString());
Assert.Equal(origin, response.Headers.Get(HttpHeaderNames.AccessControlAllowOrigin, null));
Assert.Null(response.Headers.Get(HttpHeaderNames.AccessControlAllowHeaders, null));
}
static void AssertContains(string a, string b, bool caseSensitiveEquals, bool caseInsenstaiveEquals)
{
var asciiA = new AsciiString(a);
var asciiB = new AsciiString(b);
Assert.Equal(caseSensitiveEquals, AsciiString.Contains(asciiA, asciiB));
Assert.Equal(caseInsenstaiveEquals, AsciiString.ContainsIgnoreCase(asciiA, asciiB));
}
public void ContentEqualsIgnoreCase()
{
byte[] bytes = { 32, (byte)'a' };
AsciiString asciiString = new AsciiString(bytes, 1, 1, false);
// https://github.com/netty/netty/issues/9475
Assert.False(asciiString.ContentEqualsIgnoreCase(new StringCharSequence("b")));
Assert.False(asciiString.ContentEqualsIgnoreCase(AsciiString.Of("b")));
}
public void AsciiStringLookupByIndexReturnsExpectedCharacter()
{
const char expected = 'u';
string value = "9quali52ty3";
var ascii = new AsciiString(value);
Assert.AreEqual(expected, ascii[2]);
}
public void AsciiStringGetHashCodeReturnsDifferentCodeIfAsciiStringsAreNotEqual()
{
string value = "9quali52ty3";
AsciiString asciiString1 = new AsciiString(value);
AsciiString asciiString2 = new AsciiString(value.Reverse());
Assert.AreNotEqual(asciiString1.GetHashCode(), asciiString2.GetHashCode());
}
public void AsciiStringGetHashCodeReturnsSameCodeIfAsciiStringsAreEqual()
{
string value = "9quali52ty3";
AsciiString asciiString1 = new AsciiString(value);
AsciiString asciiString2 = new AsciiString(value);
Assert.AreEqual(asciiString1.GetHashCode(), asciiString2.GetHashCode());
}
public TransactionInput(byte[] transactionHash, uint outputIndex, AsciiString scriptSignature, uint sequence)
{
TransactionHash = transactionHash;
OutputIndex = outputIndex;
Sequence = sequence;
ScriptSignature = scriptSignature;
Size = transactionHash.Length + sizeof(uint) + scriptSignature.Size + sizeof(uint);
}
protected internal ZlibWrapper?DetermineWrapper(ICharSequence acceptEncoding)
{
float starQ = -1.0f;
float gzipQ = -1.0f;
float deflateQ = -1.0f;
ICharSequence[] parts = CharUtil.Split(acceptEncoding, ',');
foreach (ICharSequence encoding in parts)
{
float q = 1.0f;
int equalsPos = encoding.IndexOf('=');
if (equalsPos != -1)
{
try
{
var ddd = encoding.ToString(equalsPos + 1);
q = float.Parse(encoding.ToString(equalsPos + 1));
}
catch (FormatException)
{
// Ignore encoding
q = 0.0f;
}
}
if (encoding.Contains('*'))
{
starQ = q;
}
else if (AsciiString.Contains(encoding, GZipString) && q > gzipQ)
{
gzipQ = q;
}
else if (AsciiString.Contains(encoding, DeflateString) && q > deflateQ)
{
deflateQ = q;
}
}
if (gzipQ > 0.0f || deflateQ > 0.0f)
{
return(gzipQ >= deflateQ ? ZlibWrapper.Gzip : ZlibWrapper.Zlib);
}
if (starQ > 0.0f)
{
// ReSharper disable CompareOfFloatsByEqualityOperator
if (gzipQ == -1.0f)
{
return(ZlibWrapper.Gzip);
}
if (deflateQ == -1.0f)
{
return(ZlibWrapper.Zlib);
}
// ReSharper restore CompareOfFloatsByEqualityOperator
}
return(null);
}
/// <summary>
/// 发送消息并清空缓冲区。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public async Task SendAndFlushAsync(TransportMessage message)
{
var buffer = GetByteBuffer(message, out int contentLength);
var response = WriteResponse(_context, buffer, TypeJson, AsciiString.Cached($"{ contentLength}"));
await _context.WriteAndFlushAsync(response);
await _context.CloseAsync();
}
public void TestExceptionDuringConnect()
{
IEventLoopGroup group = null;
IChannel serverChannel = null;
IChannel clientChannel = null;
try
{
group = new DefaultEventLoopGroup(1);
var addr = new LocalAddress("a");
var exception = new AtomicReference <Exception>();
var sf =
new ServerBootstrap().Channel <LocalServerChannel>().Group(group).ChildHandler(
new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddFirst(new HttpResponseEncoder());
var response = new DefaultFullHttpResponse(
HttpVersion.Http11,
HttpResponseStatus.BadGateway);
response.Headers.Add(AsciiString.Of("name"), "value");
response.Headers.Add(HttpHeaderNames.ContentLength, "0");
ch.WriteAndFlushAsync(response);
}
)).BindAsync(addr);
serverChannel = sf.Result;
var cf = new Bootstrap().Channel <LocalChannel>().Group(group).Handler(
new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddFirst(new HttpProxyHandler(addr));
ch.Pipeline.AddLast(new ErrorCaptureHandler(exception));
})).ConnectAsync(new DnsEndPoint("localhost", 1234));
clientChannel = cf.Result;
clientChannel.CloseAsync().Wait();
Assert.True(exception.Value is HttpProxyConnectException);
var actual = (HttpProxyConnectException)exception.Value;
Assert.NotNull(actual.Headers);
Assert.Equal("value", actual.Headers.GetAsString(AsciiString.Of("name")));
}
finally
{
if (clientChannel != null)
{
clientChannel.CloseAsync();
}
if (serverChannel != null)
{
serverChannel.CloseAsync();
}
if (group != null)
{
@group.ShutdownGracefullyAsync().Wait();
}
}
}
public void AsciiStringsOfDifferentInputStringAreNotEqual()
{
string value1 = "9quali52ty3";
string value2 = "3yt25ilauq9";
var ascii1 = new AsciiString(value1);
var ascii2 = new AsciiString(value2);
Assert.AreNotEqual(ascii1, ascii2);
}
// Fast-Path implementation
internal static int WriteAscii(AbstractByteBuffer buffer, int writerIndex, ICharSequence seq, int len)
{
// We can use the _set methods as these not need to do any index checks and reference checks.
// This is possible as we called ensureWritable(...) before.
for (int i = 0; i < len; i++)
{
buffer._SetByte(writerIndex++, AsciiString.CharToByte(seq[i]));
}
return(len);
}
public void TestGet()
{
var headers = NewClientHeaders();
Assert.True(AsciiString.ContentEqualsIgnoreCase((AsciiString)"value1", headers.Get((AsciiString)"Name1", null)));
Assert.True(AsciiString.ContentEqualsIgnoreCase((AsciiString)"/foo",
headers.Get(PseudoHeaderName.Path.Value, null)));
Assert.Null(headers.Get(PseudoHeaderName.Status.Value, null));
Assert.Null(headers.Get((AsciiString)"a missing header", null));
}
public override bool Equals(object obj)
{
AsciiString other = obj as AsciiString;
if (other != null)
{
return(_str == other._str);
}
return(false);
}
public void SimpleRequestWithNoMatchingOrigin()
{
var origin = new AsciiString("http://localhost:8888");
IHttpResponse response = SimpleRequest(CorsConfigBuilder.ForOrigins(
new AsciiString("https://localhost:8888")).Build(), origin.ToString());
Assert.Null(response.Headers.Get(HttpHeaderNames.AccessControlAllowOrigin, null));
Assert.Null(response.Headers.Get(HttpHeaderNames.AccessControlAllowHeaders, null));
Assert.True(ReferenceCountUtil.Release(response));
}
public void AsciiStringsOfDifferentInputNotEqualsOperatorReturnsTrue()
{
string value1 = "9quali52ty3";
string value2 = "3yt25ilauq9";
var ascii1 = new AsciiString(value1);
var ascii2 = new AsciiString(value2);
Assert.IsTrue(ascii1 != ascii2);
}
public HttpServerUpgradeHandler.IUpgradeCodec NewUpgradeCodec(ICharSequence protocol)
{
if (AsciiString.ContentEquals(Http2CodecUtil.HttpUpgradeProtocolName, protocol))
{
return(new Http2ServerUpgradeCodec(Http2FrameCodecBuilder.ForServer().Build(), new HelloWorldHttp2Handler()));
}
else
{
return(null);
}
}
/// <summary>
/// Returns true if the server switched to a different protocol than HTTP/1.0 or HTTP/1.1, e.g. HTTP/2 or Websocket.
/// Returns false if the upgrade happened in a different layer, e.g. upgrade from HTTP/1.1 to HTTP/1.1 over TLS.
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
protected bool IsSwitchingToNonHttp1Protocol(IHttpResponse msg)
{
if (msg.Status.Code != StatusCodes.Status101SwitchingProtocols)
{
return(false);
}
return(!msg.Headers.TryGet(HttpHeaderNames.Upgrade, out ICharSequence newProtocol) ||
!AsciiString.Contains(newProtocol, HttpVersion.Http10String) &&
!AsciiString.Contains(newProtocol, HttpVersion.Http11String));
}
public void GlobalSetup()
{
var bytes = new byte[this.Size];
RandomGenerator.NextBytes(bytes);
this.asciiString = new AsciiString(bytes, false);
string value = Encoding.ASCII.GetString(bytes);
this.stringValue = new StringCharSequence(value);
}
private static IHttp2Headers HeadersOfSize(int minSize)
{
AsciiString singleByte = new AsciiString(new byte[] { 0 }, false);
DefaultHttp2Headers headers = new DefaultHttp2Headers(false);
for (int size = 0; size < minSize; size += 2)
{
headers.Add(singleByte, singleByte);
}
return(headers);
}
private static IHttp2Headers Headers()
{
var headers = new DefaultHttp2Headers(false);
headers.Method = AsciiString.Of("GET");
headers.Scheme = AsciiString.Of("https");
headers.Authority = AsciiString.Of("example.org");
headers.Path = AsciiString.Of("/some/path/resource2");
headers.Add(Http2TestUtil.RandomString(), Http2TestUtil.RandomString());
return(headers);
}
public char this[int index]
{
get
{
if (index > _pos)
{
ThrowHelper.ThrowIndexOutOfRangeException();
}
return(AsciiString.ByteToChar(_chars[index]));
}
}
public void StaticIndexOfChar()
{
Assert.Equal(-1, AsciiString.IndexOf(null, 'a', 0));
Assert.Equal(-1, AsciiString.IndexOf((AsciiString)"", 'a', 0));
Assert.Equal(-1, AsciiString.IndexOf((AsciiString)"abc", 'd', 0));
Assert.Equal(-1, AsciiString.IndexOf((AsciiString)"aabaabaa", 'A', 0));
Assert.Equal(0, AsciiString.IndexOf((AsciiString)"aabaabaa", 'a', 0));
Assert.Equal(1, AsciiString.IndexOf((AsciiString)"aabaabaa", 'a', 1));
Assert.Equal(3, AsciiString.IndexOf((AsciiString)"aabaabaa", 'a', 2));
Assert.Equal(3, AsciiString.IndexOf((AsciiString)"aabdabaa", 'd', 1));
}
public void AsciiStringSubStringReturnsExpectedFullSubString()
{
string value = "9quali52ty3";
string expected = value.Substring(0, value.Length);
var ascii = new AsciiString(value);
var subString = ascii.SubString(0, value.Length);
Assert.AreEqual(expected, subString.ToString());
}
private static IHttp2Headers LargeHeaders()
{
DefaultHttp2Headers headers = new DefaultHttp2Headers(false);
for (int i = 0; i < 100; ++i)
{
string key = "this-is-a-test-header-key-" + i;
string value = "this-is-a-test-header-value-" + i;
headers.Add(AsciiString.Of(key), AsciiString.Of(value));
}
return(headers);
}
/// <summary>
/// Create a new read only representation of headers used by clients.
/// </summary>
/// <param name="validateHeaders"><c>true</c> will run validation on each header name/value pair to ensure protocol
/// compliance.</param>
/// <param name="method">The value for <see cref="PseudoHeaderName.Method"/>.</param>
/// <param name="path">The value for <see cref="PseudoHeaderName.Path"/>.</param>
/// <param name="scheme">The value for <see cref="PseudoHeaderName.Scheme"/>.</param>
/// <param name="authority">The value for <see cref="PseudoHeaderName.Authority"/>.</param>
/// <param name="otherHeaders">A an array of key:value pairs. Must not contain any
/// <a href="https://tools.ietf.org/html/rfc7540#section-8.1.2.1">pseudo headers</a>
/// or <c>null</c> names/values.
/// A copy will <strong>NOT</strong> be made of this array. If the contents of this array
/// may be modified externally you are responsible for passing in a copy.</param>
/// <returns>a new read only representation of headers used by clients.</returns>
public static ReadOnlyHttp2Headers ClientHeaders(bool validateHeaders,
AsciiString method, AsciiString path, AsciiString scheme, AsciiString authority,
params AsciiString[] otherHeaders)
{
return(new ReadOnlyHttp2Headers(validateHeaders,
new AsciiString[]
{
PseudoHeaderName.Method.Value, method, PseudoHeaderName.Path.Value, path,
PseudoHeaderName.Scheme.Value, scheme, PseudoHeaderName.Authority.Value, authority
},
otherHeaders));
}
public void GoToUrl (string url)
{
int index = -1;
nsISHistory history;
navigation.navigation.getSessionHistory(out history);
int count = Count;
nsIHistoryEntry entry;
for (int i = 0; i < count; i++) {
nsIURI uri;
history.getEntryAtIndex(i, false, out entry);
entry.getURI (out uri);
AsciiString spec = new AsciiString(String.Empty);
uri.getSpec (spec.Handle);
if (string.Compare (spec.ToString (), url, true) == 0) {
index = i;
break;
}
}
if (index > -1)
this.GoToIndex (index);
}
