EonaCat
/
EonaCat.Network
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Updated webSockets

This commit is contained in:
EonaCat 2024-03-19 18:02:29 +01:00
parent c5726a3e4b
commit 8d7e806d14
149 changed files with 7164 additions and 20948 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
EonaCat.Network/EonaCat.Network.csproj
View File

@ -1,28 +1,27 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<LangVersion>Latest</LangVersion>
<TargetFrameworks>
netstandard2.1;
net6.0;
net7.0;
</TargetFrameworks>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<PackageId>EonaCat.Network</PackageId>
<Authors>EonaCat (Jeroen Saey)</Authors>
<Company>EonaCat (Jeroen Saey)</Company>
<Product>EonaCat.Network</Product>
<Copyright>EonaCat (Jeroen Saey)</Copyright>
<PackageProjectUrl>https://www.nuget.org/packages/EonaCat.Network/</PackageProjectUrl>
<PackageTags>EonaCat, Network, .NET Standard, EonaCatHelpers, Jeroen, Saey, Protocol, Quic, UDP, TCP, Web, Server</PackageTags>
<PackageReleaseNotes></PackageReleaseNotes>
<Description>EonaCat Networking library with Quic, TCP, UDP, WebSockets and a Webserver</Description>
<Version>1.1.4</Version>
<AssemblyVersion>1.1.4</AssemblyVersion>
<FileVersion>1.1.4</FileVersion>
<PackageIcon>icon.png</PackageIcon>
</PropertyGroup>
<PropertyGroup>
<LangVersion>Latest</LangVersion>
<TargetFrameworks>net48;netstandard2.1;net6.0;net7.0;net8.0</TargetFrameworks>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<PackageId>EonaCat.Network</PackageId>
<Authors>EonaCat (Jeroen Saey)</Authors>
<Company>EonaCat (Jeroen Saey)</Company>
<Product>EonaCat.Network</Product>
<Copyright>EonaCat (Jeroen Saey)</Copyright>
<PackageProjectUrl>https://www.nuget.org/packages/EonaCat.Network/</PackageProjectUrl>
<PackageTags>EonaCat, Network, .NET Standard, EonaCatHelpers, Jeroen, Saey, Protocol, Quic, UDP, TCP, Web, Server</PackageTags>
<PackageReleaseNotes></PackageReleaseNotes>
<Description>EonaCat Networking library with Quic, TCP, UDP, WebSockets and a Webserver</Description>
<Version>1.1.5</Version>
<AssemblyVersion>1.1.5</AssemblyVersion>
<FileVersion>1.1.5</FileVersion>
<PackageIcon>icon.png</PackageIcon>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageLicenseFile>LICENSE</PackageLicenseFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
<PackageReadmeFile>README.md</PackageReadmeFile>
@ -30,29 +29,36 @@
<Title>EonaCat.Network</Title>
<PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
<PackageLicenseFile>LICENSE</PackageLicenseFile>
</PropertyGroup>
<ItemGroup>
<None Include="..\icon.png">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
<None Include="..\LICENSE">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
<ItemGroup>
<None Include="..\icon.png">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
<None Include="..\LICENSE">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<PackageReference Include="EonaCat.Controls" Version="1.0.2" />
<PackageReference Include="EonaCat.Json" Version="1.0.3" />
<PackageReference Include="EonaCat.Logger" Version="1.2.3" />
<PackageReference Include="EonaCat.LogSystem" Version="1.0.0" />
<PackageReference Include="EonaCat.Matchers" Version="1.0.0" />
<PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="EonaCat.Controls" Version="1.0.2" />
<PackageReference Include="EonaCat.Json" Version="1.0.3" />
<PackageReference Include="EonaCat.Logger" Version="1.2.4" />
<PackageReference Include="EonaCat.LogSystem" Version="1.0.0" />
<PackageReference Include="EonaCat.Matchers" Version="1.0.0" />
<PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
<PackageReference Include="System.Text.Encodings.Web" Version="8.0.0" />
</ItemGroup>
<ItemGroup>
<Folder Include="System\Sockets\WebSockets\" />
</ItemGroup>
</Project>

54
EonaCat.Network/System/BlockChain/Block.cs
View File

@ -1,54 +0,0 @@
using EonaCat.Json;
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
namespace EonaCat.BlockChain
{
public class Block
{
public int Index { get; set; }
private DateTime TimeStamp { get; set; }
public string PreviousHash { get; set; }
public string Hash { get; set; }
public IList<Transaction> Transactions { get; set; }
private int Nonce { get; set; }
public Block(DateTime timeStamp, string previousHash, IList<Transaction> transactions)
{
Index = 0;
TimeStamp = timeStamp;
PreviousHash = previousHash;
Transactions = transactions;
}
/// <summary>
/// Calculate the hash of the block
/// </summary>
/// <returns></returns>
public string CalculateHash()
{
var sha256 = SHA256.Create();
var inputBytes = Encoding.ASCII.GetBytes($"{TimeStamp}-{PreviousHash ?? ""}-{JsonHelper.ToJson(Transactions)}-{Nonce}");
var outputBytes = sha256.ComputeHash(inputBytes);
return Convert.ToBase64String(outputBytes);
}
/// <summary>
/// Mine the block
/// </summary>
/// <param name="difficulty"></param>
public void Mine(int difficulty)
{
var leadingZeros = new string('0', difficulty);
while (Hash == null || Hash.Substring(0, difficulty) != leadingZeros)
{
Nonce++;
Hash = CalculateHash();
}
}
}
}

106
EonaCat.Network/System/BlockChain/BlockChain.cs
View File

@ -1,106 +0,0 @@
using System;
using System.Collections.Generic;
namespace EonaCat.BlockChain
{
public class BlockChain
{
public IList<Transaction> PendingTransactions = new List<Transaction>();
public IList<Block> Chain { set; get; }
private int Difficulty { set; get; } = 2;
private readonly int _reward = 1; //1 cryptocurrency
public void InitializeChain()
{
Chain = new List<Block>();
AddGenesisBlock();
}
private Block CreateGenesisBlock()
{
Block block = new Block(DateTime.Now, null, PendingTransactions);
block.Mine(Difficulty);
PendingTransactions = new List<Transaction>();
return block;
}
private void AddGenesisBlock()
{
Chain.Add(CreateGenesisBlock());
}
private Block GetLatestBlock()
{
return Chain[Chain.Count - 1];
}
public void CreateTransaction(Transaction transaction)
{
PendingTransactions.Add(transaction);
}
public void ProcessPendingTransactions(string minerAddress)
{
Block block = new Block(DateTime.Now, GetLatestBlock().Hash, PendingTransactions);
AddBlock(block);
PendingTransactions = new List<Transaction>();
CreateTransaction(new Transaction(null, minerAddress, _reward));
}
private void AddBlock(Block block)
{
Block latestBlock = GetLatestBlock();
block.Index = latestBlock.Index + 1;
block.PreviousHash = latestBlock.Hash;
//block.Hash = block.CalculateHash();
block.Mine(Difficulty);
Chain.Add(block);
}
public bool IsValid()
{
for (int i = 1; i < Chain.Count; i++)
{
Block currentBlock = Chain[i];
Block previousBlock = Chain[i - 1];
if (currentBlock.Hash != currentBlock.CalculateHash())
{
return false;
}
if (currentBlock.PreviousHash != previousBlock.Hash)
{
return false;
}
}
return true;
}
public int GetBalance(string address)
{
int balance = 0;
for (int i = 0; i < Chain.Count; i++)
{
for (int j = 0; j < Chain[i].Transactions.Count; j++)
{
var transaction = Chain[i].Transactions[j];
if (transaction.FromAddress == address)
{
balance -= transaction.Amount;
}
if (transaction.ToAddress == address)
{
balance += transaction.Amount;
}
}
}
return balance;
}
}
}

75
EonaCat.Network/System/BlockChain/ClientServerExample.cs
View File

@ -1,75 +0,0 @@
using EonaCat.Json;
using System;
namespace EonaCat.BlockChain
{
public static class ClientServerExample
{
public static int ServerPort;
private static P2PServer _server;
private static readonly P2PClient Client = new P2PClient();
public static BlockChain BlockChain = new BlockChain();
private static string _clientUsername = "Unknown";
public static void Run(int serverPort, string clientUsername)
{
BlockChain.InitializeChain();
ServerPort = serverPort;
_clientUsername = clientUsername;
if (ServerPort > 0)
{
_server = new P2PServer();
_server.Start();
}
if (_clientUsername != "Unknown")
{
Console.WriteLine($"Current user is {_clientUsername}");
}
Console.WriteLine("=========================");
Console.WriteLine("EonaCat BlockChain");
Console.WriteLine("1. Connect to a server");
Console.WriteLine("2. Add a transaction");
Console.WriteLine("3. Display BlockChain");
Console.WriteLine("4. Exit");
Console.WriteLine("=========================");
int selection = 0;
while (selection != 4)
{
switch (selection)
{
case 1:
Console.WriteLine("Please enter the server URL");
string serverUrl = Console.ReadLine();
Client.Connect($"{serverUrl}/BlockChain");
break;
case 2:
Console.WriteLine("Please enter the receiver name");
string receiverName = Console.ReadLine();
Console.WriteLine("Please enter the amount");
string amount = Console.ReadLine();
BlockChain.CreateTransaction(new Transaction(_clientUsername, receiverName, int.Parse(amount)));
BlockChain.ProcessPendingTransactions(_clientUsername);
Client.Broadcast(JsonHelper.ToJson(BlockChain));
break;
case 3:
Console.WriteLine("BlockChain");
Console.WriteLine(JsonHelper.ToJson(BlockChain, Formatting.Indented));
break;
}
Console.WriteLine("Please select an action");
string action = Console.ReadLine();
selection = int.Parse(action);
}
Client.Close();
}
}
}

83
EonaCat.Network/System/BlockChain/P2PClient.cs
View File

@ -1,83 +0,0 @@
using EonaCat.Json;
using EonaCat.Network;
using System;
using System.Collections.Generic;
namespace EonaCat.BlockChain
{
public class P2PClient
{
private readonly IDictionary<string, WSClient> wsDict = new Dictionary<string, WSClient>();
public void Connect(string url)
{
if (!wsDict.ContainsKey(url))
{
WSClient webSocket = new WSClient(url);
webSocket.OnMessageReceived += (sender, e) =>
{
if (e.Data == "Hi Client")
{
Console.WriteLine(e.Data);
}
else
{
var newChain = JsonHelper.ToObject<BlockChain>(e.Data);
if (!newChain.IsValid() || newChain.Chain.Count <= ClientServerExample.BlockChain.Chain.Count)
{
return;
}
var newTransactions = new List<Transaction>();
newTransactions.AddRange(newChain.PendingTransactions);
newTransactions.AddRange(ClientServerExample.BlockChain.PendingTransactions);
newChain.PendingTransactions = newTransactions;
ClientServerExample.BlockChain = newChain;
}
};
webSocket.Connect();
webSocket.Send("Hi Server");
webSocket.Send(JsonHelper.ToJson(ClientServerExample.BlockChain));
wsDict.Add(url, webSocket);
}
}
public void Send(string url, string data)
{
foreach (var item in wsDict)
{
if (item.Key == url)
{
item.Value.Send(data);
}
}
}
public void Broadcast(string data)
{
foreach (var item in wsDict)
{
item.Value.Send(data);
}
}
public IList<string> GetServers()
{
IList<string> servers = new List<string>();
foreach (var item in wsDict)
{
servers.Add(item.Key);
}
return servers;
}
public void Close()
{
foreach (var item in wsDict)
{
item.Value.Close();
}
}
}
}

51
EonaCat.Network/System/BlockChain/P2PServer.cs
View File

@ -1,51 +0,0 @@
using EonaCat.Json;
using EonaCat.Network;
using System;
using System.Collections.Generic;
namespace EonaCat.BlockChain
{
public class P2PServer : WSEndpoint
{
private bool _chainSynched;
private WSServer _wss;
public void Start(string webSocketAddress = null)
{
webSocketAddress ??= $"ws://127.0.0.1:{ClientServerExample.ServerPort}";
_wss = new WSServer(webSocketAddress);
_wss.AddEndpoint<P2PServer>("/BlockChain");
_wss.Start();
Console.WriteLine($"Started server at {webSocketAddress}");
}
protected override void OnMessage(MessageEventArgs e)
{
if (e.Data == "Hi Server")
{
Console.WriteLine(e.Data);
Send("Hi Client");
}
else
{
BlockChain newChain = JsonHelper.ToObject<BlockChain>(e.Data);
if (newChain.IsValid() && newChain.Chain.Count > ClientServerExample.BlockChain.Chain.Count)
{
List<Transaction> newTransactions = new List<Transaction>();
newTransactions.AddRange(newChain.PendingTransactions);
newTransactions.AddRange(ClientServerExample.BlockChain.PendingTransactions);
newChain.PendingTransactions = newTransactions;
ClientServerExample.BlockChain = newChain;
}
if (!_chainSynched)
{
Send(JsonHelper.ToJson(ClientServerExample.BlockChain));
_chainSynched = true;
}
}
}
}
}

16
EonaCat.Network/System/BlockChain/Transaction.cs
View File

@ -1,16 +0,0 @@
namespace EonaCat.BlockChain
{
public class Transaction
{
public string FromAddress { get; set; }
public string ToAddress { get; set; }
public int Amount { get; set; }
public Transaction(string fromAddress, string toAddress, int amount)
{
FromAddress = fromAddress;
ToAddress = toAddress;
Amount = amount;
}
}
}

8
EonaCat.Network/System/Sockets/RemoteInfo.cs
View File

@ -1,11 +1,11 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System.Net;
using System.Net;
using System.Net.Sockets;
namespace EonaCat.Network
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public class RemoteInfo
{
public bool IsTcp { get; set; }

9
EonaCat.Network/System/Sockets/Tcp/SocketTcpServer.cs
View File

@ -104,7 +104,7 @@ namespace EonaCat.Network
{
try
{
int received = await socket.ReceiveAsync(new Memory<byte>(buffer), SocketFlags.None, cancellationToken).ConfigureAwait(false);
int received = await ReceiveAsync(socket, buffer, cancellationToken).ConfigureAwait(false);
if (received > 0)
{
byte[] data = new byte[received];
@ -139,6 +139,13 @@ namespace EonaCat.Network
});
}
private Task<int> ReceiveAsync(Socket socket, byte[] buffer, CancellationToken cancellationToken)
{
return Task<int>.Factory.FromAsync(socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, null, socket),
socket.EndReceive);
}
/// <summary>
/// Send data to socket
/// </summary>

12
EonaCat.Network/System/Sockets/Web/ByteOrder.cs
View File

@ -1,12 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
public enum ByteOrder
{
Little,
Big
}
}

85
EonaCat.Network/System/Sockets/Web/CloseStatusCode.cs
View File

@ -1,85 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
public enum CloseStatusCode : ushort
{
//1000: Normal Closure
//Indicates a normal closure, meaning that the purpose for which the connection was established has been fulfilled.
//1001: Going Away
//The endpoint is going away, such as a server going down or a browser tab is closing.
//1002: Protocol Error
//Indicates that the endpoint is terminating the connection due to a protocol error.
//1003: Unsupported Data
//Indicates that the endpoint is terminating the connection because it received data that it cannot process.
//1005: No Status Received
//Reserved. It indicates that no status code was received.
//1006: Abnormal Closure
//Reserved. It is a reserved value and should not be set as a status code in a Close control frame by an endpoint.
//1007: Invalid frame payload data
//Indicates that an endpoint is terminating the connection because it has received data within a message that was not consistent with the type of the message.
//1008: Policy Violation
//Indicates that an endpoint is terminating the connection because it has received a message that violates its policy.
//1009: Message Too Big
//Indicates that an endpoint is terminating the connection because it has received a message that is too big for it to process.
//1010: Missing Extension
//Indicates that an endpoint is terminating the connection because it has received a message that requires negotiation of an extension, and the client did not offer that extension.
//1011: Internal Error
//Indicates that a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
//1012: Service Restart
//Reserved. It indicates that the service is restarting.
//1013: Try Again Later
//Reserved. It indicates that the server is temporarily unable to process the request.
//1014: Bad Gateway
//Reserved. It indicates that an intermediate server failed to fulfill a request.
//1015: TLS Handshake Failure
//Reserved. It indicates that the connection was closed due to a failure to perform a TLS handshake.
Normal = 1000,
Away = 1001,
ProtocolError = 1002,
UnsupportedData = 1003,
Undefined = 1004,
NoStatus = 1005,
Abnormal = 1006,
InvalidData = 1007,
PolicyViolation = 1008,
TooBig = 1009,
MissingExtension = 1010,
ServerError = 1011,
ServiceRestart = 1012,
TryAgainLater = 1013,
BadGateway = 1014,
TlsHandshakeFailure = 1015
}
}

12
EonaCat.Network/System/Sockets/Web/CompressionMethod.cs
View File

@ -1,12 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
public enum CompressionMethod : byte
{
None,
Deflate
}
}

129
EonaCat.Network/System/Sockets/Web/Core/Authentication/AuthenticationBase.cs
View File

@ -1,129 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Specialized;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents the base class for authentication in the EonaCat network library.
/// </summary>
internal abstract class AuthenticationBase
{
/// <summary>
/// Gets or sets the collection of authentication parameters.
/// </summary>
internal NameValueCollection Parameters;
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationBase"/> class.
/// </summary>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="parameters">The collection of authentication parameters.</param>
protected AuthenticationBase(AuthenticationSchemes scheme, NameValueCollection parameters)
{
Scheme = scheme;
Parameters = parameters;
}
/// <summary>
/// Gets the algorithm used for authentication.
/// </summary>
public string Algorithm => Parameters["algorithm"];
/// <summary>
/// Gets the nonce value for authentication.
/// </summary>
public string Nonce => Parameters["nonce"];
/// <summary>
/// Gets the opaque value for authentication.
/// </summary>
public string Opaque => Parameters["opaque"];
/// <summary>
/// Gets the quality of protection for authentication.
/// </summary>
public string Qop => Parameters["qop"];
/// <summary>
/// Gets the realm for authentication.
/// </summary>
public string Realm => Parameters["realm"];
/// <summary>
/// Gets the authentication scheme.
/// </summary>
public AuthenticationSchemes Scheme { get; }
/// <summary>
/// Creates a nonce value for authentication.
/// </summary>
/// <returns>A string representing the generated nonce value.</returns>
internal static string CreateNonceValue()
{
var buffer = new byte[16];
var random = new Random();
random.NextBytes(buffer);
var result = new StringBuilder(32);
foreach (var currentByte in buffer)
{
result.Append(currentByte.ToString("x2"));
}
return result.ToString();
}
/// <summary>
/// Parses the authentication parameters from the specified string value.
/// </summary>
/// <param name="value">The string containing authentication parameters.</param>
/// <returns>A collection of authentication parameters.</returns>
internal static NameValueCollection ParseParameters(string value)
{
var result = new NameValueCollection();
foreach (var param in value.SplitHeaderValue(','))
{
var i = param.IndexOf('=');
var name = i > 0 ? param.Substring(0, i).Trim() : null;
var val = i < 0
? param.Trim().Trim('"')
: i < param.Length - 1
? param.Substring(i + 1).Trim().Trim('"')
: string.Empty;
result.Add(name, val);
}
return result;
}
/// <summary>
/// Gets the authentication string for Basic authentication.
/// </summary>
/// <returns>A string representing the Basic authentication.</returns>
internal abstract string ToBasicString();
/// <summary>
/// Gets the authentication string for Digest authentication.
/// </summary>
/// <returns>A string representing the Digest authentication.</returns>
internal abstract string ToDigestString();
/// <summary>
/// Returns a string representation of the authentication information.
/// </summary>
/// <returns>A string representation of the authentication information.</returns>
public override string ToString()
{
return Scheme == AuthenticationSchemes.Basic
? ToBasicString()
: Scheme == AuthenticationSchemes.Digest
? ToDigestString()
: string.Empty;
}
}
}

136
EonaCat.Network/System/Sockets/Web/Core/Authentication/AuthenticationChallenge.cs
View File

@ -1,136 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System.Collections.Specialized;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents an authentication challenge in the EonaCat network library.
/// </summary>
internal class AuthenticationChallenge : AuthenticationBase
{
private const string BASIC = "basic";
private const string DIGEST = "digest";
private const int DIGEST_SIZE = 128;
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationChallenge"/> class for Basic or Digest authentication.
/// </summary>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="realm">The authentication realm.</param>
internal AuthenticationChallenge(AuthenticationSchemes scheme, string realm)
: base(scheme, new NameValueCollection())
{
Parameters["realm"] = realm;
if (scheme == AuthenticationSchemes.Digest)
{
Parameters["nonce"] = CreateNonceValue();
Parameters["algorithm"] = "MD5";
Parameters["qop"] = "auth";
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationChallenge"/> class.
/// </summary>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="parameters">The collection of authentication parameters.</param>
private AuthenticationChallenge(AuthenticationSchemes scheme, NameValueCollection parameters)
: base(scheme, parameters)
{
}
/// <summary>
/// Gets the domain for Digest authentication.
/// </summary>
public string Domain => Parameters["domain"];
/// <summary>
/// Gets the stale parameter for Digest authentication.
/// </summary>
public string Stale => Parameters["stale"];
/// <summary>
/// Creates a Basic authentication challenge with the specified realm.
/// </summary>
/// <param name="realm">The authentication realm.</param>
/// <returns>An instance of <see cref="AuthenticationChallenge"/> for Basic authentication.</returns>
internal static AuthenticationChallenge CreateBasicChallenge(string realm)
{
return new AuthenticationChallenge(AuthenticationSchemes.Basic, realm);
}
/// <summary>
/// Creates a Digest authentication challenge with the specified realm.
/// </summary>
/// <param name="realm">The authentication realm.</param>
/// <returns>An instance of <see cref="AuthenticationChallenge"/> for Digest authentication.</returns>
internal static AuthenticationChallenge CreateDigestChallenge(string realm)
{
return new AuthenticationChallenge(AuthenticationSchemes.Digest, realm);
}
/// <summary>
/// Parses an authentication challenge from the specified string value.
/// </summary>
/// <param name="value">The string containing the authentication challenge.</param>
/// <returns>An instance of <see cref="AuthenticationChallenge"/> if successful; otherwise, null.</returns>
internal static AuthenticationChallenge Parse(string value)
{
var challenge = value.Split(new[] { ' ' }, 2);
if (challenge.Length != 2)
{
return null;
}
var scheme = challenge[0].ToLower();
return scheme == BASIC
? new AuthenticationChallenge(
AuthenticationSchemes.Basic, ParseParameters(challenge[1]))
: scheme == DIGEST
? new AuthenticationChallenge(
AuthenticationSchemes.Digest, ParseParameters(challenge[1]))
: null;
}
/// <summary>
/// Gets the Basic authentication string representation of the authentication challenge.
/// </summary>
/// <returns>A string representing the Basic authentication challenge.</returns>
internal override string ToBasicString()
{
return string.Format($"Basic realm=\"{{0}}\"", Parameters["realm"]);
}
internal override string ToDigestString()
{
var output = new StringBuilder(DIGEST_SIZE);
var realm = Parameters["realm"];
var nonce = Parameters["nonce"];
if (realm != null)
{
output.AppendFormat("Digest realm=\"{0}\", nonce=\"{1}\"", realm, nonce);
AppendIfNotNull(output, "domain", Parameters["domain"]);
AppendIfNotNull(output, "opaque", Parameters["opaque"]);
AppendIfNotNull(output, "stale", Parameters["stale"]);
AppendIfNotNull(output, "algorithm", Parameters["algorithm"]);
AppendIfNotNull(output, "qop", Parameters["qop"]);
}
return output.ToString();
}
private static void AppendIfNotNull(StringBuilder output, string key, string value)
{
if (value != null)
{
output.AppendFormat(", {0}=\"{1}\"", key, value);
}
}
}
}

359
EonaCat.Network/System/Sockets/Web/Core/Authentication/AuthenticationResponse.cs
View File

@ -1,359 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Specialized;
using System.Security.Cryptography;
using System.Security.Principal;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents an authentication response in the EonaCat network library.
/// </summary>
internal class AuthenticationResponse : AuthenticationBase
{
private const string BASIC = "basic";
private const string DIGEST = "digest";
private uint _nonceCount;
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationResponse"/> class for Basic authentication.
/// </summary>
/// <param name="credentials">The network credentials.</param>
internal AuthenticationResponse(NetworkCredential credentials)
: this(AuthenticationSchemes.Basic, new NameValueCollection(), credentials, 0)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationResponse"/> class for Digest authentication.
/// </summary>
/// <param name="challenge">The authentication challenge.</param>
/// <param name="credentials">The network credentials.</param>
/// <param name="nonceCount">The nonce count.</param>
internal AuthenticationResponse(
AuthenticationChallenge challenge, NetworkCredential credentials, uint nonceCount)
: this(challenge.Scheme, challenge.Parameters, credentials, nonceCount)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationResponse"/> class.
/// </summary>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="parameters">The collection of authentication parameters.</param>
/// <param name="credentials">The network credentials.</param>
/// <param name="nonceCount">The nonce count.</param>
internal AuthenticationResponse(
AuthenticationSchemes scheme,
NameValueCollection parameters,
NetworkCredential credentials,
uint nonceCount)
: base(scheme, parameters)
{
Parameters["username"] = credentials.Username;
Parameters["password"] = credentials.Password;
Parameters["uri"] = credentials.Domain;
_nonceCount = nonceCount;
if (scheme == AuthenticationSchemes.Digest)
{
InitAsDigest();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationResponse"/> class.
/// </summary>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="parameters">The collection of authentication parameters.</param>
private AuthenticationResponse(AuthenticationSchemes scheme, NameValueCollection parameters)
: base(scheme, parameters)
{
}
/// <summary>
/// Gets the cnonce value for Digest authentication.
/// </summary>
public string Cnonce => Parameters["cnonce"];
/// <summary>
/// Gets the nonce count for Digest authentication.
/// </summary>
public string Nc => Parameters["nc"];
/// <summary>
/// Gets the password for authentication.
/// </summary>
public string Password => Parameters["password"];
/// <summary>
/// Gets the response value for authentication.
/// </summary>
public string Response => Parameters["response"];
/// <summary>
/// Gets the URI for authentication.
/// </summary>
public string Uri => Parameters["uri"];
/// <summary>
/// Gets the username for authentication.
/// </summary>
public string UserName => Parameters["username"];
/// <summary>
/// Gets the nonce count.
/// </summary>
internal uint NonceCount => _nonceCount < uint.MaxValue
? _nonceCount
: 0;
/// <summary>
/// Converts the authentication response to an identity.
/// </summary>
/// <returns>An instance of <see cref="IIdentity"/>.</returns>
public IIdentity ToIdentity()
{
var scheme = Scheme;
return scheme == AuthenticationSchemes.Basic
? new HttpBasicIdentity(Parameters["username"], Parameters["password"])
: scheme == AuthenticationSchemes.Digest
? new HttpDigestIdentity(Parameters)
: null;
}
/// <summary>
/// Creates the request digest for Digest authentication.
/// </summary>
/// <param name="parameters">The authentication parameters.</param>
/// <returns>The request digest.</returns>
internal static string CreateRequestDigest(NameValueCollection parameters)
{
var user = parameters["username"];
var pass = parameters["password"];
var realm = parameters["realm"];
var nonce = parameters["nonce"];
var uri = parameters["uri"];
var algo = parameters["algorithm"];
var qop = parameters["qop"];
var cnonce = parameters["cnonce"];
var nc = parameters["nc"];
var method = parameters["method"];
var a1 = algo != null && algo.ToLower() == "md5-sess"
? CreateA1(user, pass, realm, nonce, cnonce)
: CreateA1(user, pass, realm);
var a2 = qop != null && qop.ToLower() == "auth-int"
? CreateA2(method, uri, parameters["entity"])
: CreateA2(method, uri);
var secret = Hash(a1);
var data = qop != null
? string.Format("{0}:{1}:{2}:{3}:{4}", nonce, nc, cnonce, qop, Hash(a2))
: string.Format("{0}:{1}", nonce, Hash(a2));
return Hash(string.Format("{0}:{1}", secret, data));
}
/// <summary>
/// Parses an authentication response from the specified string value.
/// </summary>
/// <param name="value">The string containing the authentication response.</param>
/// <returns>An instance of <see cref="AuthenticationResponse"/> if successful; otherwise, null.</returns>
internal static AuthenticationResponse Parse(string value)
{
try
{
var cred = value.Split(new[] { ' ' }, 2);
if (cred.Length != 2)
{
return null;
}
var scheme = cred[0].ToLower();
return scheme == BASIC
? new AuthenticationResponse(
AuthenticationSchemes.Basic, ParseBasicCredentials(cred[1]))
: scheme == DIGEST
? new AuthenticationResponse(
AuthenticationSchemes.Digest, ParseParameters(cred[1]))
: null;
}
catch
{
}
return null;
}
/// <summary>
/// Parses the basic credentials from the specified string value.
/// </summary>
/// <param name="value">The string containing basic credentials.</param>
/// <returns>A collection of basic credentials.</returns>
internal static NameValueCollection ParseBasicCredentials(string value)
{
// Decode the basic-credentials (a Base64 encoded string).
var userPass = Encoding.Default.GetString(Convert.FromBase64String(value));
// The format is [<domain>\]<username>:<password>.
var i = userPass.IndexOf(':');
var user = userPass.Substring(0, i);
var pass = i < userPass.Length - 1 ? userPass.Substring(i + 1) : string.Empty;
// Check if 'domain' exists.
i = user.IndexOf('\\');
if (i > -1)
{
user = user.Substring(i + 1);
}
var res = new NameValueCollection
{
["username"] = user,
["password"] = pass
};
return res;
}
/// <summary>
/// Gets the Basic authentication string representation of the authentication response.
/// </summary>
/// <returns>A string representing the Basic authentication response.</returns>
internal override string ToBasicString()
{
var userPass = string.Format("{0}:{1}", Parameters["username"], Parameters["password"]);
var cred = Convert.ToBase64String(Encoding.UTF8.GetBytes(userPass));
return "Basic " + cred;
}
/// <summary>
/// Gets the Digest authentication string representation of the authentication response.
/// </summary>
/// <returns>A string representing the Digest authentication response.</returns>
internal override string ToDigestString()
{
var output = new StringBuilder(256);
output.AppendFormat($"Digest username=\"{Parameters["username"]}\", realm=\"{Parameters["realm"]}\", nonce=\"{Parameters["nonce"]}\", uri=\"{Parameters["uri"]}\", response=\"{Parameters["response"]}\"");
var opaque = Parameters["opaque"];
if (opaque != null)
{
output.AppendFormat($", opaque=\"{opaque}\"");
}
var algorithm = Parameters["algorithm"];
if (algorithm != null)
{
output.AppendFormat($", algorithm={algorithm}");
}
var qop = Parameters["qop"];
if (qop != null)
{
output.AppendFormat($", qop={qop}, cnonce=\"{Parameters["cnonce"]}\", nc={Parameters["nc"]}");
}
return output.ToString();
}
/// <summary>
/// Creates the A1 value for Digest authentication.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <param name="realm">The realm.</param>
/// <returns>The A1 value.</returns>
private static string CreateA1(string username, string password, string realm)
{
return $"{username}:{realm}:{password}";
}
/// <summary>
/// Creates the A1 value for Digest authentication with cnonce and nonce.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <param name="realm">The realm.</param>
/// <param name="nonce">The nonce.</param>
/// <param name="cnonce">The cnonce.</param>
/// <returns>The A1 value.</returns>
private static string CreateA1(
string username, string password, string realm, string nonce, string cnonce)
{
return $"{Hash(CreateA1(username, password, realm))}:{nonce}:{cnonce}";
}
/// <summary>
/// Creates the A2 value for Digest authentication.
/// </summary>
/// <param name="method">The HTTP method.</param>
/// <param name="uri">The URI.</param>
/// <returns>The A2 value.</returns>
private static string CreateA2(string method, string uri)
{
return $"{method}:{uri}";
}
/// <summary>
/// Creates the A2 value for Digest authentication with an entity.
/// </summary>
/// <param name="method">The HTTP method.</param>
/// <param name="uri">The URI.</param>
/// <param name="entity">The entity.</param>
/// <returns>The A2 value.</returns>
private static string CreateA2(string method, string uri, string entity)
{
return $"{method}:{uri}:{Hash(entity)}";
}
/// <summary>
/// Computes the MD5 hash of the given value.
/// </summary>
/// <param name="value">The value to hash.</param>
/// <returns>The MD5 hash.</returns>
private static string Hash(string value)
{
var source = Encoding.UTF8.GetBytes(value);
var md5 = MD5.Create();
var hashed = md5.ComputeHash(source);
var result = new StringBuilder(64);
foreach (var currentByte in hashed)
{
result.Append(currentByte.ToString("x2"));
}
return result.ToString();
}
/// <summary>
/// Initializes the authentication as Digest.
/// </summary>
private void InitAsDigest()
{
var qops = Parameters["qop"];
if (qops != null)
{
if (qops.Split(',').Contains(qop => qop.Trim().ToLower() == "auth"))
{
Parameters["qop"] = "auth";
Parameters["cnonce"] = CreateNonceValue();
Parameters["nc"] = string.Format("{0:x8}", ++_nonceCount);
}
else
{
Parameters["qop"] = null;
}
}
Parameters["method"] = "GET";
Parameters["response"] = CreateRequestDigest(Parameters);
}
}
}

31
EonaCat.Network/System/Sockets/Web/Core/Authentication/AuthenticationSchemes.cs
View File

@ -1,31 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
/// <summary>
/// Enumerates the possible authentication schemes in the EonaCat network library.
/// </summary>
public enum AuthenticationSchemes
{
/// <summary>
/// No authentication scheme.
/// </summary>
None,
/// <summary>
/// Digest authentication scheme.
/// </summary>
Digest = 1,
/// <summary>
/// Basic authentication scheme.
/// </summary>
Basic = 8,
/// <summary>
/// Anonymous authentication scheme.
/// </summary>
Anonymous = 0x8000
}
}

113
EonaCat.Network/System/Sockets/Web/Core/Authentication/NetworkCredential.cs
View File

@ -1,113 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
/// <summary>
/// Represents network credentials used for authentication in the EonaCat network library.
/// </summary>
public class NetworkCredential
{
private static readonly string[] _noRoles;
private string _domain;
private string _password;
private string[] _roles;
static NetworkCredential()
{
_noRoles = new string[0];
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkCredential"/> class with the specified username and password.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
public NetworkCredential(string username, string password)
: this(username, password, null, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkCredential"/> class with the specified username, password, domain, and roles.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <param name="domain">The domain.</param>
/// <param name="roles">The roles.</param>
public NetworkCredential(
string username, string password, string domain, params string[] roles
)
{
if (username == null)
{
throw new ArgumentNullException(nameof(username));
}
if (username.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(username));
}
Username = username;
_password = password;
_domain = domain;
_roles = roles;
}
/// <summary>
/// Gets or sets the domain associated with the network credentials.
/// </summary>
public string Domain
{
get
{
return _domain ?? string.Empty;
}
internal set
{
_domain = value;
}
}
/// <summary>
/// Gets or sets the password associated with the network credentials.
/// </summary>
public string Password
{
get
{
return _password ?? string.Empty;
}
internal set
{
_password = value;
}
}
/// <summary>
/// Gets or sets the roles associated with the network credentials.
/// </summary>
public string[] Roles
{
get
{
return _roles ?? _noRoles;
}
internal set
{
_roles = value;
}
}
/// <summary>
/// Gets the username associated with the network credentials.
/// </summary>
public string Username { get; internal set; }
}
}

56
EonaCat.Network/System/Sockets/Web/Core/Chunks/Chunk.cs
View File

@ -1,56 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
/// <summary>
/// Represents a chunk of data in the EonaCat network library.
/// </summary>
internal class WebChunk
{
private readonly byte[] _data;
private int _offset;
/// <summary>
/// Initializes a new instance of the <see cref="WebChunk"/> class with the specified data.
/// </summary>
/// <param name="data">The byte array representing the data.</param>
public WebChunk(byte[] data)
{
_data = data;
}
/// <summary>
/// Gets the remaining bytes to read in the chunk.
/// </summary>
public int ReadLeft => _data.Length - _offset;
/// <summary>
/// Reads a specified number of bytes from the chunk into a buffer.
/// </summary>
/// <param name="buffer">The destination buffer.</param>
/// <param name="offset">The zero-based byte offset in the buffer at which to begin storing the data.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <returns>The actual number of bytes read.</returns>
public int Read(byte[] buffer, int offset, int count)
{
var left = _data.Length - _offset;
if (left == 0)
{
return left;
}
if (count > left)
{
count = left;
}
Buffer.BlockCopy(_data, _offset, buffer, offset, count);
_offset += count;
return count;
}
}
}

398
EonaCat.Network/System/Sockets/Web/Core/Chunks/ChunkStream.cs
View File

@ -1,398 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents a stream for handling chunked data in the EonaCat network library.
/// </summary>
internal class ChunkStream
{
private readonly List<WebChunk> _chunks;
private readonly StringBuilder _saved;
private int _chunkRead;
private int _chunkSize;
private bool _foundSPCode;
private bool _gotChunck;
private InputChunkState _state;
private int _trailerState;
/// <summary>
/// Initializes a new instance of the <see cref="ChunkStream"/> class with the specified headers.
/// </summary>
/// <param name="headers">The web headers associated with the chunk stream.</param>
public ChunkStream(WebHeaderCollection headers)
{
Headers = headers;
_chunkSize = -1;
_chunks = new List<WebChunk>();
_saved = new StringBuilder();
}
/// <summary>
/// Initializes a new instance of the <see cref="ChunkStream"/> class with the specified buffer, offset, count, and headers.
/// </summary>
/// <param name="buffer">The byte array containing chunked data.</param>
/// <param name="offset">The offset in the buffer at which to begin reading.</param>
/// <param name="count">The number of bytes to read from the buffer.</param>
/// <param name="headers">The web headers associated with the chunk stream.</param>
public ChunkStream(byte[] buffer, int offset, int count, WebHeaderCollection headers)
: this(headers)
{
Write(buffer, offset, count);
}
/// <summary>
/// Gets the number of bytes left in the current chunk.
/// </summary>
public int ChunkLeft => _chunkSize - _chunkRead;
/// <summary>
/// Gets a value indicating whether more data is expected.
/// </summary>
public bool WantMore => _state != InputChunkState.End;
/// <summary>
/// Gets the web headers associated with the chunk stream.
/// </summary>
internal WebHeaderCollection Headers { get; }
/// <summary>
/// Reads a specified amount of data from the chunk stream.
/// </summary>
/// <param name="buffer">The destination buffer.</param>
/// <param name="offset">The zero-based byte offset in the buffer at which to begin storing the data.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <returns>The total number of bytes read into the buffer.</returns>
public int Read(byte[] buffer, int offset, int count)
{
if (count <= 0)
{
return 0;
}
return read(buffer, offset, count);
}
/// <summary>
/// Writes a specified amount of data to the chunk stream.
/// </summary>
/// <param name="buffer">The byte array containing data to be written to the chunk stream.</param>
/// <param name="offset">The offset in the buffer at which to begin writing.</param>
/// <param name="count">The number of bytes to write to the chunk stream.</param>
public void Write(byte[] buffer, int offset, int count)
{
if (count <= 0)
{
return;
}
Write(buffer, ref offset, offset + count);
}
/// <summary>
/// Resets the internal buffer and state of the chunk stream.
/// </summary>
internal void ResetBuffer()
{
_chunkRead = 0;
_chunkSize = -1;
_chunks.Clear();
}
/// <summary>
/// Writes a specified amount of data to the chunk stream and reads it back.
/// </summary>
/// <param name="buffer">The byte array containing data to be written to the chunk stream.</param>
/// <param name="offset">The offset in the buffer at which to begin writing.</param>
/// <param name="writeCount">The number of bytes to write to the chunk stream.</param>
/// <param name="readCount">The number of bytes to read back from the chunk stream.</param>
/// <returns>The number of bytes read from the chunk stream.</returns>
internal int WriteAndReadBack(byte[] buffer, int offset, int writeCount, int readCount)
{
Write(buffer, offset, writeCount);
return Read(buffer, offset, readCount);
}
private static string RemoveChunkExtension(string value)
{
var index = value.IndexOf(';');
return index > -1 ? value.Substring(0, index) : value;
}
private static void ThrowProtocolViolation(string message)
{
throw new WebException($"EonaCat Network: {message}", null, WebExceptionStatus.ServerProtocolViolation, null);
}
private int read(byte[] buffer, int offset, int count)
{
var nread = 0;
var cnt = _chunks.Count;
for (var i = 0; i < cnt; i++)
{
var chunk = _chunks[i];
if (chunk == null)
{
continue;
}
if (chunk.ReadLeft == 0)
{
_chunks[i] = null;
continue;
}
nread += chunk.Read(buffer, offset + nread, count - nread);
if (nread == count)
{
break;
}
}
return nread;
}
private InputChunkState SeekCrLf(byte[] buffer, ref int offset, int length)
{
if (!_gotChunck)
{
if (buffer[offset++] != 13)
{
ThrowProtocolViolation("CR is expected.");
}
_gotChunck = true;
if (offset == length)
{
return InputChunkState.DataEnded;
}
}
if (buffer[offset++] != 10)
{
ThrowProtocolViolation("LF is expected.");
}
return InputChunkState.None;
}
private InputChunkState SetChunkSize(byte[] buffer, ref int offset, int length)
{
byte currentByte = 0;
while (offset < length)
{
currentByte = buffer[offset++];
if (_gotChunck)
{
if (currentByte != 10)
{
ThrowProtocolViolation("LF is expected.");
}
break;
}
if (currentByte == 13)
{
_gotChunck = true;
continue;
}
if (currentByte == 10)
{
ThrowProtocolViolation("LF is unexpected.");
}
if (currentByte == 32) // SP
{
_foundSPCode = true;
}
if (!_foundSPCode)
{
_saved.Append((char)currentByte);
}
if (_saved.Length > 20)
{
ThrowProtocolViolation("The chunk size is too long.");
}
}
if (!_gotChunck || currentByte != 10)
{
return InputChunkState.None;
}
_chunkRead = 0;
try
{
_chunkSize = int.Parse(
RemoveChunkExtension(_saved.ToString()), NumberStyles.HexNumber);
}
catch
{
ThrowProtocolViolation("The chunk size cannot be parsed.");
}
if (_chunkSize == 0)
{
_trailerState = 2;
return InputChunkState.Trailer;
}
return InputChunkState.Data;
}
private InputChunkState setTrailer(byte[] buffer, ref int offset, int length)
{
// Check if no trailer.
if (_trailerState == 2 && buffer[offset] == 13 && _saved.Length == 0)
{
offset++;
if (offset < length && buffer[offset] == 10)
{
offset++;
return InputChunkState.End;
}
offset--;
}
while (offset < length && _trailerState < 4)
{
var currentByte = buffer[offset++];
_saved.Append((char)currentByte);
if (_saved.Length > 4196)
{
ThrowProtocolViolation("The trailer is too long.");
}
if (_trailerState == 1 || _trailerState == 3)
{
if (currentByte != 10)
{
ThrowProtocolViolation("LF is expected.");
}
_trailerState++;
continue;
}
if (currentByte == 13)
{
_trailerState++;
continue;
}
if (currentByte == 10)
{
ThrowProtocolViolation("LF is unexpected.");
}
_trailerState = 0;
}
if (_trailerState < 4)
{
return InputChunkState.Trailer;
}
_saved.Length -= 2;
var reader = new StringReader(_saved.ToString());
string line;
while ((line = reader.ReadLine()) != null && line.Length > 0)
{
Headers.Add(line);
}
return InputChunkState.End;
}
private void Write(byte[] buffer, ref int offset, int length)
{
if (_state == InputChunkState.End)
{
ThrowProtocolViolation("The chunks were ended.");
}
if (_state == InputChunkState.None)
{
_state = SetChunkSize(buffer, ref offset, length);
if (_state == InputChunkState.None)
{
return;
}
_saved.Length = 0;
_gotChunck = false;
_foundSPCode = false;
}
if (_state == InputChunkState.Data && offset < length)
{
_state = WriteData(buffer, ref offset, length);
if (_state == InputChunkState.Data)
{
return;
}
}
if (_state == InputChunkState.DataEnded && offset < length)
{
_state = SeekCrLf(buffer, ref offset, length);
if (_state == InputChunkState.DataEnded)
{
return;
}
_gotChunck = false;
}
if (_state == InputChunkState.Trailer && offset < length)
{
_state = setTrailer(buffer, ref offset, length);
if (_state == InputChunkState.Trailer)
{
return;
}
_saved.Length = 0;
}
if (offset < length)
{
Write(buffer, ref offset, length);
}
}
private InputChunkState WriteData(byte[] buffer, ref int offset, int length)
{
var cnt = length - offset;
var left = _chunkSize - _chunkRead;
if (cnt > left)
{
cnt = left;
}
var data = new byte[cnt];
Buffer.BlockCopy(buffer, offset, data, 0, cnt);
_chunks.Add(new WebChunk(data));
offset += cnt;
_chunkRead += cnt;
return _chunkRead == _chunkSize ? InputChunkState.DataEnded : InputChunkState.Data;
}
}
}

208
EonaCat.Network/System/Sockets/Web/Core/Chunks/ChunkedRequestStream.cs
View File

@ -1,208 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
namespace EonaCat.Network
{
/// <summary>
/// Represents a stream for handling chunked requests in the EonaCat network library.
/// </summary>
internal class ChunkedRequestStream : RequestStream
{
private const int _bufferLength = 8192;
private readonly HttpListenerContext _context;
private bool _disposed;
private bool _noMoreData;
/// <summary>
/// Initializes a new instance of the <see cref="ChunkedRequestStream"/> class with the specified stream, buffer, offset, count, and context.
/// </summary>
/// <param name="stream">The underlying stream.</param>
/// <param name="buffer">The byte array used for buffering.</param>
/// <param name="offset">The offset in the buffer at which to begin reading.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <param name="context">The HTTP listener context.</param>
internal ChunkedRequestStream(Stream stream, byte[] buffer, int offset, int count, HttpListenerContext context)
: base(stream, buffer, offset, count)
{
_context = context;
Decoder = new ChunkStream((WebHeaderCollection)context.Request.Headers);
}
/// <summary>
/// Gets or sets the chunk stream decoder associated with the chunked request stream.
/// </summary>
internal ChunkStream Decoder { get; set; }
/// <summary>
/// Begins an asynchronous read operation from the stream.
/// </summary>
/// <param name="buffer">The destination buffer.</param>
/// <param name="offset">The zero-based byte offset in the buffer at which to begin storing the data.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <param name="callback">An optional asynchronous callback, to be called when the read is complete.</param>
/// <param name="state">A user-provided object that distinguishes this particular asynchronous read request from other requests.</param>
/// <returns>An <see cref="IAsyncResult"/> that represents the asynchronous read operation.</returns>
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), "A negative value.");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), "A negative value.");
}
var len = buffer.Length;
if (offset + count > len)
{
throw new ArgumentException(
"The sum of 'offset' and 'count' is greater than 'buffer' length.");
}
var result = new HttpStreamAsyncResult(callback, state);
if (_noMoreData)
{
result.Complete();
return result;
}
var nread = Decoder.Read(buffer, offset, count);
offset += nread;
count -= nread;
if (count == 0)
{
result.Count = nread;
result.Complete();
return result;
}
if (!Decoder.WantMore)
{
_noMoreData = nread == 0;
result.Count = nread;
result.Complete();
return result;
}
result.Buffer = new byte[_bufferLength];
result.Offset = 0;
result.Count = _bufferLength;
var readBufferState = new ReadBufferState(buffer, offset, count, result);
readBufferState.InitialCount += nread;
base.BeginRead(result.Buffer, result.Offset, result.Count, OnRead, readBufferState);
return result;
}
/// <summary>
/// Closes the stream.
/// </summary>
public override void Close()
{
if (_disposed)
{
return;
}
_disposed = true;
base.Close();
}
/// <summary>
/// Ends an asynchronous read operation from the stream.
/// </summary>
/// <param name="asyncResult">The result of the asynchronous operation.</param>
/// <returns>The number of bytes read from the stream, between zero (0) and the number of bytes you requested. Streams return zero (0) only at the end of the stream, otherwise, they should block until at least one byte is available.</returns>
public override int EndRead(IAsyncResult asyncResult)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
if (asyncResult == null)
{
throw new ArgumentNullException(nameof(asyncResult));
}
if (asyncResult is not HttpStreamAsyncResult result)
{
throw new ArgumentException("A wrong IAsyncResult.", nameof(asyncResult));
}
if (!result.IsCompleted)
{
result.AsyncWaitHandle.WaitOne();
}
if (result.HasException)
{
throw new HttpListenerException(400, "I/O operation aborted.");
}
return result.Count;
}
/// <summary>
/// Reads a sequence of bytes from the stream and advances the position within the stream by the number of bytes read.
/// </summary>
/// <param name="buffer">The byte array to read data into.</param>
/// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data.</param>
/// <param name="count">The maximum number of bytes to be read from the stream.</param>
/// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
public override int Read(byte[] buffer, int offset, int count)
{
var result = BeginRead(buffer, offset, count, null, null);
return EndRead(result);
}
private void OnRead(IAsyncResult asyncResult)
{
var readBufferState = (ReadBufferState)asyncResult.AsyncState;
var result = readBufferState.AsyncResult;
try
{
var nread = base.EndRead(asyncResult);
Decoder.Write(result.Buffer, result.Offset, nread);
nread = Decoder.Read(readBufferState.Buffer, readBufferState.Offset, readBufferState.Count);
readBufferState.Offset += nread;
readBufferState.Count -= nread;
if (readBufferState.Count == 0 || !Decoder.WantMore || nread == 0)
{
_noMoreData = !Decoder.WantMore && nread == 0;
result.Count = readBufferState.InitialCount - readBufferState.Count;
result.Complete();
return;
}
result.Offset = 0;
result.Count = Math.Min(_bufferLength, Decoder.ChunkLeft + 6);
base.BeginRead(result.Buffer, result.Offset, result.Count, OnRead, readBufferState);
}
catch (Exception ex)
{
_context.Connection.SendError(ex.Message, 400);
result.Complete(ex);
}
}
}
}

41
EonaCat.Network/System/Sockets/Web/Core/Collections/QueryStringCollection.cs
View File

@ -1,41 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System.Collections.Specialized;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents a collection of query string parameters in the EonaCat network library.
/// </summary>
internal sealed class QueryStringCollection : NameValueCollection
{
/// <summary>
/// Converts the collection to its string representation.
/// </summary>
/// <returns>A string representation of the query string parameters.</returns>
public override string ToString()
{
var count = Count;
if (count == 0)
{
return string.Empty;
}
var output = new StringBuilder();
var keys = AllKeys;
foreach (var key in keys)
{
output.AppendFormat($"{key}={this[key]}&");
}
if (output.Length > 0)
{
output.Length--;
}
return output.ToString();
}
}
}

599
EonaCat.Network/System/Sockets/Web/Core/Collections/WebHeaderCollection.cs
View File

@ -1,599 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents a collection of HTTP headers in the EonaCat Network library.
/// </summary>
[Serializable]
[ComVisible(true)]
public class WebHeaderCollection : NameValueCollection, ISerializable
{
private const int BUFFER_SIZE = 65535;
private static readonly Dictionary<string, HttpHeaderInfo> _headers;
private readonly bool _internallyUsed;
private HttpHeaderType _state;
static WebHeaderCollection()
{
_headers = new Dictionary<string, HttpHeaderInfo>(StringComparer.InvariantCultureIgnoreCase)
{
{ "Accept", new HttpHeaderInfo("Accept", HttpHeaderType.Request | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) },
{ "AcceptCharset", new HttpHeaderInfo("Accept-Charset", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "AcceptEncoding", new HttpHeaderInfo("Accept-Encoding", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "AcceptLanguage", new HttpHeaderInfo("Accept-Language", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "AcceptRanges", new HttpHeaderInfo("Accept-Ranges", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Age", new HttpHeaderInfo("Age", HttpHeaderType.Response) },
{ "Allow", new HttpHeaderInfo("Allow", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Authorization", new HttpHeaderInfo("Authorization", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "CacheControl", new HttpHeaderInfo("Cache-Control", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Connection", new HttpHeaderInfo("Connection", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) },
{ "ContentEncoding", new HttpHeaderInfo("Content-Encoding", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "ContentLanguage", new HttpHeaderInfo("Content-Language", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "ContentLength", new HttpHeaderInfo("Content-Length", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted) },
{ "ContentLocation", new HttpHeaderInfo("Content-Location", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "ContentMd5", new HttpHeaderInfo("Content-MD5", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "ContentRange", new HttpHeaderInfo("Content-Range", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "ContentType", new HttpHeaderInfo("Content-Type", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted) },
{ "Cookie", new HttpHeaderInfo("Cookie", HttpHeaderType.Request) },
{ "Cookie2", new HttpHeaderInfo("Cookie2", HttpHeaderType.Request) },
{ "Date", new HttpHeaderInfo("Date", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted) },
{ "Expect", new HttpHeaderInfo("Expect", HttpHeaderType.Request | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) },
{ "Expires", new HttpHeaderInfo("Expires", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "ETag", new HttpHeaderInfo("ETag", HttpHeaderType.Response) },
{ "From", new HttpHeaderInfo("From", HttpHeaderType.Request) },
{ "Host", new HttpHeaderInfo("Host", HttpHeaderType.Request | HttpHeaderType.Restricted) },
{ "IfMatch", new HttpHeaderInfo("If-Match", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "IfModifiedSince", new HttpHeaderInfo("If-Modified-Since", HttpHeaderType.Request | HttpHeaderType.Restricted) },
{ "IfNoneMatch", new HttpHeaderInfo("If-None-Match", HttpHeaderType.Request | HttpHeaderType.MultiValue) },
{ "IfRange", new HttpHeaderInfo("If-Range", HttpHeaderType.Request) },
{ "IfUnmodifiedSince", new HttpHeaderInfo("If-Unmodified-Since", HttpHeaderType.Request) },
{ "KeepAlive", new HttpHeaderInfo("Keep-Alive", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "LastModified", new HttpHeaderInfo("Last-Modified", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "Location", new HttpHeaderInfo("Location", HttpHeaderType.Response) },
{ "MaxForwards", new HttpHeaderInfo("Max-Forwards", HttpHeaderType.Request) },
{ "Pragma", new HttpHeaderInfo("Pragma", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "ProxyAuthenticate", new HttpHeaderInfo("Proxy-Authenticate", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "ProxyAuthorization", new HttpHeaderInfo("Proxy-Authorization", HttpHeaderType.Request) },
{ "ProxyConnection", new HttpHeaderInfo("Proxy-Connection", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted) },
{ "Public", new HttpHeaderInfo("Public", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Range", new HttpHeaderInfo("Range", HttpHeaderType.Request | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) },
{ "Referer", new HttpHeaderInfo("Referer", HttpHeaderType.Request | HttpHeaderType.Restricted) },
{ "RetryAfter", new HttpHeaderInfo("Retry-After", HttpHeaderType.Response) },
{ "SecWebSocketAccept", new HttpHeaderInfo("Sec-WebSocket-Accept", HttpHeaderType.Response | HttpHeaderType.Restricted) },
{ "SecWebSocketExtensions", new HttpHeaderInfo("Sec-WebSocket-Extensions", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted | HttpHeaderType.MultiValueInRequest) },
{ "SecWebSocketKey", new HttpHeaderInfo("Sec-WebSocket-Key", HttpHeaderType.Request | HttpHeaderType.Restricted) },
{ "SecWebSocketProtocol", new HttpHeaderInfo("Sec-WebSocket-Protocol", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValueInRequest) },
{ "SecWebSocketVersion", new HttpHeaderInfo("Sec-WebSocket-Version", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted | HttpHeaderType.MultiValueInResponse) },
{ "Server", new HttpHeaderInfo("Server", HttpHeaderType.Response) },
{ "SetCookie", new HttpHeaderInfo("Set-Cookie", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "SetCookie2", new HttpHeaderInfo("Set-Cookie2", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Te", new HttpHeaderInfo("TE", HttpHeaderType.Request) },
{ "Trailer", new HttpHeaderInfo("Trailer", HttpHeaderType.Request | HttpHeaderType.Response) },
{ "TransferEncoding", new HttpHeaderInfo("Transfer-Encoding", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) },
{ "Translate", new HttpHeaderInfo("Translate", HttpHeaderType.Request) },
{ "Upgrade", new HttpHeaderInfo("Upgrade", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "UserAgent", new HttpHeaderInfo("User-Agent", HttpHeaderType.Request | HttpHeaderType.Restricted) },
{ "Vary", new HttpHeaderInfo("Vary", HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Via", new HttpHeaderInfo("Via", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "Warning", new HttpHeaderInfo("Warning", HttpHeaderType.Request | HttpHeaderType.Response | HttpHeaderType.MultiValue) },
{ "WwwAuthenticate", new HttpHeaderInfo("WWW-Authenticate", HttpHeaderType.Response | HttpHeaderType.Restricted | HttpHeaderType.MultiValue) }
};
}
public WebHeaderCollection()
{
}
/// <summary>
/// Initializes a new instance of the WebHeaderCollection class with the specified parameters.
/// </summary>
/// <param name="state">The HTTP header type.</param>
/// <param name="internallyUsed">A boolean indicating whether the collection is internally used.</param>
internal WebHeaderCollection(HttpHeaderType state, bool internallyUsed)
{
_state = state;
_internallyUsed = internallyUsed;
}
/// <summary>
/// Initializes a new instance of the WebHeaderCollection class with serialization information.
/// </summary>
/// <param name="serializationInfo">The SerializationInfo containing the data needed to serialize the WebHeaderCollection.</param>
/// <param name="streamingContext">The StreamingContext containing the source and destination of the serialized stream associated with the WebHeaderCollection.</param>
protected WebHeaderCollection(
SerializationInfo serializationInfo, StreamingContext streamingContext)
{
if (serializationInfo == null)
{
throw new ArgumentNullException(nameof(serializationInfo));
}
try
{
_internallyUsed = serializationInfo.GetBoolean("InternallyUsed");
_state = (HttpHeaderType)serializationInfo.GetInt32("State");
var cnt = serializationInfo.GetInt32("Count");
for (var i = 0; i < cnt; i++)
{
base.Add(
serializationInfo.GetString(i.ToString()),
serializationInfo.GetString((cnt + i).ToString()));
}
}
catch (SerializationException ex)
{
throw new ArgumentException(ex.Message, nameof(serializationInfo), ex);
}
}
public override string[] AllKeys => base.AllKeys;
public override int Count => base.Count;
public override KeysCollection Keys => base.Keys;
internal HttpHeaderType State => _state;
public string this[HttpRequestHeader header]
{
get
{
return Get(Convert(header));
}
set
{
Add(header, value);
}
}
public string this[HttpResponseHeader header]
{
get
{
return Get(Convert(header));
}
set
{
Add(header, value);
}
}
public static bool IsRestricted(string headerName)
{
return isRestricted(CheckName(headerName), false);
}
public static bool IsRestricted(string headerName, bool response)
{
return isRestricted(CheckName(headerName), response);
}
public void Add(string header)
{
if (header == null || header.Length == 0)
{
throw new ArgumentNullException(nameof(header));
}
var pos = checkColonSeparated(header);
add(header.Substring(0, pos), header.Substring(pos + 1), false);
}
public void Add(HttpRequestHeader header, string value)
{
DoWithCheckingState(addWithoutCheckingName, Convert(header), value, false, true);
}
public void Add(HttpResponseHeader header, string value)
{
DoWithCheckingState(addWithoutCheckingName, Convert(header), value, true, true);
}
public override void Add(string name, string value)
{
add(name, value, false);
}
public override void Clear()
{
base.Clear();
_state = HttpHeaderType.Unspecified;
}
public override string Get(int index)
{
return base.Get(index);
}
public override string Get(string name)
{
return base.Get(name);
}
public override IEnumerator GetEnumerator()
{
return base.GetEnumerator();
}
public override string GetKey(int index)
{
return base.GetKey(index);
}
[SecurityPermission(
SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public override void GetObjectData(
SerializationInfo serializationInfo, StreamingContext streamingContext)
{
if (serializationInfo == null)
{
throw new ArgumentNullException(nameof(serializationInfo));
}
serializationInfo.AddValue("InternallyUsed", _internallyUsed);
serializationInfo.AddValue("State", (int)_state);
var cnt = Count;
serializationInfo.AddValue("Count", cnt);
cnt.Times(
i =>
{
serializationInfo.AddValue(i.ToString(), GetKey(i));
serializationInfo.AddValue((cnt + i).ToString(), Get(i));
});
}
[SecurityPermission(
SecurityAction.LinkDemand,
Flags = SecurityPermissionFlag.SerializationFormatter,
SerializationFormatter = true)]
void ISerializable.GetObjectData(
SerializationInfo serializationInfo, StreamingContext streamingContext)
{
GetObjectData(serializationInfo, streamingContext);
}
public override string[] GetValues(int index)
{
var vals = base.GetValues(index);
return vals != null && vals.Length > 0 ? vals : null;
}
public override string[] GetValues(string header)
{
var vals = base.GetValues(header);
return vals != null && vals.Length > 0 ? vals : null;
}
public override void OnDeserialization(object sender)
{
}
public void Remove(HttpRequestHeader header)
{
DoWithCheckingState(removeWithoutCheckingName, Convert(header), null, false, false);
}
public void Remove(HttpResponseHeader header)
{
DoWithCheckingState(removeWithoutCheckingName, Convert(header), null, true, false);
}
public override void Remove(string name)
{
DoWithCheckingState(removeWithoutCheckingName, CheckName(name), null, false);
}
public void Set(HttpRequestHeader header, string value)
{
DoWithCheckingState(setWithoutCheckingName, Convert(header), value, false, true);
}
public void Set(HttpResponseHeader header, string value)
{
DoWithCheckingState(setWithoutCheckingName, Convert(header), value, true, true);
}
public override void Set(string name, string value)
{
DoWithCheckingState(setWithoutCheckingName, CheckName(name), value, true);
}
/// <summary>
/// Returns a byte array representing the WebHeaderCollection in UTF-8 encoding.
/// </summary>
/// <returns>A byte array representing the WebHeaderCollection.</returns>
public byte[] ToByteArray()
{
return Encoding.UTF8.GetBytes(ToString());
}
/// <summary>
/// Returns a string representation of the WebHeaderCollection.
/// </summary>
/// <returns>A string representing the WebHeaderCollection.</returns>
public override string ToString()
{
var buff = new StringBuilder();
Count.Times(i => buff.AppendFormat($"{GetKey(i)}: {Get(i)}\r\n"));
return buff.Append("\r\n").ToString();
}
/// <summary>
/// Converts the specified HttpRequestHeader to a string.
/// </summary>
/// <param name="header">The HttpRequestHeader to convert.</param>
/// <returns>A string representing the converted HttpRequestHeader.</returns>
internal static string Convert(HttpRequestHeader header)
{
return Convert(header.ToString());
}
internal static string Convert(HttpResponseHeader header)
{
return Convert(header.ToString());
}
internal static bool IsHeaderName(string name)
{
return name != null && name.Length > 0 && name.IsToken();
}
internal static bool IsHeaderValue(string value)
{
return value.IsText();
}
internal static bool IsMultiValue(string headerName, bool response)
{
if (headerName == null || headerName.Length == 0)
{
return false;
}
var info = GetHeaderInfo(headerName);
return info != null && info.IsMultiValue(response);
}
internal void InternalRemove(string name)
{
base.Remove(name);
}
internal void InternalSet(string header, bool response)
{
var pos = checkColonSeparated(header);
InternalSet(header.Substring(0, pos), header.Substring(pos + 1), response);
}
internal void InternalSet(string name, string value, bool response)
{
value = CheckValue(value);
if (IsMultiValue(name, response))
{
base.Add(name, value);
}
else
{
base.Set(name, value);
}
}
internal string ToStringMultiValue(bool response)
{
var buff = new StringBuilder();
Count.Times(
i =>
{
var key = GetKey(i);
if (IsMultiValue(key, response))
{
foreach (var val in GetValues(i))
{
buff.AppendFormat($"{key}: {val}\r\n");
}
}
else
{
buff.AppendFormat($"{key}: {Get(i)}\r\n");
}
});
return buff.Append("\r\n").ToString();
}
protected void AddWithoutValidate(string headerName, string headerValue)
{
add(headerName, headerValue, true);
}
private static int checkColonSeparated(string header)
{
var idx = header.IndexOf(':');
if (idx == -1)
{
throw new ArgumentException("No colon could be found.", nameof(header));
}
return idx;
}
private static HttpHeaderType CheckHeaderType(string name)
{
var info = GetHeaderInfo(name);
return info == null
? HttpHeaderType.Unspecified
: info.IsRequest && !info.IsResponse
? HttpHeaderType.Request
: !info.IsRequest && info.IsResponse
? HttpHeaderType.Response
: HttpHeaderType.Unspecified;
}
private static string CheckName(string name)
{
if (name == null || name.Length == 0)
{
throw new ArgumentNullException(nameof(name));
}
name = name.Trim();
if (!IsHeaderName(name))
{
throw new ArgumentException("Contains invalid characters.", nameof(name));
}
return name;
}
private static string CheckValue(string value)
{
if (value == null || value.Length == 0)
{
return string.Empty;
}
value = value.Trim();
if (value.Length > BUFFER_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(value), "Greater than 65,535 characters.");
}
if (!IsHeaderValue(value))
{
throw new ArgumentException("Contains invalid characters.", nameof(value));
}
return value;
}
private static string Convert(string key)
{
return _headers.TryGetValue(key, out HttpHeaderInfo info) ? info.Name : string.Empty;
}
private static HttpHeaderInfo GetHeaderInfo(string name)
{
foreach (var info in _headers.Values)
{
if (info.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
return info;
}
}
return null;
}
private static bool isRestricted(string name, bool response)
{
var info = GetHeaderInfo(name);
return info != null && info.IsRestricted(response);
}
private void add(string name, string value, bool ignoreRestricted)
{
var act = ignoreRestricted
? (Action<string, string>)addWithoutCheckingNameAndRestricted
: addWithoutCheckingName;
DoWithCheckingState(act, CheckName(name), value, true);
}
private void addWithoutCheckingName(string name, string value)
{
DoWithoutCheckingName(base.Add, name, value);
}
private void addWithoutCheckingNameAndRestricted(string name, string value)
{
base.Add(name, CheckValue(value));
}
private void CheckRestricted(string name)
{
if (!_internallyUsed && isRestricted(name, true))
{
throw new ArgumentException("This header must be modified with the appropiate property.");
}
}
private void CheckState(bool response)
{
if (_state == HttpHeaderType.Unspecified)
{
return;
}
if (response && _state == HttpHeaderType.Request)
{
throw new InvalidOperationException(
"This collection has already been used to store the request headers.");
}
if (!response && _state == HttpHeaderType.Response)
{
throw new InvalidOperationException(
"This collection has already been used to store the response headers.");
}
}
private void DoWithCheckingState(
Action<string, string> action, string name, string value, bool setState)
{
var type = CheckHeaderType(name);
if (type == HttpHeaderType.Request)
{
DoWithCheckingState(action, name, value, false, setState);
}
else if (type == HttpHeaderType.Response)
{
DoWithCheckingState(action, name, value, true, setState);
}
else
{
action(name, value);
}
}
private void DoWithCheckingState(
Action<string, string> action, string name, string value, bool response, bool setState)
{
CheckState(response);
action(name, value);
if (setState && _state == HttpHeaderType.Unspecified)
{
_state = response ? HttpHeaderType.Response : HttpHeaderType.Request;
}
}
private void DoWithoutCheckingName(Action<string, string> action, string name, string value)
{
CheckRestricted(name);
action(name, CheckValue(value));
}
private void removeWithoutCheckingName(string name, string unuse)
{
CheckRestricted(name);
base.Remove(name);
}
private void setWithoutCheckingName(string name, string value)
{
DoWithoutCheckingName(base.Set, name, value);
}
}
}

111
EonaCat.Network/System/Sockets/Web/Core/Context/HttpListenerWSContext.cs
View File

@ -1,111 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents the context of a WebSocket connection within an <see cref="HttpListener"/>.
/// </summary>
/// <remarks>
/// This class provides access to various properties and methods for interacting with the WebSocket connection
/// within the context of an HTTP request handled by an <see cref="HttpListener"/>.
/// </remarks>
/// <seealso cref="WSContext"/>
public class HttpListenerWSContext : WSContext
{
private readonly HttpListenerContext _context;
private readonly WSClient _websocket;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerWSContext"/> class.
/// </summary>
/// <param name="context">The <see cref="HttpListenerContext"/> associated with the WebSocket connection.</param>
/// <param name="protocol">The WebSocket protocol negotiated during the connection.</param>
internal HttpListenerWSContext(HttpListenerContext context, string protocol)
{
_context = context;
_websocket = new WSClient(this, protocol);
}
public override CookieCollection CookieCollection => _context.Request.Cookies;
public override NameValueCollection Headers => _context.Request.Headers;
public override string Host => _context.Request.Headers["Host"];
public override bool IsAuthenticated => _context.User != null;
public override bool IsLocal => _context.Request.IsLocal;
public override bool IsSecureConnection => _context.Connection.IsSecure;
public override bool IsWebSocketRequest => _context.Request.IsWebSocketRequest;
public override string Origin => _context.Request.Headers["Origin"];
public override NameValueCollection QueryString => _context.Request.QueryString;
public override Uri RequestUri => _context.Request.Url;
public override string SecWebSocketKey => _context.Request.Headers["Sec-WebSocket-Key"];
public override IEnumerable<string> SecWebSocketProtocols
{
get
{
var protocols = _context.Request.Headers["Sec-WebSocket-Protocol"];
if (protocols != null)
{
foreach (var protocol in protocols.Split(','))
{
yield return protocol.Trim();
}
}
}
}
public override string SecWebSocketVersion => _context.Request.Headers["Sec-WebSocket-Version"];
public override System.Net.IPEndPoint ServerEndPoint => _context.Connection.LocalEndPoint;
public override IPrincipal User => _context.User;
public override System.Net.IPEndPoint UserEndPoint => _context.Connection.RemoteEndPoint;
public override WSClient WebSocket => _websocket;
/// <summary>
/// Gets the stream of the underlying TCP connection.
/// </summary>
internal Stream Stream => _context.Connection.Stream;
/// <inheritdoc />
public override string ToString()
{
return _context.Request.ToString();
}
/// <summary>
/// Closes the WebSocket connection.
/// </summary>
internal void Close()
{
_context.Connection.Close(true);
}
/// <summary>
/// Closes the WebSocket connection with the specified HTTP status code.
/// </summary>
/// <param name="code">The HTTP status code indicating the reason for closure.</param>
internal void Close(HttpStatusCode code)
{
_context.Response.Close(code);
}
}
}

230
EonaCat.Network/System/Sockets/Web/Core/Context/TcpListenerWSContext.cs
View File

@ -1,230 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Principal;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents the context of a WebSocket connection within a <see cref="TcpListener"/>.
/// </summary>
/// <remarks>
/// This internal class provides access to various properties and methods for interacting with the WebSocket connection
/// within the context of a TCP listener.
/// </remarks>
internal class TcpListenerWSContext : WSContext
{
private readonly bool _secure;
private readonly TcpClient _tcpClient;
private readonly Uri _uri;
private readonly WSClient _websocket;
private CookieCollection _cookies;
private NameValueCollection _queryString;
private WebRequest _request;
private IPrincipal _user;
/// <summary>
/// Initializes a new instance of the <see cref="TcpListenerWSContext"/> class.
/// </summary>
/// <param name="tcpClient">The <see cref="TcpClient"/> associated with the WebSocket connection.</param>
/// <param name="protocol">The WebSocket protocol negotiated during the connection.</param>
/// <param name="secure">A boolean indicating whether the connection is secure.</param>
/// <param name="sslConfig">The SSL config for secure connections.</param>
internal TcpListenerWSContext(
TcpClient tcpClient,
string protocol,
bool secure,
SSLConfigServer sslConfig
)
{
_tcpClient = tcpClient;
_secure = secure;
var netStream = tcpClient.GetStream();
if (secure)
{
var sslStream =
new SslStream(netStream, false, sslConfig.ClientCertificateValidationCallback);
sslStream.AuthenticateAsServer(
sslConfig.Certificate,
sslConfig.IsClientCertificateRequired,
sslConfig.SslProtocols,
sslConfig.CheckForCertificateRevocation
);
Stream = sslStream;
}
else
{
Stream = netStream;
}
_request = WebRequest.Read(Stream, 90000);
_uri =
HttpUtility.CreateRequestUrl(
_request.RequestUri, _request.Headers["Host"], _request.IsWebSocketRequest, secure
);
_websocket = new WSClient(this, protocol);
}
public override CookieCollection CookieCollection => _cookies ??= _request.Cookies;
public override NameValueCollection Headers => _request.Headers;
public override string Host => _request.Headers["Host"];
public override bool IsAuthenticated => _user != null;
public override bool IsLocal => UserEndPoint.Address.IsLocal();
public override bool IsSecureConnection => _secure;
public override bool IsWebSocketRequest => _request.IsWebSocketRequest;
public override string Origin => _request.Headers["Origin"];
public override NameValueCollection QueryString => _queryString ??=
HttpUtility.InternalParseQueryString(
_uri?.Query, Encoding.UTF8
)
;
public override Uri RequestUri => _uri;
public override string SecWebSocketKey => _request.Headers["Sec-WebSocket-Key"];
public override IEnumerable<string> SecWebSocketProtocols
{
get
{
var protocols = _request.Headers["Sec-WebSocket-Protocol"];
if (protocols != null)
{
foreach (var protocol in protocols.Split(','))
{
yield return protocol.Trim();
}
}
}
}
public override string SecWebSocketVersion => _request.Headers["Sec-WebSocket-Version"];
public override System.Net.IPEndPoint ServerEndPoint => (System.Net.IPEndPoint)_tcpClient.Client.LocalEndPoint;
public override IPrincipal User => _user;
public override System.Net.IPEndPoint UserEndPoint => (System.Net.IPEndPoint)_tcpClient.Client.RemoteEndPoint;
public override WSClient WebSocket => _websocket;
/// <summary>
/// Gets the stream of the underlying TCP connection.
/// </summary>
internal Stream Stream { get; }
/// <inheritdoc />
public override string ToString()
{
return _request.ToString();
}
/// <summary>
/// Authenticates the WebSocket connection based on the specified authentication scheme.
/// </summary>
/// <param name="scheme">The authentication scheme to use.</param>
/// <param name="realm">The authentication realm.</param>
/// <param name="credentialsFinder">A function to find network credentials based on identity.</param>
/// <returns>True if authentication is successful; otherwise, false.</returns>
internal bool Authenticate(
AuthenticationSchemes scheme,
string realm,
Func<IIdentity, NetworkCredential> credentialsFinder
)
{
if (scheme == AuthenticationSchemes.Anonymous)
{
return true;
}
if (scheme == AuthenticationSchemes.None)
{
Close(HttpStatusCode.Forbidden);
return false;
}
var chal = new AuthenticationChallenge(scheme, realm).ToString();
var retry = -1;
Func<bool> auth = null;
auth =
() =>
{
retry++;
if (retry > 99)
{
Close(HttpStatusCode.Forbidden);
return false;
}
var user =
HttpUtility.CreateUser(
_request.Headers["Authorization"],
scheme,
realm,
_request.HttpMethod,
credentialsFinder
);
if (user == null || !user.Identity.IsAuthenticated)
{
SendAuthenticationChallenge(chal);
return auth();
}
_user = user;
return true;
};
return auth();
}
/// <summary>
/// Closes the WebSocket connection.
/// </summary>
internal void Close()
{
Stream.Close();
_tcpClient.Close();
}
/// <summary>
/// Closes the WebSocket connection with the specified HTTP status code.
/// </summary>
/// <param name="code">The HTTP status code indicating the reason for closure.</param>
internal void Close(HttpStatusCode code)
{
_websocket.Close(WebResponse.CreateCloseResponse(code));
}
/// <summary>
/// Sends an authentication challenge to the WebSocket client.
/// </summary>
/// <param name="challenge">The authentication challenge.</param>
internal void SendAuthenticationChallenge(string challenge)
{
var buff = WebResponse.CreateUnauthorizedResponse(challenge).ToByteArray();
Stream.Write(buff, 0, buff.Length);
_request = WebRequest.Read(Stream, 15000);
}
}
}

112
EonaCat.Network/System/Sockets/Web/Core/Context/WSContext.cs
View File

@ -1,112 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents the context of a WebSocket connection.
/// </summary>
/// <remarks>
/// This abstract class defines properties and methods for accessing information related to a WebSocket connection,
/// such as headers, cookies, authentication status, and more.
/// </remarks>
public abstract class WSContext
{
/// <summary>
/// Initializes a new instance of the <see cref="WSContext"/> class.
/// </summary>
protected WSContext()
{
}
/// <summary>
/// Gets the collection of cookies associated with the WebSocket connection.
/// </summary>
public abstract CookieCollection CookieCollection { get; }
/// <summary>
/// Gets the collection of headers associated with the WebSocket connection.
/// </summary>
public abstract NameValueCollection Headers { get; }
/// <summary>
/// Gets the host information from the WebSocket connection.
/// </summary>
public abstract string Host { get; }
/// <summary>
/// Gets a value indicating whether the WebSocket connection is authenticated.
/// </summary>
public abstract bool IsAuthenticated { get; }
/// <summary>
/// Gets a value indicating whether the WebSocket connection is local.
/// </summary>
public abstract bool IsLocal { get; }
/// <summary>
/// Gets a value indicating whether the WebSocket connection is secure.
/// </summary>
public abstract bool IsSecureConnection { get; }
/// <summary>
/// Gets a value indicating whether the request is a WebSocket request.
/// </summary>
public abstract bool IsWebSocketRequest { get; }
/// <summary>
/// Gets the origin of the WebSocket connection.
/// </summary>
public abstract string Origin { get; }
/// <summary>
/// Gets the query string information from the WebSocket connection.
/// </summary>
public abstract NameValueCollection QueryString { get; }
/// <summary>
/// Gets the URI of the WebSocket request.
/// </summary>
public abstract Uri RequestUri { get; }
/// <summary>
/// Gets the value of the 'Sec-WebSocket-Key' header from the WebSocket connection.
/// </summary>
public abstract string SecWebSocketKey { get; }
/// <summary>
/// Gets the protocols specified in the 'Sec-WebSocket-Protocol' header from the WebSocket connection.
/// </summary>
public abstract IEnumerable<string> SecWebSocketProtocols { get; }
/// <summary>
/// Gets the value of the 'Sec-WebSocket-Version' header from the WebSocket connection.
/// </summary>
public abstract string SecWebSocketVersion { get; }
/// <summary>
/// Gets the local endpoint of the WebSocket server.
/// </summary>
public abstract System.Net.IPEndPoint ServerEndPoint { get; }
/// <summary>
/// Gets the user associated with the WebSocket connection.
/// </summary>
public abstract IPrincipal User { get; }
/// <summary>
/// Gets the remote endpoint of the WebSocket user.
/// </summary>
public abstract System.Net.IPEndPoint UserEndPoint { get; }
/// <summary>
/// Gets the WebSocket instance associated with the context.
/// </summary>
public abstract WSClient WebSocket { get; }
}
}

590
EonaCat.Network/System/Sockets/Web/Core/Cookies/Cookie.cs
View File

@ -1,590 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Globalization;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP cookie.
/// </summary>
[Serializable]
public sealed class Cookie
{
private static readonly char[] _reservedCharsForName;
private static readonly char[] _reservedCharsForValue;
private readonly DateTime _timestamp;
private string _comment;
private Uri _commentUri;
private bool _discard;
private string _domain;
private DateTime _expires;
private bool _httpOnly;
private string _name;
private string _path;
private string _port;
private int[] _ports;
private bool _secure;
private string _value;
private int _version;
static Cookie()
{
_reservedCharsForName = new[] { ' ', '=', ';', ',', '\n', '\r', '\t' };
_reservedCharsForValue = new[] { ';', ',' };
}
/// <summary>
/// Initializes a new instance of the <see cref="Cookie"/> class.
/// </summary>
public Cookie()
{
_comment = string.Empty;
_domain = string.Empty;
_expires = DateTime.MinValue;
_name = string.Empty;
_path = string.Empty;
_port = string.Empty;
_ports = new int[0];
_timestamp = DateTime.Now;
_value = string.Empty;
_version = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="Cookie"/> class with the specified name and value.
/// </summary>
/// <param name="name">The name of the cookie.</param>
/// <param name="value">The value of the cookie.</param>
public Cookie(string name, string value)
: this()
{
Name = name;
Value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="Cookie"/> class with the specified name, value, and path.
/// </summary>
/// <param name="name">The name of the cookie.</param>
/// <param name="value">The value of the cookie.</param>
/// <param name="path">The path for which the cookie is valid.</param>
public Cookie(string name, string value, string path)
: this(name, value)
{
Path = path;
}
/// <summary>
/// Initializes a new instance of the <see cref="Cookie"/> class with the specified name, value, path, and domain.
/// </summary>
/// <param name="name">The name of the cookie.</param>
/// <param name="value">The value of the cookie.</param>
/// <param name="path">The path for which the cookie is valid.</param>
/// <param name="domain">The domain to which the cookie belongs.</param>
public Cookie(string name, string value, string path, string domain)
: this(name, value, path)
{
Domain = domain;
}
public string Comment
{
get
{
return _comment;
}
set
{
_comment = value ?? string.Empty;
}
}
public Uri CommentUri
{
get
{
return _commentUri;
}
set
{
_commentUri = value;
}
}
public bool Discard
{
get
{
return _discard;
}
set
{
_discard = value;
}
}
public string Domain
{
get
{
return _domain;
}
set
{
if (value.IsNullOrEmpty())
{
_domain = string.Empty;
ExactDomain = true;
}
else
{
_domain = value;
ExactDomain = value[0] != '.';
}
}
}
public bool Expired
{
get
{
return _expires != DateTime.MinValue && _expires <= DateTime.Now;
}
set
{
_expires = value ? DateTime.Now : DateTime.MinValue;
}
}
public DateTime Expires
{
get
{
return _expires;
}
set
{
_expires = value;
}
}
public bool HttpOnly
{
get
{
return _httpOnly;
}
set
{
_httpOnly = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
if (!canSetName(value, out string message))
{
throw new CookieException(message);
}
_name = value;
}
}
public string Path
{
get
{
return _path;
}
set
{
_path = value ?? string.Empty;
}
}
public string Port
{
get
{
return _port;
}
set
{
if (value.IsNullOrEmpty())
{
_port = string.Empty;
_ports = new int[0];
return;
}
if (!value.IsEnclosedIn('"'))
{
throw new CookieException(
"The value specified for the Port attribute isn't enclosed in double quotes.");
}
if (!tryCreatePorts(value, out _ports, out string err))
{
throw new CookieException(
string.Format(
"The value specified for the Port attribute contains an invalid value: {0}", err));
}
_port = value;
}
}
public bool Secure
{
get
{
return _secure;
}
set
{
_secure = value;
}
}
public DateTime TimeStamp => _timestamp;
public string Value
{
get
{
return _value;
}
set
{
if (!canSetValue(value, out string message))
{
throw new CookieException(message);
}
_value = value.Length > 0 ? value : "\"\"";
}
}
public int Version
{
get
{
return _version;
}
set
{
if (value < 0 || value > 1)
{
throw new ArgumentOutOfRangeException(nameof(value), "Not 0 or 1.");
}
_version = value;
}
}
internal bool ExactDomain
{
get; set;
}
internal int MaxAge
{
get
{
if (_expires == DateTime.MinValue)
{
return 0;
}
var expires = _expires.Kind != DateTimeKind.Local
? _expires.ToLocalTime()
: _expires;
var span = expires - DateTime.Now;
return span > TimeSpan.Zero
? (int)span.TotalSeconds
: 0;
}
}
internal int[] Ports => _ports;
/// <inheritdoc />
public override bool Equals(object comparand)
{
return comparand is Cookie cookie &&
_name.Equals(cookie.Name, StringComparison.InvariantCultureIgnoreCase) &&
_value.Equals(cookie.Value, StringComparison.InvariantCulture) &&
_path.Equals(cookie.Path, StringComparison.InvariantCulture) &&
_domain.Equals(cookie.Domain, StringComparison.InvariantCultureIgnoreCase) &&
_version == cookie.Version;
}
/// <inheritdoc />
public override int GetHashCode()
{
return hash(
StringComparer.InvariantCultureIgnoreCase.GetHashCode(_name),
_value.GetHashCode(),
_path.GetHashCode(),
StringComparer.InvariantCultureIgnoreCase.GetHashCode(_domain),
_version);
}
/// <inheritdoc />
public override string ToString()
{
return ToRequestString(null);
}
// From client to server
internal string ToRequestString(Uri uri)
{
if (_name.Length == 0)
{
return string.Empty;
}
if (_version == 0)
{
return string.Format("{0}={1}", _name, _value);
}
var output = new StringBuilder(64);
output.AppendFormat("$Version={0}; {1}={2}", _version, _name, _value);
if (!_path.IsNullOrEmpty())
{
output.AppendFormat("; $Path={0}", _path);
}
else if (uri != null)
{
output.AppendFormat("; $Path={0}", uri.GetAbsolutePath());
}
else
{
output.Append("; $Path=/");
}
var appendDomain = uri == null || uri.Host != _domain;
if (appendDomain && !_domain.IsNullOrEmpty())
{
output.AppendFormat("; $Domain={0}", _domain);
}
if (!_port.IsNullOrEmpty())
{
if (_port == "\"\"")
{
output.Append("; $Port");
}
else
{
output.AppendFormat("; $Port={0}", _port);
}
}
return output.ToString();
}
// From server to client
internal string ToResponseString()
{
return _name.Length > 0
? (_version == 0 ? ToResponseStringVersion0() : ToResponseStringVersion1())
: string.Empty;
}
private static bool canSetName(string name, out string message)
{
if (name.IsNullOrEmpty())
{
message = "The value specified for the Name is null or empty.";
return false;
}
if (name[0] == '$' || name.Contains(_reservedCharsForName))
{
message = "The value specified for the Name contains an invalid character.";
return false;
}
message = string.Empty;
return true;
}
private static bool canSetValue(string value, out string message)
{
if (value == null)
{
message = "The value specified for the Value is null.";
return false;
}
if (value.Contains(_reservedCharsForValue) && !value.IsEnclosedIn('"'))
{
message = "The value specified for the Value contains an invalid character.";
return false;
}
message = string.Empty;
return true;
}
private static int hash(int i, int j, int k, int l, int m)
{
return i ^
(j << 13 | j >> 19) ^
(k << 26 | k >> 6) ^
(l << 7 | l >> 25) ^
(m << 20 | m >> 12);
}
private static bool tryCreatePorts(string value, out int[] result, out string parseError)
{
var ports = value.Trim('"').Split(',');
var len = ports.Length;
var res = new int[len];
for (var i = 0; i < len; i++)
{
res[i] = int.MinValue;
var port = ports[i].Trim();
if (port.Length == 0)
{
continue;
}
if (!int.TryParse(port, out res[i]))
{
result = new int[0];
parseError = port;
return false;
}
}
result = res;
parseError = string.Empty;
return true;
}
private string ToResponseStringVersion0()
{
var output = new StringBuilder(64);
output.AppendFormat("{0}={1}", _name, _value);
if (_expires != DateTime.MinValue)
{
output.AppendFormat(
"; Expires={0}",
_expires.ToUniversalTime().ToString(
"ddd, dd'-'MMM'-'yyyy HH':'mm':'ss 'GMT'",
CultureInfo.CreateSpecificCulture("en-US")));
}
if (!_path.IsNullOrEmpty())
{
output.AppendFormat("; Path={0}", _path);
}
if (!_domain.IsNullOrEmpty())
{
output.AppendFormat("; Domain={0}", _domain);
}
if (_secure)
{
output.Append("; Secure");
}
if (_httpOnly)
{
output.Append("; HttpOnly");
}
return output.ToString();
}
private string ToResponseStringVersion1()
{
var output = new StringBuilder(64);
output.AppendFormat("{0}={1}; Version={2}", _name, _value, _version);
if (_expires != DateTime.MinValue)
{
output.AppendFormat("; Max-Age={0}", MaxAge);
}
if (!_path.IsNullOrEmpty())
{
output.AppendFormat("; Path={0}", _path);
}
if (!_domain.IsNullOrEmpty())
{
output.AppendFormat("; Domain={0}", _domain);
}
if (!_port.IsNullOrEmpty())
{
if (_port == "\"\"")
{
output.Append("; Port");
}
else
{
output.AppendFormat("; Port={0}", _port);
}
}
if (!_comment.IsNullOrEmpty())
{
output.AppendFormat("; Comment={0}", _comment.UrlEncode());
}
if (_commentUri != null)
{
var url = _commentUri.OriginalString;
output.AppendFormat("; CommentURL={0}", url.IsToken() ? url : url.Quote());
}
if (_discard)
{
output.Append("; Discard");
}
if (_secure)
{
output.Append("; Secure");
}
return output.ToString();
}
}
}

545
EonaCat.Network/System/Sockets/Web/Core/Cookies/CookieCollection.cs
View File

@ -1,545 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents a collection of HTTP cookies.
/// </summary>
[Serializable]
public class CookieCollection : ICollection, IEnumerable
{
private readonly List<Cookie> _list;
private object _locker;
/// <summary>
/// Initializes a new instance of the <see cref="CookieCollection"/> class.
/// </summary>
public CookieCollection()
{
_list = new List<Cookie>();
}
/// <summary>
/// Gets the number of cookies in the collection.
/// </summary>
public int Count => _list.Count;
/// <summary>
/// Gets a value indicating whether the collection is read-only. Always returns true.
/// </summary>
public bool IsReadOnly => true;
/// <summary>
/// Gets a value indicating whether access to the collection is synchronized (thread-safe). Always returns false.
/// </summary>
public bool IsSynchronized => false;
/// <summary>
/// Gets an object that can be used to synchronize access to the collection.
/// </summary>
public object SyncRoot => _locker ??= ((ICollection)_list).SyncRoot;
internal IList<Cookie> List => _list;
internal IEnumerable<Cookie> Sorted
{
get
{
var list = new List<Cookie>(_list);
if (list.Count > 1)
{
list.Sort(compareCookieWithinSorted);
}
return list;
}
}
/// <summary>
/// Gets or sets the cookie at the specified index.
/// </summary>
/// <param name="index">The index of the cookie to get or set.</param>
/// <returns>The cookie at the specified index.</returns>
public Cookie this[int index]
{
get
{
if (index < 0 || index >= _list.Count)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
return _list[index];
}
}
/// <summary>
/// Gets the cookie with the specified name.
/// </summary>
/// <param name="name">The name of the cookie to retrieve.</param>
/// <returns>The cookie with the specified name, or null if the cookie is not found.</returns>
public Cookie this[string name]
{
get
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
foreach (var cookie in Sorted)
{
if (cookie.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
{
return cookie;
}
}
return null;
}
}
/// <summary>
/// Adds the specified cookie to the collection, updating it if it already exists.
/// </summary>
/// <param name="cookie">The cookie to add or update.</param>
public void Add(Cookie cookie)
{
if (cookie == null)
{
throw new ArgumentNullException(nameof(cookie));
}
var pos = searchCookie(cookie);
if (pos == -1)
{
_list.Add(cookie);
return;
}
_list[pos] = cookie;
}
/// <summary>
/// Adds the cookies from the specified <see cref="CookieCollection"/> to this collection, updating existing cookies.
/// </summary>
/// <param name="cookies">The <see cref="CookieCollection"/> to add or update from.</param>
public void Add(CookieCollection cookies)
{
if (cookies == null)
{
throw new ArgumentNullException(nameof(cookies));
}
foreach (Cookie cookie in cookies)
{
Add(cookie);
}
}
/// <summary>
/// Copies the cookies in the collection to the specified array, starting at the specified index.
/// </summary>
/// <param name="array">The destination array.</param>
/// <param name="index">The index in the destination array at which copying begins.</param>
public void CopyTo(Array array, int index)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index), "Less than zero.");
}
if (array.Rank > 1)
{
throw new ArgumentException("Multidimensional.", nameof(array));
}
if (array.Length - index < _list.Count)
{
throw new ArgumentException(
"The number of elements in this collection is greater than the available space of the destination array.");
}
if (!array.GetType().GetElementType().IsAssignableFrom(typeof(Cookie)))
{
throw new InvalidCastException(
"The elements in this collection cannot be cast automatically to the type of the destination array.");
} ((IList)_list).CopyTo(array, index);
}
/// <summary>
/// Copies the cookies in the collection to the specified <see cref="Cookie"/> array, starting at the specified index.
/// </summary>
/// <param name="array">The destination array.</param>
/// <param name="index">The index in the destination array at which copying begins.</param>
public void CopyTo(Cookie[] array, int index)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index), "Less than zero.");
}
if (array.Length - index < _list.Count)
{
throw new ArgumentException(
"The number of elements in this collection is greater than the available space of the destination array.");
}
_list.CopyTo(array, index);
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>An enumerator for the collection.</returns>
public IEnumerator GetEnumerator()
{
return _list.GetEnumerator();
}
/// <summary>
/// Parses the specified cookie string, creating a <see cref="CookieCollection"/>.
/// </summary>
/// <param name="value">The cookie string to parse.</param>
/// <param name="response">True if parsing a response header; otherwise, false.</param>
/// <returns>A <see cref="CookieCollection"/> instance representing the parsed cookies.</returns>
internal static CookieCollection Parse(string value, bool response)
{
return response
? parseResponse(value)
: parseRequest(value);
}
internal void SetOrRemove(Cookie cookie)
{
var pos = searchCookie(cookie);
if (pos == -1)
{
if (!cookie.Expired)
{
_list.Add(cookie);
}
return;
}
if (!cookie.Expired)
{
_list[pos] = cookie;
return;
}
_list.RemoveAt(pos);
}
internal void SetOrRemove(CookieCollection cookies)
{
foreach (Cookie cookie in cookies)
{
SetOrRemove(cookie);
}
}
internal void Sort()
{
if (_list.Count > 1)
{
_list.Sort(compareCookieWithinSort);
}
}
private static int compareCookieWithinSort(Cookie x, Cookie y)
{
return (x.Name.Length + x.Value.Length) - (y.Name.Length + y.Value.Length);
}
private static int compareCookieWithinSorted(Cookie x, Cookie y)
{
var ret = 0;
return (ret = x.Version - y.Version) != 0
? ret
: (ret = x.Name.CompareTo(y.Name)) != 0
? ret
: y.Path.Length - x.Path.Length;
}
private static CookieCollection parseRequest(string value)
{
var cookies = new CookieCollection();
Cookie cookie = null;
var ver = 0;
var pairs = splitCookieHeaderValue(value);
for (var i = 0; i < pairs.Length; i++)
{
var pair = pairs[i].Trim();
if (pair.Length == 0)
{
continue;
}
if (pair.StartsWith("$version", StringComparison.InvariantCultureIgnoreCase))
{
ver = int.Parse(pair.GetValue('=', true));
}
else if (pair.StartsWith("$path", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Path = pair.GetValue('=');
}
}
else if (pair.StartsWith("$domain", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Domain = pair.GetValue('=');
}
}
else if (pair.StartsWith("$port", StringComparison.InvariantCultureIgnoreCase))
{
var port = pair.Equals("$port", StringComparison.InvariantCultureIgnoreCase)
? "\"\""
: pair.GetValue('=');
if (cookie != null)
{
cookie.Port = port;
}
}
else
{
if (cookie != null)
{
cookies.Add(cookie);
}
string name;
string val = string.Empty;
var pos = pair.IndexOf('=');
if (pos == -1)
{
name = pair;
}
else if (pos == pair.Length - 1)
{
name = pair.Substring(0, pos).TrimEnd(' ');
}
else
{
name = pair.Substring(0, pos).TrimEnd(' ');
val = pair.Substring(pos + 1).TrimStart(' ');
}
cookie = new Cookie(name, val);
if (ver != 0)
{
cookie.Version = ver;
}
}
}
if (cookie != null)
{
cookies.Add(cookie);
}
return cookies;
}
private static CookieCollection parseResponse(string value)
{
var cookies = new CookieCollection();
Cookie cookie = null;
var pairs = splitCookieHeaderValue(value);
for (var i = 0; i < pairs.Length; i++)
{
var pair = pairs[i].Trim();
if (pair.Length == 0)
{
continue;
}
if (pair.StartsWith("version", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Version = int.Parse(pair.GetValue('=', true));
}
}
else if (pair.StartsWith("expires", StringComparison.InvariantCultureIgnoreCase))
{
var buff = new StringBuilder(pair.GetValue('='), 32);
if (i < pairs.Length - 1)
{
buff.AppendFormat(", {0}", pairs[++i].Trim());
}
if (!DateTime.TryParseExact(
buff.ToString(),
new[] { "ddd, dd'-'MMM'-'yyyy HH':'mm':'ss 'GMT'", "r" },
CultureInfo.CreateSpecificCulture("en-US"),
DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal,
out DateTime expires))
{
expires = DateTime.Now;
}
if (cookie != null && cookie.Expires == DateTime.MinValue)
{
cookie.Expires = expires.ToLocalTime();
}
}
else if (pair.StartsWith("max-age", StringComparison.InvariantCultureIgnoreCase))
{
var max = int.Parse(pair.GetValue('=', true));
var expires = DateTime.Now.AddSeconds(max);
if (cookie != null)
{
cookie.Expires = expires;
}
}
else if (pair.StartsWith("path", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Path = pair.GetValue('=');
}
}
else if (pair.StartsWith("domain", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Domain = pair.GetValue('=');
}
}
else if (pair.StartsWith("port", StringComparison.InvariantCultureIgnoreCase))
{
var port = pair.Equals("port", StringComparison.InvariantCultureIgnoreCase)
? "\"\""
: pair.GetValue('=');
if (cookie != null)
{
cookie.Port = port;
}
}
else if (pair.StartsWith("comment", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Comment = pair.GetValue('=').UrlDecode();
}
}
else if (pair.StartsWith("commenturl", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.CommentUri = pair.GetValue('=', true).ToUri();
}
}
else if (pair.StartsWith("discard", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Discard = true;
}
}
else if (pair.StartsWith("secure", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.Secure = true;
}
}
else if (pair.StartsWith("httponly", StringComparison.InvariantCultureIgnoreCase))
{
if (cookie != null)
{
cookie.HttpOnly = true;
}
}
else
{
if (cookie != null)
{
cookies.Add(cookie);
}
string name;
string val = string.Empty;
var pos = pair.IndexOf('=');
if (pos == -1)
{
name = pair;
}
else if (pos == pair.Length - 1)
{
name = pair.Substring(0, pos).TrimEnd(' ');
}
else
{
name = pair.Substring(0, pos).TrimEnd(' ');
val = pair.Substring(pos + 1).TrimStart(' ');
}
cookie = new Cookie(name, val);
}
}
if (cookie != null)
{
cookies.Add(cookie);
}
return cookies;
}
private static string[] splitCookieHeaderValue(string value)
{
return new List<string>(value.SplitHeaderValue(',', ';')).ToArray();
}
private int searchCookie(Cookie cookie)
{
var name = cookie.Name;
var path = cookie.Path;
var domain = cookie.Domain;
var ver = cookie.Version;
for (var i = _list.Count - 1; i >= 0; i--)
{
var c = _list[i];
if (c.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase) &&
c.Path.Equals(path, StringComparison.InvariantCulture) &&
c.Domain.Equals(domain, StringComparison.InvariantCultureIgnoreCase) &&
c.Version == ver)
{
return i;
}
}
return -1;
}
}
}

81
EonaCat.Network/System/Sockets/Web/Core/Cookies/CookieException.cs
View File

@ -1,81 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Runtime.Serialization;
using System.Security.Permissions;
namespace EonaCat.Network
{
/// <summary>
/// Represents an exception specific to EonaCat Network cookies.
/// </summary>
[Serializable]
public class CookieException : FormatException, ISerializable
{
/// <summary>
/// Initializes a new instance of the <see cref="CookieException"/> class.
/// </summary>
public CookieException()
: base()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieException"/> class with a specified error message.
/// </summary>
/// <param name="message">The error message that explains the reason for the exception.</param>
internal CookieException(string message)
: base($"EonaCat Network: {message}")
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieException"/> class with a specified error message
/// and a reference to the inner exception that is the cause of this exception.
/// </summary>
/// <param name="message">The error message that explains the reason for the exception.</param>
/// <param name="innerException">The exception that is the cause of the current exception.</param>
internal CookieException(string message, Exception innerException)
: base($"EonaCat Network: {message}", innerException)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieException"/> class.
/// </summary>
protected CookieException(
SerializationInfo serializationInfo, StreamingContext streamingContext)
: base(serializationInfo, streamingContext)
{
}
/// <summary>
/// Populates a <see cref="SerializationInfo"/> with the data needed to serialize the exception.
/// </summary>
/// <param name="serializationInfo">The <see cref="SerializationInfo"/> to populate with data.</param>
/// <param name="streamingContext">The destination (see <see cref="StreamingContext"/>) for this serialization.</param>
[SecurityPermission(
SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public override void GetObjectData(
SerializationInfo serializationInfo, StreamingContext streamingContext)
{
base.GetObjectData(serializationInfo, streamingContext);
}
/// <summary>
/// Populates a <see cref="SerializationInfo"/> with the data needed to serialize the exception.
/// </summary>
/// <param name="serializationInfo">The <see cref="SerializationInfo"/> to populate with data.</param>
/// <param name="streamingContext">The destination (see <see cref="StreamingContext"/>) for this serialization.</param>
[SecurityPermission(
SecurityAction.LinkDemand,
Flags = SecurityPermissionFlag.SerializationFormatter,
SerializationFormatter = true)]
void ISerializable.GetObjectData(
SerializationInfo serializationInfo, StreamingContext streamingContext)
{
base.GetObjectData(serializationInfo, streamingContext);
}
}
}

532
EonaCat.Network/System/Sockets/Web/Core/Endpoints/EndPointListener.cs
View File

@ -1,532 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
namespace EonaCat.Network
{
/// <summary>
/// Represents an endpoint listener for managing HTTP connections.
/// </summary>
internal sealed class EndPointListener
{
private static readonly string _defaultCertFolderPath;
private readonly IPEndPoint _endpoint;
private readonly Socket _socket;
private readonly Dictionary<HttpConnection, HttpConnection> _unregistered;
private readonly object _unregisteredSync;
private List<HttpListenerPrefix> _all; // host == '+'
private Dictionary<HttpListenerPrefix, HttpListener> _prefixes;
private List<HttpListenerPrefix> _unhandled; // host == '*'
static EndPointListener()
{
_defaultCertFolderPath =
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
}
internal EndPointListener(
IPEndPoint endpoint,
bool secure,
string certificateFolderPath,
SSLConfigServer sslConfig,
bool reuseAddress
)
{
if (secure)
{
var cert =
getCertificate(endpoint.Port, certificateFolderPath, sslConfig.Certificate);
if (cert == null)
{
throw new ArgumentException("No server certificate could be found.");
}
IsSecure = true;
SSL = new SSLConfigServer(sslConfig);
SSL.Certificate = cert;
}
_endpoint = endpoint;
_prefixes = new Dictionary<HttpListenerPrefix, HttpListener>();
_unregistered = new Dictionary<HttpConnection, HttpConnection>();
_unregisteredSync = ((ICollection)_unregistered).SyncRoot;
_socket =
new Socket(endpoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (reuseAddress)
{
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
}
_socket.Bind(endpoint);
_socket.Listen(500);
_socket.BeginAccept(onAccept, this);
}
/// <summary>
/// Gets the IP address of the endpoint.
/// </summary>
public IPAddress Address => _endpoint.Address;
/// <summary>
/// Gets a value indicating whether the endpoint is secure.
/// </summary>
public bool IsSecure { get; }
/// <summary>
/// Gets the port number of the endpoint.
/// </summary>
public int Port => _endpoint.Port;
/// <summary>
/// Gets the SSL config for the secure endpoint.
/// </summary>
public SSLConfigServer SSL { get; }
public void AddPrefix(HttpListenerPrefix prefix, HttpListener listener)
{
List<HttpListenerPrefix> current, future;
if (prefix.Host == "*")
{
do
{
current = _unhandled;
future = current != null
? new List<HttpListenerPrefix>(current)
: new List<HttpListenerPrefix>();
prefix.Listener = listener;
addSpecial(future, prefix);
}
while (Interlocked.CompareExchange(ref _unhandled, future, current) != current);
return;
}
if (prefix.Host == "+")
{
do
{
current = _all;
future = current != null
? new List<HttpListenerPrefix>(current)
: new List<HttpListenerPrefix>();
prefix.Listener = listener;
addSpecial(future, prefix);
}
while (Interlocked.CompareExchange(ref _all, future, current) != current);
return;
}
Dictionary<HttpListenerPrefix, HttpListener> prefs, prefs2;
do
{
prefs = _prefixes;
if (prefs.ContainsKey(prefix))
{
if (prefs[prefix] != listener)
{
throw new HttpListenerException(
87, string.Format("There's another listener for {0}.", prefix)
);
}
return;
}
prefs2 = new Dictionary<HttpListenerPrefix, HttpListener>(prefs)
{
[prefix] = listener
};
}
while (Interlocked.CompareExchange(ref _prefixes, prefs2, prefs) != prefs);
}
public void Close()
{
_socket.Close();
HttpConnection[] conns = null;
lock (_unregisteredSync)
{
if (_unregistered.Count == 0)
{
return;
}
var keys = _unregistered.Keys;
conns = new HttpConnection[keys.Count];
keys.CopyTo(conns, 0);
_unregistered.Clear();
}
for (var i = conns.Length - 1; i >= 0; i--)
{
conns[i].Close(true);
}
}
public void RemovePrefix(HttpListenerPrefix prefix, HttpListener listener)
{
List<HttpListenerPrefix> current, future;
if (prefix.Host == "*")
{
do
{
current = _unhandled;
if (current == null)
{
break;
}
future = new List<HttpListenerPrefix>(current);
if (!removeSpecial(future, prefix))
{
break; // The prefix wasn't found.
}
}
while (Interlocked.CompareExchange(ref _unhandled, future, current) != current);
leaveIfNoPrefix();
return;
}
if (prefix.Host == "+")
{
do
{
current = _all;
if (current == null)
{
break;
}
future = new List<HttpListenerPrefix>(current);
if (!removeSpecial(future, prefix))
{
break; // The prefix wasn't found.
}
}
while (Interlocked.CompareExchange(ref _all, future, current) != current);
leaveIfNoPrefix();
return;
}
Dictionary<HttpListenerPrefix, HttpListener> prefs, prefs2;
do
{
prefs = _prefixes;
if (!prefs.ContainsKey(prefix))
{
break;
}
prefs2 = new Dictionary<HttpListenerPrefix, HttpListener>(prefs);
prefs2.Remove(prefix);
}
while (Interlocked.CompareExchange(ref _prefixes, prefs2, prefs) != prefs);
leaveIfNoPrefix();
}
internal static bool CertificateExists(int port, string folderPath)
{
if (folderPath == null || folderPath.Length == 0)
{
folderPath = _defaultCertFolderPath;
}
var cer = Path.Combine(folderPath, string.Format("{0}.cer", port));
var key = Path.Combine(folderPath, string.Format("{0}.key", port));
return File.Exists(cer) && File.Exists(key);
}
internal void RemoveConnection(HttpConnection connection)
{
lock (_unregisteredSync)
{
_unregistered.Remove(connection);
}
}
internal bool TrySearchHttpListener(Uri uri, out HttpListener listener)
{
listener = null;
if (uri == null)
{
return false;
}
var host = uri.Host;
var dns = Uri.CheckHostName(host) == UriHostNameType.Dns;
var port = uri.Port.ToString();
var path = HttpUtility.UrlDecode(uri.AbsolutePath);
var pathSlash = path[path.Length - 1] != '/' ? path + "/" : path;
if (host != null && host.Length > 0)
{
var bestLen = -1;
foreach (var pref in _prefixes.Keys)
{
if (dns)
{
var prefHost = pref.Host;
if (Uri.CheckHostName(prefHost) == UriHostNameType.Dns && prefHost != host)
{
continue;
}
}
if (pref.Port != port && !_prefixes[pref].AllowForwardedRequest)
{
continue;
}
var prefPath = pref.Path;
var len = prefPath.Length;
if (len < bestLen)
{
continue;
}
if (path.StartsWith(prefPath) || pathSlash.StartsWith(prefPath))
{
bestLen = len;
listener = _prefixes[pref];
}
}
if (bestLen != -1)
{
return true;
}
}
var prefs = _unhandled;
listener = searchHttpListenerFromSpecial(path, prefs);
if (listener == null && pathSlash != path)
{
listener = searchHttpListenerFromSpecial(pathSlash, prefs);
}
if (listener != null)
{
return true;
}
prefs = _all;
listener = searchHttpListenerFromSpecial(path, prefs);
if (listener == null && pathSlash != path)
{
listener = searchHttpListenerFromSpecial(pathSlash, prefs);
}
return listener != null;
}
private static void addSpecial(List<HttpListenerPrefix> prefixes, HttpListenerPrefix prefix)
{
var path = prefix.Path;
foreach (var pref in prefixes)
{
if (pref.Path == path)
{
throw new HttpListenerException(87, "The prefix is already in use.");
}
}
prefixes.Add(prefix);
}
private static RSACryptoServiceProvider createRSAFromFile(string filename)
{
byte[] pvk = null;
using (var fs = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
pvk = new byte[fs.Length];
fs.Read(pvk, 0, pvk.Length);
}
var rsa = new RSACryptoServiceProvider();
rsa.ImportCspBlob(pvk);
return rsa;
}
private static X509Certificate2 getCertificate(
int port, string folderPath, X509Certificate2 defaultCertificate
)
{
if (folderPath == null || folderPath.Length == 0)
{
folderPath = _defaultCertFolderPath;
}
try
{
var cer = Path.Combine(folderPath, string.Format("{0}.cer", port));
var key = Path.Combine(folderPath, string.Format("{0}.key", port));
if (File.Exists(cer) && File.Exists(key))
{
var cert = new X509Certificate2(cer);
cert.PrivateKey = createRSAFromFile(key);
return cert;
}
}
catch
{
}
return defaultCertificate;
}
private static void onAccept(IAsyncResult asyncResult)
{
var lsnr = (EndPointListener)asyncResult.AsyncState;
Socket sock = null;
try
{
sock = lsnr._socket.EndAccept(asyncResult);
}
catch (SocketException)
{
// Do nothing
}
catch (ObjectDisposedException)
{
return;
}
try
{
lsnr._socket.BeginAccept(onAccept, lsnr);
}
catch
{
sock?.Close();
return;
}
if (sock == null)
{
return;
}
processAccepted(sock, lsnr);
}
private static void processAccepted(Socket socket, EndPointListener listener)
{
HttpConnection conn = null;
try
{
conn = new HttpConnection(socket, listener);
lock (listener._unregisteredSync)
{
listener._unregistered[conn] = conn;
}
conn.BeginReadRequest();
}
catch
{
if (conn != null)
{
conn.Close(true);
return;
}
socket.Close();
}
}
private static bool removeSpecial(List<HttpListenerPrefix> prefixes, HttpListenerPrefix prefix)
{
var path = prefix.Path;
var cnt = prefixes.Count;
for (var i = 0; i < cnt; i++)
{
if (prefixes[i].Path == path)
{
prefixes.RemoveAt(i);
return true;
}
}
return false;
}
private static HttpListener searchHttpListenerFromSpecial(
string path, List<HttpListenerPrefix> prefixes
)
{
if (prefixes == null)
{
return null;
}
HttpListener bestMatch = null;
var bestLen = -1;
foreach (var pref in prefixes)
{
var prefPath = pref.Path;
var len = prefPath.Length;
if (len < bestLen)
{
continue;
}
if (path.StartsWith(prefPath))
{
bestLen = len;
bestMatch = pref.Listener;
}
}
return bestMatch;
}
private void leaveIfNoPrefix()
{
if (_prefixes.Count > 0)
{
return;
}
var prefs = _unhandled;
if (prefs != null && prefs.Count > 0)
{
return;
}
prefs = _all;
if (prefs != null && prefs.Count > 0)
{
return;
}
EndPointManager.RemoveEndPoint(_endpoint);
}
}
}

232
EonaCat.Network/System/Sockets/Web/Core/Endpoints/EndPointManager.cs
View File

@ -1,232 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
namespace EonaCat.Network
{
/// <summary>
/// Manages HTTP endpoint listeners and their prefixes.
/// </summary>
internal sealed class EndPointManager
{
private static readonly Dictionary<IPEndPoint, EndPointListener> _endpoints;
/// <summary>
/// Initializes static members of the <see cref="EndPointManager"/> class.
/// </summary>
static EndPointManager()
{
_endpoints = new Dictionary<IPEndPoint, EndPointListener>();
}
/// <summary>
/// Prevents a default instance of the <see cref="EndPointManager"/> class from being created.
/// </summary>
private EndPointManager()
{
}
/// <summary>
/// Adds an HTTP listener and its associated prefixes.
/// </summary>
/// <param name="listener">The HTTP listener to be added.</param>
public static void AddListener(HttpListener listener)
{
var added = new List<string>();
lock (((ICollection)_endpoints).SyncRoot)
{
try
{
foreach (var pref in listener.Prefixes)
{
addPrefix(pref, listener);
added.Add(pref);
}
}
catch
{
foreach (var pref in added)
{
removePrefix(pref, listener);
}
throw;
}
}
}
/// <summary>
/// Adds an HTTP listener prefix.
/// </summary>
/// <param name="uriPrefix">The URI prefix to be added.</param>
/// <param name="listener">The HTTP listener associated with the prefix.</param>
public static void AddPrefix(string uriPrefix, HttpListener listener)
{
lock (((ICollection)_endpoints).SyncRoot)
{
addPrefix(uriPrefix, listener);
}
}
/// <summary>
/// Removes an HTTP listener and its associated prefixes.
/// </summary>
/// <param name="listener">The HTTP listener to be removed.</param>
public static void RemoveListener(HttpListener listener)
{
lock (((ICollection)_endpoints).SyncRoot)
{
foreach (var pref in listener.Prefixes)
{
removePrefix(pref, listener);
}
}
}
/// <summary>
/// Removes an HTTP listener prefix.
/// </summary>
/// <param name="uriPrefix">The URI prefix to be removed.</param>
/// <param name="listener">The HTTP listener associated with the prefix.</param>
public static void RemovePrefix(string uriPrefix, HttpListener listener)
{
lock (((ICollection)_endpoints).SyncRoot)
{
removePrefix(uriPrefix, listener);
}
}
/// <summary>
/// Removes an endpoint and closes its associated listener.
/// </summary>
/// <param name="endpoint">The endpoint to be removed.</param>
/// <returns><c>true</c> if the endpoint is successfully removed; otherwise, <c>false</c>.</returns>
internal static bool RemoveEndPoint(IPEndPoint endpoint)
{
lock (((ICollection)_endpoints).SyncRoot)
{
if (!_endpoints.TryGetValue(endpoint, out EndPointListener lsnr))
{
return false;
}
_endpoints.Remove(endpoint);
lsnr.Close();
return true;
}
}
private static void addPrefix(string uriPrefix, HttpListener listener)
{
var pref = new HttpListenerPrefix(uriPrefix);
var addr = convertToIPAddress(pref.Host);
if (!addr.IsLocal())
{
throw new HttpListenerException(87, "Includes an invalid host.");
}
if (!int.TryParse(pref.Port, out int port))
{
throw new HttpListenerException(87, "Includes an invalid port.");
}
if (!port.IsPortNumber())
{
throw new HttpListenerException(87, "Includes an invalid port.");
}
var path = pref.Path;
if (path.IndexOf('%') != -1)
{
throw new HttpListenerException(87, "Includes an invalid path.");
}
if (path.IndexOf("//", StringComparison.Ordinal) != -1)
{
throw new HttpListenerException(87, "Includes an invalid path.");
}
var endpoint = new IPEndPoint(addr, port);
if (_endpoints.TryGetValue(endpoint, out EndPointListener lsnr))
{
if (lsnr.IsSecure ^ pref.IsSecure)
{
throw new HttpListenerException(87, "Includes an invalid scheme.");
}
}
else
{
lsnr =
new EndPointListener(
endpoint,
pref.IsSecure,
listener.CertificateFolderPath,
listener.SSL,
listener.ReuseAddress
);
_endpoints.Add(endpoint, lsnr);
}
lsnr.AddPrefix(pref, listener);
}
private static IPAddress convertToIPAddress(string hostname)
{
return hostname == "*" || hostname == "+" ? IPAddress.Any : hostname.ToIPAddress();
}
private static void removePrefix(string uriPrefix, HttpListener listener)
{
var pref = new HttpListenerPrefix(uriPrefix);
var addr = convertToIPAddress(pref.Host);
if (!addr.IsLocal())
{
return;
}
if (!int.TryParse(pref.Port, out int port))
{
return;
}
if (!port.IsPortNumber())
{
return;
}
var path = pref.Path;
if (path.IndexOf('%') != -1)
{
return;
}
if (path.IndexOf("//", StringComparison.Ordinal) != -1)
{
return;
}
var endpoint = new IPEndPoint(addr, port);
if (!_endpoints.TryGetValue(endpoint, out EndPointListener lsnr))
{
return;
}
if (lsnr.IsSecure ^ pref.IsSecure)
{
return;
}
lsnr.RemovePrefix(pref, listener);
}
}
}

31
EonaCat.Network/System/Sockets/Web/Core/Http/HttpBasicIdentity.cs
View File

@ -1,31 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents a basic HTTP identity with a username and password.
/// </summary>
public class HttpBasicIdentity : GenericIdentity
{
private readonly string _password;
/// <summary>
/// Initializes a new instance of the <see cref="HttpBasicIdentity"/> class.
/// </summary>
/// <param name="username">The username associated with the identity.</param>
/// <param name="password">The password associated with the identity.</param>
internal HttpBasicIdentity(string username, string password)
: base(username, "Basic")
{
_password = password;
}
/// <summary>
/// Gets the password associated with the identity.
/// </summary>
public virtual string Password => _password;
}
}

633
EonaCat.Network/System/Sockets/Web/Core/Http/HttpConnection.cs
View File

@ -1,633 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;
using System.Threading;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP connection.
/// </summary>
internal sealed class HttpConnection
{
private const int _bufferLength = 8192;
private const int TIMEOUT_CONTINUE = 15000;
private const int TIMEOUT_INITIAL = 90000;
private readonly EndPointListener _listener;
private readonly object _lock;
private readonly Dictionary<int, bool> _timeoutCanceled;
private byte[] _buffer;
private HttpListenerContext _context;
private bool _contextRegistered;
private StringBuilder _currentLine;
private InputState _inputState;
private RequestStream _inputStream;
private HttpListener _lastListener;
private LineState _lineState;
private ResponseStream _outputStream;
private int _position;
private MemoryStream _requestBuffer;
private Socket _socket;
private int _timeout;
private Timer _timer;
/// <summary>
/// Initializes a new instance of the <see cref="HttpConnection"/> class.
/// </summary>
/// <param name="socket">The socket associated with the connection.</param>
/// <param name="listener">The endpoint listener.</param>
internal HttpConnection(Socket socket, EndPointListener listener)
{
_socket = socket;
_listener = listener;
IsSecure = listener.IsSecure;
var networkStream = new NetworkStream(socket, false);
if (IsSecure)
{
var conf = listener.SSL;
var sslStream = new SslStream(networkStream, false, conf.ClientCertificateValidationCallback);
sslStream.AuthenticateAsServer(
conf.Certificate,
conf.IsClientCertificateRequired,
conf.SslProtocols,
conf.CheckForCertificateRevocation
);
Stream = sslStream;
}
else
{
Stream = networkStream;
}
_lock = new object();
_timeout = TIMEOUT_INITIAL;
_timeoutCanceled = new Dictionary<int, bool>();
_timer = new Timer(OnTimeout, this, Timeout.Infinite, Timeout.Infinite);
Setup();
}
/// <summary>
/// Gets a value indicating whether the connection is closed.
/// </summary>
public bool IsClosed => _socket == null;
/// <summary>
/// Gets a value indicating whether the connection is secure.
/// </summary>
public bool IsSecure { get; }
/// <summary>
/// Gets the local endpoint.
/// </summary>
public IPEndPoint LocalEndPoint => (IPEndPoint)_socket.LocalEndPoint;
/// <summary>
/// Gets the remote endpoint.
/// </summary>
public IPEndPoint RemoteEndPoint => (IPEndPoint)_socket.RemoteEndPoint;
/// <summary>
/// Gets or sets the number of reuses.
/// </summary>
public int Reuses { get; private set; }
/// <summary>
/// Gets the network stream associated with the connection.
/// </summary>
public Stream Stream { get; private set; }
/// <summary>
/// Initiates reading the request.
/// </summary>
public void BeginReadRequest()
{
_buffer ??= new byte[_bufferLength];
if (Reuses == 1)
{
_timeout = TIMEOUT_CONTINUE;
}
try
{
_timeoutCanceled.Add(Reuses, false);
_timer.Change(_timeout, Timeout.Infinite);
Stream.BeginRead(_buffer, 0, _bufferLength, OnRead, this);
}
catch
{
close();
}
}
/// <summary>
/// Closes the connection.
/// </summary>
public void Close()
{
Close(false);
}
/// <summary>
/// Gets the request stream.
/// </summary>
/// <param name="contentLength">The length of the content.</param>
/// <param name="chunked">True if chunked, false otherwise.</param>
/// <returns>The request stream.</returns>
public RequestStream GetRequestStream(long contentLength, bool chunked)
{
if (_inputStream != null || _socket == null)
{
return _inputStream;
}
lock (_lock)
{
if (_socket == null)
{
return _inputStream;
}
var buff = _requestBuffer.GetBuffer();
var len = (int)_requestBuffer.Length;
DisposeRequestBuffer();
if (chunked)
{
_context.Response.SendInChunks = true;
_inputStream =
new ChunkedRequestStream(Stream, buff, _position, len - _position, _context);
}
else
{
_inputStream =
new RequestStream(Stream, buff, _position, len - _position, contentLength);
}
return _inputStream;
}
}
/// <summary>
/// Gets the response stream.
/// </summary>
/// <returns>The response stream.</returns>
public ResponseStream GetResponseStream()
{
if (_outputStream != null || _socket == null)
{
return _outputStream;
}
lock (_lock)
{
if (_socket == null)
{
return _outputStream;
}
var lsnr = _context.Listener;
var ignore = lsnr == null || lsnr.IgnoreWriteExceptions;
_outputStream = new ResponseStream(Stream, _context.Response, ignore);
return _outputStream;
}
}
/// <summary>
/// Sends an error response.
/// </summary>
public void SendError()
{
SendError(_context.ErrorMessage, _context.ErrorStatus);
}
/// <summary>
/// Sends an error response with the specified message and status code.
/// </summary>
/// <param name="message">The error message.</param>
/// <param name="status">The HTTP status code.</param>
public void SendError(string message, int status)
{
if (_socket == null)
{
return;
}
lock (_lock)
{
if (_socket == null)
{
return;
}
try
{
var httpResponse = _context.Response;
httpResponse.StatusCode = status;
httpResponse.ContentType = "text/html";
var content = new StringBuilder(64);
content.AppendFormat("<html><head><title>EonaCat.Network Error</title></head><body><h1>{0} {1}", status, httpResponse.StatusDescription);
if (message != null && message.Length > 0)
{
content.AppendFormat(" ({0})</h1></body></html>", message);
}
else
{
content.Append("</h1></body></html>");
}
var encoding = Encoding.UTF8;
var entity = encoding.GetBytes(content.ToString());
httpResponse.ContentEncoding = encoding;
httpResponse.ContentLength64 = entity.LongLength;
httpResponse.Close(entity, true);
}
catch
{
Close(true);
}
}
}
/// <summary>
/// Closes the connection.
/// </summary>
/// <param name="force">True to force close, false otherwise.</param>
internal void Close(bool force)
{
if (_socket == null)
{
return;
}
lock (_lock)
{
if (_socket == null)
{
return;
}
if (!force)
{
GetResponseStream().Close(false);
if (!_context.Response.CloseConnection && _context.Request.FlushInput())
{
// Don't close. Keep working.
Reuses++;
DisposeRequestBuffer();
UnregisterContext();
Setup();
BeginReadRequest();
return;
}
}
else
{
_outputStream?.Close(true);
}
close();
}
}
private static void OnRead(IAsyncResult asyncResult)
{
var httpConnection = (HttpConnection)asyncResult.AsyncState;
if (httpConnection._socket == null)
{
return;
}
lock (httpConnection._lock)
{
if (httpConnection._socket == null)
{
return;
}
var nread = -1;
var len = 0;
try
{
var current = httpConnection.Reuses;
if (!httpConnection._timeoutCanceled[current])
{
httpConnection._timer.Change(Timeout.Infinite, Timeout.Infinite);
httpConnection._timeoutCanceled[current] = true;
}
nread = httpConnection.Stream.EndRead(asyncResult);
httpConnection._requestBuffer.Write(httpConnection._buffer, 0, nread);
len = (int)httpConnection._requestBuffer.Length;
}
catch (Exception exception)
{
if (httpConnection._requestBuffer != null && httpConnection._requestBuffer.Length > 0)
{
httpConnection.SendError(exception.Message, 400);
return;
}
httpConnection.close();
return;
}
if (nread <= 0)
{
httpConnection.close();
return;
}
if (httpConnection.ProcessInput(httpConnection._requestBuffer.GetBuffer(), len))
{
if (!httpConnection._context.HasError)
{
httpConnection._context.Request.FinishInitialization();
}
if (httpConnection._context.HasError)
{
httpConnection.SendError();
return;
}
if (!httpConnection._listener.TrySearchHttpListener(httpConnection._context.Request.Url, out HttpListener httpListener))
{
httpConnection.SendError(null, 404);
return;
}
if (httpConnection._lastListener != httpListener)
{
httpConnection.RemoveConnection();
if (!httpListener.AddConnection(httpConnection))
{
httpConnection.close();
return;
}
httpConnection._lastListener = httpListener;
}
httpConnection._context.Listener = httpListener;
if (!httpConnection._context.Authenticate())
{
return;
}
if (httpConnection._context.Register())
{
httpConnection._contextRegistered = true;
}
return;
}
httpConnection.Stream.BeginRead(httpConnection._buffer, 0, _bufferLength, OnRead, httpConnection);
}
}
private static void OnTimeout(object state)
{
var httpConnection = (HttpConnection)state;
var current = httpConnection.Reuses;
if (httpConnection._socket == null)
{
return;
}
lock (httpConnection._lock)
{
if (httpConnection._socket == null)
{
return;
}
if (httpConnection._timeoutCanceled[current])
{
return;
}
httpConnection.SendError(null, 408);
}
}
private void close()
{
lock (_lock)
{
if (_socket == null)
{
return;
}
DisposeTimer();
DisposeRequestBuffer();
DisposeStream();
CloseSocket();
}
UnregisterContext();
RemoveConnection();
}
private void CloseSocket()
{
try
{
_socket.Shutdown(SocketShutdown.Both);
}
catch
{
}
_socket.Close();
_socket = null;
}
private void DisposeRequestBuffer()
{
if (_requestBuffer == null)
{
return;
}
_requestBuffer.Dispose();
_requestBuffer = null;
}
private void DisposeStream()
{
if (Stream == null)
{
return;
}
_inputStream = null;
_outputStream = null;
Stream.Dispose();
Stream = null;
}
private void DisposeTimer()
{
if (_timer == null)
{
return;
}
try
{
_timer.Change(Timeout.Infinite, Timeout.Infinite);
}
catch
{
}
_timer.Dispose();
_timer = null;
}
private bool ProcessInput(byte[] data, int length)
{
_currentLine ??= new StringBuilder(64);
var nread = 0;
try
{
string line;
while ((line = ReadLineFrom(data, _position, length, out nread)) != null)
{
_position += nread;
if (line.Length == 0)
{
if (_inputState == InputState.RequestLine)
{
continue;
}
if (_position > 32768)
{
_context.ErrorMessage = "Headers too long";
}
_currentLine = null;
return true;
}
if (_inputState == InputState.RequestLine)
{
_context.Request.SetRequestLine(line);
_inputState = InputState.Headers;
}
else
{
_context.Request.AddHeader(line);
}
if (_context.HasError)
{
return true;
}
}
}
catch (Exception exception)
{
_context.ErrorMessage = exception.Message;
return true;
}
_position += nread;
if (_position >= 32768)
{
_context.ErrorMessage = "Headers too long";
return true;
}
return false;
}
private string ReadLineFrom(byte[] buffer, int offset, int length, out int read)
{
read = 0;
for (var i = offset; i < length && _lineState != LineState.LineFeed; i++)
{
read++;
var b = buffer[i];
if (b == 13)
{
_lineState = LineState.CarriageReturn;
}
else if (b == 10)
{
_lineState = LineState.LineFeed;
}
else
{
_currentLine.Append((char)b);
}
}
if (_lineState != LineState.LineFeed)
{
return null;
}
var line = _currentLine.ToString();
_currentLine.Length = 0;
_lineState = LineState.None;
return line;
}
private void RemoveConnection()
{
if (_lastListener != null)
{
_lastListener.RemoveConnection(this);
}
else
{
_listener.RemoveConnection(this);
}
}
private void Setup()
{
_context = new HttpListenerContext(this);
_inputState = InputState.RequestLine;
_inputStream = null;
_lineState = LineState.None;
_outputStream = null;
_position = 0;
_requestBuffer = new MemoryStream();
}
private void UnregisterContext()
{
if (!_contextRegistered)
{
return;
}
_context.Unregister();
_contextRegistered = false;
}
}
}

95
EonaCat.Network/System/Sockets/Web/Core/Http/HttpDigestIdentity.cs
View File

@ -1,95 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System.Collections.Specialized;
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP Digest identity.
/// </summary>
public class HttpDigestIdentity : GenericIdentity
{
private readonly NameValueCollection _parameters;
/// <summary>
/// Initializes a new instance of the <see cref="HttpDigestIdentity"/> class.
/// </summary>
/// <param name="parameters">The collection of parameters.</param>
internal HttpDigestIdentity(NameValueCollection parameters)
: base(parameters["username"], "Digest")
{
_parameters = parameters;
}
/// <summary>
/// Gets the algorithm used for digest authentication.
/// </summary>
public string Algorithm => _parameters["algorithm"];
/// <summary>
/// Gets the client nonce.
/// </summary>
public string Cnonce => _parameters["cnonce"];
/// <summary>
/// Gets the nonce count.
/// </summary>
public string Nc => _parameters["nc"];
/// <summary>
/// Gets the nonce value.
/// </summary>
public string Nonce => _parameters["nonce"];
/// <summary>
/// Gets the opaque value.
/// </summary>
public string Opaque => _parameters["opaque"];
/// <summary>
/// Gets the quality of protection.
/// </summary>
public string Qop => _parameters["qop"];
/// <summary>
/// Gets the realm.
/// </summary>
public string Realm => _parameters["realm"];
/// <summary>
/// Gets the response value.
/// </summary>
public string Response => _parameters["response"];
/// <summary>
/// Gets the URI.
/// </summary>
public string Uri => _parameters["uri"];
/// <summary>
/// Validates the HTTP Digest identity.
/// </summary>
/// <param name="password">The password.</param>
/// <param name="realm">The realm.</param>
/// <param name="method">The HTTP method.</param>
/// <param name="entity">The entity.</param>
/// <returns>True if the identity is valid, false otherwise.</returns>
internal bool IsValid(
string password, string realm, string method, string entity
)
{
var copied = new NameValueCollection(_parameters)
{
["password"] = password,
["realm"] = realm,
["method"] = method,
["entity"] = entity
};
var expected = AuthenticationResponse.CreateRequestDigest(copied);
return _parameters["response"] == expected;
}
}
}

74
EonaCat.Network/System/Sockets/Web/Core/Http/HttpHeaderInfo.cs
View File

@ -1,74 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
/// <summary>
/// Represents information about an HTTP header.
/// </summary>
internal class HttpHeaderInfo
{
/// <summary>
/// Initializes a new instance of the <see cref="HttpHeaderInfo"/> class.
/// </summary>
/// <param name="name">The name of the header.</param>
/// <param name="type">The type of the header.</param>
internal HttpHeaderInfo(string name, HttpHeaderType type)
{
Name = name;
Type = type;
}
/// <summary>
/// Gets a value indicating whether the header is for a request.
/// </summary>
public bool IsRequest => (Type & HttpHeaderType.Request) == HttpHeaderType.Request;
/// <summary>
/// Gets a value indicating whether the header is for a response.
/// </summary>
public bool IsResponse => (Type & HttpHeaderType.Response) == HttpHeaderType.Response;
/// <summary>
/// Gets the name of the header.
/// </summary>
public string Name { get; }
/// <summary>
/// Gets the type of the header.
/// </summary>
public HttpHeaderType Type { get; }
/// <summary>
/// Gets a value indicating whether the header is multi-value in a request.
/// </summary>
internal bool IsMultiValueInRequest => (Type & HttpHeaderType.MultiValueInRequest) == HttpHeaderType.MultiValueInRequest;
/// <summary>
/// Gets a value indicating whether the header is multi-value in a response.
/// </summary>
internal bool IsMultiValueInResponse => (Type & HttpHeaderType.MultiValueInResponse) == HttpHeaderType.MultiValueInResponse;
/// <summary>
/// Gets a value indicating whether the header is multi-value.
/// </summary>
/// <param name="response">True if checking for a response; false for a request.</param>
/// <returns>True if the header is multi-value, false otherwise.</returns>
public bool IsMultiValue(bool response)
{
return (Type & HttpHeaderType.MultiValue) == HttpHeaderType.MultiValue
? (response ? IsResponse : IsRequest)
: (response ? IsMultiValueInResponse : IsMultiValueInRequest);
}
/// <summary>
/// Gets a value indicating whether the header is restricted.
/// </summary>
/// <param name="response">True if checking for a response; false for a request.</param>
/// <returns>True if the header is restricted, false otherwise.</returns>
public bool IsRestricted(bool response)
{
return (Type & HttpHeaderType.Restricted) == HttpHeaderType.Restricted && (response ? IsResponse : IsRequest);
}
}
}

49
EonaCat.Network/System/Sockets/Web/Core/Http/HttpHeaderType.cs
View File

@ -1,49 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
/// <summary>
/// Represents the type of an HTTP header.
/// </summary>
[Flags]
internal enum HttpHeaderType
{
/// <summary>
/// No specific header type specified.
/// </summary>
Unspecified = 0,
/// <summary>
/// Header used in an HTTP request.
/// </summary>
Request = 1,
/// <summary>
/// Header used in an HTTP response.
/// </summary>
Response = 1 << 1,
/// <summary>
/// Header with restricted use.
/// </summary>
Restricted = 1 << 2,
/// <summary>
/// Header that can have multiple values.
/// </summary>
MultiValue = 1 << 3,
/// <summary>
/// Multi-value header used in an HTTP request.
/// </summary>
MultiValueInRequest = 1 << 4,
/// <summary>
/// Multi-value header used in an HTTP response.
/// </summary>
MultiValueInResponse = 1 << 5
}
}

643
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListener.cs
View File

@ -1,643 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP listener that listens for incoming requests.
/// </summary>
public sealed class HttpListener : IDisposable
{
private static readonly string _defaultRealm;
private readonly Dictionary<HttpConnection, HttpConnection> _connections;
private readonly object _connectionsSync;
private readonly object _contextQueueLock;
private readonly Dictionary<HttpListenerContext, HttpListenerContext> _contextRegistry;
private readonly object _contextRegistryLock;
private readonly HttpListenerPrefixCollection _prefixes;
private readonly List<HttpListenerAsyncResult> _waitQueue;
private readonly object _waitQueueLock;
private readonly List<HttpListenerContext> contextQueue;
private bool _allowForwardedRequest;
private AuthenticationSchemes _authSchemes;
private Func<HttpListenerRequest, AuthenticationSchemes> _authSchemeSelector;
private string _certFolderPath;
private bool _ignoreWriteExceptions;
private volatile bool _listening;
private string _realm;
private SSLConfigServer _sslConfig;
private Func<IIdentity, NetworkCredential> _userCredFinder;
static HttpListener()
{
_defaultRealm = "SECRET AREA";
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpListener"/> class.
/// </summary>
public HttpListener()
{
_authSchemes = AuthenticationSchemes.Anonymous;
_connections = new Dictionary<HttpConnection, HttpConnection>();
_connectionsSync = ((ICollection)_connections).SyncRoot;
contextQueue = new List<HttpListenerContext>();
_contextQueueLock = ((ICollection)contextQueue).SyncRoot;
_contextRegistry = new Dictionary<HttpListenerContext, HttpListenerContext>();
_contextRegistryLock = ((ICollection)_contextRegistry).SyncRoot;
_prefixes = new HttpListenerPrefixCollection(this);
_waitQueue = new List<HttpListenerAsyncResult>();
_waitQueueLock = ((ICollection)_waitQueue).SyncRoot;
}
public static bool IsSupported => true;
/// <summary>
/// Gets or sets a value indicating whether the server accepts every
/// handshake request without checking the request URI.
/// </summary>
/// <remarks>
/// The set operation does nothing if the server has already started or
/// it is shutting down.
/// </remarks>
/// <value>
/// <para>
/// <c>true</c> if the server accepts every handshake request without
/// checking the request URI; otherwise, <c>false</c>.
/// </para>
/// <para>
/// The default value is <c>false</c>.
/// </para>
/// </value>
public bool AllowForwardedRequest
{
get { return _allowForwardedRequest; }
set { _allowForwardedRequest = value; }
}
/// <summary>
/// Gets or sets the authentication schemes used by this listener.
/// </summary>
public AuthenticationSchemes AuthenticationSchemes
{
get
{
CheckDisposed();
return _authSchemes;
}
set
{
CheckDisposed();
_authSchemes = value;
}
}
public Func<HttpListenerRequest, AuthenticationSchemes> AuthenticationSchemeSelector
{
get
{
CheckDisposed();
return _authSchemeSelector;
}
set
{
CheckDisposed();
_authSchemeSelector = value;
}
}
public string CertificateFolderPath
{
get
{
CheckDisposed();
return _certFolderPath;
}
set
{
CheckDisposed();
_certFolderPath = value;
}
}
public bool IgnoreWriteExceptions
{
get
{
CheckDisposed();
return _ignoreWriteExceptions;
}
set
{
CheckDisposed();
_ignoreWriteExceptions = value;
}
}
public bool IsListening => _listening;
public HttpListenerPrefixCollection Prefixes
{
get
{
CheckDisposed();
return _prefixes;
}
}
public string Realm
{
get
{
CheckDisposed();
return _realm;
}
set
{
CheckDisposed();
_realm = value;
}
}
public SSLConfigServer SSL
{
get
{
CheckDisposed();
return _sslConfig ??= new SSLConfigServer();
}
set
{
CheckDisposed();
_sslConfig = value;
}
}
public bool UnsafeConnectionNtlmAuthentication
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public Func<IIdentity, NetworkCredential> UserCredentialsFinder
{
get
{
CheckDisposed();
return _userCredFinder;
}
set
{
CheckDisposed();
_userCredFinder = value;
}
}
internal bool IsDisposed { get; private set; }
internal bool ReuseAddress { get; set; }
/// <summary>
/// Aborts the listener and releases all resources associated with it.
/// </summary>
public void Abort()
{
if (IsDisposed)
{
return;
}
close(true);
}
/// <summary>
/// Begins asynchronously getting an HTTP context from the listener.
/// </summary>
/// <param name="callback">The method to call when the operation completes.</param>
/// <param name="state">A user-defined object that contains information about the asynchronous operation.</param>
/// <returns>An <see cref="IAsyncResult"/> that represents the asynchronous operation.</returns>
public IAsyncResult BeginGetContext(AsyncCallback callback, object state)
{
CheckDisposed();
if (_prefixes.Count == 0)
{
throw new InvalidOperationException("The listener has no URI prefix on which listens.");
}
if (!_listening)
{
throw new InvalidOperationException("The listener hasn't been started.");
}
return BeginGetContext(new HttpListenerAsyncResult(callback, state));
}
/// <summary>
/// Closes the listener.
/// </summary>
public void Close()
{
if (IsDisposed)
{
return;
}
close(false);
}
/// <summary>
/// Disposes of the resources used by the <see cref="HttpListener"/>.
/// </summary>
void IDisposable.Dispose()
{
if (IsDisposed)
{
return;
}
close(true);
}
/// <summary>
/// Ends an asynchronous operation to get an HTTP context from the listener.
/// </summary>
/// <param name="asyncResult">The reference to the pending asynchronous request to finish.</param>
/// <returns>An <see cref="HttpListenerContext"/> that represents the context of the asynchronous operation.</returns>
public HttpListenerContext EndGetContext(IAsyncResult asyncResult)
{
CheckDisposed();
if (asyncResult == null)
{
throw new ArgumentNullException(nameof(asyncResult));
}
if (asyncResult is not HttpListenerAsyncResult result)
{
throw new ArgumentException("A wrong IAsyncResult.", nameof(asyncResult));
}
if (result.EndCalled)
{
throw new InvalidOperationException("This IAsyncResult cannot be reused.");
}
result.EndCalled = true;
if (!result.IsCompleted)
{
result.AsyncWaitHandle.WaitOne();
}
return result.GetContext();
}
/// <summary>
/// Gets the next available HTTP context from the listener.
/// </summary>
/// <returns>An <see cref="HttpListenerContext"/> that represents the context of the HTTP request.</returns>
public HttpListenerContext GetContext()
{
CheckDisposed();
if (_prefixes.Count == 0)
{
throw new InvalidOperationException("The listener has no URI prefix on which listens.");
}
if (!_listening)
{
throw new InvalidOperationException("The listener hasn't been started.");
}
var result = BeginGetContext(new HttpListenerAsyncResult(null, null));
result.InGet = true;
return EndGetContext(result);
}
/// <summary>
/// Starts listening for incoming requests.
/// </summary>
public void Start()
{
CheckDisposed();
if (_listening)
{
return;
}
EndPointManager.AddListener(this);
_listening = true;
}
/// <summary>
/// Stops listening for incoming requests.
/// </summary>
public void Stop()
{
CheckDisposed();
if (!_listening)
{
return;
}
_listening = false;
EndPointManager.RemoveListener(this);
lock (_contextRegistryLock)
{
CleanupContextQueue(true);
}
CleanupContextRegistry();
CleanupConnections();
CleanupWaitQueue(new HttpListenerException(995, "The listener is closed."));
}
internal bool AddConnection(HttpConnection connection)
{
if (!_listening)
{
return false;
}
lock (_connectionsSync)
{
if (!_listening)
{
return false;
}
_connections[connection] = connection;
return true;
}
}
internal HttpListenerAsyncResult BeginGetContext(HttpListenerAsyncResult asyncResult)
{
lock (_contextRegistryLock)
{
if (!_listening)
{
throw new HttpListenerException(995);
}
var context = GetContextFromQueue();
if (context == null)
{
_waitQueue.Add(asyncResult);
}
else
{
asyncResult.Complete(context, true);
}
return asyncResult;
}
}
internal void CheckDisposed()
{
if (IsDisposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
}
internal string GetRealm()
{
var realm = _realm;
return realm != null && realm.Length > 0 ? realm : _defaultRealm;
}
internal Func<IIdentity, NetworkCredential> GetUserCredentialsFinder()
{
return _userCredFinder;
}
internal bool RegisterContext(HttpListenerContext context)
{
if (!_listening)
{
return false;
}
lock (_contextRegistryLock)
{
if (!_listening)
{
return false;
}
_contextRegistry[context] = context;
var result = GetAsyncResultFromQueue();
if (result == null)
{
contextQueue.Add(context);
}
else
{
result.Complete(context);
}
return true;
}
}
internal void RemoveConnection(HttpConnection connection)
{
lock (_connectionsSync)
{
_connections.Remove(connection);
}
}
internal AuthenticationSchemes SelectAuthenticationScheme(HttpListenerRequest request)
{
var selector = _authSchemeSelector;
if (selector == null)
{
return _authSchemes;
}
try
{
return selector(request);
}
catch
{
return AuthenticationSchemes.None;
}
}
internal void UnregisterContext(HttpListenerContext context)
{
lock (_contextRegistryLock)
{
_contextRegistry.Remove(context);
}
}
private void CleanupConnections()
{
HttpConnection[] httpConnections = null;
lock (_connectionsSync)
{
if (_connections.Count == 0)
{
return;
}
// Need to copy this since closing will call the RemoveConnection method.
var keys = _connections.Keys;
httpConnections = new HttpConnection[keys.Count];
keys.CopyTo(httpConnections, 0);
_connections.Clear();
}
for (var i = httpConnections.Length - 1; i >= 0; i--)
{
httpConnections[i].Close(true);
}
}
private void CleanupContextQueue(bool sendServiceUnavailable)
{
HttpListenerContext[] httpContextQueues = null;
lock (_contextQueueLock)
{
if (contextQueue.Count == 0)
{
return;
}
httpContextQueues = contextQueue.ToArray();
contextQueue.Clear();
}
if (!sendServiceUnavailable)
{
return;
}
foreach (var currentContext in httpContextQueues)
{
var response = currentContext.Response;
response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
response.Close();
}
}
private void CleanupContextRegistry()
{
HttpListenerContext[] contexts = null;
lock (_contextRegistryLock)
{
if (_contextRegistry.Count == 0)
{
return;
}
// Need to copy this since closing will call the UnregisterContext method.
var keys = _contextRegistry.Keys;
contexts = new HttpListenerContext[keys.Count];
keys.CopyTo(contexts, 0);
_contextRegistry.Clear();
}
for (var i = contexts.Length - 1; i >= 0; i--)
{
contexts[i].Connection.Close(true);
}
}
private void CleanupWaitQueue(Exception exception)
{
HttpListenerAsyncResult[] results = null;
lock (_waitQueueLock)
{
if (_waitQueue.Count == 0)
{
return;
}
results = _waitQueue.ToArray();
_waitQueue.Clear();
}
foreach (var currentResult in results)
{
currentResult.Complete(exception);
}
}
private void close(bool force)
{
if (_listening)
{
_listening = false;
EndPointManager.RemoveListener(this);
}
lock (_contextRegistryLock)
{
CleanupContextQueue(!force);
}
CleanupContextRegistry();
CleanupConnections();
CleanupWaitQueue(new ObjectDisposedException(GetType().ToString()));
IsDisposed = true;
}
private HttpListenerAsyncResult GetAsyncResultFromQueue()
{
if (_waitQueue.Count == 0)
{
return null;
}
var ares = _waitQueue[0];
_waitQueue.RemoveAt(0);
return ares;
}
private HttpListenerContext GetContextFromQueue()
{
if (contextQueue.Count == 0)
{
return null;
}
var context = contextQueue[0];
contextQueue.RemoveAt(0);
return context;
}
}
}

162
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerAsyncResult.cs
View File

@ -1,162 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Threading;
namespace EonaCat.Network
{
/// <summary>
/// Represents the result of an asynchronous operation for an <see cref="HttpListener"/>.
/// </summary>
internal class HttpListenerAsyncResult : IAsyncResult
{
private readonly AsyncCallback _callback;
private readonly object _locker;
private bool _completed;
private HttpListenerContext _context;
private Exception _exception;
private ManualResetEvent _waitHandle;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerAsyncResult"/> class.
/// </summary>
/// <param name="callback">The method to call when the operation completes.</param>
/// <param name="state">A user-defined object that contains information about the asynchronous operation.</param>
internal HttpListenerAsyncResult(AsyncCallback callback, object state)
{
_callback = callback;
AsyncState = state;
_locker = new object();
}
/// <summary>
/// Gets the user-defined object that contains information about the asynchronous operation.
/// </summary>
public object AsyncState { get; }
/// <summary>
/// Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.
/// </summary>
public WaitHandle AsyncWaitHandle
{
get
{
lock (_locker)
{
return _waitHandle ??= new ManualResetEvent(_completed);
}
}
}
/// <summary>
/// Gets a value indicating whether the asynchronous operation completed synchronously.
/// </summary>
public bool CompletedSynchronously { get; private set; }
/// <summary>
/// Gets a value indicating whether the asynchronous operation has completed.
/// </summary>
public bool IsCompleted
{
get
{
lock (_locker)
{
return _completed;
}
}
}
/// <summary>
/// Gets or sets a value indicating whether the <see cref="EndGetContext"/> method has been called.
/// </summary>
internal bool EndCalled { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the asynchronous operation is in progress.
/// </summary>
internal bool InGet { get; set; }
/// <summary>
/// Completes the asynchronous operation with the specified exception.
/// </summary>
/// <param name="exception">The exception that occurred during the asynchronous operation.</param>
internal void Complete(Exception exception)
{
_exception = InGet && (exception is ObjectDisposedException)
? new HttpListenerException(995, "The listener is closed.")
: exception;
complete(this);
}
/// <summary>
/// Completes the asynchronous operation with the specified <see cref="HttpListenerContext"/>.
/// </summary>
/// <param name="context">The <see cref="HttpListenerContext"/> representing the result of the asynchronous operation.</param>
internal void Complete(HttpListenerContext context)
{
Complete(context, false);
}
/// <summary>
/// Completes the asynchronous operation with the specified <see cref="HttpListenerContext"/>.
/// </summary>
/// <param name="context">The <see cref="HttpListenerContext"/> representing the result of the asynchronous operation.</param>
/// <param name="syncCompleted">A value indicating whether the completion was synchronous.</param>
internal void Complete(HttpListenerContext context, bool syncCompleted)
{
_context = context;
CompletedSynchronously = syncCompleted;
complete(this);
}
/// <summary>
/// Gets the <see cref="HttpListenerContext"/> result of the asynchronous operation.
/// </summary>
/// <returns>The <see cref="HttpListenerContext"/> representing the result of the asynchronous operation.</returns>
internal HttpListenerContext GetContext()
{
if (_exception != null)
{
throw _exception;
}
return _context;
}
// Private method to complete the asynchronous operation
private static void complete(HttpListenerAsyncResult asyncResult)
{
lock (asyncResult._locker)
{
asyncResult._completed = true;
var waitHandle = asyncResult._waitHandle;
waitHandle?.Set();
}
var callback = asyncResult._callback;
if (callback == null)
{
return;
}
ThreadPool.QueueUserWorkItem(
state =>
{
try
{
callback(asyncResult);
}
catch
{
}
},
null
);
}
}
}

152
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerContext.cs
View File

@ -1,152 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Security.Principal;
namespace EonaCat.Network
{
/// <summary>
/// Represents the context for an HTTP listener.
/// </summary>
public sealed class HttpListenerContext
{
private HttpListenerWSContext _websocketContext;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerContext"/> class.
/// </summary>
/// <param name="connection">The underlying <see cref="HttpConnection"/> for the context.</param>
internal HttpListenerContext(HttpConnection connection)
{
Connection = connection;
ErrorStatus = 400;
Request = new HttpListenerRequest(this);
Response = new HttpListenerResponse(this);
}
/// <summary>
/// Gets the <see cref="HttpListenerRequest"/> associated with the context.
/// </summary>
public HttpListenerRequest Request { get; }
/// <summary>
/// Gets the <see cref="HttpListenerResponse"/> associated with the context.
/// </summary>
public HttpListenerResponse Response { get; }
/// <summary>
/// Gets or sets the <see cref="IPrincipal"/> associated with the user.
/// </summary>
public IPrincipal User { get; private set; }
/// <summary>
/// Gets the underlying <see cref="HttpConnection"/> for the context.
/// </summary>
internal HttpConnection Connection { get; }
/// <summary>
/// Gets or sets the error message associated with the context.
/// </summary>
internal string ErrorMessage { get; set; }
/// <summary>
/// Gets or sets the error status associated with the context.
/// </summary>
internal int ErrorStatus { get; set; }
/// <summary>
/// Gets a value indicating whether an error has occurred.
/// </summary>
internal bool HasError => ErrorMessage != null;
/// <summary>
/// Gets or sets the <see cref="HttpListener"/> associated with the context.
/// </summary>
internal HttpListener Listener { get; set; }
/// <summary>
/// Accepts a WebSocket connection with the specified protocol.
/// </summary>
/// <param name="protocol">The WebSocket subprotocol to negotiate.</param>
/// <returns>The <see cref="HttpListenerWSContext"/> for the WebSocket connection.</returns>
public HttpListenerWSContext AcceptWebSocket(string protocol)
{
if (_websocketContext != null)
{
throw new InvalidOperationException("Accepting already in progress.");
}
if (protocol != null)
{
if (protocol.Length == 0)
{
throw new ArgumentException("Empty string.", nameof(protocol));
}
if (!protocol.IsToken())
{
throw new ArgumentException("Contains invalid characters", nameof(protocol));
}
}
_websocketContext = new HttpListenerWSContext(this, protocol);
return _websocketContext;
}
/// <summary>
/// Authenticates the user based on the specified authentication scheme.
/// </summary>
/// <returns><c>true</c> if authentication is successful; otherwise, <c>false</c>.</returns>
internal bool Authenticate()
{
var schm = Listener.SelectAuthenticationScheme(Request);
if (schm == AuthenticationSchemes.Anonymous)
{
return true;
}
if (schm == AuthenticationSchemes.None)
{
Response.Close(HttpStatusCode.Forbidden);
return false;
}
var realm = Listener.GetRealm();
var user =
HttpUtility.CreateUser(
Request.Headers["Authorization"],
schm,
realm,
Request.HttpMethod,
Listener.GetUserCredentialsFinder()
);
if (user == null || !user.Identity.IsAuthenticated)
{
Response.CloseWithAuthChallenge(new AuthenticationChallenge(schm, realm).ToString());
return false;
}
User = user;
return true;
}
/// <summary>
/// Registers the context with the associated <see cref="HttpListener"/>.
/// </summary>
/// <returns><c>true</c> if registration is successful; otherwise, <c>false</c>.</returns>
internal bool Register()
{
return Listener.RegisterContext(this);
}
/// <summary>
/// Unregisters the context from the associated <see cref="HttpListener"/>.
/// </summary>
internal void Unregister()
{
Listener.UnregisterContext(this);
}
}
}

56
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerException.cs
View File

@ -1,56 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.ComponentModel;
using System.Runtime.Serialization;
namespace EonaCat.Network
{
/// <summary>
/// Represents an exception that occurs in the <see cref="HttpListener"/> class.
/// </summary>
[Serializable]
public class HttpListenerException : Win32Exception
{
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerException"/> class with no error message.
/// </summary>
public HttpListenerException()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerException"/> class with the specified error code.
/// </summary>
/// <param name="errorCode">The Win32 error code associated with this exception.</param>
public HttpListenerException(int errorCode)
: base(errorCode)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerException"/> class with the specified error code and message.
/// </summary>
/// <param name="errorCode">The Win32 error code associated with this exception.</param>
/// <param name="message">The error message that explains the reason for the exception.</param>
public HttpListenerException(int errorCode, string message)
: base(errorCode, $"EonaCat Network: {message}")
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerException"/> class.
/// </summary>
protected HttpListenerException(
SerializationInfo serializationInfo, StreamingContext streamingContext)
: base(serializationInfo, streamingContext)
{
}
/// <summary>
/// Gets the Win32 error code associated with this exception.
/// </summary>
public override int ErrorCode => NativeErrorCode;
}
}

167
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerPrefix.cs
View File

@ -1,167 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
/// <summary>
/// Represents a URI prefix for an <see cref="HttpListener"/>.
/// </summary>
internal sealed class HttpListenerPrefix
{
private string _prefix;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerPrefix"/> class with the specified URI prefix.
/// </summary>
/// <param name="uriPrefix">The URI prefix.</param>
internal HttpListenerPrefix(string uriPrefix)
{
Original = uriPrefix;
parse(uriPrefix);
}
/// <summary>
/// Gets the host specified in the URI prefix.
/// </summary>
public string Host { get; private set; }
/// <summary>
/// Gets a value indicating whether the URI prefix is for a secure connection (https).
/// </summary>
public bool IsSecure { get; private set; }
/// <summary>
/// Gets or sets the associated <see cref="HttpListener"/>.
/// </summary>
public HttpListener Listener { get; set; }
/// <summary>
/// Gets the original URI prefix.
/// </summary>
public string Original { get; }
/// <summary>
/// Gets the path specified in the URI prefix.
/// </summary>
public string Path { get; private set; }
/// <summary>
/// Gets the port specified in the URI prefix.
/// </summary>
public string Port { get; private set; }
/// <summary>
/// Checks if the specified URI prefix is valid.
/// </summary>
/// <param name="uriPrefix">The URI prefix to check.</param>
public static void CheckPrefix(string uriPrefix)
{
if (uriPrefix == null)
{
throw new ArgumentNullException(nameof(uriPrefix));
}
var len = uriPrefix.Length;
if (len == 0)
{
throw new ArgumentException("An empty string.", nameof(uriPrefix));
}
if (!(uriPrefix.StartsWith("http://") || uriPrefix.StartsWith("https://")))
{
throw new ArgumentException("The scheme isn't 'http' or 'https'.", nameof(uriPrefix));
}
var startHost = uriPrefix.IndexOf(':') + 3;
if (startHost >= len)
{
throw new ArgumentException("No host is specified.", nameof(uriPrefix));
}
if (uriPrefix[startHost] == ':')
{
throw new ArgumentException("No host is specified.", nameof(uriPrefix));
}
var root = uriPrefix.IndexOf('/', startHost, len - startHost);
if (root == startHost)
{
throw new ArgumentException("No host is specified.", nameof(uriPrefix));
}
if (root == -1 || uriPrefix[len - 1] != '/')
{
throw new ArgumentException("Ends without '/'.", nameof(uriPrefix));
}
if (uriPrefix[root - 1] == ':')
{
throw new ArgumentException("No port is specified.", nameof(uriPrefix));
}
if (root == len - 2)
{
throw new ArgumentException("No path is specified.", nameof(uriPrefix));
}
}
/// <summary>
/// Determines whether the specified object is equal to the current object.
/// </summary>
/// <param name="obj">The object to compare with the current object.</param>
/// <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
public override bool Equals(object obj)
{
return obj is HttpListenerPrefix pref && pref._prefix == _prefix;
}
/// <summary>
/// Serves as the default hash function.
/// </summary>
/// <returns>A hash code for the current object.</returns>
public override int GetHashCode()
{
return _prefix.GetHashCode();
}
/// <summary>
/// Returns a string that represents the current object.
/// </summary>
/// <returns>A string that represents the current object.</returns>
public override string ToString()
{
return _prefix;
}
private void parse(string uriPrefix)
{
if (uriPrefix.StartsWith("https"))
{
IsSecure = true;
}
var len = uriPrefix.Length;
var startHost = uriPrefix.IndexOf(':') + 3;
var root = uriPrefix.IndexOf('/', startHost + 1, len - startHost - 1);
var colon = uriPrefix.LastIndexOf(':', root - 1, root - startHost - 1);
if (uriPrefix[root - 1] != ']' && colon > startHost)
{
Host = uriPrefix.Substring(startHost, colon - startHost);
Port = uriPrefix.Substring(colon + 1, root - colon - 1);
}
else
{
Host = uriPrefix.Substring(startHost, root - startHost);
Port = IsSecure ? "443" : "80";
}
Path = uriPrefix.Substring(root);
_prefix =
string.Format("http{0}://{1}:{2}{3}", IsSecure ? "s" : "", Host, Port, Path);
}
}
}

154
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerPrefixCollection.cs
View File

@ -1,154 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
namespace EonaCat.Network
{
/// <summary>
/// Represents a collection of URI prefixes for an <see cref="HttpListener"/>.
/// </summary>
public class HttpListenerPrefixCollection : ICollection<string>, IEnumerable<string>, IEnumerable
{
private readonly HttpListener _listener;
private readonly List<string> _prefixes;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerPrefixCollection"/> class.
/// </summary>
/// <param name="listener">The associated <see cref="HttpListener"/>.</param>
internal HttpListenerPrefixCollection(HttpListener listener)
{
_listener = listener;
_prefixes = new List<string>();
}
/// <summary>
/// Gets the number of URI prefixes in the collection.
/// </summary>
public int Count => _prefixes.Count;
/// <summary>
/// Gets a value indicating whether the collection is read-only.
/// </summary>
public bool IsReadOnly => false;
/// <summary>
/// Gets a value indicating whether access to the collection is synchronized (thread-safe).
/// </summary>
public bool IsSynchronized => false;
/// <summary>
/// Adds a URI prefix to the collection.
/// </summary>
/// <param name="uriPrefix">The URI prefix to add.</param>
public void Add(string uriPrefix)
{
_listener.CheckDisposed();
HttpListenerPrefix.CheckPrefix(uriPrefix);
if (_prefixes.Contains(uriPrefix))
{
return;
}
_prefixes.Add(uriPrefix);
if (_listener.IsListening)
{
EndPointManager.AddPrefix(uriPrefix, _listener);
}
}
/// <summary>
/// Removes all URI prefixes from the collection.
/// </summary>
public void Clear()
{
_listener.CheckDisposed();
_prefixes.Clear();
if (_listener.IsListening)
{
EndPointManager.RemoveListener(_listener);
}
}
/// <summary>
/// Determines whether the collection contains a specific URI prefix.
/// </summary>
/// <param name="uriPrefix">The URI prefix to locate.</param>
/// <returns>true if the collection contains the specified URI prefix; otherwise, false.</returns>
public bool Contains(string uriPrefix)
{
_listener.CheckDisposed();
if (uriPrefix == null)
{
throw new ArgumentNullException(nameof(uriPrefix));
}
return _prefixes.Contains(uriPrefix);
}
/// <summary>
/// Copies the URI prefixes to an array, starting at a particular array index.
/// </summary>
/// <param name="array">The one-dimensional array that is the destination of the elements copied from the collection.</param>
/// <param name="offset">The zero-based index in the array at which copying begins.</param>
public void CopyTo(Array array, int offset)
{
_listener.CheckDisposed();
((ICollection)_prefixes).CopyTo(array, offset);
}
/// <summary>
/// Copies the URI prefixes to an array, starting at a particular array index.
/// </summary>
/// <param name="array">The one-dimensional array that is the destination of the elements copied from the collection.</param>
/// <param name="offset">The zero-based index in the array at which copying begins.</param>
public void CopyTo(string[] array, int offset)
{
_listener.CheckDisposed();
_prefixes.CopyTo(array, offset);
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>An enumerator that can be used to iterate through the collection.</returns>
public IEnumerator<string> GetEnumerator()
{
return _prefixes.GetEnumerator();
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>An enumerator that can be used to iterate through the collection.</returns>
IEnumerator IEnumerable.GetEnumerator()
{
return _prefixes.GetEnumerator();
}
/// <summary>
/// Removes the specified URI prefix from the collection.
/// </summary>
/// <param name="uriPrefix">The URI prefix to remove.</param>
/// <returns>true if the URI prefix is successfully removed; otherwise, false. This method also returns false if the URI prefix was not found in the collection.</returns>
public bool Remove(string uriPrefix)
{
_listener.CheckDisposed();
if (uriPrefix == null)
{
throw new ArgumentNullException(nameof(uriPrefix));
}
var ret = _prefixes.Remove(uriPrefix);
if (ret && _listener.IsListening)
{
EndPointManager.RemovePrefix(uriPrefix, _listener);
}
return ret;
}
}
}

415
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerRequest.cs
View File

@ -1,415 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP listener request.
/// </summary>
public sealed class HttpListenerRequest
{
private static readonly byte[] _100continue;
private readonly HttpListenerContext _context;
private readonly WebHeaderCollection _headers;
private bool _chunked;
private Encoding _contentEncoding;
private bool _contentLengthSet;
private CookieCollection _cookies;
private Stream _inputStream;
private bool _keepAlive;
private bool _keepAliveSet;
private NameValueCollection _queryString;
private string _uri;
private Version _version;
private bool _websocketRequest;
private bool _websocketRequestSet;
static HttpListenerRequest()
{
_100continue = Encoding.ASCII.GetBytes("HTTP/1.1 100 Continue\r\n\r\n");
}
internal HttpListenerRequest(HttpListenerContext context)
{
_context = context;
ContentLength64 = -1;
_headers = new WebHeaderCollection();
RequestTraceIdentifier = Guid.NewGuid();
}
/// <summary>
/// Gets the accepted types for the request.
/// </summary>
public string[] AcceptTypes { get; private set; }
/// <summary>
/// Gets the content encoding of the request.
/// </summary>
public Encoding ContentEncoding => _contentEncoding ??= Encoding.Default;
/// <summary>
/// Gets the content length of the request.
/// </summary>
public long ContentLength64 { get; private set; }
/// <summary>
/// Gets the content type of the request.
/// </summary>
public string ContentType => _headers["Content-Type"];
/// <summary>
/// Gets the collection of cookies in the request.
/// </summary>
public CookieCollection Cookies => _cookies ??= _headers.GetCookies(false);
/// <summary>
/// Gets a value indicating whether the request has an entity body.
/// </summary>
public bool HasEntityBody => ContentLength64 > 0 || _chunked;
/// <summary>
/// Gets the collection of headers in the request.
/// </summary>
public NameValueCollection Headers => _headers;
/// <summary>
/// Gets the HTTP method of the request.
/// </summary>
public string HttpMethod { get; private set; }
/// <summary>
/// Gets the input stream of the request.
/// </summary>
public Stream InputStream => _inputStream ??= HasEntityBody
? _context.Connection.GetRequestStream(ContentLength64, _chunked)
: Stream.Null;
/// <summary>
/// Gets a value indicating whether the user is authenticated.
/// </summary>
public bool IsAuthenticated => _context.User != null;
/// <summary>
/// Gets a value indicating whether the request is from a local address.
/// </summary>
public bool IsLocal => RemoteEndPoint.Address.IsLocal();
/// <summary>
/// Gets a value indicating whether the connection is secure.
/// </summary>
public bool IsSecureConnection => _context.Connection.IsSecure;
/// <summary>
/// Gets a value indicating whether the request is a WebSocket request.
/// </summary>
public bool IsWebSocketRequest
{
get
{
if (!_websocketRequestSet)
{
_websocketRequest = HttpMethod == "GET" &&
_version > HttpVersion.Version10 &&
_headers.Contains("Upgrade", "websocket") &&
_headers.Contains("Connection", "Upgrade");
_websocketRequestSet = true;
}
return _websocketRequest;
}
}
/// <summary>
/// Gets a value indicating whether the connection should be kept alive.
/// </summary>
public bool KeepAlive
{
get
{
if (!_keepAliveSet)
{
string keepAlive;
_keepAlive = _version > HttpVersion.Version10 ||
_headers.Contains("Connection", "keep-alive") ||
((keepAlive = _headers["Keep-Alive"]) != null && keepAlive != "closed");
_keepAliveSet = true;
}
return _keepAlive;
}
}
/// <summary>
/// Gets the local endpoint of the connection.
/// </summary>
public System.Net.IPEndPoint LocalEndPoint => _context.Connection.LocalEndPoint;
/// <summary>
/// Gets the protocol version of the request.
/// </summary>
public Version ProtocolVersion => _version;
/// <summary>
/// Gets the query string in the request.
/// </summary>
public NameValueCollection QueryString => _queryString ??= HttpUtility.InternalParseQueryString(Url.Query, ContentEncoding);
/// <summary>
/// Gets the raw URL of the request.
/// </summary>
public string RawUrl => Url.PathAndQuery;
/// <summary>
/// Gets the remote endpoint of the connection.
/// </summary>
public System.Net.IPEndPoint RemoteEndPoint => _context.Connection.RemoteEndPoint;
/// <summary>
/// Gets the trace identifier for the request.
/// </summary>
public Guid RequestTraceIdentifier { get; }
/// <summary>
/// Gets the URL of the request.
/// </summary>
public Uri Url { get; private set; }
/// <summary>
/// Gets the URL referrer of the request.
/// </summary>
public Uri UrlReferrer { get; private set; }
/// <summary>
/// Gets the user agent of the request.
/// </summary>
public string UserAgent => _headers["User-Agent"];
/// <summary>
/// Gets the user host address of the request.
/// </summary>
public string UserHostAddress => LocalEndPoint.ToString();
/// <summary>
/// Gets the user host name of the request.
/// </summary>
public string UserHostName => _headers["Host"];
/// <summary>
/// Gets the user languages of the request.
/// </summary>
public string[] UserLanguages { get; private set; }
public override string ToString()
{
var buff = new StringBuilder(64);
buff.AppendFormat("{0} {1} HTTP/{2}\r\n", HttpMethod, _uri, _version);
buff.Append(_headers.ToString());
return buff.ToString();
}
internal void AddHeader(string header)
{
var colon = header.IndexOf(':');
if (colon == -1)
{
_context.ErrorMessage = "Invalid header";
return;
}
var name = header.Substring(0, colon).Trim();
var val = header.Substring(colon + 1).Trim();
_headers.InternalSet(name, val, false);
var lower = name.ToLower(CultureInfo.InvariantCulture);
if (lower == "accept")
{
AcceptTypes = new List<string>(val.SplitHeaderValue(',')).ToArray();
return;
}
if (lower == "accept-language")
{
UserLanguages = val.Split(',');
return;
}
if (lower == "content-length")
{
if (long.TryParse(val, out long len) && len >= 0)
{
ContentLength64 = len;
_contentLengthSet = true;
}
else
{
_context.ErrorMessage = "Invalid Content-Length header";
}
return;
}
if (lower == "content-type")
{
try
{
_contentEncoding = HttpUtility.GetEncoding(val);
}
catch
{
_context.ErrorMessage = "Invalid Content-Type header";
}
return;
}
if (lower == "referer")
{
UrlReferrer = val.ToUri();
}
}
internal void FinishInitialization()
{
var host = _headers["Host"];
var nohost = host == null || host.Length == 0;
if (_version > HttpVersion.Version10 && nohost)
{
_context.ErrorMessage = "Invalid Host header";
return;
}
if (nohost)
{
host = UserHostAddress;
}
Url = HttpUtility.CreateRequestUrl(_uri, host, IsWebSocketRequest, IsSecureConnection);
if (Url == null)
{
_context.ErrorMessage = "Invalid request url";
return;
}
var enc = Headers["Transfer-Encoding"];
if (_version > HttpVersion.Version10 && enc != null && enc.Length > 0)
{
_chunked = enc.ToLower() == "chunked";
if (!_chunked)
{
_context.ErrorMessage = string.Empty;
_context.ErrorStatus = 501;
return;
}
}
if (!_chunked && !_contentLengthSet)
{
var method = HttpMethod.ToLower();
if (method == "post" || method == "put")
{
_context.ErrorMessage = string.Empty;
_context.ErrorStatus = 411;
return;
}
}
var expect = Headers["Expect"];
if (expect != null && expect.Length > 0 && expect.ToLower() == "100-continue")
{
var output = _context.Connection.GetResponseStream();
output.InternalWrite(_100continue, 0, _100continue.Length);
}
}
// Returns true is the stream could be reused.
internal bool FlushInput()
{
if (!HasEntityBody)
{
return true;
}
var len = 2048;
if (ContentLength64 > 0)
{
len = (int)Math.Min(ContentLength64, len);
}
var buff = new byte[len];
while (true)
{
try
{
var result = InputStream.BeginRead(buff, 0, len, null, null);
if (!result.IsCompleted && !result.AsyncWaitHandle.WaitOne(100))
{
return false;
}
if (InputStream.EndRead(result) <= 0)
{
return true;
}
}
catch
{
return false;
}
}
}
internal void SetRequestLine(string requestLine)
{
var parts = requestLine.Split(new[] { ' ' }, 3);
if (parts.Length != 3)
{
_context.ErrorMessage = "Invalid request line (parts)";
return;
}
HttpMethod = parts[0];
if (!HttpMethod.IsToken())
{
_context.ErrorMessage = "Invalid request line (method)";
return;
}
_uri = parts[1];
var ver = parts[2];
if (ver.Length != 8 ||
!ver.StartsWith("HTTP/") ||
!tryCreateVersion(ver.Substring(5), out _version) ||
_version.Major < 1)
{
_context.ErrorMessage = "Invalid request line (version)";
}
}
private static bool tryCreateVersion(string version, out Version result)
{
try
{
result = new Version(version);
return true;
}
catch
{
result = null;
return false;
}
}
}
}

647
EonaCat.Network/System/Sockets/Web/Core/Http/HttpListenerResponse.cs
View File

@ -1,647 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
/// <summary>
/// Represents an HTTP listener response.
/// </summary>
public sealed class HttpListenerResponse : IDisposable
{
private readonly HttpListenerContext _context;
private Encoding _contentEncoding;
private long _contentLength;
private string _contentType;
private CookieCollection _cookies;
private bool _disposed;
private WebHeaderCollection _headers;
private bool _keepAlive;
private string _location;
private ResponseStream _outputStream;
private bool _sendInChunks;
private int _statusCode;
private string _statusDescription;
private Version _version;
/// <summary>
/// Initializes a new instance of the <see cref="HttpListenerResponse"/> class.
/// </summary>
/// <param name="context">The HTTP listener context associated with the response.</param>
internal HttpListenerResponse(HttpListenerContext context)
{
_context = context;
_keepAlive = true;
_statusCode = 200;
_statusDescription = "OK";
_version = HttpVersion.Version11;
}
/// <summary>
/// Gets or sets the encoding for the response content.
/// </summary>
public Encoding ContentEncoding
{
get
{
return _contentEncoding;
}
set
{
checkDisposed();
_contentEncoding = value;
}
}
/// <summary>
/// Gets or sets the content length of the response content.
/// </summary>
public long ContentLength64
{
get
{
return _contentLength;
}
set
{
checkDisposedOrHeadersSent();
if (value < 0)
{
throw new ArgumentOutOfRangeException("Less than zero.", "value");
}
_contentLength = value;
}
}
/// <summary>
/// Gets or sets the content type of the response content.
/// </summary>
public string ContentType
{
get
{
return _contentType;
}
set
{
checkDisposed();
if (value != null && value.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(value));
}
_contentType = value;
}
}
/// <summary>
/// Gets or sets the collection of cookies in the response.
/// </summary>
public CookieCollection Cookies
{
get
{
return _cookies ??= new CookieCollection();
}
set
{
_cookies = value;
}
}
/// <summary>
/// Gets or sets the collection of headers in the response.
/// </summary>
public WebHeaderCollection Headers
{
get
{
return _headers ??= new WebHeaderCollection(HttpHeaderType.Response, false);
}
set
{
if (value != null && value.State != HttpHeaderType.Response)
{
throw new InvalidOperationException(
"The specified headers aren't valid for a response.");
}
_headers = value;
}
}
/// <summary>
/// Gets or sets a value indicating whether the connection should be kept alive.
/// </summary>
public bool KeepAlive
{
get
{
return _keepAlive;
}
set
{
checkDisposedOrHeadersSent();
_keepAlive = value;
}
}
/// <summary>
/// Gets the output stream for writing the response content.
/// </summary>
public Stream OutputStream
{
get
{
checkDisposed();
return _outputStream ??= _context.Connection.GetResponseStream();
}
}
/// <summary>
/// Gets or sets the HTTP protocol version of the response.
/// </summary>
public Version ProtocolVersion
{
get
{
return _version;
}
set
{
checkDisposedOrHeadersSent();
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.Major != 1 || (value.Minor != 0 && value.Minor != 1))
{
throw new ArgumentException("Not 1.0 or 1.1.", nameof(value));
}
_version = value;
}
}
/// <summary>
/// Gets or sets the redirect location for the response.
/// </summary>
public string RedirectLocation
{
get
{
return _location;
}
set
{
checkDisposed();
if (value == null)
{
_location = null;
return;
}
if (!value.MaybeUri() || !Uri.TryCreate(value, UriKind.Absolute, out Uri uri))
{
throw new ArgumentException("Not an absolute URL.", nameof(value));
}
_location = value;
}
}
/// <summary>
/// Gets or sets a value indicating whether the response should be sent in chunks.
/// </summary>
public bool SendInChunks
{
get
{
return _sendInChunks;
}
set
{
checkDisposedOrHeadersSent();
_sendInChunks = value;
}
}
/// <summary>
/// Gets or sets the HTTP status code for the response.
/// </summary>
public int StatusCode
{
get
{
return _statusCode;
}
set
{
checkDisposedOrHeadersSent();
if (value < 100 || value > 999)
{
throw new System.Net.ProtocolViolationException(
"A value isn't between 100 and 999 inclusive.");
}
_statusCode = value;
_statusDescription = value.GetStatusDescription();
}
}
/// <summary>
/// Gets or sets the status description for the response.
/// </summary>
public string StatusDescription
{
get
{
return _statusDescription;
}
set
{
checkDisposedOrHeadersSent();
if (value == null || value.Length == 0)
{
_statusDescription = _statusCode.GetStatusDescription();
return;
}
if (!value.IsText() || value.IndexOfAny(new[] { '\r', '\n' }) > -1)
{
throw new ArgumentException("Contains invalid characters.", nameof(value));
}
_statusDescription = value;
}
}
internal bool CloseConnection { get; set; }
internal bool HeadersSent { get; set; }
/// <summary>
/// Aborts the response.
/// </summary>
public void Abort()
{
if (_disposed)
{
return;
}
close(true);
}
/// <summary>
/// Appends a header to the response.
/// </summary>
/// <param name="name">The name of the header.</param>
/// <param name="value">The value of the header.</param>
public void AddHeader(string name, string value)
{
Headers.Set(name, value);
}
/// <summary>
/// Appends a cookie to the response.
/// </summary>
/// <param name="cookie">The cookie to append.</param>
public void AppendCookie(Cookie cookie)
{
Cookies.Add(cookie);
}
/// <summary>
/// Appends a header to the response.
/// </summary>
/// <param name="name">The name of the header.</param>
/// <param name="value">The value of the header.</param>
public void AppendHeader(string name, string value)
{
Headers.Add(name, value);
}
/// <summary>
/// Closes the response.
/// </summary>
public void Close()
{
if (_disposed)
{
return;
}
close(false);
}
/// <summary>
/// Closes the response with the specified response entity and blocking behavior.
/// </summary>
/// <param name="responseEntity">The response entity.</param>
/// <param name="willBlock">A value indicating whether the operation will block.</param>
public void Close(byte[] responseEntity, bool willBlock)
{
checkDisposed();
if (responseEntity == null)
{
throw new ArgumentNullException(nameof(responseEntity));
}
var len = responseEntity.Length;
var output = OutputStream;
if (willBlock)
{
output.Write(responseEntity, 0, len);
close(false);
return;
}
output.BeginWrite(
responseEntity,
0,
len,
ar =>
{
output.EndWrite(ar);
close(false);
},
null);
}
/// <summary>
/// Copies headers and other properties from a template response.
/// </summary>
/// <param name="templateResponse">The template response to copy from.</param>
public void CopyFrom(HttpListenerResponse templateResponse)
{
if (templateResponse == null)
{
throw new ArgumentNullException(nameof(templateResponse));
}
if (templateResponse._headers != null)
{
_headers?.Clear();
Headers.Add(templateResponse._headers);
}
else if (_headers != null)
{
_headers = null;
}
_contentLength = templateResponse._contentLength;
_statusCode = templateResponse._statusCode;
_statusDescription = templateResponse._statusDescription;
_keepAlive = templateResponse._keepAlive;
_version = templateResponse._version;
}
/// <inheritdoc/>
void IDisposable.Dispose()
{
if (_disposed)
{
return;
}
close(true);
}
/// <summary>
/// Redirects the response to the specified URL.
/// </summary>
/// <param name="url">The URL to redirect to.</param>
public void Redirect(string url)
{
checkDisposedOrHeadersSent();
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
if (!url.MaybeUri() || !Uri.TryCreate(url, UriKind.Absolute, out Uri uri))
{
throw new ArgumentException("Not an absolute URL.", nameof(url));
}
_location = url;
_statusCode = 302;
_statusDescription = "Found";
}
/// <summary>
/// Sets a cookie in the response.
/// </summary>
/// <param name="cookie">The cookie to set.</param>
public void SetCookie(Cookie cookie)
{
if (cookie == null)
{
throw new ArgumentNullException(nameof(cookie));
}
if (!canAddOrUpdate(cookie))
{
throw new ArgumentException("Cannot be replaced.", nameof(cookie));
}
Cookies.Add(cookie);
}
/// <summary>
/// Writes headers to the specified destination.
/// </summary>
/// <param name="destination">The destination stream to write headers to.</param>
/// <returns>The collection of headers written.</returns>
internal WebHeaderCollection WriteHeadersTo(MemoryStream destination)
{
var headers = new WebHeaderCollection(HttpHeaderType.Response, true);
if (_headers != null)
{
headers.Add(_headers);
}
if (_contentType != null)
{
var type = _contentType.IndexOf("charset=", StringComparison.Ordinal) == -1 &&
_contentEncoding != null
? string.Format("{0}; charset={1}", _contentType, _contentEncoding.WebName)
: _contentType;
headers.InternalSet("Content-Type", type, true);
}
if (headers["Server"] == null)
{
headers.InternalSet("Server", $"EonaCat.Network/{Constants.Version}", true);
}
var prov = CultureInfo.InvariantCulture;
if (headers["Date"] == null)
{
headers.InternalSet("Date", DateTime.UtcNow.ToString("r", prov), true);
}
if (!_sendInChunks)
{
headers.InternalSet("Content-Length", _contentLength.ToString(prov), true);
}
else
{
headers.InternalSet("Transfer-Encoding", "chunked", true);
}
/*
* Apache forces closing the connection for these status codes:
* - 400 Bad Request
* - 408 Request Timeout
* - 411 Length Required
* - 413 Request Entity Too Large
* - 414 Request-Uri Too Long
* - 500 Internal Server Error
* - 503 Service Unavailable
*/
var closeConn = !_context.Request.KeepAlive ||
!_keepAlive ||
_statusCode == 400 ||
_statusCode == 408 ||
_statusCode == 411 ||
_statusCode == 413 ||
_statusCode == 414 ||
_statusCode == 500 ||
_statusCode == 503;
var reuses = _context.Connection.Reuses;
if (closeConn || reuses >= 100)
{
headers.InternalSet("Connection", "close", true);
}
else
{
headers.InternalSet(
"Keep-Alive", string.Format("timeout=15,max={0}", 100 - reuses), true);
if (_context.Request.ProtocolVersion < HttpVersion.Version11)
{
headers.InternalSet("Connection", "keep-alive", true);
}
}
if (_location != null)
{
headers.InternalSet("Location", _location, true);
}
if (_cookies != null)
{
foreach (Cookie cookie in _cookies)
{
headers.InternalSet("Set-Cookie", cookie.ToResponseString(), true);
}
}
var enc = _contentEncoding ?? Encoding.Default;
var writer = new StreamWriter(destination, enc, 256);
writer.Write("HTTP/{0} {1} {2}\r\n", _version, _statusCode, _statusDescription);
writer.Write(headers.ToStringMultiValue(true));
writer.Flush();
// Assumes that the destination was at position 0.
destination.Position = enc.GetPreamble().Length;
return headers;
}
private bool canAddOrUpdate(Cookie cookie)
{
if (_cookies == null || _cookies.Count == 0)
{
return true;
}
var found = findCookie(cookie).ToList();
if (found.Count == 0)
{
return true;
}
var ver = cookie.Version;
foreach (var c in found)
{
if (c.Version == ver)
{
return true;
}
}
return false;
}
private void checkDisposed()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
}
private void checkDisposedOrHeadersSent()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
if (HeadersSent)
{
throw new InvalidOperationException("Cannot be changed after the headers are sent.");
}
}
private void close(bool force)
{
_disposed = true;
_context.Connection.Close(force);
}
private IEnumerable<Cookie> findCookie(Cookie cookie)
{
var name = cookie.Name;
var domain = cookie.Domain;
var path = cookie.Path;
if (_cookies != null)
{
foreach (Cookie c in _cookies)
{
if (c.Name.Equals(name, StringComparison.OrdinalIgnoreCase) &&
c.Domain.Equals(domain, StringComparison.OrdinalIgnoreCase) &&
c.Path.Equals(path, StringComparison.Ordinal))
{
yield return c;
}
}
}
}
}
}

101
EonaCat.Network/System/Sockets/Web/Core/Http/HttpRequestHeader.cs
View File

@ -1,101 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
/// <summary>
/// Represents HTTP request headers.
/// </summary>
public enum HttpRequestHeader
{
CacheControl,
Connection,
Date,
KeepAlive,
Pragma,
Trailer,
TransferEncoding,
Upgrade,
Via,
Warning,
Allow,
ContentLength,
ContentType,
ContentEncoding,
ContentLanguage,
ContentLocation,
ContentMd5,
ContentRange,
Expires,
LastModified,
Accept,
AcceptCharset,
AcceptEncoding,
AcceptLanguage,
Authorization,
Cookie,
Expect,
From,
Host,
IfMatch,
IfModifiedSince,
IfNoneMatch,
IfRange,
IfUnmodifiedSince,
MaxForwards,
ProxyAuthorization,
Referer,
Range,
Te,
Translate,
UserAgent,
SecWebSocketKey,
SecWebSocketExtensions,
SecWebSocketProtocol,
SecWebSocketVersion
}
}

79
EonaCat.Network/System/Sockets/Web/Core/Http/HttpResponseHeader.cs
View File

@ -1,79 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
/// <summary>
/// Represents HTTP response headers.
/// </summary>
public enum HttpResponseHeader
{
CacheControl,
Connection,
Date,
KeepAlive,
Pragma,
Trailer,
TransferEncoding,
Upgrade,
Via,
Warning,
Allow,
ContentLength,
ContentType,
ContentEncoding,
ContentLanguage,
ContentLocation,
ContentMd5,
ContentRange,
Expires,
LastModified,
AcceptRanges,
Age,
ETag,
Location,
ProxyAuthenticate,
RetryAfter,
Server,
SetCookie,
Vary,
WwwAuthenticate,
SecWebSocketExtensions,
SecWebSocketAccept,
SecWebSocketProtocol,
SecWebSocketVersion
}
}

103
EonaCat.Network/System/Sockets/Web/Core/Http/HttpStatusCode.cs
View File

@ -1,103 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
/// <summary>
/// Represents HTTP status codes.
/// </summary>
public enum HttpStatusCode
{
Continue = 100,
SwitchingProtocols = 101,
OK = 200,
Created = 201,
Accepted = 202,
NonAuthoritativeInformation = 203,
NoContent = 204,
ResetContent = 205,
PartialContent = 206,
MultipleChoices = 300,
Ambiguous = 300,
MovedPermanently = 301,
Moved = 301,
Found = 302,
Redirect = 302,
SeeOther = 303,
RedirectMethod = 303,
NotModified = 304,
UseProxy = 305,
Unused = 306,
TemporaryRedirect = 307,
RedirectKeepVerb = 307,
BadRequest = 400,
Unauthorized = 401,
PaymentRequired = 402,
Forbidden = 403,
NotFound = 404,
MethodNotAllowed = 405,
NotAcceptable = 406,
ProxyAuthenticationRequired = 407,
RequestTimeout = 408,
Conflict = 409,
Gone = 410,
LengthRequired = 411,
PreconditionFailed = 412,
RequestEntityTooLarge = 413,
RequestUriTooLong = 414,
UnsupportedMediaType = 415,
RequestedRangeNotSatisfiable = 416,
ExpectationFailed = 417,
InternalServerError = 500,
NotImplemented = 501,
BadGateway = 502,
ServiceUnavailable = 503,
GatewayTimeout = 504,
HttpVersionNotSupported = 505,
}
}

84
EonaCat.Network/System/Sockets/Web/Core/Http/HttpStreamAsyncResult.cs
View File

@ -1,84 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Threading;
namespace EonaCat.Network
{
internal class HttpStreamAsyncResult : IAsyncResult
{
private readonly AsyncCallback _callback;
private readonly object _locker;
private bool _isCompleted;
private ManualResetEvent _waitHandle;
internal HttpStreamAsyncResult(AsyncCallback callback, object state)
{
_callback = callback;
AsyncState = state;
_locker = new object();
}
public object AsyncState { get; }
public WaitHandle AsyncWaitHandle
{
get
{
lock (_locker)
{
return _waitHandle ??= new ManualResetEvent(_isCompleted);
}
}
}
public bool CompletedSynchronously => SyncRead == Count;
public bool IsCompleted
{
get
{
lock (_locker)
{
return _isCompleted;
}
}
}
internal byte[] Buffer { get; set; }
internal int Count { get; set; }
internal Exception Exception { get; private set; }
internal bool HasException => Exception != null;
internal int Offset { get; set; }
internal int SyncRead { get; set; }
internal void Complete()
{
lock (_locker)
{
if (_isCompleted)
{
return;
}
_isCompleted = true;
_waitHandle?.Set();
_callback?.Invoke(this);
}
}
internal void Complete(Exception exception)
{
Exception = exception;
Complete();
}
}
}

1363
EonaCat.Network/System/Sockets/Web/Core/Http/HttpUtility.cs
View File

File diff suppressed because it is too large Load Diff

30
EonaCat.Network/System/Sockets/Web/Core/Http/HttpVersion.cs
View File

@ -1,30 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
/// <summary>
/// Represents HTTP versions.
/// </summary>
public class HttpVersion
{
/// <summary>
/// Gets the HTTP version 1.0.
/// </summary>
public static readonly Version Version10 = new Version(1, 0);
/// <summary>
/// Gets the HTTP version 1.1.
/// </summary>
public static readonly Version Version11 = new Version(1, 1);
/// <summary>
/// Initializes a new instance of the <see cref="HttpVersion"/> class.
/// </summary>
public HttpVersion()
{
}
}
}

14
EonaCat.Network/System/Sockets/Web/Core/InputChunkState.cs
View File

@ -1,14 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum InputChunkState
{
None,
Data,
DataEnded,
Trailer,
End
}
}

11
EonaCat.Network/System/Sockets/Web/Core/InputState.cs
View File

@ -1,11 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum InputState
{
RequestLine,
Headers
}
}

20
EonaCat.Network/System/Sockets/Web/Core/LineState.cs
View File

@ -1,20 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum LineState
{
None,
/// <summary>
/// Moves the cursor to the beginning of the current line
/// </summary>
CarriageReturn,
/// <summary>
/// Moves the cursor down to the next line and then to the beginning of the line
/// </summary>
LineFeed
}
}

229
EonaCat.Network/System/Sockets/Web/Core/Logger.cs
View File

@ -1,229 +0,0 @@
using EonaCat.Logger;
using EonaCat.Logger.GrayLog;
using EonaCat.Logger.Managers;
using EonaCat.Logger.SplunkServer;
using EonaCat.Logger.Syslog;
using System;
using System.Collections.Generic;
namespace EonaCat.Network
{
internal class GrayLogSettings
{
internal GrayLogSettings(string facility, string source, string version = "1.1")
{
Facility = facility;
Source = source;
Version = version;
}
internal string Facility { get; }
internal string Source { get; }
internal string Version { get; }
}
internal class Logger
{
private static readonly LogManager _logManager;
static Logger()
{
_logManager = new LogManager(new LoggerSettings());
_logManager.OnException += LogManager_OnException;
}
internal static bool DisableConsole { get; set; }
internal static bool IsLoggingDirectorySet => !string.IsNullOrWhiteSpace(LoggingDirectory);
internal static bool IsLoggingEnabled { get; set; }
internal static string LoggingDirectory { get; private set; }
private static bool HasBeenSetup { get; set; }
internal static void AddGrayLogServer(string hostname, int port)
{
_logManager.Settings.GrayLogServers.Add(new GrayLogServer(hostname, port));
}
internal static void AddSplunkServer(string splunkHecUrl, string splunkHecToken, bool disableSSL = false)
{
var splunkServer = new SplunkServer(splunkHecUrl, splunkHecToken);
if (disableSSL)
{
splunkServer.DisableSSLValidation();
}
_logManager.Settings.SplunkServers.Add(splunkServer);
}
internal static void AddSyslogServer(string ipAddress, int port)
{
_logManager.Settings.SysLogServers.Add(new SyslogServer(ipAddress, port));
}
internal static void Critical(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.CRITICAL, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
internal static void Debug(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.DEBUG, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
internal static void Error(Exception exception, string message = null, bool isCriticalException = false, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
if (!IsLoggingEnabled)
{
return;
}
if (DisableConsole)
{
writeToConsole = false;
}
if (!HasBeenSetup)
{
Setup();
}
if (grayLogSettings != null)
{
_logManager.Write(exception, message, criticalException: isCriticalException, writeToConsole: writeToConsole, sendToSysLogServers: sendToSysLogServers, sendToSplunkServers: sendToSplunkServers, customSplunkSourceType: customSplunkSourceType, sendToGrayLogServers: sendToGrayLogServers, grayLogFacility: grayLogSettings.Facility, grayLogSource: grayLogSettings.Source, grayLogVersion: grayLogSettings.Version);
}
else
{
_logManager.Write(exception, message, criticalException: isCriticalException, writeToConsole: writeToConsole, sendToSysLogServers: sendToSysLogServers, sendToSplunkServers: sendToSplunkServers, customSplunkSourceType: customSplunkSourceType, sendToGrayLogServers: sendToGrayLogServers);
}
}
internal static void Error(string message = null, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null, string grayLogSource = null, string grayLogVersion = "1.1", bool isCriticalException = false)
{
if (!IsLoggingEnabled)
{
return;
}
if (DisableConsole)
{
writeToConsole = false;
}
if (!HasBeenSetup)
{
Setup();
}
if (isCriticalException)
{
_logManager.Write(message, ELogType.CRITICAL, writeToConsole);
}
else
{
_logManager.Write(message, ELogType.ERROR, writeToConsole);
}
}
internal static void GrayLogState(bool state)
{
_logManager.Settings.SendToGrayLogServers = state;
}
internal static void Info(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.INFO, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
internal static bool RemoveGrayLogServer(GrayLogServer grayLogServer)
{
return _logManager.Settings.GrayLogServers.Remove(grayLogServer);
}
internal static bool RemoveSplunkServer(SplunkServer splunkServer)
{
return _logManager.Settings.SplunkServers.Remove(splunkServer);
}
internal static bool RemoveSyslogServer(SyslogServer syslogServer)
{
return _logManager.Settings.SysLogServers.Remove(syslogServer);
}
internal static void Setup(string loggingDirectory = null)
{
LoggingDirectory = loggingDirectory;
_logManager.Settings.FileLoggerOptions.FileNamePrefix = "EonaCat.Network";
if (IsLoggingDirectorySet)
{
_logManager.Settings.FileLoggerOptions.LogDirectory = LoggingDirectory;
}
_logManager.Settings.UseLocalTime = true;
_logManager.Settings.FileLoggerOptions.UseLocalTime = true;
_logManager.Settings.SysLogServers = new List<SyslogServer>();
_logManager.Settings.SplunkServers = new List<SplunkServer>();
_logManager.Settings.GrayLogServers = new List<GrayLogServer>();
_logManager.StartNewLogAsync();
HasBeenSetup = true;
}
internal static void SplunkState(bool state)
{
_logManager.Settings.SendToSplunkServers = state;
}
internal static void SysLogState(bool state)
{
_logManager.Settings.SendToSyslogServers = state;
}
internal static void Trace(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.TRACE, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
internal static void Traffic(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.TRAFFIC, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
internal static void Warning(string message, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
Write(message, ELogType.WARNING, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings);
}
private static void LogManager_OnException(object? sender, ErrorMessage e)
{
Console.WriteLine(e.Message);
if (e.Exception != null)
{
Console.WriteLine(e.Exception);
}
}
private static void Write(string message, ELogType logType, bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, bool? sendToGrayLogServers = null, GrayLogSettings grayLogSettings = null)
{
if (!IsLoggingEnabled)
{
return;
}
if (DisableConsole)
{
writeToConsole = false;
}
if (!HasBeenSetup)
{
Setup();
}
if (grayLogSettings != null)
{
_logManager.Write(message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogSettings.Facility, grayLogSettings.Source, grayLogSettings.Version);
}
else
{
_logManager.Write(message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers);
}
}
}
}

28
EonaCat.Network/System/Sockets/Web/Core/ReadBufferState.cs
View File

@ -1,28 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal class ReadBufferState
{
public ReadBufferState(
byte[] buffer, int offset, int count, HttpStreamAsyncResult asyncResult)
{
Buffer = buffer;
Offset = offset;
Count = count;
InitialCount = count;
AsyncResult = asyncResult;
}
public HttpStreamAsyncResult AsyncResult { get; set; }
public byte[] Buffer { get; set; }
public int Count { get; set; }
public int InitialCount { get; set; }
public int Offset { get; set; }
}
}

113
EonaCat.Network/System/Sockets/Web/Core/SSLConfig/SSLConfigClient.cs
View File

@ -1,113 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
namespace EonaCat.Network
{
public class SSLConfigClient
{
private X509CertificateCollection _clientCertificates;
private LocalCertificateSelectionCallback _clientCertSelectionCallback;
private RemoteCertificateValidationCallback _serverCertValidationCallback;
public SSLConfigClient()
{
SslProtocols = SslProtocols.None;
}
public SSLConfigClient(string targetHost)
{
TargetHost = targetHost;
SslProtocols = SslProtocols.None;
}
public SSLConfigClient(SSLConfigClient sslConfig)
{
if (sslConfig == null)
{
throw new ArgumentNullException(nameof(sslConfig));
}
CheckForCertificateRevocation = sslConfig.CheckForCertificateRevocation;
_clientCertSelectionCallback = sslConfig._clientCertSelectionCallback;
_clientCertificates = sslConfig._clientCertificates;
SslProtocols = sslConfig.SslProtocols;
_serverCertValidationCallback = sslConfig._serverCertValidationCallback;
TargetHost = sslConfig.TargetHost;
}
public X509CertificateCollection Certificates
{
get
{
_clientCertificates ??= new X509CertificateCollection();
return _clientCertificates;
}
set
{
_clientCertificates = value;
}
}
public bool CheckForCertificateRevocation { get; set; }
public LocalCertificateSelectionCallback ClientCertificateSelectionCallback
{
get
{
_clientCertSelectionCallback ??= SelectClientCertificate;
return _clientCertSelectionCallback;
}
set
{
_clientCertSelectionCallback = value;
}
}
public RemoteCertificateValidationCallback ServerCertificateValidationCallback
{
get
{
_serverCertValidationCallback ??= ValidateServerCertificate;
return _serverCertValidationCallback;
}
set
{
_serverCertValidationCallback = value;
}
}
public SslProtocols SslProtocols { get; set; }
public string TargetHost { get; set; }
private static X509Certificate SelectClientCertificate(
object sender,
string targetHost,
X509CertificateCollection clientCertificates,
X509Certificate serverCertificate,
string[] acceptableIssuers
)
{
return null;
}
private static bool ValidateServerCertificate(
object sender,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors sslPolicyErrors
)
{
return true;
}
}
}

71
EonaCat.Network/System/Sockets/Web/Core/SSLConfig/SSLConfigServer.cs
View File

@ -1,71 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
namespace EonaCat.Network
{
public class SSLConfigServer
{
private RemoteCertificateValidationCallback _clientCertificationValidationCallback;
public SSLConfigServer()
{
SslProtocols = SslProtocols.None;
}
public SSLConfigServer(X509Certificate2 certificate)
{
Certificate = certificate;
SslProtocols = SslProtocols.None;
}
public SSLConfigServer(SSLConfigServer sslConfig)
{
if (sslConfig == null)
{
throw new ArgumentNullException(nameof(sslConfig));
}
CheckForCertificateRevocation = sslConfig.CheckForCertificateRevocation;
IsClientCertificateRequired = sslConfig.IsClientCertificateRequired;
_clientCertificationValidationCallback = sslConfig._clientCertificationValidationCallback;
SslProtocols = sslConfig.SslProtocols;
Certificate = sslConfig.Certificate;
}
public X509Certificate2 Certificate { get; set; }
public bool CheckForCertificateRevocation { get; set; }
public RemoteCertificateValidationCallback ClientCertificateValidationCallback
{
get
{
_clientCertificationValidationCallback ??= ValidateClientCertificate;
return _clientCertificationValidationCallback;
}
set
{
_clientCertificationValidationCallback = value;
}
}
public bool IsClientCertificateRequired { get; set; }
public SslProtocols SslProtocols { get; set; }
private static bool ValidateClientCertificate(
object sender,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors sslPolicyErrors
)
{
return true;
}
}
}

237
EonaCat.Network/System/Sockets/Web/Core/Stream/RequestStream.cs
View File

@ -1,237 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
namespace EonaCat.Network
{
internal class RequestStream : Stream
{
private readonly byte[] _buffer;
private readonly Stream _stream;
private long _bodyLeft;
private int _count;
private bool _disposed;
private int _offset;
internal RequestStream(Stream stream, byte[] buffer, int offset, int count)
: this(stream, buffer, offset, count, -1)
{
}
internal RequestStream(
Stream stream, byte[] buffer, int offset, int count, long contentLength)
{
_stream = stream;
_buffer = buffer;
_offset = offset;
_count = count;
_bodyLeft = contentLength;
}
public override bool CanRead => true;
public override bool CanSeek => false;
public override bool CanWrite => false;
public override long Length => throw new NotSupportedException();
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override IAsyncResult BeginRead(
byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
var nread = FillFromBuffer(buffer, offset, count);
if (nread > 0 || nread == -1)
{
var result = new HttpStreamAsyncResult(callback, state);
result.Buffer = buffer;
result.Offset = offset;
result.Count = count;
result.SyncRead = nread > 0 ? nread : 0;
result.Complete();
return result;
}
// Avoid reading past the end of the request to allow for HTTP pipelining.
if (_bodyLeft >= 0 && count > _bodyLeft)
{
count = (int)_bodyLeft;
}
return _stream.BeginRead(buffer, offset, count, callback, state);
}
public override IAsyncResult BeginWrite(
byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
throw new NotSupportedException();
}
public override void Close()
{
_disposed = true;
}
public override int EndRead(IAsyncResult asyncResult)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
if (asyncResult == null)
{
throw new ArgumentNullException(nameof(asyncResult));
}
if (asyncResult is HttpStreamAsyncResult)
{
var result = (HttpStreamAsyncResult)asyncResult;
if (!result.IsCompleted)
{
result.AsyncWaitHandle.WaitOne();
}
return result.SyncRead;
}
// Close on exception?
var nread = _stream.EndRead(asyncResult);
if (nread > 0 && _bodyLeft > 0)
{
_bodyLeft -= nread;
}
return nread;
}
public override void EndWrite(IAsyncResult asyncResult)
{
throw new NotSupportedException();
}
public override void Flush()
{
}
public override int Read(byte[] buffer, int offset, int count)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
// Call the fillFromBuffer method to check for buffer boundaries even when _bodyLeft is 0.
var nread = FillFromBuffer(buffer, offset, count);
if (nread == -1) // No more bytes available (Content-Length).
{
return 0;
}
if (nread > 0)
{
return nread;
}
nread = _stream.Read(buffer, offset, count);
if (nread > 0 && _bodyLeft > 0)
{
_bodyLeft -= nread;
}
return nread;
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
throw new NotSupportedException();
}
// Returns 0 if we can keep reading from the base stream,
// > 0 if we read something from the buffer,
// -1 if we had a content length set and we finished reading that many bytes.
private int FillFromBuffer(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), "A negative value.");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), "A negative value.");
}
var bufferLength = buffer.Length;
if (offset + count > bufferLength)
{
throw new ArgumentException(
"The sum of 'offset' and 'count' is greater than 'buffer' length.");
}
if (_bodyLeft == 0)
{
return -1;
}
if (_count == 0 || count == 0)
{
return 0;
}
if (count > _count)
{
count = _count;
}
if (_bodyLeft > 0 && count > _bodyLeft)
{
count = (int)_bodyLeft;
}
Buffer.BlockCopy(_buffer, _offset, buffer, offset, count);
_offset += count;
_count -= count;
if (_bodyLeft > 0)
{
_bodyLeft -= count;
}
return count;
}
}
}

286
EonaCat.Network/System/Sockets/Web/Core/Stream/ResponseStream.cs
View File

@ -1,286 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
internal class ResponseStream : Stream
{
private static readonly byte[] _crlf = new byte[] { 13, 10 };
private readonly Action<byte[], int, int> _write;
private readonly Action<byte[], int, int> _writeChunked;
private MemoryStream _body;
private bool _disposed;
private HttpListenerResponse _response;
private bool _sendChunked;
private Stream _stream;
private Action<byte[], int, int> _writeBody;
internal ResponseStream(
Stream stream, HttpListenerResponse response, bool ignoreWriteExceptions)
{
_stream = stream;
_response = response;
if (ignoreWriteExceptions)
{
_write = writeWithoutThrowingException;
_writeChunked = writeChunkedWithoutThrowingException;
}
else
{
_write = stream.Write;
_writeChunked = writeChunked;
}
_body = new MemoryStream();
}
public override bool CanRead => false;
public override bool CanSeek => false;
public override bool CanWrite => !_disposed;
public override long Length => throw new NotSupportedException();
public override long Position
{
get
{
throw new NotSupportedException();
}
set
{
throw new NotSupportedException();
}
}
public override IAsyncResult BeginRead(
byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
throw new NotSupportedException();
}
public override IAsyncResult BeginWrite(
byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
return _body.BeginWrite(buffer, offset, count, callback, state);
}
public override void Close()
{
Close(false);
}
public override int EndRead(IAsyncResult asyncResult)
{
throw new NotSupportedException();
}
public override void EndWrite(IAsyncResult asyncResult)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
_body.EndWrite(asyncResult);
}
public override void Flush()
{
if (!_disposed && (_sendChunked || _response.SendInChunks))
{
flush(false);
}
}
public override int Read(byte[] buffer, int offset, int count)
{
throw new NotSupportedException();
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().ToString());
}
_body.Write(buffer, offset, count);
}
internal void Close(bool force)
{
if (_disposed)
{
return;
}
_disposed = true;
if (!force && flush(true))
{
_response.Close();
}
else
{
if (_sendChunked)
{
var last = getChunkSizeBytes(0, true);
_write(last, 0, last.Length);
}
_body.Dispose();
_body = null;
_response.Abort();
}
_response = null;
_stream = null;
}
internal void InternalWrite(byte[] buffer, int offset, int count)
{
_write(buffer, offset, count);
}
protected override void Dispose(bool disposing)
{
Close(!disposing);
}
private static byte[] getChunkSizeBytes(int size, bool final)
{
return Encoding.ASCII.GetBytes(string.Format("{0:x}\r\n{1}", size, final ? "\r\n" : ""));
}
private bool flush(bool closing)
{
if (!_response.HeadersSent)
{
if (!flushHeaders(closing))
{
if (closing)
{
_response.CloseConnection = true;
}
return false;
}
_sendChunked = _response.SendInChunks;
_writeBody = _sendChunked ? _writeChunked : _write;
}
flushBody(closing);
if (closing && _sendChunked)
{
var last = getChunkSizeBytes(0, true);
_write(last, 0, last.Length);
}
return true;
}
private void flushBody(bool closing)
{
using (_body)
{
var len = _body.Length;
if (len > int.MaxValue)
{
_body.Position = 0;
var buffLen = 1024;
var buff = new byte[buffLen];
var nread = 0;
while ((nread = _body.Read(buff, 0, buffLen)) > 0)
{
_writeBody(buff, 0, nread);
}
}
else if (len > 0)
{
_writeBody(_body.GetBuffer(), 0, (int)len);
}
}
_body = !closing ? new MemoryStream() : null;
}
private bool flushHeaders(bool closing)
{
using (var buff = new MemoryStream())
{
var headers = _response.WriteHeadersTo(buff);
var start = buff.Position;
var len = buff.Length - start;
if (len > 32768)
{
return false;
}
if (!_response.SendInChunks && _response.ContentLength64 != _body.Length)
{
return false;
}
_write(buff.GetBuffer(), (int)start, (int)len);
_response.CloseConnection = headers["Connection"] == "close";
_response.HeadersSent = true;
}
return true;
}
private void writeChunked(byte[] buffer, int offset, int count)
{
var size = getChunkSizeBytes(count, false);
_stream.Write(size, 0, size.Length);
_stream.Write(buffer, offset, count);
_stream.Write(_crlf, 0, 2);
}
private void writeChunkedWithoutThrowingException(byte[] buffer, int offset, int count)
{
try
{
writeChunked(buffer, offset, count);
}
catch
{
}
}
private void writeWithoutThrowingException(byte[] buffer, int offset, int count)
{
try
{
_stream.Write(buffer, offset, count);
}
catch
{
}
}
}
}

17
EonaCat.Network/System/Sockets/Web/Endpoints/WelcomeEndpoint.cs
View File

@ -1,17 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public class WelcomeEndpoint : WSEndpoint
{
protected override void OnMessage(MessageEventArgs e)
{
base.OnMessage(e);
Console.WriteLine($"Received message: {e.Data}");
}
}
}

60
EonaCat.Network/System/Sockets/Web/EventArgs/CloseEventArgs.cs
View File

@ -1,60 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public class CloseEventArgs : EventArgs
{
internal CloseEventArgs()
{
Payload = Payload.Empty;
}
internal CloseEventArgs(ushort code)
: this(code, null)
{
}
internal CloseEventArgs(CloseStatusCode code)
: this((ushort)code, null)
{
}
internal CloseEventArgs(Payload payload)
{
Payload = payload;
}
internal CloseEventArgs(ushort code, string reason)
{
Payload = new Payload(code, reason);
}
internal CloseEventArgs(CloseStatusCode code, string reason)
: this((ushort)code, reason)
{
}
/// <summary>
/// Code
/// </summary>
public ushort Code => Payload.Code;
/// <summary>
/// Reason
/// </summary>
public string Reason => Payload.Reason ?? string.Empty;
/// <summary>
/// Determnines if both the client and server requests where handled
/// </summary>
public bool WasClean { get; internal set; }
/// <summary>
/// Payload
/// </summary>
internal Payload Payload { get; }
}
}

25
EonaCat.Network/System/Sockets/Web/EventArgs/ErrorEventArgs.cs
View File

@ -1,25 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public class ErrorEventArgs : EventArgs
{
internal ErrorEventArgs(string message)
: this(message, null)
{
}
internal ErrorEventArgs(string message, Exception exception)
{
Message = message;
Exception = exception;
}
public Exception Exception { get; }
public string Message { get; }
}
}

72
EonaCat.Network/System/Sockets/Web/EventArgs/MessageEventArgs.cs
View File

@ -1,72 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public class MessageEventArgs : EventArgs
{
private readonly byte[] _rawData;
private string _data;
private bool _dataSet;
internal MessageEventArgs(WSFrame frame)
{
Opcode = frame.Opcode;
_rawData = frame.Payload.ApplicationData;
}
internal MessageEventArgs(OperationCode opcode, byte[] rawData)
{
if ((ulong)rawData.LongLength > Payload.MaxLength)
{
throw new WSException(CloseStatusCode.TooBig);
}
Opcode = opcode;
_rawData = rawData;
}
public string Data
{
get
{
setData();
return _data;
}
}
public bool IsBinary => Opcode == OperationCode.Binary;
public bool IsPing => Opcode == OperationCode.Ping;
public bool IsText => Opcode == OperationCode.Text;
public byte[] RawData
{
get
{
setData();
return _rawData;
}
}
internal OperationCode Opcode { get; }
private void setData()
{
if (_dataSet)
{
return;
}
if (Opcode == OperationCode.Binary)
{
_dataSet = true;
return;
}
_data = _rawData.UTF8Decode();
_dataSet = true;
}
}
}

1650
EonaCat.Network/System/Sockets/Web/Extensions.cs
View File

File diff suppressed because it is too large Load Diff

12
EonaCat.Network/System/Sockets/Web/FinalFrame.cs
View File

@ -1,12 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum FinalFrame : byte
{
More = 0x0,
Final = 0x1
}
}

12
EonaCat.Network/System/Sockets/Web/Mask.cs
View File

@ -1,12 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum Mask : byte
{
Off = 0x0,
On = 0x1
}
}

20
EonaCat.Network/System/Sockets/Web/OperationCode.cs
View File

@ -1,20 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum OperationCode : byte
{
Continue = 0x0,
Text = 0x1,
Binary = 0x2,
Close = 0x8,
Ping = 0x9,
Pong = 0xa
}
}

155
EonaCat.Network/System/Sockets/Web/Payload.cs
View File

@ -1,155 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
namespace EonaCat.Network
{
internal class Payload : IEnumerable<byte>
{
private ushort _code;
private bool _codeSet;
private readonly byte[] _data;
private readonly long _length;
private string _reason;
private bool _reasonSet;
public static readonly Payload Empty;
public static readonly ulong MaxLength;
static Payload()
{
Empty = new Payload();
MaxLength = long.MaxValue;
}
internal Payload()
{
_code = (ushort)CloseStatusCode.NoStatus;
_reason = string.Empty;
_data = WSClient.EmptyBytes;
_codeSet = true;
_reasonSet = true;
}
internal Payload(Payload original)
{
_code = original._code;
_codeSet = original._codeSet;
ExtensionDataLength = original.ExtensionDataLength;
_length = original._length;
_reason = original._reason;
_reasonSet = original._reasonSet;
_data = new byte[_length];
original._data.CopyTo(_data, 0);
}
internal Payload(byte[] data)
: this(data, data.LongLength)
{
}
internal Payload(byte[] data, long length)
{
_data = data;
_length = length;
}
internal Payload(ushort code, string reason)
{
_code = code;
_reason = reason ?? string.Empty;
_data = code.Append(reason);
_length = _data.LongLength;
_codeSet = true;
_reasonSet = true;
}
internal ushort Code
{
get
{
if (!_codeSet)
{
_code = _length > 1
? _data.SubArray(0, 2).ToUInt16(ByteOrder.Big)
: (ushort)CloseStatusCode.NoStatus;
_codeSet = true;
}
return _code;
}
}
internal long ExtensionDataLength { get; set; }
internal bool HasReservedCode => _length > 1 && Code.IsReserved();
internal string Reason
{
get
{
if (!_reasonSet)
{
_reason = _length > 2
? _data.SubArray(2, _length - 2).UTF8Decode()
: string.Empty;
_reasonSet = true;
}
return _reason;
}
}
public byte[] ApplicationData => ExtensionDataLength > 0
? _data.SubArray(ExtensionDataLength, _length - ExtensionDataLength)
: _data;
public byte[] ExtensionData => ExtensionDataLength > 0
? _data.SubArray(0, ExtensionDataLength)
: WSClient.EmptyBytes;
public ulong Length => (ulong)_length;
internal void Mask(byte[] key)
{
for (long i = 0; i < _length; i++)
{
_data[i] = (byte)(_data[i] ^ key[i % 4]);
}
}
public IEnumerator<byte> GetEnumerator()
{
foreach (var b in _data)
{
yield return b;
}
}
public byte[] ToArray()
{
return _data;
}
public override string ToString()
{
return BitConverter.ToString(_data);
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
}

12
EonaCat.Network/System/Sockets/Web/ReservedBits.cs
View File

@ -1,12 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum ReservedBits : byte
{
Off = 0x0,
On = 0x1
}
}

102
EonaCat.Network/System/Sockets/Web/Server/HttpRequestEventArgs.cs
View File

@ -1,102 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
using System.Security.Principal;
using System.Text;
namespace EonaCat.Network
{
public class HttpRequestEventArgs : EventArgs
{
private readonly HttpListenerContext _context;
private readonly string _docRootPath;
internal HttpRequestEventArgs(
HttpListenerContext context, string documentRootPath
)
{
_context = context;
_docRootPath = documentRootPath;
}
public HttpListenerRequest Request => _context.Request;
public HttpListenerResponse Response => _context.Response;
public IPrincipal User => _context.User;
public byte[] ReadFile(string path)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path.IndexOf("..") > -1)
{
throw new ArgumentException("It contains '..'.", nameof(path));
}
tryReadFile(CreateFilePath(path), out byte[] contents);
return contents;
}
public bool TryReadFile(string path, out byte[] contents)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path.IndexOf("..") > -1)
{
throw new ArgumentException("It contains '..'.", nameof(path));
}
return tryReadFile(CreateFilePath(path), out contents);
}
private static bool tryReadFile(string path, out byte[] contents)
{
contents = null;
if (!File.Exists(path))
{
return false;
}
try
{
contents = File.ReadAllBytes(path);
}
catch
{
return false;
}
return true;
}
private string CreateFilePath(string childPath)
{
childPath = childPath.TrimStart('/', '\\');
return new StringBuilder(_docRootPath, 32)
.AppendFormat("/{0}", childPath)
.ToString()
.Replace('\\', '/');
}
}
}

885
EonaCat.Network/System/Sockets/Web/Server/HttpServer.cs
View File

@ -1,885 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
using System.Security.Principal;
using System.Threading;
namespace EonaCat.Network
{
public class HttpServer
{
private bool _allowForwardedRequest;
private string _docRootPath;
private string _hostname;
private HttpListener _listener;
private Thread _receiveThread;
private volatile ServerState _state;
private object _locker;
public HttpServer()
{
init("*", System.Net.IPAddress.Any, 80, false);
}
public HttpServer(int port)
: this(port, port == 443)
{
}
public HttpServer(string url, bool forceIpV6 = false)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
if (url.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(url));
}
if (!tryCreateUri(url, out Uri uri, out string message))
{
throw new ArgumentException(message, nameof(url));
}
var host = uri.GetDnsSafeHost(true);
var addr = host.ToIPAddress(forceIpV6);
if (addr == null)
{
message = "The host part could not be converted to an IP address.";
throw new ArgumentException(message, nameof(url));
}
if (!addr.IsLocal())
{
message = "The IP address of the host is not a local IP address.";
throw new ArgumentException(message, nameof(url));
}
init(host, addr, uri.Port, uri.Scheme == "https");
}
public HttpServer(int port, bool secure)
{
if (!port.IsPortNumber())
{
var message = "Less than 1 or greater than 65535.";
throw new ArgumentOutOfRangeException(nameof(port), message);
}
init("*", System.Net.IPAddress.Any, port, secure);
}
public HttpServer(System.Net.IPAddress address, int port)
: this(address, port, port == 443)
{
}
public HttpServer(System.Net.IPAddress address, int port, bool secure)
{
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
if (!address.IsLocal())
{
throw new ArgumentException("Not a local IP address.", nameof(address));
}
if (!port.IsPortNumber())
{
var message = "Less than 1 or greater than 65535.";
throw new ArgumentOutOfRangeException(nameof(port), message);
}
init(address.ToString(true), address, port, secure);
}
public event EventHandler<HttpRequestEventArgs> OnConnect;
public event EventHandler<HttpRequestEventArgs> OnDelete;
public event EventHandler<HttpRequestEventArgs> OnGet;
public event EventHandler<HttpRequestEventArgs> OnHead;
public event EventHandler<HttpRequestEventArgs> OnOptions;
public event EventHandler<HttpRequestEventArgs> OnPatch;
public event EventHandler<HttpRequestEventArgs> OnPost;
public event EventHandler<HttpRequestEventArgs> OnPut;
public event EventHandler<HttpRequestEventArgs> OnTrace;
public System.Net.IPAddress Address { get; private set; }
/// <summary>
/// Gets or sets a value indicating whether the server accepts every
/// handshake request without checking the request URI.
/// </summary>
/// <remarks>
/// The set operation does nothing if the server has already started or
/// it is shutting down.
/// </remarks>
/// <value>
/// <para>
/// <c>true</c> if the server accepts every handshake request without
/// checking the request URI; otherwise, <c>false</c>.
/// </para>
/// <para>
/// The default value is <c>false</c>.
/// </para>
/// </value>
public bool AllowForwardedRequest
{
get { return _allowForwardedRequest; }
set { _allowForwardedRequest = value; }
}
public AuthenticationSchemes AuthenticationSchemes
{
get
{
return _listener.AuthenticationSchemes;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_listener.AuthenticationSchemes = value;
}
}
}
public string DocumentRootPath
{
get
{
return _docRootPath;
}
set
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(value));
}
value = value.TrimSlashOrBackslashFromEnd();
string full = null;
try
{
full = Path.GetFullPath(value);
}
catch (Exception ex)
{
throw new ArgumentException("An invalid path string.", nameof(value), ex);
}
if (value == "/")
{
throw new ArgumentException("An absolute root.", nameof(value));
}
if (value == "\\")
{
throw new ArgumentException("An absolute root.", nameof(value));
}
if (value.Length == 2 && value[1] == ':')
{
throw new ArgumentException("An absolute root.", nameof(value));
}
if (full == "/")
{
throw new ArgumentException("An absolute root.", nameof(value));
}
full = full.TrimSlashOrBackslashFromEnd();
if (full.Length == 2 && full[1] == ':')
{
throw new ArgumentException("An absolute root.", nameof(value));
}
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_docRootPath = value;
}
}
}
public bool IsListening => _state == ServerState.Start;
public bool IsLoggingEnabled { get; private set; }
public bool IsSecure { get; private set; }
public bool KeepClean
{
get
{
return WSEndpoints.AutoCleanSessions;
}
set
{
WSEndpoints.AutoCleanSessions = value;
}
}
public int Port { get; private set; }
public string Realm
{
get
{
return _listener.Realm;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_listener.Realm = value;
}
}
}
public bool ReuseAddress
{
get
{
return _listener.ReuseAddress;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_listener.ReuseAddress = value;
}
}
}
public SSLConfigServer SSL
{
get
{
if (!IsSecure)
{
var message = "This instance does not provide secure connections.";
throw new InvalidOperationException(message);
}
return _listener.SSL;
}
}
public Func<IIdentity, NetworkCredential> UserCredentialsFinder
{
get
{
return _listener.UserCredentialsFinder;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_listener.UserCredentialsFinder = value;
}
}
}
public TimeSpan ResponseWaitingTime
{
get
{
return WSEndpoints.ResponseWaitingTime;
}
set
{
WSEndpoints.ResponseWaitingTime = value;
}
}
public WSEndpointManager WSEndpoints { get; private set; }
public void AddWebSocketService<TEndpoint>(string path)
where TEndpoint : WSEndpoint, new()
{
WSEndpoints.AddEndpoint<TEndpoint>(path, null);
}
public void AddWebSocketService<TEndpoint>(
string path, Action<TEndpoint> initializer
)
where TEndpoint : WSEndpoint, new()
{
WSEndpoints.AddEndpoint(path, initializer);
}
public bool RemoveWebSocketService(string path)
{
return WSEndpoints.RemoveEndpoint(path);
}
public void Start()
{
if (IsSecure)
{
if (!checkCertificate(out string message))
{
throw new InvalidOperationException(message);
}
}
start();
}
public void Stop()
{
stop((ushort)CloseStatusCode.NoStatus, string.Empty);
}
public void Stop(ushort code, string reason)
{
if (!code.IsCloseStatusCode())
{
var message = "Less than 1000 or greater than 4999.";
throw new ArgumentOutOfRangeException(nameof(code), message);
}
if (code == (ushort)CloseStatusCode.MissingExtension)
{
var message = $"{(ushort)CloseStatusCode.MissingExtension} cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.IsNullOrEmpty())
{
if (code == (ushort)CloseStatusCode.NoStatus)
{
var message = $"{(ushort)CloseStatusCode.NoStatus} cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(reason));
}
if (bytes.Length > 123)
{
var message = "Its size is greater than 123 bytes.";
throw new ArgumentOutOfRangeException(nameof(reason), message);
}
}
stop(code, reason);
}
public void Stop(CloseStatusCode code, string reason)
{
if (code == CloseStatusCode.MissingExtension)
{
var message = "MandatoryExtension cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.IsNullOrEmpty())
{
if (code == CloseStatusCode.NoStatus)
{
var message = "NoStatus cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(reason));
}
if (bytes.Length > 123)
{
var message = "Its size is greater than 123 bytes.";
throw new ArgumentOutOfRangeException(nameof(reason), message);
}
}
stop((ushort)code, reason);
}
private static HttpListener createListener(
string hostname, int port, bool secure
)
{
var lsnr = new HttpListener();
var schm = secure ? "https" : "http";
var pref = string.Format("{0}://{1}:{2}/", schm, hostname, port);
lsnr.Prefixes.Add(pref);
return lsnr;
}
private static bool tryCreateUri(
string uriString, out Uri result, out string message
)
{
result = null;
message = null;
var uri = uriString.ToUri();
if (uri == null)
{
message = "An invalid URI string.";
return false;
}
if (!uri.IsAbsoluteUri)
{
message = "A relative URI.";
return false;
}
var schm = uri.Scheme;
if (!(schm == "http" || schm == "https"))
{
message = "The scheme part is not 'http' or 'https'.";
return false;
}
if (uri.PathAndQuery != "/")
{
message = "It includes either or both path and query components.";
return false;
}
if (uri.Fragment.Length > 0)
{
message = "It includes the fragment component.";
return false;
}
if (uri.Port == 0)
{
message = "The port part is zero.";
return false;
}
result = uri;
return true;
}
private void abort()
{
lock (_locker)
{
if (_state != ServerState.Start)
{
return;
}
_state = ServerState.ShuttingDown;
}
try
{
try
{
WSEndpoints.Stop((ushort)CloseStatusCode.Abnormal, string.Empty);
}
finally
{
_listener.Abort();
}
}
catch
{
}
_state = ServerState.Stop;
}
private bool canSet(out string message)
{
message = null;
if (_state == ServerState.Start)
{
message = "The server has already started.";
return false;
}
if (_state == ServerState.ShuttingDown)
{
message = "The server is shutting down.";
return false;
}
return true;
}
private bool checkCertificate(out string message)
{
message = null;
var byUser = _listener.SSL.Certificate != null;
var path = _listener.CertificateFolderPath;
var withPort = EndPointListener.CertificateExists(Port, path);
var both = byUser && withPort;
if (both)
{
Logger.Warning("A server certificate associated with the port is used.");
return true;
}
var either = byUser || withPort;
if (!either)
{
message = "There is no server certificate for secure connections.";
return false;
}
return true;
}
private void init(
string hostname, System.Net.IPAddress address, int port, bool secure
)
{
_hostname = hostname;
Address = address;
Port = port;
IsSecure = secure;
_docRootPath = "./Public";
_listener = createListener(_hostname, Port, IsSecure);
WSEndpoints = new WSEndpointManager();
_locker = new object();
}
private void processRequest(HttpListenerContext context)
{
var method = context.Request.HttpMethod;
var evt = method == "GET"
? OnGet
: method == "HEAD"
? OnHead
: method == "POST"
? OnPost
: method == "PUT"
? OnPut
: method == "DELETE"
? OnDelete
: method == "OPTIONS"
? OnOptions
: method == "TRACE"
? OnTrace
: method == "CONNECT"
? OnConnect
: method == "PATCH"
? OnPatch
: null;
if (evt != null)
{
evt(this, new HttpRequestEventArgs(context, _docRootPath));
}
else
{
context.Response.StatusCode = 501; // Not Implemented
}
context.Response.Close();
}
private void processRequest(HttpListenerWSContext context)
{
var path = context.RequestUri.AbsolutePath;
if (!WSEndpoints.InternalTryGetEndpointHost(path, out WSEndpointHost host))
{
context.Close(HttpStatusCode.NotImplemented);
return;
}
host.StartSession(context);
}
private void receiveRequest()
{
while (true)
{
HttpListenerContext context = null;
try
{
context = _listener.GetContext();
ThreadPool.QueueUserWorkItem(
state =>
{
try
{
if (context.Request.IsUpgradeTo("websocket"))
{
processRequest(context.AcceptWebSocket(null));
return;
}
processRequest(context);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
context.Connection.Close(true);
}
}
);
}
catch (HttpListenerException)
{
Logger.Info("The underlying listener is stopped.");
break;
}
catch (InvalidOperationException)
{
Logger.Info("The underlying listener is stopped.");
break;
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
context?.Connection.Close(true);
break;
}
}
if (_state != ServerState.ShuttingDown)
{
abort();
}
}
private void start()
{
if (_state == ServerState.Start)
{
Logger.Info("The server has already started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Warning("The server is shutting down.");
return;
}
lock (_locker)
{
if (_state == ServerState.Start)
{
Logger.Info("The server has already started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Warning("The server is shutting down.");
return;
}
WSEndpoints.Start();
try
{
startReceiving();
}
catch
{
WSEndpoints.Stop((ushort)CloseStatusCode.ServerError, string.Empty);
throw;
}
_state = ServerState.Start;
}
}
private void startReceiving()
{
try
{
_listener.Start();
}
catch (Exception exception)
{
var message = "The underlying listener has failed to start.";
throw new InvalidOperationException(message, exception);
}
_receiveThread = new Thread(new ThreadStart(receiveRequest));
_receiveThread.IsBackground = true;
_receiveThread.Start();
}
private void stop(ushort code, string reason)
{
if (_state == ServerState.Started)
{
Logger.Info("The server is not started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
Logger.Info("The server has already stopped.");
return;
}
lock (_locker)
{
if (_state == ServerState.ShuttingDown)
{
Logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
Logger.Info("The server has already stopped.");
return;
}
_state = ServerState.ShuttingDown;
}
try
{
var threw = false;
try
{
WSEndpoints.Stop(code, reason);
}
catch
{
threw = true;
throw;
}
finally
{
try
{
stopReceiving(5000);
}
catch
{
if (!threw)
{
throw;
}
}
}
}
finally
{
_state = ServerState.Stop;
}
}
private void stopReceiving(int millisecondsTimeout)
{
_listener.Stop();
_receiveThread.Join(millisecondsTimeout);
}
}
}

20
EonaCat.Network/System/Sockets/Web/Server/IWSSession.cs
View File

@ -1,20 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public interface IWSSession
{
WSContext Context { get; }
string ID { get; }
string Protocol { get; }
DateTime StartTime { get; }
WSState State { get; }
}
}

13
EonaCat.Network/System/Sockets/Web/Server/ServerState.cs
View File

@ -1,13 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
internal enum ServerState
{
Started,
Start,
ShuttingDown,
Stop
}
}

209
EonaCat.Network/System/Sockets/Web/Server/WSEndpoint.cs
View File

@ -1,209 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.IO;
namespace EonaCat.Network
{
public abstract class WSEndpoint : IWSSession
{
private bool _emitOnPing;
private string _protocol;
private WSClient _websocket;
protected WSEndpoint()
{
StartTime = DateTime.MaxValue;
}
public WSContext Context { get; private set; }
public Func<CookieCollection, CookieCollection, bool> CookiesValidator { get; set; }
public bool EmitOnPing
{
get
{
return _websocket != null ? _websocket.CallMessageOnPing : _emitOnPing;
}
set
{
if (_websocket != null)
{
_websocket.CallMessageOnPing = value;
return;
}
_emitOnPing = value;
}
}
public string ID { get; private set; }
public bool IgnoreExtensions { get; set; }
public Func<string, bool> OriginValidator { get; set; }
public string Protocol
{
get
{
return _websocket != null ? _websocket.Protocol : (_protocol ?? string.Empty);
}
set
{
if (State != WSState.Connecting)
{
return;
}
if (value != null && (value.Length == 0 || !value.IsToken()))
{
return;
}
_protocol = value;
}
}
public DateTime StartTime { get; private set; }
public WSState State => _websocket != null ? _websocket.ReadyState : WSState.Connecting;
protected WSSessionManager Sessions { get; private set; }
internal void Start(WSContext context, WSSessionManager sessions)
{
if (_websocket != null)
{
Logger.Error("A session instance cannot be reused.");
context.WebSocket.Close(HttpStatusCode.ServiceUnavailable);
return;
}
Context = context;
Sessions = sessions;
_websocket = context.WebSocket;
_websocket.CustomHandshakeRequestChecker = checkHandshakeRequest;
_websocket.CallMessageOnPing = _emitOnPing;
_websocket.IgnoreExtensions = IgnoreExtensions;
_websocket.Protocol = _protocol;
var responseWaitingTime = sessions.ResponseWaitingTime;
if (responseWaitingTime != _websocket.ResponseWaitingTime)
{
_websocket.ResponseWaitingTime = responseWaitingTime;
}
_websocket.OnConnect += onOpen;
_websocket.OnMessageReceived += onMessage;
_websocket.OnError += onError;
_websocket.OnDisconnect += onClose;
_websocket.InternalAccept();
}
protected void Error(string message, Exception exception)
{
if (message != null && message.Length > 0)
{
OnError(new ErrorEventArgs(message, exception));
}
}
protected virtual void OnClose(CloseEventArgs e)
{
}
protected virtual void OnError(ErrorEventArgs e)
{
}
protected virtual void OnMessage(MessageEventArgs e)
{
}
protected virtual void OnOpen()
{
}
protected void Send(byte[] data)
{
_websocket?.Send(data);
}
protected void Send(FileInfo file)
{
_websocket?.Send(file);
}
protected void Send(string data)
{
_websocket?.Send(data);
}
protected void SendAsync(byte[] data, Action<bool> completed)
{
_websocket?.SendAsync(data, completed);
}
protected void SendAsync(FileInfo file, Action<bool> completed)
{
_websocket?.SendAsync(file, completed);
}
protected void SendAsync(string data, Action<bool> completed)
{
_websocket?.SendAsync(data, completed);
}
protected void SendAsync(Stream stream, int length, Action<bool> completed)
{
_websocket?.SendAsync(stream, length, completed);
}
private string checkHandshakeRequest(WSContext context)
{
return OriginValidator != null && !OriginValidator(context.Origin)
? "Includes no Origin header, or it has an invalid value."
: CookiesValidator != null
&& !CookiesValidator(context.CookieCollection, context.WebSocket.CookieCollection)
? "Includes no cookie, or an invalid cookie exists."
: null;
}
private void onClose(object sender, CloseEventArgs e)
{
if (ID == null)
{
return;
}
Sessions.Remove(ID);
OnClose(e);
}
private void onError(object sender, ErrorEventArgs e)
{
OnError(e);
}
private void onMessage(object sender, MessageEventArgs e)
{
OnMessage(e);
}
private void onOpen(object sender, EventArgs e)
{
ID = Sessions.Add(this);
if (ID == null)
{
_websocket.Close(CloseStatusCode.Away);
return;
}
StartTime = DateTime.Now;
OnOpen();
}
}
}

66
EonaCat.Network/System/Sockets/Web/Server/WSEndpointHost.cs
View File

@ -1,66 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public abstract class WSEndpointHost
{
protected WSEndpointHost(string path)
{
Path = path;
Sessions = new WSSessionManager();
}
public abstract Type EndpointType { get; }
public bool AutoCleanSessions
{
get
{
return Sessions.KeepClean;
}
set
{
Sessions.KeepClean = value;
}
}
public string Path { get; }
public WSSessionManager Sessions { get; }
public TimeSpan ResponseWaitingTime
{
get
{
return Sessions.ResponseWaitingTime;
}
set
{
Sessions.ResponseWaitingTime = value;
}
}
internal ServerState State => Sessions.State;
internal void Start()
{
Sessions.Start();
}
internal void StartSession(WSContext context)
{
CreateSession().Start(context, Sessions);
}
internal void Stop(ushort code, string reason)
{
Sessions.Stop(code, reason);
}
protected abstract WSEndpoint CreateSession();
}
}

467
EonaCat.Network/System/Sockets/Web/Server/WSEndpointManager.cs
View File

@ -1,467 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
namespace EonaCat.Network
{
public class WSEndpointManager
{
private readonly Dictionary<string, WSEndpointHost> _hosts;
private readonly object _locker;
private volatile bool _clean;
private volatile ServerState _state;
private TimeSpan _responseWaitingTime;
internal WSEndpointManager()
{
_clean = true;
_hosts = new Dictionary<string, WSEndpointHost>();
_state = ServerState.Started;
_locker = ((ICollection)_hosts).SyncRoot;
_responseWaitingTime = TimeSpan.FromSeconds(1);
}
public bool AutoCleanSessions
{
get
{
return _clean;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
foreach (var host in _hosts.Values)
{
host.AutoCleanSessions = value;
}
_clean = value;
}
}
}
public int Count
{
get
{
lock (_locker)
{
return _hosts.Count;
}
}
}
public IEnumerable<WSEndpointHost> Hosts
{
get
{
lock (_locker)
{
return _hosts.Values.ToList();
}
}
}
public IEnumerable<string> Paths
{
get
{
lock (_locker)
{
return _hosts.Keys.ToList();
}
}
}
public TimeSpan ResponseWaitingTime
{
get
{
return _responseWaitingTime;
}
set
{
if (value <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(value), "Zero or less.");
}
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
foreach (var host in _hosts.Values)
{
host.ResponseWaitingTime = value;
}
_responseWaitingTime = value;
}
}
}
public WSEndpointHost this[string path]
{
get
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path[0] != '/')
{
throw new ArgumentException("Not an absolute path.", nameof(path));
}
if (path.IndexOfAny(new[] { '?', '#' }) > -1)
{
var message = "It includes either or both query and fragment components.";
throw new ArgumentException(message, nameof(path));
}
InternalTryGetEndpointHost(path, out WSEndpointHost host);
return host;
}
}
public void AddEndpoint<TEndpoint>(
string path, Action<TEndpoint> initializer
)
where TEndpoint : WSEndpoint, new()
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path[0] != '/')
{
throw new ArgumentException("Not an absolute path.", nameof(path));
}
if (path.IndexOfAny(new[] { '?', '#' }) > -1)
{
var message = "It includes either or both query and fragment components.";
throw new ArgumentException(message, nameof(path));
}
path = HttpUtility.UrlDecode(path).TrimSlashFromEnd();
lock (_locker)
{
if (_hosts.TryGetValue(path, out WSEndpointHost host))
{
throw new ArgumentException("Already in use.", nameof(path));
}
host = new WebSocketEndpointHost<TEndpoint>(
path, () => new TEndpoint(), initializer
);
if (!_clean)
{
host.AutoCleanSessions = false;
}
if (_responseWaitingTime != host.ResponseWaitingTime)
{
host.ResponseWaitingTime = _responseWaitingTime;
}
if (_state == ServerState.Start)
{
host.Start();
}
_hosts.Add(path, host);
}
}
public void Clear()
{
List<WSEndpointHost> hosts = null;
lock (_locker)
{
hosts = _hosts.Values.ToList();
_hosts.Clear();
}
foreach (var host in hosts)
{
if (host.State == ServerState.Start)
{
host.Stop((ushort)CloseStatusCode.Away, string.Empty);
}
}
}
public bool RemoveEndpoint(string path)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path[0] != '/')
{
throw new ArgumentException("Not an absolute path.", nameof(path));
}
if (path.IndexOfAny(new[] { '?', '#' }) > -1)
{
var message = "It includes either or both query and fragment components.";
throw new ArgumentException(message, nameof(path));
}
path = HttpUtility.UrlDecode(path).TrimSlashFromEnd();
WSEndpointHost host;
lock (_locker)
{
if (!_hosts.TryGetValue(path, out host))
{
return false;
}
_hosts.Remove(path);
}
if (host.State == ServerState.Start)
{
host.Stop((ushort)CloseStatusCode.Away, string.Empty);
}
return true;
}
public bool TryGetEndpointHost(string path, out WSEndpointHost host)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (path.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(path));
}
if (path[0] != '/')
{
throw new ArgumentException("Not an absolute path.", nameof(path));
}
if (path.IndexOfAny(new[] { '?', '#' }) > -1)
{
var message = "It includes either or both query and fragment components.";
throw new ArgumentException(message, nameof(path));
}
return InternalTryGetEndpointHost(path, out host);
}
internal void Add<TEndpoint>(string path, Func<TEndpoint> creator)
where TEndpoint : WSEndpoint
{
path = HttpUtility.UrlDecode(path).TrimSlashFromEnd();
lock (_locker)
{
if (_hosts.TryGetValue(path, out WSEndpointHost host))
{
throw new ArgumentException("Already in use.", nameof(path));
}
host = new WebSocketEndpointHost<TEndpoint>(
path, creator, null
);
if (!_clean)
{
host.AutoCleanSessions = false;
}
if (_responseWaitingTime != host.ResponseWaitingTime)
{
host.ResponseWaitingTime = _responseWaitingTime;
}
if (_state == ServerState.Start)
{
host.Start();
}
_hosts.Add(path, host);
}
}
internal bool InternalTryGetEndpointHost(
string path, out WSEndpointHost host
)
{
path = HttpUtility.UrlDecode(path).TrimSlashFromEnd();
lock (_locker)
{
return _hosts.TryGetValue(path, out host);
}
}
internal void Start()
{
lock (_locker)
{
foreach (var host in _hosts.Values)
{
host.Start();
}
_state = ServerState.Start;
}
}
internal void Stop(ushort code, string reason)
{
lock (_locker)
{
_state = ServerState.ShuttingDown;
foreach (var host in _hosts.Values)
{
host.Stop(code, reason);
}
_state = ServerState.Stop;
}
}
private void broadcast(OperationCode opcode, byte[] data, Action completed)
{
var cache = new Dictionary<CompressionMethod, byte[]>();
try
{
foreach (var host in Hosts)
{
if (_state != ServerState.Start)
{
Logger.Error("The server is shutting down.");
break;
}
host.Sessions.Broadcast(opcode, data, cache);
}
completed?.Invoke();
}
catch (Exception ex)
{
Logger.Error(ex, "Could not broadcast");
}
finally
{
cache.Clear();
}
}
private void broadcast(OperationCode opcode, Stream stream, Action completed)
{
var cache = new Dictionary<CompressionMethod, Stream>();
try
{
foreach (var host in Hosts)
{
if (_state != ServerState.Start)
{
Logger.Error("The server is shutting down.");
break;
}
host.Sessions.Broadcast(opcode, stream, cache);
}
completed?.Invoke();
}
catch (Exception ex)
{
Logger.Error(ex, "Could not broadcast");
}
finally
{
foreach (var cached in cache.Values)
{
cached.Dispose();
}
cache.Clear();
}
}
private bool canSet(out string message)
{
message = null;
if (_state == ServerState.Start)
{
message = "The server has already started.";
return false;
}
if (_state == ServerState.ShuttingDown)
{
message = "The server is shutting down.";
return false;
}
return true;
}
}
}

786
EonaCat.Network/System/Sockets/Web/Server/WSServer.cs
View File

@ -1,786 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Net.Sockets;
using System.Security.Principal;
using System.Threading;
namespace EonaCat.Network
{
public class WSServer
{
private static readonly string _defaultRealm = "EonaCat Network - Area51";
private bool _allowForwardedRequest;
private AuthenticationSchemes _authSchemes;
private bool _dnsStyle;
private string _hostname;
private TcpListener _listener;
private string _realm;
private string _realmInUse;
private Thread _receiveThread;
private bool _reuseAddress;
private SSLConfigServer _sslConfig;
private SSLConfigServer _sslConfigInUse;
private volatile ServerState _state;
private object _locker;
private Func<IIdentity, NetworkCredential> _userCredentialsFinder;
public WSServer()
{
var address = System.Net.IPAddress.Any;
init(address.ToString(), address, 80, false);
}
public WSServer(int port)
: this(port, port == 443)
{
}
public WSServer(string url, bool forceIpV6 = false)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
if (url.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(url));
}
if (!tryCreateUri(url, out Uri uri, out string message))
{
throw new ArgumentException(message, nameof(url));
}
var host = uri.DnsSafeHost;
var addr = host.ToIPAddress(forceIpV6);
if (addr == null)
{
message = "The host part could not be converted to an IP address.";
throw new ArgumentException(message, nameof(url));
}
if (!addr.IsLocal())
{
message = "The IP address of the host is not a local IP address.";
throw new ArgumentException(message, nameof(url));
}
init(host, addr, uri.Port, uri.Scheme == "wss");
}
public WSServer(int port, bool secure)
{
if (!port.IsPortNumber())
{
var message = "Less than 1 or greater than 65535.";
throw new ArgumentOutOfRangeException(nameof(port), message);
}
var addr = System.Net.IPAddress.Any;
init(addr.ToString(), addr, port, secure);
}
public WSServer(System.Net.IPAddress address, int port)
: this(address, port, port == 443)
{
}
public WSServer(System.Net.IPAddress address, int port, bool secure)
{
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
if (!address.IsLocal())
{
throw new ArgumentException("Not a local IP address.", nameof(address));
}
if (!port.IsPortNumber())
{
var message = "Less than 1 or greater than 65535.";
throw new ArgumentOutOfRangeException(nameof(port), message);
}
init(address.ToString(), address, port, secure);
}
public System.Net.IPAddress Address { get; private set; }
public bool AllowForwardedRequest
{
get
{
return _allowForwardedRequest;
}
set
{
if (!CanSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!CanSet(out message))
{
Logger.Warning(message);
return;
}
_allowForwardedRequest = value;
}
}
}
public AuthenticationSchemes AuthenticationSchemes
{
get
{
return _authSchemes;
}
set
{
if (!CanSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!CanSet(out message))
{
Logger.Warning(message);
return;
}
_authSchemes = value;
}
}
}
/// <summary>
/// Determines if sessions need to be removed automatically
/// </summary>
public bool AutoCleanSessions
{
get
{
return Endpoints.AutoCleanSessions;
}
set
{
Endpoints.AutoCleanSessions = value;
}
}
public WSEndpointManager Endpoints { get; private set; }
public Func<IIdentity, NetworkCredential> FindCredentials
{
get
{
return _userCredentialsFinder;
}
set
{
if (!CanSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!CanSet(out message))
{
Logger.Warning(message);
return;
}
_userCredentialsFinder = value;
}
}
}
public bool IsConsoleLoggingEnabled { get; set; }
public bool IsListening => _state == ServerState.Start;
public bool IsLoggingEnabled { get; set; }
public bool IsSecure { get; private set; }
public int Port { get; private set; }
public string Realm
{
get
{
return _realm;
}
set
{
if (!CanSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!CanSet(out message))
{
Logger.Warning(message);
return;
}
_realm = value;
}
}
}
public bool ReuseAddress
{
get
{
return _reuseAddress;
}
set
{
if (!CanSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!CanSet(out message))
{
Logger.Warning(message);
return;
}
_reuseAddress = value;
}
}
}
public SSLConfigServer SSL
{
get
{
if (!IsSecure)
{
var message = "This instance does not provide secure connections.";
throw new InvalidOperationException(message);
}
return GetSSLConfig();
}
}
public TimeSpan ResponseWaitingTime
{
get
{
return Endpoints.ResponseWaitingTime;
}
set
{
Endpoints.ResponseWaitingTime = value;
}
}
public void AddEndpoint<TEndpoint>(string path) where TEndpoint : WSEndpoint, new()
{
Endpoints.AddEndpoint<TEndpoint>(path, null);
}
public void AddEndpoint<TEndpoint>(string path, Action<TEndpoint> initializer) where TEndpoint : WSEndpoint, new()
{
Endpoints.AddEndpoint(path, initializer);
}
public bool RemoveEndpoint(string path)
{
return Endpoints.RemoveEndpoint(path);
}
public void Start()
{
SSLConfigServer sslConfig = null;
if (IsSecure)
{
sslConfig = new SSLConfigServer(GetSSLConfig());
if (!CheckSslConfig(sslConfig, out string message))
{
throw new InvalidOperationException(message);
}
}
start(sslConfig);
}
public void Stop()
{
stop((ushort)CloseStatusCode.NoStatus, string.Empty);
}
public void Stop(ushort code, string reason)
{
if (!code.IsCloseStatusCode())
{
var message = "Less than 1000 or greater than 4999.";
throw new ArgumentOutOfRangeException(nameof(code), message);
}
if (code == (ushort)CloseStatusCode.MissingExtension)
{
var message = $"{(ushort)CloseStatusCode.MissingExtension} cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.IsNullOrEmpty())
{
if (code == (ushort)CloseStatusCode.NoStatus)
{
var message = $"{(ushort)CloseStatusCode.NoStatus} cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(reason));
}
if (bytes.Length > 123)
{
var message = "Its size is greater than 123 bytes.";
throw new ArgumentOutOfRangeException(nameof(reason), message);
}
}
stop(code, reason);
}
public void Stop(CloseStatusCode code, string reason)
{
if (code == CloseStatusCode.MissingExtension)
{
var message = "MandatoryExtension cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.IsNullOrEmpty())
{
if (code == CloseStatusCode.NoStatus)
{
var message = "NoStatus cannot be used.";
throw new ArgumentException(message, nameof(code));
}
if (!reason.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(reason));
}
if (bytes.Length > 123)
{
var message = "Its size is greater than 123 bytes.";
throw new ArgumentOutOfRangeException(nameof(reason), message);
}
}
stop((ushort)code, reason);
}
private static bool CheckSslConfig(SSLConfigServer sslConfig, out string message
)
{
message = null;
if (sslConfig.Certificate == null)
{
message = "There is no server certificate for secure connections.";
return false;
}
return true;
}
private static bool tryCreateUri(
string uriString, out Uri result, out string message
)
{
if (!uriString.TryCreateWebSocketUri(out result, out message))
{
return false;
}
if (result.PathAndQuery != "/")
{
result = null;
message = "It includes either or both path and query components.";
return false;
}
return true;
}
private void abort()
{
lock (_locker)
{
if (_state != ServerState.Start)
{
return;
}
_state = ServerState.ShuttingDown;
}
try
{
try
{
_listener.Stop();
}
finally
{
Endpoints.Stop((ushort)CloseStatusCode.Abnormal, string.Empty);
}
}
catch
{
}
_state = ServerState.Stop;
}
private bool CanSet(out string message)
{
message = null;
if (_state == ServerState.Start)
{
message = "The server has already started.";
return false;
}
if (_state == ServerState.ShuttingDown)
{
message = "The server is shutting down.";
return false;
}
return true;
}
private bool CheckHostNameForRequest(string name)
{
return !_dnsStyle
|| Uri.CheckHostName(name) != UriHostNameType.Dns
|| name == _hostname;
}
private string GetRealm()
{
var realm = _realm;
return realm != null && realm.Length > 0 ? realm : _defaultRealm;
}
private SSLConfigServer GetSSLConfig()
{
_sslConfig ??= new SSLConfigServer();
return _sslConfig;
}
private void init(
string hostname, System.Net.IPAddress address, int port, bool secure
)
{
_hostname = hostname;
Address = address;
Port = port;
IsSecure = secure;
_authSchemes = AuthenticationSchemes.Anonymous;
_dnsStyle = Uri.CheckHostName(hostname) == UriHostNameType.Dns;
_listener = new TcpListener(address, port);
Endpoints = new WSEndpointManager();
_locker = new object();
}
private void processRequest(TcpListenerWSContext context)
{
var uri = context.RequestUri;
if (uri == null)
{
context.Close(HttpStatusCode.BadRequest);
return;
}
if (!_allowForwardedRequest)
{
if (uri.Port != Port)
{
context.Close(HttpStatusCode.BadRequest);
return;
}
if (!CheckHostNameForRequest(uri.DnsSafeHost))
{
context.Close(HttpStatusCode.NotFound);
return;
}
}
if (!Endpoints.InternalTryGetEndpointHost(uri.AbsolutePath, out WSEndpointHost host))
{
context.Close(HttpStatusCode.NotImplemented);
return;
}
host.StartSession(context);
}
private void receiveRequest()
{
while (true)
{
TcpClient cl = null;
try
{
cl = _listener.AcceptTcpClient();
ThreadPool.QueueUserWorkItem(
state =>
{
try
{
var context = new TcpListenerWSContext(
cl, null, IsSecure, _sslConfigInUse);
if (!context.Authenticate(_authSchemes, _realmInUse, _userCredentialsFinder))
{
return;
}
processRequest(context);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
cl.Close();
}
}
);
}
catch (SocketException ex)
{
if (_state == ServerState.ShuttingDown)
{
Logger.Info("The underlying listener is stopped.");
break;
}
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
break;
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
cl?.Close();
break;
}
}
if (_state != ServerState.ShuttingDown)
{
abort();
}
}
private void start(SSLConfigServer sslConfig)
{
Logger.IsLoggingEnabled = IsLoggingEnabled;
Logger.DisableConsole = !IsConsoleLoggingEnabled;
if (_state == ServerState.Start)
{
Logger.Info("The server has already started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Warning("The server is shutting down.");
return;
}
lock (_locker)
{
if (_state == ServerState.Start)
{
Logger.Info("The server has already started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Warning("The server is shutting down.");
return;
}
_sslConfigInUse = sslConfig;
_realmInUse = GetRealm();
Endpoints.Start();
try
{
startReceiving();
}
catch
{
Endpoints.Stop((ushort)CloseStatusCode.ServerError, string.Empty);
throw;
}
_state = ServerState.Start;
}
}
private void startReceiving()
{
if (_reuseAddress)
{
_listener.Server.SetSocketOption(
SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true
);
}
try
{
_listener.Start();
}
catch (Exception ex)
{
var message = "The underlying listener has failed to start.";
throw new InvalidOperationException(message, ex);
}
_receiveThread = new Thread(new ThreadStart(receiveRequest));
_receiveThread.IsBackground = true;
_receiveThread.Start();
}
private void stop(ushort code, string reason)
{
if (_state == ServerState.Started)
{
Logger.Info("The server is not started.");
return;
}
if (_state == ServerState.ShuttingDown)
{
Logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
Logger.Info("The server has already stopped.");
return;
}
lock (_locker)
{
if (_state == ServerState.ShuttingDown)
{
Logger.Info("The server is shutting down.");
return;
}
if (_state == ServerState.Stop)
{
Logger.Info("The server has already stopped.");
return;
}
_state = ServerState.ShuttingDown;
}
try
{
var threw = false;
try
{
stopReceiving(5000);
}
catch
{
threw = true;
throw;
}
finally
{
try
{
Endpoints.Stop(code, reason);
}
catch
{
if (!threw)
{
throw;
}
}
}
}
finally
{
_state = ServerState.Stop;
}
}
private void stopReceiving(int millisecondsTimeout)
{
try
{
_listener.Stop();
}
catch (Exception ex)
{
var message = "The underlying listener has failed to stop.";
throw new InvalidOperationException(message, ex);
}
_receiveThread.Join(millisecondsTimeout);
}
}
}

871
EonaCat.Network/System/Sockets/Web/Server/WSSessionManager.cs
View File

@ -1,871 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
namespace EonaCat.Network
{
public class WSSessionManager
{
private const int _cleanupIntervalInMiliSeconds = 60000;
private readonly object _cleanLocker;
private readonly Dictionary<string, IWSSession> _sessions;
private readonly object _locker;
private volatile bool _clean;
private volatile ServerState _state;
private volatile bool _sweeping;
private System.Timers.Timer _sweepTimer;
private TimeSpan _responseWaitingTime;
internal WSSessionManager()
{
_clean = true;
_cleanLocker = new object();
_sessions = new Dictionary<string, IWSSession>();
_state = ServerState.Started;
_locker = ((ICollection)_sessions).SyncRoot;
_responseWaitingTime = TimeSpan.FromSeconds(1);
setCleanupTimer(_cleanupIntervalInMiliSeconds);
}
public IEnumerable<string> ActiveIDs
{
get
{
foreach (var res in broadping(WSFrame.EmptyPingBytes))
{
if (res.Value)
{
yield return res.Key;
}
}
}
}
public int Count
{
get
{
lock (_locker)
{
return _sessions.Count;
}
}
}
public IEnumerable<string> IDs
{
get
{
if (_state != ServerState.Start)
{
return Enumerable.Empty<string>();
}
lock (_locker)
{
if (_state != ServerState.Start)
{
return Enumerable.Empty<string>();
}
return _sessions.Keys.ToList();
}
}
}
public IEnumerable<string> InactiveIDs
{
get
{
foreach (var res in broadping(WSFrame.EmptyPingBytes))
{
if (!res.Value)
{
yield return res.Key;
}
}
}
}
public bool KeepClean
{
get
{
return _clean;
}
set
{
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_clean = value;
}
}
}
public IEnumerable<IWSSession> Sessions
{
get
{
if (_state != ServerState.Start)
{
return Enumerable.Empty<IWSSession>();
}
lock (_locker)
{
if (_state != ServerState.Start)
{
return Enumerable.Empty<IWSSession>();
}
return _sessions.Values.ToList();
}
}
}
internal TimeSpan ResponseWaitingTime
{
get
{
return _responseWaitingTime;
}
set
{
if (value <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(value), "Zero or less.");
}
if (!canSet(out string message))
{
Logger.Warning(message);
return;
}
lock (_locker)
{
if (!canSet(out message))
{
Logger.Warning(message);
return;
}
_responseWaitingTime = value;
}
}
}
internal ServerState State => _state;
public IWSSession this[string id]
{
get
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (id.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(id));
}
tryGetSession(id, out IWSSession session);
return session;
}
}
public void Broadcast(byte[] data)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (data.LongLength <= WSClient.FragmentLength)
{
broadcast(OperationCode.Binary, data, null);
}
else
{
broadcast(OperationCode.Binary, new MemoryStream(data), null);
}
}
public void Broadcast(string data)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (!data.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(data));
}
if (bytes.LongLength <= WSClient.FragmentLength)
{
broadcast(OperationCode.Text, bytes, null);
}
else
{
broadcast(OperationCode.Text, new MemoryStream(bytes), null);
}
}
public void Broadcast(Stream stream, int length)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanRead)
{
var message = "It cannot be read.";
throw new ArgumentException(message, nameof(stream));
}
if (length < 1)
{
var message = "Less than 1.";
throw new ArgumentException(message, nameof(length));
}
var bytes = stream.ReadBytes(length);
var len = bytes.Length;
if (len == 0)
{
var message = "No data could be read from it.";
throw new ArgumentException(message, nameof(stream));
}
if (len < length)
{
Logger.Warning(
string.Format(
"Only {0} byte(s) of data could be read from the stream.",
len
)
);
}
if (len <= WSClient.FragmentLength)
{
broadcast(OperationCode.Binary, bytes, null);
}
else
{
broadcast(OperationCode.Binary, new MemoryStream(bytes), null);
}
}
public void BroadcastAsync(byte[] data, Action completed)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (data.LongLength <= WSClient.FragmentLength)
{
broadcastAsync(OperationCode.Binary, data, completed);
}
else
{
broadcastAsync(OperationCode.Binary, new MemoryStream(data), completed);
}
}
public void BroadcastAsync(string data, Action completed)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (!data.TryGetUTF8EncodedBytes(out byte[] bytes))
{
var message = "It could not be UTF-8-encoded.";
throw new ArgumentException(message, nameof(data));
}
if (bytes.LongLength <= WSClient.FragmentLength)
{
broadcastAsync(OperationCode.Text, bytes, completed);
}
else
{
broadcastAsync(OperationCode.Text, new MemoryStream(bytes), completed);
}
}
public void BroadcastAsync(Stream stream, int length, Action completed)
{
if (_state != ServerState.Start)
{
var message = "The current state of the manager is not Start.";
throw new InvalidOperationException(message);
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanRead)
{
var message = "It cannot be read.";
throw new ArgumentException(message, nameof(stream));
}
if (length < 1)
{
var message = "Less than 1.";
throw new ArgumentException(message, nameof(length));
}
var bytes = stream.ReadBytes(length);
var len = bytes.Length;
if (len == 0)
{
var message = "No data could be read from it.";
throw new ArgumentException(message, nameof(stream));
}
if (len < length)
{
Logger.Warning(
string.Format(
"Only {0} byte(s) of data could be read from the stream.",
len
)
);
}
if (len <= WSClient.FragmentLength)
{
broadcastAsync(OperationCode.Binary, bytes, completed);
}
else
{
broadcastAsync(OperationCode.Binary, new MemoryStream(bytes), completed);
}
}
public void CloseSession(string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Close();
}
public void CloseSession(string id, ushort code, string reason)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Close(code, reason);
}
public void CloseSession(string id, CloseStatusCode code, string reason)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Close(code, reason);
}
public bool PingTo(string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
return session.Context.WebSocket.Ping();
}
public bool PingTo(string message, string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var pingMessage = "The session could not be found.";
throw new InvalidOperationException(pingMessage);
}
return session.Context.WebSocket.Ping(message);
}
public void SendTo(byte[] data, string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Send(data);
}
public void SendTo(string data, string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Send(data);
}
public void SendTo(Stream stream, int length, string id)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.Send(stream, length);
}
public void SendToAsync(byte[] data, string id, Action<bool> completed)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.SendAsync(data, completed);
}
public void SendToAsync(string data, string id, Action<bool> completed)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.SendAsync(data, completed);
}
public void SendToAsync(
Stream stream, int length, string id, Action<bool> completed
)
{
if (!TryGetSession(id, out IWSSession session))
{
var message = "The session could not be found.";
throw new InvalidOperationException(message);
}
session.Context.WebSocket.SendAsync(stream, length, completed);
}
public void Sweep()
{
if (_sweeping)
{
Logger.Info("The sweeping is already in progress.");
return;
}
lock (_cleanLocker)
{
if (_sweeping)
{
Logger.Info("The sweeping is already in progress.");
return;
}
_sweeping = true;
}
foreach (var id in InactiveIDs)
{
if (_state != ServerState.Start)
{
break;
}
lock (_locker)
{
if (_state != ServerState.Start)
{
break;
}
if (_sessions.TryGetValue(id, out IWSSession session))
{
var state = session.State;
if (state == WSState.Open)
{
session.Context.WebSocket.Close(CloseStatusCode.Abnormal);
}
else if (state == WSState.Closing)
{
continue;
}
else
{
_sessions.Remove(id);
}
}
}
}
_sweeping = false;
}
public bool TryGetSession(string id, out IWSSession session)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (id.Length == 0)
{
throw new ArgumentException("An empty string.", nameof(id));
}
return tryGetSession(id, out session);
}
internal string Add(IWSSession session)
{
lock (_locker)
{
if (_state != ServerState.Start)
{
return null;
}
var id = createID();
_sessions.Add(id, session);
return id;
}
}
internal void Broadcast(
OperationCode opcode, byte[] data, Dictionary<CompressionMethod, byte[]> cache
)
{
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
session.Context.WebSocket.Send(opcode, data, cache);
}
}
internal void Broadcast(
OperationCode opcode, Stream stream, Dictionary<CompressionMethod, Stream> cache
)
{
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
session.Context.WebSocket.Send(opcode, stream, cache);
}
}
internal Dictionary<string, bool> Broadping(
byte[] frameAsBytes, TimeSpan timeout
)
{
var ret = new Dictionary<string, bool>();
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
var res = session.Context.WebSocket.Ping(frameAsBytes, timeout);
ret.Add(session.ID, res);
}
return ret;
}
internal bool Remove(string id)
{
lock (_locker)
{
return _sessions.Remove(id);
}
}
internal void Start()
{
lock (_locker)
{
_sweepTimer.Enabled = _clean;
_state = ServerState.Start;
}
}
internal void Stop(ushort code, string reason)
{
if (code == (ushort)CloseStatusCode.NoStatus)
{ // == no status
stop(Payload.Empty, true);
return;
}
stop(new Payload(code, reason), !code.IsReserved());
}
private static string createID()
{
return Guid.NewGuid().ToString("N");
}
private void broadcast(OperationCode opcode, byte[] data, Action completed)
{
var cache = new Dictionary<CompressionMethod, byte[]>();
try
{
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
session.Context.WebSocket.Send(opcode, data, cache);
}
completed?.Invoke();
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
}
finally
{
cache.Clear();
}
}
private void broadcast(OperationCode opcode, Stream stream, Action completed)
{
var cache = new Dictionary<CompressionMethod, Stream>();
try
{
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
session.Context.WebSocket.Send(opcode, stream, cache);
}
completed?.Invoke();
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Debug(ex.ToString());
}
finally
{
foreach (var cached in cache.Values)
{
cached.Dispose();
}
cache.Clear();
}
}
private void broadcastAsync(OperationCode opcode, byte[] data, Action completed)
{
ThreadPool.QueueUserWorkItem(
state => broadcast(opcode, data, completed)
);
}
private void broadcastAsync(OperationCode opcode, Stream stream, Action completed)
{
ThreadPool.QueueUserWorkItem(
state => broadcast(opcode, stream, completed)
);
}
private Dictionary<string, bool> broadping(byte[] frameAsBytes)
{
var result = new Dictionary<string, bool>();
foreach (var session in Sessions)
{
if (_state != ServerState.Start)
{
Logger.Error("The endpoint is shutting down.");
break;
}
var pingResult = session.Context.WebSocket.Ping(frameAsBytes, _responseWaitingTime);
result.Add(session.ID, pingResult);
}
return result;
}
private bool canSet(out string message)
{
message = null;
if (_state == ServerState.Start)
{
message = "The endpoint has already started.";
return false;
}
if (_state == ServerState.ShuttingDown)
{
message = "The endpoint is shutting down.";
return false;
}
return true;
}
private void setCleanupTimer(double interval)
{
_sweepTimer = new System.Timers.Timer(interval);
_sweepTimer.Elapsed += (sender, e) => Sweep();
}
private void stop(Payload payload, bool send)
{
var bytes = send
? WSFrame.CreateCloseFrame(payload, false).ToArray()
: null;
lock (_locker)
{
_state = ServerState.ShuttingDown;
_sweepTimer.Enabled = false;
foreach (var session in _sessions.Values.ToList())
{
session.Context.WebSocket.Close(payload, bytes);
}
_state = ServerState.Stop;
}
}
private bool tryGetSession(string id, out IWSSession session)
{
session = null;
if (_state != ServerState.Start)
{
return false;
}
lock (_locker)
{
if (_state != ServerState.Start)
{
return false;
}
return _sessions.TryGetValue(id, out session);
}
}
}
}

55
EonaCat.Network/System/Sockets/Web/Server/WebSocketEndpointHost.cs
View File

@ -1,55 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
internal class WebSocketEndpointHost<TEndpoint> : WSEndpointHost
where TEndpoint : WSEndpoint
{
private readonly Func<TEndpoint> _creator;
internal WebSocketEndpointHost(
string path, Func<TEndpoint> creator
)
: this(path, creator, null)
{
}
internal WebSocketEndpointHost(
string path,
Func<TEndpoint> creator,
Action<TEndpoint> initializer
)
: base(path)
{
_creator = createCreator(creator, initializer);
}
public override Type EndpointType => typeof(TEndpoint);
protected override WSEndpoint CreateSession()
{
return _creator();
}
private Func<TEndpoint> createCreator(
Func<TEndpoint> creator, Action<TEndpoint> initializer
)
{
if (initializer == null)
{
return creator;
}
return () =>
{
var ret = creator();
initializer(ret);
return ret;
};
}
}
}

2980
EonaCat.Network/System/Sockets/Web/WSClient.cs
View File

File diff suppressed because it is too large Load Diff

55
EonaCat.Network/System/Sockets/Web/WSException.cs
View File

@ -1,55 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
namespace EonaCat.Network
{
public class WSException : Exception
{
internal WSException()
: this(CloseStatusCode.Abnormal, null, null)
{
}
internal WSException(Exception innerException)
: this(CloseStatusCode.Abnormal, null, innerException)
{
}
internal WSException(string message)
: this(CloseStatusCode.Abnormal, message, null)
{
}
internal WSException(CloseStatusCode code)
: this(code, null, null)
{
}
internal WSException(string message, Exception innerException)
: this(CloseStatusCode.Abnormal, message, innerException)
{
}
internal WSException(CloseStatusCode code, Exception innerException)
: this(code, null, innerException)
{
}
internal WSException(CloseStatusCode code, string message)
: this(code, message, null)
{
}
internal WSException(
CloseStatusCode code, string message, Exception innerException
)
: base("EonaCat Network: " + (message ?? code.GetMessage()), innerException)
{
Code = code;
}
public CloseStatusCode Code { get; }
}
}

641
EonaCat.Network/System/Sockets/Web/WSFrame.cs
View File

@ -1,641 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
internal class WSFrame : IEnumerable<byte>
{
internal static readonly byte[] EmptyPingBytes;
private const int BUFFER_SIZE = 1024;
static WSFrame()
{
EmptyPingBytes = CreatePingFrame(false).ToArray();
}
internal WSFrame(OperationCode opcode, Payload payload, bool mask)
: this(FinalFrame.Final, opcode, payload, false, mask)
{
}
internal WSFrame(FinalFrame finalFrame, OperationCode opcode, byte[] data, bool compressed, bool mask)
: this(finalFrame, opcode, new Payload(data), compressed, mask)
{
}
internal WSFrame(
FinalFrame fin, OperationCode opcode, Payload payload, bool compressed, bool mask)
{
Fin = fin;
Rsv1 = opcode.IsData() && compressed ? ReservedBits.On : ReservedBits.Off;
Rsv2 = ReservedBits.Off;
Rsv3 = ReservedBits.Off;
Opcode = opcode;
Payload = new Payload(payload);
var len = Payload.Length;
if (len < 126)
{
PayloadLength = (byte)len;
ExtendedPayloadLength = WSClient.EmptyBytes;
}
else if (len < 0x010000)
{
PayloadLength = 126;
ExtendedPayloadLength = ((ushort)len).InternalToByteArray(ByteOrder.Big);
}
else
{
PayloadLength = 127;
ExtendedPayloadLength = len.InternalToByteArray(ByteOrder.Big);
}
if (mask)
{
Mask = Mask.On;
MaskingKey = CreateMaskingKey();
Payload.Mask(MaskingKey);
}
else
{
Mask = Mask.Off;
MaskingKey = WSClient.EmptyBytes;
}
}
private WSFrame()
{
}
public byte[] ExtendedPayloadLength { get; private set; }
public FinalFrame Fin { get; private set; }
public bool IsBinary => Opcode == OperationCode.Binary;
public bool IsClose => Opcode == OperationCode.Close;
public bool IsCompressed => Rsv1 == ReservedBits.On;
public bool IsContinuation => Opcode == OperationCode.Continue;
public bool IsControl => Opcode >= OperationCode.Close;
public bool IsData => Opcode == OperationCode.Text || Opcode == OperationCode.Binary;
public bool IsFinal => Fin == FinalFrame.Final;
public bool IsFragment => Fin == FinalFrame.More || Opcode == OperationCode.Continue;
public bool IsMasked => Mask == Mask.On;
public bool IsPing => Opcode == OperationCode.Ping;
public bool IsPong => Opcode == OperationCode.Pong;
public bool IsText => Opcode == OperationCode.Text;
public ulong Length => 2 + (ulong)(ExtendedPayloadLength.Length + MaskingKey.Length) + Payload.Length;
public Mask Mask { get; private set; }
public byte[] MaskingKey { get; private set; }
public OperationCode Opcode { get; private set; }
public Payload Payload { get; private set; }
public byte PayloadLength { get; private set; }
public ReservedBits Rsv1 { get; private set; }
public ReservedBits Rsv2 { get; private set; }
public ReservedBits Rsv3 { get; private set; }
internal int ExtendedPayloadLengthCount => PayloadLength < 126 ? 0 : (PayloadLength == 126 ? 2 : 8);
internal ulong FullPayloadLength => PayloadLength < 126
? PayloadLength
: PayloadLength == 126
? ExtendedPayloadLength.ToUInt16(ByteOrder.Big)
: ExtendedPayloadLength.ToUInt64(ByteOrder.Big);
public IEnumerator<byte> GetEnumerator()
{
foreach (var b in ToArray())
{
yield return b;
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public void Print(bool dumped)
{
Console.WriteLine(dumped ? Dump(this) : Print(this));
}
public string PrintToString(bool dumped)
{
return dumped ? Dump(this) : Print(this);
}
public byte[] ToArray()
{
using (var buff = new MemoryStream())
{
var header = (int)Fin;
header = (header << 1) + (int)Rsv1;
header = (header << 1) + (int)Rsv2;
header = (header << 1) + (int)Rsv3;
header = (header << 4) + (int)Opcode;
header = (header << 1) + (int)Mask;
header = (header << 7) + PayloadLength;
buff.Write(((ushort)header).InternalToByteArray(ByteOrder.Big), 0, 2);
if (PayloadLength > 125)
{
buff.Write(ExtendedPayloadLength, 0, PayloadLength == 126 ? 2 : 8);
}
if (Mask == Mask.On)
{
buff.Write(MaskingKey, 0, 4);
}
if (PayloadLength > 0)
{
var bytes = Payload.ToArray();
if (PayloadLength < 127)
{
buff.Write(bytes, 0, bytes.Length);
}
else
{
buff.WriteBytes(bytes, BUFFER_SIZE);
}
}
buff.Close();
return buff.ToArray();
}
}
public override string ToString()
{
return BitConverter.ToString(ToArray());
}
internal static WSFrame CreateCloseFrame(
Payload payload, bool mask
)
{
return new WSFrame(
FinalFrame.Final, OperationCode.Close, payload, false, mask
);
}
internal static WSFrame CreatePingFrame(bool mask)
{
return new WSFrame(
FinalFrame.Final, OperationCode.Ping, Payload.Empty, false, mask
);
}
internal static WSFrame CreatePingFrame(byte[] data, bool mask)
{
return new WSFrame(
FinalFrame.Final, OperationCode.Ping, new Payload(data), false, mask
);
}
internal static WSFrame CreatePongFrame(
Payload payload, bool mask
)
{
return new WSFrame(
FinalFrame.Final, OperationCode.Pong, payload, false, mask
);
}
internal static WSFrame ReadFrame(Stream stream, bool unmask)
{
var frame = readHeader(stream);
readExtendedPayloadLength(stream, frame);
readMaskingKey(stream, frame);
readPayload(stream, frame);
if (unmask)
{
frame.Unmask();
}
return frame;
}
internal static void ReadFrameAsync(
Stream stream,
bool unmask,
Action<WSFrame> completed,
Action<Exception> error
)
{
readHeaderAsync(
stream,
frame =>
readExtendedPayloadLengthAsync(
stream,
frame,
frame1 =>
readMaskingKeyAsync(
stream,
frame1,
frame2 =>
readPayloadAsync(
stream,
frame2,
frame3 =>
{
if (unmask)
{
frame3.Unmask();
}
completed(frame3);
},
error
),
error
),
error
),
error
);
}
internal void Unmask()
{
if (Mask == Mask.Off)
{
return;
}
Mask = Mask.Off;
Payload.Mask(MaskingKey);
MaskingKey = WSClient.EmptyBytes;
}
private static byte[] CreateMaskingKey()
{
var key = new byte[4];
WSClient.RandomNumber.GetBytes(key);
return key;
}
private static string Dump(WSFrame frame)
{
var len = frame.Length;
var amount = (long)(len / 4);
var remainder = (int)(len % 4);
int digitAmount;
string frameCount;
if (amount < 10000)
{
digitAmount = 4;
frameCount = "{0,4}";
}
else if (amount < 0x010000)
{
digitAmount = 4;
frameCount = "{0,4:X}";
}
else if (amount < 0x0100000000)
{
digitAmount = 8;
frameCount = "{0,8:X}";
}
else
{
digitAmount = 16;
frameCount = "{0,16:X}";
}
var spFmt = string.Format("{{0,{0}}}", digitAmount);
var headerFormat = string.Format(@"{0} 01234567 89ABCDEF 01234567 89ABCDEF{0}+--------+--------+--------+--------+\n", spFmt);
var lineFmt = string.Format("{0}|{{1,8}} {{2,8}} {{3,8}} {{4,8}}|\n", frameCount);
var footerFmt = string.Format("{0}+--------+--------+--------+--------+", spFmt);
var output = new StringBuilder(64);
Func<Action<string, string, string, string>> linePrinter = () =>
{
long lineCnt = 0;
return (arg1, arg2, arg3, arg4) =>
output.AppendFormat(lineFmt, ++lineCnt, arg1, arg2, arg3, arg4);
};
var printLine = linePrinter();
output.AppendFormat(headerFormat, string.Empty);
var bytes = frame.ToArray();
for (long i = 0; i <= amount; i++)
{
var j = i * 4;
if (i < amount)
{
printLine(
Convert.ToString(bytes[j], 2).PadLeft(8, '0'),
Convert.ToString(bytes[j + 1], 2).PadLeft(8, '0'),
Convert.ToString(bytes[j + 2], 2).PadLeft(8, '0'),
Convert.ToString(bytes[j + 3], 2).PadLeft(8, '0'));
continue;
}
if (remainder > 0)
{
printLine(
Convert.ToString(bytes[j], 2).PadLeft(8, '0'),
remainder >= 2 ? Convert.ToString(bytes[j + 1], 2).PadLeft(8, '0') : string.Empty,
remainder == 3 ? Convert.ToString(bytes[j + 2], 2).PadLeft(8, '0') : string.Empty,
string.Empty);
}
}
output.AppendFormat(footerFmt, string.Empty);
return output.ToString();
}
private static string Print(WSFrame frame)
{
// Payload Length
var payloadLen = frame.PayloadLength;
// Extended Payload Length
var extPayloadLen = payloadLen > 125 ? frame.FullPayloadLength.ToString() : string.Empty;
// Masking Key
var maskingKey = BitConverter.ToString(frame.MaskingKey);
// Payload Data
var payload = payloadLen == 0
? string.Empty
: payloadLen > 125
? "---"
: frame.IsText && !(frame.IsFragment || frame.IsMasked || frame.IsCompressed)
? frame.Payload.ApplicationData.UTF8Decode()
: frame.Payload.ToString();
var format = @"
FIN: {0}
RSV1: {1}
RSV2: {2}
RSV3: {3}
Opcode: {4}
MASK: {5}
Payload Length: {6}
Extended Payload Length: {7}
Masking Key: {8}
Payload Data: {9}";
return string.Format(
format,
frame.Fin,
frame.Rsv1,
frame.Rsv2,
frame.Rsv3,
frame.Opcode,
frame.Mask,
payloadLen,
extPayloadLen,
maskingKey,
payload);
}
private static WSFrame ProcessHeader(byte[] header)
{
if (header.Length != 2)
{
throw new WSException("The header of a frame cannot be read from the stream.");
}
// FIN
var fin = (header[0] & 0x80) == 0x80 ? FinalFrame.Final : FinalFrame.More;
// RSV1
var rsv1 = (header[0] & 0x40) == 0x40 ? ReservedBits.On : ReservedBits.Off;
// RSV2
var rsv2 = (header[0] & 0x20) == 0x20 ? ReservedBits.On : ReservedBits.Off;
// RSV3
var rsv3 = (header[0] & 0x10) == 0x10 ? ReservedBits.On : ReservedBits.Off;
// Opcode
var opcode = (byte)(header[0] & 0x0f);
// MASK
var mask = (header[1] & 0x80) == 0x80 ? Mask.On : Mask.Off;
// Payload Length
var payloadLen = (byte)(header[1] & 0x7f);
var err = !opcode.IsSupported()
? "An unsupported opcode."
: !opcode.IsData() && rsv1 == ReservedBits.On
? "A non data frame is compressed."
: opcode.IsControl() && fin == FinalFrame.More
? "A control frame is fragmented."
: opcode.IsControl() && payloadLen > 125
? "A control frame has a long payload length."
: null;
if (err != null)
{
throw new WSException(CloseStatusCode.ProtocolError, err);
}
var frame = new WSFrame();
frame.Fin = fin;
frame.Rsv1 = rsv1;
frame.Rsv2 = rsv2;
frame.Rsv3 = rsv3;
frame.Opcode = (OperationCode)opcode;
frame.Mask = mask;
frame.PayloadLength = payloadLen;
return frame;
}
private static WSFrame readExtendedPayloadLength(Stream stream, WSFrame frame)
{
var len = frame.ExtendedPayloadLengthCount;
if (len == 0)
{
frame.ExtendedPayloadLength = WSClient.EmptyBytes;
return frame;
}
var bytes = stream.ReadBytes(len);
if (bytes.Length != len)
{
throw new WSException(
"The extended payload length of a frame cannot be read from the stream.");
}
frame.ExtendedPayloadLength = bytes;
return frame;
}
private static void readExtendedPayloadLengthAsync(
Stream stream,
WSFrame frame,
Action<WSFrame> completed,
Action<Exception> error)
{
var len = frame.ExtendedPayloadLengthCount;
if (len == 0)
{
frame.ExtendedPayloadLength = WSClient.EmptyBytes;
completed(frame);
return;
}
stream.ReadBytesAsync(
len,
bytes =>
{
if (bytes.Length != len)
{
throw new WSException(
"The extended payload length of a frame cannot be read from the stream.");
}
frame.ExtendedPayloadLength = bytes;
completed(frame);
},
error);
}
private static WSFrame readHeader(Stream stream)
{
return ProcessHeader(stream.ReadBytes(2));
}
private static void readHeaderAsync(
Stream stream, Action<WSFrame> completed, Action<Exception> error)
{
stream.ReadBytesAsync(2, bytes => completed(ProcessHeader(bytes)), error);
}
private static WSFrame readMaskingKey(Stream stream, WSFrame frame)
{
var len = frame.IsMasked ? 4 : 0;
if (len == 0)
{
frame.MaskingKey = WSClient.EmptyBytes;
return frame;
}
var bytes = stream.ReadBytes(len);
if (bytes.Length != len)
{
throw new WSException("The masking key of a frame cannot be read from the stream.");
}
frame.MaskingKey = bytes;
return frame;
}
private static void readMaskingKeyAsync(
Stream stream,
WSFrame frame,
Action<WSFrame> completed,
Action<Exception> error)
{
var len = frame.IsMasked ? 4 : 0;
if (len == 0)
{
frame.MaskingKey = WSClient.EmptyBytes;
completed(frame);
return;
}
stream.ReadBytesAsync(
len,
bytes =>
{
if (bytes.Length != len)
{
throw new WSException(
"The masking key of a frame cannot be read from the stream.");
}
frame.MaskingKey = bytes;
completed(frame);
},
error);
}
private static WSFrame readPayload(Stream stream, WSFrame frame)
{
var len = frame.FullPayloadLength;
if (len == 0)
{
frame.Payload = Payload.Empty;
return frame;
}
if (len > Payload.MaxLength)
{
throw new WSException(CloseStatusCode.TooBig, "A frame has a long payload length.");
}
var llen = (long)len;
var bytes = frame.PayloadLength < 127
? stream.ReadBytes((int)len)
: stream.ReadBytes(llen, BUFFER_SIZE);
if (bytes.LongLength != llen)
{
throw new WSException(
"The payload data of a frame cannot be read from the stream.");
}
frame.Payload = new Payload(bytes, llen);
return frame;
}
private static void readPayloadAsync(
Stream stream,
WSFrame frame,
Action<WSFrame> completed,
Action<Exception> error)
{
var len = frame.FullPayloadLength;
if (len == 0)
{
frame.Payload = Payload.Empty;
completed(frame);
return;
}
if (len > Payload.MaxLength)
{
throw new WSException(CloseStatusCode.TooBig, "A frame has a long payload length.");
}
var llen = (long)len;
Action<byte[]> compl = bytes =>
{
if (bytes.LongLength != llen)
{
throw new WSException(
"The payload data of a frame cannot be read from the stream.");
}
frame.Payload = new Payload(bytes, llen);
completed(frame);
};
if (frame.PayloadLength < 127)
{
stream.ReadBytesAsync((int)len, compl, error);
return;
}
stream.ReadBytesAsync(llen, BUFFER_SIZE, compl, error);
}
}
}

16
EonaCat.Network/System/Sockets/Web/WSState.cs
View File

@ -1,16 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
namespace EonaCat.Network
{
public enum WSState : ushort
{
Connecting = 0,
Open = 1,
Closing = 2,
Closed = 3
}
}

162
EonaCat.Network/System/Sockets/Web/WebBase.cs
View File

@ -1,162 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Text;
using System.Threading;
namespace EonaCat.Network
{
internal abstract class WebBase
{
internal byte[] EntityBodyData;
protected const string CrLf = "\r\n";
private const int _headersMaxLength = 8192;
protected WebBase(Version version, NameValueCollection headers)
{
ProtocolVersion = version;
Headers = headers;
}
public string EntityBody
{
get
{
if (EntityBodyData == null || EntityBodyData.LongLength == 0)
{
return string.Empty;
}
Encoding enc = null;
var contentType = Headers["Content-Type"];
if (contentType != null && contentType.Length > 0)
{
enc = HttpUtility.GetEncoding(contentType);
}
return (enc ?? Encoding.UTF8).GetString(EntityBodyData);
}
}
public NameValueCollection Headers { get; }
public Version ProtocolVersion { get; }
public byte[] ToByteArray()
{
return Encoding.UTF8.GetBytes(ToString());
}
protected static T Read<T>(Stream stream, Func<string[], T> parser, int millisecondsTimeout)
where T : WebBase
{
var timeout = false;
var timer = new Timer(
state =>
{
timeout = true;
stream.Close();
},
null,
millisecondsTimeout,
-1);
T http = null;
Exception exception = null;
try
{
http = parser(readHeaders(stream, _headersMaxLength));
var contentLen = http.Headers["Content-Length"];
if (contentLen != null && contentLen.Length > 0)
{
http.EntityBodyData = readEntityBody(stream, contentLen);
}
}
catch (Exception ex)
{
exception = ex;
}
finally
{
timer.Change(-1, -1);
timer.Dispose();
}
var message = timeout
? "A timeout has occurred while reading an HTTP request/response."
: exception != null
? "An exception has occurred while reading an HTTP request/response."
: null;
if (message != null)
{
throw new WSException(message, exception);
}
return http;
}
private static byte[] readEntityBody(Stream stream, string length)
{
if (!long.TryParse(length, out long len))
{
throw new ArgumentException("Cannot be parsed.", nameof(length));
}
if (len < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), "Less than zero.");
}
return len > 1024
? stream.ReadBytes(len, 1024)
: len > 0
? stream.ReadBytes((int)len)
: null;
}
private static string[] readHeaders(Stream stream, int maxLength)
{
var buff = new List<byte>();
var cnt = 0;
Action<int> add = i =>
{
if (i == -1)
{
throw new EndOfStreamException("The header cannot be read from the data source.");
}
buff.Add((byte)i);
cnt++;
};
var read = false;
while (cnt < maxLength)
{
if (stream.ReadByte().EqualsWith('\r', add) &&
stream.ReadByte().EqualsWith('\n', add) &&
stream.ReadByte().EqualsWith('\r', add) &&
stream.ReadByte().EqualsWith('\n', add))
{
read = true;
break;
}
}
if (!read)
{
throw new WSException("The length of header part is greater than the max length.");
}
return Encoding.UTF8.GetString(buff.ToArray())
.Replace(CrLf + " ", " ")
.Replace(CrLf + "\t", " ")
.Split(new[] { CrLf }, StringSplitOptions.RemoveEmptyEntries);
}
}
}

172
EonaCat.Network/System/Sockets/Web/WebRequest.cs
View File

@ -1,172 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Specialized;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
internal class WebRequest : WebBase
{
private bool _websocketRequest;
private bool _websocketRequestSet;
internal WebRequest(string method, string uri)
: this(method, uri, HttpVersion.Version11, new NameValueCollection())
{
Headers["User-Agent"] = $"EonaCat.Network/{Constants.Version}";
}
private WebRequest(string method, string uri, Version version, NameValueCollection headers)
: base(version, headers)
{
HttpMethod = method;
RequestUri = uri;
}
public AuthenticationResponse AuthenticationResponse
{
get
{
var res = Headers["Authorization"];
return res != null && res.Length > 0
? AuthenticationResponse.Parse(res)
: null;
}
}
public CookieCollection Cookies => Headers.GetCookies(false);
public string HttpMethod { get; }
public bool IsWebSocketRequest
{
get
{
if (!_websocketRequestSet)
{
var headers = Headers;
_websocketRequest = HttpMethod == "GET" &&
ProtocolVersion > HttpVersion.Version10 &&
headers.Contains("Upgrade", "websocket") &&
headers.Contains("Connection", "Upgrade");
_websocketRequestSet = true;
}
return _websocketRequest;
}
}
public string RequestUri { get; }
public void SetCookies(CookieCollection cookies)
{
if (cookies == null || cookies.Count == 0)
{
return;
}
var buff = new StringBuilder(64);
foreach (var cookie in cookies.Sorted)
{
if (!cookie.Expired)
{
buff.AppendFormat("{0}; ", cookie.ToString());
}
}
var len = buff.Length;
if (len > 2)
{
buff.Length = len - 2;
Headers["Cookie"] = buff.ToString();
}
}
public override string ToString()
{
var output = new StringBuilder(64);
output.AppendFormat("{0} {1} HTTP/{2}{3}", HttpMethod, RequestUri, ProtocolVersion, CrLf);
var headers = Headers;
foreach (var key in headers.AllKeys)
{
output.AppendFormat("{0}: {1}{2}", key, headers[key], CrLf);
}
output.Append(CrLf);
var entity = EntityBody;
if (entity.Length > 0)
{
output.Append(entity);
}
return output.ToString();
}
internal static WebRequest CreateConnectRequest(Uri uri)
{
var host = uri.DnsSafeHost;
var port = uri.Port;
var authority = string.Format("{0}:{1}", host, port);
var req = new WebRequest("CONNECT", authority);
req.Headers["Host"] = port == 80 ? host : authority;
return req;
}
internal static WebRequest CreateWebSocketRequest(Uri uri)
{
var req = new WebRequest("GET", uri.PathAndQuery);
var headers = req.Headers;
// Only includes a port number in the Host header value if it's non-default.
// See: https://tools.ietf.org/html/rfc6455#page-17
var port = uri.Port;
var schm = uri.Scheme;
headers["Host"] = (port == 80 && schm == "ws") || (port == 443 && schm == "wss")
? uri.DnsSafeHost
: uri.Authority;
headers["Upgrade"] = "websocket";
headers["Connection"] = "Upgrade";
return req;
}
internal static WebRequest Parse(string[] headerParts)
{
var requestLine = headerParts[0].Split(new[] { ' ' }, 3);
if (requestLine.Length != 3)
{
throw new ArgumentException("Invalid request line: " + headerParts[0]);
}
var headers = new WebHeaderCollection();
for (int i = 1; i < headerParts.Length; i++)
{
headers.InternalSet(headerParts[i], false);
}
return new WebRequest(
requestLine[0], requestLine[1], new Version(requestLine[2].Substring(5)), headers);
}
internal static WebRequest Read(Stream stream, int millisecondsTimeout)
{
return Read(stream, Parse, millisecondsTimeout);
}
internal WebResponse GetResponse(Stream stream, int millisecondsTimeout)
{
var buff = ToByteArray();
stream.Write(buff, 0, buff.Length);
return Read(stream, WebResponse.Parse, millisecondsTimeout);
}
}
}

143
EonaCat.Network/System/Sockets/Web/WebResponse.cs
View File

@ -1,143 +0,0 @@
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
using System;
using System.Collections.Specialized;
using System.IO;
using System.Text;
namespace EonaCat.Network
{
internal class WebResponse : WebBase
{
internal WebResponse(HttpStatusCode code)
: this(code, code.GetDescription())
{
}
internal WebResponse(HttpStatusCode code, string reason)
: this(((int)code).ToString(), reason, HttpVersion.Version11, new NameValueCollection())
{
Headers["Server"] = $"EonaCat.Network/{Constants.Version}";
}
private WebResponse(string code, string reason, Version version, NameValueCollection headers)
: base(version, headers)
{
StatusCode = code;
Reason = reason;
}
public CookieCollection Cookies => Headers.GetCookies(true);
public bool HasConnectionClose => Headers.Contains("Connection", "close");
public bool IsProxyAuthenticationRequired => StatusCode == "407";
public bool IsRedirect => StatusCode == "301" || StatusCode == "302";
public bool IsUnauthorized => StatusCode == "401";
public bool IsWebSocketResponse
{
get
{
var headers = Headers;
return ProtocolVersion > HttpVersion.Version10 &&
StatusCode == "101" &&
headers.Contains("Upgrade", "websocket") &&
headers.Contains("Connection", "Upgrade");
}
}
public string Reason { get; }
public string StatusCode { get; }
public void SetCookies(CookieCollection cookies)
{
if (cookies == null || cookies.Count == 0)
{
return;
}
var headers = Headers;
foreach (var cookie in cookies.Sorted)
{
headers.Add("Set-Cookie", cookie.ToResponseString());
}
}
public override string ToString()
{
var output = new StringBuilder(64);
output.AppendFormat("HTTP/{0} {1} {2}{3}", ProtocolVersion, StatusCode, Reason, CrLf);
var headers = Headers;
foreach (var key in headers.AllKeys)
{
output.AppendFormat("{0}: {1}{2}", key, headers[key], CrLf);
}
output.Append(CrLf);
var entity = EntityBody;
if (entity.Length > 0)
{
output.Append(entity);
}
return output.ToString();
}
internal static WebResponse CreateCloseResponse(HttpStatusCode code)
{
var res = new WebResponse(code);
res.Headers["Connection"] = "close";
return res;
}
internal static WebResponse CreateUnauthorizedResponse(string challenge)
{
var res = new WebResponse(HttpStatusCode.Unauthorized);
res.Headers["WWW-Authenticate"] = challenge;
return res;
}
internal static WebResponse CreateWebSocketResponse()
{
var res = new WebResponse(HttpStatusCode.SwitchingProtocols);
var headers = res.Headers;
headers["Upgrade"] = "websocket";
headers["Connection"] = "Upgrade";
return res;
}
internal static WebResponse Parse(string[] headerParts)
{
var statusLine = headerParts[0].Split(new[] { ' ' }, 3);
if (statusLine.Length != 3)
{
throw new ArgumentException("Invalid status line: " + headerParts[0]);
}
var headers = new WebHeaderCollection();
for (int i = 1; i < headerParts.Length; i++)
{
headers.InternalSet(headerParts[i], true);
}
return new WebResponse(
statusLine[1], statusLine[2], new Version(statusLine[0].Substring(5)), headers);
}
internal static WebResponse Read(Stream stream, int millisecondsTimeout)
{
return Read(stream, Parse, millisecondsTimeout);
}
}
}

49
EonaCat.Network/System/Sockets/WebSockets/Buffer/BufferValidator.cs Normal file
View File

@ -0,0 +1,49 @@
using System;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public class BufferValidator
{
public static void ValidateBuffer(byte[] buffer, int offset, int count,
string bufferParameterName = null,
string offsetParameterName = null,
string countParameterName = null)
{
if (buffer == null)
{
throw new ArgumentNullException(!string.IsNullOrEmpty(bufferParameterName) ? bufferParameterName : "buffer");
}
if (offset < 0 || offset > buffer.Length)
{
throw new ArgumentOutOfRangeException(!string.IsNullOrEmpty(offsetParameterName) ? offsetParameterName : "offset");
}
if (count < 0 || count > (buffer.Length - offset))
{
throw new ArgumentOutOfRangeException(!string.IsNullOrEmpty(countParameterName) ? countParameterName : "count");
}
}
public static void ValidateArraySegment<T>(ArraySegment<T> arraySegment, string arraySegmentParameterName = null)
{
if (arraySegment.Array == null)
{
throw new ArgumentNullException((!string.IsNullOrEmpty(arraySegmentParameterName) ? arraySegmentParameterName : "arraySegment") + ".Array");
}
if (arraySegment.Offset < 0 || arraySegment.Offset > arraySegment.Array.Length)
{
throw new ArgumentOutOfRangeException((!string.IsNullOrEmpty(arraySegmentParameterName) ? arraySegmentParameterName : "arraySegment") + ".Offset");
}
if (arraySegment.Count < 0 || arraySegment.Count > (arraySegment.Array.Length - arraySegment.Offset))
{
throw new ArgumentOutOfRangeException((!string.IsNullOrEmpty(arraySegmentParameterName) ? arraySegmentParameterName : "arraySegment") + ".Count");
}
}
}
}

17
EonaCat.Network/System/Sockets/WebSockets/Buffer/ISegmentBufferManager.cs Normal file
View File

@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public interface ISegmentBufferManager
{
ArraySegment<byte> BorrowBuffer();
IEnumerable<ArraySegment<byte>> BorrowBuffers(int count);
void ReturnBuffer(ArraySegment<byte> buffer);
void ReturnBuffers(IEnumerable<ArraySegment<byte>> buffers);
void ReturnBuffers(params ArraySegment<byte>[] buffers);
}
}

93
EonaCat.Network/System/Sockets/WebSockets/Buffer/SegmentBufferDeflector.cs Normal file
View File

@ -0,0 +1,93 @@
using System;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public class SegmentBufferDeflector
{
public static void AppendBuffer(
ISegmentBufferManager bufferManager,
ref ArraySegment<byte> receiveBuffer,
int receiveCount,
ref ArraySegment<byte> sessionBuffer,
ref int sessionBufferCount)
{
if (sessionBuffer.Count < (sessionBufferCount + receiveCount))
{
ArraySegment<byte> autoExpandedBuffer = bufferManager.BorrowBuffer();
if (autoExpandedBuffer.Count < (sessionBufferCount + receiveCount) * 2)
{
bufferManager.ReturnBuffer(autoExpandedBuffer);
autoExpandedBuffer = new ArraySegment<byte>(new byte[(sessionBufferCount + receiveCount) * 2]);
}
Array.Copy(sessionBuffer.Array, sessionBuffer.Offset, autoExpandedBuffer.Array, autoExpandedBuffer.Offset, sessionBufferCount);
var discardBuffer = sessionBuffer;
sessionBuffer = autoExpandedBuffer;
bufferManager.ReturnBuffer(discardBuffer);
}
Array.Copy(receiveBuffer.Array, receiveBuffer.Offset, sessionBuffer.Array, sessionBuffer.Offset + sessionBufferCount, receiveCount);
sessionBufferCount = sessionBufferCount + receiveCount;
}
public static void ShiftBuffer(
ISegmentBufferManager bufferManager,
int shiftStart,
ref ArraySegment<byte> sessionBuffer,
ref int sessionBufferCount)
{
if ((sessionBufferCount - shiftStart) < shiftStart)
{
Array.Copy(sessionBuffer.Array, sessionBuffer.Offset + shiftStart, sessionBuffer.Array, sessionBuffer.Offset, sessionBufferCount - shiftStart);
sessionBufferCount = sessionBufferCount - shiftStart;
}
else
{
ArraySegment<byte> copyBuffer = bufferManager.BorrowBuffer();
if (copyBuffer.Count < (sessionBufferCount - shiftStart))
{
bufferManager.ReturnBuffer(copyBuffer);
copyBuffer = new ArraySegment<byte>(new byte[sessionBufferCount - shiftStart]);
}
Array.Copy(sessionBuffer.Array, sessionBuffer.Offset + shiftStart, copyBuffer.Array, copyBuffer.Offset, sessionBufferCount - shiftStart);
Array.Copy(copyBuffer.Array, copyBuffer.Offset, sessionBuffer.Array, sessionBuffer.Offset, sessionBufferCount - shiftStart);
sessionBufferCount = sessionBufferCount - shiftStart;
bufferManager.ReturnBuffer(copyBuffer);
}
}
public static void ReplaceBuffer(
ISegmentBufferManager bufferManager,
ref ArraySegment<byte> receiveBuffer,
ref int receiveBufferOffset,
int receiveCount)
{
if ((receiveBufferOffset + receiveCount) < receiveBuffer.Count)
{
receiveBufferOffset = receiveBufferOffset + receiveCount;
}
else
{
ArraySegment<byte> autoExpandedBuffer = bufferManager.BorrowBuffer();
if (autoExpandedBuffer.Count < (receiveBufferOffset + receiveCount) * 2)
{
bufferManager.ReturnBuffer(autoExpandedBuffer);
autoExpandedBuffer = new ArraySegment<byte>(new byte[(receiveBufferOffset + receiveCount) * 2]);
}
Array.Copy(receiveBuffer.Array, receiveBuffer.Offset, autoExpandedBuffer.Array, autoExpandedBuffer.Offset, receiveBufferOffset + receiveCount);
receiveBufferOffset = receiveBufferOffset + receiveCount;
var discardBuffer = receiveBuffer;
receiveBuffer = autoExpandedBuffer;
bufferManager.ReturnBuffer(discardBuffer);
}
}
}
}

273
EonaCat.Network/System/Sockets/WebSockets/Buffer/SegmentBufferManager.cs Normal file
View File

@ -0,0 +1,273 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
/// <summary>
/// A manager to handle buffers for the socket connections.
/// </summary>
/// <remarks>
/// When used in an async call a buffer is pinned. Large numbers of pinned buffers
/// cause problem with the GC (in particular it causes heap fragmentation).
/// This class maintains a set of large segments and gives clients pieces of these
/// segments that they can use for their buffers. The alternative to this would be to
/// create many small arrays which it then maintained. This methodology should be slightly
/// better than the many small array methodology because in creating only a few very
/// large objects it will force these objects to be placed on the LOH. Since the
/// objects are on the LOH they are at this time not subject to compacting which would
/// require an update of all GC roots as would be the case with lots of smaller arrays
/// that were in the normal heap.
/// </remarks>
public class SegmentBufferManager : ISegmentBufferManager
{
private const int TrialsCount = 100;
private static SegmentBufferManager _defaultBufferManager;
private readonly int _segmentChunks;
private readonly int _chunkSize;
private readonly int _segmentSize;
private readonly bool _allowedToCreateMemory;
private readonly ConcurrentStack<ArraySegment<byte>> _buffers = new ConcurrentStack<ArraySegment<byte>>();
private readonly List<byte[]> _segments;
private readonly object _creatingNewSegmentLock = new object();
public static SegmentBufferManager Default
{
get
{
// default to 1024 1kb buffers if people don't want to manage it on their own;
if (_defaultBufferManager == null)
{
_defaultBufferManager = new SegmentBufferManager(1024, 1024, 1);
}
return _defaultBufferManager;
}
}
public static void SetDefaultBufferManager(SegmentBufferManager manager)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
_defaultBufferManager = manager;
}
public int ChunkSize
{
get { return _chunkSize; }
}
public int SegmentsCount
{
get { return _segments.Count; }
}
public int SegmentChunksCount
{
get { return _segmentChunks; }
}
public int AvailableBuffers
{
get { return _buffers.Count; }
}
public int TotalBufferSize
{
get { return _segments.Count * _segmentSize; }
}
public SegmentBufferManager(int segmentChunks, int chunkSize)
: this(segmentChunks, chunkSize, 1) { }
public SegmentBufferManager(int segmentChunks, int chunkSize, int initialSegments)
: this(segmentChunks, chunkSize, initialSegments, true) { }
/// <summary>
/// Constructs a new <see cref="SegmentBufferManager"></see> object
/// </summary>
/// <param name="segmentChunks">The number of chunks to create per segment</param>
/// <param name="chunkSize">The size of a chunk in bytes</param>
/// <param name="initialSegments">The initial number of segments to create</param>
/// <param name="allowedToCreateMemory">If false when empty and checkout is called an exception will be thrown</param>
public SegmentBufferManager(int segmentChunks, int chunkSize, int initialSegments, bool allowedToCreateMemory)
{
if (segmentChunks <= 0)
{
throw new ArgumentException("segmentChunks");
}
if (chunkSize <= 0)
{
throw new ArgumentException("chunkSize");
}
if (initialSegments < 0)
{
throw new ArgumentException("initialSegments");
}
_segmentChunks = segmentChunks;
_chunkSize = chunkSize;
_segmentSize = _segmentChunks * _chunkSize;
_segments = new List<byte[]>();
_allowedToCreateMemory = true;
for (int i = 0; i < initialSegments; i++)
{
CreateNewSegment(true);
}
_allowedToCreateMemory = allowedToCreateMemory;
}
private void CreateNewSegment(bool forceCreation)
{
if (!_allowedToCreateMemory)
{
throw new UnableToCreateMemoryException();
}
lock (_creatingNewSegmentLock)
{
if (!forceCreation && _buffers.Count > _segmentChunks / 2)
{
return;
}
var bytes = new byte[_segmentSize];
_segments.Add(bytes);
for (int i = 0; i < _segmentChunks; i++)
{
var chunk = new ArraySegment<byte>(bytes, i * _chunkSize, _chunkSize);
_buffers.Push(chunk);
}
}
}
public ArraySegment<byte> BorrowBuffer()
{
int trial = 0;
while (trial < TrialsCount)
{
ArraySegment<byte> result;
if (_buffers.TryPop(out result))
{
return result;
}
CreateNewSegment(false);
trial++;
}
throw new UnableToAllocateBufferException();
}
public IEnumerable<ArraySegment<byte>> BorrowBuffers(int count)
{
var result = new ArraySegment<byte>[count];
var trial = 0;
var totalReceived = 0;
try
{
while (trial < TrialsCount)
{
ArraySegment<byte> piece;
while (totalReceived < count)
{
if (!_buffers.TryPop(out piece))
{
break;
}
result[totalReceived] = piece;
++totalReceived;
}
if (totalReceived == count)
{
return result;
}
CreateNewSegment(false);
trial++;
}
throw new UnableToAllocateBufferException();
}
catch
{
if (totalReceived > 0)
{
ReturnBuffers(result.Take(totalReceived));
}
throw;
}
}
public void ReturnBuffer(ArraySegment<byte> buffer)
{
if (ValidateBuffer(buffer))
{
_buffers.Push(buffer);
}
}
public void ReturnBuffers(IEnumerable<ArraySegment<byte>> buffers)
{
if (buffers == null)
{
throw new ArgumentNullException("buffers");
}
foreach (var buf in buffers)
{
if (ValidateBuffer(buf))
{
_buffers.Push(buf);
}
}
}
public void ReturnBuffers(params ArraySegment<byte>[] buffers)
{
if (buffers == null)
{
throw new ArgumentNullException("buffers");
}
foreach (var buf in buffers)
{
if (ValidateBuffer(buf))
{
_buffers.Push(buf);
}
}
}
private bool ValidateBuffer(ArraySegment<byte> buffer)
{
if (buffer.Array == null || buffer.Count == 0 || buffer.Array.Length < buffer.Offset + buffer.Count)
{
return false;
}
if (buffer.Count != _chunkSize)
{
return false;
}
return true;
}
}
}

16
EonaCat.Network/System/Sockets/WebSockets/Buffer/UnableToAllocateBufferException.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
[Serializable]
public class UnableToAllocateBufferException : Exception
{
public UnableToAllocateBufferException()
: base("Cannot allocate buffer after few trials.")
{
}
}
}

16
EonaCat.Network/System/Sockets/WebSockets/Buffer/UnableToCreateMemoryException .cs Normal file
View File

@ -0,0 +1,16 @@
using System;
namespace EonaCat.WebSockets.Buffer
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
[Serializable]
public class UnableToCreateMemoryException : Exception
{
public UnableToCreateMemoryException()
: base("All buffers were in use and acquiring more memory has been disabled.")
{
}
}
}

1332
EonaCat.Network/System/Sockets/WebSockets/Client/AsyncWebSocketClient.cs Normal file
View File

File diff suppressed because it is too large Load Diff

81
EonaCat.Network/System/Sockets/WebSockets/Client/AsyncWebSocketClientConfiguration.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using System.Collections.Generic;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using EonaCat.WebSockets.Buffer;
using EonaCat.WebSockets.Extensions;
using EonaCat.WebSockets.SubProtocols;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public sealed class AsyncWebSocketClientConfiguration
{
public AsyncWebSocketClientConfiguration()
{
BufferManager = new SegmentBufferManager(100, 8192, 1, true);
ReceiveBufferSize = 8192;
SendBufferSize = 8192;
ReceiveTimeout = TimeSpan.Zero;
SendTimeout = TimeSpan.Zero;
NoDelay = true;
LingerState = new LingerOption(false, 0); // The socket will linger for x seconds after Socket.Close is called.
SslTargetHost = null;
SslClientCertificates = new X509CertificateCollection();
SslEncryptionPolicy = EncryptionPolicy.RequireEncryption;
SslEnabledProtocols = SslProtocols.Ssl3 | SslProtocols.Tls;
SslCheckCertificateRevocation = false;
SslPolicyErrorsBypassed = false;
ConnectTimeout = TimeSpan.FromSeconds(10);
CloseTimeout = TimeSpan.FromSeconds(5);
KeepAliveInterval = TimeSpan.FromSeconds(30);
KeepAliveTimeout = TimeSpan.FromSeconds(5);
ReasonableFragmentSize = 4096;
EnabledExtensions = new Dictionary<string, IWebSocketExtensionNegotiator>()
{
{ PerMessageCompressionExtension.RegisteredToken, new PerMessageCompressionExtensionNegotiator() },
};
EnabledSubProtocols = new Dictionary<string, IWebSocketSubProtocolNegotiator>();
OfferedExtensions = new List<WebSocketExtensionOfferDescription>()
{
new WebSocketExtensionOfferDescription(PerMessageCompressionExtension.RegisteredToken),
};
RequestedSubProtocols = new List<WebSocketSubProtocolRequestDescription>();
}
public ISegmentBufferManager BufferManager { get; set; }
public int ReceiveBufferSize { get; set; }
public int SendBufferSize { get; set; }
public TimeSpan ReceiveTimeout { get; set; }
public TimeSpan SendTimeout { get; set; }
public bool NoDelay { get; set; }
public LingerOption LingerState { get; set; }
public string SslTargetHost { get; set; }
public X509CertificateCollection SslClientCertificates { get; set; }
public EncryptionPolicy SslEncryptionPolicy { get; set; }
public SslProtocols SslEnabledProtocols { get; set; }
public bool SslCheckCertificateRevocation { get; set; }
public bool SslPolicyErrorsBypassed { get; set; }
public TimeSpan ConnectTimeout { get; set; }
public TimeSpan CloseTimeout { get; set; }
public TimeSpan KeepAliveInterval { get; set; }
public TimeSpan KeepAliveTimeout { get; set; }
public int ReasonableFragmentSize { get; set; }
public Dictionary<string, IWebSocketExtensionNegotiator> EnabledExtensions { get; set; }
public Dictionary<string, IWebSocketSubProtocolNegotiator> EnabledSubProtocols { get; set; }
public List<WebSocketExtensionOfferDescription> OfferedExtensions { get; set; }
public List<WebSocketSubProtocolRequestDescription> RequestedSubProtocols { get; set; }
}
}

19
EonaCat.Network/System/Sockets/WebSockets/Client/IAsyncWebSocketClientMessageDispatcher.cs Normal file
View File

@ -0,0 +1,19 @@
using System.Threading.Tasks;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public interface IAsyncWebSocketClientMessageDispatcher
{
Task OnServerConnected(AsyncWebSocketClient client);
Task OnServerTextReceived(AsyncWebSocketClient client, string text);
Task OnServerBinaryReceived(AsyncWebSocketClient client, byte[] data, int offset, int count);
Task OnServerDisconnected(AsyncWebSocketClient client);
Task OnServerFragmentationStreamOpened(AsyncWebSocketClient client, byte[] data, int offset, int count);
Task OnServerFragmentationStreamContinued(AsyncWebSocketClient client, byte[] data, int offset, int count);
Task OnServerFragmentationStreamClosed(AsyncWebSocketClient client, byte[] data, int offset, int count);
}
}

113
EonaCat.Network/System/Sockets/WebSockets/Client/InternalAsyncWebSocketClientMessageDispatcherImplementation.cs Normal file
View File

@ -0,0 +1,113 @@
using System;
using System.Threading.Tasks;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
internal class InternalAsyncWebSocketClientMessageDispatcherImplementation : IAsyncWebSocketClientMessageDispatcher
{
private Func<AsyncWebSocketClient, string, Task> _onServerTextReceived;
private Func<AsyncWebSocketClient, byte[], int, int, Task> _onServerBinaryReceived;
private Func<AsyncWebSocketClient, Task> _onServerConnected;
private Func<AsyncWebSocketClient, Task> _onServerDisconnected;
private Func<AsyncWebSocketClient, byte[], int, int, Task> _onServerFragmentationStreamOpened;
private Func<AsyncWebSocketClient, byte[], int, int, Task> _onServerFragmentationStreamContinued;
private Func<AsyncWebSocketClient, byte[], int, int, Task> _onServerFragmentationStreamClosed;
public InternalAsyncWebSocketClientMessageDispatcherImplementation()
{
}
public InternalAsyncWebSocketClientMessageDispatcherImplementation(
Func<AsyncWebSocketClient, string, Task> onServerTextReceived,
Func<AsyncWebSocketClient, byte[], int, int, Task> onServerDataReceived,
Func<AsyncWebSocketClient, Task> onServerConnected,
Func<AsyncWebSocketClient, Task> onServerDisconnected)
: this()
{
_onServerTextReceived = onServerTextReceived;
_onServerBinaryReceived = onServerDataReceived;
_onServerConnected = onServerConnected;
_onServerDisconnected = onServerDisconnected;
}
public InternalAsyncWebSocketClientMessageDispatcherImplementation(
Func<AsyncWebSocketClient, string, Task> onServerTextReceived,
Func<AsyncWebSocketClient, byte[], int, int, Task> onServerDataReceived,
Func<AsyncWebSocketClient, Task> onServerConnected,
Func<AsyncWebSocketClient, Task> onServerDisconnected,
Func<AsyncWebSocketClient, byte[], int, int, Task> onServerFragmentationStreamOpened,
Func<AsyncWebSocketClient, byte[], int, int, Task> onServerFragmentationStreamContinued,
Func<AsyncWebSocketClient, byte[], int, int, Task> onServerFragmentationStreamClosed)
: this()
{
_onServerTextReceived = onServerTextReceived;
_onServerBinaryReceived = onServerDataReceived;
_onServerConnected = onServerConnected;
_onServerDisconnected = onServerDisconnected;
_onServerFragmentationStreamOpened = onServerFragmentationStreamOpened;
_onServerFragmentationStreamContinued = onServerFragmentationStreamContinued;
_onServerFragmentationStreamClosed = onServerFragmentationStreamClosed;
}
public async Task OnServerConnected(AsyncWebSocketClient client)
{
if (_onServerConnected != null)
{
await _onServerConnected(client);
}
}
public async Task OnServerTextReceived(AsyncWebSocketClient client, string text)
{
if (_onServerTextReceived != null)
{
await _onServerTextReceived(client, text);
}
}
public async Task OnServerBinaryReceived(AsyncWebSocketClient client, byte[] data, int offset, int count)
{
if (_onServerBinaryReceived != null)
{
await _onServerBinaryReceived(client, data, offset, count);
}
}
public async Task OnServerDisconnected(AsyncWebSocketClient client)
{
if (_onServerDisconnected != null)
{
await _onServerDisconnected(client);
}
}
public async Task OnServerFragmentationStreamOpened(AsyncWebSocketClient client, byte[] data, int offset, int count)
{
if (_onServerFragmentationStreamOpened != null)
{
await _onServerFragmentationStreamOpened(client, data, offset, count);
}
}
public async Task OnServerFragmentationStreamContinued(AsyncWebSocketClient client, byte[] data, int offset, int count)
{
if (_onServerFragmentationStreamContinued != null)
{
await _onServerFragmentationStreamContinued(client, data, offset, count);
}
}
public async Task OnServerFragmentationStreamClosed(AsyncWebSocketClient client, byte[] data, int offset, int count)
{
if (_onServerFragmentationStreamClosed != null)
{
await _onServerFragmentationStreamClosed(client, data, offset, count);
}
}
}
}

414
EonaCat.Network/System/Sockets/WebSockets/Client/WebSocketClientHandshaker.cs Normal file
View File

@ -0,0 +1,414 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using EonaCat.WebSockets.Buffer;
using EonaCat.Logger.Extensions;
using EonaCat.Logger.Managers;
using EonaCat.Network;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
internal sealed class WebSocketClientHandshaker
{
private static readonly char[] _headerLineSplitter = new char[] { '\r', '\n' };
internal static byte[] CreateOpenningHandshakeRequest(AsyncWebSocketClient client, out string secWebSocketKey)
{
var sb = new StringBuilder();
// The handshake MUST be a valid HTTP request as specified by [RFC2616].
// The method of the request MUST be GET, and the HTTP version MUST be at least 1.1.
// For example, if the WebSocket URI is "ws://example.com/chat",
// the first line sent should be "GET /chat HTTP/1.1".
sb.AppendFormatWithCrCf("GET {0} HTTP/{1}",
!string.IsNullOrEmpty(client.Uri.PathAndQuery) ? client.Uri.PathAndQuery : "/",
Consts.HttpVersion);
// The request MUST contain a |Host| header field whose value
// contains /host/ plus optionally ":" followed by /port/ (when not
// using the default port).
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.Host, client.Uri.Host);
// The request MUST contain an |Upgrade| header field whose value
// MUST include the "websocket" keyword.
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.Upgrade, Consts.WebSocketUpgradeToken);
// The request MUST contain a |Connection| header field whose value
// MUST include the "Upgrade" token.
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.Connection, Consts.WebSocketConnectionToken);
// The request MUST include a header field with the name
// |Sec-WebSocket-Key|. The value of this header field MUST be a
// nonce consisting of a randomly selected 16-byte value that has
// been base64-encoded (see Section 4 of [RFC4648]). The nonce
// MUST be selected randomly for each connection.
secWebSocketKey = Convert.ToBase64String(Encoding.ASCII.GetBytes(Guid.NewGuid().ToString().Substring(0, 16)));
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.SecWebSocketKey, secWebSocketKey);
// The request MUST include a header field with the name
// |Sec-WebSocket-Version|. The value of this header field MUST be 13.
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.SecWebSocketVersion, Consts.WebSocketVersion);
// The request MAY include a header field with the name
// |Sec-WebSocket-Extensions|. If present, this value indicates
// the protocol-level extension(s) the client wishes to speak. The
// interpretation and format of this header field is described in Section 9.1.
if (client.OfferedExtensions != null && client.OfferedExtensions.Any())
{
foreach (var extension in client.OfferedExtensions)
{
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.SecWebSocketExtensions, extension.ExtensionNegotiationOffer);
}
}
// The request MAY include a header field with the name
// |Sec-WebSocket-Protocol|. If present, this value indicates one
// or more comma-separated subprotocol the client wishes to speak,
// ordered by preference. The elements that comprise this value
// MUST be non-empty strings with characters in the range U+0021 to
// U+007E not including separator characters as defined in
// [RFC2616] and MUST all be unique strings. The ABNF for the
// value of this header field is 1#token, where the definitions of
// constructs and rules are as given in [RFC2616].
if (client.RequestedSubProtocols != null && client.RequestedSubProtocols.Any())
{
foreach (var description in client.RequestedSubProtocols)
{
sb.AppendFormatWithCrCf(Consts.HttpHeaderLineFormat, HttpKnownHeaderNames.SecWebSocketProtocol, description.RequestedSubProtocol);
}
}
// The request MUST include a header field with the name |Origin|
// [RFC6454] if the request is coming from a browser client. If
// the connection is from a non-browser client, the request MAY
// include this header field if the semantics of that client match
// the use-case described here for browser clients. The value of
// this header field is the ASCII serialization of origin of the
// context in which the code establishing the connection is
// running. See [RFC6454] for the details of how this header field
// value is constructed.
// The request MAY include any other header fields, for example,
// cookies [RFC6265] and/or authentication-related header fields
// such as the |Authorization| header field [RFC2616], which are
// processed according to documents that define them.
sb.AppendWithCrCf();
// GET /chat HTTP/1.1
// Host: server.example.com
// Upgrade: websocket
// Connection: Upgrade
// Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
// Sec-WebSocket-Protocol: chat, superchat
// Sec-WebSocket-Version: 13
// Origin: http://example.com
var request = sb.ToString();
#if DEBUG
NetworkHelper.Logger.Debug($"{client.RemoteEndPoint}{Environment.NewLine}{request}");
#endif
return Encoding.UTF8.GetBytes(request);
}
internal static bool VerifyOpenningHandshakeResponse(AsyncWebSocketClient client, byte[] buffer, int offset, int count, string secWebSocketKey)
{
BufferValidator.ValidateBuffer(buffer, offset, count, "buffer");
if (string.IsNullOrEmpty(secWebSocketKey))
{
throw new ArgumentNullException("secWebSocketKey");
}
var response = Encoding.UTF8.GetString(buffer, offset, count);
#if DEBUG
NetworkHelper.Logger.Debug($"{client.RemoteEndPoint}{Environment.NewLine}{response}");
#endif
try
{
// HTTP/1.1 101 Switching Protocols
// Upgrade: websocket
// Connection: Upgrade
// Sec-WebSocket-Accept: 1tGBmA9p0DQDgmFll6P0/UcVS/E=
// Sec-WebSocket-Protocol: chat
Dictionary<string, string> headers;
List<string> extensions;
List<string> protocols;
ParseOpenningHandshakeResponseHeaders(response, out headers, out extensions, out protocols);
if (headers == null)
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to invalid headers.", client.RemoteEndPoint));
}
// If the status code received from the server is not 101, the
// client handles the response per HTTP [RFC2616] procedures. In
// particular, the client might perform authentication if it
// receives a 401 status code; the server might redirect the client
// using a 3xx status code (but clients are not required to follow them), etc.
if (!headers.ContainsKey(Consts.HttpStatusCodeName))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to lack of status code.", client.RemoteEndPoint));
}
if (!headers.ContainsKey(Consts.HttpStatusCodeDescription))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to lack of status description.", client.RemoteEndPoint));
}
if (headers[Consts.HttpStatusCodeName] == ((int)HttpStatusCode.BadRequest).ToString())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to bad request [{1}].",
client.RemoteEndPoint, headers[Consts.HttpStatusCodeName]));
}
if (headers[Consts.HttpStatusCodeName] != ((int)HttpStatusCode.SwitchingProtocols).ToString())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to expected 101 Switching Protocols but received [{1}].",
client.RemoteEndPoint, headers[Consts.HttpStatusCodeName]));
}
// If the response lacks an |Upgrade| header field or the |Upgrade|
// header field contains a value that is not an ASCII case-
// insensitive match for the value "websocket", the client MUST
// _Fail the WebSocket Connection_.
if (!headers.ContainsKey(HttpKnownHeaderNames.Connection))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to lack of connection header item.", client.RemoteEndPoint));
}
if (headers[HttpKnownHeaderNames.Connection].ToLowerInvariant() != Consts.WebSocketConnectionToken.ToLowerInvariant())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to invalid connection header item value [{1}].",
client.RemoteEndPoint, headers[HttpKnownHeaderNames.Connection]));
}
// If the response lacks a |Connection| header field or the
// |Connection| header field doesn't contain a token that is an
// ASCII case-insensitive match for the value "Upgrade", the client
// MUST _Fail the WebSocket Connection_.
if (!headers.ContainsKey(HttpKnownHeaderNames.Upgrade))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to lack of upgrade header item.", client.RemoteEndPoint));
}
if (headers[HttpKnownHeaderNames.Upgrade].ToLowerInvariant() != Consts.WebSocketUpgradeToken.ToLowerInvariant())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to invalid upgrade header item value [{1}].",
client.RemoteEndPoint, headers[HttpKnownHeaderNames.Upgrade]));
}
// If the response lacks a |Sec-WebSocket-Accept| header field or
// the |Sec-WebSocket-Accept| contains a value other than the
// base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-
// Key| (as a string, not base64-decoded) with the string "258EAFA5-
// E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
// trailing whitespace, the client MUST _Fail the WebSocket Connection_.
if (!headers.ContainsKey(HttpKnownHeaderNames.SecWebSocketAccept))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to lack of Sec-WebSocket-Accept header item.", client.RemoteEndPoint));
}
string challenge = GetSecWebSocketAcceptString(secWebSocketKey);
if (!headers[HttpKnownHeaderNames.SecWebSocketAccept].Equals(challenge, StringComparison.OrdinalIgnoreCase))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to invalid Sec-WebSocket-Accept header item value [{1}].",
client.RemoteEndPoint, headers[HttpKnownHeaderNames.SecWebSocketAccept]));
}
// If the response includes a |Sec-WebSocket-Extensions| header
// field and this header field indicates the use of an extension
// that was not present in the client's handshake (the server has
// indicated an extension not requested by the client), the client
// MUST _Fail the WebSocket Connection_.
if (extensions != null)
{
foreach (var extension in extensions)
{
// The empty string is not the same as the null value for these
// purposes and is not a legal value for this field.
if (string.IsNullOrWhiteSpace(extension))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to empty extension.", client.RemoteEndPoint));
}
}
client.AgreeExtensions(extensions);
}
// If the response includes a |Sec-WebSocket-Protocol| header field
// and this header field indicates the use of a subprotocol that was
// not present in the client's handshake (the server has indicated a
// subprotocol not requested by the client), the client MUST _Fail
// the WebSocket Connection_.
if (protocols != null)
{
if (!protocols.Any())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to empty sub-protocol.", client.RemoteEndPoint));
}
if (protocols.Count > 1)
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to suggest to use multiple sub-protocols.", client.RemoteEndPoint));
}
foreach (var protocol in protocols)
{
// The empty string is not the same as the null value for these
// purposes and is not a legal value for this field.
if (string.IsNullOrWhiteSpace(protocol))
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to empty sub-protocol.", client.RemoteEndPoint));
}
}
var suggestedProtocols = protocols.First().Split(',')
.Select(p => p.TrimStart().TrimEnd()).Where(p => !string.IsNullOrWhiteSpace(p));
if (!suggestedProtocols.Any())
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to invalid sub-protocol.", client.RemoteEndPoint));
}
if (suggestedProtocols.Count() > 1)
{
throw new WebSocketHandshakeException(string.Format(
"Handshake with remote [{0}] failed due to suggest to use multiple sub-protocols.", client.RemoteEndPoint));
}
// The value chosen MUST be derived
// from the client's handshake, specifically by selecting one of
// the values from the |Sec-WebSocket-Protocol| field that the
// server is willing to use for this connection (if any).
client.UseSubProtocol(suggestedProtocols.First());
}
}
catch (Exception ex)
{
NetworkHelper.Logger.Error($"{client.RemoteEndPoint}{Environment.NewLine}{ex.FormatExceptionToMessage()}");
throw;
}
return true;
}
private static void ParseOpenningHandshakeResponseHeaders(string response,
out Dictionary<string, string> headers,
out List<string> extensions,
out List<string> protocols)
{
headers = new Dictionary<string, string>();
// The |Sec-WebSocket-Extensions| header field MAY appear multiple times
// in an HTTP request (which is logically the same as a single
// |Sec-WebSocket-Extensions| header field that contains all values.
// However, the |Sec-WebSocket-Extensions| header field MUST NOT appear
// more than once in an HTTP response.
extensions = null;
// The |Sec-WebSocket-Protocol| header field MAY appear multiple times
// in an HTTP request (which is logically the same as a single
// |Sec-WebSocket-Protocol| header field that contains all values).
// However, the |Sec-WebSocket-Protocol| header field MUST NOT appear
// more than once in an HTTP response.
protocols = null;
var lines = response.Split(_headerLineSplitter).Where(l => l.Length > 0);
foreach (var line in lines)
{
// HTTP/1.1 101 Switching Protocols
// HTTP/1.1 400 Bad Request
if (line.StartsWith(@"HTTP/"))
{
var segements = line.Split(' ');
if (segements.Length > 1)
{
headers.Add(Consts.HttpStatusCodeName, segements[1]);
if (segements.Length > 2)
{
headers.Add(Consts.HttpStatusCodeDescription, segements[2]);
}
}
}
else
{
foreach (var key in HttpKnownHeaderNames.All)
{
if (line.StartsWith(key + ":"))
{
var index = line.IndexOf(':');
if (index != -1)
{
var value = line.Substring(index + 1);
if (key == HttpKnownHeaderNames.SecWebSocketExtensions)
{
if (extensions == null)
{
extensions = new List<string>();
}
extensions.Add(value.Trim());
}
else if (key == HttpKnownHeaderNames.SecWebSocketProtocol)
{
if (protocols == null)
{
protocols = new List<string>();
}
protocols.Add(value.Trim());
}
else
{
if (headers.ContainsKey(key))
{
headers[key] = string.Join(",", headers[key], value.Trim());
}
else
{
headers.Add(key, value.Trim());
}
}
}
}
}
}
}
}
private static string GetSecWebSocketAcceptString(string secWebSocketKey)
{
string retVal;
using (SHA1 sha1 = SHA1.Create())
{
string acceptString = string.Concat(secWebSocketKey, Consts.SecWebSocketKeyGuid);
byte[] toHash = Encoding.UTF8.GetBytes(acceptString);
retVal = Convert.ToBase64String(sha1.ComputeHash(toHash));
}
return retVal;
}
}
}

21
EonaCat.Network/System/Sockets/WebSockets/Exceptions/WebSocketException.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
[Serializable]
public class WebSocketException : Exception
{
public WebSocketException(string message)
: base(message)
{
}
public WebSocketException(string message, Exception innerException)
: base(message, innerException)
{
}
}
}

21
EonaCat.Network/System/Sockets/WebSockets/Exceptions/WebSocketHandshakeException.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
namespace EonaCat.WebSockets
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
[Serializable]
public sealed class WebSocketHandshakeException : WebSocketException
{
public WebSocketHandshakeException(string message)
: base(message)
{
}
public WebSocketHandshakeException(string message, Exception innerException)
: base(message, innerException)
{
}
}
}

21
EonaCat.Network/System/Sockets/WebSockets/Extensions/IWebSocketExtension.cs Normal file
View File

@ -0,0 +1,21 @@
namespace EonaCat.WebSockets.Extensions
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public interface IWebSocketExtension
{
string Name { get; }
bool Rsv1BitOccupied { get; }
bool Rsv2BitOccupied { get; }
bool Rsv3BitOccupied { get; }
string GetAgreedOffer();
byte[] BuildExtensionData(byte[] payload, int offset, int count);
byte[] ProcessIncomingMessagePayload(byte[] payload, int offset, int count);
byte[] ProcessOutgoingMessagePayload(byte[] payload, int offset, int count);
}
}

11
EonaCat.Network/System/Sockets/WebSockets/Extensions/IWebSocketExtensionNegotiator.cs Normal file
View File

@ -0,0 +1,11 @@
namespace EonaCat.WebSockets.Extensions
{
// This file is part of the EonaCat project(s) which is released under the Apache License.
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
public interface IWebSocketExtensionNegotiator
{
bool NegotiateAsServer(string offer, out string invalidParameter, out IWebSocketExtension negotiatedExtension);
bool NegotiateAsClient(string offer, out string invalidParameter, out IWebSocketExtension negotiatedExtension);
}
}

Some files were not shown because too many files have changed in this diff Show More