1 files changed, 765 insertions, 18 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 49b9378..47251b7 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -350,7 +350,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         protected IAssetService m_assetService;
         private IHyperAssetService m_hyperAssets;
-
+        private const bool m_checkPackets = true;
 
         #endregion Class Members
 
@@ -1266,10 +1266,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             //
             if (totalItems == 0 && totalFolders == 0)
                 currentPacket = CreateInventoryDescendentsPacket(ownerID, folderID, version, items.Count + folders.Count, 0, 0);
-            
+
             // To preserve SL compatibility, we will NOT combine folders and items in one packet
             //
-            while(itemsSent < totalItems || foldersSent < totalFolders)
+            while (itemsSent < totalItems || foldersSent < totalFolders)
             {
                 if (currentPacket == null) // Start a new packet
                 {
@@ -1289,7 +1289,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 if (foldersToSend-- > 0)
                     currentPacket.FolderData[foldersSent % MAX_FOLDERS_PER_PACKET] = CreateFolderDataBlock(folders[foldersSent++]);
-                else if(itemsToSend-- > 0)
+                else if (itemsToSend-- > 0)
                     currentPacket.ItemData[itemsSent % MAX_ITEMS_PER_PACKET] = CreateItemDataBlock(items[itemsSent++]);
                 else
                 {
@@ -2043,7 +2043,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             packet.AgentData.SessionID = SessionId;
 
             packet.Effect = effectBlocks;
-            
+
             OutPacket(packet, ThrottleOutPacketType.State);
         }
 
@@ -2742,7 +2742,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
              }
              llsd.Add("GroupData", GroupData);
              llsd.Add("NewGroupData", NewGroupData);
- 
+
              IEventQueue eq = this.Scene.RequestModuleInterface<IEventQueue>();
              if (eq != null)
              {
@@ -3121,7 +3121,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
             objupdate.ObjectData[0] = CreateAvatarUpdateBlock(data);
-
             OutPacket(objupdate, ThrottleOutPacketType.Task);
         }
 
@@ -3172,8 +3171,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     terse.ObjectData[i] = m_avatarTerseUpdates.Dequeue();
             }
 
-            // HACK: Using the task category until the tiered reprioritization code is in
-            OutPacket(terse, ThrottleOutPacketType.Task);
+            OutPacket(terse, ThrottleOutPacketType.State);
         }
 
         public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)
@@ -4045,7 +4043,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 if (collisionPlane == Vector4.Zero)
                     collisionPlane = Vector4.UnitW;
-
+                //m_log.DebugFormat("CollisionPlane: {0}",collisionPlane);
                 collisionPlane.ToBytes(data, pos);
                 pos += 16;
             }
@@ -4130,12 +4128,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             update.PCode = (byte)PCode.Avatar;
             update.ProfileCurve = 1;
             update.PSBlock = Utils.EmptyBytes;
-            update.Scale = Vector3.One;
+            update.Scale = new Vector3(0.45f,0.6f,1.9f);
             update.Text = Utils.EmptyBytes;
             update.TextColor = new byte[4];
             update.TextureAnim = Utils.EmptyBytes;
             update.TextureEntry = data.TextureEntry ?? Utils.EmptyBytes;
-            update.UpdateFlags = 61 + (9 << 8) + (130 << 16) + (16 << 24); // TODO: Replace these numbers with PrimFlags
+            update.UpdateFlags = (uint)(PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner | PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer | PrimFlags.ObjectOwnerModify);//61 + (9 << 8) + (130 << 16) + (16 << 24); // TODO: Replace these numbers with PrimFlags
 
             return update;
         }
@@ -4282,6 +4280,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.UUIDGroupNameRequest, HandleUUIDGroupNameRequest);
             AddLocalPacketHandler(PacketType.ObjectGroup, HandleObjectGroupRequest);
             AddLocalPacketHandler(PacketType.GenericMessage, HandleGenericMessage);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest);
+            AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate);
+            AddLocalPacketHandler(PacketType.ScriptDialogReply, HandlerScriptDialogReply);
+            AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage);
+            AddLocalPacketHandler(PacketType.AcceptFriendship, HandlerAcceptFriendship);
+            AddLocalPacketHandler(PacketType.DeclineFriendship, HandlerDeclineFriendship);
+            AddLocalPacketHandler(PacketType.TerminateFriendship, HandlerTerminateFrendship);
+            AddLocalPacketHandler(PacketType.RezObject, HandlerRezObject);
+            AddLocalPacketHandler(PacketType.DeRezObject, HandlerDeRezObject);
+            AddLocalPacketHandler(PacketType.ModifyLand, HandlerModifyLand);
+            AddLocalPacketHandler(PacketType.RegionHandshakeReply, HandlerRegionHandshakeReply);
+            AddLocalPacketHandler(PacketType.AgentWearablesRequest, HandlerAgentWearablesRequest);
+            AddLocalPacketHandler(PacketType.AgentSetAppearance, HandlerAgentSetAppearance);
+            AddLocalPacketHandler(PacketType.AgentIsNowWearing, HandlerAgentIsNowWearing);
+            AddLocalPacketHandler(PacketType.RezSingleAttachmentFromInv, HandlerRezSingleAttachmentFromInv);
+            AddLocalPacketHandler(PacketType.RezMultipleAttachmentsFromInv, HandleRezMultipleAttachmentsFromInv);
+            AddLocalPacketHandler(PacketType.DetachAttachmentIntoInv, HandleDetachAttachmentIntoInv);
+            AddLocalPacketHandler(PacketType.ObjectAttach, HandleObjectAttach);
+            AddLocalPacketHandler(PacketType.ObjectDetach, HandleObjectDetach);
+            AddLocalPacketHandler(PacketType.ObjectDrop, HandleObjectDrop);
+            AddLocalPacketHandler(PacketType.SetAlwaysRun, HandleSetAlwaysRun);
+            AddLocalPacketHandler(PacketType.CompleteAgentMovement, HandleCompleteAgentMovement);
+            AddLocalPacketHandler(PacketType.AgentAnimation, HandleAgentAnimation);
+            AddLocalPacketHandler(PacketType.AgentRequestSit, HandleAgentRequestSit);
+            AddLocalPacketHandler(PacketType.AgentSit, HandleAgentSit);
+            AddLocalPacketHandler(PacketType.SoundTrigger, HandleSoundTrigger);
+            //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+            //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+            //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+            //AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+
         }
 
         #region Packet Handlers
@@ -4497,6 +4527,723 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        private bool HandleAvatarPropertiesRequest(IClientAPI sender, Packet Pack)
+        {
+            AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarProperties.AgentData.SessionID != SessionId ||
+                    avatarProperties.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestAvatarProperties handlerRequestAvatarProperties = OnRequestAvatarProperties;
+            if (handlerRequestAvatarProperties != null)
+            {
+                handlerRequestAvatarProperties(this, avatarProperties.AgentData.AvatarID);
+            }
+            return true;
+        }
+
+        private bool HandleChatFromViewer(IClientAPI sender, Packet Pack)
+        {
+            ChatFromViewerPacket inchatpack = (ChatFromViewerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inchatpack.AgentData.SessionID != SessionId ||
+                    inchatpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string fromName = String.Empty; //ClientAvatar.firstname + " " + ClientAvatar.lastname;
+            byte[] message = inchatpack.ChatData.Message;
+            byte type = inchatpack.ChatData.Type;
+            Vector3 fromPos = new Vector3(); // ClientAvatar.Pos;
+            // UUID fromAgentID = AgentId;
+
+            int channel = inchatpack.ChatData.Channel;
+
+            if (OnChatFromClient != null)
+            {
+                OSChatMessage args = new OSChatMessage();
+                args.Channel = channel;
+                args.From = fromName;
+                args.Message = Utils.BytesToString(message);
+                args.Type = (ChatTypeEnum)type;
+                args.Position = fromPos;
+
+                args.Scene = Scene;
+                args.Sender = this;
+                args.SenderUUID = this.AgentId;
+
+                ChatMessage handlerChatFromClient = OnChatFromClient;
+                if (handlerChatFromClient != null)
+                    handlerChatFromClient(this, args);
+            }
+            return true;
+        }
+
+        private bool HandlerAvatarPropertiesUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarPropertiesUpdatePacket avatarProps = (AvatarPropertiesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarProps.AgentData.SessionID != SessionId ||
+                    avatarProps.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateAvatarProperties handlerUpdateAvatarProperties = OnUpdateAvatarProperties;
+            if (handlerUpdateAvatarProperties != null)
+            {
+                AvatarPropertiesUpdatePacket.PropertiesDataBlock Properties = avatarProps.PropertiesData;
+                UserProfileData UserProfile = new UserProfileData();
+                UserProfile.ID = AgentId;
+                UserProfile.AboutText = Utils.BytesToString(Properties.AboutText);
+                UserProfile.FirstLifeAboutText = Utils.BytesToString(Properties.FLAboutText);
+                UserProfile.FirstLifeImage = Properties.FLImageID;
+                UserProfile.Image = Properties.ImageID;
+                UserProfile.ProfileUrl = Utils.BytesToString(Properties.ProfileURL);
+
+                handlerUpdateAvatarProperties(this, UserProfile);
+            }
+            return true;
+        }
+
+        private bool HandlerScriptDialogReply(IClientAPI sender, Packet Pack)
+        {
+            ScriptDialogReplyPacket rdialog = (ScriptDialogReplyPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rdialog.AgentData.SessionID != SessionId ||
+                    rdialog.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            int ch = rdialog.Data.ChatChannel;
+            byte[] msg = rdialog.Data.ButtonLabel;
+            if (OnChatFromClient != null)
+            {
+                OSChatMessage args = new OSChatMessage();
+                args.Channel = ch;
+                args.From = String.Empty;
+                args.Message = Utils.BytesToString(msg);
+                args.Type = ChatTypeEnum.Shout;
+                args.Position = new Vector3();
+                args.Scene = Scene;
+                args.Sender = this;
+                ChatMessage handlerChatFromClient2 = OnChatFromClient;
+                if (handlerChatFromClient2 != null)
+                    handlerChatFromClient2(this, args);
+            }
+
+            return true;
+        }
+
+        private bool HandlerImprovedInstantMessage(IClientAPI sender, Packet Pack)
+        {
+            ImprovedInstantMessagePacket msgpack = (ImprovedInstantMessagePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (msgpack.AgentData.SessionID != SessionId ||
+                    msgpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string IMfromName = Util.FieldToString(msgpack.MessageBlock.FromAgentName);
+            string IMmessage = Utils.BytesToString(msgpack.MessageBlock.Message);
+            ImprovedInstantMessage handlerInstantMessage = OnInstantMessage;
+
+            if (handlerInstantMessage != null)
+            {
+                GridInstantMessage im = new GridInstantMessage(Scene,
+                        msgpack.AgentData.AgentID,
+                        IMfromName,
+                        msgpack.MessageBlock.ToAgentID,
+                        msgpack.MessageBlock.Dialog,
+                        msgpack.MessageBlock.FromGroup,
+                        IMmessage,
+                        msgpack.MessageBlock.ID,
+                        msgpack.MessageBlock.Offline != 0 ? true : false,
+                        msgpack.MessageBlock.Position,
+                        msgpack.MessageBlock.BinaryBucket);
+
+                handlerInstantMessage(this, im);
+            }
+            return true;
+
+        }
+
+        private bool HandlerAcceptFriendship(IClientAPI sender, Packet Pack)
+        {
+            AcceptFriendshipPacket afriendpack = (AcceptFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (afriendpack.AgentData.SessionID != SessionId ||
+                    afriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // My guess is this is the folder to stick the calling card into
+            List<UUID> callingCardFolders = new List<UUID>();
+
+            UUID agentID = afriendpack.AgentData.AgentID;
+            UUID transactionID = afriendpack.TransactionBlock.TransactionID;
+
+            for (int fi = 0; fi < afriendpack.FolderData.Length; fi++)
+            {
+                callingCardFolders.Add(afriendpack.FolderData[fi].FolderID);
+            }
+
+            FriendActionDelegate handlerApproveFriendRequest = OnApproveFriendRequest;
+            if (handlerApproveFriendRequest != null)
+            {
+                handlerApproveFriendRequest(this, agentID, transactionID, callingCardFolders);
+            }
+            return true;
+
+        }
+
+        private bool HandlerDeclineFriendship(IClientAPI sender, Packet Pack)
+        {
+            DeclineFriendshipPacket dfriendpack = (DeclineFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dfriendpack.AgentData.SessionID != SessionId ||
+                    dfriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnDenyFriendRequest != null)
+            {
+                OnDenyFriendRequest(this,
+                                    dfriendpack.AgentData.AgentID,
+                                    dfriendpack.TransactionBlock.TransactionID,
+                                    null);
+            }
+            return true;
+        }
+
+        private bool HandlerTerminateFrendship(IClientAPI sender, Packet Pack)
+        {
+            TerminateFriendshipPacket tfriendpack = (TerminateFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tfriendpack.AgentData.SessionID != SessionId ||
+                    tfriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID listOwnerAgentID = tfriendpack.AgentData.AgentID;
+            UUID exFriendID = tfriendpack.ExBlock.OtherID;
+
+            FriendshipTermination handlerTerminateFriendship = OnTerminateFriendship;
+            if (handlerTerminateFriendship != null)
+            {
+                handlerTerminateFriendship(this, listOwnerAgentID, exFriendID);
+            }
+            return true;
+        }
+
+        private bool HandlerRezObject(IClientAPI sender, Packet Pack)
+        {
+            RezObjectPacket rezPacket = (RezObjectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rezPacket.AgentData.SessionID != SessionId ||
+                    rezPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RezObject handlerRezObject = OnRezObject;
+            if (handlerRezObject != null)
+            {
+                handlerRezObject(this, rezPacket.InventoryData.ItemID, rezPacket.RezData.RayEnd,
+                                 rezPacket.RezData.RayStart, rezPacket.RezData.RayTargetID,
+                                 rezPacket.RezData.BypassRaycast, rezPacket.RezData.RayEndIsIntersection,
+                                 rezPacket.RezData.RezSelected, rezPacket.RezData.RemoveItem,
+                                 rezPacket.RezData.FromTaskID);
+            }
+            return true;
+        }
+
+        private bool HandlerDeRezObject(IClientAPI sender, Packet Pack)
+        {
+            DeRezObjectPacket DeRezPacket = (DeRezObjectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (DeRezPacket.AgentData.SessionID != SessionId ||
+                    DeRezPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeRezObject handlerDeRezObject = OnDeRezObject;
+            if (handlerDeRezObject != null)
+            {
+                List<uint> deRezIDs = new List<uint>();
+
+                foreach (DeRezObjectPacket.ObjectDataBlock data in
+                    DeRezPacket.ObjectData)
+                {
+                    deRezIDs.Add(data.ObjectLocalID);
+                }
+                // It just so happens that the values on the DeRezAction enumerator match the Destination
+                // values given by a Second Life client
+                handlerDeRezObject(this, deRezIDs,
+                                   DeRezPacket.AgentBlock.GroupID,
+                                   (DeRezAction)DeRezPacket.AgentBlock.Destination,
+                                   DeRezPacket.AgentBlock.DestinationID);
+
+            }
+            return true;
+        }
+
+        private bool HandlerModifyLand(IClientAPI sender, Packet Pack)
+        {
+            ModifyLandPacket modify = (ModifyLandPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (modify.AgentData.SessionID != SessionId ||
+                    modify.AgentData.AgentID != AgentId)
+                    return true;
+            }
+
+            #endregion
+            //m_log.Info("[LAND]: LAND:" + modify.ToString());
+            if (modify.ParcelData.Length > 0)
+            {
+                if (OnModifyTerrain != null)
+                {
+                    for (int i = 0; i < modify.ParcelData.Length; i++)
+                    {
+                        ModifyTerrain handlerModifyTerrain = OnModifyTerrain;
+                        if (handlerModifyTerrain != null)
+                        {
+                            handlerModifyTerrain(AgentId, modify.ModifyBlock.Height, modify.ModifyBlock.Seconds,
+                                                 modify.ModifyBlock.BrushSize,
+                                                 modify.ModifyBlock.Action, modify.ParcelData[i].North,
+                                                 modify.ParcelData[i].West, modify.ParcelData[i].South,
+                                                 modify.ParcelData[i].East, AgentId);
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandlerRegionHandshakeReply(IClientAPI sender, Packet Pack)
+        {
+            Action<IClientAPI> handlerRegionHandShakeReply = OnRegionHandShakeReply;
+            if (handlerRegionHandShakeReply != null)
+            {
+                handlerRegionHandShakeReply(this);
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentWearablesRequest(IClientAPI sender, Packet Pack)
+        {
+            GenericCall2 handlerRequestWearables = OnRequestWearables;
+
+            if (handlerRequestWearables != null)
+            {
+                handlerRequestWearables();
+            }
+
+            Action<IClientAPI> handlerRequestAvatarsData = OnRequestAvatarsData;
+
+            if (handlerRequestAvatarsData != null)
+            {
+                handlerRequestAvatarsData(this);
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentSetAppearance(IClientAPI sender, Packet Pack)
+        {
+            AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (appear.AgentData.SessionID != SessionId ||
+                    appear.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetAppearance handlerSetAppearance = OnSetAppearance;
+            if (handlerSetAppearance != null)
+            {
+                // Temporarily protect ourselves from the mantis #951 failure.
+                // However, we could do this for several other handlers where a failure isn't terminal
+                // for the client session anyway, in order to protect ourselves against bad code in plugins
+                try
+                {
+                    byte[] visualparams = new byte[appear.VisualParam.Length];
+                    for (int i = 0; i < appear.VisualParam.Length; i++)
+                        visualparams[i] = appear.VisualParam[i].ParamValue;
+
+                    Primitive.TextureEntry te = null;
+                    if (appear.ObjectData.TextureEntry.Length > 1)
+                        te = new Primitive.TextureEntry(appear.ObjectData.TextureEntry, 0, appear.ObjectData.TextureEntry.Length);
+
+                    handlerSetAppearance(te, visualparams);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[CLIENT VIEW]: AgentSetApperance packet handler threw an exception, {0}",
+                        e);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentIsNowWearing(IClientAPI sender, Packet Pack)
+        {
+            if (OnAvatarNowWearing != null)
+            {
+                AgentIsNowWearingPacket nowWearing = (AgentIsNowWearingPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (nowWearing.AgentData.SessionID != SessionId ||
+                        nowWearing.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                AvatarWearingArgs wearingArgs = new AvatarWearingArgs();
+                for (int i = 0; i < nowWearing.WearableData.Length; i++)
+                {
+                    AvatarWearingArgs.Wearable wearable =
+                        new AvatarWearingArgs.Wearable(nowWearing.WearableData[i].ItemID,
+                                                       nowWearing.WearableData[i].WearableType);
+                    wearingArgs.NowWearing.Add(wearable);
+                }
+
+                AvatarNowWearing handlerAvatarNowWearing = OnAvatarNowWearing;
+                if (handlerAvatarNowWearing != null)
+                {
+                    handlerAvatarNowWearing(this, wearingArgs);
+                }
+            }
+            return true;
+        }
+
+        private bool HandlerRezSingleAttachmentFromInv(IClientAPI sender, Packet Pack)
+        {
+            RezSingleAttachmentFromInv handlerRezSingleAttachment = OnRezSingleAttachmentFromInv;
+            if (handlerRezSingleAttachment != null)
+            {
+                RezSingleAttachmentFromInvPacket rez = (RezSingleAttachmentFromInvPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (rez.AgentData.SessionID != SessionId ||
+                        rez.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                handlerRezSingleAttachment(this, rez.ObjectData.ItemID,
+                                           rez.ObjectData.AttachmentPt);
+            }
+
+            return true;
+        }
+
+        private bool HandleRezMultipleAttachmentsFromInv(IClientAPI sender, Packet Pack)
+        {
+            RezMultipleAttachmentsFromInv handlerRezMultipleAttachments = OnRezMultipleAttachmentsFromInv;
+            if (handlerRezMultipleAttachments != null)
+            {
+                RezMultipleAttachmentsFromInvPacket rez = (RezMultipleAttachmentsFromInvPacket)Pack;
+                handlerRezMultipleAttachments(this, rez.HeaderData,
+                                              rez.ObjectData);
+            }
+
+            return true;
+        }
+
+        private bool HandleDetachAttachmentIntoInv(IClientAPI sender, Packet Pack)
+        {
+            UUIDNameRequest handlerDetachAttachmentIntoInv = OnDetachAttachmentIntoInv;
+            if (handlerDetachAttachmentIntoInv != null)
+            {
+                DetachAttachmentIntoInvPacket detachtoInv = (DetachAttachmentIntoInvPacket)Pack;
+
+                #region Packet Session and User Check
+                // UNSUPPORTED ON THIS PACKET
+                #endregion
+
+                UUID itemID = detachtoInv.ObjectData.ItemID;
+                // UUID ATTACH_agentID = detachtoInv.ObjectData.AgentID;
+
+                handlerDetachAttachmentIntoInv(itemID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectAttach(IClientAPI sender, Packet Pack)
+        {
+            if (OnObjectAttach != null)
+            {
+                ObjectAttachPacket att = (ObjectAttachPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (att.AgentData.SessionID != SessionId ||
+                        att.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                ObjectAttach handlerObjectAttach = OnObjectAttach;
+
+                if (handlerObjectAttach != null)
+                {
+                    if (att.ObjectData.Length > 0)
+                    {
+                        handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, att.ObjectData[0].Rotation, false);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDetach(IClientAPI sender, Packet Pack)
+        {
+            ObjectDetachPacket dett = (ObjectDetachPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dett.AgentData.SessionID != SessionId ||
+                    dett.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int j = 0; j < dett.ObjectData.Length; j++)
+            {
+                uint obj = dett.ObjectData[j].ObjectLocalID;
+                ObjectDeselect handlerObjectDetach = OnObjectDetach;
+                if (handlerObjectDetach != null)
+                {
+                    handlerObjectDetach(obj, this);
+                }
+
+            }
+            return true;
+        }
+
+        private bool HandleObjectDrop(IClientAPI sender, Packet Pack)
+        {
+            ObjectDropPacket dropp = (ObjectDropPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dropp.AgentData.SessionID != SessionId ||
+                    dropp.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int j = 0; j < dropp.ObjectData.Length; j++)
+            {
+                uint obj = dropp.ObjectData[j].ObjectLocalID;
+                ObjectDrop handlerObjectDrop = OnObjectDrop;
+                if (handlerObjectDrop != null)
+                {
+                    handlerObjectDrop(obj, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleSetAlwaysRun(IClientAPI sender, Packet Pack)
+        {
+            SetAlwaysRunPacket run = (SetAlwaysRunPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (run.AgentData.SessionID != SessionId ||
+                    run.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetAlwaysRun handlerSetAlwaysRun = OnSetAlwaysRun;
+            if (handlerSetAlwaysRun != null)
+                handlerSetAlwaysRun(this, run.AgentData.AlwaysRun);
+
+            return true;
+        }
+
+        private bool HandleCompleteAgentMovement(IClientAPI sender, Packet Pack)
+        {
+            GenericCall2 handlerCompleteMovementToRegion = OnCompleteMovementToRegion;
+            if (handlerCompleteMovementToRegion != null)
+            {
+                handlerCompleteMovementToRegion();
+            }
+            handlerCompleteMovementToRegion = null;
+
+            return true;
+        }
+
+        private bool HandleAgentAnimation(IClientAPI sender, Packet Pack)
+        {
+            AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (AgentAni.AgentData.SessionID != SessionId ||
+                    AgentAni.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            StartAnim handlerStartAnim = null;
+            StopAnim handlerStopAnim = null;
+
+            for (int i = 0; i < AgentAni.AnimationList.Length; i++)
+            {
+                if (AgentAni.AnimationList[i].StartAnim)
+                {
+                    handlerStartAnim = OnStartAnim;
+                    if (handlerStartAnim != null)
+                    {
+                        handlerStartAnim(this, AgentAni.AnimationList[i].AnimID);
+                    }
+                }
+                else
+                {
+                    handlerStopAnim = OnStopAnim;
+                    if (handlerStopAnim != null)
+                    {
+                        handlerStopAnim(this, AgentAni.AnimationList[i].AnimID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleAgentRequestSit(IClientAPI sender, Packet Pack)
+        {
+            if (OnAgentRequestSit != null)
+            {
+                AgentRequestSitPacket agentRequestSit = (AgentRequestSitPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (agentRequestSit.AgentData.SessionID != SessionId ||
+                        agentRequestSit.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                AgentRequestSit handlerAgentRequestSit = OnAgentRequestSit;
+                if (handlerAgentRequestSit != null)
+                    handlerAgentRequestSit(this, agentRequestSit.AgentData.AgentID,
+                                           agentRequestSit.TargetObject.TargetID, agentRequestSit.TargetObject.Offset);
+            }
+            return true;
+        }
+
+        private bool HandleAgentSit(IClientAPI sender, Packet Pack)
+        {
+            if (OnAgentSit != null)
+            {
+                AgentSitPacket agentSit = (AgentSitPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (agentSit.AgentData.SessionID != SessionId ||
+                        agentSit.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                AgentSit handlerAgentSit = OnAgentSit;
+                if (handlerAgentSit != null)
+                {
+                    OnAgentSit(this, agentSit.AgentData.AgentID);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleSoundTrigger(IClientAPI sender, Packet Pack)
+        {
+            SoundTriggerPacket soundTriggerPacket = (SoundTriggerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                // UNSUPPORTED ON THIS PACKET
+            }
+            #endregion
+
+            SoundTrigger handlerSoundTrigger = OnSoundTrigger;
+            if (handlerSoundTrigger != null)
+            {
+                handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, soundTriggerPacket.SoundData.OwnerID,
+                    soundTriggerPacket.SoundData.ObjectID, soundTriggerPacket.SoundData.ParentID,
+                    soundTriggerPacket.SoundData.Gain, soundTriggerPacket.SoundData.Position,
+                    soundTriggerPacket.SoundData.Handle);
+
+            }
+            return true;
+        }
+
+
         #endregion Packet Handlers
 
         public void SendScriptQuestion(UUID taskID, string taskName, string ownerName, UUID itemID, int question)
@@ -4988,13 +5735,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 return;
             }
 
-            const bool m_checkPackets = true;
-
             // Main packet processing conditional
             switch (Pack.Type)
             {
                 #region Scene/Avatar
-
+                #region CommentedOut
+                /*
                 case PacketType.AvatarPropertiesRequest:
                     AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack;
 
@@ -5656,7 +6402,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     }
                     break;
-
+                */
+                #endregion
                 case PacketType.AvatarPickerRequest:
                     AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack;
 
@@ -9713,7 +10460,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText),
                             Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));
                     break;
-                                                    
+
                 case PacketType.GrantUserRights:
                     GrantUserRightsPacket GrantUserRights =
                             (GrantUserRightsPacket)Pack;
@@ -9732,7 +10479,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             GrantUserRights.Rights[0].AgentRelated,
                             GrantUserRights.Rights[0].RelatedRights);
                     break;
-                    
+
                 case PacketType.PlacesQuery:
                     PlacesQueryPacket placesQueryPacket =
                             (PlacesQueryPacket)Pack;