internal void Pong(int time, PongPacket pkt)
{
try
{
if (Random.Next(1, 100000) == 1)
{
Client.GiftCodeReceived("Pong");
}
updateLastSeen++;
if (updateLastSeen >= 60)
{
Manager.Database.DoActionAsync(db =>
{
db.UpdateLastSeen(Client.Account.AccountId, Client.Character.CharacterId, WorldInstance.Name);
updateLastSeen = 0;
});
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
void DestroyWorstNeighbor(double?mutualValueLowLimit, DateTime timeNowUtc)
{
if (ConnectedNeighbors.Any(x => x.IsInTeardownState))
{
return;
}
double?worstValue = mutualValueLowLimit;
ConnectionToNeighbor worstNeighbor = null;
foreach (var neighbor in ConnectedNeighborsCanBeUsedForNewRequests)
{
var p2pConnectionValue_withNeighbor =
P2pConnectionValueCalculator.GetMutualP2pConnectionValue(CryptoLibrary,
this.Configuration.LocalPeerRegistrationId, this.ConnectedNeighborsBusySectorIds,
neighbor.RemoteRegistrationId, neighbor.RemoteNeighborsBusySectorIds ?? 0,
Engine.NumberOfDimensions,
true,
this.AnotherNeighborToSameSectorExists(neighbor),
neighbor.Remote_AnotherNeighborToSameSectorExists ?? false
);
Engine.WriteToLog_p2p_higherLevelDetail(neighbor, $"@DestroyWorstNeighbor() p2pConnectionValue_withNeighbor={p2pConnectionValue_withNeighbor} from {this} to {neighbor}", null);
if (worstValue == null || p2pConnectionValue_withNeighbor < worstValue)
{
worstValue = p2pConnectionValue_withNeighbor;
worstNeighbor = neighbor;
}
}
if (worstNeighbor != null)
{
_lastTimeDetroyedWorstNeighborUtc = timeNowUtc;
Engine.WriteToLog_p2p_higherLevelDetail(worstNeighbor, $"destroying worst P2P connection with neighbor. neighbors count = {ConnectedNeighbors.Count}", null);
var ping = worstNeighbor.CreatePing(false, true, 0, false);
var pendingPingRequest = new PendingLowLevelUdpRequest("pendingPingRequest 351", worstNeighbor.RemoteEndpoint,
PongPacket.GetScanner(worstNeighbor.LocalNeighborToken32, ping.PingRequestId32), Engine.DateTimeNowUtc,
Engine.Configuration.UdpLowLevelRequests_ExpirationTimeoutS,
ping.Encode(),
Engine.Configuration.UdpLowLevelRequests_InitialRetransmissionTimeoutS,
Engine.Configuration.UdpLowLevelRequests_RetransmissionTimeoutIncrement
);
_ = Engine.SendUdpRequestAsync_Retransmit(pendingPingRequest); // retransmit until PONG
worstNeighbor.IsInTeardownState = true;
Engine.EngineThreadQueue.EnqueueDelayed(TimeSpan.FromSeconds(PingPacket.ConnectionTeardownStateDurationS), () =>
{
if (!worstNeighbor.IsDisposed)
{
Engine.WriteToLog_p2p_higherLevelDetail(worstNeighbor, $"destroying worst P2P connection after teardown state timeout", null);
worstNeighbor.Dispose();
}
}, "estroying worst P2P connection 2146");
}
}
private void ListenForMessages()
{
NetIncomingMessage message;
Console.WriteLine("CLIENT: Listening for messages");
while (isListening)
{
while ((message = client.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
// handle custom messages
//read
PacketTypes type = (PacketTypes)message.ReadByte();
PongPacket payPacket = PacketHelper.Get <PongPacket>(type);
payPacket.Deserialize(message);
Console.WriteLine($"We got a packet of: {type} with PingMs {payPacket.PingMs}");
//send
NetOutgoingMessage msg = client.CreateMessage();
PingPacket outbound = PacketHelper.Get <PingPacket>(PacketTypes.Ping);
outbound.PingMs = DateTime.Now.Millisecond;
outbound.Serialize(msg);
client.SendMessage(msg, message.SenderConnection, NetDeliveryMethod.ReliableOrdered);
Console.WriteLine($"We sent a packet of: {PacketTypes.Ping} with PingMs {outbound.PingMs}");
break;
case NetIncomingMessageType.StatusChanged:
// handle connection status messages
//switch (message.SenderConnection.Status) {
/* .. */
//}
Console.WriteLine($"CLIENT: Status Changed = {message.SenderConnection.Status}");
break;
case NetIncomingMessageType.DebugMessage:
// handle debug messages
// (only received when compiled in DEBUG mode)
Console.WriteLine($"CLIENT: {message.ReadString()}");
break;
/* .. */
case NetIncomingMessageType.WarningMessage:
Console.WriteLine($"CLIENT: WARNING: {message}");
break;
default:
Console.WriteLine("CLIENT: unhandled message with type: "
+ message.MessageType);
break;
}
}
}
Console.WriteLine("CLIENT: Done listening for messages");
}
internal void Pong(int time, PongPacket pkt)
{
try
{
updateLastSeen++;
}
catch (Exception e)
{
log.Error(e);
}
}
public async Task PongAsync()
{
await _policy.ExecuteAsync(async (content) =>
{
await ConnectAsync();
var Packet = new PongPacket();
await _embed_channel.WriteAndFlushAsync(Packet);
}, new Dictionary <string, object>() { { "hld", "PongAsync" } });
}
public void Pong(PongPacket pkt)
{
if (lastTime != null && (pkt.Time - lastTime.Value > 3000 || pkt.Time - lastTime.Value < 0))
{
;//psr.Disconnect();
}
else
{
lastTime = pkt.Time;
}
tickMapping = ts.Dequeue() - pkt.Time;
lastPong = pkt.Time + tickMapping;
}
internal void Pong(int time, PongPacket pkt)
{
updateLastSeen++;
if (Owner.Timers.Contains(PongDCTimer))
{
Owner.Timers.Remove(PongDCTimer);
}
Owner.Timers.Add(PongDCTimer = new WorldTimer(DC_THRESOLD, (w, t) =>
{
SendError("Lost connection to server.");
Client.Disconnect();
}));
}
internal void Pong(int time, PongPacket pkt)
{
if (lastTime != null && (time - lastTime.Value > 17500 || time - lastTime.Value < 0))
{
SendError("Lost connection to server.");
client.Disconnect();
}
else
{
lastTime = time;
}
tickMapping = ts.Dequeue() - time;
lastPong = time + tickMapping;
sentPing = false;
}
public void Pong(PongPacket pkt)
{
if (lastTime != null && (pkt.Time - lastTime.Value > 15000 || pkt.Time - lastTime.Value < 0))
#pragma warning disable 642
{
; //psr.Disconnect();
}
#pragma warning restore 642
else
{
lastTime = pkt.Time;
}
tickMapping = ts.Dequeue() - pkt.Time;
lastPong = pkt.Time + tickMapping;
sentPing = false;
}
protected override void ChannelRead0(IChannelHandlerContext ctx, PingPacket msg)
{
_logger.LogDebug("Receive Ping-[{0}]", msg.PingCode);
try
{
var pongPacket = new PongPacket()
{
Sequence = 0
};
ctx.WriteAndFlushAsync(pongPacket);
}
finally
{
ReferenceCountUtil.SafeRelease(msg);
}
}
static void EncodePongMessage(IByteBufferAllocator bufferAllocator, PongPacket packet, List <object> output)
{
IByteBuffer buf = null;
try
{
buf = bufferAllocator.Buffer(PONG_BYTES.Length + CRLF_BYTES.Length);
buf.WriteBytes(PONG_BYTES);
buf.WriteBytes(CRLF_BYTES);
output.Add(buf);
buf = null;
}
finally
{
buf?.SafeRelease();
}
}
internal void Pong(int time, PongPacket pkt)
{
try
{
_updateLastSeen++;
if (_updateLastSeen >= 60)
{
Manager.Database.DoActionAsync(db =>
{
db.UpdateLastSeen(Client.Account.AccountId, Client.Character.CharacterId, WorldInstance.Name);
_updateLastSeen = 0;
});
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
internal void Pong(int time, PongPacket pkt)
{
try
{
/*if (Random.Next(-999999999, 999999999) == 1)
* Client.GiftCodeReceived("Pong");*/
/*updateLastSeen++;
* if (updateLastSeen >= 300)
* {
* Manager.Database.DoActionAsync(db =>
* {
* db.UpdateLastSeen(Client.Account.AccountId, Client.Character.CharacterId, WorldInstance.Name);
* updateLastSeen = 0;
* });
* }*/
}
catch// (Exception e)
{
//log.Error(e);
}
}
internal void Pong(int time, PongPacket pkt)
{
try
{
if (Random.Next(1, 100000) == 1)
{
updateLastSeen++;
}
if (updateLastSeen >= 60)
{
Manager.Database.DoActionAsync(db =>
{
db.UpdateLastSeen(Client.Account.AccountId, Client.Character.CharacterId, WorldInstance.Name);
updateLastSeen = 0;
});
}
}
catch (Exception e)
{
log.Error(e);
}
}
internal void DoDecode(IChannelHandlerContext context, IByteBuffer buffer, List <object> output)
{
////1 byte type, 4 byte sequence, 4 byte length
//if (buffer.ReadableBytes < 9)
//{
// return;
//}
////var lengthBuffer = buffer.Slice(5, 4);
////// is that right?
////var length = lengthBuffer.ReadInt();
//var length = buffer.GetInt(5);
//// buffer is smaller than packet length
//if (buffer.ReadableBytes < 9 + length)
//{
// return;
//}
var packetType = (PacketType)buffer.ReadByte();
var sequence = buffer.ReadInt();
switch (packetType)
{
case PacketType.PINGREQ:
var pingCode = buffer.ReadByte();
var pingPacket = new PingPacket()
{
Sequence = sequence,
PingCode = pingCode
};
output.Add(pingPacket);
break;
case PacketType.PINGRESP:
var pongCode = buffer.ReadByte();
var pongPacket = new PongPacket()
{
Sequence = sequence,
PongCode = pongCode
};
output.Add(pongPacket);
break;
case PacketType.MESSAGEREQ:
var req_code = buffer.ReadShort();
var req_length = buffer.ReadInt();
var messageReqPacket = new MessageReqPacket()
{
Sequence = sequence,
Code = req_code,
Body = new byte[req_length]
};
buffer.ReadBytes(messageReqPacket.Body);
output.Add(messageReqPacket);
break;
case PacketType.MESSAGERESP:
var resp_code = buffer.ReadShort();
var resp_length = buffer.ReadInt();
var messageRespPacket = new MessageRespPacket()
{
Sequence = sequence,
Code = resp_code,
Body = new byte[resp_length]
};
buffer.ReadBytes(messageRespPacket.Body);
output.Add(messageRespPacket);
break;
case PacketType.PUSHREQ:
var reqPush_type = buffer.ReadByte();
var reqPush_code = buffer.ReadShort();
var reqPush_length = buffer.ReadInt();
var reqPushPacket = new PushReqPacket()
{
Sequence = sequence,
Code = reqPush_code,
PushType = (PushType)reqPush_type,
Body = new byte[reqPush_length]
};
buffer.ReadBytes(reqPushPacket.Body);
output.Add(reqPushPacket);
break;
case PacketType.PUSHRESP:
var respPush_type = buffer.ReadByte();
var respPush_Code = buffer.ReadShort();
var respPush_length = buffer.ReadInt();
var respPushPacket = new PushRespPacket()
{
Sequence = sequence,
Code = respPush_Code,
PushType = (PushType)respPush_type,
Body = new byte[respPush_length]
};
buffer.ReadBytes(respPushPacket.Body);
output.Add(respPushPacket);
break;
default:
throw new ArgumentException("Invalid packet type!");
}
}
/// <summary>
/// main register responder proc for both A-EP and P2P modes
/// in P2P mode Timestamp32S, NeighborToken32 and NeighborHMAC are verified at this time
/// </summary>
/// <param name="receivedFromInP2pMode">
/// is null in A-EP mode
/// </param>
internal async Task AcceptRegisterRequestAsync(LocalDrpPeer acceptAt, RoutedRequest routedRequest) // engine thread
{
var logger = routedRequest.Logger;
logger.ModuleName = VisionChannelModuleName_reg_responderSide;
var req = routedRequest.RegisterReq;
if (req.RequesterRegistrationId.Equals(acceptAt.Configuration.LocalPeerRegistrationId))
{
throw new InvalidOperationException();
}
// check signature of requester (A)
if (!req.RequesterSignature.Verify(_cryptoLibrary,
w => req.GetSharedSignedFields(w, false),
req.RequesterRegistrationId
)
)
{
throw new BadSignatureException("invalid REGISTER REQ RequesterSignature 2396");
}
if (routedRequest.ReceivedFromNeighborNullable == null)
{ // A-EP mode
if (req.EpEndpoint.Address.Equals(acceptAt.PublicIpApiProviderResponse) == false)
{
throw new PossibleAttackException();
}
}
if (PendingRegisterRequestExists(req.RequesterRegistrationId))
{
// received duplicate REGISTER REQ packet
logger.WriteToLog_needsAttention($"ignoring duplicate registration request {req.RequesterRegistrationId} from {routedRequest.ReceivedFromEndpoint}");
return;
}
if (!RecentUniqueAcceptedRegistrationRequests.Filter(req.GetUniqueRequestIdFields))
{
logger.WriteToLog_needsAttention($"ignoring registration request {req.RequesterRegistrationId} ts={req.ReqTimestamp64} from {routedRequest.ReceivedFromEndpoint} with non-unique request ID fields");
return;
}
logger.WriteToLog_higherLevelDetail($"accepting registration from {routedRequest.ReceivedFromEndpoint}: ReqP2pSeq16={req.ReqP2pSeq16}, NumberOfHopsRemaining={req.NumberOfHopsRemaining}, epEndpoint={req.EpEndpoint}, sourcePeer={routedRequest.ReceivedFromNeighborNullable}, ts={req.ReqTimestamp64}");
if (!RecentUniquePublicEcdhKeys.Filter(req.RequesterEcdhePublicKey.Ecdh25519PublicKey))
{
logger.WriteToLog_needsAttention($"ignoring registration request {req.RequesterRegistrationId} from {routedRequest.ReceivedFromEndpoint} with non-unique RequesterEcdhePublicKey");
return;
}
_pendingRegisterRequests.Add(req.RequesterRegistrationId);
try
{
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending NPACK to REQ to {routedRequest.ReceivedFromEndpoint} (delay={routedRequest.ReqReceivedSw_ms}ms)");
}
routedRequest.SendNeighborPeerAck_accepted_IfNotAlreadyReplied();
var newConnectionToNeighbor = new ConnectionToNeighbor(this, acceptAt, ConnectedDrpPeerInitiatedBy.remotePeer, req.RequesterRegistrationId)
{
LocalEndpoint = routedRequest.ReceivedFromNeighborNullable?.LocalEndpoint ?? req.EpEndpoint,
};
byte[] ack1UdpData;
try
{
var ack1 = new RegisterAck1Packet
{
RequesterRegistrationId = req.RequesterRegistrationId,
ReqTimestamp64 = req.ReqTimestamp64,
ResponderEcdhePublicKey = new EcdhPublicKey(newConnectionToNeighbor.LocalEcdhe25519PublicKey),
ResponderRegistrationId = acceptAt.Configuration.LocalPeerRegistrationId,
ReqP2pSeq16 = GetNewNpaSeq16_AtoEP(),
};
RecentUniquePublicEcdhKeys.AssertIsUnique(ack1.ResponderEcdhePublicKey.Ecdh25519PublicKey, $"ack1.ResponderEcdhePublicKey");
ack1.ToResponderTxParametersEncrypted = newConnectionToNeighbor.Encrypt_ack1_ToResponderTxParametersEncrypted_AtResponder_DeriveSharedDhSecret(logger, req, ack1, routedRequest.ReceivedFromNeighborNullable);
ack1.ResponderSignature = RegistrationSignature.Sign(_cryptoLibrary,
(w2) =>
{
req.GetSharedSignedFields(w2, true);
ack1.GetSharedSignedFields(w2, false, true);
},
acceptAt.Configuration.LocalPeerRegistrationPrivateKey);
if (routedRequest.ReceivedFromNeighborNullable == null)
{
ack1.RequesterEndpoint = routedRequest.ReceivedFromEndpoint;
}
ack1UdpData = ack1.Encode_OpionallySignNeighborHMAC(routedRequest.ReceivedFromNeighborNullable);
var ack2Scanner = RegisterAck2Packet.GetScanner(logger, routedRequest.ReceivedFromNeighborNullable, req);
var requesterVisibleDescription = routedRequest.ReceivedFromNeighborNullable?.ToString() ?? routedRequest.ReceivedFromEndpoint.ToString();
byte[] ack2UdpData;
if (routedRequest.ReceivedFromNeighborNullable == null)
{ // wait for ACK2, retransmitting ACK1
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending ACK1, waiting for ACK2");
}
ack2UdpData = await OptionallySendUdpRequestAsync_Retransmit_WaitForResponse("ack2 33469", requesterVisibleDescription, ack1UdpData, routedRequest.ReceivedFromEndpoint, ack2Scanner);
}
else
{ // retransmit ACK1 until NPACK (via P2P); at same time wait for ACK
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending ACK1, awaiting for NPACK");
}
_ = OptionallySendUdpRequestAsync_Retransmit_WaitForNeighborPeerAck("ack1 423087", ack1UdpData, routedRequest.ReceivedFromEndpoint,
ack1.ReqP2pSeq16, routedRequest.ReceivedFromNeighborNullable, ack1.GetSignedFieldsForNeighborHMAC);
// not waiting for NPACK, wait for ACK
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"waiting for ACK2");
}
ack2UdpData = await OptionallySendUdpRequestAsync_Retransmit_WaitForResponse("ack2 46051", requesterVisibleDescription, null, routedRequest.ReceivedFromEndpoint, ack2Scanner);
}
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"received ACK2");
}
var ack2 = RegisterAck2Packet.Decode_OptionallyVerify_InitializeP2pStreamAtResponder(logger, ack2UdpData, req, ack1, newConnectionToNeighbor);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified ACK2");
}
acceptAt.AddToConnectedNeighbors(newConnectionToNeighbor, req); // added to list here in order to respond to ping requests from A
SendNeighborPeerAckResponseToRegisterAck2(ack2, routedRequest.ReceivedFromEndpoint, routedRequest.ReceivedFromNeighborNullable); // send NPACK to ACK
_ = WaitForRegistrationConfirmationRequestAsync(requesterVisibleDescription, logger, routedRequest.ReceivedFromEndpoint, req, newConnectionToNeighbor, routedRequest.ReceivedFromNeighborNullable);
#region send ping, verify pong
var ping = newConnectionToNeighbor.CreatePing(true, false, acceptAt.ConnectedNeighborsBusySectorIds, acceptAt.AnotherNeighborToSameSectorExists(newConnectionToNeighbor));
var pendingPingRequest = new PendingLowLevelUdpRequest("pendingPingRequest 693", newConnectionToNeighbor.RemoteEndpoint,
PongPacket.GetScanner(newConnectionToNeighbor.LocalNeighborToken32, ping.PingRequestId32), DateTimeNowUtc,
Configuration.InitialPingRequests_ExpirationTimeoutS,
ping.Encode(),
Configuration.InitialPingRequests_InitialRetransmissionTimeoutS,
Configuration.InitialPingRequests_RetransmissionTimeoutIncrement
);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sent PING");
}
var pongPacketData = await SendUdpRequestAsync_Retransmit(pendingPingRequest); // wait for pong from A
if (pongPacketData == null)
{
throw new DrpTimeoutException($"reg. responder initial PING request to {newConnectionToNeighbor} (timeout={Configuration.InitialPingRequests_ExpirationTimeoutS}s)");
}
var pong = PongPacket.DecodeAndVerify(_cryptoLibrary,
pongPacketData, ping, newConnectionToNeighbor,
true);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified PONG");
}
newConnectionToNeighbor.OnReceivedVerifiedPong(pong, pendingPingRequest.ResponseReceivedAtUtc.Value,
pendingPingRequest.ResponseReceivedAtUtc.Value - pendingPingRequest.InitialTxTimeUTC.Value);
#endregion
}
catch (Exception exc)
{
newConnectionToNeighbor.Dispose();
throw exc;
}
}
catch (DrpTimeoutException exc)
{
logger.WriteToLog_needsAttention($"could not accept REGISTER request: {exc}");
}
catch (Exception exc)
{
logger.WriteToLog_mediumPain($"could not accept REGISTER request: {exc}");
}
finally
{
_pendingRegisterRequests.Remove(req.RequesterRegistrationId);
}
}
public void OnPing(PingPacket packet)
{
var response = new PongPacket(packet.message);
SendPacket(response);
}
protected override bool HandlePacket(string packet)
{
var pongPkt = new PongPacket();
if (pongPkt.ParsePacket(packet))
{
IsAnyPongsAccepted = true;
return(true);
}
var loginPkt = new LoginPacket();
if (loginPkt.ParsePacket(packet))
{
if (loginPkt.Version != PacketBase.ProtocolVersion)
{
SendPacket(new ErrorPacket()
{
Text = "Unsupported protocol"
});
return(false);
}
if (loginPkt.Id == null && Id == null)
{
SendPacket(new ErrorPacket()
{
Text = "Please provide me with ID"
});
return(true);
}
if (loginPkt.Id != null)
{
foreach (var cl in server.Clients)
{
if (cl == this || cl.Id == null)
{
continue;
}
/* ID check disabled
* if (cl.Id == loginPkt.Id)
* {
* SendPacket(new ErrorPacket()
* {
* Text = "ID is already registered"
* });
* return true;
* }
*/
}
id = (Guid)loginPkt.Id;
IdChanged?.Invoke(this, new ValueCarrierEventArgs <Guid?>(id));
}
name = loginPkt.Name;
mode = loginPkt.Mode;
SendPacket(new AckPacket());
var ln = (name == null ? "" : name + " ") + "(" + (id == null ? "?" : id.ToString().Substring(0, 8)) + ")";
server.PrintLog(logName + " has registered as " + ln);
logName = ln;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));
NameChanged?.Invoke(this, new ValueCarrierEventArgs <string>(name));
return(true);
}
if (mode == LoginMode.Unspecified)
{
SendPacket(new ErrorPacket()
{
Text = "Not logged in"
});
return(true);
}
var displayPkt = new DisplayInfoPacket();
if (displayPkt.ParsePacket(packet))
{
PurgeDisplays();
var port = startingPort - 1;
var ports = new List <ushort>();
for (int d = 0; d < displayPkt.Displays.Count; d++)
{
port++;
if (port > portMax)
{
throw new Exception("No more network ports available in range");
}
if (!IsTcpPortAvailable((ushort)port))
{
d--;
continue;
}
var ds = displayPkt.Displays[d];
Displays.Add(new Display((ushort)port, this, ds.Width, ds.Height));
ports.Add((ushort)port);
}
SendPacket(new DisplayPortsPacket(ports)).Flush();
return(true);
}
var pingPkt = new PingPacket();
if (pingPkt.ParsePacket(packet))
{
SendPacket(new PongPacket()
{
Text = pingPkt.Text
});
return(true);
}
return(true);
}
/// <returns>null if registration failed with timeout or some error code</returns>
public async Task <ConnectionToNeighbor> RegisterAsync(LocalDrpPeer localDrpPeer, IPEndPoint epEndpoint, uint minimalDistanceToNeighbor,
byte numberofHops, double[] directionVectorNullable, bool allowConnectionsToRequesterRegistrationId) // engine thread
{
var regSW = Stopwatch.StartNew();
WriteToLog_reg_requesterSide_higherLevelDetail($"connecting via EntryPeer {epEndpoint}", null, null);
localDrpPeer.CurrentRegistrationOperationsCount++;
try
{
#region PoW1
RegisterPow1ResponsePacket pow1ResponsePacket = null;
if (!Configuration.SandboxModeOnly_DisablePoW)
{
WriteToLog_reg_requesterSide_detail($"generating PoW1 request", null, null);
var pow1SW = Stopwatch.StartNew();
await PowThreadQueue.EnqueueAsync("pow1 6318");
WriteToLog_reg_requesterSide_detail($"generating PoW1 request @pow thread", null, null);
var registerPow1RequestPacket = GenerateRegisterPow1RequestPacket(localDrpPeer.PublicIpApiProviderResponse.GetAddressBytes(), Timestamp32S);
await EngineThreadQueue.EnqueueAsync("pow1 234709");
WriteToLog_reg_requesterSide_detail($"generated PoW1 request @engine thread", null, null);
// send register pow1 request
if (pow1SW.Elapsed.TotalMilliseconds > 3000)
{
WriteToLog_reg_requesterSide_lightPain($"PoW1 took {(int)pow1SW.Elapsed.TotalMilliseconds}ms", null, null);
}
WriteToLog_reg_requesterSide_detail($"PoW1 took {(int)pow1SW.Elapsed.TotalMilliseconds}ms. sending PoW1 request", null, null);
var rpPow1ResponsePacketData = await SendUdpRequestAsync_Retransmit(
new PendingLowLevelUdpRequest("rpPow1 469", epEndpoint,
RegisterPow1ResponsePacket.GetScanner(registerPow1RequestPacket.Pow1RequestId),
DateTimeNowUtc,
Configuration.UdpLowLevelRequests_ExpirationTimeoutS,
registerPow1RequestPacket.Encode(),
Configuration.UdpLowLevelRequests_InitialRetransmissionTimeoutS,
Configuration.UdpLowLevelRequests_RetransmissionTimeoutIncrement
));
// wait for response, retransmit
if (rpPow1ResponsePacketData == null)
{
throw new DrpTimeoutException($"pow1 request to EP '{epEndpoint}' (timeout={Configuration.UdpLowLevelRequests_ExpirationTimeoutS}s)");
}
;
pow1ResponsePacket = new RegisterPow1ResponsePacket(rpPow1ResponsePacketData);
WriteToLog_reg_requesterSide_detail($"got PoW1 response with status={pow1ResponsePacket.StatusCode}", null, null);
if (pow1ResponsePacket.StatusCode != RegisterPow1ResponseStatusCode.succeeded_Pow2Challenge)
{
throw new Pow1RejectedException(pow1ResponsePacket.StatusCode);
}
}
#endregion
var newConnectionToNeighbor = new ConnectionToNeighbor(this, localDrpPeer, ConnectedDrpPeerInitiatedBy.localPeer, null);
PongPacket pong;
var req = new RegisterRequestPacket
{
RequesterRegistrationId = localDrpPeer.Configuration.LocalPeerRegistrationId,
ReqTimestamp64 = Timestamp64,
MinimalDistanceToNeighbor = minimalDistanceToNeighbor,
RequesterNatBehaviour = LocalNatBehaviour,
AllowConnectionsToRequesterRegistrationId = allowConnectionsToRequesterRegistrationId,
NumberOfHopsRemaining = numberofHops,
RequesterEcdhePublicKey = new EcdhPublicKey(newConnectionToNeighbor.LocalEcdhe25519PublicKey),
ReqP2pSeq16 = GetNewNpaSeq16_AtoEP(),
EpEndpoint = epEndpoint,
DirectionVectorNullableD = directionVectorNullable
};
var logger = new Logger(this, localDrpPeer, req, VisionChannelModuleName_reg_requesterSide);
try
{
#region register REQ PoW2
RecentUniquePublicEcdhKeys.AssertIsUnique(req.RequesterEcdhePublicKey.Ecdh25519PublicKey, $"req.RequesterEcdhePublicKey {req}"); // this is used in non-standard way when routing registration requests to same (local) reg. ID, too
var pow2SW = Stopwatch.StartNew();
if (!Configuration.SandboxModeOnly_DisablePoW)
{
await PowThreadQueue.EnqueueAsync("pow2 23465");
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"calculating PoW2 @pow thread");
}
GenerateRegisterReqPow2(req, pow1ResponsePacket.ProofOfWork2Request);
await EngineThreadQueue.EnqueueAsync("pow2 2496");
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"calculated PoW2 @engine thread");
}
}
else
{
req.ProofOfWork2 = new byte[64];
}
pow2SW.Stop();
if (pow2SW.Elapsed.TotalMilliseconds > 3000)
{
logger.WriteToLog_lightPain($"PoW2 took {(int)pow2SW.Elapsed.TotalMilliseconds}ms");
}
req.RequesterSignature = RegistrationSignature.Sign(_cryptoLibrary,
w => req.GetSharedSignedFields(w, false),
localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey
);
var reqToAck1Stopwatch = Stopwatch.StartNew();
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"PoW2 took {(int)pow2SW.Elapsed.TotalMilliseconds}ms. sending REQ, waiting for NPACK. ReqP2pSeq16={req.ReqP2pSeq16}");
}
#endregion
// var reqSW = Stopwatch.StartNew();
#region wait for ACK1
var sentRequest = new SentRequest(this, logger, epEndpoint, null, req.Encode_OptionallySignNeighborHMAC(null), req.ReqP2pSeq16, RegisterAck1Packet.GetScanner(logger, req));
var ack1UdpData = await sentRequest.SendRequestAsync("reg req ack1 367097");
var ack1 = RegisterAck1Packet.DecodeAndOptionallyVerify(logger, ack1UdpData, req, newConnectionToNeighbor);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified ACK1. RequesterEndpoint={ack1.RequesterEndpoint}");
}
#endregion
// check if it matches to previously known local public IP
if (ack1.RequesterEndpoint.Address.Equals(localDrpPeer.PublicIpApiProviderResponse) == false)
{
// MITM attack / EP sent local (requester) endpoint IP some bad IP address
throw new PossibleAttackException();
}
RecentUniquePublicEcdhKeys.AssertIsUnique(ack1.ResponderEcdhePublicKey.Ecdh25519PublicKey, $"ack1.ResponderEcdhePublicKey from {epEndpoint}");
newConnectionToNeighbor.LocalEndpoint = ack1.RequesterEndpoint;
newConnectionToNeighbor.RemoteRegistrationId = ack1.ResponderRegistrationId;
reqToAck1Stopwatch.Stop();
var reqToAck1TimeMs = reqToAck1Stopwatch.Elapsed.TotalMilliseconds;
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"measured REQ-ACK1_RTT={(int)reqToAck1TimeMs}ms");
}
#region send ACK2, encode local IP
var ack2 = new RegisterAck2Packet
{
ReqTimestamp64 = req.ReqTimestamp64,
RequesterRegistrationId = localDrpPeer.Configuration.LocalPeerRegistrationId,
ReqP2pSeq16 = GetNewNpaSeq16_AtoEP()
};
ack2.ToRequesterTxParametersEncrypted = newConnectionToNeighbor.Encrypt_ack2_ToRequesterTxParametersEncrypted_AtRequester(logger, req, ack1, ack2);
newConnectionToNeighbor.InitializeP2pStream(req, ack1, ack2);
ack2.RequesterSignature = RegistrationSignature.Sign(_cryptoLibrary, w =>
{
req.GetSharedSignedFields(w, true);
ack1.GetSharedSignedFields(w, true, true);
ack2.GetSharedSignedFields(w, false, true);
},
localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey
);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending ACK2 (in response to ACK1), waiting for NPACK");
}
RespondToRequestAndRetransmissions(ack1UdpData, ack2.Encode_OptionallySignNeighborHMAC(null), epEndpoint);
await OptionallySendUdpRequestAsync_Retransmit_WaitForNeighborPeerAck("ack2 46873", null, epEndpoint, ack2.ReqP2pSeq16);
#endregion
var neighborWaitTimeMs = reqToAck1TimeMs * 0.5 - 250; if (neighborWaitTimeMs < 0)
{
neighborWaitTimeMs = 0;
}
if (neighborWaitTimeMs > 20)
{
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"awaiting {(int)neighborWaitTimeMs}ms before PING...");
}
await EngineThreadQueue.WaitAsync(TimeSpan.FromMilliseconds(neighborWaitTimeMs), "before PING 34589"); // wait until the ACK2 reaches neighbor N via peers
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"... awaiting is complete");
}
}
localDrpPeer.AddToConnectedNeighbors(newConnectionToNeighbor, req);
#region send ping request directly to neighbor N, retransmit
var pingRequest = newConnectionToNeighbor.CreatePing(true, false, localDrpPeer.ConnectedNeighborsBusySectorIds, localDrpPeer.AnotherNeighborToSameSectorExists(newConnectionToNeighbor));
newConnectionToNeighbor.InitialPendingPingRequest = new PendingLowLevelUdpRequest("pingRequest 3850", newConnectionToNeighbor.RemoteEndpoint,
PongPacket.GetScanner(newConnectionToNeighbor.LocalNeighborToken32, pingRequest.PingRequestId32),
DateTimeNowUtc,
Configuration.InitialPingRequests_ExpirationTimeoutS,
pingRequest.Encode(),
Configuration.InitialPingRequests_InitialRetransmissionTimeoutS,
Configuration.InitialPingRequests_RetransmissionTimeoutIncrement
);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending PING neighborToken32={pingRequest.NeighborToken32}, waiting for PONG");
}
var pongPacketData = await SendUdpRequestAsync_Retransmit(newConnectionToNeighbor.InitialPendingPingRequest);
if (pongPacketData == null)
{
throw new DrpTimeoutException($"initial reg. requester PING to {newConnectionToNeighbor} (timeout={Configuration.InitialPingRequests_ExpirationTimeoutS}s)");
}
if (newConnectionToNeighbor.IsDisposed)
{
throw new ObjectDisposedException($"initial reg. requester PING to {newConnectionToNeighbor} (special case: connection is disposed)", (Exception)null); // ping timeout already destroyed the connection, so PONG response here is too late
}
pong = PongPacket.DecodeAndVerify(_cryptoLibrary,
pongPacketData, pingRequest, newConnectionToNeighbor,
true);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified PONG");
}
newConnectionToNeighbor.OnReceivedVerifiedPong(pong, newConnectionToNeighbor.InitialPendingPingRequest.ResponseReceivedAtUtc.Value,
newConnectionToNeighbor.InitialPendingPingRequest.ResponseReceivedAtUtc.Value - newConnectionToNeighbor.InitialPendingPingRequest.InitialTxTimeUTC.Value);
#endregion
}
catch
{
// todo update QoS
newConnectionToNeighbor.Dispose(); // remove from token32 table
throw;
}
#region send registration confirmation packet to EP->X->N
try
{
var cfm = new RegisterConfirmationPacket
{
ReqTimestamp64 = req.ReqTimestamp64,
RequesterRegistrationId = localDrpPeer.Configuration.LocalPeerRegistrationId,
ResponderRegistrationConfirmationSignature = pong.ResponderRegistrationConfirmationSignature,
ReqP2pSeq16 = GetNewNpaSeq16_AtoEP()
};
cfm.RequesterRegistrationConfirmationSignature = RegistrationSignature.Sign(_cryptoLibrary,
w => newConnectionToNeighbor.GetRequesterRegistrationConfirmationSignatureFields(w, cfm.ResponderRegistrationConfirmationSignature),
localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending CFM, waiting for NPACK");
}
await OptionallySendUdpRequestAsync_Retransmit_WaitForNeighborPeerAck("cfm 32107", cfm.Encode_OptionallySignNeighborHMAC(null), epEndpoint, cfm.ReqP2pSeq16);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"received NPACK to CFM");
}
}
catch (DrpTimeoutException exc)
{ // we ingnore exceptions here, just wite warning to log. the connection is alive already, as direct ping channel to neighbor is set up
logger.WriteToLog_needsAttention($"... registration confirmation request failed: {exc}");
}
catch (Exception exc)
{ // we ingnore exceptions here, just wite warning to log. the connection is alive already, as direct ping channel to neighbor is set up
logger.WriteToLog_mediumPain($"... registration confirmation request failed: {exc}");
}
#endregion
regSW.Stop();
if (regSW.Elapsed.TotalMilliseconds > 5000)
{
logger.WriteToLog_lightPain($"registration is completed in {(int)regSW.Elapsed.TotalMilliseconds}ms");
}
else
{
logger.WriteToLog_higherLevelDetail($"registration is completed in {(int)regSW.Elapsed.TotalMilliseconds}ms");
};
return(newConnectionToNeighbor);
}
finally
{
localDrpPeer.CurrentRegistrationOperationsCount--;
}
}
/// <summary>
/// is used to expand neighborhood
/// </summary>
internal async Task RegisterAsync(uint minimalDistanceToNeighbor, ushort busySectorIds, byte numberOfHopsRemaining, byte numberOfRandomHopsRemaining, double[] directionVectorNullable, bool allowConnectionsToRequesterRegistrationId)
{
_engine.WriteToLog_reg_requesterSide_detail($">> ConnectionToNeighbor.RegisterAsync(minimalDistanceToNeighbor={minimalDistanceToNeighbor}", null, null);
_localDrpPeer.CurrentRegistrationOperationsCount++;
try
{
var newConnectionToNeighbor = new ConnectionToNeighbor(_engine, _localDrpPeer, ConnectedDrpPeerInitiatedBy.localPeer, null);
PongPacket pong;
// PendingLowLevelUdpRequest pendingPingRequest;
var req = new RegisterRequestPacket
{
RequesterRegistrationId = _localDrpPeer.Configuration.LocalPeerRegistrationId,
ReqTimestamp64 = _engine.Timestamp64,
MinimalDistanceToNeighbor = minimalDistanceToNeighbor,
RequesterNatBehaviour = _engine.LocalNatBehaviour,
AllowConnectionsToRequesterRegistrationId = allowConnectionsToRequesterRegistrationId,
RequesterNeighborsBusySectorIds = busySectorIds,
NumberOfHopsRemaining = numberOfHopsRemaining,
NumberOfRandomHopsRemaining = numberOfRandomHopsRemaining,
RequesterEcdhePublicKey = new EcdhPublicKey(newConnectionToNeighbor.LocalEcdhe25519PublicKey),
ReqP2pSeq16 = GetNewRequestP2pSeq16_P2P(),
EpEndpoint = this.RemoteEndpoint,
DirectionVectorNullableD = directionVectorNullable
};
var logger = new Logger(Engine, LocalDrpPeer, req, DrpPeerEngine.VisionChannelModuleName_reg_requesterSide);
try
{
_engine.RecentUniquePublicEcdhKeys.AssertIsUnique(req.RequesterEcdhePublicKey.Ecdh25519PublicKey, $"req.RequesterEcdhePublicKey {req}");
req.RequesterSignature = RegistrationSignature.Sign(_engine.CryptoLibrary,
w => req.GetSharedSignedFields(w, false),
_localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey
);
var reqToAck1Stopwatch = Stopwatch.StartNew();
#region wait for ACK1, respond with NPACK
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending {req}, waiting for NPACK. ReqP2pSeq16={req.ReqP2pSeq16}");
}
var sentRequest = new SentRequest(Engine, logger, this.RemoteEndpoint, this, req.Encode_OptionallySignNeighborHMAC(this),
req.ReqP2pSeq16, RegisterAck1Packet.GetScanner(logger, req, this));
var ack1UdpData = await sentRequest.SendRequestAsync("reg req ack1 42084");
var ack1 = RegisterAck1Packet.DecodeAndOptionallyVerify(logger, ack1UdpData, req, newConnectionToNeighbor);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified ACK1, sending NPACK to ACK1");
}
_engine.SendNeighborPeerAckResponseToRegisterAck1(ack1, this);
#endregion
if (newConnectionToNeighbor.IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {newConnectionToNeighbor} is disposed during reg. request 5345322345");
return;
}
if (IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {this} is disposed during reg. request 5345322345");
return;
}
_engine.RecentUniquePublicEcdhKeys.AssertIsUnique(ack1.ResponderEcdhePublicKey.Ecdh25519PublicKey, $"ack1.ResponderEcdhePublicKey from {newConnectionToNeighbor}");
newConnectionToNeighbor.LocalEndpoint = this.LocalEndpoint;
newConnectionToNeighbor.RemoteRegistrationId = ack1.ResponderRegistrationId;
reqToAck1Stopwatch.Stop();
var reqToAck1TimeMs = reqToAck1Stopwatch.Elapsed.TotalMilliseconds;
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"measured REQ-ACK1 RTT = {(int)reqToAck1TimeMs}ms");
}
#region send ACK2, encode local IP
var ack2 = new RegisterAck2Packet
{
ReqTimestamp64 = req.ReqTimestamp64,
RequesterRegistrationId = _localDrpPeer.Configuration.LocalPeerRegistrationId,
ReqP2pSeq16 = GetNewRequestP2pSeq16_P2P(),
};
ack2.ToRequesterTxParametersEncrypted = newConnectionToNeighbor.Encrypt_ack2_ToRequesterTxParametersEncrypted_AtRequester(logger, req, ack1, ack2);
newConnectionToNeighbor.InitializeP2pStream(req, ack1, ack2);
ack2.RequesterSignature = RegistrationSignature.Sign(_engine.CryptoLibrary, w =>
{
req.GetSharedSignedFields(w, true);
ack1.GetSharedSignedFields(w, true, true);
ack2.GetSharedSignedFields(w, false, true);
},
_localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey
);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending ACK2 (in response to ACK1), waiting for NPACK");
}
await _engine.OptionallySendUdpRequestAsync_Retransmit_WaitForNeighborPeerAck("ack2 1235739", ack2.Encode_OptionallySignNeighborHMAC(this), this.RemoteEndpoint, ack2.ReqP2pSeq16);
#endregion
var neighborWaitTimeMs = reqToAck1TimeMs * 0.5 - 100; if (neighborWaitTimeMs < 0)
{
neighborWaitTimeMs = 0;
}
if (neighborWaitTimeMs > 20)
{
await _engine.EngineThreadQueue.WaitAsync(TimeSpan.FromMilliseconds(neighborWaitTimeMs), "neighborWaitTimeMs45236"); // wait until the ACK2 reaches neighbor N via peers
}
if (newConnectionToNeighbor.IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {newConnectionToNeighbor} is disposed during reg. request 234574568");
return;
}
if (IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {this} is disposed during reg. request 234574568");
return;
}
_localDrpPeer.AddToConnectedNeighbors(newConnectionToNeighbor, req);
#region send ping request directly to neighbor N, retransmit
var pingRequest = newConnectionToNeighbor.CreatePing(true, false, _localDrpPeer.ConnectedNeighborsBusySectorIds, _localDrpPeer.AnotherNeighborToSameSectorExists(newConnectionToNeighbor));
newConnectionToNeighbor.InitialPendingPingRequest = new PendingLowLevelUdpRequest("pendingPingRequest 12247", newConnectionToNeighbor.RemoteEndpoint,
PongPacket.GetScanner(newConnectionToNeighbor.LocalNeighborToken32, pingRequest.PingRequestId32),
_engine.DateTimeNowUtc,
_engine.Configuration.InitialPingRequests_ExpirationTimeoutS,
pingRequest.Encode(),
_engine.Configuration.InitialPingRequests_InitialRetransmissionTimeoutS,
_engine.Configuration.InitialPingRequests_RetransmissionTimeoutIncrement
);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending PING, waiting for PONG");
}
var pongPacketData = await _engine.SendUdpRequestAsync_Retransmit(newConnectionToNeighbor.InitialPendingPingRequest);
if (pongPacketData == null)
{
throw new DrpTimeoutException($"reg. requester initial PING to {newConnectionToNeighbor} (timeout={_engine.Configuration.InitialPingRequests_ExpirationTimeoutS}s)");
}
if (newConnectionToNeighbor.IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {newConnectionToNeighbor} is disposed during reg. request 548798");
return;
}
if (IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {this} is disposed during reg. request 548798");
return;
}
pong = PongPacket.DecodeAndVerify(_engine.CryptoLibrary,
pongPacketData, pingRequest, newConnectionToNeighbor,
true);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"verified PONG");
}
newConnectionToNeighbor.OnReceivedVerifiedPong(pong, newConnectionToNeighbor.InitialPendingPingRequest.ResponseReceivedAtUtc.Value,
newConnectionToNeighbor.InitialPendingPingRequest.ResponseReceivedAtUtc.Value - newConnectionToNeighbor.InitialPendingPingRequest.InitialTxTimeUTC.Value);
#endregion
}
catch
{
// todo update QoS
newConnectionToNeighbor.Dispose(); // remove from token32 table
throw;
}
#region send registration confirmation packet to X->N
try
{
if (newConnectionToNeighbor.IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {newConnectionToNeighbor} is disposed during reg. request 541687987");
return;
}
if (IsDisposed)
{
logger.WriteToLog_needsAttention($"connection {this} is disposed during reg. request 541687987");
return;
}
var cfm = new RegisterConfirmationPacket
{
ReqTimestamp64 = req.ReqTimestamp64,
RequesterRegistrationId = _localDrpPeer.Configuration.LocalPeerRegistrationId,
ResponderRegistrationConfirmationSignature = pong.ResponderRegistrationConfirmationSignature,
ReqP2pSeq16 = GetNewRequestP2pSeq16_P2P()
};
cfm.RequesterRegistrationConfirmationSignature = RegistrationSignature.Sign(_engine.CryptoLibrary,
w => newConnectionToNeighbor.GetRequesterRegistrationConfirmationSignatureFields(w, cfm.ResponderRegistrationConfirmationSignature),
_localDrpPeer.Configuration.LocalPeerRegistrationPrivateKey);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"sending CFM, waiting for NPACK");
}
await _engine.OptionallySendUdpRequestAsync_Retransmit_WaitForNeighborPeerAck("cfm 14478", cfm.Encode_OptionallySignNeighborHMAC(this), this.RemoteEndpoint, cfm.ReqP2pSeq16);
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"received NPACK to CFM");
}
}
catch (DrpTimeoutException exc)
{ // we ingnore exceptions here, just wite warning to log. the connection is alive already, as direct ping channel to neighbor is set up
logger.WriteToLog_needsAttention($"... registration confirmation request failed: {exc}");
}
catch (Exception exc)
{ // we ingnore exceptions here, just wite warning to log. the connection is alive already, as direct ping channel to neighbor is set up
logger.WriteToLog_mediumPain($"... registration confirmation request failed: {exc}");
}
#endregion
return;// newConnectionToNeighbor;
}
finally
{
_localDrpPeer.CurrentRegistrationOperationsCount--;
}
}
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;
}
}
private Object readPong(short packetType, NetworkStream buffer)
{
return(PongPacket.ReadBuffer(packetType, buffer));
}
public void processPacket(ClientConnection client, BasePacket packet)
{
if (packet.header.isCompressed == 0x01)
{
BasePacket.decryptPacket(client.blowfish, ref packet);
}
List <SubPacket> subPackets = packet.getSubpackets();
foreach (SubPacket subpacket in subPackets)
{
if (subpacket.header.type == 0x01)
{
packet.debugPrintPacket();
byte[] reply1Data =
{
0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x18, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFD, 0xFF, 0xFF,
0xE5, 0x6E, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x0
};
byte[] reply2Data =
{
0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x38, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x2B, 0x5F, 0x26,
0x66, 0x00, 0x00, 0x00, 0xC8, 0xD6, 0xAF, 0x2B, 0x38, 0x2B, 0x5F, 0x26, 0xB8, 0x8D, 0xF0, 0x2B,
0xC8, 0xFD, 0x85, 0xFE, 0xA8, 0x7C, 0x5B, 0x09, 0x38, 0x2B, 0x5F, 0x26, 0xC8, 0xD6, 0xAF, 0x2B,
0xB8, 0x8D, 0xF0, 0x2B, 0x88, 0xAF, 0x5E, 0x26
};
BasePacket reply1 = new BasePacket(reply1Data);
BasePacket reply2 = new BasePacket(reply2Data);
//Write Timestamp into Reply1
using (MemoryStream mem = new MemoryStream(reply1.data))
{
using (BinaryWriter binReader = new BinaryWriter(mem))
{
binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
binReader.Write((UInt32)Utils.UnixTimeStampUTC());
}
}
//Read in Actor Id that owns this connection
uint actorID = 0;
using (MemoryStream mem = new MemoryStream(packet.data))
{
using (BinaryReader binReader = new BinaryReader(mem))
{
try
{
byte[] readIn = new byte[12];
binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
binReader.Read(readIn, 0, 12);
actorID = UInt32.Parse(Encoding.ASCII.GetString(readIn));
}
catch (Exception)
{ }
}
}
//Should never happen.... unless actor id IS 0!
if (actorID == 0)
{
break;
}
client.owner = actorID;
//Write Actor ID into reply2
using (MemoryStream mem = new MemoryStream(reply2.data))
{
using (BinaryWriter binReader = new BinaryWriter(mem))
{
binReader.BaseStream.Seek(0x10, SeekOrigin.Begin);
binReader.Write(actorID);
}
}
ConnectedPlayer player = null;
if (packet.header.connectionType == BasePacket.TYPE_ZONE)
{
while (!mPlayers.ContainsKey(client.owner))
{
}
player = mPlayers[client.owner];
}
//Create connected player if not created
if (player == null)
{
player = new ConnectedPlayer(actorID);
mPlayers[actorID] = player;
}
player.setConnection(packet.header.connectionType, client);
if (packet.header.connectionType == BasePacket.TYPE_ZONE)
{
Log.debug(String.Format("Got {0} connection for ActorID {1} @ {2}.", "zone", actorID, client.getAddress()));
}
else if (packet.header.connectionType == BasePacket.TYPE_CHAT)
{
Log.debug(String.Format("Got {0} connection for ActorID {1} @ {2}.", "chat", actorID, client.getAddress()));
}
//Create player actor
reply1.debugPrintPacket();
client.queuePacket(reply1);
client.queuePacket(reply2);
break;
}
else if (subpacket.header.type == 0x07)
{
BasePacket init = Login0x7ResponsePacket.buildPacket(BitConverter.ToUInt32(packet.data, 0x10), Utils.UnixTimeStampUTC());
//client.queuePacket(init);
}
else if (subpacket.header.type == 0x08)
{
//Response, client's current [actorID][time]
packet.debugPrintPacket();
}
else if (subpacket.header.type == 0x03)
{
ConnectedPlayer player = null;
if (mPlayers.ContainsKey(client.owner))
{
player = mPlayers[client.owner];
}
if (player == null)
{
return;
}
//Normal Game Opcode
switch (subpacket.gameMessage.opcode)
{
//Ping
case 0x0001:
//subpacket.debugPrintSubPacket();
PingPacket pingPacket = new PingPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(PongPacket.buildPacket(player.actorID, pingPacket.time), true, false));
player.ping();
break;
//Unknown
case 0x0002:
subpacket.debugPrintSubPacket();
client.queuePacket(_0x2Packet.buildPacket(player.actorID), true, false);
Server.GetWorldManager().DoLogin(player.getActor());
break;
//Chat Received
case 0x0003:
ChatMessagePacket chatMessage = new ChatMessagePacket(subpacket.data);
Log.info(String.Format("Got type-{5} message: {0} @ {1}, {2}, {3}, Rot: {4}", chatMessage.message, chatMessage.posX, chatMessage.posY, chatMessage.posZ, chatMessage.posRot, chatMessage.logType));
subpacket.debugPrintSubPacket();
if (chatMessage.message.StartsWith("!"))
{
if (cp.doCommand(chatMessage.message, player))
{
continue;
}
}
player.getActor().broadcastPacket(SendMessagePacket.buildPacket(player.actorID, player.actorID, chatMessage.logType, player.getActor().customDisplayName, chatMessage.message), false);
break;
//Langauge Code
case 0x0006:
LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data);
player.languageCode = langCode.languageCode;
break;
//Unknown - Happens a lot at login, then once every time player zones
case 0x0007:
//subpacket.debugPrintSubPacket();
_0x07Packet unknown07 = new _0x07Packet(subpacket.data);
break;
//Update Position
case 0x00CA:
//Update Position
//subpacket.debugPrintSubPacket();
UpdatePlayerPositionPacket posUpdate = new UpdatePlayerPositionPacket(subpacket.data);
player.updatePlayerActorPosition(posUpdate.x, posUpdate.y, posUpdate.z, posUpdate.rot, posUpdate.moveState);
player.getActor().sendInstanceUpdate();
if (player.getActor().isInZoneChange())
{
player.getActor().setZoneChanging(false);
}
break;
//Set Target
case 0x00CD:
//subpacket.debugPrintSubPacket();
SetTargetPacket setTarget = new SetTargetPacket(subpacket.data);
player.getActor().currentTarget = setTarget.actorID;
player.getActor().broadcastPacket(SetActorTargetAnimatedPacket.buildPacket(player.actorID, player.actorID, setTarget.actorID), true);
break;
//Lock Target
case 0x00CC:
LockTargetPacket lockTarget = new LockTargetPacket(subpacket.data);
player.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)
* Log.error("\n"+player.errorMessage);
*
*
* break;
* }
*/
Actor ownerActor = Server.getStaticActors(eventStart.scriptOwnerActorID);
if (ownerActor != null && ownerActor is Command)
{
player.getActor().currentCommand = eventStart.scriptOwnerActorID;
player.getActor().currentCommandName = eventStart.triggerName;
}
else
{
player.getActor().currentEventOwner = eventStart.scriptOwnerActorID;
player.getActor().currentEventName = eventStart.triggerName;
}
if (ownerActor == null)
{
//Is it a instance actor?
ownerActor = Server.GetWorldManager().GetActorInWorld(player.getActor().currentEventOwner);
if (ownerActor == null)
{
//Is it a Director?
if (player.getActor().currentDirector != null && player.getActor().currentEventOwner == player.getActor().currentDirector.actorId)
{
ownerActor = player.getActor().currentDirector;
}
else
{
Log.debug(String.Format("\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;
}
}
}
LuaEngine.doActorOnEventStarted(player.getActor(), ownerActor, eventStart);
Log.debug(String.Format("\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:
break;
//Event Result
case 0x012E:
subpacket.debugPrintSubPacket();
EventUpdatePacket eventUpdate = new EventUpdatePacket(subpacket.data);
Log.debug(String.Format("\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(player.getActor().currentEventOwner);
if (updateOwnerActor == null)
{
updateOwnerActor = Server.GetWorldManager().GetActorInWorld(player.getActor().currentEventOwner);
if (player.getActor().currentDirector != null && player.getActor().currentEventOwner == player.getActor().currentDirector.actorId)
{
updateOwnerActor = player.getActor().currentDirector;
}
if (updateOwnerActor == null)
{
break;
}
}
LuaEngine.doActorOnEventUpdated(player.getActor(), updateOwnerActor, eventUpdate);
break;
case 0x012F:
subpacket.debugPrintSubPacket();
ParameterDataRequestPacket paramRequest = new ParameterDataRequestPacket(subpacket.data);
if (paramRequest.paramName.Equals("charaWork/exp"))
{
player.getActor().sendCharaExpInfo();
}
break;
/* RECRUITMENT */
//Start Recruiting
case 0x01C3:
StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(StartRecruitingResponse.buildPacket(player.actorID, true), true, false));
break;
//End Recruiting
case 0x01C4:
client.queuePacket(BasePacket.createPacket(EndRecruitmentPacket.buildPacket(player.actorID), true, false));
break;
//Party Window Opened, Request State
case 0x01C5:
client.queuePacket(BasePacket.createPacket(RecruiterStatePacket.buildPacket(player.actorID, true, true, 1), true, false));
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;
client.queuePacket(BasePacket.createPacket(CurrentRecruitmentDetailsPacket.buildPacket(player.actorID, details), true, false));
break;
//Accepted Recruiting
case 0x01C6:
subpacket.debugPrintSubPacket();
break;
/* SOCIAL STUFF */
case 0x01C9:
AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(BlacklistAddedPacket.buildPacket(player.actorID, true, addBlackList.name), true, false));
break;
case 0x01CA:
AddRemoveSocialPacket removeBlackList = new AddRemoveSocialPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(BlacklistRemovedPacket.buildPacket(player.actorID, true, removeBlackList.name), true, false));
break;
case 0x01CB:
int offset1 = 0;
client.queuePacket(BasePacket.createPacket(SendBlacklistPacket.buildPacket(player.actorID, new String[] { "Test" }, ref offset1), true, false));
break;
case 0x01CC:
AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(FriendlistAddedPacket.buildPacket(player.actorID, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name), true, false));
break;
case 0x01CD:
AddRemoveSocialPacket removeFriendList = new AddRemoveSocialPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(FriendlistRemovedPacket.buildPacket(player.actorID, true, removeFriendList.name), true, false));
break;
case 0x01CE:
int offset2 = 0;
client.queuePacket(BasePacket.createPacket(SendFriendlistPacket.buildPacket(player.actorID, new Tuple <long, string>[] { new Tuple <long, string>(01, "Test2") }, ref offset2), true, false));
break;
case 0x01CF:
client.queuePacket(BasePacket.createPacket(FriendStatusPacket.buildPacket(player.actorID, null), true, false));
break;
/* SUPPORT DESK STUFF */
//Request for FAQ/Info List
case 0x01D0:
FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(FaqListResponsePacket.buildPacket(player.actorID, new string[] { "Testing FAQ1", "Coded style!" }), true, false));
break;
//Request for body of a faq/info selection
case 0x01D1:
FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(FaqBodyResponsePacket.buildPacket(player.actorID, "HERE IS A GIANT BODY. Nothing else to say!"), true, false));
break;
//Request issue list
case 0x01D2:
GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data);
client.queuePacket(BasePacket.createPacket(IssueListResponsePacket.buildPacket(player.actorID, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }), true, false));
break;
//Request if GM ticket exists
case 0x01D3:
client.queuePacket(BasePacket.createPacket(StartGMTicketPacket.buildPacket(player.actorID, false), true, false));
break;
//Request for GM response message
case 0x01D4:
client.queuePacket(BasePacket.createPacket(GMTicketPacket.buildPacket(player.actorID, "This is a GM Ticket Title", "This is a GM Ticket Body."), true, false));
break;
//GM Ticket Sent
case 0x01D5:
GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data);
Log.info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody);
client.queuePacket(BasePacket.createPacket(GMTicketSentResponsePacket.buildPacket(player.actorID, true), true, false));
break;
//Request to end ticket
case 0x01D6:
client.queuePacket(BasePacket.createPacket(EndGMTicketPacket.buildPacket(player.actorID), true, false));
break;
default:
Log.debug(String.Format("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode));
subpacket.debugPrintSubPacket();
break;
}
}
else
{
packet.debugPrintPacket();
}
}
}
/// <summary>
/// Processes a packet if its an internal packet.
/// </summary>
/// <param name="packet">Packet to process.</param>
/// <returns>True if the packet was processes, otherwise false.</returns>
private bool ProcessInternalPacket(Packet packet)
{
// Responds to a ping request from a client.
if (packet is PingPacket)
{
PongPacket pong = new PongPacket();
SendPacket(pong, packet);
return true;
}
// Registers the response from a ping packet we have sent.
else if (packet is PongPacket)
{
m_ping = Environment.TickCount - m_timeSinceLastPing;
m_timeSinceLastPong = Environment.TickCount;
m_waitingForPong = false;
return true;
}
// Provides connections details regarding their connection.
else if (packet is ConnectPacket)
{
if (m_listenConnection == null)
{
throw new InvalidOperationException("Remote host sent a connect packet to a non-listening connection.");
}
ConnectPacket p = (ConnectPacket)packet;
m_hardwareFingerprint = p.HardwareFingerprint;
m_guid = p.ConnectionGUID;
m_computerUserName = p.ComputerUserName;
m_computerName = p.ComputerName;
Logger.Info("Connection from {0} established connection.", LoggerVerboseLevel.High, m_endPoint.Serialize().ToString());
Logger.Info("\tHardware Fingerprint: {0}", LoggerVerboseLevel.High, StringHelper.ByteArrayToHexString(m_hardwareFingerprint));
Logger.Info("\tGUID: {0}", LoggerVerboseLevel.High, StringHelper.ByteArrayToHexString(m_guid));
Logger.Info("\tComputer Name: {0}", LoggerVerboseLevel.High, m_computerName);
Logger.Info("\tComputer User Name: {0}", LoggerVerboseLevel.High, m_computerUserName);
// Send an AOK message :3.
ConnectReplyPacket reply = new ConnectReplyPacket();
SendPacket(reply, packet);
lock (m_socket_lock)
{
m_connectionEstablished = true;
lock (m_listenConnection.m_peers_lock)
{
m_listenConnection.m_connected_peers.Add(this);
}
m_encryptor = new StreamEncryptor(GenerateEncryptionKey());
}
return true;
}
// Finishes establishing a connection.
else if (packet is ConnectReplyPacket)
{
// Generate new encryption keys.
lock (m_socket_lock)
{
m_encryptor = new StreamEncryptor(GenerateEncryptionKey());
}
m_connectionEstablished = true;
}
// Disconnects the user from the server gracefully.
else if (packet is DisconnectPacket)
{
DisconnectAsync(true).Wait();
return true;
}
return false;
}
public void getPackets()
{
//GD.Print("Get Packets");
//GD.Print(wrapped_client.GetAvailablePacketCount());
if (connected && client.GetAvailableBytes() > 0)
{
//byte[] packet_data = wrapped_client.GetPacket();
//UInt32 packetLength = BitConverter.ToUInt32(packet_data, 0);
//short packetId = BitConverter.ToInt16(packet_data, 4);
UInt32 packetLength = (UInt32)client.GetU32();
short packetId = (short)client.Get16();
var packetData = client.GetData((int)packetLength - 2);
//var data = new List<byte>(packet_data).GetRange(6, packet_data.Length -6).ToArray();
//GD.Print(BitConverter.ToString( (byte[]) packetData[1]));
var data = (byte[])packetData[1];
var packet = Packets.Packets.decode(packetId, data);
if (GetParent().GetNodeOrNull("GUI") != null)
{
var gui = (Control)GetParent().GetNodeOrNull("GUI");
gui.Call("recordPacket", packetLength + 4);
}
GD.Print(String.Format("Received packet {0}, ID: {1} Length: {2}", packet.name, packetId, packetLength));
if (packet is ReadyPacket)
{
ReadyPacket parsed_packet = (ReadyPacket)packet;
if (parsed_packet.code == 0)
{
string token = (string)GetParent().GetNode("Discord Integration").Call("getToken");
var loginPacket = new LoginPacket(token);
GD.Print("Sending login");
sendPacket(loginPacket);
}
else if (parsed_packet.code == 1)
{
var requestWorldPacket = new RequestWorldPacket();
sendPacket(requestWorldPacket);
if (!joined)
{
var loadingRes = GD.Load <PackedScene>("res://scenes/world.tscn");
var node = loadingRes.Instance();
node.SetName("WorldScene");
var loadingGuiRes = GD.Load <PackedScene>("res://scenes/gui.tscn");
var gui = (Control)loadingGuiRes.Instance();
gui.SetName("GUI");
GetParent().Call("setState", 2);
GetParent().AddChild(node);
//GetParent().AddChild(gui);
GetParent().AddChild(gui);
//node.AddChild(gui);
GetParent().GetNode("GameLoader").Free();
//var playerSpriteScene = (PackedScene) node.Call("getSprite", "rowan");
//var playerSprite = (AnimatedSprite) playerSpriteScene.Instance();
//playerSprite.SetName("PlayerSprite");
//node.GetNode("World/Player").AddChild(playerSprite);
//playerSprite.Position = ((KinematicBody2D) node.GetNode("Player")).Position;
//playerSprite.Visible = true;
//GD.Print(playerSprite);
joined = true;
}
}
}
else if (packet is PongPacket)
{
PongPacket parsed_packet = (PongPacket)packet;
GD.Print("Got pong of " + parsed_packet.message);
}
else if (packet is LoginResultPacket)
{
LoginResultPacket parsed_packet = (LoginResultPacket)packet;
GD.Print("Login Result: " + parsed_packet.responseCode.ToString() + " Name: " + parsed_packet.userId);
var joinGamePacket = new JoinGamePacket();
sendPacket(joinGamePacket);
}
else if (packet is WorldPacket)
{
WorldPacket parsed_packet = (WorldPacket)packet;
//GD.Print(parsed_packet.debug);
GetParent().GetNode("WorldScene").Call("loadWorld", new object[] { parsed_packet.worldData, parsed_packet.bumpData, parsed_packet.height, parsed_packet.width });
}
else if (packet is PlayerPositionPacket)
{
PlayerPositionPacket parsed_packet = (PlayerPositionPacket)packet;
GetParent().GetNode("WorldScene/World/Player").Call("move", new object[] { parsed_packet.x, parsed_packet.y });
}
else if (packet is ChatPacket)
{
ChatPacket parsed_packet = (ChatPacket)packet;
GetNode("../GUI/Chat").Call("AddMessage", parsed_packet.author + ": " + parsed_packet.msg);
}
else if (packet is EntityPacket)
{
EntityPacket parsed_packet = (EntityPacket)packet;
GD.Print("Got entity '", parsed_packet.sprite, "' at ", parsed_packet.x, ",", parsed_packet.y, " ID: ", parsed_packet.uuid);
GetNode("../WorldScene").Call("addEntity", parsed_packet.x, parsed_packet.y, parsed_packet.type, parsed_packet.facing, parsed_packet.interactable, parsed_packet.sprite, parsed_packet.uuid, parsed_packet.type != 2);
}
else if (packet is EntityMovePacket)
{
EntityMovePacket parsed_packet = (EntityMovePacket)packet;
GD.Print("Got entity moving to ", parsed_packet.x, ",", parsed_packet.y, " ID: ", parsed_packet.uuid);
GetNode("../WorldScene").Call("moveEntity", parsed_packet.uuid, parsed_packet.x, parsed_packet.y, parsed_packet.facing);
}
else if (packet is InvalidateCachePacket)
{
InvalidateCachePacket parsed_packet = (InvalidateCachePacket)packet;
GD.Print(parsed_packet.uuid, " Invalidated.");
GetNode("../WorldScene").Call("hideEntity", parsed_packet.uuid);
}
else if (packet is DialoguePacket)
{
DialoguePacket parsed_packet = (DialoguePacket)packet;
GD.Print("Got dialogue \"", parsed_packet.text, "\"");
Window window = (Window)GetNode("../GUI/Window");
window.OpenDialoguePanel();
DialoguePanel dialoguePanel = window.OpenDialoguePanel(); //(DialoguePanel) GetNode("../GUI/Window/DialoguePanel");
dialoguePanel.SetDialogue(parsed_packet.text, parsed_packet.author, parsed_packet.sprite, parsed_packet.substitutions, parsed_packet.optionViews);
}
else if (packet is CloseDialoguePacket)
{
CloseDialoguePacket parsed_packet = (CloseDialoguePacket)packet;
DialoguePanel dialoguePanel = (DialoguePanel)GetNode("../GUI/Window/DialoguePanel");
dialoguePanel.CloseDialogue(parsed_packet.guid);
//dialoguePanel.SetDialogue(parsed_packet.text, parsed_packet.author, parsed_packet.sprite, parsed_packet.substitutions, parsed_packet.optionViews);
}
else if (packet is PlayerDataPacket)
{
PlayerDataPacket parsed_packet = (PlayerDataPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
player.SetUuid(parsed_packet.guid);
if (player.GetNodeOrNull("PlayerSprite") != null)
{
player.GetNodeOrNull("PlayerSprite").Free();
}
var playerSpriteScene = (PackedScene)GetNode("../WorldScene").Call("getSprite", parsed_packet.sprite);
var playerSprite = (AnimatedSprite)playerSpriteScene.Instance();
playerSprite.SetName("PlayerSprite");
player.AddChild(playerSprite);
}
else if (packet is InventoryPacket)
{
InventoryPacket parsed_packet = (InventoryPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.inventory.guid)
{
player.inventory = parsed_packet.inventory;
foreach (Item item in player.inventory.items)
{
GD.Print("Item: ", item.GetName(), " \"", item.GetDescription(), "\"");
}
}
}
else if (packet is AddItemPacket)
{
AddItemPacket parsed_packet = (AddItemPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.guid)
{
//TODO: Make use of indices.
player.inventory.AddItem(parsed_packet.item, true);
}
}
else if (packet is ModifyItemPacket)
{
ModifyItemPacket parsed_packet = (ModifyItemPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.guid)
{
//TODO: Make use of indices.
player.inventory.UpdateItem(parsed_packet.item, parsed_packet.index);
}
}
}
else
{
var testPacket = new Packets.PingPacket("Hello There!");
//sendPacket(testPacket);
}
}
