diff options
Merge branch 'presence-refactor' of ssh://opensimulator.org/var/git/opensim into presence-refactor
Diffstat (limited to 'OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs')
-rw-r--r-- | OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | 4851 |
1 files changed, 4 insertions, 4847 deletions
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs index 1f5946b..afc5270 100644 --- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs +++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | |||
@@ -5224,7 +5224,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
5224 | args.Type = ChatTypeEnum.Shout; | 5224 | args.Type = ChatTypeEnum.Shout; |
5225 | args.Position = new Vector3(); | 5225 | args.Position = new Vector3(); |
5226 | args.Scene = Scene; | 5226 | args.Scene = Scene; |
5227 | args.Sender = this; | 5227 | args.Sender = this; |
5228 | ChatMessage handlerChatFromClient2 = OnChatFromClient; | 5228 | ChatMessage handlerChatFromClient2 = OnChatFromClient; |
5229 | if (handlerChatFromClient2 != null) | 5229 | if (handlerChatFromClient2 != null) |
5230 | handlerChatFromClient2(this, args); | 5230 | handlerChatFromClient2(this, args); |
@@ -11036,4855 +11036,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
11036 | /// <param name="Pack">OpenMetaverse.packet</param> | 11036 | /// <param name="Pack">OpenMetaverse.packet</param> |
11037 | public void ProcessInPacket(Packet Pack) | 11037 | public void ProcessInPacket(Packet Pack) |
11038 | { | 11038 | { |
11039 | 11039 | // m_log.DebugFormat("[CLIENT]: Packet IN {0}", Pack); | |
11040 | if (ProcessPacketMethod(Pack)) | ||
11041 | { | ||
11042 | PacketPool.Instance.ReturnPacket(Pack); | ||
11043 | return; | ||
11044 | } | ||
11045 | |||
11046 | // Main packet processing conditional | ||
11047 | switch (Pack.Type) | ||
11048 | { | ||
11049 | #region CommentedOut | ||
11050 | /* | ||
11051 | #region Scene/Avatar | ||
11052 | |||
11053 | |||
11054 | case PacketType.AvatarPropertiesRequest: | ||
11055 | AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack; | ||
11056 | |||
11057 | #region Packet Session and User Check | ||
11058 | if (m_checkPackets) | ||
11059 | { | ||
11060 | if (avatarProperties.AgentData.SessionID != SessionId || | ||
11061 | avatarProperties.AgentData.AgentID != AgentId) | ||
11062 | break; | ||
11063 | } | ||
11064 | #endregion | ||
11065 | |||
11066 | RequestAvatarProperties handlerRequestAvatarProperties = OnRequestAvatarProperties; | ||
11067 | if (handlerRequestAvatarProperties != null) | ||
11068 | { | ||
11069 | handlerRequestAvatarProperties(this, avatarProperties.AgentData.AvatarID); | ||
11070 | } | ||
11071 | |||
11072 | break; | ||
11073 | |||
11074 | case PacketType.ChatFromViewer: | ||
11075 | ChatFromViewerPacket inchatpack = (ChatFromViewerPacket)Pack; | ||
11076 | |||
11077 | #region Packet Session and User Check | ||
11078 | if (m_checkPackets) | ||
11079 | { | ||
11080 | if (inchatpack.AgentData.SessionID != SessionId || | ||
11081 | inchatpack.AgentData.AgentID != AgentId) | ||
11082 | break; | ||
11083 | } | ||
11084 | #endregion | ||
11085 | |||
11086 | string fromName = String.Empty; //ClientAvatar.firstname + " " + ClientAvatar.lastname; | ||
11087 | byte[] message = inchatpack.ChatData.Message; | ||
11088 | byte type = inchatpack.ChatData.Type; | ||
11089 | Vector3 fromPos = new Vector3(); // ClientAvatar.Pos; | ||
11090 | // UUID fromAgentID = AgentId; | ||
11091 | |||
11092 | int channel = inchatpack.ChatData.Channel; | ||
11093 | |||
11094 | if (OnChatFromClient != null) | ||
11095 | { | ||
11096 | OSChatMessage args = new OSChatMessage(); | ||
11097 | args.Channel = channel; | ||
11098 | args.From = fromName; | ||
11099 | args.Message = Utils.BytesToString(message); | ||
11100 | args.Type = (ChatTypeEnum)type; | ||
11101 | args.Position = fromPos; | ||
11102 | |||
11103 | args.Scene = Scene; | ||
11104 | args.Sender = this; | ||
11105 | args.SenderUUID = this.AgentId; | ||
11106 | |||
11107 | ChatMessage handlerChatFromClient = OnChatFromClient; | ||
11108 | if (handlerChatFromClient != null) | ||
11109 | handlerChatFromClient(this, args); | ||
11110 | } | ||
11111 | break; | ||
11112 | |||
11113 | case PacketType.AvatarPropertiesUpdate: | ||
11114 | AvatarPropertiesUpdatePacket avatarProps = (AvatarPropertiesUpdatePacket)Pack; | ||
11115 | |||
11116 | #region Packet Session and User Check | ||
11117 | if (m_checkPackets) | ||
11118 | { | ||
11119 | if (avatarProps.AgentData.SessionID != SessionId || | ||
11120 | avatarProps.AgentData.AgentID != AgentId) | ||
11121 | break; | ||
11122 | } | ||
11123 | #endregion | ||
11124 | |||
11125 | UpdateAvatarProperties handlerUpdateAvatarProperties = OnUpdateAvatarProperties; | ||
11126 | if (handlerUpdateAvatarProperties != null) | ||
11127 | { | ||
11128 | AvatarPropertiesUpdatePacket.PropertiesDataBlock Properties = avatarProps.PropertiesData; | ||
11129 | UserProfileData UserProfile = new UserProfileData(); | ||
11130 | UserProfile.ID = AgentId; | ||
11131 | UserProfile.AboutText = Utils.BytesToString(Properties.AboutText); | ||
11132 | UserProfile.FirstLifeAboutText = Utils.BytesToString(Properties.FLAboutText); | ||
11133 | UserProfile.FirstLifeImage = Properties.FLImageID; | ||
11134 | UserProfile.Image = Properties.ImageID; | ||
11135 | UserProfile.ProfileUrl = Utils.BytesToString(Properties.ProfileURL); | ||
11136 | |||
11137 | handlerUpdateAvatarProperties(this, UserProfile); | ||
11138 | } | ||
11139 | break; | ||
11140 | |||
11141 | case PacketType.ScriptDialogReply: | ||
11142 | ScriptDialogReplyPacket rdialog = (ScriptDialogReplyPacket)Pack; | ||
11143 | |||
11144 | #region Packet Session and User Check | ||
11145 | if (m_checkPackets) | ||
11146 | { | ||
11147 | if (rdialog.AgentData.SessionID != SessionId || | ||
11148 | rdialog.AgentData.AgentID != AgentId) | ||
11149 | break; | ||
11150 | } | ||
11151 | #endregion | ||
11152 | |||
11153 | int ch = rdialog.Data.ChatChannel; | ||
11154 | byte[] msg = rdialog.Data.ButtonLabel; | ||
11155 | if (OnChatFromClient != null) | ||
11156 | { | ||
11157 | OSChatMessage args = new OSChatMessage(); | ||
11158 | args.Channel = ch; | ||
11159 | args.From = String.Empty; | ||
11160 | args.Message = Utils.BytesToString(msg); | ||
11161 | args.Type = ChatTypeEnum.Shout; | ||
11162 | args.Position = new Vector3(); | ||
11163 | args.Scene = Scene; | ||
11164 | args.Sender = this; | ||
11165 | ChatMessage handlerChatFromClient2 = OnChatFromClient; | ||
11166 | if (handlerChatFromClient2 != null) | ||
11167 | handlerChatFromClient2(this, args); | ||
11168 | } | ||
11169 | |||
11170 | break; | ||
11171 | |||
11172 | case PacketType.ImprovedInstantMessage: | ||
11173 | ImprovedInstantMessagePacket msgpack = (ImprovedInstantMessagePacket)Pack; | ||
11174 | |||
11175 | #region Packet Session and User Check | ||
11176 | if (m_checkPackets) | ||
11177 | { | ||
11178 | if (msgpack.AgentData.SessionID != SessionId || | ||
11179 | msgpack.AgentData.AgentID != AgentId) | ||
11180 | break; | ||
11181 | } | ||
11182 | #endregion | ||
11183 | |||
11184 | string IMfromName = Util.FieldToString(msgpack.MessageBlock.FromAgentName); | ||
11185 | string IMmessage = Utils.BytesToString(msgpack.MessageBlock.Message); | ||
11186 | ImprovedInstantMessage handlerInstantMessage = OnInstantMessage; | ||
11187 | |||
11188 | if (handlerInstantMessage != null) | ||
11189 | { | ||
11190 | GridInstantMessage im = new GridInstantMessage(Scene, | ||
11191 | msgpack.AgentData.AgentID, | ||
11192 | IMfromName, | ||
11193 | msgpack.MessageBlock.ToAgentID, | ||
11194 | msgpack.MessageBlock.Dialog, | ||
11195 | msgpack.MessageBlock.FromGroup, | ||
11196 | IMmessage, | ||
11197 | msgpack.MessageBlock.ID, | ||
11198 | msgpack.MessageBlock.Offline != 0 ? true : false, | ||
11199 | msgpack.MessageBlock.Position, | ||
11200 | msgpack.MessageBlock.BinaryBucket); | ||
11201 | |||
11202 | handlerInstantMessage(this, im); | ||
11203 | } | ||
11204 | break; | ||
11205 | |||
11206 | case PacketType.AcceptFriendship: | ||
11207 | AcceptFriendshipPacket afriendpack = (AcceptFriendshipPacket)Pack; | ||
11208 | |||
11209 | #region Packet Session and User Check | ||
11210 | if (m_checkPackets) | ||
11211 | { | ||
11212 | if (afriendpack.AgentData.SessionID != SessionId || | ||
11213 | afriendpack.AgentData.AgentID != AgentId) | ||
11214 | break; | ||
11215 | } | ||
11216 | #endregion | ||
11217 | |||
11218 | // My guess is this is the folder to stick the calling card into | ||
11219 | List<UUID> callingCardFolders = new List<UUID>(); | ||
11220 | |||
11221 | UUID agentID = afriendpack.AgentData.AgentID; | ||
11222 | UUID transactionID = afriendpack.TransactionBlock.TransactionID; | ||
11223 | |||
11224 | for (int fi = 0; fi < afriendpack.FolderData.Length; fi++) | ||
11225 | { | ||
11226 | callingCardFolders.Add(afriendpack.FolderData[fi].FolderID); | ||
11227 | } | ||
11228 | |||
11229 | FriendActionDelegate handlerApproveFriendRequest = OnApproveFriendRequest; | ||
11230 | if (handlerApproveFriendRequest != null) | ||
11231 | { | ||
11232 | handlerApproveFriendRequest(this, agentID, transactionID, callingCardFolders); | ||
11233 | } | ||
11234 | break; | ||
11235 | |||
11236 | case PacketType.DeclineFriendship: | ||
11237 | DeclineFriendshipPacket dfriendpack = (DeclineFriendshipPacket)Pack; | ||
11238 | |||
11239 | #region Packet Session and User Check | ||
11240 | if (m_checkPackets) | ||
11241 | { | ||
11242 | if (dfriendpack.AgentData.SessionID != SessionId || | ||
11243 | dfriendpack.AgentData.AgentID != AgentId) | ||
11244 | break; | ||
11245 | } | ||
11246 | #endregion | ||
11247 | |||
11248 | if (OnDenyFriendRequest != null) | ||
11249 | { | ||
11250 | OnDenyFriendRequest(this, | ||
11251 | dfriendpack.AgentData.AgentID, | ||
11252 | dfriendpack.TransactionBlock.TransactionID, | ||
11253 | null); | ||
11254 | } | ||
11255 | break; | ||
11256 | |||
11257 | case PacketType.TerminateFriendship: | ||
11258 | TerminateFriendshipPacket tfriendpack = (TerminateFriendshipPacket)Pack; | ||
11259 | |||
11260 | #region Packet Session and User Check | ||
11261 | if (m_checkPackets) | ||
11262 | { | ||
11263 | if (tfriendpack.AgentData.SessionID != SessionId || | ||
11264 | tfriendpack.AgentData.AgentID != AgentId) | ||
11265 | break; | ||
11266 | } | ||
11267 | #endregion | ||
11268 | |||
11269 | UUID listOwnerAgentID = tfriendpack.AgentData.AgentID; | ||
11270 | UUID exFriendID = tfriendpack.ExBlock.OtherID; | ||
11271 | |||
11272 | FriendshipTermination handlerTerminateFriendship = OnTerminateFriendship; | ||
11273 | if (handlerTerminateFriendship != null) | ||
11274 | { | ||
11275 | handlerTerminateFriendship(this, listOwnerAgentID, exFriendID); | ||
11276 | } | ||
11277 | break; | ||
11278 | |||
11279 | case PacketType.RezObject: | ||
11280 | RezObjectPacket rezPacket = (RezObjectPacket)Pack; | ||
11281 | |||
11282 | #region Packet Session and User Check | ||
11283 | if (m_checkPackets) | ||
11284 | { | ||
11285 | if (rezPacket.AgentData.SessionID != SessionId || | ||
11286 | rezPacket.AgentData.AgentID != AgentId) | ||
11287 | break; | ||
11288 | } | ||
11289 | #endregion | ||
11290 | |||
11291 | RezObject handlerRezObject = OnRezObject; | ||
11292 | if (handlerRezObject != null) | ||
11293 | { | ||
11294 | handlerRezObject(this, rezPacket.InventoryData.ItemID, rezPacket.RezData.RayEnd, | ||
11295 | rezPacket.RezData.RayStart, rezPacket.RezData.RayTargetID, | ||
11296 | rezPacket.RezData.BypassRaycast, rezPacket.RezData.RayEndIsIntersection, | ||
11297 | rezPacket.RezData.RezSelected, rezPacket.RezData.RemoveItem, | ||
11298 | rezPacket.RezData.FromTaskID); | ||
11299 | } | ||
11300 | break; | ||
11301 | |||
11302 | case PacketType.DeRezObject: | ||
11303 | DeRezObjectPacket DeRezPacket = (DeRezObjectPacket)Pack; | ||
11304 | |||
11305 | #region Packet Session and User Check | ||
11306 | if (m_checkPackets) | ||
11307 | { | ||
11308 | if (DeRezPacket.AgentData.SessionID != SessionId || | ||
11309 | DeRezPacket.AgentData.AgentID != AgentId) | ||
11310 | break; | ||
11311 | } | ||
11312 | #endregion | ||
11313 | |||
11314 | DeRezObject handlerDeRezObject = OnDeRezObject; | ||
11315 | if (handlerDeRezObject != null) | ||
11316 | { | ||
11317 | List<uint> deRezIDs = new List<uint>(); | ||
11318 | |||
11319 | foreach (DeRezObjectPacket.ObjectDataBlock data in | ||
11320 | DeRezPacket.ObjectData) | ||
11321 | { | ||
11322 | deRezIDs.Add(data.ObjectLocalID); | ||
11323 | } | ||
11324 | // It just so happens that the values on the DeRezAction enumerator match the Destination | ||
11325 | // values given by a Second Life client | ||
11326 | handlerDeRezObject(this, deRezIDs, | ||
11327 | DeRezPacket.AgentBlock.GroupID, | ||
11328 | (DeRezAction)DeRezPacket.AgentBlock.Destination, | ||
11329 | DeRezPacket.AgentBlock.DestinationID); | ||
11330 | |||
11331 | } | ||
11332 | break; | ||
11333 | |||
11334 | case PacketType.ModifyLand: | ||
11335 | ModifyLandPacket modify = (ModifyLandPacket)Pack; | ||
11336 | |||
11337 | #region Packet Session and User Check | ||
11338 | if (m_checkPackets) | ||
11339 | { | ||
11340 | if (modify.AgentData.SessionID != SessionId || | ||
11341 | modify.AgentData.AgentID != AgentId) | ||
11342 | break; | ||
11343 | } | ||
11344 | |||
11345 | #endregion | ||
11346 | //m_log.Info("[LAND]: LAND:" + modify.ToString()); | ||
11347 | if (modify.ParcelData.Length > 0) | ||
11348 | { | ||
11349 | if (OnModifyTerrain != null) | ||
11350 | { | ||
11351 | for (int i = 0; i < modify.ParcelData.Length; i++) | ||
11352 | { | ||
11353 | ModifyTerrain handlerModifyTerrain = OnModifyTerrain; | ||
11354 | if (handlerModifyTerrain != null) | ||
11355 | { | ||
11356 | handlerModifyTerrain(AgentId, modify.ModifyBlock.Height, modify.ModifyBlock.Seconds, | ||
11357 | modify.ModifyBlock.BrushSize, | ||
11358 | modify.ModifyBlock.Action, modify.ParcelData[i].North, | ||
11359 | modify.ParcelData[i].West, modify.ParcelData[i].South, | ||
11360 | modify.ParcelData[i].East, AgentId); | ||
11361 | } | ||
11362 | } | ||
11363 | } | ||
11364 | } | ||
11365 | |||
11366 | break; | ||
11367 | |||
11368 | case PacketType.RegionHandshakeReply: | ||
11369 | |||
11370 | Action<IClientAPI> handlerRegionHandShakeReply = OnRegionHandShakeReply; | ||
11371 | if (handlerRegionHandShakeReply != null) | ||
11372 | { | ||
11373 | handlerRegionHandShakeReply(this); | ||
11374 | } | ||
11375 | |||
11376 | break; | ||
11377 | |||
11378 | case PacketType.AgentWearablesRequest: | ||
11379 | GenericCall2 handlerRequestWearables = OnRequestWearables; | ||
11380 | |||
11381 | if (handlerRequestWearables != null) | ||
11382 | { | ||
11383 | handlerRequestWearables(); | ||
11384 | } | ||
11385 | |||
11386 | Action<IClientAPI> handlerRequestAvatarsData = OnRequestAvatarsData; | ||
11387 | |||
11388 | if (handlerRequestAvatarsData != null) | ||
11389 | { | ||
11390 | handlerRequestAvatarsData(this); | ||
11391 | } | ||
11392 | |||
11393 | break; | ||
11394 | |||
11395 | case PacketType.AgentSetAppearance: | ||
11396 | AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack; | ||
11397 | |||
11398 | #region Packet Session and User Check | ||
11399 | if (m_checkPackets) | ||
11400 | { | ||
11401 | if (appear.AgentData.SessionID != SessionId || | ||
11402 | appear.AgentData.AgentID != AgentId) | ||
11403 | break; | ||
11404 | } | ||
11405 | #endregion | ||
11406 | |||
11407 | SetAppearance handlerSetAppearance = OnSetAppearance; | ||
11408 | if (handlerSetAppearance != null) | ||
11409 | { | ||
11410 | // Temporarily protect ourselves from the mantis #951 failure. | ||
11411 | // However, we could do this for several other handlers where a failure isn't terminal | ||
11412 | // for the client session anyway, in order to protect ourselves against bad code in plugins | ||
11413 | try | ||
11414 | { | ||
11415 | byte[] visualparams = new byte[appear.VisualParam.Length]; | ||
11416 | for (int i = 0; i < appear.VisualParam.Length; i++) | ||
11417 | visualparams[i] = appear.VisualParam[i].ParamValue; | ||
11418 | |||
11419 | Primitive.TextureEntry te = null; | ||
11420 | if (appear.ObjectData.TextureEntry.Length > 1) | ||
11421 | te = new Primitive.TextureEntry(appear.ObjectData.TextureEntry, 0, appear.ObjectData.TextureEntry.Length); | ||
11422 | |||
11423 | handlerSetAppearance(te, visualparams); | ||
11424 | } | ||
11425 | catch (Exception e) | ||
11426 | { | ||
11427 | m_log.ErrorFormat( | ||
11428 | "[CLIENT VIEW]: AgentSetApperance packet handler threw an exception, {0}", | ||
11429 | e); | ||
11430 | } | ||
11431 | } | ||
11432 | |||
11433 | break; | ||
11434 | |||
11435 | case PacketType.AgentIsNowWearing: | ||
11436 | if (OnAvatarNowWearing != null) | ||
11437 | { | ||
11438 | AgentIsNowWearingPacket nowWearing = (AgentIsNowWearingPacket)Pack; | ||
11439 | |||
11440 | #region Packet Session and User Check | ||
11441 | if (m_checkPackets) | ||
11442 | { | ||
11443 | if (nowWearing.AgentData.SessionID != SessionId || | ||
11444 | nowWearing.AgentData.AgentID != AgentId) | ||
11445 | break; | ||
11446 | } | ||
11447 | #endregion | ||
11448 | |||
11449 | AvatarWearingArgs wearingArgs = new AvatarWearingArgs(); | ||
11450 | for (int i = 0; i < nowWearing.WearableData.Length; i++) | ||
11451 | { | ||
11452 | AvatarWearingArgs.Wearable wearable = | ||
11453 | new AvatarWearingArgs.Wearable(nowWearing.WearableData[i].ItemID, | ||
11454 | nowWearing.WearableData[i].WearableType); | ||
11455 | wearingArgs.NowWearing.Add(wearable); | ||
11456 | } | ||
11457 | |||
11458 | AvatarNowWearing handlerAvatarNowWearing = OnAvatarNowWearing; | ||
11459 | if (handlerAvatarNowWearing != null) | ||
11460 | { | ||
11461 | handlerAvatarNowWearing(this, wearingArgs); | ||
11462 | } | ||
11463 | } | ||
11464 | break; | ||
11465 | |||
11466 | case PacketType.RezSingleAttachmentFromInv: | ||
11467 | RezSingleAttachmentFromInv handlerRezSingleAttachment = OnRezSingleAttachmentFromInv; | ||
11468 | if (handlerRezSingleAttachment != null) | ||
11469 | { | ||
11470 | RezSingleAttachmentFromInvPacket rez = (RezSingleAttachmentFromInvPacket)Pack; | ||
11471 | |||
11472 | #region Packet Session and User Check | ||
11473 | if (m_checkPackets) | ||
11474 | { | ||
11475 | if (rez.AgentData.SessionID != SessionId || | ||
11476 | rez.AgentData.AgentID != AgentId) | ||
11477 | break; | ||
11478 | } | ||
11479 | #endregion | ||
11480 | |||
11481 | handlerRezSingleAttachment(this, rez.ObjectData.ItemID, | ||
11482 | rez.ObjectData.AttachmentPt); | ||
11483 | } | ||
11484 | |||
11485 | break; | ||
11486 | |||
11487 | case PacketType.RezMultipleAttachmentsFromInv: | ||
11488 | RezMultipleAttachmentsFromInv handlerRezMultipleAttachments = OnRezMultipleAttachmentsFromInv; | ||
11489 | if (handlerRezMultipleAttachments != null) | ||
11490 | { | ||
11491 | RezMultipleAttachmentsFromInvPacket rez = (RezMultipleAttachmentsFromInvPacket)Pack; | ||
11492 | handlerRezMultipleAttachments(this, rez.HeaderData, | ||
11493 | rez.ObjectData); | ||
11494 | } | ||
11495 | |||
11496 | break; | ||
11497 | |||
11498 | case PacketType.DetachAttachmentIntoInv: | ||
11499 | UUIDNameRequest handlerDetachAttachmentIntoInv = OnDetachAttachmentIntoInv; | ||
11500 | if (handlerDetachAttachmentIntoInv != null) | ||
11501 | { | ||
11502 | DetachAttachmentIntoInvPacket detachtoInv = (DetachAttachmentIntoInvPacket)Pack; | ||
11503 | |||
11504 | #region Packet Session and User Check | ||
11505 | // UNSUPPORTED ON THIS PACKET | ||
11506 | #endregion | ||
11507 | |||
11508 | UUID itemID = detachtoInv.ObjectData.ItemID; | ||
11509 | // UUID ATTACH_agentID = detachtoInv.ObjectData.AgentID; | ||
11510 | |||
11511 | handlerDetachAttachmentIntoInv(itemID, this); | ||
11512 | } | ||
11513 | break; | ||
11514 | |||
11515 | case PacketType.ObjectAttach: | ||
11516 | if (OnObjectAttach != null) | ||
11517 | { | ||
11518 | ObjectAttachPacket att = (ObjectAttachPacket)Pack; | ||
11519 | |||
11520 | #region Packet Session and User Check | ||
11521 | if (m_checkPackets) | ||
11522 | { | ||
11523 | if (att.AgentData.SessionID != SessionId || | ||
11524 | att.AgentData.AgentID != AgentId) | ||
11525 | break; | ||
11526 | } | ||
11527 | #endregion | ||
11528 | |||
11529 | ObjectAttach handlerObjectAttach = OnObjectAttach; | ||
11530 | |||
11531 | if (handlerObjectAttach != null) | ||
11532 | { | ||
11533 | if (att.ObjectData.Length > 0) | ||
11534 | { | ||
11535 | handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, att.ObjectData[0].Rotation, false); | ||
11536 | } | ||
11537 | } | ||
11538 | } | ||
11539 | break; | ||
11540 | |||
11541 | case PacketType.ObjectDetach: | ||
11542 | ObjectDetachPacket dett = (ObjectDetachPacket)Pack; | ||
11543 | |||
11544 | #region Packet Session and User Check | ||
11545 | if (m_checkPackets) | ||
11546 | { | ||
11547 | if (dett.AgentData.SessionID != SessionId || | ||
11548 | dett.AgentData.AgentID != AgentId) | ||
11549 | break; | ||
11550 | } | ||
11551 | #endregion | ||
11552 | |||
11553 | for (int j = 0; j < dett.ObjectData.Length; j++) | ||
11554 | { | ||
11555 | uint obj = dett.ObjectData[j].ObjectLocalID; | ||
11556 | ObjectDeselect handlerObjectDetach = OnObjectDetach; | ||
11557 | if (handlerObjectDetach != null) | ||
11558 | { | ||
11559 | handlerObjectDetach(obj, this); | ||
11560 | } | ||
11561 | |||
11562 | } | ||
11563 | break; | ||
11564 | |||
11565 | case PacketType.ObjectDrop: | ||
11566 | ObjectDropPacket dropp = (ObjectDropPacket)Pack; | ||
11567 | |||
11568 | #region Packet Session and User Check | ||
11569 | if (m_checkPackets) | ||
11570 | { | ||
11571 | if (dropp.AgentData.SessionID != SessionId || | ||
11572 | dropp.AgentData.AgentID != AgentId) | ||
11573 | break; | ||
11574 | } | ||
11575 | #endregion | ||
11576 | |||
11577 | for (int j = 0; j < dropp.ObjectData.Length; j++) | ||
11578 | { | ||
11579 | uint obj = dropp.ObjectData[j].ObjectLocalID; | ||
11580 | ObjectDrop handlerObjectDrop = OnObjectDrop; | ||
11581 | if (handlerObjectDrop != null) | ||
11582 | { | ||
11583 | handlerObjectDrop(obj, this); | ||
11584 | } | ||
11585 | } | ||
11586 | break; | ||
11587 | |||
11588 | case PacketType.SetAlwaysRun: | ||
11589 | SetAlwaysRunPacket run = (SetAlwaysRunPacket)Pack; | ||
11590 | |||
11591 | #region Packet Session and User Check | ||
11592 | if (m_checkPackets) | ||
11593 | { | ||
11594 | if (run.AgentData.SessionID != SessionId || | ||
11595 | run.AgentData.AgentID != AgentId) | ||
11596 | break; | ||
11597 | } | ||
11598 | #endregion | ||
11599 | |||
11600 | SetAlwaysRun handlerSetAlwaysRun = OnSetAlwaysRun; | ||
11601 | if (handlerSetAlwaysRun != null) | ||
11602 | handlerSetAlwaysRun(this, run.AgentData.AlwaysRun); | ||
11603 | |||
11604 | break; | ||
11605 | |||
11606 | case PacketType.CompleteAgentMovement: | ||
11607 | GenericCall2 handlerCompleteMovementToRegion = OnCompleteMovementToRegion; | ||
11608 | if (handlerCompleteMovementToRegion != null) | ||
11609 | { | ||
11610 | handlerCompleteMovementToRegion(); | ||
11611 | } | ||
11612 | handlerCompleteMovementToRegion = null; | ||
11613 | |||
11614 | break; | ||
11615 | |||
11616 | case PacketType.AgentAnimation: | ||
11617 | AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack; | ||
11618 | |||
11619 | #region Packet Session and User Check | ||
11620 | if (m_checkPackets) | ||
11621 | { | ||
11622 | if (AgentAni.AgentData.SessionID != SessionId || | ||
11623 | AgentAni.AgentData.AgentID != AgentId) | ||
11624 | break; | ||
11625 | } | ||
11626 | #endregion | ||
11627 | |||
11628 | StartAnim handlerStartAnim = null; | ||
11629 | StopAnim handlerStopAnim = null; | ||
11630 | |||
11631 | for (int i = 0; i < AgentAni.AnimationList.Length; i++) | ||
11632 | { | ||
11633 | if (AgentAni.AnimationList[i].StartAnim) | ||
11634 | { | ||
11635 | handlerStartAnim = OnStartAnim; | ||
11636 | if (handlerStartAnim != null) | ||
11637 | { | ||
11638 | handlerStartAnim(this, AgentAni.AnimationList[i].AnimID); | ||
11639 | } | ||
11640 | } | ||
11641 | else | ||
11642 | { | ||
11643 | handlerStopAnim = OnStopAnim; | ||
11644 | if (handlerStopAnim != null) | ||
11645 | { | ||
11646 | handlerStopAnim(this, AgentAni.AnimationList[i].AnimID); | ||
11647 | } | ||
11648 | } | ||
11649 | } | ||
11650 | break; | ||
11651 | |||
11652 | case PacketType.AgentRequestSit: | ||
11653 | if (OnAgentRequestSit != null) | ||
11654 | { | ||
11655 | AgentRequestSitPacket agentRequestSit = (AgentRequestSitPacket)Pack; | ||
11656 | |||
11657 | #region Packet Session and User Check | ||
11658 | if (m_checkPackets) | ||
11659 | { | ||
11660 | if (agentRequestSit.AgentData.SessionID != SessionId || | ||
11661 | agentRequestSit.AgentData.AgentID != AgentId) | ||
11662 | break; | ||
11663 | } | ||
11664 | #endregion | ||
11665 | |||
11666 | AgentRequestSit handlerAgentRequestSit = OnAgentRequestSit; | ||
11667 | if (handlerAgentRequestSit != null) | ||
11668 | handlerAgentRequestSit(this, agentRequestSit.AgentData.AgentID, | ||
11669 | agentRequestSit.TargetObject.TargetID, agentRequestSit.TargetObject.Offset); | ||
11670 | } | ||
11671 | break; | ||
11672 | |||
11673 | case PacketType.AgentSit: | ||
11674 | if (OnAgentSit != null) | ||
11675 | { | ||
11676 | AgentSitPacket agentSit = (AgentSitPacket)Pack; | ||
11677 | |||
11678 | #region Packet Session and User Check | ||
11679 | if (m_checkPackets) | ||
11680 | { | ||
11681 | if (agentSit.AgentData.SessionID != SessionId || | ||
11682 | agentSit.AgentData.AgentID != AgentId) | ||
11683 | break; | ||
11684 | } | ||
11685 | #endregion | ||
11686 | |||
11687 | AgentSit handlerAgentSit = OnAgentSit; | ||
11688 | if (handlerAgentSit != null) | ||
11689 | { | ||
11690 | OnAgentSit(this, agentSit.AgentData.AgentID); | ||
11691 | } | ||
11692 | } | ||
11693 | break; | ||
11694 | |||
11695 | case PacketType.SoundTrigger: | ||
11696 | SoundTriggerPacket soundTriggerPacket = (SoundTriggerPacket)Pack; | ||
11697 | |||
11698 | #region Packet Session and User Check | ||
11699 | if (m_checkPackets) | ||
11700 | { | ||
11701 | // UNSUPPORTED ON THIS PACKET | ||
11702 | } | ||
11703 | #endregion | ||
11704 | |||
11705 | SoundTrigger handlerSoundTrigger = OnSoundTrigger; | ||
11706 | if (handlerSoundTrigger != null) | ||
11707 | { | ||
11708 | handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, soundTriggerPacket.SoundData.OwnerID, | ||
11709 | soundTriggerPacket.SoundData.ObjectID, soundTriggerPacket.SoundData.ParentID, | ||
11710 | soundTriggerPacket.SoundData.Gain, soundTriggerPacket.SoundData.Position, | ||
11711 | soundTriggerPacket.SoundData.Handle); | ||
11712 | |||
11713 | } | ||
11714 | break; | ||
11715 | |||
11716 | case PacketType.AvatarPickerRequest: | ||
11717 | AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack; | ||
11718 | |||
11719 | #region Packet Session and User Check | ||
11720 | if (m_checkPackets) | ||
11721 | { | ||
11722 | if (avRequestQuery.AgentData.SessionID != SessionId || | ||
11723 | avRequestQuery.AgentData.AgentID != AgentId) | ||
11724 | break; | ||
11725 | } | ||
11726 | #endregion | ||
11727 | |||
11728 | AvatarPickerRequestPacket.AgentDataBlock Requestdata = avRequestQuery.AgentData; | ||
11729 | AvatarPickerRequestPacket.DataBlock querydata = avRequestQuery.Data; | ||
11730 | //m_log.Debug("Agent Sends:" + Utils.BytesToString(querydata.Name)); | ||
11731 | |||
11732 | AvatarPickerRequest handlerAvatarPickerRequest = OnAvatarPickerRequest; | ||
11733 | if (handlerAvatarPickerRequest != null) | ||
11734 | { | ||
11735 | handlerAvatarPickerRequest(this, Requestdata.AgentID, Requestdata.QueryID, | ||
11736 | Utils.BytesToString(querydata.Name)); | ||
11737 | } | ||
11738 | break; | ||
11739 | |||
11740 | case PacketType.AgentDataUpdateRequest: | ||
11741 | AgentDataUpdateRequestPacket avRequestDataUpdatePacket = (AgentDataUpdateRequestPacket)Pack; | ||
11742 | |||
11743 | #region Packet Session and User Check | ||
11744 | if (m_checkPackets) | ||
11745 | { | ||
11746 | if (avRequestDataUpdatePacket.AgentData.SessionID != SessionId || | ||
11747 | avRequestDataUpdatePacket.AgentData.AgentID != AgentId) | ||
11748 | break; | ||
11749 | } | ||
11750 | #endregion | ||
11751 | |||
11752 | FetchInventory handlerAgentDataUpdateRequest = OnAgentDataUpdateRequest; | ||
11753 | |||
11754 | if (handlerAgentDataUpdateRequest != null) | ||
11755 | { | ||
11756 | handlerAgentDataUpdateRequest(this, avRequestDataUpdatePacket.AgentData.AgentID, avRequestDataUpdatePacket.AgentData.SessionID); | ||
11757 | } | ||
11758 | |||
11759 | break; | ||
11760 | |||
11761 | case PacketType.UserInfoRequest: | ||
11762 | UserInfoRequest handlerUserInfoRequest = OnUserInfoRequest; | ||
11763 | if (handlerUserInfoRequest != null) | ||
11764 | { | ||
11765 | handlerUserInfoRequest(this); | ||
11766 | } | ||
11767 | else | ||
11768 | { | ||
11769 | SendUserInfoReply(false, true, ""); | ||
11770 | } | ||
11771 | break; | ||
11772 | |||
11773 | case PacketType.UpdateUserInfo: | ||
11774 | UpdateUserInfoPacket updateUserInfo = (UpdateUserInfoPacket)Pack; | ||
11775 | |||
11776 | #region Packet Session and User Check | ||
11777 | if (m_checkPackets) | ||
11778 | { | ||
11779 | if (updateUserInfo.AgentData.SessionID != SessionId || | ||
11780 | updateUserInfo.AgentData.AgentID != AgentId) | ||
11781 | break; | ||
11782 | } | ||
11783 | #endregion | ||
11784 | |||
11785 | UpdateUserInfo handlerUpdateUserInfo = OnUpdateUserInfo; | ||
11786 | if (handlerUpdateUserInfo != null) | ||
11787 | { | ||
11788 | bool visible = true; | ||
11789 | string DirectoryVisibility = | ||
11790 | Utils.BytesToString(updateUserInfo.UserData.DirectoryVisibility); | ||
11791 | if (DirectoryVisibility == "hidden") | ||
11792 | visible = false; | ||
11793 | |||
11794 | handlerUpdateUserInfo( | ||
11795 | updateUserInfo.UserData.IMViaEMail, | ||
11796 | visible, this); | ||
11797 | } | ||
11798 | break; | ||
11799 | |||
11800 | case PacketType.SetStartLocationRequest: | ||
11801 | SetStartLocationRequestPacket avSetStartLocationRequestPacket = (SetStartLocationRequestPacket)Pack; | ||
11802 | |||
11803 | #region Packet Session and User Check | ||
11804 | if (m_checkPackets) | ||
11805 | { | ||
11806 | if (avSetStartLocationRequestPacket.AgentData.SessionID != SessionId || | ||
11807 | avSetStartLocationRequestPacket.AgentData.AgentID != AgentId) | ||
11808 | break; | ||
11809 | } | ||
11810 | #endregion | ||
11811 | |||
11812 | if (avSetStartLocationRequestPacket.AgentData.AgentID == AgentId && avSetStartLocationRequestPacket.AgentData.SessionID == SessionId) | ||
11813 | { | ||
11814 | TeleportLocationRequest handlerSetStartLocationRequest = OnSetStartLocationRequest; | ||
11815 | if (handlerSetStartLocationRequest != null) | ||
11816 | { | ||
11817 | handlerSetStartLocationRequest(this, 0, avSetStartLocationRequestPacket.StartLocationData.LocationPos, | ||
11818 | avSetStartLocationRequestPacket.StartLocationData.LocationLookAt, | ||
11819 | avSetStartLocationRequestPacket.StartLocationData.LocationID); | ||
11820 | } | ||
11821 | } | ||
11822 | break; | ||
11823 | |||
11824 | case PacketType.AgentThrottle: | ||
11825 | AgentThrottlePacket atpack = (AgentThrottlePacket)Pack; | ||
11826 | |||
11827 | #region Packet Session and User Check | ||
11828 | if (m_checkPackets) | ||
11829 | { | ||
11830 | if (atpack.AgentData.SessionID != SessionId || | ||
11831 | atpack.AgentData.AgentID != AgentId) | ||
11832 | break; | ||
11833 | } | ||
11834 | #endregion | ||
11835 | |||
11836 | m_udpClient.SetThrottles(atpack.Throttle.Throttles); | ||
11837 | break; | ||
11838 | |||
11839 | case PacketType.AgentPause: | ||
11840 | m_udpClient.IsPaused = true; | ||
11841 | break; | ||
11842 | |||
11843 | case PacketType.AgentResume: | ||
11844 | m_udpClient.IsPaused = false; | ||
11845 | SendStartPingCheck(m_udpClient.CurrentPingSequence++); | ||
11846 | |||
11847 | break; | ||
11848 | |||
11849 | case PacketType.ForceScriptControlRelease: | ||
11850 | ForceReleaseControls handlerForceReleaseControls = OnForceReleaseControls; | ||
11851 | if (handlerForceReleaseControls != null) | ||
11852 | { | ||
11853 | handlerForceReleaseControls(this, AgentId); | ||
11854 | } | ||
11855 | break; | ||
11856 | |||
11857 | #endregion | ||
11858 | |||
11859 | |||
11860 | //#region Objects/m_sceneObjects | ||
11861 | |||
11862 | case PacketType.ObjectLink: | ||
11863 | ObjectLinkPacket link = (ObjectLinkPacket)Pack; | ||
11864 | |||
11865 | #region Packet Session and User Check | ||
11866 | if (m_checkPackets) | ||
11867 | { | ||
11868 | if (link.AgentData.SessionID != SessionId || | ||
11869 | link.AgentData.AgentID != AgentId) | ||
11870 | break; | ||
11871 | } | ||
11872 | #endregion | ||
11873 | |||
11874 | uint parentprimid = 0; | ||
11875 | List<uint> childrenprims = new List<uint>(); | ||
11876 | if (link.ObjectData.Length > 1) | ||
11877 | { | ||
11878 | parentprimid = link.ObjectData[0].ObjectLocalID; | ||
11879 | |||
11880 | for (int i = 1; i < link.ObjectData.Length; i++) | ||
11881 | { | ||
11882 | childrenprims.Add(link.ObjectData[i].ObjectLocalID); | ||
11883 | } | ||
11884 | } | ||
11885 | LinkObjects handlerLinkObjects = OnLinkObjects; | ||
11886 | if (handlerLinkObjects != null) | ||
11887 | { | ||
11888 | handlerLinkObjects(this, parentprimid, childrenprims); | ||
11889 | } | ||
11890 | break; | ||
11891 | |||
11892 | case PacketType.ObjectDelink: | ||
11893 | ObjectDelinkPacket delink = (ObjectDelinkPacket)Pack; | ||
11894 | |||
11895 | #region Packet Session and User Check | ||
11896 | if (m_checkPackets) | ||
11897 | { | ||
11898 | if (delink.AgentData.SessionID != SessionId || | ||
11899 | delink.AgentData.AgentID != AgentId) | ||
11900 | break; | ||
11901 | } | ||
11902 | #endregion | ||
11903 | |||
11904 | // It appears the prim at index 0 is not always the root prim (for | ||
11905 | // instance, when one prim of a link set has been edited independently | ||
11906 | // of the others). Therefore, we'll pass all the ids onto the delink | ||
11907 | // method for it to decide which is the root. | ||
11908 | List<uint> prims = new List<uint>(); | ||
11909 | for (int i = 0; i < delink.ObjectData.Length; i++) | ||
11910 | { | ||
11911 | prims.Add(delink.ObjectData[i].ObjectLocalID); | ||
11912 | } | ||
11913 | DelinkObjects handlerDelinkObjects = OnDelinkObjects; | ||
11914 | if (handlerDelinkObjects != null) | ||
11915 | { | ||
11916 | handlerDelinkObjects(prims); | ||
11917 | } | ||
11918 | |||
11919 | break; | ||
11920 | |||
11921 | case PacketType.ObjectAdd: | ||
11922 | if (OnAddPrim != null) | ||
11923 | { | ||
11924 | ObjectAddPacket addPacket = (ObjectAddPacket)Pack; | ||
11925 | |||
11926 | #region Packet Session and User Check | ||
11927 | if (m_checkPackets) | ||
11928 | { | ||
11929 | if (addPacket.AgentData.SessionID != SessionId || | ||
11930 | addPacket.AgentData.AgentID != AgentId) | ||
11931 | break; | ||
11932 | } | ||
11933 | #endregion | ||
11934 | |||
11935 | PrimitiveBaseShape shape = GetShapeFromAddPacket(addPacket); | ||
11936 | // m_log.Info("[REZData]: " + addPacket.ToString()); | ||
11937 | //BypassRaycast: 1 | ||
11938 | //RayStart: <69.79469, 158.2652, 98.40343> | ||
11939 | //RayEnd: <61.97724, 141.995, 92.58341> | ||
11940 | //RayTargetID: 00000000-0000-0000-0000-000000000000 | ||
11941 | |||
11942 | //Check to see if adding the prim is allowed; useful for any module wanting to restrict the | ||
11943 | //object from rezing initially | ||
11944 | |||
11945 | AddNewPrim handlerAddPrim = OnAddPrim; | ||
11946 | if (handlerAddPrim != null) | ||
11947 | handlerAddPrim(AgentId, ActiveGroupId, addPacket.ObjectData.RayEnd, addPacket.ObjectData.Rotation, shape, addPacket.ObjectData.BypassRaycast, addPacket.ObjectData.RayStart, addPacket.ObjectData.RayTargetID, addPacket.ObjectData.RayEndIsIntersection); | ||
11948 | } | ||
11949 | break; | ||
11950 | |||
11951 | case PacketType.ObjectShape: | ||
11952 | ObjectShapePacket shapePacket = (ObjectShapePacket)Pack; | ||
11953 | |||
11954 | #region Packet Session and User Check | ||
11955 | if (m_checkPackets) | ||
11956 | { | ||
11957 | if (shapePacket.AgentData.SessionID != SessionId || | ||
11958 | shapePacket.AgentData.AgentID != AgentId) | ||
11959 | break; | ||
11960 | } | ||
11961 | #endregion | ||
11962 | |||
11963 | UpdateShape handlerUpdatePrimShape = null; | ||
11964 | for (int i = 0; i < shapePacket.ObjectData.Length; i++) | ||
11965 | { | ||
11966 | handlerUpdatePrimShape = OnUpdatePrimShape; | ||
11967 | if (handlerUpdatePrimShape != null) | ||
11968 | { | ||
11969 | UpdateShapeArgs shapeData = new UpdateShapeArgs(); | ||
11970 | shapeData.ObjectLocalID = shapePacket.ObjectData[i].ObjectLocalID; | ||
11971 | shapeData.PathBegin = shapePacket.ObjectData[i].PathBegin; | ||
11972 | shapeData.PathCurve = shapePacket.ObjectData[i].PathCurve; | ||
11973 | shapeData.PathEnd = shapePacket.ObjectData[i].PathEnd; | ||
11974 | shapeData.PathRadiusOffset = shapePacket.ObjectData[i].PathRadiusOffset; | ||
11975 | shapeData.PathRevolutions = shapePacket.ObjectData[i].PathRevolutions; | ||
11976 | shapeData.PathScaleX = shapePacket.ObjectData[i].PathScaleX; | ||
11977 | shapeData.PathScaleY = shapePacket.ObjectData[i].PathScaleY; | ||
11978 | shapeData.PathShearX = shapePacket.ObjectData[i].PathShearX; | ||
11979 | shapeData.PathShearY = shapePacket.ObjectData[i].PathShearY; | ||
11980 | shapeData.PathSkew = shapePacket.ObjectData[i].PathSkew; | ||
11981 | shapeData.PathTaperX = shapePacket.ObjectData[i].PathTaperX; | ||
11982 | shapeData.PathTaperY = shapePacket.ObjectData[i].PathTaperY; | ||
11983 | shapeData.PathTwist = shapePacket.ObjectData[i].PathTwist; | ||
11984 | shapeData.PathTwistBegin = shapePacket.ObjectData[i].PathTwistBegin; | ||
11985 | shapeData.ProfileBegin = shapePacket.ObjectData[i].ProfileBegin; | ||
11986 | shapeData.ProfileCurve = shapePacket.ObjectData[i].ProfileCurve; | ||
11987 | shapeData.ProfileEnd = shapePacket.ObjectData[i].ProfileEnd; | ||
11988 | shapeData.ProfileHollow = shapePacket.ObjectData[i].ProfileHollow; | ||
11989 | |||
11990 | handlerUpdatePrimShape(m_agentId, shapePacket.ObjectData[i].ObjectLocalID, | ||
11991 | shapeData); | ||
11992 | } | ||
11993 | } | ||
11994 | break; | ||
11995 | |||
11996 | case PacketType.ObjectExtraParams: | ||
11997 | ObjectExtraParamsPacket extraPar = (ObjectExtraParamsPacket)Pack; | ||
11998 | |||
11999 | #region Packet Session and User Check | ||
12000 | if (m_checkPackets) | ||
12001 | { | ||
12002 | if (extraPar.AgentData.SessionID != SessionId || | ||
12003 | extraPar.AgentData.AgentID != AgentId) | ||
12004 | break; | ||
12005 | } | ||
12006 | #endregion | ||
12007 | |||
12008 | ObjectExtraParams handlerUpdateExtraParams = OnUpdateExtraParams; | ||
12009 | if (handlerUpdateExtraParams != null) | ||
12010 | { | ||
12011 | for (int i = 0; i < extraPar.ObjectData.Length; i++) | ||
12012 | { | ||
12013 | handlerUpdateExtraParams(m_agentId, extraPar.ObjectData[i].ObjectLocalID, | ||
12014 | extraPar.ObjectData[i].ParamType, | ||
12015 | extraPar.ObjectData[i].ParamInUse, extraPar.ObjectData[i].ParamData); | ||
12016 | } | ||
12017 | } | ||
12018 | break; | ||
12019 | |||
12020 | case PacketType.ObjectDuplicate: | ||
12021 | ObjectDuplicatePacket dupe = (ObjectDuplicatePacket)Pack; | ||
12022 | |||
12023 | #region Packet Session and User Check | ||
12024 | if (m_checkPackets) | ||
12025 | { | ||
12026 | if (dupe.AgentData.SessionID != SessionId || | ||
12027 | dupe.AgentData.AgentID != AgentId) | ||
12028 | break; | ||
12029 | } | ||
12030 | #endregion | ||
12031 | |||
12032 | ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData; | ||
12033 | |||
12034 | ObjectDuplicate handlerObjectDuplicate = null; | ||
12035 | |||
12036 | for (int i = 0; i < dupe.ObjectData.Length; i++) | ||
12037 | { | ||
12038 | handlerObjectDuplicate = OnObjectDuplicate; | ||
12039 | if (handlerObjectDuplicate != null) | ||
12040 | { | ||
12041 | handlerObjectDuplicate(dupe.ObjectData[i].ObjectLocalID, dupe.SharedData.Offset, | ||
12042 | dupe.SharedData.DuplicateFlags, AgentandGroupData.AgentID, | ||
12043 | AgentandGroupData.GroupID); | ||
12044 | } | ||
12045 | } | ||
12046 | |||
12047 | break; | ||
12048 | |||
12049 | case PacketType.RequestMultipleObjects: | ||
12050 | RequestMultipleObjectsPacket incomingRequest = (RequestMultipleObjectsPacket)Pack; | ||
12051 | |||
12052 | #region Packet Session and User Check | ||
12053 | if (m_checkPackets) | ||
12054 | { | ||
12055 | if (incomingRequest.AgentData.SessionID != SessionId || | ||
12056 | incomingRequest.AgentData.AgentID != AgentId) | ||
12057 | break; | ||
12058 | } | ||
12059 | #endregion | ||
12060 | |||
12061 | ObjectRequest handlerObjectRequest = null; | ||
12062 | |||
12063 | for (int i = 0; i < incomingRequest.ObjectData.Length; i++) | ||
12064 | { | ||
12065 | handlerObjectRequest = OnObjectRequest; | ||
12066 | if (handlerObjectRequest != null) | ||
12067 | { | ||
12068 | handlerObjectRequest(incomingRequest.ObjectData[i].ID, this); | ||
12069 | } | ||
12070 | } | ||
12071 | break; | ||
12072 | |||
12073 | case PacketType.ObjectSelect: | ||
12074 | ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack; | ||
12075 | |||
12076 | #region Packet Session and User Check | ||
12077 | if (m_checkPackets) | ||
12078 | { | ||
12079 | if (incomingselect.AgentData.SessionID != SessionId || | ||
12080 | incomingselect.AgentData.AgentID != AgentId) | ||
12081 | break; | ||
12082 | } | ||
12083 | #endregion | ||
12084 | |||
12085 | ObjectSelect handlerObjectSelect = null; | ||
12086 | |||
12087 | for (int i = 0; i < incomingselect.ObjectData.Length; i++) | ||
12088 | { | ||
12089 | handlerObjectSelect = OnObjectSelect; | ||
12090 | if (handlerObjectSelect != null) | ||
12091 | { | ||
12092 | handlerObjectSelect(incomingselect.ObjectData[i].ObjectLocalID, this); | ||
12093 | } | ||
12094 | } | ||
12095 | break; | ||
12096 | |||
12097 | case PacketType.ObjectDeselect: | ||
12098 | ObjectDeselectPacket incomingdeselect = (ObjectDeselectPacket)Pack; | ||
12099 | |||
12100 | #region Packet Session and User Check | ||
12101 | if (m_checkPackets) | ||
12102 | { | ||
12103 | if (incomingdeselect.AgentData.SessionID != SessionId || | ||
12104 | incomingdeselect.AgentData.AgentID != AgentId) | ||
12105 | break; | ||
12106 | } | ||
12107 | #endregion | ||
12108 | |||
12109 | ObjectDeselect handlerObjectDeselect = null; | ||
12110 | |||
12111 | for (int i = 0; i < incomingdeselect.ObjectData.Length; i++) | ||
12112 | { | ||
12113 | handlerObjectDeselect = OnObjectDeselect; | ||
12114 | if (handlerObjectDeselect != null) | ||
12115 | { | ||
12116 | OnObjectDeselect(incomingdeselect.ObjectData[i].ObjectLocalID, this); | ||
12117 | } | ||
12118 | } | ||
12119 | break; | ||
12120 | |||
12121 | case PacketType.ObjectPosition: | ||
12122 | // DEPRECATED: but till libsecondlife removes it, people will use it | ||
12123 | ObjectPositionPacket position = (ObjectPositionPacket)Pack; | ||
12124 | |||
12125 | #region Packet Session and User Check | ||
12126 | if (m_checkPackets) | ||
12127 | { | ||
12128 | if (position.AgentData.SessionID != SessionId || | ||
12129 | position.AgentData.AgentID != AgentId) | ||
12130 | break; | ||
12131 | } | ||
12132 | #endregion | ||
12133 | |||
12134 | |||
12135 | for (int i = 0; i < position.ObjectData.Length; i++) | ||
12136 | { | ||
12137 | UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition; | ||
12138 | if (handlerUpdateVector != null) | ||
12139 | handlerUpdateVector(position.ObjectData[i].ObjectLocalID, position.ObjectData[i].Position, this); | ||
12140 | } | ||
12141 | |||
12142 | break; | ||
12143 | |||
12144 | case PacketType.ObjectScale: | ||
12145 | // DEPRECATED: but till libsecondlife removes it, people will use it | ||
12146 | ObjectScalePacket scale = (ObjectScalePacket)Pack; | ||
12147 | |||
12148 | #region Packet Session and User Check | ||
12149 | if (m_checkPackets) | ||
12150 | { | ||
12151 | if (scale.AgentData.SessionID != SessionId || | ||
12152 | scale.AgentData.AgentID != AgentId) | ||
12153 | break; | ||
12154 | } | ||
12155 | #endregion | ||
12156 | |||
12157 | for (int i = 0; i < scale.ObjectData.Length; i++) | ||
12158 | { | ||
12159 | UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale; | ||
12160 | if (handlerUpdatePrimGroupScale != null) | ||
12161 | handlerUpdatePrimGroupScale(scale.ObjectData[i].ObjectLocalID, scale.ObjectData[i].Scale, this); | ||
12162 | } | ||
12163 | |||
12164 | break; | ||
12165 | |||
12166 | case PacketType.ObjectRotation: | ||
12167 | // DEPRECATED: but till libsecondlife removes it, people will use it | ||
12168 | ObjectRotationPacket rotation = (ObjectRotationPacket)Pack; | ||
12169 | |||
12170 | #region Packet Session and User Check | ||
12171 | if (m_checkPackets) | ||
12172 | { | ||
12173 | if (rotation.AgentData.SessionID != SessionId || | ||
12174 | rotation.AgentData.AgentID != AgentId) | ||
12175 | break; | ||
12176 | } | ||
12177 | #endregion | ||
12178 | |||
12179 | for (int i = 0; i < rotation.ObjectData.Length; i++) | ||
12180 | { | ||
12181 | UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation; | ||
12182 | if (handlerUpdatePrimRotation != null) | ||
12183 | handlerUpdatePrimRotation(rotation.ObjectData[i].ObjectLocalID, rotation.ObjectData[i].Rotation, this); | ||
12184 | } | ||
12185 | |||
12186 | break; | ||
12187 | |||
12188 | case PacketType.ObjectFlagUpdate: | ||
12189 | ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack; | ||
12190 | |||
12191 | #region Packet Session and User Check | ||
12192 | if (m_checkPackets) | ||
12193 | { | ||
12194 | if (flags.AgentData.SessionID != SessionId || | ||
12195 | flags.AgentData.AgentID != AgentId) | ||
12196 | break; | ||
12197 | } | ||
12198 | #endregion | ||
12199 | |||
12200 | UpdatePrimFlags handlerUpdatePrimFlags = OnUpdatePrimFlags; | ||
12201 | |||
12202 | if (handlerUpdatePrimFlags != null) | ||
12203 | { | ||
12204 | byte[] data = Pack.ToBytes(); | ||
12205 | // 46,47,48 are special positions within the packet | ||
12206 | // This may change so perhaps we need a better way | ||
12207 | // of storing this (OMV.FlagUpdatePacket.UsePhysics,etc?) | ||
12208 | bool UsePhysics = (data[46] != 0) ? true : false; | ||
12209 | bool IsTemporary = (data[47] != 0) ? true : false; | ||
12210 | bool IsPhantom = (data[48] != 0) ? true : false; | ||
12211 | handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, this); | ||
12212 | } | ||
12213 | break; | ||
12214 | case PacketType.ObjectImage: | ||
12215 | ObjectImagePacket imagePack = (ObjectImagePacket)Pack; | ||
12216 | |||
12217 | UpdatePrimTexture handlerUpdatePrimTexture = null; | ||
12218 | for (int i = 0; i < imagePack.ObjectData.Length; i++) | ||
12219 | { | ||
12220 | handlerUpdatePrimTexture = OnUpdatePrimTexture; | ||
12221 | if (handlerUpdatePrimTexture != null) | ||
12222 | { | ||
12223 | handlerUpdatePrimTexture(imagePack.ObjectData[i].ObjectLocalID, | ||
12224 | imagePack.ObjectData[i].TextureEntry, this); | ||
12225 | } | ||
12226 | } | ||
12227 | break; | ||
12228 | |||
12229 | case PacketType.ObjectGrab: | ||
12230 | ObjectGrabPacket grab = (ObjectGrabPacket)Pack; | ||
12231 | |||
12232 | #region Packet Session and User Check | ||
12233 | if (m_checkPackets) | ||
12234 | { | ||
12235 | if (grab.AgentData.SessionID != SessionId || | ||
12236 | grab.AgentData.AgentID != AgentId) | ||
12237 | break; | ||
12238 | } | ||
12239 | #endregion | ||
12240 | |||
12241 | GrabObject handlerGrabObject = OnGrabObject; | ||
12242 | |||
12243 | if (handlerGrabObject != null) | ||
12244 | { | ||
12245 | List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>(); | ||
12246 | if ((grab.SurfaceInfo != null) && (grab.SurfaceInfo.Length > 0)) | ||
12247 | { | ||
12248 | foreach (ObjectGrabPacket.SurfaceInfoBlock surfaceInfo in grab.SurfaceInfo) | ||
12249 | { | ||
12250 | SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs(); | ||
12251 | arg.Binormal = surfaceInfo.Binormal; | ||
12252 | arg.FaceIndex = surfaceInfo.FaceIndex; | ||
12253 | arg.Normal = surfaceInfo.Normal; | ||
12254 | arg.Position = surfaceInfo.Position; | ||
12255 | arg.STCoord = surfaceInfo.STCoord; | ||
12256 | arg.UVCoord = surfaceInfo.UVCoord; | ||
12257 | touchArgs.Add(arg); | ||
12258 | } | ||
12259 | } | ||
12260 | handlerGrabObject(grab.ObjectData.LocalID, grab.ObjectData.GrabOffset, this, touchArgs); | ||
12261 | } | ||
12262 | break; | ||
12263 | |||
12264 | case PacketType.ObjectGrabUpdate: | ||
12265 | ObjectGrabUpdatePacket grabUpdate = (ObjectGrabUpdatePacket)Pack; | ||
12266 | |||
12267 | #region Packet Session and User Check | ||
12268 | if (m_checkPackets) | ||
12269 | { | ||
12270 | if (grabUpdate.AgentData.SessionID != SessionId || | ||
12271 | grabUpdate.AgentData.AgentID != AgentId) | ||
12272 | break; | ||
12273 | } | ||
12274 | #endregion | ||
12275 | |||
12276 | MoveObject handlerGrabUpdate = OnGrabUpdate; | ||
12277 | |||
12278 | if (handlerGrabUpdate != null) | ||
12279 | { | ||
12280 | List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>(); | ||
12281 | if ((grabUpdate.SurfaceInfo != null) && (grabUpdate.SurfaceInfo.Length > 0)) | ||
12282 | { | ||
12283 | foreach (ObjectGrabUpdatePacket.SurfaceInfoBlock surfaceInfo in grabUpdate.SurfaceInfo) | ||
12284 | { | ||
12285 | SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs(); | ||
12286 | arg.Binormal = surfaceInfo.Binormal; | ||
12287 | arg.FaceIndex = surfaceInfo.FaceIndex; | ||
12288 | arg.Normal = surfaceInfo.Normal; | ||
12289 | arg.Position = surfaceInfo.Position; | ||
12290 | arg.STCoord = surfaceInfo.STCoord; | ||
12291 | arg.UVCoord = surfaceInfo.UVCoord; | ||
12292 | touchArgs.Add(arg); | ||
12293 | } | ||
12294 | } | ||
12295 | handlerGrabUpdate(grabUpdate.ObjectData.ObjectID, grabUpdate.ObjectData.GrabOffsetInitial, | ||
12296 | grabUpdate.ObjectData.GrabPosition, this, touchArgs); | ||
12297 | } | ||
12298 | break; | ||
12299 | |||
12300 | case PacketType.ObjectDeGrab: | ||
12301 | ObjectDeGrabPacket deGrab = (ObjectDeGrabPacket)Pack; | ||
12302 | |||
12303 | #region Packet Session and User Check | ||
12304 | if (m_checkPackets) | ||
12305 | { | ||
12306 | if (deGrab.AgentData.SessionID != SessionId || | ||
12307 | deGrab.AgentData.AgentID != AgentId) | ||
12308 | break; | ||
12309 | } | ||
12310 | #endregion | ||
12311 | |||
12312 | DeGrabObject handlerDeGrabObject = OnDeGrabObject; | ||
12313 | if (handlerDeGrabObject != null) | ||
12314 | { | ||
12315 | List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>(); | ||
12316 | if ((deGrab.SurfaceInfo != null) && (deGrab.SurfaceInfo.Length > 0)) | ||
12317 | { | ||
12318 | foreach (ObjectDeGrabPacket.SurfaceInfoBlock surfaceInfo in deGrab.SurfaceInfo) | ||
12319 | { | ||
12320 | SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs(); | ||
12321 | arg.Binormal = surfaceInfo.Binormal; | ||
12322 | arg.FaceIndex = surfaceInfo.FaceIndex; | ||
12323 | arg.Normal = surfaceInfo.Normal; | ||
12324 | arg.Position = surfaceInfo.Position; | ||
12325 | arg.STCoord = surfaceInfo.STCoord; | ||
12326 | arg.UVCoord = surfaceInfo.UVCoord; | ||
12327 | touchArgs.Add(arg); | ||
12328 | } | ||
12329 | } | ||
12330 | handlerDeGrabObject(deGrab.ObjectData.LocalID, this, touchArgs); | ||
12331 | } | ||
12332 | break; | ||
12333 | |||
12334 | case PacketType.ObjectSpinStart: | ||
12335 | //m_log.Warn("[CLIENT]: unhandled ObjectSpinStart packet"); | ||
12336 | ObjectSpinStartPacket spinStart = (ObjectSpinStartPacket)Pack; | ||
12337 | |||
12338 | #region Packet Session and User Check | ||
12339 | if (m_checkPackets) | ||
12340 | { | ||
12341 | if (spinStart.AgentData.SessionID != SessionId || | ||
12342 | spinStart.AgentData.AgentID != AgentId) | ||
12343 | break; | ||
12344 | } | ||
12345 | #endregion | ||
12346 | |||
12347 | SpinStart handlerSpinStart = OnSpinStart; | ||
12348 | if (handlerSpinStart != null) | ||
12349 | { | ||
12350 | handlerSpinStart(spinStart.ObjectData.ObjectID, this); | ||
12351 | } | ||
12352 | break; | ||
12353 | case PacketType.ObjectSpinUpdate: | ||
12354 | //m_log.Warn("[CLIENT]: unhandled ObjectSpinUpdate packet"); | ||
12355 | ObjectSpinUpdatePacket spinUpdate = (ObjectSpinUpdatePacket)Pack; | ||
12356 | |||
12357 | #region Packet Session and User Check | ||
12358 | if (m_checkPackets) | ||
12359 | { | ||
12360 | if (spinUpdate.AgentData.SessionID != SessionId || | ||
12361 | spinUpdate.AgentData.AgentID != AgentId) | ||
12362 | break; | ||
12363 | } | ||
12364 | #endregion | ||
12365 | |||
12366 | Vector3 axis; | ||
12367 | float angle; | ||
12368 | spinUpdate.ObjectData.Rotation.GetAxisAngle(out axis, out angle); | ||
12369 | //m_log.Warn("[CLIENT]: ObjectSpinUpdate packet rot axis:" + axis + " angle:" + angle); | ||
12370 | |||
12371 | SpinObject handlerSpinUpdate = OnSpinUpdate; | ||
12372 | if (handlerSpinUpdate != null) | ||
12373 | { | ||
12374 | handlerSpinUpdate(spinUpdate.ObjectData.ObjectID, spinUpdate.ObjectData.Rotation, this); | ||
12375 | } | ||
12376 | break; | ||
12377 | |||
12378 | |||
12379 | case PacketType.ObjectSpinStop: | ||
12380 | //m_log.Warn("[CLIENT]: unhandled ObjectSpinStop packet"); | ||
12381 | ObjectSpinStopPacket spinStop = (ObjectSpinStopPacket)Pack; | ||
12382 | |||
12383 | #region Packet Session and User Check | ||
12384 | if (m_checkPackets) | ||
12385 | { | ||
12386 | if (spinStop.AgentData.SessionID != SessionId || | ||
12387 | spinStop.AgentData.AgentID != AgentId) | ||
12388 | break; | ||
12389 | } | ||
12390 | #endregion | ||
12391 | |||
12392 | SpinStop handlerSpinStop = OnSpinStop; | ||
12393 | if (handlerSpinStop != null) | ||
12394 | { | ||
12395 | handlerSpinStop(spinStop.ObjectData.ObjectID, this); | ||
12396 | } | ||
12397 | break; | ||
12398 | |||
12399 | case PacketType.ObjectDescription: | ||
12400 | ObjectDescriptionPacket objDes = (ObjectDescriptionPacket)Pack; | ||
12401 | |||
12402 | #region Packet Session and User Check | ||
12403 | if (m_checkPackets) | ||
12404 | { | ||
12405 | if (objDes.AgentData.SessionID != SessionId || | ||
12406 | objDes.AgentData.AgentID != AgentId) | ||
12407 | break; | ||
12408 | } | ||
12409 | #endregion | ||
12410 | |||
12411 | GenericCall7 handlerObjectDescription = null; | ||
12412 | |||
12413 | for (int i = 0; i < objDes.ObjectData.Length; i++) | ||
12414 | { | ||
12415 | handlerObjectDescription = OnObjectDescription; | ||
12416 | if (handlerObjectDescription != null) | ||
12417 | { | ||
12418 | handlerObjectDescription(this, objDes.ObjectData[i].LocalID, | ||
12419 | Util.FieldToString(objDes.ObjectData[i].Description)); | ||
12420 | } | ||
12421 | } | ||
12422 | break; | ||
12423 | |||
12424 | case PacketType.ObjectName: | ||
12425 | ObjectNamePacket objName = (ObjectNamePacket)Pack; | ||
12426 | |||
12427 | #region Packet Session and User Check | ||
12428 | if (m_checkPackets) | ||
12429 | { | ||
12430 | if (objName.AgentData.SessionID != SessionId || | ||
12431 | objName.AgentData.AgentID != AgentId) | ||
12432 | break; | ||
12433 | } | ||
12434 | #endregion | ||
12435 | |||
12436 | GenericCall7 handlerObjectName = null; | ||
12437 | for (int i = 0; i < objName.ObjectData.Length; i++) | ||
12438 | { | ||
12439 | handlerObjectName = OnObjectName; | ||
12440 | if (handlerObjectName != null) | ||
12441 | { | ||
12442 | handlerObjectName(this, objName.ObjectData[i].LocalID, | ||
12443 | Util.FieldToString(objName.ObjectData[i].Name)); | ||
12444 | } | ||
12445 | } | ||
12446 | break; | ||
12447 | |||
12448 | case PacketType.ObjectPermissions: | ||
12449 | if (OnObjectPermissions != null) | ||
12450 | { | ||
12451 | ObjectPermissionsPacket newobjPerms = (ObjectPermissionsPacket)Pack; | ||
12452 | |||
12453 | #region Packet Session and User Check | ||
12454 | if (m_checkPackets) | ||
12455 | { | ||
12456 | if (newobjPerms.AgentData.SessionID != SessionId || | ||
12457 | newobjPerms.AgentData.AgentID != AgentId) | ||
12458 | break; | ||
12459 | } | ||
12460 | #endregion | ||
12461 | |||
12462 | UUID AgentID = newobjPerms.AgentData.AgentID; | ||
12463 | UUID SessionID = newobjPerms.AgentData.SessionID; | ||
12464 | |||
12465 | ObjectPermissions handlerObjectPermissions = null; | ||
12466 | |||
12467 | for (int i = 0; i < newobjPerms.ObjectData.Length; i++) | ||
12468 | { | ||
12469 | ObjectPermissionsPacket.ObjectDataBlock permChanges = newobjPerms.ObjectData[i]; | ||
12470 | |||
12471 | byte field = permChanges.Field; | ||
12472 | uint localID = permChanges.ObjectLocalID; | ||
12473 | uint mask = permChanges.Mask; | ||
12474 | byte set = permChanges.Set; | ||
12475 | |||
12476 | handlerObjectPermissions = OnObjectPermissions; | ||
12477 | |||
12478 | if (handlerObjectPermissions != null) | ||
12479 | handlerObjectPermissions(this, AgentID, SessionID, field, localID, mask, set); | ||
12480 | } | ||
12481 | } | ||
12482 | |||
12483 | // Here's our data, | ||
12484 | // PermField contains the field the info goes into | ||
12485 | // PermField determines which mask we're changing | ||
12486 | // | ||
12487 | // chmask is the mask of the change | ||
12488 | // setTF is whether we're adding it or taking it away | ||
12489 | // | ||
12490 | // objLocalID is the localID of the object. | ||
12491 | |||
12492 | // Unfortunately, we have to pass the event the packet because objData is an array | ||
12493 | // That means multiple object perms may be updated in a single packet. | ||
12494 | |||
12495 | break; | ||
12496 | |||
12497 | case PacketType.Undo: | ||
12498 | UndoPacket undoitem = (UndoPacket)Pack; | ||
12499 | |||
12500 | #region Packet Session and User Check | ||
12501 | if (m_checkPackets) | ||
12502 | { | ||
12503 | if (undoitem.AgentData.SessionID != SessionId || | ||
12504 | undoitem.AgentData.AgentID != AgentId) | ||
12505 | break; | ||
12506 | } | ||
12507 | #endregion | ||
12508 | |||
12509 | if (undoitem.ObjectData.Length > 0) | ||
12510 | { | ||
12511 | for (int i = 0; i < undoitem.ObjectData.Length; i++) | ||
12512 | { | ||
12513 | UUID objiD = undoitem.ObjectData[i].ObjectID; | ||
12514 | AgentSit handlerOnUndo = OnUndo; | ||
12515 | if (handlerOnUndo != null) | ||
12516 | { | ||
12517 | handlerOnUndo(this, objiD); | ||
12518 | } | ||
12519 | |||
12520 | } | ||
12521 | } | ||
12522 | break; | ||
12523 | |||
12524 | case PacketType.ObjectDuplicateOnRay: | ||
12525 | ObjectDuplicateOnRayPacket dupeOnRay = (ObjectDuplicateOnRayPacket)Pack; | ||
12526 | |||
12527 | #region Packet Session and User Check | ||
12528 | if (m_checkPackets) | ||
12529 | { | ||
12530 | if (dupeOnRay.AgentData.SessionID != SessionId || | ||
12531 | dupeOnRay.AgentData.AgentID != AgentId) | ||
12532 | break; | ||
12533 | } | ||
12534 | #endregion | ||
12535 | |||
12536 | ObjectDuplicateOnRay handlerObjectDuplicateOnRay = null; | ||
12537 | |||
12538 | for (int i = 0; i < dupeOnRay.ObjectData.Length; i++) | ||
12539 | { | ||
12540 | handlerObjectDuplicateOnRay = OnObjectDuplicateOnRay; | ||
12541 | if (handlerObjectDuplicateOnRay != null) | ||
12542 | { | ||
12543 | handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID, dupeOnRay.AgentData.DuplicateFlags, | ||
12544 | dupeOnRay.AgentData.AgentID, dupeOnRay.AgentData.GroupID, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd, | ||
12545 | dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast, dupeOnRay.AgentData.RayEndIsIntersection, | ||
12546 | dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates); | ||
12547 | } | ||
12548 | } | ||
12549 | |||
12550 | break; | ||
12551 | |||
12552 | case PacketType.RequestObjectPropertiesFamily: | ||
12553 | //This powers the little tooltip that appears when you move your mouse over an object | ||
12554 | RequestObjectPropertiesFamilyPacket packToolTip = (RequestObjectPropertiesFamilyPacket)Pack; | ||
12555 | |||
12556 | #region Packet Session and User Check | ||
12557 | if (m_checkPackets) | ||
12558 | { | ||
12559 | if (packToolTip.AgentData.SessionID != SessionId || | ||
12560 | packToolTip.AgentData.AgentID != AgentId) | ||
12561 | break; | ||
12562 | } | ||
12563 | #endregion | ||
12564 | |||
12565 | RequestObjectPropertiesFamilyPacket.ObjectDataBlock packObjBlock = packToolTip.ObjectData; | ||
12566 | |||
12567 | RequestObjectPropertiesFamily handlerRequestObjectPropertiesFamily = OnRequestObjectPropertiesFamily; | ||
12568 | |||
12569 | if (handlerRequestObjectPropertiesFamily != null) | ||
12570 | { | ||
12571 | handlerRequestObjectPropertiesFamily(this, m_agentId, packObjBlock.RequestFlags, | ||
12572 | packObjBlock.ObjectID); | ||
12573 | } | ||
12574 | |||
12575 | break; | ||
12576 | |||
12577 | case PacketType.ObjectIncludeInSearch: | ||
12578 | //This lets us set objects to appear in search (stuff like DataSnapshot, etc) | ||
12579 | ObjectIncludeInSearchPacket packInSearch = (ObjectIncludeInSearchPacket)Pack; | ||
12580 | ObjectIncludeInSearch handlerObjectIncludeInSearch = null; | ||
12581 | |||
12582 | #region Packet Session and User Check | ||
12583 | if (m_checkPackets) | ||
12584 | { | ||
12585 | if (packInSearch.AgentData.SessionID != SessionId || | ||
12586 | packInSearch.AgentData.AgentID != AgentId) | ||
12587 | break; | ||
12588 | } | ||
12589 | #endregion | ||
12590 | |||
12591 | foreach (ObjectIncludeInSearchPacket.ObjectDataBlock objData in packInSearch.ObjectData) | ||
12592 | { | ||
12593 | bool inSearch = objData.IncludeInSearch; | ||
12594 | uint localID = objData.ObjectLocalID; | ||
12595 | |||
12596 | handlerObjectIncludeInSearch = OnObjectIncludeInSearch; | ||
12597 | |||
12598 | if (handlerObjectIncludeInSearch != null) | ||
12599 | { | ||
12600 | handlerObjectIncludeInSearch(this, inSearch, localID); | ||
12601 | } | ||
12602 | } | ||
12603 | break; | ||
12604 | |||
12605 | case PacketType.ScriptAnswerYes: | ||
12606 | ScriptAnswerYesPacket scriptAnswer = (ScriptAnswerYesPacket)Pack; | ||
12607 | |||
12608 | #region Packet Session and User Check | ||
12609 | if (m_checkPackets) | ||
12610 | { | ||
12611 | if (scriptAnswer.AgentData.SessionID != SessionId || | ||
12612 | scriptAnswer.AgentData.AgentID != AgentId) | ||
12613 | break; | ||
12614 | } | ||
12615 | #endregion | ||
12616 | |||
12617 | ScriptAnswer handlerScriptAnswer = OnScriptAnswer; | ||
12618 | if (handlerScriptAnswer != null) | ||
12619 | { | ||
12620 | handlerScriptAnswer(this, scriptAnswer.Data.TaskID, scriptAnswer.Data.ItemID, scriptAnswer.Data.Questions); | ||
12621 | } | ||
12622 | break; | ||
12623 | |||
12624 | case PacketType.ObjectClickAction: | ||
12625 | ObjectClickActionPacket ocpacket = (ObjectClickActionPacket)Pack; | ||
12626 | |||
12627 | #region Packet Session and User Check | ||
12628 | if (m_checkPackets) | ||
12629 | { | ||
12630 | if (ocpacket.AgentData.SessionID != SessionId || | ||
12631 | ocpacket.AgentData.AgentID != AgentId) | ||
12632 | break; | ||
12633 | } | ||
12634 | #endregion | ||
12635 | |||
12636 | GenericCall7 handlerObjectClickAction = OnObjectClickAction; | ||
12637 | if (handlerObjectClickAction != null) | ||
12638 | { | ||
12639 | foreach (ObjectClickActionPacket.ObjectDataBlock odata in ocpacket.ObjectData) | ||
12640 | { | ||
12641 | byte action = odata.ClickAction; | ||
12642 | uint localID = odata.ObjectLocalID; | ||
12643 | handlerObjectClickAction(this, localID, action.ToString()); | ||
12644 | } | ||
12645 | } | ||
12646 | break; | ||
12647 | |||
12648 | case PacketType.ObjectMaterial: | ||
12649 | ObjectMaterialPacket ompacket = (ObjectMaterialPacket)Pack; | ||
12650 | |||
12651 | #region Packet Session and User Check | ||
12652 | if (m_checkPackets) | ||
12653 | { | ||
12654 | if (ompacket.AgentData.SessionID != SessionId || | ||
12655 | ompacket.AgentData.AgentID != AgentId) | ||
12656 | break; | ||
12657 | } | ||
12658 | #endregion | ||
12659 | |||
12660 | GenericCall7 handlerObjectMaterial = OnObjectMaterial; | ||
12661 | if (handlerObjectMaterial != null) | ||
12662 | { | ||
12663 | foreach (ObjectMaterialPacket.ObjectDataBlock odata in ompacket.ObjectData) | ||
12664 | { | ||
12665 | byte material = odata.Material; | ||
12666 | uint localID = odata.ObjectLocalID; | ||
12667 | handlerObjectMaterial(this, localID, material.ToString()); | ||
12668 | } | ||
12669 | } | ||
12670 | break; | ||
12671 | |||
12672 | //#endregion | ||
12673 | |||
12674 | //#region Inventory/Asset/Other related packets | ||
12675 | |||
12676 | case PacketType.RequestImage: | ||
12677 | RequestImagePacket imageRequest = (RequestImagePacket)Pack; | ||
12678 | //m_log.Debug("image request: " + Pack.ToString()); | ||
12679 | |||
12680 | #region Packet Session and User Check | ||
12681 | if (m_checkPackets) | ||
12682 | { | ||
12683 | if (imageRequest.AgentData.SessionID != SessionId || | ||
12684 | imageRequest.AgentData.AgentID != AgentId) | ||
12685 | break; | ||
12686 | } | ||
12687 | #endregion | ||
12688 | |||
12689 | //handlerTextureRequest = null; | ||
12690 | for (int i = 0; i < imageRequest.RequestImage.Length; i++) | ||
12691 | { | ||
12692 | if (OnRequestTexture != null) | ||
12693 | { | ||
12694 | TextureRequestArgs args = new TextureRequestArgs(); | ||
12695 | |||
12696 | RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i]; | ||
12697 | |||
12698 | args.RequestedAssetID = block.Image; | ||
12699 | args.DiscardLevel = block.DiscardLevel; | ||
12700 | args.PacketNumber = block.Packet; | ||
12701 | args.Priority = block.DownloadPriority; | ||
12702 | args.requestSequence = imageRequest.Header.Sequence; | ||
12703 | |||
12704 | // NOTE: This is not a built in part of the LLUDP protocol, but we double the | ||
12705 | // priority of avatar textures to get avatars rezzing in faster than the | ||
12706 | // surrounding scene | ||
12707 | if ((ImageType)block.Type == ImageType.Baked) | ||
12708 | args.Priority *= 2.0f; | ||
12709 | |||
12710 | //handlerTextureRequest = OnRequestTexture; | ||
12711 | |||
12712 | //if (handlerTextureRequest != null) | ||
12713 | //OnRequestTexture(this, args); | ||
12714 | |||
12715 | // in the end, we null this, so we have to check if it's null | ||
12716 | if (m_imageManager != null) | ||
12717 | { | ||
12718 | m_imageManager.EnqueueReq(args); | ||
12719 | } | ||
12720 | } | ||
12721 | } | ||
12722 | break; | ||
12723 | |||
12724 | case PacketType.TransferRequest: | ||
12725 | //m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request"); | ||
12726 | |||
12727 | TransferRequestPacket transfer = (TransferRequestPacket)Pack; | ||
12728 | //m_log.Debug("Transfer Request: " + transfer.ToString()); | ||
12729 | // Validate inventory transfers | ||
12730 | // Has to be done here, because AssetCache can't do it | ||
12731 | // | ||
12732 | UUID taskID = UUID.Zero; | ||
12733 | if (transfer.TransferInfo.SourceType == 3) | ||
12734 | { | ||
12735 | taskID = new UUID(transfer.TransferInfo.Params, 48); | ||
12736 | UUID itemID = new UUID(transfer.TransferInfo.Params, 64); | ||
12737 | UUID requestID = new UUID(transfer.TransferInfo.Params, 80); | ||
12738 | if (!(((Scene)m_scene).Permissions.BypassPermissions())) | ||
12739 | { | ||
12740 | if (taskID != UUID.Zero) // Prim | ||
12741 | { | ||
12742 | SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID); | ||
12743 | if (part == null) | ||
12744 | break; | ||
12745 | |||
12746 | if (part.OwnerID != AgentId) | ||
12747 | break; | ||
12748 | |||
12749 | if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0) | ||
12750 | break; | ||
12751 | |||
12752 | TaskInventoryItem ti = part.Inventory.GetInventoryItem(itemID); | ||
12753 | if (ti == null) | ||
12754 | break; | ||
12755 | |||
12756 | if (ti.OwnerID != AgentId) | ||
12757 | break; | ||
12758 | |||
12759 | if ((ti.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) | ||
12760 | break; | ||
12761 | |||
12762 | if (ti.AssetID != requestID) | ||
12763 | break; | ||
12764 | } | ||
12765 | else // Agent | ||
12766 | { | ||
12767 | IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>(); | ||
12768 | InventoryItemBase assetRequestItem = new InventoryItemBase(itemID, AgentId); | ||
12769 | assetRequestItem = invService.GetItem(assetRequestItem); | ||
12770 | if (assetRequestItem == null) | ||
12771 | { | ||
12772 | assetRequestItem = ((Scene)m_scene).CommsManager.UserProfileCacheService.LibraryRoot.FindItem(itemID); | ||
12773 | if (assetRequestItem == null) | ||
12774 | return; | ||
12775 | } | ||
12776 | |||
12777 | // At this point, we need to apply perms | ||
12778 | // only to notecards and scripts. All | ||
12779 | // other asset types are always available | ||
12780 | // | ||
12781 | if (assetRequestItem.AssetType == 10) | ||
12782 | { | ||
12783 | if (!((Scene)m_scene).Permissions.CanViewScript(itemID, UUID.Zero, AgentId)) | ||
12784 | { | ||
12785 | SendAgentAlertMessage("Insufficient permissions to view script", false); | ||
12786 | break; | ||
12787 | } | ||
12788 | } | ||
12789 | else if (assetRequestItem.AssetType == 7) | ||
12790 | { | ||
12791 | if (!((Scene)m_scene).Permissions.CanViewNotecard(itemID, UUID.Zero, AgentId)) | ||
12792 | { | ||
12793 | SendAgentAlertMessage("Insufficient permissions to view notecard", false); | ||
12794 | break; | ||
12795 | } | ||
12796 | } | ||
12797 | |||
12798 | if (assetRequestItem.AssetID != requestID) | ||
12799 | break; | ||
12800 | } | ||
12801 | } | ||
12802 | } | ||
12803 | |||
12804 | //m_assetCache.AddAssetRequest(this, transfer); | ||
12805 | |||
12806 | MakeAssetRequest(transfer, taskID); | ||
12807 | |||
12808 | // RequestAsset = OnRequestAsset; | ||
12809 | // if (RequestAsset != null) | ||
12810 | // { | ||
12811 | // RequestAsset(this, transfer); | ||
12812 | // } | ||
12813 | |||
12814 | break; | ||
12815 | |||
12816 | case PacketType.AssetUploadRequest: | ||
12817 | AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack; | ||
12818 | |||
12819 | |||
12820 | // m_log.Debug("upload request " + request.ToString()); | ||
12821 | // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString()); | ||
12822 | UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId); | ||
12823 | |||
12824 | UDPAssetUploadRequest handlerAssetUploadRequest = OnAssetUploadRequest; | ||
12825 | |||
12826 | if (handlerAssetUploadRequest != null) | ||
12827 | { | ||
12828 | handlerAssetUploadRequest(this, temp, | ||
12829 | request.AssetBlock.TransactionID, request.AssetBlock.Type, | ||
12830 | request.AssetBlock.AssetData, request.AssetBlock.StoreLocal, | ||
12831 | request.AssetBlock.Tempfile); | ||
12832 | } | ||
12833 | break; | ||
12834 | |||
12835 | case PacketType.RequestXfer: | ||
12836 | RequestXferPacket xferReq = (RequestXferPacket)Pack; | ||
12837 | |||
12838 | RequestXfer handlerRequestXfer = OnRequestXfer; | ||
12839 | |||
12840 | if (handlerRequestXfer != null) | ||
12841 | { | ||
12842 | handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename)); | ||
12843 | } | ||
12844 | break; | ||
12845 | |||
12846 | case PacketType.SendXferPacket: | ||
12847 | SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack; | ||
12848 | |||
12849 | XferReceive handlerXferReceive = OnXferReceive; | ||
12850 | if (handlerXferReceive != null) | ||
12851 | { | ||
12852 | handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data); | ||
12853 | } | ||
12854 | break; | ||
12855 | |||
12856 | case PacketType.ConfirmXferPacket: | ||
12857 | ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack; | ||
12858 | |||
12859 | ConfirmXfer handlerConfirmXfer = OnConfirmXfer; | ||
12860 | if (handlerConfirmXfer != null) | ||
12861 | { | ||
12862 | handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet); | ||
12863 | } | ||
12864 | break; | ||
12865 | |||
12866 | case PacketType.AbortXfer: | ||
12867 | AbortXferPacket abortXfer = (AbortXferPacket)Pack; | ||
12868 | AbortXfer handlerAbortXfer = OnAbortXfer; | ||
12869 | if (handlerAbortXfer != null) | ||
12870 | { | ||
12871 | handlerAbortXfer(this, abortXfer.XferID.ID); | ||
12872 | } | ||
12873 | |||
12874 | break; | ||
12875 | |||
12876 | case PacketType.CreateInventoryFolder: | ||
12877 | CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack; | ||
12878 | |||
12879 | #region Packet Session and User Check | ||
12880 | if (m_checkPackets) | ||
12881 | { | ||
12882 | if (invFolder.AgentData.SessionID != SessionId || | ||
12883 | invFolder.AgentData.AgentID != AgentId) | ||
12884 | break; | ||
12885 | } | ||
12886 | #endregion | ||
12887 | |||
12888 | CreateInventoryFolder handlerCreateInventoryFolder = OnCreateNewInventoryFolder; | ||
12889 | if (handlerCreateInventoryFolder != null) | ||
12890 | { | ||
12891 | handlerCreateInventoryFolder(this, invFolder.FolderData.FolderID, | ||
12892 | (ushort)invFolder.FolderData.Type, | ||
12893 | Util.FieldToString(invFolder.FolderData.Name), | ||
12894 | invFolder.FolderData.ParentID); | ||
12895 | } | ||
12896 | break; | ||
12897 | |||
12898 | case PacketType.UpdateInventoryFolder: | ||
12899 | if (OnUpdateInventoryFolder != null) | ||
12900 | { | ||
12901 | UpdateInventoryFolderPacket invFolderx = (UpdateInventoryFolderPacket)Pack; | ||
12902 | |||
12903 | #region Packet Session and User Check | ||
12904 | if (m_checkPackets) | ||
12905 | { | ||
12906 | if (invFolderx.AgentData.SessionID != SessionId || | ||
12907 | invFolderx.AgentData.AgentID != AgentId) | ||
12908 | break; | ||
12909 | } | ||
12910 | #endregion | ||
12911 | |||
12912 | UpdateInventoryFolder handlerUpdateInventoryFolder = null; | ||
12913 | |||
12914 | for (int i = 0; i < invFolderx.FolderData.Length; i++) | ||
12915 | { | ||
12916 | handlerUpdateInventoryFolder = OnUpdateInventoryFolder; | ||
12917 | if (handlerUpdateInventoryFolder != null) | ||
12918 | { | ||
12919 | OnUpdateInventoryFolder(this, invFolderx.FolderData[i].FolderID, | ||
12920 | (ushort)invFolderx.FolderData[i].Type, | ||
12921 | Util.FieldToString(invFolderx.FolderData[i].Name), | ||
12922 | invFolderx.FolderData[i].ParentID); | ||
12923 | } | ||
12924 | } | ||
12925 | } | ||
12926 | break; | ||
12927 | |||
12928 | case PacketType.MoveInventoryFolder: | ||
12929 | if (OnMoveInventoryFolder != null) | ||
12930 | { | ||
12931 | MoveInventoryFolderPacket invFoldery = (MoveInventoryFolderPacket)Pack; | ||
12932 | |||
12933 | #region Packet Session and User Check | ||
12934 | if (m_checkPackets) | ||
12935 | { | ||
12936 | if (invFoldery.AgentData.SessionID != SessionId || | ||
12937 | invFoldery.AgentData.AgentID != AgentId) | ||
12938 | break; | ||
12939 | } | ||
12940 | #endregion | ||
12941 | |||
12942 | MoveInventoryFolder handlerMoveInventoryFolder = null; | ||
12943 | |||
12944 | for (int i = 0; i < invFoldery.InventoryData.Length; i++) | ||
12945 | { | ||
12946 | handlerMoveInventoryFolder = OnMoveInventoryFolder; | ||
12947 | if (handlerMoveInventoryFolder != null) | ||
12948 | { | ||
12949 | OnMoveInventoryFolder(this, invFoldery.InventoryData[i].FolderID, | ||
12950 | invFoldery.InventoryData[i].ParentID); | ||
12951 | } | ||
12952 | } | ||
12953 | } | ||
12954 | break; | ||
12955 | |||
12956 | case PacketType.CreateInventoryItem: | ||
12957 | CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack; | ||
12958 | |||
12959 | #region Packet Session and User Check | ||
12960 | if (m_checkPackets) | ||
12961 | { | ||
12962 | if (createItem.AgentData.SessionID != SessionId || | ||
12963 | createItem.AgentData.AgentID != AgentId) | ||
12964 | break; | ||
12965 | } | ||
12966 | #endregion | ||
12967 | |||
12968 | CreateNewInventoryItem handlerCreateNewInventoryItem = OnCreateNewInventoryItem; | ||
12969 | if (handlerCreateNewInventoryItem != null) | ||
12970 | { | ||
12971 | handlerCreateNewInventoryItem(this, createItem.InventoryBlock.TransactionID, | ||
12972 | createItem.InventoryBlock.FolderID, | ||
12973 | createItem.InventoryBlock.CallbackID, | ||
12974 | Util.FieldToString(createItem.InventoryBlock.Description), | ||
12975 | Util.FieldToString(createItem.InventoryBlock.Name), | ||
12976 | createItem.InventoryBlock.InvType, | ||
12977 | createItem.InventoryBlock.Type, | ||
12978 | createItem.InventoryBlock.WearableType, | ||
12979 | createItem.InventoryBlock.NextOwnerMask, | ||
12980 | Util.UnixTimeSinceEpoch()); | ||
12981 | } | ||
12982 | break; | ||
12983 | |||
12984 | case PacketType.FetchInventory: | ||
12985 | if (OnFetchInventory != null) | ||
12986 | { | ||
12987 | FetchInventoryPacket FetchInventoryx = (FetchInventoryPacket)Pack; | ||
12988 | |||
12989 | #region Packet Session and User Check | ||
12990 | if (m_checkPackets) | ||
12991 | { | ||
12992 | if (FetchInventoryx.AgentData.SessionID != SessionId || | ||
12993 | FetchInventoryx.AgentData.AgentID != AgentId) | ||
12994 | break; | ||
12995 | } | ||
12996 | #endregion | ||
12997 | |||
12998 | FetchInventory handlerFetchInventory = null; | ||
12999 | |||
13000 | for (int i = 0; i < FetchInventoryx.InventoryData.Length; i++) | ||
13001 | { | ||
13002 | handlerFetchInventory = OnFetchInventory; | ||
13003 | |||
13004 | if (handlerFetchInventory != null) | ||
13005 | { | ||
13006 | OnFetchInventory(this, FetchInventoryx.InventoryData[i].ItemID, | ||
13007 | FetchInventoryx.InventoryData[i].OwnerID); | ||
13008 | } | ||
13009 | } | ||
13010 | } | ||
13011 | break; | ||
13012 | |||
13013 | case PacketType.FetchInventoryDescendents: | ||
13014 | FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack; | ||
13015 | |||
13016 | #region Packet Session and User Check | ||
13017 | if (m_checkPackets) | ||
13018 | { | ||
13019 | if (Fetch.AgentData.SessionID != SessionId || | ||
13020 | Fetch.AgentData.AgentID != AgentId) | ||
13021 | break; | ||
13022 | } | ||
13023 | #endregion | ||
13024 | |||
13025 | FetchInventoryDescendents handlerFetchInventoryDescendents = OnFetchInventoryDescendents; | ||
13026 | if (handlerFetchInventoryDescendents != null) | ||
13027 | { | ||
13028 | handlerFetchInventoryDescendents(this, Fetch.InventoryData.FolderID, Fetch.InventoryData.OwnerID, | ||
13029 | Fetch.InventoryData.FetchFolders, Fetch.InventoryData.FetchItems, | ||
13030 | Fetch.InventoryData.SortOrder); | ||
13031 | } | ||
13032 | break; | ||
13033 | |||
13034 | case PacketType.PurgeInventoryDescendents: | ||
13035 | PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack; | ||
13036 | |||
13037 | #region Packet Session and User Check | ||
13038 | if (m_checkPackets) | ||
13039 | { | ||
13040 | if (Purge.AgentData.SessionID != SessionId || | ||
13041 | Purge.AgentData.AgentID != AgentId) | ||
13042 | break; | ||
13043 | } | ||
13044 | #endregion | ||
13045 | |||
13046 | PurgeInventoryDescendents handlerPurgeInventoryDescendents = OnPurgeInventoryDescendents; | ||
13047 | if (handlerPurgeInventoryDescendents != null) | ||
13048 | { | ||
13049 | handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID); | ||
13050 | } | ||
13051 | break; | ||
13052 | |||
13053 | case PacketType.UpdateInventoryItem: | ||
13054 | UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack; | ||
13055 | |||
13056 | #region Packet Session and User Check | ||
13057 | if (m_checkPackets) | ||
13058 | { | ||
13059 | if (inventoryItemUpdate.AgentData.SessionID != SessionId || | ||
13060 | inventoryItemUpdate.AgentData.AgentID != AgentId) | ||
13061 | break; | ||
13062 | } | ||
13063 | #endregion | ||
13064 | |||
13065 | if (OnUpdateInventoryItem != null) | ||
13066 | { | ||
13067 | UpdateInventoryItem handlerUpdateInventoryItem = null; | ||
13068 | for (int i = 0; i < inventoryItemUpdate.InventoryData.Length; i++) | ||
13069 | { | ||
13070 | handlerUpdateInventoryItem = OnUpdateInventoryItem; | ||
13071 | |||
13072 | if (handlerUpdateInventoryItem != null) | ||
13073 | { | ||
13074 | InventoryItemBase itemUpd = new InventoryItemBase(); | ||
13075 | itemUpd.ID = inventoryItemUpdate.InventoryData[i].ItemID; | ||
13076 | itemUpd.Name = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Name); | ||
13077 | itemUpd.Description = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Description); | ||
13078 | itemUpd.GroupID = inventoryItemUpdate.InventoryData[i].GroupID; | ||
13079 | itemUpd.GroupOwned = inventoryItemUpdate.InventoryData[i].GroupOwned; | ||
13080 | itemUpd.GroupPermissions = inventoryItemUpdate.InventoryData[i].GroupMask; | ||
13081 | itemUpd.NextPermissions = inventoryItemUpdate.InventoryData[i].NextOwnerMask; | ||
13082 | itemUpd.EveryOnePermissions = inventoryItemUpdate.InventoryData[i].EveryoneMask; | ||
13083 | itemUpd.CreationDate = inventoryItemUpdate.InventoryData[i].CreationDate; | ||
13084 | itemUpd.Folder = inventoryItemUpdate.InventoryData[i].FolderID; | ||
13085 | itemUpd.InvType = inventoryItemUpdate.InventoryData[i].InvType; | ||
13086 | itemUpd.SalePrice = inventoryItemUpdate.InventoryData[i].SalePrice; | ||
13087 | itemUpd.SaleType = inventoryItemUpdate.InventoryData[i].SaleType; | ||
13088 | itemUpd.Flags = inventoryItemUpdate.InventoryData[i].Flags; | ||
13089 | |||
13090 | OnUpdateInventoryItem(this, inventoryItemUpdate.InventoryData[i].TransactionID, | ||
13091 | inventoryItemUpdate.InventoryData[i].ItemID, | ||
13092 | itemUpd); | ||
13093 | } | ||
13094 | } | ||
13095 | } | ||
13096 | break; | ||
13097 | |||
13098 | case PacketType.CopyInventoryItem: | ||
13099 | CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack; | ||
13100 | |||
13101 | #region Packet Session and User Check | ||
13102 | if (m_checkPackets) | ||
13103 | { | ||
13104 | if (copyitem.AgentData.SessionID != SessionId || | ||
13105 | copyitem.AgentData.AgentID != AgentId) | ||
13106 | break; | ||
13107 | } | ||
13108 | #endregion | ||
13109 | |||
13110 | CopyInventoryItem handlerCopyInventoryItem = null; | ||
13111 | if (OnCopyInventoryItem != null) | ||
13112 | { | ||
13113 | foreach (CopyInventoryItemPacket.InventoryDataBlock datablock in copyitem.InventoryData) | ||
13114 | { | ||
13115 | handlerCopyInventoryItem = OnCopyInventoryItem; | ||
13116 | if (handlerCopyInventoryItem != null) | ||
13117 | { | ||
13118 | handlerCopyInventoryItem(this, datablock.CallbackID, datablock.OldAgentID, | ||
13119 | datablock.OldItemID, datablock.NewFolderID, | ||
13120 | Util.FieldToString(datablock.NewName)); | ||
13121 | } | ||
13122 | } | ||
13123 | } | ||
13124 | break; | ||
13125 | |||
13126 | case PacketType.MoveInventoryItem: | ||
13127 | MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack; | ||
13128 | |||
13129 | #region Packet Session and User Check | ||
13130 | if (m_checkPackets) | ||
13131 | { | ||
13132 | if (moveitem.AgentData.SessionID != SessionId || | ||
13133 | moveitem.AgentData.AgentID != AgentId) | ||
13134 | break; | ||
13135 | } | ||
13136 | #endregion | ||
13137 | |||
13138 | if (OnMoveInventoryItem != null) | ||
13139 | { | ||
13140 | MoveInventoryItem handlerMoveInventoryItem = null; | ||
13141 | InventoryItemBase itm = null; | ||
13142 | List<InventoryItemBase> items = new List<InventoryItemBase>(); | ||
13143 | foreach (MoveInventoryItemPacket.InventoryDataBlock datablock in moveitem.InventoryData) | ||
13144 | { | ||
13145 | itm = new InventoryItemBase(datablock.ItemID, AgentId); | ||
13146 | itm.Folder = datablock.FolderID; | ||
13147 | itm.Name = Util.FieldToString(datablock.NewName); | ||
13148 | // weird, comes out as empty string | ||
13149 | //m_log.DebugFormat("[XXX] new name: {0}", itm.Name); | ||
13150 | items.Add(itm); | ||
13151 | } | ||
13152 | handlerMoveInventoryItem = OnMoveInventoryItem; | ||
13153 | if (handlerMoveInventoryItem != null) | ||
13154 | { | ||
13155 | handlerMoveInventoryItem(this, items); | ||
13156 | } | ||
13157 | } | ||
13158 | break; | ||
13159 | |||
13160 | case PacketType.RemoveInventoryItem: | ||
13161 | RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack; | ||
13162 | |||
13163 | #region Packet Session and User Check | ||
13164 | if (m_checkPackets) | ||
13165 | { | ||
13166 | if (removeItem.AgentData.SessionID != SessionId || | ||
13167 | removeItem.AgentData.AgentID != AgentId) | ||
13168 | break; | ||
13169 | } | ||
13170 | #endregion | ||
13171 | |||
13172 | if (OnRemoveInventoryItem != null) | ||
13173 | { | ||
13174 | RemoveInventoryItem handlerRemoveInventoryItem = null; | ||
13175 | List<UUID> uuids = new List<UUID>(); | ||
13176 | foreach (RemoveInventoryItemPacket.InventoryDataBlock datablock in removeItem.InventoryData) | ||
13177 | { | ||
13178 | uuids.Add(datablock.ItemID); | ||
13179 | } | ||
13180 | handlerRemoveInventoryItem = OnRemoveInventoryItem; | ||
13181 | if (handlerRemoveInventoryItem != null) | ||
13182 | { | ||
13183 | handlerRemoveInventoryItem(this, uuids); | ||
13184 | } | ||
13185 | |||
13186 | } | ||
13187 | break; | ||
13188 | |||
13189 | case PacketType.RemoveInventoryFolder: | ||
13190 | RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack; | ||
13191 | |||
13192 | #region Packet Session and User Check | ||
13193 | if (m_checkPackets) | ||
13194 | { | ||
13195 | if (removeFolder.AgentData.SessionID != SessionId || | ||
13196 | removeFolder.AgentData.AgentID != AgentId) | ||
13197 | break; | ||
13198 | } | ||
13199 | #endregion | ||
13200 | |||
13201 | if (OnRemoveInventoryFolder != null) | ||
13202 | { | ||
13203 | RemoveInventoryFolder handlerRemoveInventoryFolder = null; | ||
13204 | List<UUID> uuids = new List<UUID>(); | ||
13205 | foreach (RemoveInventoryFolderPacket.FolderDataBlock datablock in removeFolder.FolderData) | ||
13206 | { | ||
13207 | uuids.Add(datablock.FolderID); | ||
13208 | } | ||
13209 | handlerRemoveInventoryFolder = OnRemoveInventoryFolder; | ||
13210 | if (handlerRemoveInventoryFolder != null) | ||
13211 | { | ||
13212 | handlerRemoveInventoryFolder(this, uuids); | ||
13213 | } | ||
13214 | } | ||
13215 | break; | ||
13216 | |||
13217 | case PacketType.RemoveInventoryObjects: | ||
13218 | RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack; | ||
13219 | #region Packet Session and User Check | ||
13220 | if (m_checkPackets) | ||
13221 | { | ||
13222 | if (removeObject.AgentData.SessionID != SessionId || | ||
13223 | removeObject.AgentData.AgentID != AgentId) | ||
13224 | break; | ||
13225 | } | ||
13226 | #endregion | ||
13227 | if (OnRemoveInventoryFolder != null) | ||
13228 | { | ||
13229 | RemoveInventoryFolder handlerRemoveInventoryFolder = null; | ||
13230 | List<UUID> uuids = new List<UUID>(); | ||
13231 | foreach (RemoveInventoryObjectsPacket.FolderDataBlock datablock in removeObject.FolderData) | ||
13232 | { | ||
13233 | uuids.Add(datablock.FolderID); | ||
13234 | } | ||
13235 | handlerRemoveInventoryFolder = OnRemoveInventoryFolder; | ||
13236 | if (handlerRemoveInventoryFolder != null) | ||
13237 | { | ||
13238 | handlerRemoveInventoryFolder(this, uuids); | ||
13239 | } | ||
13240 | } | ||
13241 | |||
13242 | if (OnRemoveInventoryItem != null) | ||
13243 | { | ||
13244 | RemoveInventoryItem handlerRemoveInventoryItem = null; | ||
13245 | List<UUID> uuids = new List<UUID>(); | ||
13246 | foreach (RemoveInventoryObjectsPacket.ItemDataBlock datablock in removeObject.ItemData) | ||
13247 | { | ||
13248 | uuids.Add(datablock.ItemID); | ||
13249 | } | ||
13250 | handlerRemoveInventoryItem = OnRemoveInventoryItem; | ||
13251 | if (handlerRemoveInventoryItem != null) | ||
13252 | { | ||
13253 | handlerRemoveInventoryItem(this, uuids); | ||
13254 | } | ||
13255 | } | ||
13256 | break; | ||
13257 | |||
13258 | case PacketType.RequestTaskInventory: | ||
13259 | RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack; | ||
13260 | |||
13261 | #region Packet Session and User Check | ||
13262 | if (m_checkPackets) | ||
13263 | { | ||
13264 | if (requesttask.AgentData.SessionID != SessionId || | ||
13265 | requesttask.AgentData.AgentID != AgentId) | ||
13266 | break; | ||
13267 | } | ||
13268 | #endregion | ||
13269 | |||
13270 | RequestTaskInventory handlerRequestTaskInventory = OnRequestTaskInventory; | ||
13271 | if (handlerRequestTaskInventory != null) | ||
13272 | { | ||
13273 | handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID); | ||
13274 | } | ||
13275 | break; | ||
13276 | |||
13277 | case PacketType.UpdateTaskInventory: | ||
13278 | UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack; | ||
13279 | |||
13280 | #region Packet Session and User Check | ||
13281 | if (m_checkPackets) | ||
13282 | { | ||
13283 | if (updatetask.AgentData.SessionID != SessionId || | ||
13284 | updatetask.AgentData.AgentID != AgentId) | ||
13285 | break; | ||
13286 | } | ||
13287 | #endregion | ||
13288 | |||
13289 | if (OnUpdateTaskInventory != null) | ||
13290 | { | ||
13291 | if (updatetask.UpdateData.Key == 0) | ||
13292 | { | ||
13293 | UpdateTaskInventory handlerUpdateTaskInventory = OnUpdateTaskInventory; | ||
13294 | if (handlerUpdateTaskInventory != null) | ||
13295 | { | ||
13296 | TaskInventoryItem newTaskItem = new TaskInventoryItem(); | ||
13297 | newTaskItem.ItemID = updatetask.InventoryData.ItemID; | ||
13298 | newTaskItem.ParentID = updatetask.InventoryData.FolderID; | ||
13299 | newTaskItem.CreatorID = updatetask.InventoryData.CreatorID; | ||
13300 | newTaskItem.OwnerID = updatetask.InventoryData.OwnerID; | ||
13301 | newTaskItem.GroupID = updatetask.InventoryData.GroupID; | ||
13302 | newTaskItem.BasePermissions = updatetask.InventoryData.BaseMask; | ||
13303 | newTaskItem.CurrentPermissions = updatetask.InventoryData.OwnerMask; | ||
13304 | newTaskItem.GroupPermissions = updatetask.InventoryData.GroupMask; | ||
13305 | newTaskItem.EveryonePermissions = updatetask.InventoryData.EveryoneMask; | ||
13306 | newTaskItem.NextPermissions = updatetask.InventoryData.NextOwnerMask; | ||
13307 | //newTaskItem.GroupOwned=updatetask.InventoryData.GroupOwned; | ||
13308 | newTaskItem.Type = updatetask.InventoryData.Type; | ||
13309 | newTaskItem.InvType = updatetask.InventoryData.InvType; | ||
13310 | newTaskItem.Flags = updatetask.InventoryData.Flags; | ||
13311 | //newTaskItem.SaleType=updatetask.InventoryData.SaleType; | ||
13312 | //newTaskItem.SalePrice=updatetask.InventoryData.SalePrice;; | ||
13313 | newTaskItem.Name = Util.FieldToString(updatetask.InventoryData.Name); | ||
13314 | newTaskItem.Description = Util.FieldToString(updatetask.InventoryData.Description); | ||
13315 | newTaskItem.CreationDate = (uint)updatetask.InventoryData.CreationDate; | ||
13316 | handlerUpdateTaskInventory(this, updatetask.InventoryData.TransactionID, | ||
13317 | newTaskItem, updatetask.UpdateData.LocalID); | ||
13318 | } | ||
13319 | } | ||
13320 | } | ||
13321 | |||
13322 | break; | ||
13323 | |||
13324 | case PacketType.RemoveTaskInventory: | ||
13325 | |||
13326 | RemoveTaskInventoryPacket removeTask = (RemoveTaskInventoryPacket)Pack; | ||
13327 | |||
13328 | #region Packet Session and User Check | ||
13329 | if (m_checkPackets) | ||
13330 | { | ||
13331 | if (removeTask.AgentData.SessionID != SessionId || | ||
13332 | removeTask.AgentData.AgentID != AgentId) | ||
13333 | break; | ||
13334 | } | ||
13335 | #endregion | ||
13336 | |||
13337 | RemoveTaskInventory handlerRemoveTaskItem = OnRemoveTaskItem; | ||
13338 | |||
13339 | if (handlerRemoveTaskItem != null) | ||
13340 | { | ||
13341 | handlerRemoveTaskItem(this, removeTask.InventoryData.ItemID, removeTask.InventoryData.LocalID); | ||
13342 | } | ||
13343 | |||
13344 | break; | ||
13345 | |||
13346 | case PacketType.MoveTaskInventory: | ||
13347 | |||
13348 | MoveTaskInventoryPacket moveTaskInventoryPacket = (MoveTaskInventoryPacket)Pack; | ||
13349 | |||
13350 | #region Packet Session and User Check | ||
13351 | if (m_checkPackets) | ||
13352 | { | ||
13353 | if (moveTaskInventoryPacket.AgentData.SessionID != SessionId || | ||
13354 | moveTaskInventoryPacket.AgentData.AgentID != AgentId) | ||
13355 | break; | ||
13356 | } | ||
13357 | #endregion | ||
13358 | |||
13359 | MoveTaskInventory handlerMoveTaskItem = OnMoveTaskItem; | ||
13360 | |||
13361 | if (handlerMoveTaskItem != null) | ||
13362 | { | ||
13363 | handlerMoveTaskItem( | ||
13364 | this, moveTaskInventoryPacket.AgentData.FolderID, | ||
13365 | moveTaskInventoryPacket.InventoryData.LocalID, | ||
13366 | moveTaskInventoryPacket.InventoryData.ItemID); | ||
13367 | } | ||
13368 | |||
13369 | break; | ||
13370 | |||
13371 | case PacketType.RezScript: | ||
13372 | //m_log.Debug(Pack.ToString()); | ||
13373 | RezScriptPacket rezScriptx = (RezScriptPacket)Pack; | ||
13374 | |||
13375 | #region Packet Session and User Check | ||
13376 | if (m_checkPackets) | ||
13377 | { | ||
13378 | if (rezScriptx.AgentData.SessionID != SessionId || | ||
13379 | rezScriptx.AgentData.AgentID != AgentId) | ||
13380 | break; | ||
13381 | } | ||
13382 | #endregion | ||
13383 | |||
13384 | RezScript handlerRezScript = OnRezScript; | ||
13385 | InventoryItemBase item = new InventoryItemBase(); | ||
13386 | item.ID = rezScriptx.InventoryBlock.ItemID; | ||
13387 | item.Folder = rezScriptx.InventoryBlock.FolderID; | ||
13388 | item.CreatorId = rezScriptx.InventoryBlock.CreatorID.ToString(); | ||
13389 | item.Owner = rezScriptx.InventoryBlock.OwnerID; | ||
13390 | item.BasePermissions = rezScriptx.InventoryBlock.BaseMask; | ||
13391 | item.CurrentPermissions = rezScriptx.InventoryBlock.OwnerMask; | ||
13392 | item.EveryOnePermissions = rezScriptx.InventoryBlock.EveryoneMask; | ||
13393 | item.NextPermissions = rezScriptx.InventoryBlock.NextOwnerMask; | ||
13394 | item.GroupPermissions = rezScriptx.InventoryBlock.GroupMask; | ||
13395 | item.GroupOwned = rezScriptx.InventoryBlock.GroupOwned; | ||
13396 | item.GroupID = rezScriptx.InventoryBlock.GroupID; | ||
13397 | item.AssetType = rezScriptx.InventoryBlock.Type; | ||
13398 | item.InvType = rezScriptx.InventoryBlock.InvType; | ||
13399 | item.Flags = rezScriptx.InventoryBlock.Flags; | ||
13400 | item.SaleType = rezScriptx.InventoryBlock.SaleType; | ||
13401 | item.SalePrice = rezScriptx.InventoryBlock.SalePrice; | ||
13402 | item.Name = Util.FieldToString(rezScriptx.InventoryBlock.Name); | ||
13403 | item.Description = Util.FieldToString(rezScriptx.InventoryBlock.Description); | ||
13404 | item.CreationDate = rezScriptx.InventoryBlock.CreationDate; | ||
13405 | |||
13406 | if (handlerRezScript != null) | ||
13407 | { | ||
13408 | handlerRezScript(this, item, rezScriptx.InventoryBlock.TransactionID, rezScriptx.UpdateBlock.ObjectLocalID); | ||
13409 | } | ||
13410 | break; | ||
13411 | |||
13412 | case PacketType.MapLayerRequest: | ||
13413 | RequestMapLayer(); | ||
13414 | break; | ||
13415 | case PacketType.MapBlockRequest: | ||
13416 | MapBlockRequestPacket MapRequest = (MapBlockRequestPacket)Pack; | ||
13417 | |||
13418 | #region Packet Session and User Check | ||
13419 | if (m_checkPackets) | ||
13420 | { | ||
13421 | if (MapRequest.AgentData.SessionID != SessionId || | ||
13422 | MapRequest.AgentData.AgentID != AgentId) | ||
13423 | break; | ||
13424 | } | ||
13425 | #endregion | ||
13426 | |||
13427 | RequestMapBlocks handlerRequestMapBlocks = OnRequestMapBlocks; | ||
13428 | if (handlerRequestMapBlocks != null) | ||
13429 | { | ||
13430 | handlerRequestMapBlocks(this, MapRequest.PositionData.MinX, MapRequest.PositionData.MinY, | ||
13431 | MapRequest.PositionData.MaxX, MapRequest.PositionData.MaxY, MapRequest.AgentData.Flags); | ||
13432 | } | ||
13433 | break; | ||
13434 | case PacketType.MapNameRequest: | ||
13435 | MapNameRequestPacket map = (MapNameRequestPacket)Pack; | ||
13436 | |||
13437 | #region Packet Session and User Check | ||
13438 | if (m_checkPackets) | ||
13439 | { | ||
13440 | if (map.AgentData.SessionID != SessionId || | ||
13441 | map.AgentData.AgentID != AgentId) | ||
13442 | break; | ||
13443 | } | ||
13444 | #endregion | ||
13445 | |||
13446 | string mapName = Util.UTF8.GetString(map.NameData.Name, 0, | ||
13447 | map.NameData.Name.Length - 1); | ||
13448 | RequestMapName handlerMapNameRequest = OnMapNameRequest; | ||
13449 | if (handlerMapNameRequest != null) | ||
13450 | { | ||
13451 | handlerMapNameRequest(this, mapName); | ||
13452 | } | ||
13453 | break; | ||
13454 | |||
13455 | case PacketType.TeleportLandmarkRequest: | ||
13456 | TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack; | ||
13457 | |||
13458 | #region Packet Session and User Check | ||
13459 | if (m_checkPackets) | ||
13460 | { | ||
13461 | if (tpReq.Info.SessionID != SessionId || | ||
13462 | tpReq.Info.AgentID != AgentId) | ||
13463 | break; | ||
13464 | } | ||
13465 | #endregion | ||
13466 | |||
13467 | UUID lmid = tpReq.Info.LandmarkID; | ||
13468 | AssetLandmark lm; | ||
13469 | if (lmid != UUID.Zero) | ||
13470 | { | ||
13471 | //AssetBase lma = m_assetCache.GetAsset(lmid, false); | ||
13472 | AssetBase lma = m_assetService.Get(lmid.ToString()); | ||
13473 | |||
13474 | if (lma == null) | ||
13475 | { | ||
13476 | // Failed to find landmark | ||
13477 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
13478 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
13479 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
13480 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
13481 | } | ||
13482 | |||
13483 | try | ||
13484 | { | ||
13485 | lm = new AssetLandmark(lma); | ||
13486 | } | ||
13487 | catch (NullReferenceException) | ||
13488 | { | ||
13489 | // asset not found generates null ref inside the assetlandmark constructor. | ||
13490 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
13491 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
13492 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
13493 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
13494 | break; | ||
13495 | } | ||
13496 | } | ||
13497 | else | ||
13498 | { | ||
13499 | // Teleport home request | ||
13500 | UUIDNameRequest handlerTeleportHomeRequest = OnTeleportHomeRequest; | ||
13501 | if (handlerTeleportHomeRequest != null) | ||
13502 | { | ||
13503 | handlerTeleportHomeRequest(AgentId, this); | ||
13504 | } | ||
13505 | break; | ||
13506 | } | ||
13507 | |||
13508 | TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest; | ||
13509 | if (handlerTeleportLandmarkRequest != null) | ||
13510 | { | ||
13511 | handlerTeleportLandmarkRequest(this, lm.RegionID, lm.Position); | ||
13512 | } | ||
13513 | else | ||
13514 | { | ||
13515 | //no event handler so cancel request | ||
13516 | |||
13517 | |||
13518 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
13519 | tpCancel.Info.AgentID = tpReq.Info.AgentID; | ||
13520 | tpCancel.Info.SessionID = tpReq.Info.SessionID; | ||
13521 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
13522 | |||
13523 | } | ||
13524 | break; | ||
13525 | |||
13526 | case PacketType.TeleportLocationRequest: | ||
13527 | TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack; | ||
13528 | // m_log.Debug(tpLocReq.ToString()); | ||
13529 | |||
13530 | #region Packet Session and User Check | ||
13531 | if (m_checkPackets) | ||
13532 | { | ||
13533 | if (tpLocReq.AgentData.SessionID != SessionId || | ||
13534 | tpLocReq.AgentData.AgentID != AgentId) | ||
13535 | break; | ||
13536 | } | ||
13537 | #endregion | ||
13538 | |||
13539 | TeleportLocationRequest handlerTeleportLocationRequest = OnTeleportLocationRequest; | ||
13540 | if (handlerTeleportLocationRequest != null) | ||
13541 | { | ||
13542 | handlerTeleportLocationRequest(this, tpLocReq.Info.RegionHandle, tpLocReq.Info.Position, | ||
13543 | tpLocReq.Info.LookAt, 16); | ||
13544 | } | ||
13545 | else | ||
13546 | { | ||
13547 | //no event handler so cancel request | ||
13548 | TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel); | ||
13549 | tpCancel.Info.SessionID = tpLocReq.AgentData.SessionID; | ||
13550 | tpCancel.Info.AgentID = tpLocReq.AgentData.AgentID; | ||
13551 | OutPacket(tpCancel, ThrottleOutPacketType.Task); | ||
13552 | } | ||
13553 | break; | ||
13554 | |||
13555 | //#endregion | ||
13556 | |||
13557 | case PacketType.UUIDNameRequest: | ||
13558 | UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack; | ||
13559 | |||
13560 | foreach (UUIDNameRequestPacket.UUIDNameBlockBlock UUIDBlock in incoming.UUIDNameBlock) | ||
13561 | { | ||
13562 | UUIDNameRequest handlerNameRequest = OnNameFromUUIDRequest; | ||
13563 | if (handlerNameRequest != null) | ||
13564 | { | ||
13565 | handlerNameRequest(UUIDBlock.ID, this); | ||
13566 | } | ||
13567 | } | ||
13568 | break; | ||
13569 | |||
13570 | //#region Parcel related packets | ||
13571 | |||
13572 | |||
13573 | case PacketType.RegionHandleRequest: | ||
13574 | RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack; | ||
13575 | |||
13576 | RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest; | ||
13577 | if (handlerRegionHandleRequest != null) | ||
13578 | { | ||
13579 | handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID); | ||
13580 | } | ||
13581 | break; | ||
13582 | |||
13583 | case PacketType.ParcelInfoRequest: | ||
13584 | ParcelInfoRequestPacket pirPack = (ParcelInfoRequestPacket)Pack; | ||
13585 | |||
13586 | #region Packet Session and User Check | ||
13587 | if (m_checkPackets) | ||
13588 | { | ||
13589 | if (pirPack.AgentData.SessionID != SessionId || | ||
13590 | pirPack.AgentData.AgentID != AgentId) | ||
13591 | break; | ||
13592 | } | ||
13593 | #endregion | ||
13594 | |||
13595 | ParcelInfoRequest handlerParcelInfoRequest = OnParcelInfoRequest; | ||
13596 | if (handlerParcelInfoRequest != null) | ||
13597 | { | ||
13598 | handlerParcelInfoRequest(this, pirPack.Data.ParcelID); | ||
13599 | } | ||
13600 | break; | ||
13601 | |||
13602 | case PacketType.ParcelAccessListRequest: | ||
13603 | ParcelAccessListRequestPacket requestPacket = (ParcelAccessListRequestPacket)Pack; | ||
13604 | |||
13605 | #region Packet Session and User Check | ||
13606 | if (m_checkPackets) | ||
13607 | { | ||
13608 | if (requestPacket.AgentData.SessionID != SessionId || | ||
13609 | requestPacket.AgentData.AgentID != AgentId) | ||
13610 | break; | ||
13611 | } | ||
13612 | #endregion | ||
13613 | |||
13614 | ParcelAccessListRequest handlerParcelAccessListRequest = OnParcelAccessListRequest; | ||
13615 | |||
13616 | if (handlerParcelAccessListRequest != null) | ||
13617 | { | ||
13618 | handlerParcelAccessListRequest(requestPacket.AgentData.AgentID, requestPacket.AgentData.SessionID, | ||
13619 | requestPacket.Data.Flags, requestPacket.Data.SequenceID, | ||
13620 | requestPacket.Data.LocalID, this); | ||
13621 | } | ||
13622 | break; | ||
13623 | |||
13624 | case PacketType.ParcelAccessListUpdate: | ||
13625 | ParcelAccessListUpdatePacket updatePacket = (ParcelAccessListUpdatePacket)Pack; | ||
13626 | |||
13627 | #region Packet Session and User Check | ||
13628 | if (m_checkPackets) | ||
13629 | { | ||
13630 | if (updatePacket.AgentData.SessionID != SessionId || | ||
13631 | updatePacket.AgentData.AgentID != AgentId) | ||
13632 | break; | ||
13633 | } | ||
13634 | #endregion | ||
13635 | |||
13636 | List<ParcelManager.ParcelAccessEntry> entries = new List<ParcelManager.ParcelAccessEntry>(); | ||
13637 | foreach (ParcelAccessListUpdatePacket.ListBlock block in updatePacket.List) | ||
13638 | { | ||
13639 | ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); | ||
13640 | entry.AgentID = block.ID; | ||
13641 | entry.Flags = (AccessList)block.Flags; | ||
13642 | entry.Time = new DateTime(); | ||
13643 | entries.Add(entry); | ||
13644 | } | ||
13645 | |||
13646 | ParcelAccessListUpdateRequest handlerParcelAccessListUpdateRequest = OnParcelAccessListUpdateRequest; | ||
13647 | if (handlerParcelAccessListUpdateRequest != null) | ||
13648 | { | ||
13649 | handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID, | ||
13650 | updatePacket.AgentData.SessionID, updatePacket.Data.Flags, | ||
13651 | updatePacket.Data.LocalID, entries, this); | ||
13652 | } | ||
13653 | break; | ||
13654 | |||
13655 | case PacketType.ParcelPropertiesRequest: | ||
13656 | |||
13657 | ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack; | ||
13658 | |||
13659 | #region Packet Session and User Check | ||
13660 | if (m_checkPackets) | ||
13661 | { | ||
13662 | if (propertiesRequest.AgentData.SessionID != SessionId || | ||
13663 | propertiesRequest.AgentData.AgentID != AgentId) | ||
13664 | break; | ||
13665 | } | ||
13666 | #endregion | ||
13667 | |||
13668 | ParcelPropertiesRequest handlerParcelPropertiesRequest = OnParcelPropertiesRequest; | ||
13669 | if (handlerParcelPropertiesRequest != null) | ||
13670 | { | ||
13671 | handlerParcelPropertiesRequest((int)Math.Round(propertiesRequest.ParcelData.West), | ||
13672 | (int)Math.Round(propertiesRequest.ParcelData.South), | ||
13673 | (int)Math.Round(propertiesRequest.ParcelData.East), | ||
13674 | (int)Math.Round(propertiesRequest.ParcelData.North), | ||
13675 | propertiesRequest.ParcelData.SequenceID, | ||
13676 | propertiesRequest.ParcelData.SnapSelection, this); | ||
13677 | } | ||
13678 | break; | ||
13679 | |||
13680 | case PacketType.ParcelDivide: | ||
13681 | ParcelDividePacket landDivide = (ParcelDividePacket)Pack; | ||
13682 | |||
13683 | #region Packet Session and User Check | ||
13684 | if (m_checkPackets) | ||
13685 | { | ||
13686 | if (landDivide.AgentData.SessionID != SessionId || | ||
13687 | landDivide.AgentData.AgentID != AgentId) | ||
13688 | break; | ||
13689 | } | ||
13690 | #endregion | ||
13691 | |||
13692 | ParcelDivideRequest handlerParcelDivideRequest = OnParcelDivideRequest; | ||
13693 | if (handlerParcelDivideRequest != null) | ||
13694 | { | ||
13695 | handlerParcelDivideRequest((int)Math.Round(landDivide.ParcelData.West), | ||
13696 | (int)Math.Round(landDivide.ParcelData.South), | ||
13697 | (int)Math.Round(landDivide.ParcelData.East), | ||
13698 | (int)Math.Round(landDivide.ParcelData.North), this); | ||
13699 | } | ||
13700 | break; | ||
13701 | |||
13702 | case PacketType.ParcelJoin: | ||
13703 | ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack; | ||
13704 | |||
13705 | #region Packet Session and User Check | ||
13706 | if (m_checkPackets) | ||
13707 | { | ||
13708 | if (landJoin.AgentData.SessionID != SessionId || | ||
13709 | landJoin.AgentData.AgentID != AgentId) | ||
13710 | break; | ||
13711 | } | ||
13712 | #endregion | ||
13713 | |||
13714 | ParcelJoinRequest handlerParcelJoinRequest = OnParcelJoinRequest; | ||
13715 | |||
13716 | if (handlerParcelJoinRequest != null) | ||
13717 | { | ||
13718 | handlerParcelJoinRequest((int)Math.Round(landJoin.ParcelData.West), | ||
13719 | (int)Math.Round(landJoin.ParcelData.South), | ||
13720 | (int)Math.Round(landJoin.ParcelData.East), | ||
13721 | (int)Math.Round(landJoin.ParcelData.North), this); | ||
13722 | } | ||
13723 | break; | ||
13724 | |||
13725 | case PacketType.ParcelPropertiesUpdate: | ||
13726 | ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack; | ||
13727 | |||
13728 | #region Packet Session and User Check | ||
13729 | if (m_checkPackets) | ||
13730 | { | ||
13731 | if (parcelPropertiesPacket.AgentData.SessionID != SessionId || | ||
13732 | parcelPropertiesPacket.AgentData.AgentID != AgentId) | ||
13733 | break; | ||
13734 | } | ||
13735 | #endregion | ||
13736 | |||
13737 | ParcelPropertiesUpdateRequest handlerParcelPropertiesUpdateRequest = OnParcelPropertiesUpdateRequest; | ||
13738 | |||
13739 | if (handlerParcelPropertiesUpdateRequest != null) | ||
13740 | { | ||
13741 | LandUpdateArgs args = new LandUpdateArgs(); | ||
13742 | |||
13743 | args.AuthBuyerID = parcelPropertiesPacket.ParcelData.AuthBuyerID; | ||
13744 | args.Category = (ParcelCategory)parcelPropertiesPacket.ParcelData.Category; | ||
13745 | args.Desc = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Desc); | ||
13746 | args.GroupID = parcelPropertiesPacket.ParcelData.GroupID; | ||
13747 | args.LandingType = parcelPropertiesPacket.ParcelData.LandingType; | ||
13748 | args.MediaAutoScale = parcelPropertiesPacket.ParcelData.MediaAutoScale; | ||
13749 | args.MediaID = parcelPropertiesPacket.ParcelData.MediaID; | ||
13750 | args.MediaURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MediaURL); | ||
13751 | args.MusicURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MusicURL); | ||
13752 | args.Name = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Name); | ||
13753 | args.ParcelFlags = parcelPropertiesPacket.ParcelData.ParcelFlags; | ||
13754 | args.PassHours = parcelPropertiesPacket.ParcelData.PassHours; | ||
13755 | args.PassPrice = parcelPropertiesPacket.ParcelData.PassPrice; | ||
13756 | args.SalePrice = parcelPropertiesPacket.ParcelData.SalePrice; | ||
13757 | args.SnapshotID = parcelPropertiesPacket.ParcelData.SnapshotID; | ||
13758 | args.UserLocation = parcelPropertiesPacket.ParcelData.UserLocation; | ||
13759 | args.UserLookAt = parcelPropertiesPacket.ParcelData.UserLookAt; | ||
13760 | handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this); | ||
13761 | } | ||
13762 | break; | ||
13763 | |||
13764 | case PacketType.ParcelSelectObjects: | ||
13765 | ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack; | ||
13766 | |||
13767 | #region Packet Session and User Check | ||
13768 | if (m_checkPackets) | ||
13769 | { | ||
13770 | if (selectPacket.AgentData.SessionID != SessionId || | ||
13771 | selectPacket.AgentData.AgentID != AgentId) | ||
13772 | break; | ||
13773 | } | ||
13774 | #endregion | ||
13775 | |||
13776 | List<UUID> returnIDs = new List<UUID>(); | ||
13777 | |||
13778 | foreach (ParcelSelectObjectsPacket.ReturnIDsBlock rb in | ||
13779 | selectPacket.ReturnIDs) | ||
13780 | { | ||
13781 | returnIDs.Add(rb.ReturnID); | ||
13782 | } | ||
13783 | |||
13784 | ParcelSelectObjects handlerParcelSelectObjects = OnParcelSelectObjects; | ||
13785 | |||
13786 | if (handlerParcelSelectObjects != null) | ||
13787 | { | ||
13788 | handlerParcelSelectObjects(selectPacket.ParcelData.LocalID, | ||
13789 | Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this); | ||
13790 | } | ||
13791 | break; | ||
13792 | |||
13793 | case PacketType.ParcelObjectOwnersRequest: | ||
13794 | //m_log.Debug(Pack.ToString()); | ||
13795 | ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack; | ||
13796 | |||
13797 | #region Packet Session and User Check | ||
13798 | if (m_checkPackets) | ||
13799 | { | ||
13800 | if (reqPacket.AgentData.SessionID != SessionId || | ||
13801 | reqPacket.AgentData.AgentID != AgentId) | ||
13802 | break; | ||
13803 | } | ||
13804 | #endregion | ||
13805 | |||
13806 | ParcelObjectOwnerRequest handlerParcelObjectOwnerRequest = OnParcelObjectOwnerRequest; | ||
13807 | |||
13808 | if (handlerParcelObjectOwnerRequest != null) | ||
13809 | { | ||
13810 | handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this); | ||
13811 | } | ||
13812 | break; | ||
13813 | |||
13814 | case PacketType.ParcelGodForceOwner: | ||
13815 | ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack; | ||
13816 | |||
13817 | #region Packet Session and User Check | ||
13818 | if (m_checkPackets) | ||
13819 | { | ||
13820 | if (godForceOwnerPacket.AgentData.SessionID != SessionId || | ||
13821 | godForceOwnerPacket.AgentData.AgentID != AgentId) | ||
13822 | break; | ||
13823 | } | ||
13824 | #endregion | ||
13825 | |||
13826 | ParcelGodForceOwner handlerParcelGodForceOwner = OnParcelGodForceOwner; | ||
13827 | if (handlerParcelGodForceOwner != null) | ||
13828 | { | ||
13829 | handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this); | ||
13830 | } | ||
13831 | break; | ||
13832 | |||
13833 | case PacketType.ParcelRelease: | ||
13834 | ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack; | ||
13835 | |||
13836 | #region Packet Session and User Check | ||
13837 | if (m_checkPackets) | ||
13838 | { | ||
13839 | if (releasePacket.AgentData.SessionID != SessionId || | ||
13840 | releasePacket.AgentData.AgentID != AgentId) | ||
13841 | break; | ||
13842 | } | ||
13843 | #endregion | ||
13844 | |||
13845 | ParcelAbandonRequest handlerParcelAbandonRequest = OnParcelAbandonRequest; | ||
13846 | if (handlerParcelAbandonRequest != null) | ||
13847 | { | ||
13848 | handlerParcelAbandonRequest(releasePacket.Data.LocalID, this); | ||
13849 | } | ||
13850 | break; | ||
13851 | |||
13852 | case PacketType.ParcelReclaim: | ||
13853 | ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack; | ||
13854 | |||
13855 | #region Packet Session and User Check | ||
13856 | if (m_checkPackets) | ||
13857 | { | ||
13858 | if (reclaimPacket.AgentData.SessionID != SessionId || | ||
13859 | reclaimPacket.AgentData.AgentID != AgentId) | ||
13860 | break; | ||
13861 | } | ||
13862 | #endregion | ||
13863 | |||
13864 | ParcelReclaim handlerParcelReclaim = OnParcelReclaim; | ||
13865 | if (handlerParcelReclaim != null) | ||
13866 | { | ||
13867 | handlerParcelReclaim(reclaimPacket.Data.LocalID, this); | ||
13868 | } | ||
13869 | break; | ||
13870 | |||
13871 | case PacketType.ParcelReturnObjects: | ||
13872 | |||
13873 | |||
13874 | ParcelReturnObjectsPacket parcelReturnObjects = (ParcelReturnObjectsPacket)Pack; | ||
13875 | |||
13876 | #region Packet Session and User Check | ||
13877 | if (m_checkPackets) | ||
13878 | { | ||
13879 | if (parcelReturnObjects.AgentData.SessionID != SessionId || | ||
13880 | parcelReturnObjects.AgentData.AgentID != AgentId) | ||
13881 | break; | ||
13882 | } | ||
13883 | #endregion | ||
13884 | |||
13885 | UUID[] puserselectedOwnerIDs = new UUID[parcelReturnObjects.OwnerIDs.Length]; | ||
13886 | for (int parceliterator = 0; parceliterator < parcelReturnObjects.OwnerIDs.Length; parceliterator++) | ||
13887 | puserselectedOwnerIDs[parceliterator] = parcelReturnObjects.OwnerIDs[parceliterator].OwnerID; | ||
13888 | |||
13889 | UUID[] puserselectedTaskIDs = new UUID[parcelReturnObjects.TaskIDs.Length]; | ||
13890 | |||
13891 | for (int parceliterator = 0; parceliterator < parcelReturnObjects.TaskIDs.Length; parceliterator++) | ||
13892 | puserselectedTaskIDs[parceliterator] = parcelReturnObjects.TaskIDs[parceliterator].TaskID; | ||
13893 | |||
13894 | ParcelReturnObjectsRequest handlerParcelReturnObjectsRequest = OnParcelReturnObjectsRequest; | ||
13895 | if (handlerParcelReturnObjectsRequest != null) | ||
13896 | { | ||
13897 | handlerParcelReturnObjectsRequest(parcelReturnObjects.ParcelData.LocalID, parcelReturnObjects.ParcelData.ReturnType, puserselectedOwnerIDs, puserselectedTaskIDs, this); | ||
13898 | |||
13899 | } | ||
13900 | break; | ||
13901 | |||
13902 | case PacketType.ParcelSetOtherCleanTime: | ||
13903 | ParcelSetOtherCleanTimePacket parcelSetOtherCleanTimePacket = (ParcelSetOtherCleanTimePacket)Pack; | ||
13904 | |||
13905 | #region Packet Session and User Check | ||
13906 | if (m_checkPackets) | ||
13907 | { | ||
13908 | if (parcelSetOtherCleanTimePacket.AgentData.SessionID != SessionId || | ||
13909 | parcelSetOtherCleanTimePacket.AgentData.AgentID != AgentId) | ||
13910 | break; | ||
13911 | } | ||
13912 | #endregion | ||
13913 | |||
13914 | ParcelSetOtherCleanTime handlerParcelSetOtherCleanTime = OnParcelSetOtherCleanTime; | ||
13915 | if (handlerParcelSetOtherCleanTime != null) | ||
13916 | { | ||
13917 | handlerParcelSetOtherCleanTime(this, | ||
13918 | parcelSetOtherCleanTimePacket.ParcelData.LocalID, | ||
13919 | parcelSetOtherCleanTimePacket.ParcelData.OtherCleanTime); | ||
13920 | } | ||
13921 | break; | ||
13922 | |||
13923 | case PacketType.LandStatRequest: | ||
13924 | LandStatRequestPacket lsrp = (LandStatRequestPacket)Pack; | ||
13925 | |||
13926 | #region Packet Session and User Check | ||
13927 | if (m_checkPackets) | ||
13928 | { | ||
13929 | if (lsrp.AgentData.SessionID != SessionId || | ||
13930 | lsrp.AgentData.AgentID != AgentId) | ||
13931 | break; | ||
13932 | } | ||
13933 | #endregion | ||
13934 | |||
13935 | GodLandStatRequest handlerLandStatRequest = OnLandStatRequest; | ||
13936 | if (handlerLandStatRequest != null) | ||
13937 | { | ||
13938 | handlerLandStatRequest(lsrp.RequestData.ParcelLocalID, lsrp.RequestData.ReportType, lsrp.RequestData.RequestFlags, Utils.BytesToString(lsrp.RequestData.Filter), this); | ||
13939 | } | ||
13940 | break; | ||
13941 | |||
13942 | case PacketType.ParcelDwellRequest: | ||
13943 | ParcelDwellRequestPacket dwellrq = | ||
13944 | (ParcelDwellRequestPacket)Pack; | ||
13945 | |||
13946 | #region Packet Session and User Check | ||
13947 | if (m_checkPackets) | ||
13948 | { | ||
13949 | if (dwellrq.AgentData.SessionID != SessionId || | ||
13950 | dwellrq.AgentData.AgentID != AgentId) | ||
13951 | break; | ||
13952 | } | ||
13953 | #endregion | ||
13954 | |||
13955 | ParcelDwellRequest handlerParcelDwellRequest = OnParcelDwellRequest; | ||
13956 | if (handlerParcelDwellRequest != null) | ||
13957 | { | ||
13958 | handlerParcelDwellRequest(dwellrq.Data.LocalID, this); | ||
13959 | } | ||
13960 | break; | ||
13961 | |||
13962 | //#endregion | ||
13963 | |||
13964 | //#region Estate Packets | ||
13965 | |||
13966 | case PacketType.EstateOwnerMessage: | ||
13967 | EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack; | ||
13968 | //m_log.Debug(messagePacket.ToString()); | ||
13969 | |||
13970 | #region Packet Session and User Check | ||
13971 | if (m_checkPackets) | ||
13972 | { | ||
13973 | if (messagePacket.AgentData.SessionID != SessionId || | ||
13974 | messagePacket.AgentData.AgentID != AgentId) | ||
13975 | break; | ||
13976 | } | ||
13977 | #endregion | ||
13978 | |||
13979 | switch (Utils.BytesToString(messagePacket.MethodData.Method)) | ||
13980 | { | ||
13981 | case "getinfo": | ||
13982 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
13983 | { | ||
13984 | OnDetailedEstateDataRequest(this, messagePacket.MethodData.Invoice); | ||
13985 | } | ||
13986 | break; | ||
13987 | case "setregioninfo": | ||
13988 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
13989 | { | ||
13990 | OnSetEstateFlagsRequest(convertParamStringToBool(messagePacket.ParamList[0].Parameter), convertParamStringToBool(messagePacket.ParamList[1].Parameter), | ||
13991 | convertParamStringToBool(messagePacket.ParamList[2].Parameter), !convertParamStringToBool(messagePacket.ParamList[3].Parameter), | ||
13992 | Convert.ToInt16(Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[4].Parameter), Culture.NumberFormatInfo)), | ||
13993 | (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo), | ||
13994 | Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[6].Parameter)), | ||
13995 | convertParamStringToBool(messagePacket.ParamList[7].Parameter), convertParamStringToBool(messagePacket.ParamList[8].Parameter)); | ||
13996 | } | ||
13997 | break; | ||
13998 | // case "texturebase": | ||
13999 | // if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14000 | // { | ||
14001 | // foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
14002 | // { | ||
14003 | // string s = Utils.BytesToString(block.Parameter); | ||
14004 | // string[] splitField = s.Split(' '); | ||
14005 | // if (splitField.Length == 2) | ||
14006 | // { | ||
14007 | // UUID tempUUID = new UUID(splitField[1]); | ||
14008 | // OnSetEstateTerrainBaseTexture(this, Convert.ToInt16(splitField[0]), tempUUID); | ||
14009 | // } | ||
14010 | // } | ||
14011 | // } | ||
14012 | // break; | ||
14013 | case "texturedetail": | ||
14014 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14015 | { | ||
14016 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
14017 | { | ||
14018 | string s = Utils.BytesToString(block.Parameter); | ||
14019 | string[] splitField = s.Split(' '); | ||
14020 | if (splitField.Length == 2) | ||
14021 | { | ||
14022 | Int16 corner = Convert.ToInt16(splitField[0]); | ||
14023 | UUID textureUUID = new UUID(splitField[1]); | ||
14024 | |||
14025 | OnSetEstateTerrainDetailTexture(this, corner, textureUUID); | ||
14026 | } | ||
14027 | } | ||
14028 | } | ||
14029 | |||
14030 | break; | ||
14031 | case "textureheights": | ||
14032 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14033 | { | ||
14034 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
14035 | { | ||
14036 | string s = Utils.BytesToString(block.Parameter); | ||
14037 | string[] splitField = s.Split(' '); | ||
14038 | if (splitField.Length == 3) | ||
14039 | { | ||
14040 | Int16 corner = Convert.ToInt16(splitField[0]); | ||
14041 | float lowValue = (float)Convert.ToDecimal(splitField[1], Culture.NumberFormatInfo); | ||
14042 | float highValue = (float)Convert.ToDecimal(splitField[2], Culture.NumberFormatInfo); | ||
14043 | |||
14044 | OnSetEstateTerrainTextureHeights(this, corner, lowValue, highValue); | ||
14045 | } | ||
14046 | } | ||
14047 | } | ||
14048 | break; | ||
14049 | case "texturecommit": | ||
14050 | OnCommitEstateTerrainTextureRequest(this); | ||
14051 | break; | ||
14052 | case "setregionterrain": | ||
14053 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14054 | { | ||
14055 | if (messagePacket.ParamList.Length != 9) | ||
14056 | { | ||
14057 | m_log.Error("EstateOwnerMessage: SetRegionTerrain method has a ParamList of invalid length"); | ||
14058 | } | ||
14059 | else | ||
14060 | { | ||
14061 | try | ||
14062 | { | ||
14063 | string tmp = Utils.BytesToString(messagePacket.ParamList[0].Parameter); | ||
14064 | if (!tmp.Contains(".")) tmp += ".00"; | ||
14065 | float WaterHeight = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo); | ||
14066 | tmp = Utils.BytesToString(messagePacket.ParamList[1].Parameter); | ||
14067 | if (!tmp.Contains(".")) tmp += ".00"; | ||
14068 | float TerrainRaiseLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo); | ||
14069 | tmp = Utils.BytesToString(messagePacket.ParamList[2].Parameter); | ||
14070 | if (!tmp.Contains(".")) tmp += ".00"; | ||
14071 | float TerrainLowerLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo); | ||
14072 | bool UseEstateSun = convertParamStringToBool(messagePacket.ParamList[3].Parameter); | ||
14073 | bool UseFixedSun = convertParamStringToBool(messagePacket.ParamList[4].Parameter); | ||
14074 | float SunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo); | ||
14075 | bool UseGlobal = convertParamStringToBool(messagePacket.ParamList[6].Parameter); | ||
14076 | bool EstateFixedSun = convertParamStringToBool(messagePacket.ParamList[7].Parameter); | ||
14077 | float EstateSunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[8].Parameter), Culture.NumberFormatInfo); | ||
14078 | |||
14079 | OnSetRegionTerrainSettings(WaterHeight, TerrainRaiseLimit, TerrainLowerLimit, UseEstateSun, UseFixedSun, SunHour, UseGlobal, EstateFixedSun, EstateSunHour); | ||
14080 | |||
14081 | } | ||
14082 | catch (Exception ex) | ||
14083 | { | ||
14084 | m_log.Error("EstateOwnerMessage: Exception while setting terrain settings: \n" + messagePacket + "\n" + ex); | ||
14085 | } | ||
14086 | } | ||
14087 | } | ||
14088 | |||
14089 | break; | ||
14090 | case "restart": | ||
14091 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14092 | { | ||
14093 | // There's only 1 block in the estateResetSim.. and that's the number of seconds till restart. | ||
14094 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
14095 | { | ||
14096 | float timeSeconds; | ||
14097 | Utils.TryParseSingle(Utils.BytesToString(block.Parameter), out timeSeconds); | ||
14098 | timeSeconds = (int)timeSeconds; | ||
14099 | OnEstateRestartSimRequest(this, (int)timeSeconds); | ||
14100 | |||
14101 | } | ||
14102 | } | ||
14103 | break; | ||
14104 | case "estatechangecovenantid": | ||
14105 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14106 | { | ||
14107 | foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList) | ||
14108 | { | ||
14109 | UUID newCovenantID = new UUID(Utils.BytesToString(block.Parameter)); | ||
14110 | OnEstateChangeCovenantRequest(this, newCovenantID); | ||
14111 | } | ||
14112 | } | ||
14113 | break; | ||
14114 | case "estateaccessdelta": // Estate access delta manages the banlist and allow list too. | ||
14115 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14116 | { | ||
14117 | int estateAccessType = Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
14118 | OnUpdateEstateAccessDeltaRequest(this, messagePacket.MethodData.Invoice, estateAccessType, new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter))); | ||
14119 | |||
14120 | } | ||
14121 | break; | ||
14122 | case "simulatormessage": | ||
14123 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14124 | { | ||
14125 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14126 | UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
14127 | string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter); | ||
14128 | string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter); | ||
14129 | UUID sessionID = messagePacket.AgentData.SessionID; | ||
14130 | OnSimulatorBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message); | ||
14131 | } | ||
14132 | break; | ||
14133 | case "instantmessage": | ||
14134 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14135 | { | ||
14136 | if (messagePacket.ParamList.Length < 5) | ||
14137 | break; | ||
14138 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14139 | UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
14140 | string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter); | ||
14141 | string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter); | ||
14142 | UUID sessionID = messagePacket.AgentData.SessionID; | ||
14143 | OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message); | ||
14144 | } | ||
14145 | break; | ||
14146 | case "setregiondebug": | ||
14147 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14148 | { | ||
14149 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14150 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
14151 | bool scripted = convertParamStringToBool(messagePacket.ParamList[0].Parameter); | ||
14152 | bool collisionEvents = convertParamStringToBool(messagePacket.ParamList[1].Parameter); | ||
14153 | bool physics = convertParamStringToBool(messagePacket.ParamList[2].Parameter); | ||
14154 | |||
14155 | OnEstateDebugRegionRequest(this, invoice, SenderID, scripted, collisionEvents, physics); | ||
14156 | } | ||
14157 | break; | ||
14158 | case "teleporthomeuser": | ||
14159 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14160 | { | ||
14161 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14162 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
14163 | UUID Prey; | ||
14164 | |||
14165 | UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[1].Parameter), out Prey); | ||
14166 | |||
14167 | OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey); | ||
14168 | } | ||
14169 | break; | ||
14170 | case "teleporthomeallusers": | ||
14171 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14172 | { | ||
14173 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14174 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
14175 | OnEstateTeleportAllUsersHomeRequest(this, invoice, SenderID); | ||
14176 | } | ||
14177 | break; | ||
14178 | case "colliders": | ||
14179 | handlerLandStatRequest = OnLandStatRequest; | ||
14180 | if (handlerLandStatRequest != null) | ||
14181 | { | ||
14182 | handlerLandStatRequest(0, 1, 0, "", this); | ||
14183 | } | ||
14184 | break; | ||
14185 | case "scripts": | ||
14186 | handlerLandStatRequest = OnLandStatRequest; | ||
14187 | if (handlerLandStatRequest != null) | ||
14188 | { | ||
14189 | handlerLandStatRequest(0, 0, 0, "", this); | ||
14190 | } | ||
14191 | break; | ||
14192 | case "terrain": | ||
14193 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14194 | { | ||
14195 | if (messagePacket.ParamList.Length > 0) | ||
14196 | { | ||
14197 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "bake") | ||
14198 | { | ||
14199 | BakeTerrain handlerBakeTerrain = OnBakeTerrain; | ||
14200 | if (handlerBakeTerrain != null) | ||
14201 | { | ||
14202 | handlerBakeTerrain(this); | ||
14203 | } | ||
14204 | } | ||
14205 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "download filename") | ||
14206 | { | ||
14207 | if (messagePacket.ParamList.Length > 1) | ||
14208 | { | ||
14209 | RequestTerrain handlerRequestTerrain = OnRequestTerrain; | ||
14210 | if (handlerRequestTerrain != null) | ||
14211 | { | ||
14212 | handlerRequestTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
14213 | } | ||
14214 | } | ||
14215 | } | ||
14216 | if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "upload filename") | ||
14217 | { | ||
14218 | if (messagePacket.ParamList.Length > 1) | ||
14219 | { | ||
14220 | RequestTerrain handlerUploadTerrain = OnUploadTerrain; | ||
14221 | if (handlerUploadTerrain != null) | ||
14222 | { | ||
14223 | handlerUploadTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
14224 | } | ||
14225 | } | ||
14226 | } | ||
14227 | |||
14228 | } | ||
14229 | |||
14230 | |||
14231 | } | ||
14232 | break; | ||
14233 | |||
14234 | case "estatechangeinfo": | ||
14235 | if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false)) | ||
14236 | { | ||
14237 | UUID invoice = messagePacket.MethodData.Invoice; | ||
14238 | UUID SenderID = messagePacket.AgentData.AgentID; | ||
14239 | UInt32 param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter)); | ||
14240 | UInt32 param2 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[2].Parameter)); | ||
14241 | |||
14242 | EstateChangeInfo handlerEstateChangeInfo = OnEstateChangeInfo; | ||
14243 | if (handlerEstateChangeInfo != null) | ||
14244 | { | ||
14245 | handlerEstateChangeInfo(this, invoice, SenderID, param1, param2); | ||
14246 | } | ||
14247 | } | ||
14248 | break; | ||
14249 | |||
14250 | default: | ||
14251 | m_log.Error("EstateOwnerMessage: Unknown method requested\n" + messagePacket); | ||
14252 | break; | ||
14253 | } | ||
14254 | |||
14255 | //int parcelID, uint reportType, uint requestflags, string filter | ||
14256 | |||
14257 | //lsrp.RequestData.ParcelLocalID; | ||
14258 | //lsrp.RequestData.ReportType; // 1 = colliders, 0 = scripts | ||
14259 | //lsrp.RequestData.RequestFlags; | ||
14260 | //lsrp.RequestData.Filter; | ||
14261 | |||
14262 | break; | ||
14263 | |||
14264 | case PacketType.RequestRegionInfo: | ||
14265 | RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData; | ||
14266 | |||
14267 | #region Packet Session and User Check | ||
14268 | if (m_checkPackets) | ||
14269 | { | ||
14270 | if (mPacket.SessionID != SessionId || | ||
14271 | mPacket.AgentID != AgentId) | ||
14272 | break; | ||
14273 | } | ||
14274 | #endregion | ||
14275 | |||
14276 | RegionInfoRequest handlerRegionInfoRequest = OnRegionInfoRequest; | ||
14277 | if (handlerRegionInfoRequest != null) | ||
14278 | { | ||
14279 | handlerRegionInfoRequest(this); | ||
14280 | } | ||
14281 | break; | ||
14282 | |||
14283 | case PacketType.EstateCovenantRequest: | ||
14284 | |||
14285 | //EstateCovenantRequestPacket.AgentDataBlock epack = | ||
14286 | // ((EstateCovenantRequestPacket)Pack).AgentData; | ||
14287 | |||
14288 | EstateCovenantRequest handlerEstateCovenantRequest = OnEstateCovenantRequest; | ||
14289 | if (handlerEstateCovenantRequest != null) | ||
14290 | { | ||
14291 | handlerEstateCovenantRequest(this); | ||
14292 | } | ||
14293 | break; | ||
14294 | |||
14295 | //#endregion | ||
14296 | |||
14297 | //#region GodPackets | ||
14298 | |||
14299 | case PacketType.RequestGodlikePowers: | ||
14300 | RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack; | ||
14301 | RequestGodlikePowersPacket.RequestBlockBlock rblock = rglpPack.RequestBlock; | ||
14302 | UUID token = rblock.Token; | ||
14303 | |||
14304 | RequestGodlikePowersPacket.AgentDataBlock ablock = rglpPack.AgentData; | ||
14305 | |||
14306 | RequestGodlikePowers handlerReqGodlikePowers = OnRequestGodlikePowers; | ||
14307 | |||
14308 | if (handlerReqGodlikePowers != null) | ||
14309 | { | ||
14310 | handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike, this); | ||
14311 | } | ||
14312 | |||
14313 | break; | ||
14314 | |||
14315 | case PacketType.GodKickUser: | ||
14316 | GodKickUserPacket gkupack = (GodKickUserPacket)Pack; | ||
14317 | |||
14318 | if (gkupack.UserInfo.GodSessionID == SessionId && AgentId == gkupack.UserInfo.GodID) | ||
14319 | { | ||
14320 | GodKickUser handlerGodKickUser = OnGodKickUser; | ||
14321 | if (handlerGodKickUser != null) | ||
14322 | { | ||
14323 | handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID, | ||
14324 | gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason,gkupack.UserInfo); | ||
14325 | } | ||
14326 | } | ||
14327 | else | ||
14328 | { | ||
14329 | SendAgentAlertMessage("Kick request denied", false); | ||
14330 | } | ||
14331 | //KickUserPacket kupack = new KickUserPacket(); | ||
14332 | //KickUserPacket.UserInfoBlock kupackib = kupack.UserInfo; | ||
14333 | |||
14334 | //kupack.UserInfo.AgentID = gkupack.UserInfo.AgentID; | ||
14335 | //kupack.UserInfo.SessionID = gkupack.UserInfo.GodSessionID; | ||
14336 | |||
14337 | //kupack.TargetBlock.TargetIP = (uint)0; | ||
14338 | //kupack.TargetBlock.TargetPort = (ushort)0; | ||
14339 | //kupack.UserInfo.Reason = gkupack.UserInfo.Reason; | ||
14340 | |||
14341 | //OutPacket(kupack, ThrottleOutPacketType.Task); | ||
14342 | break; | ||
14343 | |||
14344 | //#endregion | ||
14345 | |||
14346 | //#region Economy/Transaction Packets | ||
14347 | |||
14348 | case PacketType.MoneyBalanceRequest: | ||
14349 | MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack; | ||
14350 | |||
14351 | #region Packet Session and User Check | ||
14352 | if (m_checkPackets) | ||
14353 | { | ||
14354 | if (moneybalancerequestpacket.AgentData.SessionID != SessionId || | ||
14355 | moneybalancerequestpacket.AgentData.AgentID != AgentId) | ||
14356 | break; | ||
14357 | } | ||
14358 | #endregion | ||
14359 | |||
14360 | MoneyBalanceRequest handlerMoneyBalanceRequest = OnMoneyBalanceRequest; | ||
14361 | |||
14362 | if (handlerMoneyBalanceRequest != null) | ||
14363 | { | ||
14364 | handlerMoneyBalanceRequest(this, moneybalancerequestpacket.AgentData.AgentID, moneybalancerequestpacket.AgentData.SessionID, moneybalancerequestpacket.MoneyData.TransactionID); | ||
14365 | } | ||
14366 | |||
14367 | break; | ||
14368 | |||
14369 | case PacketType.EconomyDataRequest: | ||
14370 | |||
14371 | |||
14372 | EconomyDataRequest handlerEconomoyDataRequest = OnEconomyDataRequest; | ||
14373 | if (handlerEconomoyDataRequest != null) | ||
14374 | { | ||
14375 | handlerEconomoyDataRequest(AgentId); | ||
14376 | } | ||
14377 | break; | ||
14378 | |||
14379 | case PacketType.RequestPayPrice: | ||
14380 | RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack; | ||
14381 | |||
14382 | RequestPayPrice handlerRequestPayPrice = OnRequestPayPrice; | ||
14383 | if (handlerRequestPayPrice != null) | ||
14384 | { | ||
14385 | handlerRequestPayPrice(this, requestPayPricePacket.ObjectData.ObjectID); | ||
14386 | } | ||
14387 | break; | ||
14388 | |||
14389 | case PacketType.ObjectSaleInfo: | ||
14390 | ObjectSaleInfoPacket objectSaleInfoPacket = (ObjectSaleInfoPacket)Pack; | ||
14391 | |||
14392 | #region Packet Session and User Check | ||
14393 | if (m_checkPackets) | ||
14394 | { | ||
14395 | if (objectSaleInfoPacket.AgentData.SessionID != SessionId || | ||
14396 | objectSaleInfoPacket.AgentData.AgentID != AgentId) | ||
14397 | break; | ||
14398 | } | ||
14399 | #endregion | ||
14400 | |||
14401 | ObjectSaleInfo handlerObjectSaleInfo = OnObjectSaleInfo; | ||
14402 | if (handlerObjectSaleInfo != null) | ||
14403 | { | ||
14404 | foreach (ObjectSaleInfoPacket.ObjectDataBlock d | ||
14405 | in objectSaleInfoPacket.ObjectData) | ||
14406 | { | ||
14407 | handlerObjectSaleInfo(this, | ||
14408 | objectSaleInfoPacket.AgentData.AgentID, | ||
14409 | objectSaleInfoPacket.AgentData.SessionID, | ||
14410 | d.LocalID, | ||
14411 | d.SaleType, | ||
14412 | d.SalePrice); | ||
14413 | } | ||
14414 | } | ||
14415 | break; | ||
14416 | |||
14417 | case PacketType.ObjectBuy: | ||
14418 | ObjectBuyPacket objectBuyPacket = (ObjectBuyPacket)Pack; | ||
14419 | |||
14420 | #region Packet Session and User Check | ||
14421 | if (m_checkPackets) | ||
14422 | { | ||
14423 | if (objectBuyPacket.AgentData.SessionID != SessionId || | ||
14424 | objectBuyPacket.AgentData.AgentID != AgentId) | ||
14425 | break; | ||
14426 | } | ||
14427 | #endregion | ||
14428 | |||
14429 | ObjectBuy handlerObjectBuy = OnObjectBuy; | ||
14430 | |||
14431 | if (handlerObjectBuy != null) | ||
14432 | { | ||
14433 | foreach (ObjectBuyPacket.ObjectDataBlock d | ||
14434 | in objectBuyPacket.ObjectData) | ||
14435 | { | ||
14436 | handlerObjectBuy(this, | ||
14437 | objectBuyPacket.AgentData.AgentID, | ||
14438 | objectBuyPacket.AgentData.SessionID, | ||
14439 | objectBuyPacket.AgentData.GroupID, | ||
14440 | objectBuyPacket.AgentData.CategoryID, | ||
14441 | d.ObjectLocalID, | ||
14442 | d.SaleType, | ||
14443 | d.SalePrice); | ||
14444 | } | ||
14445 | } | ||
14446 | break; | ||
14447 | |||
14448 | //#endregion | ||
14449 | |||
14450 | //#region Script Packets | ||
14451 | |||
14452 | case PacketType.GetScriptRunning: | ||
14453 | GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack; | ||
14454 | |||
14455 | GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning; | ||
14456 | if (handlerGetScriptRunning != null) | ||
14457 | { | ||
14458 | handlerGetScriptRunning(this, scriptRunning.Script.ObjectID, scriptRunning.Script.ItemID); | ||
14459 | } | ||
14460 | break; | ||
14461 | |||
14462 | case PacketType.SetScriptRunning: | ||
14463 | SetScriptRunningPacket setScriptRunning = (SetScriptRunningPacket)Pack; | ||
14464 | |||
14465 | #region Packet Session and User Check | ||
14466 | if (m_checkPackets) | ||
14467 | { | ||
14468 | if (setScriptRunning.AgentData.SessionID != SessionId || | ||
14469 | setScriptRunning.AgentData.AgentID != AgentId) | ||
14470 | break; | ||
14471 | } | ||
14472 | #endregion | ||
14473 | |||
14474 | SetScriptRunning handlerSetScriptRunning = OnSetScriptRunning; | ||
14475 | if (handlerSetScriptRunning != null) | ||
14476 | { | ||
14477 | handlerSetScriptRunning(this, setScriptRunning.Script.ObjectID, setScriptRunning.Script.ItemID, setScriptRunning.Script.Running); | ||
14478 | } | ||
14479 | break; | ||
14480 | |||
14481 | case PacketType.ScriptReset: | ||
14482 | ScriptResetPacket scriptResetPacket = (ScriptResetPacket)Pack; | ||
14483 | |||
14484 | #region Packet Session and User Check | ||
14485 | if (m_checkPackets) | ||
14486 | { | ||
14487 | if (scriptResetPacket.AgentData.SessionID != SessionId || | ||
14488 | scriptResetPacket.AgentData.AgentID != AgentId) | ||
14489 | break; | ||
14490 | } | ||
14491 | #endregion | ||
14492 | |||
14493 | ScriptReset handlerScriptReset = OnScriptReset; | ||
14494 | if (handlerScriptReset != null) | ||
14495 | { | ||
14496 | handlerScriptReset(this, scriptResetPacket.Script.ObjectID, scriptResetPacket.Script.ItemID); | ||
14497 | } | ||
14498 | break; | ||
14499 | |||
14500 | //#endregion | ||
14501 | |||
14502 | //#region Gesture Managment | ||
14503 | |||
14504 | case PacketType.ActivateGestures: | ||
14505 | ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack; | ||
14506 | |||
14507 | #region Packet Session and User Check | ||
14508 | if (m_checkPackets) | ||
14509 | { | ||
14510 | if (activateGesturePacket.AgentData.SessionID != SessionId || | ||
14511 | activateGesturePacket.AgentData.AgentID != AgentId) | ||
14512 | break; | ||
14513 | } | ||
14514 | #endregion | ||
14515 | |||
14516 | ActivateGesture handlerActivateGesture = OnActivateGesture; | ||
14517 | if (handlerActivateGesture != null) | ||
14518 | { | ||
14519 | handlerActivateGesture(this, | ||
14520 | activateGesturePacket.Data[0].AssetID, | ||
14521 | activateGesturePacket.Data[0].ItemID); | ||
14522 | } | ||
14523 | else m_log.Error("Null pointer for activateGesture"); | ||
14524 | |||
14525 | break; | ||
14526 | |||
14527 | case PacketType.DeactivateGestures: | ||
14528 | DeactivateGesturesPacket deactivateGesturePacket = (DeactivateGesturesPacket)Pack; | ||
14529 | |||
14530 | #region Packet Session and User Check | ||
14531 | if (m_checkPackets) | ||
14532 | { | ||
14533 | if (deactivateGesturePacket.AgentData.SessionID != SessionId || | ||
14534 | deactivateGesturePacket.AgentData.AgentID != AgentId) | ||
14535 | break; | ||
14536 | } | ||
14537 | #endregion | ||
14538 | |||
14539 | DeactivateGesture handlerDeactivateGesture = OnDeactivateGesture; | ||
14540 | if (handlerDeactivateGesture != null) | ||
14541 | { | ||
14542 | handlerDeactivateGesture(this, deactivateGesturePacket.Data[0].ItemID); | ||
14543 | } | ||
14544 | break; | ||
14545 | case PacketType.ObjectOwner: | ||
14546 | ObjectOwnerPacket objectOwnerPacket = (ObjectOwnerPacket)Pack; | ||
14547 | |||
14548 | #region Packet Session and User Check | ||
14549 | if (m_checkPackets) | ||
14550 | { | ||
14551 | if (objectOwnerPacket.AgentData.SessionID != SessionId || | ||
14552 | objectOwnerPacket.AgentData.AgentID != AgentId) | ||
14553 | break; | ||
14554 | } | ||
14555 | #endregion | ||
14556 | |||
14557 | List<uint> localIDs = new List<uint>(); | ||
14558 | |||
14559 | foreach (ObjectOwnerPacket.ObjectDataBlock d in objectOwnerPacket.ObjectData) | ||
14560 | localIDs.Add(d.ObjectLocalID); | ||
14561 | |||
14562 | ObjectOwner handlerObjectOwner = OnObjectOwner; | ||
14563 | if (handlerObjectOwner != null) | ||
14564 | { | ||
14565 | handlerObjectOwner(this, objectOwnerPacket.HeaderData.OwnerID, objectOwnerPacket.HeaderData.GroupID, localIDs); | ||
14566 | } | ||
14567 | break; | ||
14568 | |||
14569 | //#endregion | ||
14570 | |||
14571 | case PacketType.AgentFOV: | ||
14572 | AgentFOVPacket fovPacket = (AgentFOVPacket)Pack; | ||
14573 | |||
14574 | if (fovPacket.FOVBlock.GenCounter > m_agentFOVCounter) | ||
14575 | { | ||
14576 | m_agentFOVCounter = fovPacket.FOVBlock.GenCounter; | ||
14577 | AgentFOV handlerAgentFOV = OnAgentFOV; | ||
14578 | if (handlerAgentFOV != null) | ||
14579 | { | ||
14580 | handlerAgentFOV(this, fovPacket.FOVBlock.VerticalAngle); | ||
14581 | } | ||
14582 | } | ||
14583 | break; | ||
14584 | |||
14585 | //#region unimplemented handlers | ||
14586 | |||
14587 | case PacketType.ViewerStats: | ||
14588 | // TODO: handle this packet | ||
14589 | //m_log.Warn("[CLIENT]: unhandled ViewerStats packet"); | ||
14590 | break; | ||
14591 | |||
14592 | case PacketType.MapItemRequest: | ||
14593 | MapItemRequestPacket mirpk = (MapItemRequestPacket)Pack; | ||
14594 | |||
14595 | #region Packet Session and User Check | ||
14596 | if (m_checkPackets) | ||
14597 | { | ||
14598 | if (mirpk.AgentData.SessionID != SessionId || | ||
14599 | mirpk.AgentData.AgentID != AgentId) | ||
14600 | break; | ||
14601 | } | ||
14602 | #endregion | ||
14603 | |||
14604 | //m_log.Debug(mirpk.ToString()); | ||
14605 | MapItemRequest handlerMapItemRequest = OnMapItemRequest; | ||
14606 | if (handlerMapItemRequest != null) | ||
14607 | { | ||
14608 | handlerMapItemRequest(this, mirpk.AgentData.Flags, mirpk.AgentData.EstateID, | ||
14609 | mirpk.AgentData.Godlike, mirpk.RequestData.ItemType, | ||
14610 | mirpk.RequestData.RegionHandle); | ||
14611 | |||
14612 | } | ||
14613 | break; | ||
14614 | |||
14615 | case PacketType.TransferAbort: | ||
14616 | // TODO: handle this packet | ||
14617 | //m_log.Warn("[CLIENT]: unhandled TransferAbort packet"); | ||
14618 | break; | ||
14619 | |||
14620 | case PacketType.MuteListRequest: | ||
14621 | MuteListRequestPacket muteListRequest = | ||
14622 | (MuteListRequestPacket)Pack; | ||
14623 | |||
14624 | #region Packet Session and User Check | ||
14625 | if (m_checkPackets) | ||
14626 | { | ||
14627 | if (muteListRequest.AgentData.SessionID != SessionId || | ||
14628 | muteListRequest.AgentData.AgentID != AgentId) | ||
14629 | break; | ||
14630 | } | ||
14631 | #endregion | ||
14632 | |||
14633 | MuteListRequest handlerMuteListRequest = OnMuteListRequest; | ||
14634 | if (handlerMuteListRequest != null) | ||
14635 | { | ||
14636 | handlerMuteListRequest(this, muteListRequest.MuteData.MuteCRC); | ||
14637 | } | ||
14638 | else | ||
14639 | { | ||
14640 | SendUseCachedMuteList(); | ||
14641 | } | ||
14642 | break; | ||
14643 | |||
14644 | case PacketType.UseCircuitCode: | ||
14645 | // Don't display this one, we handle it at a lower level | ||
14646 | break; | ||
14647 | |||
14648 | case PacketType.AgentHeightWidth: | ||
14649 | // TODO: handle this packet | ||
14650 | //m_log.Warn("[CLIENT]: unhandled AgentHeightWidth packet"); | ||
14651 | break; | ||
14652 | |||
14653 | case PacketType.InventoryDescendents: | ||
14654 | // TODO: handle this packet | ||
14655 | //m_log.Warn("[CLIENT]: unhandled InventoryDescent packet"); | ||
14656 | |||
14657 | break; | ||
14658 | |||
14659 | case PacketType.DirPlacesQuery: | ||
14660 | DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack; | ||
14661 | //m_log.Debug(dirPlacesQueryPacket.ToString()); | ||
14662 | |||
14663 | #region Packet Session and User Check | ||
14664 | if (m_checkPackets) | ||
14665 | { | ||
14666 | if (dirPlacesQueryPacket.AgentData.SessionID != SessionId || | ||
14667 | dirPlacesQueryPacket.AgentData.AgentID != AgentId) | ||
14668 | break; | ||
14669 | } | ||
14670 | #endregion | ||
14671 | |||
14672 | DirPlacesQuery handlerDirPlacesQuery = OnDirPlacesQuery; | ||
14673 | if (handlerDirPlacesQuery != null) | ||
14674 | { | ||
14675 | handlerDirPlacesQuery(this, | ||
14676 | dirPlacesQueryPacket.QueryData.QueryID, | ||
14677 | Utils.BytesToString( | ||
14678 | dirPlacesQueryPacket.QueryData.QueryText), | ||
14679 | (int)dirPlacesQueryPacket.QueryData.QueryFlags, | ||
14680 | (int)dirPlacesQueryPacket.QueryData.Category, | ||
14681 | Utils.BytesToString( | ||
14682 | dirPlacesQueryPacket.QueryData.SimName), | ||
14683 | dirPlacesQueryPacket.QueryData.QueryStart); | ||
14684 | } | ||
14685 | break; | ||
14686 | |||
14687 | case PacketType.DirFindQuery: | ||
14688 | DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack; | ||
14689 | |||
14690 | #region Packet Session and User Check | ||
14691 | if (m_checkPackets) | ||
14692 | { | ||
14693 | if (dirFindQueryPacket.AgentData.SessionID != SessionId || | ||
14694 | dirFindQueryPacket.AgentData.AgentID != AgentId) | ||
14695 | break; | ||
14696 | } | ||
14697 | #endregion | ||
14698 | |||
14699 | DirFindQuery handlerDirFindQuery = OnDirFindQuery; | ||
14700 | if (handlerDirFindQuery != null) | ||
14701 | { | ||
14702 | handlerDirFindQuery(this, | ||
14703 | dirFindQueryPacket.QueryData.QueryID, | ||
14704 | Utils.BytesToString( | ||
14705 | dirFindQueryPacket.QueryData.QueryText), | ||
14706 | dirFindQueryPacket.QueryData.QueryFlags, | ||
14707 | dirFindQueryPacket.QueryData.QueryStart); | ||
14708 | } | ||
14709 | break; | ||
14710 | |||
14711 | case PacketType.DirLandQuery: | ||
14712 | DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack; | ||
14713 | |||
14714 | #region Packet Session and User Check | ||
14715 | if (m_checkPackets) | ||
14716 | { | ||
14717 | if (dirLandQueryPacket.AgentData.SessionID != SessionId || | ||
14718 | dirLandQueryPacket.AgentData.AgentID != AgentId) | ||
14719 | break; | ||
14720 | } | ||
14721 | #endregion | ||
14722 | |||
14723 | DirLandQuery handlerDirLandQuery = OnDirLandQuery; | ||
14724 | if (handlerDirLandQuery != null) | ||
14725 | { | ||
14726 | handlerDirLandQuery(this, | ||
14727 | dirLandQueryPacket.QueryData.QueryID, | ||
14728 | dirLandQueryPacket.QueryData.QueryFlags, | ||
14729 | dirLandQueryPacket.QueryData.SearchType, | ||
14730 | dirLandQueryPacket.QueryData.Price, | ||
14731 | dirLandQueryPacket.QueryData.Area, | ||
14732 | dirLandQueryPacket.QueryData.QueryStart); | ||
14733 | } | ||
14734 | break; | ||
14735 | |||
14736 | case PacketType.DirPopularQuery: | ||
14737 | DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack; | ||
14738 | |||
14739 | #region Packet Session and User Check | ||
14740 | if (m_checkPackets) | ||
14741 | { | ||
14742 | if (dirPopularQueryPacket.AgentData.SessionID != SessionId || | ||
14743 | dirPopularQueryPacket.AgentData.AgentID != AgentId) | ||
14744 | break; | ||
14745 | } | ||
14746 | #endregion | ||
14747 | |||
14748 | DirPopularQuery handlerDirPopularQuery = OnDirPopularQuery; | ||
14749 | if (handlerDirPopularQuery != null) | ||
14750 | { | ||
14751 | handlerDirPopularQuery(this, | ||
14752 | dirPopularQueryPacket.QueryData.QueryID, | ||
14753 | dirPopularQueryPacket.QueryData.QueryFlags); | ||
14754 | } | ||
14755 | break; | ||
14756 | |||
14757 | case PacketType.DirClassifiedQuery: | ||
14758 | DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack; | ||
14759 | |||
14760 | #region Packet Session and User Check | ||
14761 | if (m_checkPackets) | ||
14762 | { | ||
14763 | if (dirClassifiedQueryPacket.AgentData.SessionID != SessionId || | ||
14764 | dirClassifiedQueryPacket.AgentData.AgentID != AgentId) | ||
14765 | break; | ||
14766 | } | ||
14767 | #endregion | ||
14768 | |||
14769 | DirClassifiedQuery handlerDirClassifiedQuery = OnDirClassifiedQuery; | ||
14770 | if (handlerDirClassifiedQuery != null) | ||
14771 | { | ||
14772 | handlerDirClassifiedQuery(this, | ||
14773 | dirClassifiedQueryPacket.QueryData.QueryID, | ||
14774 | Utils.BytesToString( | ||
14775 | dirClassifiedQueryPacket.QueryData.QueryText), | ||
14776 | dirClassifiedQueryPacket.QueryData.QueryFlags, | ||
14777 | dirClassifiedQueryPacket.QueryData.Category, | ||
14778 | dirClassifiedQueryPacket.QueryData.QueryStart); | ||
14779 | } | ||
14780 | break; | ||
14781 | |||
14782 | case PacketType.EventInfoRequest: | ||
14783 | EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack; | ||
14784 | |||
14785 | #region Packet Session and User Check | ||
14786 | if (m_checkPackets) | ||
14787 | { | ||
14788 | if (eventInfoRequestPacket.AgentData.SessionID != SessionId || | ||
14789 | eventInfoRequestPacket.AgentData.AgentID != AgentId) | ||
14790 | break; | ||
14791 | } | ||
14792 | #endregion | ||
14793 | |||
14794 | if (OnEventInfoRequest != null) | ||
14795 | { | ||
14796 | OnEventInfoRequest(this, eventInfoRequestPacket.EventData.EventID); | ||
14797 | } | ||
14798 | break; | ||
14799 | |||
14800 | //#region Calling Card | ||
14801 | |||
14802 | case PacketType.OfferCallingCard: | ||
14803 | OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack; | ||
14804 | |||
14805 | #region Packet Session and User Check | ||
14806 | if (m_checkPackets) | ||
14807 | { | ||
14808 | if (offerCallingCardPacket.AgentData.SessionID != SessionId || | ||
14809 | offerCallingCardPacket.AgentData.AgentID != AgentId) | ||
14810 | break; | ||
14811 | } | ||
14812 | #endregion | ||
14813 | |||
14814 | if (OnOfferCallingCard != null) | ||
14815 | { | ||
14816 | OnOfferCallingCard(this, | ||
14817 | offerCallingCardPacket.AgentBlock.DestID, | ||
14818 | offerCallingCardPacket.AgentBlock.TransactionID); | ||
14819 | } | ||
14820 | break; | ||
14821 | |||
14822 | case PacketType.AcceptCallingCard: | ||
14823 | AcceptCallingCardPacket acceptCallingCardPacket = (AcceptCallingCardPacket)Pack; | ||
14824 | |||
14825 | #region Packet Session and User Check | ||
14826 | if (m_checkPackets) | ||
14827 | { | ||
14828 | if (acceptCallingCardPacket.AgentData.SessionID != SessionId || | ||
14829 | acceptCallingCardPacket.AgentData.AgentID != AgentId) | ||
14830 | break; | ||
14831 | } | ||
14832 | #endregion | ||
14833 | |||
14834 | // according to http://wiki.secondlife.com/wiki/AcceptCallingCard FolderData should | ||
14835 | // contain exactly one entry | ||
14836 | if (OnAcceptCallingCard != null && acceptCallingCardPacket.FolderData.Length > 0) | ||
14837 | { | ||
14838 | OnAcceptCallingCard(this, | ||
14839 | acceptCallingCardPacket.TransactionBlock.TransactionID, | ||
14840 | acceptCallingCardPacket.FolderData[0].FolderID); | ||
14841 | } | ||
14842 | break; | ||
14843 | |||
14844 | case PacketType.DeclineCallingCard: | ||
14845 | DeclineCallingCardPacket declineCallingCardPacket = (DeclineCallingCardPacket)Pack; | ||
14846 | |||
14847 | #region Packet Session and User Check | ||
14848 | if (m_checkPackets) | ||
14849 | { | ||
14850 | if (declineCallingCardPacket.AgentData.SessionID != SessionId || | ||
14851 | declineCallingCardPacket.AgentData.AgentID != AgentId) | ||
14852 | break; | ||
14853 | } | ||
14854 | #endregion | ||
14855 | |||
14856 | if (OnDeclineCallingCard != null) | ||
14857 | { | ||
14858 | OnDeclineCallingCard(this, | ||
14859 | declineCallingCardPacket.TransactionBlock.TransactionID); | ||
14860 | } | ||
14861 | break; | ||
14862 | //#endregion | ||
14863 | |||
14864 | //#region Groups | ||
14865 | case PacketType.ActivateGroup: | ||
14866 | ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack; | ||
14867 | |||
14868 | #region Packet Session and User Check | ||
14869 | if (m_checkPackets) | ||
14870 | { | ||
14871 | if (activateGroupPacket.AgentData.SessionID != SessionId || | ||
14872 | activateGroupPacket.AgentData.AgentID != AgentId) | ||
14873 | break; | ||
14874 | } | ||
14875 | #endregion | ||
14876 | |||
14877 | if (m_GroupsModule != null) | ||
14878 | { | ||
14879 | m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID); | ||
14880 | m_GroupsModule.SendAgentGroupDataUpdate(this); | ||
14881 | } | ||
14882 | break; | ||
14883 | |||
14884 | |||
14885 | case PacketType.GroupTitlesRequest: | ||
14886 | GroupTitlesRequestPacket groupTitlesRequest = | ||
14887 | (GroupTitlesRequestPacket)Pack; | ||
14888 | |||
14889 | #region Packet Session and User Check | ||
14890 | if (m_checkPackets) | ||
14891 | { | ||
14892 | if (groupTitlesRequest.AgentData.SessionID != SessionId || | ||
14893 | groupTitlesRequest.AgentData.AgentID != AgentId) | ||
14894 | break; | ||
14895 | } | ||
14896 | #endregion | ||
14897 | |||
14898 | if (m_GroupsModule != null) | ||
14899 | { | ||
14900 | GroupTitlesReplyPacket groupTitlesReply = (GroupTitlesReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupTitlesReply); | ||
14901 | |||
14902 | groupTitlesReply.AgentData = | ||
14903 | new GroupTitlesReplyPacket.AgentDataBlock(); | ||
14904 | |||
14905 | groupTitlesReply.AgentData.AgentID = AgentId; | ||
14906 | groupTitlesReply.AgentData.GroupID = | ||
14907 | groupTitlesRequest.AgentData.GroupID; | ||
14908 | |||
14909 | groupTitlesReply.AgentData.RequestID = | ||
14910 | groupTitlesRequest.AgentData.RequestID; | ||
14911 | |||
14912 | List<GroupTitlesData> titles = | ||
14913 | m_GroupsModule.GroupTitlesRequest(this, | ||
14914 | groupTitlesRequest.AgentData.GroupID); | ||
14915 | |||
14916 | groupTitlesReply.GroupData = | ||
14917 | new GroupTitlesReplyPacket.GroupDataBlock[titles.Count]; | ||
14918 | |||
14919 | int i = 0; | ||
14920 | foreach (GroupTitlesData d in titles) | ||
14921 | { | ||
14922 | groupTitlesReply.GroupData[i] = | ||
14923 | new GroupTitlesReplyPacket.GroupDataBlock(); | ||
14924 | |||
14925 | groupTitlesReply.GroupData[i].Title = | ||
14926 | Util.StringToBytes256(d.Name); | ||
14927 | groupTitlesReply.GroupData[i].RoleID = | ||
14928 | d.UUID; | ||
14929 | groupTitlesReply.GroupData[i].Selected = | ||
14930 | d.Selected; | ||
14931 | i++; | ||
14932 | } | ||
14933 | |||
14934 | OutPacket(groupTitlesReply, ThrottleOutPacketType.Task); | ||
14935 | } | ||
14936 | break; | ||
14937 | |||
14938 | case PacketType.GroupProfileRequest: | ||
14939 | GroupProfileRequestPacket groupProfileRequest = | ||
14940 | (GroupProfileRequestPacket)Pack; | ||
14941 | |||
14942 | #region Packet Session and User Check | ||
14943 | if (m_checkPackets) | ||
14944 | { | ||
14945 | if (groupProfileRequest.AgentData.SessionID != SessionId || | ||
14946 | groupProfileRequest.AgentData.AgentID != AgentId) | ||
14947 | break; | ||
14948 | } | ||
14949 | #endregion | ||
14950 | |||
14951 | if (m_GroupsModule != null) | ||
14952 | { | ||
14953 | GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply); | ||
14954 | |||
14955 | groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock(); | ||
14956 | groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock(); | ||
14957 | groupProfileReply.AgentData.AgentID = AgentId; | ||
14958 | |||
14959 | GroupProfileData d = m_GroupsModule.GroupProfileRequest(this, | ||
14960 | groupProfileRequest.GroupData.GroupID); | ||
14961 | |||
14962 | groupProfileReply.GroupData.GroupID = d.GroupID; | ||
14963 | groupProfileReply.GroupData.Name = Util.StringToBytes256(d.Name); | ||
14964 | groupProfileReply.GroupData.Charter = Util.StringToBytes1024(d.Charter); | ||
14965 | groupProfileReply.GroupData.ShowInList = d.ShowInList; | ||
14966 | groupProfileReply.GroupData.MemberTitle = Util.StringToBytes256(d.MemberTitle); | ||
14967 | groupProfileReply.GroupData.PowersMask = d.PowersMask; | ||
14968 | groupProfileReply.GroupData.InsigniaID = d.InsigniaID; | ||
14969 | groupProfileReply.GroupData.FounderID = d.FounderID; | ||
14970 | groupProfileReply.GroupData.MembershipFee = d.MembershipFee; | ||
14971 | groupProfileReply.GroupData.OpenEnrollment = d.OpenEnrollment; | ||
14972 | groupProfileReply.GroupData.Money = d.Money; | ||
14973 | groupProfileReply.GroupData.GroupMembershipCount = d.GroupMembershipCount; | ||
14974 | groupProfileReply.GroupData.GroupRolesCount = d.GroupRolesCount; | ||
14975 | groupProfileReply.GroupData.AllowPublish = d.AllowPublish; | ||
14976 | groupProfileReply.GroupData.MaturePublish = d.MaturePublish; | ||
14977 | groupProfileReply.GroupData.OwnerRole = d.OwnerRole; | ||
14978 | |||
14979 | OutPacket(groupProfileReply, ThrottleOutPacketType.Task); | ||
14980 | } | ||
14981 | break; | ||
14982 | |||
14983 | case PacketType.GroupMembersRequest: | ||
14984 | GroupMembersRequestPacket groupMembersRequestPacket = | ||
14985 | (GroupMembersRequestPacket)Pack; | ||
14986 | |||
14987 | #region Packet Session and User Check | ||
14988 | if (m_checkPackets) | ||
14989 | { | ||
14990 | if (groupMembersRequestPacket.AgentData.SessionID != SessionId || | ||
14991 | groupMembersRequestPacket.AgentData.AgentID != AgentId) | ||
14992 | break; | ||
14993 | } | ||
14994 | #endregion | ||
14995 | |||
14996 | if (m_GroupsModule != null) | ||
14997 | { | ||
14998 | List<GroupMembersData> members = | ||
14999 | m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID); | ||
15000 | |||
15001 | int memberCount = members.Count; | ||
15002 | |||
15003 | while (true) | ||
15004 | { | ||
15005 | int blockCount = members.Count; | ||
15006 | if (blockCount > 40) | ||
15007 | blockCount = 40; | ||
15008 | |||
15009 | GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply); | ||
15010 | |||
15011 | groupMembersReply.AgentData = | ||
15012 | new GroupMembersReplyPacket.AgentDataBlock(); | ||
15013 | groupMembersReply.GroupData = | ||
15014 | new GroupMembersReplyPacket.GroupDataBlock(); | ||
15015 | groupMembersReply.MemberData = | ||
15016 | new GroupMembersReplyPacket.MemberDataBlock[ | ||
15017 | blockCount]; | ||
15018 | |||
15019 | groupMembersReply.AgentData.AgentID = AgentId; | ||
15020 | groupMembersReply.GroupData.GroupID = | ||
15021 | groupMembersRequestPacket.GroupData.GroupID; | ||
15022 | groupMembersReply.GroupData.RequestID = | ||
15023 | groupMembersRequestPacket.GroupData.RequestID; | ||
15024 | groupMembersReply.GroupData.MemberCount = memberCount; | ||
15025 | |||
15026 | for (int i = 0; i < blockCount; i++) | ||
15027 | { | ||
15028 | GroupMembersData m = members[0]; | ||
15029 | members.RemoveAt(0); | ||
15030 | |||
15031 | groupMembersReply.MemberData[i] = | ||
15032 | new GroupMembersReplyPacket.MemberDataBlock(); | ||
15033 | groupMembersReply.MemberData[i].AgentID = | ||
15034 | m.AgentID; | ||
15035 | groupMembersReply.MemberData[i].Contribution = | ||
15036 | m.Contribution; | ||
15037 | groupMembersReply.MemberData[i].OnlineStatus = | ||
15038 | Util.StringToBytes256(m.OnlineStatus); | ||
15039 | groupMembersReply.MemberData[i].AgentPowers = | ||
15040 | m.AgentPowers; | ||
15041 | groupMembersReply.MemberData[i].Title = | ||
15042 | Util.StringToBytes256(m.Title); | ||
15043 | groupMembersReply.MemberData[i].IsOwner = | ||
15044 | m.IsOwner; | ||
15045 | } | ||
15046 | OutPacket(groupMembersReply, ThrottleOutPacketType.Task); | ||
15047 | if (members.Count == 0) | ||
15048 | break; | ||
15049 | } | ||
15050 | } | ||
15051 | break; | ||
15052 | |||
15053 | case PacketType.GroupRoleDataRequest: | ||
15054 | GroupRoleDataRequestPacket groupRolesRequest = | ||
15055 | (GroupRoleDataRequestPacket)Pack; | ||
15056 | |||
15057 | #region Packet Session and User Check | ||
15058 | if (m_checkPackets) | ||
15059 | { | ||
15060 | if (groupRolesRequest.AgentData.SessionID != SessionId || | ||
15061 | groupRolesRequest.AgentData.AgentID != AgentId) | ||
15062 | break; | ||
15063 | } | ||
15064 | #endregion | ||
15065 | |||
15066 | if (m_GroupsModule != null) | ||
15067 | { | ||
15068 | GroupRoleDataReplyPacket groupRolesReply = (GroupRoleDataReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleDataReply); | ||
15069 | |||
15070 | groupRolesReply.AgentData = | ||
15071 | new GroupRoleDataReplyPacket.AgentDataBlock(); | ||
15072 | |||
15073 | groupRolesReply.AgentData.AgentID = AgentId; | ||
15074 | |||
15075 | groupRolesReply.GroupData = | ||
15076 | new GroupRoleDataReplyPacket.GroupDataBlock(); | ||
15077 | |||
15078 | groupRolesReply.GroupData.GroupID = | ||
15079 | groupRolesRequest.GroupData.GroupID; | ||
15080 | |||
15081 | groupRolesReply.GroupData.RequestID = | ||
15082 | groupRolesRequest.GroupData.RequestID; | ||
15083 | |||
15084 | List<GroupRolesData> titles = | ||
15085 | m_GroupsModule.GroupRoleDataRequest(this, | ||
15086 | groupRolesRequest.GroupData.GroupID); | ||
15087 | |||
15088 | groupRolesReply.GroupData.RoleCount = | ||
15089 | titles.Count; | ||
15090 | |||
15091 | groupRolesReply.RoleData = | ||
15092 | new GroupRoleDataReplyPacket.RoleDataBlock[titles.Count]; | ||
15093 | |||
15094 | int i = 0; | ||
15095 | foreach (GroupRolesData d in titles) | ||
15096 | { | ||
15097 | groupRolesReply.RoleData[i] = | ||
15098 | new GroupRoleDataReplyPacket.RoleDataBlock(); | ||
15099 | |||
15100 | groupRolesReply.RoleData[i].RoleID = | ||
15101 | d.RoleID; | ||
15102 | groupRolesReply.RoleData[i].Name = | ||
15103 | Util.StringToBytes256(d.Name); | ||
15104 | groupRolesReply.RoleData[i].Title = | ||
15105 | Util.StringToBytes256(d.Title); | ||
15106 | groupRolesReply.RoleData[i].Description = | ||
15107 | Util.StringToBytes1024(d.Description); | ||
15108 | groupRolesReply.RoleData[i].Powers = | ||
15109 | d.Powers; | ||
15110 | groupRolesReply.RoleData[i].Members = | ||
15111 | (uint)d.Members; | ||
15112 | |||
15113 | i++; | ||
15114 | } | ||
15115 | |||
15116 | OutPacket(groupRolesReply, ThrottleOutPacketType.Task); | ||
15117 | } | ||
15118 | break; | ||
15119 | |||
15120 | case PacketType.GroupRoleMembersRequest: | ||
15121 | GroupRoleMembersRequestPacket groupRoleMembersRequest = | ||
15122 | (GroupRoleMembersRequestPacket)Pack; | ||
15123 | |||
15124 | #region Packet Session and User Check | ||
15125 | if (m_checkPackets) | ||
15126 | { | ||
15127 | if (groupRoleMembersRequest.AgentData.SessionID != SessionId || | ||
15128 | groupRoleMembersRequest.AgentData.AgentID != AgentId) | ||
15129 | break; | ||
15130 | } | ||
15131 | #endregion | ||
15132 | |||
15133 | if (m_GroupsModule != null) | ||
15134 | { | ||
15135 | List<GroupRoleMembersData> mappings = | ||
15136 | m_GroupsModule.GroupRoleMembersRequest(this, | ||
15137 | groupRoleMembersRequest.GroupData.GroupID); | ||
15138 | |||
15139 | int mappingsCount = mappings.Count; | ||
15140 | |||
15141 | while (mappings.Count > 0) | ||
15142 | { | ||
15143 | int pairs = mappings.Count; | ||
15144 | if (pairs > 32) | ||
15145 | pairs = 32; | ||
15146 | |||
15147 | GroupRoleMembersReplyPacket groupRoleMembersReply = (GroupRoleMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleMembersReply); | ||
15148 | groupRoleMembersReply.AgentData = | ||
15149 | new GroupRoleMembersReplyPacket.AgentDataBlock(); | ||
15150 | groupRoleMembersReply.AgentData.AgentID = | ||
15151 | AgentId; | ||
15152 | groupRoleMembersReply.AgentData.GroupID = | ||
15153 | groupRoleMembersRequest.GroupData.GroupID; | ||
15154 | groupRoleMembersReply.AgentData.RequestID = | ||
15155 | groupRoleMembersRequest.GroupData.RequestID; | ||
15156 | |||
15157 | groupRoleMembersReply.AgentData.TotalPairs = | ||
15158 | (uint)mappingsCount; | ||
15159 | |||
15160 | groupRoleMembersReply.MemberData = | ||
15161 | new GroupRoleMembersReplyPacket.MemberDataBlock[pairs]; | ||
15162 | |||
15163 | for (int i = 0; i < pairs; i++) | ||
15164 | { | ||
15165 | GroupRoleMembersData d = mappings[0]; | ||
15166 | mappings.RemoveAt(0); | ||
15167 | |||
15168 | groupRoleMembersReply.MemberData[i] = | ||
15169 | new GroupRoleMembersReplyPacket.MemberDataBlock(); | ||
15170 | |||
15171 | groupRoleMembersReply.MemberData[i].RoleID = | ||
15172 | d.RoleID; | ||
15173 | groupRoleMembersReply.MemberData[i].MemberID = | ||
15174 | d.MemberID; | ||
15175 | } | ||
15176 | |||
15177 | OutPacket(groupRoleMembersReply, ThrottleOutPacketType.Task); | ||
15178 | } | ||
15179 | } | ||
15180 | break; | ||
15181 | |||
15182 | case PacketType.CreateGroupRequest: | ||
15183 | CreateGroupRequestPacket createGroupRequest = | ||
15184 | (CreateGroupRequestPacket)Pack; | ||
15185 | |||
15186 | #region Packet Session and User Check | ||
15187 | if (m_checkPackets) | ||
15188 | { | ||
15189 | if (createGroupRequest.AgentData.SessionID != SessionId || | ||
15190 | createGroupRequest.AgentData.AgentID != AgentId) | ||
15191 | break; | ||
15192 | } | ||
15193 | #endregion | ||
15194 | |||
15195 | if (m_GroupsModule != null) | ||
15196 | { | ||
15197 | m_GroupsModule.CreateGroup(this, | ||
15198 | Utils.BytesToString(createGroupRequest.GroupData.Name), | ||
15199 | Utils.BytesToString(createGroupRequest.GroupData.Charter), | ||
15200 | createGroupRequest.GroupData.ShowInList, | ||
15201 | createGroupRequest.GroupData.InsigniaID, | ||
15202 | createGroupRequest.GroupData.MembershipFee, | ||
15203 | createGroupRequest.GroupData.OpenEnrollment, | ||
15204 | createGroupRequest.GroupData.AllowPublish, | ||
15205 | createGroupRequest.GroupData.MaturePublish); | ||
15206 | } | ||
15207 | break; | ||
15208 | |||
15209 | case PacketType.UpdateGroupInfo: | ||
15210 | UpdateGroupInfoPacket updateGroupInfo = | ||
15211 | (UpdateGroupInfoPacket)Pack; | ||
15212 | |||
15213 | #region Packet Session and User Check | ||
15214 | if (m_checkPackets) | ||
15215 | { | ||
15216 | if (updateGroupInfo.AgentData.SessionID != SessionId || | ||
15217 | updateGroupInfo.AgentData.AgentID != AgentId) | ||
15218 | break; | ||
15219 | } | ||
15220 | #endregion | ||
15221 | |||
15222 | if (m_GroupsModule != null) | ||
15223 | { | ||
15224 | m_GroupsModule.UpdateGroupInfo(this, | ||
15225 | updateGroupInfo.GroupData.GroupID, | ||
15226 | Utils.BytesToString(updateGroupInfo.GroupData.Charter), | ||
15227 | updateGroupInfo.GroupData.ShowInList, | ||
15228 | updateGroupInfo.GroupData.InsigniaID, | ||
15229 | updateGroupInfo.GroupData.MembershipFee, | ||
15230 | updateGroupInfo.GroupData.OpenEnrollment, | ||
15231 | updateGroupInfo.GroupData.AllowPublish, | ||
15232 | updateGroupInfo.GroupData.MaturePublish); | ||
15233 | } | ||
15234 | |||
15235 | break; | ||
15236 | |||
15237 | case PacketType.SetGroupAcceptNotices: | ||
15238 | SetGroupAcceptNoticesPacket setGroupAcceptNotices = | ||
15239 | (SetGroupAcceptNoticesPacket)Pack; | ||
15240 | |||
15241 | #region Packet Session and User Check | ||
15242 | if (m_checkPackets) | ||
15243 | { | ||
15244 | if (setGroupAcceptNotices.AgentData.SessionID != SessionId || | ||
15245 | setGroupAcceptNotices.AgentData.AgentID != AgentId) | ||
15246 | break; | ||
15247 | } | ||
15248 | #endregion | ||
15249 | |||
15250 | if (m_GroupsModule != null) | ||
15251 | { | ||
15252 | m_GroupsModule.SetGroupAcceptNotices(this, | ||
15253 | setGroupAcceptNotices.Data.GroupID, | ||
15254 | setGroupAcceptNotices.Data.AcceptNotices, | ||
15255 | setGroupAcceptNotices.NewData.ListInProfile); | ||
15256 | } | ||
15257 | |||
15258 | break; | ||
15259 | |||
15260 | case PacketType.GroupTitleUpdate: | ||
15261 | GroupTitleUpdatePacket groupTitleUpdate = | ||
15262 | (GroupTitleUpdatePacket)Pack; | ||
15263 | |||
15264 | #region Packet Session and User Check | ||
15265 | if (m_checkPackets) | ||
15266 | { | ||
15267 | if (groupTitleUpdate.AgentData.SessionID != SessionId || | ||
15268 | groupTitleUpdate.AgentData.AgentID != AgentId) | ||
15269 | break; | ||
15270 | } | ||
15271 | #endregion | ||
15272 | |||
15273 | if (m_GroupsModule != null) | ||
15274 | { | ||
15275 | m_GroupsModule.GroupTitleUpdate(this, | ||
15276 | groupTitleUpdate.AgentData.GroupID, | ||
15277 | groupTitleUpdate.AgentData.TitleRoleID); | ||
15278 | } | ||
15279 | |||
15280 | break; | ||
15281 | |||
15282 | |||
15283 | case PacketType.ParcelDeedToGroup: | ||
15284 | ParcelDeedToGroupPacket parcelDeedToGroup = (ParcelDeedToGroupPacket)Pack; | ||
15285 | if (m_GroupsModule != null) | ||
15286 | { | ||
15287 | ParcelDeedToGroup handlerParcelDeedToGroup = OnParcelDeedToGroup; | ||
15288 | if (handlerParcelDeedToGroup != null) | ||
15289 | { | ||
15290 | handlerParcelDeedToGroup(parcelDeedToGroup.Data.LocalID, parcelDeedToGroup.Data.GroupID, this); | ||
15291 | |||
15292 | } | ||
15293 | } | ||
15294 | |||
15295 | break; | ||
15296 | |||
15297 | |||
15298 | case PacketType.GroupNoticesListRequest: | ||
15299 | GroupNoticesListRequestPacket groupNoticesListRequest = | ||
15300 | (GroupNoticesListRequestPacket)Pack; | ||
15301 | |||
15302 | #region Packet Session and User Check | ||
15303 | if (m_checkPackets) | ||
15304 | { | ||
15305 | if (groupNoticesListRequest.AgentData.SessionID != SessionId || | ||
15306 | groupNoticesListRequest.AgentData.AgentID != AgentId) | ||
15307 | break; | ||
15308 | } | ||
15309 | #endregion | ||
15310 | |||
15311 | if (m_GroupsModule != null) | ||
15312 | { | ||
15313 | GroupNoticeData[] gn = | ||
15314 | m_GroupsModule.GroupNoticesListRequest(this, | ||
15315 | groupNoticesListRequest.Data.GroupID); | ||
15316 | |||
15317 | GroupNoticesListReplyPacket groupNoticesListReply = (GroupNoticesListReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupNoticesListReply); | ||
15318 | groupNoticesListReply.AgentData = | ||
15319 | new GroupNoticesListReplyPacket.AgentDataBlock(); | ||
15320 | groupNoticesListReply.AgentData.AgentID = AgentId; | ||
15321 | groupNoticesListReply.AgentData.GroupID = groupNoticesListRequest.Data.GroupID; | ||
15322 | |||
15323 | groupNoticesListReply.Data = new GroupNoticesListReplyPacket.DataBlock[gn.Length]; | ||
15324 | |||
15325 | int i = 0; | ||
15326 | foreach (GroupNoticeData g in gn) | ||
15327 | { | ||
15328 | groupNoticesListReply.Data[i] = new GroupNoticesListReplyPacket.DataBlock(); | ||
15329 | groupNoticesListReply.Data[i].NoticeID = | ||
15330 | g.NoticeID; | ||
15331 | groupNoticesListReply.Data[i].Timestamp = | ||
15332 | g.Timestamp; | ||
15333 | groupNoticesListReply.Data[i].FromName = | ||
15334 | Util.StringToBytes256(g.FromName); | ||
15335 | groupNoticesListReply.Data[i].Subject = | ||
15336 | Util.StringToBytes256(g.Subject); | ||
15337 | groupNoticesListReply.Data[i].HasAttachment = | ||
15338 | g.HasAttachment; | ||
15339 | groupNoticesListReply.Data[i].AssetType = | ||
15340 | g.AssetType; | ||
15341 | i++; | ||
15342 | } | ||
15343 | |||
15344 | OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task); | ||
15345 | } | ||
15346 | |||
15347 | break; | ||
15348 | |||
15349 | case PacketType.GroupNoticeRequest: | ||
15350 | GroupNoticeRequestPacket groupNoticeRequest = | ||
15351 | (GroupNoticeRequestPacket)Pack; | ||
15352 | |||
15353 | #region Packet Session and User Check | ||
15354 | if (m_checkPackets) | ||
15355 | { | ||
15356 | if (groupNoticeRequest.AgentData.SessionID != SessionId || | ||
15357 | groupNoticeRequest.AgentData.AgentID != AgentId) | ||
15358 | break; | ||
15359 | } | ||
15360 | #endregion | ||
15361 | |||
15362 | if (m_GroupsModule != null) | ||
15363 | { | ||
15364 | m_GroupsModule.GroupNoticeRequest(this, | ||
15365 | groupNoticeRequest.Data.GroupNoticeID); | ||
15366 | } | ||
15367 | break; | ||
15368 | |||
15369 | case PacketType.GroupRoleUpdate: | ||
15370 | GroupRoleUpdatePacket groupRoleUpdate = | ||
15371 | (GroupRoleUpdatePacket)Pack; | ||
15372 | |||
15373 | #region Packet Session and User Check | ||
15374 | if (m_checkPackets) | ||
15375 | { | ||
15376 | if (groupRoleUpdate.AgentData.SessionID != SessionId || | ||
15377 | groupRoleUpdate.AgentData.AgentID != AgentId) | ||
15378 | break; | ||
15379 | } | ||
15380 | #endregion | ||
15381 | |||
15382 | if (m_GroupsModule != null) | ||
15383 | { | ||
15384 | foreach (GroupRoleUpdatePacket.RoleDataBlock d in | ||
15385 | groupRoleUpdate.RoleData) | ||
15386 | { | ||
15387 | m_GroupsModule.GroupRoleUpdate(this, | ||
15388 | groupRoleUpdate.AgentData.GroupID, | ||
15389 | d.RoleID, | ||
15390 | Utils.BytesToString(d.Name), | ||
15391 | Utils.BytesToString(d.Description), | ||
15392 | Utils.BytesToString(d.Title), | ||
15393 | d.Powers, | ||
15394 | d.UpdateType); | ||
15395 | } | ||
15396 | m_GroupsModule.NotifyChange(groupRoleUpdate.AgentData.GroupID); | ||
15397 | } | ||
15398 | break; | ||
15399 | |||
15400 | case PacketType.GroupRoleChanges: | ||
15401 | GroupRoleChangesPacket groupRoleChanges = | ||
15402 | (GroupRoleChangesPacket)Pack; | ||
15403 | |||
15404 | #region Packet Session and User Check | ||
15405 | if (m_checkPackets) | ||
15406 | { | ||
15407 | if (groupRoleChanges.AgentData.SessionID != SessionId || | ||
15408 | groupRoleChanges.AgentData.AgentID != AgentId) | ||
15409 | break; | ||
15410 | } | ||
15411 | #endregion | ||
15412 | |||
15413 | if (m_GroupsModule != null) | ||
15414 | { | ||
15415 | foreach (GroupRoleChangesPacket.RoleChangeBlock d in | ||
15416 | groupRoleChanges.RoleChange) | ||
15417 | { | ||
15418 | m_GroupsModule.GroupRoleChanges(this, | ||
15419 | groupRoleChanges.AgentData.GroupID, | ||
15420 | d.RoleID, | ||
15421 | d.MemberID, | ||
15422 | d.Change); | ||
15423 | } | ||
15424 | m_GroupsModule.NotifyChange(groupRoleChanges.AgentData.GroupID); | ||
15425 | } | ||
15426 | break; | ||
15427 | |||
15428 | case PacketType.JoinGroupRequest: | ||
15429 | JoinGroupRequestPacket joinGroupRequest = | ||
15430 | (JoinGroupRequestPacket)Pack; | ||
15431 | |||
15432 | #region Packet Session and User Check | ||
15433 | if (m_checkPackets) | ||
15434 | { | ||
15435 | if (joinGroupRequest.AgentData.SessionID != SessionId || | ||
15436 | joinGroupRequest.AgentData.AgentID != AgentId) | ||
15437 | break; | ||
15438 | } | ||
15439 | #endregion | ||
15440 | |||
15441 | if (m_GroupsModule != null) | ||
15442 | { | ||
15443 | m_GroupsModule.JoinGroupRequest(this, | ||
15444 | joinGroupRequest.GroupData.GroupID); | ||
15445 | } | ||
15446 | break; | ||
15447 | |||
15448 | case PacketType.LeaveGroupRequest: | ||
15449 | LeaveGroupRequestPacket leaveGroupRequest = | ||
15450 | (LeaveGroupRequestPacket)Pack; | ||
15451 | |||
15452 | #region Packet Session and User Check | ||
15453 | if (m_checkPackets) | ||
15454 | { | ||
15455 | if (leaveGroupRequest.AgentData.SessionID != SessionId || | ||
15456 | leaveGroupRequest.AgentData.AgentID != AgentId) | ||
15457 | break; | ||
15458 | } | ||
15459 | #endregion | ||
15460 | |||
15461 | if (m_GroupsModule != null) | ||
15462 | { | ||
15463 | m_GroupsModule.LeaveGroupRequest(this, | ||
15464 | leaveGroupRequest.GroupData.GroupID); | ||
15465 | } | ||
15466 | break; | ||
15467 | |||
15468 | case PacketType.EjectGroupMemberRequest: | ||
15469 | EjectGroupMemberRequestPacket ejectGroupMemberRequest = | ||
15470 | (EjectGroupMemberRequestPacket)Pack; | ||
15471 | |||
15472 | #region Packet Session and User Check | ||
15473 | if (m_checkPackets) | ||
15474 | { | ||
15475 | if (ejectGroupMemberRequest.AgentData.SessionID != SessionId || | ||
15476 | ejectGroupMemberRequest.AgentData.AgentID != AgentId) | ||
15477 | break; | ||
15478 | } | ||
15479 | #endregion | ||
15480 | |||
15481 | if (m_GroupsModule != null) | ||
15482 | { | ||
15483 | foreach (EjectGroupMemberRequestPacket.EjectDataBlock e | ||
15484 | in ejectGroupMemberRequest.EjectData) | ||
15485 | { | ||
15486 | m_GroupsModule.EjectGroupMemberRequest(this, | ||
15487 | ejectGroupMemberRequest.GroupData.GroupID, | ||
15488 | e.EjecteeID); | ||
15489 | } | ||
15490 | } | ||
15491 | break; | ||
15492 | |||
15493 | case PacketType.InviteGroupRequest: | ||
15494 | InviteGroupRequestPacket inviteGroupRequest = | ||
15495 | (InviteGroupRequestPacket)Pack; | ||
15496 | |||
15497 | #region Packet Session and User Check | ||
15498 | if (m_checkPackets) | ||
15499 | { | ||
15500 | if (inviteGroupRequest.AgentData.SessionID != SessionId || | ||
15501 | inviteGroupRequest.AgentData.AgentID != AgentId) | ||
15502 | break; | ||
15503 | } | ||
15504 | #endregion | ||
15505 | |||
15506 | if (m_GroupsModule != null) | ||
15507 | { | ||
15508 | foreach (InviteGroupRequestPacket.InviteDataBlock b in | ||
15509 | inviteGroupRequest.InviteData) | ||
15510 | { | ||
15511 | m_GroupsModule.InviteGroupRequest(this, | ||
15512 | inviteGroupRequest.GroupData.GroupID, | ||
15513 | b.InviteeID, | ||
15514 | b.RoleID); | ||
15515 | } | ||
15516 | } | ||
15517 | break; | ||
15518 | |||
15519 | //#endregion | ||
15520 | |||
15521 | case PacketType.StartLure: | ||
15522 | StartLurePacket startLureRequest = (StartLurePacket)Pack; | ||
15523 | |||
15524 | #region Packet Session and User Check | ||
15525 | if (m_checkPackets) | ||
15526 | { | ||
15527 | if (startLureRequest.AgentData.SessionID != SessionId || | ||
15528 | startLureRequest.AgentData.AgentID != AgentId) | ||
15529 | break; | ||
15530 | } | ||
15531 | #endregion | ||
15532 | |||
15533 | StartLure handlerStartLure = OnStartLure; | ||
15534 | if (handlerStartLure != null) | ||
15535 | handlerStartLure(startLureRequest.Info.LureType, | ||
15536 | Utils.BytesToString( | ||
15537 | startLureRequest.Info.Message), | ||
15538 | startLureRequest.TargetData[0].TargetID, | ||
15539 | this); | ||
15540 | break; | ||
15541 | |||
15542 | case PacketType.TeleportLureRequest: | ||
15543 | TeleportLureRequestPacket teleportLureRequest = | ||
15544 | (TeleportLureRequestPacket)Pack; | ||
15545 | |||
15546 | #region Packet Session and User Check | ||
15547 | if (m_checkPackets) | ||
15548 | { | ||
15549 | if (teleportLureRequest.Info.SessionID != SessionId || | ||
15550 | teleportLureRequest.Info.AgentID != AgentId) | ||
15551 | break; | ||
15552 | } | ||
15553 | #endregion | ||
15554 | |||
15555 | TeleportLureRequest handlerTeleportLureRequest = OnTeleportLureRequest; | ||
15556 | if (handlerTeleportLureRequest != null) | ||
15557 | handlerTeleportLureRequest( | ||
15558 | teleportLureRequest.Info.LureID, | ||
15559 | teleportLureRequest.Info.TeleportFlags, | ||
15560 | this); | ||
15561 | break; | ||
15562 | |||
15563 | case PacketType.ClassifiedInfoRequest: | ||
15564 | ClassifiedInfoRequestPacket classifiedInfoRequest = | ||
15565 | (ClassifiedInfoRequestPacket)Pack; | ||
15566 | |||
15567 | #region Packet Session and User Check | ||
15568 | if (m_checkPackets) | ||
15569 | { | ||
15570 | if (classifiedInfoRequest.AgentData.SessionID != SessionId || | ||
15571 | classifiedInfoRequest.AgentData.AgentID != AgentId) | ||
15572 | break; | ||
15573 | } | ||
15574 | #endregion | ||
15575 | |||
15576 | ClassifiedInfoRequest handlerClassifiedInfoRequest = OnClassifiedInfoRequest; | ||
15577 | if (handlerClassifiedInfoRequest != null) | ||
15578 | handlerClassifiedInfoRequest( | ||
15579 | classifiedInfoRequest.Data.ClassifiedID, | ||
15580 | this); | ||
15581 | break; | ||
15582 | |||
15583 | case PacketType.ClassifiedInfoUpdate: | ||
15584 | ClassifiedInfoUpdatePacket classifiedInfoUpdate = | ||
15585 | (ClassifiedInfoUpdatePacket)Pack; | ||
15586 | |||
15587 | #region Packet Session and User Check | ||
15588 | if (m_checkPackets) | ||
15589 | { | ||
15590 | if (classifiedInfoUpdate.AgentData.SessionID != SessionId || | ||
15591 | classifiedInfoUpdate.AgentData.AgentID != AgentId) | ||
15592 | break; | ||
15593 | } | ||
15594 | #endregion | ||
15595 | |||
15596 | ClassifiedInfoUpdate handlerClassifiedInfoUpdate = OnClassifiedInfoUpdate; | ||
15597 | if (handlerClassifiedInfoUpdate != null) | ||
15598 | handlerClassifiedInfoUpdate( | ||
15599 | classifiedInfoUpdate.Data.ClassifiedID, | ||
15600 | classifiedInfoUpdate.Data.Category, | ||
15601 | Utils.BytesToString( | ||
15602 | classifiedInfoUpdate.Data.Name), | ||
15603 | Utils.BytesToString( | ||
15604 | classifiedInfoUpdate.Data.Desc), | ||
15605 | classifiedInfoUpdate.Data.ParcelID, | ||
15606 | classifiedInfoUpdate.Data.ParentEstate, | ||
15607 | classifiedInfoUpdate.Data.SnapshotID, | ||
15608 | new Vector3( | ||
15609 | classifiedInfoUpdate.Data.PosGlobal), | ||
15610 | classifiedInfoUpdate.Data.ClassifiedFlags, | ||
15611 | classifiedInfoUpdate.Data.PriceForListing, | ||
15612 | this); | ||
15613 | break; | ||
15614 | |||
15615 | case PacketType.ClassifiedDelete: | ||
15616 | ClassifiedDeletePacket classifiedDelete = | ||
15617 | (ClassifiedDeletePacket)Pack; | ||
15618 | |||
15619 | #region Packet Session and User Check | ||
15620 | if (m_checkPackets) | ||
15621 | { | ||
15622 | if (classifiedDelete.AgentData.SessionID != SessionId || | ||
15623 | classifiedDelete.AgentData.AgentID != AgentId) | ||
15624 | break; | ||
15625 | } | ||
15626 | #endregion | ||
15627 | |||
15628 | ClassifiedDelete handlerClassifiedDelete = OnClassifiedDelete; | ||
15629 | if (handlerClassifiedDelete != null) | ||
15630 | handlerClassifiedDelete( | ||
15631 | classifiedDelete.Data.ClassifiedID, | ||
15632 | this); | ||
15633 | break; | ||
15634 | |||
15635 | case PacketType.ClassifiedGodDelete: | ||
15636 | ClassifiedGodDeletePacket classifiedGodDelete = | ||
15637 | (ClassifiedGodDeletePacket)Pack; | ||
15638 | |||
15639 | #region Packet Session and User Check | ||
15640 | if (m_checkPackets) | ||
15641 | { | ||
15642 | if (classifiedGodDelete.AgentData.SessionID != SessionId || | ||
15643 | classifiedGodDelete.AgentData.AgentID != AgentId) | ||
15644 | break; | ||
15645 | } | ||
15646 | #endregion | ||
15647 | |||
15648 | ClassifiedDelete handlerClassifiedGodDelete = OnClassifiedGodDelete; | ||
15649 | if (handlerClassifiedGodDelete != null) | ||
15650 | handlerClassifiedGodDelete( | ||
15651 | classifiedGodDelete.Data.ClassifiedID, | ||
15652 | this); | ||
15653 | break; | ||
15654 | |||
15655 | case PacketType.EventGodDelete: | ||
15656 | EventGodDeletePacket eventGodDelete = | ||
15657 | (EventGodDeletePacket)Pack; | ||
15658 | |||
15659 | #region Packet Session and User Check | ||
15660 | if (m_checkPackets) | ||
15661 | { | ||
15662 | if (eventGodDelete.AgentData.SessionID != SessionId || | ||
15663 | eventGodDelete.AgentData.AgentID != AgentId) | ||
15664 | break; | ||
15665 | } | ||
15666 | #endregion | ||
15667 | |||
15668 | EventGodDelete handlerEventGodDelete = OnEventGodDelete; | ||
15669 | if (handlerEventGodDelete != null) | ||
15670 | handlerEventGodDelete( | ||
15671 | eventGodDelete.EventData.EventID, | ||
15672 | eventGodDelete.QueryData.QueryID, | ||
15673 | Utils.BytesToString( | ||
15674 | eventGodDelete.QueryData.QueryText), | ||
15675 | eventGodDelete.QueryData.QueryFlags, | ||
15676 | eventGodDelete.QueryData.QueryStart, | ||
15677 | this); | ||
15678 | break; | ||
15679 | |||
15680 | case PacketType.EventNotificationAddRequest: | ||
15681 | EventNotificationAddRequestPacket eventNotificationAdd = | ||
15682 | (EventNotificationAddRequestPacket)Pack; | ||
15683 | |||
15684 | #region Packet Session and User Check | ||
15685 | if (m_checkPackets) | ||
15686 | { | ||
15687 | if (eventNotificationAdd.AgentData.SessionID != SessionId || | ||
15688 | eventNotificationAdd.AgentData.AgentID != AgentId) | ||
15689 | break; | ||
15690 | } | ||
15691 | #endregion | ||
15692 | |||
15693 | EventNotificationAddRequest handlerEventNotificationAddRequest = OnEventNotificationAddRequest; | ||
15694 | if (handlerEventNotificationAddRequest != null) | ||
15695 | handlerEventNotificationAddRequest( | ||
15696 | eventNotificationAdd.EventData.EventID, this); | ||
15697 | break; | ||
15698 | |||
15699 | case PacketType.EventNotificationRemoveRequest: | ||
15700 | EventNotificationRemoveRequestPacket eventNotificationRemove = | ||
15701 | (EventNotificationRemoveRequestPacket)Pack; | ||
15702 | |||
15703 | #region Packet Session and User Check | ||
15704 | if (m_checkPackets) | ||
15705 | { | ||
15706 | if (eventNotificationRemove.AgentData.SessionID != SessionId || | ||
15707 | eventNotificationRemove.AgentData.AgentID != AgentId) | ||
15708 | break; | ||
15709 | } | ||
15710 | #endregion | ||
15711 | |||
15712 | EventNotificationRemoveRequest handlerEventNotificationRemoveRequest = OnEventNotificationRemoveRequest; | ||
15713 | if (handlerEventNotificationRemoveRequest != null) | ||
15714 | handlerEventNotificationRemoveRequest( | ||
15715 | eventNotificationRemove.EventData.EventID, this); | ||
15716 | break; | ||
15717 | |||
15718 | case PacketType.RetrieveInstantMessages: | ||
15719 | RetrieveInstantMessagesPacket rimpInstantMessagePack = (RetrieveInstantMessagesPacket)Pack; | ||
15720 | |||
15721 | #region Packet Session and User Check | ||
15722 | if (m_checkPackets) | ||
15723 | { | ||
15724 | if (rimpInstantMessagePack.AgentData.SessionID != SessionId || | ||
15725 | rimpInstantMessagePack.AgentData.AgentID != AgentId) | ||
15726 | break; | ||
15727 | } | ||
15728 | #endregion | ||
15729 | |||
15730 | RetrieveInstantMessages handlerRetrieveInstantMessages = OnRetrieveInstantMessages; | ||
15731 | if (handlerRetrieveInstantMessages != null) | ||
15732 | handlerRetrieveInstantMessages(this); | ||
15733 | break; | ||
15734 | |||
15735 | case PacketType.PickDelete: | ||
15736 | PickDeletePacket pickDelete = | ||
15737 | (PickDeletePacket)Pack; | ||
15738 | |||
15739 | #region Packet Session and User Check | ||
15740 | if (m_checkPackets) | ||
15741 | { | ||
15742 | if (pickDelete.AgentData.SessionID != SessionId || | ||
15743 | pickDelete.AgentData.AgentID != AgentId) | ||
15744 | break; | ||
15745 | } | ||
15746 | #endregion | ||
15747 | |||
15748 | PickDelete handlerPickDelete = OnPickDelete; | ||
15749 | if (handlerPickDelete != null) | ||
15750 | handlerPickDelete(this, pickDelete.Data.PickID); | ||
15751 | break; | ||
15752 | |||
15753 | case PacketType.PickGodDelete: | ||
15754 | PickGodDeletePacket pickGodDelete = | ||
15755 | (PickGodDeletePacket)Pack; | ||
15756 | |||
15757 | #region Packet Session and User Check | ||
15758 | if (m_checkPackets) | ||
15759 | { | ||
15760 | if (pickGodDelete.AgentData.SessionID != SessionId || | ||
15761 | pickGodDelete.AgentData.AgentID != AgentId) | ||
15762 | break; | ||
15763 | } | ||
15764 | #endregion | ||
15765 | |||
15766 | PickGodDelete handlerPickGodDelete = OnPickGodDelete; | ||
15767 | if (handlerPickGodDelete != null) | ||
15768 | handlerPickGodDelete(this, | ||
15769 | pickGodDelete.AgentData.AgentID, | ||
15770 | pickGodDelete.Data.PickID, | ||
15771 | pickGodDelete.Data.QueryID); | ||
15772 | break; | ||
15773 | |||
15774 | case PacketType.PickInfoUpdate: | ||
15775 | PickInfoUpdatePacket pickInfoUpdate = | ||
15776 | (PickInfoUpdatePacket)Pack; | ||
15777 | |||
15778 | #region Packet Session and User Check | ||
15779 | if (m_checkPackets) | ||
15780 | { | ||
15781 | if (pickInfoUpdate.AgentData.SessionID != SessionId || | ||
15782 | pickInfoUpdate.AgentData.AgentID != AgentId) | ||
15783 | break; | ||
15784 | } | ||
15785 | #endregion | ||
15786 | |||
15787 | PickInfoUpdate handlerPickInfoUpdate = OnPickInfoUpdate; | ||
15788 | if (handlerPickInfoUpdate != null) | ||
15789 | handlerPickInfoUpdate(this, | ||
15790 | pickInfoUpdate.Data.PickID, | ||
15791 | pickInfoUpdate.Data.CreatorID, | ||
15792 | pickInfoUpdate.Data.TopPick, | ||
15793 | Utils.BytesToString(pickInfoUpdate.Data.Name), | ||
15794 | Utils.BytesToString(pickInfoUpdate.Data.Desc), | ||
15795 | pickInfoUpdate.Data.SnapshotID, | ||
15796 | pickInfoUpdate.Data.SortOrder, | ||
15797 | pickInfoUpdate.Data.Enabled); | ||
15798 | break; | ||
15799 | |||
15800 | case PacketType.AvatarNotesUpdate: | ||
15801 | AvatarNotesUpdatePacket avatarNotesUpdate = | ||
15802 | (AvatarNotesUpdatePacket)Pack; | ||
15803 | |||
15804 | #region Packet Session and User Check | ||
15805 | if (m_checkPackets) | ||
15806 | { | ||
15807 | if (avatarNotesUpdate.AgentData.SessionID != SessionId || | ||
15808 | avatarNotesUpdate.AgentData.AgentID != AgentId) | ||
15809 | break; | ||
15810 | } | ||
15811 | #endregion | ||
15812 | |||
15813 | AvatarNotesUpdate handlerAvatarNotesUpdate = OnAvatarNotesUpdate; | ||
15814 | if (handlerAvatarNotesUpdate != null) | ||
15815 | handlerAvatarNotesUpdate(this, | ||
15816 | avatarNotesUpdate.Data.TargetID, | ||
15817 | Utils.BytesToString(avatarNotesUpdate.Data.Notes)); | ||
15818 | break; | ||
15819 | |||
15820 | case PacketType.AvatarInterestsUpdate: | ||
15821 | AvatarInterestsUpdatePacket avatarInterestUpdate = | ||
15822 | (AvatarInterestsUpdatePacket)Pack; | ||
15823 | |||
15824 | #region Packet Session and User Check | ||
15825 | if (m_checkPackets) | ||
15826 | { | ||
15827 | if (avatarInterestUpdate.AgentData.SessionID != SessionId || | ||
15828 | avatarInterestUpdate.AgentData.AgentID != AgentId) | ||
15829 | break; | ||
15830 | } | ||
15831 | #endregion | ||
15832 | 11040 | ||
15833 | AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate; | 11041 | if (!ProcessPacketMethod(Pack)) |
15834 | if (handlerAvatarInterestUpdate != null) | 11042 | m_log.Warn("[CLIENT]: unhandled packet " + Pack); |
15835 | handlerAvatarInterestUpdate(this, | ||
15836 | avatarInterestUpdate.PropertiesData.WantToMask, | ||
15837 | Utils.BytesToString(avatarInterestUpdate.PropertiesData.WantToText), | ||
15838 | avatarInterestUpdate.PropertiesData.SkillsMask, | ||
15839 | Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText), | ||
15840 | Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText)); | ||
15841 | break; | ||
15842 | |||
15843 | case PacketType.GrantUserRights: | ||
15844 | GrantUserRightsPacket GrantUserRights = | ||
15845 | (GrantUserRightsPacket)Pack; | ||
15846 | #region Packet Session and User Check | ||
15847 | if (m_checkPackets) | ||
15848 | { | ||
15849 | if (GrantUserRights.AgentData.SessionID != SessionId || | ||
15850 | GrantUserRights.AgentData.AgentID != AgentId) | ||
15851 | break; | ||
15852 | } | ||
15853 | #endregion | ||
15854 | GrantUserFriendRights GrantUserRightsHandler = OnGrantUserRights; | ||
15855 | if (GrantUserRightsHandler != null) | ||
15856 | GrantUserRightsHandler(this, | ||
15857 | GrantUserRights.AgentData.AgentID, | ||
15858 | GrantUserRights.Rights[0].AgentRelated, | ||
15859 | GrantUserRights.Rights[0].RelatedRights); | ||
15860 | break; | ||
15861 | |||
15862 | case PacketType.PlacesQuery: | ||
15863 | PlacesQueryPacket placesQueryPacket = | ||
15864 | (PlacesQueryPacket)Pack; | ||
15865 | |||
15866 | PlacesQuery handlerPlacesQuery = OnPlacesQuery; | ||
15867 | |||
15868 | if (handlerPlacesQuery != null) | ||
15869 | handlerPlacesQuery(placesQueryPacket.AgentData.QueryID, | ||
15870 | placesQueryPacket.TransactionData.TransactionID, | ||
15871 | Utils.BytesToString( | ||
15872 | placesQueryPacket.QueryData.QueryText), | ||
15873 | placesQueryPacket.QueryData.QueryFlags, | ||
15874 | (byte)placesQueryPacket.QueryData.Category, | ||
15875 | Utils.BytesToString( | ||
15876 | placesQueryPacket.QueryData.SimName), | ||
15877 | this); | ||
15878 | break; | ||
15879 | */ | ||
15880 | #endregion | ||
15881 | default: | ||
15882 | m_log.Warn("[CLIENT]: unhandled packet " + Pack); | ||
15883 | break; | ||
15884 | } | ||
15885 | 11043 | ||
15886 | PacketPool.Instance.ReturnPacket(Pack); | 11044 | PacketPool.Instance.ReturnPacket(Pack); |
15887 | |||
15888 | } | 11045 | } |
15889 | 11046 | ||
15890 | private static PrimitiveBaseShape GetShapeFromAddPacket(ObjectAddPacket addPacket) | 11047 | private static PrimitiveBaseShape GetShapeFromAddPacket(ObjectAddPacket addPacket) |