/// <summary>
/// Creates a <see cref="IIncomingPhysicalMessageContext" /> based on the current context.
/// </summary>
public static IIncomingPhysicalMessageContext CreateIncomingPhysicalMessageContext(this StageConnector<ITransportReceiveContext, IIncomingPhysicalMessageContext> stageConnector, IncomingMessage incomingMessage, ITransportReceiveContext sourceContext)
{
Guard.AgainstNull(nameof(incomingMessage), incomingMessage);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new IncomingPhysicalMessageContext(incomingMessage, sourceContext);
}
public void HandleCommand(IRCServer server, string command, IncomingMessage msg)
{
CommandManager commands = CommandManager.GetInstance();
if (!msg.HasMessage())
{
msg.SendChat("Available commands: " + commands.AvailableCommands());
return;
}
string cmd = msg.Message.ToLower();
if (!commands.HasCommand(cmd))
{
msg.SendChat("No help for command: " + cmd);
}
else
{
string help = commands.GetCommand(cmd).Help();
if (help == null || help.Equals(""))
{
msg.SendChat("No help available for: " + cmd);
}
else
{
msg.SendChat("Help for " + cmd + ": " + help);
}
}
}
protected override void OnRun(IncomingMessage message)
{
ServerEnvelopeObject envelope = Manager.Serializer.GetObject<ServerEnvelopeObject>(message.Data);
GameMessageType gmt = (GameMessageType)Enum.ToObject(typeof(GameMessageType), envelope.InnerOperationCode);
switch (gmt)
{
case GameMessageType.Server_ReceiveTableListingRequest:
OnTableListingRequest(Manager.Serializer.GetObject<TableListingRequest>(envelope.InnerData), envelope.RouteInfo);
break;
case GameMessageType.Server_ReceiveJoinTableRequest:
OnJoinTableRequest(envelope);
break;
default:
IncomingGameMessageQueueItem defaultItem = new IncomingGameMessageQueueItem();
defaultItem.OperationCode = (GameMessageType)envelope.InnerOperationCode;
defaultItem.Data = envelope.InnerData;
defaultItem.RouteInfo = envelope.RouteInfo;
Manager.Tables[defaultItem.RouteInfo.TableId].PlayerPortal.IncomingQueue.Add(defaultItem);
break;
}
message.WasMessageHandled = true;
}
public void TestIncomingBasic()
{
Message message = LoadMessage("simple.eml");
DirectAddressCollection rcpto = new DirectAddressCollection(
new DirectAddress[] {
new DirectAddress("*****@*****.**"),
new DirectAddress("*****@*****.**")
}
);
IncomingMessage incoming = new IncomingMessage(message, rcpto, new DirectAddress("*****@*****.**"));
Assert.True(incoming.Recipients.Count == 2);
DirectAddressCollection routingRecipients = incoming.GetRecipientsInRoutingHeaders();
Assert.True(routingRecipients.Count == 1);
Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));
incoming.Recipients.Remove(x => MimeStandard.Equals(x.Address, "*****@*****.**"));
Assert.True(incoming.AreAddressesInRoutingHeaders(rcpto));
message.ToValue = "*****@*****.**";
incoming = new IncomingMessage(message, rcpto, new DirectAddress("*****@*****.**"));
Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));
message.ToValue = "*****@*****.**";
incoming = new IncomingMessage(message, rcpto, new DirectAddress("*****@*****.**"));
Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));
}
public void Handle(IncomingMessage msg)
{
string lastSeenEvent = null;
if (msg.Command.Equals("PRIVMSG"))
{
lastSeenEvent = "saying: " + msg.Message;
}
else if (msg.Command.Equals("JOIN"))
{
lastSeenEvent = "joining " + msg.Message;
}
else if (msg.Command.Equals("PART"))
{
lastSeenEvent = "leaving " + msg.TargetParams + ": " + msg.Message;
}
else if (msg.Command.Equals("QUIT"))
{
lastSeenEvent = "quitting: " + msg.Message;
}
else if (msg.Command.Equals("NICK"))
{
lastSeenEvent = "changing nick to: " + msg.TargetParams;
}
if (lastSeenEvent != null)
{
string nick = msg.Sender.ToLower();
Database.SetKeyValue(msg.Server, "lastseen.time." + nick, Environment.TickCount);
Database.SetKeyValue(msg.Server, "lastseen.event." + nick, lastSeenEvent);
}
}
internal void InvokeMessageHasBeenSentToErrorQueue(IncomingMessage message, Exception exception, string errorQueue)
{
MessageSentToErrorQueue?.Invoke(this, new FailedMessage(
message.MessageId,
new Dictionary<string, string>(message.Headers),
CopyOfBody(message.Body), exception, errorQueue));
}
private OutgoingMessage Pull(IncomingMessage requestMessage)
{
var response = CreatePullResponse();
var request = requestMessage.GetPayload<PullRequest>();
IPullHandler handler;
var context = request.EnumerationContext.Text;
lock (_handlers)
{
if (!_handlers.TryGetValue(context, out handler))
{
throw new InvalidEnumerationContextFaultException();
}
}
var maxElements = GetMaxElements(request);
var maxTime = GetMaxTime(request);
var pullResult = handler.Pull(maxElements, maxTime, context);
var items = new EnumerationItemList(pullResult.Items, pullResult.EnumerationMode);
if (pullResult.EndOfSequence)
{
handler.Dispose();
lock (_handlers)
{
_handlers.Remove(context);
}
}
response.SetBody(
new SerializerBodyWriter(new PullResponse
{
Items = items,
EndOfSequence = pullResult.EndOfSequence ? new EndOfSequence() : null,
EnumerationContext = pullResult.EndOfSequence ? null : request.EnumerationContext
}));
return response;
}
internal static void ProcessSSOTicket(Habbo sender, IncomingMessage message)
{
ClassicIncomingMessage classicMessage = (ClassicIncomingMessage)message;
Habbo fullHabbo = CoreManager.ServerCore.HabboDistributor.GetHabboFromSSOTicket(classicMessage.PopPrefixedString());
if (fullHabbo == null)
{
new MConnectionClosed
{
Reason = ConnectionClosedReason.InvalidSSOTicket
}.Send(sender);
sender.Socket.Disconnect("Invalid SSO Ticket");
}
else
{
// If this Habbo is already logged in...
if (fullHabbo.LoggedIn)
{
// Disconnect them.
new MConnectionClosed
{
Reason = ConnectionClosedReason.ConcurrentLogin
}.Send(fullHabbo);
fullHabbo.Socket.Disconnect("Concurrent Login");
}
LoginMerge(fullHabbo, sender);
}
}
public override void HandleIncomingMessage(IncomingMessage message)
{
if (message is CredentialsMessage)
{
CredentialsMessage cm = message as CredentialsMessage;
if (AuthenticationHandler.Authenticate(cm.Credentials))
{
_session.ClientId.Credentials = cm.Credentials;
_session.Communication.SendAuthenticationAccepted();
_session.State = new PairingState(_session);
}
else
{
_session.Communication.SendAuthenticationRejected();
}
}
else if (message is ClientPausedMessage ||
message is ClientResumedMessage)
{
// Ignore, but not reject!
}
else
{
string errorMsg = string.Format("Message type '{0}' is not supported at this point", message.GetType().Name);
Debug.WriteLine(errorMsg);
throw new NotSupportedException(errorMsg);
}
}
internal static void ProcessBalanceRequest(Habbo sender, IncomingMessage message)
{
new MCreditBalance
{
Balance = sender.Credits
}.Send(sender);
}
private OutgoingMessage Subscribe(IncomingMessage requestMessage)
{
var toHeader = requestMessage.GetHeader<ToHeader>();
var subscriptionManagerReference = new EndpointReference(toHeader.Uri);
var request = requestMessage.GetPayload<SubscribeRequest>();
var responseMessage = new OutgoingMessage()
.AddHeader(new ActionHeader(Constants.SubscribeResponseAction), false);
var expiration = CalculateExpiration(request.Expires);
var filterInstance = GetFilterInstance(request);
var identifier = GenerateUniqueSubscriptionIdentifier();
var subscription = new Subscription(expiration, _requestHandler, filterInstance, subscriptionManagerReference, requestMessage);
_activeSubscriptions.Add(identifier, subscription);
OnSubscribed(identifier, subscription);
//R7.2.4-1
var body = new SubscribeResponse
{
SubscriptionManager = subscriptionManagerReference,
EnumerationContext = request.Delivery.Mode == Delivery.DeliveryModePull
? new EnumerationContextKey(
identifier)
: null,
Expires = expiration
};
responseMessage.SetBody(new SerializerBodyWriter(body));
return responseMessage;
}
internal static void ProcessEncryptionRequest(Habbo sender, IncomingMessage message)
{
new MSetupEncryption
{
UnknownA = false
}.Send(sender);
}
public static RequestResponseStateLookup.State? TryRemoveResponseStateBasedOnCorrelationId(this IIncomingContext context, IncomingMessage message, RequestResponseStateLookup lookup)
{
var correlationId = context.GetCorrelationId();
if (correlationId == null)
{
return null;
}
string version;
var checkMessageIntent = true;
if (message.Headers.TryGetValue(Headers.NServiceBusVersion, out version))
{
Version parsedVersion;
if (Version.TryParse(version, out parsedVersion))
{
if (parsedVersion < minimumVersionThatSupportMessageIntent_Reply)
{
checkMessageIntent = false;
}
}
}
var messageIntentEnum = message.GetMesssageIntent();
if (checkMessageIntent && messageIntentEnum != MessageIntentEnum.Reply)
{
return null;
}
RequestResponseStateLookup.State state;
return lookup.TryRemove(correlationId, out state) ? (RequestResponseStateLookup.State?) state : null;
}
static bool HasReachedMaxTime(IncomingMessage message)
{
string timestampHeader;
if (!message.Headers.TryGetValue(Headers.DelayedRetriesTimestamp, out timestampHeader))
{
return false;
}
if (string.IsNullOrEmpty(timestampHeader))
{
return false;
}
try
{
var handledAt = DateTimeExtensions.ToUtcDateTime(timestampHeader);
var now = DateTime.UtcNow;
if (now > handledAt.AddDays(1))
{
return true;
}
}
// ReSharper disable once EmptyGeneralCatchClause
// this code won't usually throw but in case a user has decided to hack a message/headers and for some bizarre reason
// they changed the date and that parse fails, we want to make sure that doesn't prevent the message from being
// forwarded to the error queue.
catch (Exception)
{
}
return false;
}
private static void ProcessRequestCategoryListings(Habbo sender, IncomingMessage message)
{
bool excludeFullRooms = message.PopWiredBoolean();
int categoryID = message.PopWiredInt32();
Category category = CoreManager.ServerCore.GetNavigator().GetCategory(categoryID);
if (category == null)
new MNavigatorCategoryListing // TODO: Remove this. Maybe even throw an exception?
{
ID = categoryID,
ExcludeFullRooms = excludeFullRooms,
Name = "Non-Existant Category",
ParentID = categoryID,
IsPublicCategory = true,
Listings = new Listing[0],
UnknownA = 0,
UnknownB = 10000,
UnknownC = 0
}.Send(sender);
else
new MNavigatorCategoryListing
{
ID = categoryID,
ExcludeFullRooms = excludeFullRooms,
Name = category.Name,
ParentID = (category.PrimaryCategory != null ? category.PrimaryCategory.ID : category.ID),
IsPublicCategory = category.IsPublicCategory,
Listings = category.GetListings(),
UnknownA = 0,
UnknownB = 10000,
UnknownC = 0
}.Send(sender);
}
protected override void OnRun(IncomingMessage message)
{
JoinTableRequest request = Manager.Serializer.GetObject<JoinTableRequest>(message.Data);
RouteInfo routeInfo = Manager.GetRouteInfo(request.PlayerName);
string gameServerId = Manager.GetServerWithTable(request.TableToJoin);
//-- Stop people trying to bring down the server by sending join requests to tables that do not exist.
if (string.IsNullOrEmpty(gameServerId) == false)
{
IPEndPoint serverEndpoint = Manager.ResolveServer(gameServerId);
//-- Has the destination server been found?
if (serverEndpoint != null)
{
Manager.SendEnvelopeObjectToServer(GameMessageType.Server_ReceiveJoinTableRequest,
Manager.Serializer.GetBytes(request),
serverEndpoint.ToList(),
routeInfo);
}
else
{
ServerUIShell.WriteLine("-IPEndPoint for server could not be resolved (" + gameServerId + ")");
}
}
message.WasMessageHandled = true;
}
internal static void ProcessSessionRequest(Habbo sender, IncomingMessage message)
{
new MSessionParams
{
A = 9,
B = 0,
C = 0,
D = 1,
E = 1,
F = 3,
G = 0,
H = 2,
I = 1,
J = 4,
K = 0,
L = 5,
DateFormat = "dd-MM-yyyy",
M = "",
N = 7,
O = false,
P = 8,
URL = "http://null",
Q = "",
R = 9,
S = false
}.Send(sender);
}
public async Task<int> Retry(IncomingMessage message, TimeSpan delay, TransportTransaction transportTransaction)
{
var outgoingMessage = new OutgoingMessage(message.MessageId, new Dictionary<string, string>(message.Headers), message.Body);
var currentDelayedRetriesAttempt = message.GetDelayedDeliveriesPerformed() + 1;
outgoingMessage.SetCurrentDelayedDeliveries(currentDelayedRetriesAttempt);
outgoingMessage.SetDelayedDeliveryTimestamp(DateTime.UtcNow);
UnicastAddressTag messageDestination;
List<DeliveryConstraint> deliveryConstraints = null;
if (timeoutManagerAddress == null)
{
// transport supports native deferred messages, directly send to input queue with delay constraint:
deliveryConstraints = new List<DeliveryConstraint>(1)
{
new DelayDeliveryWith(delay)
};
messageDestination = new UnicastAddressTag(endpointInputQueue);
}
else
{
// transport doesn't support native deferred messages, reroute to timeout manager:
outgoingMessage.Headers[TimeoutManagerHeaders.RouteExpiredTimeoutTo] = endpointInputQueue;
outgoingMessage.Headers[TimeoutManagerHeaders.Expire] = DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow + delay);
messageDestination = new UnicastAddressTag(timeoutManagerAddress);
}
var transportOperations = new TransportOperations(new TransportOperation(outgoingMessage, messageDestination, deliveryConstraints: deliveryConstraints));
await dispatcher.Dispatch(transportOperations, transportTransaction, new ContextBag()).ConfigureAwait(false);
return currentDelayedRetriesAttempt;
}
public void HandleCommand(IRCServer server, string command, IncomingMessage message)
{
if (!message.HasMessage())
{
// bad syntax
return;
}
if (COMMAND_REGEX.IsMatch(message.Message))
{
Match m = COMMAND_REGEX.Match(message.Message);
string cmd = m.Groups[1].Value;
if (cmd.Equals("about"))
{
if (m.Groups[2].Value == null || m.Groups[2].Value.Equals(""))
{
message.SendChat("Need context");
}
string markov = MarkovDatabaseAdapter.MarkovFind(m.Groups[2].Value, m.Groups[3].Value);
if (markov == null || markov.Equals(""))
{
message.SendChat("I can't :(");
}
else
{
message.SendChat(markov);
}
}
}
}
public void Handle(IncomingMessage msg)
{
IRCServer server = msg.Server;
string ourNick = server.Nick;
if (msg.Command.Equals("NICK"))
{
string whoChanging = msg.Sender;
string changingTo = msg.Target;
if (whoChanging.Equals(ourNick))
{
server.Nick = changingTo;
server.SetAttemptNickChange(false);
}
else
{
// update user nick list
}
}
else if (msg.Command.Equals("ERROR"))
{
server.Dispose();
}
else
{
string raw = msg.Raw;
switch (msg.Command)
{
// nick change
case "433":
if (server.Connected)
{
// are we attempting a nick name change?
if (server.IsAttemptNickChange())
{
server.Nick = server.LastNick;
server.SetAttemptNickChange(false);
}
}
else
{
string nick;
if (server.Nick.Equals(server.AltNick))
{
nick = server.AltNick + 1;
}
else
{
nick = server.AltNick;
}
server.Nick = nick;
}
break;
}
}
}
internal void InvokeMessageHasBeenSentToDelayedRetries(int delayedRetryAttempt, IncomingMessage message, Exception exception)
{
MessageHasBeenSentToDelayedRetries?.Invoke(this, new DelayedRetryMessage(
new Dictionary<string, string>(message.Headers),
CopyOfBody(message.Body),
exception,
delayedRetryAttempt));
}
public IEnumerable<object> Enumerate(IEnumerationContext context, IncomingMessage incomingMessage, OutgoingMessage outgoingMessage)
{
var name = context.Selectors.ExtractObjectName();
if (_server.IsRegistered(name))
{
yield return ObjectNameSelector.CreateEndpointAddress(name);
}
}
/// <summary>
/// Creates a new transport receive context.
/// </summary>
/// <param name="receivedMessage">The received message.</param>
/// <param name="transportTransaction">The transport transaction.</param>
/// <param name="cancellationTokenSource">
/// Allows the pipeline to flag that it has been aborted and the receive operation should be rolled back.
/// It also allows the transport to communicate to the pipeline to abort if possible.
/// </param>
/// <param name="parentContext">The parent context.</param>
public TransportReceiveContext(IncomingMessage receivedMessage, TransportTransaction transportTransaction, CancellationTokenSource cancellationTokenSource, IBehaviorContext parentContext)
: base(parentContext)
{
this.cancellationTokenSource = cancellationTokenSource;
Message = receivedMessage;
Set(Message);
Set(transportTransaction);
}
public void HandleCommand(IRCServer server, string command, IncomingMessage msg)
{
if (msg.HasMessage())
{
string nick = msg.Message.Split(' ')[0];
server.Nick = nick;
}
}
internal static void ProcessGetVolumeLevel(Habbo sender, IncomingMessage message)
{
new MVolumeLevel
{
// TODO: Should Volume really be an extension?
Volume = sender.VolumeProperty()
}.Send(sender);
}
internal void InvokeMessageHasFailedAnImmediateRetryAttempt(int immediateRetryAttempt, IncomingMessage message, Exception exception)
{
MessageHasFailedAnImmediateRetryAttempt?.Invoke(this, new ImmediateRetryMessage(
message.MessageId,
new Dictionary<string, string>(message.Headers),
CopyOfBody(message.Body),
exception,
immediateRetryAttempt));
}
public IEnumerable<object> Enumerate(IEnumerationContext context, IncomingMessage requestMessage, OutgoingMessage responseMessage)
{
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-1.org");
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-2.org");
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-3.org");
}
private static void ProcessRequestOwnRoomListing(Habbo sender, IncomingMessage message)
{
// TODO: Database tables for rooms.
new MOwnRoomListing
{
Rooms = null
}.Send(sender);
}
internal OutgoingMessage( IncomingMessage req, Converter converter, uint flags, object payload )
{
InitializeForSend( req.Parent, converter, req.Header.m_cmd, flags, payload );
m_base.m_header.m_seqReply = req.Header.m_seq;
m_base.m_header.m_flags |= Flags.c_Reply;
UpdateCRC( converter );
}
public void HandleCommand(IRCServer server, string command, IncomingMessage msg)
{
var delta = DateTime.Now - BEGIN;
var seconds = delta.Seconds.ToString("n0");
var minutes = Math.Floor(delta.TotalMinutes).ToString("n0");
var hours = Math.Floor(delta.TotalHours).ToString("n0");
var days = Math.Floor(delta.TotalDays).ToString("n0");
string reply = "";
if (!seconds.Equals("0"))
{
if (minutes.Equals("1"))
{
reply = seconds + " second.";
}
else
{
reply = seconds + " seconds.";
}
}
if (!minutes.Equals("0"))
{
if (minutes.Equals("1"))
{
reply = minutes + " minute, " + reply;
}
else
{
reply = minutes + " minutes, " + reply;
}
}
if (!hours.Equals("0"))
{
if (hours.Equals("1"))
{
reply = hours + " hour, " + reply;
}
else
{
reply = hours + " hours, " + reply;
}
}
if (!days.Equals("0"))
{
if (days.Equals("1"))
{
reply = days + " day, " + reply;
}
else
{
reply = days + " days, " + reply;
}
}
msg.SendChat("Current uptime: " + reply);
}
private bool IsPinValid(string pin, IncomingMessage incomingMessage)
{
return(PinCodes.Any(code => code.Pin == pin && code.UserId == incomingMessage.UserId));
}
private void OnCreateRoomRequest(IncomingMessage <CreateRoomRequest> incoming)
{
this.Create(incoming.Data.Id);
}
void NewNodeMessage(IncomingMessage message)
{
if (message.Message.Payload is InvPayload)
{
InvPayload invPayload = (InvPayload)message.Message.Payload;
if (_Reject == null)
{
message.Node.SendMessage(new GetDataPayload(invPayload.Inventory.ToArray()));
}
else
{
_Reject.Message = "tx";
_Reject.Hash = invPayload.Inventory[0].Hash;
message.Node.SendMessage(_Reject);
}
}
if (message.Message.Payload is TxPayload)
{
TxPayload txPayload = (TxPayload)message.Message.Payload;
_ReceivedTransactions.AddOrUpdate(txPayload.Object.GetHash(), txPayload.Object, (k, v) => v);
_Transactions.AddOrUpdate(txPayload.Object.GetHash(), txPayload.Object, (k, v) => v);
foreach (var node in _NodeServer.ConnectedNodes)
{
if (node != message.Node)
{
node.SendMessage(new InvPayload(txPayload.Object));
}
}
}
if (message.Message.Payload is GetHeadersPayload)
{
var headers = (GetHeadersPayload)message.Message.Payload;
var fork = _Server.ChainBuilder.Chain.FindFork(headers.BlockLocators);
var response =
_Server.ChainBuilder.Chain
.ToEnumerable(true)
.TakeWhile(f => f.HashBlock != fork.HashBlock && f.HashBlock != headers.HashStop)
.Select(f => f.Header)
.Reverse()
.ToArray();
HeadersPayload res = new HeadersPayload();
res.Headers.AddRange(response);
message.Node.SendMessage(res);
}
if (message.Message.Payload is GetDataPayload)
{
Transaction tx;
Block block;
var getData = message.Message.Payload as GetDataPayload;
foreach (var inv in getData.Inventory)
{
if (inv.Type == InventoryType.MSG_TX)
{
if (_Transactions.TryGetValue(inv.Hash, out tx))
{
message.Node.SendMessage(new TxPayload(tx));
}
}
if (inv.Type == InventoryType.MSG_BLOCK)
{
if (_Blocks.TryGetValue(inv.Hash, out block))
{
message.Node.SendMessage(new BlockPayload(block));
}
else
{
}
}
}
}
}
public void DeleteIncomingMessage(IncomingMessage message)
{
context.IncomingMessages.Remove(message);
context.SaveChanges();
}
/// <summary>
/// Handles the messages received from the host.
/// </summary>
private void ClientMessageReceived(object sender, NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
if (this.networkService.ClientIdentifier == playerIdentifier)
{
this.HandlePlayerSelectionResponse(playerSpriteIndex);
}
}
/// <summary>
/// Handles the messages received from the clients. Only when this player is the host.
/// </summary>
private void HostMessageReceived(object sender, NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
var resultPlayerSpriteIndex = this.AssignPlayerSpriteIndex(playerIdentifier, playerSpriteIndex);
var responseMessage = this.networkService.CreateServerMessage();
responseMessage.Write(playerIdentifier);
responseMessage.Write(resultPlayerSpriteIndex);
this.networkService.SendToClients(responseMessage, DeliveryMethod.ReliableUnordered);
}
public override void ReadSyncData(IncomingMessage binaryReader)
{
person.SetSyncValues(binaryReader);
}
/// <summary>
/// Creates a <see cref="IIncomingPhysicalMessageContext" /> based on the current context.
/// </summary>
public static IIncomingPhysicalMessageContext CreateIncomingPhysicalMessageContext(this StageConnector <ITransportReceiveContext, IIncomingPhysicalMessageContext> stageConnector, IncomingMessage incomingMessage, ITransportReceiveContext sourceContext)
{
Guard.AgainstNull(nameof(incomingMessage), incomingMessage);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return(new IncomingPhysicalMessageContext(incomingMessage, sourceContext));
}
/// <summary>
/// Calls event handlers when a new message is received from the peer.
/// </summary>
/// <param name="message">Message that was received.</param>
public void OnMessageReceived(IncomingMessage message)
{
this.logger.LogTrace("({0}:'{1}')", nameof(message), message.Message.Command);
var version = message.Message.Payload as VersionPayload;
if ((version != null) && (this.State == NetworkPeerState.HandShaked))
{
if (message.NetworkPeer.Version >= ProtocolVersion.REJECT_VERSION)
{
message.NetworkPeer.SendMessageAsync(new RejectPayload()
{
Code = RejectCode.DUPLICATE
});
}
}
if (version != null)
{
this.TimeOffset = this.dateTimeProvider.GetTimeOffset() - version.Timestamp;
if ((version.Services & NetworkPeerServices.NODE_WITNESS) != 0)
{
this.SupportedTransactionOptions |= NetworkOptions.Witness;
}
}
if (message.Message.Payload is HaveWitnessPayload)
{
this.SupportedTransactionOptions |= NetworkOptions.Witness;
}
this.MessageProducer.PushMessage(message);
NetworkPeerMessageReceivedEventHandler messageReceivedPriority = MessageReceivedPriority;
if (messageReceivedPriority != null)
{
foreach (NetworkPeerMessageReceivedEventHandler handler in messageReceivedPriority.GetInvocationList().Cast <NetworkPeerMessageReceivedEventHandler>())
{
try
{
handler.DynamicInvoke(this, message);
}
catch (TargetInvocationException ex)
{
this.logger.LogError("Exception occurred: {0}", ex.InnerException.ToString());
}
}
}
NetworkPeerMessageReceivedEventHandler messageReceived = MessageReceived;
if (messageReceived != null)
{
foreach (NetworkPeerMessageReceivedEventHandler handler in messageReceived.GetInvocationList().Cast <NetworkPeerMessageReceivedEventHandler>())
{
try
{
handler.DynamicInvoke(this, message);
}
catch (TargetInvocationException ex)
{
this.logger.LogError("Exception occurred: {0}", ex.InnerException.ToString());
}
}
}
this.logger.LogTrace("(-)");
}
void Intercept(IncomingMessage message, Action act)
{
var inv = message.Message.Payload as InvPayload;
if (inv != null)
{
if (inv.Inventory.Any(i => ((i.Type & InventoryType.MSG_BLOCK) != 0) && !Chain.Contains(i.Hash)))
{
_Refresh.Dispose(); //No need of periodical refresh, the peer is notifying us
if (AutoSync)
{
TrySync();
}
}
}
// == GetHeadersPayload ==
// represents our height from the peer's point of view
// it is sent from the peer on first connect, in response to Inv(Block)
// or in response to HeaderPayload until an empty array is returned
// this payload notifies peers of our current best validated height
// use the ChainState.HighestValidatedPoW property (not Chain.Tip)
// if the peer is behind/equal to our best height an empty array is sent back
// Ignoring getheaders from peers because node is in initial block download
var getheaders = message.Message.Payload as GetHeadersPayload;
if (getheaders != null && CanRespondToGetHeaders &&
(!this.SharedState.IsInitialBlockDownload ||
this.AttachedNode.Behavior <ConnectionManagerBehavior>().Whitelisted)) // if not in IBD whitelisted won't be checked
{
HeadersPayload headers = new HeadersPayload();
var highestPow = SharedState.HighestValidatedPoW;
highestPow = Chain.GetBlock(highestPow.HashBlock);
var fork = Chain.FindFork(getheaders.BlockLocators);
if (fork != null)
{
if (highestPow == null || fork.Height > highestPow.Height)
{
fork = null; //fork not yet validated
}
if (fork != null)
{
foreach (var header in Chain.EnumerateToTip(fork).Skip(1))
{
if (header.Height > highestPow.Height)
{
break;
}
headers.Headers.Add(header.Header);
if (header.HashBlock == getheaders.HashStop || headers.Headers.Count == 2000)
{
break;
}
}
}
}
AttachedNode.SendMessageAsync(headers);
}
// == HeadersPayload ==
// represents the peers height from our point view
// this updates the pending tip parameter which is the
// peers current best validated height
// if the peer's height is higher Chain.Tip is updated to have
// the most PoW header
// is sent in response to GetHeadersPayload or is solicited by the
// peer when a new block is validated (and not in IBD)
var newheaders = message.Message.Payload as HeadersPayload;
var pendingTipBefore = GetPendingTipOrChainTip();
if (newheaders != null && CanSync)
{
// TODO: implement MAX_HEADERS_RESULTS in NBitcoin.HeadersPayload
var tip = GetPendingTipOrChainTip();
foreach (var header in newheaders.Headers)
{
var prev = tip.FindAncestorOrSelf(header.HashPrevBlock);
if (prev == null)
{
break;
}
tip = new ChainedBlock(header, header.GetHash(), prev);
var validated = Chain.GetBlock(tip.HashBlock) != null || tip.Validate(AttachedNode.Network);
validated &= !SharedState.IsMarkedInvalid(tip.HashBlock);
if (!validated)
{
invalidHeaderReceived = true;
break;
}
_PendingTip = tip;
}
if (_PendingTip.ChainWork > Chain.Tip.ChainWork)
{
Chain.SetTip(_PendingTip);
}
var chainedPendingTip = Chain.GetBlock(_PendingTip.HashBlock);
if (chainedPendingTip != null)
{
_PendingTip = chainedPendingTip; //This allows garbage collection to collect the duplicated pendingtip and ancestors
}
if (newheaders.Headers.Count != 0 && pendingTipBefore.HashBlock != GetPendingTipOrChainTip().HashBlock)
{
TrySync();
}
Interlocked.Decrement(ref _SynchingCount);
}
act();
}
public static void LogEndReceive(this ILogger logger, QueueType queueType, IncomingMessage message)
{
EndReceive(logger, queueType, message.MessageFunction, message.FromHerId, message.ToHerId, message.MessageId, null);
}
static string GetSubscriptionMessageTypeFrom(IncomingMessage msg)
{
return((from header in msg.Headers where header.Key == Headers.SubscriptionMessageType select header.Value).FirstOrDefault());
}
void IMessagingNotification.NotifySynchronousMessageReceivedCompleted(IncomingMessage message)
{
_logger.LogDebug("NotifySynchronousMessageReceivedCompleted");
_onSynchronousMessageReceivedCompleted?.Invoke(message);
}
XDocument IMessagingNotification.NotifySynchronousMessageReceived(IncomingMessage message)
{
_logger.LogDebug("NotifySynchronousMessageReceived");
return(_onSynchronousMessageReceived?.Invoke(message));
}
internal static IIncomingPhysicalMessageContext CreateIncomingPhysicalMessageContext(this IStageForkConnector <ITransportReceiveContext, IIncomingPhysicalMessageContext, IBatchDispatchContext> stageForkConnector, IncomingMessage incomingMessage, ITransportReceiveContext sourceContext)
{
return(new IncomingPhysicalMessageContext(incomingMessage, sourceContext));
}
private IEnumerable <ResponseMessage> HandlePinCodes(IncomingMessage incomingMessage)
{
if (
incomingMessage.RawText.ToLower().StartsWith("addpin:"))
{
var updateJson = incomingMessage.RawText.Substring("addpin:".Length);
var update = JObject.Parse(updateJson).ToObject <AddPin>();
var authenticated = IsPinValid(update.Pin, incomingMessage);
if (!authenticated)
{
yield return(incomingMessage.ReplyDirectlyToUser("You're not authorized to do this punk"));
yield break;
}
if (PinCodes.Any(code => code.UserId == update.UserId))
{
yield return(incomingMessage.ReplyDirectlyToUser("You're not authorized to do this punk"));
yield break;
}
var newPinCode = Guid.NewGuid().ToString();
PinCodes.Add(new PinCode()
{
Pin = newPinCode,
UserId = update.UserId
});
_jsonStoragePlugin.SaveFile("pincodes", PinCodes.ToArray());
yield return(ResponseMessage.DirectUserMessage(update.UserId,
$"You have been granted a pin code: `{newPinCode}` " +
"You may change it by sending " +
"`changepin:{\"Pin\": \"" + newPinCode + "\"}`"));
yield return(incomingMessage.ReplyDirectlyToUser($"Pin generated for user {update.UserId}."));
}
if (
incomingMessage.RawText.ToLower().StartsWith("changepin:"))
{
var updateJson = incomingMessage.RawText.Substring("changepin:".Length);
var update = JObject.Parse(updateJson).ToObject <ChangePin>();
var authenticated = IsPinValid(update.Pin, incomingMessage);
if (!authenticated)
{
yield return(incomingMessage.ReplyDirectlyToUser("You're not authorized to do this punk"));
yield break;
}
var newPinCode = Guid.NewGuid().ToString();
var i = PinCodes.FindIndex(code => code.UserId == incomingMessage.UserId);
PinCodes[i].Pin = newPinCode;
_jsonStoragePlugin.SaveFile("pincodes", PinCodes.ToArray());
yield return(incomingMessage.ReplyDirectlyToUser($"You have been granted a pin code: `{newPinCode}` " +
"You may change it by sending " +
"`changepin:{\"Pin\": \"" + newPinCode + "\"}`"));
}
}
public ReceivePipelineCompleted(IncomingMessage processedMessage, DateTime startedAt, DateTime completedAt)
{
ProcessedMessage = processedMessage;
StartedAt = startedAt;
CompletedAt = completedAt;
}
/// <summary>
/// Обработать игровое сообщение и изменить состояние сеанса
/// </summary>
/// <param name="message">Игровое сообщение для обработки</param>
public void ProcessGameMessage(IncomingMessage message)
{
messagesProcessor.Process(message);
}
public override void ShouldRespondCorrectly()
{
Subject.Slack.Received().SendAsync(IncomingMessage.ReplyTo(), Arg.Any <string>());
}
private void AttachedPeer_MessageReceived(NetworkPeer peer, IncomingMessage message)
{
this.logger.LogTrace("({0}:'{1}',{2}:'{3}')", nameof(peer), peer.RemoteSocketEndpoint, nameof(message), message.Message.Command);
switch (message.Message.Payload)
{
case InvPayload inv:
{
if (inv.Inventory.Any(i => ((i.Type & InventoryType.MSG_BLOCK) != 0) && !this.Chain.Contains(i.Hash)))
{
// No need of periodical refresh, the peer is notifying us.
this.refreshTimer.Dispose();
if (this.AutoSync)
{
this.TrySync();
}
}
break;
}
case GetHeadersPayload getHeaders:
{
// Represents our height from the peer's point of view.
// It is sent from the peer on first connect, in response to Inv(Block)
// or in response to HeaderPayload until an empty array is returned.
// This payload notifies peers of our current best validated height.
// Use the ChainState.ConsensusTip property (not Chain.Tip)
// if the peer is behind/equal to our best height an empty array is sent back.
if (!this.CanRespondToGetHeaders)
{
break;
}
// Ignoring "getheaders" from peers because node is in initial block download.
// If not in IBD whitelisted won't be checked.
if (this.chainState.IsInitialBlockDownload && !this.AttachedPeer.Behavior <ConnectionManagerBehavior>().Whitelisted)
{
break;
}
HeadersPayload headers = new HeadersPayload();
ChainedBlock consensusTip = this.chainState.ConsensusTip;
consensusTip = this.Chain.GetBlock(consensusTip.HashBlock);
ChainedBlock fork = this.Chain.FindFork(getHeaders.BlockLocators);
if (fork != null)
{
if ((consensusTip == null) || (fork.Height > consensusTip.Height))
{
// Fork not yet validated.
fork = null;
}
if (fork != null)
{
foreach (ChainedBlock header in this.Chain.EnumerateToTip(fork).Skip(1))
{
if (header.Height > consensusTip.Height)
{
break;
}
headers.Headers.Add(header.Header);
if ((header.HashBlock == getHeaders.HashStop) || (headers.Headers.Count == 2000))
{
break;
}
}
}
}
this.AttachedPeer.SendMessageAsync(headers);
break;
}
case HeadersPayload newHeaders:
{
// Represents the peers height from our point view.
// This updates the pending tip parameter which is
// the peers current best validated height.
// If the peer's height is higher Chain.Tip is updated to have
// the most PoW header.
// It is sent in response to GetHeadersPayload or is solicited by the
// peer when a new block is validated (and not in IBD).
if (!this.CanSync)
{
break;
}
ChainedBlock pendingTipBefore = this.GetPendingTipOrChainTip();
this.logger.LogTrace("Pending tip is '{0}', received {1} new headers.", pendingTipBefore, newHeaders.Headers.Count);
// TODO: implement MAX_HEADERS_RESULTS in NBitcoin.HeadersPayload
ChainedBlock tip = pendingTipBefore;
foreach (BlockHeader header in newHeaders.Headers)
{
ChainedBlock prev = tip.FindAncestorOrSelf(header.HashPrevBlock);
if (prev == null)
{
break;
}
tip = new ChainedBlock(header, header.GetHash(), prev);
bool validated = this.Chain.GetBlock(tip.HashBlock) != null || tip.Validate(this.AttachedPeer.Network);
validated &= !this.chainState.IsMarkedInvalid(tip.HashBlock);
if (!validated)
{
this.logger.LogTrace("Validation of new header '{0}' failed.", tip);
this.InvalidHeaderReceived = true;
break;
}
this.pendingTip = tip;
}
if (pendingTipBefore != this.pendingTip)
{
this.logger.LogTrace("Pending tip changed to '{0}'.", this.pendingTip);
}
// Long reorganization protection on POS networks.
bool reorgPrevented = false;
uint maxReorgLength = this.chainState.MaxReorgLength;
if (maxReorgLength != 0)
{
Network network = this.AttachedPeer?.Network;
ChainedBlock consensusTip = this.chainState.ConsensusTip;
if ((network != null) && (consensusTip != null))
{
ChainedBlock fork = this.pendingTip.FindFork(consensusTip);
if ((fork != null) && (fork != consensusTip))
{
int reorgLength = consensusTip.Height - fork.Height;
if (reorgLength > maxReorgLength)
{
this.logger.LogTrace("Reorganization of length {0} prevented, maximal reorganization length is {1}, consensus tip is '{2}'.", reorgLength, maxReorgLength, consensusTip);
this.InvalidHeaderReceived = true;
reorgPrevented = true;
}
else
{
this.logger.LogTrace("Reorganization of length {0} accepted, consensus tip is '{1}'.", reorgLength, consensusTip);
}
}
}
}
if (!reorgPrevented && (this.pendingTip.ChainWork > this.Chain.Tip.ChainWork))
{
this.logger.LogTrace("New chain tip '{0}' selected, chain work is '{1}'.", this.pendingTip, this.pendingTip.ChainWork);
this.Chain.SetTip(this.pendingTip);
}
ChainedBlock chainedPendingTip = this.Chain.GetBlock(this.pendingTip.HashBlock);
if (chainedPendingTip != null)
{
// This allows garbage collection to collect the duplicated pendingTip and ancestors.
this.pendingTip = chainedPendingTip;
}
if ((!this.InvalidHeaderReceived) && (newHeaders.Headers.Count != 0) && (pendingTipBefore.HashBlock != this.GetPendingTipOrChainTip().HashBlock))
{
this.TrySync();
}
break;
}
}
this.logger.LogTrace("(-)");
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // RegisterSystemEventForDiscoveryImpl
RegisterSystemEventForDiscoveryImpl(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 1: { // Unknown1
Unknown1();
om.Initialize(0, 0, 0);
break;
}
case 2: { // Unknown2
Unknown2();
om.Initialize(0, 0, 0);
break;
}
case 3: { // Unknown3
Unknown3(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 4: { // Unknown4
Unknown4(null);
om.Initialize(0, 0, 0);
break;
}
case 5: { // Unknown5
Unknown5(null);
om.Initialize(0, 0, 0);
break;
}
case 6: { // Unknown6
Unknown6(null);
om.Initialize(0, 0, 0);
break;
}
case 7: { // Unknown7
Unknown7(null);
om.Initialize(0, 0, 0);
break;
}
case 8: { // Unknown8
Unknown8(null);
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IBtmDebug: {im.CommandId}");
}
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // StartGamepadPairingImpl
StartGamepadPairingImpl();
om.Initialize(0, 0, 0);
break;
}
case 1: { // CancelGamepadPairingImpl
CancelGamepadPairingImpl();
om.Initialize(0, 0, 0);
break;
}
case 2: { // ClearGamepadPairingDatabaseImpl
ClearGamepadPairingDatabaseImpl();
om.Initialize(0, 0, 0);
break;
}
case 3: { // GetPairedGamepadCountImpl
var ret = GetPairedGamepadCountImpl();
om.Initialize(0, 0, 0);
break;
}
case 4: { // EnableRadioImpl
EnableRadioImpl();
om.Initialize(0, 0, 0);
break;
}
case 5: { // DisableRadioImpl
DisableRadioImpl();
om.Initialize(0, 0, 0);
break;
}
case 6: { // GetRadioOnOffImpl
var ret = GetRadioOnOffImpl();
om.Initialize(0, 0, 0);
break;
}
case 7: { // AcquireRadioEventImpl
AcquireRadioEventImpl(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 8: { // AcquireGamepadPairingEventImpl
AcquireGamepadPairingEventImpl(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 9: { // IsGamepadPairingStartedImpl
var ret = IsGamepadPairingStartedImpl();
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IBtmSystemCore: {im.CommandId}");
}
}
internal virtual void Reset()
{
Socket = null;
Sending = false;
Message = null;
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // Unknown0
var ret = Unknown0();
om.Initialize(0, 0, 0);
break;
}
case 1: { // Unknown1
var ret = Unknown1();
om.Initialize(0, 0, 0);
break;
}
case 2: { // RegisterSystemEventForConnectedDeviceConditionImpl
RegisterSystemEventForConnectedDeviceConditionImpl(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 3: { // Unknown3
Unknown3(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 4: { // Unknown4
Unknown4(null);
om.Initialize(0, 0, 0);
break;
}
case 5: { // Unknown5
Unknown5(im.GetBuffer <byte>(0x19, 0));
om.Initialize(0, 0, 0);
break;
}
case 6: { // Unknown6
Unknown6(null);
om.Initialize(0, 0, 0);
break;
}
case 7: { // Unknown7
Unknown7(null);
om.Initialize(0, 0, 0);
break;
}
case 8: { // RegisterSystemEventForRegisteredDeviceInfoImpl
RegisterSystemEventForRegisteredDeviceInfoImpl(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 9: { // Unknown9
Unknown9(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 10: { // Unknown10
Unknown10(null);
om.Initialize(0, 0, 0);
break;
}
case 11: { // Unknown11
Unknown11(null);
om.Initialize(0, 0, 0);
break;
}
case 12: { // Unknown12
Unknown12(null);
om.Initialize(0, 0, 0);
break;
}
case 13: { // Unknown13
Unknown13(null);
om.Initialize(0, 0, 0);
break;
}
case 14: { // EnableRadioImpl
EnableRadioImpl();
om.Initialize(0, 0, 0);
break;
}
case 15: { // DisableRadioImpl
DisableRadioImpl();
om.Initialize(0, 0, 0);
break;
}
case 16: { // Unknown16
Unknown16(null);
om.Initialize(0, 0, 0);
break;
}
case 17: { // Unknown17
Unknown17(null, im.GetBuffer <byte>(0x19, 0));
om.Initialize(0, 0, 0);
break;
}
case 18: { // Unknown18
Unknown18(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 19: { // Unknown19
Unknown19(out var _0, out var _1);
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(_1, copy: true));
break;
}
case 20: { // Unknown20
var ret = Unknown20();
om.Initialize(0, 0, 0);
break;
}
case 21: { // Unknown21
Unknown21(null);
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IBtm: {im.CommandId}");
}
}
public bool ShouldHandle(IncomingMessage msg)
{
return(true);
}
public void HandleCommand(IRCServer server, string command, IncomingMessage msg)
{
if (!msg.HasMessage())
{
msg.SendChat(Help());
return;
}
string term = msg.Message;
long lastquery;
try
{
lastquery = long.Parse(Database.GetKeyValue(msg.Server, LASTQUERY_PREFIX + term));
}
catch (Exception)
{
lastquery = -1;
}
if (lastquery > 0 && Environment.TickCount - lastquery < TIMEOUT)
{
string lastdata = Database.GetKeyValue(msg.Server, LASTRESULT_PREFIX + term);
if (lastdata != null && !lastdata.Equals(""))
{
msg.SendChat(msg.Sender + ": " + lastdata);
}
else
{
msg.SendChat(string.Format("{0}: There was an error last time retrieving the definition for {1}, please try again in {2} minute(s)", msg.Sender, term,
TimeSpan.FromMilliseconds(TIMEOUT - (Environment.TickCount - lastquery)).Minutes));
}
}
else
{
string term_encoded;
try
{
term_encoded = Uri.EscapeUriString(term);
}
catch (Exception)
{
msg.SendChat(msg.Sender + ": Error parsing location," + msg.Message);
return;
}
Database.SetKeyValue(msg.Server, LASTQUERY_PREFIX + term, Environment.TickCount);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URBAN_URL + term_encoded);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
string responseContent;
using (var streamReader = new StreamReader(response.GetResponseStream()))
{
responseContent = streamReader.ReadToEnd();
}
JObject json = JObject.Parse(responseContent);
StringBuilder definition = new StringBuilder("Urban definition of `" + term + "`: ");
try
{
definition.Append(json["list"][0]["definition"].ToString());
}
catch (Exception)
{
msg.SendChat(msg.Sender + ": Error parsing urban data for, " + msg.Message);
return;
}
string formatted = definition.ToString();
Database.SetKeyValue(msg.Server, LASTRESULT_PREFIX + term, formatted);
msg.SendChat(msg.Sender + ": " + formatted);
}
}
void AttachedNode_MessageReceived(Node node, IncomingMessage message)
{
InvPayload invPayload = message.Message.Payload as InvPayload;
if (invPayload != null)
{
foreach (var hash in invPayload.Where(i => i.Type == InventoryType.MSG_TX).Select(i => i.Hash))
{
var tx = GetTransaction(hash, true);
if (tx != null)
{
tx.State = BroadcastState.Accepted;
}
Transaction unused;
if (_BroadcastHub.BroadcastedTransaction.TryRemove(hash, out unused))
{
_BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
}
}
}
RejectPayload reject = message.Message.Payload as RejectPayload;
if (reject != null && reject.Message == "tx")
{
var tx = GetTransaction(reject.Hash, true);
if (tx != null)
{
tx.State = BroadcastState.Rejected;
}
Transaction tx2;
if (_BroadcastHub.BroadcastedTransaction.TryRemove(reject.Hash, out tx2))
{
_BroadcastHub.OnTransactionRejected(tx2, reject);
}
}
GetDataPayload getData = message.Message.Payload as GetDataPayload;
if (getData != null)
{
foreach (var inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_TX))
{
var tx = GetTransaction(inventory.Hash, false);
if (tx != null)
{
tx.State = BroadcastState.Broadcasted;
var ping = new PingPayload();
tx.PingValue = ping.Nonce;
_PingToTransaction.TryAdd(tx.PingValue, tx);
node.SendMessageAsync(new TxPayload(tx.Transaction));
node.SendMessageAsync(ping);
}
}
}
PongPayload pong = message.Message.Payload as PongPayload;
if (pong != null)
{
var tx = GetTransaction(pong.Nonce, true);
if (tx != null)
{
tx.State = BroadcastState.Accepted;
Transaction unused;
if (_BroadcastHub.BroadcastedTransaction.TryRemove(tx.Transaction.GetHash(), out unused))
{
_BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
}
}
}
}
public void OnReceivingMessage(IncomingMessage message, Action next)
{
_OnIncoming(message, next);
}
void IMessagingNotification.NotifySynchronousMessageReceivedStarting(IncomingMessage message)
{
_logger.LogDebug("NotifySynchronousMessageReceivedStarting");
_onSynchronousMessageReceivedStarting?.Invoke(message);
}
void Intercept(IncomingMessage message, Action act)
{
var inv = message.Message.Payload as InvPayload;
if (inv != null)
{
if (inv.Inventory.Any(i => ((i.Type & InventoryType.MSG_BLOCK) != 0) && !Chain.Contains(i.Hash)))
{
_Refresh.Dispose(); //No need of periodical refresh, the peer is notifying us
if (AutoSync)
{
TrySync();
}
}
}
var getheaders = message.Message.Payload as GetHeadersPayload;
if (getheaders != null && CanRespondToGetHeaders)
{
HeadersPayload headers = new HeadersPayload();
var fork = Chain.FindFork(getheaders.BlockLocators);
if (fork != null)
{
foreach (var header in Chain.EnumerateToTip(fork).Skip(1))
{
headers.Headers.Add(header.Header);
if (header.HashBlock == getheaders.HashStop || headers.Headers.Count == 2000)
{
break;
}
}
}
AttachedNode.SendMessageAsync(headers);
}
var newheaders = message.Message.Payload as HeadersPayload;
var pendingTipBefore = GetPendingTip();
if (newheaders != null && CanSync)
{
var tip = GetPendingTip();
foreach (var header in newheaders.Headers)
{
var prev = tip.FindAncestorOrSelf(header.HashPrevBlock);
if (prev == null)
{
break;
}
tip = new ChainedBlock(header, header.GetHash(), prev);
if (!AttachedNode.IsTrusted)
{
var validated = Chain.GetBlock(tip.HashBlock) != null || tip.Validate(AttachedNode.Network);
if (!validated)
{
invalidHeaderReceived = true;
break;
}
}
_PendingTip = tip;
}
if (_PendingTip.Height > Chain.Tip.Height)
{
Chain.SetTip(_PendingTip);
}
var chainedPendingTip = Chain.GetBlock(_PendingTip.HashBlock);
if (chainedPendingTip != null)
{
_PendingTip = chainedPendingTip; //This allows garbage collection to collect the duplicated pendingtip and ancestors
}
if (newheaders.Headers.Count != 0 && pendingTipBefore.HashBlock != GetPendingTip().HashBlock)
{
TrySync();
}
Interlocked.Decrement(ref _SynchingCount);
}
act();
}
