/// <summary>
/// Triggerd if datareceived while in monitoring mode
/// </summary>
public void Process(ReceivedEventArgs data1)
{
var data = data1.Bytes;
_buffer.AddRange(data);
if (_buffer.Count < 5) return;
for (var i = 0; i < _buffer.Count; i++)
{
if (_buffer.Count >= i + 5)
{
int unitId;
if (ErrorCodes.IsMonitoringTimeout(_buffer.Skip(i).Take(5).ToList(), out unitId))
{
i += 5;
_buffer.RemoveRange(0, 5);
OnMonitorTimer(unitId);
}
}
if (_buffer.Count < i + 10) continue;
ErrorLineModel error;
if (!ErrorCodes.GetErrorFromEscCode(_buffer.Skip(i).Take(10).ToArray(), out error)) continue;
i += 9;
_buffer.RemoveRange(0, 10);
OnErrorReceived(error);
}
if (_buffer.Count >= 19)
_buffer.RemoveRange(0, 10);
}
void server_Received(object sender, ReceivedEventArgs e)
{
var session = sender as ISocketSession;
var str = e.Stream.ToStr();
var remote = "" + session.Remote.EndPoint;
if (remote == "" + HoleServer)
{
WriteLog("HoleServer数据到来：{0} {1}", session.Remote, str);
var ss = str.Split(":");
if (ss == null || ss.Length < 2) return;
IPAddress address = null;
if (!IPAddress.TryParse(ss[0], out address)) return;
Int32 port = 0;
if (!Int32.TryParse(ss[1], out port)) return;
var ep = new IPEndPoint(address, port);
ParterAddress = ep;
Console.WriteLine("准备连接对方：{0}", ep);
while (Success <= 0)
{
(Server as UdpServer).Client.Send("Hello!", null, ep);
Thread.Sleep(100);
if (Success > 0) break;
Thread.Sleep(3000);
}
}
else if (remote == "" + ParterAddress)
{
WriteLog("Parter数据到来：{0} {1}", session.Remote, str);
//Success = true;
if (Success > 0) Success++;
//var session = e.Session;
if (session != null)
{
session.Send("P2P连接已建立！", null);
WriteLog("P2P连接已建立！");
session.Send("我与" + session.Remote + "的P2P连接已建立！", null);
while (true)
{
Console.Write("请输入要说的话：");
String line = Console.ReadLine();
if (String.IsNullOrEmpty(line)) continue;
if (line == "exit") break;
session.Send(line, null);
Console.WriteLine("已发送！");
}
}
}
else
{
WriteLog("未识别的数据到来：{0} {1}", session.Remote, str);
}
}
void client_Received(object sender, ReceivedEventArgs e)
{
var session = Session.Session;
var s = e.Stream;
//// 如果上次还留有数据，复制进去
//if (session.Stream != null && session.Stream.Position < session.Stream.Length)
//{
// var ms = new MemoryStream();
// session.Stream.CopyTo(ms);
// s.CopyTo(ms);
// s = ms;
//}
try
{
Process(s, session, session.Remote);
//// 如果还有剩下，写入数据流，供下次使用
//if (s.Position < s.Length)
// session.Stream = s;
//else
// session.Stream = null;
}
catch (Exception ex)
{
if (NetHelper.Debug) NetHelper.WriteLog(ex.ToString());
// 去掉内部异常，以免过大
if (ex.InnerException != null) ex.SetValue("_innerException", null);
var msg = new ExceptionMessage() { Value = ex };
session.Send(msg.GetStream());
//// 出错后清空数据流，避免连锁反应
//session.Stream = null;
}
}
protected override void OnReceived(ReceivedEventArgs args)
{
CurrentStatement = args.ReceivedObject as FtpStatement;
Console.WriteLine("[{0:000}]:{1} {2}", this.ChannelId, CurrentStatement.Name, CurrentStatement.Argument);
base.OnReceived(args);
}
void client_Received(object sender, ReceivedEventArgs e)
{
var session = Session;
try
{
var message = Message.Read(e.Stream);
Process(message, session.Remote);
}
catch (Exception ex)
{
var msg = new ExceptionMessage() { Value = ex };
Process(msg, session.Remote);
}
}
private void OnIrReceive(object sender, ReceivedEventArgs e)
{
try
{
if (_commands.Any(c => c.IrCode == e.IRCode))
{
var cmd = _commands.First(c => c.IrCode == e.IRCode);
Send(cmd, this);
}
}
catch (Exception ex)
{
Log.Error("Ir receivefailed", ex);
}
}
/// <summary>收到客户端发来的数据。子类可通过重载该方法来修改数据</summary>
/// <param name="e"></param>
protected override void OnReceive(ReceivedEventArgs e)
{
// 解析请求头
var stream = e.Stream;
var entity = HttpHeader.Read(stream, HttpHeaderReadMode.Request);
if (entity == null)
{
base.OnReceive(e);
return;
}
WriteLog("{3}请求：{0} {1} [{2}]", entity.Method, entity.Url, entity.ContentLength, ID);
Request = entity;
if (OnRequest != null) OnRequest(this, e);
var host = entity.Url.IsAbsoluteUri ? entity.Url.Host : Proxy.RemoteServer.Host;
Host = host;
RawHost = entity.Host;
entity.Host = host;
// 引用
var r = entity.Referer;
if (!String.IsNullOrEmpty(r))
{
Uri ri = new Uri(r, UriKind.RelativeOrAbsolute);
if (ri.IsAbsoluteUri && ri.Authority == RawHost)
{
r = r.Replace(RawHost, host);
entity.Referer = r;
}
}
//// 取消压缩
//var key = "Accept-Encoding";
//if (entity.Headers.ContainsKey(key)) entity.Headers.Remove(key);
// 重新构造请求
var ms = new MemoryStream();
entity.Write(ms);
stream.CopyTo(ms);
ms.Position = 0;
e.Stream = ms;
base.OnReceive(e);
}
void ConnectionReceived(object sender, ReceivedEventArgs e)
{
MultichannelMessage msg;
try
{
msg = (MultichannelMessage)e.Message;
}
catch(Exception exception)
{
Logger.ErrorFormat("Received invalid multichannel message: {0}", exception);
return;
}
if (!channels.ContainsKey(msg.ChannelId))
{
Logger.Error(String.Format("Received message of type {0} on unknown channel {1} -- Will be ignored", msg.Message.GetType(), msg.ChannelId));
return;
}
TunneledConnection channel = channels[msg.ChannelId];
channel.OnReceived(new ReceivedEventArgs(msg.Message));
}
void client_Received(object sender, ReceivedEventArgs e)
{
//WriteLog("数据到来：{0} {1}", e.RemoteIPEndPoint, e.GetString());
//var ss = e.GetString().Split(":");
var ss = e.Stream.ToStr().Split(":");
if (ss == null || ss.Length < 2) return;
IPAddress address = null;
if (!IPAddress.TryParse(ss[0], out address)) return;
Int32 port = 0;
if (!Int32.TryParse(ss[1], out port)) return;
var ep = new IPEndPoint(address, port);
ParterAddress = ep;
Client.Dispose();
var server = Server;
//Random rnd = new Random((Int32)DateTime.Now.Ticks);
Thread.Sleep(Rand.Next(0, 2000));
var client = new TcpSession();
Client = client;
//client.Address = server.LocalEndPoint.Address;
//client.Port = server.LocalEndPoint.Port;
//client.ReuseAddress = true;
client.Local.EndPoint = server.Local.EndPoint;
Console.WriteLine("准备连接对方：{0}", ep);
try
{
//client.Connect(ep);
client.Received += client_Received2;
client.ReceiveAsync();
Client.Send("Hello!");
}
catch (Exception ex)
{
WriteLog(ex.Message);
}
}
private void DataChannel_Closed(object sender, EventArgs e)
{
var dataChannel = sender as IFtpDataChannel;
if (dataChannel == null)
throw new ArgumentOutOfRangeException("sender");
dataChannel.Received -= DataChannel_Received;
dataChannel.Error -= DataChannel_Failed;
dataChannel.Closed -= DataChannel_Closed;
var channel = dataChannel.ServerChannel;
if (channel == null)
return;
if (channel.Status != FtpSessionStatus.Upload)
return;
var stream = channel.UpFileStream;
channel.UpFileStream = null;
if (stream != null)
stream.Dispose();
try
{
if (channel.UpFileFailed)
File.Delete(channel.UpFileLocalPath);
}
catch{ }
channel.Status = FtpSessionStatus.Wait;
if (!channel.UpFileFailed)
{
var statement = channel.CurrentStatement;
channel.Send("226 Transfer complete.");
if (statement != null &&
string.Equals(statement.Name, "STOR", StringComparison.OrdinalIgnoreCase))
{
var args = new ReceivedEventArgs(channel, statement);
Task.Factory.StartNew(() => channel.Server.NotifiyReceived(args));
}
}
channel.UpFileLocalPath = null;
}
private static void Svr_Received(Object sender, ReceivedEventArgs e)
{
XTrace.WriteLine(e.ToStr());
}
static void server_Received(Object sender, ReceivedEventArgs e)
{
OnReceive(sender as ISocketSession, e.Packet.GetStream());
}
/// <summary>收到客户端发来的数据。子类可通过重载该方法来修改数据</summary>
/// <param name="e"></param>
/// <returns>修改后的数据</returns>
protected override void OnReceiveRemote(ReceivedEventArgs e)
{
var pxy = Host as HttpProxy;
var parseHeader = pxy.EnableCache || pxy.GetHandler(EventKind.OnResponse) != null;
var parseBody = pxy.EnableCache || pxy.GetHandler(EventKind.OnResponseBody) != null;
var entity = UnFinishedResponse;
var stream = e.Packet.GetStream() as Stream;
if (parseHeader || parseBody)
{
#region 解析响应头
// 解析头部
if (entity == null)
{
#region 未完成响应为空，可能是第一个响应包，也可能是后续数据包
// 如果当前未完成响应为空，说明这是第一个数据包，可能包含头部
entity = HttpHeader.Read(stream, HttpHeaderReadMode.Response);
if (entity == null)
{
var he = new HttpProxyEventArgs(Response, stream);
if (pxy.RaiseEvent(this, EventKind.OnResponseBody, he))
{
return;
}
//e.Stream = he.Stream;
e.Packet = he.Stream.ReadBytes();
// 如果现在正在缓存之中，那么也罢这些非头部数据一并拷贝到缓存里面
if (cacheItem != null)
{
var ms = e.Packet.GetStream();
var p = ms.Position;
ms.CopyTo(cacheItem.Stream);
var count = ms.Position = p;
ms.Position = p;
//WriteDebugLog("[{0}] {1} 缓存数据[{2}]", ID, Request.RawUrl, count);
}
base.OnReceiveRemote(e);
return;
}
if (!entity.IsFinish)
{
UnFinishedResponse = entity;
}
else
{
Response = entity;
}
#endregion
}
else if (!entity.IsFinish)
{
#region 未完成响应，继续读取头部
// 如果请求未完成，说明现在的数据内容还是头部
entity.ReadHeaders(stream);
if (entity.IsFinish)
{
Response = entity;
UnFinishedResponse = null;
}
#endregion
}
else
{
#region 未完成响应的头部已完成？似乎不大可能
// 否则，头部已完成，现在就是内容
var he = new HttpProxyEventArgs(Response, stream);
if (pxy.RaiseEvent(this, EventKind.OnResponseBody, he))
{
return;
}
base.OnReceiveRemote(e);
//e.Stream = he.Stream;
e.Packet = he.Stream.ReadBytes();
// 如果现在正在缓存之中，那么也罢这些非头部数据一并拷贝到缓存里面
if (cacheItem != null)
{
var ms = e.Packet.GetStream();
var p = ms.Position;
ms.CopyTo(cacheItem.Stream);
var count = ms.Position = p;
ms.Position = p;
//WriteDebugLog("[{0}] {1} 缓存数据[{2}]", ID, Request.RawUrl, count);
}
return;
#endregion
}
#endregion
// 请求头不完整，不发送，等下一部分到来
if (!entity.IsFinish)
{
return;
}
{
var he = new HttpProxyEventArgs(entity, stream);
if (pxy.RaiseEvent(this, EventKind.OnResponse, he))
{
return;
}
stream = he.Stream;
}
// 写入头部扩展
entity.Headers["Powered-By-Proxy"] = pxy.Name;
entity.Headers["RequestTime"] = RequestTime.ToString("yyyy-MM-dd HH:mm:ss.fff");
entity.Headers["TotalTime"] = (DateTime.Now - RequestTime).ToString();
}
#region 缓存
if (pxy.EnableCache)
{
SetCache(Response, e);
}
#endregion
#region 重构响应包
if (entity != null)
{
var ms = new MemoryStream();
entity.Write(ms);
if (parseBody && stream.Position < stream.Length)
{
var he = new HttpProxyEventArgs(Response, stream);
if (pxy.RaiseEvent(this, EventKind.OnResponseBody, he))
{
return;
}
stream = he.Stream;
}
stream.CopyTo(ms);
ms.Position = 0;
//stream = ms;
//e.Stream = ms;
e.Packet = ms.ToArray();
}
if (cacheItem != null)
{
var ms = e.Packet.GetStream();
var p = ms.Position;
ms.CopyTo(cacheItem.Stream);
var count = ms.Position = p;
ms.Position = p;
//WriteDebugLog("[{0}] {1} 增加缓存[{2}]", ID, Request.RawUrl, count);
}
#endregion
base.OnReceiveRemote(e);
}
private void ChannelOnReceived(ILetter letter, ReceivedEventArgs receivedEventArgs)
{
Received(letter, receivedEventArgs);
}
/// <summary>
/// 接收事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TcpClient_OnReceive(object sender, ReceivedEventArgs e)
{
try { this.Invoke(new OnReceviceCallBack(Receive), sender, e); }
catch (Exception ex) { YsuSoftHelper.Helper.logHelper.WriteErrLog("iTcpClient1_OnRecevice", ex); }
}
private void session_Received(object sender, ReceivedEventArgs e)
{
Process(sender as ISocketSession, e);
}
private static void Show_Incoming_PersonCreated(object sender, ReceivedEventArgs e)
{
Console.WriteLine(e);
}
internal void InvokeReceivedEvent(ReceivedEventArgs args)
{
OnReceivedEvent?.Invoke(this, args);
}
void Client_Received(object sender, ReceivedEventArgs e)
{
}
static void svr_Received(object sender, ReceivedEventArgs e)
{
XTrace.WriteLine(e.ToStr());
}
static void _udpServer_Received(object sender, ReceivedEventArgs e)
{
var session = sender as ISocketSession;
XTrace.WriteLine("{0} [{1}]：{2}", session.Remote, e.Stream.Length, e.Stream.ReadBytes().ToHex());
}
void OnReceived(Object sender, ReceivedEventArgs e)
{
var data = e.Packet.ReadBytes();
if (data == null || data.Length < 1)
{
return;
}
BytesOfReceived += data.Length;
// 处理数据委托
if (Received != null)
{
var e2 = new BufferEventArgs {
Value = data
};
Received(this, e2);
if (!e2.Cancel)
{
return;
}
// 外部可能修改了数据
data = e2.Value;
//if (!BufferEventArgs.Invoke(Received, data)) return null;
}
// 处理字符串委托
if (ReceivedString == null)
{
return;
}
var cfg = SerialPortConfig.Current;
var line = "";
if (cfg.HexShow)
{
if (data.Length > 32)
{
line = "[{0}]=\r\n{1}".F(data.Length, data.ToHex("-", 32));
}
else
{
line = "[{0}]={1}".F(data.Length, data.ToHex("-", 32));
}
if (cfg.HexNewLine)
{
line += Environment.NewLine;
}
}
else
{
line = cfg.Encoding.GetString(data);
if (_stream == null)
{
_stream = new MemoryStream();
}
else if (_stream.Length > 10 * 1024 && _stream.Position == _stream.Length) // 达到最大大小时，从头开始使用
{
_stream = new MemoryStream();
}
_stream.Write(data);
_stream.Seek(-1 * data.Length, SeekOrigin.Current);
if (_reader == null ||
_reader.BaseStream != _stream ||
_reader.CurrentEncoding != cfg.Encoding)
{
_reader = new StreamReader(_stream, cfg.Encoding);
}
line = _reader.ReadToEnd();
// 替换掉无效数据
line = line.Replace("\0", null);
}
ReceivedString?.Invoke(this, new StringEventArgs {
Value = line
});
}
private void DataChannel_Closed(object sender, EventArgs e)
{
var dataChannel = sender as IFtpDataChannel;
if (dataChannel == null)
{
throw new ArgumentOutOfRangeException("sender");
}
dataChannel.Received -= DataChannel_Received;
dataChannel.Error -= DataChannel_Failed;
dataChannel.Closed -= DataChannel_Closed;
var channel = dataChannel.ServerChannel;
if (channel == null)
{
return;
}
if (channel.Status != FtpSessionStatus.Upload)
{
return;
}
var stream = channel.UpFileStream;
channel.UpFileStream = null;
if (stream != null)
{
stream.Dispose();
}
try
{
if (channel.UpFileFailed)
{
File.Delete(channel.UpFileLocalPath);
}
}
catch { }
channel.Status = FtpSessionStatus.Wait;
if (!channel.UpFileFailed)
{
var statement = channel.statement;
channel.Send("226 Transfer complete.");
if (statement != null &&
string.Equals(statement.Name, "STOR", StringComparison.OrdinalIgnoreCase))
{
var args = new ReceivedEventArgs(channel, statement);
Task.Factory.StartNew(() => channel.Server.NotifiyReceived(args));
}
}
channel.UpFileLocalPath = null;
}
public void ItExists()
{
ReceivedEventArgs args = new ReceivedEventArgs("value");
}
private void InterfaceOnDataReceived(object sender, ReceivedEventArgs receivedEventArgs)
{
if (_data.CheckData(receivedEventArgs.Bytes))
{
_sendState.Fire(SendEvent.Succes);
}
else
{
Debug.WriteLine("DataSender: ReceivePart " + _data.ModuleName);
}
}
private void OnReceived(Object sender, ReceivedEventArgs e)
{
var session = sender as NetSession;
if (session == null)
{
return;
}
var msg = ModbusMessage.Read(e.Packet);
if (msg == null)
{
return;
}
session.Log?.Info("<= {0}", msg);
var rs = msg.CreateReply();
switch (msg.Code)
{
case FunctionCodes.ReadCoil:
case FunctionCodes.ReadDiscrete:
{
// 连续地址
var count = (Int32)Math.Ceiling(msg.Count / 8.0);
var addr = msg.Address - _data[0].Address;
if (addr >= 0 && addr + count <= _data.Count)
{
rs.Payload = _data.Skip(addr).Take(count).SelectMany(e => e.Value.GetBytes()).ToArray();
}
}
break;
case FunctionCodes.ReadRegister:
case FunctionCodes.ReadInput:
{
// 连续地址
var addr = msg.Address - _data[0].Address;
if (addr >= 0 && addr + msg.Count <= _data.Count)
{
rs.Payload = _data.Skip(addr).Take(msg.Count).SelectMany(e => e.Value.GetBytes()).ToArray();
}
}
break;
case FunctionCodes.WriteCoil:
break;
case FunctionCodes.WriteRegister:
break;
case FunctionCodes.WriteCoils:
break;
case FunctionCodes.WriteRegisters:
break;
default:
break;
}
session.Log?.Info("=> {0}", rs);
session.Send(rs.ToPacket());
}
private void Channel_Received(object sender, ReceivedEventArgs e)
{
this.OnReceived(e);
}
/// <summary>收到新的Http请求，只有头部</summary>
/// <param name="request"></param>
/// <param name="e"></param>
protected virtual void OnNewRequest(HttpRequest request, ReceivedEventArgs e)
{
}
private static void OnReceive(object sender, ReceivedEventArgs e)
{
Console.WriteLine("Received: " + e.IRCode);
}
/// <summary>收到客户端发来的数据</summary>
/// <param name="e"></param>
protected override void OnReceive(ReceivedEventArgs e)
{
if (e.Packet.Total == 0 /*|| !HttpBase.FastValidHeader(e.Packet)*/)
{
base.OnReceive(e);
return;
}
// WebSocket 数据
if (_websocket != null)
{
_websocket.Process(e.Packet);
base.OnReceive(e);
return;
}
var req = Request;
var request = new HttpRequest();
if (request.Parse(e.Packet))
{
req = Request = request;
WriteLog("{0} {1}", request.Method, request.Url);
_websocket = null;
OnNewRequest(request, e);
// 后面还有数据包，克隆缓冲区
if (req.IsCompleted)
{
_cache = null;
}
else
{
// 限制最大请求为1G
if (req.ContentLength > 1 * 1024 * 1024 * 1024)
{
var rs = new HttpResponse {
StatusCode = HttpStatusCode.RequestEntityTooLarge
};
Send(rs.Build());
Dispose();
return;
}
_cache = new MemoryStream(req.ContentLength);
req.Body.CopyTo(_cache);
//req.Body = req.Body.Clone();
}
}
else if (req != null)
{
// 链式数据包
//req.Body.Append(e.Packet.Clone());
e.Packet.CopyTo(_cache);
if (_cache.Length >= req.ContentLength)
{
_cache.Position = 0;
req.Body = new Packet(_cache);
_cache = null;
}
}
// 收到全部数据后，触发请求处理
if (req != null && req.IsCompleted)
{
var rs = ProcessRequest(req, e);
if (rs != null)
{
var server = (this as INetSession).Host as HttpServer;
if (!server.ServerName.IsNullOrEmpty() && !rs.Headers.ContainsKey("Server"))
{
rs.Headers["Server"] = server.ServerName;
}
var closing = !req.KeepAlive && _websocket == null;
if (closing && !rs.Headers.ContainsKey("Connection"))
{
rs.Headers["Connection"] = "close";
}
Send(rs.Build());
if (closing)
{
Dispose();
}
}
}
base.OnReceive(e);
}
/// <summary>收到请求时</summary>
/// <param name="entity"></param>
/// <param name="e"></param>
/// <returns></returns>
protected virtual Boolean OnRequest(HttpHeader entity, ReceivedEventArgs e)
{
var host = "";
var oriUrl = entity.Url;
// 特殊处理CONNECT
if (entity.Method.EqualIgnoreCase("CONNECT"))
{
return(ProcessConnect(entity, e));
}
// 检查缓存
if (GetCache(entity, e))
{
return(false);
}
var remote = RemoteServer;
var ruri = RemoteServerUri;
if (entity.Url.IsAbsoluteUri)
{
var uri = entity.Url;
host = uri.Host + ":" + uri.Port;
// 如果地址或端口改变，则重新连接服务器
if (remote != null && (uri.Host != ruri.Host || uri.Port != ruri.Port))
{
remote.Dispose();
RemoteServer = null;
}
//RemoteHost = uri.Host;
//LastPort = uri.Port;
//RemoteEndPoint = new IPEndPoint(NetHelper.ParseAddress(uri.Host), uri.Port);
ruri.Host = uri.Host;
ruri.Port = uri.Port;
entity.Url = new Uri(uri.PathAndQuery, UriKind.Relative);
}
else if (!String.IsNullOrEmpty(entity.Host))
{
//RemoteEndPoint = NetHelper.ParseEndPoint(entity.Host, 80);
ruri.Host = entity.Host;
ruri.Port = 80;
}
else
{
throw new XException("无法处理的请求！{0}", entity);
}
//WriteDebugLog("[{4}] {3} => {0} {1} [{2}]", entity.Method, oriUrl, entity.ContentLength, Session.Remote.EndPoint, ID);
// 可能不含Host
if (String.IsNullOrEmpty(entity.Host))
{
entity.Host = host;
}
// 处理KeepAlive
KeepAlive = false;
if (!String.IsNullOrEmpty(entity.ProxyConnection))
{
entity.KeepAlive = entity.ProxyKeepAlive;
entity.ProxyConnection = null;
KeepAlive = entity.ProxyKeepAlive;
}
RequestTime = DateTime.Now;
return(true);
}
protected virtual void OnReceived(ReceivedEventArgs args)
{
//处理接收到的数据
Utility.ProcessReceive(_executor, args);
if(this.Received != null)
this.Received(this, args);
}
private void OnRecieved(object sender, ReceivedEventArgs e)
{
_lastReceivedCode = e.IRCode;
_waitHandle.Set();
}
private void OnReceived(object sender, ReceivedEventArgs e)
{
lock (testLock)
{
IList<ArraySegment<byte>> buffers = e.Buffers;
ArraySegment<byte> pong = buffers[0];
clientResult = UTF8Encoding.Default.GetString(pong.Array);
Monitor.Pulse(testLock);
}
}
private void Session_Received(object sender, ReceivedEventArgs e)
{
e.Feedback = true;
}
private void RaiseReceived(ReceivedEventArgs e)
{
Received?.Invoke(this, e);
}
private void ChannelReceived(ILetter letter, ReceivedEventArgs receivedEventArgs)
{
Action<ILetter, IReceivedEventArgs> evnt = Received;
if(evnt != null) {
receivedEventArgs.Socket = this;
evnt(letter, receivedEventArgs);
}
}
/// <summary>处理收到的数据</summary>
/// <param name="e"></param>
protected override void OnReceive(ReceivedEventArgs e)
{
//base.OnReceive(e);
var stream = e.Packet.GetStream();
// 第一个数据包解析头部
if (e.Packet.Total > 0 && Inf == null)
{
var fi = new FileFormat();
try
{
fi.Read(stream);
if (fi.Checksum != fi.Crc)
{
throw new XException("文件{0}校验和错误{1:X8}!={2:X8}！", fi.Name, fi.Checksum, fi.Crc);
}
}
catch (Exception ex)
{
WriteError("无法解析文件头！{0}", ex.Message);
// 如果加载失败，则关闭会话
Dispose();
return;
}
Inf = fi;
Length = 0;
if (StartTime == DateTime.MinValue)
{
StartTime = Session.StartTime;
}
// 加大网络缓冲区
Session.Client.ReceiveBufferSize = 8 * 1024 * 1024;
var file = Host.SavedPath.CombinePath(Inf.Name).EnsureDirectory();
Stream = file.AsFile().OpenWrite();
WriteLog("接收{0}，{1:n0}kb", Inf.Name, Inf.Length / 1024);
if (stream.Position >= stream.Length)
{
return;
}
}
var len = stream.Length - stream.Position;
if (len > 0)
{
Length += len;
var ms = (DateTime.Now - StartTime).TotalMilliseconds;
var speed = Length / 1024 / ms * 1000;
WriteLog("收到{0:n0}字节，{1:n0}kb/s，完成{2:p}", len, (Int32)speed, (Double)Length / Inf.Length);
if (Stream != null && Stream.CanWrite)
{
Stream.Write(stream);
}
//}
//else
//{
if (Length >= Inf.Length)
{
//var ms = (DateTime.Now - StartTime).TotalMilliseconds;
//var speed = Length / 1024 / ms * 1000;
WriteLog("{0}接收完成，{1:n0}ms，{2:n0}kb/s", Inf.Name, (Int32)ms, (Int32)speed);
//Dispose();
// 清空，方便接收下一个文件
Inf = null;
CloseStream();
StartTime = DateTime.MinValue;
}
}
}
private void ReadCallback(IAsyncResult ar)
{
string content = string.Empty;
StringBuilder rb = new StringBuilder();
PanelLibrary state = (PanelLibrary)ar.AsyncState;
if (state.WorkSocket != null && state.WorkSocket.Connected)
{
try
{
Socket handler = state.WorkSocket;
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
List<byte> raw = new List<byte>();
for (int loop = 0; loop < bytesRead; loop++)
{
raw.Add(state.Buffer[loop]);
}
Decode translate = new Decode();
translate.ToReadable(state.Buffer, 0, bytesRead);
rb.Length = 0;
rb.AppendFormat("[recv: {0,4} bytes on {1:H:mm:ss.fff} port: {2,5}]\t{3}", bytesRead, DateTime.Now, state.WorkSocket.Handle, translate.Decoded);
ReceivedEventArgs de = new ReceivedEventArgs();
de.Message = rb.ToString();
de.ClientSocket = state.WorkSocket;
de.Raw = raw;
Events.DoReceived(this, de);
Array.Clear(state.Buffer, 0, bytesRead);
handler.BeginReceive(state.Buffer, 0, state.BufferSize, 0, new AsyncCallback(ReadCallback), state);
}
}
catch (ObjectDisposedException)
{
ClientDisconnected(state);
_clientSockets.Remove(state.WorkSocket);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.WouldBlock ||
se.SocketErrorCode == SocketError.IOPending ||
se.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
{
return;
}
else
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("ReadCallback({0}) Socket Exception - {1}", se.SocketErrorCode, se.Message);
Events.DoLog(this, sb.ToString());
ClientDisconnected(state);
_clientSockets.Remove(state.WorkSocket);
}
}
}
}
private void SocketTcpClient_OnRecevice(object sender, ReceivedEventArgs e)
{
this.received += " " + e.ReceivedHexString;
this.Infos.Timer = 0;
}
void client_Received2(object sender, ReceivedEventArgs e)
{
var session = sender as ISocketSession;
WriteLog("数据到来2：{0} {1}", session.Remote, e.Stream.ToStr());
}
private void SocketTcpServer_TcpServerRecevice(Socket temp, ReceivedEventArgs e)
{
this.received += " " + e.ReceivedHexString;
this.Infos.Timer = 0;
}
internal new void OnReceived(ReceivedEventArgs e)
{
base.OnReceived(e);
}
protected override void OnReceived(ReceivedEventArgs args)
{
var statement = args.ReceivedObject as FtpStatement;
object result = null;
if(statement != null)
{
try
{
result = _commandExecutor.Execute(statement.Name, args);
}
catch(CommandNotFoundException)
{
args.Channel.Send("502 Command not implemented.", null);
}
}
if(result != null)
{
//调用基类同名方法
base.OnReceived(new ReceivedEventArgs(args.Channel, result));
}
}
public object Execute(string name, ReceivedEventArgs args)
{
return base.Execute(name, args);
}
void _serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
StringBuilder sb = new StringBuilder();
if (_serialPort != null)
{
int numBytes = _serialPort.BytesToRead;
List<byte> newReceived = new List<byte>();
for (int count = 0; count < numBytes; count++)
{
newReceived.Add((byte)_serialPort.ReadByte());
}
Decode dec = new Decode();
dec.ToReadable(newReceived.ToArray());
sb.Length = 0;
sb.AppendFormat("[recv: {0,4} bytes on {1:H:mm:ss.fff}]{2}", newReceived.Count, DateTime.Now, dec.Decoded);
ReceivedEventArgs de = new ReceivedEventArgs();
de.Message = sb.ToString();
de.Port = _serialPort.PortName;
de.Raw = newReceived;
Events.DoReceived(this, de);
}
}
void client_PlaintextReceived(object sender, ReceivedEventArgs<string> e)
{
JsonMutualObject JsonMutualObject1 = new JsonMutualObject();
this.txtReceive.Dispatcher.Invoke(new Action(() => { txtReceive.Text = e.Datagram;
if (e.Datagram.IndexOf(ConfigurationManager.AppSettings["CustomTerminatorSign"])>0) //判断当前服务器端返回的消息是否有终结符，如果没有，则表示信息丢失了，或传输不完整。
{
string BackInfo = e.Datagram.Replace(ConfigurationManager.AppSettings["CustomTerminatorSign"], "");
if (BackInfo.IndexOf("Welcome:") == 0) //判断是否是连接服务器之后，服务器返回的欢迎消息。
{
string msgTmp = BackInfo.Replace("Welcome:", ""); //Welcome:为和服务器端约定的业务协议简述。然后再把终结符也取消掉。剩下的就是一个标准的json
BasicMsgEntity deviceLoginEntity = JsonMutualObject1.ScriptDeserialize<BasicMsgEntity>(msgTmp); //Json字符串转换为类
if (deviceLoginEntity != null)
{
SessionID_Temp = deviceLoginEntity.key;
}
}
else if (BackInfo.IndexOf("DeviceLogin:"******"\"status\": 1")>0) //status:1表示登录成功
{
btnUserLogin.IsEnabled = false;
}
}
else if (BackInfo.IndexOf("TerminalEquipment:") == 0) //服务器端发来的“终端指令信息。”，CommandTypeId表示发送的指令类型，1表示开机，2表示关机，3表示重启，4表示播放，5表示停止，6表示暂停,7表示文字类时时公告信息
{
#region//模拟已经成功执行指令，返回正确信息给服务器
string msgTmp = BackInfo.Replace("TerminalEquipment:", "");
TerminalEquipmentSerialCommand_EntityModel terminalEquipmentEntity = JsonMutualObject1.ScriptDeserialize<TerminalEquipmentSerialCommand_EntityModel>(msgTmp); //Json字符串转换为类
if (terminalEquipmentEntity!=null)
{
if (terminalEquipmentEntity.status==0)
{
MessageBox.Show(terminalEquipmentEntity.msg);
}
else
{
string ReadySendMsg = "TerminalEquipment:"; //分号前面表示 大的业务类别简述,是一个和服务器端通讯的约定。此时表示服务器发送的 终端指令信息
JsonObjectCollection delivered = new JsonObjectCollection();
delivered.Add(new JsonStringValue("ReceiveBackTime", DateTime.Now.ToString()));
delivered.Add(new JsonStringValue("msg", "客户端已成功执行终端指令"));
delivered.Add(new JsonNumericValue("TerSerialCommandID", Convert.ToInt32(terminalEquipmentEntity.TerSerialCommandID)));
delivered.Add(new JsonNumericValue("status", 1));
ReadySendMsg = ReadySendMsg + delivered.ToString();
client.Send(ReadySendMsg);
}
}
#endregion
}
else if (BackInfo.IndexOf("TerminalProgram:") == 0) //服务器端发来的“节目制作信息。”
{
#region//模拟已经成功执行指令，返回正确信息给服务器
string msgTmp = BackInfo.Replace("TerminalProgram:", "");
try
{
ProgramSendSerialList_EntityModel programSendSerialList_EntityModel = JsonMutualObject1.ScriptDeserialize<ProgramSendSerialList_EntityModel>(msgTmp); //Json字符串转换为类
if (programSendSerialList_EntityModel != null)
{
if (programSendSerialList_EntityModel.status == 0)
{
MessageBox.Show(programSendSerialList_EntityModel.msg);
}
else
{
string ReadySendMsg = "TerminalProgram:"; //分号前面表示 大的业务类别简述,是一个和服务器端通讯的约定。此时表示服务器发送的 终端指令信息
JsonObjectCollection delivered = new JsonObjectCollection();
delivered.Add(new JsonStringValue("ReceiveBackTime", DateTime.Now.ToString()));
delivered.Add(new JsonStringValue("msg", "客户端已成功执行终端指令"));
delivered.Add(new JsonNumericValue("ProgramSendSerialID", Convert.ToInt32(programSendSerialList_EntityModel.ProgramSendSerialID)));
delivered.Add(new JsonNumericValue("status", 1));
ReadySendMsg = ReadySendMsg + delivered.ToString();
client.Send(ReadySendMsg);
}
}
}
catch //(Exception)
{
string ReadySendMsg = "TerminalProgram:"; //分号前面表示 大的业务类别简述,是一个和服务器端通讯的约定。此时表示服务器发送的 终端指令信息
JsonObjectCollection delivered = new JsonObjectCollection();
delivered.Add(new JsonStringValue("ReceiveBackTime", DateTime.Now.ToString()));
delivered.Add(new JsonStringValue("msg", "客户端接收到的json格式不对，疑似数据包丢失"));
delivered.Add(new JsonNumericValue("ProgramSendSerialID", 0));
delivered.Add(new JsonNumericValue("status", 0));
ReadySendMsg = ReadySendMsg + delivered.ToString();
client.Send(ReadySendMsg);
}
#endregion
}
}
}));
}
/// <summary>
/// 开始接收网关上传的数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void socketServer_OnDataReceived(object sender, ReceivedEventArgs <byte[]> e)
{
AsyncSocketConnection conn = (AsyncSocketConnection)sender;
TPKGHead packet = new TPKGHead();
bool isOk = false;
try
{
isOk = packet.Parse(e.Data);//解析收到的数据包
log.Info($"SensorNetwork.Server.Management.Framework中接收的包，Serv_Type:" + packet.Serv_Type + ",Serv_Code:" + packet.Serv_Code + "包数据域Data：\r\n{" + packet.Data.ToBytes().ToHexString() + "}");
if (isOk == false)
{
log.Error($"包解析错误：\r\n{BitConverter.ToString(e.Data).Replace("-", " ")}");
}
else
{
log.Info($"包解析成功(16进制)：\r\n{BitConverter.ToString(e.Data).Replace("-", " ")}");
log.Info($"包数据域：\r\n{packet.Data.ToString()}");
}
bool isNew = isOk && string.IsNullOrWhiteSpace(conn.TerminalId) && string.IsNullOrWhiteSpace(packet.Term_Code) == false;
if (isNew)
{
AddLog(packet.Term_Code, "设备已连接。");
}
if (string.IsNullOrWhiteSpace(packet.Term_Code) == false)
{
conn.TerminalId = packet.Term_Code;
lastAlive[packet.Term_Code] = Tuple.Create(conn.Token, DateTime.Now);
//if (conn.Protocol == null)
// conn.Protocol = ProtocolManager.Find(packet.Term_Code);
var s = Newtonsoft.Json.JsonConvert.SerializeObject(packet.Data);
AddLog(packet.Term_Code, packet.Data, "收到数据包：Data:{0}", packet.Data.ToString());
}
Interlocked.Increment(ref receivedMessageCount);
conn.LastAlive = DateTime.Now;//更新连接的最后活动时间
//else
//{
// var json = Newtonsoft.Json.JsonConvert.SerializeObject(packet.Data, Newtonsoft.Json.Formatting.Indented);
// log.DebugFormat("{0}\nMACID: {1}\n{2}", packet., packet.Id, json);
//}
if (isOk) //如果解析成功
{
ackQueue.Enqueue(Tuple.Create(conn, packet)); //将接收到的数据包放到队列中
if (isNew) //如果是一条新的连接，则创建一条新的连接写入DB中
{
newConnections.Enqueue(new TerminalConnectionLog()
{
id = conn.Token,//guid
connected = conn.Created,
ipaddress = conn.RemoteEndPoint.ToString(),
server_id = ServerId,
terminal_id = conn.TerminalId,
disconnected = conn.Created,
});
conn.Closed += AsyncSocketConnection_Closed;
log.DebugFormat("new client: {0}", conn.TerminalId);
}
}
}
catch (Exception ex)
{
log.Error($"包解析/处理异常：\r\n{BitConverter.ToString(e.Data).Replace("-", " ")}");
log.Error(ex);
}
}
void client_Received2(Object sender, ReceivedEventArgs e)
{
var session = sender as ISocketSession;
WriteLog("数据到来2：{0} {1}", session.Remote, e.Stream.ToStr());
}
void OnReceive(object sender, ReceivedEventArgs e)
{
Boolean valid = false;
var code = e.IRCode;
var now = DateTime.UtcNow;
// we keep track of when we see codes so we don't fire too often
lock (this.Locker) {
DateTime lastTime;
if (this.LastSeen.TryGetValue(code, out lastTime))
{
if (now - lastTime > MinimumDuration)
{
valid = true;
}
}
else
{
valid = true;
}
if (valid)
{
this.LastSeen[code] = now;
}
}
//Console.WriteLine("IR RX: " + e.IRCode + " " + valid);
if (!valid)
{
return;
}
GenericCommand ev = null;
switch (code)
{
// OK button
case "230A011050A5":
ev = this.OnDvrOk;
break;
// Red C button
case "2308041050A5":
ev = this.OnDvrAv;
break;
case "2308151050A5":
ev = this.OnDvrChannelUp;
break;
case "2308150450A5":
ev = this.OnDvrChannelDown;
break;
case "435B541051F4":
ev = this.OnOppoOk;
break;
default:
break;
}
if (ev != null)
{
ev();
}
}
internal void NotifiyReceived(ReceivedEventArgs args)
{
var statement = args.ReceivedObject as FtpStatement;
if(statement != null)
{
//Console.WriteLine("{0}:{1}:{2}", statement.Name, statement.Argument, statement.Result);
}
base.OnReceived(args);
}
void server_Received(Object sender, ReceivedEventArgs e)
{
var session = sender as ISocketSession;
var str = e.Stream.ToStr();
var remote = "" + session.Remote.EndPoint;
if (remote == "" + HoleServer)
{
WriteLog("HoleServer数据到来：{0} {1}", session.Remote, str);
var ss = str.Split(":");
if (ss == null || ss.Length < 2)
{
return;
}
IPAddress address = null;
if (!IPAddress.TryParse(ss[0], out address))
{
return;
}
var port = 0;
if (!Int32.TryParse(ss[1], out port))
{
return;
}
var ep = new IPEndPoint(address, port);
ParterAddress = ep;
Console.WriteLine("准备连接对方：{0}", ep);
while (Success <= 0)
{
(Server as UdpServer).Client.Send("Hello!", null, ep);
Thread.Sleep(100);
if (Success > 0)
{
break;
}
Thread.Sleep(3000);
}
}
else if (remote == "" + ParterAddress)
{
WriteLog("Parter数据到来：{0} {1}", session.Remote, str);
//Success = true;
if (Success > 0)
{
Success++;
}
//var session = e.Session;
if (session != null)
{
session.Send("P2P连接已建立！", null);
WriteLog("P2P连接已建立！");
session.Send("我与" + session.Remote + "的P2P连接已建立！", null);
while (true)
{
Console.Write("请输入要说的话：");
var line = Console.ReadLine();
if (String.IsNullOrEmpty(line))
{
continue;
}
if (line == "exit")
{
break;
}
session.Send(line, null);
Console.WriteLine("已发送！");
}
}
}
else
{
WriteLog("未识别的数据到来：{0} {1}", session.Remote, str);
}
}
//List<String> process = new List<String>();
void Udp_Received(Object sender, ReceivedEventArgs e)
{
var content = e.Packet.ToStr();
if (String.IsNullOrEmpty(content))
{
return;
}
//var udp = e as UdpReceivedEventArgs;
var remote = e.Remote;
var address = remote.Address;
WriteLog("发现UPnP设备：{0}", remote);
//分析数据并反序列化
var sp = "LOCATION:";
var p = content.IndexOf(sp);
if (p <= 0)
{
return;
}
var url = content.Substring(p + sp.Length);
p = url.IndexOf(Environment.NewLine);
if (p <= 0)
{
return;
}
url = url.Substring(0, p);
url = url.Trim();
if (String.IsNullOrEmpty(url))
{
return;
}
try
{
//下载IGD.XML
var client = new WebClient();
var xml = client.DownloadString(url);
if (xml != null)
{
xml = xml.Trim();
}
var uri = new Uri(url);
if (CacheGateway)
{
File.WriteAllText(GetCacheFile(uri.Host), xml);
}
AddGateway(uri.Host, xml, false);
}
catch (Exception ex)
{
WriteLog(ex.Message + " 路径[" + url + "]");
throw;
}
}
private void FooUserControl_OnSomethingReceived(object sender, ReceivedEventArgs e)
{
Debug.WriteLine("Received: " + e.Data);
}
protected virtual void OnDataReceived(ReceivedEventArgs e)
{
EventHandler<ReceivedEventArgs> handler = DataReceived;
if (handler != null) handler(this, e);
}
static void server_Received(object sender, ReceivedEventArgs e)
{
OnReceive(sender as ISocketSession, e.Stream);
}
private void RaiseReceived(object receivedObject)
{
//更新最后接收到数据的时间，因为空包也要计算在内，所以必须放在下面的条件判断之前
this.LastReceivedTime = DateTime.Now;
//创建接收数据事件参数对象
var eventArgs = new ReceivedEventArgs(this, receivedObject);
//启动一个新异步任务进行事件回调
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
//激发当前通道的“Received”事件
this.OnReceived(eventArgs);
//如果接收到的对象是流则关闭它
if(receivedObject is Stream)
((Stream)receivedObject).Dispose();
});
}
/// <summary>收到客户端发来的数据。子类可通过重载该方法来修改数据</summary>
/// <remarks>
/// 如果数据包包括头部和主体，可以分开处理。
/// 最麻烦的就是数据包不是一个完整的头部，还落了一部分在后面的包上。
/// </remarks>
/// <param name="e"></param>
protected override void OnReceive(ReceivedEventArgs e)
{
if (e.Packet.Total == 0)
{
base.OnReceive(e);
return;
}
var pxy = Host as HttpProxy;
#region 解析请求头
// 解析请求头。
var stream = e.Packet.GetStream() as Stream;
// 当前正在处理的未完整的头部，浏览器可能把请求头分成几块发过来
var entity = UnFinishedRequest;
// 如果当前请求为空，说明这是第一个数据包，可能包含头部
if (entity == null)
{
// 读取并分析头部
entity = HttpHeader.Read(stream, HttpHeaderReadMode.Request);
if (entity == null)
{
// 分析失败？这个可能不是Http请求头
var he = new HttpProxyEventArgs(Request, stream);
if (pxy.RaiseEvent(this, EventKind.OnRequestBody, he))
{
return;
}
//e.Stream = he.Stream;
e.Packet = he.Stream.ReadBytes();
base.OnReceive(e);
return;
}
// 根据完成情况保存到不同的本地变量中
if (!entity.IsFinish)
{
UnFinishedRequest = entity;
}
else
{
Request = entity;
}
}
else if (!entity.IsFinish)
{
// 如果请求未完成，说明现在的数据内容还是头部
entity.ReadHeaders(stream);
if (entity.IsFinish)
{
Request = entity;
UnFinishedRequest = null;
}
}
else
{
// 否则，头部已完成，现在就是内容，直接转发
var he = new HttpProxyEventArgs(Request, stream);
if (pxy.RaiseEvent(this, EventKind.OnRequestBody, he))
{
return;
}
//e.Stream = he.Stream;
e.Packet = he.Stream.ReadBytes();
base.OnReceive(e);
return;
}
// 请求头不完整，不发送，等下一部分到来
if (!entity.IsFinish)
{
return;
}
#endregion
WriteLog("{0}", entity.Url);
#region 重构请求包
// 现在所在位置是一个全新的请求
var rs = OnRequest(entity, e);
{
var he = new HttpProxyEventArgs(Request, stream)
{
Cancel = !rs
};
rs = !pxy.RaiseEvent(this, EventKind.OnRequest, he);
}
if (!rs)
{
return;
}
// 如果流中还有数据，可能是请求体，也要拷贝
if (stream.Position < stream.Length)
{
var he = new HttpProxyEventArgs(Request, stream);
if (pxy.RaiseEvent(this, EventKind.OnRequestBody, he))
{
return;
}
stream = he.Stream;
}
// 重新构造请求
var ms = new MemoryStream();
entity.Write(ms);
stream.CopyTo(ms);
ms.Position = 0;
//e.Stream = ms;
e.Packet = ms.ToArray();
#endregion
base.OnReceive(e);
}
void Client_Received(object sender, ReceivedEventArgs e)
{
}
public object Execute(string name, ReceivedEventArgs args)
{
return(base.Execute(name, args));
}
