public static DisconnectMessage Deserialize(string rawMessage)
{
DisconnectMessage msg = new DisconnectMessage();
// 0::
// 0::/test
msg.RawMessage = rawMessage;
string[] args = rawMessage.Split(SPLITCHARS, 3);
if (args.Length == 3)
{
if (!string.IsNullOrWhiteSpace(args[2]))
msg.Endpoint = args[2];
}
return msg;
}
static void Disconnect()
{
DisconnectMessage disconnectMessage = new DisconnectMessage()
{
SessionId = SessionId
};
SendMessage(JsonSerializer.Serialize(disconnectMessage));
StopReceiveDataThread();
IsConnecting = false;
IsConnected = false;
SessionId = string.Empty;
client.Close();
client = null;
}
internal override MqttMessage Decode(byte[] message)
{
DisconnectMessage disconnect = new DisconnectMessage();
int index = 0;
byte fixedHeader = message[index];
base.DecodeFixedHeader(fixedHeader);
int remainingLength = base.DecodeRemainingLength(message);
if (remainingLength != 0)
{
//fault
}
return(disconnect);
}
public void Disconnect(DisconnectReason reason, string description)
{
if (reason == DisconnectReason.ByApplication)
{
var message = new DisconnectMessage(reason, description);
this.TrySendMessage(message);
}
try {
this.socket.Disconnect(true);
this.socket.Dispose();
} catch {
// ignored
}
this.Disconnected?.Invoke(this, EventArgs.Empty);
}
public void StopStream(Exception exception, IDisconnectMessage disconnectMessage = null)
{
lock (_lockStream)
{
StopStreamAndUnsubscribeFromEvents();
if (exception is ITwitterTimeoutException && disconnectMessage == null)
{
disconnectMessage = new DisconnectMessage
{
Code = 503,
Reason = "Timeout"
};
}
var streamExceptionEventArgs = new StreamExceptionEventArgs(exception, disconnectMessage);
this.Raise(StreamStopped, streamExceptionEventArgs);
}
}
public void DisconnectAllPlayers()
{
foreach (var connection in ManagerPlayer.Instance.GetPlayers())
{
var message = new DisconnectMessage()
{
Message = "Server stopping",
PlayerId = connection.Value.Player.Id
};
message.SetDestinataires(new List <NetConnection>()
{
connection.Value.Connection
});
ManagerNetwork.Instance.Disconnect(message);
//connection.Value.Connection.Deny("Server stopped !");
}
_connections.Clear();
ManagerPlayer.Instance.Clear();
}
public void Disconnect(DisconnectReason reason, string description)
{
if (reason == DisconnectReason.ByApplication)
{
var message = new DisconnectMessage(reason, description);
TrySendMessage(message);
}
try
{
_socket.Disconnect(true);
_socket.Dispose();
}
catch { }
if (Disconnected != null)
{
Disconnected(this, EventArgs.Empty);
}
}
/// <summary>
/// The announcement server runs on port 22024/udp and is used to... server announcements to among us players.
/// </summary>
/// <param name="master">The plugin's main.</param>
/// <param name="configFolder">The configuration folder, to store the message identifiers.</param>
public AnnouncementServer(Class master, string configFolder)
{
this.Listener = new UdpConnectionListener(new IPEndPoint(IPAddress.Any, 22024));
this.Listener.Start();
this.Listener.NewConnection += Listener_NewConnection;
this.Master = master;
this.Message = MessageWriter.Get(SendOption.Reliable);
this.DisconnectMessage = MessageWriter.Get(SendOption.Reliable);
DisconnectMessage.Write((byte)09);
this.ConfigPath = Path.Combine(configFolder, "announcement.id");
this.ReadBuffer = new byte[4];
if (!File.Exists(ConfigPath))
{
IdStream = File.Create(ConfigPath);
IdStream.Write(GetInt(0), 0, 4);
}
else
{
IdStream = File.Open(ConfigPath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
}
}
public void Disconnect(DisconnectReason reason = DisconnectReason.ByApplication, string description = "Connection terminated by the server.")
{
if (reason == DisconnectReason.ByApplication)
{
var message = new DisconnectMessage(reason, description);
TrySendMessage(message);
}
try
{
_socket.Shutdown(SocketShutdown.Both);
_socket.Close();
_socket.Dispose();
}
catch { }
if (Disconnected != null)
{
Disconnected(this, EventArgs.Empty);
}
}
protected void OnDisconnect(NetworkConnection connection, DisconnectMessage message)
{
//How to handle disconnections?
if (gamePhase == GamePhase.LOBBY)
{
try {
players.Remove(connection);
}
catch (KeyNotFoundException) {}
try {
viewers.Remove(connection);
}
catch (KeyNotFoundException) {}
SendLobbyUpdate();
}
else
{
Debug.LogWarning("Disconnections after the lobby phase aren't handled");
}
}
public override void OnClose()
{
if (hashId != null)
{
var curGame = Games.FirstOrDefault(g => g.ParticipantsHashId.Contains(hashId));
if (curGame != null)
{
if (curGame.HostHashId == hashId)
{
Games.Remove(curGame);
}
else
{
var gameService = new GameService(_token);
var disconnectMessage = new DisconnectMessage()
{
GameHashId = curGame.HashId
};
gameService.DisconnectOfGame(disconnectMessage);
dynamic leaveMessage = new JObject();
leaveMessage.user_id = hashId;
leaveMessage.match_id = curGame.HashId;
leaveMessage.event_type = 0;
foreach (var playerId in curGame.ParticipantsHashId)
{
clientUser[playerId].Send(leaveMessage.ToString());
}
}
}
if (hashId != null)
{
clientUser.Remove(hashId);
}
}
Clients.Remove(this);
}
private void OnConnectQueryMessageRsp(IMessage msg, NetConnection conn)
{
var queryMsg = (QueryConnectMessageRsp)msg;
if (queryMsg.ConnectionType != QueryConnectMessageRsp.ServerType)
{
var disMsg = new DisconnectMessage();
server.SendMessage(disMsg, conn);
}
else
{
string name = "TestServerName";
string ip = "127.0.0.1";
string info = "ext info";
var connMsg = new ConnectMessage()
{
Address = ip,
ConnectName = name,
Information = info,
};
server.SendMessage(connMsg, conn);
}
}
private void Disconnect(DisconnectMessage message)
{
Logger.LogDebug($"subscriberId={message.Id} disconnect message received");
if (!_subscribers.ContainsKey(message.Id))
{
return;
}
try
{
var subscriber = _subscribers[message.Id];
_subscribers.Remove(message.Id);
subscriber.Resource.Tell(message);
Logger.LogDebug(
$"subscriberId={message.Id} removed from UpdateDispatcherActor and stream disconnected; subscribersCount={_subscribers.Count}");
}
catch (Exception ex)
{
Logger.LogError($"failed removing/disconnecting subscriberId={message.Id}", ex);
}
}
public void TestHandleDisconnectNotStarted()
{
string uid = "uid";
string userName = "******";
CreateExistingGame();
JoinGame(uid, userName, ExistingGameName);
MessagePackets messages = gm.HandleDisconnect(uid);
List <Player> players = gm.GetPlayers();
Assert.AreEqual(players.Count, 1);
CollectionAssert.DoesNotContain(players.Select(p => p.Uid).ToList(), uid);
Assert.IsFalse(gm.HasEnded());
Assert.IsTrue(Utils.VerifyMessagePackets(messages, typeof(DisconnectMessage)));
DisconnectMessage d = (DisconnectMessage)messages.Messages[0].Message;
Assert.AreEqual(messages.Messages[0].SendTo.Count(), 1);
Assert.AreEqual(messages.Messages[0].SendTo.Single(), ExistingUid);
Assert.AreEqual(d.PlayerName, userName);
Assert.IsFalse(d.ShouldDisableGame);
}
protected void Connection_Disconnect(Connection Sender, DisconnectMessage Message)
{
// On disconnect, make sure we're invoked on the UI thread
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke((Action <Connection, DisconnectMessage>)Connection_Disconnect, Sender, Message);
}
else
{
Connection.Disconnect -= Connection_Disconnect;
// Close all windows unless they're the tray icon
foreach (Window w in Windows)
{
if (w != MainWindow)
{
if (!w.Dispatcher.CheckAccess())
{
w.Dispatcher.Invoke((Action)w.Close);
}
else
{
w.Close();
}
}
}
// Only hide the tray icon, not close
MainWindow.Hide();
// Show the disconnection message
MessageBox.Show("Lost connection to the server. Will continue trying to connect in the background.");
// Restart the connection task
NetTask = Task.Factory.StartNew(NetHandler);
}
}
/// <summary>Called on the client upon disconnecting from a host</summary>
/// <remarks>
/// Some memory and ports are freed here.
/// </remarks>
/// <param name="message"></param>
private void OnClientDisconnect(NetworkConnection conn, DisconnectMessage message)
{
if (baseClient != null) baseClient.EndSession(hostBridgeEndPoint);
}
private void OnConnectionChanged(Codes code, Exception error, string text)
{
try
{
Message message;
if (error == null)
{
switch (code)
{
case Codes.DllConnected:
case Codes.QuikConnected:
try
{
bool isAlive;
try
{
isAlive = IsConnectionAlive();
}
catch
{
isAlive = false;
}
GetTerminal().AssignProcess();
message = new ConnectMessage
{
Error = isAlive ? null : new ApiException(code, LocalizedStrings.Str1837)
};
}
catch (Exception ex)
{
message = new ConnectMessage {
Error = ex
};
}
break;
case Codes.DllDisconnected:
message = new DisconnectMessage();
break;
case Codes.QuikDisconnected:
message = new ConnectMessage {
Error = new ApiException(code, text)
};
break;
default:
message = new ConnectMessage
{
Error = new InvalidOperationException(LocalizedStrings.Str1838Params.Put(code))
};
break;
}
}
else
{
message = new ConnectMessage {
Error = error
};
}
SendOutMessage(message);
}
catch (Exception ex)
{
SendOutError(ex);
}
}
public void DisconnectMessageConstructorTest()
{
DisconnectMessage target = new DisconnectMessage();
Assert.Inconclusive("TODO: Implement code to verify target");
}
protected override void SetupData()
{
base.SetupData();
_disconnectMessage = new DisconnectMessage(DisconnectReason.ServiceNotAvailable, "Not today!");
}
private void OnClientDisconnect(NetworkConnection connection, DisconnectMessage message)
{
Debug.Log("Disconnected");
}
protected virtual void SetupData()
{
Random = new Random();
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, 8122);
ConnectionInfo = new ConnectionInfo(
_serverEndPoint.Address.ToString(),
_serverEndPoint.Port,
"user",
new PasswordAuthenticationMethod("user", "password"))
{
Timeout = TimeSpan.FromSeconds(20)
};
_keyExchangeAlgorithm = Random.Next().ToString(CultureInfo.InvariantCulture);
SessionId = new byte[10];
Random.NextBytes(SessionId);
DisconnectedRegister = new List <EventArgs>();
DisconnectReceivedRegister = new List <MessageEventArgs <DisconnectMessage> >();
ErrorOccurredRegister = new List <ExceptionEventArgs>();
ServerBytesReceivedRegister = new List <byte[]>();
ServerIdentification = new SshIdentification("2.0", "OurServerStub");
_authenticationStarted = false;
_disconnectMessage = new DisconnectMessage(DisconnectReason.ServiceNotAvailable, "Not today!");
_socketFactory = new SocketFactory();
Session = new Session(ConnectionInfo, _serviceFactoryMock.Object, _socketFactoryMock.Object);
Session.Disconnected += (sender, args) => DisconnectedRegister.Add(args);
Session.DisconnectReceived += (sender, args) => DisconnectReceivedRegister.Add(args);
Session.ErrorOccured += (sender, args) => ErrorOccurredRegister.Add(args);
Session.KeyExchangeInitReceived += (sender, args) =>
{
var newKeysMessage = new NewKeysMessage();
var newKeys = newKeysMessage.GetPacket(8, null);
ServerSocket.Send(newKeys, 4, newKeys.Length - 4, SocketFlags.None);
};
ServerListener = new AsyncSocketListener(_serverEndPoint);
ServerListener.Connected += socket =>
{
ServerSocket = socket;
// Since we're mocking the protocol version exchange, we'll immediately stat KEX upon
// having established the connection instead of when the client has been identified
var keyExchangeInitMessage = new KeyExchangeInitMessage
{
CompressionAlgorithmsClientToServer = new string[0],
CompressionAlgorithmsServerToClient = new string[0],
EncryptionAlgorithmsClientToServer = new string[0],
EncryptionAlgorithmsServerToClient = new string[0],
KeyExchangeAlgorithms = new[] { _keyExchangeAlgorithm },
LanguagesClientToServer = new string[0],
LanguagesServerToClient = new string[0],
MacAlgorithmsClientToServer = new string[0],
MacAlgorithmsServerToClient = new string[0],
ServerHostKeyAlgorithms = new string[0]
};
var keyExchangeInit = keyExchangeInitMessage.GetPacket(8, null);
ServerSocket.Send(keyExchangeInit, 4, keyExchangeInit.Length - 4, SocketFlags.None);
};
ServerListener.BytesReceived += (received, socket) =>
{
ServerBytesReceivedRegister.Add(received);
if (!_authenticationStarted)
{
var serviceAcceptMessage = ServiceAcceptMessageBuilder.Create(ServiceName.UserAuthentication).Build();
ServerSocket.Send(serviceAcceptMessage, 0, serviceAcceptMessage.Length, SocketFlags.None);
_authenticationStarted = true;
}
};
ServerListener.Start();
ClientSocket = new DirectConnector(_socketFactory).Connect(ConnectionInfo);
}
/// <summary>Called on the server when a client disconnects</summary>
/// <remarks>
/// Some memory and ports are freed here.
/// </remarks>
/// <param name="message"></param>
static private void OnServerDisconnect(NetworkConnection conn, DisconnectMessage message)
{
OnServerDisconnect(conn);
}
protected override void Arrange()
{
_disconnectMessage = new DisconnectMessage(DisconnectReason.ServiceNotAvailable, "Not today!");
base.Arrange();
}
public override void HandleMessage(BaseMessage message)
{
DisconnectMessage msg = (DisconnectMessage)message;
}
public async Task DisconnectAsync()
{
DisconnectMessage msg = new DisconnectMessage();
await channel.SendAsync(msg.Encode());
}
private void ProcessInnerAdapterDisconnectMessage(IMessageAdapter innerAdapter, DisconnectMessage message)
{
if (message.Error != null)
{
SessionHolder.AddErrorLog(LocalizedStrings.Str627Params, innerAdapter.GetType().Name, message.Error);
}
Exception error = null;
var canProcess = _innerAdapters.SyncGet(c =>
{
_adapterStates[innerAdapter] = new RefPair <bool, Exception>(false, message.Error);
if (_canRaiseDisconnected && _adapterStates.Values.All(p => !p.First))
{
_canRaiseConnected = true;
_canRaiseDisconnected = false;
var errors = _adapterStates.Values.Where(p => p.Second != null).Select(p => p.Second).ToArray();
if (errors.Length != 0)
{
error = new AggregateException(LocalizedStrings.Str628, errors);
ResetConnectionErrors();
}
DisposeInnerAdapters();
return(true);
}
return(false);
});
if (canProcess)
{
SendOutMessage(new DisconnectMessage {
Error = error
});
}
}
public void ChatDisconnect()
{
DisconnectMessage msg = new DisconnectMessage();
//jcm.nickname = ServiceLocator.Get<LoginViewModel>().Nickname;
chatReceiver.SendToServiceAsync(msg);
}
private void HandleMessage(DisconnectMessage message)
{
Disconnect(message.ReasonCode, message.Description);
}
private void CheckMessageType(string data)
{
try
{
Tweet tweet = JsonUtility.FromJson <Tweet>(data);
if (tweet.text != null && tweet.id_str != null)
{
messageType = StreamMessageType.Tweet;
return;
}
StreamEvent streamEvent = JsonUtility.FromJson <StreamEvent>(data);
if (streamEvent.event_name != null)
{
messageType = StreamMessageType.StreamEvent;
return;
}
FriendsList friendsList = JsonUtility.FromJson <FriendsList>(data);
if (friendsList.friends != null)
{
messageType = StreamMessageType.FriendsList;
return;
}
DirectMessage directMessage = JsonUtility.FromJson <DirectMessage>(data);
if (directMessage.recipient_screen_name != null)
{
messageType = StreamMessageType.DirectMessage;
return;
}
StatusDeletionNotice statusDeletionNotice = JsonUtility.FromJson <StatusDeletionNotice>(data);
if (statusDeletionNotice.delete != null)
{
messageType = StreamMessageType.StatusDeletionNotice;
return;
}
LocationDeletionNotice locationDeletionNotice = JsonUtility.FromJson <LocationDeletionNotice>(data);
if (locationDeletionNotice.scrub_geo != null)
{
messageType = StreamMessageType.LocationDeletionNotice;
return;
}
LimitNotice limitNotice = JsonUtility.FromJson <LimitNotice>(data);
if (limitNotice.limit != null)
{
messageType = StreamMessageType.LimitNotice;
return;
}
WithheldContentNotice withheldContentNotice = JsonUtility.FromJson <WithheldContentNotice>(data);
if (withheldContentNotice.status_withheld != null || withheldContentNotice.user_withheld != null)
{
messageType = StreamMessageType.WithheldContentNotice;
return;
}
DisconnectMessage disconnectMessage = JsonUtility.FromJson <DisconnectMessage>(data);
if (disconnectMessage.disconnect != null)
{
messageType = StreamMessageType.DisconnectMessage;
return;
}
StallWarning stallWarning = JsonUtility.FromJson <StallWarning>(data);
if (stallWarning.warning != null)
{
messageType = StreamMessageType.StallWarning;
return;
}
messageType = StreamMessageType.None;
return;
} catch (System.Exception e)
{
// Debug.Log("CheckMessageType Error : " + data); // I'm sick of these messages
messageType = StreamMessageType.None;
return;
}
}
protected void OnDisconnect(NetworkConnection connection, DisconnectMessage message) {
Debug.LogWarning("Lost connection");
}
public static void HandleRequestLoadHomePage(INetworkService service, Client.BaseMessage message)
{
var data = (RequestLoadHomePage)message;
if (data.BuildId != Program.BUILD_ID)
{
var disconnect = new DisconnectMessage(DisconnectMessage.DisconnectReason.OldVersion);
service.SendMessage(disconnect);
return;
}
var userData = PlayerManager.GetUserData(data.Username);
var password = userData?.PasswordMd5;
if (userData == null || password == null || !Crypto.VerifyPassword(password, data.PasswordEncrypted))
{
var disconnect = new DisconnectMessage(DisconnectMessage.DisconnectReason.InvalidUsernameOrPassword);
service.SendMessage(disconnect);
return;
}
var homePage = new LoadHomePageMessage(false);
service.UserData = userData;
var userStats = new UserStatisticsMessage(userData.UserStatistics);
var settingsInfo = new SettingsInformationMessage(userData.UserSettings);
var selectionSettings = new SelectionSettingsMessage(userData.UserSelections);
var userInformation = new UserInformationMessage(
userData.UserName,
userData.TownPoints,
userData.MeritPoints
);
var currencyMultiplier = new CurrencyMultiplierMessage(
userData.TownPointsMultiplier,
userData.MeritPointsMultiplier
);
var activeSpecialEvents = new ActiveSpecialEventsMessage(new List <SpecialEvent>());
var lastBonusWinTime = new LastBonusWinTimeMessage(userData.LastBonusWinTime);
var earnedAchievements = new EarnedAchievementsMessage(userData.EarnedAchievements);
var purchasedCharacters = new PurchasedCharactersMessage(userData.PurchasedCharacters);
var purchasedHouses = new PurchasedHousesMessage(userData.PurchasedHouses);
var purchasedBackgrounds = new PurchasedBackgroundsMessage(userData.PurchasedBackgrounds);
var purchasedPets = new PurchasedPetsMessage(userData.PurchasedPets);
var friendIds = userData.FriendIds;
var friendList = new List <Friend>();
foreach (var friendId in friendIds)
{
var friendData = PlayerManager.GetUserData(friendId);
if (friendData == null) // ?
{
continue;
}
var friendClient = Program.AllConnectedClients.FirstOrDefault(x => x.UserData.UserId == friendData.UserId);
var friend = new Friend
{
AccountId = friendData.UserId,
OwnsCoven = friendData.UserAccountFlags.OwnsCoven,
Status = friendClient?.Status ?? ActivityStatus.Offline,
UserName = friendData.UserName
};
friendList.Add(friend);
}
var friendListPacket = new FriendListMessage(friendList);
var purchasedLobbyIcons = new PurchasedLobbyIconsMessage(userData.PurchasedLobbyIcons);
var purchasedDeathAnimations = new PurchasedDeathAnimationsMessage(userData.PurchasedDeathAnimations);
var purchasedScrolls = new PurchasedScrollsMessage(userData.PurchasedScrolls);
var tutorialStatus = new TutorialStatusMessage(userData.TutorialStatus);
var activeGameModes = new ActiveGameModesMessage(new[] { 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 18, 19 });
var serverFlags = new ServerFlagsMessage(true);
var accountFlags = new AccountFlagsMessage(userData.UserAccountFlags);
var rankedInfo = new RankedInfoUpdateMessage(userData.RankedInformation);
service.SendMessage(homePage);
service.SendMultipleMessages(userStats, settingsInfo, selectionSettings, userInformation,
currencyMultiplier, activeSpecialEvents, lastBonusWinTime, earnedAchievements, purchasedCharacters,
purchasedHouses, purchasedBackgrounds, purchasedPets, friendListPacket, purchasedLobbyIcons,
purchasedDeathAnimations, purchasedScrolls, tutorialStatus, activeGameModes, serverFlags, accountFlags,
rankedInfo);
Thread.Sleep(1000);
service.SendMessage(new ReturnToHomeMessage());
}
private Task Disconnect(DisconnectMessage msg)
{
Logger.LogDebug($"resourceActorId={Id} Disconnection message raised for {msg.Id}");
return(Consumer.OnStreamDisconnected());
}
private void OnConnectQueryMessageRsp(IMessage msg, NetConnection conn)
{
var queryMsg = (QueryConnectMessageRsp)msg;
if (queryMsg.ConnectionType != QueryConnectMessageRsp.ServerType)
{
var disMsg = new DisconnectMessage();
server.SendMessage(disMsg, conn);
}
else
{
string name = "TestServerName";
string ip = "127.0.0.1";
string info = "ext info";
var connMsg = new ConnectMessage()
{
Address = ip,
ConnectName = name,
Information = info,
};
server.SendMessage(connMsg, conn);
}
}
