internal static void ProcessEncryptionRequest(Habbo sender, IncomingMessage message)
{
new MSetupEncryption
{
UnknownA = false
}.Send(sender);
}
private List<FriendUpdate> fUpdateList; // The updates to send next time SendUpdates() is called.
#endregion Fields
#region Constructors
/// <summary>
/// Constructs a new Messenger.
/// </summary>
/// <param name="User">The user who's messenger to manage.</param>
/// <param name="BlockFlags">Not done yet</param>
internal Messenger(Habbo User, byte BlockFlags)
{
this.fHabbo = User;
this.fBlockFlags = BlockFlags; // TODO: Add BlockFlags
this.fUpdateList = new List<FriendUpdate>(); // Prepare to store update data.
}
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);
}
internal static void ProcessPong(Habbo sender, IncomingMessage message)
{
HabboEventArgs eventArgs = new HabboEventArgs(sender);
R36StandardStuff.EventFirer.Fire("habbo_pong:before", eventArgs);
if (!eventArgs.IsCancelled)
R36StandardStuff.EventFirer.Fire("habbo_pong:after", eventArgs);
}
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);
}
internal static void ProcessCurrentDateRequest(Habbo sender, IncomingMessage message)
{
new MCurrentDate
{
Date = DateTime.Today
}.Send(sender);
}
public IEnumerable<Category> GetCategories(Habbo habbo)
{
CategoryHabboEventArgs eventArgs = new CategoryHabboEventArgs(habbo);
_pluginInstance.EventFirer.Fire(_pluginInstance.Id + ":habbo_category_request:before", eventArgs);
_pluginInstance.EventFirer.Fire(_pluginInstance.Id + ":habbo_category_request:after", eventArgs);
return eventArgs.GetCategories();
}
private static void ProcessRequestOwnRoomListing(Habbo sender, IncomingMessage message)
{
// TODO: Database tables for rooms.
new MOwnRoomListing
{
Rooms = null
}.Send(sender);
}
internal PacketProcessor(Habbo User)
{
this.fUser = User;
IonTcpConnection Connection = this.fUser.GetConnection();
Connection.AddHandler(196, PacketHandlerPriority.DefaultAction, new PacketHandler(Process_Pong));
Connection.AddHandler(512, PacketHandlerPriority.DefaultAction, new PacketHandler(Process_Disconnect));
}
/// <summary>
/// Checks if a given user has requested to be friends with this user.
/// </summary>
/// <returns>Returns true if a friend request exists, false otherwise.</returns>
public bool HasRequestFrom(Habbo User)
{
/*
using (DatabaseClient dbClient = Core.GetDatabaseManager().GetClient())
{
dbClient.AddParamWithValue("localuserid", this.fUser.GetID());
dbClient.AddParamWithValue("remoteuserid", User.GetID());
return dbClient.ReadExist("SELECT 0 FROM messenger_friendrequests WHERE (userid_to = @me AND userid_from = @them AND userid_to > 0 AND userid_from > 0) OR (userid_to = @them AND userid_from = @me AND userid_to > 0 AND userid_from > 0)");
}*/
return false;
}
private bool fWasLoggedIn; // Was the user logged in last Update()?
#endregion Fields
#region Constructors
/// <summary>
/// Construct a new Friend object.
/// </summary>
/// <param name="User">The User who is a Friend.</param>
/// <param name="LocalCategory">The category ID that this Friend appears in.</param>
/// <param name="RemoteCategory">The category ID that this Friend appears in for the friend.</param>
public Friend(Habbo Habbo, int LocalCategory, int RemoteCategory)
{
this.fHabbo = Habbo;
this.fLocalCategory = LocalCategory;
this.fRemoteCategory = RemoteCategory;
this.fWasLoggedIn = false;
this.fWasInRoom = false;
Update(); // Ensure the Friend object is up to date before use.
}
public Friend(Habbo Habbo, int? LocalCategory, int? RemoteCategory)
{
this.fHabbo = Habbo;
if (LocalCategory.HasValue)
this.fLocalCategory = LocalCategory.Value;
if (RemoteCategory.HasValue)
this.fRemoteCategory = RemoteCategory.Value;
this.fWasLoggedIn = false;
this.fWasInRoom = false;
}
private static void Process_RequestSubscriptionData(Habbo Sender, IncomingMessage Message)
{
string SubscriptionName = Message.PopPrefixedString();
SubscriptionData Data = new SubscriptionData(Sender, SubscriptionName);
// 86400 = 24 hours in seconds.
// 2678400 = 31 days in seconds.
byte RemainingFullMonths = (byte)(Data.GetRemainingSeconds() / 2678400);
byte ExpiredFullMonths = (byte)(Data.GetExpiredSeconds() / 2678400);
byte ExpiredMonthDays = (byte)((Data.GetExpiredSeconds() % 2678400) / 86400);
Sender.GetPacketSender().Send_SubscriptionInfo(SubscriptionName, ExpiredMonthDays, ExpiredFullMonths, RemainingFullMonths, Data.IsActive());
}
private void SafeInvoke(GameSocketMessageHandler handler, Habbo sender, IncomingMessage message)
{
try
{
handler(sender, message);
}
catch (Exception e)
{
sender.Socket.Disconnect("Unhandled Exception in packet handler");
string dumpPath = CoreManager.ServerCore.DumpException(e);
CoreManager.ServerCore.ConsoleManager.Error("Event Handler", "An unhandled exception from a packet handler has been caught and the socket has been closed!");
CoreManager.ServerCore.ConsoleManager.Error("Event Handler", " An exception dump has been saved to " + dumpPath);
}
}
internal static void ProcessAccountDetailsRequest(Habbo sender, IncomingMessage message)
{
new MAccountDetails
{
ConnectionId = 0,
Username = sender.Username, // Should this be DisplayName
Motto = sender.Motto,
Figure = sender.Figure,
UnknownA = "",
UnknownB = 12,
UnknownC = 0,
UnknownD = 1
}.Send(sender);
}
internal static void ProcessMessengerInit(Habbo sender, IncomingMessage message)
{
MessengerManager manager = CoreManager.ServerCore.GetMessengerManager();
new MMessengerInit
{
BefriendablesToExclude = new HashSet<Befriendable>
{
manager.GetBefriendable(sender)
},
Categories = manager.GetCategories(sender),
MaximumFriends = 200, // TODO: Make this controllable by plugins.
UnknownA = 10,
UnknownB = 20,
UnknownC = 30,
UnknownD = false
}.Send(sender);
}
public MessengerObject(Habbo owner)
{
_categories = new Dictionary<int, Category>();
_friends = new Dictionary<int, Friend>();
_friendRequests = new Dictionary<int, IBefriendable>();
Owner = owner;
// TODO: Fix at later date
/*
if (Owner.GetPersistantVariable("Messenger.StalkBlock") != null)
Owner.BlockStalking = true;
if (Owner.GetPersistantVariable("Messenger.RequestBlock") != null)
Owner.BlockRequests = true;
if (Owner.GetPersistantVariable("Messenger.InviteBlock") != null)
Owner.BlockInvites = true;
*/
}
public Befriendable GetBefriendable(Habbo habbo)
{
Befriendable befriendableInstance = habbo.InstanceStorage[_pluginInstance, "befriendable_instance"];
if (befriendableInstance == null)
{
befriendableInstance = new Befriendable(
(() => habbo.Id),
(() => habbo.DisplayName),
(() => habbo.Motto),
(() => habbo.Figure),
(() => habbo.Position),
(() => habbo.LoggedIn),
(() => habbo.LastAccess));
habbo.InstanceStorage[_pluginInstance, "befriendable_instance"] = befriendableInstance;
}
return befriendableInstance;
}
public GameSocketMessageHandlers Invoke(Habbo sender, IncomingMessage message)
{
if (HighPriority != null)
SafeInvoke(HighPriority, sender, message);
if (message.Cancelled)
return this;
if (LowPriority != null)
SafeInvoke(LowPriority, sender, message);
if (message.Cancelled)
return this;
if (DefaultAction != null)
SafeInvoke(DefaultAction, sender, message);
if (Watcher != null)
SafeInvoke(Watcher, sender, message);
return this;
}
// TODO: Check if it is worth adding an ID-Username cache.
#endregion
#region Methods
#region Exposed Methods
/// <summary>
/// Return a Habbo from the cache if possible.
/// If the Habbo is not cached then put it in the cache and return it.
/// </summary>
/// <param name = "username">The username of the Habbo to return.</param>
public Habbo GetHabbo(string username)
{
lock (this)
{
// Is the ID cached for this username (and therefore the Habbo)?
if (_usernameIDCache.ContainsKey(username))
{
// Yes, get the cached Habbo.
Habbo cached = _habboCache[_usernameIDCache[username]].Target as Habbo;
// Has the cached Habbo been collected and removed from memory?
if (cached != null)
{
// No, return the cached copy.
return(cached);
}
// The cached Habbo has been collected and is no longer in memory...
// Remove the WeakReference to the cached Habbo.
_habboCache.Remove(_usernameIDCache[username]);
// Remove the cached Username and ID.
_usernameIDCache.Remove(username);
}
// Load the Habbo into memory from the database.
Habbo theHabbo = new Habbo(username);
// Yes, cache it.
CacheHabbo(theHabbo);
// Return the newly cached Habbo.
return(theHabbo);
}
}
/// <summary>
/// Return a Habbo from the cache if possible.
/// If the Habbo is not cached then put it in the cache and return it.
/// </summary>
/// <param name = "username">The username of the Habbo to return.</param>
public Habbo GetHabbo(string username)
{
lock (this)
{
// Is the ID cached for this username (and therefore the Habbo)?
if (_usernameIDCache.ContainsKey(username))
{
// Yes, get the cached Habbo.
Habbo cached = _habboCache[_usernameIDCache[username]].Target as Habbo;
// Has the cached Habbo been collected and removed from memory?
if (cached != null)
// No, return the cached copy.
return cached;
// The cached Habbo has been collected and is no longer in memory...
// Remove the WeakReference to the cached Habbo.
_habboCache.Remove(_usernameIDCache[username]);
// Remove the cached Username and ID.
_usernameIDCache.Remove(username);
}
// Load the Habbo into memory from the database.
Habbo theHabbo = new Habbo(username);
// Yes, cache it.
CacheHabbo(theHabbo);
// Return the newly cached Habbo.
return theHabbo;
}
}
/// <summary>
/// Add a Habbo into the cache.
/// </summary>
/// <param name = "theHabbo">The Habbo to cache.</param>
private void CacheHabbo(Habbo theHabbo)
{
lock (this)
{
// Cache the Habbo.
_habboCache.Add(theHabbo.GetID(), new WeakReference(theHabbo));
// Cache the Username-ID.
_usernameIDCache.Add(theHabbo.GetUsername(), theHabbo.GetID());
}
}
/// <summary>
/// Return a Habbo from the cache if possible.
/// If the Habbo is not cached then put it in the cache and return it.
/// FYI: If the Habbo is not cached then this the Habbo will be created from the data provided.
/// </summary>
/// <param name = "habbo">The database result of the Habbo to return.</param>
public Habbo GetHabbo(Database.Habbo habbo)
{
lock (this)
{
// Is this Habbo already cached?
if (_habboCache.ContainsKey(habbo.habbo_id))
{
// Yes, get the cached Habbo.
Habbo cached = _habboCache[habbo.habbo_id].Target as Habbo;
// Has the cached Habbo been collected and removed from memory?
if (cached != null)
// No, return the cached copy.
return cached;
// Yes, we may as well do a full clean up here. We'll have to loop over it all anyway.
CleanUp(true);
}
// Load the Habbo into memory from the database.
Habbo theHabbo = new Habbo(habbo);
// Yes, cache it.
CacheHabbo(theHabbo);
// Return the newly cached Habbo.
return theHabbo;
}
}
public HabboEventArgs(Habbo habbo)
{
Habbo = habbo;
}
/// <summary>
/// Starts the Connection, prepares the received data buffer and waits for data.
/// </summary>
internal void Start()
{
_dataBuffer = new byte[ReceivedataBufferSize];
_dataReceivedCallback = new AsyncCallback(DataReceived);
_routeReceivedDataCallback = new RouteReceivedDataCallback(HandleConnectionData);
Habbo = new Habbo(this);
WaitForData();
}
public SubscriptionData(Habbo habbo, string type)
{
Subscriber = habbo;
Type = type;
}
private void Process_DYNAMIC(Habbo Sender, IncomingMessage Message)
{
lock (this.fPacketLogs)
{
this.fPacketLogs.
Append("<div class='packet'>").
Append('[').
Append(Message.GetID()).
Append("] <u>").
Append(Message.GetHeader()).
Append("</u>").
Append(Message.GetContentString()).
Append("</div>");
}
}
private static void ProcessRequestUsableCategoryListing(Habbo sender, IncomingMessage message)
{
// TODO: Permissions
LibNav.Navigator navigator = CoreManager.ServerCore.GetNavigator();
new MUsableGuestCategoryListing
{
Categories = navigator.GetChildren(navigator.GuestRoot, NavigatorTreeSearchMode.GuestOnly)
}.Send(sender);
}
private static void ProcessRequestRecommendedRoomListing(Habbo sender, IncomingMessage message)
{
// TODO: Recommended Room API methods
new MRecommendedRoomListing
{
RoomListings = new GuestRoomListing[0] // No recommended rooms for now.
}.Send(sender);
}
internal static void ProcessGroupStatusInit(Habbo sender, IncomingMessage message)
{
// Load group stuff
}
public void LoginMerge(Habbo loggedInUser)
{
_connection = loggedInUser._connection;
_connection.Habbo = this;
}
public GameSocketMessageHandlerInvoker Invoke(Habbo sender, IncomingMessage message)
{
lock (_handlers)
{
// Are there any handlers registered for this packet?
if (!_handlers.ContainsKey(message.HeaderId))
{
CoreManager.ServerCore.ConsoleManager.Warning("Game Socket Manager", "Unhandled HeaderID " + message.HeaderId + " (\"" + message.HeaderString + "\")");
// No, do nothing.
return this;
}
// Yes, let's invoke them.
_handlers[message.HeaderId].Invoke(sender, message);
}
return this;
}
