Merge branch 'master' of ssh://opensimulator.org/var/git/opensim

OpenSim/Data/IFriendsData.cs

@@ -34,7 +34,7 @@ namespace OpenSim.Data
 {
     public class FriendsData
     {
-        public UUID PrincipalID;
+        public string PrincipalID;
         public string Friend;
         public Dictionary<string, string> Data;
     }
@@ -46,6 +46,8 @@ namespace OpenSim.Data
     {
         bool Store(FriendsData data);
         bool Delete(UUID ownerID, string friend);
+        bool Delete(string ownerID, string friend);
         FriendsData[] GetFriends(UUID principalID);
+        FriendsData[] GetFriends(string principalID);
     }
 }

OpenSim/Data/IXInventoryData.cs

@@ -74,9 +74,38 @@ namespace OpenSim.Data
         bool StoreFolder(XInventoryFolder folder);
         bool StoreItem(XInventoryItem item);
 
+        /// <summary>
+        /// Delete folders where field == val
+        /// </summary>
+        /// <param name="field"></param>
+        /// <param name="val"></param>
+        /// <returns>true if the delete was successful, false if it was not</returns>
         bool DeleteFolders(string field, string val);
+
+        /// <summary>
+        /// Delete folders where field1 == val1, field2 == val2...
+        /// </summary>
+        /// <param name="fields"></param>
+        /// <param name="vals"></param>
+        /// <returns>true if the delete was successful, false if it was not</returns>
+        bool DeleteFolders(string[] fields, string[] vals);
+
+        /// <summary>
+        /// Delete items where field == val
+        /// </summary>
+        /// <param name="field"></param>
+        /// <param name="val"></param>
+        /// <returns>true if the delete was successful, false if it was not</returns>
         bool DeleteItems(string field, string val);
 
+        /// <summary>
+        /// Delete items where field1 == val1, field2 == val2...
+        /// </summary>
+        /// <param name="fields"></param>
+        /// <param name="vals"></param>
+        /// <returns>true if the delete was successful, false if it was not</returns>
+        bool DeleteItems(string[] fields, string[] vals);
+
         bool MoveItem(string id, string newParent);
         XInventoryItem[] GetActiveGestures(UUID principalID);
         int GetAssetPermissions(UUID principalID, UUID assetID);

OpenSim/Data/MSSQL/MSSQLEstateData.cs

@@ -41,7 +41,7 @@ namespace OpenSim.Data.MSSQL
     {
         private const string _migrationStore = "EstateStore";
 
-        private static readonly ILog _Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private MSSQLManager _Database;
         private string m_connectionString;
@@ -72,7 +72,12 @@ namespace OpenSim.Data.MSSQL
             }
 
             //Migration settings
-            _Database.CheckMigration(_migrationStore);
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                Migration m = new Migration(conn, GetType().Assembly, "EstateStore");
+                m.Update();
+            }
 
             //Interesting way to get parameters! Maybe implement that also with other types
             Type t = typeof(EstateSettings);
@@ -112,19 +117,19 @@ namespace OpenSim.Data.MSSQL
                         {
                             FieldInfo f = _FieldMap[name];
                             object v = reader[name];
-                            if (f.FieldType == typeof(bool) )
+                            if (f.FieldType == typeof(bool))
                             {
                                 f.SetValue(es, Convert.ToInt32(v) != 0);
                             }
-                            else if (f.FieldType == typeof(UUID) )
+                            else if (f.FieldType == typeof(UUID))
                             {
                                 f.SetValue(es, new UUID((Guid)v)); // uuid);
                             }
-                            else if (f.FieldType == typeof(string)) 
+                            else if (f.FieldType == typeof(string))
                             {
                                 f.SetValue(es, v.ToString());
                             }
-                            else if (f.FieldType == typeof(UInt32))  
+                            else if (f.FieldType == typeof(UInt32))
                             {
                                 f.SetValue(es, Convert.ToUInt32(v));
                             }
@@ -186,7 +191,7 @@ namespace OpenSim.Data.MSSQL
                     }
                     catch (Exception e)
                     {
-                        _Log.DebugFormat("[ESTATE DB]: Error inserting regionID and EstateID in estate_map: {0}", e);
+                        m_log.DebugFormat("[ESTATE DB]: Error inserting regionID and EstateID in estate_map: {0}", e);
                     }
                 }
 
@@ -310,12 +315,12 @@ namespace OpenSim.Data.MSSQL
                 conn.Open();
                 using (SqlCommand cmd = conn.CreateCommand())
                 {
-                    cmd.CommandText  = "delete from estateban where EstateID = @EstateID";
+                    cmd.CommandText = "delete from estateban where EstateID = @EstateID";
                     cmd.Parameters.AddWithValue("@EstateID", (int)es.EstateID);
                     cmd.ExecuteNonQuery();
 
                     //Insert after
-                    cmd.CommandText = "insert into estateban (EstateID, bannedUUID) values ( @EstateID, @bannedUUID )";
+                    cmd.CommandText = "insert into estateban (EstateID, bannedUUID,bannedIp, bannedIpHostMask, bannedNameMask) values ( @EstateID, @bannedUUID, '','','' )";
                     cmd.Parameters.AddWithValue("@bannedUUID", Guid.Empty);
                     foreach (EstateBan b in es.EstateBans)
                     {
@@ -350,43 +355,195 @@ namespace OpenSim.Data.MSSQL
 
         public EstateSettings LoadEstateSettings(int estateID)
         {
-            // TODO: Implementation!
-            return new EstateSettings();
+            EstateSettings es = new EstateSettings();
+            string sql = "select estate_settings." + String.Join(",estate_settings.", FieldList) + " from estate_settings where EstateID = @EstateID";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.AddWithValue("@EstateID", (int)estateID);
+                    using (SqlDataReader reader = cmd.ExecuteReader())
+                    {
+                        if (reader.Read())
+                        {
+                            foreach (string name in FieldList)
+                            {
+                                FieldInfo f = _FieldMap[name];
+                                object v = reader[name];
+                                if (f.FieldType == typeof(bool))
+                                {
+                                    f.SetValue(es, Convert.ToInt32(v) != 0);
+                                }
+                                else if (f.FieldType == typeof(UUID))
+                                {
+                                    f.SetValue(es, new UUID((Guid)v)); // uuid);
+                                }
+                                else if (f.FieldType == typeof(string))
+                                {
+                                    f.SetValue(es, v.ToString());
+                                }
+                                else if (f.FieldType == typeof(UInt32))
+                                {
+                                    f.SetValue(es, Convert.ToUInt32(v));
+                                }
+                                else if (f.FieldType == typeof(Single))
+                                {
+                                    f.SetValue(es, Convert.ToSingle(v));
+                                }
+                                else
+                                    f.SetValue(es, v);
+                            }
+                        }
+
+                    }
+                }
+            }
+            LoadBanList(es);
+
+            es.EstateManagers = LoadUUIDList(es.EstateID, "estate_managers");
+            es.EstateAccess = LoadUUIDList(es.EstateID, "estate_users");
+            es.EstateGroups = LoadUUIDList(es.EstateID, "estate_groups");
+
+            //Set event
+            es.OnSave += StoreEstateSettings;
+            return es;
+
         }
-        
+
         public List<EstateSettings> LoadEstateSettingsAll()
         {
-            // TODO: Implementation!
-            return new List<EstateSettings>();            
+            List<EstateSettings> allEstateSettings = new List<EstateSettings>();
+
+            List<int> allEstateIds = GetEstatesAll();
+
+            foreach (int estateId in allEstateIds)
+                allEstateSettings.Add(LoadEstateSettings(estateId));
+
+            return allEstateSettings;
         }
 
         public List<int> GetEstates(string search)
         {
-            // TODO: Implementation!            
-            return new List<int>();
+            List<int> result = new List<int>();
+            string sql = "select estateID from estate_settings where EstateName = @EstateName";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.AddWithValue("@EstateName", search);
+
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            result.Add(Convert.ToInt32(reader["EstateID"]));
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+
+            return result;
         }
-        
+
         public List<int> GetEstatesAll()
         {
-            // TODO: Implementation!            
-            return new List<int>();
+            List<int> result = new List<int>();
+            string sql = "select estateID from estate_settings";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            result.Add(Convert.ToInt32(reader["EstateID"]));
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+
+            return result;
         }
 
         public List<int> GetEstatesByOwner(UUID ownerID)
         {
-            return new List<int>();
+            List<int> result = new List<int>();
+            string sql = "select estateID from estate_settings where EstateOwner = @EstateOwner";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.AddWithValue("@EstateOwner", ownerID);
+
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            result.Add(Convert.ToInt32(reader["EstateID"]));
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+
+            return result;
         }
 
         public bool LinkRegion(UUID regionID, int estateID)
         {
-            // TODO: Implementation!            
+            string sql = "insert into estate_map values (@RegionID, @EstateID)";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                try
+                {
+                    using (SqlCommand cmd = new SqlCommand(sql, conn))
+                    {
+                        cmd.Parameters.AddWithValue("@RegionID", regionID);
+                        cmd.Parameters.AddWithValue("@EstateID", estateID);
+
+                        int ret = cmd.ExecuteNonQuery();
+                        return (ret != 0);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[REGION DB]: LinkRegion failed: " + ex.Message);
+                }
+            }
             return false;
         }
 
         public List<UUID> GetRegions(int estateID)
         {
-            // TODO: Implementation!            
-            return new List<UUID>();
+            List<UUID> result = new List<UUID>();
+            string sql = "select RegionID from estate_map where EstateID = @EstateID";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.AddWithValue("@EstateID", estateID);
+
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            result.Add(DBGuid.FromDB(reader["RegionID"]));
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+
+            return result;
         }
 
         public bool DeleteEstate(int estateID)

OpenSim/Data/MSSQL/MSSQLFriendsData.cs

@@ -51,6 +51,11 @@ namespace OpenSim.Data.MSSQL
         }
 
         public bool Delete(UUID principalID, string friend)
+        {
+            return Delete(principalID.ToString(), friend);
+        }
+
+        public bool Delete(string principalID, string friend)
         {
             using (SqlConnection conn = new SqlConnection(m_ConnectionString))
             using (SqlCommand cmd = new SqlCommand())
@@ -67,6 +72,11 @@ namespace OpenSim.Data.MSSQL
         }
 
         public FriendsData[] GetFriends(UUID principalID)
+        {
+            return GetFriends(principalID.ToString());
+        }
+
+        public FriendsData[] GetFriends(string principalID)
         {
             using (SqlConnection conn = new SqlConnection(m_ConnectionString))
             using (SqlCommand cmd = new SqlCommand())

OpenSim/Data/MSSQL/MSSQLGenericTableHandler.cs

@@ -168,14 +168,13 @@ namespace OpenSim.Data.MSSQL
 
         protected T[] DoQuery(SqlCommand cmd)
         {
+            List<T> result = new List<T>();
             using (SqlDataReader reader = cmd.ExecuteReader())
             {
                 if (reader == null)
                     return new T[0];
 
-                CheckColumnNames(reader);
-
-                List<T> result = new List<T>();
+                CheckColumnNames(reader);                
 
                 while (reader.Read())
                 {
@@ -262,6 +261,15 @@ namespace OpenSim.Data.MSSQL
                 {
                     names.Add(fi.Name);
                     values.Add("@" + fi.Name);
+                    // Temporarily return more information about what field is unexpectedly null for
+                    // http://opensimulator.org/mantis/view.php?id=5403.  This might be due to a bug in the 
+                    // InventoryTransferModule or we may be required to substitute a DBNull here.
+                    if (fi.GetValue(row) == null)
+                        throw new NullReferenceException(
+                            string.Format(
+                                "[MSSQL GENERIC TABLE HANDLER]: Trying to store field {0} for {1} which is unexpectedly null",
+                                fi.Name, row));
+
                     if (constraintFields.Count > 0 && constraintFields.Contains(fi.Name))
                     {
                         constraints.Add(new KeyValuePair<string, string>(fi.Name, fi.GetValue(row).ToString()));
@@ -335,16 +343,33 @@ namespace OpenSim.Data.MSSQL
             }
         }
 
-        public virtual bool Delete(string field, string val)
+        public virtual bool Delete(string field, string key)
         {
+            return Delete(new string[] { field }, new string[] { key });
+        }
+
+        public virtual bool Delete(string[] fields, string[] keys)
+        {
+            if (fields.Length != keys.Length)
+                return false;
+
+            List<string> terms = new List<string>();
+
             using (SqlConnection conn = new SqlConnection(m_ConnectionString))
             using (SqlCommand cmd = new SqlCommand())
             {
-                string deleteCommand = String.Format("DELETE FROM {0} WHERE [{1}] = @{1}", m_Realm, field);
-                cmd.CommandText = deleteCommand;
-                
-                cmd.Parameters.Add(m_database.CreateParameter(field, val));
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    cmd.Parameters.Add(m_database.CreateParameter(fields[i], keys[i]));
+                    terms.Add("[" + fields[i] + "] = @" + fields[i]);
+                }
+
+                string where = String.Join(" AND ", terms.ToArray());
+
+                string query = String.Format("DELETE FROM {0} WHERE {1}", m_Realm, where);
+
                 cmd.Connection = conn;
+                cmd.CommandText = query;
                 conn.Open();
 
                 if (cmd.ExecuteNonQuery() > 0)

OpenSim/Data/MSSQL/MSSQLMigration.cs

@@ -29,16 +29,19 @@ using System;
 using System.Data;
 using System.Data.Common;
 using System.Reflection;
+using System.Data.SqlClient;
 
 namespace OpenSim.Data.MSSQL
 {
     public class MSSQLMigration : Migration
     {
-        public MSSQLMigration(DbConnection conn, Assembly assem, string type) : base(conn, assem, type)
+        public MSSQLMigration(DbConnection conn, Assembly assem, string type)
+            : base(conn, assem, type)
         {
         }
 
-        public MSSQLMigration(DbConnection conn, Assembly assem, string subtype, string type) : base(conn, assem, subtype, type)
+        public MSSQLMigration(DbConnection conn, Assembly assem, string subtype, string type)
+            : base(conn, assem, subtype, type)
         {
         }
 
@@ -67,5 +70,30 @@ namespace OpenSim.Data.MSSQL
             }
             return version;
         }
+
+        protected override void ExecuteScript(DbConnection conn, string[] script)
+        {
+            if (!(conn is SqlConnection))
+            {
+                base.ExecuteScript(conn, script);
+                return;
+            }
+
+            foreach (string sql in script)
+            {
+                try
+                {
+                    using (SqlCommand cmd = new SqlCommand(sql, (SqlConnection)conn))
+                    {
+                        cmd.ExecuteNonQuery();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    throw new Exception(sql);
+
+                }
+            }
+        }
     }
 }

OpenSim/Data/MSSQL/MSSQLRegionData.cs

@@ -70,6 +70,7 @@ namespace OpenSim.Data.MSSQL
             string sql = "select * from ["+m_Realm+"] where regionName like @regionName";
             if (scopeID != UUID.Zero)
                 sql += " and ScopeID = @scopeID";
+            sql += " order by regionName";
             using (SqlConnection conn = new SqlConnection(m_ConnectionString))
             using (SqlCommand cmd = new SqlCommand(sql, conn))
             {

OpenSim/Data/MSSQL/MSSQLSimulationData.cs

@@ -55,6 +55,10 @@ namespace OpenSim.Data.MSSQL
         /// </summary>
         private MSSQLManager _Database;
         private string m_connectionString;
+        protected virtual Assembly Assembly
+        {
+            get { return GetType().Assembly; }
+        }
 
         public MSSQLSimulationData()
         {
@@ -74,9 +78,28 @@ namespace OpenSim.Data.MSSQL
             m_connectionString = connectionString;
             _Database = new MSSQLManager(connectionString);
 
+            using (SqlConnection conn = new SqlConnection(connectionString))
+            {
+                conn.Open();
+                //New Migration settings
+                Migration m = new Migration(conn, Assembly, "RegionStore");
+                m.Update();
 
-            //Migration settings
-            _Database.CheckMigration(_migrationStore);
+                // Clean dropped attachments
+                //
+                try
+                {
+                    using (SqlCommand cmd = conn.CreateCommand())
+                    {
+                        cmd.CommandText = "delete from prims where prims.UUID in (select UUID from primshapes where PCode = 9 and State <> 0); delete from primshapes where PCode = 9 and State <> 0";
+                        cmd.ExecuteNonQuery();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _Log.Error("[REGION DB]: Error cleaning up dropped attachments: " + ex.Message);
+                }
+            }
         }
 
         /// <summary>
@@ -214,7 +237,7 @@ namespace OpenSim.Data.MSSQL
                 {
                     command.Parameters.Clear();
                     command.Parameters.Add(_Database.CreateParameter("@PrimID", objectPart.UUID));
-                    
+
                     List<TaskInventoryItem> inventory = new List<TaskInventoryItem>();
 
                     using (SqlDataReader reader = command.ExecuteReader())
@@ -241,6 +264,14 @@ namespace OpenSim.Data.MSSQL
         /// <param name="regionUUID"></param>
         public void StoreObject(SceneObjectGroup obj, UUID regionUUID)
         {
+            uint flags = obj.RootPart.GetEffectiveObjectFlags();
+            // Eligibility check
+            //
+            if ((flags & (uint)PrimFlags.Temporary) != 0)
+                return;
+            if ((flags & (uint)PrimFlags.TemporaryOnRez) != 0)
+                return;
+
             _Log.DebugFormat("[MSSQL]: Adding/Changing SceneObjectGroup: {0} to region: {1}, object has {2} prims.", obj.UUID, regionUUID, obj.Parts.Length);
 
             using (SqlConnection conn = new SqlConnection(m_connectionString))
@@ -700,16 +731,470 @@ VALUES
         }
         public RegionLightShareData LoadRegionWindlightSettings(UUID regionUUID)
         {
-            //This connector doesn't support the windlight module yet
-            //Return default LL windlight settings
-            return new RegionLightShareData();
+            RegionLightShareData nWP = new RegionLightShareData();
+            nWP.OnSave += StoreRegionWindlightSettings;
+            string sql = "select * from [regionwindlight] where region_id = @regionID";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            using (SqlCommand cmd = new SqlCommand(sql, conn))
+            {
+                cmd.Parameters.Add(_Database.CreateParameter("@regionID", regionUUID));
+                conn.Open();
+                using (SqlDataReader result = cmd.ExecuteReader())
+                {
+                    if (!result.Read())
+                    {
+                        //No result, so store our default windlight profile and return it
+                        nWP.regionID = regionUUID;
+                        StoreRegionWindlightSettings(nWP);
+                        return nWP;
+                    }
+                    else
+                    {
+                        nWP.regionID = DBGuid.FromDB(result["region_id"]);
+                        nWP.waterColor.X = Convert.ToSingle(result["water_color_r"]);
+                        nWP.waterColor.Y = Convert.ToSingle(result["water_color_g"]);
+                        nWP.waterColor.Z = Convert.ToSingle(result["water_color_b"]);
+                        nWP.waterFogDensityExponent = Convert.ToSingle(result["water_fog_density_exponent"]);
+                        nWP.underwaterFogModifier = Convert.ToSingle(result["underwater_fog_modifier"]);
+                        nWP.reflectionWaveletScale.X = Convert.ToSingle(result["reflection_wavelet_scale_1"]);
+                        nWP.reflectionWaveletScale.Y = Convert.ToSingle(result["reflection_wavelet_scale_2"]);
+                        nWP.reflectionWaveletScale.Z = Convert.ToSingle(result["reflection_wavelet_scale_3"]);
+                        nWP.fresnelScale = Convert.ToSingle(result["fresnel_scale"]);
+                        nWP.fresnelOffset = Convert.ToSingle(result["fresnel_offset"]);
+                        nWP.refractScaleAbove = Convert.ToSingle(result["refract_scale_above"]);
+                        nWP.refractScaleBelow = Convert.ToSingle(result["refract_scale_below"]);
+                        nWP.blurMultiplier = Convert.ToSingle(result["blur_multiplier"]);
+                        nWP.bigWaveDirection.X = Convert.ToSingle(result["big_wave_direction_x"]);
+                        nWP.bigWaveDirection.Y = Convert.ToSingle(result["big_wave_direction_y"]);
+                        nWP.littleWaveDirection.X = Convert.ToSingle(result["little_wave_direction_x"]);
+                        nWP.littleWaveDirection.Y = Convert.ToSingle(result["little_wave_direction_y"]);
+                        UUID.TryParse(result["normal_map_texture"].ToString(), out nWP.normalMapTexture);
+                        nWP.horizon.X = Convert.ToSingle(result["horizon_r"]);
+                        nWP.horizon.Y = Convert.ToSingle(result["horizon_g"]);
+                        nWP.horizon.Z = Convert.ToSingle(result["horizon_b"]);
+                        nWP.horizon.W = Convert.ToSingle(result["horizon_i"]);
+                        nWP.hazeHorizon = Convert.ToSingle(result["haze_horizon"]);
+                        nWP.blueDensity.X = Convert.ToSingle(result["blue_density_r"]);
+                        nWP.blueDensity.Y = Convert.ToSingle(result["blue_density_g"]);
+                        nWP.blueDensity.Z = Convert.ToSingle(result["blue_density_b"]);
+                        nWP.blueDensity.W = Convert.ToSingle(result["blue_density_i"]);
+                        nWP.hazeDensity = Convert.ToSingle(result["haze_density"]);
+                        nWP.densityMultiplier = Convert.ToSingle(result["density_multiplier"]);
+                        nWP.distanceMultiplier = Convert.ToSingle(result["distance_multiplier"]);
+                        nWP.maxAltitude = Convert.ToUInt16(result["max_altitude"]);
+                        nWP.sunMoonColor.X = Convert.ToSingle(result["sun_moon_color_r"]);
+                        nWP.sunMoonColor.Y = Convert.ToSingle(result["sun_moon_color_g"]);
+                        nWP.sunMoonColor.Z = Convert.ToSingle(result["sun_moon_color_b"]);
+                        nWP.sunMoonColor.W = Convert.ToSingle(result["sun_moon_color_i"]);
+                        nWP.sunMoonPosition = Convert.ToSingle(result["sun_moon_position"]);
+                        nWP.ambient.X = Convert.ToSingle(result["ambient_r"]);
+                        nWP.ambient.Y = Convert.ToSingle(result["ambient_g"]);
+                        nWP.ambient.Z = Convert.ToSingle(result["ambient_b"]);
+                        nWP.ambient.W = Convert.ToSingle(result["ambient_i"]);
+                        nWP.eastAngle = Convert.ToSingle(result["east_angle"]);
+                        nWP.sunGlowFocus = Convert.ToSingle(result["sun_glow_focus"]);
+                        nWP.sunGlowSize = Convert.ToSingle(result["sun_glow_size"]);
+                        nWP.sceneGamma = Convert.ToSingle(result["scene_gamma"]);
+                        nWP.starBrightness = Convert.ToSingle(result["star_brightness"]);
+                        nWP.cloudColor.X = Convert.ToSingle(result["cloud_color_r"]);
+                        nWP.cloudColor.Y = Convert.ToSingle(result["cloud_color_g"]);
+                        nWP.cloudColor.Z = Convert.ToSingle(result["cloud_color_b"]);
+                        nWP.cloudColor.W = Convert.ToSingle(result["cloud_color_i"]);
+                        nWP.cloudXYDensity.X = Convert.ToSingle(result["cloud_x"]);
+                        nWP.cloudXYDensity.Y = Convert.ToSingle(result["cloud_y"]);
+                        nWP.cloudXYDensity.Z = Convert.ToSingle(result["cloud_density"]);
+                        nWP.cloudCoverage = Convert.ToSingle(result["cloud_coverage"]);
+                        nWP.cloudScale = Convert.ToSingle(result["cloud_scale"]);
+                        nWP.cloudDetailXYDensity.X = Convert.ToSingle(result["cloud_detail_x"]);
+                        nWP.cloudDetailXYDensity.Y = Convert.ToSingle(result["cloud_detail_y"]);
+                        nWP.cloudDetailXYDensity.Z = Convert.ToSingle(result["cloud_detail_density"]);
+                        nWP.cloudScrollX = Convert.ToSingle(result["cloud_scroll_x"]);
+                        nWP.cloudScrollXLock = Convert.ToBoolean(result["cloud_scroll_x_lock"]);
+                        nWP.cloudScrollY = Convert.ToSingle(result["cloud_scroll_y"]);
+                        nWP.cloudScrollYLock = Convert.ToBoolean(result["cloud_scroll_y_lock"]);
+                        nWP.drawClassicClouds = Convert.ToBoolean(result["draw_classic_clouds"]);
+                        nWP.valid = true;
+                    }
+                }
+            }
+            return nWP;
         }
+
         public void RemoveRegionWindlightSettings(UUID regionID)
         {
+            string sql = "delete from [regionwindlight] where region_id = @region_id";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            using (SqlCommand cmd = new SqlCommand(sql, conn))
+            {
+                conn.Open();
+                cmd.Parameters.Add(_Database.CreateParameter("@region_id", regionID));
+                cmd.ExecuteNonQuery();
+            }
         }
+
         public void StoreRegionWindlightSettings(RegionLightShareData wl)
         {
-            //This connector doesn't support the windlight module yet
+            string sql = "select count (region_id) from regionwindlight where region_id = @region_id";
+            bool exists = false;
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.Add(_Database.CreateParameter("@region_id", wl.regionID));
+                    exists = (int)cmd.ExecuteScalar() > 0;
+                }
+            }
+            if (exists)
+            {
+                RemoveRegionWindlightSettings(wl.regionID);
+            }
+
+            // sql insert
+            sql = @"INSERT INTO [regionwindlight]
+                       ([region_id]
+                       ,[water_color_r]
+                       ,[water_color_g]
+                       ,[water_color_b]
+                       ,[water_fog_density_exponent]
+                       ,[underwater_fog_modifier]
+                       ,[reflection_wavelet_scale_1]
+                       ,[reflection_wavelet_scale_2]
+                       ,[reflection_wavelet_scale_3]
+                       ,[fresnel_scale]
+                       ,[fresnel_offset]
+                       ,[refract_scale_above]
+                       ,[refract_scale_below]
+                       ,[blur_multiplier]
+                       ,[big_wave_direction_x]
+                       ,[big_wave_direction_y]
+                       ,[little_wave_direction_x]
+                       ,[little_wave_direction_y]
+                       ,[normal_map_texture]
+                       ,[horizon_r]
+                       ,[horizon_g]
+                       ,[horizon_b]
+                       ,[horizon_i]
+                       ,[haze_horizon]
+                       ,[blue_density_r]
+                       ,[blue_density_g]
+                       ,[blue_density_b]
+                       ,[blue_density_i]
+                       ,[haze_density]
+                       ,[density_multiplier]
+                       ,[distance_multiplier]
+                       ,[max_altitude]
+                       ,[sun_moon_color_r]
+                       ,[sun_moon_color_g]
+                       ,[sun_moon_color_b]
+                       ,[sun_moon_color_i]
+                       ,[sun_moon_position]
+                       ,[ambient_r]
+                       ,[ambient_g]
+                       ,[ambient_b]
+                       ,[ambient_i]
+                       ,[east_angle]
+                       ,[sun_glow_focus]
+                       ,[sun_glow_size]
+                       ,[scene_gamma]
+                       ,[star_brightness]
+                       ,[cloud_color_r]
+                       ,[cloud_color_g]
+                       ,[cloud_color_b]
+                       ,[cloud_color_i]
+                       ,[cloud_x]
+                       ,[cloud_y]
+                       ,[cloud_density]
+                       ,[cloud_coverage]
+                       ,[cloud_scale]
+                       ,[cloud_detail_x]
+                       ,[cloud_detail_y]
+                       ,[cloud_detail_density]
+                       ,[cloud_scroll_x]
+                       ,[cloud_scroll_x_lock]
+                       ,[cloud_scroll_y]
+                       ,[cloud_scroll_y_lock]
+                       ,[draw_classic_clouds])
+                 VALUES
+                       (@region_id
+                       ,@water_color_r
+                       ,@water_color_g
+                       ,@water_color_b
+                       ,@water_fog_density_exponent
+                       ,@underwater_fog_modifier
+                       ,@reflection_wavelet_scale_1
+                       ,@reflection_wavelet_scale_2
+                       ,@reflection_wavelet_scale_3
+                       ,@fresnel_scale
+                       ,@fresnel_offset
+                       ,@refract_scale_above
+                       ,@refract_scale_below
+                       ,@blur_multiplier
+                       ,@big_wave_direction_x
+                       ,@big_wave_direction_y
+                       ,@little_wave_direction_x
+                       ,@little_wave_direction_y
+                       ,@normal_map_texture
+                       ,@horizon_r
+                       ,@horizon_g
+                       ,@horizon_b
+                       ,@horizon_i
+                       ,@haze_horizon
+                       ,@blue_density_r
+                       ,@blue_density_g
+                       ,@blue_density_b
+                       ,@blue_density_i
+                       ,@haze_density
+                       ,@density_multiplier
+                       ,@distance_multiplier
+                       ,@max_altitude
+                       ,@sun_moon_color_r
+                       ,@sun_moon_color_g
+                       ,@sun_moon_color_b
+                       ,@sun_moon_color_i
+                       ,@sun_moon_position
+                       ,@ambient_r
+                       ,@ambient_g
+                       ,@ambient_b
+                       ,@ambient_i
+                       ,@east_angle
+                       ,@sun_glow_focus
+                       ,@sun_glow_size
+                       ,@scene_gamma
+                       ,@star_brightness
+                       ,@cloud_color_r
+                       ,@cloud_color_g
+                       ,@cloud_color_b
+                       ,@cloud_color_i
+                       ,@cloud_x
+                       ,@cloud_y
+                       ,@cloud_density
+                       ,@cloud_coverage
+                       ,@cloud_scale
+                       ,@cloud_detail_x
+                       ,@cloud_detail_y
+                       ,@cloud_detail_density
+                       ,@cloud_scroll_x
+                       ,@cloud_scroll_x_lock
+                       ,@cloud_scroll_y
+                       ,@cloud_scroll_y_lock
+                       ,@draw_classic_clouds)";
+            using (SqlConnection conn = new SqlConnection(m_connectionString))
+            {
+                conn.Open();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.Add(_Database.CreateParameter("region_id", wl.regionID));
+                    cmd.Parameters.Add(_Database.CreateParameter("water_color_r", wl.waterColor.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("water_color_g", wl.waterColor.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("water_color_b", wl.waterColor.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("water_fog_density_exponent", wl.waterFogDensityExponent));
+                    cmd.Parameters.Add(_Database.CreateParameter("underwater_fog_modifier", wl.underwaterFogModifier));
+                    cmd.Parameters.Add(_Database.CreateParameter("reflection_wavelet_scale_1", wl.reflectionWaveletScale.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("reflection_wavelet_scale_2", wl.reflectionWaveletScale.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("reflection_wavelet_scale_3", wl.reflectionWaveletScale.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("fresnel_scale", wl.fresnelScale));
+                    cmd.Parameters.Add(_Database.CreateParameter("fresnel_offset", wl.fresnelOffset));
+                    cmd.Parameters.Add(_Database.CreateParameter("refract_scale_above", wl.refractScaleAbove));
+                    cmd.Parameters.Add(_Database.CreateParameter("refract_scale_below", wl.refractScaleBelow));
+                    cmd.Parameters.Add(_Database.CreateParameter("blur_multiplier", wl.blurMultiplier));
+                    cmd.Parameters.Add(_Database.CreateParameter("big_wave_direction_x", wl.bigWaveDirection.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("big_wave_direction_y", wl.bigWaveDirection.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("little_wave_direction_x", wl.littleWaveDirection.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("little_wave_direction_y", wl.littleWaveDirection.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("normal_map_texture", wl.normalMapTexture));
+                    cmd.Parameters.Add(_Database.CreateParameter("horizon_r", wl.horizon.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("horizon_g", wl.horizon.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("horizon_b", wl.horizon.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("horizon_i", wl.horizon.W));
+                    cmd.Parameters.Add(_Database.CreateParameter("haze_horizon", wl.hazeHorizon));
+                    cmd.Parameters.Add(_Database.CreateParameter("blue_density_r", wl.blueDensity.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("blue_density_g", wl.blueDensity.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("blue_density_b", wl.blueDensity.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("blue_density_i", wl.blueDensity.W));
+                    cmd.Parameters.Add(_Database.CreateParameter("haze_density", wl.hazeDensity));
+                    cmd.Parameters.Add(_Database.CreateParameter("density_multiplier", wl.densityMultiplier));
+                    cmd.Parameters.Add(_Database.CreateParameter("distance_multiplier", wl.distanceMultiplier));
+                    cmd.Parameters.Add(_Database.CreateParameter("max_altitude", wl.maxAltitude));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_moon_color_r", wl.sunMoonColor.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_moon_color_g", wl.sunMoonColor.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_moon_color_b", wl.sunMoonColor.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_moon_color_i", wl.sunMoonColor.W));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_moon_position", wl.sunMoonPosition));
+                    cmd.Parameters.Add(_Database.CreateParameter("ambient_r", wl.ambient.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("ambient_g", wl.ambient.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("ambient_b", wl.ambient.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("ambient_i", wl.ambient.W));
+                    cmd.Parameters.Add(_Database.CreateParameter("east_angle", wl.eastAngle));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_glow_focus", wl.sunGlowFocus));
+                    cmd.Parameters.Add(_Database.CreateParameter("sun_glow_size", wl.sunGlowSize));
+                    cmd.Parameters.Add(_Database.CreateParameter("scene_gamma", wl.sceneGamma));
+                    cmd.Parameters.Add(_Database.CreateParameter("star_brightness", wl.starBrightness));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_color_r", wl.cloudColor.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_color_g", wl.cloudColor.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_color_b", wl.cloudColor.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_color_i", wl.cloudColor.W));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_x", wl.cloudXYDensity.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_y", wl.cloudXYDensity.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_density", wl.cloudXYDensity.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_coverage", wl.cloudCoverage));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_scale", wl.cloudScale));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_detail_x", wl.cloudDetailXYDensity.X));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_detail_y", wl.cloudDetailXYDensity.Y));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_detail_density", wl.cloudDetailXYDensity.Z));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_scroll_x", wl.cloudScrollX));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_scroll_x_lock", wl.cloudScrollXLock));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_scroll_y", wl.cloudScrollY));
+                    cmd.Parameters.Add(_Database.CreateParameter("cloud_scroll_y_lock", wl.cloudScrollYLock));
+                    cmd.Parameters.Add(_Database.CreateParameter("draw_classic_clouds", wl.drawClassicClouds));
+
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            #region update
+            //            }
+            //            else
+            //            {
+            //                // sql update
+            //                sql = @"UPDATE [OpenSim].[dbo].[regionwindlight]
+            //   SET [region_id] =                   @region_id
+            //      ,[water_color_r] =               @water_color_r
+            //      ,[water_color_g] =               @water_color_g
+            //      ,[water_color_b] =               @water_color_b
+            //      ,[water_fog_density_exponent] =  @water_fog_density_exponent
+            //      ,[underwater_fog_modifier] =     @underwater_fog_modifier
+            //      ,[reflection_wavelet_scale_1] =  @reflection_wavelet_scale_1
+            //      ,[reflection_wavelet_scale_2] =  @reflection_wavelet_scale_2
+            //      ,[reflection_wavelet_scale_3] =  @reflection_wavelet_scale_3
+            //      ,[fresnel_scale] =               @fresnel_scale
+            //      ,[fresnel_offset] =              @fresnel_offset
+            //      ,[refract_scale_above] =         @refract_scale_above
+            //      ,[refract_scale_below] =         @refract_scale_below
+            //      ,[blur_multiplier] =             @blur_multiplier
+            //      ,[big_wave_direction_x] =        @big_wave_direction_x
+            //      ,[big_wave_direction_y] =        @big_wave_direction_y
+            //      ,[little_wave_direction_x] =     @little_wave_direction_x
+            //      ,[little_wave_direction_y] =     @little_wave_direction_y
+            //      ,[normal_map_texture] =          @normal_map_texture
+            //      ,[horizon_r] =                   @horizon_r
+            //      ,[horizon_g] =                   @horizon_g
+            //      ,[horizon_b] =                   @horizon_b
+            //      ,[horizon_i] =                   @horizon_i
+            //      ,[haze_horizon] =                @haze_horizon
+            //      ,[blue_density_r] =              @blue_density_r
+            //      ,[blue_density_g] =              @blue_density_g
+            //      ,[blue_density_b] =              @blue_density_b
+            //      ,[blue_density_i] =              @blue_density_i
+            //      ,[haze_density] =                @haze_density
+            //      ,[density_multiplier] =          @density_multiplier
+            //      ,[distance_multiplier] =         @distance_multiplier
+            //      ,[max_altitude] =                @max_altitude
+            //      ,[sun_moon_color_r] =            @sun_moon_color_r
+            //      ,[sun_moon_color_g] =            @sun_moon_color_g
+            //      ,[sun_moon_color_b] =            @sun_moon_color_b
+            //      ,[sun_moon_color_i] =            @sun_moon_color_i
+            //      ,[sun_moon_position] =           @sun_moon_position
+            //      ,[ambient_r] =                   @ambient_r
+            //      ,[ambient_g] =                   @ambient_g
+            //      ,[ambient_b] =                   @ambient_b
+            //      ,[ambient_i] =                   @ambient_i
+            //      ,[east_angle] =                  @east_angle
+            //      ,[sun_glow_focus] =              @sun_glow_focus
+            //      ,[sun_glow_size] =               @sun_glow_size
+            //      ,[scene_gamma] =                 @scene_gamma
+            //      ,[star_brightness] =             @star_brightness
+            //      ,[cloud_color_r] =               @cloud_color_r
+            //      ,[cloud_color_g] =               @cloud_color_g
+            //      ,[cloud_color_b] =               @cloud_color_b
+            //      ,[cloud_color_i] =               @cloud_color_i
+            //      ,[cloud_x] =                     @cloud_x
+            //      ,[cloud_y] =                     @cloud_y
+            //      ,[cloud_density] =               @cloud_density
+            //      ,[cloud_coverage] =              @cloud_coverage
+            //      ,[cloud_scale] =                 @cloud_scale
+            //      ,[cloud_detail_x] =              @cloud_detail_x
+            //      ,[cloud_detail_y] =              @cloud_detail_y
+            //      ,[cloud_detail_density] =        @cloud_detail_density
+            //      ,[cloud_scroll_x] =              @cloud_scroll_x
+            //      ,[cloud_scroll_x_lock] =         @cloud_scroll_x_lock
+            //      ,[cloud_scroll_y] =              @cloud_scroll_y
+            //      ,[cloud_scroll_y_lock] =         @cloud_scroll_y_lock
+            //      ,[draw_classic_clouds] =         @draw_classic_clouds
+            // WHERE region_id = @region_id";
+            //                using (SqlConnection conn = new SqlConnection(m_connectionString))
+            //                {
+            //                    conn.Open();
+            //                    using (SqlCommand cmd = new SqlCommand(sql, conn))
+            //                    {
+            //                        cmd.Parameters.AddWithValue("region_id", wl.regionID);
+            //                        cmd.Parameters.AddWithValue("water_color_r", wl.waterColor.X);
+            //                        cmd.Parameters.AddWithValue("water_color_g", wl.waterColor.Y);
+            //                        cmd.Parameters.AddWithValue("water_color_b", wl.waterColor.Z);
+            //                        cmd.Parameters.AddWithValue("water_fog_density_exponent", wl.waterFogDensityExponent);
+            //                        cmd.Parameters.AddWithValue("underwater_fog_modifier", wl.underwaterFogModifier);
+            //                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_1", wl.reflectionWaveletScale.X);
+            //                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_2", wl.reflectionWaveletScale.Y);
+            //                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_3", wl.reflectionWaveletScale.Z);
+            //                        cmd.Parameters.AddWithValue("fresnel_scale", wl.fresnelScale);
+            //                        cmd.Parameters.AddWithValue("fresnel_offset", wl.fresnelOffset);
+            //                        cmd.Parameters.AddWithValue("refract_scale_above", wl.refractScaleAbove);
+            //                        cmd.Parameters.AddWithValue("refract_scale_below", wl.refractScaleBelow);
+            //                        cmd.Parameters.AddWithValue("blur_multiplier", wl.blurMultiplier);
+            //                        cmd.Parameters.AddWithValue("big_wave_direction_x", wl.bigWaveDirection.X);
+            //                        cmd.Parameters.AddWithValue("big_wave_direction_y", wl.bigWaveDirection.Y);
+            //                        cmd.Parameters.AddWithValue("little_wave_direction_x", wl.littleWaveDirection.X);
+            //                        cmd.Parameters.AddWithValue("little_wave_direction_y", wl.littleWaveDirection.Y);
+            //                        cmd.Parameters.AddWithValue("normal_map_texture", wl.normalMapTexture);
+            //                        cmd.Parameters.AddWithValue("horizon_r", wl.horizon.X);
+            //                        cmd.Parameters.AddWithValue("horizon_g", wl.horizon.Y);
+            //                        cmd.Parameters.AddWithValue("horizon_b", wl.horizon.Z);
+            //                        cmd.Parameters.AddWithValue("horizon_i", wl.horizon.W);
+            //                        cmd.Parameters.AddWithValue("haze_horizon", wl.hazeHorizon);
+            //                        cmd.Parameters.AddWithValue("blue_density_r", wl.blueDensity.X);
+            //                        cmd.Parameters.AddWithValue("blue_density_g", wl.blueDensity.Y);
+            //                        cmd.Parameters.AddWithValue("blue_density_b", wl.blueDensity.Z);
+            //                        cmd.Parameters.AddWithValue("blue_density_i", wl.blueDensity.W);
+            //                        cmd.Parameters.AddWithValue("haze_density", wl.hazeDensity);
+            //                        cmd.Parameters.AddWithValue("density_multiplier", wl.densityMultiplier);
+            //                        cmd.Parameters.AddWithValue("distance_multiplier", wl.distanceMultiplier);
+            //                        cmd.Parameters.AddWithValue("max_altitude", wl.maxAltitude);
+            //                        cmd.Parameters.AddWithValue("sun_moon_color_r", wl.sunMoonColor.X);
+            //                        cmd.Parameters.AddWithValue("sun_moon_color_g", wl.sunMoonColor.Y);
+            //                        cmd.Parameters.AddWithValue("sun_moon_color_b", wl.sunMoonColor.Z);
+            //                        cmd.Parameters.AddWithValue("sun_moon_color_i", wl.sunMoonColor.W);
+            //                        cmd.Parameters.AddWithValue("sun_moon_position", wl.sunMoonPosition);
+            //                        cmd.Parameters.AddWithValue("ambient_r", wl.ambient.X);
+            //                        cmd.Parameters.AddWithValue("ambient_g", wl.ambient.Y);
+            //                        cmd.Parameters.AddWithValue("ambient_b", wl.ambient.Z);
+            //                        cmd.Parameters.AddWithValue("ambient_i", wl.ambient.W);
+            //                        cmd.Parameters.AddWithValue("east_angle", wl.eastAngle);
+            //                        cmd.Parameters.AddWithValue("sun_glow_focus", wl.sunGlowFocus);
+            //                        cmd.Parameters.AddWithValue("sun_glow_size", wl.sunGlowSize);
+            //                        cmd.Parameters.AddWithValue("scene_gamma", wl.sceneGamma);
+            //                        cmd.Parameters.AddWithValue("star_brightness", wl.starBrightness);
+            //                        cmd.Parameters.AddWithValue("cloud_color_r", wl.cloudColor.X);
+            //                        cmd.Parameters.AddWithValue("cloud_color_g", wl.cloudColor.Y);
+            //                        cmd.Parameters.AddWithValue("cloud_color_b", wl.cloudColor.Z);
+            //                        cmd.Parameters.AddWithValue("cloud_color_i", wl.cloudColor.W);
+            //                        cmd.Parameters.AddWithValue("cloud_x", wl.cloudXYDensity.X);
+            //                        cmd.Parameters.AddWithValue("cloud_y", wl.cloudXYDensity.Y);
+            //                        cmd.Parameters.AddWithValue("cloud_density", wl.cloudXYDensity.Z);
+            //                        cmd.Parameters.AddWithValue("cloud_coverage", wl.cloudCoverage);
+            //                        cmd.Parameters.AddWithValue("cloud_scale", wl.cloudScale);
+            //                        cmd.Parameters.AddWithValue("cloud_detail_x", wl.cloudDetailXYDensity.X);
+            //                        cmd.Parameters.AddWithValue("cloud_detail_y", wl.cloudDetailXYDensity.Y);
+            //                        cmd.Parameters.AddWithValue("cloud_detail_density", wl.cloudDetailXYDensity.Z);
+            //                        cmd.Parameters.AddWithValue("cloud_scroll_x", wl.cloudScrollX);
+            //                        cmd.Parameters.AddWithValue("cloud_scroll_x_lock", wl.cloudScrollXLock);
+            //                        cmd.Parameters.AddWithValue("cloud_scroll_y", wl.cloudScrollY);
+            //                        cmd.Parameters.AddWithValue("cloud_scroll_y_lock", wl.cloudScrollYLock);
+            //                        cmd.Parameters.AddWithValue("draw_classic_clouds", wl.drawClassicClouds);
+
+            //                        cmd.ExecuteNonQuery();
+            //                    }
+            //                }
+            //            }
+            #endregion
         }
         /// <summary>
         /// Loads the settings of a region.
@@ -1136,7 +1621,7 @@ VALUES
             if (Convert.ToInt16(primRow["PassTouches"]) != 0)
                 prim.PassTouches = true;
             prim.LinkNum = Convert.ToInt32(primRow["LinkNumber"]);
-            
+
             if (!(primRow["MediaURL"] is System.DBNull))
                 prim.MediaUrl = (string)primRow["MediaURL"];
 
@@ -1192,11 +1677,11 @@ VALUES
             {
             }
 
-            if (!(shapeRow["Media"] is System.DBNull) )
+            if (!(shapeRow["Media"] is System.DBNull))
             {
                 baseShape.Media = PrimitiveBaseShape.MediaList.FromXml((string)shapeRow["Media"]);
             }
-                
+
 
             return baseShape;
         }
@@ -1576,15 +2061,15 @@ VALUES
             parameters.Add(_Database.CreateParameter("ExtraParams", s.ExtraParams));
             parameters.Add(_Database.CreateParameter("State", s.State));
 
-            if(null == s.Media )
+            if (null == s.Media)
             {
-                parameters.Add(_Database.CreateParameter("Media", DBNull.Value));    
+                parameters.Add(_Database.CreateParameter("Media", DBNull.Value));
             }
             else
             {
-                parameters.Add(_Database.CreateParameter("Media", s.Media.ToXml()));    
+                parameters.Add(_Database.CreateParameter("Media", s.Media.ToXml()));
             }
-            
+
 
             return parameters.ToArray();
         }

OpenSim/Data/MSSQL/MSSQLXInventoryData.cs

@@ -66,11 +66,18 @@ namespace OpenSim.Data.MSSQL
 
         public bool StoreFolder(XInventoryFolder folder)
         {
+            if (folder.folderName.Length > 64)
+                folder.folderName = folder.folderName.Substring(0, 64);
             return m_Folders.Store(folder);
         }
 
         public bool StoreItem(XInventoryItem item)
         {
+            if (item.inventoryName.Length > 64)
+                item.inventoryName = item.inventoryName.Substring(0, 64);
+            if (item.inventoryDescription.Length > 128)
+                item.inventoryDescription = item.inventoryDescription.Substring(0, 128);
+
             return m_Items.Store(item);
         }
 
@@ -78,12 +85,19 @@ namespace OpenSim.Data.MSSQL
         {
             return m_Folders.Delete(field, val);
         }
+        public bool DeleteFolders(string[] fields, string[] vals)
+        {
+            return m_Folders.Delete(fields, vals);
+        }
 
         public bool DeleteItems(string field, string val)
         {
             return m_Items.Delete(field, val);
         }
-
+        public bool DeleteItems(string[] fields, string[] vals)
+        {
+            return m_Items.Delete(fields, vals);
+        }
         public bool MoveItem(string id, string newParent)
         {
             return m_Items.MoveItem(id, newParent);
@@ -162,5 +176,27 @@ namespace OpenSim.Data.MSSQL
 
             }
         }
+        public override bool Store(XInventoryItem item)
+        {
+            if (!base.Store(item))
+                return false;
+            string sql = "update inventoryfolders set version=version+1 where folderID = @folderID";
+            using (SqlConnection conn = new SqlConnection(m_ConnectionString))
+            using (SqlCommand cmd = new SqlCommand(sql, conn))
+            {
+                conn.Open();
+
+                    cmd.Parameters.AddWithValue("@folderID", item.parentFolderID.ToString());
+                    try
+                    {
+                        cmd.ExecuteNonQuery();
+                    }
+                    catch (Exception e)
+                    {
+                        return false;
+                    }                
+            }
+            return true;
+        }
     }
 }

OpenSim/Data/MSSQL/Resources/Avatar.migrations

@@ -37,4 +37,28 @@ EXECUTE sp_rename N'dbo.Tmp_Avatars', N'Avatars', 'OBJECT'
 
 COMMIT
 
+:VERSION 3
+
+BEGIN TRANSACTION
+
+CREATE TABLE dbo.Tmp_Avatars
+	(
+	PrincipalID uniqueidentifier NOT NULL,
+	[Name] varchar(32) NOT NULL, 
+	Value text NOT NULL DEFAULT '',
+	PRIMARY KEY CLUSTERED 
+(
+	[PrincipalID] ASC, [Name] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+)  ON [PRIMARY]
+	 TEXTIMAGE_ON [PRIMARY]
+
+IF EXISTS(SELECT * FROM dbo.Avatars)
+	 EXEC('INSERT INTO dbo.Tmp_Avatars (PrincipalID, Name, Value)
+		SELECT PrincipalID, CONVERT(text, Name), Value FROM dbo.Avatars WITH (HOLDLOCK TABLOCKX)')
+
+DROP TABLE dbo.Avatars
+
+EXECUTE sp_rename N'dbo.Tmp_Avatars', N'Avatars', 'OBJECT' 
+COMMIT
 

OpenSim/Data/MSSQL/Resources/GridUserStore.migrations

@@ -17,3 +17,49 @@ CREATE TABLE "GridUser" (
 ) 
 
 COMMIT
+
+:VERSION 2         # -------------------------- 
+
+BEGIN TRANSACTION
+
+CREATE TABLE [GridUser_tmp] (
+    [UserID] VARCHAR(255) NOT NULL,
+    [HomeRegionID] uniqueidentifier NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000',
+    [HomePosition] CHAR(64) NOT NULL DEFAULT '<0,0,0>',
+    [HomeLookAt] CHAR(64) NOT NULL DEFAULT '<0,0,0>',
+    [LastRegionID] uniqueidentifier NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000',
+    [LastPosition] CHAR(64) NOT NULL DEFAULT '<0,0,0>',
+    [LastLookAt] CHAR(64) NOT NULL DEFAULT '<0,0,0>',
+    [Online] CHAR(5) NOT NULL DEFAULT 'false',
+    [Login] CHAR(16) NOT NULL DEFAULT '0',
+    [Logout] CHAR(16) NOT NULL DEFAULT '0',
+    
+	  PRIMARY KEY CLUSTERED
+		(
+			[UserID] ASC
+		)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+	) ON [PRIMARY]
+
+COMMIT
+
+IF EXISTS(SELECT * FROM dbo.GridUser)
+	 EXEC('INSERT INTO dbo.GridUser_tmp ([UserID]
+           ,[HomeRegionID]
+           ,[HomePosition]
+           ,[HomeLookAt]
+           ,[LastRegionID]
+           ,[LastPosition]
+           ,[LastLookAt]
+           ,[Online]
+           ,[Login]
+           ,[Logout])
+		SELECT CONVERT(varchar(36), [HomeRegionID]), [HomePosition] ,[HomeLookAt] , CONVERT(varchar(36),[LastRegionID])
+      ,[LastPosition]
+      ,[LastLookAt]
+      ,[Online]
+      ,[Login]
+      ,[Logout] FROM dbo.GridUser WITH (HOLDLOCK TABLOCKX)')
+
+DROP TABLE dbo.GridUser
+
+EXECUTE sp_rename N'dbo.GridUser_tmp', N'GridUser', 'OBJECT' 

OpenSim/Data/MSSQL/Resources/RegionStore.migrations

@@ -1003,7 +1003,7 @@ CREATE TABLE "regionwindlight" (
   PRIMARY KEY ("region_id")
 )
 
-COMMIT TRANSACTION
+COMMIT
 
 :VERSION 26
 

OpenSim/Data/MySQL/MySQLFriendsData.cs

@@ -43,6 +43,11 @@ namespace OpenSim.Data.MySQL
         }
 
         public bool Delete(UUID principalID, string friend)
+        {
+            return Delete(principalID.ToString(), friend);
+        }
+
+        public bool Delete(string principalID, string friend)
         {
             MySqlCommand cmd = new MySqlCommand();
 
@@ -64,5 +69,14 @@ namespace OpenSim.Data.MySQL
 
             return DoQuery(cmd);
         }
+
+        public FriendsData[] GetFriends(string principalID)
+        {
+            MySqlCommand cmd = new MySqlCommand();
+
+            cmd.CommandText = String.Format("select a.*,case when b.Flags is null then -1 else b.Flags end as TheirFlags from {0} as a left join {0} as b on a.PrincipalID = b.Friend and a.Friend = b.PrincipalID where a.PrincipalID LIKE ?PrincipalID", m_Realm);
+            cmd.Parameters.AddWithValue("?PrincipalID", principalID.ToString() + '%');
+            return DoQuery(cmd);
+        }
     }
 }

OpenSim/Data/MySQL/MySQLGenericTableHandler.cs

@@ -264,18 +264,33 @@ namespace OpenSim.Data.MySQL
             }
         }
 
-        public virtual bool Delete(string field, string val)
+        public virtual bool Delete(string field, string key)
         {
+            return Delete(new string[] { field }, new string[] { key });
+        }
+
+        public virtual bool Delete(string[] fields, string[] keys)
+        {
+            if (fields.Length != keys.Length)
+                return false;
+
+            List<string> terms = new List<string>();
+
             using (MySqlCommand cmd = new MySqlCommand())
             {
+                for (int i = 0 ; i < fields.Length ; i++)
+                {
+                    cmd.Parameters.AddWithValue(fields[i], keys[i]);
+                    terms.Add("`" + fields[i] + "` = ?" + fields[i]);
+                }
 
-                cmd.CommandText = String.Format("delete from {0} where `{1}` = ?{1}", m_Realm, field);
-                cmd.Parameters.AddWithValue(field, val);
+                string where = String.Join(" and ", terms.ToArray());
 
-                if (ExecuteNonQuery(cmd) > 0)
-                    return true;
+                string query = String.Format("delete from {0} where {1}", m_Realm, where);
 
-                return false;
+                cmd.CommandText = query;
+
+                return ExecuteNonQuery(cmd) > 0;
             }
         }
     }

OpenSim/Data/MySQL/MySQLXInventoryData.cs

@@ -85,11 +85,21 @@ namespace OpenSim.Data.MySQL
             return m_Folders.Delete(field, val);
         }
 
+        public bool DeleteFolders(string[] fields, string[] vals)
+        {
+            return m_Folders.Delete(fields, vals);
+        }
+
         public bool DeleteItems(string field, string val)
         {
             return m_Items.Delete(field, val);
         }
 
+        public bool DeleteItems(string[] fields, string[] vals)
+        {
+            return m_Items.Delete(fields, vals);
+        }
+
         public bool MoveItem(string id, string newParent)
         {
             return m_Items.MoveItem(id, newParent);

OpenSim/Data/MySQL/Resources/FriendsStore.migrations

@@ -21,5 +21,12 @@ INSERT INTO `Friends` SELECT `ownerID`, `friendID`, `friendPerms`, 0 FROM `userf
 
 COMMIT;
 
+:VERSION 3       # -------------------------
 
+BEGIN;
 
+ALTER TABLE `Friends` DROP PRIMARY KEY;
+ALTER TABLE `Friends` ADD PRIMARY KEY(PrincipalID(36), Friend(36));
+ALTER TABLE `Friends` MODIFY COLUMN PrincipalID varchar(255) NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000';
+
+COMMIT;

OpenSim/Data/MySQL/Resources/RegionStore.migrations

@@ -826,3 +826,19 @@ ALTER TABLE `prims` MODIFY COLUMN `CreatorID` VARCHAR(255) NOT NULL DEFAULT '';
 ALTER TABLE `primitems` MODIFY COLUMN `CreatorID` VARCHAR(255) NOT NULL DEFAULT '';
 
 COMMIT;
+
+:VERSION 38          #---------------------
+
+BEGIN;
+
+alter table land ENGINE = MyISAM;
+alter table landaccesslist ENGINE = MyISAM;
+alter table migrations ENGINE = MyISAM;
+alter table primitems ENGINE = MyISAM;
+alter table prims ENGINE = MyISAM;
+alter table primshapes ENGINE = MyISAM;
+alter table regionban ENGINE = MyISAM;
+alter table regionsettings ENGINE = MyISAM;
+alter table terrain ENGINE = MyISAM;
+
+COMMIT;

OpenSim/Data/Null/NullFriendsData.cs

@@ -42,6 +42,11 @@ namespace OpenSim.Data.Null
         {
         }
 
+        public FriendsData[] GetFriends(UUID principalID)
+        {
+            return GetFriends(principalID.ToString());
+        }
+
         /// <summary>
         /// Tries to implement the Get [] semantics, but it cuts corners.
         /// Specifically, it gets all friendships even if they weren't accepted yet.
@@ -49,11 +54,11 @@ namespace OpenSim.Data.Null
         /// <param name="fields"></param>
         /// <param name="values"></param>
         /// <returns></returns>
-        public FriendsData[] GetFriends(UUID userID)
+        public FriendsData[] GetFriends(string userID)
         {
             List<FriendsData> lst = m_Data.FindAll(delegate (FriendsData fdata)
             {
-                return fdata.PrincipalID == userID;
+                return fdata.PrincipalID == userID.ToString();
             });
 
             if (lst != null)
@@ -72,9 +77,14 @@ namespace OpenSim.Data.Null
             return true;
         }
 
-        public bool Delete(UUID userID, string friendID)
+        public bool Delete(UUID principalID, string friend)
         {
-            List<FriendsData> lst = m_Data.FindAll(delegate(FriendsData fdata) { return fdata.PrincipalID == userID; });
+            return Delete(principalID.ToString(), friend);
+        }
+
+        public bool Delete(string userID, string friendID)
+        {
+            List<FriendsData> lst = m_Data.FindAll(delegate(FriendsData fdata) { return fdata.PrincipalID == userID.ToString(); });
             if (lst != null)
             {
                 FriendsData friend = lst.Find(delegate(FriendsData fdata) { return fdata.Friend == friendID; });

OpenSim/Data/SQLite/SQLiteFriendsData.cs

@@ -46,7 +46,12 @@ namespace OpenSim.Data.SQLite
         {
         }
 
-        public FriendsData[] GetFriends(UUID userID)
+        public FriendsData[] GetFriends(UUID principalID)
+        {
+            return GetFriends(principalID.ToString());
+        }
+
+        public FriendsData[] GetFriends(string userID)
         {
             SqliteCommand cmd = new SqliteCommand();
 
@@ -58,6 +63,11 @@ namespace OpenSim.Data.SQLite
         }
 
         public bool Delete(UUID principalID, string friend)
+        {
+            return Delete(principalID.ToString(), friend);
+        }
+
+        public bool Delete(string principalID, string friend)
         {
             SqliteCommand cmd = new SqliteCommand();
 

OpenSim/Data/SQLite/SQLiteGenericTableHandler.cs

@@ -258,17 +258,33 @@ namespace OpenSim.Data.SQLite
             return false;
         }
 
-        public bool Delete(string field, string val)
+        public virtual bool Delete(string field, string key)
         {
+            return Delete(new string[] { field }, new string[] { key });
+        }        
+
+        public bool Delete(string[] fields, string[] keys)
+        {
+            if (fields.Length != keys.Length)
+                return false;
+
+            List<string> terms = new List<string>();
+
             SqliteCommand cmd = new SqliteCommand();
 
-            cmd.CommandText = String.Format("delete from {0} where `{1}` = :{1}", m_Realm, field);
-            cmd.Parameters.Add(new SqliteParameter(field, val));
+            for (int i = 0 ; i < fields.Length ; i++)
+            {
+                cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i]));
+                terms.Add("`" + fields[i] + "` = :" + fields[i]);
+            }
 
-            if (ExecuteNonQuery(cmd, m_Connection) > 0)
-                return true;
+            string where = String.Join(" and ", terms.ToArray());
 
-            return false;
+            string query = String.Format("delete from {0} where {1}", m_Realm, where);
+
+            cmd.CommandText = query;
+
+            return ExecuteNonQuery(cmd, m_Connection) > 0;
         }
     }
 }

OpenSim/Data/SQLite/SQLiteXInventoryData.cs

@@ -91,11 +91,21 @@ namespace OpenSim.Data.SQLite
             return m_Folders.Delete(field, val);
         }
 
+        public bool DeleteFolders(string[] fields, string[] vals)
+        {
+            return m_Folders.Delete(fields, vals);
+        }
+
         public bool DeleteItems(string field, string val)
         {
             return m_Items.Delete(field, val);
         }
 
+        public bool DeleteItems(string[] fields, string[] vals)
+        {
+            return m_Items.Delete(fields, vals);
+        }        
+
         public bool MoveItem(string id, string newParent)
         {
             return m_Items.MoveItem(id, newParent);

OpenSim/Framework/AgentCircuitData.cs

@@ -345,6 +345,7 @@ namespace OpenSim.Framework
                 }
             }
         }
+
     }
 
 

OpenSim/Framework/AssetBase.cs

@@ -215,6 +215,12 @@ namespace OpenSim.Framework
             set { m_metadata.Temporary = value; }
         }
 
+        public string CreatorID
+        {
+            get { return m_metadata.CreatorID; }
+            set { m_metadata.CreatorID = value; }
+        }
+
         public AssetFlags Flags
         {
             get { return m_metadata.Flags; }

OpenSim/Framework/AssetLandmark.cs

@@ -35,6 +35,7 @@ namespace OpenSim.Framework
         public Vector3 Position;
         public ulong RegionHandle;
         public UUID RegionID;
+        public string Gatekeeper = string.Empty;
         public int Version;
 
         public AssetLandmark(AssetBase a)
@@ -51,6 +52,8 @@ namespace OpenSim.Framework
             string[] parts = temp.Split('\n');
             int.TryParse(parts[0].Substring(17, 1), out Version);
             UUID.TryParse(parts[1].Substring(10, 36), out RegionID);
+            if (parts.Length >= 5)
+                Gatekeeper = parts[4].Replace("gatekeeper ", "");
             // The position is a vector with spaces as separators ("10.3 32.5 43").
             // Parse each scalar separately to take into account the system's culture setting.
             string[] scalars = parts[2].Substring(10, parts[2].Length - 10).Split(' ');

OpenSim/Framework/IClientAPI.cs

@@ -83,7 +83,7 @@ namespace OpenSim.Framework
         IClientAPI remoteClient, ulong regionHandle, Vector3 position, Vector3 lookAt, uint flags);
 
     public delegate void TeleportLandmarkRequest(
-        IClientAPI remoteClient, UUID regionID, Vector3 position);
+        IClientAPI remoteClient, AssetLandmark lm);
 
     public delegate void DisconnectUser();
 
@@ -1159,7 +1159,19 @@ namespace OpenSim.Framework
         void SendAgentAlertMessage(string message, bool modal);
         void SendLoadURL(string objectname, UUID objectID, UUID ownerID, bool groupOwned, string message, string url);
 
-        void SendDialog(string objectname, UUID objectID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch,
+        /// <summary>
+        /// Open a dialog box on the client.
+        /// </summary>
+        /// <param name="objectname"></param>
+        /// <param name="objectID"></param>
+        /// <param name="ownerID">/param>
+        /// <param name="ownerFirstName"></param>
+        /// <param name="ownerLastName"></param>
+        /// <param name="msg"></param>
+        /// <param name="textureID"></param>
+        /// <param name="ch"></param>
+        /// <param name="buttonlabels"></param>
+        void SendDialog(string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch,
                         string[] buttonlabels);
 
         bool AddMoney(int debit);

OpenSim/Framework/ILandObject.cs

@@ -35,8 +35,8 @@ namespace OpenSim.Framework
 
     public interface ILandObject
     {
-        int GetParcelMaxPrimCount(ILandObject thisObject);
-        int GetSimulatorMaxPrimCount(ILandObject thisObject);
+        int GetParcelMaxPrimCount();
+        int GetSimulatorMaxPrimCount();
         int GetPrimsFree();
 
         LandData LandData { get; set; }

OpenSim/Framework/Tests/AnimationTests.cs

@@ -33,7 +33,6 @@ using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 using Animation = OpenSim.Framework.Animation;
 
 namespace OpenSim.Framework.Tests

OpenSim/Framework/Util.cs

@@ -1694,5 +1694,68 @@ namespace OpenSim.Framework
             return (T)Enum.Parse(typeof(T), value); ;
         }
         #endregion
+
+        #region Universal User Identifiers
+       /// <summary>
+        /// </summary>
+        /// <param name="value">uuid[;endpoint[;name]]</param>
+        /// <param name="uuid"></param>
+        /// <param name="url"></param>
+        /// <param name="firstname"></param>
+        /// <param name="lastname"></param>
+        public static bool ParseUniversalUserIdentifier(string value, out UUID uuid, out string url, out string firstname, out string lastname, out string secret)
+        {
+            uuid = UUID.Zero; url = string.Empty; firstname = "Unknown"; lastname = "User"; secret = string.Empty;
+
+            string[] parts = value.Split(';');
+            if (parts.Length >= 1)
+                if (!UUID.TryParse(parts[0], out uuid))
+                    return false;
+
+            if (parts.Length >= 2)
+                url = parts[1];
+
+            if (parts.Length >= 3)
+            {
+                string[] name = parts[2].Split();
+                if (name.Length == 2)
+                {
+                    firstname = name[0];
+                    lastname = name[1];
+                }
+            }
+            if (parts.Length >= 4)
+                secret = parts[3];
+
+            return true;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="acircuit"></param>
+        /// <returns>uuid[;endpoint[;name]]</returns>
+        public static string ProduceUserUniversalIdentifier(AgentCircuitData acircuit)
+        {
+            if (acircuit.ServiceURLs.ContainsKey("HomeURI"))
+            {
+                string agentsURI = acircuit.ServiceURLs["HomeURI"].ToString();
+                if (!agentsURI.EndsWith("/"))
+                    agentsURI += "/";
+
+                // This is ugly, but there's no other way, given that the name is changed
+                // in the agent circuit data for foreigners
+                if (acircuit.lastname.Contains("@"))
+                {
+                    string[] parts = acircuit.firstname.Split(new char[] { '.' });
+                    if (parts.Length == 2)
+                        return acircuit.AgentID.ToString() + ";" + agentsURI + ";" + parts[0] + " " + parts[1];
+                }
+                return acircuit.AgentID.ToString() + ";" + agentsURI + ";" + acircuit.firstname + " " + acircuit.lastname;
+            }
+            else
+                return acircuit.AgentID.ToString();
+        }        
+        #endregion
     }
 }

OpenSim/Framework/WebUtil.cs

@@ -251,11 +251,11 @@ namespace OpenSim.Framework
                 // This just dumps a warning for any operation that takes more than 100 ms
                 int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
                 if (tickdiff > LongCallTime)
-                    m_log.InfoFormat("[WEB UTIL]: osd request <{0}> (URI:{1}, METHOD:{2}) took {3}ms overall, {4}ms writing",
+                    m_log.DebugFormat("[WEB UTIL]: osd request <{0}> (URI:{1}, METHOD:{2}) took {3}ms overall, {4}ms writing",
                                      reqnum,url,method,tickdiff,tickdata);
             }
            
-	    m_log.WarnFormat("[WEB UTIL]: <{0}> osd request for {1}, method {2} FAILED: {3}", reqnum, url, method, errorMessage); 
+	        m_log.DebugFormat("[WEB UTIL]: <{0}> osd request for {1}, method {2} FAILED: {3}", reqnum, url, method, errorMessage); 
             return ErrorResponseMap(errorMessage);
         }
 
@@ -967,7 +967,7 @@ namespace OpenSim.Framework
                 }
                 catch (Exception e)
                 {
-                    m_log.WarnFormat("[SynchronousRestObjectRequester]: exception in sending data to {0}: {1}", requestUrl, e); 
+                    m_log.DebugFormat("[SynchronousRestObjectRequester]: exception in sending data to {0}: {1}", requestUrl, e); 
                     return deserial;
                 }
                 finally
@@ -979,8 +979,11 @@ namespace OpenSim.Framework
 
             try
             {
-                using (WebResponse resp = request.GetResponse())
+                using (HttpWebResponse resp = (HttpWebResponse)request.GetResponse())
                 {
+                    if (resp.StatusCode == HttpStatusCode.NotFound)
+                        return deserial;
+
                     if (resp.ContentLength != 0)
                     {
                         Stream respStream = resp.GetResponseStream();
@@ -989,18 +992,18 @@ namespace OpenSim.Framework
                         respStream.Close();
                     }
                     else
-                        m_log.WarnFormat("[SynchronousRestObjectRequester]: Oops! no content found in response stream from {0} {1}", requestUrl, verb);
+                        m_log.DebugFormat("[SynchronousRestObjectRequester]: Oops! no content found in response stream from {0} {1}", requestUrl, verb);
 
                 }
             }
             catch (System.InvalidOperationException)
             {
                 // This is what happens when there is invalid XML
-                m_log.WarnFormat("[SynchronousRestObjectRequester]: Invalid XML {0} {1}", requestUrl, typeof(TResponse).ToString());
+                m_log.DebugFormat("[SynchronousRestObjectRequester]: Invalid XML {0} {1}", requestUrl, typeof(TResponse).ToString());
             }
             catch (Exception e)
             {
-                m_log.WarnFormat("[SynchronousRestObjectRequester]: Exception on response from {0} {1}", requestUrl, e);
+                m_log.DebugFormat("[SynchronousRestObjectRequester]: Exception on response from {0} {1}", requestUrl, e);
             }
 
             return deserial;

OpenSim/Region/Application/Application.cs

@@ -231,6 +231,8 @@ namespace OpenSim
             configSource.Alias.AddAlias("Off", false);
             configSource.Alias.AddAlias("True", true);
             configSource.Alias.AddAlias("False", false);
+            configSource.Alias.AddAlias("Yes", true);
+            configSource.Alias.AddAlias("No", false);
 
             configSource.AddSwitch("Startup", "background");
             configSource.AddSwitch("Startup", "inifile");
@@ -239,6 +241,8 @@ namespace OpenSim
             configSource.AddSwitch("Startup", "physics");
             configSource.AddSwitch("Startup", "gui");
             configSource.AddSwitch("Startup", "console");
+            configSource.AddSwitch("Startup", "save_crashes");
+            configSource.AddSwitch("Startup", "crash_dir");
 
             configSource.AddConfig("StandAlone");
             configSource.AddConfig("Network");

OpenSim/Region/Application/OpenSim.cs

@@ -267,12 +267,13 @@ namespace OpenSim
 
             m_console.Commands.AddCommand("region", false, "save oar",
                                           //"save oar [-v|--version=<N>] [-p|--profile=<url>] [<OAR path>]",
-                                          "save oar [-p|--profile=<url>] [<OAR path>]",
+                                          "save oar [-p|--profile=<url>] [--noassets] [<OAR path>]",
                                           "Save a region's data to an OAR archive.",
 //                                          "-v|--version=<N> generates scene objects as per older versions of the serialization (e.g. -v=0)" + Environment.NewLine
-                                          "-p|--profile=<url> adds the url of the profile service to the saved user information" + Environment.NewLine
-                                          + "The OAR path must be a filesystem path."
-                                          + "  If this is not given then the oar is saved to region.oar in the current directory.",
+                                          "-p|--profile=<url> adds the url of the profile service to the saved user information." + Environment.NewLine
+                                          + "  The OAR path must be a filesystem path."
+                                          + "  If this is not given then the oar is saved to region.oar in the current directory." + Environment.NewLine
+                                          + "--noassets stops assets being saved to the OAR.",
                                           SaveOar);
 
             m_console.Commands.AddCommand("region", false, "edit scale",

OpenSim/Region/Application/OpenSimBase.cs

@@ -836,7 +836,7 @@ namespace OpenSim
 
             if (regInfo.EstateSettings.EstateID == 0) // No record at all
             {
-                MainConsole.Instance.OutputFormat("Region {0} is not part of an estate.", regInfo.RegionName);
+                m_log.WarnFormat("[ESTATE] Region {0} is not part of an estate.", regInfo.RegionName);
                 
                 List<EstateSettings> estates = EstateDataService.LoadEstateSettingsAll();                
                 List<string> estateNames = new List<string>();
@@ -847,7 +847,7 @@ namespace OpenSim
                 {
                     if (estates.Count == 0)
                     {                        
-                        MainConsole.Instance.Output("No existing estates found.  You must create a new one.");
+                        m_log.Info("[ESTATE] No existing estates found.  You must create a new one.");
                         
                         if (CreateEstate(regInfo, estateNames))
                             break;                        

OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs

@@ -428,6 +428,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #endregion Properties
 
+//        ~LLClientView()
+//        {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Destructor called for {0}, circuit code {1}", Name, CircuitCode);
+//        }
+
         /// <summary>
         /// Constructor
         /// </summary>
@@ -1469,6 +1474,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             money.MoneyData.TransactionSuccess = success;
             money.MoneyData.Description = description;
             money.MoneyData.MoneyBalance = balance;
+            money.TransactionInfo.ItemDescription = Util.StringToBytes256("NONE");
             OutPacket(money, ThrottleOutPacketType.Task);
         }
 
@@ -2213,7 +2219,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(loadURL, ThrottleOutPacketType.Task);
         }
 
-        public void SendDialog(string objectname, UUID objectID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
+        public void SendDialog(
+            string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg,
+            UUID textureID, int ch, string[] buttonlabels)
         {
             ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);
             dialog.Data.ObjectID = objectID;
@@ -2231,6 +2239,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 buttons[i].ButtonLabel = Util.StringToBytes256(buttonlabels[i]);
             }
             dialog.Buttons = buttons;
+
+            dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];
+            dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();
+            dialog.OwnerData[0].OwnerID = ownerID;
+
             OutPacket(dialog, ThrottleOutPacketType.Task);
         }
 
@@ -2293,8 +2306,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 OrbitalPosition = (OrbitalPosition - m_sunPainDaHalfOrbitalCutoff) * 0.6666666667f + m_sunPainDaHalfOrbitalCutoff;
             }
 
-
-
             SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);
             viewertime.TimeInfo.SunDirection = Position;
             viewertime.TimeInfo.SunAngVelocity = Velocity;
@@ -8295,16 +8306,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
+
+                    // Let's try to search in the user's home asset server
+                    lma = FindAssetInUserAssetServer(lmid.ToString());
+
+                    if (lma == null)
+                    {
+                        // Really doesn't exist
+                        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
@@ -8335,13 +8355,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest;
             if (handlerTeleportLandmarkRequest != null)
             {
-                handlerTeleportLandmarkRequest(this, lm.RegionID, lm.Position);
+                handlerTeleportLandmarkRequest(this, lm);
             }
             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;
@@ -8351,6 +8369,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        private AssetBase FindAssetInUserAssetServer(string id)
+        {
+            AgentCircuitData aCircuit = ((Scene)Scene).AuthenticateHandler.GetAgentCircuitData(CircuitCode);
+            if (aCircuit != null && aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
+            {
+                string assetServer = aCircuit.ServiceURLs["AssetServerURI"].ToString();
+                return ((Scene)Scene).AssetService.Get(assetServer + "/" + id);
+            }
+
+            return null;
+        }
+
         private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack)
         {
             TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;

OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs

@@ -124,7 +124,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
 
             ScenePresence sp = m_scene.GetScenePresence(avatarID);
             if (sp != null)
-                sp.ControllingClient.SendDialog(objectName, objectID, ownerFirstName, ownerLastName, message, textureID, ch, buttonlabels);
+                sp.ControllingClient.SendDialog(
+                    objectName, objectID, ownerID, ownerFirstName, ownerLastName, message, textureID, ch, buttonlabels);
         }
 
         public void SendUrlToUser(

OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs

@@ -49,6 +49,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 {
     public class FriendsModule : ISharedRegionModule, IFriendsModule
     {
+        protected bool m_Enabled = false;
+
         protected class UserFriendData
         {
             public UUID PrincipalID;
@@ -67,7 +69,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             }
         }
 
-        private static readonly FriendInfo[] EMPTY_FRIENDS = new FriendInfo[0];
+        protected static readonly FriendInfo[] EMPTY_FRIENDS = new FriendInfo[0];
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         protected List<Scene> m_Scenes = new List<Scene>();
@@ -130,7 +132,24 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             }
         }
 
+        #region ISharedRegionModule
         public void Initialise(IConfigSource config)
+        {
+            IConfig moduleConfig = config.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("FriendsModule", "FriendsModule");
+                if (name == Name)
+                {
+                    InitModule(config);
+
+                    m_Enabled = true;
+                    m_log.InfoFormat("[FRIENDS MODULE]: {0} enabled.", Name);
+                }
+            }            
+        }
+
+        protected void InitModule(IConfigSource config)
         {
             IConfig friendsConfig = config.Configs["Friends"];
             if (friendsConfig != null)
@@ -153,7 +172,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 m_log.Error("[FRIENDS]: No Connector defined in section Friends, or failed to load, cannot continue");
                 throw new Exception("Connector load error");
             }
-
         }
 
         public void PostInitialise()
@@ -164,8 +182,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
         {
         }
 
-        public void AddRegion(Scene scene)
+        public virtual void AddRegion(Scene scene)
         {
+            if (!m_Enabled)
+                return;
+            m_log.DebugFormat("[FRIENDS MODULE]: AddRegion on {0}", Name);
+
             m_Scenes.Add(scene);
             scene.RegisterModuleInterface<IFriendsModule>(this);
 
@@ -181,10 +203,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         public void RemoveRegion(Scene scene)
         {
+            if (!m_Enabled)
+                return;
+
             m_Scenes.Remove(scene);
         }
 
-        public string Name
+        public virtual string Name
         {
             get { return "FriendsModule"; }
         }
@@ -194,13 +219,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             get { return null; }
         }
 
-        public uint GetFriendPerms(UUID principalID, UUID friendID)
+        #endregion
+
+        public virtual uint GetFriendPerms(UUID principalID, UUID friendID)
         {
             FriendInfo[] friends = GetFriends(principalID);
-            foreach (FriendInfo fi in friends)
+            FriendInfo finfo = GetFriend(friends, friendID);
+            if (finfo != null)
             {
-                if (fi.Friend == friendID.ToString())
-                    return (uint)fi.TheirFlags;
+                return (uint)finfo.TheirFlags;
             }
 
             return 0;
@@ -214,30 +241,34 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             client.OnTerminateFriendship += OnTerminateFriendship;
             client.OnGrantUserRights += OnGrantUserRights;
 
-            // Asynchronously fetch the friends list or increment the refcount for the existing 
-            // friends list
-            Util.FireAndForget(
-                delegate(object o)
-                {
-                    lock (m_Friends)
-                    {
-                        UserFriendData friendsData;
-                        if (m_Friends.TryGetValue(client.AgentId, out friendsData))
-                        {
-                            friendsData.Refcount++;
-                        }
-                        else
-                        {
-                            friendsData = new UserFriendData();
-                            friendsData.PrincipalID = client.AgentId;
-                            friendsData.Friends = FriendsService.GetFriends(client.AgentId);
-                            friendsData.Refcount = 1;
+            Util.FireAndForget(delegate { FetchFriendslist(client); });
+        }
 
-                            m_Friends[client.AgentId] = friendsData;
-                        }
-                    }
+        /// Fetch the friends list or increment the refcount for the existing 
+        /// friends list
+        /// Returns true if the list was fetched, false if it wasn't
+        protected virtual bool FetchFriendslist(IClientAPI client)
+        {
+            UUID agentID = client.AgentId;
+            lock (m_Friends)
+            {
+                UserFriendData friendsData;
+                if (m_Friends.TryGetValue(agentID, out friendsData))
+                {
+                    friendsData.Refcount++;
+                    return false;
                 }
-            );
+                else
+                {
+                    friendsData = new UserFriendData();
+                    friendsData.PrincipalID = agentID;
+                    friendsData.Friends = GetFriendsFromService(client);
+                    friendsData.Refcount = 1;
+
+                    m_Friends[agentID] = friendsData;
+                    return true;
+                }
+            }
         }
 
         private void OnClientClosed(UUID agentID, Scene scene)
@@ -263,14 +294,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         private void OnMakeRootAgent(ScenePresence sp)
         {
-            UUID agentID = sp.ControllingClient.AgentId;
-            UpdateFriendsCache(agentID);
+            RefetchFriends(sp.ControllingClient);
         }
 
         private void OnClientLogin(IClientAPI client)
         {
             UUID agentID = client.AgentId;
 
+            //m_log.DebugFormat("[XXX]: OnClientLogin!");
             // Inform the friends that this user is online
             StatusChange(agentID, true);
             
@@ -279,7 +310,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 m_NeedsListOfFriends.Add(agentID);
         }
 
-        public void SendFriendsOnlineIfNeeded(IClientAPI client)
+        public virtual bool SendFriendsOnlineIfNeeded(IClientAPI client)
         {
             UUID agentID = client.AgentId;
 
@@ -287,7 +318,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             lock (m_NeedsListOfFriends)
             {
                 if (!m_NeedsListOfFriends.Remove(agentID))
-                    return;
+                    return false;
             }
 
             // Send the friends online
@@ -313,10 +344,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             foreach (string fid in outstanding)
             {
                 UUID fromAgentID;
-                if (!UUID.TryParse(fid, out fromAgentID))
+                string firstname = "Unknown", lastname = "User";
+                if (!GetAgentInfo(client.Scene.RegionInfo.ScopeID, fid, out fromAgentID, out firstname, out lastname))
+                {
+                    m_log.DebugFormat("[FRIENDS MODULE]: skipping malformed friend {0}", fid);
                     continue;
-
-                UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(client.Scene.RegionInfo.ScopeID, fromAgentID);
+                }
 
                 PresenceInfo presence = null;
                 PresenceInfo[] presences = PresenceService.GetAgents(new string[] { fid });
@@ -326,13 +359,37 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                     im.offline = 0;
 
                 im.fromAgentID = fromAgentID.Guid;
-                im.fromAgentName = account.FirstName + " " + account.LastName;
+                im.fromAgentName = firstname + " " + lastname;
                 im.offline = (byte)((presence == null) ? 1 : 0);
                 im.imSessionID = im.fromAgentID;
+                im.message = FriendshipMessage(fid);
 
                 // Finally
                 LocalFriendshipOffered(agentID, im);
             }
+
+            return true;
+        }
+
+        protected virtual string FriendshipMessage(string friendID)
+        {
+            return "Will you be my friend?";
+        }
+
+        protected virtual bool GetAgentInfo(UUID scopeID, string fid, out UUID agentID, out string first, out string last)
+        {
+            first = "Unknown"; last = "User";
+            if (!UUID.TryParse(fid, out agentID))
+                return false;
+
+            UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(scopeID, agentID);
+            if (account != null)
+            {
+                first = account.FirstName;
+                last = account.LastName;
+            }
+
+            return true;
         }
 
         List<UUID> GetOnlineFriends(UUID userID)
@@ -348,19 +405,22 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             }
 
             if (friendList.Count > 0)
-            {
-                PresenceInfo[] presence = PresenceService.GetAgents(friendList.ToArray());
-                foreach (PresenceInfo pi in presence)
-                {
-                    UUID presenceID;
-                    if (UUID.TryParse(pi.UserID, out presenceID))
-                        online.Add(presenceID);
-                }
-            }
+                GetOnlineFriends(userID, friendList, online);
 
             return online;
         }
 
+        protected virtual void GetOnlineFriends(UUID userID, List<string> friendList, /*collector*/ List<UUID> online)
+        {
+            PresenceInfo[] presence = PresenceService.GetAgents(friendList.ToArray());
+            foreach (PresenceInfo pi in presence)
+            {
+                UUID presenceID;
+                if (UUID.TryParse(pi.UserID, out presenceID))
+                    online.Add(presenceID);
+            }
+        }
+
         /// <summary>
         /// Find the client for a ID
         /// </summary>
@@ -415,51 +475,51 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 Util.FireAndForget(
                     delegate
                     {
-                        foreach (FriendInfo fi in friendList)
-                        {
-                            //m_log.DebugFormat("[FRIENDS]: Notifying {0}", fi.PrincipalID);
-                            // Notify about this user status
-                            StatusNotify(fi, agentID, online);
-                        }
+                        m_log.DebugFormat("[FRIENDS MODULE]: Notifying {0} friends", friendList.Count);
+                        // Notify about this user status
+                        StatusNotify(friendList, agentID, online);
                     }
                 );
             }
         }
 
-        private void StatusNotify(FriendInfo friend, UUID userID, bool online)
+        protected virtual void StatusNotify(List<FriendInfo> friendList, UUID userID, bool online)
         {
-            UUID friendID;
-            if (UUID.TryParse(friend.Friend, out friendID))
+            foreach (FriendInfo friend in friendList)
             {
-                // Try local
-                if (LocalStatusNotification(userID, friendID, online))
-                    return;
-
-                // The friend is not here [as root]. Let's forward.
-                PresenceInfo[] friendSessions = PresenceService.GetAgents(new string[] { friendID.ToString() });
-                if (friendSessions != null && friendSessions.Length > 0)
+                UUID friendID;
+                if (UUID.TryParse(friend.Friend, out friendID))
                 {
-                    PresenceInfo friendSession = null; 
-                    foreach (PresenceInfo pinfo in friendSessions)
-                        if (pinfo.RegionID != UUID.Zero) // let's guard against sessions-gone-bad
-                        {
-                            friendSession = pinfo;
-                            break;
-                        }
+                    // Try local
+                    if (LocalStatusNotification(userID, friendID, online))
+                        return;
 
-                    if (friendSession != null)
+                    // The friend is not here [as root]. Let's forward.
+                    PresenceInfo[] friendSessions = PresenceService.GetAgents(new string[] { friendID.ToString() });
+                    if (friendSessions != null && friendSessions.Length > 0)
                     {
-                        GridRegion region = GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID, friendSession.RegionID);
-                        //m_log.DebugFormat("[FRIENDS]: Remote Notify to region {0}", region.RegionName);
-                        m_FriendsSimConnector.StatusNotify(region, userID, friendID, online);
-                    }
-                }
+                        PresenceInfo friendSession = null;
+                        foreach (PresenceInfo pinfo in friendSessions)
+                            if (pinfo.RegionID != UUID.Zero) // let's guard against sessions-gone-bad
+                            {
+                                friendSession = pinfo;
+                                break;
+                            }
 
-                // Friend is not online. Ignore.
-            }
-            else
-            {
-                m_log.WarnFormat("[FRIENDS]: Error parsing friend ID {0}", friend.Friend);
+                        if (friendSession != null)
+                        {
+                            GridRegion region = GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID, friendSession.RegionID);
+                            //m_log.DebugFormat("[FRIENDS]: Remote Notify to region {0}", region.RegionName);
+                            m_FriendsSimConnector.StatusNotify(region, userID, friendID, online);
+                        }
+                    }
+
+                    // Friend is not online. Ignore.
+                }
+                else
+                {
+                    m_log.WarnFormat("[FRIENDS]: Error parsing friend ID {0}", friend.Friend);
+                }
             }
         }
 
@@ -475,7 +535,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
                 // This user wants to be friends with the other user.
                 // Let's add the relation backwards, in case the other is not online
-                FriendsService.StoreFriend(friendID, principalID.ToString(), 0);
+                StoreBackwards(friendID, principalID);
 
                 // Now let's ask the other user to be friends with this user
                 ForwardFriendshipOffer(principalID, friendID, im);
@@ -487,11 +547,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             // !!!!!!!! This is a hack so that we don't have to keep state (transactionID/imSessionID)
             // We stick this agent's ID as imSession, so that it's directly available on the receiving end
             im.imSessionID = im.fromAgentID;
+            im.fromAgentName = GetFriendshipRequesterName(agentID);
 
-            // Try the local sim
-            UserAccount account = UserAccountService.GetUserAccount(UUID.Zero, agentID);
-            im.fromAgentName = (account == null) ? "Unknown" : account.FirstName + " " + account.LastName;
-            
+            // Try the local sim            
             if (LocalFriendshipOffered(friendID, im))
                 return;
 
@@ -509,15 +567,20 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             // If the prospective friend is not online, he'll get the message upon login.
         }
 
+        protected virtual string GetFriendshipRequesterName(UUID agentID)
+        {
+            UserAccount account = UserAccountService.GetUserAccount(UUID.Zero, agentID);
+            return (account == null) ? "Unknown" : account.FirstName + " " + account.LastName;
+        }
+
         private void OnApproveFriendRequest(IClientAPI client, UUID agentID, UUID friendID, List<UUID> callingCardFolders)
         {
             m_log.DebugFormat("[FRIENDS]: {0} accepted friendship from {1}", agentID, friendID);
-            
-            FriendsService.StoreFriend(agentID, friendID.ToString(), 1);
-            FriendsService.StoreFriend(friendID, agentID.ToString(), 1);
+
+            StoreFriendships(agentID, friendID);
 
             // Update the local cache
-            UpdateFriendsCache(agentID);
+            RefetchFriends(client);
 
             //
             // Notify the friend
@@ -548,8 +611,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
         {
             m_log.DebugFormat("[FRIENDS]: {0} denied friendship to {1}", agentID, friendID);
 
-            FriendsService.Delete(agentID, friendID.ToString());
-            FriendsService.Delete(friendID, agentID.ToString());
+            DeleteFriendship(agentID, friendID);
 
             //
             // Notify the friend
@@ -576,11 +638,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         private void OnTerminateFriendship(IClientAPI client, UUID agentID, UUID exfriendID)
         {
-            FriendsService.Delete(agentID, exfriendID.ToString());
-            FriendsService.Delete(exfriendID, agentID.ToString());
+            if (!DeleteFriendship(agentID, exfriendID))
+                client.SendAlertMessage("Unable to terminate friendship on this sim.");
 
             // Update local cache
-            UpdateFriendsCache(agentID);
+            RefetchFriends(client);
 
             client.SendTerminateFriend(exfriendID);
 
@@ -606,23 +668,25 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         private void OnGrantUserRights(IClientAPI remoteClient, UUID requester, UUID target, int rights)
         {
+            m_log.DebugFormat("[FRIENDS MODULE]: User {0} changing rights to {1} for friend {2}", requester, rights, target);
+
             FriendInfo[] friends = GetFriends(remoteClient.AgentId);
             if (friends.Length == 0)
-                return;
-
-            m_log.DebugFormat("[FRIENDS MODULE]: User {0} changing rights to {1} for friend {2}", requester, rights, target);
-            // Let's find the friend in this user's friend list
-            FriendInfo friend = null;
-            foreach (FriendInfo fi in friends)
             {
-                if (fi.Friend == target.ToString())
-                    friend = fi;
+                return;
             }
 
+            // Let's find the friend in this user's friend list
+            FriendInfo friend = GetFriend(friends, target);
+
             if (friend != null) // Found it
             {
                 // Store it on the DB
-                FriendsService.StoreFriend(requester, target.ToString(), rights);
+                if (!StoreRights(requester, target, rights))
+                {
+                    remoteClient.SendAlertMessage("Unable to grant rights.");
+                    return;
+                }
 
                 // Store it in the local cache
                 int myFlags = friend.MyFlags;
@@ -652,6 +716,18 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                     }
                 }
             }
+            else
+                m_log.DebugFormat("[FRIENDS MODULE]: friend {0} not found for {1}", target, requester);
+        }
+
+        protected virtual FriendInfo GetFriend(FriendInfo[] friends, UUID friendID)
+        {
+            foreach (FriendInfo fi in friends)
+            {
+                if (fi.Friend == friendID.ToString())
+                    return fi;
+            }
+            return null;
         }
 
         #region Local
@@ -680,7 +756,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 friendClient.SendInstantMessage(im);
 
                 // Update the local cache
-                UpdateFriendsCache(friendID);
+                RefetchFriends(friendClient);
 
                 // we're done
                 return true;
@@ -713,7 +789,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 // the friend in this sim as root agent
                 friendClient.SendTerminateFriend(exfriendID);
                 // update local cache
-                UpdateFriendsCache(exfriendID);
+                RefetchFriends(friendClient);
                 // we're done
                 return true;
             }
@@ -743,15 +819,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                 }
 
                 // Update local cache
-                lock (m_Friends)
-                {
-                    FriendInfo[] friends = GetFriends(friendID);
-                    foreach (FriendInfo finfo in friends)
-                    {
-                        if (finfo.Friend == userID.ToString())
-                            finfo.TheirFlags = rights;
-                    }
-                }
+                UpdateLocalCache(userID, friendID, rights);
 
                 return true;
             }
@@ -762,10 +830,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         public bool LocalStatusNotification(UUID userID, UUID friendID, bool online)
         {
+            m_log.DebugFormat("[FRIENDS]: Local Status Notify {0} that user {1} is {2}", friendID, userID, online);
             IClientAPI friendClient = LocateClientObject(friendID);
             if (friendClient != null)
             {
-                //m_log.DebugFormat("[FRIENDS]: Local Status Notify {0} that user {1} is {2}", friendID, userID, online);
                 // the  friend in this sim as root agent
                 if (online)
                     friendClient.SendAgentOnline(new UUID[] { userID });
@@ -780,7 +848,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         #endregion
 
-        private FriendInfo[] GetFriends(UUID agentID)
+        #region Get / Set friends in several flavours
+        /// <summary>
+        /// Get friends from local cache only
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <returns></returns>
+        protected FriendInfo[] GetFriends(UUID agentID)
         {
             UserFriendData friendsData;
 
@@ -793,14 +867,63 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             return EMPTY_FRIENDS;
         }
 
-        private void UpdateFriendsCache(UUID agentID)
+        /// <summary>
+        /// Update loca cache only
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <param name="friendID"></param>
+        /// <param name="rights"></param>
+        protected void UpdateLocalCache(UUID userID, UUID friendID, int rights)
         {
+            // Update local cache
+            lock (m_Friends)
+            {
+                FriendInfo[] friends = GetFriends(friendID);
+                FriendInfo finfo = GetFriend(friends, userID);
+                finfo.TheirFlags = rights;
+            }
+        }
+
+        protected virtual FriendInfo[] GetFriendsFromService(IClientAPI client)
+        {
+            return FriendsService.GetFriends(client.AgentId);
+        }
+
+        private void RefetchFriends(IClientAPI client)
+        {
+            UUID agentID = client.AgentId;
             lock (m_Friends)
             {
                 UserFriendData friendsData;
                 if (m_Friends.TryGetValue(agentID, out friendsData))
-                    friendsData.Friends = FriendsService.GetFriends(agentID);
+                    friendsData.Friends = GetFriendsFromService(client);
             }
         }
+
+        protected virtual bool StoreRights(UUID agentID, UUID friendID, int rights)
+        {
+            FriendsService.StoreFriend(agentID.ToString(), friendID.ToString(), rights);
+            return true;
+        }
+
+        protected virtual void StoreBackwards(UUID friendID, UUID agentID)
+        {
+            FriendsService.StoreFriend(friendID.ToString(), agentID.ToString(), 0);
+        }
+
+        protected virtual void StoreFriendships(UUID agentID, UUID friendID)
+        {
+            FriendsService.StoreFriend(agentID.ToString(), friendID.ToString(), 1);
+            FriendsService.StoreFriend(friendID.ToString(), agentID.ToString(), 1);
+        }
+
+        protected virtual bool DeleteFriendship(UUID agentID, UUID exfriendID)
+        {
+            FriendsService.Delete(agentID, exfriendID.ToString());
+            FriendsService.Delete(exfriendID, agentID.ToString());
+            return true;
+        }
+
+        #endregion
     }
 }

OpenSim/Region/CoreModules/Avatar/Friends/HGFriendsModule.cs

@@ -0,0 +1,628 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Hypergrid;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Region.CoreModules.Avatar.Friends
+{
+    public class HGFriendsModule : FriendsModule, ISharedRegionModule, IFriendsModule, IFriendsSimConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        #region ISharedRegionModule
+        public override string Name
+        {
+            get { return "HGFriendsModule"; }
+        }
+
+        public override void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            base.AddRegion(scene);
+            scene.RegisterModuleInterface<IFriendsSimConnector>(this);
+        }
+
+        #endregion
+
+        #region IFriendsSimConnector
+
+        /// <summary>
+        /// Notify the user that the friend's status changed
+        /// </summary>
+        /// <param name="userID">user to be notified</param>
+        /// <param name="friendID">friend whose status changed</param>
+        /// <param name="online">status</param>
+        /// <returns></returns>
+        public bool StatusNotify(UUID friendID, UUID userID, bool online)
+        {
+            return LocalStatusNotification(friendID, userID, online);
+        }
+
+        #endregion
+
+        protected override bool FetchFriendslist(IClientAPI client)
+        {
+            if (base.FetchFriendslist(client))
+            {
+                UUID agentID = client.AgentId;
+                // we do this only for the root agent
+                if (m_Friends[agentID].Refcount == 1)
+                {
+                    // We need to preload the user management cache with the names
+                    // of foreign friends, just like we do with SOPs' creators
+                    foreach (FriendInfo finfo in m_Friends[agentID].Friends)
+                    {
+                        if (finfo.TheirFlags != -1)
+                        {
+                            UUID id;
+                            if (!UUID.TryParse(finfo.Friend, out id))
+                            {
+                                string url = string.Empty, first = string.Empty, last = string.Empty, tmp = string.Empty;
+                                if (Util.ParseUniversalUserIdentifier(finfo.Friend, out id, out url, out first, out last, out tmp))
+                                {
+                                    IUserManagement uMan = m_Scenes[0].RequestModuleInterface<IUserManagement>();
+                                    uMan.AddUser(id, url + ";" + first + " " + last);
+                                }
+                            }
+                        }
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public override bool SendFriendsOnlineIfNeeded(IClientAPI client)
+        {
+            if (base.SendFriendsOnlineIfNeeded(client))
+            {
+                AgentCircuitData aCircuit = ((Scene)client.Scene).AuthenticateHandler.GetAgentCircuitData(client.AgentId);
+                if (aCircuit != null && (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0)
+                {
+                    UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(client.Scene.RegionInfo.ScopeID, client.AgentId);
+                    if (account == null) // foreign
+                    {
+                        FriendInfo[] friends = GetFriends(client.AgentId);
+                        foreach (FriendInfo f in friends)
+                        {
+                            client.SendChangeUserRights(new UUID(f.Friend), client.AgentId, f.TheirFlags);
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        protected override void GetOnlineFriends(UUID userID, List<string> friendList, /*collector*/ List<UUID> online)
+        {
+            List<string> fList = new List<string>();
+            foreach (string s in friendList)
+                fList.Add(s.Substring(0, 36));
+
+            PresenceInfo[] presence = PresenceService.GetAgents(fList.ToArray());
+            foreach (PresenceInfo pi in presence)
+            {
+                UUID presenceID;
+                if (UUID.TryParse(pi.UserID, out presenceID))
+                    online.Add(presenceID);
+            }
+        }
+
+        //protected override void GetOnlineFriends(UUID userID, List<string> friendList, /*collector*/ List<UUID> online)
+        //{
+        //    // Let's single out the UUIs
+        //    List<string> localFriends = new List<string>();
+        //    List<string> foreignFriends = new List<string>();
+        //    string tmp = string.Empty;
+
+        //    foreach (string s in friendList)
+        //    {
+        //        UUID id;
+        //        if (UUID.TryParse(s, out id))
+        //            localFriends.Add(s);
+        //        else if (Util.ParseUniversalUserIdentifier(s, out id, out tmp, out tmp, out tmp, out tmp))
+        //        {
+        //            foreignFriends.Add(s);
+        //            // add it here too, who knows maybe the foreign friends happens to be on this grid
+        //            localFriends.Add(id.ToString());
+        //        }
+        //    }
+
+        //    // OK, see who's present on this grid
+        //    List<string> toBeRemoved = new List<string>();
+        //    PresenceInfo[] presence = PresenceService.GetAgents(localFriends.ToArray());
+        //    foreach (PresenceInfo pi in presence)
+        //    {
+        //        UUID presenceID;
+        //        if (UUID.TryParse(pi.UserID, out presenceID))
+        //        {
+        //            online.Add(presenceID);
+        //            foreach (string s in foreignFriends)
+        //                if (s.StartsWith(pi.UserID))
+        //                    toBeRemoved.Add(s);
+        //        }
+        //    }
+
+        //    foreach (string s in toBeRemoved)
+        //        foreignFriends.Remove(s);
+
+        //    // OK, let's send this up the stack, and leave a closure here
+        //    // collecting online friends in other grids
+        //    Util.FireAndForget(delegate { CollectOnlineFriendsElsewhere(userID, foreignFriends); });
+
+        //}
+
+        private void CollectOnlineFriendsElsewhere(UUID userID, List<string> foreignFriends)
+        {
+            // let's divide the friends on a per-domain basis
+            Dictionary<string, List<string>> friendsPerDomain = new Dictionary<string, List<string>>();
+            foreach (string friend in foreignFriends)
+            {
+                UUID friendID;
+                if (!UUID.TryParse(friend, out friendID))
+                {
+                    // it's a foreign friend
+                    string url = string.Empty, tmp = string.Empty;
+                    if (Util.ParseUniversalUserIdentifier(friend, out friendID, out url, out tmp, out tmp, out tmp))
+                    {
+                        if (!friendsPerDomain.ContainsKey(url))
+                            friendsPerDomain[url] = new List<string>();
+                        friendsPerDomain[url].Add(friend);
+                    }
+                }
+            }
+
+            // Now, call those worlds
+            
+            foreach (KeyValuePair<string, List<string>> kvp in friendsPerDomain)
+            {
+                List<string> ids = new List<string>();
+                foreach (string f in kvp.Value)
+                    ids.Add(f);
+                UserAgentServiceConnector uConn = new UserAgentServiceConnector(kvp.Key);
+                List<UUID> online = uConn.GetOnlineFriends(userID, ids);
+                // Finally send the notifications to the user
+                // this whole process may take a while, so let's check at every
+                // iteration that the user is still here
+                IClientAPI client = LocateClientObject(userID);
+                if (client != null)
+                    client.SendAgentOnline(online.ToArray());
+                else
+                    break;
+            }
+
+        }
+
+        protected override void StatusNotify(List<FriendInfo> friendList, UUID userID, bool online)
+        {
+            // First, let's divide the friends on a per-domain basis
+            Dictionary<string, List<FriendInfo>> friendsPerDomain = new Dictionary<string, List<FriendInfo>>();
+            foreach (FriendInfo friend in friendList)
+            {
+                UUID friendID;
+                if (UUID.TryParse(friend.Friend, out friendID))
+                {
+                    if (!friendsPerDomain.ContainsKey("local"))
+                        friendsPerDomain["local"] = new List<FriendInfo>();
+                    friendsPerDomain["local"].Add(friend);
+                }
+                else
+                {
+                    // it's a foreign friend
+                    string url = string.Empty, tmp = string.Empty;
+                    if (Util.ParseUniversalUserIdentifier(friend.Friend, out friendID, out url, out tmp, out tmp, out tmp))
+                    {
+                        // Let's try our luck in the local sim. Who knows, maybe it's here
+                        if (LocalStatusNotification(userID, friendID, online))
+                            continue;
+
+                        if (!friendsPerDomain.ContainsKey(url))
+                            friendsPerDomain[url] = new List<FriendInfo>();
+                        friendsPerDomain[url].Add(friend);
+                    }
+                }
+            }
+
+            // For the local friends, just call the base method
+            // Let's do this first of all
+            if (friendsPerDomain.ContainsKey("local"))
+                base.StatusNotify(friendsPerDomain["local"], userID, online);
+
+            foreach (KeyValuePair<string, List<FriendInfo>> kvp in friendsPerDomain)
+            {
+                if (kvp.Key != "local")
+                {
+                    // For the others, call the user agent service 
+                    List<string> ids = new List<string>();
+                    foreach (FriendInfo f in kvp.Value)
+                        ids.Add(f.Friend);
+                    UserAgentServiceConnector uConn = new UserAgentServiceConnector(kvp.Key);
+                    List<UUID> friendsOnline = uConn.StatusNotification(ids, userID, online);
+                    // need to debug this here
+                    if (online)
+                    {
+                        IClientAPI client = LocateClientObject(userID);
+                        if (client != null)
+                            client.SendAgentOnline(friendsOnline.ToArray());
+                    }
+                }
+            }
+        }
+
+        protected override bool GetAgentInfo(UUID scopeID, string fid, out UUID agentID, out string first, out string last)
+        {
+            first = "Unknown"; last = "User";
+            if (base.GetAgentInfo(scopeID, fid, out agentID, out first, out last))
+                return true;
+
+            // fid is not a UUID...
+            string url = string.Empty, tmp = string.Empty;
+            if (Util.ParseUniversalUserIdentifier(fid, out agentID, out url, out first, out last, out tmp))
+            {
+                IUserManagement userMan = m_Scenes[0].RequestModuleInterface<IUserManagement>();
+                userMan.AddUser(agentID, url + ";" + first + " " + last);
+
+                try // our best
+                {
+                    string[] parts = userMan.GetUserName(agentID).Split();
+                    first = parts[0];
+                    last = parts[1];
+                }
+                catch { }
+                return true;
+            }
+            return false;
+        }
+
+        protected override string GetFriendshipRequesterName(UUID agentID)
+        {
+            // For the time being we assume that HG friendship requests can only happen 
+            // when avies are on the same region.
+            IClientAPI client = LocateClientObject(agentID);
+            if (client != null)
+                return client.FirstName + " " + client.LastName;
+            else
+                return base.GetFriendshipRequesterName(agentID);
+        }
+
+        protected override string FriendshipMessage(string friendID)
+        {
+            UUID id;
+            if (UUID.TryParse(friendID, out id))
+                return base.FriendshipMessage(friendID);
+
+            return "Please confirm this friendship you made while you were away.";
+        }
+
+        protected override FriendInfo GetFriend(FriendInfo[] friends, UUID friendID)
+        {
+            foreach (FriendInfo fi in friends)
+            {
+                if (fi.Friend.StartsWith(friendID.ToString()))
+                    return fi;
+            }
+            return null;
+        }
+
+
+        protected override FriendInfo[] GetFriendsFromService(IClientAPI client)
+        {
+            UserAccount account1 = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, client.AgentId);
+            if (account1 != null)
+                return base.GetFriendsFromService(client);
+
+            FriendInfo[] finfos = new FriendInfo[0];
+            // Foreigner
+            AgentCircuitData agentClientCircuit = ((Scene)(client.Scene)).AuthenticateHandler.GetAgentCircuitData(client.CircuitCode);
+            if (agentClientCircuit != null)
+            {
+                string agentUUI = Util.ProduceUserUniversalIdentifier(agentClientCircuit);
+
+                finfos = FriendsService.GetFriends(agentUUI);
+                m_log.DebugFormat("[HGFRIENDS MODULE]: Fetched {0} local friends for visitor {1}", finfos.Length, agentUUI);
+            }
+            return finfos;
+        }
+
+        protected override bool StoreRights(UUID agentID, UUID friendID, int rights)
+        {
+            UserAccount account1 = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, agentID);
+            UserAccount account2 = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, friendID);
+            // Are they both local users?
+            if (account1 != null && account2 != null)
+            {
+                // local grid users
+                return base.StoreRights(agentID, friendID, rights);
+            }
+
+            if (account1 != null) // agent is local, friend is foreigner
+            {
+                FriendInfo[] finfos = GetFriends(agentID);
+                FriendInfo finfo = GetFriend(finfos, friendID);
+                if (finfo != null)
+                {
+                    FriendsService.StoreFriend(agentID.ToString(), finfo.Friend, rights);
+                    return true;
+                }
+            }
+
+            if (account2 != null) // agent is foreigner, friend is local
+            {
+                string agentUUI = GetUUI(friendID, agentID);
+                if (agentUUI != string.Empty)
+                {
+                    FriendsService.StoreFriend(agentUUI, friendID.ToString(), rights);
+                    return true;
+                }
+            }
+
+            return false;
+
+        }
+
+        protected override void StoreBackwards(UUID friendID, UUID agentID)
+        {
+            UserAccount account1 = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, agentID);
+            UserAccount account2 = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, friendID);
+            // Are they both local users?
+            if (account1 != null && account2 != null)
+            {
+                // local grid users
+                m_log.DebugFormat("[HGFRIENDS MODULE]: Users are both local");
+                base.StoreBackwards(friendID, agentID);
+                return;
+            }
+
+            // no provision for this temporary friendship state
+            //FriendsService.StoreFriend(friendID.ToString(), agentID.ToString(), 0);
+        }
+
+        protected override void StoreFriendships(UUID agentID, UUID friendID)
+        {
+            UserAccount agentAccount = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, agentID);
+            UserAccount friendAccount = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, friendID);
+            // Are they both local users?
+            if (agentAccount != null && friendAccount != null)
+            {
+                // local grid users
+                m_log.DebugFormat("[HGFRIENDS MODULE]: Users are both local");
+                base.StoreFriendships(agentID, friendID);
+                return;
+            }
+
+            // ok, at least one of them is foreigner, let's get their data
+            IClientAPI agentClient = LocateClientObject(agentID);
+            IClientAPI friendClient = LocateClientObject(friendID);
+            AgentCircuitData agentClientCircuit = null;
+            AgentCircuitData friendClientCircuit = null;
+            string agentUUI = string.Empty;
+            string friendUUI = string.Empty;
+            string agentFriendService = string.Empty;
+            string friendFriendService = string.Empty;
+
+            if (agentClient != null)
+            {
+                agentClientCircuit = ((Scene)(agentClient.Scene)).AuthenticateHandler.GetAgentCircuitData(agentClient.CircuitCode);
+                agentUUI = Util.ProduceUserUniversalIdentifier(agentClientCircuit);
+                agentFriendService = agentClientCircuit.ServiceURLs["FriendsServerURI"].ToString();
+            }
+            if (friendClient != null)
+            {
+                friendClientCircuit = ((Scene)(friendClient.Scene)).AuthenticateHandler.GetAgentCircuitData(friendClient.CircuitCode);
+                friendUUI = Util.ProduceUserUniversalIdentifier(friendClientCircuit);
+                friendFriendService = friendClientCircuit.ServiceURLs["FriendsServerURI"].ToString();
+            }
+
+            m_log.DebugFormat("[HGFRIENDS MODULE] HG Friendship! thisUUI={0}; friendUUI={1}; foreignThisFriendService={2}; foreignFriendFriendService={3}",
+                    agentUUI, friendUUI, agentFriendService, friendFriendService);
+
+            // Generate a random 8-character hex number that will sign this friendship
+            string secret = UUID.Random().ToString().Substring(0, 8);
+
+            if (agentAccount != null) // agent is local, 'friend' is foreigner
+            {
+                // This may happen when the agent returned home, in which case the friend is not there
+                // We need to look for its information in the friends list itself
+                bool confirming = false;
+                if (friendUUI == string.Empty)
+                {
+                    FriendInfo[] finfos = GetFriends(agentID);
+                    foreach (FriendInfo finfo in finfos)
+                    {
+                        if (finfo.TheirFlags == -1)
+                        {
+                            if (finfo.Friend.StartsWith(friendID.ToString()))
+                            {
+                                friendUUI = finfo.Friend;
+                                confirming = true;
+                            }
+                        }
+                    }
+                }
+
+                // If it's confirming the friendship, we already have the full friendUUI with the secret
+                string theFriendUUID = confirming ? friendUUI : friendUUI + ";" + secret;
+
+                // store in the local friends service a reference to the foreign friend
+                FriendsService.StoreFriend(agentID.ToString(), theFriendUUID, 1);
+                // and also the converse
+                FriendsService.StoreFriend(theFriendUUID, agentID.ToString(), 1);
+
+                if (!confirming && friendClientCircuit != null)
+                {
+                    // store in the foreign friends service a reference to the local agent
+                    HGFriendsServicesConnector friendsConn = new HGFriendsServicesConnector(friendFriendService, friendClientCircuit.SessionID, friendClientCircuit.ServiceSessionID);
+                    friendsConn.NewFriendship(friendID, agentUUI + ";" + secret);
+                }
+            }
+            else if (friendAccount != null) // 'friend' is local,  agent is foreigner
+            {
+                // store in the local friends service a reference to the foreign agent
+                FriendsService.StoreFriend(friendID.ToString(), agentUUI + ";" + secret, 1);
+                // and also the converse
+                FriendsService.StoreFriend(agentUUI + ";" + secret, friendID.ToString(), 1);
+
+                if (agentClientCircuit != null)
+                {
+                    // store in the foreign friends service a reference to the local agent
+                    HGFriendsServicesConnector friendsConn = new HGFriendsServicesConnector(agentFriendService, agentClientCircuit.SessionID, agentClientCircuit.ServiceSessionID);
+                    friendsConn.NewFriendship(agentID, friendUUI + ";" + secret);
+                }
+            }
+            else // They're both foreigners!
+            {
+                HGFriendsServicesConnector friendsConn;
+                if (agentClientCircuit != null)
+                {
+                    friendsConn = new HGFriendsServicesConnector(agentFriendService, agentClientCircuit.SessionID, agentClientCircuit.ServiceSessionID);
+                    friendsConn.NewFriendship(agentID, friendUUI + ";" + secret);
+                }
+                if (friendClientCircuit != null)
+                {
+                    friendsConn = new HGFriendsServicesConnector(friendFriendService, friendClientCircuit.SessionID, friendClientCircuit.ServiceSessionID);
+                    friendsConn.NewFriendship(friendID, agentUUI + ";" + secret);
+                }
+            }
+            // my brain hurts now
+        }
+
+        protected override bool DeleteFriendship(UUID agentID, UUID exfriendID)
+        {
+            UserAccount agentAccount = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, agentID);
+            UserAccount friendAccount = UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, exfriendID);
+            // Are they both local users?
+            if (agentAccount != null && friendAccount != null)
+            {
+                // local grid users
+                return base.DeleteFriendship(agentID, exfriendID);
+            }
+
+            // ok, at least one of them is foreigner, let's get their data
+            string agentUUI = string.Empty;
+            string friendUUI = string.Empty;
+
+            if (agentAccount != null) // agent is local, 'friend' is foreigner
+            {
+                // We need to look for its information in the friends list itself
+                FriendInfo[] finfos = GetFriends(agentID);
+                FriendInfo finfo = GetFriend(finfos, exfriendID);
+                if (finfo != null)
+                {
+                    friendUUI = finfo.Friend;
+
+                    // delete in the local friends service the reference to the foreign friend
+                    FriendsService.Delete(agentID, friendUUI);
+                    // and also the converse
+                    FriendsService.Delete(friendUUI, agentID.ToString());
+
+                    // notify the exfriend's service
+                    Util.FireAndForget(delegate { Delete(exfriendID, agentID, friendUUI); });
+
+                    m_log.DebugFormat("[HGFRIENDS MODULE]: {0} terminated {1}", agentID, friendUUI);
+                    return true;
+                }
+            }
+            else if (friendAccount != null) // agent is foreigner, 'friend' is local
+            {
+                agentUUI = GetUUI(exfriendID, agentID);
+
+                if (agentUUI != string.Empty)
+                {
+                    // delete in the local friends service the reference to the foreign agent
+                    FriendsService.Delete(exfriendID, agentUUI);
+                    // and also the converse
+                    FriendsService.Delete(agentUUI, exfriendID.ToString());
+
+                    // notify the agent's service?
+                    Util.FireAndForget(delegate { Delete(agentID, exfriendID, agentUUI); });
+
+                    m_log.DebugFormat("[HGFRIENDS MODULE]: {0} terminated {1}", agentUUI, exfriendID);
+                    return true;
+                }
+            }
+            //else They're both foreigners! Can't handle this
+
+            return false;
+        }
+
+        private string GetUUI(UUID localUser, UUID foreignUser)
+        {
+            // Let's see if the user is here by any chance
+            FriendInfo[] finfos = GetFriends(localUser);
+            if (finfos != EMPTY_FRIENDS) // friend is here, cool
+            {
+                FriendInfo finfo = GetFriend(finfos, foreignUser);
+                if (finfo != null)
+                {
+                    return finfo.Friend;
+                }
+            }
+            else // user is not currently on this sim, need to get from the service
+            {
+                finfos = FriendsService.GetFriends(localUser);
+                foreach (FriendInfo finfo in finfos)
+                {
+                    if (finfo.Friend.StartsWith(foreignUser.ToString())) // found it!
+                    {
+                        return finfo.Friend;
+                    }
+                }
+            }
+            return string.Empty;
+        }
+
+        private void Delete(UUID foreignUser, UUID localUser, string uui)
+        {
+            UUID id;
+            string url = string.Empty, secret = string.Empty, tmp = string.Empty;
+            if (Util.ParseUniversalUserIdentifier(uui, out id, out url, out tmp, out tmp, out secret))
+            {
+                m_log.DebugFormat("[HGFRIENDS MODULE]: Deleting friendship from {0}", url);
+                HGFriendsServicesConnector friendConn = new HGFriendsServicesConnector(url);
+                friendConn.DeleteFriendship(foreignUser, localUser, secret);
+            }
+        }
+    }
+}

OpenSim/Region/CoreModules/Avatar/InstantMessage/HGMessageTransferModule.cs

@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.InstantMessage;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Server.Handlers.Hypergrid;
+
+namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class HGMessageTransferModule : ISharedRegionModule, IMessageTransferModule, IInstantMessageSimConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected bool m_Enabled = false;
+        protected List<Scene> m_Scenes = new List<Scene>();
+
+        protected IInstantMessage m_IMService;
+        protected Dictionary<UUID, object> m_UserLocationMap = new Dictionary<UUID, object>();
+
+        public event UndeliveredMessage OnUndeliveredMessage;
+
+        IUserManagement m_uMan;
+        IUserManagement UserManagementModule
+        {
+            get
+            {
+                if (m_uMan == null)
+                    m_uMan = m_Scenes[0].RequestModuleInterface<IUserManagement>();
+                return m_uMan;
+            }
+        }
+
+        public virtual void Initialise(IConfigSource config)
+        {
+            IConfig cnf = config.Configs["Messaging"];
+            if (cnf != null && cnf.GetString(
+                    "MessageTransferModule", "MessageTransferModule") != Name)
+            {
+                m_log.Debug("[HG MESSAGE TRANSFER]: Disabled by configuration");
+                return;
+            }
+
+            InstantMessageServerConnector imServer = new InstantMessageServerConnector(config, MainServer.Instance, this);
+            m_IMService = imServer.GetService();
+            m_Enabled = true;
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_Scenes)
+            {
+                m_log.DebugFormat("[HG MESSAGE TRANSFER]: Message transfer module {0} active", Name);
+                scene.RegisterModuleInterface<IMessageTransferModule>(this);
+                m_Scenes.Add(scene);
+            }
+        }
+
+        public virtual void PostInitialise()
+        {
+            if (!m_Enabled)
+                return;
+
+        }
+
+        public virtual void RegionLoaded(Scene scene)
+        {
+        }
+
+        public virtual void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_Scenes)
+            {
+                m_Scenes.Remove(scene);
+            }
+        }
+
+        public virtual void Close()
+        {
+        }
+
+        public virtual string Name
+        {
+            get { return "HGMessageTransferModule"; }
+        }
+
+        public virtual Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void SendInstantMessage(GridInstantMessage im, MessageResultNotification result)
+        {
+            UUID toAgentID = new UUID(im.toAgentID);
+
+            // Try root avatar only first
+            foreach (Scene scene in m_Scenes)
+            {
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+//                    m_log.DebugFormat(
+//                        "[INSTANT MESSAGE]: Looking for root agent {0} in {1}", 
+//                        toAgentID.ToString(), scene.RegionInfo.RegionName);
+                                        
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+                    if (!user.IsChildAgent)
+                    {
+                        // Local message
+//                        m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to root agent {0} {1}", user.Name, toAgentID);
+                        user.ControllingClient.SendInstantMessage(im);
+
+                        // Message sent
+                        result(true);
+                        return;
+                    }
+                }
+            }
+
+            // try child avatar second
+            foreach (Scene scene in m_Scenes)
+            {
+//                m_log.DebugFormat(
+//                    "[INSTANT MESSAGE]: Looking for child of {0} in {1}", toAgentID, scene.RegionInfo.RegionName);
+
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    // Local message
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+
+//                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to child agent {0} {1}", user.Name, toAgentID);
+                    user.ControllingClient.SendInstantMessage(im);
+
+                    // Message sent
+                    result(true);
+                    return;
+                }
+            }
+
+//            m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to {0} via XMLRPC", im.toAgentID);
+            // Is the user a local user?
+            UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, toAgentID);
+            string url = string.Empty;
+            bool foreigner = false;
+            if (account == null) // foreign user
+            {
+                url = UserManagementModule.GetUserServerURL(toAgentID, "IMServerURI");
+                foreigner = true;
+            }
+
+            Util.FireAndForget(delegate
+            {
+                bool success = false;
+                if (foreigner && url == string.Empty) // we don't know about this user
+                {
+                    string recipientUUI = TryGetRecipientUUI(new UUID(im.fromAgentID), toAgentID);
+                    m_log.DebugFormat("[HG MESSAGE TRANSFER]: Got UUI {0}", recipientUUI);
+                    if (recipientUUI != string.Empty)
+                    {
+                        UUID id; string u = string.Empty, first = string.Empty, last = string.Empty, secret = string.Empty;
+                        if (Util.ParseUniversalUserIdentifier(recipientUUI, out id, out u, out first, out last, out secret))
+                        {
+                            success = m_IMService.OutgoingInstantMessage(im, u, true);
+                            if (success)
+                                UserManagementModule.AddUser(toAgentID, u + ";" + first + " " + last);
+                        }
+                    }
+                }
+                else
+                    success = m_IMService.OutgoingInstantMessage(im, url, foreigner);
+
+                if (!success && !foreigner)
+                    HandleUndeliveredMessage(im, result);
+                else
+                    result(success);
+            });
+
+            return;
+        }
+
+        protected bool SendIMToScene(GridInstantMessage gim, UUID toAgentID)
+        {
+            bool successful = false;
+            foreach (Scene scene in m_Scenes)
+            {
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    ScenePresence user =
+                            (ScenePresence)scene.Entities[toAgentID];
+
+                    if (!user.IsChildAgent)
+                    {
+                        scene.EventManager.TriggerIncomingInstantMessage(gim);
+                        successful = true;
+                    }
+                }
+            }
+            if (!successful)
+            {
+                // If the message can't be delivered to an agent, it
+                // is likely to be a group IM. On a group IM, the
+                // imSessionID = toAgentID = group id. Raise the
+                // unhandled IM event to give the groups module
+                // a chance to pick it up. We raise that in a random
+                // scene, since the groups module is shared.
+                //
+                m_Scenes[0].EventManager.TriggerUnhandledInstantMessage(gim);
+            }
+
+            return successful;
+        }
+
+        protected void HandleUndeliveredMessage(GridInstantMessage im, MessageResultNotification result)
+        {
+            UndeliveredMessage handlerUndeliveredMessage = OnUndeliveredMessage;
+
+            // If this event has handlers, then an IM from an agent will be
+            // considered delivered. This will suppress the error message.
+            //
+            if (handlerUndeliveredMessage != null)
+            {
+                handlerUndeliveredMessage(im);
+                if (im.dialog == (byte)InstantMessageDialog.MessageFromAgent)
+                    result(true);
+                else
+                    result(false);
+                return;
+            }
+
+            //m_log.DebugFormat("[INSTANT MESSAGE]: Undeliverable");
+            result(false);
+        }
+
+        private string TryGetRecipientUUI(UUID fromAgent, UUID toAgent)
+        {
+            // Let's call back the fromAgent's user agent service
+            // Maybe that service knows about the toAgent
+            IClientAPI client = LocateClientObject(fromAgent);
+            if (client != null)
+            {
+                AgentCircuitData circuit = m_Scenes[0].AuthenticateHandler.GetAgentCircuitData(client.AgentId);
+                if (circuit != null)
+                {
+                    if (circuit.ServiceURLs.ContainsKey("HomeURI"))
+                    {
+                        string uasURL = circuit.ServiceURLs["HomeURI"].ToString();
+                        m_log.DebugFormat("[HG MESSAGE TRANSFER]: getting UUI of user {0} from {1}", toAgent, uasURL);
+                        UserAgentServiceConnector uasConn = new UserAgentServiceConnector(uasURL);
+                        return uasConn.GetUUI(fromAgent, toAgent);
+                    }
+                }
+            }
+
+            return string.Empty;
+        }
+
+
+        /// <summary>
+        /// Find the scene for an agent
+        /// </summary>
+        private Scene GetClientScene(UUID agentId)
+        {
+            lock (m_Scenes)
+            {
+                foreach (Scene scene in m_Scenes)
+                {
+                    ScenePresence presence = scene.GetScenePresence(agentId);
+                    if (presence != null && !presence.IsChildAgent)
+                        return scene;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Find the client for a ID
+        /// </summary>
+        public IClientAPI LocateClientObject(UUID agentID)
+        {
+            Scene scene = GetClientScene(agentID);
+            if (scene != null)
+            {
+                ScenePresence presence = scene.GetScenePresence(agentID);
+                if (presence != null)
+                    return presence.ControllingClient;
+            }
+
+            return null;
+        }
+
+        #region IInstantMessageSimConnector
+        public bool SendInstantMessage(GridInstantMessage im)
+        {
+            //m_log.DebugFormat("[XXX] Hook SendInstantMessage {0}", im.message);
+            UUID agentID = new UUID(im.toAgentID);
+            return SendIMToScene(im, agentID);
+        }
+        #endregion
+
+
+    }
+}

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveUtils.cs

@@ -149,14 +149,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
         /// <summary>
         /// Find an item given a PATH_DELIMITOR delimited path starting from the user's root folder.
-        ///
+        /// </summary>
+        /// <remarks>
         /// This method does not handle paths that contain multiple delimitors
         ///
         /// FIXME: We do not yet handle situations where folders or items have the same name.  We could handle this by some
         /// XPath like expression
         ///
         /// FIXME: Delimitors which occur in names themselves are not currently escapable.
-        /// </summary>
+        /// </remarks>
         /// 
         /// <param name="inventoryService">
         /// Inventory service to query
@@ -178,32 +179,66 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
             return FindItemByPath(inventoryService, rootFolder, path);
         }
-        
+
         /// <summary>
         /// Find an item given a PATH_DELIMITOR delimited path starting from this folder.
-        ///
-        /// This method does not handle paths that contain multiple delimitors
+        /// </summary>
+        /// <remarks>
+        /// This method does not handle paths that contain multiple delimiters
         ///
         /// FIXME: We do not yet handle situations where folders or items have the same name.  We could handle this by some
         /// XPath like expression
         ///
         /// FIXME: Delimitors which occur in names themselves are not currently escapable.
-        /// </summary>
-        /// 
-        /// <param name="inventoryService">
-        /// Inventory service to query
-        /// </param>
-        /// <param name="startFolder">
-        /// The folder from which the path starts
-        /// </param>
-        /// <param name="path">
-        /// <param name="path">
-        /// The path to the required item.
-        /// </param>
+        /// </remarks>
+        ///
+        /// <param name="inventoryService">Inventory service to query</param>
+        /// <param name="startFolder">The folder from which the path starts</param>
+        /// <param name="path">The path to the required item.</param>
         /// <returns>null if the item is not found</returns>
         public static InventoryItemBase FindItemByPath(
             IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
         {
+            List<InventoryItemBase> foundItems = FindItemsByPath(inventoryService, startFolder, path);
+
+            if (foundItems.Count != 0)
+                return foundItems[0];
+            else
+                return null;
+        }
+
+        public static List<InventoryItemBase> FindItemsByPath(
+            IInventoryService inventoryService, UUID userId, string path)
+        {
+            InventoryFolderBase rootFolder = inventoryService.GetRootFolder(userId);
+
+            if (null == rootFolder)
+                return new List<InventoryItemBase>();
+
+            return FindItemsByPath(inventoryService, rootFolder, path);
+        }
+
+        /// <summary>
+        /// Find items that match a given PATH_DELIMITOR delimited path starting from this folder.
+        /// </summary>
+        /// <remarks>
+        /// This method does not handle paths that contain multiple delimiters
+        ///
+        /// FIXME: We do not yet handle situations where folders or items have the same name.  We could handle this by some
+        /// XPath like expression
+        ///
+        /// FIXME: Delimitors which occur in names themselves are not currently escapable.
+        /// </remarks>
+        /// 
+        /// <param name="inventoryService">Inventory service to query</param>
+        /// <param name="startFolder">The folder from which the path starts</param>
+        /// <param name="path">The path to the required item.</param>
+        /// <returns>The items that were found with this path.  An empty list if no items were found.</returns>
+        public static List<InventoryItemBase> FindItemsByPath(
+            IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
+        {
+            List<InventoryItemBase> foundItems = new List<InventoryItemBase>();
+
             // If the path isn't just / then trim any starting extraneous slashes
             path = path.TrimStart(new char[] { PATH_DELIMITER });
             
@@ -215,11 +250,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             if (components.Length == 1)
             {
 //                m_log.DebugFormat(
-//                    "FOUND SINGLE COMPONENT [{0}].  Looking for this in [{1}] {2}", 
+//                    "FOUND SINGLE COMPONENT [{0}].  Looking for this in [{1}] {2}",
 //                    components[0], startFolder.Name, startFolder.ID);
                 
                 List<InventoryItemBase> items = inventoryService.GetFolderItems(startFolder.Owner, startFolder.ID);
-                
+
 //                m_log.DebugFormat("[INVENTORY ARCHIVE UTILS]: Found {0} items in FindItemByPath()", items.Count);
                 
                 foreach (InventoryItemBase item in items)
@@ -227,24 +262,23 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 //                    m_log.DebugFormat("[INVENTORY ARCHIVE UTILS]: Inspecting item {0} {1}", item.Name, item.ID);
                     
                     if (item.Name == components[0])
-                        return item;
+                        foundItems.Add(item);
                 }
             }
             else
             {
 //                m_log.DebugFormat("FOUND COMPONENTS [{0}] and [{1}]", components[0], components[1]);
-                
+
                 InventoryCollection contents = inventoryService.GetFolderContent(startFolder.Owner, startFolder.ID);
                 
                 foreach (InventoryFolderBase folder in contents.Folders)
                 {
                     if (folder.Name == components[0])
-                        return FindItemByPath(inventoryService, folder, components[1]);
+                        foundItems.AddRange(FindItemsByPath(inventoryService, folder, components[1]));
                 }
             }
 
-            // We didn't find an item or intermediate folder with the given name
-            return null;
+            return foundItems;
         }
 
         /// <summary>

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs

@@ -46,6 +46,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        /// <summary>
+        /// Determine whether this archive will save assets.  Default is true.
+        /// </summary>
+        public bool SaveAssets { get; set; }
+
         /// <value>
         /// Used to select all inventory nodes in a folder but not the folder itself
         /// </value>
@@ -112,6 +117,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             m_invPath = invPath;
             m_saveStream = saveStream;
             m_assetGatherer = new UuidGatherer(m_scene.AssetService);
+
+            SaveAssets = true;
         }
 
         protected void ReceivedAllAssets(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
@@ -150,7 +157,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             string serialization = UserInventoryItemSerializer.Serialize(inventoryItem, options, userAccountService);
             m_archiveWriter.WriteFile(filename, serialization);
 
-            m_assetGatherer.GatherAssetUuids(inventoryItem.AssetID, (AssetType)inventoryItem.AssetType, m_assetUuids);
+            AssetType itemAssetType = (AssetType)inventoryItem.AssetType;
+
+            // Don't chase down link asset items as they actually point to their target item IDs rather than an asset
+            if (SaveAssets && itemAssetType != AssetType.Link && itemAssetType != AssetType.LinkFolder)
+                m_assetGatherer.GatherAssetUuids(inventoryItem.AssetID, (AssetType)inventoryItem.AssetType, m_assetUuids);
         }
 
         /// <summary>
@@ -195,6 +206,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// </summary>
         public void Execute(Dictionary<string, object> options, IUserAccountService userAccountService)
         {
+            if (options.ContainsKey("noassets") && (bool)options["noassets"])
+                SaveAssets = false;
+
             try
             {
                 InventoryFolderBase inventoryFolder = null;
@@ -241,10 +255,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
     
                 // The path may point to an item instead
                 if (inventoryFolder == null)
-                {
                     inventoryItem = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, rootFolder, m_invPath);
-                    //inventoryItem = m_userInfo.RootFolder.FindItemByPath(m_invPath);
-                }
     
                 if (null == inventoryFolder && null == inventoryItem)
                 {
@@ -285,12 +296,23 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             
                 // Don't put all this profile information into the archive right now.
                 //SaveUsers();
-                            
-                new AssetsRequest(
-                    new AssetsArchiver(m_archiveWriter), 
-                    m_assetUuids, m_scene.AssetService, 
-                    m_scene.UserAccountService, m_scene.RegionInfo.ScopeID,
-                    options, ReceivedAllAssets).Execute();
+
+                if (SaveAssets)
+                {
+                    m_log.DebugFormat("[INVENTORY ARCHIVER]: Saving {0} assets for items", m_assetUuids.Count);
+
+                    new AssetsRequest(
+                        new AssetsArchiver(m_archiveWriter),
+                        m_assetUuids, m_scene.AssetService,
+                        m_scene.UserAccountService, m_scene.RegionInfo.ScopeID,
+                        options, ReceivedAllAssets).Execute();
+                }
+                else
+                {
+                    m_log.DebugFormat("[INVENTORY ARCHIVER]: Not saving assets since --noassets was specified");
+
+                    ReceivedAllAssets(new List<UUID>(), new List<UUID>());
+                }
             }
             catch (Exception)
             {
@@ -387,19 +409,19 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// </summary>
         /// <param name="options"></param>
         /// <returns></returns>
-        public static string CreateControlFile(Dictionary<string, object> options)
+        public string CreateControlFile(Dictionary<string, object> options)
         {
             int majorVersion, minorVersion;
             
             if (options.ContainsKey("profile"))
             {
                 majorVersion = 1;
-                minorVersion = 1;
+                minorVersion = 2;
             }
             else
             {
                 majorVersion = 0;
-                minorVersion = 2;
+                minorVersion = 3;
             }            
             
             m_log.InfoFormat("[INVENTORY ARCHIVER]: Creating version {0}.{1} IAR", majorVersion, minorVersion);
@@ -411,6 +433,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             xtw.WriteStartElement("archive");
             xtw.WriteAttributeString("major_version", majorVersion.ToString());
             xtw.WriteAttributeString("minor_version", minorVersion.ToString());
+
+            xtw.WriteElementString("assets_included", SaveAssets.ToString());
+
             xtw.WriteEndElement();
 
             xtw.Flush();

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs

@@ -122,7 +122,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 
                 scene.AddCommand(
                     this, "save iar",
-                    "save iar [--p|-profile=<url>] <first> <last> <inventory path> <password> [<IAR path>] [--v|-verbose]",
+                    "save iar [--p|-profile=<url>] [--noassets] <first> <last> <inventory path> <password> [<IAR path>] [--v|-verbose]",
                     "Save user inventory archive (IAR).", 
                     "<first> is the user's first name." + Environment.NewLine
                     + "<last> is the user's last name." + Environment.NewLine
@@ -130,6 +130,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     + "-p|--profile=<url> adds the url of the profile service to the saved user information." + Environment.NewLine
                     + "-c|--creators preserves information about foreign creators." + Environment.NewLine
                     + "-v|--verbose extra debug messages." + Environment.NewLine
+                    + "--noassets stops assets being saved to the IAR."
                     + "<IAR path> is the filesystem path at which to save the IAR."
                     + string.Format("  If this is not given then the filename {0} in the current directory is used", DEFAULT_INV_BACKUP_FILENAME),
                     HandleSaveInvConsoleCommand);
@@ -398,6 +399,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             ops.Add("p|profile=", delegate(string v) { options["profile"] = v; });
             ops.Add("v|verbose", delegate(string v) { options["verbose"] = v; });
             ops.Add("c|creators", delegate(string v) { options["creators"] = v; });
+            ops.Add("noassets", delegate(string v) { options["noassets"] = v != null; });
 
             List<string> mainParams = ops.Parse(cmdparams);
 
@@ -406,7 +408,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 if (mainParams.Count < 6)
                 {
                     m_log.Error(
-                        "[INVENTORY ARCHIVER]: usage is save iar [--p|-profile=<url>] <first name> <last name> <inventory path> <user password> [<save file path>]");
+                        "[INVENTORY ARCHIVER]: usage is save iar [--p|-profile=<url>] [--noassets] <first name> <last name> <inventory path> <user password> [<save file path>]");
                     return;
                 }
     
@@ -423,16 +425,16 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 m_log.InfoFormat(
                     "[INVENTORY ARCHIVER]: Saving archive {0} using inventory path {1} for {2} {3}",
                     savePath, invPath, firstName, lastName);
-                    
+
+                lock (m_pendingConsoleSaves)
+                    m_pendingConsoleSaves.Add(id);
+
                 ArchiveInventory(id, firstName, lastName, invPath, pass, savePath, options);
             }
             catch (InventoryArchiverException e)
             {
                 m_log.ErrorFormat("[INVENTORY ARCHIVER]: {0}", e.Message);
             }
-                
-            lock (m_pendingConsoleSaves)
-                m_pendingConsoleSaves.Add(id);
         }
         
         private void SaveInvConsoleCommandCompleted(

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs

@@ -44,7 +44,6 @@ using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
@@ -104,7 +103,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             Scene scene = SceneSetupHelpers.SetupScene();
             SceneSetupHelpers.SetupSceneModules(scene, archiverModule);            
             
-            UserProfileTestUtils.CreateUserWithInventory(scene, m_uaLL1, "hampshire");
+            UserAccountHelpers.CreateUserWithInventory(scene, m_uaLL1, "hampshire");
 
             MemoryStream archiveWriteStream = new MemoryStream();
             

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs

@@ -44,7 +44,6 @@ using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
@@ -72,7 +71,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             TestHelper.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, m_uaLL1, "password");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "password");
             m_archiverModule.DearchiveInventory(m_uaLL1.FirstName, m_uaLL1.LastName, "/", "password", m_iarStream);            
             
             InventoryItemBase coaItem
@@ -124,11 +123,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
         }
         
         /// <summary>
-        /// Test saving a single inventory item to a V0.1 OpenSim Inventory Archive 
+        /// Test saving a single inventory item to an IAR
         /// (subject to change since there is no fixed format yet).
         /// </summary>
         [Test]
-        public void TestSaveItemToIarV0_1()
+        public void TestSaveItemToIar()
         {
             TestHelper.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
@@ -138,7 +137,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             string userLastName = "Stirrup";
             string userPassword = "troll";
             UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, userFirstName, userLastName, userId, userPassword);
+            UserAccountHelpers.CreateUserWithInventory(m_scene, userFirstName, userLastName, userId, userPassword);
             
             // Create asset
             UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040");
@@ -212,6 +211,106 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
                 }
             }
 
+//            Assert.That(gotControlFile, Is.True, "No control file in archive");
+            Assert.That(gotObject1File, Is.True, "No item1 file in archive");
+//            Assert.That(gotObject2File, Is.True, "No object2 file in archive");
+
+            // TODO: Test presence of more files and contents of files.
+        }
+
+        /// <summary>
+        /// Test saving a single inventory item to an IAR without its asset
+        /// </summary>
+        [Test]
+        public void TestSaveItemToIarNoAssets()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            // Create user
+            string userFirstName = "Jock";
+            string userLastName = "Stirrup";
+            string userPassword = "troll";
+            UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, userFirstName, userLastName, userId, userPassword);
+
+            // Create asset
+            UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040");
+            SceneObjectGroup object1 = SceneSetupHelpers.CreateSceneObject(1, ownerId, "My Little Dog Object", 0x50);
+
+            UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060");
+            AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, object1);
+            m_scene.AssetService.Store(asset1);
+
+            // Create item
+            UUID item1Id = UUID.Parse("00000000-0000-0000-0000-000000000080");
+            string item1Name = "My Little Dog";
+            InventoryItemBase item1 = new InventoryItemBase();
+            item1.Name = item1Name;
+            item1.AssetID = asset1.FullID;
+            item1.ID = item1Id;
+            InventoryFolderBase objsFolder
+                = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, userId, "Objects")[0];
+            item1.Folder = objsFolder.ID;
+            m_scene.AddInventoryItem(item1);
+
+            MemoryStream archiveWriteStream = new MemoryStream();
+
+            Dictionary<string, Object> options = new Dictionary<string, Object>();
+            options.Add("noassets", true);
+
+            // When we're not saving assets, archiving is being done synchronously.
+            m_archiverModule.ArchiveInventory(
+                Guid.NewGuid(), userFirstName, userLastName, "Objects/" + item1Name, userPassword, archiveWriteStream, options);
+
+            byte[] archive = archiveWriteStream.ToArray();
+            MemoryStream archiveReadStream = new MemoryStream(archive);
+            TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
+
+            //bool gotControlFile = false;
+            bool gotObject1File = false;
+            //bool gotObject2File = false;
+            string expectedObject1FileName = InventoryArchiveWriteRequest.CreateArchiveItemName(item1);
+            string expectedObject1FilePath = string.Format(
+                "{0}{1}",
+                ArchiveConstants.INVENTORY_PATH,
+                expectedObject1FileName);
+
+            string filePath;
+            TarArchiveReader.TarEntryType tarEntryType;
+
+//            Console.WriteLine("Reading archive");
+
+            while (tar.ReadEntry(out filePath, out tarEntryType) != null)
+            {
+                Console.WriteLine("Got {0}", filePath);
+
+//                if (ArchiveConstants.CONTROL_FILE_PATH == filePath)
+//                {
+//                    gotControlFile = true;
+//                }
+
+                if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH) && filePath.EndsWith(".xml"))
+                {
+//                    string fileName = filePath.Remove(0, "Objects/".Length);
+//
+//                    if (fileName.StartsWith(part1.Name))
+//                    {
+                        Assert.That(expectedObject1FilePath, Is.EqualTo(filePath));
+                        gotObject1File = true;
+//                    }
+//                    else if (fileName.StartsWith(part2.Name))
+//                    {
+//                        Assert.That(fileName, Is.EqualTo(expectedObject2FileName));
+//                        gotObject2File = true;
+//                    }
+                }
+                else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
+                {
+                    Assert.Fail("Found asset path in TestSaveItemToIarNoAssets()");
+                }
+            }
+
 //            Assert.That(gotControlFile, Is.True, "No control file in archive");
             Assert.That(gotObject1File, Is.True, "No item1 file in archive");
 //            Assert.That(gotObject2File, Is.True, "No object2 file in archive");
@@ -229,7 +328,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             TestHelper.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, m_uaLL1, "meowfood");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "meowfood");
             
             m_archiverModule.DearchiveInventory(m_uaLL1.FirstName, m_uaLL1.LastName, "/", "meowfood", m_iarStream);            
             InventoryItemBase foundItem1
@@ -261,8 +360,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             TestHelper.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
             
             m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
             InventoryItemBase foundItem1
@@ -294,7 +393,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             TestHelper.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
             
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, m_uaMT, "password");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "password");
             m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "password", m_iarStream);
 
             InventoryItemBase foundItem1

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/PathTests.cs

@@ -44,7 +44,6 @@ using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
@@ -71,7 +70,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             string userLastName = "Stirrup";
             string userPassword = "troll";
             UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
-            UserProfileTestUtils.CreateUserWithInventory(scene, userFirstName, userLastName, userId, userPassword);
+            UserAccountHelpers.CreateUserWithInventory(scene, userFirstName, userLastName, userId, userPassword);
             
             // Create asset
             SceneObjectGroup object1;
@@ -184,8 +183,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             
             SceneSetupHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
 
-            UserProfileTestUtils.CreateUserWithInventory(scene, m_uaMT, "meowfood");
-            UserProfileTestUtils.CreateUserWithInventory(scene, m_uaLL1, "hampshire");
+            UserAccountHelpers.CreateUserWithInventory(scene, m_uaMT, "meowfood");
+            UserAccountHelpers.CreateUserWithInventory(scene, m_uaLL1, "hampshire");
             
             archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
             InventoryItemBase foundItem1
@@ -194,7 +193,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1");            
 
             // Now try loading to a root child folder
-            UserInventoryTestUtils.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xA");
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xA");
             MemoryStream archiveReadStream = new MemoryStream(m_iarStream.ToArray());
             archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "xA", "meowfood", archiveReadStream);
 
@@ -203,7 +202,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             Assert.That(foundItem2, Is.Not.Null, "Didn't find loaded item 2");
 
             // Now try loading to a more deeply nested folder
-            UserInventoryTestUtils.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xB/xC");
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xB/xC");
             archiveReadStream = new MemoryStream(archiveReadStream.ToArray());
             archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "xB/xC", "meowfood", archiveReadStream);
 
@@ -226,7 +225,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             Scene scene = SceneSetupHelpers.SetupScene();
             SceneSetupHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
             
-            UserProfileTestUtils.CreateUserWithInventory(scene, m_uaMT, "password");
+            UserAccountHelpers.CreateUserWithInventory(scene, m_uaMT, "password");
             archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/Objects", "password", m_iarStream);
 
             InventoryItemBase foundItem1
@@ -255,7 +254,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             string userFirstName = "Jock";
             string userLastName = "Stirrup";
             UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
-            UserProfileTestUtils.CreateUserWithInventory(scene, userFirstName, userLastName, userId, "meowfood");
+            UserAccountHelpers.CreateUserWithInventory(scene, userFirstName, userLastName, userId, "meowfood");
             
             // Create asset
             SceneObjectGroup object1;
@@ -328,7 +327,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 //            log4net.Config.XmlConfigurator.Configure();
             
             Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount ua1 = UserProfileTestUtils.CreateUserWithInventory(scene);
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene);
             
             Dictionary <string, InventoryFolderBase> foldersCreated = new Dictionary<string, InventoryFolderBase>();
             HashSet<InventoryNodeBase> nodesLoaded = new HashSet<InventoryNodeBase>();
@@ -395,13 +394,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             //log4net.Config.XmlConfigurator.Configure();
             
             Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount ua1 = UserProfileTestUtils.CreateUserWithInventory(scene);
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene);
             
             string folder1ExistingName = "a";
             string folder2Name = "b";
             
             InventoryFolderBase folder1 
-                = UserInventoryTestUtils.CreateInventoryFolder(
+                = UserInventoryHelpers.CreateInventoryFolder(
                     scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
             
             string folder1ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder1ExistingName, UUID.Random());
@@ -446,13 +445,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 //            log4net.Config.XmlConfigurator.Configure();
             
             Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount ua1 = UserProfileTestUtils.CreateUserWithInventory(scene);
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene);
             
             string folder1ExistingName = "a";
             string folder2Name = "b";
             
             InventoryFolderBase folder1 
-                = UserInventoryTestUtils.CreateInventoryFolder(
+                = UserInventoryHelpers.CreateInventoryFolder(
                     scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
             
             string folder1ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder1ExistingName, UUID.Random());

OpenSim/Region/CoreModules/Avatar/Lure/HGLureModule.cs

@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using Mono.Addins;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Connectors.Hypergrid;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Region.CoreModules.Avatar.Lure
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class HGLureModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private readonly List<Scene> m_scenes = new List<Scene>();
+
+        private IMessageTransferModule m_TransferModule = null;
+        private bool m_Enabled = false;
+
+        private string m_ThisGridURL;
+
+        private ExpiringCache<UUID, GridInstantMessage> m_PendingLures = new ExpiringCache<UUID, GridInstantMessage>();
+
+        public void Initialise(IConfigSource config)
+        {
+            if (config.Configs["Messaging"] != null)
+            {
+                if (config.Configs["Messaging"].GetString("LureModule", string.Empty) == "HGLureModule")
+                {
+                    m_Enabled = true;
+
+                    m_ThisGridURL = config.Configs["Messaging"].GetString("Gatekeeper", string.Empty);
+                    m_log.DebugFormat("[LURE MODULE]: {0} enabled", Name);
+                }
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Add(scene);
+                scene.EventManager.OnIncomingInstantMessage += OnIncomingInstantMessage;
+                scene.EventManager.OnNewClient += OnNewClient;
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            if (m_TransferModule == null)
+            {
+                m_TransferModule =
+                    scene.RequestModuleInterface<IMessageTransferModule>();
+
+                if (m_TransferModule == null)
+                {
+                    m_log.Error("[LURE MODULE]: No message transfer module, lures will not work!");
+
+                    m_Enabled = false;
+                    m_scenes.Clear();
+                    scene.EventManager.OnNewClient -= OnNewClient;
+                    scene.EventManager.OnIncomingInstantMessage -= OnIncomingInstantMessage;
+                }
+            }
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_scenes)
+            {
+                m_scenes.Remove(scene);
+                scene.EventManager.OnNewClient -= OnNewClient;
+                scene.EventManager.OnIncomingInstantMessage -= OnIncomingInstantMessage;
+            }
+        }
+
+        void OnNewClient(IClientAPI client)
+        {
+            client.OnInstantMessage += OnInstantMessage;
+            client.OnStartLure += OnStartLure;
+            client.OnTeleportLureRequest += OnTeleportLureRequest;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "HGLureModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+        }
+
+        void OnIncomingInstantMessage(GridInstantMessage im)
+        {
+            if (im.dialog == (byte)InstantMessageDialog.RequestTeleport)
+            {
+                UUID sessionID = new UUID(im.imSessionID);
+                m_log.DebugFormat("[HG LURE MODULE]: RequestTeleport sessionID={0}, regionID={1}, message={2}", im.imSessionID, im.RegionID, im.message);
+                m_PendingLures.Add(sessionID, im, 7200); // 2 hours
+
+                // Forward. We do this, because the IM module explicitly rejects
+                // IMs of this type
+                if (m_TransferModule != null)
+                    m_TransferModule.SendInstantMessage(im, delegate(bool success) { });
+
+            }
+        }
+
+        public void OnStartLure(byte lureType, string message, UUID targetid, IClientAPI client)
+        {
+            if (!(client.Scene is Scene))
+                return;
+
+            Scene scene = (Scene)(client.Scene);
+            ScenePresence presence = scene.GetScenePresence(client.AgentId);
+
+            message += "@" + m_ThisGridURL;
+
+            m_log.DebugFormat("[HG LURE MODULE]: TP invite with message {0}", message);
+
+            GridInstantMessage m = new GridInstantMessage(scene, client.AgentId,
+                    client.FirstName+" "+client.LastName, targetid,
+                    (byte)InstantMessageDialog.RequestTeleport, false,
+                    message, UUID.Random(), false, presence.AbsolutePosition,
+                    new Byte[0]);
+            m.RegionID = client.Scene.RegionInfo.RegionID.Guid;
+                    
+            if (m_TransferModule != null)
+            {
+                m_TransferModule.SendInstantMessage(m,
+                    delegate(bool success) { });
+            }
+        }
+
+        public void OnTeleportLureRequest(UUID lureID, uint teleportFlags, IClientAPI client)
+        {
+            if (!(client.Scene is Scene))
+                return;
+
+            Scene scene = (Scene)(client.Scene);
+
+            GridInstantMessage im = null;
+            if (m_PendingLures.TryGetValue(lureID, out im))
+            {
+                m_PendingLures.Remove(lureID);
+                Lure(client, teleportFlags, im);
+            }
+            else
+                m_log.DebugFormat("[HG LURE MODULE]: pending lure {0} not found", lureID);
+
+        }
+
+        private void Lure(IClientAPI client, uint teleportflags, GridInstantMessage im)
+        {
+            Scene scene = (Scene)(client.Scene);
+            GridRegion region = scene.GridService.GetRegionByUUID(scene.RegionInfo.ScopeID, new UUID(im.RegionID));
+            if (region != null)
+                scene.RequestTeleportLocation(client, region.RegionHandle, im.Position + new Vector3(0.5f, 0.5f, 0f), Vector3.UnitX, teleportflags);
+            else // we don't have that region here. Check if it's HG
+            {
+                string[] parts = im.message.Split(new char[] { '@' });
+                if (parts.Length > 1)
+                {
+                    string url = parts[parts.Length - 1]; // the last part
+                    if (url.Trim(new char[] {'/'}) != m_ThisGridURL.Trim(new char[] {'/'}))
+                    {
+                        m_log.DebugFormat("[HG LURE MODULE]: Luring agent to grid {0} region {1} position {2}", url, im.RegionID, im.Position);
+                        GatekeeperServiceConnector gConn = new GatekeeperServiceConnector();
+                        GridRegion gatekeeper = new GridRegion();
+                        gatekeeper.ServerURI = url;
+                        GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(im.RegionID));
+                        if (finalDestination != null)
+                        {
+                            ScenePresence sp = scene.GetScenePresence(client.AgentId);
+                            IEntityTransferModule transferMod = scene.RequestModuleInterface<IEntityTransferModule>();
+                            IEventQueue eq = sp.Scene.RequestModuleInterface<IEventQueue>();
+                            if (transferMod != null && sp != null && eq != null)
+                                transferMod.DoTeleport(sp, gatekeeper, finalDestination, im.Position + new Vector3(0.5f, 0.5f, 0f), Vector3.UnitX, teleportflags, eq);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs

@@ -45,16 +45,19 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
         private readonly List<Scene> m_scenes = new List<Scene>();
 
         private IMessageTransferModule m_TransferModule = null;
-        private bool m_Enabled = true;
+        private bool m_Enabled = false;
 
         public void Initialise(IConfigSource config)
         {
             if (config.Configs["Messaging"] != null)
             {
                 if (config.Configs["Messaging"].GetString(
-                        "LureModule", "LureModule") !=
+                        "LureModule", "LureModule") ==
                         "LureModule")
-                    m_Enabled = false;
+                {
+                    m_Enabled = true;
+                    m_log.DebugFormat("[LURE MODULE]: {0} enabled", Name);
+                }
             }
         }
 
@@ -74,6 +77,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
 
         public void RegionLoaded(Scene scene)
         {
+            if (!m_Enabled)
+                return;
+
             if (m_TransferModule == null)
             {
                 m_TransferModule =
@@ -96,6 +102,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
 
         public void RemoveRegion(Scene scene)
         {
+            if (!m_Enabled)
+                return;
+
             lock (m_scenes)
             {
                 m_scenes.Remove(scene);

OpenSim/Region/CoreModules/Avatar/Profile/BasicProfileModule.cs

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Region.CoreModules.Avatar.Profile
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class BasicProfileModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        //
+        // Module vars
+        //
+        private List<Scene> m_Scenes = new List<Scene>();
+        private bool m_Enabled = false;
+
+        #region ISharedRegionModule
+
+        public void Initialise(IConfigSource config)
+        {
+            if (config.Configs["Profile"] != null)
+            {
+                if (config.Configs["Profile"].GetString("Module", string.Empty) != "BasicProfileModule")
+                    return;
+            }
+
+            m_log.DebugFormat("[PROFILE MODULE]: Basic Profile Module enabled");
+            m_Enabled = true;
+
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_Scenes)
+            {
+                if (!m_Scenes.Contains(scene))
+                {
+                    m_Scenes.Add(scene);
+                    // Hook up events
+                    scene.EventManager.OnNewClient += OnNewClient;
+                }
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            lock (m_Scenes)
+            {
+                m_Scenes.Remove(scene);
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "BasicProfileModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        /// New Client Event Handler
+        private void OnNewClient(IClientAPI client)
+        {
+            //Profile
+            client.OnRequestAvatarProperties += RequestAvatarProperties;
+        }
+
+        public void RequestAvatarProperties(IClientAPI remoteClient, UUID avatarID)
+        {
+            IScene s = remoteClient.Scene;
+            if (!(s is Scene))
+                return;
+
+            Scene scene = (Scene)s;
+
+            string profileUrl = String.Empty;
+            string aboutText = String.Empty;
+            string firstLifeAboutText = String.Empty;
+            UUID image = UUID.Zero;
+            UUID firstLifeImage = UUID.Zero;
+            UUID partner = UUID.Zero;
+            uint wantMask = 0;
+            string wantText = String.Empty;
+            uint skillsMask = 0;
+            string skillsText = String.Empty;
+            string languages = String.Empty;
+
+            Byte[] charterMember = Utils.StringToBytes("Avatar");
+
+            profileUrl = "No profile data";
+            aboutText = string.Empty;
+            firstLifeAboutText = string.Empty;
+            image = UUID.Zero;
+            firstLifeImage = UUID.Zero;
+            partner = UUID.Zero;
+
+            remoteClient.SendAvatarProperties(avatarID, aboutText,
+                        Util.ToDateTime(0).ToString(
+                                "M/d/yyyy", CultureInfo.InvariantCulture),
+                        charterMember, firstLifeAboutText,
+                        (uint)(0 & 0xff),
+                        firstLifeImage, image, profileUrl, partner);
+
+            //Viewer expects interest data when it asks for properties.
+            remoteClient.SendAvatarInterestsReply(avatarID, wantMask, wantText,
+                                                    skillsMask, skillsText, languages);
+        }
+
+    }
+}

OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs

@@ -52,6 +52,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         protected bool m_Enabled = false;
         protected Scene m_aScene;
+        protected List<Scene> m_Scenes = new List<Scene>();
         protected List<UUID> m_agentsInTransit;
         private ExpiringCache<UUID, ExpiringCache<ulong, DateTime>> m_bannedRegions =
                 new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
@@ -96,6 +97,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (m_aScene == null)
                 m_aScene = scene;
 
+            m_Scenes.Add(scene);
             scene.RegisterModuleInterface<IEntityTransferModule>(this);
             scene.EventManager.OnNewClient += OnNewClient;
         }
@@ -103,6 +105,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         protected virtual void OnNewClient(IClientAPI client)
         {
             client.OnTeleportHomeRequest += TeleportHome;
+            client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
         }
 
         public virtual void Close()
@@ -118,6 +121,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             if (scene == m_aScene)
                 m_aScene = null;
+
+            m_Scenes.Remove(scene);
         }
 
         public virtual void RegionLoaded(Scene scene)
@@ -127,7 +132,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         }
 
-
         #endregion
 
         #region Agent Teleports
@@ -248,7 +252,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
         }
 
-        protected void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
+        public void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
         {
             if (reg == null || finalDestination == null)
             {
@@ -556,6 +560,29 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #endregion
 
+        #region Landmark Teleport
+        /// <summary>
+        /// Tries to teleport agent to landmark.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="regionHandle"></param>
+        /// <param name="position"></param>
+        public virtual void RequestTeleportLandmark(IClientAPI remoteClient, AssetLandmark lm)
+        {
+            GridRegion info = m_aScene.GridService.GetRegionByUUID(UUID.Zero, lm.RegionID);
+
+            if (info == null)
+            {
+                // can't find the region: Tell viewer and abort
+                remoteClient.SendTeleportFailed("The teleport destination could not be found.");
+                return;
+            }
+            ((Scene)(remoteClient.Scene)).RequestTeleportLocation(remoteClient, info.RegionHandle, lm.Position, 
+                Vector3.Zero, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark));
+        }
+
+        #endregion 
+
         #region Teleport Home
 
         public virtual void TeleportHome(UUID id, IClientAPI client)

OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs

@@ -87,6 +87,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         protected override void OnNewClient(IClientAPI client)
         {
             client.OnTeleportHomeRequest += TeleportHome;
+            client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
             client.OnConnectionClosed += new Action<IClientAPI>(OnConnectionClosed);
         }
 
@@ -146,8 +147,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             base.AgentHasMovedAway(sp, logout);
             if (logout)
+            {
+                // Reset the map
+                ResetMap(sp);
+
                 // Log them out of this grid
                 m_aScene.PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
+            }
         }
 
         protected override bool CreateAgent(ScenePresence sp, GridRegion reg, GridRegion finalDestination, AgentCircuitData agentCircuit, uint teleportFlags, out string reason, out bool logout)
@@ -228,6 +234,79 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             DoTeleport(sp, homeGatekeeper, finalDestination, position, lookAt, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaHome), eq);
         }
+
+        /// <summary>
+        /// Tries to teleport agent to landmark.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="regionHandle"></param>
+        /// <param name="position"></param>
+        public override void RequestTeleportLandmark(IClientAPI remoteClient, AssetLandmark lm)
+        {
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Teleporting agent via landmark to {0} region {1} position {2}", 
+                (lm.Gatekeeper == string.Empty) ? "local" : lm.Gatekeeper, lm.RegionID, lm.Position);
+            if (lm.Gatekeeper == string.Empty)
+            {
+                base.RequestTeleportLandmark(remoteClient, lm);
+                return;
+            }
+
+            GridRegion info = m_aScene.GridService.GetRegionByUUID(UUID.Zero, lm.RegionID);
+
+            // Local region?
+            if (info != null)
+            {
+                ((Scene)(remoteClient.Scene)).RequestTeleportLocation(remoteClient, info.RegionHandle, lm.Position,
+                    Vector3.Zero, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark));
+                return;
+            }
+            else 
+            {
+                // Foreign region
+                Scene scene = (Scene)(remoteClient.Scene);
+                GatekeeperServiceConnector gConn = new GatekeeperServiceConnector();
+                GridRegion gatekeeper = new GridRegion();
+                gatekeeper.ServerURI = lm.Gatekeeper;
+                GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(lm.RegionID));
+                if (finalDestination != null)
+                {
+                    ScenePresence sp = scene.GetScenePresence(remoteClient.AgentId);
+                    IEntityTransferModule transferMod = scene.RequestModuleInterface<IEntityTransferModule>();
+                    IEventQueue eq = sp.Scene.RequestModuleInterface<IEventQueue>();
+                    if (transferMod != null && sp != null && eq != null)
+                        transferMod.DoTeleport(sp, gatekeeper, finalDestination, lm.Position,
+                            Vector3.UnitX, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark), eq);
+                }
+
+            }
+
+            // can't find the region: Tell viewer and abort
+            remoteClient.SendTeleportFailed("The teleport destination could not be found.");
+
+        }
+
+        protected void ResetMap(ScenePresence sp)
+        {
+            List<GridRegion> regions = m_Scenes[0].GridService.GetRegionRange(m_Scenes[0].RegionInfo.ScopeID, 0, 17000 * (int)Constants.RegionSize, 0, 17000 * (int)Constants.RegionSize);
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Resetting {0} tiles on the map", regions.Count);
+            if (regions != null)
+            {
+                List<MapBlockData> mapBlocks = new List<MapBlockData>();
+                foreach (GridRegion r in regions)
+                {
+                    MapBlockData mblock = new MapBlockData();
+                    mblock.X = (ushort)(r.RegionLocX / Constants.RegionSize);
+                    mblock.Y = (ushort)(r.RegionLocY / Constants.RegionSize);
+                    mblock.Name = "";
+                    mblock.Access = 254; // means 'simulator is offline'. We need this because the viewer ignores 255's
+                    mblock.MapImageId = UUID.Zero;
+                    mapBlocks.Add(mblock);
+                }
+                sp.ControllingClient.SendMapBlock(mapBlocks, 0);
+            }
+
+        }
+
         #endregion
 
         #region IUserAgentVerificationModule

OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs

@@ -56,6 +56,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
         private string m_ProfileServerURI;
         private bool m_OutboundPermission;
+        private string m_ThisGatekeeper;
 
 //        private bool m_Initialized = false;
 
@@ -85,6 +86,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     {
                         m_ProfileServerURI = thisModuleConfig.GetString("ProfileServerURI", string.Empty);
                         m_OutboundPermission = thisModuleConfig.GetBoolean("OutboundPermission", true);
+                        m_ThisGatekeeper = thisModuleConfig.GetString("Gatekeeper", string.Empty);
                     }
                     else
                         m_log.Warn("[HG INVENTORY ACCESS MODULE]: HGInventoryAccessModule configs not found. ProfileServerURI not set!");
@@ -110,7 +112,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
         public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel)
         {
             string userAssetServer = string.Empty;
-            if (IsForeignUser(avatarID, out userAssetServer) && m_OutboundPermission)
+            if (IsForeignUser(avatarID, out userAssetServer) && userAssetServer != string.Empty && m_OutboundPermission)
             {
                 Util.FireAndForget(delegate { m_assMapper.Post(assetID, avatarID, userAssetServer); });
             }
@@ -119,6 +121,24 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
         #endregion
 
         #region Overrides of Basic Inventory Access methods
+
+        protected override string GenerateLandmark(ScenePresence presence, out string prefix, out string suffix)
+        {
+            UserAccount account = m_Scene.UserAccountService.GetUserAccount(m_Scene.RegionInfo.ScopeID, presence.UUID);
+            if (account == null)
+                prefix = "HG ";
+            else
+                prefix = string.Empty;
+            suffix = " @ " + m_ThisGatekeeper;
+            Vector3 pos = presence.AbsolutePosition;
+            return String.Format("Landmark version 2\nregion_id {0}\nlocal_pos {1} {2} {3}\nregion_handle {4}\ngatekeeper {5}\n",
+                                presence.Scene.RegionInfo.RegionID,
+                                pos.X, pos.Y, pos.Z,
+                                presence.RegionHandle,
+                                m_ThisGatekeeper);
+        }
+
+
         /// 
         /// CapsUpdateInventoryItemAsset
         ///
@@ -180,10 +200,10 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
         public override void TransferInventoryAssets(InventoryItemBase item, UUID sender, UUID receiver)
         {
             string userAssetServer = string.Empty;
-            if (IsForeignUser(sender, out userAssetServer))
+            if (IsForeignUser(sender, out userAssetServer) && userAssetServer != string.Empty)
                 m_assMapper.Get(item.AssetID, sender, userAssetServer);
 
-            if (IsForeignUser(receiver, out userAssetServer) && m_OutboundPermission)
+            if (IsForeignUser(receiver, out userAssetServer) && userAssetServer != string.Empty && m_OutboundPermission)
                 m_assMapper.Post(item.AssetID, receiver, userAssetServer);
         }
 
@@ -203,9 +223,15 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     if (aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
                     {
                         assetServerURL = aCircuit.ServiceURLs["AssetServerURI"].ToString();
-                        assetServerURL = assetServerURL.Trim(new char[] { '/' }); return true;
+                        assetServerURL = assetServerURL.Trim(new char[] { '/' }); 
                     }
                 }
+                else
+                {
+                    assetServerURL = UserManagementModule.GetUserServerURL(userID, "AssetServerURI");
+                    assetServerURL = assetServerURL.Trim(new char[] { '/' });
+                }
+                return true;
             }
 
             return false;

OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs

@@ -30,6 +30,7 @@ using System.Collections.Generic;
 using System.Net;
 using System.Xml;
 using System.Reflection;
+using System.Text;
 using System.Threading;
 
 using OpenSim.Framework;
@@ -128,7 +129,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
         protected virtual void OnNewClient(IClientAPI client)
         {
-            
+            client.OnCreateNewInventoryItem += CreateNewInventoryItem;
         }
 
         public virtual void Close()
@@ -156,6 +157,87 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
         #region Inventory Access
 
+        /// <summary>
+        /// Create a new inventory item.  Called when the client creates a new item directly within their
+        /// inventory (e.g. by selecting a context inventory menu option).
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="transactionID"></param>
+        /// <param name="folderID"></param>
+        /// <param name="callbackID"></param>
+        /// <param name="description"></param>
+        /// <param name="name"></param>
+        /// <param name="invType"></param>
+        /// <param name="type"></param>
+        /// <param name="wearableType"></param>
+        /// <param name="nextOwnerMask"></param>
+        public void CreateNewInventoryItem(IClientAPI remoteClient, UUID transactionID, UUID folderID,
+                                           uint callbackID, string description, string name, sbyte invType,
+                                           sbyte assetType,
+                                           byte wearableType, uint nextOwnerMask, int creationDate)
+        {
+            m_log.DebugFormat("[AGENT INVENTORY]: Received request to create inventory item {0} in folder {1}", name, folderID);
+
+            if (!m_Scene.Permissions.CanCreateUserInventory(invType, remoteClient.AgentId))
+                return;
+
+            InventoryFolderBase f = new InventoryFolderBase(folderID, remoteClient.AgentId);
+            InventoryFolderBase folder = m_Scene.InventoryService.GetFolder(f);
+
+            if (folder == null || folder.Owner != remoteClient.AgentId)
+                return;
+
+            if (transactionID == UUID.Zero)
+            {
+                ScenePresence presence;
+                if (m_Scene.TryGetScenePresence(remoteClient.AgentId, out presence))
+                {
+                    byte[] data = null;
+
+                    if (invType == (sbyte)InventoryType.Landmark && presence != null)
+                    {
+                        string suffix = string.Empty, prefix = string.Empty;
+                        string strdata = GenerateLandmark(presence, out prefix, out suffix);
+                        data = Encoding.ASCII.GetBytes(strdata);
+                        name = prefix + name;
+                        description += suffix;
+                    }
+
+                    AssetBase asset = m_Scene.CreateAsset(name, description, assetType, data, remoteClient.AgentId);
+                    m_Scene.AssetService.Store(asset);
+
+                    m_Scene.CreateNewInventoryItem(remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID, asset.Name, 0, callbackID, asset, invType, nextOwnerMask, creationDate);
+                }
+                else
+                {
+                    m_log.ErrorFormat(
+                        "ScenePresence for agent uuid {0} unexpectedly not found in CreateNewInventoryItem",
+                        remoteClient.AgentId);
+                }
+            }
+            else
+            {
+                IAgentAssetTransactions agentTransactions = m_Scene.RequestModuleInterface<IAgentAssetTransactions>();
+                if (agentTransactions != null)
+                {
+                    agentTransactions.HandleItemCreationFromTransaction(
+                        remoteClient, transactionID, folderID, callbackID, description,
+                        name, invType, assetType, wearableType, nextOwnerMask);
+                }
+            }
+        }
+
+        protected virtual string GenerateLandmark(ScenePresence presence, out string prefix, out string suffix)
+        {
+            prefix = string.Empty;
+            suffix = string.Empty;
+            Vector3 pos = presence.AbsolutePosition;
+            return String.Format("Landmark version 2\nregion_id {0}\nlocal_pos {1} {2} {3}\nregion_handle {4}\n",
+                                presence.Scene.RegionInfo.RegionID,
+                                pos.X, pos.Y, pos.Z,
+                                presence.RegionHandle);
+        }
+
         /// <summary>
         /// Capability originating call to update the asset of an item in an agent's inventory
         /// </summary>

OpenSim/Region/CoreModules/Framework/InventoryAccess/Tests/InventoryAccessModuleTests.cs

@@ -45,7 +45,6 @@ using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
 {
@@ -73,7 +72,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
             string userFirstName = "Jock";
             string userLastName = "Stirrup";
             string userPassword = "troll";
-            UserProfileTestUtils.CreateUserWithInventory(m_scene, userFirstName, userLastName, m_userId, userPassword);                        
+            UserAccountHelpers.CreateUserWithInventory(m_scene, userFirstName, userLastName, m_userId, userPassword);                        
             
             AgentCircuitData acd = new AgentCircuitData();
             acd.AgentID = m_userId;

OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs

@@ -30,11 +30,13 @@ using System.IO;
 using System.Reflection;
 
 using OpenSim.Framework;
+using OpenSim.Framework.Console;
 
 using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Hypergrid;
 
 using OpenMetaverse;
 using log4net;
@@ -47,7 +49,8 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
         public UUID Id;
         public string FirstName;
         public string LastName;
-        public string ProfileURL;
+        public string HomeURL;
+        public Dictionary<string, object> ServerURLs;
     }
 
     public class UserManagementModule : ISharedRegionModule, IUserManagement
@@ -78,6 +81,14 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             //        }
             //    }
             //}
+            MainConsole.Instance.Commands.AddCommand("grid", true,
+                "show names",
+                "show names",
+                "Show the bindings between user UUIDs and user names",
+                String.Empty,
+                HandleShowUsers);
+
+
         }
 
         public bool IsSharedModule
@@ -101,6 +112,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
             scene.RegisterModuleInterface<IUserManagement>(this);
             scene.EventManager.OnNewClient += new EventManager.OnNewClientDelegate(EventManager_OnNewClient);
+            scene.EventManager.OnPrimsLoaded += new EventManager.PrimsLoaded(EventManager_OnPrimsLoaded);
         }
 
         public void RemoveRegion(Scene scene)
@@ -109,18 +121,12 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             m_Scenes.Remove(scene);
         }
 
-        public void RegionLoaded(Scene scene)
+        public void RegionLoaded(Scene s)
         {
         }
 
         public void PostInitialise()
         {
-            foreach (Scene s in m_Scenes)
-            {
-                // let's sniff all the user names referenced by objects in the scene
-                m_log.DebugFormat("[USER MANAGEMENT MODULE]: Caching creators' data from {0} ({1} objects)...", s.RegionInfo.RegionName, s.GetEntities().Length);
-                s.ForEachSOG(delegate(SceneObjectGroup sog) { CacheCreators(sog); });
-            }
         }
 
         public void Close()
@@ -134,6 +140,14 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
  
         #region Event Handlers
 
+        void EventManager_OnPrimsLoaded(Scene s)
+        {
+            // let's sniff all the user names referenced by objects in the scene
+            m_log.DebugFormat("[USER MANAGEMENT MODULE]: Caching creators' data from {0} ({1} objects)...", s.RegionInfo.RegionName, s.GetEntities().Length);
+            s.ForEachSOG(delegate(SceneObjectGroup sog) { CacheCreators(sog); });
+        }
+
+
         void EventManager_OnNewClient(IClientAPI client)
         {
             client.OnNameFromUUIDRequest += new UUIDNameRequest(HandleUUIDNameRequest);
@@ -150,6 +164,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
                 string[] names = GetUserNames(uuid);
                 if (names.Length == 2)
                 {
+                    //m_log.DebugFormat("[XXX] HandleUUIDNameRequest {0} is {1} {2}", uuid, names[0], names[1]);
                     remote_client.SendNameReply(uuid, names[0], names[1]);
                 }
 
@@ -210,6 +225,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
         public string GetUserName(UUID uuid)
         {
+            //m_log.DebugFormat("[XXX] GetUserName {0}", uuid);
             string[] names = GetUserNames(uuid);
             if (names.Length == 2)
             {
@@ -222,6 +238,60 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             return "(hippos)";
         }
 
+        public string GetUserHomeURL(UUID userID)
+        {
+            if (m_UserCache.ContainsKey(userID))
+                return m_UserCache[userID].HomeURL;
+
+            return string.Empty;
+        }
+
+        public string GetUserServerURL(UUID userID, string serverType)
+        {
+            if (m_UserCache.ContainsKey(userID))
+            {
+                UserData userdata = m_UserCache[userID];
+                if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
+                    return userdata.ServerURLs[serverType].ToString();
+
+                if (userdata.HomeURL != string.Empty)
+                {
+                    UserAgentServiceConnector uConn = new UserAgentServiceConnector(userdata.HomeURL);
+                    userdata.ServerURLs = uConn.GetServerURLs(userID);
+                    if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)
+                        return userdata.ServerURLs[serverType].ToString();
+                }
+            }
+
+            return string.Empty;
+        }
+
+        public string GetUserUUI(UUID userID)
+        {
+            UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, userID);
+            if (account != null)
+                return userID.ToString();
+
+            if (m_UserCache.ContainsKey(userID))
+            {
+                UserData ud = m_UserCache[userID];
+                string homeURL = ud.HomeURL;
+                string first = ud.FirstName, last = ud.LastName;
+                if (ud.LastName.StartsWith("@"))
+                {
+                    string[] parts = ud.FirstName.Split('.');
+                    if (parts.Length >= 2)
+                    {
+                        first = parts[0];
+                        last = parts[1];
+                    }
+                    return userID + ";" + homeURL + ";" + first + " " + last;
+                }
+            }
+
+            return userID.ToString();
+        }
+
         public void AddUser(UUID id, string creatorData)
         {
             if (m_UserCache.ContainsKey(id))
@@ -247,13 +317,13 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
                     string[] parts = creatorData.Split(';');
                     if (parts.Length >= 1)
                     {
-                        user.ProfileURL = parts[0];
+                        user.HomeURL = parts[0];
                         try
                         {
                             Uri uri = new Uri(parts[0]);
                             user.LastName = "@" + uri.Authority;
                         }
-                        catch
+                        catch (UriFormatException)
                         {
                             m_log.DebugFormat("[SCENE]: Unable to parse Uri {0}", parts[0]);
                             user.LastName = "@unknown";
@@ -272,7 +342,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
             lock (m_UserCache)
                 m_UserCache[id] = user;
 
-            m_log.DebugFormat("[USER MANAGEMENT MODULE]: Added user {0} {1} {2} {3}", user.Id, user.FirstName, user.LastName, user.ProfileURL);
+            m_log.DebugFormat("[USER MANAGEMENT MODULE]: Added user {0} {1} {2} {3}", user.Id, user.FirstName, user.LastName, user.HomeURL);
         }
 
         public void AddUser(UUID uuid, string first, string last, string profileURL)
@@ -311,5 +381,25 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
         //}
 
         #endregion IUserManagement
+
+        private void HandleShowUsers(string module, string[] cmd)
+        {
+            if (m_UserCache.Count == 0)
+            {
+                MainConsole.Instance.Output("No users not found");
+                return;
+            }
+
+            MainConsole.Instance.Output("UUID                                 User Name");
+            MainConsole.Instance.Output("-----------------------------------------------------------------------------");
+            foreach (KeyValuePair<UUID, UserData> kvp in m_UserCache)
+            {
+                MainConsole.Instance.Output(String.Format("{0} {1} {2}",
+                       kvp.Key, kvp.Value.FirstName, kvp.Value.LastName));
+            }
+            return;
+        }
+
+
     }
 }

OpenSim/Region/CoreModules/Hypergrid/HGWorldMapModule.cs

@@ -25,6 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using log4net;
@@ -58,26 +59,44 @@ namespace OpenSim.Region.CoreModules.Hypergrid
 
         #endregion
 
-        protected override void GetAndSendBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag)
-        {
-            List<MapBlockData> mapBlocks = new List<MapBlockData>();
-            List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                minX * (int)Constants.RegionSize, maxX * (int)Constants.RegionSize, 
-                minY * (int)Constants.RegionSize, maxY * (int)Constants.RegionSize);
+        //protected override void GetAndSendBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag)
+        //{
+        //    List<MapBlockData> mapBlocks = new List<MapBlockData>();
+        //    List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
+        //        minX * (int)Constants.RegionSize, maxX * (int)Constants.RegionSize, 
+        //        minY * (int)Constants.RegionSize, maxY * (int)Constants.RegionSize);
 
-            foreach (GridRegion r in regions)
-            {
-                MapBlockData block = new MapBlockData();
-                MapBlockFromGridRegion(block, r);
-                mapBlocks.Add(block);
-            }
+        //    foreach (GridRegion r in regions)
+        //    {
+        //        uint x = 0, y = 0;
+        //        long handle = 0;
+        //        if (r.RegionSecret != null && r.RegionSecret != string.Empty)
+        //        {
+        //            if (long.TryParse(r.RegionSecret, out handle))
+        //            {
+        //                Utils.LongToUInts((ulong)handle, out x, out y);
+        //                x = x / Constants.RegionSize;
+        //                y = y / Constants.RegionSize;
+        //            }
+        //        }
 
-            // Different from super
-            FillInMap(mapBlocks, minX, minY, maxX, maxY);
-            //
+        //        if (handle == 0 || 
+        //            // Check the distance from the current region
+        //            (handle != 0 && Math.Abs((int)(x - m_scene.RegionInfo.RegionLocX)) < 4096 && Math.Abs((int)(y - m_scene.RegionInfo.RegionLocY)) < 4096))
+        //        {
+        //            MapBlockData block = new MapBlockData();
+        //            MapBlockFromGridRegion(block, r);
+        //            mapBlocks.Add(block);
+        //        }
+        //    }
 
-            remoteClient.SendMapBlock(mapBlocks, 0);
-        }
+        //    // Different from super
+        //    //FillInMap(mapBlocks, minX, minY, maxX, maxY);
+        //    //
+
+        //    remoteClient.SendMapBlock(mapBlocks, 0);
+
+        //}
 
 
         private void FillInMap(List<MapBlockData> mapBlocks, int minX, int minY, int maxX, int maxY)

OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml

@@ -24,6 +24,7 @@
         <RegionModule id="UrlModule" type="OpenSim.Region.CoreModules.Scripting.LSLHttp.UrlModule" />
         <RegionModule id="Chat" type="OpenSim.Region.CoreModules.Avatar.Chat.ChatModule" />
         <RegionModule id="FriendsModule" type="OpenSim.Region.CoreModules.Avatar.Friends.FriendsModule" />
+        <RegionModule id="HGFriendsModule" type="OpenSim.Region.CoreModules.Avatar.Friends.HGFriendsModule" />
         <RegionModule id="PresenceModule" type="OpenSim.Region.CoreModules.Avatar.InstantMessage.PresenceModule" />
         <RegionModule id="MuteListModule" type="OpenSim.Region.CoreModules.Avatar.InstantMessage.MuteListModule" />
         <RegionModule id="OfflineMessageModule" type="OpenSim.Region.CoreModules.Avatar.InstantMessage.OfflineMessageModule" />

OpenSim/Region/CoreModules/ServiceConnectorsIn/Hypergrid/HypergridServiceInConnectorModule.cs

@@ -113,8 +113,10 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsIn.Hypergrid
                 ISimulationService simService = scene.RequestModuleInterface<ISimulationService>();
                 m_HypergridHandler = new GatekeeperServiceInConnector(m_Config, MainServer.Instance, simService);
 
-                new UserAgentServerConnector(m_Config, MainServer.Instance);
+                IFriendsSimConnector friendsConn = scene.RequestModuleInterface<IFriendsSimConnector>();
+                new UserAgentServerConnector(m_Config, MainServer.Instance, friendsConn);
                 new HeloServiceInConnector(m_Config, MainServer.Instance, "HeloService");
+                new HGFriendsServerConnector(m_Config, MainServer.Instance, "HGFriendsService");
             }
             scene.RegisterModuleInterface<IGatekeeperService>(m_HypergridHandler.GateKeeper);
         }

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs

@@ -40,7 +40,6 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid;
 using OpenSim.Region.Framework.Scenes;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid.Tests
 {

OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/HGInventoryBroker.cs

@@ -58,6 +58,17 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
 
         private List<Scene> m_Scenes = new List<Scene>();
 
+        protected IUserManagement m_UserManagement;
+        protected IUserManagement UserManagementModule
+        {
+            get
+            {
+                if (m_UserManagement == null)
+                    m_UserManagement = m_Scenes[0].RequestModuleInterface<IUserManagement>();
+                return m_UserManagement;
+            }
+        }
+
         public Type ReplaceableInterface 
         {
             get { return null; }
@@ -207,6 +218,18 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
                         }
                     }
                 }
+                if (sp == null)
+                {
+                    inventoryURL = UserManagementModule.GetUserServerURL(userID, "InventoryServerURI");
+                    if (inventoryURL != null && inventoryURL != string.Empty)
+                    {
+                        inventoryURL = inventoryURL.Trim(new char[] { '/' });
+                        m_InventoryURLs.Add(userID, inventoryURL);
+                        m_log.DebugFormat("[HG INVENTORY CONNECTOR]: Added {0} to the cache of inventory URLs", inventoryURL);
+                    }
+
+                }
+
             }
         }
 

OpenSim/Region/CoreModules/ServiceConnectorsOut/Presence/Tests/PresenceConnectorsTests.cs

@@ -40,7 +40,6 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Presence;
 using OpenSim.Region.Framework.Scenes;
 using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Presence.Tests
 {

OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs

@@ -347,12 +347,15 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 
                 landData.Add(parcel);
             }
-            
-            if (!m_merge)                
-                m_scene.LandChannel.Clear(false);
+
+            if (!m_merge)
+            {
+                bool setupDefaultParcel = (landData.Count == 0);
+                m_scene.LandChannel.Clear(setupDefaultParcel);
+            }
             
             m_scene.EventManager.TriggerIncomingLandDataFromStorage(landData);
-            m_log.InfoFormat("[ARCHIVER]: Restored {0} parcels.", landData.Count);            
+            m_log.InfoFormat("[ARCHIVER]: Restored {0} parcels.", landData.Count);
         }
 
         /// <summary>

OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs

@@ -49,7 +49,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
     public class ArchiveWriteRequestPreparation
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-                
+
         /// <summary>
         /// The minimum major version of OAR that we can write.
         /// </summary>
@@ -58,7 +58,12 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <summary>
         /// The maximum major version of OAR that we can write.
         /// </summary>
-        public static int MAX_MAJOR_VERSION = 0;        
+        public static int MAX_MAJOR_VERSION = 0;
+
+        /// <summary>
+        /// Determine whether this archive will save assets.  Default is true.
+        /// </summary>
+        public bool SaveAssets { get; set; }
         
         protected Scene m_scene;
         protected Stream m_saveStream;
@@ -73,10 +78,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <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)
+        public ArchiveWriteRequestPreparation(Scene scene, string savePath, Guid requestId) : this(scene, requestId)
         {
-            m_scene = scene;
-
             try
             {
                 m_saveStream = new GZipStream(new FileStream(savePath, FileMode.Create), CompressionMode.Compress);
@@ -86,10 +89,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 m_log.ErrorFormat(
                     "[ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream."
                         + "If you've manually installed Mono, have you appropriately updated zlib1g as well?");
-                m_log.Error(e);
+                m_log.ErrorFormat("{0} {1}", e.Message, e.StackTrace);
             }
-            
-            m_requestId = requestId;
         }
         
         /// <summary>
@@ -98,11 +99,17 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <param name="scene"></param>
         /// <param name="saveStream">The stream to which to save data.</param>
         /// <param name="requestId">The id associated with this request</param>
-        public ArchiveWriteRequestPreparation(Scene scene, Stream saveStream, Guid requestId)
+        public ArchiveWriteRequestPreparation(Scene scene, Stream saveStream, Guid requestId) : this(scene, requestId)
+        {
+            m_saveStream = saveStream;
+        }
+
+        protected ArchiveWriteRequestPreparation(Scene scene, Guid requestId)
         {
             m_scene = scene;
-            m_saveStream = saveStream;
             m_requestId = requestId;
+
+            SaveAssets = true;
         }
 
         /// <summary>
@@ -111,22 +118,15 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <exception cref="System.IO.IOException">if there was an io problem with creating the file</exception>
         public void ArchiveRegion(Dictionary<string, object> options)
         {
+            if (options.ContainsKey("noassets") && (bool)options["noassets"])
+                SaveAssets = false;
+
             try
             {
                 Dictionary<UUID, AssetType> assetUuids = new Dictionary<UUID, AssetType>();
     
                 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
@@ -141,17 +141,24 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                             sceneObjects.Add((SceneObjectGroup)entity);
                     }
                 }
-                
-                UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
-    
-                foreach (SceneObjectGroup sceneObject in sceneObjects)
+
+                if (SaveAssets)
                 {
-                    assetGatherer.GatherAssetUuids(sceneObject, assetUuids);
+                    UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
+
+                    foreach (SceneObjectGroup sceneObject in sceneObjects)
+                    {
+                        assetGatherer.GatherAssetUuids(sceneObject, assetUuids);
+                    }
+
+                    m_log.DebugFormat(
+                        "[ARCHIVER]: {0} scene objects to serialize requiring save of {1} assets",
+                        sceneObjects.Count, assetUuids.Count);
+                }
+                else
+                {
+                    m_log.DebugFormat("[ARCHIVER]: Not saving assets since --noassets was specified");
                 }
-    
-                m_log.DebugFormat(
-                    "[ARCHIVER]: {0} scene objects to serialize requiring save of {1} assets",
-                    sceneObjects.Count, assetUuids.Count);
                 
                 // Make sure that we also request terrain texture assets
                 RegionSettings regionSettings = m_scene.RegionInfo.RegionSettings;
@@ -187,11 +194,14 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 // XXX: I know this is a weak way of doing it since external non-OAR aware tar executables will not do this
                 archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, CreateControlFile(options));
                 m_log.InfoFormat("[ARCHIVER]: Added control file to archive.");
-                
-                new AssetsRequest(
-                    new AssetsArchiver(archiveWriter), assetUuids, 
-                    m_scene.AssetService, m_scene.UserAccountService, 
-                    m_scene.RegionInfo.ScopeID, options, awre.ReceivedAllAssets).Execute();
+
+                if (SaveAssets)
+                    new AssetsRequest(
+                        new AssetsArchiver(archiveWriter), assetUuids,
+                        m_scene.AssetService, m_scene.UserAccountService, 
+                        m_scene.RegionInfo.ScopeID, options, awre.ReceivedAllAssets).Execute();
+                else
+                    awre.ReceivedAllAssets(new List<UUID>(), new List<UUID>());
             }
             catch (Exception) 
             {
@@ -204,9 +214,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// Create the control file for the most up to date archive
         /// </summary>
         /// <returns></returns>
-        public static string CreateControlFile(Dictionary<string, object> options)
+        public string CreateControlFile(Dictionary<string, object> options)
         {
-            int majorVersion = MAX_MAJOR_VERSION, minorVersion = 6;
+            int majorVersion = MAX_MAJOR_VERSION, minorVersion = 7;
 //
 //            if (options.ContainsKey("version"))
 //            {
@@ -258,6 +268,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             xtw.WriteElementString("datetime", ((int)t.TotalSeconds).ToString());
             xtw.WriteElementString("id", UUID.Random().ToString());
             xtw.WriteEndElement();
+
+            xtw.WriteElementString("assets_included", SaveAssets.ToString());
+
             xtw.WriteEndElement();
 
             xtw.Flush();

OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs

@@ -127,6 +127,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             OptionSet ops = new OptionSet();
 //            ops.Add("v|version=", delegate(string v) { options["version"] = v; });
             ops.Add("p|profile=", delegate(string v) { options["profile"] = v; });
+            ops.Add("noassets", delegate(string v) { options["noassets"] = v != null; });
 
             List<string> mainParams = ops.Parse(cmdparams);
 
@@ -160,7 +161,12 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
         public void ArchiveRegion(Stream saveStream, Guid requestId)
         {
-            new ArchiveWriteRequestPreparation(m_scene, saveStream, requestId).ArchiveRegion(new Dictionary<string, object>());
+            ArchiveRegion(saveStream, requestId, new Dictionary<string, object>());
+        }
+
+        public void ArchiveRegion(Stream saveStream, Guid requestId, Dictionary<string, object> options)
+        {
+            new ArchiveWriteRequestPreparation(m_scene, saveStream, requestId).ArchiveRegion(options);
         }
 
         public void DearchiveRegion(string loadPath)

OpenSim/Region/CoreModules/World/Archiver/AssetsRequest.cs

@@ -230,6 +230,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <param name="asset"></param>
         public void AssetRequestCallback(string id, object sender, AssetBase asset)
         {
+            Culture.SetCurrentCulture();
+            
             try
             {
                 lock (this)
@@ -293,6 +295,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// </summary>
         protected void PerformAssetsRequestCallback(object o)
         {
+            Culture.SetCurrentCulture();
+
             try
             {
                 m_assetsRequestCallback(m_foundAssetUuids, m_notFoundAssetUuids);

OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs

@@ -43,7 +43,6 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 using ArchiveConstants = OpenSim.Framework.Serialization.ArchiveConstants;
 using TarArchiveReader = OpenSim.Framework.Serialization.TarArchiveReader;
 using TarArchiveWriter = OpenSim.Framework.Serialization.TarArchiveWriter;
@@ -212,6 +211,89 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             // TODO: Test presence of more files and contents of files.
         }
 
+        /// <summary>
+        /// Test saving an OpenSim Region Archive with the no assets option
+        /// </summary>
+        [Test]
+        public void TestSaveOarNoAssets()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            SceneObjectPart part1 = CreateSceneObjectPart1();
+            SceneObjectGroup sog1 = new SceneObjectGroup(part1);
+            m_scene.AddNewSceneObject(sog1, false);
+
+            SceneObjectPart part2 = CreateSceneObjectPart2();
+            
+            AssetNotecard nc = new AssetNotecard();
+            nc.BodyText = "Hello World!";
+            nc.Encode();
+            UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
+            UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
+            AssetBase ncAsset
+                = AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
+            m_scene.AssetService.Store(ncAsset);
+            SceneObjectGroup sog2 = new SceneObjectGroup(part2);
+            TaskInventoryItem ncItem 
+                = new TaskInventoryItem { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid };
+            part2.Inventory.AddInventoryItem(ncItem, true);
+            
+            m_scene.AddNewSceneObject(sog2, false);
+
+            MemoryStream archiveWriteStream = new MemoryStream();
+
+            Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
+
+            Dictionary<string, Object> options = new Dictionary<string, Object>();
+            options.Add("noassets", true);
+            m_archiverModule.ArchiveRegion(archiveWriteStream, requestId, options);
+            //AssetServerBase assetServer = (AssetServerBase)scene.CommsManager.AssetCache.AssetServer;
+            //while (assetServer.HasWaitingRequests())
+            //    assetServer.ProcessNextRequest();
+
+            // Don't wait for completion - with --noassets save oar happens synchronously
+//                Monitor.Wait(this, 60000);
+
+            Assert.That(m_lastRequestId, Is.EqualTo(requestId));
+
+            byte[] archive = archiveWriteStream.ToArray();
+            MemoryStream archiveReadStream = new MemoryStream(archive);
+            TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
+
+            List<string> foundPaths = new List<string>();
+            List<string> expectedPaths = new List<string>();
+            expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog1));
+            expectedPaths.Add(ArchiveHelpers.CreateObjectPath(sog2));
+
+            string filePath;
+            TarArchiveReader.TarEntryType tarEntryType;         
+
+            byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
+            Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
+            
+            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, false, false, Guid.Empty);
+            arr.LoadControlFile(filePath, data);
+            
+            Assert.That(arr.ControlFileLoaded, Is.True);        
+            
+            while (tar.ReadEntry(out filePath, out tarEntryType) != null)
+            {
+                if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
+                {
+                    Assert.Fail("Asset was found in saved oar of TestSaveOarNoAssets()");
+                }
+                else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
+                {
+                    foundPaths.Add(filePath);
+                }
+            }
+
+            Assert.That(foundPaths, Is.EquivalentTo(expectedPaths));
+
+            // TODO: Test presence of more files and contents of files.
+        }
+
         /// <summary>
         /// Test loading an OpenSim Region Archive.
         /// </summary>
@@ -231,7 +313,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             // upset load
             tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
             
-            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestPreparation.CreateControlFile(new Dictionary<string, Object>()));
+            tar.WriteFile(
+                ArchiveConstants.CONTROL_FILE_PATH,
+                new ArchiveWriteRequestPreparation(null, (Stream)null, Guid.Empty).CreateControlFile(new Dictionary<string, Object>()));
 
             SceneObjectPart part1 = CreateSceneObjectPart1();
             SceneObjectGroup object1 = new SceneObjectGroup(part1);
@@ -313,6 +397,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             Assert.That(loadedSoundAsset, Is.Not.Null, "loaded sound asset was null");
             Assert.That(loadedSoundAsset.Data, Is.EqualTo(soundData), "saved and loaded sound data do not match");
 
+            Assert.Greater(m_scene.LandChannel.AllParcels().Count, 0, "incorrect number of parcels");
+
             // Temporary
             Console.WriteLine("Successfully completed {0}", MethodBase.GetCurrentMethod());
         }
@@ -330,7 +416,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             TarArchiveWriter tar = new TarArchiveWriter(archiveWriteStream);
             
             tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
-            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestPreparation.CreateControlFile(new Dictionary<string, Object>()));
+            tar.WriteFile(
+                ArchiveConstants.CONTROL_FILE_PATH,
+                new ArchiveWriteRequestPreparation(null, (Stream)null, Guid.Empty).CreateControlFile(new Dictionary<string, Object>()));
 
             RegionSettings rs = new RegionSettings();
             rs.AgentLimit = 17;

OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs

@@ -520,8 +520,12 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
         }
 
+        /// <summary>
+        /// Like handleEventManagerOnSignificantClientMovement, but called with an AgentUpdate regardless of distance.
+        /// </summary>
+        /// <param name="avatar"></param>
         public void EventManagerOnClientMovement(ScenePresence avatar)
-        //Like handleEventManagerOnSignificantClientMovement, but called with an AgentUpdate regardless of distance.
+        //
         {
             ILandObject over = GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
             if (over != null)
@@ -534,7 +538,6 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
         }
 
-
         public void ClientOnParcelAccessListRequest(UUID agentID, UUID sessionID, uint flags, int sequenceID,
                                                     int landLocalID, IClientAPI remote_client)
         {
@@ -668,14 +671,14 @@ namespace OpenSim.Region.CoreModules.World.Land
                     //m_scene.SimulationDataService.RemoveLandObject(lo.LandData.GlobalID);
                     m_scene.EventManager.TriggerLandObjectRemoved(lo.LandData.GlobalID);
                 }
-                
+
                 m_landList.Clear();
+
+                ResetSimLandObjects();
+
+                if (setupDefaultParcel)
+                    CreateDefaultParcel();
             }
-            
-            ResetSimLandObjects();
-            
-            if (setupDefaultParcel)
-                CreateDefaultParcel();
         }
 
         private void performFinalLandJoin(ILandObject master, ILandObject slave)
@@ -1391,8 +1394,11 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         public void EventManagerOnNoLandDataFromStorage()
         {
-            ResetSimLandObjects();
-            CreateDefaultParcel();
+            lock (m_landList)
+            {
+                ResetSimLandObjects();
+                CreateDefaultParcel();
+            }
         }
 
         #endregion

OpenSim/Region/CoreModules/World/Land/LandObject.cs

@@ -67,7 +67,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         public int GetPrimsFree()
         {
             m_scene.EventManager.TriggerParcelPrimCountUpdate();
-            int free = GetSimulatorMaxPrimCount(this) - m_landData.SimwidePrims;
+            int free = GetSimulatorMaxPrimCount() - m_landData.SimwidePrims;
             return free;
         }
 
@@ -181,11 +181,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             overrideSimulatorMaxPrimCount = overrideDel;
         }
 
-        public int GetParcelMaxPrimCount(ILandObject thisObject)
+        public int GetParcelMaxPrimCount()
         {
             if (overrideParcelMaxPrimCount != null)
             {
-                return overrideParcelMaxPrimCount(thisObject);
+                return overrideParcelMaxPrimCount(this);
             }
             else
             {
@@ -197,11 +197,12 @@ namespace OpenSim.Region.CoreModules.World.Land
                 return parcelMax;
             }
         }
-        public int GetSimulatorMaxPrimCount(ILandObject thisObject)
+
+        public int GetSimulatorMaxPrimCount()
         {
             if (overrideSimulatorMaxPrimCount != null)
             {
-                return overrideSimulatorMaxPrimCount(thisObject);
+                return overrideSimulatorMaxPrimCount(this);
             }
             else
             {
@@ -244,8 +245,8 @@ namespace OpenSim.Region.CoreModules.World.Land
             remote_client.SendLandProperties(seq_id,
                     snap_selection, request_result, this,
                     (float)m_scene.RegionInfo.RegionSettings.ObjectBonus,
-                    GetParcelMaxPrimCount(this),
-                    GetSimulatorMaxPrimCount(this), regionFlags);
+                    GetParcelMaxPrimCount(),
+                    GetSimulatorMaxPrimCount(), regionFlags);
         }
 
         public void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client)

OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs

@@ -37,7 +37,6 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.World.Land.Tests
 {

OpenSim/Region/CoreModules/World/Media/Moap/Tests/MoapTests.cs

@@ -40,7 +40,6 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.World.Media.Moap.Tests
 {

OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs

@@ -548,18 +548,18 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
             // libomv will moan about PrimFlags.ObjectYouOfficer being
             // deprecated
-            #pragma warning disable 0612 
+#pragma warning disable 0612
             objflags &= (uint)
                 ~(PrimFlags.ObjectCopy | // Tells client you can copy the object
-                  PrimFlags.ObjectModify | // tells client you can modify the object
-                  PrimFlags.ObjectMove |   // tells client that you can move the object (only, no mod)
-                  PrimFlags.ObjectTransfer | // tells the client that you can /take/ the object if you don't own it
-                  PrimFlags.ObjectYouOwner | // Tells client that you're the owner of the object
-                  PrimFlags.ObjectAnyOwner | // Tells client that someone owns the object
-                  PrimFlags.ObjectOwnerModify | // Tells client that you're the owner of the object
-                  PrimFlags.ObjectYouOfficer // Tells client that you've got group object editing permission. Used when ObjectGroupOwned is set
+                    PrimFlags.ObjectModify | // tells client you can modify the object
+                    PrimFlags.ObjectMove |   // tells client that you can move the object (only, no mod)
+                    PrimFlags.ObjectTransfer | // tells the client that you can /take/ the object if you don't own it
+                    PrimFlags.ObjectYouOwner | // Tells client that you're the owner of the object
+                    PrimFlags.ObjectAnyOwner | // Tells client that someone owns the object
+                    PrimFlags.ObjectOwnerModify | // Tells client that you're the owner of the object
+                    PrimFlags.ObjectYouOfficer // Tells client that you've got group object editing permission. Used when ObjectGroupOwned is set
                     );
-            #pragma warning restore 0612
+#pragma warning restore 0612
 
             // Creating the three ObjectFlags options for this method to choose from.
             // Customize the OwnerMask
@@ -576,22 +576,27 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
             if (m_bypassPermissions)
                 return objectOwnerMask;
-        
+
             // Object owners should be able to edit their own content
             if (user == objectOwner)
                 return objectOwnerMask;
-            
-            if (IsFriendWithPerms(user, objectOwner))
-                return objectOwnerMask;
 
+            if (IsFriendWithPerms(user, objectOwner))
+            {
+                return objectOwnerMask;
+            }
             // Estate users should be able to edit anything in the sim if RegionOwnerIsGod is set
             if (m_RegionOwnerIsGod && IsEstateManager(user) && !IsAdministrator(objectOwner))
+            {
                 return objectOwnerMask;
+            }
 
             // Admin should be able to edit anything in the sim (including admin objects)
             if (IsAdministrator(user))
+            {
                 return objectOwnerMask;
-            
+            }
+
             // Users should be able to edit what is over their land.
             Vector3 taskPos = task.AbsolutePosition;
             ILandObject parcel = m_scene.LandChannel.GetLandObject(taskPos.X, taskPos.Y);
@@ -599,13 +604,15 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             {
                 // Admin objects should not be editable by the above
                 if (!IsAdministrator(objectOwner))
+                {
                     return objectOwnerMask;
+                }
             }
 
             // Group permissions
             if ((task.GroupID != UUID.Zero) && IsGroupMember(task.GroupID, user, 0))
                 return objectGroupMask | objectEveryoneMask;
-        
+
             return objectEveryoneMask;
         }
 
@@ -673,7 +680,6 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             //
             // Nobody but the object owner can set permissions on an object
             //
-
             if (locked && (!IsAdministrator(currentUser)) && denyOnLocked)
             {
                 return false;
@@ -704,6 +710,11 @@ namespace OpenSim.Region.CoreModules.World.Permissions
                 // Return immediately, so that the administrator can shares group objects
                 return true;
             }
+
+            // Friends with benefits should be able to edit the objects too
+            if (IsFriendWithPerms(currentUser, objectOwner))
+                // Return immediately, so that the administrator can share objects with friends
+                return true;
         
             // Users should be able to edit what is over their land.
             ILandObject parcel = m_scene.LandChannel.GetLandObject(group.AbsolutePosition.X, group.AbsolutePosition.Y);

OpenSim/Region/CoreModules/World/Region/RestartModule.cs

@@ -70,14 +70,14 @@ namespace OpenSim.Region.CoreModules.World.Region
                     false, "region restart bluebox",
                     "region restart bluebox <message> <delta seconds>+",
                     "Schedule a region restart", 
-                    "Schedule a region restart after a given number of seconds.  If one delta is given then the region is restarted in delta seconds time.  A time to restart is sent to users in the region as a transient notice.  If multiple deltas are given then a notice is sent when we reach each delta.",
+                    "Schedule a region restart after a given number of seconds.  If one delta is given then the region is restarted in delta seconds time.  A time to restart is sent to users in the region as a dismissable bluebox notice.  If multiple deltas are given then a notice is sent when we reach each delta.",
                     HandleRegionRestart);
             
             MainConsole.Instance.Commands.AddCommand("RestartModule",
                     false, "region restart notice",
                     "region restart notice <message> <delta seconds>+",
                     "Schedule a region restart", 
-                    "Schedule a region restart after a given number of seconds.  If one delta is given then the region is restarted in delta seconds time.  A time to restart is sent to users in the region as a dismissable bluebox notice.  If multiple deltas are given then a notice is sent when we reach each delta.",
+                    "Schedule a region restart after a given number of seconds.  If one delta is given then the region is restarted in delta seconds time.  A time to restart is sent to users in the region as a transient notice.  If multiple deltas are given then a notice is sent when we reach each delta.",
                     HandleRegionRestart);
             
             MainConsole.Instance.Commands.AddCommand("RestartModule",

OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs

@@ -35,7 +35,6 @@ using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.CoreModules.World.Serialiser.Tests
 {

OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs

@@ -208,52 +208,65 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
             //m_log.DebugFormat("[MAPLAYER]: path: {0}, param: {1}, agent:{2}",
             //                  path, param, agentID.ToString());
 
-            // this is here because CAPS map requests work even beyond the 10,000 limit.
-            ScenePresence avatarPresence = null;
+            // There is a major hack going on in this method. The viewer doesn't request
+            // map blocks (RequestMapBlocks) above 2048. That means that if we don't hack,
+            // grids above that cell don't have a map at all. So, here's the hack: we wait
+            // for this CAP request to come, and we inject the map blocks at this point. 
+            // In a normal scenario, this request simply sends back the MapLayer (the blue color).
+            // In the hacked scenario, it also sends the map blocks via UDP.
+            //
+            // 6/8/2011 -- I'm adding an explicit 2048 check, so that we never forget that there is
+            // a hack here, and so that regions below 4096 don't get spammed with unnecessary map blocks.
 
-            m_scene.TryGetScenePresence(agentID, out avatarPresence);
-
-            if (avatarPresence != null)
+            if (m_scene.RegionInfo.RegionLocX >= 2048 || m_scene.RegionInfo.RegionLocY >= 2048)
             {
-                bool lookup = false;
+                ScenePresence avatarPresence = null;
 
-                lock (cachedMapBlocks)
+                m_scene.TryGetScenePresence(agentID, out avatarPresence);
+
+                if (avatarPresence != null)
                 {
-                    if (cachedMapBlocks.Count > 0 && ((cachedTime + 1800) > Util.UnixTimeSinceEpoch()))
-                    {
-                        List<MapBlockData> mapBlocks;
-
-                        mapBlocks = cachedMapBlocks;
-                        avatarPresence.ControllingClient.SendMapBlock(mapBlocks, 0);
-                    }
-                    else
-                    {
-                        lookup = true;
-                    }
-                }
-                if (lookup)
-                {
-                    List<MapBlockData> mapBlocks = new List<MapBlockData>(); ;
-
-                    List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                        (int)(m_scene.RegionInfo.RegionLocX - 8) * (int)Constants.RegionSize,
-                        (int)(m_scene.RegionInfo.RegionLocX + 8) * (int)Constants.RegionSize,
-                        (int)(m_scene.RegionInfo.RegionLocY - 8) * (int)Constants.RegionSize,
-                        (int)(m_scene.RegionInfo.RegionLocY + 8) * (int)Constants.RegionSize);
-                    foreach (GridRegion r in regions)
-                    {
-                        MapBlockData block = new MapBlockData();
-                        MapBlockFromGridRegion(block, r);
-                        mapBlocks.Add(block);
-                    }
-                    avatarPresence.ControllingClient.SendMapBlock(mapBlocks, 0);
+                    bool lookup = false;
 
                     lock (cachedMapBlocks)
-                        cachedMapBlocks = mapBlocks;
+                    {
+                        if (cachedMapBlocks.Count > 0 && ((cachedTime + 1800) > Util.UnixTimeSinceEpoch()))
+                        {
+                            List<MapBlockData> mapBlocks;
 
-                    cachedTime = Util.UnixTimeSinceEpoch();
+                            mapBlocks = cachedMapBlocks;
+                            avatarPresence.ControllingClient.SendMapBlock(mapBlocks, 0);
+                        }
+                        else
+                        {
+                            lookup = true;
+                        }
+                    }
+                    if (lookup)
+                    {
+                        List<MapBlockData> mapBlocks = new List<MapBlockData>(); ;
+
+                        List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
+                            (int)(m_scene.RegionInfo.RegionLocX - 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.RegionLocX + 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.RegionLocY - 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.RegionLocY + 8) * (int)Constants.RegionSize);
+                        foreach (GridRegion r in regions)
+                        {
+                            MapBlockData block = new MapBlockData();
+                            MapBlockFromGridRegion(block, r);
+                            mapBlocks.Add(block);
+                        }
+                        avatarPresence.ControllingClient.SendMapBlock(mapBlocks, 0);
+
+                        lock (cachedMapBlocks)
+                            cachedMapBlocks = mapBlocks;
+
+                        cachedTime = Util.UnixTimeSinceEpoch();
+                    }
                 }
             }
+
             LLSDMapLayerResponse mapResponse = new LLSDMapLayerResponse();
             mapResponse.LayerData.Array.Add(GetOSDMapLayerResponse());
             return mapResponse.ToString();

OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs

@@ -540,7 +540,7 @@ namespace OpenSim.Region.Examples.SimpleModule
         {
         }
 
-        public virtual void SendDialog(string objectname, UUID objectID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
+        public virtual void SendDialog(string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
         {
         }
 

OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs

@@ -40,6 +40,9 @@ namespace OpenSim.Region.Framework.Interfaces
         void Teleport(ScenePresence agent, ulong regionHandle, Vector3 position,
                                                       Vector3 lookAt, uint teleportFlags);
 
+        void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination,
+            Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq);
+
         void TeleportHome(UUID id, IClientAPI client);
 
         bool Cross(ScenePresence agent, bool isFlying);

OpenSim/Region/Framework/Interfaces/IFriendsModule.cs

@@ -34,6 +34,6 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IFriendsModule
     {
         uint GetFriendPerms(UUID PrincipalID, UUID FriendID);
-        void SendFriendsOnlineIfNeeded(IClientAPI client);
+        bool SendFriendsOnlineIfNeeded(IClientAPI client);
     }
 }

OpenSim/Region/Framework/Interfaces/IRegionArchiverModule.cs

@@ -52,31 +52,44 @@ namespace OpenSim.Region.Framework.Interfaces
         /// <summary>
         /// Archive the region to the given path
         /// </summary>
-        /// 
+        /// <remarks>
         /// This method occurs asynchronously.  If you want notification of when it has completed then subscribe to
         /// the EventManager.OnOarFileSaved event.
-        /// 
+        /// </remarks>
         /// <param name="savePath"></param>
         /// <param name="requestId">If supplied, this request Id is later returned in the saved event</param>
+        /// <param name="options">Options for the save</param>
         void ArchiveRegion(string savePath, Guid requestId, Dictionary<string, object> options);
 
         /// <summary>
         /// Archive the region to a stream.
         /// </summary>
-        /// 
+        /// <remarks>
         /// This method occurs asynchronously.  If you want notification of when it has completed then subscribe to
         /// the EventManager.OnOarFileSaved event.
-        /// 
+        /// </remarks>
         /// <param name="saveStream"></param>
         /// <param name="requestId">If supplied, this request Id is later returned in the saved event</param>
         void ArchiveRegion(Stream saveStream, Guid requestId);
 
+        /// <summary>
+        /// Archive the region to a stream.
+        /// </summary>
+        /// <remarks>
+        /// This method occurs asynchronously.  If you want notification of when it has completed then subscribe to
+        /// the EventManager.OnOarFileSaved event.
+        /// </remarks>
+        /// <param name="saveStream"></param>
+        /// <param name="requestId">If supplied, this request Id is later returned in the saved event</param>
+        /// <param name="options">Options for the save</param>
+        void ArchiveRegion(Stream saveStream, Guid requestId, Dictionary<string, object> options);
+
         /// <summary>
         /// Dearchive the given region archive.  This replaces the existing scene.
         /// </summary>
-        /// 
+        /// <remarks>
         /// If you want notification of when it has completed then subscribe to the EventManager.OnOarFileLoaded event.
-        /// 
+        /// </remarks>
         /// <param name="loadPath"></param>
         void DearchiveRegion(string loadPath);
         

OpenSim/Region/Framework/Interfaces/IScriptModule.cs

@@ -50,5 +50,7 @@ namespace OpenSim.Region.Framework.Interfaces
         void ResumeScript(UUID itemID);
 
         ArrayList GetScriptErrors(UUID itemID);
+
+        void SaveAllState();
     }
 }

OpenSim/Region/Framework/Interfaces/IUserManagement.cs

@@ -8,6 +8,9 @@ namespace OpenSim.Region.Framework.Interfaces
     public interface IUserManagement
     {
         string GetUserName(UUID uuid);
+        string GetUserHomeURL(UUID uuid);
+        string GetUserUUI(UUID uuid);
+        string GetUserServerURL(UUID uuid, string serverType);
         void AddUser(UUID uuid, string userData);
         void AddUser(UUID uuid, string firstName, string lastName, string profileURL);
     }

OpenSim/Region/Framework/Scenes/EventManager.cs

@@ -111,6 +111,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
 
+        public delegate void SceneShuttingDownDelegate(Scene scene);
+
+        public event SceneShuttingDownDelegate OnSceneShuttingDown;
+
         /// <summary>
         /// Fired when an object is touched/grabbed.
         /// </summary>
@@ -385,6 +389,12 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void RegionUp(GridRegion region);
         public event RegionUp OnRegionUp;
 
+        public delegate void LoginsEnabled(string regionName);
+        public event LoginsEnabled OnLoginsEnabled;
+
+        public delegate void PrimsLoaded(Scene s);
+        public event PrimsLoaded OnPrimsLoaded;
+
         public class MoneyTransferArgs : EventArgs
         {
             public UUID sender;
@@ -2193,5 +2203,68 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         }
+
+        public void TriggerSceneShuttingDown(Scene s)
+        {
+            SceneShuttingDownDelegate handler = OnSceneShuttingDown;
+            if (handler != null)
+            {
+                foreach (SceneShuttingDownDelegate d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(s);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerSceneShuttingDown failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
+
+        public void TriggerLoginsEnabled (string regionName)
+        {
+            LoginsEnabled handler = OnLoginsEnabled;
+
+            if ( handler != null)
+            {
+                foreach (LoginsEnabled d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(regionName);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[EVENT MANAGER]: Delegate for LoginsEnabled failed - continuing {0} - {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
+
+        public void TriggerPrimsLoaded(Scene s)
+        {
+            PrimsLoaded handler = OnPrimsLoaded;
+
+            if (handler != null)
+            {
+                foreach (PrimsLoaded d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(s);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[EVENT MANAGER]: Delegate for PrimsLoaded failed - continuing {0} - {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
     }
 }

OpenSim/Region/Framework/Scenes/Scene.Inventory.cs

@@ -425,192 +425,198 @@ namespace OpenSim.Region.Framework.Scenes
             InventoryItemBase item = new InventoryItemBase(itemId, senderId);
             item = InventoryService.GetItem(item);
 
-            if ((item != null) && (item.Owner == senderId))
+            if (item == null)
             {
-                IUserManagement uman = RequestModuleInterface<IUserManagement>();
-                if (uman != null)
-                    uman.AddUser(item.CreatorIdAsUuid, item.CreatorData);
-
-                if (!Permissions.BypassPermissions())
-                {
-                    if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
-                        return null;
-                }
-
-                // Insert a copy of the item into the recipient
-                InventoryItemBase itemCopy = new InventoryItemBase();
-                itemCopy.Owner = recipient;
-                itemCopy.CreatorId = item.CreatorId;
-                itemCopy.CreatorData = item.CreatorData;
-                itemCopy.ID = UUID.Random();
-                itemCopy.AssetID = item.AssetID;
-                itemCopy.Description = item.Description;
-                itemCopy.Name = item.Name;
-                itemCopy.AssetType = item.AssetType;
-                itemCopy.InvType = item.InvType;
-                itemCopy.Folder = recipientFolderId;
-
-                if (Permissions.PropagatePermissions() && recipient != senderId)
-                {
-                    // Trying to do this right this time. This is evil. If
-                    // you believe in Good, go elsewhere. Vampires and other
-                    // evil creatores only beyond this point. You have been
-                    // warned.
-
-                    // We're going to mask a lot of things by the next perms
-                    // Tweak the next perms to be nicer to our data
-                    //
-                    // In this mask, all the bits we do NOT want to mess
-                    // with are set. These are:
-                    //
-                    // Transfer
-                    // Copy
-                    // Modufy
-                    uint permsMask = ~ ((uint)PermissionMask.Copy |
-                                        (uint)PermissionMask.Transfer |
-                                        (uint)PermissionMask.Modify);
-
-                    // Now, reduce the next perms to the mask bits
-                    // relevant to the operation
-                    uint nextPerms = permsMask | (item.NextPermissions &
-                                      ((uint)PermissionMask.Copy |
-                                       (uint)PermissionMask.Transfer |
-                                       (uint)PermissionMask.Modify));
-
-                    // nextPerms now has all bits set, except for the actual
-                    // next permission bits.
-
-                    // This checks for no mod, no copy, no trans.
-                    // This indicates an error or messed up item. Do it like
-                    // SL and assume trans
-                    if (nextPerms == permsMask)
-                        nextPerms |= (uint)PermissionMask.Transfer;
-
-                    // Inventory owner perms are the logical AND of the
-                    // folded perms and the root prim perms, however, if
-                    // the root prim is mod, the inventory perms will be
-                    // mod. This happens on "take" and is of little concern
-                    // here, save for preventing escalation
-
-                    // This hack ensures that items previously permalocked
-                    // get unlocked when they're passed or rezzed
-                    uint basePerms = item.BasePermissions |
-                                    (uint)PermissionMask.Move;
-                    uint ownerPerms = item.CurrentPermissions;
-
-                    // If this is an object, root prim perms may be more
-                    // permissive than folded perms. Use folded perms as
-                    // a mask
-                    if (item.InvType == (int)InventoryType.Object)
-                    {
-                        // Create a safe mask for the current perms
-                        uint foldedPerms = (item.CurrentPermissions & 7) << 13;
-                        foldedPerms |= permsMask;
-
-                        bool isRootMod = (item.CurrentPermissions &
-                                          (uint)PermissionMask.Modify) != 0 ?
-                                          true : false;
-
-                        // Mask the owner perms to the folded perms
-                        ownerPerms &= foldedPerms;
-                        basePerms &= foldedPerms;
-
-                        // If the root was mod, let the mask reflect that
-                        // We also need to adjust the base here, because
-                        // we should be able to edit in-inventory perms
-                        // for the root prim, if it's mod.
-                        if (isRootMod)
-                        {
-                            ownerPerms |= (uint)PermissionMask.Modify;
-                            basePerms |= (uint)PermissionMask.Modify;
-                        }
-                    }
-
-                    // These will be applied to the root prim at next rez.
-                    // The slam bit (bit 3) and folded permission (bits 0-2)
-                    // are preserved due to the above mangling
-                    ownerPerms &= nextPerms;
-
-                    // Mask the base permissions. This is a conservative
-                    // approach altering only the three main perms
-                    basePerms &= nextPerms;
-
-                    // Assign to the actual item. Make sure the slam bit is
-                    // set, if it wasn't set before.
-                    itemCopy.BasePermissions = basePerms;
-                    itemCopy.CurrentPermissions = ownerPerms;
-                    itemCopy.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
-
-                    itemCopy.NextPermissions = item.NextPermissions;
-
-                    // This preserves "everyone can move"
-                    itemCopy.EveryOnePermissions = item.EveryOnePermissions &
-                                                   nextPerms;
-
-                    // Intentionally killing "share with group" here, as
-                    // the recipient will not have the group this is
-                    // set to
-                    itemCopy.GroupPermissions = 0;
-                }
-                else
-                {
-                    itemCopy.CurrentPermissions = item.CurrentPermissions;
-                    itemCopy.NextPermissions = item.NextPermissions;
-                    itemCopy.EveryOnePermissions = item.EveryOnePermissions & item.NextPermissions;
-                    itemCopy.GroupPermissions = item.GroupPermissions & item.NextPermissions;
-                    itemCopy.BasePermissions = item.BasePermissions;
-                }
-                
-                if (itemCopy.Folder == UUID.Zero)
-                {
-                    InventoryFolderBase folder = InventoryService.GetFolderForType(recipient, (AssetType)itemCopy.AssetType);
-
-                    if (folder != null)
-                    {
-                        itemCopy.Folder = folder.ID;
-                    }
-                    else
-                    {
-                        InventoryFolderBase root = InventoryService.GetRootFolder(recipient);
-
-                        if (root != null)
-                            itemCopy.Folder = root.ID;
-                        else
-                            return null; // No destination
-                    }
-                }
-
-                itemCopy.GroupID = UUID.Zero;
-                itemCopy.GroupOwned = false;
-                itemCopy.Flags = item.Flags;
-                itemCopy.SalePrice = item.SalePrice;
-                itemCopy.SaleType = item.SaleType;
-
-                if (AddInventoryItem(itemCopy))
-                {
-                    IInventoryAccessModule invAccess = RequestModuleInterface<IInventoryAccessModule>();
-                    if (invAccess != null)
-                        invAccess.TransferInventoryAssets(itemCopy, senderId, recipient);
-                }
-
-                if (!Permissions.BypassPermissions())
-                {
-                    if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
-                    {
-                        List<UUID> items = new List<UUID>();
-                        items.Add(itemId);
-                        InventoryService.DeleteItems(senderId, items);
-                    }
-                }
-
-                return itemCopy;
-            }
-            else
-            {
-                m_log.WarnFormat("[AGENT INVENTORY]: Failed to find item {0} or item does not belong to giver ", itemId);
+                m_log.WarnFormat(
+                    "[AGENT INVENTORY]: Failed to find item {0} sent by {1} to {2}", itemId, senderId, recipient);
                 return null;
             }
 
+            if (item.Owner != senderId)
+            {
+                m_log.WarnFormat(
+                    "[AGENT INVENTORY]: Attempt to send item {0} {1} to {2} failed because sender {3} did not match item owner {4}",
+                    item.Name, item.ID, recipient, senderId, item.Owner);
+                return null;
+            }
+
+            IUserManagement uman = RequestModuleInterface<IUserManagement>();
+            if (uman != null)
+                uman.AddUser(item.CreatorIdAsUuid, item.CreatorData);
+
+            if (!Permissions.BypassPermissions())
+            {
+                if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
+                    return null;
+            }
+
+            // Insert a copy of the item into the recipient
+            InventoryItemBase itemCopy = new InventoryItemBase();
+            itemCopy.Owner = recipient;
+            itemCopy.CreatorId = item.CreatorId;
+            itemCopy.CreatorData = item.CreatorData;
+            itemCopy.ID = UUID.Random();
+            itemCopy.AssetID = item.AssetID;
+            itemCopy.Description = item.Description;
+            itemCopy.Name = item.Name;
+            itemCopy.AssetType = item.AssetType;
+            itemCopy.InvType = item.InvType;
+            itemCopy.Folder = recipientFolderId;
+
+            if (Permissions.PropagatePermissions() && recipient != senderId)
+            {
+                // Trying to do this right this time. This is evil. If
+                // you believe in Good, go elsewhere. Vampires and other
+                // evil creatores only beyond this point. You have been
+                // warned.
+
+                // We're going to mask a lot of things by the next perms
+                // Tweak the next perms to be nicer to our data
+                //
+                // In this mask, all the bits we do NOT want to mess
+                // with are set. These are:
+                //
+                // Transfer
+                // Copy
+                // Modufy
+                uint permsMask = ~ ((uint)PermissionMask.Copy |
+                                    (uint)PermissionMask.Transfer |
+                                    (uint)PermissionMask.Modify);
+
+                // Now, reduce the next perms to the mask bits
+                // relevant to the operation
+                uint nextPerms = permsMask | (item.NextPermissions &
+                                  ((uint)PermissionMask.Copy |
+                                   (uint)PermissionMask.Transfer |
+                                   (uint)PermissionMask.Modify));
+
+                // nextPerms now has all bits set, except for the actual
+                // next permission bits.
+
+                // This checks for no mod, no copy, no trans.
+                // This indicates an error or messed up item. Do it like
+                // SL and assume trans
+                if (nextPerms == permsMask)
+                    nextPerms |= (uint)PermissionMask.Transfer;
+
+                // Inventory owner perms are the logical AND of the
+                // folded perms and the root prim perms, however, if
+                // the root prim is mod, the inventory perms will be
+                // mod. This happens on "take" and is of little concern
+                // here, save for preventing escalation
+
+                // This hack ensures that items previously permalocked
+                // get unlocked when they're passed or rezzed
+                uint basePerms = item.BasePermissions |
+                                (uint)PermissionMask.Move;
+                uint ownerPerms = item.CurrentPermissions;
+
+                // If this is an object, root prim perms may be more
+                // permissive than folded perms. Use folded perms as
+                // a mask
+                if (item.InvType == (int)InventoryType.Object)
+                {
+                    // Create a safe mask for the current perms
+                    uint foldedPerms = (item.CurrentPermissions & 7) << 13;
+                    foldedPerms |= permsMask;
+
+                    bool isRootMod = (item.CurrentPermissions &
+                                      (uint)PermissionMask.Modify) != 0 ?
+                                      true : false;
+
+                    // Mask the owner perms to the folded perms
+                    ownerPerms &= foldedPerms;
+                    basePerms &= foldedPerms;
+
+                    // If the root was mod, let the mask reflect that
+                    // We also need to adjust the base here, because
+                    // we should be able to edit in-inventory perms
+                    // for the root prim, if it's mod.
+                    if (isRootMod)
+                    {
+                        ownerPerms |= (uint)PermissionMask.Modify;
+                        basePerms |= (uint)PermissionMask.Modify;
+                    }
+                }
+
+                // These will be applied to the root prim at next rez.
+                // The slam bit (bit 3) and folded permission (bits 0-2)
+                // are preserved due to the above mangling
+                ownerPerms &= nextPerms;
+
+                // Mask the base permissions. This is a conservative
+                // approach altering only the three main perms
+                basePerms &= nextPerms;
+
+                // Assign to the actual item. Make sure the slam bit is
+                // set, if it wasn't set before.
+                itemCopy.BasePermissions = basePerms;
+                itemCopy.CurrentPermissions = ownerPerms;
+                itemCopy.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
+
+                itemCopy.NextPermissions = item.NextPermissions;
+
+                // This preserves "everyone can move"
+                itemCopy.EveryOnePermissions = item.EveryOnePermissions &
+                                               nextPerms;
+
+                // Intentionally killing "share with group" here, as
+                // the recipient will not have the group this is
+                // set to
+                itemCopy.GroupPermissions = 0;
+            }
+            else
+            {
+                itemCopy.CurrentPermissions = item.CurrentPermissions;
+                itemCopy.NextPermissions = item.NextPermissions;
+                itemCopy.EveryOnePermissions = item.EveryOnePermissions & item.NextPermissions;
+                itemCopy.GroupPermissions = item.GroupPermissions & item.NextPermissions;
+                itemCopy.BasePermissions = item.BasePermissions;
+            }
+            
+            if (itemCopy.Folder == UUID.Zero)
+            {
+                InventoryFolderBase folder = InventoryService.GetFolderForType(recipient, (AssetType)itemCopy.AssetType);
+
+                if (folder != null)
+                {
+                    itemCopy.Folder = folder.ID;
+                }
+                else
+                {
+                    InventoryFolderBase root = InventoryService.GetRootFolder(recipient);
+
+                    if (root != null)
+                        itemCopy.Folder = root.ID;
+                    else
+                        return null; // No destination
+                }
+            }
+
+            itemCopy.GroupID = UUID.Zero;
+            itemCopy.GroupOwned = false;
+            itemCopy.Flags = item.Flags;
+            itemCopy.SalePrice = item.SalePrice;
+            itemCopy.SaleType = item.SaleType;
+
+            if (AddInventoryItem(itemCopy))
+            {
+                IInventoryAccessModule invAccess = RequestModuleInterface<IInventoryAccessModule>();
+                if (invAccess != null)
+                    invAccess.TransferInventoryAssets(itemCopy, senderId, recipient);
+            }
+
+            if (!Permissions.BypassPermissions())
+            {
+                if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
+                {
+                    List<UUID> items = new List<UUID>();
+                    items.Add(itemId);
+                    InventoryService.DeleteItems(senderId, items);
+                }
+            }
+
+            return itemCopy;
         }
 
         /// <summary>
@@ -778,7 +784,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="asset"></param>
         /// <param name="invType"></param>
         /// <param name="nextOwnerMask"></param>
-        private void CreateNewInventoryItem(IClientAPI remoteClient, string creatorID, string creatorData, UUID folderID, string name, uint flags, uint callbackID,
+        public void CreateNewInventoryItem(IClientAPI remoteClient, string creatorID, string creatorData, UUID folderID, string name, uint flags, uint callbackID,
                                             AssetBase asset, sbyte invType, uint nextOwnerMask, int creationDate)
         {
             CreateNewInventoryItem(
@@ -832,78 +838,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        /// <summary>
-        /// Create a new inventory item.  Called when the client creates a new item directly within their
-        /// inventory (e.g. by selecting a context inventory menu option).
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        /// <param name="transactionID"></param>
-        /// <param name="folderID"></param>
-        /// <param name="callbackID"></param>
-        /// <param name="description"></param>
-        /// <param name="name"></param>
-        /// <param name="invType"></param>
-        /// <param name="type"></param>
-        /// <param name="wearableType"></param>
-        /// <param name="nextOwnerMask"></param>
-        public void CreateNewInventoryItem(IClientAPI remoteClient, UUID transactionID, UUID folderID,
-                                           uint callbackID, string description, string name, sbyte invType,
-                                           sbyte assetType,
-                                           byte wearableType, uint nextOwnerMask, int creationDate)
-        {
-            m_log.DebugFormat("[AGENT INVENTORY]: Received request to create inventory item {0} in folder {1}", name, folderID);
-
-            if (!Permissions.CanCreateUserInventory(invType, remoteClient.AgentId))
-                return;
-
-            InventoryFolderBase f = new InventoryFolderBase(folderID, remoteClient.AgentId);
-            InventoryFolderBase folder = InventoryService.GetFolder(f);
-
-            if (folder == null || folder.Owner != remoteClient.AgentId)
-                return;
-
-            if (transactionID == UUID.Zero)
-            {
-                ScenePresence presence;
-                if (TryGetScenePresence(remoteClient.AgentId, out presence))
-                {
-                    byte[] data = null;
-
-                    if (invType == (sbyte)InventoryType.Landmark && presence != null)
-                    {
-                        Vector3 pos = presence.AbsolutePosition;
-                        string strdata = String.Format(
-                            "Landmark version 2\nregion_id {0}\nlocal_pos {1} {2} {3}\nregion_handle {4}\n",
-                            presence.Scene.RegionInfo.RegionID,
-                            pos.X, pos.Y, pos.Z,
-                            presence.RegionHandle);
-                        data = Encoding.ASCII.GetBytes(strdata);
-                    }
-
-                    AssetBase asset = CreateAsset(name, description, assetType, data, remoteClient.AgentId);
-                    AssetService.Store(asset);
-
-                    CreateNewInventoryItem(remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID, asset.Name, 0, callbackID, asset, invType, nextOwnerMask, creationDate);
-                }
-                else
-                {
-                    m_log.ErrorFormat(
-                        "ScenePresence for agent uuid {0} unexpectedly not found in CreateNewInventoryItem",
-                        remoteClient.AgentId);
-                }
-            }
-            else
-            {
-                IAgentAssetTransactions agentTransactions = this.RequestModuleInterface<IAgentAssetTransactions>();
-                if (agentTransactions != null)
-                {
-                    agentTransactions.HandleItemCreationFromTransaction(
-                        remoteClient, transactionID, folderID, callbackID, description,
-                        name, invType, assetType, wearableType, nextOwnerMask);
-                }
-            }
-        }
-
         /// <summary>
         /// Link an inventory item to an existing item.
         /// </summary>
@@ -924,9 +858,9 @@ namespace OpenSim.Region.Framework.Scenes
                                              uint callbackID, string description, string name,
                                              sbyte invType, sbyte type, UUID olditemID)
         {
-            m_log.DebugFormat(
-                "[AGENT INVENTORY]: Received request from {0} to create inventory item link {1} in folder {2} pointing to {3}",
-                remoteClient.Name, name, folderID, olditemID);
+//            m_log.DebugFormat(
+//                "[AGENT INVENTORY]: Received request from {0} to create inventory item link {1} in folder {2} pointing to {3}",
+//                remoteClient.Name, name, folderID, olditemID);
 
             if (!Permissions.CanCreateUserInventory(invType, remoteClient.AgentId))
                 return;
@@ -934,20 +868,25 @@ namespace OpenSim.Region.Framework.Scenes
             ScenePresence presence;
             if (TryGetScenePresence(remoteClient.AgentId, out presence))
             {
-                bool linkAlreadyExists = false;
-                List<InventoryItemBase> existingItems = InventoryService.GetFolderItems(remoteClient.AgentId, folderID);
-                foreach (InventoryItemBase item in existingItems)
-                    if (item.AssetID == olditemID)
-                        linkAlreadyExists = true;
-
-                if (linkAlreadyExists)
-                {
-                    m_log.WarnFormat(
-                        "[AGENT INVENTORY]: Ignoring request from {0} to create item link {1} in folder {2} pointing to {3} since a link already exists",
-                        remoteClient.Name, name, folderID, olditemID);
-
-                    return;
-                }
+                // Disabled the check for duplicate links.
+                //
+                // When outfits are being adjusted, the viewer rapidly sends delete link messages followed by
+                // create links.  However, since these are handled asynchronously, the deletes do not complete before
+                // the creates are handled.  Therefore, we cannot enforce a duplicate link check.
+//                InventoryItemBase existingLink = null;
+//                List<InventoryItemBase> existingItems = InventoryService.GetFolderItems(remoteClient.AgentId, folderID);
+//                foreach (InventoryItemBase item in existingItems)
+//                    if (item.AssetID == olditemID)
+//                        existingLink = item;
+//
+//                if (existingLink != null)
+//                {
+//                    m_log.WarnFormat(
+//                        "[AGENT INVENTORY]: Ignoring request from {0} to create item link {1} in folder {2} pointing to {3} since a link named {4} with id {5} already exists",
+//                        remoteClient.Name, name, folderID, olditemID, existingLink.Name, existingLink.ID);
+//
+//                    return;
+//                }
 
                 AssetBase asset = new AssetBase();
                 asset.FullID = olditemID;
@@ -975,7 +914,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="itemID"></param>
         private void RemoveInventoryItem(IClientAPI remoteClient, List<UUID> itemIDs)
         {
-            //m_log.Debug("[SCENE INVENTORY]: user " + remoteClient.AgentId);
+//            m_log.DebugFormat(
+//                "[AGENT INVENTORY]: Removing inventory items {0} for {1}",
+//                string.Join(",", itemIDs.ConvertAll<string>(uuid => uuid.ToString()).ToArray()),
+//                remoteClient.Name);
+
             InventoryService.DeleteItems(remoteClient.AgentId, itemIDs);
         }
 
@@ -1395,7 +1338,10 @@ namespace OpenSim.Region.Framework.Scenes
                     if (item.AssetType == (int)AssetType.Link)
                     {
                         InventoryItemBase linkedItem = InventoryService.GetItem(new InventoryItemBase(item.AssetID));
-                        linkedItemFolderIdsToSend.Add(linkedItem.Folder);
+
+                        // Take care of genuinely broken links where the target doesn't exist
+                        if (linkedItem != null)
+                            linkedItemFolderIdsToSend.Add(linkedItem.Folder);
                     }
                 }
 
@@ -2083,19 +2029,7 @@ namespace OpenSim.Region.Framework.Scenes
                     sourcePart.Inventory.RemoveInventoryItem(item.ItemID);
             }
                                     
-            AddNewSceneObject(group, true);
-            
-            group.AbsolutePosition = pos;
-            group.Velocity = vel;            
-            
-            if (rot != null)
-                group.UpdateGroupRotationR((Quaternion)rot);
-            
-            // TODO: This needs to be refactored with the similar code in 
-            // SceneGraph.AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, Vector3 pos, Quaternion rot, Vector3 vel)
-            // possibly by allowing this method to take a null rotation.
-            if (group.RootPart.PhysActor != null && group.RootPart.PhysActor.IsPhysical && vel != Vector3.Zero)
-                group.RootPart.ApplyImpulse((vel * group.GetMass()), false);
+            AddNewSceneObject(group, true, pos, rot, vel);
             
             // We can only call this after adding the scene object, since the scene object references the scene
             // to find out if scripts should be activated at all.

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -94,7 +94,10 @@ namespace OpenSim.Region.Framework.Scenes
         // root agents when ACL denies access to root agent
         public bool m_strictAccessControl = true;
         public int MaxUndoCount = 5;
+        // Using this for RegionReady module to prevent LoginsDisabled from changing under our feet;
+        public bool LoginLock = false;
         public bool LoginsDisabled = true;
+        public bool StartDisabled = false;
         public bool LoadingPrims;
         public IXfer XferManager;
 
@@ -204,6 +207,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         private Timer m_mapGenerationTimer = new Timer();
         private bool m_generateMaptiles;
+        private bool m_useBackup = true;
 
 //        private Dictionary<UUID, string[]> m_UserNamesCache = new Dictionary<UUID, string[]>();
 
@@ -459,6 +463,11 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_sceneGraph; }
         }
 
+        public bool UseBackup
+        {
+            get { return m_useBackup; }
+        }
+
         // an instance to the physics plugin's Scene object.
         public PhysicsScene PhysicsScene
         {
@@ -597,7 +606,7 @@ namespace OpenSim.Region.Framework.Scenes
                                           "delete object uuid <UUID>",
                                           "Delete object by uuid", HandleDeleteObject);
             MainConsole.Instance.Commands.AddCommand("region", false, "delete object name",
-                                          "delete object name <UUID>",
+                                          "delete object name <name>",
                                           "Delete object by name", HandleDeleteObject);
 
             //Bind Storage Manager functions to some land manager functions for this scene
@@ -647,6 +656,9 @@ namespace OpenSim.Region.Framework.Scenes
                 IConfig startupConfig = m_config.Configs["Startup"];
 
                 m_defaultDrawDistance = startupConfig.GetFloat("DefaultDrawDistance",m_defaultDrawDistance);
+                m_useBackup = startupConfig.GetBoolean("UseSceneBackup", m_useBackup);
+                if (!m_useBackup)
+                    m_log.InfoFormat("[SCENE]: Backup has been disabled for {0}", RegionInfo.RegionName);
                 
                 //Animation states
                 m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
@@ -1064,6 +1076,8 @@ namespace OpenSim.Region.Framework.Scenes
             shuttingdown = true;
 
             m_log.Debug("[SCENE]: Persisting changed objects");
+            EventManager.TriggerSceneShuttingDown(this);
+
             EntityBase[] entities = GetEntities();
             foreach (EntityBase entity in entities)
             {
@@ -1362,10 +1376,26 @@ namespace OpenSim.Region.Framework.Scenes
                     IConfig startupConfig = m_config.Configs["Startup"];
                     if (startupConfig == null || !startupConfig.GetBoolean("StartDisabled", false))
                     {
+                        // This handles a case of a region having no scripts for the RegionReady module
+                        if (m_sceneGraph.GetActiveScriptsCount() == 0)
+                        {
+                            // need to be able to tell these have changed in RegionReady
+                            LoginLock = false;
+                            EventManager.TriggerLoginsEnabled(RegionInfo.RegionName);
+                        }
                         m_log.DebugFormat("[REGION]: Enabling logins for {0}", RegionInfo.RegionName);
-                        LoginsDisabled = false;
+                        // For RegionReady lockouts
+                        if( LoginLock == false)
+                        {
+                            LoginsDisabled = false;
+                        }
                         m_sceneGridService.InformNeighborsThatRegionisUp(RequestModuleInterface<INeighbourService>(), RegionInfo);
                     }
+                    else
+                    {
+                        StartDisabled = true;
+                        LoginsDisabled = true;
+                    }
                 }
             }
             catch (NotImplementedException)
@@ -1724,6 +1754,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_log.Info("[SCENE]: Loaded " + PrimsFromDB.Count.ToString() + " SceneObject(s)");
             LoadingPrims = false;
+            EventManager.TriggerPrimsLoaded(this);
         }
 
 
@@ -1879,6 +1910,10 @@ namespace OpenSim.Region.Framework.Scenes
                 sceneObject.SetGroup(groupID, null);
             }
 
+            IUserManagement uman = RequestModuleInterface<IUserManagement>();
+            if (uman != null)
+                sceneObject.RootPart.CreatorIdentification = uman.GetUserUUI(ownerID);
+
             sceneObject.ScheduleGroupForFullUpdate();
 
             return sceneObject;
@@ -1971,16 +2006,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Add a newly created object to the scene.
         /// </summary>
-        /// 
+        /// <remarks>
         /// This method does not send updates to the client - callers need to handle this themselves.
+        /// </remarks>
         /// <param name="sceneObject"></param>
         /// <param name="attachToBackup"></param>
-        /// <param name="pos">Position of the object</param>
-        /// <param name="rot">Rotation of the object</param>
+        /// <param name="pos">Position of the object.  If null then the position stored in the object is used.</param>
+        /// <param name="rot">Rotation of the object.  If null then the rotation stored in the object is used.</param>
         /// <param name="vel">Velocity of the object.  This parameter only has an effect if the object is physical</param>
         /// <returns></returns>
         public bool AddNewSceneObject(
-            SceneObjectGroup sceneObject, bool attachToBackup, Vector3 pos, Quaternion rot, Vector3 vel)
+            SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
         {
             if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel))
             {            
@@ -2540,12 +2576,38 @@ namespace OpenSim.Region.Framework.Scenes
             if (GetScenePresence(client.AgentId) != null)
             {
                 m_LastLogin = Util.EnvironmentTickCount();
+
+                // Cache the user's name
+                CacheUserName(aCircuit);
+
                 EventManager.TriggerOnNewClient(client);
                 if (vialogin)
                     EventManager.TriggerOnClientLogin(client);
             }
         }
 
+        private void CacheUserName(AgentCircuitData aCircuit)
+        {
+            IUserManagement uMan = RequestModuleInterface<IUserManagement>();
+            if (uMan != null)
+            {
+                string homeURL = string.Empty;
+                string first = aCircuit.firstname, last = aCircuit.lastname;
+                if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                    homeURL = aCircuit.ServiceURLs["HomeURI"].ToString();
+                if (aCircuit.lastname.StartsWith("@"))
+                {
+                    string[] parts = aCircuit.firstname.Split('.');
+                    if (parts.Length >= 2)
+                    {
+                        first = parts[0];
+                        last = parts[1];
+                    }
+                }
+                uMan.AddUser(aCircuit.AgentID, first, last, homeURL);
+            }
+        }
+
         private bool VerifyClient(AgentCircuitData aCircuit, System.Net.IPEndPoint ep, out bool vialogin)
         {
             vialogin = false;
@@ -2695,7 +2757,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public virtual void SubscribeToClientInventoryEvents(IClientAPI client)
         {
-            client.OnCreateNewInventoryItem += CreateNewInventoryItem;
+            
             client.OnLinkInventoryItem += HandleLinkInventoryItem;
             client.OnCreateNewInventoryFolder += HandleCreateInventoryFolder;
             client.OnUpdateInventoryFolder += HandleUpdateInventoryFolder;
@@ -2718,7 +2780,6 @@ namespace OpenSim.Region.Framework.Scenes
         public virtual void SubscribeToClientTeleportEvents(IClientAPI client)
         {
             client.OnTeleportLocationRequest += RequestTeleportLocation;
-            client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
         }
 
         public virtual void SubscribeToClientScriptEvents(IClientAPI client)
@@ -2822,7 +2883,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public virtual void UnSubscribeToClientInventoryEvents(IClientAPI client)
         {
-            client.OnCreateNewInventoryItem -= CreateNewInventoryItem;
+            
             client.OnCreateNewInventoryFolder -= HandleCreateInventoryFolder;
             client.OnUpdateInventoryFolder -= HandleUpdateInventoryFolder;
             client.OnMoveInventoryFolder -= HandleMoveInventoryFolder; // 2; //!!
@@ -2844,7 +2905,7 @@ namespace OpenSim.Region.Framework.Scenes
         public virtual void UnSubscribeToClientTeleportEvents(IClientAPI client)
         {
             client.OnTeleportLocationRequest -= RequestTeleportLocation;
-            client.OnTeleportLandmarkRequest -= RequestTeleportLandmark;
+            //client.OnTeleportLandmarkRequest -= RequestTeleportLandmark;
             //client.OnTeleportHomeRequest -= TeleportClientHome;
         }
 
@@ -3894,26 +3955,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        /// <summary>
-        /// Tries to teleport agent to landmark.
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        /// <param name="regionHandle"></param>
-        /// <param name="position"></param>
-        public void RequestTeleportLandmark(IClientAPI remoteClient, UUID regionID, Vector3 position)
-        {
-            GridRegion info = GridService.GetRegionByUUID(UUID.Zero, regionID);
-
-            if (info == null)
-            {
-                // can't find the region: Tell viewer and abort
-                remoteClient.SendTeleportFailed("The teleport destination could not be found.");
-                return;
-            }
-
-            RequestTeleportLocation(remoteClient, info.RegionHandle, position, Vector3.Zero, (uint)(TPFlags.SetLastToTarget | TPFlags.ViaLandmark));
-        }
-
         public bool CrossAgentToNewRegion(ScenePresence agent, bool isFlying)
         {
             if (m_teleportModule != null)
@@ -4278,7 +4319,28 @@ namespace OpenSim.Region.Framework.Scenes
         //        }
 
         /// <summary>
-        /// Get a named prim contained in this scene (will return the first
+        /// Get a group via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <returns>null if no group with that name exists</returns>
+        public SceneObjectGroup GetSceneObjectGroup(UUID fullID)
+        {
+            return m_sceneGraph.GetSceneObjectGroup(fullID);
+        }
+
+        /// <summary>
+        /// Get a group by name from the scene (will return the first
+        /// found, if there are more than one prim with the same name)
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns>null if no group with that name exists</returns>
+        public SceneObjectGroup GetSceneObjectGroup(string name)
+        {
+            return m_sceneGraph.GetSceneObjectGroup(name);
+        }
+
+        /// <summary>
+        /// Get a prim by name from the scene (will return the first
         /// found, if there are more than one prim with the same name)
         /// </summary>
         /// <param name="name"></param>

OpenSim/Region/Framework/Scenes/SceneGraph.cs

@@ -311,25 +311,26 @@ namespace OpenSim.Region.Framework.Scenes
         /// This method does not send updates to the client - callers need to handle this themselves.
         /// <param name="sceneObject"></param>
         /// <param name="attachToBackup"></param>
-        /// <param name="pos">Position of the object</param>
-        /// <param name="rot">Rotation of the object</param>
+        /// <param name="pos">Position of the object.  If null then the position stored in the object is used.</param>
+        /// <param name="rot">Rotation of the object.  If null then the rotation stored in the object is used.</param>
         /// <param name="vel">Velocity of the object.  This parameter only has an effect if the object is physical</param>
         /// <returns></returns>
         public bool AddNewSceneObject(
-            SceneObjectGroup sceneObject, bool attachToBackup, Vector3 pos, Quaternion rot, Vector3 vel)
+            SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
         {
             AddNewSceneObject(sceneObject, true, false);
 
-            // we set it's position in world.
-            sceneObject.AbsolutePosition = pos;
+            if (pos != null)
+                sceneObject.AbsolutePosition = (Vector3)pos;
 
             if (sceneObject.RootPart.Shape.PCode == (byte)PCode.Prim)
             {
                 sceneObject.ClearPartAttachmentData();
             }
-            
-            sceneObject.UpdateGroupRotationR(rot);
-            
+
+            if (rot != null)
+                sceneObject.UpdateGroupRotationR((Quaternion)rot);
+
             //group.ApplyPhysics(m_physicalPrim);
             if (sceneObject.RootPart.PhysActor != null && sceneObject.RootPart.PhysActor.IsPhysical && vel != Vector3.Zero)
             {
@@ -344,6 +345,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// Add an object to the scene.  This will both update the scene, and send information about the
         /// new object to all clients interested in the scene.
         /// </summary>
+        /// <remarks>
+        /// The object's stored position, rotation and velocity are used.
+        /// </remarks>
         /// <param name="sceneObject"></param>
         /// <param name="attachToBackup">
         /// If true, the object is made persistent into the scene.
@@ -972,6 +976,51 @@ namespace OpenSim.Region.Framework.Scenes
             return result;
         }
 
+        /// <summary>
+        /// Get a group in the scene
+        /// </summary>
+        /// <param name="fullID">UUID of the group</param>
+        /// <returns>null if no such group was found</returns>
+        protected internal SceneObjectGroup GetSceneObjectGroup(UUID fullID)
+        {
+            lock (SceneObjectGroupsByFullID)
+            {
+                if (SceneObjectGroupsByFullID.ContainsKey(fullID))
+                    return SceneObjectGroupsByFullID[fullID];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get a group by name from the scene (will return the first
+        /// found, if there are more than one prim with the same name)
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns>null if the part was not found</returns>
+        protected internal SceneObjectGroup GetSceneObjectGroup(string name)
+        {
+            SceneObjectGroup so = null;
+
+            Entities.Find(
+                delegate(EntityBase entity)
+                {
+                    if (entity is SceneObjectGroup)
+                    {
+                        if (entity.Name == name)
+                        {
+                            so = (SceneObjectGroup)entity;
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+            );
+
+            return so;
+        }
+
         /// <summary>
         /// Get a part contained in this scene.
         /// </summary>
@@ -986,7 +1035,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
         
         /// <summary>
-        /// Get a named prim contained in this scene (will return the first 
+        /// Get a prim by name from the scene (will return the first
         /// found, if there are more than one prim with the same name)
         /// </summary>
         /// <param name="name"></param>
@@ -1455,7 +1504,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        ///
+        /// Handle a prim description set request from a viewer.
         /// </summary>
         /// <param name="primLocalID"></param>
         /// <param name="description"></param>
@@ -1472,8 +1521,17 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        /// <summary>
+        /// Set a click action for the prim.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="primLocalID"></param>
+        /// <param name="clickAction"></param>
         protected internal void PrimClickAction(IClientAPI remoteClient, uint primLocalID, string clickAction)
         {
+//            m_log.DebugFormat(
+//                "[SCENEGRAPH]: User {0} set click action for {1} to {2}", remoteClient.Name, primLocalID, clickAction);
+
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {

OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs

@@ -469,6 +469,11 @@ namespace OpenSim.Region.Framework.Scenes
 
         #endregion
 
+//        ~SceneObjectGroup()
+//        {
+//            m_log.DebugFormat("[SCENE OBJECT GROUP]: Destructor called for {0}, local id {1}", Name, LocalId);
+//        }
+
         #region Constructors
 
         /// <summary>
@@ -1335,7 +1340,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                 }
 
-                if (HasGroupChanged)
+                if (m_scene.UseBackup && HasGroupChanged)
                 {
                     // don't backup while it's selected or you're asking for changes mid stream.
                     if (isTimeToPersist() || forcedBackup)

OpenSim/Region/Framework/Scenes/SceneObjectPart.cs

@@ -144,11 +144,10 @@ namespace OpenSim.Region.Framework.Scenes
         
         public Vector3 StatusSandboxPos;
 
-        // TODO: This needs to be persisted in next XML version update!
-        
-        public readonly int[] PayPrice = {-2,-2,-2,-2,-2};
-        
-        
+        [XmlIgnore]
+        public int[] PayPrice = {-2,-2,-2,-2,-2};
+
+        [XmlIgnore]
         public PhysicsActor PhysActor
         {
             get { return m_physActor; }
@@ -347,6 +346,13 @@ namespace OpenSim.Region.Framework.Scenes
 
         #endregion Fields
 
+//        ~SceneObjectPart()
+//        {
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT PART]: Destructor called for {0}, local id {1}, parent {2} {3}",
+//                Name, LocalId, ParentGroup.Name, ParentGroup.LocalId);
+//        }
+
         #region Constructors
 
         /// <summary>

OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs

@@ -121,7 +121,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
-
         /// <summary>
         /// Serialize a scene object to the original xml format
         /// </summary>
@@ -341,6 +340,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             m_SOPXmlProcessors.Add("MediaUrl", ProcessMediaUrl);
             m_SOPXmlProcessors.Add("TextureAnimation", ProcessTextureAnimation);
             m_SOPXmlProcessors.Add("ParticleSystem", ProcessParticleSystem);
+            m_SOPXmlProcessors.Add("PayPrice0", ProcessPayPrice0);
+            m_SOPXmlProcessors.Add("PayPrice1", ProcessPayPrice1);
+            m_SOPXmlProcessors.Add("PayPrice2", ProcessPayPrice2);
+            m_SOPXmlProcessors.Add("PayPrice3", ProcessPayPrice3);
+            m_SOPXmlProcessors.Add("PayPrice4", ProcessPayPrice4);
             #endregion
 
             #region TaskInventoryXmlProcessors initialization
@@ -565,7 +569,13 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
         private static void ProcessShape(SceneObjectPart obj, XmlTextReader reader)
         {
-            obj.Shape = ReadShape(reader, "Shape");
+            bool errors = false;
+            obj.Shape = ReadShape(reader, "Shape", out errors);
+
+            if (errors)
+                m_log.DebugFormat(
+                    "[SceneObjectSerializer]: Parsing PrimitiveBaseShape for object part {0} {1} encountered errors.  Please see earlier log entries.",
+                    obj.Name, obj.UUID);
         }
 
         private static void ProcessScale(SceneObjectPart obj, XmlTextReader reader)
@@ -698,6 +708,32 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         {
             obj.ParticleSystem = Convert.FromBase64String(reader.ReadElementContentAsString("ParticleSystem", String.Empty));
         }
+
+        private static void ProcessPayPrice0(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PayPrice[0] = (int)reader.ReadElementContentAsInt("PayPrice0", String.Empty);
+        }
+
+        private static void ProcessPayPrice1(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PayPrice[1] = (int)reader.ReadElementContentAsInt("PayPrice1", String.Empty);
+        }
+
+        private static void ProcessPayPrice2(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PayPrice[2] = (int)reader.ReadElementContentAsInt("PayPrice2", String.Empty);
+        }
+
+        private static void ProcessPayPrice3(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PayPrice[3] = (int)reader.ReadElementContentAsInt("PayPrice3", String.Empty);
+        }
+
+        private static void ProcessPayPrice4(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PayPrice[4] = (int)reader.ReadElementContentAsInt("PayPrice4", String.Empty);
+        }
+
         #endregion
 
         #region TaskInventoryXmlProcessors
@@ -1069,7 +1105,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             shp.Media = PrimitiveBaseShape.MediaList.FromXml(value);
         }
 
-
         #endregion
 
         ////////// Write /////////
@@ -1175,6 +1210,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 writer.WriteElementString("MediaUrl", sop.MediaUrl.ToString());
             WriteBytes(writer, "TextureAnimation", sop.TextureAnimation);
             WriteBytes(writer, "ParticleSystem", sop.ParticleSystem);
+            writer.WriteElementString("PayPrice0", sop.PayPrice[0].ToString());
+            writer.WriteElementString("PayPrice1", sop.PayPrice[1].ToString());
+            writer.WriteElementString("PayPrice2", sop.PayPrice[2].ToString());
+            writer.WriteElementString("PayPrice3", sop.PayPrice[3].ToString());
+            writer.WriteElementString("PayPrice4", sop.PayPrice[4].ToString());
 
             writer.WriteEndElement();
         }
@@ -1435,7 +1475,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                     }
                     catch (Exception e)
                     {
-                        m_log.DebugFormat("[SceneObjectSerializer]: exception while parsing {0}: {1}", nodeName, e);
+                        m_log.DebugFormat(
+                            "[SceneObjectSerializer]: exception while parsing {0} in object {1} {2}: {3}{4}",
+                            obj.Name, obj.UUID, nodeName, e.Message, e.StackTrace);
                         if (reader.NodeType == XmlNodeType.EndElement)
                             reader.Read();
                     }
@@ -1493,8 +1535,17 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             return tinv;
         }
 
-        static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name)
+        /// <summary>
+        /// Read a shape from xml input
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="name">The name of the xml element containing the shape</param>
+        /// <param name="errors">true if any errors were encountered during parsing, false otherwise</param>
+        /// <returns>The shape parsed</returns>
+        static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name, out bool errors)
         {
+            errors = false;
+
             PrimitiveBaseShape shape = new PrimitiveBaseShape();
 
             if (reader.IsEmptyElement)
@@ -1519,7 +1570,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                     }
                     catch (Exception e)
                     {
-                        m_log.DebugFormat("[SceneObjectSerializer]: exception while parsing Shape {0}: {1}", nodeName, e);
+                        errors = true;
+                        m_log.DebugFormat(
+                            "[SceneObjectSerializer]: exception while parsing Shape property {0}: {1}{2}",
+                            nodeName, e.Message, e.StackTrace);
+
                         if (reader.NodeType == XmlNodeType.EndElement)
                             reader.Read();
                     }

OpenSim/Region/Framework/Scenes/Tests/AttachmentTests.cs

@@ -43,7 +43,6 @@ using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/EntityManagerTests.cs

@@ -37,7 +37,6 @@ using OpenSim.Framework;
 using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/SceneGraphTests.cs

@@ -34,7 +34,6 @@ using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/SceneObjectBasicTests.cs

@@ -34,7 +34,6 @@ using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs

@@ -37,7 +37,6 @@ using OpenSim.Region.CoreModules.World.Permissions;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/SceneObjectLinkingTests.cs

@@ -35,7 +35,6 @@ using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 using log4net;
 
 namespace OpenSim.Region.Framework.Scenes.Tests

OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs

@@ -40,7 +40,6 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTests.cs

@@ -44,7 +44,6 @@ using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs

@@ -43,7 +43,6 @@ using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Scenes.Tests
 {

OpenSim/Region/Framework/Scenes/Tests/StandaloneTeleportTests.cs

@@ -36,7 +36,6 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 using System.Threading;
 
 namespace OpenSim.Region.Framework.Scenes.Tests

OpenSim/Region/Framework/Scenes/Tests/TaskInventoryTests.cs

@@ -46,55 +46,55 @@ using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common.Setup;
 
 namespace OpenSim.Region.Framework.Tests
 {
     [TestFixture]
     public class TaskInventoryTests
     {
-        protected UserAccount CreateUser(Scene scene)
+        [Test]
+        public void TestRezObjectFromInventoryItem()
         {
-            string userFirstName = "Jock";
-            string userLastName = "Stirrup";
-            string userPassword = "troll";
-            UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
-            return UserProfileTestUtils.CreateUserWithInventory(scene, userFirstName, userLastName, userId, userPassword);
-        }
-        
-        protected SceneObjectGroup CreateSO1(Scene scene, UUID ownerId)
-        {
-            string part1Name = "part1";
-            UUID part1Id = UUID.Parse("10000000-0000-0000-0000-000000000000");
-            SceneObjectPart part1
-                = new SceneObjectPart(ownerId, PrimitiveBaseShape.Default, Vector3.Zero, Quaternion.Identity, Vector3.Zero) 
-                    { Name = part1Name, UUID = part1Id };
-            return new SceneObjectGroup(part1);
-        }
-        
-        protected TaskInventoryItem CreateSOItem1(Scene scene, SceneObjectPart part)
-        {
-            AssetNotecard nc = new AssetNotecard();
-            nc.BodyText = "Hello World!";
-            nc.Encode();
-            UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
-            UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
-            AssetBase ncAsset 
-                = AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
-            scene.AssetService.Store(ncAsset);
-            TaskInventoryItem ncItem 
-                = new TaskInventoryItem 
-                    { Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid, 
-                      Type = (int)AssetType.Notecard, InvType = (int)InventoryType.Notecard };
-            part.Inventory.AddInventoryItem(ncItem, true); 
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
             
-            return ncItem;
+            Scene scene = SceneSetupHelpers.SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
+            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
+            SceneObjectPart sop1 = sog1.RootPart;
+
+            // Create an object embedded inside the first
+            UUID taskSceneObjectItemId = UUID.Parse("00000000-0000-0000-0000-100000000000");
+            TaskInventoryItem taskSceneObjectItem
+                = TaskInventoryHelpers.AddSceneObject(scene, sop1, "tso", taskSceneObjectItemId);
+
+            scene.AddSceneObject(sog1);
+
+            Vector3 rezPos = new Vector3(10, 10, 10);
+            Quaternion rezRot = new Quaternion(0.5f, 0.5f, 0.5f, 0.5f);
+            Vector3 rezVel = new Vector3(2, 2, 2);
+
+            scene.RezObject(sop1, taskSceneObjectItem, rezPos, rezRot, rezVel, 0);
+
+            SceneObjectGroup rezzedObject = scene.GetSceneObjectGroup("tso");
+
+            Assert.That(rezzedObject, Is.Not.Null);
+            Assert.That(rezzedObject.AbsolutePosition, Is.EqualTo(rezPos));
+
+            // Velocity doesn't get applied, probably because there is no physics in tests (yet)
+//            Assert.That(rezzedObject.Velocity, Is.EqualTo(rezVel));
+            Assert.That(rezzedObject.Velocity, Is.EqualTo(Vector3.Zero));
+
+            // Confusingly, this isn't the rezzedObject.Rotation
+            Assert.That(rezzedObject.RootPart.RotationOffset, Is.EqualTo(rezRot));
         }
-        
+
         /// <summary>
         /// Test MoveTaskInventoryItem where the item has no parent folder assigned.
         /// </summary>
+        /// <remarks>
         /// This should place it in the most suitable user folder.
+        /// </remarks>
         [Test]
         public void TestMoveTaskInventoryItem()
         {
@@ -102,10 +102,11 @@ namespace OpenSim.Region.Framework.Tests
 //            log4net.Config.XmlConfigurator.Configure();
             
             Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount user1 = CreateUser(scene);
-            SceneObjectGroup sog1 = CreateSO1(scene, user1.PrincipalID);
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
+            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
-            TaskInventoryItem sopItem1 = CreateSOItem1(scene, sop1);
+            TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
+
             InventoryFolderBase folder 
                 = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, user1.PrincipalID, "Objects")[0];
             
@@ -128,10 +129,10 @@ namespace OpenSim.Region.Framework.Tests
 //            log4net.Config.XmlConfigurator.Configure();
             
             Scene scene = SceneSetupHelpers.SetupScene();
-            UserAccount user1 = CreateUser(scene);
-            SceneObjectGroup sog1 = CreateSO1(scene, user1.PrincipalID);
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene);
+            SceneObjectGroup sog1 = SceneSetupHelpers.CreateSceneObject(1, user1.PrincipalID);
             SceneObjectPart sop1 = sog1.RootPart;
-            TaskInventoryItem sopItem1 = CreateSOItem1(scene, sop1);
+            TaskInventoryItem sopItem1 = TaskInventoryHelpers.AddNotecard(scene, sop1);
             
             // Perform test
             scene.MoveTaskInventoryItem(user1.PrincipalID, UUID.Zero, sop1, sopItem1.ItemID);

OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Timers;
+using Timer=System.Timers.Timer;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
+using OpenSim.Region.CoreModules.World.Serialiser;
+using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+
+namespace OpenSim.Region.Framework.Tests
+{
+    [TestFixture]
+    public class UserInventoryTests
+    {
+        [Test]
+        public void TestGiveInventoryItem()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            Scene scene = SceneSetupHelpers.SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, 1001);
+            UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, 1002);
+            InventoryItemBase item1 = UserInventoryHelpers.CreateInventoryItem(scene, "item1", user1.PrincipalID);
+
+            scene.GiveInventoryItem(user2.PrincipalID, user1.PrincipalID, item1.ID);
+
+            InventoryItemBase retrievedItem1
+                = UserInventoryHelpers.GetInventoryItem(scene.InventoryService, user2.PrincipalID, "Notecards/item1");
+
+            Assert.That(retrievedItem1, Is.Not.Null);
+
+            // Try giving back the freshly received item
+            scene.GiveInventoryItem(user1.PrincipalID, user2.PrincipalID, retrievedItem1.ID);
+
+            List<InventoryItemBase> reretrievedItems
+                = UserInventoryHelpers.GetInventoryItems(scene.InventoryService, user1.PrincipalID, "Notecards/item1");
+
+            Assert.That(reretrievedItems.Count, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestGiveInventoryFolder()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            Scene scene = SceneSetupHelpers.SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, 1001);
+            UserAccount user2 = UserAccountHelpers.CreateUserWithInventory(scene, 1002);
+            InventoryFolderBase folder1
+                = UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, "folder1");
+
+            scene.GiveInventoryFolder(user2.PrincipalID, user1.PrincipalID, folder1.ID, UUID.Zero);
+
+            InventoryFolderBase retrievedFolder1
+                = UserInventoryHelpers.GetInventoryFolder(scene.InventoryService, user2.PrincipalID, "folder1");
+
+            Assert.That(retrievedFolder1, Is.Not.Null);
+
+            // Try giving back the freshly received folder
+            scene.GiveInventoryFolder(user1.PrincipalID, user2.PrincipalID, retrievedFolder1.ID, UUID.Zero);
+
+            List<InventoryFolderBase> reretrievedFolders
+                = UserInventoryHelpers.GetInventoryFolders(scene.InventoryService, user1.PrincipalID, "folder1");
+
+            Assert.That(reretrievedFolders.Count, Is.EqualTo(2));
+        }
+    }
+}

OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs

@@ -33,7 +33,6 @@ using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Setup;
 using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.Framework.Scenes.Tests

OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs

@@ -1177,7 +1177,7 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
             IRC_SendChannelPrivmsg(objectname,url);
         }
 
-        public void SendDialog(string objectname, UUID objectID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
+        public void SendDialog(string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
         {
             
         }

OpenSim/Region/OptionalModules/Avatar/Appearance/AppearanceInfoModule.cs

@@ -95,8 +95,9 @@ namespace OpenSim.Region.OptionalModules.Avatar.Appearance
             scene.AddCommand(
                 this, "appearance show",
                 "appearance show",
-                "Show appearance information for each avatar in the simulator.  At the moment, ",
-                ShowAppearanceInfo);             
+                "Show appearance information for each avatar in the simulator.",
+                "At the moment this actually just checks that we have all the required baked textures.  If not, then appearance is 'corrupt' and other avatars will continue to see a cloud.",
+                ShowAppearanceInfo);
         }                 
 
         protected void ShowAppearanceInfo(string module, string[] cmd)

OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs

@@ -1223,6 +1223,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         /// <summary>
         /// Get a list of groups memberships for the agent that are marked "ListInProfile"
+        /// (unless that agent has a godLike aspect, in which case get all groups)
         /// </summary>
         /// <param name="dataForAgentID"></param>
         /// <returns></returns>
@@ -1231,20 +1232,32 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             List<GroupMembershipData> membershipData = m_groupData.GetAgentGroupMemberships(requestingClient.AgentId, dataForAgentID);
             GroupMembershipData[] membershipArray;
 
-            if (requestingClient.AgentId != dataForAgentID)
-            {
-                Predicate<GroupMembershipData> showInProfile = delegate(GroupMembershipData membership)
-                {
-                    return membership.ListInProfile;
-                };
+            //  cScene and property accessor 'isGod' are in support of the opertions to bypass 'hidden' group attributes for
+            // those with a GodLike aspect.
+            Scene cScene = (Scene)requestingClient.Scene;
+            bool isGod = cScene.Permissions.IsGod(requestingClient.AgentId);
 
-                membershipArray = membershipData.FindAll(showInProfile).ToArray();
-            }
-            else
+            if (isGod)
             {
                 membershipArray = membershipData.ToArray();
             }
+            else
+            {
+                if (requestingClient.AgentId != dataForAgentID)
+                {
+                    Predicate<GroupMembershipData> showInProfile = delegate(GroupMembershipData membership)
+                    {
+                        return membership.ListInProfile;
+                    };
 
+                    membershipArray = membershipData.FindAll(showInProfile).ToArray();
+                }
+                else
+                {
+                    membershipArray = membershipData.ToArray();
+                }
+            }
+            
             if (m_debugEnabled)
             {
                 m_log.InfoFormat("[GROUPS]: Get group membership information for {0} requested by {1}", dataForAgentID, requestingClient.AgentId);
@@ -1257,6 +1270,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return membershipArray;
         }
 
+ 
         private void SendAgentDataUpdate(IClientAPI remoteClient, UUID dataForAgentID, UUID activeGroupID, string activeGroupName, ulong activeGroupPowers, string activeGroupTitle)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);