private static void startVoIPSession()
{
try
{
audioPlayer = DependencyService.Get <IAudioPlayer>(DependencyFetchTarget.NewInstance);
audioPlayer.start(currentCallCodec);
audioRecorder = DependencyService.Get <IAudioRecorder>(DependencyFetchTarget.NewInstance);
audioRecorder.start(currentCallCodec);
audioRecorder.setOnSoundDataReceived((data) =>
{
StreamProcessor.sendAppData(currentCallContact, currentCallSessionId, data);
});
currentCallStartedTime = Clock.getTimestamp();
startLastPacketReceivedCheck();
}
catch (Exception e)
{
Logging.error("Exception occured while starting VoIP session: " + e);
endVoIPSession();
}
}
public static void acceptCall(byte[] session_id)
{
if (!hasSession(session_id))
{
return;
}
if (currentCallAccepted)
{
return;
}
DependencyService.Get <ISpixiPermissions>().requestAudioRecordingPermissions();
currentCallAccepted = true;
StreamProcessor.sendAppRequestAccept(currentCallContact, session_id, Encoding.UTF8.GetBytes(currentCallCodec));
startVoIPSession();
if (currentCallContact != null)
{
((SpixiContentPage)App.Current.MainPage.Navigation.NavigationStack.Last()).displayCallBar(currentCallSessionId, SpixiLocalization._SL("global-call-in-call") + " - " + currentCallContact.nickname, currentCallStartedTime);
}
}
public async static Task Main(string[] args)
{
if (args.Length != 1)
{
System.Console.WriteLine($"Usage: {Assembly.GetExecutingAssembly().GetName()} log_file_path");
return;
}
var filePath = args[0];
if (!File.Exists(filePath))
{
System.Console.WriteLine($"File not found at {filePath}");
return;
}
using var liteDbPersister = new LiteDbPersistence(configuration);
var streamProcessor = new StreamProcessor(liteDbPersister, configuration);
using var fileStream = File.OpenRead(filePath);
var watch = Stopwatch.StartNew();
await streamProcessor.Process(fileStream);
Log.Logger.Information($"{Path.GetFileName(filePath)} processed in {watch.Elapsed}");
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessorRegistrationResult"/> class.
/// </summary>
/// <param name="success">Whether the <see cref="StreamProcessor" /> was successfully registered.</param>
/// <param name="streamProcessor">The <see cref="StreamProcessor" />.</param>
public EventProcessorRegistrationResult(bool success, StreamProcessor streamProcessor)
{
Success = success;
StreamProcessor = streamProcessor;
}
/// <summary>
/// Performs the transformation.
/// </summary>
/// <param name="key">The key to be used as the encryption key.</param>
/// <param name="inputFile">The file to be transformed.</param>
/// <param name="outputFile">The file to output the result of the transformation.</param>
/// <param name="streamProcessor">A <see cref="StreamProcessor"/> delegate that performs the actual transformation</param>
private static void TransformFile(string key, string inputFile, string outputFile, StreamProcessor streamProcessor)
{
FileStream inputStream = null;
FileStream outputStream = null;
try
{
inputStream = new FileStream(inputFile, FileMode.Open);
outputStream = new FileStream(outputFile, FileMode.Create);
streamProcessor(key, inputStream, outputStream);
}
finally
{
if (inputStream != null)
{
inputStream.Close();
inputStream.Dispose();
}
if (outputStream != null)
{
outputStream.Close();
outputStream.Dispose();
}
}
}
// Unified protocol message parsing
public static void parseProtocolMessage(ProtocolMessageCode code, byte[] data, RemoteEndpoint endpoint)
{
if (endpoint == null)
{
Logging.error("Endpoint was null. parseProtocolMessage");
return;
}
try
{
switch (code)
{
case ProtocolMessageCode.hello:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
CoreProtocolMessage.sendHelloMessage(endpoint, true);
endpoint.helloReceived = true;
return;
}
}
}
}
break;
case ProtocolMessageCode.helloData:
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
ulong last_block_num = reader.ReadUInt64();
int bcLen = reader.ReadInt32();
byte[] block_checksum = reader.ReadBytes(bcLen);
int wsLen = reader.ReadInt32();
byte[] walletstate_checksum = reader.ReadBytes(wsLen);
int consensus = reader.ReadInt32();
endpoint.blockHeight = last_block_num;
int block_version = reader.ReadInt32();
Node.setLastBlock(last_block_num, block_checksum, walletstate_checksum, block_version);
Node.setRequiredConsensus(consensus);
// Check for legacy level
ulong legacy_level = reader.ReadUInt64();
// Check for legacy node
if (Legacy.isLegacy(legacy_level))
{
// TODO TODO TODO TODO check this out
//endpoint.setLegacy(true);
}
// Process the hello data
endpoint.helloReceived = true;
NetworkClientManager.recalculateLocalTimeDifference();
}
// Get presences
endpoint.sendData(ProtocolMessageCode.syncPresenceList, new byte[1]);
// Subscribe to transaction events
byte[] event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionFrom, Node.walletStorage.getPrimaryAddress());
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
event_data = NetworkEvents.prepareEventMessageData(NetworkEvents.Type.transactionTo, Node.walletStorage.getPrimaryAddress());
endpoint.sendData(ProtocolMessageCode.attachEvent, event_data);
}
}
break;
case ProtocolMessageCode.s2data:
{
StreamProcessor.receiveData(data, endpoint);
}
break;
case ProtocolMessageCode.s2keys:
{
Console.WriteLine("NET: Receiving S2 keys!");
// StreamProcessor.receivedKeys(data, socket);
}
break;
case ProtocolMessageCode.syncPresenceList:
{
byte[] pdata = PresenceList.getBytes();
// byte[] ba = prepareProtocolMessage(ProtocolMessageCode.presenceList, pdata);
// socket.Send(ba, SocketFlags.None);
}
break;
case ProtocolMessageCode.presenceList:
{
Logging.info("NET: Receiving complete presence list");
PresenceList.syncFromBytes(data);
// NetworkClientManager.searchForStreamNode();
}
break;
case ProtocolMessageCode.updatePresence:
{
Console.WriteLine("NET: Receiving presence list update");
// Parse the data and update entries in the presence list
PresenceList.updateFromBytes(data);
}
break;
case ProtocolMessageCode.balance:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int address_length = reader.ReadInt32();
byte[] address = reader.ReadBytes(address_length);
// Retrieve the latest balance
IxiNumber balance = reader.ReadString();
if (address.SequenceEqual(Node.walletStorage.getPrimaryAddress()))
{
Node.balance = balance;
}
// Retrieve the blockheight for the balance
ulong blockheight = reader.ReadUInt64();
Node.blockHeight = blockheight;
}
}
}
break;
case ProtocolMessageCode.transactionData:
{
// TODO: check for errors/exceptions
Transaction transaction = new Transaction(data);
TransactionCache.addTransaction(transaction);
}
break;
case ProtocolMessageCode.newTransaction:
{
// Forward the new transaction message to the DLT network
Logging.info("RECIEVED NEW TRANSACTION");
Transaction transaction = new Transaction(data);
if (transaction.toList.Keys.First().SequenceEqual(Node.walletStorage.getPrimaryAddress()))
{
TransactionCache.addTransaction(transaction);
}
}
break;
case ProtocolMessageCode.bye:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
endpoint.stop();
bool byeV1 = false;
try
{
int byeCode = reader.ReadInt32();
string byeMessage = reader.ReadString();
string byeData = reader.ReadString();
byeV1 = true;
if (byeCode != 200)
{
Logging.warn(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
}
if (byeCode == 600)
{
if (IxiUtils.validateIPv4(byeData))
{
if (NetworkClientManager.getConnectedClients().Length < 2)
{
Config.publicServerIP = byeData;
Logging.info("Changed internal IP Address to " + byeData + ", reconnecting");
}
}
}
else if (byeCode == 601)
{
Logging.error("This node must be connectable from the internet, to connect to the network.");
Logging.error("Please setup uPNP and/or port forwarding on your router for port " + Config.serverPort + ".");
}
}
catch (Exception)
{
}
if (byeV1)
{
return;
}
reader.BaseStream.Seek(0, SeekOrigin.Begin);
// Retrieve the message
string message = reader.ReadString();
if (message.Length > 0)
{
Logging.info(string.Format("Disconnected with message: {0}", message));
}
else
{
Logging.info("Disconnected");
}
}
}
}
break;
default:
break;
}
}
catch (Exception e)
{
Logging.error(string.Format("Error parsing network message. Details: {0}", e.ToString()));
}
}
// Unified protocol message parsing
public static void parseProtocolMessage(ProtocolMessageCode code, byte[] data, RemoteEndpoint endpoint)
{
if (endpoint == null)
{
Logging.error("Endpoint was null. parseProtocolMessage");
return;
}
try
{
switch (code)
{
case ProtocolMessageCode.hello:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
byte[] challenge_response = null;
int challenge_len = reader.ReadInt32();
byte[] challenge = reader.ReadBytes(challenge_len);
challenge_response = CryptoManager.lib.getSignature(challenge, IxianHandler.getWalletStorage().getPrimaryPrivateKey());
CoreProtocolMessage.sendHelloMessage(endpoint, true, challenge_response);
endpoint.helloReceived = true;
return;
}
}
}
}
break;
case ProtocolMessageCode.helloData:
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (!CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
return;
}
ulong last_block_num = reader.ReadUInt64();
int bcLen = reader.ReadInt32();
byte[] block_checksum = reader.ReadBytes(bcLen);
int wsLen = reader.ReadInt32();
byte[] walletstate_checksum = reader.ReadBytes(wsLen);
int consensus = reader.ReadInt32(); // deprecated
endpoint.blockHeight = last_block_num;
int block_version = reader.ReadInt32();
Node.setLastBlock(last_block_num, block_checksum, walletstate_checksum, block_version);
// Check for legacy level
ulong legacy_level = reader.ReadUInt64(); // deprecated
int challenge_response_len = reader.ReadInt32();
byte[] challenge_response = reader.ReadBytes(challenge_response_len);
if (!CryptoManager.lib.verifySignature(endpoint.challenge, endpoint.serverPubKey, challenge_response))
{
CoreProtocolMessage.sendBye(endpoint, ProtocolByeCode.authFailed, string.Format("Invalid challenge response."), "", true);
return;
}
ulong highest_block_height = IxianHandler.getHighestKnownNetworkBlockHeight();
if (last_block_num + 10 < highest_block_height)
{
CoreProtocolMessage.sendBye(endpoint, ProtocolByeCode.tooFarBehind, string.Format("Your node is too far behind, your block height is {0}, highest network block height is {1}.", last_block_num, highest_block_height), highest_block_height.ToString(), true);
return;
}
// Process the hello data
endpoint.helloReceived = true;
NetworkClientManager.recalculateLocalTimeDifference();
if (endpoint.presenceAddress.type == 'R')
{
string[] connected_servers = StreamClientManager.getConnectedClients(true);
if (connected_servers.Count() == 1 || !connected_servers.Contains(StreamClientManager.primaryS2Address))
{
if (StreamClientManager.primaryS2Address == "")
{
FriendList.requestAllFriendsPresences();
}
// TODO set the primary s2 host more efficiently, perhaps allow for multiple s2 primary hosts
StreamClientManager.primaryS2Address = endpoint.getFullAddress(true);
// TODO TODO do not set if directly connectable
IxianHandler.publicIP = endpoint.address;
IxianHandler.publicPort = endpoint.incomingPort;
PresenceList.forceSendKeepAlive = true;
Logging.info("Forcing KA from networkprotocol");
}
}
else if (endpoint.presenceAddress.type == 'C')
{
Friend f = FriendList.getFriend(endpoint.presence.wallet);
if (f != null && f.bot)
{
StreamProcessor.sendGetMessages(f);
}
}
if (endpoint.presenceAddress.type == 'M')
{
subscribeToEvents(endpoint);
}
}
}
break;
case ProtocolMessageCode.s2data:
{
StreamProcessor.receiveData(data, endpoint);
}
break;
case ProtocolMessageCode.updatePresence:
{
Logging.info("NET: Receiving presence list update");
// Parse the data and update entries in the presence list
Presence p = PresenceList.updateFromBytes(data);
}
break;
case ProtocolMessageCode.keepAlivePresence:
{
byte[] address = null;
bool updated = PresenceList.receiveKeepAlive(data, out address, endpoint);
}
break;
case ProtocolMessageCode.getPresence:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int walletLen = reader.ReadInt32();
byte[] wallet = reader.ReadBytes(walletLen);
Presence p = PresenceList.getPresenceByAddress(wallet);
if (p != null)
{
lock (p)
{
byte[][] presence_chunks = p.getByteChunks();
foreach (byte[] presence_chunk in presence_chunks)
{
endpoint.sendData(ProtocolMessageCode.updatePresence, presence_chunk, null);
}
}
}
else
{
// TODO blacklisting point
Logging.warn(string.Format("Node has requested presence information about {0} that is not in our PL.", Base58Check.Base58CheckEncoding.EncodePlain(wallet)));
}
}
}
}
break;
case ProtocolMessageCode.balance:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int address_length = reader.ReadInt32();
byte[] address = reader.ReadBytes(address_length);
// Retrieve the latest balance
IxiNumber balance = reader.ReadString();
if (address.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress()))
{
Node.balance = balance;
}
// Retrieve the blockheight for the balance
ulong blockheight = reader.ReadUInt64();
Node.blockHeight = blockheight;
}
}
}
break;
case ProtocolMessageCode.transactionData:
{
// TODO: check for errors/exceptions
Transaction transaction = new Transaction(data, true);
TransactionCache.addTransaction(transaction);
}
break;
case ProtocolMessageCode.newTransaction:
{
Transaction transaction = new Transaction(data, true);
TransactionCache.addTransaction(transaction);
}
break;
case ProtocolMessageCode.bye:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
endpoint.stop();
bool byeV1 = false;
try
{
ProtocolByeCode byeCode = (ProtocolByeCode)reader.ReadInt32();
string byeMessage = reader.ReadString();
string byeData = reader.ReadString();
byeV1 = true;
switch (byeCode)
{
case ProtocolByeCode.bye: // all good
break;
case ProtocolByeCode.forked: // forked node disconnected
Logging.info(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
case ProtocolByeCode.deprecated: // deprecated node disconnected
Logging.info(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
case ProtocolByeCode.incorrectIp: // incorrect IP
if (IxiUtils.validateIPv4(byeData))
{
if (NetworkClientManager.getConnectedClients(true).Length < 2)
{
// TODO TODO do not set if not directly connectable
IxianHandler.publicIP = byeData;
Logging.info("Changed internal IP Address to " + byeData + ", reconnecting");
}
}
break;
case ProtocolByeCode.notConnectable: // not connectable from the internet
Logging.error("This node must be connectable from the internet, to connect to the network.");
Logging.error("Please setup uPNP and/or port forwarding on your router for port " + IxianHandler.publicPort + ".");
NetworkServer.connectable = false;
break;
default:
Logging.warn(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
}
}
catch (Exception)
{
}
if (byeV1)
{
return;
}
reader.BaseStream.Seek(0, SeekOrigin.Begin);
// Retrieve the message
string message = reader.ReadString();
if (message.Length > 0)
{
Logging.info(string.Format("Disconnected with message: {0}", message));
}
else
{
Logging.info("Disconnected");
}
}
}
}
break;
default:
break;
}
}
catch (Exception e)
{
Logging.error(string.Format("Error parsing network message. Details: {0}", e.ToString()));
}
if (waitingFor == code)
{
blocked = false;
}
}
// Unified protocol message parsing
public static void parseProtocolMessage(ProtocolMessageCode code, byte[] data, RemoteEndpoint endpoint)
{
if (endpoint == null)
{
Logging.error("Endpoint was null. parseProtocolMessage");
return;
}
try
{
switch (code)
{
case ProtocolMessageCode.hello:
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
byte[] challenge_response = null;
try
{
// TODO TODO TODO TODO TODO try/catch wrapper will be removed when everybody upgrades
int challenge_len = reader.ReadInt32();
byte[] challenge = reader.ReadBytes(challenge_len);
challenge_response = CryptoManager.lib.getSignature(challenge, Node.walletStorage.getPrimaryPrivateKey());
}
catch (Exception e)
{
}
CoreProtocolMessage.sendHelloMessage(endpoint, true, challenge_response);
endpoint.helloReceived = true;
return;
}
}
}
break;
case ProtocolMessageCode.helloData:
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
if (CoreProtocolMessage.processHelloMessage(endpoint, reader))
{
char node_type = endpoint.presenceAddress.type;
if (node_type != 'M' && node_type != 'H')
{
CoreProtocolMessage.sendBye(endpoint, ProtocolByeCode.expectingMaster, string.Format("Expecting master node."), "", true);
return;
}
ulong last_block_num = reader.ReadUInt64();
int bcLen = reader.ReadInt32();
byte[] block_checksum = reader.ReadBytes(bcLen);
int wsLen = reader.ReadInt32();
byte[] walletstate_checksum = reader.ReadBytes(wsLen);
int consensus = reader.ReadInt32();
endpoint.blockHeight = last_block_num;
int block_version = reader.ReadInt32();
Node.setLastBlock(last_block_num, block_checksum, walletstate_checksum, block_version);
Node.setRequiredConsensus(consensus);
// Check for legacy level
ulong legacy_level = reader.ReadUInt64();
// Check for legacy node
if (Legacy.isLegacy(legacy_level))
{
// TODO TODO TODO TODO check this out
//endpoint.setLegacy(true);
}
int challenge_response_len = reader.ReadInt32();
byte[] challenge_response = reader.ReadBytes(challenge_response_len);
if (!CryptoManager.lib.verifySignature(endpoint.challenge, endpoint.serverPubKey, challenge_response))
{
CoreProtocolMessage.sendBye(endpoint, ProtocolByeCode.authFailed, string.Format("Invalid challenge response."), "", true);
return;
}
// Process the hello data
endpoint.helloReceived = true;
NetworkClientManager.recalculateLocalTimeDifference();
}
}
}
break;
case ProtocolMessageCode.s2data:
{
StreamProcessor.receiveData(data, endpoint);
}
break;
case ProtocolMessageCode.s2failed:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
Logging.error("Failed to send s2 data");
}
}
}
break;
case ProtocolMessageCode.s2signature:
{
StreamProcessor.receivedTransactionSignature(data, endpoint);
}
break;
case ProtocolMessageCode.newTransaction:
{
// Forward the new transaction message to the DLT network
CoreProtocolMessage.broadcastProtocolMessage(new char[] { 'M', 'H' }, ProtocolMessageCode.newTransaction, data, null);
}
break;
case ProtocolMessageCode.syncPresenceList:
{
byte[] pdata = PresenceList.getBytes();
byte[] ba = CoreProtocolMessage.prepareProtocolMessage(ProtocolMessageCode.presenceList, pdata);
endpoint.sendData(ProtocolMessageCode.presenceList, pdata);
}
break;
case ProtocolMessageCode.presenceList:
{
Logging.info("Receiving complete presence list");
PresenceList.syncFromBytes(data);
}
break;
case ProtocolMessageCode.updatePresence:
{
// Parse the data and update entries in the presence list
PresenceList.updateFromBytes(data);
}
break;
case ProtocolMessageCode.keepAlivePresence:
{
byte[] address = null;
bool updated = PresenceList.receiveKeepAlive(data, out address);
// If a presence entry was updated, broadcast this message again
if (updated)
{
CoreProtocolMessage.broadcastProtocolMessage(new char[] { 'M', 'R', 'H', 'W' }, ProtocolMessageCode.keepAlivePresence, data, address, endpoint);
// Send this keepalive message to all connected clients
CoreProtocolMessage.broadcastEventDataMessage(NetworkEvents.Type.keepAlive, address, ProtocolMessageCode.keepAlivePresence, data, address, endpoint);
}
}
break;
case ProtocolMessageCode.getPresence:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int walletLen = reader.ReadInt32();
byte[] wallet = reader.ReadBytes(walletLen);
lock (PresenceList.presences)
{
// TODO re-verify this
Presence p = PresenceList.presences.Find(x => x.wallet.SequenceEqual(wallet));
if (p != null)
{
byte[][] presence_chunks = p.getByteChunks();
int i = 0;
foreach (byte[] presence_chunk in presence_chunks)
{
endpoint.sendData(ProtocolMessageCode.updatePresence, presence_chunk);
i++;
}
}
else
{
// TODO blacklisting point
Logging.warn(string.Format("Node has requested presence information about {0} that is not in our PL.", Base58Check.Base58CheckEncoding.EncodePlain(wallet)));
}
}
}
}
}
break;
case ProtocolMessageCode.balance:
{
// TODO: make sure this is received from a DLT node only.
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int address_length = reader.ReadInt32();
byte[] address = reader.ReadBytes(address_length);
// Retrieve the latest balance
IxiNumber balance = reader.ReadString();
if (address.SequenceEqual(Node.walletStorage.getPrimaryAddress()))
{
Node.balance = balance;
}
// Retrieve the blockheight for the balance
ulong blockheight = reader.ReadUInt64();
Node.blockHeight = blockheight;
}
}
}
break;
case ProtocolMessageCode.bye:
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
endpoint.stop();
bool byeV1 = false;
try
{
ProtocolByeCode byeCode = (ProtocolByeCode)reader.ReadInt32();
string byeMessage = reader.ReadString();
string byeData = reader.ReadString();
byeV1 = true;
switch (byeCode)
{
case ProtocolByeCode.bye: // all good
break;
case ProtocolByeCode.forked: // forked node disconnected
Logging.info(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
case ProtocolByeCode.deprecated: // deprecated node disconnected
Logging.info(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
case ProtocolByeCode.incorrectIp: // incorrect IP
if (IxiUtils.validateIPv4(byeData))
{
if (NetworkClientManager.getConnectedClients().Length < 2)
{
Config.publicServerIP = byeData;
Logging.info("Changed internal IP Address to " + byeData + ", reconnecting");
}
}
break;
case ProtocolByeCode.notConnectable: // not connectable from the internet
Logging.error("This node must be connectable from the internet, to connect to the network.");
Logging.error("Please setup uPNP and/or port forwarding on your router for port " + Config.serverPort + ".");
NetworkServer.connectable = false;
break;
case ProtocolByeCode.insufficientFunds:
break;
default:
Logging.warn(string.Format("Disconnected with message: {0} {1}", byeMessage, byeData));
break;
}
}
catch (Exception)
{
}
if (byeV1)
{
return;
}
reader.BaseStream.Seek(0, SeekOrigin.Begin);
// Retrieve the message
string message = reader.ReadString();
if (message.Length > 0)
{
Logging.info(string.Format("Disconnected with message: {0}", message));
}
else
{
Logging.info("Disconnected");
}
}
}
}
break;
case ProtocolMessageCode.extend:
{
if (Config.isTestClient)
{
TestClientNode.handleExtendProtocol(data);
}
}
break;
default:
break;
}
}
catch (Exception e)
{
Logging.error(string.Format("Error parsing network message. Details: {0}", e.ToString()));
}
}
public virtual void resetKey()
{
RECEIVE_KEY = StreamProcessor.cloneArrary(StreamProcessor.KEY);
SEND_KEY = StreamProcessor.cloneArrary(StreamProcessor.KEY);
}
public void Setup()
{
ClassUnderTest = new StreamProcessor();
}