private static void AlertRoom(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
Session.SendData(NotificationMessageComposer.Compose("Could not send room alert."));
return;
}
int Unknown1 = Message.PopWiredInt32();
int AlertMode = Message.PopWiredInt32();
string AlertMessage = Message.PopString();
bool IsCaution = AlertMode != 3;
Instance.SendModerationAlert(AlertMessage, IsCaution);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationLogs.LogModerationAction(MySqlClient, Session, "Sent room " + (IsCaution ? "caution" : "message"),
"Room " + Instance.Info.Name + " (ID " + Instance.RoomId + "): '" + AlertMessage + "'");
}
}
private static void BanUser(Session Session, ClientMessage Message)
{
if (!Session.HasRight("moderation_tool"))
{
return;
}
uint UserId = Message.PopWiredUInt32();
string MessageText = Message.PopString();
double Length = (Message.PopWiredInt32() * 3600);
Session TargetSession = SessionManager.GetSessionByCharacterId(UserId);
if (TargetSession == null || TargetSession.HasRight("moderation_tool"))
{
Session.SendData(NotificationMessageComposer.Compose("This user is not online or you do not have permission to ban them.\nPlease use housekeeping to ban users that are offline."));
return;
}
SessionManager.StopSession(TargetSession.Id);
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
ModerationBanManager.BanUser(MySqlClient, UserId, MessageText, Session.CharacterId, Length);
ModerationLogs.LogModerationAction(MySqlClient, Session, "Banned user",
"User '" + TargetSession.CharacterInfo.Username + "' (ID " + TargetSession.CharacterId + ") for " +
Length + " hours: '" + MessageText + "'");
}
}
private static void DeleteSticky(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Instance.GetItem(Message.PopWiredUInt32());
if (Item == null || Item.Definition.Behavior != ItemBehavior.StickyNote)
{
return;
}
if (Instance.TakeItem(Item.Id))
{
Instance.RegenerateRelativeHeightmap();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
Item.RemovePermanently(MySqlClient);
}
}
}
private static void SubmitAnswer(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
int AnswerId = Message.PopWiredInt32();
lock (mInfobusQuestions)
{
if (mInfobusQuestions.ContainsKey(Instance.RoomId))
{
mInfobusQuestions[Instance.RoomId].SubmitAnswer(Actor.Id, AnswerId);
}
}
}
private static void ApplyEffect(Session Session, ClientMessage Message)
{
int EffectSpriteId = Message.PopWiredInt32();
if (EffectSpriteId < 0)
{
EffectSpriteId = 0;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null || (EffectSpriteId != 0 && !Session.AvatarEffectCache.HasEffect(EffectSpriteId, true)))
{
return;
}
Actor.ApplyEffect(EffectSpriteId);
Session.CurrentEffect = EffectSpriteId;
}
private static void OnSessionLatencyTest(Session Session, ClientMessage Message)
{
// Sesion timer sends a number to the server and expects it right back.
// Maybe something to do with latency testing... or a keepalive?
// Seems like a waste of bandwith since we're using pinging
Session.SendData(LatencyTestResponseComposer.Compose(Message.PopWiredInt32()));
}
private static void InitCrypto(Session Session, ClientMessage Message)
{
if (Session.Authenticated)
{
return;
}
Session.SendData(SessionParamsComposer.Compose());
}
private static void SsoLogin(Session Session, ClientMessage Message)
{
if (Session.Authenticated)
{
return;
}
string Ticket = UserInputFilter.FilterString(Message.PopString());
Session.TryAuthenticate(Ticket, Session.RemoteAddress.ToString());
}
private static void OnUserAgent(Session Session, ClientMessage Message)
{
string UserAgent = Message.PopString();
if (UserAgent.Length > 2000)
{
UserAgent = UserAgent.Substring(0, 2000);
}
Session.UserAgent = UserAgent;
}
private static void TradeComplete(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Trade Trade = Instance.TradeManager.GetTradeForUser(Session.CharacterId);
if (Trade == null)
{
return;
}
Session TargetSession = SessionManager.GetSessionByCharacterId(Trade.UserOne == Session.CharacterId ?
Trade.UserTwo : Trade.UserOne);
if (TargetSession == null || !Trade.AcceptTrade(Trade.UserOne == Session.CharacterId))
{
return;
}
if (Trade.TradeStage == TradeStage.Finalized)
{
Session User1 = (TargetSession.CharacterId == Trade.UserOne ? TargetSession : Session);
Session User2 = (TargetSession.CharacterId == Trade.UserTwo ? TargetSession : Session);
Trade.DeliverItems(User1, User2);
Session.SendData(TradeFinalizedComposer.Compose());
TargetSession.SendData(TradeFinalizedComposer.Compose());
Instance.TradeManager.StopTradeForUser(Session.CharacterId);
Instance.TradeManager.StopTradeForUser(TargetSession.CharacterId);
RoomActor Actor1 = Instance.GetActorByReferenceId(Session.CharacterId);
RoomActor Actor2 = Instance.GetActorByReferenceId(TargetSession.CharacterId);
if (Actor1 != null)
{
Actor1.RemoveStatus("trd");
Actor1.UpdateNeeded = true;
}
if (Actor2 != null)
{
Actor2.RemoveStatus("trd");
Actor2.UpdateNeeded = true;
}
}
}
private static void ActivateEffect(Session Session, ClientMessage Message)
{
AvatarEffect Effect = Session.AvatarEffectCache.GetEffect(Message.PopWiredInt32(), false, true);
// If we do not have an effect that needs activating OR if we already have an effect
// of this sort which IS activated, stop.
if (Effect == null || Session.AvatarEffectCache.HasEffect(Effect.SpriteId, true))
{
return;
}
Effect.Activate();
Session.SendData(UserEffectActivatedComposer.Compose(Effect));
}
private static void GetIgnoredUsers(Session Session, ClientMessage Message)
{
ReadOnlyCollection<uint> IgnoredUsers = Session.IgnoreCache.List;
List<string> Names = new List<string>();
foreach (uint IgnoredUser in IgnoredUsers)
{
string Name = CharacterResolverCache.GetNameFromUid(IgnoredUser);
if (Name != "Unknown User" && !Names.Contains(Name))
{
Names.Add(Name);
}
}
Session.SendData(IgnoredUserListComposer.Compose(Names));
}
private static void OnClientConfig(Session Session, ClientMessage Message)
{
int Volume = Message.PopWiredInt32();
bool Something = Message.PopWiredBoolean();
if (Volume < 0)
{
Volume = 0;
}
if (Volume > 100)
{
Volume = 100;
}
Session.CharacterInfo.ConfigVolume = Volume;
}
private static void GetMoodlightInfo(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null || !Instance.CheckUserRights(Session, true))
{
return;
}
Item Item = Instance.MoodlightItem;
if (Item == null)
{
return;
}
Session.SendData(MoodlightDataComposer.Compose(MoodlightData.GenerateFromFlags(Item.Flags)));
}
public static void HandleData(Session Session, ClientMessage Message)
{
if (Session == null || Session.Stopped || Message == null)
{
return;
}
if (!mCallbacks.ContainsKey(Message.Id))
{
Output.WriteLine("Unhandled packet: " + Message.Id + " (" + Constants.DefaultEncoding.GetString(Base64Encoding.EncodeUint32(Message.Id, 2)) + "), no suitable handler found.", OutputLevel.Warning);
return;
}
if (!Session.Authenticated && !mCallbacksWithoutAuthentication.Contains(Message.Id))
{
return;
}
mCallbacks[Message.Id].Invoke(Session, Message);
}
private static void TradeAccept(Session Session, ClientMessage Message)
{
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
Trade Trade = Instance.TradeManager.GetTradeForUser(Session.CharacterId);
if (Trade == null || !Trade.AcceptTrade(Trade.UserOne == Session.CharacterId))
{
return;
}
ServerMessage TradeAcceptState = TradeAcceptStateComposer.Compose(Session.CharacterId, true);
ServerMessage TradeFinalizing = (Trade.TradeStage == TradeStage.Finalizing ? TradeFinalizingComposer.Compose()
: null);
Session.SendData(TradeAcceptState);
if (TradeFinalizing != null)
{
Session.SendData(TradeFinalizing);
}
Session TargetSession = SessionManager.GetSessionByCharacterId(Trade.UserOne == Session.CharacterId ?
Trade.UserTwo : Trade.UserOne);
if (TargetSession != null)
{
TargetSession.SendData(TradeAcceptState);
if (TradeFinalizing != null)
{
TargetSession.SendData(TradeFinalizing);
}
}
}
private static ServerMessage TryGetResponseFromCache(uint GroupId, ClientMessage Request)
{
return (CacheEnabled ? mCacheController.TryGetResponse(GroupId, Request) : null);
}
private static void PerformSearch(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
Dictionary<uint, RoomInfo> Rooms = new Dictionary<uint, RoomInfo>();
string Query = UserInputFilter.FilterString(Message.PopString()).ToLower().Trim();
int SearchEventCatId = 0;
if (mEventSearchQueries.ContainsKey(Query.ToLower()))
{
SearchEventCatId = mEventSearchQueries[Query.ToLower()];
}
// Limit query length. just a precaution.
if (Query.Length > 64)
{
Query = Query.Substring(0, 64);
}
if (Query.Length > 0)
{
IEnumerable<RoomInstance> InstanceMatches =
(from RoomInstance in RoomManager.RoomInstances
where RoomInstance.Value.HumanActorCount > 0 &&
RoomInstance.Value.Info.Type == RoomType.Flat &&
(RoomInstance.Value.Info.OwnerName.StartsWith(Query) ||
RoomInstance.Value.SearchableTags.Contains(Query) ||
RoomInstance.Value.Info.Name.Contains(Query) ||
(RoomInstance.Value.HasOngoingEvent &&
(RoomInstance.Value.Event.Name.StartsWith(Query) ||
(SearchEventCatId > 0 && RoomInstance.Value.Event.CategoryId == SearchEventCatId))))
orderby RoomInstance.Value.HumanActorCount descending
select RoomInstance.Value).Take(50);
foreach (RoomInstance Instance in InstanceMatches)
{
Rooms.Add(Instance.RoomId, Instance.Info);
}
if (Rooms.Count < 50) // need db results?
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
MySqlClient.SetParameter("query", Query + "%");
MySqlClient.SetParameter("fquery", "%" + Query + "%");
uint ToUid = CharacterResolverCache.GetUidFromName(Query);
if (ToUid > 0)
{
MySqlClient.SetParameter("owneruid", ToUid);
}
DataTable Table = MySqlClient.ExecuteQueryTable("SELECT * FROM rooms WHERE name LIKE @query AND type = 'flat' OR tags LIKE @fquery AND type = 'flat'" + (ToUid > 0 ? " OR owner_id = @owneruid AND type = 'flat'" : string.Empty) + " LIMIT 50");
foreach (DataRow Row in Table.Rows)
{
uint RoomId = (uint)Row["id"];
if (!Rooms.ContainsKey(RoomId))
{
Rooms.Add(RoomId, RoomInfoLoader.GenerateRoomInfoFromRow(Row));
}
}
}
}
}
Response = NavigatorRoomListComposer.Compose(1, 9, Query, Rooms.Values.Take(50).ToList());
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void RemoveFavorite(Session Session, ClientMessage Message)
{
uint RoomId = Message.PopWiredUInt32();
if (Session.FavoriteRoomsCache.RemoveRoomFromFavorites(RoomId))
{
Session.SendData(NavigatorFavoriteRoomsChanged.Compose(RoomId, false));
}
ClearCacheGroup(Session.CharacterId);
}
private static void GetRecentRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(Session.CharacterId, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
List<uint> VisitedUids = new List<uint>();
List<RoomInfo> Rooms = new List<RoomInfo>();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
MySqlClient.SetParameter("userid", Session.CharacterId);
DataTable Table = MySqlClient.ExecuteQueryTable("SELECT room_id FROM room_visits WHERE user_id = @userid ORDER BY timestamp_entered DESC LIMIT 50");
foreach (DataRow Row in Table.Rows)
{
uint Id = (uint)Row["room_id"];
if (VisitedUids.Contains(Id))
{
continue;
}
RoomInfo Info = RoomInfoLoader.GetRoomInfo(Id);
if (Info == null || Info.Type == RoomType.Public)
{
continue;
}
Rooms.Add(Info);
VisitedUids.Add(Info.Id);
}
}
Response = NavigatorRoomListComposer.Compose(0, 7, string.Empty, Rooms);
AddToCacheIfNeeded(Session.CharacterId, Message, Response);
Session.SendData(Response);
}
private static void GetRoomsWithFriends(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(Session.CharacterId, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
List<uint> RoomUids = new List<uint>();
ReadOnlyCollection<uint> Friends = Session.MessengerFriendCache.Friends;
foreach (uint FriendId in Friends)
{
Session FriendSession = SessionManager.GetSessionByCharacterId(FriendId);
if (FriendSession != null && FriendSession.CurrentRoomId > 0)
{
RoomUids.Add(FriendSession.CurrentRoomId);
}
}
IEnumerable<RoomInstance> Rooms =
(from RoomInstance in RoomManager.RoomInstances
where RoomUids.Contains(RoomInstance.Value.RoomId)
select RoomInstance.Value).Take(50);
Response = NavigatorRoomListComposer.Compose(0, 4, string.Empty, Rooms.ToList());
AddToCacheIfNeeded(Session.CharacterId, Message, Response);
Session.SendData(Response);
}
private static void GetPopularTags(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
IEnumerable<List<string>> Tags =
(from RoomInstance in RoomManager.RoomInstances
where RoomInstance.Value.HumanActorCount > 0
orderby RoomInstance.Value.HumanActorCount descending
select RoomInstance.Value.SearchableTags).Take(50);
Dictionary<string, int> TagValues = new Dictionary<string, int>();
foreach (List<string> TagList in Tags)
{
foreach (string Tag in TagList)
{
if (!TagValues.ContainsKey(Tag))
{
TagValues.Add(Tag, 1);
}
else
{
TagValues[Tag]++;
}
}
}
List<KeyValuePair<string, int>> SortedTags = new List<KeyValuePair<string, int>>(TagValues);
SortedTags.Sort((FirstPair, NextPair) =>
{
return FirstPair.Value.CompareTo(NextPair.Value);
});
SortedTags.Reverse();
Response = NavigatorPopularTagListComposer.Compose(SortedTags);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void GetRatedRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
List<RoomInfo> Rooms = new List<RoomInfo>();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
DataTable Table = MySqlClient.ExecuteQueryTable("SELECT * FROM rooms WHERE type = 'flat' AND score > 0 ORDER BY score DESC LIMIT 50");
foreach (DataRow Row in Table.Rows)
{
Rooms.Add(RoomInfoLoader.GenerateRoomInfoFromRow(Row));
}
}
Response = NavigatorRoomListComposer.Compose(0, 2, string.Empty, Rooms);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void GetOfficialRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
Response = NavigatorOfficialRoomsComposer.Message(mOfficialItems);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void GetPopularRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
int Category = -1;
int.TryParse(Message.PopString(), out Category);
IEnumerable<RoomInstance> Rooms =
(from RoomInstance in RoomManager.RoomInstances
where RoomInstance.Value.Info.Type == RoomType.Flat &&
RoomInstance.Value.CachedNavigatorUserCount > 0 &&
(Category == -1 || RoomInstance.Value.Info.CategoryId == Category)
orderby RoomInstance.Value.CachedNavigatorUserCount descending
select RoomInstance.Value).Take(50);
Response = NavigatorRoomListComposer.Compose(Category, 1, string.Empty, Rooms.ToList());
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void GetFriendsRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(Session.CharacterId, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
List<RoomInfo> Rooms = new List<RoomInfo>();
ReadOnlyCollection<uint> Friends = Session.MessengerFriendCache.Friends;
if (Friends.Count > 0)
{
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
StringBuilder QueryBuilder = new StringBuilder("SELECT * FROM rooms WHERE ");
int i = 0;
foreach (uint FriendId in Friends)
{
if (i >= 1)
{
QueryBuilder.Append("OR ");
}
QueryBuilder.Append("owner_id = " + FriendId + " ");
i++;
}
QueryBuilder.Append("ORDER BY current_users DESC LIMIT 50");
DataTable Table = MySqlClient.ExecuteQueryTable(QueryBuilder.ToString());
foreach (DataRow Row in Table.Rows)
{
Rooms.Add(RoomInfoLoader.GenerateRoomInfoFromRow(Row));
}
}
}
Response = NavigatorRoomListComposer.Compose(0, 3, string.Empty, Rooms);
AddToCacheIfNeeded(Session.CharacterId, Message, Response);
Session.SendData(Response);
}
private static void GetEventRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
int Category = -1;
int.TryParse(Message.PopString(), out Category);
IEnumerable<RoomInstance> Rooms =
(from RoomInstance in RoomManager.RoomInstances
where (RoomInstance.Value.HasOngoingEvent &&
(Category == -1 || RoomInstance.Value.Event.CategoryId == Category))
orderby RoomInstance.Value.Event.TimestampStarted descending
select RoomInstance.Value).Take(50);
Response = NavigatorRoomListComposer.Compose(Category, 12, string.Empty, Rooms.ToList(), true);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void GetCategories(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(0, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
Response = NavigatorFlatCategoriesComposer.Compose(mFlatCategories);
AddToCacheIfNeeded(0, Message, Response);
Session.SendData(Response);
}
private static void AddToCacheIfNeeded(uint GroupId, ClientMessage Request, ServerMessage Response)
{
if (!CacheEnabled)
{
return;
}
mCacheController.AddIfNeeded(GroupId, Request, Response);
}
public static void GetUserRooms(Session Session, ClientMessage Message)
{
ServerMessage Response = TryGetResponseFromCache(Session.CharacterId, Message);
if (Response != null)
{
Session.SendData(Response);
return;
}
List<RoomInfo> Rooms = new List<RoomInfo>();
using (SqlDatabaseClient MySqlClient = SqlDatabaseManager.GetClient())
{
MySqlClient.SetParameter("ownerid", Session.CharacterId);
MySqlClient.SetParameter("limit", MaxRoomsPerUser);
DataTable Table = MySqlClient.ExecuteQueryTable("SELECT * FROM rooms WHERE owner_id = @ownerid ORDER BY name ASC LIMIT @limit");
foreach (DataRow Row in Table.Rows)
{
Rooms.Add(RoomInfoLoader.GenerateRoomInfoFromRow(Row));
}
}
Response = NavigatorRoomListComposer.Compose(0, 5, string.Empty, Rooms);
AddToCacheIfNeeded(Session.CharacterId, Message, Response);
Session.SendData(Response);
}
