private void SendAddSubscribePackage()
{
try
{
if (mMaskMsg == null || mMessageMsg == null)
{
OnDebug(string.Format("MaskMsg or MessageMsg is null"));
return;
}
_TAG_NETPACK_MESSAGE mask = mMaskMsg.GetMessage();
_TAG_NETPACK_MESSAGE message = mMessageMsg.GetMessage();
_TAG_NETPACK_BASEHEAD_REQ_ADD_SUBSCRIBE addSubscribe = new _TAG_NETPACK_BASEHEAD_REQ_ADD_SUBSCRIBE();
addSubscribe._requestid = GetRequestID();
addSubscribe._mask = mask;
addSubscribe._message = message;
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_REQUEST,
DecDefines.NETPACK_BASETYPE_REQ_ADDSUBSCRIBE,
DecDefines.NETPACK_EXTTYPE_NOTHING,
0);
byte[] messageHead = Converter.Struct2Bytes(addSubscribe);
SendMessage(ver1Head, messageHead);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
private void SendHelloPackage()
{
try
{
_TAG_NETPACK_BASEHEAD_CONNECT_HELLO helloPackage = new _TAG_NETPACK_BASEHEAD_CONNECT_HELLO();
helloPackage._client_appname = Helpers.ConvertStringToByteArray(mAppName, DecDefines.LEN_APPNAME);
helloPackage._client_moduleid = mModuleType;
helloPackage._client_number = mModuleNumber;
helloPackage._client_version = Helpers.ConvertStringToByteArray(mAppVersion, DecDefines.LEN_VERSION);
helloPackage._client_starttime = Helpers.CreateTimestamp(DateTime.Now.ToUniversalTime());
helloPackage._client_connecttime = Helpers.CreateTimestamp(DateTime.Now.ToUniversalTime());
helloPackage._client_protocol = new ulong[4];
helloPackage._client_protocol[0] = Helpers.MakeNetPackProtocol(1, 0);
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_CONNECT,
DecDefines.NETPACK_BASETYPE_CONNECT_HELLO,
DecDefines.NETPACK_EXTTYPE_NOTHING,
0);
byte[] messageHead = Converter.Struct2Bytes(helloPackage);
SendMessage(ver1Head, messageHead);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
internal void SendMessage(_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head)
{
byte[] byteHead = Converter.Struct2Bytes(ver1Head);
byte[] byteSend = new byte[byteHead.Length];
Array.Copy(byteHead, 0, byteSend, 0, byteHead.Length);
SendMessage(byteSend);
}
private void SendHeartbeatPackage()
{
try
{
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_HEARTBEAT,
DecDefines.NETPACK_BASETYPE_NOTHING,
DecDefines.NETPACK_EXTTYPE_NOTHING,
0);
SendMessage(ver1Head);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
internal static DistHead FromHead(_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head)
{
DistHead info = new DistHead();
info.PackType = ver1Head._packtype;
info.FollowSize = ver1Head._followsize;
info.SourceID = ver1Head._source;
info.TargetID = ver1Head._target;
info.Time = Helpers.GetTimeFromTimestamp((long)ver1Head._timestamp);
info.BaseType = ver1Head._basehead;
info.BaseSize = ver1Head._basesize;
info.ExtType = ver1Head._exthead;
info.ExtSize = ver1Head._extsize;
info.DataSize = ver1Head._datasize;
info.ModuleID = ver1Head._moduleid;
info.Number = ver1Head._number;
info.Message = MessageString.FromMessage(ver1Head._message);
return(info);
}
private void SendClearSubscribePackage()
{
try
{
_TAG_NETPACK_BASEHEAD_REQ_CLEAR_SUBSCRIBE clearSubscribe = new _TAG_NETPACK_BASEHEAD_REQ_CLEAR_SUBSCRIBE();
clearSubscribe._requestid = mRequestID++;
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_REQUEST,
DecDefines.NETPACK_BASETYPE_REQ_CLEARSUBSCRIBE,
DecDefines.NETPACK_EXTTYPE_NOTHING,
0);
byte[] messageHead = Converter.Struct2Bytes(clearSubscribe);
SendMessage(ver1Head, messageHead);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
private void SendPublishMessage(string msg, MessageString message)
{
try
{
byte[] byteMsg = Encoding.UTF8.GetBytes(msg);
NETPACK_BASEHEAD_APPLICATION_VER1 appVer1 = new NETPACK_BASEHEAD_APPLICATION_VER1();
appVer1._channel = 0;
appVer1._encrypt = (byte)mDataEncrypt;
appVer1._compress = 0;
appVer1._format = (byte)mDataFormat;
appVer1._datasize = (ushort)byteMsg.Length;
appVer1._validsize = Helpers.GetEncryptStoreSize((byte)mDataEncrypt, (ushort)byteMsg.Length);
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_APPLICATION,
DecDefines.NETPACK_BASETYPE_APPLICATION_VER1,
DecDefines.NETPACK_EXTTYPE_NOTHING,
appVer1._validsize);
_TAG_NETPACK_MESSAGE messageMessage = Helpers.CreateMessage(message.SourceModule, message.SourceNumber,
message.TargetModule, message.TargetNumber, message.Number, message.SmallType, message.MiddleType,
message.LargeType);
ver1Head._message = messageMessage;
byte[] byteBaseHead = Converter.Struct2Bytes(appVer1);
byte[] byteSend = new byte[byteBaseHead.Length + byteMsg.Length];
Array.Copy(byteBaseHead, 0, byteSend, 0, byteBaseHead.Length);
Array.Copy(byteMsg, 0, byteSend, byteBaseHead.Length, byteMsg.Length);
SendMessage(ver1Head, byteSend);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
private void SendLogonPackage(_TAG_NETPACK_BASEHEAD_CONNECT_WELCOME welcome)
{
try
{
byte[] session = welcome._authenticatecode;
byte[] code = Helpers.GetValidicationCode(session); //计算认证码
_TAG_NETPACK_BASEHEAD_CONNECT_LOGON logon = new _TAG_NETPACK_BASEHEAD_CONNECT_LOGON();
logon._heartbeat = mHearbeatDuration;
logon._authenticatecode = code;
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1Head = CreateVer1Head(
DecDefines.NETPACK_PACKTYPE_CONNECT,
DecDefines.NETPACK_BASETYPE_CONNECT_LOGON,
DecDefines.NETPACK_EXTTYPE_NOTHING,
0);
byte[] messageHead = Converter.Struct2Bytes(logon);
SendMessage(ver1Head, messageHead);
}
catch (Exception ex)
{
OnDebug(string.Format("SendMessage fail.\t{0}", ex.Message));
}
}
private _TAG_NETPACK_DISTINGUISHHEAD_VER1 CreateVer1Head(byte packType,
ushort baseHeadType,
ushort extHeadType,
ushort validSize)
{
_TAG_NETPACK_DISTINGUISHHEAD distHead = Helpers.CreateDistinguishHead();
ushort distHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_DISTINGUISHHEAD));
ushort baseHeadSize = 0;
switch (baseHeadType)
{
case DecDefines.NETPACK_BASETYPE_NOTHING:
baseHeadSize = 0;
break;
case DecDefines.NETPACK_BASETYPE_APPLICATION_VER1:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(NETPACK_BASEHEAD_APPLICATION_VER1));
break;
case DecDefines.NETPACK_BASETYPE_CONNECT_ERROR:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_ERROR));
break;
case DecDefines.NETPACK_BASETYPE_CONNECT_HELLO:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_CONNECT_HELLO));
break;
case DecDefines.NETPACK_BASETYPE_CONNECT_WELCOME:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_CONNECT_WELCOME));
break;
case DecDefines.NETPACK_BASETYPE_CONNECT_LOGON:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_CONNECT_LOGON));
break;
case DecDefines.NETPACK_BASETYPE_CONNECT_AUTHEN:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_CONNECT_AUTHEN));
break;
case DecDefines.NETPACK_BASETYPE_REQ_ADDSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_REQ_ADD_SUBSCRIBE));
break;
case DecDefines.NETPACK_BASETYPE_RES_ADDSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_RES_ADD_SUBSCRIBE));
break;
case DecDefines.NETPACK_BASETYPE_REQ_DELSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_REQ_DEL_SUBSCRIBE));
break;
case DecDefines.NETPACK_BASETYPE_RES_DELSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_RES_DEL_SUBSCRIBE));
break;
case DecDefines.NETPACK_BASETYPE_REQ_CLEARSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_REQ_CLEAR_SUBSCRIBE));
break;
case DecDefines.NETPACK_BASETYPE_RES_CLEARSUBSCRIBE:
baseHeadSize = (ushort)Marshal.SizeOf(typeof(_TAG_NETPACK_BASEHEAD_RES_CLEAR_SUBSCRIBE));
break;
}
ushort extHeadSize = 0;
//扩展包头类型
switch (extHeadType)
{
case DecDefines.NETPACK_EXTTYPE_NOTHING:
extHeadSize = 0;
break;
}
int headSize = distHeadSize + baseHeadSize + extHeadSize;
_TAG_NETPACK_ENCRYPT_CONTEXT encryptContext = new _TAG_NETPACK_ENCRYPT_CONTEXT();
encryptContext._encrypt = DecDefines.NETPACK_ENCRYPT_NOTHING;
ushort dataSize = Helpers.GetEncryptStoreSize(encryptContext._encrypt, validSize);
short packSize = (short)(headSize + dataSize);
_TAG_NETPACK_DISTINGUISHHEAD_VER1 ver1head = new _TAG_NETPACK_DISTINGUISHHEAD_VER1();
ver1head._dist = distHead;
ver1head._packtype = packType;
ver1head._followsize = (ushort)(packSize - distHeadSize);
ver1head._source = mEndpointID;
ver1head._target = 0xffffffffffffffff;
ver1head._timestamp = (ulong)DateTime.Now.Ticks;
ver1head._basehead = baseHeadType;
ver1head._basesize = baseHeadSize;
ver1head._exthead = extHeadType;
ver1head._extsize = extHeadSize;
ver1head._datasize = dataSize;
ver1head._state = 0;
ver1head._moduleid = mModuleType;
ver1head._number = mModuleNumber;
ver1head._timestamp = (ulong)DateTime.Now.Ticks;
return(ver1head);
}
