Merge branch 'careminster' into tests

48 files changed, 6051 insertions, 1240 deletions

diff --git a/OpenSim/Region/Application/HGCommands.cs b/OpenSim/Region/Application/HGCommands.cs
index f503db7..7ae161d 100644
--- a/OpenSim/Region/Application/HGCommands.cs
+++ b/OpenSim/Region/Application/HGCommands.cs
@@ -42,7 +42,7 @@ namespace OpenSim
 {
     public class HGCommands
     {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         public static Scene CreateScene(RegionInfo regionInfo, AgentCircuitManager circuitManager, CommunicationsManager m_commsManager,
             StorageManager storageManager, ModuleLoader m_moduleLoader, ConfigSettings m_configSettings, OpenSimConfigSource m_config, string m_version)
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index 60c34df..5228e4b 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -232,7 +232,7 @@ namespace OpenSim
                                           "Save named prim to XML2", SavePrimsXml2);
 
             m_console.Commands.AddCommand("region", false, "load oar",
-                                          "load oar <oar name>",
+                                          "load oar [--merge] <oar name>",
                                           "Load a region's data from OAR archive", LoadOar);
 
             m_console.Commands.AddCommand("region", false, "save oar",
@@ -1294,14 +1294,7 @@ namespace OpenSim
         {
             try
             {
-                if (cmdparams.Length > 2)
-                {
-                    m_sceneManager.LoadArchiveToCurrentScene(cmdparams[2]);
-                }
-                else
-                {
-                    m_sceneManager.LoadArchiveToCurrentScene(DEFAULT_OAR_BACKUP_FILENAME);
-                }
+                m_sceneManager.LoadArchiveToCurrentScene(cmdparams);
             }
             catch (Exception e)
             {
@@ -1315,14 +1308,7 @@ namespace OpenSim
         /// <param name="cmdparams"></param>
         protected void SaveOar(string module, string[] cmdparams)
         {
-            if (cmdparams.Length > 2)
-            {
-                m_sceneManager.SaveCurrentSceneToArchive(cmdparams[2]);
-            }
-            else
-            {
-                m_sceneManager.SaveCurrentSceneToArchive(DEFAULT_OAR_BACKUP_FILENAME);
-            }
+            m_sceneManager.SaveCurrentSceneToArchive(cmdparams);
         }
 
         private static string CombineParams(string[] commandParams, int pos)
diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index cc18f1a..391856b 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -75,11 +75,6 @@ namespace OpenSim
         /// </value>
         protected const string DEFAULT_PRIM_BACKUP_FILENAME = "prim-backup.xml";
 
-        /// <value>
-        /// The file used to load and save an opensimulator archive if no filename has been specified
-        /// </value>
-        protected const string DEFAULT_OAR_BACKUP_FILENAME = "region.oar";
-
         public ConfigSettings ConfigurationSettings
         {
             get { return m_configSettings; }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 47251b7..ac16b02 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -4307,15 +4307,168 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
-
+            AddLocalPacketHandler(PacketType.AvatarPickerRequest, HandleAvatarPickerRequest);
+            AddLocalPacketHandler(PacketType.AgentDataUpdateRequest, HandleAgentDataUpdateRequest);
+            AddLocalPacketHandler(PacketType.UserInfoRequest, HandleUserInfoRequest);
+            AddLocalPacketHandler(PacketType.UpdateUserInfo, HandleUpdateUserInfo);
+            AddLocalPacketHandler(PacketType.SetStartLocationRequest, HandleSetStartLocationRequest);
+            AddLocalPacketHandler(PacketType.AgentThrottle, HandleAgentThrottle);
+            AddLocalPacketHandler(PacketType.AgentPause, HandleAgentPause);
+            AddLocalPacketHandler(PacketType.AgentResume, HandleAgentResume);
+            AddLocalPacketHandler(PacketType.ForceScriptControlRelease, HandleForceScriptControlRelease);
+            AddLocalPacketHandler(PacketType.ObjectLink, HandleObjectLink);
+            AddLocalPacketHandler(PacketType.ObjectDelink, HandleObjectDelink);
+            AddLocalPacketHandler(PacketType.ObjectAdd, HandleObjectAdd);
+            AddLocalPacketHandler(PacketType.ObjectShape, HandleObjectShape);
+            AddLocalPacketHandler(PacketType.ObjectExtraParams, HandleObjectExtraParams);
+            AddLocalPacketHandler(PacketType.ObjectDuplicate, HandleObjectDuplicate);
+            AddLocalPacketHandler(PacketType.RequestMultipleObjects, HandleRequestMultipleObjects);
+            AddLocalPacketHandler(PacketType.ObjectSelect, HandleObjectSelect);
+            AddLocalPacketHandler(PacketType.ObjectDeselect, HandleObjectDeselect);
+            AddLocalPacketHandler(PacketType.ObjectPosition, HandleObjectPosition);
+            AddLocalPacketHandler(PacketType.ObjectScale, HandleObjectScale);
+            AddLocalPacketHandler(PacketType.ObjectRotation, HandleObjectRotation);
+            AddLocalPacketHandler(PacketType.ObjectFlagUpdate, HandleObjectFlagUpdate);
+            AddLocalPacketHandler(PacketType.ObjectImage, HandleObjectImage);
+            AddLocalPacketHandler(PacketType.ObjectGrab, HandleObjectGrab);
+            AddLocalPacketHandler(PacketType.ObjectGrabUpdate, HandleObjectGrabUpdate);
+            AddLocalPacketHandler(PacketType.ObjectDeGrab, HandleObjectDeGrab);
+            AddLocalPacketHandler(PacketType.ObjectSpinStart, HandleObjectSpinStart);
+            AddLocalPacketHandler(PacketType.ObjectSpinUpdate, HandleObjectSpinUpdate);
+            AddLocalPacketHandler(PacketType.ObjectSpinStop, HandleObjectSpinStop);
+            AddLocalPacketHandler(PacketType.ObjectDescription, HandleObjectDescription);
+            AddLocalPacketHandler(PacketType.ObjectName, HandleObjectName);
+            AddLocalPacketHandler(PacketType.ObjectPermissions, HandleObjectPermissions);
+            AddLocalPacketHandler(PacketType.Undo, HandleUndo);
+            AddLocalPacketHandler(PacketType.ObjectDuplicateOnRay, HandleObjectDuplicateOnRay);
+            AddLocalPacketHandler(PacketType.RequestObjectPropertiesFamily, HandleRequestObjectPropertiesFamily);
+            AddLocalPacketHandler(PacketType.ObjectIncludeInSearch, HandleObjectIncludeInSearch);
+            AddLocalPacketHandler(PacketType.ScriptAnswerYes, HandleScriptAnswerYes);
+            AddLocalPacketHandler(PacketType.ObjectClickAction, HandleObjectClickAction);
+            AddLocalPacketHandler(PacketType.ObjectMaterial, HandleObjectMaterial);
+            AddLocalPacketHandler(PacketType.RequestImage, HandleRequestImage);
+            AddLocalPacketHandler(PacketType.TransferRequest, HandleTransferRequest);
+            AddLocalPacketHandler(PacketType.AssetUploadRequest, HandleAssetUploadRequest);
+            AddLocalPacketHandler(PacketType.RequestXfer, HandleRequestXfer);
+            AddLocalPacketHandler(PacketType.SendXferPacket, HandleSendXferPacket);
+            AddLocalPacketHandler(PacketType.ConfirmXferPacket, HandleConfirmXferPacket);
+            AddLocalPacketHandler(PacketType.AbortXfer, HandleAbortXfer);
+            AddLocalPacketHandler(PacketType.CreateInventoryFolder, HandleCreateInventoryFolder);
+            AddLocalPacketHandler(PacketType.UpdateInventoryFolder, HandleUpdateInventoryFolder);
+            AddLocalPacketHandler(PacketType.MoveInventoryFolder, HandleMoveInventoryFolder);
+            AddLocalPacketHandler(PacketType.CreateInventoryItem, HandleCreateInventoryItem);
+            AddLocalPacketHandler(PacketType.FetchInventory, HandleFetchInventory);
+            AddLocalPacketHandler(PacketType.FetchInventoryDescendents, HandleFetchInventoryDescendents);
+            AddLocalPacketHandler(PacketType.PurgeInventoryDescendents, HandlePurgeInventoryDescendents);
+            AddLocalPacketHandler(PacketType.UpdateInventoryItem, HandleUpdateInventoryItem);
+            AddLocalPacketHandler(PacketType.CopyInventoryItem, HandleCopyInventoryItem);
+            AddLocalPacketHandler(PacketType.MoveInventoryItem, HandleMoveInventoryItem);
+            AddLocalPacketHandler(PacketType.RemoveInventoryItem, HandleRemoveInventoryItem);
+            AddLocalPacketHandler(PacketType.RemoveInventoryFolder, HandleRemoveInventoryFolder);
+            AddLocalPacketHandler(PacketType.RemoveInventoryObjects, HandleRemoveInventoryObjects);
+            AddLocalPacketHandler(PacketType.RequestTaskInventory, HandleRequestTaskInventory);
+            AddLocalPacketHandler(PacketType.UpdateTaskInventory, HandleUpdateTaskInventory);
+            AddLocalPacketHandler(PacketType.RemoveTaskInventory, HandleRemoveTaskInventory);
+            AddLocalPacketHandler(PacketType.MoveTaskInventory, HandleMoveTaskInventory);
+            AddLocalPacketHandler(PacketType.RezScript, HandleRezScript);
+            AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest);
+            AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest);
+            AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest);
+            AddLocalPacketHandler(PacketType.TeleportLandmarkRequest, HandleTeleportLandmarkRequest);
+            AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);
+            AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest);
+            AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest);
+            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest);
+            AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest);
+            AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate);
+            AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest);
+            AddLocalPacketHandler(PacketType.ParcelDivide, HandleParcelDivide);
+            AddLocalPacketHandler(PacketType.ParcelJoin, HandleParcelJoin);
+            AddLocalPacketHandler(PacketType.ParcelPropertiesUpdate, HandleParcelPropertiesUpdate);
+            AddLocalPacketHandler(PacketType.ParcelSelectObjects, HandleParcelSelectObjects);
+            AddLocalPacketHandler(PacketType.ParcelObjectOwnersRequest, HandleParcelObjectOwnersRequest);
+            AddLocalPacketHandler(PacketType.ParcelGodForceOwner, HandleParcelGodForceOwner);
+            AddLocalPacketHandler(PacketType.ParcelRelease, HandleParcelRelease);
+            AddLocalPacketHandler(PacketType.ParcelReclaim, HandleParcelReclaim);
+            AddLocalPacketHandler(PacketType.ParcelReturnObjects, HandleParcelReturnObjects);
+            AddLocalPacketHandler(PacketType.ParcelSetOtherCleanTime, HandleParcelSetOtherCleanTime);
+            AddLocalPacketHandler(PacketType.LandStatRequest, HandleLandStatRequest);
+            AddLocalPacketHandler(PacketType.ParcelDwellRequest, HandleParcelDwellRequest);
+            AddLocalPacketHandler(PacketType.EstateOwnerMessage, HandleEstateOwnerMessage);
+            AddLocalPacketHandler(PacketType.RequestRegionInfo, HandleRequestRegionInfo);
+            AddLocalPacketHandler(PacketType.EstateCovenantRequest, HandleEstateCovenantRequest);
+            AddLocalPacketHandler(PacketType.RequestGodlikePowers, HandleRequestGodlikePowers);
+            AddLocalPacketHandler(PacketType.GodKickUser, HandleGodKickUser);
+            AddLocalPacketHandler(PacketType.MoneyBalanceRequest, HandleMoneyBalanceRequest);
+            AddLocalPacketHandler(PacketType.EconomyDataRequest, HandleEconomyDataRequest);
+            AddLocalPacketHandler(PacketType.RequestPayPrice, HandleRequestPayPrice);
+            AddLocalPacketHandler(PacketType.ObjectSaleInfo, HandleObjectSaleInfo);
+            AddLocalPacketHandler(PacketType.ObjectBuy, HandleObjectBuy);
+            AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning);
+            AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning);
+            AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset);
+            AddLocalPacketHandler(PacketType.ActivateGestures, HandleActivateGestures);
+            AddLocalPacketHandler(PacketType.DeactivateGestures, HandleDeactivateGestures);
+            AddLocalPacketHandler(PacketType.ObjectOwner, HandleObjectOwner);
+            AddLocalPacketHandler(PacketType.AgentFOV, HandleAgentFOV);
+            AddLocalPacketHandler(PacketType.ViewerStats, HandleViewerStats);
+            AddLocalPacketHandler(PacketType.MapItemRequest, HandleMapItemRequest);
+            AddLocalPacketHandler(PacketType.TransferAbort, HandleTransferAbort);
+            AddLocalPacketHandler(PacketType.MuteListRequest, HandleMuteListRequest);
+            AddLocalPacketHandler(PacketType.UseCircuitCode, HandleUseCircuitCode);
+            AddLocalPacketHandler(PacketType.AgentHeightWidth, HandleAgentHeightWidth);
+            AddLocalPacketHandler(PacketType.InventoryDescendents, HandleInventoryDescendents);
+            AddLocalPacketHandler(PacketType.DirPlacesQuery, HandleDirPlacesQuery);
+            AddLocalPacketHandler(PacketType.DirFindQuery, HandleDirFindQuery);
+            AddLocalPacketHandler(PacketType.DirLandQuery, HandleDirLandQuery);
+            AddLocalPacketHandler(PacketType.DirPopularQuery, HandleDirPopularQuery);
+            AddLocalPacketHandler(PacketType.DirClassifiedQuery, HandleDirClassifiedQuery);
+            AddLocalPacketHandler(PacketType.EventInfoRequest, HandleEventInfoRequest);
+            AddLocalPacketHandler(PacketType.OfferCallingCard, HandleOfferCallingCard);
+            AddLocalPacketHandler(PacketType.AcceptCallingCard, HandleAcceptCallingCard);
+            AddLocalPacketHandler(PacketType.DeclineCallingCard, HandleDeclineCallingCard);
+            AddLocalPacketHandler(PacketType.ActivateGroup, HandleActivateGroup);
+            AddLocalPacketHandler(PacketType.GroupTitlesRequest, HandleGroupTitlesRequest);
+            AddLocalPacketHandler(PacketType.GroupProfileRequest, HandleGroupProfileRequest);
+            AddLocalPacketHandler(PacketType.GroupMembersRequest, HandleGroupMembersRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleDataRequest, HandleGroupRoleDataRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleMembersRequest, HandleGroupRoleMembersRequest);
+            AddLocalPacketHandler(PacketType.CreateGroupRequest, HandleCreateGroupRequest);
+            AddLocalPacketHandler(PacketType.UpdateGroupInfo, HandleUpdateGroupInfo);
+            AddLocalPacketHandler(PacketType.SetGroupAcceptNotices, HandleSetGroupAcceptNotices);
+            AddLocalPacketHandler(PacketType.GroupTitleUpdate, HandleGroupTitleUpdate);
+            AddLocalPacketHandler(PacketType.ParcelDeedToGroup, HandleParcelDeedToGroup);
+            AddLocalPacketHandler(PacketType.GroupNoticesListRequest, HandleGroupNoticesListRequest);
+            AddLocalPacketHandler(PacketType.GroupNoticeRequest, HandleGroupNoticeRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleUpdate, HandleGroupRoleUpdate);
+            AddLocalPacketHandler(PacketType.GroupRoleChanges, HandleGroupRoleChanges);
+            AddLocalPacketHandler(PacketType.JoinGroupRequest, HandleJoinGroupRequest);
+            AddLocalPacketHandler(PacketType.LeaveGroupRequest, HandleLeaveGroupRequest);
+            AddLocalPacketHandler(PacketType.EjectGroupMemberRequest, HandleEjectGroupMemberRequest);
+            AddLocalPacketHandler(PacketType.InviteGroupRequest, HandleInviteGroupRequest);
+            AddLocalPacketHandler(PacketType.StartLure, HandleStartLure);
+            AddLocalPacketHandler(PacketType.TeleportLureRequest, HandleTeleportLureRequest);
+            AddLocalPacketHandler(PacketType.ClassifiedInfoRequest, HandleClassifiedInfoRequest);
+            AddLocalPacketHandler(PacketType.ClassifiedInfoUpdate, HandleClassifiedInfoUpdate);
+            AddLocalPacketHandler(PacketType.ClassifiedDelete, HandleClassifiedDelete);
+            AddLocalPacketHandler(PacketType.ClassifiedGodDelete, HandleClassifiedGodDelete);
+            AddLocalPacketHandler(PacketType.EventGodDelete, HandleEventGodDelete);
+            AddLocalPacketHandler(PacketType.EventNotificationAddRequest, HandleEventNotificationAddRequest);
+            AddLocalPacketHandler(PacketType.EventNotificationRemoveRequest, HandleEventNotificationRemoveRequest);
+            AddLocalPacketHandler(PacketType.RetrieveInstantMessages, HandleRetrieveInstantMessages);
+            AddLocalPacketHandler(PacketType.PickDelete, HandlePickDelete);
+            AddLocalPacketHandler(PacketType.PickGodDelete, HandlePickGodDelete);
+            AddLocalPacketHandler(PacketType.PickInfoUpdate, HandlePickInfoUpdate);
+            AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate);
+            AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate);
+            AddLocalPacketHandler(PacketType.GrantUserRights, HandleGrantUserRights);
+            AddLocalPacketHandler(PacketType.PlacesQuery, HandlePlacesQuery);
         }
 
         #region Packet Handlers
 
+        #region Scene/Avatar
+
         private bool HandleAgentUpdate(IClientAPI sener, Packet Pack)
         {
             if (OnAgentUpdate != null)
@@ -5243,6 +5396,4432 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        private bool HandleAvatarPickerRequest(IClientAPI sender, Packet Pack)
+        {
+            AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avRequestQuery.AgentData.SessionID != SessionId ||
+                    avRequestQuery.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarPickerRequestPacket.AgentDataBlock Requestdata = avRequestQuery.AgentData;
+            AvatarPickerRequestPacket.DataBlock querydata = avRequestQuery.Data;
+            //m_log.Debug("Agent Sends:" + Utils.BytesToString(querydata.Name));
+
+            AvatarPickerRequest handlerAvatarPickerRequest = OnAvatarPickerRequest;
+            if (handlerAvatarPickerRequest != null)
+            {
+                handlerAvatarPickerRequest(this, Requestdata.AgentID, Requestdata.QueryID,
+                                           Utils.BytesToString(querydata.Name));
+            }
+            return true;
+        }
+
+        private bool HandleAgentDataUpdateRequest(IClientAPI sender, Packet Pack)
+        {
+            AgentDataUpdateRequestPacket avRequestDataUpdatePacket = (AgentDataUpdateRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avRequestDataUpdatePacket.AgentData.SessionID != SessionId ||
+                    avRequestDataUpdatePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            FetchInventory handlerAgentDataUpdateRequest = OnAgentDataUpdateRequest;
+
+            if (handlerAgentDataUpdateRequest != null)
+            {
+                handlerAgentDataUpdateRequest(this, avRequestDataUpdatePacket.AgentData.AgentID, avRequestDataUpdatePacket.AgentData.SessionID);
+            }
+
+            return true;
+        }
+
+        private bool HandleUserInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            UserInfoRequest handlerUserInfoRequest = OnUserInfoRequest;
+            if (handlerUserInfoRequest != null)
+            {
+                handlerUserInfoRequest(this);
+            }
+            else
+            {
+                SendUserInfoReply(false, true, "");
+            }
+            return true;
+
+        }
+
+        private bool HandleUpdateUserInfo(IClientAPI sender, Packet Pack)
+        {
+            UpdateUserInfoPacket updateUserInfo = (UpdateUserInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updateUserInfo.AgentData.SessionID != SessionId ||
+                    updateUserInfo.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateUserInfo handlerUpdateUserInfo = OnUpdateUserInfo;
+            if (handlerUpdateUserInfo != null)
+            {
+                bool visible = true;
+                string DirectoryVisibility =
+                        Utils.BytesToString(updateUserInfo.UserData.DirectoryVisibility);
+                if (DirectoryVisibility == "hidden")
+                    visible = false;
+
+                handlerUpdateUserInfo(
+                        updateUserInfo.UserData.IMViaEMail,
+                        visible, this);
+            }
+            return true;
+        }
+
+        private bool HandleSetStartLocationRequest(IClientAPI sender, Packet Pack)
+        {
+            SetStartLocationRequestPacket avSetStartLocationRequestPacket = (SetStartLocationRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avSetStartLocationRequestPacket.AgentData.SessionID != SessionId ||
+                    avSetStartLocationRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (avSetStartLocationRequestPacket.AgentData.AgentID == AgentId && avSetStartLocationRequestPacket.AgentData.SessionID == SessionId)
+            {
+                TeleportLocationRequest handlerSetStartLocationRequest = OnSetStartLocationRequest;
+                if (handlerSetStartLocationRequest != null)
+                {
+                    handlerSetStartLocationRequest(this, 0, avSetStartLocationRequestPacket.StartLocationData.LocationPos,
+                                                   avSetStartLocationRequestPacket.StartLocationData.LocationLookAt,
+                                                   avSetStartLocationRequestPacket.StartLocationData.LocationID);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleAgentThrottle(IClientAPI sender, Packet Pack)
+        {
+            AgentThrottlePacket atpack = (AgentThrottlePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (atpack.AgentData.SessionID != SessionId ||
+                    atpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            m_udpClient.SetThrottles(atpack.Throttle.Throttles);
+            return true;
+        }
+
+        private bool HandleAgentPause(IClientAPI sender, Packet Pack)
+        {
+            m_udpClient.IsPaused = true;
+            return true;
+        }
+
+        private bool HandleAgentResume(IClientAPI sender, Packet Pack)
+        {
+            m_udpClient.IsPaused = false;
+            SendStartPingCheck(m_udpClient.CurrentPingSequence++);
+            return true;
+        }
+
+        private bool HandleForceScriptControlRelease(IClientAPI sender, Packet Pack)
+        {
+            ForceReleaseControls handlerForceReleaseControls = OnForceReleaseControls;
+            if (handlerForceReleaseControls != null)
+            {
+                handlerForceReleaseControls(this, AgentId);
+            }
+            return true;
+        }
+
+        #endregion Scene/Avatar
+
+        #region Objects/m_sceneObjects
+
+        private bool HandleObjectLink(IClientAPI sender, Packet Pack)
+        {
+            ObjectLinkPacket link = (ObjectLinkPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (link.AgentData.SessionID != SessionId ||
+                    link.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            uint parentprimid = 0;
+            List<uint> childrenprims = new List<uint>();
+            if (link.ObjectData.Length > 1)
+            {
+                parentprimid = link.ObjectData[0].ObjectLocalID;
+
+                for (int i = 1; i < link.ObjectData.Length; i++)
+                {
+                    childrenprims.Add(link.ObjectData[i].ObjectLocalID);
+                }
+            }
+            LinkObjects handlerLinkObjects = OnLinkObjects;
+            if (handlerLinkObjects != null)
+            {
+                handlerLinkObjects(this, parentprimid, childrenprims);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDelink(IClientAPI sender, Packet Pack)
+        {
+            ObjectDelinkPacket delink = (ObjectDelinkPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (delink.AgentData.SessionID != SessionId ||
+                    delink.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // It appears the prim at index 0 is not always the root prim (for
+            // instance, when one prim of a link set has been edited independently
+            // of the others).  Therefore, we'll pass all the ids onto the delink
+            // method for it to decide which is the root.
+            List<uint> prims = new List<uint>();
+            for (int i = 0; i < delink.ObjectData.Length; i++)
+            {
+                prims.Add(delink.ObjectData[i].ObjectLocalID);
+            }
+            DelinkObjects handlerDelinkObjects = OnDelinkObjects;
+            if (handlerDelinkObjects != null)
+            {
+                handlerDelinkObjects(prims);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectAdd(IClientAPI sender, Packet Pack)
+        {
+            if (OnAddPrim != null)
+            {
+                ObjectAddPacket addPacket = (ObjectAddPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (addPacket.AgentData.SessionID != SessionId ||
+                        addPacket.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                PrimitiveBaseShape shape = GetShapeFromAddPacket(addPacket);
+                // m_log.Info("[REZData]: " + addPacket.ToString());
+                //BypassRaycast: 1
+                //RayStart: <69.79469, 158.2652, 98.40343>
+                //RayEnd: <61.97724, 141.995, 92.58341>
+                //RayTargetID: 00000000-0000-0000-0000-000000000000
+
+                //Check to see if adding the prim is allowed; useful for any module wanting to restrict the
+                //object from rezing initially
+
+                AddNewPrim handlerAddPrim = OnAddPrim;
+                if (handlerAddPrim != null)
+                    handlerAddPrim(AgentId, ActiveGroupId, addPacket.ObjectData.RayEnd, addPacket.ObjectData.Rotation, shape, addPacket.ObjectData.BypassRaycast, addPacket.ObjectData.RayStart, addPacket.ObjectData.RayTargetID, addPacket.ObjectData.RayEndIsIntersection);
+            }
+            return true;
+        }
+
+        private bool HandleObjectShape(IClientAPI sender, Packet Pack)
+        {
+            ObjectShapePacket shapePacket = (ObjectShapePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (shapePacket.AgentData.SessionID != SessionId ||
+                    shapePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateShape handlerUpdatePrimShape = null;
+            for (int i = 0; i < shapePacket.ObjectData.Length; i++)
+            {
+                handlerUpdatePrimShape = OnUpdatePrimShape;
+                if (handlerUpdatePrimShape != null)
+                {
+                    UpdateShapeArgs shapeData = new UpdateShapeArgs();
+                    shapeData.ObjectLocalID = shapePacket.ObjectData[i].ObjectLocalID;
+                    shapeData.PathBegin = shapePacket.ObjectData[i].PathBegin;
+                    shapeData.PathCurve = shapePacket.ObjectData[i].PathCurve;
+                    shapeData.PathEnd = shapePacket.ObjectData[i].PathEnd;
+                    shapeData.PathRadiusOffset = shapePacket.ObjectData[i].PathRadiusOffset;
+                    shapeData.PathRevolutions = shapePacket.ObjectData[i].PathRevolutions;
+                    shapeData.PathScaleX = shapePacket.ObjectData[i].PathScaleX;
+                    shapeData.PathScaleY = shapePacket.ObjectData[i].PathScaleY;
+                    shapeData.PathShearX = shapePacket.ObjectData[i].PathShearX;
+                    shapeData.PathShearY = shapePacket.ObjectData[i].PathShearY;
+                    shapeData.PathSkew = shapePacket.ObjectData[i].PathSkew;
+                    shapeData.PathTaperX = shapePacket.ObjectData[i].PathTaperX;
+                    shapeData.PathTaperY = shapePacket.ObjectData[i].PathTaperY;
+                    shapeData.PathTwist = shapePacket.ObjectData[i].PathTwist;
+                    shapeData.PathTwistBegin = shapePacket.ObjectData[i].PathTwistBegin;
+                    shapeData.ProfileBegin = shapePacket.ObjectData[i].ProfileBegin;
+                    shapeData.ProfileCurve = shapePacket.ObjectData[i].ProfileCurve;
+                    shapeData.ProfileEnd = shapePacket.ObjectData[i].ProfileEnd;
+                    shapeData.ProfileHollow = shapePacket.ObjectData[i].ProfileHollow;
+
+                    handlerUpdatePrimShape(m_agentId, shapePacket.ObjectData[i].ObjectLocalID,
+                                           shapeData);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectExtraParams(IClientAPI sender, Packet Pack)
+        {
+            ObjectExtraParamsPacket extraPar = (ObjectExtraParamsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (extraPar.AgentData.SessionID != SessionId ||
+                    extraPar.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectExtraParams handlerUpdateExtraParams = OnUpdateExtraParams;
+            if (handlerUpdateExtraParams != null)
+            {
+                for (int i = 0; i < extraPar.ObjectData.Length; i++)
+                {
+                    handlerUpdateExtraParams(m_agentId, extraPar.ObjectData[i].ObjectLocalID,
+                                             extraPar.ObjectData[i].ParamType,
+                                             extraPar.ObjectData[i].ParamInUse, extraPar.ObjectData[i].ParamData);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDuplicate(IClientAPI sender, Packet Pack)
+        {
+            ObjectDuplicatePacket dupe = (ObjectDuplicatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dupe.AgentData.SessionID != SessionId ||
+                    dupe.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData;
+
+            ObjectDuplicate handlerObjectDuplicate = null;
+
+            for (int i = 0; i < dupe.ObjectData.Length; i++)
+            {
+                handlerObjectDuplicate = OnObjectDuplicate;
+                if (handlerObjectDuplicate != null)
+                {
+                    handlerObjectDuplicate(dupe.ObjectData[i].ObjectLocalID, dupe.SharedData.Offset,
+                                           dupe.SharedData.DuplicateFlags, AgentandGroupData.AgentID,
+                                           AgentandGroupData.GroupID);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRequestMultipleObjects(IClientAPI sender, Packet Pack)
+        {
+            RequestMultipleObjectsPacket incomingRequest = (RequestMultipleObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingRequest.AgentData.SessionID != SessionId ||
+                    incomingRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectRequest handlerObjectRequest = null;
+
+            for (int i = 0; i < incomingRequest.ObjectData.Length; i++)
+            {
+                handlerObjectRequest = OnObjectRequest;
+                if (handlerObjectRequest != null)
+                {
+                    handlerObjectRequest(incomingRequest.ObjectData[i].ID, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectSelect(IClientAPI sender, Packet Pack)
+        {
+            ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingselect.AgentData.SessionID != SessionId ||
+                    incomingselect.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectSelect handlerObjectSelect = null;
+
+            for (int i = 0; i < incomingselect.ObjectData.Length; i++)
+            {
+                handlerObjectSelect = OnObjectSelect;
+                if (handlerObjectSelect != null)
+                {
+                    handlerObjectSelect(incomingselect.ObjectData[i].ObjectLocalID, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDeselect(IClientAPI sender, Packet Pack)
+        {
+            ObjectDeselectPacket incomingdeselect = (ObjectDeselectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingdeselect.AgentData.SessionID != SessionId ||
+                    incomingdeselect.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectDeselect handlerObjectDeselect = null;
+
+            for (int i = 0; i < incomingdeselect.ObjectData.Length; i++)
+            {
+                handlerObjectDeselect = OnObjectDeselect;
+                if (handlerObjectDeselect != null)
+                {
+                    OnObjectDeselect(incomingdeselect.ObjectData[i].ObjectLocalID, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectPosition(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectPositionPacket position = (ObjectPositionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (position.AgentData.SessionID != SessionId ||
+                    position.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+
+            for (int i = 0; i < position.ObjectData.Length; i++)
+            {
+                UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;
+                if (handlerUpdateVector != null)
+                    handlerUpdateVector(position.ObjectData[i].ObjectLocalID, position.ObjectData[i].Position, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectScale(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectScalePacket scale = (ObjectScalePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scale.AgentData.SessionID != SessionId ||
+                    scale.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int i = 0; i < scale.ObjectData.Length; i++)
+            {
+                UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
+                if (handlerUpdatePrimGroupScale != null)
+                    handlerUpdatePrimGroupScale(scale.ObjectData[i].ObjectLocalID, scale.ObjectData[i].Scale, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectRotation(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectRotationPacket rotation = (ObjectRotationPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rotation.AgentData.SessionID != SessionId ||
+                    rotation.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int i = 0; i < rotation.ObjectData.Length; i++)
+            {
+                UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;
+                if (handlerUpdatePrimRotation != null)
+                    handlerUpdatePrimRotation(rotation.ObjectData[i].ObjectLocalID, rotation.ObjectData[i].Rotation, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectFlagUpdate(IClientAPI sender, Packet Pack)
+        {
+            ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (flags.AgentData.SessionID != SessionId ||
+                    flags.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdatePrimFlags handlerUpdatePrimFlags = OnUpdatePrimFlags;
+
+            if (handlerUpdatePrimFlags != null)
+            {
+                byte[] data = Pack.ToBytes();
+                // 46,47,48 are special positions within the packet
+                // This may change so perhaps we need a better way
+                // of storing this (OMV.FlagUpdatePacket.UsePhysics,etc?)
+                bool UsePhysics = (data[46] != 0) ? true : false;
+                bool IsTemporary = (data[47] != 0) ? true : false;
+                bool IsPhantom = (data[48] != 0) ? true : false;
+                handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectImage(IClientAPI sender, Packet Pack)
+        {
+            ObjectImagePacket imagePack = (ObjectImagePacket)Pack;
+
+            UpdatePrimTexture handlerUpdatePrimTexture = null;
+            for (int i = 0; i < imagePack.ObjectData.Length; i++)
+            {
+                handlerUpdatePrimTexture = OnUpdatePrimTexture;
+                if (handlerUpdatePrimTexture != null)
+                {
+                    handlerUpdatePrimTexture(imagePack.ObjectData[i].ObjectLocalID,
+                                             imagePack.ObjectData[i].TextureEntry, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectGrab(IClientAPI sender, Packet Pack)
+        {
+            ObjectGrabPacket grab = (ObjectGrabPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (grab.AgentData.SessionID != SessionId ||
+                    grab.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GrabObject handlerGrabObject = OnGrabObject;
+
+            if (handlerGrabObject != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((grab.SurfaceInfo != null) && (grab.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectGrabPacket.SurfaceInfoBlock surfaceInfo in grab.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+                handlerGrabObject(grab.ObjectData.LocalID, grab.ObjectData.GrabOffset, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectGrabUpdate(IClientAPI sender, Packet Pack)
+        {
+            ObjectGrabUpdatePacket grabUpdate = (ObjectGrabUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (grabUpdate.AgentData.SessionID != SessionId ||
+                    grabUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoveObject handlerGrabUpdate = OnGrabUpdate;
+
+            if (handlerGrabUpdate != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((grabUpdate.SurfaceInfo != null) && (grabUpdate.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectGrabUpdatePacket.SurfaceInfoBlock surfaceInfo in grabUpdate.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+                handlerGrabUpdate(grabUpdate.ObjectData.ObjectID, grabUpdate.ObjectData.GrabOffsetInitial,
+                                  grabUpdate.ObjectData.GrabPosition, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDeGrab(IClientAPI sender, Packet Pack)
+        {
+            ObjectDeGrabPacket deGrab = (ObjectDeGrabPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (deGrab.AgentData.SessionID != SessionId ||
+                    deGrab.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeGrabObject handlerDeGrabObject = OnDeGrabObject;
+            if (handlerDeGrabObject != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((deGrab.SurfaceInfo != null) && (deGrab.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectDeGrabPacket.SurfaceInfoBlock surfaceInfo in deGrab.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+                handlerDeGrabObject(deGrab.ObjectData.LocalID, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinStart(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinStart packet");
+            ObjectSpinStartPacket spinStart = (ObjectSpinStartPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinStart.AgentData.SessionID != SessionId ||
+                    spinStart.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SpinStart handlerSpinStart = OnSpinStart;
+            if (handlerSpinStart != null)
+            {
+                handlerSpinStart(spinStart.ObjectData.ObjectID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinUpdate(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinUpdate packet");
+            ObjectSpinUpdatePacket spinUpdate = (ObjectSpinUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinUpdate.AgentData.SessionID != SessionId ||
+                    spinUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            Vector3 axis;
+            float angle;
+            spinUpdate.ObjectData.Rotation.GetAxisAngle(out axis, out angle);
+            //m_log.Warn("[CLIENT]: ObjectSpinUpdate packet rot axis:" + axis + " angle:" + angle);
+
+            SpinObject handlerSpinUpdate = OnSpinUpdate;
+            if (handlerSpinUpdate != null)
+            {
+                handlerSpinUpdate(spinUpdate.ObjectData.ObjectID, spinUpdate.ObjectData.Rotation, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinStop(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinStop packet");
+            ObjectSpinStopPacket spinStop = (ObjectSpinStopPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinStop.AgentData.SessionID != SessionId ||
+                    spinStop.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SpinStop handlerSpinStop = OnSpinStop;
+            if (handlerSpinStop != null)
+            {
+                handlerSpinStop(spinStop.ObjectData.ObjectID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDescription(IClientAPI sender, Packet Pack)
+        {
+            ObjectDescriptionPacket objDes = (ObjectDescriptionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objDes.AgentData.SessionID != SessionId ||
+                    objDes.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectDescription = null;
+
+            for (int i = 0; i < objDes.ObjectData.Length; i++)
+            {
+                handlerObjectDescription = OnObjectDescription;
+                if (handlerObjectDescription != null)
+                {
+                    handlerObjectDescription(this, objDes.ObjectData[i].LocalID,
+                                             Util.FieldToString(objDes.ObjectData[i].Description));
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectName(IClientAPI sender, Packet Pack)
+        {
+            ObjectNamePacket objName = (ObjectNamePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objName.AgentData.SessionID != SessionId ||
+                    objName.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectName = null;
+            for (int i = 0; i < objName.ObjectData.Length; i++)
+            {
+                handlerObjectName = OnObjectName;
+                if (handlerObjectName != null)
+                {
+                    handlerObjectName(this, objName.ObjectData[i].LocalID,
+                                      Util.FieldToString(objName.ObjectData[i].Name));
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectPermissions(IClientAPI sender, Packet Pack)
+        {
+            if (OnObjectPermissions != null)
+            {
+                ObjectPermissionsPacket newobjPerms = (ObjectPermissionsPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (newobjPerms.AgentData.SessionID != SessionId ||
+                        newobjPerms.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                UUID AgentID = newobjPerms.AgentData.AgentID;
+                UUID SessionID = newobjPerms.AgentData.SessionID;
+
+                ObjectPermissions handlerObjectPermissions = null;
+
+                for (int i = 0; i < newobjPerms.ObjectData.Length; i++)
+                {
+                    ObjectPermissionsPacket.ObjectDataBlock permChanges = newobjPerms.ObjectData[i];
+
+                    byte field = permChanges.Field;
+                    uint localID = permChanges.ObjectLocalID;
+                    uint mask = permChanges.Mask;
+                    byte set = permChanges.Set;
+
+                    handlerObjectPermissions = OnObjectPermissions;
+
+                    if (handlerObjectPermissions != null)
+                        handlerObjectPermissions(this, AgentID, SessionID, field, localID, mask, set);
+                }
+            }
+
+            // Here's our data,
+            // PermField contains the field the info goes into
+            // PermField determines which mask we're changing
+            //
+            // chmask is the mask of the change
+            // setTF is whether we're adding it or taking it away
+            //
+            // objLocalID is the localID of the object.
+
+            // Unfortunately, we have to pass the event the packet because objData is an array
+            // That means multiple object perms may be updated in a single packet.
+
+            return true;
+        }
+
+        private bool HandleUndo(IClientAPI sender, Packet Pack)
+        {
+            UndoPacket undoitem = (UndoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (undoitem.AgentData.SessionID != SessionId ||
+                    undoitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (undoitem.ObjectData.Length > 0)
+            {
+                for (int i = 0; i < undoitem.ObjectData.Length; i++)
+                {
+                    UUID objiD = undoitem.ObjectData[i].ObjectID;
+                    AgentSit handlerOnUndo = OnUndo;
+                    if (handlerOnUndo != null)
+                    {
+                        handlerOnUndo(this, objiD);
+                    }
+
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDuplicateOnRay(IClientAPI sender, Packet Pack)
+        {
+            ObjectDuplicateOnRayPacket dupeOnRay = (ObjectDuplicateOnRayPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dupeOnRay.AgentData.SessionID != SessionId ||
+                    dupeOnRay.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectDuplicateOnRay handlerObjectDuplicateOnRay = null;
+
+            for (int i = 0; i < dupeOnRay.ObjectData.Length; i++)
+            {
+                handlerObjectDuplicateOnRay = OnObjectDuplicateOnRay;
+                if (handlerObjectDuplicateOnRay != null)
+                {
+                    handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID, dupeOnRay.AgentData.DuplicateFlags,
+                                                dupeOnRay.AgentData.AgentID, dupeOnRay.AgentData.GroupID, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,
+                                                dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast, dupeOnRay.AgentData.RayEndIsIntersection,
+                                                dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRequestObjectPropertiesFamily(IClientAPI sender, Packet Pack)
+        {
+            //This powers the little tooltip that appears when you move your mouse over an object
+            RequestObjectPropertiesFamilyPacket packToolTip = (RequestObjectPropertiesFamilyPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (packToolTip.AgentData.SessionID != SessionId ||
+                    packToolTip.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestObjectPropertiesFamilyPacket.ObjectDataBlock packObjBlock = packToolTip.ObjectData;
+
+            RequestObjectPropertiesFamily handlerRequestObjectPropertiesFamily = OnRequestObjectPropertiesFamily;
+
+            if (handlerRequestObjectPropertiesFamily != null)
+            {
+                handlerRequestObjectPropertiesFamily(this, m_agentId, packObjBlock.RequestFlags,
+                                                     packObjBlock.ObjectID);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectIncludeInSearch(IClientAPI sender, Packet Pack)
+        {
+            //This lets us set objects to appear in search (stuff like DataSnapshot, etc)
+            ObjectIncludeInSearchPacket packInSearch = (ObjectIncludeInSearchPacket)Pack;
+            ObjectIncludeInSearch handlerObjectIncludeInSearch = null;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (packInSearch.AgentData.SessionID != SessionId ||
+                    packInSearch.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            foreach (ObjectIncludeInSearchPacket.ObjectDataBlock objData in packInSearch.ObjectData)
+            {
+                bool inSearch = objData.IncludeInSearch;
+                uint localID = objData.ObjectLocalID;
+
+                handlerObjectIncludeInSearch = OnObjectIncludeInSearch;
+
+                if (handlerObjectIncludeInSearch != null)
+                {
+                    handlerObjectIncludeInSearch(this, inSearch, localID);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleScriptAnswerYes(IClientAPI sender, Packet Pack)
+        {
+            ScriptAnswerYesPacket scriptAnswer = (ScriptAnswerYesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scriptAnswer.AgentData.SessionID != SessionId ||
+                    scriptAnswer.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ScriptAnswer handlerScriptAnswer = OnScriptAnswer;
+            if (handlerScriptAnswer != null)
+            {
+                handlerScriptAnswer(this, scriptAnswer.Data.TaskID, scriptAnswer.Data.ItemID, scriptAnswer.Data.Questions);
+            }
+            return true;
+        }
+
+        private bool HandleObjectClickAction(IClientAPI sender, Packet Pack)
+        {
+            ObjectClickActionPacket ocpacket = (ObjectClickActionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ocpacket.AgentData.SessionID != SessionId ||
+                    ocpacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectClickAction = OnObjectClickAction;
+            if (handlerObjectClickAction != null)
+            {
+                foreach (ObjectClickActionPacket.ObjectDataBlock odata in ocpacket.ObjectData)
+                {
+                    byte action = odata.ClickAction;
+                    uint localID = odata.ObjectLocalID;
+                    handlerObjectClickAction(this, localID, action.ToString());
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectMaterial(IClientAPI sender, Packet Pack)
+        {
+            ObjectMaterialPacket ompacket = (ObjectMaterialPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ompacket.AgentData.SessionID != SessionId ||
+                    ompacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectMaterial = OnObjectMaterial;
+            if (handlerObjectMaterial != null)
+            {
+                foreach (ObjectMaterialPacket.ObjectDataBlock odata in ompacket.ObjectData)
+                {
+                    byte material = odata.Material;
+                    uint localID = odata.ObjectLocalID;
+                    handlerObjectMaterial(this, localID, material.ToString());
+                }
+            }
+            return true;
+        }
+
+        #endregion Objects/m_sceneObjects
+
+        #region Inventory/Asset/Other related packets
+
+        private bool HandleRequestImage(IClientAPI sender, Packet Pack)
+        {
+            RequestImagePacket imageRequest = (RequestImagePacket)Pack;
+            //m_log.Debug("image request: " + Pack.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (imageRequest.AgentData.SessionID != SessionId ||
+                    imageRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            //handlerTextureRequest = null;
+            for (int i = 0; i < imageRequest.RequestImage.Length; i++)
+            {
+                if (OnRequestTexture != null)
+                {
+                    TextureRequestArgs args = new TextureRequestArgs();
+
+                    RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i];
+
+                    args.RequestedAssetID = block.Image;
+                    args.DiscardLevel = block.DiscardLevel;
+                    args.PacketNumber = block.Packet;
+                    args.Priority = block.DownloadPriority;
+                    args.requestSequence = imageRequest.Header.Sequence;
+
+                    // NOTE: This is not a built in part of the LLUDP protocol, but we double the
+                    // priority of avatar textures to get avatars rezzing in faster than the
+                    // surrounding scene
+                    if ((ImageType)block.Type == ImageType.Baked)
+                        args.Priority *= 2.0f;
+
+                    //handlerTextureRequest = OnRequestTexture;
+
+                    //if (handlerTextureRequest != null)
+                    //OnRequestTexture(this, args);
+
+                    // in the end, we null this, so we have to check if it's null
+                    if (m_imageManager != null)
+                    {
+                        m_imageManager.EnqueueReq(args);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleTransferRequest(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request");
+
+            TransferRequestPacket transfer = (TransferRequestPacket)Pack;
+            //m_log.Debug("Transfer Request: " + transfer.ToString());
+            // Validate inventory transfers
+            // Has to be done here, because AssetCache can't do it
+            //
+            UUID taskID = UUID.Zero;
+            if (transfer.TransferInfo.SourceType == 3)
+            {
+                taskID = new UUID(transfer.TransferInfo.Params, 48);
+                UUID itemID = new UUID(transfer.TransferInfo.Params, 64);
+                UUID requestID = new UUID(transfer.TransferInfo.Params, 80);
+                if (!(((Scene)m_scene).Permissions.BypassPermissions()))
+                {
+                    if (taskID != UUID.Zero) // Prim
+                    {
+                        SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID);
+                        if (part == null)
+                            return true;
+
+                        if (part.OwnerID != AgentId)
+                            return true;
+
+                        if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
+                            return true;
+
+                        TaskInventoryItem ti = part.Inventory.GetInventoryItem(itemID);
+                        if (ti == null)
+                            return true;
+
+                        if (ti.OwnerID != AgentId)
+                            return true;
+
+                        if ((ti.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))
+                            return true;
+
+                        if (ti.AssetID != requestID)
+                            return true;
+                    }
+                    else // Agent
+                    {
+                        IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>();
+                        InventoryItemBase assetRequestItem = new InventoryItemBase(itemID, AgentId);
+                        assetRequestItem = invService.GetItem(assetRequestItem);
+                        if (assetRequestItem == null)
+                        {
+                            assetRequestItem = ((Scene)m_scene).CommsManager.UserProfileCacheService.LibraryRoot.FindItem(itemID);
+                            if (assetRequestItem == null)
+                                return true;
+                        }
+
+                        // At this point, we need to apply perms
+                        // only to notecards and scripts. All
+                        // other asset types are always available
+                        //
+                        if (assetRequestItem.AssetType == 10)
+                        {
+                            if (!((Scene)m_scene).Permissions.CanViewScript(itemID, UUID.Zero, AgentId))
+                            {
+                                SendAgentAlertMessage("Insufficient permissions to view script", false);
+                                return true;
+                            }
+                        }
+                        else if (assetRequestItem.AssetType == 7)
+                        {
+                            if (!((Scene)m_scene).Permissions.CanViewNotecard(itemID, UUID.Zero, AgentId))
+                            {
+                                SendAgentAlertMessage("Insufficient permissions to view notecard", false);
+                                return true;
+                            }
+                        }
+
+                        if (assetRequestItem.AssetID != requestID)
+                            return true;
+                    }
+                }
+            }
+
+            //m_assetCache.AddAssetRequest(this, transfer);
+
+            MakeAssetRequest(transfer, taskID);
+
+            /* RequestAsset = OnRequestAsset;
+                 if (RequestAsset != null)
+                 {
+                     RequestAsset(this, transfer);
+                 }*/
+            return true;
+        }
+
+        private bool HandleAssetUploadRequest(IClientAPI sender, Packet Pack)
+        {
+            AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
+
+
+            // m_log.Debug("upload request " + request.ToString());
+            // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString());
+            UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId);
+
+            UDPAssetUploadRequest handlerAssetUploadRequest = OnAssetUploadRequest;
+
+            if (handlerAssetUploadRequest != null)
+            {
+                handlerAssetUploadRequest(this, temp,
+                                          request.AssetBlock.TransactionID, request.AssetBlock.Type,
+                                          request.AssetBlock.AssetData, request.AssetBlock.StoreLocal,
+                                          request.AssetBlock.Tempfile);
+            }
+            return true;
+        }
+
+        private bool HandleRequestXfer(IClientAPI sender, Packet Pack)
+        {
+            RequestXferPacket xferReq = (RequestXferPacket)Pack;
+
+            RequestXfer handlerRequestXfer = OnRequestXfer;
+
+            if (handlerRequestXfer != null)
+            {
+                handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename));
+            }
+            return true;
+        }
+
+        private bool HandleSendXferPacket(IClientAPI sender, Packet Pack)
+        {
+            SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack;
+
+            XferReceive handlerXferReceive = OnXferReceive;
+            if (handlerXferReceive != null)
+            {
+                handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data);
+            }
+            return true;
+        }
+
+        private bool HandleConfirmXferPacket(IClientAPI sender, Packet Pack)
+        {
+            ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack;
+
+            ConfirmXfer handlerConfirmXfer = OnConfirmXfer;
+            if (handlerConfirmXfer != null)
+            {
+                handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet);
+            }
+            return true;
+        }
+
+        private bool HandleAbortXfer(IClientAPI sender, Packet Pack)
+        {
+            AbortXferPacket abortXfer = (AbortXferPacket)Pack;
+            AbortXfer handlerAbortXfer = OnAbortXfer;
+            if (handlerAbortXfer != null)
+            {
+                handlerAbortXfer(this, abortXfer.XferID.ID);
+            }
+
+            return true;
+        }
+
+        private bool HandleCreateInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (invFolder.AgentData.SessionID != SessionId ||
+                    invFolder.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CreateInventoryFolder handlerCreateInventoryFolder = OnCreateNewInventoryFolder;
+            if (handlerCreateInventoryFolder != null)
+            {
+                handlerCreateInventoryFolder(this, invFolder.FolderData.FolderID,
+                                             (ushort)invFolder.FolderData.Type,
+                                             Util.FieldToString(invFolder.FolderData.Name),
+                                             invFolder.FolderData.ParentID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            if (OnUpdateInventoryFolder != null)
+            {
+                UpdateInventoryFolderPacket invFolderx = (UpdateInventoryFolderPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (invFolderx.AgentData.SessionID != SessionId ||
+                        invFolderx.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                UpdateInventoryFolder handlerUpdateInventoryFolder = null;
+
+                for (int i = 0; i < invFolderx.FolderData.Length; i++)
+                {
+                    handlerUpdateInventoryFolder = OnUpdateInventoryFolder;
+                    if (handlerUpdateInventoryFolder != null)
+                    {
+                        OnUpdateInventoryFolder(this, invFolderx.FolderData[i].FolderID,
+                                                (ushort)invFolderx.FolderData[i].Type,
+                                                Util.FieldToString(invFolderx.FolderData[i].Name),
+                                                invFolderx.FolderData[i].ParentID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleMoveInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            if (OnMoveInventoryFolder != null)
+            {
+                MoveInventoryFolderPacket invFoldery = (MoveInventoryFolderPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (invFoldery.AgentData.SessionID != SessionId ||
+                        invFoldery.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                MoveInventoryFolder handlerMoveInventoryFolder = null;
+
+                for (int i = 0; i < invFoldery.InventoryData.Length; i++)
+                {
+                    handlerMoveInventoryFolder = OnMoveInventoryFolder;
+                    if (handlerMoveInventoryFolder != null)
+                    {
+                        OnMoveInventoryFolder(this, invFoldery.InventoryData[i].FolderID,
+                                              invFoldery.InventoryData[i].ParentID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleCreateInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createItem.AgentData.SessionID != SessionId ||
+                    createItem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CreateNewInventoryItem handlerCreateNewInventoryItem = OnCreateNewInventoryItem;
+            if (handlerCreateNewInventoryItem != null)
+            {
+                handlerCreateNewInventoryItem(this, createItem.InventoryBlock.TransactionID,
+                                              createItem.InventoryBlock.FolderID,
+                                              createItem.InventoryBlock.CallbackID,
+                                              Util.FieldToString(createItem.InventoryBlock.Description),
+                                              Util.FieldToString(createItem.InventoryBlock.Name),
+                                              createItem.InventoryBlock.InvType,
+                                              createItem.InventoryBlock.Type,
+                                              createItem.InventoryBlock.WearableType,
+                                              createItem.InventoryBlock.NextOwnerMask,
+                                              Util.UnixTimeSinceEpoch());
+            }
+            return true;
+        }
+
+        private bool HandleFetchInventory(IClientAPI sender, Packet Pack)
+        {
+            if (OnFetchInventory != null)
+            {
+                FetchInventoryPacket FetchInventoryx = (FetchInventoryPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (FetchInventoryx.AgentData.SessionID != SessionId ||
+                        FetchInventoryx.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                FetchInventory handlerFetchInventory = null;
+
+                for (int i = 0; i < FetchInventoryx.InventoryData.Length; i++)
+                {
+                    handlerFetchInventory = OnFetchInventory;
+
+                    if (handlerFetchInventory != null)
+                    {
+                        OnFetchInventory(this, FetchInventoryx.InventoryData[i].ItemID,
+                                         FetchInventoryx.InventoryData[i].OwnerID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleFetchInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (Fetch.AgentData.SessionID != SessionId ||
+                    Fetch.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            FetchInventoryDescendents handlerFetchInventoryDescendents = OnFetchInventoryDescendents;
+            if (handlerFetchInventoryDescendents != null)
+            {
+                handlerFetchInventoryDescendents(this, Fetch.InventoryData.FolderID, Fetch.InventoryData.OwnerID,
+                                                 Fetch.InventoryData.FetchFolders, Fetch.InventoryData.FetchItems,
+                                                 Fetch.InventoryData.SortOrder);
+            }
+            return true;
+        }
+
+        private bool HandlePurgeInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (Purge.AgentData.SessionID != SessionId ||
+                    Purge.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PurgeInventoryDescendents handlerPurgeInventoryDescendents = OnPurgeInventoryDescendents;
+            if (handlerPurgeInventoryDescendents != null)
+            {
+                handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inventoryItemUpdate.AgentData.SessionID != SessionId ||
+                    inventoryItemUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnUpdateInventoryItem != null)
+            {
+                UpdateInventoryItem handlerUpdateInventoryItem = null;
+                for (int i = 0; i < inventoryItemUpdate.InventoryData.Length; i++)
+                {
+                    handlerUpdateInventoryItem = OnUpdateInventoryItem;
+
+                    if (handlerUpdateInventoryItem != null)
+                    {
+                        InventoryItemBase itemUpd = new InventoryItemBase();
+                        itemUpd.ID = inventoryItemUpdate.InventoryData[i].ItemID;
+                        itemUpd.Name = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Name);
+                        itemUpd.Description = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Description);
+                        itemUpd.GroupID = inventoryItemUpdate.InventoryData[i].GroupID;
+                        itemUpd.GroupOwned = inventoryItemUpdate.InventoryData[i].GroupOwned;
+                        itemUpd.GroupPermissions = inventoryItemUpdate.InventoryData[i].GroupMask;
+                        itemUpd.NextPermissions = inventoryItemUpdate.InventoryData[i].NextOwnerMask;
+                        itemUpd.EveryOnePermissions = inventoryItemUpdate.InventoryData[i].EveryoneMask;
+                        itemUpd.CreationDate = inventoryItemUpdate.InventoryData[i].CreationDate;
+                        itemUpd.Folder = inventoryItemUpdate.InventoryData[i].FolderID;
+                        itemUpd.InvType = inventoryItemUpdate.InventoryData[i].InvType;
+                        itemUpd.SalePrice = inventoryItemUpdate.InventoryData[i].SalePrice;
+                        itemUpd.SaleType = inventoryItemUpdate.InventoryData[i].SaleType;
+                        itemUpd.Flags = inventoryItemUpdate.InventoryData[i].Flags;
+
+                        OnUpdateInventoryItem(this, inventoryItemUpdate.InventoryData[i].TransactionID,
+                                              inventoryItemUpdate.InventoryData[i].ItemID,
+                                              itemUpd);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleCopyInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (copyitem.AgentData.SessionID != SessionId ||
+                    copyitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CopyInventoryItem handlerCopyInventoryItem = null;
+            if (OnCopyInventoryItem != null)
+            {
+                foreach (CopyInventoryItemPacket.InventoryDataBlock datablock in copyitem.InventoryData)
+                {
+                    handlerCopyInventoryItem = OnCopyInventoryItem;
+                    if (handlerCopyInventoryItem != null)
+                    {
+                        handlerCopyInventoryItem(this, datablock.CallbackID, datablock.OldAgentID,
+                                                 datablock.OldItemID, datablock.NewFolderID,
+                                                 Util.FieldToString(datablock.NewName));
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleMoveInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moveitem.AgentData.SessionID != SessionId ||
+                    moveitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnMoveInventoryItem != null)
+            {
+                MoveInventoryItem handlerMoveInventoryItem = null;
+                InventoryItemBase itm = null;
+                List<InventoryItemBase> items = new List<InventoryItemBase>();
+                foreach (MoveInventoryItemPacket.InventoryDataBlock datablock in moveitem.InventoryData)
+                {
+                    itm = new InventoryItemBase(datablock.ItemID, AgentId);
+                    itm.Folder = datablock.FolderID;
+                    itm.Name = Util.FieldToString(datablock.NewName);
+                    // weird, comes out as empty string
+                    //m_log.DebugFormat("[XXX] new name: {0}", itm.Name);
+                    items.Add(itm);
+                }
+                handlerMoveInventoryItem = OnMoveInventoryItem;
+                if (handlerMoveInventoryItem != null)
+                {
+                    handlerMoveInventoryItem(this, items);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeItem.AgentData.SessionID != SessionId ||
+                    removeItem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnRemoveInventoryItem != null)
+            {
+                RemoveInventoryItem handlerRemoveInventoryItem = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryItemPacket.InventoryDataBlock datablock in removeItem.InventoryData)
+                {
+                    uuids.Add(datablock.ItemID);
+                }
+                handlerRemoveInventoryItem = OnRemoveInventoryItem;
+                if (handlerRemoveInventoryItem != null)
+                {
+                    handlerRemoveInventoryItem(this, uuids);
+                }
+
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeFolder.AgentData.SessionID != SessionId ||
+                    removeFolder.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnRemoveInventoryFolder != null)
+            {
+                RemoveInventoryFolder handlerRemoveInventoryFolder = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryFolderPacket.FolderDataBlock datablock in removeFolder.FolderData)
+                {
+                    uuids.Add(datablock.FolderID);
+                }
+                handlerRemoveInventoryFolder = OnRemoveInventoryFolder;
+                if (handlerRemoveInventoryFolder != null)
+                {
+                    handlerRemoveInventoryFolder(this, uuids);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryObjects(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack;
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeObject.AgentData.SessionID != SessionId ||
+                    removeObject.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            if (OnRemoveInventoryFolder != null)
+            {
+                RemoveInventoryFolder handlerRemoveInventoryFolder = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryObjectsPacket.FolderDataBlock datablock in removeObject.FolderData)
+                {
+                    uuids.Add(datablock.FolderID);
+                }
+                handlerRemoveInventoryFolder = OnRemoveInventoryFolder;
+                if (handlerRemoveInventoryFolder != null)
+                {
+                    handlerRemoveInventoryFolder(this, uuids);
+                }
+            }
+
+            if (OnRemoveInventoryItem != null)
+            {
+                RemoveInventoryItem handlerRemoveInventoryItem = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryObjectsPacket.ItemDataBlock datablock in removeObject.ItemData)
+                {
+                    uuids.Add(datablock.ItemID);
+                }
+                handlerRemoveInventoryItem = OnRemoveInventoryItem;
+                if (handlerRemoveInventoryItem != null)
+                {
+                    handlerRemoveInventoryItem(this, uuids);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRequestTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (requesttask.AgentData.SessionID != SessionId ||
+                    requesttask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestTaskInventory handlerRequestTaskInventory = OnRequestTaskInventory;
+            if (handlerRequestTaskInventory != null)
+            {
+                handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updatetask.AgentData.SessionID != SessionId ||
+                    updatetask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnUpdateTaskInventory != null)
+            {
+                if (updatetask.UpdateData.Key == 0)
+                {
+                    UpdateTaskInventory handlerUpdateTaskInventory = OnUpdateTaskInventory;
+                    if (handlerUpdateTaskInventory != null)
+                    {
+                        TaskInventoryItem newTaskItem = new TaskInventoryItem();
+                        newTaskItem.ItemID = updatetask.InventoryData.ItemID;
+                        newTaskItem.ParentID = updatetask.InventoryData.FolderID;
+                        newTaskItem.CreatorID = updatetask.InventoryData.CreatorID;
+                        newTaskItem.OwnerID = updatetask.InventoryData.OwnerID;
+                        newTaskItem.GroupID = updatetask.InventoryData.GroupID;
+                        newTaskItem.BasePermissions = updatetask.InventoryData.BaseMask;
+                        newTaskItem.CurrentPermissions = updatetask.InventoryData.OwnerMask;
+                        newTaskItem.GroupPermissions = updatetask.InventoryData.GroupMask;
+                        newTaskItem.EveryonePermissions = updatetask.InventoryData.EveryoneMask;
+                        newTaskItem.NextPermissions = updatetask.InventoryData.NextOwnerMask;
+                        //newTaskItem.GroupOwned=updatetask.InventoryData.GroupOwned;
+                        newTaskItem.Type = updatetask.InventoryData.Type;
+                        newTaskItem.InvType = updatetask.InventoryData.InvType;
+                        newTaskItem.Flags = updatetask.InventoryData.Flags;
+                        //newTaskItem.SaleType=updatetask.InventoryData.SaleType;
+                        //newTaskItem.SalePrice=updatetask.InventoryData.SalePrice;;
+                        newTaskItem.Name = Util.FieldToString(updatetask.InventoryData.Name);
+                        newTaskItem.Description = Util.FieldToString(updatetask.InventoryData.Description);
+                        newTaskItem.CreationDate = (uint)updatetask.InventoryData.CreationDate;
+                        handlerUpdateTaskInventory(this, updatetask.InventoryData.TransactionID,
+                                                   newTaskItem, updatetask.UpdateData.LocalID);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRemoveTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            RemoveTaskInventoryPacket removeTask = (RemoveTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeTask.AgentData.SessionID != SessionId ||
+                    removeTask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RemoveTaskInventory handlerRemoveTaskItem = OnRemoveTaskItem;
+
+            if (handlerRemoveTaskItem != null)
+            {
+                handlerRemoveTaskItem(this, removeTask.InventoryData.ItemID, removeTask.InventoryData.LocalID);
+            }
+
+            return true;
+        }
+
+        private bool HandleMoveTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            MoveTaskInventoryPacket moveTaskInventoryPacket = (MoveTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moveTaskInventoryPacket.AgentData.SessionID != SessionId ||
+                    moveTaskInventoryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoveTaskInventory handlerMoveTaskItem = OnMoveTaskItem;
+
+            if (handlerMoveTaskItem != null)
+            {
+                handlerMoveTaskItem(
+                    this, moveTaskInventoryPacket.AgentData.FolderID,
+                    moveTaskInventoryPacket.InventoryData.LocalID,
+                    moveTaskInventoryPacket.InventoryData.ItemID);
+            }
+
+            return true;
+        }
+
+        private bool HandleRezScript(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Debug(Pack.ToString());
+            RezScriptPacket rezScriptx = (RezScriptPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rezScriptx.AgentData.SessionID != SessionId ||
+                    rezScriptx.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RezScript handlerRezScript = OnRezScript;
+            InventoryItemBase item = new InventoryItemBase();
+            item.ID = rezScriptx.InventoryBlock.ItemID;
+            item.Folder = rezScriptx.InventoryBlock.FolderID;
+            item.CreatorId = rezScriptx.InventoryBlock.CreatorID.ToString();
+            item.Owner = rezScriptx.InventoryBlock.OwnerID;
+            item.BasePermissions = rezScriptx.InventoryBlock.BaseMask;
+            item.CurrentPermissions = rezScriptx.InventoryBlock.OwnerMask;
+            item.EveryOnePermissions = rezScriptx.InventoryBlock.EveryoneMask;
+            item.NextPermissions = rezScriptx.InventoryBlock.NextOwnerMask;
+            item.GroupPermissions = rezScriptx.InventoryBlock.GroupMask;
+            item.GroupOwned = rezScriptx.InventoryBlock.GroupOwned;
+            item.GroupID = rezScriptx.InventoryBlock.GroupID;
+            item.AssetType = rezScriptx.InventoryBlock.Type;
+            item.InvType = rezScriptx.InventoryBlock.InvType;
+            item.Flags = rezScriptx.InventoryBlock.Flags;
+            item.SaleType = rezScriptx.InventoryBlock.SaleType;
+            item.SalePrice = rezScriptx.InventoryBlock.SalePrice;
+            item.Name = Util.FieldToString(rezScriptx.InventoryBlock.Name);
+            item.Description = Util.FieldToString(rezScriptx.InventoryBlock.Description);
+            item.CreationDate = rezScriptx.InventoryBlock.CreationDate;
+
+            if (handlerRezScript != null)
+            {
+                handlerRezScript(this, item, rezScriptx.InventoryBlock.TransactionID, rezScriptx.UpdateBlock.ObjectLocalID);
+            }
+            return true;
+        }
+
+        private bool HandleMapLayerRequest(IClientAPI sender, Packet Pack)
+        {
+            RequestMapLayer();
+            return true;
+        }
+
+        private bool HandleMapBlockRequest(IClientAPI sender, Packet Pack)
+        {
+            MapBlockRequestPacket MapRequest = (MapBlockRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (MapRequest.AgentData.SessionID != SessionId ||
+                    MapRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestMapBlocks handlerRequestMapBlocks = OnRequestMapBlocks;
+            if (handlerRequestMapBlocks != null)
+            {
+                handlerRequestMapBlocks(this, MapRequest.PositionData.MinX, MapRequest.PositionData.MinY,
+                                        MapRequest.PositionData.MaxX, MapRequest.PositionData.MaxY, MapRequest.AgentData.Flags);
+            }
+            return true;
+        }
+
+        private bool HandleMapNameRequest(IClientAPI sender, Packet Pack)
+        {
+            MapNameRequestPacket map = (MapNameRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (map.AgentData.SessionID != SessionId ||
+                    map.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string mapName = Util.UTF8.GetString(map.NameData.Name, 0,
+                                                     map.NameData.Name.Length - 1);
+            RequestMapName handlerMapNameRequest = OnMapNameRequest;
+            if (handlerMapNameRequest != null)
+            {
+                handlerMapNameRequest(this, mapName);
+            }
+            return true;
+        }
+
+        private bool HandleTeleportLandmarkRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tpReq.Info.SessionID != SessionId ||
+                    tpReq.Info.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID lmid = tpReq.Info.LandmarkID;
+            AssetLandmark lm;
+            if (lmid != UUID.Zero)
+            {
+                //AssetBase lma = m_assetCache.GetAsset(lmid, false);
+                AssetBase lma = m_assetService.Get(lmid.ToString());
+
+                if (lma == null)
+                {
+                    // Failed to find landmark
+                    TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                    tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                    tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                    OutPacket(tpCancel, ThrottleOutPacketType.Task);
+                }
+
+                try
+                {
+                    lm = new AssetLandmark(lma);
+                }
+                catch (NullReferenceException)
+                {
+                    // asset not found generates null ref inside the assetlandmark constructor.
+                    TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                    tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                    tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                    OutPacket(tpCancel, ThrottleOutPacketType.Task);
+                    return true;
+                }
+            }
+            else
+            {
+                // Teleport home request
+                UUIDNameRequest handlerTeleportHomeRequest = OnTeleportHomeRequest;
+                if (handlerTeleportHomeRequest != null)
+                {
+                    handlerTeleportHomeRequest(AgentId, this);
+                }
+                return true;
+            }
+
+            TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest;
+            if (handlerTeleportLandmarkRequest != null)
+            {
+                handlerTeleportLandmarkRequest(this, lm.RegionID, lm.Position);
+            }
+            else
+            {
+                //no event handler so cancel request
+
+
+                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                OutPacket(tpCancel, ThrottleOutPacketType.Task);
+
+            }
+            return true;
+        }
+
+        private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;
+            // m_log.Debug(tpLocReq.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tpLocReq.AgentData.SessionID != SessionId ||
+                    tpLocReq.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            TeleportLocationRequest handlerTeleportLocationRequest = OnTeleportLocationRequest;
+            if (handlerTeleportLocationRequest != null)
+            {
+                handlerTeleportLocationRequest(this, tpLocReq.Info.RegionHandle, tpLocReq.Info.Position,
+                                               tpLocReq.Info.LookAt, 16);
+            }
+            else
+            {
+                //no event handler so cancel request
+                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                tpCancel.Info.SessionID = tpLocReq.AgentData.SessionID;
+                tpCancel.Info.AgentID = tpLocReq.AgentData.AgentID;
+                OutPacket(tpCancel, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+
+        #endregion Inventory/Asset/Other related packets
+
+        private bool HandleUUIDNameRequest(IClientAPI sender, Packet Pack)
+        {
+            UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack;
+
+            foreach (UUIDNameRequestPacket.UUIDNameBlockBlock UUIDBlock in incoming.UUIDNameBlock)
+            {
+                UUIDNameRequest handlerNameRequest = OnNameFromUUIDRequest;
+                if (handlerNameRequest != null)
+                {
+                    handlerNameRequest(UUIDBlock.ID, this);
+                }
+            }
+            return true;
+        }
+
+        #region Parcel related packets
+
+        private bool HandleRegionHandleRequest(IClientAPI sender, Packet Pack)
+        {
+            RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;
+
+            RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest;
+            if (handlerRegionHandleRequest != null)
+            {
+                handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID);
+            }
+            return true;
+        }
+
+        private bool HandleParcelInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelInfoRequestPacket pirPack = (ParcelInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pirPack.AgentData.SessionID != SessionId ||
+                    pirPack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelInfoRequest handlerParcelInfoRequest = OnParcelInfoRequest;
+            if (handlerParcelInfoRequest != null)
+            {
+                handlerParcelInfoRequest(this, pirPack.Data.ParcelID);
+            }
+            return true;
+        }
+
+        private bool HandleParcelAccessListRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelAccessListRequestPacket requestPacket = (ParcelAccessListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (requestPacket.AgentData.SessionID != SessionId ||
+                    requestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelAccessListRequest handlerParcelAccessListRequest = OnParcelAccessListRequest;
+
+            if (handlerParcelAccessListRequest != null)
+            {
+                handlerParcelAccessListRequest(requestPacket.AgentData.AgentID, requestPacket.AgentData.SessionID,
+                                               requestPacket.Data.Flags, requestPacket.Data.SequenceID,
+                                               requestPacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelAccessListUpdate(IClientAPI sender, Packet Pack)
+        {
+            ParcelAccessListUpdatePacket updatePacket = (ParcelAccessListUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updatePacket.AgentData.SessionID != SessionId ||
+                    updatePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<ParcelManager.ParcelAccessEntry> entries = new List<ParcelManager.ParcelAccessEntry>();
+            foreach (ParcelAccessListUpdatePacket.ListBlock block in updatePacket.List)
+            {
+                ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+                entry.AgentID = block.ID;
+                entry.Flags = (AccessList)block.Flags;
+                entry.Time = new DateTime();
+                entries.Add(entry);
+            }
+
+            ParcelAccessListUpdateRequest handlerParcelAccessListUpdateRequest = OnParcelAccessListUpdateRequest;
+            if (handlerParcelAccessListUpdateRequest != null)
+            {
+                handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID,
+                                                     updatePacket.AgentData.SessionID, updatePacket.Data.Flags,
+                                                     updatePacket.Data.LocalID, entries, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelPropertiesRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (propertiesRequest.AgentData.SessionID != SessionId ||
+                    propertiesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelPropertiesRequest handlerParcelPropertiesRequest = OnParcelPropertiesRequest;
+            if (handlerParcelPropertiesRequest != null)
+            {
+                handlerParcelPropertiesRequest((int)Math.Round(propertiesRequest.ParcelData.West),
+                                               (int)Math.Round(propertiesRequest.ParcelData.South),
+                                               (int)Math.Round(propertiesRequest.ParcelData.East),
+                                               (int)Math.Round(propertiesRequest.ParcelData.North),
+                                               propertiesRequest.ParcelData.SequenceID,
+                                               propertiesRequest.ParcelData.SnapSelection, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelDivide(IClientAPI sender, Packet Pack)
+        {
+            ParcelDividePacket landDivide = (ParcelDividePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (landDivide.AgentData.SessionID != SessionId ||
+                    landDivide.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelDivideRequest handlerParcelDivideRequest = OnParcelDivideRequest;
+            if (handlerParcelDivideRequest != null)
+            {
+                handlerParcelDivideRequest((int)Math.Round(landDivide.ParcelData.West),
+                                           (int)Math.Round(landDivide.ParcelData.South),
+                                           (int)Math.Round(landDivide.ParcelData.East),
+                                           (int)Math.Round(landDivide.ParcelData.North), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelJoin(IClientAPI sender, Packet Pack)
+        {
+            ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (landJoin.AgentData.SessionID != SessionId ||
+                    landJoin.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelJoinRequest handlerParcelJoinRequest = OnParcelJoinRequest;
+
+            if (handlerParcelJoinRequest != null)
+            {
+                handlerParcelJoinRequest((int)Math.Round(landJoin.ParcelData.West),
+                                         (int)Math.Round(landJoin.ParcelData.South),
+                                         (int)Math.Round(landJoin.ParcelData.East),
+                                         (int)Math.Round(landJoin.ParcelData.North), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelPropertiesUpdate(IClientAPI sender, Packet Pack)
+        {
+            ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelPropertiesPacket.AgentData.SessionID != SessionId ||
+                    parcelPropertiesPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelPropertiesUpdateRequest handlerParcelPropertiesUpdateRequest = OnParcelPropertiesUpdateRequest;
+
+            if (handlerParcelPropertiesUpdateRequest != null)
+            {
+                LandUpdateArgs args = new LandUpdateArgs();
+
+                args.AuthBuyerID = parcelPropertiesPacket.ParcelData.AuthBuyerID;
+                args.Category = (ParcelCategory)parcelPropertiesPacket.ParcelData.Category;
+                args.Desc = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Desc);
+                args.GroupID = parcelPropertiesPacket.ParcelData.GroupID;
+                args.LandingType = parcelPropertiesPacket.ParcelData.LandingType;
+                args.MediaAutoScale = parcelPropertiesPacket.ParcelData.MediaAutoScale;
+                args.MediaID = parcelPropertiesPacket.ParcelData.MediaID;
+                args.MediaURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MediaURL);
+                args.MusicURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MusicURL);
+                args.Name = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Name);
+                args.ParcelFlags = parcelPropertiesPacket.ParcelData.ParcelFlags;
+                args.PassHours = parcelPropertiesPacket.ParcelData.PassHours;
+                args.PassPrice = parcelPropertiesPacket.ParcelData.PassPrice;
+                args.SalePrice = parcelPropertiesPacket.ParcelData.SalePrice;
+                args.SnapshotID = parcelPropertiesPacket.ParcelData.SnapshotID;
+                args.UserLocation = parcelPropertiesPacket.ParcelData.UserLocation;
+                args.UserLookAt = parcelPropertiesPacket.ParcelData.UserLookAt;
+                handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelSelectObjects(IClientAPI sender, Packet Pack)
+        {
+            ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (selectPacket.AgentData.SessionID != SessionId ||
+                    selectPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<UUID> returnIDs = new List<UUID>();
+
+            foreach (ParcelSelectObjectsPacket.ReturnIDsBlock rb in
+                     selectPacket.ReturnIDs)
+            {
+                returnIDs.Add(rb.ReturnID);
+            }
+
+            ParcelSelectObjects handlerParcelSelectObjects = OnParcelSelectObjects;
+
+            if (handlerParcelSelectObjects != null)
+            {
+                handlerParcelSelectObjects(selectPacket.ParcelData.LocalID,
+                                           Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelObjectOwnersRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (reqPacket.AgentData.SessionID != SessionId ||
+                    reqPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelObjectOwnerRequest handlerParcelObjectOwnerRequest = OnParcelObjectOwnerRequest;
+
+            if (handlerParcelObjectOwnerRequest != null)
+            {
+                handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this);
+            }
+            return true;
+
+        }
+
+        private bool HandleParcelGodForceOwner(IClientAPI sender, Packet Pack)
+        {
+            ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (godForceOwnerPacket.AgentData.SessionID != SessionId ||
+                    godForceOwnerPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelGodForceOwner handlerParcelGodForceOwner = OnParcelGodForceOwner;
+            if (handlerParcelGodForceOwner != null)
+            {
+                handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelRelease(IClientAPI sender, Packet Pack)
+        {
+            ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (releasePacket.AgentData.SessionID != SessionId ||
+                    releasePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelAbandonRequest handlerParcelAbandonRequest = OnParcelAbandonRequest;
+            if (handlerParcelAbandonRequest != null)
+            {
+                handlerParcelAbandonRequest(releasePacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelReclaim(IClientAPI sender, Packet Pack)
+        {
+            ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (reclaimPacket.AgentData.SessionID != SessionId ||
+                    reclaimPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelReclaim handlerParcelReclaim = OnParcelReclaim;
+            if (handlerParcelReclaim != null)
+            {
+                handlerParcelReclaim(reclaimPacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelReturnObjects(IClientAPI sender, Packet Pack)
+        {
+            ParcelReturnObjectsPacket parcelReturnObjects = (ParcelReturnObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelReturnObjects.AgentData.SessionID != SessionId ||
+                    parcelReturnObjects.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID[] puserselectedOwnerIDs = new UUID[parcelReturnObjects.OwnerIDs.Length];
+            for (int parceliterator = 0; parceliterator < parcelReturnObjects.OwnerIDs.Length; parceliterator++)
+                puserselectedOwnerIDs[parceliterator] = parcelReturnObjects.OwnerIDs[parceliterator].OwnerID;
+
+            UUID[] puserselectedTaskIDs = new UUID[parcelReturnObjects.TaskIDs.Length];
+
+            for (int parceliterator = 0; parceliterator < parcelReturnObjects.TaskIDs.Length; parceliterator++)
+                puserselectedTaskIDs[parceliterator] = parcelReturnObjects.TaskIDs[parceliterator].TaskID;
+
+            ParcelReturnObjectsRequest handlerParcelReturnObjectsRequest = OnParcelReturnObjectsRequest;
+            if (handlerParcelReturnObjectsRequest != null)
+            {
+                handlerParcelReturnObjectsRequest(parcelReturnObjects.ParcelData.LocalID, parcelReturnObjects.ParcelData.ReturnType, puserselectedOwnerIDs, puserselectedTaskIDs, this);
+
+            }
+            return true;
+        }
+
+        private bool HandleParcelSetOtherCleanTime(IClientAPI sender, Packet Pack)
+        {
+            ParcelSetOtherCleanTimePacket parcelSetOtherCleanTimePacket = (ParcelSetOtherCleanTimePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelSetOtherCleanTimePacket.AgentData.SessionID != SessionId ||
+                    parcelSetOtherCleanTimePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelSetOtherCleanTime handlerParcelSetOtherCleanTime = OnParcelSetOtherCleanTime;
+            if (handlerParcelSetOtherCleanTime != null)
+            {
+                handlerParcelSetOtherCleanTime(this,
+                                               parcelSetOtherCleanTimePacket.ParcelData.LocalID,
+                                               parcelSetOtherCleanTimePacket.ParcelData.OtherCleanTime);
+            }
+            return true;
+        }
+
+        private bool HandleLandStatRequest(IClientAPI sender, Packet Pack)
+        {
+            LandStatRequestPacket lsrp = (LandStatRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (lsrp.AgentData.SessionID != SessionId ||
+                    lsrp.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GodLandStatRequest handlerLandStatRequest = OnLandStatRequest;
+            if (handlerLandStatRequest != null)
+            {
+                handlerLandStatRequest(lsrp.RequestData.ParcelLocalID, lsrp.RequestData.ReportType, lsrp.RequestData.RequestFlags, Utils.BytesToString(lsrp.RequestData.Filter), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelDwellRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelDwellRequestPacket dwellrq =
+                            (ParcelDwellRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dwellrq.AgentData.SessionID != SessionId ||
+                    dwellrq.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelDwellRequest handlerParcelDwellRequest = OnParcelDwellRequest;
+            if (handlerParcelDwellRequest != null)
+            {
+                handlerParcelDwellRequest(dwellrq.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        #endregion Parcel related packets
+
+        #region Estate Packets
+
+        private bool HandleEstateOwnerMessage(IClientAPI sender, Packet Pack)
+        {
+            EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack;
+            //m_log.Debug(messagePacket.ToString());
+            GodLandStatRequest handlerLandStatRequest;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (messagePacket.AgentData.SessionID != SessionId ||
+                    messagePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            switch (Utils.BytesToString(messagePacket.MethodData.Method))
+            {
+                case "getinfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        OnDetailedEstateDataRequest(this, messagePacket.MethodData.Invoice);
+                    }
+                    return true;
+                case "setregioninfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        OnSetEstateFlagsRequest(convertParamStringToBool(messagePacket.ParamList[0].Parameter), convertParamStringToBool(messagePacket.ParamList[1].Parameter),
+                                                convertParamStringToBool(messagePacket.ParamList[2].Parameter), !convertParamStringToBool(messagePacket.ParamList[3].Parameter),
+                                                Convert.ToInt16(Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[4].Parameter))),
+                                                (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter)),
+                                                Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[6].Parameter)),
+                                                convertParamStringToBool(messagePacket.ParamList[7].Parameter), convertParamStringToBool(messagePacket.ParamList[8].Parameter));
+                    }
+                    return true;
+                //                            case "texturebase":
+                //                                if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                //                                {
+                //                                    foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                //                                    {
+                //                                        string s = Utils.BytesToString(block.Parameter);
+                //                                        string[] splitField = s.Split(' ');
+                //                                        if (splitField.Length == 2)
+                //                                        {
+                //                                            UUID tempUUID = new UUID(splitField[1]);
+                //                                            OnSetEstateTerrainBaseTexture(this, Convert.ToInt16(splitField[0]), tempUUID);
+                //                                        }
+                //                                    }
+                //                                }
+                //                                break;
+                case "texturedetail":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            string s = Utils.BytesToString(block.Parameter);
+                            string[] splitField = s.Split(' ');
+                            if (splitField.Length == 2)
+                            {
+                                Int16 corner = Convert.ToInt16(splitField[0]);
+                                UUID textureUUID = new UUID(splitField[1]);
+
+                                OnSetEstateTerrainDetailTexture(this, corner, textureUUID);
+                            }
+                        }
+                    }
+
+                    return true;
+                case "textureheights":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            string s = Utils.BytesToString(block.Parameter);
+                            string[] splitField = s.Split(' ');
+                            if (splitField.Length == 3)
+                            {
+                                Int16 corner = Convert.ToInt16(splitField[0]);
+                                float lowValue = (float)Convert.ToDecimal(splitField[1]);
+                                float highValue = (float)Convert.ToDecimal(splitField[2]);
+
+                                OnSetEstateTerrainTextureHeights(this, corner, lowValue, highValue);
+                            }
+                        }
+                    }
+                    return true;
+                case "texturecommit":
+                    OnCommitEstateTerrainTextureRequest(this);
+                    return true;
+                case "setregionterrain":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length != 9)
+                        {
+                            m_log.Error("EstateOwnerMessage: SetRegionTerrain method has a ParamList of invalid length");
+                        }
+                        else
+                        {
+                            try
+                            {
+                                string tmp = Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float WaterHeight = (float)Convert.ToDecimal(tmp);
+                                tmp = Utils.BytesToString(messagePacket.ParamList[1].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float TerrainRaiseLimit = (float)Convert.ToDecimal(tmp);
+                                tmp = Utils.BytesToString(messagePacket.ParamList[2].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float TerrainLowerLimit = (float)Convert.ToDecimal(tmp);
+                                bool UseEstateSun = convertParamStringToBool(messagePacket.ParamList[3].Parameter);
+                                bool UseFixedSun = convertParamStringToBool(messagePacket.ParamList[4].Parameter);
+                                float SunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter));
+                                bool UseGlobal = convertParamStringToBool(messagePacket.ParamList[6].Parameter);
+                                bool EstateFixedSun = convertParamStringToBool(messagePacket.ParamList[7].Parameter);
+                                float EstateSunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[8].Parameter));
+
+                                OnSetRegionTerrainSettings(WaterHeight, TerrainRaiseLimit, TerrainLowerLimit, UseEstateSun, UseFixedSun, SunHour, UseGlobal, EstateFixedSun, EstateSunHour);
+
+                            }
+                            catch (Exception ex)
+                            {
+                                m_log.Error("EstateOwnerMessage: Exception while setting terrain settings: \n" + messagePacket + "\n" + ex);
+                            }
+                        }
+                    }
+
+                    return true;
+                case "restart":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        // There's only 1 block in the estateResetSim..   and that's the number of seconds till restart.
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            float timeSeconds;
+                            Utils.TryParseSingle(Utils.BytesToString(block.Parameter), out timeSeconds);
+                            timeSeconds = (int)timeSeconds;
+                            OnEstateRestartSimRequest(this, (int)timeSeconds);
+
+                        }
+                    }
+                    return true;
+                case "estatechangecovenantid":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            UUID newCovenantID = new UUID(Utils.BytesToString(block.Parameter));
+                            OnEstateChangeCovenantRequest(this, newCovenantID);
+                        }
+                    }
+                    return true;
+                case "estateaccessdelta": // Estate access delta manages the banlist and allow list too.
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        int estateAccessType = Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                        OnUpdateEstateAccessDeltaRequest(this, messagePacket.MethodData.Invoice, estateAccessType, new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)));
+
+                    }
+                    return true;
+                case "simulatormessage":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                        string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                        string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        UUID sessionID = messagePacket.AgentData.SessionID;
+                        OnSimulatorBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
+                    }
+                    return true;
+                case "instantmessage":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length < 5)
+                            return true;
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                        string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                        string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        UUID sessionID = messagePacket.AgentData.SessionID;
+                        OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
+                    }
+                    return true;
+                case "setregiondebug":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        bool scripted = convertParamStringToBool(messagePacket.ParamList[0].Parameter);
+                        bool collisionEvents = convertParamStringToBool(messagePacket.ParamList[1].Parameter);
+                        bool physics = convertParamStringToBool(messagePacket.ParamList[2].Parameter);
+
+                        OnEstateDebugRegionRequest(this, invoice, SenderID, scripted, collisionEvents, physics);
+                    }
+                    return true;
+                case "teleporthomeuser":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UUID Prey;
+
+                        UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[1].Parameter), out Prey);
+
+                        OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey);
+                    }
+                    return true;
+                case "teleporthomeallusers":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        OnEstateTeleportAllUsersHomeRequest(this, invoice, SenderID);
+                    }
+                    return true;
+                case "colliders":
+                    handlerLandStatRequest = OnLandStatRequest;
+                    if (handlerLandStatRequest != null)
+                    {
+                        handlerLandStatRequest(0, 1, 0, "", this);
+                    }
+                    return true;
+                case "scripts":
+                    handlerLandStatRequest = OnLandStatRequest;
+                    if (handlerLandStatRequest != null)
+                    {
+                        handlerLandStatRequest(0, 0, 0, "", this);
+                    }
+                    return true;
+                case "terrain":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length > 0)
+                        {
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "bake")
+                            {
+                                BakeTerrain handlerBakeTerrain = OnBakeTerrain;
+                                if (handlerBakeTerrain != null)
+                                {
+                                    handlerBakeTerrain(this);
+                                }
+                            }
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "download filename")
+                            {
+                                if (messagePacket.ParamList.Length > 1)
+                                {
+                                    RequestTerrain handlerRequestTerrain = OnRequestTerrain;
+                                    if (handlerRequestTerrain != null)
+                                    {
+                                        handlerRequestTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                                    }
+                                }
+                            }
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "upload filename")
+                            {
+                                if (messagePacket.ParamList.Length > 1)
+                                {
+                                    RequestTerrain handlerUploadTerrain = OnUploadTerrain;
+                                    if (handlerUploadTerrain != null)
+                                    {
+                                        handlerUploadTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                                    }
+                                }
+                            }
+
+                        }
+
+
+                    }
+                    return true;
+
+                case "estatechangeinfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UInt32 param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                        UInt32 param2 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+
+                        EstateChangeInfo handlerEstateChangeInfo = OnEstateChangeInfo;
+                        if (handlerEstateChangeInfo != null)
+                        {
+                            handlerEstateChangeInfo(this, invoice, SenderID, param1, param2);
+                        }
+                    }
+                    return true;
+
+                default:
+                    m_log.Error("EstateOwnerMessage: Unknown method requested\n" + messagePacket);
+                    return true;
+            }
+
+            //int parcelID, uint reportType, uint requestflags, string filter
+
+            //lsrp.RequestData.ParcelLocalID;
+            //lsrp.RequestData.ReportType; // 1 = colliders, 0 = scripts
+            //lsrp.RequestData.RequestFlags;
+            //lsrp.RequestData.Filter;
+
+//            return true;
+        }
+        
+        private bool HandleRequestRegionInfo(IClientAPI sender, Packet Pack)
+        {
+            RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (mPacket.SessionID != SessionId ||
+                    mPacket.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RegionInfoRequest handlerRegionInfoRequest = OnRegionInfoRequest;
+            if (handlerRegionInfoRequest != null)
+            {
+                handlerRegionInfoRequest(this);
+            }
+            return true;
+        }
+        
+        private bool HandleEstateCovenantRequest(IClientAPI sender, Packet Pack)
+        {
+
+            //EstateCovenantRequestPacket.AgentDataBlock epack =
+            //     ((EstateCovenantRequestPacket)Pack).AgentData;
+
+            EstateCovenantRequest handlerEstateCovenantRequest = OnEstateCovenantRequest;
+            if (handlerEstateCovenantRequest != null)
+            {
+                handlerEstateCovenantRequest(this);
+            }
+            return true;
+
+        }
+
+        #endregion Estate Packets
+
+        #region GodPackets
+
+        private bool HandleRequestGodlikePowers(IClientAPI sender, Packet Pack)
+        {
+            RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack;
+            RequestGodlikePowersPacket.RequestBlockBlock rblock = rglpPack.RequestBlock;
+            UUID token = rblock.Token;
+
+            RequestGodlikePowersPacket.AgentDataBlock ablock = rglpPack.AgentData;
+
+            RequestGodlikePowers handlerReqGodlikePowers = OnRequestGodlikePowers;
+
+            if (handlerReqGodlikePowers != null)
+            {
+                handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike, this);
+            }
+
+            return true;
+        }
+        private bool HandleGodKickUser(IClientAPI sender, Packet Pack)
+        {
+            GodKickUserPacket gkupack = (GodKickUserPacket)Pack;
+
+            if (gkupack.UserInfo.GodSessionID == SessionId && AgentId == gkupack.UserInfo.GodID)
+            {
+                GodKickUser handlerGodKickUser = OnGodKickUser;
+                if (handlerGodKickUser != null)
+                {
+                    handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID,
+                                       gkupack.UserInfo.AgentID, (uint)0, gkupack.UserInfo.Reason);
+                }
+            }
+            else
+            {
+                SendAgentAlertMessage("Kick request denied", false);
+            }
+            //KickUserPacket kupack = new KickUserPacket();
+            //KickUserPacket.UserInfoBlock kupackib = kupack.UserInfo;
+
+            //kupack.UserInfo.AgentID = gkupack.UserInfo.AgentID;
+            //kupack.UserInfo.SessionID = gkupack.UserInfo.GodSessionID;
+
+            //kupack.TargetBlock.TargetIP = (uint)0;
+            //kupack.TargetBlock.TargetPort = (ushort)0;
+            //kupack.UserInfo.Reason = gkupack.UserInfo.Reason;
+
+            //OutPacket(kupack, ThrottleOutPacketType.Task);
+            return true;
+        }
+        #endregion GodPackets
+
+        #region Economy/Transaction Packets
+
+        private bool HandleMoneyBalanceRequest(IClientAPI sender, Packet Pack)
+        {
+            MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moneybalancerequestpacket.AgentData.SessionID != SessionId ||
+                    moneybalancerequestpacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoneyBalanceRequest handlerMoneyBalanceRequest = OnMoneyBalanceRequest;
+
+            if (handlerMoneyBalanceRequest != null)
+            {
+                handlerMoneyBalanceRequest(this, moneybalancerequestpacket.AgentData.AgentID, moneybalancerequestpacket.AgentData.SessionID, moneybalancerequestpacket.MoneyData.TransactionID);
+            }
+
+            return true;
+        }
+        private bool HandleEconomyDataRequest(IClientAPI sender, Packet Pack)
+        {
+            EconomyDataRequest handlerEconomoyDataRequest = OnEconomyDataRequest;
+            if (handlerEconomoyDataRequest != null)
+            {
+                handlerEconomoyDataRequest(AgentId);
+            }
+            return true;
+        }
+        private bool HandleRequestPayPrice(IClientAPI sender, Packet Pack)
+        {
+            RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack;
+
+            RequestPayPrice handlerRequestPayPrice = OnRequestPayPrice;
+            if (handlerRequestPayPrice != null)
+            {
+                handlerRequestPayPrice(this, requestPayPricePacket.ObjectData.ObjectID);
+            }
+            return true;
+        }
+        private bool HandleObjectSaleInfo(IClientAPI sender, Packet Pack)
+        {
+            ObjectSaleInfoPacket objectSaleInfoPacket = (ObjectSaleInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectSaleInfoPacket.AgentData.SessionID != SessionId ||
+                    objectSaleInfoPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectSaleInfo handlerObjectSaleInfo = OnObjectSaleInfo;
+            if (handlerObjectSaleInfo != null)
+            {
+                foreach (ObjectSaleInfoPacket.ObjectDataBlock d
+                    in objectSaleInfoPacket.ObjectData)
+                {
+                    handlerObjectSaleInfo(this,
+                                          objectSaleInfoPacket.AgentData.AgentID,
+                                          objectSaleInfoPacket.AgentData.SessionID,
+                                          d.LocalID,
+                                          d.SaleType,
+                                          d.SalePrice);
+                }
+            }
+            return true;
+        }
+        private bool HandleObjectBuy(IClientAPI sender, Packet Pack)
+        {
+            ObjectBuyPacket objectBuyPacket = (ObjectBuyPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectBuyPacket.AgentData.SessionID != SessionId ||
+                    objectBuyPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectBuy handlerObjectBuy = OnObjectBuy;
+
+            if (handlerObjectBuy != null)
+            {
+                foreach (ObjectBuyPacket.ObjectDataBlock d
+                    in objectBuyPacket.ObjectData)
+                {
+                    handlerObjectBuy(this,
+                                     objectBuyPacket.AgentData.AgentID,
+                                     objectBuyPacket.AgentData.SessionID,
+                                     objectBuyPacket.AgentData.GroupID,
+                                     objectBuyPacket.AgentData.CategoryID,
+                                     d.ObjectLocalID,
+                                     d.SaleType,
+                                     d.SalePrice);
+                }
+            }
+            return true;
+        }
+        
+        #endregion Economy/Transaction Packets
+
+        #region Script Packets
+        private bool HandleGetScriptRunning(IClientAPI sender, Packet Pack)
+        {
+            GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack;
+
+            GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning;
+            if (handlerGetScriptRunning != null)
+            {
+                handlerGetScriptRunning(this, scriptRunning.Script.ObjectID, scriptRunning.Script.ItemID);
+            }
+            return true;
+        }
+        private bool HandleSetScriptRunning(IClientAPI sender, Packet Pack)
+        {
+            SetScriptRunningPacket setScriptRunning = (SetScriptRunningPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (setScriptRunning.AgentData.SessionID != SessionId ||
+                    setScriptRunning.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetScriptRunning handlerSetScriptRunning = OnSetScriptRunning;
+            if (handlerSetScriptRunning != null)
+            {
+                handlerSetScriptRunning(this, setScriptRunning.Script.ObjectID, setScriptRunning.Script.ItemID, setScriptRunning.Script.Running);
+            }
+            return true;
+        }
+
+        private bool HandleScriptReset(IClientAPI sender, Packet Pack)
+        {
+            ScriptResetPacket scriptResetPacket = (ScriptResetPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scriptResetPacket.AgentData.SessionID != SessionId ||
+                    scriptResetPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ScriptReset handlerScriptReset = OnScriptReset;
+            if (handlerScriptReset != null)
+            {
+                handlerScriptReset(this, scriptResetPacket.Script.ObjectID, scriptResetPacket.Script.ItemID);
+            }
+            return true;
+        }
+
+        #endregion Script Packets
+
+        #region Gesture Managment
+
+        private bool HandleActivateGestures(IClientAPI sender, Packet Pack)
+        {
+            ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (activateGesturePacket.AgentData.SessionID != SessionId ||
+                    activateGesturePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ActivateGesture handlerActivateGesture = OnActivateGesture;
+            if (handlerActivateGesture != null)
+            {
+                handlerActivateGesture(this,
+                                       activateGesturePacket.Data[0].AssetID,
+                                       activateGesturePacket.Data[0].ItemID);
+            }
+            else m_log.Error("Null pointer for activateGesture");
+
+            return true;
+        }
+        private bool HandleDeactivateGestures(IClientAPI sender, Packet Pack)
+        {
+            DeactivateGesturesPacket deactivateGesturePacket = (DeactivateGesturesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (deactivateGesturePacket.AgentData.SessionID != SessionId ||
+                    deactivateGesturePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeactivateGesture handlerDeactivateGesture = OnDeactivateGesture;
+            if (handlerDeactivateGesture != null)
+            {
+                handlerDeactivateGesture(this, deactivateGesturePacket.Data[0].ItemID);
+            }
+            return true;
+        }
+        private bool HandleObjectOwner(IClientAPI sender, Packet Pack)
+        {
+            ObjectOwnerPacket objectOwnerPacket = (ObjectOwnerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectOwnerPacket.AgentData.SessionID != SessionId ||
+                    objectOwnerPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<uint> localIDs = new List<uint>();
+
+            foreach (ObjectOwnerPacket.ObjectDataBlock d in objectOwnerPacket.ObjectData)
+                localIDs.Add(d.ObjectLocalID);
+
+            ObjectOwner handlerObjectOwner = OnObjectOwner;
+            if (handlerObjectOwner != null)
+            {
+                handlerObjectOwner(this, objectOwnerPacket.HeaderData.OwnerID, objectOwnerPacket.HeaderData.GroupID, localIDs);
+            }
+            return true;
+        }
+
+        #endregion Gesture Managment
+
+        private bool HandleAgentFOV(IClientAPI sender, Packet Pack)
+        {
+            AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;
+
+            if (fovPacket.FOVBlock.GenCounter > m_agentFOVCounter)
+            {
+                m_agentFOVCounter = fovPacket.FOVBlock.GenCounter;
+                AgentFOV handlerAgentFOV = OnAgentFOV;
+                if (handlerAgentFOV != null)
+                {
+                    handlerAgentFOV(this, fovPacket.FOVBlock.VerticalAngle);
+                }
+            }
+            return true;
+        }
+
+        #region unimplemented handlers
+
+        private bool HandleViewerStats(IClientAPI sender, Packet Pack)
+        {
+            // TODO: handle this packet
+            //m_log.Warn("[CLIENT]: unhandled ViewerStats packet");
+            return true;
+        }
+
+        private bool HandleMapItemRequest(IClientAPI sender, Packet Pack)
+        {
+            MapItemRequestPacket mirpk = (MapItemRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (mirpk.AgentData.SessionID != SessionId ||
+                    mirpk.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            //m_log.Debug(mirpk.ToString());
+            MapItemRequest handlerMapItemRequest = OnMapItemRequest;
+            if (handlerMapItemRequest != null)
+            {
+                handlerMapItemRequest(this, mirpk.AgentData.Flags, mirpk.AgentData.EstateID,
+                                      mirpk.AgentData.Godlike, mirpk.RequestData.ItemType,
+                                      mirpk.RequestData.RegionHandle);
+
+            }
+            return true;
+        }
+
+        private bool HandleTransferAbort(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        private bool HandleMuteListRequest(IClientAPI sender, Packet Pack)
+        {
+            MuteListRequestPacket muteListRequest =
+                            (MuteListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (muteListRequest.AgentData.SessionID != SessionId ||
+                    muteListRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MuteListRequest handlerMuteListRequest = OnMuteListRequest;
+            if (handlerMuteListRequest != null)
+            {
+                handlerMuteListRequest(this, muteListRequest.MuteData.MuteCRC);
+            }
+            else
+            {
+                SendUseCachedMuteList();
+            }
+            return true;
+        }
+
+        private bool HandleUseCircuitCode(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        private bool HandleAgentHeightWidth(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        private bool HandleInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        #endregion unimplemented handlers
+
+        #region Dir handlers
+
+        private bool HandleDirPlacesQuery(IClientAPI sender, Packet Pack)
+        {
+            DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;
+            //m_log.Debug(dirPlacesQueryPacket.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirPlacesQueryPacket.AgentData.SessionID != SessionId ||
+                    dirPlacesQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirPlacesQuery handlerDirPlacesQuery = OnDirPlacesQuery;
+            if (handlerDirPlacesQuery != null)
+            {
+                handlerDirPlacesQuery(this,
+                                      dirPlacesQueryPacket.QueryData.QueryID,
+                                      Utils.BytesToString(
+                                          dirPlacesQueryPacket.QueryData.QueryText),
+                                      (int)dirPlacesQueryPacket.QueryData.QueryFlags,
+                                      (int)dirPlacesQueryPacket.QueryData.Category,
+                                      Utils.BytesToString(
+                                          dirPlacesQueryPacket.QueryData.SimName),
+                                      dirPlacesQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirFindQuery(IClientAPI sender, Packet Pack)
+        {
+            DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirFindQueryPacket.AgentData.SessionID != SessionId ||
+                    dirFindQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirFindQuery handlerDirFindQuery = OnDirFindQuery;
+            if (handlerDirFindQuery != null)
+            {
+                handlerDirFindQuery(this,
+                                    dirFindQueryPacket.QueryData.QueryID,
+                                    Utils.BytesToString(
+                                        dirFindQueryPacket.QueryData.QueryText),
+                                    dirFindQueryPacket.QueryData.QueryFlags,
+                                    dirFindQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirLandQuery(IClientAPI sender, Packet Pack)
+        {
+            DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirLandQueryPacket.AgentData.SessionID != SessionId ||
+                    dirLandQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirLandQuery handlerDirLandQuery = OnDirLandQuery;
+            if (handlerDirLandQuery != null)
+            {
+                handlerDirLandQuery(this,
+                                    dirLandQueryPacket.QueryData.QueryID,
+                                    dirLandQueryPacket.QueryData.QueryFlags,
+                                    dirLandQueryPacket.QueryData.SearchType,
+                                    dirLandQueryPacket.QueryData.Price,
+                                    dirLandQueryPacket.QueryData.Area,
+                                    dirLandQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirPopularQuery(IClientAPI sender, Packet Pack)
+        {
+            DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirPopularQueryPacket.AgentData.SessionID != SessionId ||
+                    dirPopularQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirPopularQuery handlerDirPopularQuery = OnDirPopularQuery;
+            if (handlerDirPopularQuery != null)
+            {
+                handlerDirPopularQuery(this,
+                                       dirPopularQueryPacket.QueryData.QueryID,
+                                       dirPopularQueryPacket.QueryData.QueryFlags);
+            }
+            return true;
+        }
+
+        private bool HandleDirClassifiedQuery(IClientAPI sender, Packet Pack)
+        {
+            DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirClassifiedQueryPacket.AgentData.SessionID != SessionId ||
+                    dirClassifiedQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirClassifiedQuery handlerDirClassifiedQuery = OnDirClassifiedQuery;
+            if (handlerDirClassifiedQuery != null)
+            {
+                handlerDirClassifiedQuery(this,
+                                          dirClassifiedQueryPacket.QueryData.QueryID,
+                                          Utils.BytesToString(
+                                              dirClassifiedQueryPacket.QueryData.QueryText),
+                                          dirClassifiedQueryPacket.QueryData.QueryFlags,
+                                          dirClassifiedQueryPacket.QueryData.Category,
+                                          dirClassifiedQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleEventInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventInfoRequestPacket.AgentData.SessionID != SessionId ||
+                    eventInfoRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnEventInfoRequest != null)
+            {
+                OnEventInfoRequest(this, eventInfoRequestPacket.EventData.EventID);
+            }
+            return true;
+        }
+
+        #endregion
+
+        #region Calling Card
+
+        private bool HandleOfferCallingCard(IClientAPI sender, Packet Pack)
+        {
+            OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (offerCallingCardPacket.AgentData.SessionID != SessionId ||
+                    offerCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnOfferCallingCard != null)
+            {
+                OnOfferCallingCard(this,
+                                   offerCallingCardPacket.AgentBlock.DestID,
+                                   offerCallingCardPacket.AgentBlock.TransactionID);
+            }
+            return true;
+        }
+
+        private bool HandleAcceptCallingCard(IClientAPI sender, Packet Pack)
+        {
+            AcceptCallingCardPacket acceptCallingCardPacket = (AcceptCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (acceptCallingCardPacket.AgentData.SessionID != SessionId ||
+                    acceptCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // according to http://wiki.secondlife.com/wiki/AcceptCallingCard FolderData should
+            // contain exactly one entry
+            if (OnAcceptCallingCard != null && acceptCallingCardPacket.FolderData.Length > 0)
+            {
+                OnAcceptCallingCard(this,
+                                    acceptCallingCardPacket.TransactionBlock.TransactionID,
+                                    acceptCallingCardPacket.FolderData[0].FolderID);
+            }
+            return true;
+        }
+
+        private bool HandleDeclineCallingCard(IClientAPI sender, Packet Pack)
+        {
+            DeclineCallingCardPacket declineCallingCardPacket = (DeclineCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (declineCallingCardPacket.AgentData.SessionID != SessionId ||
+                    declineCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnDeclineCallingCard != null)
+            {
+                OnDeclineCallingCard(this,
+                                     declineCallingCardPacket.TransactionBlock.TransactionID);
+            }
+            return true;
+        }
+
+        #endregion Calling Card
+
+        #region Groups
+
+        private bool HandleActivateGroup(IClientAPI sender, Packet Pack)
+        {
+            ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (activateGroupPacket.AgentData.SessionID != SessionId ||
+                    activateGroupPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID);
+                m_GroupsModule.SendAgentGroupDataUpdate(this);
+            }
+            return true;
+
+        }
+
+        private bool HandleGroupTitlesRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupTitlesRequestPacket groupTitlesRequest =
+                            (GroupTitlesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupTitlesRequest.AgentData.SessionID != SessionId ||
+                    groupTitlesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupTitlesReplyPacket groupTitlesReply = (GroupTitlesReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupTitlesReply);
+
+                groupTitlesReply.AgentData =
+                    new GroupTitlesReplyPacket.AgentDataBlock();
+
+                groupTitlesReply.AgentData.AgentID = AgentId;
+                groupTitlesReply.AgentData.GroupID =
+                    groupTitlesRequest.AgentData.GroupID;
+
+                groupTitlesReply.AgentData.RequestID =
+                    groupTitlesRequest.AgentData.RequestID;
+
+                List<GroupTitlesData> titles =
+                    m_GroupsModule.GroupTitlesRequest(this,
+                                                      groupTitlesRequest.AgentData.GroupID);
+
+                groupTitlesReply.GroupData =
+                    new GroupTitlesReplyPacket.GroupDataBlock[titles.Count];
+
+                int i = 0;
+                foreach (GroupTitlesData d in titles)
+                {
+                    groupTitlesReply.GroupData[i] =
+                        new GroupTitlesReplyPacket.GroupDataBlock();
+
+                    groupTitlesReply.GroupData[i].Title =
+                        Util.StringToBytes256(d.Name);
+                    groupTitlesReply.GroupData[i].RoleID =
+                        d.UUID;
+                    groupTitlesReply.GroupData[i].Selected =
+                        d.Selected;
+                    i++;
+                }
+
+                OutPacket(groupTitlesReply, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+        private bool HandleGroupProfileRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupProfileRequestPacket groupProfileRequest =
+                       (GroupProfileRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupProfileRequest.AgentData.SessionID != SessionId ||
+                    groupProfileRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);
+
+                groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();
+                groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();
+                groupProfileReply.AgentData.AgentID = AgentId;
+
+                GroupProfileData d = m_GroupsModule.GroupProfileRequest(this,
+                                                                        groupProfileRequest.GroupData.GroupID);
+
+                groupProfileReply.GroupData.GroupID = d.GroupID;
+                groupProfileReply.GroupData.Name = Util.StringToBytes256(d.Name);
+                groupProfileReply.GroupData.Charter = Util.StringToBytes1024(d.Charter);
+                groupProfileReply.GroupData.ShowInList = d.ShowInList;
+                groupProfileReply.GroupData.MemberTitle = Util.StringToBytes256(d.MemberTitle);
+                groupProfileReply.GroupData.PowersMask = d.PowersMask;
+                groupProfileReply.GroupData.InsigniaID = d.InsigniaID;
+                groupProfileReply.GroupData.FounderID = d.FounderID;
+                groupProfileReply.GroupData.MembershipFee = d.MembershipFee;
+                groupProfileReply.GroupData.OpenEnrollment = d.OpenEnrollment;
+                groupProfileReply.GroupData.Money = d.Money;
+                groupProfileReply.GroupData.GroupMembershipCount = d.GroupMembershipCount;
+                groupProfileReply.GroupData.GroupRolesCount = d.GroupRolesCount;
+                groupProfileReply.GroupData.AllowPublish = d.AllowPublish;
+                groupProfileReply.GroupData.MaturePublish = d.MaturePublish;
+                groupProfileReply.GroupData.OwnerRole = d.OwnerRole;
+
+                OutPacket(groupProfileReply, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+        private bool HandleGroupMembersRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupMembersRequestPacket groupMembersRequestPacket =
+                        (GroupMembersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupMembersRequestPacket.AgentData.SessionID != SessionId ||
+                    groupMembersRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                List<GroupMembersData> members =
+                    m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID);
+
+                int memberCount = members.Count;
+
+                while (true)
+                {
+                    int blockCount = members.Count;
+                    if (blockCount > 40)
+                        blockCount = 40;
+
+                    GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply);
+
+                    groupMembersReply.AgentData =
+                        new GroupMembersReplyPacket.AgentDataBlock();
+                    groupMembersReply.GroupData =
+                        new GroupMembersReplyPacket.GroupDataBlock();
+                    groupMembersReply.MemberData =
+                        new GroupMembersReplyPacket.MemberDataBlock[
+                            blockCount];
+
+                    groupMembersReply.AgentData.AgentID = AgentId;
+                    groupMembersReply.GroupData.GroupID =
+                        groupMembersRequestPacket.GroupData.GroupID;
+                    groupMembersReply.GroupData.RequestID =
+                        groupMembersRequestPacket.GroupData.RequestID;
+                    groupMembersReply.GroupData.MemberCount = memberCount;
+
+                    for (int i = 0; i < blockCount; i++)
+                    {
+                        GroupMembersData m = members[0];
+                        members.RemoveAt(0);
+
+                        groupMembersReply.MemberData[i] =
+                            new GroupMembersReplyPacket.MemberDataBlock();
+                        groupMembersReply.MemberData[i].AgentID =
+                            m.AgentID;
+                        groupMembersReply.MemberData[i].Contribution =
+                            m.Contribution;
+                        groupMembersReply.MemberData[i].OnlineStatus =
+                            Util.StringToBytes256(m.OnlineStatus);
+                        groupMembersReply.MemberData[i].AgentPowers =
+                            m.AgentPowers;
+                        groupMembersReply.MemberData[i].Title =
+                            Util.StringToBytes256(m.Title);
+                        groupMembersReply.MemberData[i].IsOwner =
+                            m.IsOwner;
+                    }
+                    OutPacket(groupMembersReply, ThrottleOutPacketType.Task);
+                    if (members.Count == 0)
+                        return true;
+                }
+            }
+            return true;
+        }
+        private bool HandleGroupRoleDataRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleDataRequestPacket groupRolesRequest =
+                        (GroupRoleDataRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRolesRequest.AgentData.SessionID != SessionId ||
+                    groupRolesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupRoleDataReplyPacket groupRolesReply = (GroupRoleDataReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleDataReply);
+
+                groupRolesReply.AgentData =
+                    new GroupRoleDataReplyPacket.AgentDataBlock();
+
+                groupRolesReply.AgentData.AgentID = AgentId;
+
+                groupRolesReply.GroupData =
+                    new GroupRoleDataReplyPacket.GroupDataBlock();
+
+                groupRolesReply.GroupData.GroupID =
+                    groupRolesRequest.GroupData.GroupID;
+
+                groupRolesReply.GroupData.RequestID =
+                    groupRolesRequest.GroupData.RequestID;
+
+                List<GroupRolesData> titles =
+                    m_GroupsModule.GroupRoleDataRequest(this,
+                                                        groupRolesRequest.GroupData.GroupID);
+
+                groupRolesReply.GroupData.RoleCount =
+                    titles.Count;
+
+                groupRolesReply.RoleData =
+                    new GroupRoleDataReplyPacket.RoleDataBlock[titles.Count];
+
+                int i = 0;
+                foreach (GroupRolesData d in titles)
+                {
+                    groupRolesReply.RoleData[i] =
+                        new GroupRoleDataReplyPacket.RoleDataBlock();
+
+                    groupRolesReply.RoleData[i].RoleID =
+                        d.RoleID;
+                    groupRolesReply.RoleData[i].Name =
+                        Util.StringToBytes256(d.Name);
+                    groupRolesReply.RoleData[i].Title =
+                        Util.StringToBytes256(d.Title);
+                    groupRolesReply.RoleData[i].Description =
+                        Util.StringToBytes1024(d.Description);
+                    groupRolesReply.RoleData[i].Powers =
+                        d.Powers;
+                    groupRolesReply.RoleData[i].Members =
+                        (uint)d.Members;
+
+                    i++;
+                }
+
+                OutPacket(groupRolesReply, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+        private bool HandleGroupRoleMembersRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleMembersRequestPacket groupRoleMembersRequest =
+                       (GroupRoleMembersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleMembersRequest.AgentData.SessionID != SessionId ||
+                    groupRoleMembersRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                List<GroupRoleMembersData> mappings =
+                        m_GroupsModule.GroupRoleMembersRequest(this,
+                        groupRoleMembersRequest.GroupData.GroupID);
+
+                int mappingsCount = mappings.Count;
+
+                while (mappings.Count > 0)
+                {
+                    int pairs = mappings.Count;
+                    if (pairs > 32)
+                        pairs = 32;
+
+                    GroupRoleMembersReplyPacket groupRoleMembersReply = (GroupRoleMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleMembersReply);
+                    groupRoleMembersReply.AgentData =
+                            new GroupRoleMembersReplyPacket.AgentDataBlock();
+                    groupRoleMembersReply.AgentData.AgentID =
+                            AgentId;
+                    groupRoleMembersReply.AgentData.GroupID =
+                            groupRoleMembersRequest.GroupData.GroupID;
+                    groupRoleMembersReply.AgentData.RequestID =
+                            groupRoleMembersRequest.GroupData.RequestID;
+
+                    groupRoleMembersReply.AgentData.TotalPairs =
+                            (uint)mappingsCount;
+
+                    groupRoleMembersReply.MemberData =
+                            new GroupRoleMembersReplyPacket.MemberDataBlock[pairs];
+
+                    for (int i = 0; i < pairs; i++)
+                    {
+                        GroupRoleMembersData d = mappings[0];
+                        mappings.RemoveAt(0);
+
+                        groupRoleMembersReply.MemberData[i] =
+                            new GroupRoleMembersReplyPacket.MemberDataBlock();
+
+                        groupRoleMembersReply.MemberData[i].RoleID =
+                                d.RoleID;
+                        groupRoleMembersReply.MemberData[i].MemberID =
+                                d.MemberID;
+                    }
+
+                    OutPacket(groupRoleMembersReply, ThrottleOutPacketType.Task);
+                }
+            }
+            return true;
+        }
+        private bool HandleCreateGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            CreateGroupRequestPacket createGroupRequest =
+                       (CreateGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createGroupRequest.AgentData.SessionID != SessionId ||
+                    createGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.CreateGroup(this,
+                                           Utils.BytesToString(createGroupRequest.GroupData.Name),
+                                           Utils.BytesToString(createGroupRequest.GroupData.Charter),
+                                           createGroupRequest.GroupData.ShowInList,
+                                           createGroupRequest.GroupData.InsigniaID,
+                                           createGroupRequest.GroupData.MembershipFee,
+                                           createGroupRequest.GroupData.OpenEnrollment,
+                                           createGroupRequest.GroupData.AllowPublish,
+                                           createGroupRequest.GroupData.MaturePublish);
+            }
+            return true;
+        }
+        private bool HandleUpdateGroupInfo(IClientAPI sender, Packet Pack)
+        {
+            UpdateGroupInfoPacket updateGroupInfo =
+                        (UpdateGroupInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updateGroupInfo.AgentData.SessionID != SessionId ||
+                    updateGroupInfo.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.UpdateGroupInfo(this,
+                                               updateGroupInfo.GroupData.GroupID,
+                                               Utils.BytesToString(updateGroupInfo.GroupData.Charter),
+                                               updateGroupInfo.GroupData.ShowInList,
+                                               updateGroupInfo.GroupData.InsigniaID,
+                                               updateGroupInfo.GroupData.MembershipFee,
+                                               updateGroupInfo.GroupData.OpenEnrollment,
+                                               updateGroupInfo.GroupData.AllowPublish,
+                                               updateGroupInfo.GroupData.MaturePublish);
+            }
+
+            return true;
+        }
+        private bool HandleSetGroupAcceptNotices(IClientAPI sender, Packet Pack)
+        {
+            SetGroupAcceptNoticesPacket setGroupAcceptNotices =
+                        (SetGroupAcceptNoticesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (setGroupAcceptNotices.AgentData.SessionID != SessionId ||
+                    setGroupAcceptNotices.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.SetGroupAcceptNotices(this,
+                                                     setGroupAcceptNotices.Data.GroupID,
+                                                     setGroupAcceptNotices.Data.AcceptNotices,
+                                                     setGroupAcceptNotices.NewData.ListInProfile);
+            }
+
+            return true;
+        }
+        private bool HandleGroupTitleUpdate(IClientAPI sender, Packet Pack)
+        {
+            GroupTitleUpdatePacket groupTitleUpdate =
+                        (GroupTitleUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupTitleUpdate.AgentData.SessionID != SessionId ||
+                    groupTitleUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.GroupTitleUpdate(this,
+                                                groupTitleUpdate.AgentData.GroupID,
+                                                groupTitleUpdate.AgentData.TitleRoleID);
+            }
+
+            return true;
+        }
+        private bool HandleParcelDeedToGroup(IClientAPI sender, Packet Pack)
+        {
+            ParcelDeedToGroupPacket parcelDeedToGroup = (ParcelDeedToGroupPacket)Pack;
+            if (m_GroupsModule != null)
+            {
+                ParcelDeedToGroup handlerParcelDeedToGroup = OnParcelDeedToGroup;
+                if (handlerParcelDeedToGroup != null)
+                {
+                    handlerParcelDeedToGroup(parcelDeedToGroup.Data.LocalID, parcelDeedToGroup.Data.GroupID, this);
+
+                }
+            }
+
+            return true;
+        }
+        private bool HandleGroupNoticesListRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupNoticesListRequestPacket groupNoticesListRequest =
+                        (GroupNoticesListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupNoticesListRequest.AgentData.SessionID != SessionId ||
+                    groupNoticesListRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupNoticeData[] gn =
+                    m_GroupsModule.GroupNoticesListRequest(this,
+                                                           groupNoticesListRequest.Data.GroupID);
+
+                GroupNoticesListReplyPacket groupNoticesListReply = (GroupNoticesListReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupNoticesListReply);
+                groupNoticesListReply.AgentData =
+                    new GroupNoticesListReplyPacket.AgentDataBlock();
+                groupNoticesListReply.AgentData.AgentID = AgentId;
+                groupNoticesListReply.AgentData.GroupID = groupNoticesListRequest.Data.GroupID;
+
+                groupNoticesListReply.Data = new GroupNoticesListReplyPacket.DataBlock[gn.Length];
+
+                int i = 0;
+                foreach (GroupNoticeData g in gn)
+                {
+                    groupNoticesListReply.Data[i] = new GroupNoticesListReplyPacket.DataBlock();
+                    groupNoticesListReply.Data[i].NoticeID =
+                        g.NoticeID;
+                    groupNoticesListReply.Data[i].Timestamp =
+                        g.Timestamp;
+                    groupNoticesListReply.Data[i].FromName =
+                        Util.StringToBytes256(g.FromName);
+                    groupNoticesListReply.Data[i].Subject =
+                        Util.StringToBytes256(g.Subject);
+                    groupNoticesListReply.Data[i].HasAttachment =
+                        g.HasAttachment;
+                    groupNoticesListReply.Data[i].AssetType =
+                        g.AssetType;
+                    i++;
+                }
+
+                OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);
+            }
+
+            return true;
+        }
+        private bool HandleGroupNoticeRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupNoticeRequestPacket groupNoticeRequest =
+                        (GroupNoticeRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupNoticeRequest.AgentData.SessionID != SessionId ||
+                    groupNoticeRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.GroupNoticeRequest(this,
+                                                  groupNoticeRequest.Data.GroupNoticeID);
+            }
+            return true;
+        }
+        private bool HandleGroupRoleUpdate(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleUpdatePacket groupRoleUpdate =
+                        (GroupRoleUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleUpdate.AgentData.SessionID != SessionId ||
+                    groupRoleUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (GroupRoleUpdatePacket.RoleDataBlock d in
+                    groupRoleUpdate.RoleData)
+                {
+                    m_GroupsModule.GroupRoleUpdate(this,
+                                                   groupRoleUpdate.AgentData.GroupID,
+                                                   d.RoleID,
+                                                   Utils.BytesToString(d.Name),
+                                                   Utils.BytesToString(d.Description),
+                                                   Utils.BytesToString(d.Title),
+                                                   d.Powers,
+                                                   d.UpdateType);
+                }
+                m_GroupsModule.NotifyChange(groupRoleUpdate.AgentData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleGroupRoleChanges(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleChangesPacket groupRoleChanges =
+                        (GroupRoleChangesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleChanges.AgentData.SessionID != SessionId ||
+                    groupRoleChanges.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (GroupRoleChangesPacket.RoleChangeBlock d in
+                    groupRoleChanges.RoleChange)
+                {
+                    m_GroupsModule.GroupRoleChanges(this,
+                                                    groupRoleChanges.AgentData.GroupID,
+                                                    d.RoleID,
+                                                    d.MemberID,
+                                                    d.Change);
+                }
+                m_GroupsModule.NotifyChange(groupRoleChanges.AgentData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleJoinGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            JoinGroupRequestPacket joinGroupRequest =
+                        (JoinGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (joinGroupRequest.AgentData.SessionID != SessionId ||
+                    joinGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.JoinGroupRequest(this,
+                        joinGroupRequest.GroupData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleLeaveGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            LeaveGroupRequestPacket leaveGroupRequest =
+                        (LeaveGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (leaveGroupRequest.AgentData.SessionID != SessionId ||
+                    leaveGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.LeaveGroupRequest(this,
+                        leaveGroupRequest.GroupData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleEjectGroupMemberRequest(IClientAPI sender, Packet Pack)
+        {
+            EjectGroupMemberRequestPacket ejectGroupMemberRequest =
+                       (EjectGroupMemberRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ejectGroupMemberRequest.AgentData.SessionID != SessionId ||
+                    ejectGroupMemberRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (EjectGroupMemberRequestPacket.EjectDataBlock e
+                        in ejectGroupMemberRequest.EjectData)
+                {
+                    m_GroupsModule.EjectGroupMemberRequest(this,
+                            ejectGroupMemberRequest.GroupData.GroupID,
+                            e.EjecteeID);
+                }
+            }
+            return true;
+        }
+        private bool HandleInviteGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            InviteGroupRequestPacket inviteGroupRequest =
+                        (InviteGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inviteGroupRequest.AgentData.SessionID != SessionId ||
+                    inviteGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (InviteGroupRequestPacket.InviteDataBlock b in
+                        inviteGroupRequest.InviteData)
+                {
+                    m_GroupsModule.InviteGroupRequest(this,
+                            inviteGroupRequest.GroupData.GroupID,
+                            b.InviteeID,
+                            b.RoleID);
+                }
+            }
+            return true;
+        }
+
+        #endregion Groups
+
+        private bool HandleStartLure(IClientAPI sender, Packet Pack)
+        {
+            StartLurePacket startLureRequest = (StartLurePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (startLureRequest.AgentData.SessionID != SessionId ||
+                    startLureRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            StartLure handlerStartLure = OnStartLure;
+            if (handlerStartLure != null)
+                handlerStartLure(startLureRequest.Info.LureType,
+                                 Utils.BytesToString(
+                                    startLureRequest.Info.Message),
+                                 startLureRequest.TargetData[0].TargetID,
+                                 this);
+            return true;
+        }
+        private bool HandleTeleportLureRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLureRequestPacket teleportLureRequest =
+                            (TeleportLureRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (teleportLureRequest.Info.SessionID != SessionId ||
+                    teleportLureRequest.Info.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            TeleportLureRequest handlerTeleportLureRequest = OnTeleportLureRequest;
+            if (handlerTeleportLureRequest != null)
+                handlerTeleportLureRequest(
+                         teleportLureRequest.Info.LureID,
+                         teleportLureRequest.Info.TeleportFlags,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedInfoRequestPacket classifiedInfoRequest =
+                            (ClassifiedInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedInfoRequest.AgentData.SessionID != SessionId ||
+                    classifiedInfoRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedInfoRequest handlerClassifiedInfoRequest = OnClassifiedInfoRequest;
+            if (handlerClassifiedInfoRequest != null)
+                handlerClassifiedInfoRequest(
+                         classifiedInfoRequest.Data.ClassifiedID,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedInfoUpdate(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedInfoUpdatePacket classifiedInfoUpdate =
+                            (ClassifiedInfoUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedInfoUpdate.AgentData.SessionID != SessionId ||
+                    classifiedInfoUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedInfoUpdate handlerClassifiedInfoUpdate = OnClassifiedInfoUpdate;
+            if (handlerClassifiedInfoUpdate != null)
+                handlerClassifiedInfoUpdate(
+                        classifiedInfoUpdate.Data.ClassifiedID,
+                        classifiedInfoUpdate.Data.Category,
+                        Utils.BytesToString(
+                                classifiedInfoUpdate.Data.Name),
+                        Utils.BytesToString(
+                                classifiedInfoUpdate.Data.Desc),
+                        classifiedInfoUpdate.Data.ParcelID,
+                        classifiedInfoUpdate.Data.ParentEstate,
+                        classifiedInfoUpdate.Data.SnapshotID,
+                        new Vector3(
+                            classifiedInfoUpdate.Data.PosGlobal),
+                        classifiedInfoUpdate.Data.ClassifiedFlags,
+                        classifiedInfoUpdate.Data.PriceForListing,
+                        this);
+            return true;
+        }
+        private bool HandleClassifiedDelete(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedDeletePacket classifiedDelete =
+                           (ClassifiedDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedDelete.AgentData.SessionID != SessionId ||
+                    classifiedDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedDelete handlerClassifiedDelete = OnClassifiedDelete;
+            if (handlerClassifiedDelete != null)
+                handlerClassifiedDelete(
+                         classifiedDelete.Data.ClassifiedID,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedGodDelete(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedGodDeletePacket classifiedGodDelete =
+                            (ClassifiedGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedGodDelete.AgentData.SessionID != SessionId ||
+                    classifiedGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;
+            if (handlerClassifiedGodDelete != null)
+                handlerClassifiedGodDelete(
+                         classifiedGodDelete.Data.ClassifiedID,
+                         this);
+            return true;
+        }
+        private bool HandleEventGodDelete(IClientAPI sender, Packet Pack)
+        {
+            EventGodDeletePacket eventGodDelete =
+                               (EventGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventGodDelete.AgentData.SessionID != SessionId ||
+                    eventGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventGodDelete handlerEventGodDelete = OnEventGodDelete;
+            if (handlerEventGodDelete != null)
+                handlerEventGodDelete(
+                        eventGodDelete.EventData.EventID,
+                        eventGodDelete.QueryData.QueryID,
+                        Utils.BytesToString(
+                                eventGodDelete.QueryData.QueryText),
+                        eventGodDelete.QueryData.QueryFlags,
+                        eventGodDelete.QueryData.QueryStart,
+                        this);
+            return true;
+        }
+        private bool HandleEventNotificationAddRequest(IClientAPI sender, Packet Pack)
+        {
+            EventNotificationAddRequestPacket eventNotificationAdd =
+                            (EventNotificationAddRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventNotificationAdd.AgentData.SessionID != SessionId ||
+                    eventNotificationAdd.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventNotificationAddRequest handlerEventNotificationAddRequest = OnEventNotificationAddRequest;
+            if (handlerEventNotificationAddRequest != null)
+                handlerEventNotificationAddRequest(
+                        eventNotificationAdd.EventData.EventID, this);
+            return true;
+        }
+        private bool HandleEventNotificationRemoveRequest(IClientAPI sender, Packet Pack)
+        {
+            EventNotificationRemoveRequestPacket eventNotificationRemove =
+                            (EventNotificationRemoveRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventNotificationRemove.AgentData.SessionID != SessionId ||
+                    eventNotificationRemove.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventNotificationRemoveRequest handlerEventNotificationRemoveRequest = OnEventNotificationRemoveRequest;
+            if (handlerEventNotificationRemoveRequest != null)
+                handlerEventNotificationRemoveRequest(
+                        eventNotificationRemove.EventData.EventID, this);
+            return true;
+        }
+        private bool HandleRetrieveInstantMessages(IClientAPI sender, Packet Pack)
+        {
+            RetrieveInstantMessagesPacket rimpInstantMessagePack = (RetrieveInstantMessagesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rimpInstantMessagePack.AgentData.SessionID != SessionId ||
+                    rimpInstantMessagePack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RetrieveInstantMessages handlerRetrieveInstantMessages = OnRetrieveInstantMessages;
+            if (handlerRetrieveInstantMessages != null)
+                handlerRetrieveInstantMessages(this);
+            return true;
+        }
+        private bool HandlePickDelete(IClientAPI sender, Packet Pack)
+        {
+            PickDeletePacket pickDelete =
+                            (PickDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickDelete.AgentData.SessionID != SessionId ||
+                    pickDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickDelete handlerPickDelete = OnPickDelete;
+            if (handlerPickDelete != null)
+                handlerPickDelete(this, pickDelete.Data.PickID);
+            return true;
+        }
+        private bool HandlePickGodDelete(IClientAPI sender, Packet Pack)
+        {
+            PickGodDeletePacket pickGodDelete =
+                           (PickGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickGodDelete.AgentData.SessionID != SessionId ||
+                    pickGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickGodDelete handlerPickGodDelete = OnPickGodDelete;
+            if (handlerPickGodDelete != null)
+                handlerPickGodDelete(this,
+                        pickGodDelete.AgentData.AgentID,
+                        pickGodDelete.Data.PickID,
+                        pickGodDelete.Data.QueryID);
+            return true;
+        }
+        private bool HandlePickInfoUpdate(IClientAPI sender, Packet Pack)
+        {
+            PickInfoUpdatePacket pickInfoUpdate =
+                            (PickInfoUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickInfoUpdate.AgentData.SessionID != SessionId ||
+                    pickInfoUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickInfoUpdate handlerPickInfoUpdate = OnPickInfoUpdate;
+            if (handlerPickInfoUpdate != null)
+                handlerPickInfoUpdate(this,
+                        pickInfoUpdate.Data.PickID,
+                        pickInfoUpdate.Data.CreatorID,
+                        pickInfoUpdate.Data.TopPick,
+                        Utils.BytesToString(pickInfoUpdate.Data.Name),
+                        Utils.BytesToString(pickInfoUpdate.Data.Desc),
+                        pickInfoUpdate.Data.SnapshotID,
+                        pickInfoUpdate.Data.SortOrder,
+                        pickInfoUpdate.Data.Enabled);
+            return true;
+        }
+        private bool HandleAvatarNotesUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarNotesUpdatePacket avatarNotesUpdate =
+                            (AvatarNotesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarNotesUpdate.AgentData.SessionID != SessionId ||
+                    avatarNotesUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarNotesUpdate handlerAvatarNotesUpdate = OnAvatarNotesUpdate;
+            if (handlerAvatarNotesUpdate != null)
+                handlerAvatarNotesUpdate(this,
+                        avatarNotesUpdate.Data.TargetID,
+                        Utils.BytesToString(avatarNotesUpdate.Data.Notes));
+            return true;
+        }
+        private bool HandleAvatarInterestsUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarInterestsUpdatePacket avatarInterestUpdate =
+                            (AvatarInterestsUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarInterestUpdate.AgentData.SessionID != SessionId ||
+                    avatarInterestUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;
+            if (handlerAvatarInterestUpdate != null)
+                handlerAvatarInterestUpdate(this,
+                    avatarInterestUpdate.PropertiesData.WantToMask,
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.WantToText),
+                    avatarInterestUpdate.PropertiesData.SkillsMask,
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText),
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));
+            return true;
+        }
+        private bool HandleGrantUserRights(IClientAPI sender, Packet Pack)
+        {
+            GrantUserRightsPacket GrantUserRights =
+                            (GrantUserRightsPacket)Pack;
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (GrantUserRights.AgentData.SessionID != SessionId ||
+                    GrantUserRights.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            GrantUserFriendRights GrantUserRightsHandler = OnGrantUserRights;
+            if (GrantUserRightsHandler != null)
+                GrantUserRightsHandler(this,
+                    GrantUserRights.AgentData.AgentID,
+                    GrantUserRights.Rights[0].AgentRelated,
+                    GrantUserRights.Rights[0].RelatedRights);
+            return true;
+        }
+        private bool HandlePlacesQuery(IClientAPI sender, Packet Pack)
+        {
+            PlacesQueryPacket placesQueryPacket =
+                            (PlacesQueryPacket)Pack;
+
+            PlacesQuery handlerPlacesQuery = OnPlacesQuery;
+
+            if (handlerPlacesQuery != null)
+                handlerPlacesQuery(placesQueryPacket.AgentData.QueryID,
+                        placesQueryPacket.TransactionData.TransactionID,
+                        Utils.BytesToString(
+                                placesQueryPacket.QueryData.QueryText),
+                        placesQueryPacket.QueryData.QueryFlags,
+                        (byte)placesQueryPacket.QueryData.Category,
+                        Utils.BytesToString(
+                                placesQueryPacket.QueryData.SimName),
+                        this);
+            return true;
+        }
 
         #endregion Packet Handlers
 
@@ -5732,15 +10311,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (ProcessPacketMethod(Pack))
             {
+                PacketPool.Instance.ReturnPacket(Pack);
                 return;
             }
 
             // Main packet processing conditional
             switch (Pack.Type)
             {
-                #region Scene/Avatar
                 #region CommentedOut
                 /*
+                #region Scene/Avatar
+                
+                
                 case PacketType.AvatarPropertiesRequest:
                     AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack;
 
@@ -6402,8 +10984,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     }
                     break;
-                */
-                #endregion
+
                 case PacketType.AvatarPickerRequest:
                     AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack;
 
@@ -6427,7 +11008,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                    Utils.BytesToString(querydata.Name));
                     }
                     break;
-
+                
                 case PacketType.AgentDataUpdateRequest:
                     AgentDataUpdateRequestPacket avRequestDataUpdatePacket = (AgentDataUpdateRequestPacket)Pack;
 
@@ -6547,7 +11128,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 #endregion
 
-                #region Objects/m_sceneObjects
+
+                //#region Objects/m_sceneObjects
 
                 case PacketType.ObjectLink:
                     ObjectLinkPacket link = (ObjectLinkPacket)Pack;
@@ -6706,6 +11288,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectDuplicate:
                     ObjectDuplicatePacket dupe = (ObjectDuplicatePacket)Pack;
 
@@ -6758,6 +11341,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectSelect:
                     ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;
 
@@ -6781,6 +11365,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectDeselect:
                     ObjectDeselectPacket incomingdeselect = (ObjectDeselectPacket)Pack;
 
@@ -6804,6 +11389,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectPosition:
                     // DEPRECATED: but till libsecondlife removes it, people will use it
                     ObjectPositionPacket position = (ObjectPositionPacket)Pack;
@@ -6826,6 +11412,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.ObjectScale:
                     // DEPRECATED: but till libsecondlife removes it, people will use it
                     ObjectScalePacket scale = (ObjectScalePacket)Pack;
@@ -6847,6 +11434,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.ObjectRotation:
                     // DEPRECATED: but till libsecondlife removes it, people will use it
                     ObjectRotationPacket rotation = (ObjectRotationPacket)Pack;
@@ -6868,6 +11456,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.ObjectFlagUpdate:
                     ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;
 
@@ -6908,6 +11497,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectGrab:
                     ObjectGrabPacket grab = (ObjectGrabPacket)Pack;
 
@@ -6942,6 +11532,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerGrabObject(grab.ObjectData.LocalID, grab.ObjectData.GrabOffset, this, touchArgs);
                     }
                     break;
+
                 case PacketType.ObjectGrabUpdate:
                     ObjectGrabUpdatePacket grabUpdate = (ObjectGrabUpdatePacket)Pack;
 
@@ -6977,6 +11568,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                           grabUpdate.ObjectData.GrabPosition, this, touchArgs);
                     }
                     break;
+
                 case PacketType.ObjectDeGrab:
                     ObjectDeGrabPacket deGrab = (ObjectDeGrabPacket)Pack;
 
@@ -7010,6 +11602,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerDeGrabObject(deGrab.ObjectData.LocalID, this, touchArgs);
                     }
                     break;
+
                 case PacketType.ObjectSpinStart:
                     //m_log.Warn("[CLIENT]: unhandled ObjectSpinStart packet");
                     ObjectSpinStartPacket spinStart = (ObjectSpinStartPacket)Pack;
@@ -7053,6 +11646,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerSpinUpdate(spinUpdate.ObjectData.ObjectID, spinUpdate.ObjectData.Rotation, this);
                     }
                     break;
+
+
                 case PacketType.ObjectSpinStop:
                     //m_log.Warn("[CLIENT]: unhandled ObjectSpinStop packet");
                     ObjectSpinStopPacket spinStop = (ObjectSpinStopPacket)Pack;
@@ -7097,6 +11692,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectName:
                     ObjectNamePacket objName = (ObjectNamePacket)Pack;
 
@@ -7120,6 +11716,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectPermissions:
                     if (OnObjectPermissions != null)
                     {
@@ -7195,6 +11792,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.ObjectDuplicateOnRay:
                     ObjectDuplicateOnRayPacket dupeOnRay = (ObjectDuplicateOnRayPacket)Pack;
 
@@ -7222,6 +11820,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.RequestObjectPropertiesFamily:
                     //This powers the little tooltip that appears when you move your mouse over an object
                     RequestObjectPropertiesFamilyPacket packToolTip = (RequestObjectPropertiesFamilyPacket)Pack;
@@ -7246,6 +11845,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.ObjectIncludeInSearch:
                     //This lets us set objects to appear in search (stuff like DataSnapshot, etc)
                     ObjectIncludeInSearchPacket packInSearch = (ObjectIncludeInSearchPacket)Pack;
@@ -7341,9 +11941,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
-                #region Inventory/Asset/Other related packets
+                //#region Inventory/Asset/Other related packets
 
                 case PacketType.RequestImage:
                     RequestImagePacket imageRequest = (RequestImagePacket)Pack;
@@ -7477,12 +12077,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     MakeAssetRequest(transfer, taskID);
 
-                    /* RequestAsset = OnRequestAsset;
-                         if (RequestAsset != null)
-                         {
-                             RequestAsset(this, transfer);
-                         }*/
+                    // RequestAsset = OnRequestAsset;
+                    //     if (RequestAsset != null)
+                    //     {
+                    //         RequestAsset(this, transfer);
+                    //     }
+
                     break;
+
                 case PacketType.AssetUploadRequest:
                     AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
 
@@ -7501,6 +12103,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                   request.AssetBlock.Tempfile);
                     }
                     break;
+
                 case PacketType.RequestXfer:
                     RequestXferPacket xferReq = (RequestXferPacket)Pack;
 
@@ -7511,6 +12114,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename));
                     }
                     break;
+
                 case PacketType.SendXferPacket:
                     SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack;
 
@@ -7520,6 +12124,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data);
                     }
                     break;
+
                 case PacketType.ConfirmXferPacket:
                     ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack;
 
@@ -7529,6 +12134,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet);
                     }
                     break;
+
                 case PacketType.AbortXfer:
                     AbortXferPacket abortXfer = (AbortXferPacket)Pack;
                     AbortXfer handlerAbortXfer = OnAbortXfer;
@@ -7538,6 +12144,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.CreateInventoryFolder:
                     CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;
 
@@ -7559,6 +12166,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                      invFolder.FolderData.ParentID);
                     }
                     break;
+
                 case PacketType.UpdateInventoryFolder:
                     if (OnUpdateInventoryFolder != null)
                     {
@@ -7588,6 +12196,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.MoveInventoryFolder:
                     if (OnMoveInventoryFolder != null)
                     {
@@ -7615,6 +12224,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.CreateInventoryItem:
                     CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;
 
@@ -7642,6 +12252,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                       Util.UnixTimeSinceEpoch());
                     }
                     break;
+
                 case PacketType.FetchInventory:
                     if (OnFetchInventory != null)
                     {
@@ -7670,6 +12281,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.FetchInventoryDescendents:
                     FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;
 
@@ -7690,6 +12302,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                          Fetch.InventoryData.SortOrder);
                     }
                     break;
+
                 case PacketType.PurgeInventoryDescendents:
                     PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack;
 
@@ -7708,6 +12321,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID);
                     }
                     break;
+
                 case PacketType.UpdateInventoryItem:
                     UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack;
 
@@ -7752,6 +12366,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.CopyInventoryItem:
                     CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack;
 
@@ -7779,6 +12394,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.MoveInventoryItem:
                     MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack;
 
@@ -7812,6 +12428,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.RemoveInventoryItem:
                     RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack;
 
@@ -7840,6 +12457,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     }
                     break;
+
                 case PacketType.RemoveInventoryFolder:
                     RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack;
 
@@ -7867,6 +12485,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.RemoveInventoryObjects:
                     RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack;
                     #region Packet Session and User Check
@@ -7907,6 +12526,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                     break;
+
                 case PacketType.RequestTaskInventory:
                     RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;
 
@@ -7925,6 +12545,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID);
                     }
                     break;
+
                 case PacketType.UpdateTaskInventory:
                     UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack;
 
@@ -8102,6 +12723,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerMapNameRequest(this, mapName);
                     }
                     break;
+
                 case PacketType.TeleportLandmarkRequest:
                     TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack;
 
@@ -8172,7 +12794,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     }
                     break;
-
+         
                 case PacketType.TeleportLocationRequest:
                     TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;
                     // m_log.Debug(tpLocReq.ToString());
@@ -8202,7 +12824,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
                 case PacketType.UUIDNameRequest:
                     UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack;
@@ -8217,7 +12839,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #region Parcel related packets
+                //#region Parcel related packets
+                
 
                 case PacketType.RegionHandleRequest:
                     RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;
@@ -8300,6 +12923,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                              updatePacket.Data.LocalID, entries, this);
                     }
                     break;
+
                 case PacketType.ParcelPropertiesRequest:
 
                     ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack;
@@ -8324,6 +12948,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                        propertiesRequest.ParcelData.SnapSelection, this);
                     }
                     break;
+
                 case PacketType.ParcelDivide:
                     ParcelDividePacket landDivide = (ParcelDividePacket)Pack;
 
@@ -8345,6 +12970,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                    (int)Math.Round(landDivide.ParcelData.North), this);
                     }
                     break;
+
                 case PacketType.ParcelJoin:
                     ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack;
 
@@ -8367,6 +12993,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                  (int)Math.Round(landJoin.ParcelData.North), this);
                     }
                     break;
+
                 case PacketType.ParcelPropertiesUpdate:
                     ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack;
 
@@ -8405,6 +13032,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this);
                     }
                     break;
+
                 case PacketType.ParcelSelectObjects:
                     ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack;
 
@@ -8433,6 +13061,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                    Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this);
                     }
                     break;
+
                 case PacketType.ParcelObjectOwnersRequest:
                     //m_log.Debug(Pack.ToString());
                     ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack;
@@ -8453,6 +13082,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this);
                     }
                     break;
+
                 case PacketType.ParcelGodForceOwner:
                     ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack;
 
@@ -8471,6 +13101,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this);
                     }
                     break;
+
                 case PacketType.ParcelRelease:
                     ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack;
 
@@ -8489,6 +13120,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerParcelAbandonRequest(releasePacket.Data.LocalID, this);
                     }
                     break;
+
                 case PacketType.ParcelReclaim:
                     ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack;
 
@@ -8507,6 +13139,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerParcelReclaim(reclaimPacket.Data.LocalID, this);
                     }
                     break;
+
                 case PacketType.ParcelReturnObjects:
 
 
@@ -8598,9 +13231,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
-                #region Estate Packets
+                //#region Estate Packets
 
                 case PacketType.EstateOwnerMessage:
                     EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack;
@@ -8918,6 +13551,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerRegionInfoRequest(this);
                     }
                     break;
+        
                 case PacketType.EstateCovenantRequest:
 
                     //EstateCovenantRequestPacket.AgentDataBlock epack =
@@ -8930,9 +13564,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
-                #region GodPackets
+                //#region GodPackets
 
                 case PacketType.RequestGodlikePowers:
                     RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack;
@@ -8949,6 +13583,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.GodKickUser:
                     GodKickUserPacket gkupack = (GodKickUserPacket)Pack;
 
@@ -8978,9 +13613,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     //OutPacket(kupack, ThrottleOutPacketType.Task);
                     break;
 
-                #endregion
+                //#endregion
 
-                #region Economy/Transaction Packets
+                //#region Economy/Transaction Packets
 
                 case PacketType.MoneyBalanceRequest:
                     MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack;
@@ -9002,6 +13637,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
 
                     break;
+
                 case PacketType.EconomyDataRequest:
 
 
@@ -9011,6 +13647,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         handlerEconomoyDataRequest(AgentId);
                     }
                     break;
+
                 case PacketType.RequestPayPrice:
                     RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack;
 
@@ -9080,9 +13717,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
-                #region Script Packets
+                //#region Script Packets
 
                 case PacketType.GetScriptRunning:
                     GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack;
@@ -9132,9 +13769,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
-                #region Gesture Managment
+                //#region Gesture Managment
 
                 case PacketType.ActivateGestures:
                     ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;
@@ -9201,7 +13838,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
 
                 case PacketType.AgentFOV:
                     AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;
@@ -9217,7 +13854,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #region unimplemented handlers
+                //#region unimplemented handlers
 
                 case PacketType.ViewerStats:
                     // TODO: handle this packet
@@ -9251,6 +13888,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     // TODO: handle this packet
                     //m_log.Warn("[CLIENT]: unhandled TransferAbort packet");
                     break;
+
                 case PacketType.MuteListRequest:
                     MuteListRequestPacket muteListRequest =
                             (MuteListRequestPacket)Pack;
@@ -9274,6 +13912,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         SendUseCachedMuteList();
                     }
                     break;
+
                 case PacketType.UseCircuitCode:
                     // Don't display this one, we handle it at a lower level
                     break;
@@ -9288,6 +13927,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     //m_log.Warn("[CLIENT]: unhandled InventoryDescent packet");
 
                     break;
+
                 case PacketType.DirPlacesQuery:
                     DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;
                     //m_log.Debug(dirPlacesQueryPacket.ToString());
@@ -9315,6 +13955,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                               dirPlacesQueryPacket.QueryData.QueryStart);
                     }
                     break;
+
                 case PacketType.DirFindQuery:
                     DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;
 
@@ -9338,6 +13979,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                             dirFindQueryPacket.QueryData.QueryStart);
                     }
                     break;
+
                 case PacketType.DirLandQuery:
                     DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;
 
@@ -9362,6 +14004,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                             dirLandQueryPacket.QueryData.QueryStart);
                     }
                     break;
+
                 case PacketType.DirPopularQuery:
                     DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;
 
@@ -9382,6 +14025,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                dirPopularQueryPacket.QueryData.QueryFlags);
                     }
                     break;
+
                 case PacketType.DirClassifiedQuery:
                     DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;
 
@@ -9406,6 +14050,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                   dirClassifiedQueryPacket.QueryData.QueryStart);
                     }
                     break;
+
                 case PacketType.EventInfoRequest:
                     EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;
 
@@ -9424,7 +14069,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #region Calling Card
+                //#region Calling Card
 
                 case PacketType.OfferCallingCard:
                     OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;
@@ -9486,9 +14131,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                              declineCallingCardPacket.TransactionBlock.TransactionID);
                     }
                     break;
-                #endregion
+                //#endregion
 
-                #region Groups
+                //#region Groups
                 case PacketType.ActivateGroup:
                     ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;
 
@@ -9508,6 +14153,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
+
                 case PacketType.GroupTitlesRequest:
                     GroupTitlesRequestPacket groupTitlesRequest =
                         (GroupTitlesRequestPacket)Pack;
@@ -9969,8 +14615,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                         OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);
                     }
-
+             
                     break;
+
                 case PacketType.GroupNoticeRequest:
                     GroupNoticeRequestPacket groupNoticeRequest =
                         (GroupNoticeRequestPacket)Pack;
@@ -10141,7 +14788,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     break;
 
-                #endregion
+                //#endregion
+
                 case PacketType.StartLure:
                     StartLurePacket startLureRequest = (StartLurePacket)Pack;
 
@@ -10373,6 +15021,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (handlerPickDelete != null)
                         handlerPickDelete(this, pickDelete.Data.PickID);
                     break;
+
                 case PacketType.PickGodDelete:
                     PickGodDeletePacket pickGodDelete =
                             (PickGodDeletePacket)Pack;
@@ -10393,6 +15042,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                 pickGodDelete.Data.PickID,
                                 pickGodDelete.Data.QueryID);
                     break;
+
                 case PacketType.PickInfoUpdate:
                     PickInfoUpdatePacket pickInfoUpdate =
                             (PickInfoUpdatePacket)Pack;
@@ -10418,6 +15068,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                 pickInfoUpdate.Data.SortOrder,
                                 pickInfoUpdate.Data.Enabled);
                     break;
+
                 case PacketType.AvatarNotesUpdate:
                     AvatarNotesUpdatePacket avatarNotesUpdate =
                             (AvatarNotesUpdatePacket)Pack;
@@ -10450,7 +15101,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             break;
                     }
                     #endregion
-
+            
                     AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;
                     if (handlerAvatarInterestUpdate != null)
                         handlerAvatarInterestUpdate(this,
@@ -10497,11 +15148,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                         placesQueryPacket.QueryData.SimName),
                                 this);
                     break;
+                */
+                #endregion
                 default:
                     m_log.Warn("[CLIENT]: unhandled packet " + Pack);
                     break;
-
-                #endregion
             }
 
             PacketPool.Instance.ReturnPacket(Pack);
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
index cd59bdb..e3e8718 100644
--- a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
@@ -49,7 +49,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
         private int m_shoutdistance = 100;
         private int m_whisperdistance = 10;
         private List<Scene> m_scenes = new List<Scene>();
-
+        private string m_adminPrefix = "";
         internal object m_syncy = new object();
 
         internal IConfig m_config;
@@ -57,25 +57,26 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
         #region ISharedRegionModule Members
         public virtual void Initialise(IConfigSource config)
         {
-
             m_config = config.Configs["Chat"];
 
             if (null == m_config)
             {
                 m_log.Info("[CHAT]: no config found, plugin disabled");
+                m_enabled = false;
                 return;
             }
 
-            if (!m_config.GetBoolean("enabled", false))
+            if (!m_config.GetBoolean("enabled", true))
             {
                 m_log.Info("[CHAT]: plugin disabled by configuration");
+                m_enabled = false;
                 return;
             }
-            m_enabled = true;
 
             m_whisperdistance = config.Configs["Chat"].GetInt("whisper_distance", m_whisperdistance);
             m_saydistance = config.Configs["Chat"].GetInt("say_distance", m_saydistance);
             m_shoutdistance = config.Configs["Chat"].GetInt("shout_distance", m_shoutdistance);
+            m_adminPrefix = config.Configs["Chat"].GetString("admin_prefix", "");
         }
 
         public virtual void AddRegion(Scene scene)
@@ -185,6 +186,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
         protected virtual void DeliverChatToAvatars(ChatSourceType sourceType, OSChatMessage c)
         {
             string fromName = c.From;
+            string fromNamePrefix = "";
             UUID fromID = UUID.Zero;
             string message = c.Message;
             IScene scene = c.Scene;
@@ -207,7 +209,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
                 fromPos = avatar.AbsolutePosition;
                 fromName = avatar.Name;
                 fromID = c.Sender.AgentId;
-
+                if (avatar.GodLevel > 200)
+                {
+                    fromNamePrefix = m_adminPrefix;
+                }
                 break;
 
             case ChatSourceType.Object:
@@ -227,7 +232,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
                 s.ForEachScenePresence(
                     delegate(ScenePresence presence)
                     {
-                        TrySendChatMessage(presence, fromPos, regionPos, fromID, fromName, c.Type, message, sourceType);
+                        TrySendChatMessage(presence, fromPos, regionPos, fromID, fromNamePrefix+fromName, c.Type, message, sourceType);
                     }
                 );
             }
@@ -266,25 +271,29 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
             }
             
             // m_log.DebugFormat("[CHAT] Broadcast: fromID {0} fromName {1}, cType {2}, sType {3}", fromID, fromName, cType, sourceType);
-
-            ((Scene)c.Scene).ForEachScenePresence(
-                delegate(ScenePresence presence)
-                {
-                    // ignore chat from child agents
-                    if (presence.IsChildAgent) return;
-                    
-                    IClientAPI client = presence.ControllingClient;
-                    
-                    // don't forward SayOwner chat from objects to
-                    // non-owner agents
-                    if ((c.Type == ChatTypeEnum.Owner) &&
-                        (null != c.SenderObject) &&
-                        (((SceneObjectPart)c.SenderObject).OwnerID != client.AgentId))
-                        return;
-                    
-                    client.SendChatMessage(c.Message, (byte)cType, CenterOfRegion, fromName, fromID, 
-                                           (byte)sourceType, (byte)ChatAudibleLevel.Fully);
-                });
+            if (c.Scene != null)
+            {
+                ((Scene)c.Scene).ForEachScenePresence
+                (
+                    delegate(ScenePresence presence)
+                    {
+                        // ignore chat from child agents
+                        if (presence.IsChildAgent) return;
+                        
+                        IClientAPI client = presence.ControllingClient;
+                        
+                        // don't forward SayOwner chat from objects to
+                        // non-owner agents
+                        if ((c.Type == ChatTypeEnum.Owner) &&
+                            (null != c.SenderObject) &&
+                            (((SceneObjectPart)c.SenderObject).OwnerID != client.AgentId))
+                            return;
+                        
+                        client.SendChatMessage(c.Message, (byte)cType, CenterOfRegion, fromName, fromID, 
+                                               (byte)sourceType, (byte)ChatAudibleLevel.Fully);
+                    }
+                );
+             }
         }
 
 
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
index 9e76d79..b778389 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
@@ -121,45 +121,51 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
             byte[] data;
             TarArchiveReader.TarEntryType entryType;
-            while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
-            {
-                if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
-                {
-                    if (LoadAsset(filePath, data))
-                        successfulAssetRestores++;
-                    else
-                        failedAssetRestores++;
 
-                    if ((successfulAssetRestores) % 50 == 0)
-                        m_log.DebugFormat(
-                            "[INVENTORY ARCHIVER]: Loaded {0} assets...", 
-                            successfulAssetRestores);
-                }
-                else if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH))
+            try
+            {
+                while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
                 {
-                    InventoryFolderBase foundFolder 
-                        = ReplicateArchivePathToUserInventory(
-                            filePath, TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType, 
-                            rootDestinationFolder, foldersCreated, nodesLoaded);
-
-                    if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType)
+                    if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
                     {
-                        InventoryItemBase item = LoadItem(data, foundFolder);
-
-                        if (item != null)
+                        if (LoadAsset(filePath, data))
+                            successfulAssetRestores++;
+                        else
+                            failedAssetRestores++;
+    
+                        if ((successfulAssetRestores) % 50 == 0)
+                            m_log.DebugFormat(
+                                "[INVENTORY ARCHIVER]: Loaded {0} assets...", 
+                                successfulAssetRestores);
+                    }
+                    else if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH))
+                    {
+                        InventoryFolderBase foundFolder 
+                            = ReplicateArchivePathToUserInventory(
+                                filePath, TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType, 
+                                rootDestinationFolder, foldersCreated, nodesLoaded);
+    
+                        if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType)
                         {
-                            successfulItemRestores++;
-                            
-                            // If we're loading an item directly into the given destination folder then we need to record
-                            // it separately from any loaded root folders
-                            if (rootDestinationFolder == foundFolder)
-                                nodesLoaded.Add(item);
+                            InventoryItemBase item = LoadItem(data, foundFolder);
+    
+                            if (item != null)
+                            {
+                                successfulItemRestores++;
+                                
+                                // If we're loading an item directly into the given destination folder then we need to record
+                                // it separately from any loaded root folders
+                                if (rootDestinationFolder == foundFolder)
+                                    nodesLoaded.Add(item);
+                            }
                         }
                     }
                 }
             }
-
-            archive.Close();
+            finally
+            {
+                archive.Close();
+            }
 
             m_log.DebugFormat(
                 "[INVENTORY ARCHIVER]: Successfully loaded {0} assets with {1} failures", 
@@ -342,9 +348,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
             UUID ospResolvedId = OspResolver.ResolveOspa(item.CreatorId, m_scene.CommsManager); 
             if (UUID.Zero != ospResolvedId)
+            {                
                 item.CreatorIdAsUuid = ospResolvedId;
+
+                // XXX: For now, don't preserve the OSPA in the creator id (which actually gets persisted to the
+                // database).  Instead, replace with the UUID that we found.
+                item.CreatorId = ospResolvedId.ToString();                
+            }
             else
+            {
                 item.CreatorIdAsUuid = m_userInfo.UserProfile.ID;
+            }
             
             item.Owner = m_userInfo.UserProfile.ID;
 
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
index 6e11f36..c85d974 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
@@ -117,19 +117,19 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         protected void ReceivedAllAssets(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
-        {
-            // We're almost done.  Just need to write out the control file now
-            m_archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, Create0p1ControlFile());
-            m_log.InfoFormat("[ARCHIVER]: Added control file to archive.");
-            
+        {               
             Exception reportedException = null;
             bool succeeded = true;
-
+            
             try
-            {
+            {            
+                // We're almost done.  Just need to write out the control file now
+                m_archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, Create0p1ControlFile());
+                m_log.InfoFormat("[ARCHIVER]: Added control file to archive.");
+
                 m_archiveWriter.Close();
             }
-            catch (IOException e)
+            catch (Exception e)
             {
                 m_saveStream.Close();
                 reportedException = e;
@@ -261,39 +261,47 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 //inventoryItem = m_userInfo.RootFolder.FindItemByPath(m_invPath);
             }
 
-            m_archiveWriter = new TarArchiveWriter(m_saveStream);
-
-            if (inventoryFolder != null)
-            {
-                m_log.DebugFormat(
-                    "[INVENTORY ARCHIVER]: Found folder {0} {1} at {2}",
-                    inventoryFolder.Name, inventoryFolder.ID, m_invPath);
-
-                //recurse through all dirs getting dirs and files
-                SaveInvFolder(inventoryFolder, ArchiveConstants.INVENTORY_PATH, !foundStar);
-            }
-            else if (inventoryItem != null)
-            {
-                m_log.DebugFormat(
-                    "[INVENTORY ARCHIVER]: Found item {0} {1} at {2}",
-                    inventoryItem.Name, inventoryItem.ID, m_invPath);
-
-                SaveInvItem(inventoryItem, ArchiveConstants.INVENTORY_PATH);
-            }
-            else
+            if (null == inventoryFolder && null == inventoryItem)
             {
                 // We couldn't find the path indicated 
-                m_saveStream.Close();
                 string errorMessage = string.Format("Aborted save.  Could not find inventory path {0}", m_invPath);
                 m_log.ErrorFormat("[INVENTORY ARCHIVER]: {0}", errorMessage);
                 m_module.TriggerInventoryArchiveSaved(
                     m_id, false, m_userInfo, m_invPath, m_saveStream,
                     new Exception(errorMessage));
-                return;
+                return;                
             }
+            
+            m_archiveWriter = new TarArchiveWriter(m_saveStream);
 
-            // Don't put all this profile information into the archive right now.
-            //SaveUsers();
+            try
+            {
+                if (inventoryFolder != null)
+                {
+                    m_log.DebugFormat(
+                        "[INVENTORY ARCHIVER]: Found folder {0} {1} at {2}",
+                        inventoryFolder.Name, inventoryFolder.ID, m_invPath);
+    
+                    //recurse through all dirs getting dirs and files
+                    SaveInvFolder(inventoryFolder, ArchiveConstants.INVENTORY_PATH, !foundStar);
+                }
+                else if (inventoryItem != null)
+                {
+                    m_log.DebugFormat(
+                        "[INVENTORY ARCHIVER]: Found item {0} {1} at {2}",
+                        inventoryItem.Name, inventoryItem.ID, m_invPath);
+    
+                    SaveInvItem(inventoryItem, ArchiveConstants.INVENTORY_PATH);
+                }
+            
+                // Don't put all this profile information into the archive right now.
+                //SaveUsers();
+            }
+            catch (Exception)
+            {
+                m_archiveWriter.Close();
+                throw;
+            }
             
             new AssetsRequest(
                 new AssetsArchiver(m_archiveWriter), m_assetUuids.Keys, 
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
index 1228eb1..ecd60bd 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
@@ -92,12 +92,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 scene.AddCommand(
                     this, "load iar",
                     "load iar <first> <last> <inventory path> <password> [<archive path>]",
-                    "Load user inventory archive.  EXPERIMENTAL", HandleLoadInvConsoleCommand); 
+                    "Load user inventory archive.", HandleLoadInvConsoleCommand); 
                 
                 scene.AddCommand(
                     this, "save iar",
                     "save iar <first> <last> <inventory path> <password> [<archive path>]",
-                    "Save user inventory archive.  EXPERIMENTAL", HandleSaveInvConsoleCommand);
+                    "Save user inventory archive.", HandleSaveInvConsoleCommand);
 
                 m_aScene = scene;
             }
@@ -280,7 +280,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             string savePath = (cmdparams.Length > 6 ? cmdparams[6] : DEFAULT_INV_BACKUP_FILENAME);
 
             m_log.InfoFormat(
-                "[INVENTORY ARCHIVER]: Saving archive {0} from inventory path {1} for {2} {3}",
+                "[INVENTORY ARCHIVER]: Saving archive {0} using inventory path {1} for {2} {3}",
                 savePath, invPath, firstName, lastName);
 
             Guid id = Guid.NewGuid();
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
index 7927352..e4dad18 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
@@ -259,9 +259,16 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
                 = InventoryArchiveUtils.FindItemByPath(scene.InventoryService, userInfo.UserProfile.ID, item1Name);
             
             Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1");
+
+// We have to disable this check since loaded items that did find users via OSPA resolution are now only storing the
+// UUID, not the OSPA itself.
+//            Assert.That(
+//                foundItem1.CreatorId, Is.EqualTo(item1.CreatorId), 
+//                "Loaded item non-uuid creator doesn't match original");
             Assert.That(
-                foundItem1.CreatorId, Is.EqualTo(item1.CreatorId), 
+                foundItem1.CreatorId, Is.EqualTo(userItemCreatorUuid.ToString()), 
                 "Loaded item non-uuid creator doesn't match original");
+            
             Assert.That(
                 foundItem1.CreatorIdAsUuid, Is.EqualTo(userItemCreatorUuid), 
                 "Loaded item uuid creator doesn't match original");
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
index d9a021f..b60b32b 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
@@ -389,7 +389,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
         {
             // Check if this is ours to handle
             //
-            m_log.Info("OnFridInstantMessage");
+            //m_log.Info("OnFridInstantMessage");
             if (msg.dialog != (byte) InstantMessageDialog.InventoryOffered)
                 return;
 
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
index ee809bd..d9f6e33 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
@@ -263,8 +263,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
                     {
                         // We need to make a local copy of the object
                         ISceneObject sogClone = sog.CloneForNewScene();
-                        sogClone.SetState(sog.GetStateSnapshot(),
-                                s.RegionInfo.RegionID);
+                        sogClone.SetState(sog.GetStateSnapshot(), s);
                         return s.IncomingCreateObject(sogClone);
                     }
                     else
@@ -294,15 +293,15 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
 
         #region Misc
 
-        public UUID GetRegionID(ulong regionhandle)
+        public Scene GetScene(ulong regionhandle)
         {
             foreach (Scene s in m_sceneList)
             {
                 if (s.RegionInfo.RegionHandle == regionhandle)
-                    return s.RegionInfo.RegionID;
+                    return s;
             }
             // ? weird. should not happen
-            return m_sceneList[0].RegionInfo.RegionID;
+            return m_sceneList[0];
         }
 
         public bool IsLocalRegion(ulong regionhandle)
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/RESTInterregionComms.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/RESTInterregionComms.cs
index 696225c..710e3ca 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/RESTInterregionComms.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/RESTInterregionComms.cs
@@ -641,7 +641,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
             if (args["extra"] != null)
                 extraStr = args["extra"].AsString();
 
-            UUID regionID = m_localBackend.GetRegionID(regionhandle);
+            IScene s = m_localBackend.GetScene(regionhandle);
             SceneObjectGroup sog = null;
             try
             {
@@ -663,7 +663,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
                 {
                     try
                     {
-                        sog.SetState(stateXmlStr, regionID);
+                        sog.SetState(stateXmlStr, s);
                     }
                     catch (Exception ex)
                     {
@@ -695,8 +695,6 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
             if (args["itemid"] != null)
                 itemID = args["itemid"].AsUUID();
 
-            //UUID regionID = m_localBackend.GetRegionID(regionhandle);
-
             // This is the meaning of PUT object
             bool result = m_localBackend.SendCreateObject(regionhandle, userID, itemID);
 
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
index 70a225e..114dd13 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
@@ -103,14 +103,13 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             List<string> serialisedSceneObjects = new List<string>();
             List<string> serialisedParcels = new List<string>();
             string filePath = "NONE";
+
+            TarArchiveReader archive = new TarArchiveReader(m_loadStream);          
+            byte[] data;
+            TarArchiveReader.TarEntryType entryType;
             
             try
             {
-                TarArchiveReader archive = new TarArchiveReader(m_loadStream);
-               
-                byte[] data;
-                TarArchiveReader.TarEntryType entryType;
-
                 while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
                 {
                     //m_log.DebugFormat(
@@ -152,8 +151,6 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 }
 
                 //m_log.Debug("[ARCHIVER]: Reached end of archive");
-
-                archive.Close();
             }
             catch (Exception e)
             {
@@ -163,6 +160,10 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 m_scene.EventManager.TriggerOarFileLoaded(m_requestId, m_errorMessage);
                 return;
             }
+            finally
+            {
+                archive.Close();
+            }
 
             m_log.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
 
@@ -246,21 +247,20 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     // Fix ownership/creator of inventory items
                     // Not doing so results in inventory items
                     // being no copy/no mod for everyone
-                    lock (part.TaskInventory)
+                    part.TaskInventory.LockItemsForRead(true);
+                    TaskInventoryDictionary inv = part.TaskInventory;
+                    foreach (KeyValuePair<UUID, TaskInventoryItem> kvp in inv)
                     {
-                        TaskInventoryDictionary inv = part.TaskInventory;
-                        foreach (KeyValuePair<UUID, TaskInventoryItem> kvp in inv)
+                        if (!ResolveUserUuid(kvp.Value.OwnerID))
+                        {
+                            kvp.Value.OwnerID = masterAvatarId;
+                        }
+                        if (!ResolveUserUuid(kvp.Value.CreatorID))
                         {
-                            if (!ResolveUserUuid(kvp.Value.OwnerID))
-                            {
-                                kvp.Value.OwnerID = masterAvatarId;
-                            }
-                            if (!ResolveUserUuid(kvp.Value.CreatorID))
-                            {
-                                kvp.Value.CreatorID = masterAvatarId;
-                            }
+                            kvp.Value.CreatorID = masterAvatarId;
                         }
                     }
+                    part.TaskInventory.LockItemsForRead(false);
                 }
 
                 if (m_scene.AddRestoredSceneObject(sceneObject, true, false))
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
index f039be8..75c4557 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
@@ -80,6 +80,22 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         protected internal void ReceivedAllAssets(
             ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
         {
+            try
+            {
+                Save(assetsFoundUuids, assetsNotFoundUuids);
+            }
+            finally
+            {
+                m_archiveWriter.Close();
+            }
+            
+            m_log.InfoFormat("[ARCHIVER]: Finished writing out OAR for {0}", m_scene.RegionInfo.RegionName);
+
+            m_scene.EventManager.TriggerOarFileSaved(m_requestId, String.Empty);            
+        }
+
+        protected internal void Save(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
+        {
             foreach (UUID uuid in assetsNotFoundUuids)
             {
                 m_log.DebugFormat("[ARCHIVER]: Could not find asset {0}", uuid);
@@ -143,12 +159,6 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             }
 
             m_log.InfoFormat("[ARCHIVER]: Added scene objects to archive.");
-
-            m_archiveWriter.Close();
-
-            m_log.InfoFormat("[ARCHIVER]: Finished writing out OAR for {0}", m_scene.RegionInfo.RegionName);
-
-            m_scene.EventManager.TriggerOarFileSaved(m_requestId, String.Empty);
         }
 
         /// <summary>
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
index 9e4fbbe..71bfe57 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
@@ -56,6 +56,12 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <summary>
         /// Constructor
         /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="savePath">The path to which to save data.</param>
+        /// <param name="requestId">The id associated with this request</param>
+        /// <exception cref="System.IO.IOException">
+        /// If there was a problem opening a stream for the file specified by the savePath
+        /// </exception>
         public ArchiveWriteRequestPreparation(Scene scene, string savePath, Guid requestId)
         {
             m_scene = scene;
@@ -87,6 +93,16 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             List<EntityBase> entities = m_scene.GetEntities();
             List<SceneObjectGroup> sceneObjects = new List<SceneObjectGroup>();
 
+            /*
+                foreach (ILandObject lo in m_scene.LandChannel.AllParcels())
+                {
+                    if (name == lo.LandData.Name)
+                    {
+                        // This is the parcel we want
+                    }
+                }
+                */
+     
             // Filter entities so that we only have scene objects.
             // FIXME: Would be nicer to have this as a proper list in SceneGraph, since lots of methods
             // end up having to do this
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
index 8d4f91b..27763bb 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
@@ -26,9 +26,11 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using log4net;
+using NDesk.Options;
 using Nini.Config;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -45,6 +47,11 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
         private Scene m_scene;
 
+        /// <value>
+        /// The file used to load and save an opensimulator archive if no filename has been specified
+        /// </value>
+        protected const string DEFAULT_OAR_BACKUP_FILENAME = "region.oar";        
+
         public string Name 
         { 
             get { return "RegionArchiverModule"; } 
@@ -80,6 +87,48 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         {
         }
 
+        /// <summary>
+        /// Load a whole region from an opensimulator archive.
+        /// </summary>
+        /// <param name="cmdparams"></param>
+        public void HandleLoadOarConsoleCommand(string module, string[] cmdparams)
+        {
+            bool mergeOar = false;
+            
+            OptionSet options = new OptionSet().Add("m|merge", delegate (string v) { mergeOar = v != null; });
+            List<string> mainParams = options.Parse(cmdparams);
+          
+//            m_log.DebugFormat("MERGE OAR IS [{0}]", mergeOar);
+//
+//            foreach (string param in mainParams)
+//                m_log.DebugFormat("GOT PARAM [{0}]", param);
+            
+            if (mainParams.Count > 2)
+            {
+                DearchiveRegion(mainParams[2], mergeOar, Guid.Empty);
+            }
+            else
+            {
+                DearchiveRegion(DEFAULT_OAR_BACKUP_FILENAME, mergeOar, Guid.Empty);
+            }
+        }        
+
+        /// <summary>
+        /// Save a region to a file, including all the assets needed to restore it.
+        /// </summary>
+        /// <param name="cmdparams"></param>
+        public void HandleSaveOarConsoleCommand(string module, string[] cmdparams)
+        {
+            if (cmdparams.Length > 2)
+            {
+                ArchiveRegion(cmdparams[2]);
+            }
+            else
+            {
+                ArchiveRegion(DEFAULT_OAR_BACKUP_FILENAME);
+            }
+        }
+        
         public void ArchiveRegion(string savePath)
         {
             ArchiveRegion(savePath, Guid.Empty);
diff --git a/OpenSim/Region/CoreModules/World/Land/LandChannel.cs b/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
index 4ed23bb..81024db 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
@@ -105,7 +105,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             ILandObject obj = new LandObject(UUID.Zero, false, m_scene);
             obj.LandData.Name = "NO LAND";
             return obj;
-        }
+        }      
 
         public List<ILandObject> AllParcels()
         {
@@ -154,6 +154,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 m_landManagementModule.UpdateLandObject(localID, data);
             }
         }
+        
         public void ReturnObjectsInParcel(int localID, uint returnType, UUID[] agentIDs, UUID[] taskIDs, IClientAPI remoteClient)
         {
             if (m_landManagementModule != null)
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index 968f46a..9a2ef50 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -67,7 +67,14 @@ namespace OpenSim.Region.CoreModules.World.Land
         private const int landArrayMax = ((int)((int)Constants.RegionSize / 4) >= 64) ? (int)((int)Constants.RegionSize / 4) : 64;
         #pragma warning restore 0429
 
+        /// <value>
+        /// Local land ids at specified region co-ordinates (region size / 4) 
+        /// </value>
         private readonly int[,] m_landIDList = new int[landArrayMax, landArrayMax];
+
+        /// <value>
+        /// Land objects keyed by local id 
+        /// </value>
         private readonly Dictionary<int, ILandObject> m_landList = new Dictionary<int, ILandObject>();
 
         private bool m_landPrimCountTainted;
@@ -570,6 +577,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             if (x_float > Constants.RegionSize || x_float <= 0 || y_float > Constants.RegionSize || y_float <= 0)
                 return null;
+            
             try
             {
                 x = Convert.ToInt32(Math.Floor(Convert.ToDouble(x_float) / 4.0));
@@ -584,6 +592,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 return null;
             }
+            
             lock (m_landList)
             {
                 // Corner case. If an autoreturn happens during sim startup
@@ -603,6 +612,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 // they happen every time at border crossings
                 throw new Exception("Error: Parcel not found at point " + x + ", " + y);
             }
+            
             lock (m_landIDList)
             {
                 try
@@ -617,7 +627,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     return null;
                 }
             }
-        }
+        }      
 
         #endregion
 
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 2c906a2..89a45da 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -185,19 +185,11 @@ namespace OpenSim.Region.Framework.Interfaces
         List<UUID> GetInventoryList();
         
         /// <summary>
-        /// Get the names of the assemblies associated with scripts in this inventory.
-        /// </summary>
-        /// <returns></returns>
-        string[] GetScriptAssemblies();
-        
-        /// <summary>
         /// Get the xml representing the saved states of scripts in this inventory.
         /// </summary>
         /// <returns>
         /// A <see cref="Dictionary`2"/>
         /// </returns>
         Dictionary<UUID, string> GetScriptStates();
-
-        bool CanBeDeleted();
     }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/ILandChannel.cs b/OpenSim/Region/Framework/Interfaces/ILandChannel.cs
index 74f404f..6fe6118 100644
--- a/OpenSim/Region/Framework/Interfaces/ILandChannel.cs
+++ b/OpenSim/Region/Framework/Interfaces/ILandChannel.cs
@@ -33,26 +33,41 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface ILandChannel
     {
-        List<ILandObject> ParcelsNearPoint(Vector3 position);
+        /// <summary>
+        /// Get all parcels
+        /// </summary>
+        /// <returns></returns>
         List<ILandObject> AllParcels();
              
         /// <summary>
-        /// Get the land object at the specified point
+        /// Get the parcel at the specified point
         /// </summary>
         /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
         /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
         /// <returns>Land object at the point supplied</returns>
         ILandObject GetLandObject(int x, int y);
 
-        ILandObject GetLandObject(int localID);
-
         /// <summary>
-        /// Get the land object at the specified point
+        /// Get the parcel at the specified point
         /// </summary>
         /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
         /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
         /// <returns>Land object at the point supplied</returns>
         ILandObject GetLandObject(float x, float y);
+
+        /// <summary>
+        /// Get the parcels near the specified point
+        /// </summary>
+        /// <param name="position"></param>
+        /// <returns></returns>
+        List<ILandObject> ParcelsNearPoint(Vector3 position);        
+
+        /// <summary>
+        /// Get the parcel given the land's local id.
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        ILandObject GetLandObject(int localID);
         
         bool IsLandPrimCountTainted();
         bool IsForcefulBansAllowed();
diff --git a/OpenSim/Region/Framework/Interfaces/IRegionArchiverModule.cs b/OpenSim/Region/Framework/Interfaces/IRegionArchiverModule.cs
index 9ad2036..1a8babc 100644
--- a/OpenSim/Region/Framework/Interfaces/IRegionArchiverModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IRegionArchiverModule.cs
@@ -34,7 +34,10 @@ namespace OpenSim.Region.Framework.Interfaces
     /// Interface to region archive functionality
     /// </summary>
     public interface IRegionArchiverModule
-    {
+    {        
+        void HandleLoadOarConsoleCommand(string module, string[] cmdparams);
+        void HandleSaveOarConsoleCommand(string module, string[] cmdparams);
+            
         /// <summary>
         /// Archive the region to the given path
         /// </summary>
diff --git a/OpenSim/Region/Framework/Interfaces/IScriptModule.cs b/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
index 10835b9..f11e571 100644
--- a/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IScriptModule.cs
@@ -34,9 +34,8 @@ namespace OpenSim.Region.Framework.Interfaces
     {
         string ScriptEngineName { get; }
 
-        string GetAssemblyName(UUID itemID);
         string GetXMLState(UUID itemID);
-        bool CanBeDeleted(UUID itemID);
+        void SetXMLState(UUID itemID, string xml);
 
         bool PostScriptEvent(UUID itemID, string name, Object[] args);
         bool PostObjectEvent(UUID itemID, string name, Object[] args);
diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index 2d41342..b031f61 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -163,8 +163,8 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             // Check control flags
             bool heldForward = ((controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_AT_POS) == AgentManager.ControlFlags.AGENT_CONTROL_AT_POS || (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS) == AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS);
             bool heldBack = ((controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_AT_NEG) == AgentManager.ControlFlags.AGENT_CONTROL_AT_NEG || (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_NEG) == AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_NEG);
-            bool heldLeft = (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS) == AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS;
-            bool heldRight = (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG) == AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG;
+            bool heldLeft = ((controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS) == AgentManager.ControlFlags.AGENT_CONTROL_LEFT_POS || (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS) == AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS);
+            bool heldRight = ((controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG) == AgentManager.ControlFlags.AGENT_CONTROL_LEFT_NEG || (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG) == AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG);
             //bool heldTurnLeft = (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_LEFT) == AgentManager.ControlFlags.AGENT_CONTROL_TURN_LEFT;
             //bool heldTurnRight = (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_RIGHT) == AgentManager.ControlFlags.AGENT_CONTROL_TURN_RIGHT;
             bool heldUp = (controlFlags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) == AgentManager.ControlFlags.AGENT_CONTROL_UP_POS;
@@ -252,8 +252,7 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             else if (m_movementAnimation == "LAND")
             {
                 float landElapsed = (float)(Environment.TickCount - m_animTickFall) / 1000f;
-
-                if (landElapsed <= FALL_DELAY)
+                if ((m_animTickFall != 0) && (landElapsed <= FALL_DELAY))
                     return "LAND";
             }
 
diff --git a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
index 5b571c7..9a7863b 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
@@ -131,11 +131,6 @@ namespace OpenSim.Region.Framework.Scenes
                     if (left > 0)
                     {
                         x = m_inventoryDeletes.Dequeue();
-                        if (!x.objectGroup.CanBeDeleted())
-                        {
-                            m_inventoryDeletes.Enqueue(x);
-                            return true;
-                        }
 
                         m_log.DebugFormat(
                             "[SCENE]: Sending object to user's inventory, {0} item(s) remaining.", left);
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 66fb918..83208e9 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -840,8 +840,12 @@ namespace OpenSim.Region.Framework.Scenes
         public void RemoveTaskInventory(IClientAPI remoteClient, UUID itemID, uint localID)
         {
             SceneObjectPart part = GetSceneObjectPart(localID);
-            SceneObjectGroup group = part.ParentGroup;
-            if (group != null)
+            SceneObjectGroup group = null;
+            if (part != null)
+            {
+                group = part.ParentGroup;
+            }            
+            if (part != null && group != null)
             {
                 TaskInventoryItem item = group.GetInventoryItem(localID, itemID);
                 if (item == null)
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 4ffa1a2..3034f9a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -387,6 +387,11 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get { return StatsReporter.getLastReportedSimFPS(); }
         }
+                
+                public float[] SimulatorStats
+                {
+                        get { return StatsReporter.getLastReportedSimStats(); }
+                }
 
         public string DefaultScriptEngine
         {
@@ -618,7 +623,7 @@ namespace OpenSim.Region.Framework.Scenes
                   startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
                 m_persistAfter *= 10000000;
 
-                m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "DotNetEngine");
+                m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
 
                 IConfig packetConfig = m_config.Configs["PacketPool"];
                 if (packetConfig != null)
@@ -873,6 +878,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="seconds">float indicating duration before restart.</param>
         public virtual void Restart(float seconds)
         {
+            Restart(seconds, true);
+        }
+
+        /// <summary>
+        /// Given float seconds, this will restart the region. showDialog will optionally alert the users.
+        /// </summary>
+        /// <param name="seconds">float indicating duration before restart.</param>
+        public virtual void Restart(float seconds, bool showDialog)
+        {
             // notifications are done in 15 second increments
             // so ..   if the number of seconds is less then 15 seconds, it's not really a restart request
             // It's a 'Cancel restart' request.
@@ -893,8 +907,11 @@ namespace OpenSim.Region.Framework.Scenes
                 m_restartTimer.Elapsed += new ElapsedEventHandler(RestartTimer_Elapsed);
                 m_log.Info("[REGION]: Restarting Region in " + (seconds / 60) + " minutes");
                 m_restartTimer.Start();
-                m_dialogModule.SendNotificationToUsersInRegion(
-                    UUID.Random(), String.Empty, RegionInfo.RegionName + ": Restarting in 2 Minutes");
+                if (showDialog)
+                {
+                    m_dialogModule.SendNotificationToUsersInRegion(
+                    UUID.Random(), String.Empty, RegionInfo.RegionName + ": Restarting in " + (seconds / 60).ToString() + " Minutes");
+                }
             }
         }
 
@@ -2381,103 +2398,6 @@ namespace OpenSim.Region.Framework.Scenes
             return successYN;
         }
 
-        /// <summary>
-        /// Handle a scene object that is crossing into this region from another.
-        /// NOTE: Unused as of 2009-02-09. Soon to be deleted.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="primID"></param>
-        /// <param name="objXMLData"></param>
-        /// <param name="XMLMethod"></param>
-        /// <returns></returns>
-        public bool IncomingInterRegionPrimGroup(UUID primID, string objXMLData, int XMLMethod)
-        {
-            if (XMLMethod == 0)
-            {
-                m_log.DebugFormat("[INTERREGION]: A new prim {0} arrived from a neighbor", primID);
-                SceneObjectGroup sceneObject = m_serialiser.DeserializeGroupFromXml2(objXMLData);
-                if (sceneObject.IsAttachment)
-                    sceneObject.RootPart.ObjectFlags |= (uint)PrimFlags.Phantom;
-
-                return AddSceneObject(sceneObject);
-            }
-            else if ((XMLMethod == 100) && m_allowScriptCrossings)
-            {
-                m_log.Warn("[INTERREGION]: Prim state data arrived from a neighbor");
-
-                XmlDocument doc = new XmlDocument();
-                doc.LoadXml(objXMLData);
-
-                XmlNodeList rootL = doc.GetElementsByTagName("ScriptData");
-                if (rootL.Count == 1)
-                {
-                    XmlNode rootNode = rootL[0];
-                    if (rootNode != null)
-                    {
-                        XmlNodeList partL = rootNode.ChildNodes;
-
-                        foreach (XmlNode part in partL)
-                        {
-                            XmlNodeList nodeL = part.ChildNodes;
-
-                            switch (part.Name)
-                            {
-                            case "Assemblies":
-                                foreach (XmlNode asm in nodeL)
-                                {
-                                    string fn = asm.Attributes.GetNamedItem("Filename").Value;
-
-                                    Byte[] filedata = Convert.FromBase64String(asm.InnerText);
-                                    string path = Path.Combine("ScriptEngines", RegionInfo.RegionID.ToString());
-                                    path = Path.Combine(path, fn);
-
-                                    if (!File.Exists(path))
-                                    {
-                                        FileStream fs = File.Create(path);
-                                        fs.Write(filedata, 0, filedata.Length);
-                                        fs.Close();
-                                    }
-                                }
-                                break;
-                            case "ScriptStates":
-                                foreach (XmlNode st in nodeL)
-                                {
-                                    string id = st.Attributes.GetNamedItem("UUID").Value;
-                                    UUID uuid = new UUID(id);
-                                    XmlNode state = st.ChildNodes[0];
-
-                                    XmlDocument sdoc = new XmlDocument();
-                                    XmlNode sxmlnode = sdoc.CreateNode(
-                                            XmlNodeType.XmlDeclaration,
-                                            "", "");
-                                    sdoc.AppendChild(sxmlnode);
-
-                                    XmlNode newnode = sdoc.ImportNode(state, true);
-                                    sdoc.AppendChild(newnode);
-
-                                    string spath = Path.Combine("ScriptEngines", RegionInfo.RegionID.ToString());
-                                    spath = Path.Combine(spath, uuid.ToString());
-                                    FileStream sfs = File.Create(spath + ".state");
-                                    ASCIIEncoding enc = new ASCIIEncoding();
-                                    Byte[] buf = enc.GetBytes(sdoc.InnerXml);
-                                    sfs.Write(buf, 0, buf.Length);
-                                    sfs.Close();
-                                }
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                SceneObjectPart RootPrim = GetSceneObjectPart(primID);
-                RootPrim.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, 1);
-
-                return true;
-            }
-
-            return true;
-        }
-
         public bool IncomingCreateObject(ISceneObject sog)
         {
             //m_log.Debug(" >>> IncomingCreateObject <<< " + ((SceneObjectGroup)sog).AbsolutePosition + " deleted? " + ((SceneObjectGroup)sog).IsDeleted);
@@ -3350,7 +3270,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_sceneGridService.OnCloseAgentConnection += IncomingCloseAgent;
             //m_eventManager.OnRegionUp += OtherRegionUp;
             //m_sceneGridService.OnChildAgentUpdate += IncomingChildAgentDataUpdate;
-            m_sceneGridService.OnExpectPrim += IncomingInterRegionPrimGroup;
             //m_sceneGridService.OnRemoveKnownRegionFromAvatar += HandleRemoveKnownRegionsFromAvatar;
             m_sceneGridService.OnLogOffUser += HandleLogOffUserFromGrid;
             m_sceneGridService.KiPrimitive += SendKillObject;
@@ -3374,7 +3293,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_sceneGridService.KiPrimitive -= SendKillObject;
             m_sceneGridService.OnLogOffUser -= HandleLogOffUserFromGrid;
             //m_sceneGridService.OnRemoveKnownRegionFromAvatar -= HandleRemoveKnownRegionsFromAvatar;
-            m_sceneGridService.OnExpectPrim -= IncomingInterRegionPrimGroup;
             //m_sceneGridService.OnChildAgentUpdate -= IncomingChildAgentDataUpdate;
             //m_eventManager.OnRegionUp -= OtherRegionUp;
             m_sceneGridService.OnExpectUser -= HandleNewUserConnection;
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 76c6cab..3892769 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -85,7 +85,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// A Prim will arrive shortly
         /// </summary>
-        public event ExpectPrimDelegate OnExpectPrim;
         public event CloseAgentConnection OnCloseAgentConnection;
 
         /// <summary>
@@ -116,7 +115,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         private AgentCrossing handlerAvatarCrossingIntoRegion = null; // OnAvatarCrossingIntoRegion;
         private ExpectUserDelegate handlerExpectUser = null; // OnExpectUser;
-        private ExpectPrimDelegate handlerExpectPrim = null; // OnExpectPrim;
         private CloseAgentConnection handlerCloseAgentConnection = null; // OnCloseAgentConnection;
         private PrimCrossing handlerPrimCrossingIntoRegion = null; // OnPrimCrossingIntoRegion;
         //private RegionUp handlerRegionUp = null; // OnRegionUp;
@@ -147,30 +145,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// <exception cref="System.Exception">Thrown if region registration fails.</exception>
         public void RegisterRegion(IInterregionCommsOut comms_out, RegionInfo regionInfos)
         {
-            //m_interregionCommsOut = comms_out;
-
-            //m_regionInfo = regionInfos;
-            //m_commsProvider.GridService.gdebugRegionName = regionInfos.RegionName;
-            //regionCommsHost = m_commsProvider.GridService.RegisterRegion(m_regionInfo);
-
-            //if (regionCommsHost != null)
-            //{
-            //    //m_log.Info("[INTER]: " + debugRegionName + ": SceneCommunicationService: registered with gridservice and got" + regionCommsHost.ToString());
-
-            //    regionCommsHost.debugRegionName = regionInfos.RegionName;
-            //    regionCommsHost.OnExpectPrim += IncomingPrimCrossing;
-            //    regionCommsHost.OnExpectUser += NewUserConnection;
-            //    regionCommsHost.OnAvatarCrossingIntoRegion += AgentCrossing;
-            //    regionCommsHost.OnCloseAgentConnection += CloseConnection;
-            //    regionCommsHost.OnRegionUp += newRegionUp;
-            //    regionCommsHost.OnChildAgentUpdate += ChildAgentUpdate;
-            //    regionCommsHost.OnLogOffUser += GridLogOffUser;
-            //    regionCommsHost.OnGetLandData += FetchLandData;
-            //}
-            //else
-            //{
-            //    //m_log.Info("[INTER]: " + debugRegionName + ": SceneCommunicationService: registered with gridservice and got null");
-            //}
         }
 
         /// <summary>
@@ -179,31 +153,6 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void Close()
         {
-
-            //if (regionCommsHost != null)
-            //{
-            //    regionCommsHost.OnLogOffUser -= GridLogOffUser;
-            //    regionCommsHost.OnChildAgentUpdate -= ChildAgentUpdate;
-            //    regionCommsHost.OnRegionUp -= newRegionUp;
-            //    regionCommsHost.OnExpectUser -= NewUserConnection;
-            //    regionCommsHost.OnExpectPrim -= IncomingPrimCrossing;
-            //    regionCommsHost.OnAvatarCrossingIntoRegion -= AgentCrossing;
-            //    regionCommsHost.OnCloseAgentConnection -= CloseConnection;
-            //    regionCommsHost.OnGetLandData -= FetchLandData;
-                
-            //    try
-            //    {
-            //        m_commsProvider.GridService.DeregisterRegion(m_regionInfo);
-            //    }
-            //    catch (Exception e)
-            //    {
-            //        m_log.ErrorFormat(
-            //            "[GRID]: Deregistration of region {0} from the grid failed - {1}.  Continuing", 
-            //            m_regionInfo.RegionName, e);
-            //    }
-                
-            //    regionCommsHost = null;
-            //}
         }
 
         #region CommsManager Event handlers
@@ -263,27 +212,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        /// <summary>
-        /// We have a new prim from a neighbor
-        /// </summary>
-        /// <param name="primID">unique ID for the primative</param>
-        /// <param name="objXMLData">XML2 encoded data of the primative</param>
-        /// <param name="XMLMethod">An Int that represents the version of the XMLMethod</param>
-        /// <returns>True if the prim was accepted, false if it was not</returns>
-        protected bool IncomingPrimCrossing(UUID primID, String objXMLData, int XMLMethod)
-        {
-            handlerExpectPrim = OnExpectPrim;
-            if (handlerExpectPrim != null)
-            {
-                return handlerExpectPrim(primID, objXMLData, XMLMethod);
-            }
-            else
-            {
-                return false;
-            }
-
-        }
-
         protected void PrimCrossing(UUID primID, Vector3 position, bool isPhysical)
         {
             handlerPrimCrossingIntoRegion = OnPrimCrossingIntoRegion;
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index dfaa7ea..c2e3370 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -241,24 +241,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// Save the current scene to an OpenSimulator archive.  This archive will eventually include the prim's assets
         /// as well as the details of the prims themselves.
         /// </summary>
-        /// <param name="filename"></param>
-        public void SaveCurrentSceneToArchive(string filename)
+        /// <param name="cmdparams"></param>
+        public void SaveCurrentSceneToArchive(string[] cmdparams)
         {
             IRegionArchiverModule archiver = CurrentOrFirstScene.RequestModuleInterface<IRegionArchiverModule>();
             if (archiver != null)
-                archiver.ArchiveRegion(filename);
+                archiver.HandleSaveOarConsoleCommand(string.Empty, cmdparams);
         }
 
         /// <summary>
         /// Load an OpenSim archive into the current scene.  This will load both the shapes of the prims and upload
         /// their assets to the asset service.
         /// </summary>
-        /// <param name="filename"></param>
-        public void LoadArchiveToCurrentScene(string filename)
+        /// <param name="cmdparams"></param>
+        public void LoadArchiveToCurrentScene(string[] cmdparams)
         {
             IRegionArchiverModule archiver = CurrentOrFirstScene.RequestModuleInterface<IRegionArchiverModule>();
             if (archiver != null)
-                archiver.DearchiveRegion(filename);
+                archiver.HandleLoadOarConsoleCommand(string.Empty, cmdparams);
         }
 
         public string SaveCurrentSceneMapToXmlString()
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index 3cec77f..5a06bdb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -309,26 +309,15 @@ namespace OpenSim.Region.Framework.Scenes
 
         public string GetStateSnapshot()
         {
-            //m_log.Debug(" >>> GetStateSnapshot <<<");
-
-            List<string> assemblies = new List<string>();
             Dictionary<UUID, string> states = new Dictionary<UUID, string>();
 
             foreach (SceneObjectPart part in m_parts.Values)
             {
-                foreach (string a in part.Inventory.GetScriptAssemblies())
-                {
-                    if (a != "" && !assemblies.Contains(a))
-                        assemblies.Add(a);
-                }
-
                 foreach (KeyValuePair<UUID, string> s in part.Inventory.GetScriptStates())
-                {
                     states[s.Key] = s.Value;
-                }
             }
 
-            if (states.Count < 1 || assemblies.Count < 1)
+            if (states.Count < 1)
                 return "";
 
             XmlDocument xmldoc = new XmlDocument();
@@ -342,104 +331,49 @@ namespace OpenSim.Region.Framework.Scenes
             
             xmldoc.AppendChild(rootElement);
 
-            XmlElement wrapper = xmldoc.CreateElement("", "Assemblies",
-                    "");
             
-            rootElement.AppendChild(wrapper);
-
-            foreach (string assembly in assemblies)
-            {
-                string fn = Path.GetFileName(assembly);
-                if (fn == String.Empty)
-                    continue;
-
-                String filedata = String.Empty;
-
-                if (File.Exists(assembly+".text"))
-                {
-                    FileInfo tfi = new FileInfo(assembly+".text");
-
-                    if (tfi == null)
-                        continue;
-
-                    Byte[] tdata = new Byte[tfi.Length];
-
-                    try
-                    {
-                        FileStream tfs = File.Open(assembly+".text", FileMode.Open, FileAccess.Read);
-                        tfs.Read(tdata, 0, tdata.Length);
-                        tfs.Close();
-                    }
-                    catch (Exception e)
-                    {
-                        m_log.DebugFormat("[SOG]: Unable to open script textfile {0}, reason: {1}", assembly+".text", e.Message);
-                    }
-
-                    filedata = new System.Text.ASCIIEncoding().GetString(tdata);
-                }
-                else
-                {
-                    FileInfo fi = new FileInfo(assembly);
-
-                    if (fi == null)
-                        continue;
-
-                    Byte[] data = new Byte[fi.Length];
-
-                    try
-                    {
-                        FileStream fs = File.Open(assembly, FileMode.Open, FileAccess.Read);
-                        fs.Read(data, 0, data.Length);
-                        fs.Close();
-                    }
-                    catch (Exception e)
-                    {
-                        m_log.DebugFormat("[SOG]: Unable to open script assembly {0}, reason: {1}", assembly, e.Message);
-                    }
-
-                    filedata = System.Convert.ToBase64String(data);
-                }
-                XmlElement assemblyData = xmldoc.CreateElement("", "Assembly", "");
-                XmlAttribute assemblyName = xmldoc.CreateAttribute("", "Filename", "");
-                assemblyName.Value = fn;
-                assemblyData.Attributes.Append(assemblyName);
-
-                assemblyData.InnerText = filedata;
-
-                wrapper.AppendChild(assemblyData);
-            }
-
-            wrapper = xmldoc.CreateElement("", "ScriptStates",
+            XmlElement wrapper = xmldoc.CreateElement("", "ScriptStates",
                     "");
             
             rootElement.AppendChild(wrapper);
 
             foreach (KeyValuePair<UUID, string> state in states)
             {
-                XmlElement stateData = xmldoc.CreateElement("", "State", "");
-
-                XmlAttribute stateID = xmldoc.CreateAttribute("", "UUID", "");
-                stateID.Value = state.Key.ToString();
-                stateData.Attributes.Append(stateID);
-
                 XmlDocument sdoc = new XmlDocument();
                 sdoc.LoadXml(state.Value);
-                XmlNodeList rootL = sdoc.GetElementsByTagName("ScriptState");
+                XmlNodeList rootL = sdoc.GetElementsByTagName("State");
                 XmlNode rootNode = rootL[0];
 
                 XmlNode newNode = xmldoc.ImportNode(rootNode, true);
-                stateData.AppendChild(newNode);
-                wrapper.AppendChild(stateData);
+                wrapper.AppendChild(newNode);
             }
 
             return xmldoc.InnerXml;
         }
 
-        public void SetState(string objXMLData, UUID RegionID)
+        public void SetState(string objXMLData, IScene ins)
         {
+            if (!(ins is Scene))
+                return;
+
+            Scene s = (Scene)ins;
+
             if (objXMLData == String.Empty)
                 return;
 
+            IScriptModule scriptModule = null;
+            
+            foreach (IScriptModule sm in s.RequestModuleInterfaces<IScriptModule>())
+            {
+                if (sm.ScriptEngineName == s.DefaultScriptEngine)
+                    scriptModule = sm;
+                else if (scriptModule == null)
+                    scriptModule = sm;
+            }
+
+            if (scriptModule == null)
+                return;
+
             XmlDocument doc = new XmlDocument();
             try
             {
@@ -457,69 +391,23 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             XmlNodeList rootL = doc.GetElementsByTagName("ScriptData");
-            if (rootL.Count == 1)
+            if (rootL.Count != 1)
+                return;
+
+            XmlElement rootE = (XmlElement)rootL[0];
+
+            XmlNodeList dataL = rootE.GetElementsByTagName("ScriptStates");
+            if (dataL.Count != 1)
+                return;
+
+            XmlElement dataE = (XmlElement)dataL[0];
+            
+            foreach (XmlNode n in dataE.ChildNodes)
             {
-                XmlNode rootNode = rootL[0];
-                if (rootNode != null)
-                {
-                    XmlNodeList partL = rootNode.ChildNodes;
-
-                    foreach (XmlNode part in partL)
-                    {
-                        XmlNodeList nodeL = part.ChildNodes;
-
-                        switch (part.Name)
-                        {
-                            case "Assemblies":
-                                foreach (XmlNode asm in nodeL)
-                                {
-                                    string fn = asm.Attributes.GetNamedItem("Filename").Value;
-
-                                    Byte[] filedata = Convert.FromBase64String(asm.InnerText);
-                                    string path = Path.Combine("ScriptEngines", RegionID.ToString());
-                                    path = Path.Combine(path, fn);
-
-                                    if (!File.Exists(path))
-                                    {
-                                        FileStream fs = File.Create(path);
-                                        fs.Write(filedata, 0, filedata.Length);
-                                        fs.Close();
-
-                                        Byte[] textbytes = new System.Text.ASCIIEncoding().GetBytes(asm.InnerText);
-                                        fs = File.Create(path+".text");
-                                        fs.Write(textbytes, 0, textbytes.Length);
-                                        fs.Close();
-                                    }
-                                }
-                                break;
-                            case "ScriptStates":
-                                foreach (XmlNode st in nodeL)
-                                {
-                                    string id = st.Attributes.GetNamedItem("UUID").Value;
-                                    UUID uuid = new UUID(id);
-                                    XmlNode state = st.ChildNodes[0];
-
-                                    XmlDocument sdoc = new XmlDocument();
-                                    XmlNode sxmlnode = sdoc.CreateNode(
-                                            XmlNodeType.XmlDeclaration,
-                                            "", "");
-                                    sdoc.AppendChild(sxmlnode);
-
-                                    XmlNode newnode = sdoc.ImportNode(state, true);
-                                    sdoc.AppendChild(newnode);
-
-                                    string spath = Path.Combine("ScriptEngines", RegionID.ToString());
-                                    spath = Path.Combine(spath, uuid.ToString());
-                                    FileStream sfs = File.Create(spath + ".state");
-                                    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
-                                    Byte[] buf = enc.GetBytes(sdoc.InnerXml);
-                                    sfs.Write(buf, 0, buf.Length);
-                                    sfs.Close();
-                                }
-                                break;
-                        }
-                    }
-                }
+                XmlElement stateE = (XmlElement)n;
+                UUID itemID = new UUID(stateE.GetAttribute("UUID"));
+
+                scriptModule.SetXMLState(itemID, n.OuterXml);
             }
         }
     }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index ea4f2c7..f36ff1d 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -3380,17 +3380,6 @@ namespace OpenSim.Region.Framework.Scenes
         }
         #endregion 
 
-        public bool CanBeDeleted()
-        {
-            foreach (SceneObjectPart part in Children.Values)
-            {
-                if (!part.CanBeDeleted())
-                    return false;
-            }
-
-            return true;
-        }
-
         public double GetUpdatePriority(IClientAPI client)
         {
             switch (Scene.UpdatePrioritizationScheme)
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index cdec135..19e3023 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -389,12 +389,16 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <value>
-        /// Access should be via Inventory directly - this property temporarily remains for xml serialization purposes
+        /// Get the inventory list
         /// </value>
         public TaskInventoryDictionary TaskInventory
         {
-            get { return m_inventory.Items; }
-            set { m_inventory.Items = value; }
+            get {
+                return m_inventory.Items;
+            }
+            set {
+                m_inventory.Items = value;
+            }
         }
 
         public uint ObjectFlags
@@ -2101,17 +2105,18 @@ namespace OpenSim.Region.Framework.Scenes
                 //Trys to fetch sound id from prim's inventory.
                 //Prim's inventory doesn't support non script items yet
                 
-                lock (TaskInventory)
+                TaskInventory.LockItemsForRead(true);
+
+                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
                 {
-                    foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
+                    if (item.Value.Name == sound)
                     {
-                        if (item.Value.Name == sound)
-                        {
-                            soundID = item.Value.ItemID;
-                            break;
-                        }
+                        soundID = item.Value.ItemID;
+                        break;
                     }
                 }
+
+                TaskInventory.LockItemsForRead(false);
             }
 
             List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
@@ -2457,17 +2462,16 @@ namespace OpenSim.Region.Framework.Scenes
             if (!UUID.TryParse(sound, out soundID))
             {
                 // search sound file from inventory
-                lock (TaskInventory)
+                TaskInventory.LockItemsForRead(true);
+                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
                 {
-                    foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
+                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
                     {
-                        if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
-                        {
-                            soundID = item.Value.ItemID;
-                            break;
-                        }
+                        soundID = item.Value.ItemID;
+                        break;
                     }
                 }
+                TaskInventory.LockItemsForRead(false);
             }
 
             if (soundID == UUID.Zero)
@@ -3803,10 +3807,5 @@ namespace OpenSim.Region.Framework.Scenes
 
             Inventory.ApplyNextOwnerPermissions();
         }
-
-        public bool CanBeDeleted()
-        {
-            return Inventory.CanBeDeleted();
-        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index f4ca877..eca8588 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -80,7 +80,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </value>
         protected internal TaskInventoryDictionary Items
         {
-            get { return m_items; }
+            get { 
+                return m_items; 
+            }
             set
             {
                 m_items = value;
@@ -116,22 +118,25 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="linkNum">Link number for the part</param>
         public void ResetInventoryIDs()
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+
+            if (0 == Items.Count)
             {
-                if (0 == Items.Count)
-                    return;
+                m_items.LockItemsForWrite(false);
+                return;
+            }
 
-                HasInventoryChanged = true;
-                m_part.ParentGroup.HasGroupChanged = true;
-                IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-                Items.Clear();
+            HasInventoryChanged = true;
+            m_part.ParentGroup.HasGroupChanged = true;
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.Clear();
 
-                foreach (TaskInventoryItem item in items)
-                {
-                    item.ResetIDs(m_part.UUID);
-                    Items.Add(item.ItemID, item);
-                }
+            foreach (TaskInventoryItem item in items)
+            {
+                item.ResetIDs(m_part.UUID);
+                Items.Add(item.ItemID, item);
             }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -140,25 +145,25 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="ownerId"></param>
         public void ChangeInventoryOwner(UUID ownerId)
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+            if (0 == Items.Count)
             {
-                if (0 == Items.Count)
-                {
-                    return;
-                }
+                m_items.LockItemsForWrite(false);
+                return;
+            }
 
-                HasInventoryChanged = true;
-                m_part.ParentGroup.HasGroupChanged = true;
-                IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-                foreach (TaskInventoryItem item in items)
+            HasInventoryChanged = true;
+            m_part.ParentGroup.HasGroupChanged = true;
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            foreach (TaskInventoryItem item in items)
+            {
+                if (ownerId != item.OwnerID)
                 {
-                    if (ownerId != item.OwnerID)
-                    {
-                        item.LastOwnerID = item.OwnerID;
-                        item.OwnerID = ownerId;
-                    }
+                    item.LastOwnerID = item.OwnerID;
+                    item.OwnerID = ownerId;
                 }
             }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -167,24 +172,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="groupID"></param>
         public void ChangeInventoryGroup(UUID groupID)
         {
-            lock (Items)
+            m_items.LockItemsForWrite(true);
+            if (0 == Items.Count)
             {
-                if (0 == Items.Count)
-                {
-                    return;
-                }
+                m_items.LockItemsForWrite(false);
+                return;
+            }
 
-                HasInventoryChanged = true;
-                m_part.ParentGroup.HasGroupChanged = true;
-                IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
-                foreach (TaskInventoryItem item in items)
+            HasInventoryChanged = true;
+            m_part.ParentGroup.HasGroupChanged = true;
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            foreach (TaskInventoryItem item in items)
+            {
+                if (groupID != item.GroupID)
                 {
-                    if (groupID != item.GroupID)
-                    {
-                        item.GroupID = groupID;
-                    }
+                    item.GroupID = groupID;
                 }
             }
+            m_items.LockItemsForWrite(false);
         }
 
         /// <summary>
@@ -192,14 +197,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
         {
-            lock (m_items)
+            Items.LockItemsForRead(true);
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.LockItemsForRead(false);
+            foreach (TaskInventoryItem item in items)
             {
-                foreach (TaskInventoryItem item in Items.Values)
+                if ((int)InventoryType.LSL == item.InvType)
                 {
-                    if ((int)InventoryType.LSL == item.InvType)
-                    {
-                        CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
-                    }
+                    CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
                 }
             }
         }
@@ -209,17 +214,20 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void RemoveScriptInstances()
         {
-            lock (Items)
+            Items.LockItemsForRead(true);
+            IList<TaskInventoryItem> items = new List<TaskInventoryItem>(Items.Values);
+            Items.LockItemsForRead(false);
+
+            foreach (TaskInventoryItem item in items)
             {
-                foreach (TaskInventoryItem item in Items.Values)
+                if ((int)InventoryType.LSL == item.InvType)
                 {
-                    if ((int)InventoryType.LSL == item.InvType)
-                    {
-                        RemoveScriptInstance(item.ItemID);
-                        m_part.RemoveScriptEvents(item.ItemID);
-                    }
+                    RemoveScriptInstance(item.ItemID);
+                    m_part.RemoveScriptEvents(item.ItemID);
                 }
             }
+
+            
         }
 
         /// <summary>
@@ -244,8 +252,10 @@ namespace OpenSim.Region.Framework.Scenes
                 if (stateSource == 1 && // Prim crossing
                         m_part.ParentGroup.Scene.m_trustBinaries)
                 {
+                    m_items.LockItemsForWrite(true);
                     m_items[item.ItemID].PermsMask = 0;
                     m_items[item.ItemID].PermsGranter = UUID.Zero;
+                    m_items.LockItemsForWrite(false);
                     m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
                         m_part.LocalId, item.ItemID, String.Empty, startParam, postOnRez, engine, stateSource);
                     m_part.ParentGroup.AddActiveScriptCount(1);
@@ -266,8 +276,10 @@ namespace OpenSim.Region.Framework.Scenes
                                    {
                                        if (m_part.ParentGroup.m_savedScriptState != null)
                                            RestoreSavedScriptState(item.OldItemID, item.ItemID);
+                                       m_items.LockItemsForWrite(true);
                                        m_items[item.ItemID].PermsMask = 0;
                                        m_items[item.ItemID].PermsGranter = UUID.Zero;
+                                       m_items.LockItemsForWrite(false);
                                        string script = Utils.BytesToString(asset.Data);
                                        m_part.ParentGroup.Scene.EventManager.TriggerRezScript(
                                             m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
@@ -302,20 +314,22 @@ namespace OpenSim.Region.Framework.Scenes
         /// </param>
         public void CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
         {
-            lock (m_items)
+            m_items.LockItemsForRead(true);
+            if (m_items.ContainsKey(itemId))
             {
-                if (m_items.ContainsKey(itemId))
-                {
-                    CreateScriptInstance(m_items[itemId], startParam, postOnRez, engine, stateSource);
-                }
-                else
-                {
-                    m_log.ErrorFormat(
-                        "[PRIM INVENTORY]: " +
-                        "Couldn't start script with ID {0} since it couldn't be found for prim {1}, {2}",
-                        itemId, m_part.Name, m_part.UUID);
-                }
+                TaskInventoryItem item = m_items[itemId];
+                m_items.LockItemsForRead(false);
+                CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+            }
+            else
+            {
+                m_items.LockItemsForRead(false);
+                m_log.ErrorFormat(
+                    "[PRIM INVENTORY]: " +
+                    "Couldn't start script with ID {0} since it couldn't be found for prim {1}, {2}",
+                    itemId, m_part.Name, m_part.UUID);
             }
+            
         }
 
         /// <summary>
@@ -346,11 +360,16 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         private bool InventoryContainsName(string name)
         {
-            foreach (TaskInventoryItem item in Items.Values)
+            m_items.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_items.Values)
             {
                 if (item.Name == name)
+                {
+                    m_items.LockItemsForRead(false);
                     return true;
+                }
             }
+            m_items.LockItemsForRead(false);
             return false;
         }
 
@@ -392,7 +411,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="item"></param>
         public void AddInventoryItemExclusive(TaskInventoryItem item, bool allowedDrop)
         {
+            m_items.LockItemsForRead(true);
             List<TaskInventoryItem> il = new List<TaskInventoryItem>(m_items.Values);
+            m_items.LockItemsForRead(false);
             foreach (TaskInventoryItem i in il)
             {
                 if (i.Name == item.Name)
@@ -429,15 +450,14 @@ namespace OpenSim.Region.Framework.Scenes
             item.ParentPartID = m_part.UUID;
             item.Name = name;
 
-            lock (m_items)
-            {
-                m_items.Add(item.ItemID, item);
-
+            m_items.LockItemsForWrite(true);
+            m_items.Add(item.ItemID, item);
+            m_items.LockItemsForWrite(false);
                 if (allowedDrop) 
                     m_part.TriggerScriptChangedEvent(Changed.ALLOWED_DROP);
                 else
                     m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-            }
+            
 
             m_inventorySerial++;
             //m_inventorySerial += 2;
@@ -454,14 +474,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="items"></param>
         public void RestoreInventoryItems(ICollection<TaskInventoryItem> items)
         {
-            lock (m_items)
+            m_items.LockItemsForWrite(true);
+            foreach (TaskInventoryItem item in items)
             {
-                foreach (TaskInventoryItem item in items)
-                {
-                    m_items.Add(item.ItemID, item);
-                    m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-                }
+                m_items.Add(item.ItemID, item);
+                m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
             }
+            m_items.LockItemsForWrite(false);
 
             m_inventorySerial++;
         }
@@ -474,8 +493,9 @@ namespace OpenSim.Region.Framework.Scenes
         public TaskInventoryItem GetInventoryItem(UUID itemId)
         {
             TaskInventoryItem item;
+            m_items.LockItemsForRead(true);
             m_items.TryGetValue(itemId, out item);
-
+            m_items.LockItemsForRead(false);
             return item;
         }
 
@@ -487,45 +507,45 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns>false if the item did not exist, true if the update occurred successfully</returns>
         public bool UpdateInventoryItem(TaskInventoryItem item)
         {
-            lock (m_items)
+            m_items.LockItemsForWrite(true);
+
+            if (m_items.ContainsKey(item.ItemID))
             {
-                if (m_items.ContainsKey(item.ItemID))
+                item.ParentID = m_part.UUID;
+                item.ParentPartID = m_part.UUID;
+                item.Flags = m_items[item.ItemID].Flags;
+                if (item.AssetID == UUID.Zero)
                 {
-                    item.ParentID = m_part.UUID;
-                    item.ParentPartID = m_part.UUID;
-                    item.Flags = m_items[item.ItemID].Flags;
-                    if (item.AssetID == UUID.Zero)
-                    {
-                        item.AssetID = m_items[item.ItemID].AssetID;
-                    }
-                    else if ((InventoryType)item.Type == InventoryType.Notecard)
-                    {
-                        ScenePresence presence = m_part.ParentGroup.Scene.GetScenePresence(item.OwnerID);
+                    item.AssetID = m_items[item.ItemID].AssetID;
+                }
+                else if ((InventoryType)item.Type == InventoryType.Notecard)
+                {
+                    ScenePresence presence = m_part.ParentGroup.Scene.GetScenePresence(item.OwnerID);
 
-                        if (presence != null)
-                        {
-                            presence.ControllingClient.SendAgentAlertMessage(
-                                    "Notecard saved", false);
-                        }
+                    if (presence != null)
+                    {
+                        presence.ControllingClient.SendAgentAlertMessage(
+                                "Notecard saved", false);
                     }
+                }
 
-                    m_items[item.ItemID] = item;
-                    m_inventorySerial++;
-                    m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-
-                    HasInventoryChanged = true;
-                    m_part.ParentGroup.HasGroupChanged = true;
+                m_items[item.ItemID] = item;
+                m_inventorySerial++;
+                m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
 
-                    return true;
-                }
-                else
-                {
-                    m_log.ErrorFormat(
-                        "[PRIM INVENTORY]: " +
-                        "Tried to retrieve item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
-                        item.ItemID, m_part.Name, m_part.UUID);
-                }
+                HasInventoryChanged = true;
+                m_part.ParentGroup.HasGroupChanged = true;
+                m_items.LockItemsForWrite(false);
+                return true;
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[PRIM INVENTORY]: " +
+                    "Tried to retrieve item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
+                    item.ItemID, m_part.Name, m_part.UUID);
             }
+            m_items.LockItemsForWrite(false);
 
             return false;
         }
@@ -538,51 +558,54 @@ namespace OpenSim.Region.Framework.Scenes
         /// in this prim's inventory.</returns>
         public int RemoveInventoryItem(UUID itemID)
         {
-            lock (m_items)
+            m_items.LockItemsForRead(true);
+
+            if (m_items.ContainsKey(itemID))
             {
-                if (m_items.ContainsKey(itemID))
+                int type = m_items[itemID].InvType;
+                m_items.LockItemsForRead(false);
+                if (type == 10) // Script
                 {
-                    int type = m_items[itemID].InvType;
-                    if (type == 10) // Script
-                    {
-                        m_part.ParentGroup.Scene.EventManager.TriggerRemoveScript(m_part.LocalId, itemID);
-                    }
-                    m_items.Remove(itemID);
-                    m_inventorySerial++;
-                    m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-
-                    HasInventoryChanged = true;
-                    m_part.ParentGroup.HasGroupChanged = true;
+                    m_part.ParentGroup.Scene.EventManager.TriggerRemoveScript(m_part.LocalId, itemID);
+                }
+                m_items.LockItemsForWrite(true);
+                m_items.Remove(itemID);
+                m_items.LockItemsForWrite(false);
+                m_inventorySerial++;
+                m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
 
-                    int scriptcount = 0;
-                    lock (m_items)
-                    {
-                        foreach (TaskInventoryItem item in m_items.Values)
-                        {
-                            if (item.Type == 10)
-                            {
-                                scriptcount++;
-                            }
-                        }
-                    }
+                HasInventoryChanged = true;
+                m_part.ParentGroup.HasGroupChanged = true;
 
-                    if (scriptcount <= 0)
+                int scriptcount = 0;
+                m_items.LockItemsForRead(true);
+                foreach (TaskInventoryItem item in m_items.Values)
+                {
+                    if (item.Type == 10)
                     {
-                        m_part.RemFlag(PrimFlags.Scripted);
+                        scriptcount++;
                     }
-
-                    m_part.ScheduleFullUpdate();
-
-                    return type;
                 }
-                else
+                m_items.LockItemsForRead(false);
+                
+
+                if (scriptcount <= 0)
                 {
-                    m_log.ErrorFormat(
-                        "[PRIM INVENTORY]: " +
-                        "Tried to remove item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
-                        itemID, m_part.Name, m_part.UUID);
+                    m_part.RemFlag(PrimFlags.Scripted);
                 }
+
+                m_part.ScheduleFullUpdate();
+
+                return type;
             }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[PRIM INVENTORY]: " +
+                    "Tried to remove item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
+                    itemID, m_part.Name, m_part.UUID);
+            }
+            m_items.LockItemsForWrite(false);
 
             return -1;
         }
@@ -635,52 +658,53 @@ namespace OpenSim.Region.Framework.Scenes
             // isn't available (such as drag from prim inventory to agent inventory)
             InventoryStringBuilder invString = new InventoryStringBuilder(m_part.UUID, UUID.Zero);
 
-            lock (m_items)
+            m_items.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_items.Values)
             {
-                foreach (TaskInventoryItem item in m_items.Values)
-                {
-                    UUID ownerID = item.OwnerID;
-                    uint everyoneMask = 0;
-                    uint baseMask = item.BasePermissions;
-                    uint ownerMask = item.CurrentPermissions;
+                UUID ownerID = item.OwnerID;
+                uint everyoneMask = 0;
+                uint baseMask = item.BasePermissions;
+                uint ownerMask = item.CurrentPermissions;
 
-                    invString.AddItemStart();
-                    invString.AddNameValueLine("item_id", item.ItemID.ToString());
-                    invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
+                invString.AddItemStart();
+                invString.AddNameValueLine("item_id", item.ItemID.ToString());
+                invString.AddNameValueLine("parent_id", m_part.UUID.ToString());
 
-                    invString.AddPermissionsStart();
+                invString.AddPermissionsStart();
 
-                    invString.AddNameValueLine("base_mask", Utils.UIntToHexString(baseMask));
-                    invString.AddNameValueLine("owner_mask", Utils.UIntToHexString(ownerMask));
-                    invString.AddNameValueLine("group_mask", Utils.UIntToHexString(0));
-                    invString.AddNameValueLine("everyone_mask", Utils.UIntToHexString(everyoneMask));
-                    invString.AddNameValueLine("next_owner_mask", Utils.UIntToHexString(item.NextPermissions));
+                invString.AddNameValueLine("base_mask", Utils.UIntToHexString(baseMask));
+                invString.AddNameValueLine("owner_mask", Utils.UIntToHexString(ownerMask));
+                invString.AddNameValueLine("group_mask", Utils.UIntToHexString(0));
+                invString.AddNameValueLine("everyone_mask", Utils.UIntToHexString(everyoneMask));
+                invString.AddNameValueLine("next_owner_mask", Utils.UIntToHexString(item.NextPermissions));
 
-                    invString.AddNameValueLine("creator_id", item.CreatorID.ToString());
-                    invString.AddNameValueLine("owner_id", ownerID.ToString());
+                invString.AddNameValueLine("creator_id", item.CreatorID.ToString());
+                invString.AddNameValueLine("owner_id", ownerID.ToString());
 
-                    invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
+                invString.AddNameValueLine("last_owner_id", item.LastOwnerID.ToString());
 
-                    invString.AddNameValueLine("group_id", item.GroupID.ToString());
-                    invString.AddSectionEnd();
+                invString.AddNameValueLine("group_id", item.GroupID.ToString());
+                invString.AddSectionEnd();
 
-                    invString.AddNameValueLine("asset_id", item.AssetID.ToString());
-                    invString.AddNameValueLine("type", TaskInventoryItem.Types[item.Type]);
-                    invString.AddNameValueLine("inv_type", TaskInventoryItem.InvTypes[item.InvType]);
-                    invString.AddNameValueLine("flags", Utils.UIntToHexString(item.Flags));
+                invString.AddNameValueLine("asset_id", item.AssetID.ToString());
+                invString.AddNameValueLine("type", TaskInventoryItem.Types[item.Type]);
+                invString.AddNameValueLine("inv_type", TaskInventoryItem.InvTypes[item.InvType]);
+                invString.AddNameValueLine("flags", Utils.UIntToHexString(item.Flags));
 
-                    invString.AddSaleStart();
-                    invString.AddNameValueLine("sale_type", "not");
-                    invString.AddNameValueLine("sale_price", "0");
-                    invString.AddSectionEnd();
+                invString.AddSaleStart();
+                invString.AddNameValueLine("sale_type", "not");
+                invString.AddNameValueLine("sale_price", "0");
+                invString.AddSectionEnd();
 
-                    invString.AddNameValueLine("name", item.Name + "|");
-                    invString.AddNameValueLine("desc", item.Description + "|");
+                invString.AddNameValueLine("name", item.Name + "|");
+                invString.AddNameValueLine("desc", item.Description + "|");
 
-                    invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
-                    invString.AddSectionEnd();
-                }
+                invString.AddNameValueLine("creation_date", item.CreationDate.ToString());
+                invString.AddSectionEnd();
             }
+            int count = m_items.Count;
+            m_items.LockItemsForRead(false);
 
             fileData = Utils.StringToBytes(invString.BuildString);
 
@@ -701,10 +725,9 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (HasInventoryChanged)
             {
-                lock (Items)
-                {
-                    datastore.StorePrimInventory(m_part.UUID, Items.Values);
-                }
+                Items.LockItemsForRead(true);
+                datastore.StorePrimInventory(m_part.UUID, Items.Values);
+                Items.LockItemsForRead(false);
 
                 HasInventoryChanged = false;
             }
@@ -857,36 +880,6 @@ namespace OpenSim.Region.Framework.Scenes
             return ret;
         }
         
-        public string[] GetScriptAssemblies()
-        {
-            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
-
-            List<string> ret = new List<string>();
-            if (engines == null) // No engine at all
-                return new string[0];
-
-            foreach (TaskInventoryItem item in m_items.Values)
-            {
-                if (item.InvType == (int)InventoryType.LSL)
-                {
-                    foreach (IScriptModule e in engines)
-                    {
-                        if (e != null)
-                        {
-                            string n = e.GetAssemblyName(item.ItemID);
-                            if (n != String.Empty)
-                            {
-                                if (!ret.Contains(n))
-                                    ret.Add(n);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            return ret.ToArray();
-        }
-        
         public Dictionary<UUID, string> GetScriptStates()
         {
             IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
@@ -916,30 +909,5 @@ namespace OpenSim.Region.Framework.Scenes
             }
             return ret;
         }
-
-        public bool CanBeDeleted()
-        {
-            if (!ContainsScripts())
-                return true;
-
-            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
-
-            if (engines == null) // No engine at all
-                return true;
-
-            foreach (TaskInventoryItem item in m_items.Values)
-            {
-                if (item.InvType == (int)InventoryType.LSL)
-                {
-                    foreach (IScriptModule e in engines)
-                    {
-                        if (!e.CanBeDeleted(item.ItemID))
-                            return false;
-                    }
-                }
-            }
-
-            return true;
-        }
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index e677cfd..cebd108 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -171,7 +171,7 @@ namespace OpenSim.Region.Framework.Scenes
         protected RegionInfo m_regionInfo;
         protected ulong crossingFromRegion;
 
-        private readonly Vector3[] Dir_Vectors = new Vector3[9];
+        private readonly Vector3[] Dir_Vectors = new Vector3[11];
         private bool m_isNudging = false;
 
         // Position of agent's camera in world (region cordinates)
@@ -241,6 +241,8 @@ namespace OpenSim.Region.Framework.Scenes
             DIR_CONTROL_FLAG_DOWN = AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG,
             DIR_CONTROL_FLAG_FORWARD_NUDGE = AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_POS,
             DIR_CONTROL_FLAG_BACK_NUDGE = AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_AT_NEG,
+            DIR_CONTROL_FLAG_LEFT_NUDGE = AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_POS,
+            DIR_CONTROL_FLAG_RIGHT_NUDGE = AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_LEFT_NEG,
             DIR_CONTROL_FLAG_DOWN_NUDGE = AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG
         }
         
@@ -725,12 +727,14 @@ namespace OpenSim.Region.Framework.Scenes
             Dir_Vectors[5] = -Vector3.UnitZ; //DOWN
             Dir_Vectors[6] = new Vector3(0.5f, 0f, 0f); //FORWARD_NUDGE
             Dir_Vectors[7] = new Vector3(-0.5f, 0f, 0f);  //BACK_NUDGE
-            Dir_Vectors[8] = new Vector3(0f, 0f, -0.5f); //DOWN_Nudge
+            Dir_Vectors[8] = new Vector3(0f, 0.5f, 0f);  //LEFT_NUDGE
+            Dir_Vectors[9] = new Vector3(0f, -0.5f, 0f);  //RIGHT_NUDGE
+            Dir_Vectors[10] = new Vector3(0f, 0f, -0.5f); //DOWN_Nudge
         }
 
         private Vector3[] GetWalkDirectionVectors()
         {
-            Vector3[] vector = new Vector3[9];
+            Vector3[] vector = new Vector3[11];
             vector[0] = new Vector3(m_CameraUpAxis.Z, 0f, -m_CameraAtAxis.Z); //FORWARD
             vector[1] = new Vector3(-m_CameraUpAxis.Z, 0f, m_CameraAtAxis.Z); //BACK
             vector[2] = Vector3.UnitY; //LEFT
@@ -739,13 +743,15 @@ namespace OpenSim.Region.Framework.Scenes
             vector[5] = new Vector3(-m_CameraAtAxis.Z, 0f, -m_CameraUpAxis.Z); //DOWN
             vector[6] = new Vector3(m_CameraUpAxis.Z, 0f, -m_CameraAtAxis.Z); //FORWARD_NUDGE
             vector[7] = new Vector3(-m_CameraUpAxis.Z, 0f, m_CameraAtAxis.Z); //BACK_NUDGE
-            vector[8] = new Vector3(-m_CameraAtAxis.Z, 0f, -m_CameraUpAxis.Z); //DOWN_Nudge
+            vector[8] = Vector3.UnitY; //LEFT_NUDGE
+            vector[9] = -Vector3.UnitY; //RIGHT_NUDGE
+            vector[10] = new Vector3(-m_CameraAtAxis.Z, 0f, -m_CameraUpAxis.Z); //DOWN_NUDGE
             return vector;
         }
         
         private bool[] GetDirectionIsNudge()
         {
-            bool[] isNudge = new bool[9];
+            bool[] isNudge = new bool[11];
             isNudge[0] = false; //FORWARD
             isNudge[1] = false; //BACK
             isNudge[2] = false; //LEFT
@@ -754,7 +760,9 @@ namespace OpenSim.Region.Framework.Scenes
             isNudge[5] = false; //DOWN
             isNudge[6] = true; //FORWARD_NUDGE
             isNudge[7] = true; //BACK_NUDGE
-            isNudge[8] = true; //DOWN_Nudge
+            isNudge[8] = true; //LEFT_NUDGE
+            isNudge[9] = true; //RIGHT_NUDGE
+            isNudge[10] = true; //DOWN_Nudge
             return isNudge;
         }
 
@@ -1618,21 +1626,19 @@ namespace OpenSim.Region.Framework.Scenes
                 SceneObjectPart part = m_scene.GetSceneObjectPart(m_parentID);
                 if (part != null)
                 {
+                    part.TaskInventory.LockItemsForRead(true);
                     TaskInventoryDictionary taskIDict = part.TaskInventory;
                     if (taskIDict != null)
                     {
-                        lock (taskIDict)
+                        foreach (UUID taskID in taskIDict.Keys)
                         {
-                            foreach (UUID taskID in taskIDict.Keys)
-                            {
-                                UnRegisterControlEventsToScript(LocalId, taskID);
-                                taskIDict[taskID].PermsMask &= ~(
-                                    2048 | //PERMISSION_CONTROL_CAMERA
-                                    4); // PERMISSION_TAKE_CONTROLS
-                            }
+                            UnRegisterControlEventsToScript(LocalId, taskID);
+                            taskIDict[taskID].PermsMask &= ~(
+                                2048 | //PERMISSION_CONTROL_CAMERA
+                                4); // PERMISSION_TAKE_CONTROLS
                         }
-
                     }
+                    part.TaskInventory.LockItemsForRead(false);
                     // Reset sit target.
                     if (part.GetAvatarOnSitTarget() == UUID)
                         part.SetAvatarOnSitTarget(UUID.Zero);
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index ee288b3..56c6ed6 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -82,6 +82,7 @@ namespace OpenSim.Region.Framework.Scenes
         private int m_fps = 0;
         // saved last reported value so there is something available for llGetRegionFPS 
         private float lastReportedSimFPS = 0;
+                private float[] lastReportedSimStats = new float[21];
         private float m_pfps = 0;
         private int m_agentUpdates = 0;
 
@@ -259,6 +260,11 @@ namespace OpenSim.Region.Framework.Scenes
 
                 sb[20].StatID = (uint)Stats.ScriptLinesPerSecond;
                 sb[20].StatValue = m_scriptLinesPerSecond / statsUpdateFactor;
+                                
+                                for (int i = 0; i < 21; i++)
+                                {
+                                        lastReportedSimStats[i] = sb[i].StatValue;
+                                }
               
                 SimStats simStats 
                     = new SimStats(
@@ -438,6 +444,11 @@ namespace OpenSim.Region.Framework.Scenes
         {
             return lastReportedSimFPS;
         }
+                
+                public float[] getLastReportedSimStats()
+                {
+                        return lastReportedSimStats;
+                }
 
         public void AddPacketsStats(int inPackets, int outPackets, int unAckedBytes)
         {
diff --git a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
index 91c25a6..c653e98 100644
--- a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
@@ -62,7 +62,7 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
             
         public void Initialise(IConfigSource config)
         {
-            m_log.Info("[RegionReady] Initialising");
+            //m_log.Info("[RegionReady] Initialising");
 
             m_config = config.Configs["RegionReady"];
             if (m_config != null) 
@@ -74,8 +74,8 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
                 } 
             }
 
-            if (!m_enabled)
-                m_log.Info("[RegionReady] disabled.");
+//            if (!m_enabled)
+//                m_log.Info("[RegionReady] disabled.");
         }
 
         public void AddRegion(Scene scene)
@@ -92,7 +92,7 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
             m_scene.EventManager.OnEmptyScriptCompileQueue += OnEmptyScriptCompileQueue;
             m_scene.EventManager.OnOarFileLoaded += OnOarFileLoaded;
 
-            m_log.InfoFormat("[RegionReady]: Enabled for region {0}", scene.RegionInfo.RegionName);
+            m_log.DebugFormat("[RegionReady]: Enabled for region {0}", scene.RegionInfo.RegionName);
         }
 
         public void RemoveRegion(Scene scene)
@@ -120,7 +120,6 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
         }
 
         #endregion
-
         
         void OnEmptyScriptCompileQueue(int numScriptsFailed, string message)
         {
diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
index e6b31ca..a0aba2a 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -835,7 +835,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                 // allows us to have different settings
                 
                 // We only need to test p2 for 'jump crouch purposes'
-                if (p2 is OdeCharacter)
+                if (p2 is OdeCharacter && p1.PhysicsActorType == (int)ActorTypes.Prim)
                 {
                     // Testing if the collision is at the feet of the avatar
 
diff --git a/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs b/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
index 146ec66..9da818a 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
@@ -118,6 +118,7 @@ public class RegionCombinerLargeLandChannel : ILandChannel
                         return regionData.RegionScene.LandChannel.GetLandObject(x - offsetX, y - offsetY);
                     }
                 }
+                
                 ILandObject obj = new LandObject(UUID.Zero, false, RegData.RegionScene);
                 obj.LandData.Name = "NO LAND";
                 return obj;
diff --git a/OpenSim/Region/ScriptEngine/Interfaces/IScriptInstance.cs b/OpenSim/Region/ScriptEngine/Interfaces/IScriptInstance.cs
index f49aea8..ae148a9 100644
--- a/OpenSim/Region/ScriptEngine/Interfaces/IScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Interfaces/IScriptInstance.cs
@@ -96,7 +96,6 @@ namespace OpenSim.Region.ScriptEngine.Interfaces
         UUID GetDetectID(int idx);
         void SaveState(string assembly);
         void DestroyScriptInstance();
-        bool CanBeDeleted();
 
         IScriptApi GetApi(string name);
 
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 50b2fb5..8274fbf 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics; //for [DebuggerNonUserCode]
 using System.Runtime.Remoting.Lifetime;
 using System.Text;
 using System.Threading;
@@ -151,6 +152,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             get { return m_ScriptEngine.World; }
         }
 
+        [DebuggerNonUserCode]
         public void state(string newState)
         {
             m_ScriptEngine.SetState(m_itemID, newState);
@@ -160,6 +162,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         /// Reset the named script. The script must be present
         /// in the same prim.
         /// </summary>
+        [DebuggerNonUserCode]
         public void llResetScript()
         {
             m_host.AddScriptLPS(1);
@@ -272,40 +275,48 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         protected UUID InventorySelf()
         {
             UUID invItemID = new UUID();
-
-            lock (m_host.TaskInventory)
+            bool unlock = false;
+            if (!m_host.TaskInventory.IsReadLockedByMe())
+            {
+                m_host.TaskInventory.LockItemsForRead(true);
+                unlock = true;
+            }
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID)
                 {
-                    if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID)
-                    {
-                        invItemID = inv.Key;
-                        break;
-                    }
+                    invItemID = inv.Key;
+                    break;
                 }
             }
-
+            if (unlock)
+            {
+                m_host.TaskInventory.LockItemsForRead(false);
+            }
             return invItemID;
         }
 
         protected UUID InventoryKey(string name, int type)
         {
             m_host.AddScriptLPS(1);
-
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    
+                    if (inv.Value.Type != type)
                     {
-                        if (inv.Value.Type != type)
-                            return UUID.Zero;
-
-                        return inv.Value.AssetID;
+                        return UUID.Zero;
                     }
+
+                    return inv.Value.AssetID;
                 }
             }
 
+            m_host.TaskInventory.LockItemsForRead(false);
             return UUID.Zero;
         }
 
@@ -313,17 +324,21 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            
+            m_host.TaskInventory.LockItemsForRead(true);
+
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
-                    {
-                        return inv.Value.AssetID;
-                    }
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return inv.Value.AssetID;
                 }
             }
 
+            m_host.TaskInventory.LockItemsForRead(false);
+
+
             return UUID.Zero;
         }
 
@@ -1987,6 +2002,18 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
 //KF:  Do NOT use this next line if using ODE physics engine. This need a switch based on .ini Phys Engine type
 //          part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition;
+            
+            // So, after thinking about this for a bit, the issue with the part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition line
+            // is it isn't compatible with vehicles because it causes the vehicle body to have to be broken down and rebuilt
+            // It's perfectly okay when the object is not an active physical body though.
+            // So, part.ParentGroup.ResetChildPrimPhysicsPositions(); does the thing that Kitto is warning against
+            // but only if the object is not physial and active.   This is important for rotating doors.
+            // without the absoluteposition = absoluteposition happening, the doors do not move in the physics
+            // scene
+            if (part.PhysActor != null && !part.PhysActor.IsPhysical)
+            {
+                part.ParentGroup.ResetChildPrimPhysicsPositions();
+            }
         }
 
         /// <summary>
@@ -2534,12 +2561,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             m_host.AddScriptLPS(1);
 
+            m_host.TaskInventory.LockItemsForRead(true);
             TaskInventoryItem item = m_host.TaskInventory[invItemID];
-
-            lock (m_host.TaskInventory)
-            {
-                item = m_host.TaskInventory[invItemID];
-            }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (item.PermsGranter == UUID.Zero)
                 return 0;
@@ -2614,6 +2638,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (dist > m_ScriptDistanceFactor * 10.0f)
                 return;
 
+            //Clone is thread-safe
             TaskInventoryDictionary partInventory = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
 
             foreach (KeyValuePair<UUID, TaskInventoryItem> inv in partInventory)
@@ -2747,13 +2772,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
             {
-                if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
-                    return;
-                else
-                    item = m_host.TaskInventory[InventorySelf()];
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
             }
+            else
+            {
+                item = m_host.TaskInventory[InventorySelf()];
+            }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (item.PermsGranter != UUID.Zero)
             {
@@ -2775,13 +2804,21 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             TaskInventoryItem item;
 
+            m_host.TaskInventory.LockItemsForRead(true);
             lock (m_host.TaskInventory)
             {
+                
                 if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
+                {
+                    m_host.TaskInventory.LockItemsForRead(false);
                     return;
+                }
                 else
+                {
                     item = m_host.TaskInventory[InventorySelf()];
+                }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             m_host.AddScriptLPS(1);
 
@@ -2818,14 +2855,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
             {
-                if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
-                    return;
-                else
-                    item = m_host.TaskInventory[InventorySelf()];
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            else
+            {
+                item = m_host.TaskInventory[InventorySelf()];
             }
 
+            m_host.TaskInventory.LockItemsForRead(false);
+
             if (item.PermsGranter != m_host.OwnerID)
                 return;
 
@@ -2850,13 +2893,19 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
             {
-                if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
-                    return;
-                else
-                    item = m_host.TaskInventory[InventorySelf()];
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            else
+            {
+                item = m_host.TaskInventory[InventorySelf()];
             }
+            m_host.TaskInventory.LockItemsForRead(false);
+
 
             if (item.PermsGranter != m_host.OwnerID)
                 return;
@@ -3080,14 +3129,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
             {
-                if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
-                    return;
-                else
-                    item = m_host.TaskInventory[InventorySelf()];
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
             }
-
+            else
+            {
+                item = m_host.TaskInventory[InventorySelf()];
+            }
+            m_host.TaskInventory.LockItemsForRead(false);
             if (item.PermsGranter == UUID.Zero)
                 return;
 
@@ -3117,13 +3169,18 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
             {
-                if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
-                    return;
-                else
-                    item = m_host.TaskInventory[InventorySelf()];
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            else
+            {
+                item = m_host.TaskInventory[InventorySelf()];
             }
+            m_host.TaskInventory.LockItemsForRead(false);
+            
 
             if (item.PermsGranter == UUID.Zero)
                 return;
@@ -3196,10 +3253,18 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             TaskInventoryItem item;
 
-            lock (m_host.TaskInventory)
+
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (!m_host.TaskInventory.ContainsKey(invItemID))
+            {
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            else
             {
                 item = m_host.TaskInventory[invItemID];
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (agentID == UUID.Zero || perm == 0) // Releasing permissions
             {
@@ -3231,11 +3296,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
                 if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
                 {
-                    lock (m_host.TaskInventory)
-                    {
-                        m_host.TaskInventory[invItemID].PermsGranter = agentID;
-                        m_host.TaskInventory[invItemID].PermsMask = perm;
-                    }
+                    m_host.TaskInventory.LockItemsForWrite(true);
+                    m_host.TaskInventory[invItemID].PermsGranter = agentID;
+                    m_host.TaskInventory[invItemID].PermsMask = perm;
+                    m_host.TaskInventory.LockItemsForWrite(false);
 
                     m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
                             "run_time_permissions", new Object[] {
@@ -3255,11 +3319,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
                 if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
                 {
-                    lock (m_host.TaskInventory)
-                    {
-                        m_host.TaskInventory[invItemID].PermsGranter = agentID;
-                        m_host.TaskInventory[invItemID].PermsMask = perm;
-                    }
+                    m_host.TaskInventory.LockItemsForWrite(true);
+                    m_host.TaskInventory[invItemID].PermsGranter = agentID;
+                    m_host.TaskInventory[invItemID].PermsMask = perm;
+                    m_host.TaskInventory.LockItemsForWrite(false);
 
                     m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
                             "run_time_permissions", new Object[] {
@@ -3280,11 +3343,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
                 if (!m_waitingForScriptAnswer)
                 {
-                    lock (m_host.TaskInventory)
-                    {
-                        m_host.TaskInventory[invItemID].PermsGranter = agentID;
-                        m_host.TaskInventory[invItemID].PermsMask = 0;
-                    }
+                    m_host.TaskInventory.LockItemsForWrite(true);
+                    m_host.TaskInventory[invItemID].PermsGranter = agentID;
+                    m_host.TaskInventory[invItemID].PermsMask = 0;
+                    m_host.TaskInventory.LockItemsForWrite(false);
 
                     presence.ControllingClient.OnScriptAnswer += handleScriptAnswer;
                     m_waitingForScriptAnswer=true;
@@ -3319,10 +3381,11 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if ((answer & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) == 0)
                 llReleaseControls();
 
-            lock (m_host.TaskInventory)
-            {
-                m_host.TaskInventory[invItemID].PermsMask = answer;
-            }
+            
+            m_host.TaskInventory.LockItemsForWrite(true);
+            m_host.TaskInventory[invItemID].PermsMask = answer;
+            m_host.TaskInventory.LockItemsForWrite(false);
+            
 
             m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
                     "run_time_permissions", new Object[] {
@@ -3334,16 +3397,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
             {
-                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                if (item.Type == 10 && item.ItemID == m_itemID)
                 {
-                    if (item.Type == 10 && item.ItemID == m_itemID)
-                    {
-                        return item.PermsGranter.ToString();
-                    }
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return item.PermsGranter.ToString();
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return UUID.Zero.ToString();
         }
@@ -3352,19 +3416,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
             {
-                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                if (item.Type == 10 && item.ItemID == m_itemID)
                 {
-                    if (item.Type == 10 && item.ItemID == m_itemID)
-                    {
-                        int perms = item.PermsMask;
-                        if (m_automaticLinkPermission)
-                            perms |= ScriptBaseClass.PERMISSION_CHANGE_LINKS;
-                        return perms;
-                    }
+                    int perms = item.PermsMask;
+                    if (m_automaticLinkPermission)
+                        perms |= ScriptBaseClass.PERMISSION_CHANGE_LINKS;
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return perms;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return 0;
         }
@@ -3397,11 +3462,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             UUID invItemID = InventorySelf();
 
             TaskInventoryItem item;
-            lock (m_host.TaskInventory)
-            {
-                item = m_host.TaskInventory[invItemID];
-            }
-
+            m_host.TaskInventory.LockItemsForRead(true);
+            item = m_host.TaskInventory[invItemID];
+            m_host.TaskInventory.LockItemsForRead(false);
+             
             if ((item.PermsMask & ScriptBaseClass.PERMISSION_CHANGE_LINKS) == 0
                 && !m_automaticLinkPermission)
             {
@@ -3454,16 +3518,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             UUID invItemID = InventorySelf();
 
-            lock (m_host.TaskInventory)
-            {
+            m_host.TaskInventory.LockItemsForRead(true);
                 if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_CHANGE_LINKS) == 0
                     && !m_automaticLinkPermission)
                 {
                     ShoutError("Script trying to link but PERMISSION_CHANGE_LINKS permission not set!");
+                    m_host.TaskInventory.LockItemsForRead(false);
                     return;
                 }
-            }
-
+            m_host.TaskInventory.LockItemsForRead(false);
+            
             if (linknum < ScriptBaseClass.LINK_THIS)
                 return;
 
@@ -3632,17 +3696,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             int count = 0;
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Type == type || type == -1)
                 {
-                    if (inv.Value.Type == type || type == -1)
-                    {
-                        count = count + 1;
-                    }
+                    count = count + 1;
                 }
             }
-
+            
+            m_host.TaskInventory.LockItemsForRead(false);
             return count;
         }
 
@@ -3651,16 +3714,15 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             ArrayList keys = new ArrayList();
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Type == type || type == -1)
                 {
-                    if (inv.Value.Type == type || type == -1)
-                    {
-                        keys.Add(inv.Value.Name);
-                    }
+                    keys.Add(inv.Value.Name);
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (keys.Count == 0)
             {
@@ -3697,20 +3759,19 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             }
 
             // move the first object found with this inventory name
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == inventory)
                 {
-                    if (inv.Value.Name == inventory)
-                    {
-                        found = true;
-                        objId = inv.Key;
-                        assetType = inv.Value.Type;
-                        objName = inv.Value.Name;
-                        break;
-                    }
+                    found = true;
+                    objId = inv.Key;
+                    assetType = inv.Value.Type;
+                    objName = inv.Value.Name;
+                    break;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (!found)
             {
@@ -3755,24 +3816,26 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             ScriptSleep(3000);
         }
 
+        [DebuggerNonUserCode]
         public void llRemoveInventory(string name)
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
             {
-                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                if (item.Name == name)
                 {
-                    if (item.Name == name)
-                    {
-                        if (item.ItemID == m_itemID)
-                            throw new ScriptDeleteException();
-                        else
-                            m_host.Inventory.RemoveInventoryItem(item.ItemID);
-                        return;
-                    }
+                    if (item.ItemID == m_itemID)
+                        throw new ScriptDeleteException();
+                    else
+                        m_host.Inventory.RemoveInventoryItem(item.ItemID);
+
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
         }
 
         public void llSetText(string text, LSL_Vector color, double alpha)
@@ -3861,6 +3924,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
+            //Clone is thread safe
             TaskInventoryDictionary itemDictionary = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
 
             foreach (TaskInventoryItem item in itemDictionary.Values)
@@ -3951,17 +4015,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             UUID soundId = UUID.Zero;
             if (!UUID.TryParse(impact_sound, out soundId))
             {
-                lock (m_host.TaskInventory)
+                m_host.TaskInventory.LockItemsForRead(true);
+                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
                 {
-                    foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                    if (item.Type == (int)AssetType.Sound && item.Name == impact_sound)
                     {
-                        if (item.Type == (int)AssetType.Sound && item.Name == impact_sound)
-                        {
-                            soundId = item.AssetID;
-                            break;
-                        }
+                        soundId = item.AssetID;
+                        break;
                     }
                 }
+                m_host.TaskInventory.LockItemsForRead(false);
             }
             m_host.CollisionSound = soundId;
             m_host.CollisionSoundVolume = (float)impact_volume;
@@ -4007,6 +4070,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             UUID partItemID;
             foreach (SceneObjectPart part in parts)
             {
+                //Clone is thread safe
                 TaskInventoryDictionary itemsDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
 
                 foreach (TaskInventoryItem item in itemsDictionary.Values)
@@ -4214,17 +4278,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
             {
-                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                if (item.Type == 10 && item.ItemID == m_itemID)
                 {
-                    if (item.Type == 10 && item.ItemID == m_itemID)
-                    {
-                        result =  item.Name!=null?item.Name:String.Empty;
-                        break;
-                    }
+                    result =  item.Name!=null?item.Name:String.Empty;
+                    break;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return result;
         }
@@ -4482,23 +4545,24 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
+                    if ((inv.Value.CurrentPermissions & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify))
                     {
-                        if ((inv.Value.CurrentPermissions & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify))
-                        {
-                            return inv.Value.AssetID.ToString();
-                        }
-                        else
-                        {
-                            return UUID.Zero.ToString();
-                        }
+                        m_host.TaskInventory.LockItemsForRead(false);
+                        return inv.Value.AssetID.ToString();
+                    }
+                    else
+                    {
+                        m_host.TaskInventory.LockItemsForRead(false);
+                        return UUID.Zero.ToString();
                     }
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return UUID.Zero.ToString();
         }
@@ -5776,6 +5840,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             return World.SimulatorFPS;
         }
+                
 
         /* particle system rules should be coming into this routine as doubles, that is
         rule[0] should be an integer from this list and rule[1] should be the arg
@@ -5993,14 +6058,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
         protected UUID GetTaskInventoryItem(string name)
         {
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
-                        return inv.Key;
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return inv.Key;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return UUID.Zero;
         }
@@ -6311,22 +6378,21 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             }
 
             // copy the first script found with this inventory name
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
+                    // make sure the object is a script
+                    if (10 == inv.Value.Type)
                     {
-                        // make sure the object is a script
-                        if (10 == inv.Value.Type)
-                        {
-                            found = true;
-                            srcId = inv.Key;
-                            break;
-                        }
+                        found = true;
+                        srcId = inv.Key;
+                        break;
                     }
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             if (!found)
             {
@@ -8129,28 +8195,28 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == item)
                 {
-                    if (inv.Value.Name == item)
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    switch (mask)
                     {
-                        switch (mask)
-                        {
-                            case 0:
-                                return (int)inv.Value.BasePermissions;
-                            case 1:
-                                return (int)inv.Value.CurrentPermissions;
-                            case 2:
-                                return (int)inv.Value.GroupPermissions;
-                            case 3:
-                                return (int)inv.Value.EveryonePermissions;
-                            case 4:
-                                return (int)inv.Value.NextPermissions;
-                        }
+                        case 0:
+                            return (int)inv.Value.BasePermissions;
+                        case 1:
+                            return (int)inv.Value.CurrentPermissions;
+                        case 2:
+                            return (int)inv.Value.GroupPermissions;
+                        case 3:
+                            return (int)inv.Value.EveryonePermissions;
+                        case 4:
+                            return (int)inv.Value.NextPermissions;
                     }
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return -1;
         }
@@ -8165,16 +8231,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == item)
                 {
-                    if (inv.Value.Name == item)
-                    {
-                        return inv.Value.CreatorID.ToString();
-                    }
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return inv.Value.CreatorID.ToString();
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             llSay(0, "No item name '" + item + "'");
 
@@ -8698,16 +8764,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
             {
-                foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                if (inv.Value.Name == name)
                 {
-                    if (inv.Value.Name == name)
-                    {
-                        return inv.Value.Type;
-                    }
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return inv.Value.Type;
                 }
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             return -1;
         }
@@ -8738,17 +8804,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (invItemID == UUID.Zero)
                 return new LSL_Vector();
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (m_host.TaskInventory[invItemID].PermsGranter == UUID.Zero)
             {
-                if (m_host.TaskInventory[invItemID].PermsGranter == UUID.Zero)
-                   return new LSL_Vector();
+                m_host.TaskInventory.LockItemsForRead(false);
+                return new LSL_Vector();
+            }
 
-                if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRACK_CAMERA) == 0)
-                {
-                    ShoutError("No permissions to track the camera");
-                    return new LSL_Vector();
-                }
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRACK_CAMERA) == 0)
+            {
+                ShoutError("No permissions to track the camera");
+                m_host.TaskInventory.LockItemsForRead(false);
+                return new LSL_Vector();
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             ScenePresence presence = World.GetScenePresence(m_host.OwnerID);
             if (presence != null)
@@ -8766,17 +8835,19 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (invItemID == UUID.Zero)
                 return new LSL_Rotation();
 
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            if (m_host.TaskInventory[invItemID].PermsGranter == UUID.Zero)
             {
-                if (m_host.TaskInventory[invItemID].PermsGranter == UUID.Zero)
-                   return new LSL_Rotation();
-
-                if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRACK_CAMERA) == 0)
-                {
-                    ShoutError("No permissions to track the camera");
-                    return new LSL_Rotation();
-                }
+                m_host.TaskInventory.LockItemsForRead(false);
+                return new LSL_Rotation();
+            }
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRACK_CAMERA) == 0)
+            {
+                ShoutError("No permissions to track the camera");
+                m_host.TaskInventory.LockItemsForRead(false);
+                return new LSL_Rotation();
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             ScenePresence presence = World.GetScenePresence(m_host.OwnerID);
             if (presence != null)
@@ -8926,14 +8997,21 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (objectID == UUID.Zero) return;
 
             UUID agentID;
-            lock (m_host.TaskInventory)
-            {
-                // we need the permission first, to know which avatar we want to set the camera for
-                agentID = m_host.TaskInventory[invItemID].PermsGranter;
+            m_host.TaskInventory.LockItemsForRead(true);
+            // we need the permission first, to know which avatar we want to set the camera for
+            agentID = m_host.TaskInventory[invItemID].PermsGranter;
 
-                if (agentID == UUID.Zero) return;
-                if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_CONTROL_CAMERA) == 0) return;
+            if (agentID == UUID.Zero)
+            {
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_CONTROL_CAMERA) == 0)
+            {
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
             }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             ScenePresence presence = World.GetScenePresence(agentID);
 
@@ -8983,12 +9061,19 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             // we need the permission first, to know which avatar we want to clear the camera for
             UUID agentID;
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+            agentID = m_host.TaskInventory[invItemID].PermsGranter;
+            if (agentID == UUID.Zero)
             {
-                agentID = m_host.TaskInventory[invItemID].PermsGranter;
-                if (agentID == UUID.Zero) return;
-                if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_CONTROL_CAMERA) == 0) return;
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
             }
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_CONTROL_CAMERA) == 0)
+            {
+                m_host.TaskInventory.LockItemsForRead(false);
+                return;
+            }
+            m_host.TaskInventory.LockItemsForRead(false);
 
             ScenePresence presence = World.GetScenePresence(agentID);
 
@@ -9445,15 +9530,19 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
         internal UUID ScriptByName(string name)
         {
-            lock (m_host.TaskInventory)
+            m_host.TaskInventory.LockItemsForRead(true);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
             {
-                foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                if (item.Type == 10 && item.Name == name)
                 {
-                    if (item.Type == 10 && item.Name == name)
-                        return item.ItemID;
+                    m_host.TaskInventory.LockItemsForRead(false);
+                    return item.ItemID;
                 }
             }
 
+            m_host.TaskInventory.LockItemsForRead(false);
+
             return UUID.Zero;
         }
 
@@ -9494,6 +9583,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
+            //Clone is thread safe
             TaskInventoryDictionary itemsDictionary = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
 
             UUID assetID = UUID.Zero;
@@ -9556,6 +9646,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
 
+            //Clone is thread safe
             TaskInventoryDictionary itemsDictionary = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
 
             UUID assetID = UUID.Zero;
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index 7fdbac8..7f739b1 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -636,13 +636,13 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         }
 
         // Teleport functions
-        public void osTeleportAgent(string agent, uint regionX, uint regionY, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat)
+        public void osTeleportAgent(string agent, int regionX, int regionY, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat)
         {
             // High because there is no security check. High griefer potential
             //
             CheckThreatLevel(ThreatLevel.High, "osTeleportAgent");
 
-            ulong regionHandle = Util.UIntsToLong((regionX * (uint)Constants.RegionSize), (regionY * (uint)Constants.RegionSize));
+            ulong regionHandle = Util.UIntsToLong(((uint)regionX * (uint)Constants.RegionSize), ((uint)regionY * (uint)Constants.RegionSize));
 
             m_host.AddScriptLPS(1);
             UUID agentId = new UUID();
@@ -728,18 +728,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 if (target != null)
                 {
                     UUID animID=UUID.Zero;
-                    lock (m_host.TaskInventory)
+                    m_host.TaskInventory.LockItemsForRead(true);
+                    foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
                     {
-                        foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                        if (inv.Value.Name == animation)
                         {
-                            if (inv.Value.Name == animation)
-                            {
-                                if (inv.Value.Type == (int)AssetType.Animation)
-                                    animID = inv.Value.AssetID;
-                                continue;
-                            }
+                            if (inv.Value.Type == (int)AssetType.Animation)
+                                animID = inv.Value.AssetID;
+                            continue;
                         }
                     }
+                    m_host.TaskInventory.LockItemsForRead(false);
                     if (animID == UUID.Zero)
                         target.Animator.AddAnimation(animation, m_host.UUID);
                     else
@@ -761,18 +760,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 if (target != null)
                 {
                     UUID animID=UUID.Zero;
-                    lock (m_host.TaskInventory)
+                    m_host.TaskInventory.LockItemsForRead(true);
+                    foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
                     {
-                        foreach (KeyValuePair<UUID, TaskInventoryItem> inv in m_host.TaskInventory)
+                        if (inv.Value.Name == animation)
                         {
-                            if (inv.Value.Name == animation)
-                            {
-                                if (inv.Value.Type == (int)AssetType.Animation)
-                                    animID = inv.Value.AssetID;
-                                continue;
-                            }
+                            if (inv.Value.Type == (int)AssetType.Animation)
+                                animID = inv.Value.AssetID;
+                            continue;
                         }
                     }
+                    m_host.TaskInventory.LockItemsForRead(false);
                     
                     if (animID == UUID.Zero)
                         target.Animator.RemoveAnimation(animation);
@@ -1541,6 +1539,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             if (!UUID.TryParse(name, out assetID))
             {
+                m_host.TaskInventory.LockItemsForRead(true);
                 foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
                 {
                     if (item.Type == 7 && item.Name == name)
@@ -1548,6 +1547,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         assetID = item.AssetID;
                     }
                 }
+                m_host.TaskInventory.LockItemsForRead(false);
             }
 
             if (assetID == UUID.Zero)
@@ -1594,6 +1594,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             if (!UUID.TryParse(name, out assetID))
             {
+                m_host.TaskInventory.LockItemsForRead(true);
                 foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
                 {
                     if (item.Type == 7 && item.Name == name)
@@ -1601,6 +1602,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         assetID = item.AssetID;
                     }
                 }
+                m_host.TaskInventory.LockItemsForRead(false);
             }
 
             if (assetID == UUID.Zero)
@@ -1651,6 +1653,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             if (!UUID.TryParse(name, out assetID))
             {
+                m_host.TaskInventory.LockItemsForRead(true);
                 foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
                 {
                     if (item.Type == 7 && item.Name == name)
@@ -1658,6 +1661,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         assetID = item.AssetID;
                     }
                 }
+                m_host.TaskInventory.LockItemsForRead(false);
             }
 
             if (assetID == UUID.Zero)
@@ -1948,5 +1952,27 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             return key.ToString();
         }
+                
+       /// <summary>
+        /// Return information regarding various simulator statistics (sim fps, physics fps, time
+        /// dilation, total number of prims, total number of active scripts, script lps, various
+        /// timing data, packets in/out, etc. Basically much the information that's shown in the
+        /// client's Statistics Bar (Ctrl-Shift-1)
+        /// </summary>
+        /// <returns>List of floats</returns>
+                public LSL_List osGetRegionStats()
+                {
+            CheckThreatLevel(ThreatLevel.Moderate, "osGetRegionStats");
+            m_host.AddScriptLPS(1);
+            LSL_List ret = new LSL_List();
+                        float[] stats = World.SimulatorStats;
+                        
+                        for (int i = 0; i < 21; i++)
+                        {
+                                ret.Add(new LSL_Float( stats[i] ));
+                        }
+                        return ret;
+                }
+
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
index 2a403bf..0b0dc00 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
@@ -83,7 +83,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
 
         // Teleport commands
         void osTeleportAgent(string agent, string regionName, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
-        void osTeleportAgent(string agent, uint regionX, uint regionY, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
+        void osTeleportAgent(string agent, int regionX, int regionY, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
         void osTeleportAgent(string agent, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
 
         // Animation commands
@@ -162,5 +162,6 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
 
         key osGetMapTexture();
         key osGetRegionMapTexture(string regionName);
+                LSL_List osGetRegionStats();
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/Executor.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/Executor.cs
index 7f67599..15e0408 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/Executor.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/Executor.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics; //for [DebuggerNonUserCode]
 using System.Reflection;
 using System.Runtime.Remoting.Lifetime;
 using OpenSim.Region.ScriptEngine.Shared;
@@ -131,6 +132,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
             return (eventFlags);
         }
 
+        [DebuggerNonUserCode]
         public void ExecuteEvent(string state, string FunctionName, object[] args)
         {
             // IMPORTANT: Types and MemberInfo-derived objects require a LOT of memory.
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
index 753ca55..acff8fb 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
@@ -515,6 +515,29 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         public const string TEXTURE_PLYWOOD = "89556747-24cb-43ed-920b-47caed15465f";
         public const string TEXTURE_TRANSPARENT = "8dcd4a48-2d37-4909-9f78-f7a9eb4ef903";
         public const string TEXTURE_MEDIA = "8b5fec65-8d8d-9dc5-cda8-8fdf2716e361";
+                
+                // Constants for osGetRegionStats
+                public const int STATS_TIME_DILATION = 0;
+                public const int STATS_SIM_FPS = 1;
+                public const int STATS_PHYSICS_FPS = 2;
+                public const int STATS_AGENT_UPDATES = 3;
+                public const int STATS_ROOT_AGENTS = 4;
+                public const int STATS_CHILD_AGENTS = 5;
+                public const int STATS_TOTAL_PRIMS = 6;
+                public const int STATS_ACTIVE_PRIMS = 7;
+                public const int STATS_FRAME_MS = 8;
+                public const int STATS_NET_MS = 9;
+                public const int STATS_PHYSICS_MS = 10;
+                public const int STATS_IMAGE_MS = 11;
+                public const int STATS_OTHER_MS = 12;
+                public const int STATS_IN_PACKETS_PER_SECOND = 13;
+                public const int STATS_OUT_PACKETS_PER_SECOND = 14;
+                public const int STATS_UNACKED_BYTES = 15;
+                public const int STATS_AGENT_MS = 16;
+                public const int STATS_PENDING_DOWNLOADS = 17;
+                public const int STATS_PENDING_UPLOADS = 18;
+                public const int STATS_ACTIVE_SCRIPTS = 19;
+                public const int STATS_SCRIPT_LPS = 20;
 
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
index 4928e90..519463e 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
@@ -201,9 +201,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
             m_OSSL_Functions.osTeleportAgent(agent, regionName, position, lookat);
         }
 
-        public void osTeleportAgent(string agent, long regionX, long regionY, vector position, vector lookat)
+        public void osTeleportAgent(string agent, int regionX, int regionY, vector position, vector lookat)
         {
-            m_OSSL_Functions.osTeleportAgent(agent, (uint) regionX, (uint) regionY, position, lookat);
+            m_OSSL_Functions.osTeleportAgent(agent, regionX, regionY, position, lookat);
         }
 
         public void osTeleportAgent(string agent, vector position, vector lookat)
@@ -632,5 +632,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         {
             return m_OSSL_Functions.osGetRegionMapTexture(regionName);
         }
+                
+                public LSL_List osGetRegionStats()
+                {
+                        return m_OSSL_Functions.osGetRegionStats();
+                }
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
index 121159c..a44abb0 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
@@ -33,6 +33,7 @@ using System.Threading;
 using System.Reflection;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics; //for [DebuggerNonUserCode]
 using OpenSim.Region.ScriptEngine.Interfaces;
 using OpenSim.Region.ScriptEngine.Shared;
 using OpenSim.Region.ScriptEngine.Shared.Api.Runtime;
@@ -90,6 +91,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
             return (int)m_Executor.GetStateEventFlags(state);
         }
 
+        [DebuggerNonUserCode]
         public void ExecuteEvent(string state, string FunctionName, object[] args)
         {
             m_Executor.ExecuteEvent(state, FunctionName, args);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
index 41b5d49..8333a27 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.IO;
+using System.Diagnostics; //for [DebuggerNonUserCode]
 using System.Runtime.Remoting;
 using System.Runtime.Remoting.Lifetime;
 using System.Threading;
@@ -237,13 +238,12 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
 
             if (part != null)
             {
-                lock (part.TaskInventory)
+                part.TaskInventory.LockItemsForRead(true);
+                if (part.TaskInventory.ContainsKey(m_ItemID))
                 {
-                    if (part.TaskInventory.ContainsKey(m_ItemID))
-                    {
-                        m_thisScriptTask = part.TaskInventory[m_ItemID];
-                    }
+                    m_thisScriptTask = part.TaskInventory[m_ItemID];
                 }
+                part.TaskInventory.LockItemsForRead(false);
             }
 
             ApiManager am = new ApiManager();
@@ -428,14 +428,15 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
             {
                 int permsMask;
                 UUID permsGranter;
-                lock (part.TaskInventory)
+                part.TaskInventory.LockItemsForRead(true);
+                if (!part.TaskInventory.ContainsKey(m_ItemID))
                 {
-                    if (!part.TaskInventory.ContainsKey(m_ItemID))
-                        return;
-
-                    permsGranter = part.TaskInventory[m_ItemID].PermsGranter;
-                    permsMask = part.TaskInventory[m_ItemID].PermsMask;
+                    part.TaskInventory.LockItemsForRead(false);
+                    return;
                 }
+                permsGranter = part.TaskInventory[m_ItemID].PermsGranter;
+                permsMask = part.TaskInventory[m_ItemID].PermsMask;
+                part.TaskInventory.LockItemsForRead(false);
 
                 if ((permsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0)
                 {
@@ -544,6 +545,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
             return true;
         }
 
+        [DebuggerNonUserCode] //Prevents the debugger from farting in this function
         public void SetState(string state)
         {
             if (state == State)
@@ -555,7 +557,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                                        new DetectParams[0]));
             PostEvent(new EventParams("state_entry", new Object[0],
                                        new DetectParams[0]));
-
+            
             throw new EventAbortException();
         }
 
@@ -638,154 +640,158 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
         /// <returns></returns>
         public object EventProcessor()
         {
+
+        EventParams data = null;
+
+        lock (m_EventQueue)
+        {
             lock (m_Script)
             {
-                EventParams data = null;
-
-                lock (m_EventQueue)
+                data = (EventParams) m_EventQueue.Dequeue();
+                if (data == null) // Shouldn't happen
                 {
-                    data = (EventParams) m_EventQueue.Dequeue();
-                    if (data == null) // Shouldn't happen
+                    if ((m_EventQueue.Count > 0) && m_RunEvents && (!m_ShuttingDown))
                     {
-                        if ((m_EventQueue.Count > 0) && m_RunEvents && (!m_ShuttingDown))
-                        {
-                            m_CurrentResult = m_Engine.QueueEventHandler(this);
-                        }
-                        else
-                        {
-                            m_CurrentResult = null;
-                        }
-                        return 0;
+                        m_CurrentResult = m_Engine.QueueEventHandler(this);
                     }
-
-                    if (data.EventName == "timer")
-                        m_TimerQueued = false;
-                    if (data.EventName == "control")
+                    else
                     {
-                        if (m_ControlEventsInQueue > 0)
-                            m_ControlEventsInQueue--;
+                        m_CurrentResult = null;
                     }
-                    if (data.EventName == "collision")
-                        m_CollisionInQueue = false;
+                    return 0;
                 }
-                
-                //m_log.DebugFormat("[XENGINE]: Processing event {0} for {1}", data.EventName, this);
-
-                m_DetectParams = data.DetectParams;
 
-                if (data.EventName == "state") // Hardcoded state change
+                if (data.EventName == "timer")
+                    m_TimerQueued = false;
+                if (data.EventName == "control")
                 {
-    //                m_log.DebugFormat("[Script] Script {0}.{1} state set to {2}",
-    //                        m_PrimName, m_ScriptName, data.Params[0].ToString());
-                    m_State=data.Params[0].ToString();
-                    AsyncCommandManager.RemoveScript(m_Engine,
-                        m_LocalID, m_ItemID);
+                    if (m_ControlEventsInQueue > 0)
+                        m_ControlEventsInQueue--;
+                }
+                if (data.EventName == "collision")
+                    m_CollisionInQueue = false;
+            }
+        }
+        lock(m_Script)
+        {
+            
+            //m_log.DebugFormat("[XENGINE]: Processing event {0} for {1}", data.EventName, this);
 
-                    SceneObjectPart part = m_Engine.World.GetSceneObjectPart(
-                        m_LocalID);
-                    if (part != null)
-                    {
-                        part.SetScriptEvents(m_ItemID,
-                                             (int)m_Script.GetStateEventFlags(State));
-                    }
+            m_DetectParams = data.DetectParams;
+
+            if (data.EventName == "state") // Hardcoded state change
+            {
+//                m_log.DebugFormat("[Script] Script {0}.{1} state set to {2}",
+//                        m_PrimName, m_ScriptName, data.Params[0].ToString());
+                m_State=data.Params[0].ToString();
+                AsyncCommandManager.RemoveScript(m_Engine,
+                    m_LocalID, m_ItemID);
+
+                SceneObjectPart part = m_Engine.World.GetSceneObjectPart(
+                    m_LocalID);
+                if (part != null)
+                {
+                    part.SetScriptEvents(m_ItemID,
+                                         (int)m_Script.GetStateEventFlags(State));
                 }
-                else
+            }
+            else
+            {
+                if (m_Engine.World.PipeEventsForScript(m_LocalID) ||
+                    data.EventName == "control") // Don't freeze avies!
                 {
-                    if (m_Engine.World.PipeEventsForScript(m_LocalID) ||
-                        data.EventName == "control") // Don't freeze avies!
-                    {
-                        SceneObjectPart part = m_Engine.World.GetSceneObjectPart(
-                            m_LocalID);
-        //                m_log.DebugFormat("[Script] Delivered event {2} in state {3} to {0}.{1}",
-        //                        m_PrimName, m_ScriptName, data.EventName, m_State);
+                    SceneObjectPart part = m_Engine.World.GetSceneObjectPart(
+                        m_LocalID);
+    //                m_log.DebugFormat("[Script] Delivered event {2} in state {3} to {0}.{1}",
+    //                        m_PrimName, m_ScriptName, data.EventName, m_State);
 
-                        try
-                        {
-                            m_CurrentEvent = data.EventName;
-                            m_EventStart = DateTime.Now;
-                            m_InEvent = true;
+                    try
+                    {
+                        m_CurrentEvent = data.EventName;
+                        m_EventStart = DateTime.Now;
+                        m_InEvent = true;
 
-                            m_Script.ExecuteEvent(State, data.EventName, data.Params);
+                        m_Script.ExecuteEvent(State, data.EventName, data.Params);
 
-                            m_InEvent = false;
-                            m_CurrentEvent = String.Empty;
+                        m_InEvent = false;
+                        m_CurrentEvent = String.Empty;
 
-                            if (m_SaveState)
-                            {
-                                // This will be the very first event we deliver
-                                // (state_entry) in default state
-                                //
+                        if (m_SaveState)
+                        {
+                            // This will be the very first event we deliver
+                            // (state_entry) in default state
+                            //
 
-                                SaveState(m_Assembly);
+                            SaveState(m_Assembly);
 
-                                m_SaveState = false;
-                            }
+                            m_SaveState = false;
                         }
-                        catch (Exception e)
-                        {
-                            // m_log.DebugFormat("[SCRIPT] Exception: {0}", e.Message);
-                            m_InEvent = false;
-                            m_CurrentEvent = String.Empty;
+                    }
+                    catch (Exception e)
+                    {
+                        // m_log.DebugFormat("[SCRIPT] Exception: {0}", e.Message);
+                        m_InEvent = false;
+                        m_CurrentEvent = String.Empty;
 
-                            if ((!(e is TargetInvocationException) || (!(e.InnerException is SelfDeleteException) && !(e.InnerException is ScriptDeleteException))) && !(e is ThreadAbortException))
-                            {
-                                try
-                                {
-                                    // DISPLAY ERROR INWORLD
-                                    string text = FormatException(e);
-
-                                    if (text.Length > 1000)
-                                        text = text.Substring(0, 1000);
-                                    m_Engine.World.SimChat(Utils.StringToBytes(text),
-                                                           ChatTypeEnum.DebugChannel, 2147483647,
-                                                           part.AbsolutePosition,
-                                                           part.Name, part.UUID, false);
-                                }
-                                catch (Exception)
-                                {
-                                }
-                                // catch (Exception e2) // LEGIT: User Scripting
-                                // {
-                                    // m_log.Error("[SCRIPT]: "+
-                                      //           "Error displaying error in-world: " +
-                                        //         e2.ToString());
-                                 //    m_log.Error("[SCRIPT]: " +
-                                   //              "Errormessage: Error compiling script:\r\n" +
-                                     //            e.ToString());
-                                // }
-                            }
-                            else if ((e is TargetInvocationException) && (e.InnerException is SelfDeleteException))
+                        if ((!(e is TargetInvocationException) || (!(e.InnerException is SelfDeleteException) && !(e.InnerException is ScriptDeleteException))) && !(e is ThreadAbortException))
+                        {
+                            try
                             {
-                                m_InSelfDelete = true;
-                                if (part != null && part.ParentGroup != null)
-                                    m_Engine.World.DeleteSceneObject(part.ParentGroup, false);
+                                // DISPLAY ERROR INWORLD
+                                string text = FormatException(e);
+
+                                if (text.Length > 1000)
+                                    text = text.Substring(0, 1000);
+                                m_Engine.World.SimChat(Utils.StringToBytes(text),
+                                                       ChatTypeEnum.DebugChannel, 2147483647,
+                                                       part.AbsolutePosition,
+                                                       part.Name, part.UUID, false);
                             }
-                            else if ((e is TargetInvocationException) && (e.InnerException is ScriptDeleteException))
+                            catch (Exception)
                             {
-                                m_InSelfDelete = true;
-                                if (part != null && part.ParentGroup != null)
-                                    part.Inventory.RemoveInventoryItem(m_ItemID);
                             }
+                            // catch (Exception e2) // LEGIT: User Scripting
+                            // {
+                                // m_log.Error("[SCRIPT]: "+
+                                  //           "Error displaying error in-world: " +
+                                    //         e2.ToString());
+                             //    m_log.Error("[SCRIPT]: " +
+                               //              "Errormessage: Error compiling script:\r\n" +
+                                 //            e.ToString());
+                            // }
+                        }
+                        else if ((e is TargetInvocationException) && (e.InnerException is SelfDeleteException))
+                        {
+                            m_InSelfDelete = true;
+                            if (part != null && part.ParentGroup != null)
+                                m_Engine.World.DeleteSceneObject(part.ParentGroup, false);
+                        }
+                        else if ((e is TargetInvocationException) && (e.InnerException is ScriptDeleteException))
+                        {
+                            m_InSelfDelete = true;
+                            if (part != null && part.ParentGroup != null)
+                                part.Inventory.RemoveInventoryItem(m_ItemID);
                         }
                     }
                 }
+            }
 
-                lock (m_EventQueue)
+            lock (m_EventQueue)
+            {
+                if ((m_EventQueue.Count > 0) && m_RunEvents && (!m_ShuttingDown))
                 {
-                    if ((m_EventQueue.Count > 0) && m_RunEvents && (!m_ShuttingDown))
-                    {
-                        m_CurrentResult = m_Engine.QueueEventHandler(this);
-                    }
-                    else
-                    {
-                        m_CurrentResult = null;
-                    }
+                    m_CurrentResult = m_Engine.QueueEventHandler(this);
                 }
+                else
+                {
+                    m_CurrentResult = null;
+                }
+            }
 
-                m_DetectParams = null;
+            m_DetectParams = null;
 
-                return 0;
-            }
+            return 0;
+        }
         }
 
         public int EventTime()
@@ -824,6 +830,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                     new Object[0], new DetectParams[0]));
         }
 
+        [DebuggerNonUserCode] //Stops the VS debugger from farting in this function
         public void ApiResetScript()
         {
             // bool running = Running;
@@ -1011,10 +1018,5 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
         {
             get { return m_RegionID; }
         }
-
-        public bool CanBeDeleted()
-        {
-            return true;
-        }
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs b/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs
index 3f38bb6..1fc31c5 100644
--- a/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/LSL_Types.cs
@@ -429,6 +429,11 @@ namespace OpenSim.Region.ScriptEngine.Shared
                 }
             }
 
+            public int Size
+            {
+                get { return 0; }
+            }
+
             public object[] Data
             {
                 get {
diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index a60c0ba..2fc2ea1 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -30,6 +30,7 @@ using System.IO;
 using System.Threading;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics; //for [DebuggerNonUserCode]
 using System.Security;
 using System.Security.Policy;
 using System.Reflection;
@@ -1119,6 +1120,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             return false;
         }
 
+        [DebuggerNonUserCode]
         public void ApiResetScript(UUID itemID)
         {
             IScriptInstance instance = GetInstance(itemID);
@@ -1170,6 +1172,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             return UUID.Zero;
         }
 
+        [DebuggerNonUserCode]
         public void SetState(UUID itemID, string newState)
         {
             IScriptInstance instance = GetInstance(itemID);
@@ -1245,34 +1248,219 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
         }
 
-        public string GetAssemblyName(UUID itemID)
-        {
-            IScriptInstance instance = GetInstance(itemID);
-            if (instance == null)
-                return "";
-            return instance.GetAssemblyName();
-        }
-
         public string GetXMLState(UUID itemID)
         {
             IScriptInstance instance = GetInstance(itemID);
             if (instance == null)
                 return "";
-            return instance.GetXMLState();
-        }
+            string xml = instance.GetXMLState();
 
-        public bool CanBeDeleted(UUID itemID)
-        {
-            IScriptInstance instance = GetInstance(itemID);
-            if (instance == null)
-                return true;
+            XmlDocument sdoc = new XmlDocument();
+            sdoc.LoadXml(xml);
+            XmlNodeList rootL = sdoc.GetElementsByTagName("ScriptState");
+            XmlNode rootNode = rootL[0];
+
+            // Create <State UUID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx">
+            XmlDocument doc = new XmlDocument();
+            XmlElement stateData = doc.CreateElement("", "State", "");
+            XmlAttribute stateID = doc.CreateAttribute("", "UUID", "");
+            stateID.Value = itemID.ToString();
+            stateData.Attributes.Append(stateID);
+            XmlAttribute assetID = doc.CreateAttribute("", "Asset", "");
+            assetID.Value = instance.AssetID.ToString();
+            stateData.Attributes.Append(assetID);
+            doc.AppendChild(stateData);
+
+            // Add <ScriptState>...</ScriptState>
+            XmlNode xmlstate = doc.ImportNode(rootNode, true);
+            stateData.AppendChild(xmlstate);
+
+            string assemName = instance.GetAssemblyName();
+
+            string fn = Path.GetFileName(assemName);
+
+            string assem = String.Empty;
+
+            if (File.Exists(assemName + ".text"))
+            {
+                FileInfo tfi = new FileInfo(assemName + ".text");
+
+                if (tfi != null)
+                {
+                    Byte[] tdata = new Byte[tfi.Length];
+
+                    try
+                    {
+                        FileStream tfs = File.Open(assemName + ".text",
+                                FileMode.Open, FileAccess.Read);
+                        tfs.Read(tdata, 0, tdata.Length);
+                        tfs.Close();
+
+                        assem = new System.Text.ASCIIEncoding().GetString(tdata);
+                    }
+                    catch (Exception e)
+                    {
+                         m_log.DebugFormat("[XEngine]: Unable to open script textfile {0}, reason: {1}", assemName+".text", e.Message);
+                    }
+                }
+            }
+            else
+            {
+                FileInfo fi = new FileInfo(assemName);
+
+                if (fi != null)
+                {
+                    Byte[] data = new Byte[fi.Length];
+
+                    try
+                    {
+                        FileStream fs = File.Open(assemName, FileMode.Open, FileAccess.Read);
+                        fs.Read(data, 0, data.Length);
+                        fs.Close();
+
+                        assem = System.Convert.ToBase64String(data);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.DebugFormat("[XEngine]: Unable to open script assembly {0}, reason: {1}", assemName, e.Message);
+                    }
+
+                }
+            }
+
+            string map = String.Empty;
+
+            if (File.Exists(fn + ".map"))
+            {
+                FileStream mfs = File.Open(fn + ".map", FileMode.Open, FileAccess.Read);
+                StreamReader msr = new StreamReader(mfs);
+
+                map = msr.ReadToEnd();
+
+                msr.Close();
+                mfs.Close();
+            }
+
+            XmlElement assemblyData = doc.CreateElement("", "Assembly", "");
+            XmlAttribute assemblyName = doc.CreateAttribute("", "Filename", "");
+
+            assemblyName.Value = fn;
+            assemblyData.Attributes.Append(assemblyName);
+
+            assemblyData.InnerText = assem;
+
+            stateData.AppendChild(assemblyData);
 
-            return instance.CanBeDeleted();
+            XmlElement mapData = doc.CreateElement("", "LineMap", "");
+            XmlAttribute mapName = doc.CreateAttribute("", "Filename", "");
+
+            mapName.Value = fn + ".map";
+            mapData.Attributes.Append(mapName);
+
+            mapData.InnerText = map;
+
+            stateData.AppendChild(mapData);
+            return doc.InnerXml;
         }
 
         private bool ShowScriptSaveResponse(UUID ownerID, UUID assetID, string text, bool compiled)
         {
             return false;
         }
+
+        public void SetXMLState(UUID itemID, string xml)
+        {
+            if (xml == String.Empty)
+                return;
+
+            XmlDocument doc = new XmlDocument();
+
+            try
+            {
+                doc.LoadXml(xml);
+            }
+            catch (Exception)
+            {
+                m_log.Error("[XEngine]: Exception decoding XML data from region transfer");
+                return;
+            }
+
+            XmlNodeList rootL = doc.GetElementsByTagName("State");
+            if (rootL.Count < 1)
+                return;
+
+            XmlElement rootE = (XmlElement)rootL[0];
+
+            if (rootE.GetAttribute("UUID") != itemID.ToString())
+                return;
+
+            string assetID = rootE.GetAttribute("Asset");
+
+            XmlNodeList stateL = rootE.GetElementsByTagName("ScriptState");
+
+            if (stateL.Count != 1)
+                return;
+
+            XmlElement stateE = (XmlElement)stateL[0];
+
+            if (World.m_trustBinaries)
+            {
+                XmlNodeList assemL = rootE.GetElementsByTagName("Assembly");
+
+                if (assemL.Count != 1)
+                    return;
+
+                XmlElement assemE = (XmlElement)assemL[0];
+
+                string fn = assemE.GetAttribute("Filename");
+                string base64 = assemE.InnerText;
+
+                string path = Path.Combine("ScriptEngines", World.RegionInfo.RegionID.ToString());
+                path = Path.Combine(path, fn);
+
+                if (!File.Exists(path))
+                {
+                    Byte[] filedata = Convert.FromBase64String(base64);
+
+                    FileStream fs = File.Create(path);
+                    fs.Write(filedata, 0, filedata.Length);
+                    fs.Close();
+
+                    fs = File.Create(path + ".text");
+                    StreamWriter sw = new StreamWriter(fs);
+
+                    sw.Write(base64);
+
+                    sw.Close();
+                    fs.Close();
+                }
+            }
+
+            string statepath = Path.Combine("ScriptEngines", World.RegionInfo.RegionID.ToString());
+            statepath = Path.Combine(statepath, itemID.ToString() + ".state");
+
+            FileStream sfs = File.Create(statepath);
+            StreamWriter ssw = new StreamWriter(sfs);
+
+            ssw.Write(stateE.OuterXml);
+
+            ssw.Close();
+            sfs.Close();
+
+            XmlNodeList mapL = rootE.GetElementsByTagName("LineMap");
+            
+            XmlElement mapE = (XmlElement)mapL[0];
+
+            string mappath = Path.Combine("ScriptEngines", World.RegionInfo.RegionID.ToString());
+            mappath = Path.Combine(mappath, mapE.GetAttribute("Filename"));
+
+            FileStream mfs = File.Create(mappath);
+            StreamWriter msw = new StreamWriter(mfs);
+
+            msw.Write(mapE.InnerText);
+
+            msw.Close();
+            mfs.Close();
+        }
     }
 }