/// <summary>
/// 发送一个数据库操作请求。如果发送成功返回true，否则返回false
/// </summary>
/// <param name="userModel">用户对象</param>
/// <param name="operation">操作类型</param>
/// <param name="parameter">操作参数</param>
public bool SendDatabaseRequest(User user, string operation, string parameter)
{
if (ClientState)
{
byte[] buffer = BytesConvert.ObjectToBytes(new Transmit()
{
SourceID = ClientID,
TargetID = ClientID,
DataType = DataType.Request,
Parameter = $"Database;{operation},{parameter}",
Object = user
});
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
try
{
args.SetBuffer(buffer, 0, buffer.Length);
clientSocket.SendAsync(args);
return(true);
}
catch (Exception exception)
{
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "在发送请求时发生错误"));
}
finally
{
args.Dispose();
}
}
return(false);
}
/// <summary>
/// 异步的发送文本消息。如果发送成功返回true，否则返回false
/// </summary>
/// <param name="targetUserID">目标用户ID</param>
/// <param name="message">文本消息</param>
public async Task <bool> SendTextAsync(string targetUserID, string message)
{
if (ClientState && targetUserID != null && message != null)
{
return(await Task.Run <bool>(() =>
{
byte[] buffer = BytesConvert.ObjectToBytes(new Transmit()
{
SourceID = ClientID,
TargetID = targetUserID,
DataType = DataType.Text,
Parameter = message
});
try
{
clientSocket.Send(buffer, buffer.Length, SocketFlags.None);
return true;
}
catch (Exception exception)
{
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "在发送文本消息时发生错误"));
return false;
}
}));
}
return(false);
}
/// <summary>
/// 异步的发送图片。如果发送成功返回true，否则返回false
/// </summary>
/// <param name="targetUserID">目标ID</param>
/// <param name="imagePath">图片路径</param>
public async Task <bool> SendImageAsync(string targetUserID, string imagePath)
{
if (ClientState && targetUserID != null && imagePath != null)
{
return(await Task.Run <bool>(() =>
{
FileStream fileStream = null; //文件流
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
try
{
fileStream = new FileStream(imagePath, FileMode.Open, FileAccess.Read);
if (fileStream.Length == 0)
{
return false;
}
byte[] buffer = BytesConvert.ObjectToBytes(new Transmit()
{
SourceID = ClientID,
TargetID = targetUserID,
DataType = DataType.Image,
Parameter = $"{Path.GetFileName(imagePath)};{fileStream.Length}"
});
clientSocket.Send(buffer, buffer.Length, SocketFlags.None);
Thread.Sleep(100);
while (true)
{
int readBytes = fileStream.Read(dataBuffer, 0, dataBuffer.Length);
if (readBytes <= 0)
{
break;
}
clientSocket.Send(dataBuffer, readBytes, SocketFlags.None);
Thread.Sleep(10);
}
}
catch (Exception exception)
{
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "在发送图片时发生错误"));
return false;
}
finally
{
fileStream?.Close();
fileStream?.Dispose();
fileStream = null;
}
return true;
}));
}
return(false);
}
public void Test2()
{
Aes.Create().Then(_ =>
{
_.SetEmptyIV();
_.Key = "1234567890123456".Bytes(Encoding.ASCII);
Assert.Equal("0c66182ec710840065ebaa47c5e6ce90",
_.Encrypt <AesEmptyIVCombiner>("123".Bytes(Encoding.UTF8)).Flow(BytesFlow.HexString));
});
Aes.Create().Then(_ =>
{
var now = DateTime.Now.ToString();
var flow = new Flow <byte[], string>(x => BytesConvert.Base64(_.Encrypt(x)));
var encrypted = _.Encrypt(now.ToString().Bytes(Encoding.UTF8)).Flow(BytesFlow.Base64);
Assert.Equal(now, _.Decrypt(encrypted.Flow(BytesFlow.FromBase64)).String(Encoding.UTF8));
});
}
/// <summary>
/// Generate one or more sentinal files
/// </summary>
/// <returns>int number of failures</returns>
static int Genfiles()
{
int rc = 0;
foreach (FileRecord File in config.Files)
{
if (File.Sentinal) // only generate for files where Sentinal is true
{
if (System.IO.File.Exists(File.Path))
{
Console.WriteLine("Failure: '" + File.Path + "' already exists ");
rc++;
continue;
}
Sentinal s = new Sentinal(File.Path);
int length = File.GetLength();
if (length == 0)
{
s.Length = new Random().Next(4, 32768) * 1024; // set a random size if not specified
}
else
{
s.Length = length;
}
try
{
if (s.GenerateType1())
{
Console.WriteLine("Success: '" + s.Path + "' Generated, " + BytesConvert.ToString(s.Length));
}
else
{
Console.WriteLine("Something wierd happened attempting to write '" + File.Path); // shouldnt be here
}
// there should have been an execption if anything went wrong in s.Generate().
}
catch (Exception e)
{
Console.WriteLine("301 Error writing file: " + " " + e.Message);
rc++;
}
}
}
Console.WriteLine("RC=" + rc);
return(rc);
}
internal override string GetCommandLogString()
{
return($"{Arg.Handle} {Arg.Datalen} ({BytesConvert.ToHexString(Arg.Data)})");
}
public static string HexString(byte[] bytes) => BytesConvert.ToHexString(bytes);
/// <summary>
/// 接收数据
/// </summary>
/// <param name="socket">客户端Socket对象</param>
private void ReceiveMessage(Socket socket)
{
bool isMain = true; //是否为主端口
string clientID = string.Empty; //客户端ID
IPEndPoint clientIPEndPoint = (IPEndPoint)socket.RemoteEndPoint; //客户端网络终结点
bool isFirstConnection = true; //是否为首次连接
byte[] dataBuffer = new byte[1024 * 1024]; //缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
int targetPort = -1; //发送目标端口
while (true)
{
int readBytes = 0;
if (socket.Poll(-1, SelectMode.SelectRead) == true)
{
if (!ServerState)
{
break;
}
try
{
readBytes = socket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
if (isMain)
{
CloseClient(clientID);
break;
}
CloseClientPort(clientID, clientIPEndPoint.Port);
break;
}
}
catch (Exception exception)
{
if (isMain)
{
CloseClient(clientID, false, exception);
break;
}
CloseClientPort(clientID, clientIPEndPoint.Port, false, exception);
break;
}
}
//首次连接
if (isFirstConnection)
{
isFirstConnection = false;
clientID = Encoding.UTF8.GetString(dataBuffer, 0, readBytes);
if (clientCollection.AddClient(clientID, clientIPEndPoint, socket))
{
ServerMessage?.Invoke(this, new ServerNotifyEventArgs($"客户端 {clientID}({clientIPEndPoint}) 已连接"));
}
else
{
if (!clientCollection.AddPort(clientID, clientIPEndPoint.Port, socket))
{
break;
}
isMain = false;
ServerMessage?.Invoke(this, new ServerNotifyEventArgs($"客户端 {clientID} 的 {clientIPEndPoint.Port} 端口已连接"));
}
socket.Send(new byte[] { 1 });
continue;
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter == null)
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
if (isMain)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
switch (transmit.DataType)
{
case DataType.Text:
if (!Forward(transmit, dataBuffer, readBytes))
{
return;
}
break;
case DataType.Image:
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
if (!Forward(transmit, dataBuffer, readBytes))
{
return;
}
continue;
}
}
break;
case DataType.Request:
if (transmit.Parameter.StartsWith("Database"))
{
if (parameters.Length == 2)
{
var result = DatabaseRequest?.Invoke(this, new DatabaseEventArgs(parameters[1], transmit.Object))?.Result;
if (result != null)
{
transmit.Parameter = "Client;RequestResult";
transmit.Object = result;
byte[] buffer = BytesConvert.ObjectToBytes(transmit);
if (!Forward(transmit, buffer, buffer.Length))
{
return;
}
}
}
}
break;
}
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
if (transmit.DataType == DataType.File)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
Transmit requestTransmit = new Transmit()
{
SourceID = transmit.SourceID,
TargetID = transmit.TargetID,
DataType = DataType.Request,
Parameter = "Client;AddSocket"
};
byte[] buffer = BytesConvert.ObjectToBytes(requestTransmit);
if (!Forward(requestTransmit, buffer, buffer.Length))
{
return;
}
Thread.Sleep(3000);
List <Socket> sockets = clientCollection.GetClientSockets(transmit.TargetID);
targetPort = ((IPEndPoint)sockets[sockets.Count - 1].RemoteEndPoint).Port;
if (!Forward(transmit, dataBuffer, readBytes, targetPort))
{
return;
}
continue;
}
}
}
CloseClientPort(clientID, clientIPEndPoint.Port);
return;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
if (!Forward(transmit, dataBuffer, readBytes, targetPort))
{
break;
}
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
if (isMain)
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
CloseClientPort(clientID, clientIPEndPoint.Port);
break;
}
}
}
/// <summary>
/// 辅助接收器
/// </summary>
/// <param name="socket">客户端Socket对象</param>
private void SecondaryReceiver(Socket socket)
{
if (socket == null)
{
return;
}
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
while (true)
{
int readBytes = 0;
if (socket.Poll(15000000, SelectMode.SelectRead))
{
if (!ClientState)
{
break;
}
try
{
readBytes = socket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
socketManager.CloseConnection(socket);
break;
}
}
catch
{
socketManager.CloseConnection(socket);
break;
}
}
else
{
socketManager.CloseConnection(socket);
break;
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter != null)
{
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
continue;
}
}
}
socketManager.CloseConnection(socket);
break;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
ReceiveDataHandler(transmit, dataBuffer, readBytes);
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
socketManager.CloseConnection(socket);
break;
}
}
}
/// <summary>
/// 主接收器
/// </summary>
private void MainReceiver()
{
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
bool isFirstReceive = true; //是否为首次接收数据
Transmit transmit = null; //传输对象
double dataSize = 0.0; //数据总大小
double receiveBytes = 0.0; //已接收的字节数
while (true)
{
int readBytes = 0;
if (clientSocket.Poll(-1, SelectMode.SelectRead))
{
if (!ClientState)
{
break;
}
try
{
readBytes = clientSocket.Receive(dataBuffer, dataBuffer.Length, SocketFlags.None);
if (readBytes == 0)
{
CloseClient();
ClientMessage?.Invoke(this, new ClientNotifyEventArgs("服务器断开连接"));
break;
}
}
catch (Exception exception)
{
CloseClient();
ClientMessage?.Invoke(this, new ClientNotifyEventArgs("服务器断开连接"));
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "服务器意外的断开连接"));
break;
}
}
//首次接收数据
if (isFirstReceive)
{
isFirstReceive = false;
transmit = BytesConvert.BytesToObject(dataBuffer, readBytes, "MiniSocket.Transmitting") as Transmit;
if (transmit?.Parameter != null)
{
switch (transmit.DataType)
{
case DataType.Text:
ReceiveDataHandler(transmit, null, 0);
break;
case DataType.Image:
string[] parameters = transmit.Parameter.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length == 2)
{
if (double.TryParse(parameters[1], out dataSize))
{
continue;
}
}
break;
case DataType.Request:
ReceiveRequestHandler(transmit);
break;
}
}
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
receiveBytes += readBytes; //已接收到的数据累加
//判断已接收到的数据是否有效
if (receiveBytes > 0 && receiveBytes <= dataSize)
{
ReceiveDataHandler(transmit, dataBuffer, readBytes);
}
//判断是否接收完成或数据是否有误
if (receiveBytes == dataSize || (receiveBytes <= 0 || receiveBytes > dataSize))
{
ResetParameter(ref isFirstReceive, ref transmit, ref dataSize, ref receiveBytes);
continue;
}
}
}
/// <summary>
/// 异步的发送文件。如果发送成功返回true，否则返回false
/// </summary>
/// <param name="targetUserID">目标ID</param>
/// <param name="filePath">文件路径</param>
public async Task <bool> SendFileAsync(string targetUserID, string filePath)
{
if (ClientState && targetUserID != null && filePath != null)
{
return(await Task.Run <bool>(async() =>
{
FileStream fileStream = null; //文件流
byte[] dataBuffer = new byte[1024 * 1024]; //数据缓冲区
try
{
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
if (fileStream.Length == 0)
{
return false;
}
byte[] buffer = BytesConvert.ObjectToBytes(new Transmit()
{
SourceID = ClientID,
TargetID = targetUserID,
DataType = DataType.File,
Parameter = $"{Path.GetFileName(filePath)};{fileStream.Length}"
});
SocketResult socketResult = await socketManager.CreateConnectionAsync();
switch (socketResult.State)
{
case ConnectionState.Success:
socketResult.Socket.Send(buffer, buffer.Length, SocketFlags.None);
break;
case ConnectionState.Failed:
throw new ArgumentException("服务器拒绝连接");
case ConnectionState.Timeout:
throw new ArgumentException("服务器连接超时");
case ConnectionState.Error:
throw socketResult.Exception;
}
Thread.Sleep(5000);
while (true)
{
int readBytes = fileStream.Read(dataBuffer, 0, dataBuffer.Length);
if (readBytes <= 0)
{
break;
}
socketResult.Socket.Send(dataBuffer, readBytes, SocketFlags.None);
Thread.Sleep(10);
}
}
catch (Exception exception)
{
ClientError?.Invoke(this, new ClientErrorEventArgs(exception, "在发送文件时发生错误"));
return false;
}
finally
{
fileStream?.Close();
fileStream?.Dispose();
fileStream = null;
}
return true;
}));
}
return(false);
}
internal override string GetCommandLogString()
{
return($"{Arg.Handle} {Arg.Ipaddr} {Arg.Port} {(char)Arg.Sec} {Arg.Datalen} ({BytesConvert.ToHexString(Arg.Data)})");
}
public LANClient(ILogger <LANClient> logger)
{
var selfAddresses = NetworkInterface.GetAllNetworkInterfaces().SelectMany(ni => ni.GetIPProperties().UnicastAddresses.Select(ua => ua.Address.ToString()));
_logger = logger;
try
{
receiveUdpClient = new UdpClient(DefaultUdpPort)
{
EnableBroadcast = true
};
}
catch (Exception ex)
{
_logger.LogDebug(ex, "Exception");
throw;
}
Task.Run(async() =>
{
try
{
while (true)
{
var receivedResults = await receiveUdpClient.ReceiveAsync();
if (selfAddresses.Contains(receivedResults.RemoteEndPoint.Address.ToString()))
{
//ブロードキャストを自分で受信(無視)
continue;
}
_logger.LogDebug($"UDP受信:{receivedResults.RemoteEndPoint.Address.ToString()} {BytesConvert.ToHexString(receivedResults.Buffer)}");
OnEventReceived?.Invoke(this, (receivedResults.RemoteEndPoint.Address.ToString(), receivedResults.Buffer));
}
}
catch (System.ObjectDisposedException)
{
//握りつぶす
}
catch (Exception ex)
{
_logger.LogDebug(ex, "Exception");
}
});
}
