public void FilenameContainingSemicolon2() { const string Boundary = "dLV9Wyq26L_-JQxk6ferf-RT153LhOO"; var req = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); req.Headers.Add(HttpHeaderNames.ContentType, "multipart/form-data; boundary=" + Boundary); // Force to use memory-based data. var inMemoryFactory = new DefaultHttpDataFactory(false); const string Data = "asdf"; const string Filename = "tmp;0.txt"; const string Body = "--" + Boundary + "\r\n" + "Content-Disposition: form-data; name=\"file\"; filename=\"" + Filename + "\"\r\n" + "Content-Type: image/gif\r\n" + "\r\n" + Data + "\r\n" + "--" + Boundary + "--\r\n"; req.Content.WriteBytes(Encoding.UTF8.GetBytes(Body)); var decoder = new HttpPostRequestDecoder(inMemoryFactory, req); List <IInterfaceHttpData> list = decoder.GetBodyHttpDatas(); Assert.NotNull(list); Assert.False(list.Count == 0); IInterfaceHttpData part1 = list[0]; Assert.IsAssignableFrom <IFileUpload>(part1); var fileUpload = (IFileUpload)part1; Assert.Equal("tmp 0.txt", fileUpload.FileName); decoder.Destroy(); }
public void TestEncodeHttpsSchemeWhenSslHandlerExists() { var frames = new ConcurrentQueue <IHttp2StreamFrame>(); var ch = new EmbeddedChannel(new TestChannelOutboundHandlerAdapter(frames), new Http2StreamFrameToHttpObjectCodec(false)); try { var req = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "/hello/world"); Assert.True(ch.WriteOutbound(req)); ch.FinishAndReleaseAll(); frames.TryDequeue(out var streamFrame); var headersFrame = (IHttp2HeadersFrame)streamFrame; var headers = headersFrame.Headers; Assert.Equal("http", headers.Scheme); Assert.Equal("GET", headers.Method); Assert.Equal("/hello/world", headers.Path); Assert.True(headersFrame.IsEndStream); Assert.False(frames.TryDequeue(out _)); } finally { ch.FinishAndReleaseAll(); } }
public void TestEncodeEmptyFullRequestWithTrailers() { EmbeddedChannel ch = new EmbeddedChannel(new Http2StreamFrameToHttpObjectCodec(false)); IFullHttpRequest request = new DefaultFullHttpRequest( HttpVersion.Http11, HttpMethod.Put, "/hello/world"); HttpHeaders trailers = request.TrailingHeaders; trailers.Set((AsciiString)"key", "value"); Assert.True(ch.WriteOutbound(request)); var headersFrame = ch.ReadOutbound <IHttp2HeadersFrame>(); IHttp2Headers headers = headersFrame.Headers; Assert.Equal("http", headers.Scheme); Assert.Equal("PUT", headers.Method); Assert.Equal("/hello/world", headers.Path); Assert.False(headersFrame.IsEndStream); IHttp2HeadersFrame trailersFrame = ch.ReadOutbound <IHttp2HeadersFrame>(); Assert.Equal("value", trailersFrame.Headers.Get((AsciiString)"key", null)); Assert.True(trailersFrame.IsEndStream); Assert.Null(ch.ReadOutbound()); Assert.False(ch.Finish()); }
public void DecodesFinalResponseAfterSwitchingProtocols() { const string SwitchingProtocolsResponse = "HTTP/1.1 101 Switching Protocols\r\n" + "Connection: Upgrade\r\n" + "Upgrade: TLS/1.2, HTTP/1.1\r\n\r\n"; var codec = new HttpClientCodec(4096, 8192, 8192, true); var ch = new EmbeddedChannel(codec, new HttpObjectAggregator(1024)); IHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "http://localhost/"); request.Headers.Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade); request.Headers.Set(HttpHeaderNames.Upgrade, "TLS/1.2"); Assert.True(ch.WriteOutbound(request), "Channel outbound write failed."); Assert.True( ch.WriteInbound(Unpooled.CopiedBuffer(Encoding.UTF8.GetBytes(SwitchingProtocolsResponse))), "Channel inbound write failed."); var switchingProtocolsResponse = ch.ReadInbound <IFullHttpResponse>(); Assert.NotNull(switchingProtocolsResponse); switchingProtocolsResponse.Release(); Assert.True( ch.WriteInbound(Unpooled.CopiedBuffer(Encoding.UTF8.GetBytes(Response))), "Channel inbound write failed"); var finalResponse = ch.ReadInbound <IFullHttpResponse>(); Assert.NotNull(finalResponse); finalResponse.Release(); Assert.True(ch.FinishAndReleaseAll(), "Channel finish failed"); }
public void MultipleCookieEntriesAreCombined() { this.BootstrapEnv(2, 1, 0); IFullHttpRequest request = new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Get, "http://[email protected]:5555/example"); HttpHeaders httpHeaders = request.Headers; httpHeaders.SetInt(HttpConversionUtil.ExtensionHeaderNames.StreamId, 5); httpHeaders.Set(HttpHeaderNames.Host, "[email protected]:5555"); httpHeaders.Set(HttpConversionUtil.ExtensionHeaderNames.Scheme, "http"); httpHeaders.Set(HttpHeaderNames.Cookie, "a=b; c=d; e=f"); var http2Headers = new DefaultHttp2Headers() { Method = new AsciiString("GET"), Path = new AsciiString("/example"), Authority = new AsciiString("www.example.org:5555"), Scheme = new AsciiString("http") }; http2Headers.Add(HttpHeaderNames.Cookie, new AsciiString("a=b")); http2Headers.Add(HttpHeaderNames.Cookie, new AsciiString("c=d")); http2Headers.Add(HttpHeaderNames.Cookie, new AsciiString("e=f")); var writePromise = this.NewPromise(); this.VerifyHeadersOnly(http2Headers, writePromise, this.clientChannel.WriteAndFlushAsync(request, writePromise)); }
public void KeepAlive(bool isKeepAliveResponseExpected, HttpVersion httpVersion, HttpResponseStatus responseStatus, string sendKeepAlive, int setSelfDefinedMessageLength, ICharSequence setResponseConnection) { var channel = new EmbeddedChannel(new HttpServerKeepAliveHandler()); var request = new DefaultFullHttpRequest(httpVersion, HttpMethod.Get, "/v1/foo/bar"); HttpUtil.SetKeepAlive(request, RequestKeepAlive.Equals(sendKeepAlive)); var response = new DefaultFullHttpResponse(httpVersion, responseStatus); if (!CharUtil.IsNullOrEmpty(setResponseConnection)) { response.Headers.Set(HttpHeaderNames.Connection, setResponseConnection); } SetupMessageLength(setSelfDefinedMessageLength, response); Assert.True(channel.WriteInbound(request)); var requestForwarded = channel.ReadInbound <object>(); Assert.Equal(request, requestForwarded); ReferenceCountUtil.Release(requestForwarded); channel.WriteAndFlushAsync(response).Wait(TimeSpan.FromSeconds(1)); var writtenResponse = channel.ReadOutbound <IHttpResponse>(); Assert.Equal(isKeepAliveResponseExpected, channel.Open); Assert.Equal(isKeepAliveResponseExpected, HttpUtil.IsKeepAlive(writtenResponse)); ReferenceCountUtil.Release(writtenResponse); Assert.False(channel.FinishAndReleaseAll()); }
protected override object NewInitialMessage(IChannelHandlerContext ctx) { if (!TryParseEndpoint(DestinationAddress, out string hostnameString, out int port)) { throw new NotSupportedException($"Endpoint {DestinationAddress} is not supported as http proxy destination"); } string url = hostnameString + ":" + port; string hostHeader = _ignoreDefaultPortsInConnectHostHeader && (port == 80 || port == 443) ? hostnameString : url; IFullHttpRequest req = new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Connect, url, Unpooled.Empty, false); req.Headers.Set(HttpHeaderNames.Host, hostHeader); if (_authorization != null) { req.Headers.Set(HttpHeaderNames.ProxyAuthorization, _authorization); } if (_outboundHeaders != null) { req.Headers.Add(_outboundHeaders); } return(req); }
public void SingleFileUploadNoName() { var request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); var encoder = new HttpPostRequestEncoder(request, true); FileStream fileStream = File.Open("./Multipart/file-01.txt", FileMode.Open, FileAccess.Read); this.files.Add(fileStream); encoder.AddBodyAttribute("foo", "bar"); encoder.AddBodyFileUpload("quux", "", fileStream, "text/plain", false); string multipartDataBoundary = encoder.MultipartDataBoundary; string content = GetRequestBody(encoder); string expected = "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"foo\"" + "\r\n" + HttpHeaderNames.ContentLength + ": 3" + "\r\n" + HttpHeaderNames.ContentType + ": text/plain; charset=utf-8" + "\r\n" + "\r\n" + "bar" + "\r\n" + "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"quux\"\r\n" + HttpHeaderNames.ContentLength + ": " + fileStream.Length + "\r\n" + HttpHeaderNames.ContentType + ": text/plain" + "\r\n" + HttpHeaderNames.ContentTransferEncoding + ": binary" + "\r\n" + "\r\n" + "File 01" + StringUtil.Newline + "\r\n" + "--" + multipartDataBoundary + "--" + "\r\n"; Assert.Equal(expected, content); }
protected internal override IFullHttpRequest NewHandshakeRequest() { Uri wsUrl = Uri; // Get 16 bit nonce and base 64 encode it byte[] nonce = WebSocketUtil.RandomBytes(16); string key = WebSocketUtil.Base64String(nonce); string acceptSeed = key + MagicGuid; byte[] sha1 = WebSocketUtil.Sha1(Encoding.ASCII.GetBytes(acceptSeed)); _expectedChallengeResponseString = new AsciiString(WebSocketUtil.Base64String(sha1)); #if DEBUG if (Logger.DebugEnabled) { Logger.WebSocketVersion08ClientHandshakeKey(key, _expectedChallengeResponseString); } #endif // Format request var request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, UpgradeUrl(wsUrl), Unpooled.Empty); HttpHeaders headers = request.Headers; if (CustomHeaders is object) { _ = headers.Add(CustomHeaders); if (!headers.Contains(HttpHeaderNames.Host)) { // Only add HOST header if customHeaders did not contain it. // // See https://github.com/netty/netty/issues/10101 _ = headers.Set(HttpHeaderNames.Host, WebsocketHostValue(wsUrl)); } } else { _ = headers.Set(HttpHeaderNames.Host, WebsocketHostValue(wsUrl)); } _ = headers.Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket) .Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade) .Set(HttpHeaderNames.SecWebsocketKey, key); if (!headers.Contains(HttpHeaderNames.SecWebsocketOrigin)) { _ = headers.Set(HttpHeaderNames.SecWebsocketOrigin, WebsocketOriginValue(wsUrl)); } string expectedSubprotocol = ExpectedSubprotocol; if (!string.IsNullOrEmpty(expectedSubprotocol)) { _ = headers.Set(HttpHeaderNames.SecWebsocketProtocol, expectedSubprotocol); } _ = headers.Set(HttpHeaderNames.SecWebsocketVersion, Version.ToString()); return(request); }
static void ShouldThrowExceptionIfNotAllowed(HttpMethod method, FileStream fileStream) { fileStream.Position = 0; // Reset to the begining var request = new DefaultFullHttpRequest(HttpVersion.Http11, method, "http://localhost"); var encoder = new HttpPostRequestEncoder(request, true); encoder.AddBodyAttribute("foo", "bar"); encoder.AddBodyFileUpload("quux", fileStream, "text/plain", false); string multipartDataBoundary = encoder.MultipartDataBoundary; string content = GetRequestBody(encoder); string expected = "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"foo\"" + "\r\n" + HttpHeaderNames.ContentLength + ": 3" + "\r\n" + HttpHeaderNames.ContentType + ": text/plain; charset=utf-8" + "\r\n" + "\r\n" + "bar" + "\r\n" + "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"quux\"; filename=\"file-01.txt\"" + "\r\n" + HttpHeaderNames.ContentLength + ": " + fileStream.Length + "\r\n" + HttpHeaderNames.ContentType + ": text/plain" + "\r\n" + HttpHeaderNames.ContentTransferEncoding + ": binary" + "\r\n" + "\r\n" + "File 01" + StringUtil.Newline + "\r\n" + "--" + multipartDataBoundary + "--" + "\r\n"; Assert.Equal(expected, content); }
public void DataIsMultipleOfChunkSize1() { var factory = new DefaultHttpDataFactory(DefaultHttpDataFactory.MinSize); var request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); var encoder = new HttpPostRequestEncoder(factory, request, true, HttpConstants.DefaultEncoding, HttpPostRequestEncoder.EncoderMode.RFC1738); var first = new MemoryFileUpload("resources", "", "application/json", null, Encoding.UTF8, -1); first.MaxSize = -1; first.SetContent(new MemoryStream(new byte[7955])); encoder.AddBodyHttpData(first); var second = new MemoryFileUpload("resources2", "", "application/json", null, Encoding.UTF8, -1); second.MaxSize = -1; second.SetContent(new MemoryStream(new byte[7928])); encoder.AddBodyHttpData(second); Assert.NotNull(encoder.FinalizeRequest()); CheckNextChunkSize(encoder, 8080); CheckNextChunkSize(encoder, 8055); IHttpContent httpContent = encoder.ReadChunk(default(IByteBufferAllocator)); Assert.True(httpContent is ILastHttpContent, "Expected LastHttpContent is not received"); httpContent.Release(); Assert.True(encoder.IsEndOfInput, "Expected end of input is not receive"); }
public async Task PerformHandshakeWithoutOriginHeader() { EmbeddedChannel ch = new EmbeddedChannel( new HttpObjectAggregator(42), new HttpRequestDecoder(), new HttpResponseEncoder()); IFullHttpRequest req = new DefaultFullHttpRequest( Http11, HttpMethod.Get, "/chat", Unpooled.CopiedBuffer("^n:ds[4U", Encoding.ASCII)); req.Headers.Set(HttpHeaderNames.Host, "server.example.com"); req.Headers.Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket); req.Headers.Set(HttpHeaderNames.Connection, "Upgrade"); req.Headers.Set(HttpHeaderNames.SecWebsocketKey1, "4 @1 46546xW%0l 1 5"); req.Headers.Set(HttpHeaderNames.SecWebsocketProtocol, "chat, superchat"); WebSocketServerHandshaker00 handshaker00 = new WebSocketServerHandshaker00( "ws://example.com/chat", "chat", int.MaxValue); try { await handshaker00.HandshakeAsync(ch, req); Assert.False(true, "Expecting WebSocketHandshakeException"); } catch (WebSocketHandshakeException e) { Assert.Equal("Missing origin header, got only " + "[host, upgrade, connection, sec-websocket-key1, sec-websocket-protocol]", e.Message); } finally { req.Release(); } }
protected async Task DoRequestAsync(List <Uri> uris, int requestCount) { foreach (var uri in uris) { var sw = Stopwatch.StartNew(); var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2)); var tasks = Enumerable.Range(0, requestCount).Select(async m => { IFullHttpResponse response = null; try { var request = new DefaultFullHttpRequest(DNHttpVersion.Http11, DNHttpMethod.Get, uri.OriginalString); response = await _executor.ExecuteAsync(request, cts.Token).ConfigureAwait(false); Assert.AreEqual(200, response.Status.Code); } catch { } finally { response.SafeRelease(); } }).ToArray(); await Task.WhenAll(tasks).ConfigureAwait(false); sw.Stop(); Debug.WriteLine($"{uri.OriginalString}:{sw.Elapsed}"); } }
public static async Task DoRequest(Channel channel) { DefaultFullHttpRequest req = null; req = new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Get, "/"); req.Headers.Add(AsciiString.Cached("Host"), AsciiString.Cached("localhost")); req.Headers.Add(AsciiString.Cached("Connection"), AsciiString.Cached("Keep-Alive")); // Console.WriteLine("send get"); channel.Busy = true; if (!upChannels.ContainsKey(channel.upstream)) { upChannels.TryAdd(channel.upstream, channel); } Task.Run(async() => { try { await channel.upstream.WriteAndFlushAsync(req).ConfigureAwait(false); // Console.WriteLine("send done"); } catch (Exception ex) { await channel.request.DisconnectAsync(); //Console.WriteLine("close connection"); Channel old = null; upChannels.TryRemove(channel.upstream, out old); Console.WriteLine(ex.Message); } }); }
public void Http10() { var ch = new EmbeddedChannel(new TestEncoder()); var req = new DefaultFullHttpRequest(HttpVersion.Http10, HttpMethod.Get, "/"); Assert.True(ch.WriteInbound(req)); var res = new DefaultHttpResponse(HttpVersion.Http10, HttpResponseStatus.OK); res.Headers.Set(HttpHeaderNames.ContentLength, HttpHeaderValues.Zero); Assert.True(ch.WriteOutbound(res)); Assert.True(ch.WriteOutbound(EmptyLastHttpContent.Default)); Assert.True(ch.Finish()); var request = ch.ReadInbound <IFullHttpRequest>(); Assert.True(request.Release()); var next = ch.ReadInbound(); Assert.Null(next); var response = ch.ReadOutbound <IHttpResponse>(); Assert.Same(res, response); var content = ch.ReadOutbound <ILastHttpContent>(); Assert.Same(content, EmptyLastHttpContent.Default); content.Release(); next = ch.ReadOutbound(); Assert.Null(next); }
public void MultipartRequestWithoutContentTypeBody() { const string Boundary = "dLV9Wyq26L_-JQxk6ferf-RT153LhOO"; var req = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); req.Result = DecoderResult.Success; req.Headers.Add(HttpHeaderNames.ContentType, "multipart/form-data; boundary=" + Boundary); req.Headers.Add(HttpHeaderNames.TransferEncoding, HttpHeaderValues.Chunked); // Force to use memory-based data. var inMemoryFactory = new DefaultHttpDataFactory(false); var values = new[] { "", "\r", "\r\r", "\r\r\r" }; foreach (string data in values) { string body = "--" + Boundary + "\r\n" + "Content-Disposition: form-data; name=\"file\"; filename=\"tmp-0.txt\"\r\n" + "\r\n" + data + "\r\n" + "--" + Boundary + "--\r\n"; req.Content.WriteBytes(Encoding.UTF8.GetBytes(body)); } // Create decoder instance to test without any exception. var decoder = new HttpPostRequestDecoder(inMemoryFactory, req); List <IInterfaceHttpData> list = decoder.GetBodyHttpDatas(); Assert.NotNull(list); Assert.False(list.Count == 0); decoder.Destroy(); }
public virtual RequestHandle createConnection(Protocol protocol, LightstreamerRequest request, com.lightstreamer.client.transport.providers.HttpProvider_HttpRequestListener httpListener, IDictionary <string, string> extraHeaders, Proxy proxy, long tcpConnectTimeout, long tcpReadTimeout) { string address = request.TargetServer + "lightstreamer/" + request.RequestName + ".txt" + "?LS_protocol=" + Constants.TLCP_VERSION; Uri uri; try { uri = new Uri(address); } catch (Exception e) { log.Fatal("Unexpectedly invalid URI: " + address, e); throw new System.ArgumentException(e.Message); } bool secure = isSSL(address); int port = uri.Port == -1 ? (secure ? 443 : 80) : uri.Port; IFullHttpRequest httpRequest = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, uri.PathAndQuery); httpRequest.Headers.Set(HttpHeaderNames.Host, uri.Host); string cookies = CookieHelper.getCookieHeader(uri); log.Info("Requested cookies for uri " + uri + ": " + cookies); if (!string.ReferenceEquals(cookies, null) && cookies.Length > 0) { httpRequest.Headers.Set(HttpHeaderNames.Cookie, cookies); } httpRequest.Headers.Set(HttpHeaderNames.UserAgent, ua); httpRequest.Headers.Set(HttpHeaderNames.ContentType, "text/plain; charset=UTF-8"); if (extraHeaders != null) { foreach (KeyValuePair <string, string> header in extraHeaders.SetOfKeyValuePairs()) { httpRequest.Headers.Set(new AsciiString(header.Key), header.Value); } } IByteBuffer bbuf = Unpooled.CopiedBuffer(request.getTransportAwareQueryString(null, true) + "\r\n", Encoding.UTF8); httpRequest.Headers.Set(HttpHeaderNames.ContentLength, bbuf.ReadableBytes); httpRequest.Content.Clear().WriteBytes(bbuf); string host4Netty = System.Net.Dns.GetHostAddresses(uri.Host)[0].ToString(); log.Debug("cs ---- address: " + address + ", " + host4Netty); NettyFullAddress target = new NettyFullAddress(secure, host4Netty, port, uri.Host, proxy); NettyInterruptionHandler interruptionHandler = new NettyInterruptionHandler(); bindAsync(uri, target, httpListener, httpRequest, interruptionHandler); return(interruptionHandler); }
public IByteBufferHolder Replace(IByteBuffer newContent) { var duplicate = new DefaultFullHttpRequest(this.ProtocolVersion, this.Method, this.Uri, newContent); duplicate.Headers.Set(this.Headers); duplicate.TrailingHeaders.Set(this.TrailingHeaders); return(duplicate); }
static void RunUnsupportedExpectationTest(HttpVersion version, string expectations, bool expect) { var message = new DefaultFullHttpRequest(version, HttpMethod.Get, "/"); if (expectations != null) { message.Headers.Set(new AsciiString("Expect"), expectations); } RunUnsupportedExpectationTest(message, expect); }
public void ClientRequestStreamDependencyInHttpMessageFlow() { this.BootstrapEnv(1, 2, 1); string text = "hello world big time data!"; IByteBuffer content = Unpooled.CopiedBuffer(Encoding.UTF8.GetBytes(text)); string text2 = "hello world big time data...number 2!!"; IByteBuffer content2 = Unpooled.CopiedBuffer(Encoding.UTF8.GetBytes(text2)); IFullHttpRequest request = new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Put, "/some/path/resource", content, true); IFullHttpMessage request2 = new DefaultFullHttpRequest(DotNetty.Codecs.Http.HttpVersion.Http11, HttpMethod.Put, "/some/path/resource2", content2, true); try { HttpHeaders httpHeaders = request.Headers; httpHeaders.SetInt(HttpConversionUtil.ExtensionHeaderNames.StreamId, 3); httpHeaders.SetInt(HttpHeaderNames.ContentLength, text.Length); httpHeaders.SetShort(HttpConversionUtil.ExtensionHeaderNames.StreamWeight, 16); HttpHeaders httpHeaders2 = request2.Headers; httpHeaders2.SetInt(HttpConversionUtil.ExtensionHeaderNames.StreamId, 5); httpHeaders2.SetInt(HttpConversionUtil.ExtensionHeaderNames.StreamDependencyId, 3); httpHeaders2.SetShort(HttpConversionUtil.ExtensionHeaderNames.StreamWeight, 123); httpHeaders2.SetInt(HttpHeaderNames.ContentLength, text2.Length); var http2Headers = new DefaultHttp2Headers() { Method = new AsciiString("PUT"), Path = new AsciiString("/some/path/resource"), }; var http2Headers2 = new DefaultHttp2Headers() { Method = new AsciiString("PUT"), Path = new AsciiString("/some/path/resource2"), }; Http2TestUtil.RunInChannel(this.clientChannel, () => { this.clientHandler.Encoder.WriteHeadersAsync(this.CtxClient(), 3, http2Headers, 0, false, this.NewPromiseClient()); this.clientHandler.Encoder.WriteHeadersAsync(this.CtxClient(), 5, http2Headers2, 3, 123, true, 0, false, this.NewPromiseClient()); this.clientChannel.Flush(); // Headers are queued in the flow controller and so flush them. this.clientHandler.Encoder.WriteDataAsync(this.CtxClient(), 3, content.RetainedDuplicate(), 0, true, this.NewPromiseClient()); this.clientHandler.Encoder.WriteDataAsync(this.CtxClient(), 5, content2.RetainedDuplicate(), 0, true, this.NewPromiseClient()); this.clientChannel.Flush(); }); this.AwaitRequests(); var httpObjectCaptor = new ArgumentCaptor <IFullHttpMessage>(); this.serverListener.Verify(x => x.MessageReceived(It.Is <IHttpObject>(v => httpObjectCaptor.Capture((IFullHttpMessage)v))), Times.Exactly(2)); this.capturedRequests = httpObjectCaptor.GetAllValues(); Assert.Equal(request, (IFullHttpRequest)this.capturedRequests[0]); Assert.Equal(request2, this.capturedRequests[1]); } finally { request.Release(); request2.Release(); } }
public void AuthorizationQuertStringFailTest() { IServiceCollection serviceDescriptors = new ServiceCollection(); serviceDescriptors.Configure <JT808Configuration>((options) => { }); var options = serviceDescriptors.BuildServiceProvider().GetRequiredService <IOptionsMonitor <JT808Configuration> >(); JT808AuthorizationDefault jT808AuthorizationDefault = new JT808AuthorizationDefault(options); var m = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "/demo?token=12345"); Assert.False(jT808AuthorizationDefault.Authorization(m, out var principal)); }
static void Run100ContinueTest(HttpVersion version, string expectations, bool expect) { var message = new DefaultFullHttpRequest(version, HttpMethod.Get, "/"); if (expectations != null) { message.Headers.Set(HttpHeaderNames.Expect, expectations); } Run100ContinueTest(message, expect); }
public void MultipartCodecWithCRasEndOfAttribute() { const string Boundary = "dLV9Wyq26L_-JQxk6ferf-RT153LhOO"; // Force to use memory-based data. var inMemoryFactory = new DefaultHttpDataFactory(false); const string Extradata = "aaaa"; var strings = new string[5]; for (int i = 0; i < 4; i++) { strings[i] = Extradata; for (int j = 0; j < i; j++) { strings[i] += '\r'; } } for (int i = 0; i < 4; i++) { var req = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); req.Result = DecoderResult.Success; req.Headers.Add(HttpHeaderNames.ContentType, "multipart/form-data; boundary=" + Boundary); req.Headers.Add(HttpHeaderNames.TransferEncoding, HttpHeaderValues.Chunked); string body = "--" + Boundary + "\r\n" + "Content-Disposition: form-data; name=\"file" + i + "\"\r\n" + "Content-Type: image/gif\r\n" + "\r\n" + strings[i] + "\r\n" + "--" + Boundary + "--\r\n"; req.Content.WriteBytes(Encoding.UTF8.GetBytes(body)); // Create decoder instance to test. var decoder = new HttpPostRequestDecoder(inMemoryFactory, req); List <IInterfaceHttpData> list = decoder.GetBodyHttpDatas(); Assert.NotNull(list); Assert.False(list.Count == 0); // Check correctness: data size IInterfaceHttpData httpData = decoder.GetBodyHttpData($"file{i}"); Assert.NotNull(httpData); var attribute = httpData as IAttribute; Assert.NotNull(attribute); byte[] data = attribute.GetBytes(); Assert.NotNull(data); Assert.Equal(Encoding.UTF8.GetBytes(strings[i]).Length, data.Length); decoder.Destroy(); } }
public void AuthorizationHeaderTest() { IServiceCollection serviceDescriptors = new ServiceCollection(); serviceDescriptors.Configure <JT808Configuration>((options) => { }); var options = serviceDescriptors.BuildServiceProvider().GetRequiredService <IOptionsMonitor <JT808Configuration> >(); JT808AuthorizationDefault jT808AuthorizationDefault = new JT808AuthorizationDefault(options); var m = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "/"); m.Headers.Add((AsciiString)"token", "123456"); Assert.True(jT808AuthorizationDefault.Authorization(m, out var principal)); }
public void MultiFileUploadInMixedModeNoName() { var request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "http://localhost"); var encoder = new HttpPostRequestEncoder(request, true); FileStream fileStream1 = File.Open("./Multipart/file-01.txt", FileMode.Open, FileAccess.Read); this.files.Add(fileStream1); FileStream fileStream2 = File.Open("./Multipart/file-02.txt", FileMode.Open, FileAccess.Read); this.files.Add(fileStream2); encoder.AddBodyAttribute("foo", "bar"); encoder.AddBodyFileUpload("quux", "", fileStream1, "text/plain", false); encoder.AddBodyFileUpload("quux", "", fileStream2, "text/plain", false); // We have to query the value of these two fields before finalizing // the request, which unsets one of them. string multipartDataBoundary = encoder.MultipartDataBoundary; string multipartMixedBoundary = encoder.MultipartMixedBoundary; string content = GetRequestBody(encoder); string expected = "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"foo\"" + "\r\n" + HttpHeaderNames.ContentLength + ": 3" + "\r\n" + HttpHeaderNames.ContentType + ": text/plain; charset=utf-8" + "\r\n" + "\r\n" + "bar" + "\r\n" + "--" + multipartDataBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": form-data; name=\"quux\"" + "\r\n" + HttpHeaderNames.ContentType + ": multipart/mixed; boundary=" + multipartMixedBoundary + "\r\n" + "\r\n" + "--" + multipartMixedBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": attachment\r\n" + HttpHeaderNames.ContentLength + ": " + fileStream1.Length + "\r\n" + HttpHeaderNames.ContentType + ": text/plain" + "\r\n" + HttpHeaderNames.ContentTransferEncoding + ": binary" + "\r\n" + "\r\n" + "File 01" + /*StringUtil.*/ Newline + "\r\n" + "--" + multipartMixedBoundary + "\r\n" + HttpHeaderNames.ContentDisposition + ": attachment\r\n" + HttpHeaderNames.ContentLength + ": " + fileStream2.Length + "\r\n" + HttpHeaderNames.ContentType + ": text/plain" + "\r\n" + HttpHeaderNames.ContentTransferEncoding + ": binary" + "\r\n" + "\r\n" + "File 02" + /*StringUtil.*/ Newline + "\r\n" + "--" + multipartMixedBoundary + "--" + "\r\n" + "--" + multipartDataBoundary + "--" + "\r\n"; Assert.Equal(expected, content); }
public void TestDuplicateHandshakeResponseHeaders() { WebSocketServerHandshaker serverHandshaker = NewHandshaker("ws://example.com/chat", "chat", WebSocketDecoderConfig.Default); IFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Get, "/chat"); request.Headers .Set(HttpHeaderNames.Host, "example.com") .Set(HttpHeaderNames.Origin, "example.com") .Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket) .Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade) .Set(HttpHeaderNames.SecWebsocketKey, "dGhlIHNhbXBsZSBub25jZQ==") .Set(HttpHeaderNames.SecWebsocketOrigin, "http://example.com") .Set(HttpHeaderNames.SecWebsocketProtocol, "chat, superchat") .Set(HttpHeaderNames.SecWebsocketVersion, WebSocketVersion().ToHttpHeaderValue()); HttpHeaders customResponseHeaders = new DefaultHttpHeaders(); // set duplicate required headers and one custom customResponseHeaders .Set(HttpHeaderNames.Connection, HttpHeaderValues.Upgrade) .Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket) .Set(AsciiString.Of("custom"), AsciiString.Of("header")); if (WebSocketVersion() != Http.WebSockets.WebSocketVersion.V00) { customResponseHeaders.Set(HttpHeaderNames.SecWebsocketAccept, "12345"); } IFullHttpResponse response = null; try { response = serverHandshaker.NewHandshakeResponse(request, customResponseHeaders); HttpHeaders responseHeaders = response.Headers; Assert.Equal(1, responseHeaders.GetAll(HttpHeaderNames.Connection).Count); Assert.Equal(1, responseHeaders.GetAll(HttpHeaderNames.Upgrade).Count); Assert.True(responseHeaders.ContainsValue(AsciiString.Of("custom"), AsciiString.Of("header"), true)); if (WebSocketVersion() != Http.WebSockets.WebSocketVersion.V00) { Assert.False(responseHeaders.ContainsValue(HttpHeaderNames.SecWebsocketAccept, AsciiString.Of("12345"), false)); } } finally { request.Release(); if (response != null) { response.Release(); } } }
static void PerformOpeningHandshake0(bool subProtocol) { var ch = new EmbeddedChannel( new HttpObjectAggregator(42), new HttpRequestDecoder(), new HttpResponseEncoder()); var req = new DefaultFullHttpRequest(Http11, HttpMethod.Get, "/chat"); req.Headers.Set(HttpHeaderNames.Host, "server.example.com"); req.Headers.Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket); req.Headers.Set(HttpHeaderNames.Connection, "Upgrade"); req.Headers.Set(HttpHeaderNames.SecWebsocketKey, "dGhlIHNhbXBsZSBub25jZQ=="); req.Headers.Set(HttpHeaderNames.SecWebsocketOrigin, "http://example.com"); req.Headers.Set(HttpHeaderNames.SecWebsocketProtocol, "chat, superchat"); req.Headers.Set(HttpHeaderNames.SecWebsocketVersion, "13"); WebSocketServerHandshaker13 handshaker; if (subProtocol) { handshaker = new WebSocketServerHandshaker13( "ws://example.com/chat", "chat", false, int.MaxValue, false); } else { handshaker = new WebSocketServerHandshaker13( "ws://example.com/chat", null, false, int.MaxValue, false); } Assert.True(handshaker.HandshakeAsync(ch, req).Wait(TimeSpan.FromSeconds(2))); var resBuf = ch.ReadOutbound <IByteBuffer>(); var ch2 = new EmbeddedChannel(new HttpResponseDecoder()); ch2.WriteInbound(resBuf); var res = ch2.ReadInbound <IHttpResponse>(); Assert.True(res.Headers.TryGet(HttpHeaderNames.SecWebsocketAccept, out ICharSequence value)); Assert.Equal("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", value.ToString()); if (subProtocol) { Assert.True(res.Headers.TryGet(HttpHeaderNames.SecWebsocketProtocol, out value)); Assert.Equal("chat", value.ToString()); } else { Assert.False(res.Headers.TryGet(HttpHeaderNames.SecWebsocketProtocol, out value)); } ReferenceCountUtil.Release(res); req.Release(); }
static void PerformOpeningHandshake0(bool subProtocol) { var ch = new EmbeddedChannel( new HttpObjectAggregator(42), new HttpRequestDecoder(), new HttpResponseEncoder()); var req = new DefaultFullHttpRequest(Http11, HttpMethod.Get, "/chat", Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes("^n:ds[4U"))); req.Headers.Set(HttpHeaderNames.Host, "server.example.com"); req.Headers.Set(HttpHeaderNames.Upgrade, HttpHeaderValues.Websocket); req.Headers.Set(HttpHeaderNames.Connection, "Upgrade"); req.Headers.Set(HttpHeaderNames.Origin, "http://example.com"); req.Headers.Set(HttpHeaderNames.SecWebsocketKey1, "4 @1 46546xW%0l 1 5"); req.Headers.Set(HttpHeaderNames.SecWebsocketKey2, "12998 5 Y3 1 .P00"); req.Headers.Set(HttpHeaderNames.SecWebsocketProtocol, "chat, superchat"); WebSocketServerHandshaker00 handshaker; if (subProtocol) { handshaker = new WebSocketServerHandshaker00("ws://example.com/chat", "chat", int.MaxValue); } else { handshaker = new WebSocketServerHandshaker00("ws://example.com/chat", null, int.MaxValue); } Assert.True(handshaker.HandshakeAsync(ch, req).Wait(TimeSpan.FromSeconds(2))); var ch2 = new EmbeddedChannel(new HttpResponseDecoder()); ch2.WriteInbound(ch.ReadOutbound <IByteBuffer>()); var res = ch2.ReadInbound <IHttpResponse>(); Assert.True(res.Headers.TryGet(HttpHeaderNames.SecWebsocketLocation, out ICharSequence value)); Assert.Equal("ws://example.com/chat", value.ToString()); if (subProtocol) { Assert.True(res.Headers.TryGet(HttpHeaderNames.SecWebsocketProtocol, out value)); Assert.Equal("chat", value.ToString()); } else { Assert.False(res.Headers.TryGet(HttpHeaderNames.SecWebsocketProtocol, out value)); } var content = ch2.ReadInbound <ILastHttpContent>(); Assert.Equal("8jKS'y:G*Co,Wxa-", content.Content.ToString(Encoding.ASCII)); content.Release(); req.Release(); }
private static void NotLeakWhenWrapIllegalArgumentException(IByteBuffer buf) { buf.WriteCharSequence((AsciiString)"a=b&foo=%22bar%22&==", Encoding.ASCII); IFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Post, "/", buf); try { new HttpPostStandardRequestDecoder(request); } finally { Assert.True(request.Release()); } }
private static void TestUpgrade(Http2ConnectionHandler handler, IChannelHandler multiplexer) { IFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Options, "*"); request.Headers.Set(HttpHeaderNames.Host, "netty.io"); request.Headers.Set(HttpHeaderNames.Connection, "Upgrade, HTTP2-Settings"); request.Headers.Set(HttpHeaderNames.Upgrade, "h2c"); request.Headers.Set((AsciiString)"HTTP2-Settings", "AAMAAABkAAQAAP__"); var parent = new Mock <IServerChannel>(); EmbeddedChannel channel = new EmbeddedChannel(parent.Object, DefaultChannelId.NewInstance(), false, true, new ChannelHandlerAdapter()); IChannelHandlerContext ctx = channel.Pipeline.FirstContext(); Http2ServerUpgradeCodec codec; if (multiplexer == null) { codec = new Http2ServerUpgradeCodec(handler); } else { codec = new Http2ServerUpgradeCodec((Http2FrameCodec)handler, multiplexer); } Assert.True(codec.PrepareUpgradeResponse(ctx, request, new DefaultHttpHeaders())); codec.UpgradeTo(ctx, request); // Flush the channel to ensure we write out all buffered data channel.Flush(); channel.WriteInbound(Http2CodecUtil.ConnectionPrefaceBuf()); Http2FrameInboundWriter writer = new Http2FrameInboundWriter(channel); writer.WriteInboundSettings(new Http2Settings()); writer.WriteInboundRstStream(Http2CodecUtil.HttpUpgradeStreamId, Http2Error.Cancel); Assert.Same(handler, channel.Pipeline.Remove <Http2ConnectionHandler>()); Assert.Null(channel.Pipeline.Get <Http2ConnectionHandler>()); Assert.True(channel.Finish()); // Check that the preface was send (a.k.a the settings frame) var settingsBuffer = channel.ReadOutbound <IByteBuffer>(); Assert.NotNull(settingsBuffer); settingsBuffer.Release(); var buf = channel.ReadOutbound <IByteBuffer>(); Assert.NotNull(buf); buf.Release(); Assert.Null(channel.ReadOutbound()); }