public void Set_ErrorCode_after_disposed()
{
ErrorPacket packet = new ErrorPacket();
packet.Dispose();
Assert.Throws<ObjectDisposedException>(() => packet.ErrorCode = 1);
}
public ErrorCaptureDialog(ErrorPacket ePack)
{
InitializeComponent();
ErrorPacket = ePack;
string fmt = lblHeader.Text;
lblHeader.Text = String.Format(fmt, ePack.ApplicationName);
}
public void ErrorCode_constructor()
{
foreach (int value in new[] { 1, Int32.MaxValue, -1, Int32.MinValue, 0 })
{
ErrorPacket packet = new ErrorPacket(value);
Assert.AreEqual(value, packet.ErrorCode);
packet.Dispose();
}
}
public void ErrorCode()
{
ErrorPacket packet = new ErrorPacket();
foreach (int value in new[] { 1, Int32.MaxValue, -1, Int32.MinValue, 0 })
{
packet.ErrorCode = value;
Assert.AreEqual(value, packet.ErrorCode);
}
packet.Dispose();
}
public void Create_and_dispose()
{
ErrorPacket packet = new ErrorPacket();
Assert.AreEqual(0, packet.DestinationId);
Assert.AreEqual(0, packet.ErrorCode);
Assert.IsFalse(packet.IsDisposed);
Assert.IsTrue(packet.IsEditable);
Assert.AreEqual(TimeSpan.Zero, packet.TimeStamp);
packet.Dispose();
Assert.Throws<ObjectDisposedException>(() => { var x = packet.DestinationId; });
Assert.Throws<ObjectDisposedException>(() => { var x = packet.ErrorCode; });
Assert.IsTrue(packet.IsDisposed);
Assert.IsFalse(packet.IsEditable);
Assert.Throws<ObjectDisposedException>(() => { var x = packet.TimeStamp; });
}
private void LoadErrorContent(ErrorPacket ePack)
{
FieldInfo [] fis = typeof(ErrorPacket).GetFields();
foreach (FieldInfo fi in fis)
{
object[] atts = fi.GetCustomAttributes( typeof(ShowOnErrorDialog), false);
if (atts.Length > 0)
{
ShowOnErrorDialog s = (ShowOnErrorDialog)atts[0];
txtErrorInfo.Text += s.FriendlyName + ": " + fi.GetValue(ePack) + "\r\n\r\n";
//DataRow row = tbl.NewRow();
//row[0] = s.FriendlyName;
//row[1] = fi.GetValue(ePack);
//tbl.Rows.Add(row);
}
}
}
/// <summary>
/// All incoming packets are handled through this and then directed to the appropriate function
/// </summary>
/// <param name="receivedPacket"></param>
public void ProcessPacket(BasePacket receivedPacket)
{
if (connect == null)
{
}
if (receivedPacket == null)
{
Debug.Log("tis null");
}
if (!isAuthenticated && receivedPacket.isAuthenticated())
{
isAuthenticated = true;
}
List <SubPacket> subPackets = receivedPacket.GetSubpackets();
foreach (SubPacket subPacket in subPackets)
{
/* var stdOut = System.Console.Out;
* var consoleOut = new System.IO.StringWriter();
* System.Console.SetOut(consoleOut);
* subPacket.debugPrintSubPacket();
* Debug.Log(consoleOut.ToString());
* System.Console.SetOut(stdOut);*/
DoAuthenticationChecks(receivedPacket, subPacket);
if (!receivedPacket.isAuthenticated())
{
if (subPacket.header.type == (ushort)SubPacketTypes.ErrorPacket)
{
if (subPacket.gameMessage.opcode == (ushort)GamePacketOpCode.AccountError)
{
ErrorPacket ep = new ErrorPacket();
ep.ReadPacket(subPacket.data);
string msg = ep.GetErrorMessage();
StatusBoxHandler.statusText = msg;
Debug.Log("fam error packet");
Utils.SetAccountName(null);
StatusBoxHandler.readyToClose = true;
}
}
if (subPacket.gameMessage.opcode == (ushort)GamePacketOpCode.RegisterSuccess)
{
StatusBoxHandler.statusText = Encoding.Unicode.GetString(subPacket.data);
StatusBoxHandler.readyToClose = true;
break;
}
}
else
{
if (subPacket.header.type == (ushort)SubPacketTypes.ErrorPacket)
{
switch (subPacket.gameMessage.opcode)
{
case ((ushort)GamePacketOpCode.CreateCharacterError):
{
StatusBoxHandler.statusText = "Character name has already been taken";
StatusBoxHandler.readyToClose = true;
break;
}
}
}
switch (subPacket.gameMessage.opcode)
{
//TODO: Refactor statusbox ready to close to use event system
case ((ushort)GamePacketOpCode.AccountSuccess):
StatusBoxHandler.statusText = Encoding.Unicode.GetString(subPacket.data);
isAuthenticated = true;
loggedInSuccessfully = true;
StatusBoxHandler.readyToClose = true;
break;
//TODO: Refactor statusbox ready to close to use event system
case ((ushort)GamePacketOpCode.CreateCharacter):
StatusBoxHandler.statusText = Encoding.Unicode.GetString(subPacket.data);
StatusBoxHandler.readyToClose = true;
break;
//TODO: Refactor statusbox ready to close to use event system
case ((ushort)GamePacketOpCode.CreateCharacterSuccess):
StatusBoxHandler.statusText = Encoding.Unicode.GetString(subPacket.data);
StatusBoxHandler.readyToClose = true;
break;
//TODO: Refactor this to use event system
case ((ushort)GamePacketOpCode.CharacterListQuery):
if (BitConverter.ToInt32(subPacket.data, 0) == -1)
{
CharacterLoader.serverResponseFinished = true;
break;
}
else
{
characterLoader.SetCharacterListFromServer(subPacket);
//else send each received packet to CharacterLoader to process
}
break;
case ((ushort)GamePacketOpCode.CharacterDeleteSuccess):
StatusBoxHandler.statusText = Encoding.Unicode.GetString(subPacket.data);
StatusBoxHandler.readyToClose = true;
break;
case ((ushort)GamePacketOpCode.Acknowledgement):
Debug.Log("Gets here");
AcknowledgePacket ack = new AcknowledgePacket(subPacket.data);
GameEventManager.TriggerHandshakeResponseReceived(new GameEventArgs {
serverResponse = ack.AckSuccessful
});
//ackpacket has other data which is useful which i'm currently unsure on how to use atm
//anything set here won't be visible when scene is changed to world map.
break;
default:
Debug.Log("Unknown or corrupted packet");
break;
}
}
}
}
private void ErrorProcess(Packet p_Packet)
{
ErrorPacket l_Packet = (ErrorPacket)p_Packet;
}
public void ProcessPacket(ZoneConnection client, SubPacket subpacket)
{
Session session = mServer.GetSession(subpacket.header.sourceId);
if (session == null && subpacket.gameMessage.opcode != 0x1000)
{
return;
}
//Normal Game Opcode
switch (subpacket.gameMessage.opcode)
{
//World Server - Error
case 0x100A:
ErrorPacket worldError = new ErrorPacket(subpacket.data);
switch (worldError.errorCode)
{
case 0x01:
session.GetActor().SendGameMessage(Server.GetWorldManager().GetActor(), 60005, 0x20);
break;
}
break;
//World Server - Session Begin
case 0x1000:
subpacket.DebugPrintSubPacket();
SessionBeginPacket beginSessionPacket = new SessionBeginPacket(subpacket.data);
session = mServer.AddSession(subpacket.header.sourceId);
if (!beginSessionPacket.isLogin)
{
Server.GetWorldManager().DoZoneIn(session.GetActor(), false, session.GetActor().destinationSpawnType);
}
Program.Log.Info("{0} has been added to the session list.", session.GetActor().customDisplayName);
client.FlushQueuedSendPackets();
break;
//World Server - Session End
case 0x1001:
SessionEndPacket endSessionPacket = new SessionEndPacket(subpacket.data);
if (endSessionPacket.destinationZoneId == 0)
{
session.GetActor().CleanupAndSave();
}
else
{
session.GetActor().CleanupAndSave(endSessionPacket.destinationZoneId, endSessionPacket.destinationSpawnType, endSessionPacket.destinationX, endSessionPacket.destinationY, endSessionPacket.destinationZ, endSessionPacket.destinationRot);
}
Server.GetServer().RemoveSession(session.id);
Program.Log.Info("{0} has been removed from the session list.", session.GetActor().customDisplayName);
session.QueuePacket(SessionEndConfirmPacket.BuildPacket(session, endSessionPacket.destinationZoneId));
client.FlushQueuedSendPackets();
break;
//World Server - Party Synch
case 0x1020:
PartySyncPacket partySyncPacket = new PartySyncPacket(subpacket.data);
Server.GetWorldManager().PartyMemberListRecieved(partySyncPacket);
break;
//Ping
case 0x0001:
//subpacket.DebugPrintSubPacket();
PingPacket pingPacket = new PingPacket(subpacket.data);
session.QueuePacket(PongPacket.BuildPacket(session.id, pingPacket.time));
session.Ping();
break;
//Unknown
case 0x0002:
subpacket.DebugPrintSubPacket();
session.QueuePacket(_0x2Packet.BuildPacket(session.id));
client.FlushQueuedSendPackets();
break;
//Chat Received
case 0x0003:
ChatMessagePacket chatMessage = new ChatMessagePacket(subpacket.data);
//Program.Log.Info("Got type-{5} message: {0} @ {1}, {2}, {3}, Rot: {4}", chatMessage.message, chatMessage.posX, chatMessage.posY, chatMessage.posZ, chatMessage.posRot, chatMessage.logType);
if (chatMessage.message.StartsWith("!"))
{
if (Server.GetCommandProcessor().DoCommand(chatMessage.message, session))
{
return;
}
;
}
if (chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SAY || chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SHOUT)
{
session.GetActor().BroadcastPacket(SendMessagePacket.BuildPacket(session.id, chatMessage.logType, session.GetActor().customDisplayName, chatMessage.message), false);
}
break;
//Langauge Code (Client safe to send packets to now)
case 0x0006:
LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data);
LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onBeginLogin", true);
Server.GetWorldManager().DoZoneIn(session.GetActor(), true, 0x1);
LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onLogin", true);
session.languageCode = langCode.languageCode;
break;
//Unknown - Happens a lot at login, then once every time player zones
case 0x0007:
//subpacket.DebugPrintSubPacket();
ZoneInCompletePacket zoneInCompletePacket = new ZoneInCompletePacket(subpacket.data);
break;
//Update Position
case 0x00CA:
//Update Position
UpdatePlayerPositionPacket posUpdate = new UpdatePlayerPositionPacket(subpacket.data);
session.UpdatePlayerActorPosition(posUpdate.x, posUpdate.y, posUpdate.z, posUpdate.rot, posUpdate.moveState);
session.GetActor().SendInstanceUpdate();
if (session.GetActor().IsInZoneChange())
{
session.GetActor().SetZoneChanging(false);
}
break;
//Set Target
case 0x00CD:
//subpacket.DebugPrintSubPacket();
SetTargetPacket setTarget = new SetTargetPacket(subpacket.data);
session.GetActor().currentTarget = setTarget.actorID;
session.GetActor().BroadcastPacket(SetActorTargetAnimatedPacket.BuildPacket(session.id, setTarget.actorID), true);
break;
//Lock Target
case 0x00CC:
LockTargetPacket lockTarget = new LockTargetPacket(subpacket.data);
session.GetActor().currentLockedTarget = lockTarget.actorID;
break;
//Start Event
case 0x012D:
subpacket.DebugPrintSubPacket();
EventStartPacket eventStart = new EventStartPacket(subpacket.data);
/*
* if (eventStart.error != null)
* {
* player.errorMessage += eventStart.error;
*
* if (eventStart.errorIndex == eventStart.errorNum - 1)
* Program.Log.Error("\n"+player.errorMessage);
*
*
* break;
* }
*/
Actor ownerActor = Server.GetStaticActors(eventStart.scriptOwnerActorID);
session.GetActor().currentEventOwner = eventStart.scriptOwnerActorID;
session.GetActor().currentEventName = eventStart.triggerName;
if (ownerActor == null)
{
//Is it a instance actor?
ownerActor = session.GetActor().zone.FindActorInArea(session.GetActor().currentEventOwner);
if (ownerActor == null)
{
//Is it a Director?
Director director = session.GetActor().GetDirector(eventStart.scriptOwnerActorID);
if (director != null)
{
ownerActor = director;
}
else
{
Program.Log.Debug("\n===Event START===\nCould not find actor 0x{0:X} for event started by caller: 0x{1:X}\nEvent Starter: {2}\nParams: {3}", eventStart.actorID, eventStart.scriptOwnerActorID, eventStart.triggerName, LuaUtils.DumpParams(eventStart.luaParams));
break;
}
}
}
session.GetActor().StartEvent(ownerActor, eventStart);
Program.Log.Debug("\n===Event START===\nSource Actor: 0x{0:X}\nCaller Actor: 0x{1:X}\nVal1: 0x{2:X}\nVal2: 0x{3:X}\nEvent Starter: {4}\nParams: {5}", eventStart.actorID, eventStart.scriptOwnerActorID, eventStart.val1, eventStart.val2, eventStart.triggerName, LuaUtils.DumpParams(eventStart.luaParams));
break;
//Unknown, happens at npc spawn and cutscene play????
case 0x00CE:
subpacket.DebugPrintSubPacket();
break;
//Event Result
case 0x012E:
subpacket.DebugPrintSubPacket();
EventUpdatePacket eventUpdate = new EventUpdatePacket(subpacket.data);
Program.Log.Debug("\n===Event UPDATE===\nSource Actor: 0x{0:X}\nCaller Actor: 0x{1:X}\nVal1: 0x{2:X}\nVal2: 0x{3:X}\nStep: 0x{4:X}\nParams: {5}", eventUpdate.actorID, eventUpdate.scriptOwnerActorID, eventUpdate.val1, eventUpdate.val2, eventUpdate.step, LuaUtils.DumpParams(eventUpdate.luaParams));
/*
* //Is it a static actor? If not look in the player's instance
* Actor updateOwnerActor = Server.GetStaticActors(session.GetActor().currentEventOwner);
* if (updateOwnerActor == null)
* {
* updateOwnerActor = Server.GetWorldManager().GetActorInWorld(session.GetActor().currentEventOwner);
*
* if (session.GetActor().currentDirector != null && session.GetActor().currentEventOwner == session.GetActor().currentDirector.actorId)
* updateOwnerActor = session.GetActor().currentDirector;
*
* if (updateOwnerActor == null)
* break;
* }
*/
session.GetActor().UpdateEvent(eventUpdate);
//LuaEngine.DoActorOnEventUpdated(session.GetActor(), updateOwnerActor, eventUpdate);
break;
case 0x012F:
subpacket.DebugPrintSubPacket();
ParameterDataRequestPacket paramRequest = new ParameterDataRequestPacket(subpacket.data);
if (paramRequest.paramName.Equals("charaWork/exp"))
{
session.GetActor().SendCharaExpInfo();
}
break;
//Group Created Confirm
case 0x0133:
GroupCreatedPacket groupCreated = new GroupCreatedPacket(subpacket.data);
Server.GetWorldManager().SendGroupInit(session, groupCreated.groupId);
break;
/* RECRUITMENT */
//Start Recruiting
case 0x01C3:
StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data);
session.QueuePacket(StartRecruitingResponse.BuildPacket(session.id, true));
break;
//End Recruiting
case 0x01C4:
session.QueuePacket(EndRecruitmentPacket.BuildPacket(session.id));
break;
//Party Window Opened, Request State
case 0x01C5:
session.QueuePacket(RecruiterStatePacket.BuildPacket(session.id, false, false, 0));
break;
//Search Recruiting
case 0x01C7:
RecruitmentSearchRequestPacket recruitSearchPacket = new RecruitmentSearchRequestPacket(subpacket.data);
break;
//Get Recruitment Details
case 0x01C8:
RecruitmentDetailsRequestPacket currentRecruitDetailsPacket = new RecruitmentDetailsRequestPacket(subpacket.data);
RecruitmentDetails details = new RecruitmentDetails();
details.recruiterName = "Localhost Character";
details.purposeId = 2;
details.locationId = 1;
details.subTaskId = 1;
details.comment = "This is a test details packet sent by the server. No implementation has been Created yet...";
details.num[0] = 1;
session.QueuePacket(CurrentRecruitmentDetailsPacket.BuildPacket(session.id, details));
break;
//Accepted Recruiting
case 0x01C6:
subpacket.DebugPrintSubPacket();
break;
/* SOCIAL STUFF */
case 0x01C9:
AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data);
session.QueuePacket(BlacklistAddedPacket.BuildPacket(session.id, true, addBlackList.name));
break;
case 0x01CA:
AddRemoveSocialPacket RemoveBlackList = new AddRemoveSocialPacket(subpacket.data);
session.QueuePacket(BlacklistRemovedPacket.BuildPacket(session.id, true, RemoveBlackList.name));
break;
case 0x01CB:
int offset1 = 0;
session.QueuePacket(SendBlacklistPacket.BuildPacket(session.id, new String[] { "Test" }, ref offset1));
break;
case 0x01CC:
AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data);
session.QueuePacket(FriendlistAddedPacket.BuildPacket(session.id, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name));
break;
case 0x01CD:
AddRemoveSocialPacket RemoveFriendList = new AddRemoveSocialPacket(subpacket.data);
session.QueuePacket(FriendlistRemovedPacket.BuildPacket(session.id, true, RemoveFriendList.name));
break;
case 0x01CE:
int offset2 = 0;
session.QueuePacket(SendFriendlistPacket.BuildPacket(session.id, new Tuple <long, string>[] { new Tuple <long, string>(01, "Test2") }, ref offset2));
break;
case 0x01CF:
session.QueuePacket(FriendStatusPacket.BuildPacket(session.id, null));
break;
/* SUPPORT DESK STUFF */
//Request for FAQ/Info List
case 0x01D0:
FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data);
session.QueuePacket(FaqListResponsePacket.BuildPacket(session.id, new string[] { "Testing FAQ1", "Coded style!" }));
break;
//Request for body of a faq/info selection
case 0x01D1:
FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data);
session.QueuePacket(FaqBodyResponsePacket.BuildPacket(session.id, "HERE IS A GIANT BODY. Nothing else to say!"));
break;
//Request issue list
case 0x01D2:
GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data);
session.QueuePacket(IssueListResponsePacket.BuildPacket(session.id, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }));
break;
//Request if GM ticket exists
case 0x01D3:
session.QueuePacket(StartGMTicketPacket.BuildPacket(session.id, false));
break;
//Request for GM response message
case 0x01D4:
session.QueuePacket(GMTicketPacket.BuildPacket(session.id, "This is a GM Ticket Title", "This is a GM Ticket Body."));
break;
//GM Ticket Sent
case 0x01D5:
GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data);
Program.Log.Info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody);
session.QueuePacket(GMTicketSentResponsePacket.BuildPacket(session.id, true));
break;
//Request to end ticket
case 0x01D6:
session.QueuePacket(EndGMTicketPacket.BuildPacket(session.id));
break;
default:
Program.Log.Debug("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode);
subpacket.DebugPrintSubPacket();
break;
}
}
internal void SendError(int v1, string v2)
{
ErrorPacket errorPacket = new ErrorPacket(v1, v2);
this.Send(errorPacket);
}
protected override void OnHandle(IPacket packet, ClientWorldState worldState)
{
ErrorPacket recivedPacket = (ErrorPacket)packet;
NetworkEngine.Instance.AddServerError(recivedPacket.Code, recivedPacket.Message);
}
public ShowErrorDialog(ErrorPacket ePack)
{
InitializeComponent();
LoadErrorContent(ePack);
}
public ShowErrorDialog(ErrorPacket ePack)
{
InitializeComponent();
LoadErrorContent(ePack);
}
public void PacketArrived(LumaQQ.NET.Packets.InPacket inPacket)
{
// BasicInPacket packet = (BasicInPacket)inPacket;
if (inPacket is UnknownInPacket)
{
client.PacketManager.OnReceivedUnknownPacket(new QQEventArgs <UnknownInPacket, OutPacket>(client, (UnknownInPacket)inPacket, null));
return;
}
if (inPacket is ErrorPacket)
{
ErrorPacket error = (ErrorPacket)inPacket;
if (error.ErrorType == ErrorPacketType.ERROR_TIMEOUT)
{
client.PacketManager.OnSendPacketTimeOut(new QQEventArgs <InPacket, OutPacket>(client, null, error.TimeOutPacket));
}
else
{
client.OnError(new QQEventArgs <ErrorPacket, OutPacket>(client, (ErrorPacket)inPacket, null));
}
return;
}
// 检查目前是否已经登录
if (user == null || !user.IsLoggedIn)
{
//按理说应该把在登陆之前时收到的包缓存起来，但是在实际中观察发现，登录之前收到的
//东西基本没用，所以在这里不做任何事情，简单的抛弃这个包
if (!IsPreloginPacket(inPacket))
{
return;
}
}
// 现在开始判断包的类型，作出相应的处理
ConnectionPolicy policy = client.ConnectionManager.GetConnection(inPacket.PortName).Policy;
// 根据输入包，检索对应的输出包
OutPacket outPacket = policy.RetrieveSent(inPacket);
// 这里检查是不是服务器发回的确认包
// 为什么要检查这个呢，因为有些包是服务器主动发出的，对于这些包我们是不需要
// 从超时发送队列中移除的，如果是服务器的确认包，那么我们就需要把超时发送队列
// 中包移除
switch (inPacket.Command)
{
// 这三种包是服务器先发出的，我们要确认
case QQCommand.Recv_IM:
case QQCommand.Recv_Msg_Sys:
case QQCommand.Recv_Msg_Friend_Change_Status:
break;
// 其他情况我们删除超时队列中的包
default:
client.PacketManager.RemoveResendPacket(inPacket);
client.PacketManager.OnSendPacketSuccessed(new QQEventArgs <InPacket, OutPacket>(client, inPacket, outPacket));
break;
}
switch (inPacket.Command)
{
case QQCommand.Request_Login_Token:
this.user = client.QQUser;
ProcessRequestLoginTokenReply((RequestLoginTokenReplyPacket)inPacket, outPacket as RequestLoginTokenPacket);
break;
case QQCommand.Login:
ProcessLoginReply((LoginReplyPacket)inPacket, outPacket as LoginPacket);
break;
case QQCommand.Keep_Alive:
ProcessKeepAliveReply((KeepAliveReplyPacket)inPacket, outPacket as KeepAlivePacket);
break;
case QQCommand.Recv_IM:
ProcessReceiveIM((ReceiveIMPacket)inPacket);
break;
case QQCommand.Get_Friend_List:
ProcessGetFriendListReply((GetFriendListReplyPacket)inPacket, outPacket as GetFriendListPacket);
break;
case QQCommand.Get_Online_OP:
ProcessGetFriendOnlineReply((GetOnlineOpReplyPacket)inPacket, outPacket as GetOnlineOpPacket);
break;
case QQCommand.Get_UserInfo:
ProcessGetUserInfoReply((GetUserInfoReplyPacket)inPacket, outPacket as GetUserInfoPacket);
break;
case QQCommand.Change_Status:
ProcessChangeStatusReply((ChangeStatusReplyPacket)inPacket, outPacket as ChangeStatusPacket);
break;
case QQCommand.Recv_Msg_Friend_Change_Status:
ProcessFriendChangeStatus((FriendChangeStatusPacket)inPacket);
break;
case QQCommand.Recv_Msg_Sys:
ProcessSystemNotification((SystemNotificationPacket)inPacket);
break;
case QQCommand.Add_Friend_Ex:
ProcessAddFriendExReply((AddFriendExReplyPacket)inPacket, outPacket as AddFriendExPacket);
break;
case QQCommand.Add_Friend_Auth:
ProcessAddFriendAuthReply((AddFriendAuthResponseReplyPacket)inPacket, outPacket as AddFriendAuthResponsePacket);
break;
case QQCommand.Remove_Self:
ProcessRemoveSelfReply((RemoveSelfReplyPacket)inPacket, outPacket as RemoveSelfPacket);
break;
case QQCommand.Delete_Friend:
ProcessDeleteFriendReply((DeleteFriendReplyPacket)inPacket, outPacket as DeleteFriendPacket);
break;
case QQCommand.Authorize:
ProcessAuthorizeReply((AuthorizeReplyPacket)inPacket, outPacket as AuthorizePacket);
break;
case QQCommand.Upload_Group_Friend:
ProcessUploadGroupFriendReply((UploadGroupFriendReplyPacket)inPacket, (UploadGroupFriendPacket)outPacket);
break;
case QQCommand.Modify_Info:
ProcessModifyInfoReply((ModifyInfoReplyPacket)inPacket, (ModifyInfoPacket)outPacket);
break;
case QQCommand.Signature_OP:
ProcessSignatureOpReply((SignatureOpReplyPacket)inPacket, (SignatureOpPacket)outPacket);
break;
case QQCommand.Privacy_Data_OP:
ProcessPrivacyDataOpReply((PrivacyDataOpReplyPacket)inPacket, (PrivacyDataOpPacket)outPacket);
break;
case QQCommand.Friend_Data_OP:
ProcessFriendDataOpReply((FriendDataOpReplyPacket)inPacket, (FriendDataOpPacket)outPacket);
break;
case QQCommand.Friend_Level_OP:
ProcessFriendLevelOpReply((FriendLevelOpReplyPacket)inPacket, (FriendLevelOpPacket)outPacket);
break;
case QQCommand.User_Property_OP:
PocessUserPropertyOpReply((UserPropertyOpReplyPacket)inPacket, (UserPropertyOpPacket)outPacket);
break;
case QQCommand.Download_Group_Friend:
ProcessDownloadGroupFriendReply((DownloadGroupFriendReplyPacket)inPacket, (DownloadGroupFriendPacket)outPacket);
break;
case QQCommand.Group_Data_OP:
ProcessGroupNameOpReply((GroupDataOpReplyPacket)inPacket, (GroupDataOpPacket)outPacket);
break;
case QQCommand.Search_User:
ProcessSearchUserReply((SearchUserReplyPacket)inPacket, (SearchUserPacket)outPacket);
break;
case QQCommand.Weather_OP:
ProcessWeatherOpReply((WeatherOpReplyPacket)inPacket, (WeatherOpPacket)outPacket);
break;
}
}
public static Packet RenderPacket(PacketType type, string payload)
{
switch (type)
{
case PacketType.Exit:
{
ExitPacket p = JsonConvert.DeserializeObject <ExitPacket>(payload);
return(p);
}
case PacketType.Error:
{
ErrorPacket p = JsonConvert.DeserializeObject <ErrorPacket>(payload);
return(p);
}
case PacketType.VersionRequest:
{
VersionPacket p = JsonConvert.DeserializeObject <VersionPacket>(payload);
return(p);
}
case PacketType.VersionResponse:
{
VersionPacket p = JsonConvert.DeserializeObject <VersionPacket>(payload);
return(p);
}
case PacketType.LoginRequest:
{
LoginRequestPacket p = JsonConvert.DeserializeObject <LoginRequestPacket>(payload);
return(p);
}
case PacketType.LoginResponse:
{
LoginResponsePacket p = JsonConvert.DeserializeObject <LoginResponsePacket>(payload);
return(p);
}
case PacketType.PlayerListRequest:
{
PlayerListRequestPacket p = JsonConvert.DeserializeObject <PlayerListRequestPacket>(payload);
return(p);
}
case PacketType.PlayerListResponse:
{
LoginResponsePacket p = JsonConvert.DeserializeObject <LoginResponsePacket>(payload);
return(p);
}
case PacketType.CreateLobbyRequest:
{
CreateLobbyRequestPacket p = JsonConvert.DeserializeObject <CreateLobbyRequestPacket>(payload);
return(p);
}
case PacketType.CreateLobbyResponse:
{
CreateLobbyResponsePacket p = JsonConvert.DeserializeObject <CreateLobbyResponsePacket>(payload);
return(p);
}
default:
Console.WriteLine("packet type not found.");
return(new Packet());
}
}
// Processes a file and extracts the packet data
private void processFile(string path)
{
string[] lines;
{
List <string> linesList = File.ReadLines(@path).ToList();
linesList.RemoveAll(string.IsNullOrEmpty);
lines = linesList.ToArray();
}
int lineCount = lines.Length;
byte entryPort;
byte exitPort;
List <string> allPacketTimes = new List <string>();
List <string> allPacketEndMarkers = new List <string>();
List <List <byte> > allPacketBytes = new List <List <byte> >();
List <bool> duplicatePacket = new List <bool>();
if (lineCount >= 2)
{
int lineIndex = 0;
// First two lines are timestamp for measurement start and port
{
DateTime tmpTime = Packet.parseDateString(lines[lineIndex++]);
if (startTime == DateTime.MinValue || tmpTime.Ticks < startTime.Ticks)
{
startTime = tmpTime;
if (endTime == DateTime.MinValue || startTime.Ticks > endTime.Ticks)
{
endTime = startTime;
}
}
}
entryPort = Convert.ToByte(lines[lineIndex++]);
if (!m_portsLoaded.Contains(entryPort))
{
m_portsLoaded.Add(entryPort);
m_portsLoaded.Sort();
}
exitPort = (byte)(entryPort + (entryPort % 2 == 0 ? -1 : 1));
string lastByteString = "";
while (lineIndex < lineCount)
{
string time, startCode, endCode, byteString, errorText;
// Next line is a timestamp
time = lines[lineIndex];
// Store this time in case file ends
{
DateTime tmpTime = Packet.parseDateString(time);
if (tmpTime.Ticks > endTime.Ticks)
{
endTime = tmpTime;
}
}
if (++lineIndex >= lines.Length)
{
break;
}
// Start code (E or P)
startCode = lines[lineIndex];
if (++lineIndex >= lines.Length)
{
break;
}
if (startCode.Equals("E", StringComparison.Ordinal))
{
// This is an error packet
errorText = lines[lineIndex];
ErrorPacket errorMessage = new ErrorPacket(entryPort, exitPort, time, errorText);
errorMessage.TimeStamp = errorMessage.TimeStamp.AddTicks(2);
m_packets.Add(errorMessage);
}
else if (startCode.Equals("P", StringComparison.Ordinal))
{
// This is a packet
byteString = lines[lineIndex];
duplicatePacket.Add(byteString == lastByteString);
lastByteString = byteString;
if (++lineIndex >= lines.Length)
{
break;
}
endCode = lines[lineIndex];
string[] byteStringSplit = byteString.Split(' ');
int byteCount = byteStringSplit.Count();
List <byte> packetBytes = new List <byte>(byteCount);
for (int i = 0; i < byteCount; ++i)
{
packetBytes.Add(Convert.ToByte(byteStringSplit[i], 16));
}
allPacketTimes.Add(time);
allPacketBytes.Add(packetBytes);
allPacketEndMarkers.Add(endCode);
}
else
{
// Unknown start code
// throw error?
break;
}
++lineIndex;
}
int sequenceIdIndex = -1;
int lastSequenceId = -1;
for (int i = 0; i < allPacketBytes.Count; ++i)
{
bool sequenceIdError = false;
Type packetType = DataPacket.GetPacketType(allPacketBytes[i]);
object[] args;
if (packetType == typeof(NonRmapPacket))
{
if (sequenceIdIndex == -1)
{
sequenceIdIndex = getSequenceIdIndex(allPacketBytes);
}
int sequenceId = sequenceIdIndex == -1 ? 0 : allPacketBytes[i][sequenceIdIndex];
if (lastSequenceId == -1)
{
lastSequenceId = sequenceId;
}
else
{
sequenceIdError = !((sequenceId == 0 && lastSequenceId == 255) || sequenceId == lastSequenceId + 1);
lastSequenceId = sequenceId;
}
args = new object[] {
entryPort,
exitPort,
allPacketTimes[i],
allPacketBytes[i],
allPacketEndMarkers[i],
sequenceIdIndex
};
}
else
{
args = new object[] {
entryPort,
exitPort,
allPacketTimes[i],
allPacketBytes[i],
allPacketEndMarkers[i]
};
}
dynamic packet = Activator.CreateInstance(packetType, args);
packet.SequenceIdError = sequenceIdError;
packet.DuplicatePacketError = duplicatePacket[i];
if (!packet.Valid)
{
packet.TimeStamp = packet.TimeStamp.AddTicks(1);
}
if (packet.GetType() == typeof(DataPacket))
{
packet.FormatError = true;
}
m_packets.Add(packet);
}
}
}
