static void DataOn(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt = read.ReadInt32();
if (lengt == read.Length)
{
int cmd = read.ReadInt32();
switch (cmd)
{
case 1000:
{
string msg = read.ReadString();
Console.WriteLine(msg);
}
break;
}
}
}
private async Task DataOnByRead(ReadBytes read, byte runtype)
{
var cmd = read.ReadInt32();
if (cmd.HasValue)
{
var id = (read.ReadInt64()).GetValueOrDefault(-1);
if (MethodInstanceDict.TryGetValue(cmd.Value, out InstanceRegister service))
{
var argslen = (read.ReadInt32()).Value;
if (argslen == service.ArgsLen)
{
object[] args = new object[argslen];
for (int i = 0; i < argslen; i++)
{
args[i] = base.ReadData(read, service.ArgsType[i]);
}
RunCall(service, cmd.Value, id, runtype, args);
}
else
{
Log.WarnFormat("call method tag :{0} Args Error: len {1}->{2} to\r\n {3}", cmd.Value, argslen, service.ArgsType.Length, service);
await SendError(id, $"call method tag :{ cmd.Value} Args Error: len {argslen}->{service.ArgsType.Length} to\r\n {service}", ErrorType.ArgLenErr);
}
}
}
else
{
Log.WarnFormat("call read cmd error");
await SendError(-1, "not read cmd", ErrorType.NotReadCmd);
}
}
protected virtual void ReadResult(ReadBytes read)
{
var id = read.ReadInt64();
if (id.HasValue)
{
if ((read.ReadBoolean()).Value) //is error
{
AsyncBackResult(new Result()
{
Id = id.Value,
ErrorId = (read.ReadInt32()).Value,
ErrorMsg = read.ReadString()
});
}
else
{
var count = (read.ReadInt32()).Value;
List <byte[]> args = new List <byte[]>(count);
for (int i = 0; i < count; i++)
{
args.Add(read.ReadArray());
}
AsyncBackResult(new Result(args)
{
Id = id.Value
});
}
}
else
{
throw new NetxException($"data error:2500", ErrorType.ReadErr);
}
}
static void IpDataIn(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.AcceptSocket != null)
{
ReadBytes read = new ReadBytes(data);
int length;
int Cmd;
string key;
int netport;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out Cmd) && read.ReadString(out key) && read.ReadInt32(out netport))
{
if (Cmd == 100)
{
string ip = ((IPEndPoint)socketAsync.AcceptSocket.RemoteEndPoint).Address.ToString(); //获取外网IP地址
string port = ((IPEndPoint)socketAsync.AcceptSocket.RemoteEndPoint).Port.ToString(); //获取端口号
if (UserList.ContainsKey(key)) //检查是否包含此KEY
{
UserList[key].WANhost = ip;
UserList[key].CPort = port;
UserList[key].NatNetPort = netport - 1;
Console.WriteLine("注册端口号: 客户端:Key {0} 外网IP地址: {1} 下次开放端口: {2}", key, ip, netport);
}
}
}
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEventAsServer socketAsync)
{
//USE SSL+GZIP
var(fiberRw, errMsg) = await socketAsync.GetFiberRwSSL <string>(certificate, (input, output) =>
{
//var gzip_input = new GZipStream(input, CompressionMode.Decompress, true);
//var gzip_output = new GZipStream(output, CompressionMode.Compress, true);
//return new GetFiberRwResult(gzip_input, gzip_output); //return gzip mode
var lz4_input = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Decode(input, leaveOpen: true);
var lz4_output = K4os.Compression.LZ4.AsyncStreams.LZ4Stream.Encode(output, leaveOpen: true);
return(new GetFiberRwResult(lz4_input, lz4_output)); //return lz4 mode
});
if (fiberRw is null)
{
Console.WriteLine(errMsg);
socketAsync.Disconnect();
return;
}
//var fiberRw = await socketAsync.GetFiberRw<string>((input, output) =>
//{
// var lz4_input = K4os.Compression.LZ4.Streams.LZ4Stream.Decode(input, leaveOpen: true);
// var lz4_output = K4os.Compression.LZ4.Streams.LZ4Stream.Encode(output, leaveOpen: true);
// return new GetFiberRwResult(lz4_input, lz4_output); //return lz4 mode
//});
//var fiberRw = await socketAsync.GetFiberRw<string>();
fiberRw.UserToken = "my is ttk";
for (; ;)
{
try
{
//提供2种数据 读取写入方式
ReadBytes readBytes = await new ReadBytes(fiberRw).Init();
DataOn(ref readBytes, fiberRw);
await DataOnByLine(fiberRw);
}
catch (System.IO.IOException)
{
break;
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.Disconnect();
}
protected virtual async Task DataOnByLine(IFiberRw fiberRw)
{
using (ReadBytes read = new ReadBytes(fiberRw))
{
await read.Init();
var cmd = read.ReadInt32();
switch (cmd)
{
case 2000: //set session
{
var sessionid = (read.ReadInt64()).GetValueOrDefault(0);
Log.TraceFormat("save sessionid {0}", sessionid);
Session.SaveSessionId(sessionid);
}
break;
case 2400: //Call It
{
await Calling(read);
}
break;
case 2500: //set result
{
ReadResult(read);
}
break;
default:
throw new NetxException($"data error:{cmd.GetValueOrDefault()}", ErrorType.ReadErr);
}
}
}
static void DataOn(byte[] data, UserInfo userinfo)
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
string msg = read.ReadString();
while (true)
{
BufferFormat buffer = new BufferFormat(1000);
buffer.AddItem(msg.ToString());
buffer.AddItem(new byte[8096]);
byte[] pdata = buffer.Finish();
server.Send(userinfo, pdata);
}
break;
}
}
}
/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e, bool isTaskQueue, out ReadBytes read, out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
if (isTaskQueue)
{
Task.Factory.StartNew((pack) => Call(pack as RPCCallPack, e)
, tmp, CancellationToken.None, TaskCreationOptions.None, e.Scheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch
{
}
});
return(true);
}
else
{
Call(tmp, e);
}
}
}
break;
case 1001001:
{
Result_Have_Return val;
if (read.ReadObject <Result_Have_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return(true);
}
}
break;
}
}
return(false);
}
static void DataOn(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt = read.ReadInt32();
if (lengt == read.Length)
{
int cmd = read.ReadInt32();
switch (cmd)
{
case 1000:
{
string msg = read.ReadString();
count++;
if (count >= 100000)
{
stop.Stop();
Console.WriteLine(count + ":" + msg + ":" + stop.ElapsedMilliseconds);
}
}
break;
}
}
}
static void DataOn(ReadBytes read, IFiberRw <string> fiberRw)
{
var cmd = read.ReadInt32();
var p1 = read.ReadInt32();
var p2 = read.ReadInt64();
var p3 = read.ReadDouble();
var p4 = read.ReadSingle();
var p5 = read.ReadBoolean();
var p6 = read.ReadBoolean();
var p7 = read.ReadString();
var p8 = read.ReadMemory();
var p9 = read.ReadInt16();
// var p10 = read.ReadObject<List<Guid>>();
// read.Dispose();
using (WriteBytes writeBytes = new WriteBytes(fiberRw))
{
writeBytes.WriteLen();
writeBytes.Cmd(cmd);
writeBytes.Write(p1);
writeBytes.Write(p2);
writeBytes.Write(p3);
writeBytes.Write(p4);
writeBytes.Write(p5);
writeBytes.Write(p6);
writeBytes.Write(p7);
writeBytes.Write(p8);
writeBytes.Write(p9);
//writeBytes.Write(p10);
writeBytes.Flush();
}
}
/// <summary>
/// 送入字节流
/// </summary>
/// <param name="readAction">参数依次为buff,offset,length</param>
public void SendToRead(ReadBytes readAction)
{
int remain;
byte[] buff = new byte[PackageSize];
while((remain = readAction(buff, 0, PackageSize)) != 0)
{
for(int i = 0; i < remain; i++)
{
if(remainBody > 0)
{
remainBody--;
packages.Enqueue(buff[i]);
}
else
{
if (matchedHead < Head.Count() && buff[i] == Head[matchedHead])
{
matchedHead++;//匹配到下一个满足的头部
}
if(matchedHead == Head.Count())
{
matchedHead = 0;//prepair for next
remainBody = PackageSize - Head.Count();//匹配到完整的头部
foreach (var b in Head)
packages.Enqueue(b);
}
}
}
}
}
protected virtual void ReadResult(ReadBytes read)
{
var id = read.ReadInt64();
if (read.ReadBoolean()) //is error
{
AsyncBackResult(new Result()
{
Id = id,
ErrorId = (read.ReadInt32()),
ErrorMsg = read.ReadString()
});
}
else
{
var count = (read.ReadInt32());
List <byte[]> args = new List <byte[]>(count);
for (int i = 0; i < count; i++)
{
args.Add(read.ReadArray());
}
AsyncBackResult(new Result(args)
{
Id = id
});
}
}
private async Task DataOnByRead(ReadBytes read, byte runtype)
{
var cmd = read.ReadInt32();
var id = read.ReadInt64();
if (MethodInstanceDict.TryGetValue(cmd, out InstanceRegister service))
{
var argslen = read.ReadInt32();
if (argslen == service.ArgsLen)
{
object[] args = new object[argslen];
for (int i = 0; i < argslen; i++)
{
args[i] = base.ReadData(read, service.ArgsType[i]);
}
RunCall(service, cmd, id, runtype, args);
}
else
{
Log.WarnFormat("call method tag :{cmd} Args Error: len {argslen}->{Length} to\r\n {service}"
, cmd
, argslen
, service.ArgsType.Length
, service);
await SendError(id, $"call method tag :{ cmd} Args Error: len {argslen}->{service.ArgsType.Length} to\r\n {service}", ErrorType.ArgLenErr);
}
}
}
public void _RegSession(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
RegSession regSession;
if (read.ReadObject <RegSession>(out regSession))
{
session.LANIP = regSession.LocalHost;
session.Group = regSession.Group;
if (!Server.SessionDiy.ContainsKey(session.Id))
{
regSession.Id = session.Id;
regSession.IsSuccess = true;
regSession.Port = Server.RegPort;
Server.SessionDiy.AddOrUpdate(session.Id, session, (a, b) => session);
Server.Send(session, BufferFormat.FormatFCA(regSession));
AddSession add = new AddSession()
{
Id = regSession.Id
};
Server.SendAll(BufferFormat.FormatFCA(add));
}
else
{
regSession.IsSuccess = false;
regSession.Msg = "User Id Is Have";
Server.Send(session, BufferFormat.FormatFCA(regSession));
Server.Service.Disconnect(session.Asyn.AcceptSocket);
}
}
}
protected async Task Calling(ReadBytes read)
{
var type = read.ReadByte();
switch (type)
{
case 0: //RUN CALL NOT RES
{
await DataOnByRead(read, 0);
}
break;
case 1: //RUN CALL HAVE RES
{
await DataOnByRead(read, 1);
}
break;
case 2: // RUN CALL RETURN
{
await DataOnByRead(read, 2);
}
break;
default:
throw new NetxException($"not is call type{type}", ErrorType.CallErr);
}
}
/// <summary>
/// 输入包输入处理
/// </summary>
/// <param name="Data"></param>
void SocketManager_DataInput(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 500: //如果是Message类型数据包
BuffLibrary.Message ms;
if (read.ReadObject<BuffLibrary.Message>(out ms))
{
if (ms != null)
{
if (ms.Type == 1) //1登入失败
MessageBox.Show(ms.MessageStr);
else if (ms.Type == 2) //2登入成功
{
Logins = true; //设置 LOGINS
this.BeginInvoke(new EventHandler((o, p) => Close())); //关闭窗口
}
}
}
break;
}
}
}
/// <summary>
/// 输入包输入处理
/// </summary>
/// <param name="Data"></param>
void SocketManager_DataInput(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 500: //如果是Message类型数据包
BuffLibrary.Message ms;
if (read.ReadObject <BuffLibrary.Message>(out ms))
{
if (ms != null)
{
if (ms.Type == 1) //1登入失败
{
MessageBox.Show(ms.MessageStr);
}
else if (ms.Type == 2) //2登入成功
{
Logins = true; //设置 LOGINS
this.BeginInvoke(new EventHandler((o, p) => Close())); //关闭窗口
}
}
}
break;
}
}
}
public void _SetGroup(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
int group;
if (read.ReadInt32(out group))
{
session.Group = group;
}
}
void client_DataOn(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800: //PING命令
{
Ping p;
if (read.ReadObject<Ping>(out p))
{
if(p!=null)
this.BeginInvoke(new EventHandler((o, x) =>
{
Ping nn = o as Ping;
if (nn != null)
{
toolStripStatusLabel1.Text = string.Format("Ping:{0} ({1})", //计算并显示PING
(DateTime.Now - nn.UserSendTime).Milliseconds,
(DateTime.Now - nn.ServerReviceTime).Milliseconds);
}
}),p);
}
}
break;
case 1002:
ReadDataSet dox;
if (read.ReadObject<ReadDataSet>(out dox)) //获取服务器发送过来的 DATASET
{
if (dox != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
ReadDataSet nn = o as ReadDataSet;
if (nn != null)
{
this.dataGridView1.DataSource = nn.Data; //绑定到视图
this.dataGridView1.Update();
}
}), dox);
}
}
break;
}
}
}
void client_DataOn(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800: //PING命令
{
Ping p;
if (read.ReadObject <Ping>(out p))
{
if (p != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
Ping nn = o as Ping;
if (nn != null)
{
toolStripStatusLabel1.Text = string.Format("Ping:{0} ({1})", //计算并显示PING
(DateTime.Now - nn.UserSendTime).Milliseconds,
(DateTime.Now - nn.ServerReviceTime).Milliseconds);
}
}), p);
}
}
}
break;
case 1002:
ReadDataSet dox;
if (read.ReadObject <ReadDataSet>(out dox)) //获取服务器发送过来的 DATASET
{
if (dox != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
ReadDataSet nn = o as ReadDataSet;
if (nn != null)
{
this.dataGridView1.DataSource = nn.Data; //绑定到视图
this.dataGridView1.Update();
}
}), dox);
}
}
break;
}
}
}
private void DataOn(byte[] data, SocketAsyncEventArgs socketAsync, ZYNetRingBufferPool stream)
{
ReadBytes read = new ReadBytes(data);
if (read.Length >= 4)
{
if (read.ReadInt32(out int lengt) && lengt == read.Length)
{
if (read.ReadByte() == 0xED &&
read.ReadByte() == 0xCE &&
read.ReadByte() == 0xFE &&
read.ReadByte() == 0x10)
{
long sessionId = read.ReadInt64();
if (sessionId == 0)
{
var token = MakeNewToken(socketAsync, stream, ref sessionId);
if (token != null)
{
BufferFormat session = new BufferFormat(0x10FECEED);
session.AddItem(sessionId);
Send(token.Sendobj, session.Finish());
}
}
else
{
if (TokenList.TryGetValue(sessionId, out ASyncToken token))
{
token.SetSocketEventAsync(socketAsync);
socketAsync.UserToken = token;
Log.Debug($"ReUse Token {token.SessionKey}");
}
else
{
var _token = MakeNewToken(socketAsync, stream, ref sessionId);
if (_token != null)
{
BufferFormat session = new BufferFormat(0x10FECEED);
session.AddItem(sessionId);
Send(_token.Sendobj, session.Finish());
}
}
}
}
else
{
Server.Disconnect(socketAsync.AcceptSocket);
}
}
else
{
Server.Disconnect(socketAsync.AcceptSocket);
}
}
public void ReadDataSet(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
ReadDataSet rd;
if (read.ReadObject <ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List <DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
}
static void DataOn(byte[] data, UserInfo user)
{
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
if (read.ReadInt32(out lengt) && read.Length == lengt)
{
BufferRun.Run <UserInfo>(read, user);
}
}
private static void DataOn(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int length;
if (read.ReadInt32(out length) && length == read.Length)
{
autobuffer.Run(read);
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static async void BinaryInputHandler(ISockAsyncEvent socketAsync)
{
var fiberRw = await socketAsync.GetFiberRw <string>();
fiberRw.UserToken = "my is ttk";
for (; ;)
{
//try
//{
// //读取 发送 测试
// var data = await fiberRw.ReadToBlockArrayEnd();
// fiberRw.Write(data);
// await fiberRw.FlushAsync();
//}
//catch (SocketException)
//{
// break;
//}
//catch (Exception er)
//{
// Console.WriteLine(er.ToString());
// break;
//}
try
{
//提供2种数据 读取写入方式
using (ReadBytes readBytes = new ReadBytes(fiberRw))
{
await readBytes.Init();
DataOn(readBytes, fiberRw);
}
await DataOnByLine(fiberRw);
}
catch (System.Net.Sockets.SocketException)
{
break;
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
break;
}
}
socketAsync.Disconnect();
}
private void DataOn(byte[] data)
{
ReadBytes read = null;
if (DecodingHandler != null)
{
read = new ReadBytes(data, 4, -1, DecodingHandler);
}
else
{
read = new ReadBytes(data);
}
int cmd;
int length;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && read.Length == read.Length)
{
switch (cmd)
{
case CmdDef.CallCmd:
{
CallPack tmp;
if (read.ReadObject <CallPack>(out tmp))
{
try
{
CallPackRun(tmp);
}
catch (Exception er)
{
LogAction.Log(LogType.Err, "CMD:" + tmp.CmdTag + "\r\n" + er.ToString());
}
}
}
break;
case CmdDef.ReturnResult:
{
ReturnResult result;
if (read.ReadObject <ReturnResult>(out result))
{
SetReturnValue(result);
}
}
break;
}
}
}
public void Ping(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Ping pdata;
if (read.ReadObject <Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
}
static void Main(string[] args)
{
#region DES
BufferFormat fan = new BufferFormat(1000, new FDataExtraHandle((o) =>
{
return DES.EncryptDES(o, DESkeys, "hello word");
}));
fan.AddItem(true);
fan.AddItem("abc");
fan.AddItem(123);
byte[] data = fan.Finish();
ReadBytes read = new ReadBytes(data, 4, -1, new RDataExtraHandle((o) =>
{
return DES.DecryptDES(o, DESkeys, "hello word");
}));
int lengt;
int cmd;
bool var1;
string var2;
int var3;
if (read.IsDataExtraSuccess &&
read.ReadInt32(out lengt) &&
lengt == read.Length &&
read.ReadInt32(out cmd) &&
read.ReadBoolean(out var1) &&
read.ReadString(out var2) &&
read.ReadInt32(out var3))
{
Console.WriteLine("This DES-> Length:{0} Cmd:{1} var1:{2} var2:{3} var3:{4}", lengt, cmd, var1, var2, var3);
}
#endregion
//AES测试
AEStest();
//数据压缩
Deflatetest();
Console.ReadLine();
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
if (read.ReadInt32(out lengt) && read.Length == lengt)
{
BufferRun.Run <SocketAsyncEventArgs>(read, e);
}
}
static void Main(string[] args)
{
#region DES
BufferFormat fan = new BufferFormat(1000, new FDataExtraHandle((o) =>
{
return(DES.EncryptDES(o, DESkeys, "hello word"));
}));
fan.AddItem(true);
fan.AddItem("abc");
fan.AddItem(123);
byte[] data = fan.Finish();
ReadBytes read = new ReadBytes(data, 4, -1, new RDataExtraHandle((o) =>
{
return(DES.DecryptDES(o, DESkeys, "hello word"));
}));
int lengt;
int cmd;
bool var1;
string var2;
int var3;
if (read.IsDataExtraSuccess &&
read.ReadInt32(out lengt) &&
lengt == read.Length &&
read.ReadInt32(out cmd) &&
read.ReadBoolean(out var1) &&
read.ReadString(out var2) &&
read.ReadInt32(out var3))
{
Console.WriteLine("This DES-> Length:{0} Cmd:{1} var1:{2} var2:{3} var3:{4}", lengt, cmd, var1, var2, var3);
}
#endregion
//AES测试
AEStest();
//数据压缩
Deflatetest();
Console.ReadLine();
}
static void DataOn(byte[] data, SocketAsyncEventArgs socketAsync)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
if (!CmdToCallManager <ZYSocketSuper, ReadBytes, SocketAsyncEventArgs> .GetInstance().pointerRun(server, cmd, read, socketAsync)) //如果用户发送的是登入数据包
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
}
/// <summary>
/// 数据包输入 以处理
/// </summary>
/// <param name="data"></param>
/// <param name="session"></param>
private void DataOn(byte[] data, ZYNetSession session)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (cmd != -2000)
{
if (!CmdToCallManager <ZYNetServer, ReadBytes, ZYNetSession> .GetInstance().pointerRun(this, cmd, read, session))
{
LLOG("Not Find CMD:" + cmd, EventLogType.ERR);
}
}
else
{
ProxyData tmp;
if (read.ReadObject <ProxyData>(out tmp))
{
if (tmp.Source == session.Id)
{
if (tmp.Ids != null)
{
if (tmp.Ids.Contains(0))
{
if (UserDataInput != null)
{
UserDataInput(session, tmp.Data);
}
}
foreach (var Id in tmp.Ids)
{
if (Id != 0 && SessionDiy.ContainsKey(Id))
{
Service.SendData(SessionDiy[Id].Asyn.AcceptSocket, data);
}
}
}
}
}
}
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.UserToken == null) //如果用户第一次登入
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (!CmdToCallManager<ZYSocketSuper,int,ReadBytes,SocketAsyncEventArgs>.GetInstance().pointerRun(server,cmd,read,socketAsync)) //如果用户发送的是登入数据包
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else //无法读取数据包 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else
{
User.UserInfo user = socketAsync.UserToken as User.UserInfo; //读取用户USERTRKEN
if (user != null)
{
if (user.BuffManger.Write(data)) //这里的 4表示 数据包长度是用4字节的整数存储的 Int
{
byte[] pdata;
while (user.BuffManger.Read(out pdata))
{
DataOn(pdata, socketAsync);
}
}
}
}
}
public void LogOn(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Login p;
if (read.ReadObject<Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord))//检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
public void _LEFTConnect(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
long ToId;
if (read.ReadInt64(out ToId))
{
if (Server.SessionDiy.ContainsKey(ToId) && !string.IsNullOrEmpty(session.WANIP) && session.WANPort != 0)
{
ZYNetSession toUser = Server.SessionDiy[ToId];
if (toUser.Group != session.Group)
{
return;
}
if (!session.WANIP.Equals(toUser.WANIP)) //如果不再一个局域网内
{
LEFTConnect tmp = new LEFTConnect()
{
Id = session.Id,
Host = session.WANIP,
Port = session.WANPort,
IsSuccess = true
};
Server.Send(toUser, BufferFormat.FormatFCA(tmp));
}
else //同局域网内
{
LEFTConnect tmp = new LEFTConnect()
{
Id = session.Id,
Host = session.LANIP,
Port = session.NatNextPort,
IsSuccess = true
};
Server.Send(toUser, BufferFormat.FormatFCA(tmp));
}
}
}
}
public void _GetAllSession(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
GetAllSession pack;
if (read.ReadObject <GetAllSession>(out pack))
{
var userlist = Server.SessionDiy.Values.Where(p => p.Group == session.Group && p.Id != session.Id);
pack.UserIds = new List <long>();
foreach (var item in userlist)
{
pack.UserIds.Add(item.Id);
}
pack.IsSuccess = true;
Server.Send(session, BufferFormat.FormatFCA(pack));
}
}
static void Deflatetest()
{
BufferFormat fan = new BufferFormat(1000, new FDataExtraHandle((o) =>
{
return Deflate.Compress(o);
}));
fan.AddItem(true);
fan.AddItem("abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc");
fan.AddItem(123);
byte[] data = fan.Finish();
ReadBytes read = new ReadBytes(data, 4, -1, new RDataExtraHandle((o) =>
{
return Deflate.Decompress(o);
}));
int lengt;
int cmd;
bool var1;
string var2;
int var3;
if (read.IsDataExtraSuccess &&
read.ReadInt32(out lengt) &&
lengt == read.Length &&
read.ReadInt32(out cmd) &&
read.ReadBoolean(out var1) &&
read.ReadString(out var2) &&
read.ReadInt32(out var3))
{
Console.WriteLine("压缩前长度:{0}", read.Data.Length);
Console.WriteLine("压缩后长度:{0}", read.Length);
Console.WriteLine("This Deflate-> Length:{0} Cmd:{1} var1:{2} var2:{3} var3:{4}", lengt, cmd, var1, var2, var3);
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
try
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
testClass.PPo temp;
if (read.ReadObject<testClass.PPo>(out temp))
{
if (temp != null)
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
}
}
break;
case 1001:
{
int id;
string mn;
Guid guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadObject<Guid>(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1002:
{
int id;
string mn;
string guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadString(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1003:
{
server.SendData(e.AcceptSocket, data);
}
break;
}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
try
{
Console.WriteLine(Marshal.SizeOf(typeof(ID3V1)));
Console.WriteLine(Marshal.SizeOf(typeof(PPo)));
Console.WriteLine("---------------------------------------------------------------------------");
var stream = new MemoryStream(data);
using (var reader = new BinaryReader(stream))
{
reader.BaseStream.Seek(-1 * Marshal.SizeOf(typeof(PPo)), SeekOrigin.End);
var id3Tag = reader.ReadMarshal<PPo>();
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n \r\n\r\n", id3Tag.Id,UTF8ToGB2312(id3Tag.Message), id3Tag.Guid);
//Console.WriteLine(WordsIScn(id3Tag.Message).ToString());
var s = Encoding.Default.GetBytes(id3Tag.Message);
Console.WriteLine(Encoding.UTF8.GetString(s));
}
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt)
{ //read.Read系列函数是不会产生异常的
int id;
string mn;
SocketClinetTest.PPo temp;
//if (read.ReadInt32(out id) && read.ReadObject<SocketClinetTest.PPo>(out temp))
//{
// if (temp != null)
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
// }
//}
if (read.ReadObject<SocketClinetTest.PPo>(out temp))
{
if (temp != null)
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.Guid, read.Length);
}
}
//根据命令读取数据包
//switch (cmd)
//{
// case 1000:
// testClass.PPo temp;
// if (read.ReadObject<testClass.PPo>(out temp))
// {
// if (temp != null)
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
// }
// }
// break;
// case 1001:
// {
// int id;
// string mn;
// Guid guid;
// if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadObject<Guid>(out guid))
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
// }
// }
// break;
// case 1002:
// {
// int id;
// string mn;
// string guid;
// if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadString(out guid))
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
// }
// }
// break;
// case 1003:
// {
// server.SendData(e.AcceptSocket, data);
// }
// break;
//}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
public void ReadDataSet(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
ReadDataSet rd;
if (read.ReadObject<ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List<DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs socketAsync)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
if (!CmdToCallManager<ZYSocketSuper, ReadBytes, SocketAsyncEventArgs>.GetInstance().pointerRun(server, cmd, read, socketAsync)) //如果用户发送的是登入数据包
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
}
static void IpDataIn(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.AcceptSocket != null)
{
ReadBytes read = new ReadBytes(data);
int length;
int Cmd;
string key;
int netport;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out Cmd) && read.ReadString(out key) && read.ReadInt32(out netport))
{
if (Cmd == 100)
{
string ip = ((IPEndPoint)socketAsync.AcceptSocket.RemoteEndPoint).Address.ToString(); //获取外网IP地址
string port = ((IPEndPoint)socketAsync.AcceptSocket.RemoteEndPoint).Port.ToString(); //获取端口号
if (UserList.ContainsKey(key)) //检查是否包含此KEY
{
UserList[key].WANhost = ip;
UserList[key].CPort = port;
UserList[key].NatNetPort = netport - 1;
Console.WriteLine("注册端口号: 客户端:Key {0} 外网IP地址: {1} 下次开放端口: {2}", key, ip, netport);
}
}
}
}
}
static void DataOn(byte[] data, UserInfo userinfo)
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
string msg = read.ReadString();
while (true)
{
BufferFormat buffer = new BufferFormat(1000);
buffer.AddItem(msg.ToString());
buffer.AddItem(new byte[8096]);
byte[] pdata = buffer.Finish();
server.Send(userinfo, pdata);
}
break;
}
}
}
static void AEStest()
{
BufferFormat fan = new BufferFormat(1000, new FDataExtraHandle((o) =>
{
return AES.AESEncrypt(o, AESkeys, "hello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello word");
}));
fan.AddItem(true);
fan.AddItem("abc");
fan.AddItem(123);
byte[] data = fan.Finish();
ReadBytes read = new ReadBytes(data, 4, -1, new RDataExtraHandle((o) =>
{
return AES.AESDecrypt(o, AESkeys, "hello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello wordhello word");
}));
int lengt;
int cmd;
bool var1;
string var2;
int var3;
if (read.IsDataExtraSuccess&&
read.ReadInt32(out lengt) &&
lengt == read.Length &&
read.ReadInt32(out cmd) &&
read.ReadBoolean(out var1) &&
read.ReadString(out var2) &&
read.ReadInt32(out var3))
{
Console.WriteLine("This AES-> Length:{0} Cmd:{1} var1:{2} var2:{3} var3:{4}", lengt, cmd, var1, var2, var3);
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.UserToken == null) //如果用户第一次登入
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (cmd == 1000) //如果用户发送的是登入数据包
{
Login p;
if (read.ReadObject <Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord))//检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
else //现在还没登入 如果有其他命令的请求那么 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else //无法读取数据包 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else
{
User.UserInfo user = socketAsync.UserToken as User.UserInfo; //读取用户USERTRKEN
if (user != null)
{
user.BuffManger.Write(data);
byte[] pdata;
while (user.BuffManger.Read(out pdata))
{
DataOn(pdata, socketAsync);
}
}
}
}
public void Ping(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Ping pdata;
if (read.ReadObject<Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs socketAsync)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800:
Ping pdata;
if (read.ReadObject<Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
break;
case 1002:
ReadDataSet rd;
if (read.ReadObject<ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List<DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
break;
}
}
}
/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e,out ReadBytes read,out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject<RPCCallPack>(out tmp))
{
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
object returnValue;
CallContext.SetData("Current", e);
if (e.RPC_Call.RunModule(tmp, out returnValue))
{
if (tmp.IsNeedReturn)
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
var.ReturnType = returnValue.GetType();
}
e.EnsureSend(BufferFormat.FormatFCA(var));
}
}
}, CancellationToken.None, TaskCreationOptions.None, e.QueueScheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch (Exception er)
{
if (MsgOut != null)
MsgOut(er.ToString());
}
});
return true;
}
}
break;
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject<ZYClient_Result_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return true;
}
}
break;
}
}
return false;
}
