78 files changed, 2755 insertions, 1004 deletions
diff --git a/CONTRIBUTORS.txt b/CONTRIBUTORS.txt
index 8744a08..0d78928 100644
--- a/CONTRIBUTORS.txt
+++ b/CONTRIBUTORS.txt
@@ -1,170 +1,173 @@
-The following people have contributed to OpenSim (Thank you 
+The following people have contributed to OpenSim (Thank you 
-for your effort!)
+for your effort!)
-Add your name in here if you have committed to OpenSim
+Add your name in here if you have committed to OpenSim
-= Current OpenSim Developers (in very rough order of appearance) =
+= Current OpenSim Developers (in very rough order of appearance) =
-These folks represent the current core team for OpenSim, and are the
+These folks represent the current core team for OpenSim, and are the
-people that make the day to day of OpenSim happen.
+people that make the day to day of OpenSim happen.
-* MW (Tribal Media AB)
+* MW (Tribal Media AB)
-* Adam Frisby   (DeepThink Pty Ltd)
+* Adam Frisby   (DeepThink Pty Ltd)
-* MingChen      (DeepThink Pty Ltd)
+* MingChen      (DeepThink Pty Ltd)
-* lbsa71 (Tribal Media AB)
+* lbsa71 (Tribal Media AB)
-* Sean Dague / sdague (IBM)
+* Sean Dague / sdague (IBM)
-* Tedd
+* Tedd
-* justincc
+* justincc
-* Teravus (w3z)
+* Teravus (w3z)
-* Johan Berntsson (3Di)
+* Johan Berntsson (3Di)
-* Ckrinke (Charles Krinke)
+* Ckrinke (Charles Krinke)
-* chi11ken (Genkii)
+* chi11ken (Genkii)
-* adjohn (Genkii)
+* adjohn (Genkii)
-* Dr Scofield aka Dirk Husemann (IBM Research - Zurich)
+* Dr Scofield aka Dirk Husemann (IBM Research - Zurich)
-* dahlia
+* dahlia
-* mikem (3Di)
+* mikem (3Di)
-* Melanie Thielker
+* Melanie Thielker
-* Homer_Horwitz
+* Homer_Horwitz
-* idb (Ian Brown)
+* idb (Ian Brown)
-* Diva (Crista Lopes, University of California, Irvine)
+* Diva (Crista Lopes, University of California, Irvine)
-* nlin (3Di)
+* nlin (3Di)
-* Arthur Rodrigo S Valadares (IBM)
+* Arthur Rodrigo S Valadares (IBM)
-= Past Open Sim Developers =
+= Past Open Sim Developers =
-These folks are alumns of the OpenSim core group, but are now
+These folks are alumns of the OpenSim core group, but are now
-currently not active.  Their great contributions helped get us to
+currently not active.  Their great contributions helped get us to
-where we are today.
+where we are today.
-* Gareth
+* Gareth
-* Andy- 
+* Andy- 
-* MorphW
+* MorphW
-* CW
+* CW
-* Babblefrog
+* Babblefrog
-* Danx0r
+* Danx0r
-* Dalien
+* Dalien
-* Darok
+* Darok
-* Alondria
+* Alondria
-= Additional OpenSim Contributors =
+= Additional OpenSim Contributors =
-These folks have contributed code patches to OpenSim to help make it
+These folks have contributed code patches to OpenSim to help make it
-what it is today.  
+what it is today.  
-* aduffy70
+* aduffy70
-* A_Biondi
+* A_Biondi
-* alex_carnell
+* alex_carnell
-* Alan Webb (IBM)
+* Alan Webb (IBM)
-* BigFootAg
+* BigFootAg
-* BlueWall Slade
+* BlueWall Slade
-* brianw/Sir_Ahzz
+* brianw/Sir_Ahzz
-* CharlieO
+* CharlieO
-* ChrisDown
+* ChrisDown
-* Chris Yeoh (IBM)
+* Chris Yeoh (IBM)
-* coyled
+* coyled
-* Daedius
+* Daedius
-* Dong Jun Lan (IBM)
+* Dong Jun Lan (IBM)
-* DoranZemlja
+* DoranZemlja
-* daTwitch 
+* daTwitch 
-* devalnor-#708
+* devalnor-#708
-* dmiles (Daxtron Labs)
+* dmiles (Daxtron Labs)
-* dslake (Intel)
+* dslake (Intel)
-* FredoChaplin
+* FredoChaplin
-* Gerhard
+* Gerhard
-* Godfrey
+* Godfrey
-* Grumly57
+* Grumly57
-* Ewe Loon
+* Ewe Loon
-* Fly-Man
+* Fly-Man
-* Flyte Xevious
+* Flyte Xevious
-* Imaze Rhiano
+* Imaze Rhiano
-* Intimidated
+* Intimidated
-* Jeremy Bongio (IBM)
+* Jeremy Bongio (IBM)
-* jhurliman
+* jhurliman
-* John R Sohn (XenReborn)
+* John R Sohn (XenReborn)
-* jonc
+* jonc
-* Junta Kohime
+* Junta Kohime
-* Kayne
+* Kayne
-* Kevin Cozens
+* Kevin Cozens
-* kinoc (Daxtron Labs)
+* kinoc (Daxtron Labs)
-* Kitto Flora
+* Kitto Flora
-* Kurt Taylor (IBM)
+* KittyLiu
-* lulurun 
+* Kurt Taylor (IBM)
-* M.Igarashi
+* lulurun 
-* maimedleech
+* M.Igarashi
-* Mic Bowman
+* maimedleech
-* Michelle Argus
+* Mic Bowman
-* Michael Cortez (The Flotsam Project, http://osflotsam.org/)
+* Michelle Argus
-* Mike Osias (IBM)
+* Michael Cortez (The Flotsam Project, http://osflotsam.org/)
-* Mike Pitman (IBM)
+* Mike Osias (IBM)
-* mikkopa/_someone - RealXtend
+* Mike Pitman (IBM)
-* Mircea Kitsune
+* mikkopa/_someone - RealXtend
-* mpallari
+* Misterblue (Intel)
-* nornalbion
+* Mircea Kitsune
-* Omar Vera Ustariz (IBM)
+* mpallari
-* openlifegrid.com
+* nornalbion
-* otakup0pe
+* Omar Vera Ustariz (IBM)
-* ralphos
+* openlifegrid.com
-* RemedyTomm
+* otakup0pe
-* Richard Alimi (IBM)
+* ralphos
-* Rick Alther (IBM)
+* RemedyTomm
-* Rob Smart (IBM)
+* Revolution
-* rtomita
+* Richard Alimi (IBM)
-* Ruud Lathorp
+* Rick Alther (IBM)
-* SachaMagne
+* Rob Smart (IBM)
-* Salahzar Stenvaag
+* rtomita
-* sempuki
+* Ruud Lathorp
-* Snoopy
+* SachaMagne
-* Strawberry Fride
+* Salahzar Stenvaag
-* tglion
+* sempuki
-* tlaukkan/Tommil (Tommi S. E. Laukkanen, Bubble Cloud)
+* Snoopy
-* tyre
+* Strawberry Fride
-* Vytek
+* tglion
-* webmage (IBM)
+* tlaukkan/Tommil (Tommi S. E. Laukkanen, Bubble Cloud)
-* Xantor
+* tyre
-* Y. Nitta
+* Vytek
-* YZh
+* webmage (IBM)
-* Zackary Geers aka Kunnis Basiat
+* Xantor
-* Zha Ewry
+* Y. Nitta
+* YZh
+* Zackary Geers aka Kunnis Basiat
-= LSL Devs =
+* Zha Ewry
-* Alondria
-* CharlieO
+= LSL Devs =
-* Tedd
-* Melanie Thielker
+* Alondria
+* CharlieO
+* Tedd
-= Testers =
+* Melanie Thielker
-* Ai Austin
-* CharlieO (LSL)
+= Testers =
-* Ckrinke
-* openlifegrid.com
+* Ai Austin
+* CharlieO (LSL)
+* Ckrinke
-This software uses components from the following developers:
+* openlifegrid.com
-* Sleepycat Software (Berkeley DB)
-* SQLite (Public Domain)
-* XmlRpcCS (http://xmlrpccs.sf.net/)
+This software uses components from the following developers:
-* MySQL, Inc. (MySQL Connector/NET)
+* Sleepycat Software (Berkeley DB)
-* NUnit (http://www.nunit.org)
+* SQLite (Public Domain)
-* AGEIA Inc. (PhysX)
+* XmlRpcCS (http://xmlrpccs.sf.net/)
-* Russel L. Smith (ODE)
+* MySQL, Inc. (MySQL Connector/NET)
-* Prebuild (http://sourceforge.net/projects/dnpb/)
+* NUnit (http://www.nunit.org)
-* LibOpenMetaverse (http://lib.openmetaverse.org/)
+* AGEIA Inc. (PhysX)
-* DotNetOpenMail v0.5.8b (http://dotnetopenmail.sourceforge.net)
+* Russel L. Smith (ODE)
-* Prototype JavaScript Framework ajax (http://www.prototypejs.org/)
+* Prebuild (http://sourceforge.net/projects/dnpb/)
-* C5 GENERIC COLLECTION LIBRARY FOR C#/CLI
+* LibOpenMetaverse (http://lib.openmetaverse.org/)
-* Nini (http://nini.sourceforge.net/)
+* DotNetOpenMail v0.5.8b (http://dotnetopenmail.sourceforge.net)
-* log4net (http://logging.apache.org/log4net/)
+* Prototype JavaScript Framework ajax (http://www.prototypejs.org/)
-* GlynnTucker.Cache (http://gtcache.sourceforge.net/)
+* C5 GENERIC COLLECTION LIBRARY FOR C#/CLI
-* NDesk.Options 0.2.1 (http://www.ndesk.org/Options)
+* Nini (http://nini.sourceforge.net/)
+* log4net (http://logging.apache.org/log4net/)
-Some plugins are based on Cable Beach
+* GlynnTucker.Cache (http://gtcache.sourceforge.net/)
-Cable Beach is Copyright (c) 2008 Intel Corporation
+* NDesk.Options 0.2.1 (http://www.ndesk.org/Options)
-see http://forge.opensimulator.org/gf/project/assetserver/
+Some plugins are based on Cable Beach
-In addition, we would like to thank:
+Cable Beach is Copyright (c) 2008 Intel Corporation
-* The Mono Project
+see http://forge.opensimulator.org/gf/project/assetserver/
-* The NANT Developers
-* Microsoft (.NET, MSSQL-Adapters)
+In addition, we would like to thank:
+* The Mono Project
+* The NANT Developers
+* Microsoft (.NET, MSSQL-Adapters)
diff --git a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
index 325816d..b22003c 100644
--- a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
+++ b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
@@ -413,8 +413,21 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                ITerrainModule terrainModule = region.RequestModuleInterface<ITerrainModule>();
                if (null == terrainModule) throw new Exception("terrain module not available");
-                terrainModule.LoadFromFile(file);
+                if (Uri.IsWellFormedUriString(file, UriKind.Absolute))
+                {
+                    m_log.Info("[RADMIN]: Terrain path is URL");
+                    Uri result;
+                    if (Uri.TryCreate(file, UriKind.RelativeOrAbsolute, out result))
+                    {
+                        // the url is valid
+                        string fileType = file.Substring(file.LastIndexOf('/') + 1);                       
+                        terrainModule.LoadFromStream(fileType, result);                        
+                    }
+                }
+                else
+                {
+                    terrainModule.LoadFromFile(file);
+                }
                responseData["success"] = false;
                response.Value = responseData;
diff --git a/OpenSim/Client/MXP/ClientStack/MXPClientView.cs b/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
index 0cae3dd..9f9d151 100644
--- a/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
+++ b/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
@@ -902,7 +902,7 @@ namespace OpenSim.Client.MXP.ClientStack
            // Need to translate to MXP somehow
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
            // Need to translate to MXP somehow
        }
diff --git a/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs b/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
index fb87c15..533475f 100644
--- a/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
+++ b/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
@@ -483,7 +483,7 @@ namespace OpenSim.Client.VWoHTTP.ClientStack
            throw new System.NotImplementedException();
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
            throw new System.NotImplementedException();
        }
diff --git a/OpenSim/Data/MSSQL/MSSQLLegacyRegionData.cs b/OpenSim/Data/MSSQL/MSSQLLegacyRegionData.cs
index 6371307..0b430c7 100644
--- a/OpenSim/Data/MSSQL/MSSQLLegacyRegionData.cs
+++ b/OpenSim/Data/MSSQL/MSSQLLegacyRegionData.cs
@@ -671,7 +671,16 @@ VALUES
                cmd.ExecuteNonQuery();
            }
        }
+        public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+        {
+            //This connector doesn't support the windlight module yet
+            //Return default LL windlight settings
+            return new RegionMeta7WindlightData();
+        }
+        public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+        {
+            //This connector doesn't support the windlight module yet
+        }
        /// <summary>
        /// Loads the settings of a region.
        /// </summary>
@@ -696,7 +705,7 @@ VALUES
                }
            }
-            //If comes here then there is now region setting for that region
+            //If we reach this point then there are new region settings for that region
            regionSettings = new RegionSettings();
            regionSettings.RegionUUID = regionUUID;
            regionSettings.OnSave += StoreRegionSettings;
diff --git a/OpenSim/Data/MySQL/MySQLLegacyRegionData.cs b/OpenSim/Data/MySQL/MySQLLegacyRegionData.cs
index c49153f..e2a5406 100644
--- a/OpenSim/Data/MySQL/MySQLLegacyRegionData.cs
+++ b/OpenSim/Data/MySQL/MySQLLegacyRegionData.cs
@@ -479,7 +479,9 @@ namespace OpenSim.Data.MySQL
                    }
                    else
                    {
-                        m_log.Warn("[REGION DB]: Database contains an orphan child prim " + prim.UUID + " pointing to missing parent " + prim.ParentUUID);
+                        m_log.WarnFormat(
+                            "[REGION DB]: Database contains an orphan child prim {0} {1} at {2} in region {3} pointing to missing parent {4}.  This prim will not be loaded.",
+                            prim.Name, prim.UUID, prim.AbsolutePosition, regionID, prim.ParentUUID);
                    }
                }
            }
@@ -691,6 +693,97 @@ namespace OpenSim.Data.MySQL
            }
        }
+        public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+        {
+            RegionMeta7WindlightData nWP = new RegionMeta7WindlightData();
+            nWP.OnSave += StoreRegionWindlightSettings;
+            lock (m_Connection)
+            {
+                
+                string command = "select * from `regionwindlight` where region_id = ?regionID";
+                MySqlCommand cmd = new MySqlCommand(command);
+                cmd.Parameters.AddWithValue("?regionID", regionUUID.ToString());
+                IDataReader result = ExecuteReader(cmd);
+                if (!result.Read())
+                {
+                    //No result, so store our default windlight profile and return it
+                    nWP.regionID = regionUUID;
+                    StoreRegionWindlightSettings(nWP);
+                    return nWP;
+                }
+                else
+                {
+                    UUID.TryParse(result["region_id"].ToString(), out nWP.regionID);
+                    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"]);
+                }
+            }
+            return nWP;
+        }
        public RegionSettings LoadRegionSettings(UUID regionUUID)
        {
            RegionSettings rs = null;
@@ -724,6 +817,107 @@ namespace OpenSim.Data.MySQL
            return rs;
        }
+        public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+        {
+            lock (m_Connection)
+            {
+                using (MySqlCommand cmd = m_Connection.CreateCommand())
+                {
+                    cmd.CommandText = "REPLACE INTO `regionwindlight` (`region_id`, `water_color_r`, `water_color_g`, ";
+                    cmd.CommandText += "`water_color_b`, `water_fog_density_exponent`, `underwater_fog_modifier`, ";
+                    cmd.CommandText += "`reflection_wavelet_scale_1`, `reflection_wavelet_scale_2`, `reflection_wavelet_scale_3`, ";
+                    cmd.CommandText += "`fresnel_scale`, `fresnel_offset`, `refract_scale_above`, `refract_scale_below`, ";
+                    cmd.CommandText += "`blur_multiplier`, `big_wave_direction_x`, `big_wave_direction_y`, `little_wave_direction_x`, ";
+                    cmd.CommandText += "`little_wave_direction_y`, `normal_map_texture`, `horizon_r`, `horizon_g`, `horizon_b`, ";
+                    cmd.CommandText += "`horizon_i`, `haze_horizon`, `blue_density_r`, `blue_density_g`, `blue_density_b`, ";
+                    cmd.CommandText += "`blue_density_i`, `haze_density`, `density_multiplier`, `distance_multiplier`, `max_altitude`, ";
+                    cmd.CommandText += "`sun_moon_color_r`, `sun_moon_color_g`, `sun_moon_color_b`, `sun_moon_color_i`, `sun_moon_position`, ";
+                    cmd.CommandText += "`ambient_r`, `ambient_g`, `ambient_b`, `ambient_i`, `east_angle`, `sun_glow_focus`, `sun_glow_size`, ";
+                    cmd.CommandText += "`scene_gamma`, `star_brightness`, `cloud_color_r`, `cloud_color_g`, `cloud_color_b`, `cloud_color_i`, ";
+                    cmd.CommandText += "`cloud_x`, `cloud_y`, `cloud_density`, `cloud_coverage`, `cloud_scale`, `cloud_detail_x`, ";
+                    cmd.CommandText += "`cloud_detail_y`, `cloud_detail_density`, `cloud_scroll_x`, `cloud_scroll_x_lock`, `cloud_scroll_y`, ";
+                    cmd.CommandText += "`cloud_scroll_y_lock`, `draw_classic_clouds`) VALUES (?region_id, ?water_color_r, ";
+                    cmd.CommandText += "?water_color_g, ?water_color_b, ?water_fog_density_exponent, ?underwater_fog_modifier, ?reflection_wavelet_scale_1, ";
+                    cmd.CommandText += "?reflection_wavelet_scale_2, ?reflection_wavelet_scale_3, ?fresnel_scale, ?fresnel_offset, ?refract_scale_above, ";
+                    cmd.CommandText += "?refract_scale_below, ?blur_multiplier, ?big_wave_direction_x, ?big_wave_direction_y, ?little_wave_direction_x, ";
+                    cmd.CommandText += "?little_wave_direction_y, ?normal_map_texture, ?horizon_r, ?horizon_g, ?horizon_b, ?horizon_i, ?haze_horizon, ";
+                    cmd.CommandText += "?blue_density_r, ?blue_density_g, ?blue_density_b, ?blue_density_i, ?haze_density, ?density_multiplier, ";
+                    cmd.CommandText += "?distance_multiplier, ?max_altitude, ?sun_moon_color_r, ?sun_moon_color_g, ?sun_moon_color_b, ";
+                    cmd.CommandText += "?sun_moon_color_i, ?sun_moon_position, ?ambient_r, ?ambient_g, ?ambient_b, ?ambient_i, ?east_angle, ";
+                    cmd.CommandText += "?sun_glow_focus, ?sun_glow_size, ?scene_gamma, ?star_brightness, ?cloud_color_r, ?cloud_color_g, ";
+                    cmd.CommandText += "?cloud_color_b, ?cloud_color_i, ?cloud_x, ?cloud_y, ?cloud_density, ?cloud_coverage, ?cloud_scale, ";
+                    cmd.CommandText += "?cloud_detail_x, ?cloud_detail_y, ?cloud_detail_density, ?cloud_scroll_x, ?cloud_scroll_x_lock, ";
+                    cmd.CommandText += "?cloud_scroll_y, ?cloud_scroll_y_lock, ?draw_classic_clouds)";
+                    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);
+                    
+                    ExecuteNonQuery(cmd);
+                }
+            }
+        }
        public void StoreRegionSettings(RegionSettings rs)
        {
            lock (m_Connection)
diff --git a/OpenSim/Data/MySQL/Resources/032_RegionStore.sql b/OpenSim/Data/MySQL/Resources/032_RegionStore.sql
new file mode 100644
index 0000000..0545ee1
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/032_RegionStore.sql
@@ -0,0 +1,70 @@
+BEGIN;
+CREATE TABLE `regionwindlight` (
+  `region_id` varchar(36) NOT NULL DEFAULT '000000-0000-0000-0000-000000000000',
+  `water_color_r` float(9,6) unsigned NOT NULL DEFAULT '4.000000',
+  `water_color_g` float(9,6) unsigned NOT NULL DEFAULT '38.000000',
+  `water_color_b` float(9,6) unsigned NOT NULL DEFAULT '64.000000',
+  `water_fog_density_exponent` float(3,1) unsigned NOT NULL DEFAULT '4.0',
+  `underwater_fog_modifier` float(3,2) unsigned NOT NULL DEFAULT '0.25',
+  `reflection_wavelet_scale_1` float(3,1) unsigned NOT NULL DEFAULT '2.0',
+  `reflection_wavelet_scale_2` float(3,1) unsigned NOT NULL DEFAULT '2.0',
+  `reflection_wavelet_scale_3` float(3,1) unsigned NOT NULL DEFAULT '2.0',
+  `fresnel_scale` float(3,2) unsigned NOT NULL DEFAULT '0.40',
+  `fresnel_offset` float(3,2) unsigned NOT NULL DEFAULT '0.50',
+  `refract_scale_above` float(3,2) unsigned NOT NULL DEFAULT '0.03',
+  `refract_scale_below` float(3,2) unsigned NOT NULL DEFAULT '0.20',
+  `blur_multiplier` float(4,3) unsigned NOT NULL DEFAULT '0.040',
+  `big_wave_direction_x` float(3,2) NOT NULL DEFAULT '1.05',
+  `big_wave_direction_y` float(3,2) NOT NULL DEFAULT '-0.42',
+  `little_wave_direction_x` float(3,2) NOT NULL DEFAULT '1.11',
+  `little_wave_direction_y` float(3,2) NOT NULL DEFAULT '-1.16',
+  `normal_map_texture` varchar(36) NOT NULL DEFAULT '822ded49-9a6c-f61c-cb89-6df54f42cdf4',
+  `horizon_r` float(3,2) unsigned NOT NULL DEFAULT '0.26',
+  `horizon_g` float(3,2) unsigned NOT NULL DEFAULT '0.24',
+  `horizon_b` float(3,2) unsigned NOT NULL DEFAULT '0.33',
+  `horizon_i` float(3,2) unsigned NOT NULL DEFAULT '0.33',
+  `haze_horizon` float(3,2) unsigned NOT NULL DEFAULT '0.19',
+  `blue_density_r` float(3,2) unsigned NOT NULL DEFAULT '0.10',
+  `blue_density_g` float(3,2) unsigned NOT NULL DEFAULT '0.93',
+  `blue_density_b` float(3,2) unsigned NOT NULL DEFAULT '0.02',
+  `blue_density_i` float(3,2) unsigned NOT NULL DEFAULT '0.93',
+  `haze_density` float(3,2) unsigned NOT NULL DEFAULT '0.70',
+  `density_multiplier` float(3,2) unsigned NOT NULL DEFAULT '0.18',
+  `distance_multiplier` float(4,1) unsigned NOT NULL DEFAULT '0.8',
+  `max_altitude` int(4) unsigned NOT NULL DEFAULT '1605',
+  `sun_moon_color_r` float(3,2) unsigned NOT NULL DEFAULT '0.24',
+  `sun_moon_color_g` float(3,2) unsigned NOT NULL DEFAULT '0.26',
+  `sun_moon_color_b` float(3,2) unsigned NOT NULL DEFAULT '0.30',
+  `sun_moon_color_i` float(3,2) unsigned NOT NULL DEFAULT '0.30',
+  `sun_moon_position` float(4,3) unsigned NOT NULL DEFAULT '0.335',
+  `ambient_r` float(3,2) unsigned NOT NULL DEFAULT '0.35',
+  `ambient_g` float(3,2) unsigned NOT NULL DEFAULT '0.35',
+  `ambient_b` float(3,2) unsigned NOT NULL DEFAULT '0.35',
+  `ambient_i` float(3,2) unsigned NOT NULL DEFAULT '0.35',
+  `east_angle` float(3,2) unsigned NOT NULL DEFAULT '0.00',
+  `sun_glow_focus` float(3,2) unsigned NOT NULL DEFAULT '0.10',
+  `sun_glow_size` float(3,2) unsigned NOT NULL DEFAULT '1.75',
+  `scene_gamma` float(4,2) unsigned NOT NULL DEFAULT '1.00',
+  `star_brightness` float(3,2) unsigned NOT NULL DEFAULT '0.00',
+  `cloud_color_r` float(3,2) unsigned NOT NULL DEFAULT '0.41',
+  `cloud_color_g` float(3,2) unsigned NOT NULL DEFAULT '0.41',
+  `cloud_color_b` float(3,2) unsigned NOT NULL DEFAULT '0.41',
+  `cloud_color_i` float(3,2) unsigned NOT NULL DEFAULT '0.41',
+  `cloud_x` float(3,2) unsigned NOT NULL DEFAULT '1.00',
+  `cloud_y` float(3,2) unsigned NOT NULL DEFAULT '0.53',
+  `cloud_density` float(3,2) unsigned NOT NULL DEFAULT '1.00',
+  `cloud_coverage` float(3,2) unsigned NOT NULL DEFAULT '0.27',
+  `cloud_scale` float(3,2) unsigned NOT NULL DEFAULT '0.42',
+  `cloud_detail_x` float(3,2) unsigned NOT NULL DEFAULT '1.00',
+  `cloud_detail_y` float(3,2) unsigned NOT NULL DEFAULT '0.53',
+  `cloud_detail_density` float(3,2) unsigned NOT NULL DEFAULT '0.12',
+  `cloud_scroll_x` float(3,2) unsigned NOT NULL DEFAULT '0.20',
+  `cloud_scroll_x_lock` tinyint(1) unsigned NOT NULL DEFAULT '0',
+  `cloud_scroll_y` float(3,2) unsigned NOT NULL DEFAULT '0.01',
+  `cloud_scroll_y_lock` tinyint(1) unsigned NOT NULL DEFAULT '0',
+  `draw_classic_clouds` tinyint(1) unsigned NOT NULL DEFAULT '0',
+  PRIMARY KEY (`region_id`)
+);
+COMMIT;
+\ No newline at end of file
diff --git a/OpenSim/Data/Null/NullDataStore.cs b/OpenSim/Data/Null/NullDataStore.cs
index 427fa0a..4b6d0f3 100644
--- a/OpenSim/Data/Null/NullDataStore.cs
+++ b/OpenSim/Data/Null/NullDataStore.cs
@@ -50,7 +50,16 @@ namespace OpenSim.Data.Null
        public void StoreRegionSettings(RegionSettings rs)
        {
        }
+        public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+        {
+            //This connector doesn't support the windlight module yet
+            //Return default LL windlight settings
+            return new RegionMeta7WindlightData();
+        }
+        public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+        {
+            //This connector doesn't support the windlight module yet
+        }
        public RegionSettings LoadRegionSettings(UUID regionUUID)
        {
            return null;
diff --git a/OpenSim/Data/SQLite/SQLiteRegionData.cs b/OpenSim/Data/SQLite/SQLiteRegionData.cs
index b68de1a..f1c1f78 100644
--- a/OpenSim/Data/SQLite/SQLiteRegionData.cs
+++ b/OpenSim/Data/SQLite/SQLiteRegionData.cs
@@ -272,7 +272,16 @@ namespace OpenSim.Data.SQLite
                Commit();
            }
        }
+        public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+        {
+            //This connector doesn't support the windlight module yet
+            //Return default LL windlight settings
+            return new RegionMeta7WindlightData();
+        }
+        public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+        {
+            //This connector doesn't support the windlight module yet
+        }
        public RegionSettings LoadRegionSettings(UUID regionUUID)
        {
            lock (ds)
diff --git a/OpenSim/Data/SQLite/SQLiteUserData.cs b/OpenSim/Data/SQLite/SQLiteUserData.cs
index b9f3515..caddcf8 100644
--- a/OpenSim/Data/SQLite/SQLiteUserData.cs
+++ b/OpenSim/Data/SQLite/SQLiteUserData.cs
@@ -819,7 +819,10 @@ namespace OpenSim.Data.SQLite
            SQLiteUtil.createCol(users, "homeLookAtZ", typeof (Double));
            SQLiteUtil.createCol(users, "created", typeof (Int32));
            SQLiteUtil.createCol(users, "lastLogin", typeof (Int32));
+            //TODO: Please delete this column.  It's now a brick
            SQLiteUtil.createCol(users, "rootInventoryFolderID", typeof (String));
            SQLiteUtil.createCol(users, "userInventoryURI", typeof (String));
            SQLiteUtil.createCol(users, "userAssetURI", typeof (String));
            SQLiteUtil.createCol(users, "profileCanDoMask", typeof (Int32));
@@ -980,7 +983,6 @@ namespace OpenSim.Data.SQLite
            user.Created = Convert.ToInt32(row["created"]);
            user.LastLogin = Convert.ToInt32(row["lastLogin"]);
-            user.RootInventoryFolderID = new UUID((String) row["rootInventoryFolderID"]);
            user.UserInventoryURI = (String) row["userInventoryURI"];
            user.UserAssetURI = (String) row["userAssetURI"];
            user.CanDoMask = Convert.ToUInt32(row["profileCanDoMask"]);
@@ -1026,7 +1028,8 @@ namespace OpenSim.Data.SQLite
            row["created"] = user.Created;
            row["lastLogin"] = user.LastLogin;
-            row["rootInventoryFolderID"] = user.RootInventoryFolderID.ToString();
+            //TODO: Get rid of rootInventoryFolderID in a safe way.
+            row["rootInventoryFolderID"] = UUID.Zero.ToString();
            row["userInventoryURI"] = user.UserInventoryURI;
            row["userAssetURI"] = user.UserAssetURI;
            row["profileCanDoMask"] = user.CanDoMask;
diff --git a/OpenSim/Data/Tests/BasicEstateTest.cs b/OpenSim/Data/Tests/BasicEstateTest.cs
index d8e1725..907bb38 100644
--- a/OpenSim/Data/Tests/BasicEstateTest.cs
+++ b/OpenSim/Data/Tests/BasicEstateTest.cs
@@ -154,13 +154,14 @@ namespace OpenSim.Data.Tests
                );
        }
-        //[Test]
+        [Test]
-        // Currently fails occasionally
        public void T012_EstateSettingsRandomStorage()
        {
            // Letting estate store generate rows to database for us
            EstateSettings originalSettings = db.LoadEstateSettings(REGION_ID);
-            new PropertyScrambler<EstateSettings>().Scramble(originalSettings);
+            new PropertyScrambler<EstateSettings>()
+                .DontScramble(x=>x.EstateID)
+                .Scramble(originalSettings);
            // Saving settings.
            db.StoreEstateSettings(originalSettings);
diff --git a/OpenSim/Data/Tests/BasicUserTest.cs b/OpenSim/Data/Tests/BasicUserTest.cs
index 1f472a5..d3b6041 100644
--- a/OpenSim/Data/Tests/BasicUserTest.cs
+++ b/OpenSim/Data/Tests/BasicUserTest.cs
@@ -170,8 +170,8 @@ namespace OpenSim.Data.Tests
        {
            UserProfileData u0 = NewUser(zero,fname0,lname0); 
            UserProfileData u4 = NewUser(user4,fname2,lname2);
-            db.AddNewUserProfile(u0);
+            db.AddNewUserProfile(u0); //UserID 0 should fail to save.
-            db.AddNewUserProfile(u4);
+            db.AddNewUserProfile(u4); //The first name and last name are already in use (from T010), so this should fail too
            Assert.That(db.GetUserByUUID(zero),Is.Null);
            Assert.That(db.GetUserByUUID(user4),Is.Null);
        }
@@ -267,8 +267,6 @@ namespace OpenSim.Data.Tests
            Assert.That(homelookat,Is.EqualTo(u1a.HomeLookAt), "Assert.That(homelookat,Is.EqualTo(u1a.HomeLookAt))");
            Assert.That(created,Is.EqualTo(u1a.Created), "Assert.That(created,Is.EqualTo(u1a.Created))");
            Assert.That(lastlogin,Is.EqualTo(u1a.LastLogin), "Assert.That(lastlogin,Is.EqualTo(u1a.LastLogin))");
-            // RootInventoryFolderID is not tested because it is saved in SQLite,
-            // but not in MySQL
            Assert.That(userinvuri,Is.EqualTo(u1a.UserInventoryURI), "Assert.That(userinvuri,Is.EqualTo(u1a.UserInventoryURI))");
            Assert.That(userasseturi,Is.EqualTo(u1a.UserAssetURI), "Assert.That(userasseturi,Is.EqualTo(u1a.UserAssetURI))");
            Assert.That(candomask,Is.EqualTo(u1a.CanDoMask), "Assert.That(candomask,Is.EqualTo(u1a.CanDoMask))");
@@ -367,8 +365,6 @@ namespace OpenSim.Data.Tests
            Assert.That(homelookat,Is.EqualTo(u1a.HomeLookAt), "Assert.That(homelookat,Is.EqualTo(u1a.HomeLookAt))");
            Assert.That(created,Is.EqualTo(u1a.Created), "Assert.That(created,Is.EqualTo(u1a.Created))");
            Assert.That(lastlogin,Is.EqualTo(u1a.LastLogin), "Assert.That(lastlogin,Is.EqualTo(u1a.LastLogin))");
-            // RootInventoryFolderID is not tested because it is saved in SQLite,
-            // but not in MySQL
            Assert.That(userasseturi,Is.EqualTo(u1a.UserAssetURI), "Assert.That(userasseturi,Is.EqualTo(u1a.UserAssetURI))");
            Assert.That(candomask,Is.EqualTo(u1a.CanDoMask), "Assert.That(candomask,Is.EqualTo(u1a.CanDoMask))");
            Assert.That(wantdomask,Is.EqualTo(u1a.WantDoMask), "Assert.That(wantdomask,Is.EqualTo(u1a.WantDoMask))");
@@ -395,7 +391,6 @@ namespace OpenSim.Data.Tests
            Assert.That(u1a, Constraints.PropertyCompareConstraint(u)
                .IgnoreProperty(x=>x.HomeRegionX)
                .IgnoreProperty(x=>x.HomeRegionY)
-                .IgnoreProperty(x=>x.RootInventoryFolderID)
                );
        }
        
diff --git a/OpenSim/Framework/Communications/Services/LoginService.cs b/OpenSim/Framework/Communications/Services/LoginService.cs
index b652299..57ca704 100644
--- a/OpenSim/Framework/Communications/Services/LoginService.cs
+++ b/OpenSim/Framework/Communications/Services/LoginService.cs
@@ -244,7 +244,6 @@ namespace OpenSim.Framework.Communications.Services
                            InventoryRootHash["folder_id"] = inventData.RootFolderID.ToString();
                            ArrayList InventoryRoot = new ArrayList();
                            InventoryRoot.Add(InventoryRootHash);
-                            userProfile.RootInventoryFolderID = inventData.RootFolderID;
                            logResponse.InventoryRoot = InventoryRoot;
                            logResponse.InventorySkeleton = AgentInventoryArray;
@@ -501,7 +500,6 @@ namespace OpenSim.Framework.Communications.Services
                        InventoryRootHash["folder_id"] = inventData.RootFolderID.ToString();
                        ArrayList InventoryRoot = new ArrayList();
                        InventoryRoot.Add(InventoryRootHash);
-                        userProfile.RootInventoryFolderID = inventData.RootFolderID;
                        // Inventory Library Section
diff --git a/OpenSim/Framework/Communications/UserManagerBase.cs b/OpenSim/Framework/Communications/UserManagerBase.cs
index bf4f331..4f0af06 100644
--- a/OpenSim/Framework/Communications/UserManagerBase.cs
+++ b/OpenSim/Framework/Communications/UserManagerBase.cs
@@ -697,9 +697,6 @@ namespace OpenSim.Framework.Communications
                    // local service (standalone)
                    m_log.Debug("[USERSTORAGE]: using IInventoryService to create user's inventory");
                    m_InventoryService.CreateUserInventory(userProf.ID);
-                    InventoryFolderBase rootfolder = m_InventoryService.GetRootFolder(userProf.ID);
-                    if (rootfolder != null)
-                        userProf.RootInventoryFolderID = rootfolder.ID;
                }
                else if (m_commsManager.InterServiceInventoryService != null)
                {
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index 04ba9c6..cb136e2 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -1077,7 +1077,7 @@ namespace OpenSim.Framework
        void SendInstantMessage(GridInstantMessage im);
-        void SendGenericMessage(string method, List<string> message);
+        void SendGenericMessage(string method, List<byte[]> message);
        void SendLayerData(float[] map);
        void SendLayerData(int px, int py, float[] map);
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index 721233d..c39cc03 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -36,8 +36,59 @@ using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework.Console;
 namespace OpenSim.Framework
 {
+    public class RegionMeta7WindlightData
+    {
+        public UUID regionID = UUID.Zero;
+        public Vector3 waterColor = new Vector3(4.0f,38.0f,64.0f);
+        public float waterFogDensityExponent = 4.0f;
+        public float underwaterFogModifier = 0.25f;
+        public Vector3 reflectionWaveletScale = new Vector3(2.0f,2.0f,2.0f);
+        public float fresnelScale = 0.40f;
+        public float fresnelOffset = 0.50f;
+        public float refractScaleAbove = 0.03f;
+        public float refractScaleBelow = 0.20f;
+        public float blurMultiplier = 0.040f;
+        public Vector2 bigWaveDirection = new Vector2(1.05f,-0.42f);
+        public Vector2 littleWaveDirection = new Vector2(1.11f,-1.16f);
+        public UUID normalMapTexture = new UUID("822ded49-9a6c-f61c-cb89-6df54f42cdf4");
+        public Vector4 horizon = new Vector4(0.26f, 0.24f, 0.34f, 0.33f);
+        public float hazeHorizon = 0.19f;
+        public Vector4 blueDensity = new Vector4(0.10f, 0.93f, 0.02f, 0.93f);
+        public float hazeDensity = 0.70f;
+        public float densityMultiplier = 0.18f;
+        public float distanceMultiplier = 0.8f;
+        public UInt16 maxAltitude = 1605;
+        public Vector4 sunMoonColor = new Vector4(0.24f, 0.26f, 0.30f, 0.30f);
+        public float sunMoonPosition = 0.335f;
+        public Vector4 ambient = new Vector4(0.35f,0.35f,0.35f,0.35f);
+        public float eastAngle = 0.0f;
+        public float sunGlowFocus = 0.10f;
+        public float sunGlowSize = 0.10f;
+        public float sceneGamma = 1.0f;
+        public float starBrightness = 0.0f;
+        public Vector4 cloudColor = new Vector4(0.41f, 0.41f, 0.41f, 0.41f);
+        public Vector3 cloudXYDensity = new Vector3(1.00f, 0.53f, 1.00f);
+        public float cloudCoverage = 0.27f;
+        public float cloudScale = 0.42f;
+        public Vector3 cloudDetailXYDensity = new Vector3(1.00f, 0.53f, 0.12f);
+        public float cloudScrollX = 0.20f;
+        public bool cloudScrollXLock = false;
+        public float cloudScrollY = 0.01f;
+        public bool cloudScrollYLock = false;
+        public bool drawClassicClouds = false;
+        public delegate void SaveDelegate(RegionMeta7WindlightData wl);
+        public event SaveDelegate OnSave;
+        public void Save()
+        {
+            if (OnSave != null)
+                OnSave(this);
+        }
+    }
    [Serializable]
    public class SimpleRegionInfo
    {
@@ -304,8 +355,7 @@ namespace OpenSim.Framework
        private bool m_clampPrimSize = false;
        private int m_objectCapacity = 0;
        private string m_regionType = String.Empty;
+        private RegionMeta7WindlightData m_windlight = new RegionMeta7WindlightData();
        // Apparently, we're applying the same estatesettings regardless of whether it's local or remote.
        // MT: Yes. Estates can't span trust boundaries. Therefore, it can be
@@ -454,6 +504,21 @@ namespace OpenSim.Framework
            set { m_regionSettings = value; }
        }
+        public RegionMeta7WindlightData WindlightSettings
+        {
+            get
+            {
+                if (m_windlight == null)
+                {
+                    m_windlight = new RegionMeta7WindlightData();
+                }
+                return m_windlight;
+            }
+            set { m_windlight = value; }
+        }
        public int NonphysPrimMax
        {
            get { return m_nonphysPrimMax; }
diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index 0d93ff7..655df9d 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -442,7 +442,7 @@ namespace OpenSim.Framework.Servers
            if (File.Exists(gitCommitFileName))
            {
                StreamReader CommitFile = File.OpenText(gitCommitFileName);
-                buildVersion = Environment.NewLine + "git# " + CommitFile.ReadLine();
+                buildVersion = CommitFile.ReadLine();
                CommitFile.Close();
                m_version += buildVersion ?? "";
            }
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index bec5ed3..75cdeb4 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -724,12 +724,20 @@ namespace OpenSim.Framework.Servers.HttpServer
                        }
                        catch(Exception e)
                        {
+                            string errorMessage
+                                = String.Format(
+                                    "Requested method [{0}] from {1} threw exception: {2} {3}",
+                                    methodName, request.RemoteIPEndPoint.Address, e.Message, e.StackTrace);
+                            m_log.ErrorFormat("[BASE HTTP SERVER]: {0}", errorMessage);
                            // if the registered XmlRpc method threw an exception, we pass a fault-code along
                            xmlRpcResponse = new XmlRpcResponse();
                            // Code probably set in accordance with http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
-                            xmlRpcResponse.SetFault(-32603, String.Format("Requested method [{0}] threw exception: {1}",
+                            xmlRpcResponse.SetFault(-32603, errorMessage);                            
-                                                                          methodName, e.Message));
                        }
                        // if the method wasn't found, we can't determine KeepAlive state anyway, so lets do it only here
                        response.KeepAlive = m_rpcHandlersKeepAlive[methodName];
                    }
diff --git a/OpenSim/Framework/Servers/HttpServer/OSHttpRequest.cs b/OpenSim/Framework/Servers/HttpServer/OSHttpRequest.cs
index c53160f..bcfb0a4 100644
--- a/OpenSim/Framework/Servers/HttpServer/OSHttpRequest.cs
+++ b/OpenSim/Framework/Servers/HttpServer/OSHttpRequest.cs
@@ -188,7 +188,15 @@ namespace OpenSim.Framework.Servers.HttpServer
                try
                {
                    IPAddress addr = IPAddress.Parse(req.Headers["remote_addr"]);
-                    int port = Int32.Parse(req.Headers["remote_port"]);
+                    // sometimes req.Headers["remote_port"] returns a comma separated list, so use
+                    // the first one in the list and log it 
+                    string[] strPorts = req.Headers["remote_port"].Split(new char[] { ',' });
+                    if (strPorts.Length > 1)
+                    {
+                        _log.ErrorFormat("[OSHttpRequest]: format exception on addr/port {0}:{1}, ignoring",
+                                     req.Headers["remote_addr"], req.Headers["remote_port"]);
+                    }
+                    int port = Int32.Parse(strPorts[0]);
                    _remoteIPEndPoint = new IPEndPoint(addr, port);
                }
                catch (FormatException)
diff --git a/OpenSim/Framework/TaskInventoryDictionary.cs b/OpenSim/Framework/TaskInventoryDictionary.cs
index efe5f0c..4b9a509 100644
--- a/OpenSim/Framework/TaskInventoryDictionary.cs
+++ b/OpenSim/Framework/TaskInventoryDictionary.cs
@@ -109,7 +109,10 @@ namespace OpenSim.Framework
            }
            else
            {
-                m_itemLock.ExitReadLock();
+                if (m_itemLock.RecursiveReadCount>0)
+                {
+                    m_itemLock.ExitReadLock();
+                }
            }
        }
@@ -144,7 +147,10 @@ namespace OpenSim.Framework
            }
            else
            {
-                m_itemLock.ExitWriteLock();
+                if (m_itemLock.RecursiveWriteCount > 0)
+                {
+                    m_itemLock.ExitWriteLock();
+                }
            }
        }
diff --git a/OpenSim/Framework/UserProfileData.cs b/OpenSim/Framework/UserProfileData.cs
index 413f152..9bac739 100644
--- a/OpenSim/Framework/UserProfileData.cs
+++ b/OpenSim/Framework/UserProfileData.cs
@@ -119,8 +119,6 @@ namespace OpenSim.Framework
        /// </summary>
        private string m_profileUrl;
-        private UUID m_rootInventoryFolderId;
        /// <summary>
        /// The second component of a users account name
        /// </summary>
@@ -312,12 +310,6 @@ namespace OpenSim.Framework
            set { m_lastLogin = value; }
        }
-        public UUID RootInventoryFolderID
-        {
-            get { return m_rootInventoryFolderId; }
-            set { m_rootInventoryFolderId = value; }
-        }
        public string UserInventoryURI
        {
            get { return m_userInventoryUri; }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index c052745..b5e2872 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -1390,5 +1390,29 @@ namespace OpenSim.Framework
        }
        #endregion FireAndForget Threading Pattern
+        /// <summary>
+        /// Environment.TickCount is an int but it counts all 32 bits so it goes positive
+        /// and negative every 24.9 days. This trims down TickCount so it doesn't wrap
+        /// for the callers. 
+        /// This trims it to a 12 day interval so don't let your frame time get too long.
+        /// </summary>
+        /// <returns></returns>
+        public static Int32 EnvironmentTickCount()
+        {
+            return Environment.TickCount & EnvironmentTickCountMask;
+        }
+        const Int32 EnvironmentTickCountMask = 0x3fffffff;
+        /// <summary>
+        /// Environment.TickCount is an int but it counts all 32 bits so it goes positive
+        /// and negative every 24.9 days. Subtracts the passed value (previously fetched by
+        /// 'EnvironmentTickCount()') and accounts for any wrapping.
+        /// </summary>
+        /// <returns>subtraction of passed prevValue from current Environment.TickCount</returns>
+        public static Int32 EnvironmentTickCountSubtract(Int32 prevValue)
+        {
+            Int32 diff = EnvironmentTickCount() - prevValue;
+            return (diff >= 0) ? diff : (diff + EnvironmentTickCountMask + 1);
+        }
    }
 }
diff --git a/OpenSim/Grid/UserServer.Modules/MessageServersConnector.cs b/OpenSim/Grid/UserServer.Modules/MessageServersConnector.cs
index f24cef6..3384952 100644
--- a/OpenSim/Grid/UserServer.Modules/MessageServersConnector.cs
+++ b/OpenSim/Grid/UserServer.Modules/MessageServersConnector.cs
@@ -201,6 +201,7 @@ namespace OpenSim.Grid.UserServer.Modules
            }
            return response;
        }
+        
        public XmlRpcResponse XmlRPCUserMovedtoRegion(XmlRpcRequest request, IPEndPoint remoteClient)
        {
            XmlRpcResponse response = new XmlRpcResponse();
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index 5228e4b..82b2fd4 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -939,8 +939,8 @@ namespace OpenSim
                    m_log.Info(String.Format("\nAgents connected: {0}\n", agents.Count));
                    m_log.Info(
-                        String.Format("{0,-16}{1,-16}{2,-37}{3,-11}{4,-16}", "Firstname", "Lastname",
+                        String.Format("{0,-16}{1,-16}{2,-37}{3,-11}{4,-16}{5,-30}", "Firstname", "Lastname",
-                                      "Agent ID", "Root/Child", "Region"));
+                                      "Agent ID", "Root/Child", "Region", "Position"));
                    foreach (ScenePresence presence in agents)
                    {
@@ -958,12 +958,13 @@ namespace OpenSim
                        m_log.Info(
                            String.Format(
-                                "{0,-16}{1,-16}{2,-37}{3,-11}{4,-16}",
+                                "{0,-16}{1,-16}{2,-37}{3,-11}{4,-16}{5,-30}",
                                presence.Firstname,
                                presence.Lastname,
                                presence.UUID,
                                presence.IsChildAgent ? "Child" : "Root",
-                                regionName));
+                                regionName,
+                                presence.AbsolutePosition.ToString()));
                    }
                    m_log.Info(String.Empty);
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index ac16b02..2b5e632 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -352,6 +352,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        private IHyperAssetService m_hyperAssets;
        private const bool m_checkPackets = true;
+        private Timer m_propertiesPacketTimer;
+        private List<ObjectPropertiesPacket.ObjectDataBlock> m_propertiesBlocks = new List<ObjectPropertiesPacket.ObjectDataBlock>();
        #endregion Class Members
        #region Properties
@@ -433,6 +436,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            m_udpClient.OnQueueEmpty += HandleQueueEmpty;
            m_udpClient.OnPacketStats += PopulateStats;
+            m_propertiesPacketTimer = new Timer(100);
+            m_propertiesPacketTimer.Elapsed += ProcessObjectPropertiesPacket;
            RegisterLocalPacketHandlers();
        }
@@ -764,16 +770,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            }
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
            GenericMessagePacket gmp = new GenericMessagePacket();
            gmp.MethodData.Method = Util.StringToBytes256(method);
            gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];
            int i = 0;
-            foreach (string val in message)
+            foreach (byte[] val in message)
            {
                gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
-                gmp.ParamList[i++].Parameter = Util.StringToBytes256(val);
+                gmp.ParamList[i++].Parameter = val;
            }
            OutPacket(gmp, ThrottleOutPacketType.Task);
        }
@@ -3562,42 +3568,88 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            string ItemDescription, uint OwnerMask, uint NextOwnerMask, uint GroupMask, uint EveryoneMask,
            uint BaseMask, byte saleType, int salePrice)
        {
-            ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
            // TODO: don't create new blocks if recycling an old packet
-            proper.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[1];
+            ObjectPropertiesPacket.ObjectDataBlock block =
-            proper.ObjectData[0] = new ObjectPropertiesPacket.ObjectDataBlock();
+                    new ObjectPropertiesPacket.ObjectDataBlock();
-            proper.ObjectData[0].ItemID = ItemID;
-            proper.ObjectData[0].CreationDate = CreationDate;
+            block.ItemID = ItemID;
-            proper.ObjectData[0].CreatorID = CreatorUUID;
+            block.CreationDate = CreationDate;
-            proper.ObjectData[0].FolderID = FolderUUID;
+            block.CreatorID = CreatorUUID;
-            proper.ObjectData[0].FromTaskID = FromTaskUUID;
+            block.FolderID = FolderUUID;
-            proper.ObjectData[0].GroupID = GroupUUID;
+            block.FromTaskID = FromTaskUUID;
-            proper.ObjectData[0].InventorySerial = InventorySerial;
+            block.GroupID = GroupUUID;
+            block.InventorySerial = InventorySerial;
-            proper.ObjectData[0].LastOwnerID = LastOwnerUUID;
+            block.LastOwnerID = LastOwnerUUID;
            //            proper.ObjectData[0].LastOwnerID = UUID.Zero;
-            proper.ObjectData[0].ObjectID = ObjectUUID;
+            block.ObjectID = ObjectUUID;
            if (OwnerUUID == GroupUUID)
-                proper.ObjectData[0].OwnerID = UUID.Zero;
+                block.OwnerID = UUID.Zero;
            else
-                proper.ObjectData[0].OwnerID = OwnerUUID;
+                block.OwnerID = OwnerUUID;
-            proper.ObjectData[0].TouchName = Util.StringToBytes256(TouchTitle);
+            block.TouchName = Util.StringToBytes256(TouchTitle);
-            proper.ObjectData[0].TextureID = TextureID;
+            block.TextureID = TextureID;
-            proper.ObjectData[0].SitName = Util.StringToBytes256(SitTitle);
+            block.SitName = Util.StringToBytes256(SitTitle);
-            proper.ObjectData[0].Name = Util.StringToBytes256(ItemName);
+            block.Name = Util.StringToBytes256(ItemName);
-            proper.ObjectData[0].Description = Util.StringToBytes256(ItemDescription);
+            block.Description = Util.StringToBytes256(ItemDescription);
-            proper.ObjectData[0].OwnerMask = OwnerMask;
+            block.OwnerMask = OwnerMask;
-            proper.ObjectData[0].NextOwnerMask = NextOwnerMask;
+            block.NextOwnerMask = NextOwnerMask;
-            proper.ObjectData[0].GroupMask = GroupMask;
+            block.GroupMask = GroupMask;
-            proper.ObjectData[0].EveryoneMask = EveryoneMask;
+            block.EveryoneMask = EveryoneMask;
-            proper.ObjectData[0].BaseMask = BaseMask;
+            block.BaseMask = BaseMask;
            //            proper.ObjectData[0].AggregatePerms = 53;
            //            proper.ObjectData[0].AggregatePermTextures = 0;
            //            proper.ObjectData[0].AggregatePermTexturesOwner = 0;
-            proper.ObjectData[0].SaleType = saleType;
+            block.SaleType = saleType;
-            proper.ObjectData[0].SalePrice = salePrice;
+            block.SalePrice = salePrice;
+            lock (m_propertiesPacketTimer)
+            {
+                m_propertiesBlocks.Add(block);
+                int length = 0;
+                foreach (ObjectPropertiesPacket.ObjectDataBlock b in m_propertiesBlocks)
+                {
+                    length += b.Length;
+                }
+                if (length > 1100) // FIXME: use real MTU
+                {
+                    ProcessObjectPropertiesPacket(null, null);
+                    m_propertiesPacketTimer.Stop();
+                    return;
+                }
+                    
+                m_propertiesPacketTimer.Stop();
+                m_propertiesPacketTimer.Start();
+            }
+            //proper.Header.Zerocoded = true;
+            //OutPacket(proper, ThrottleOutPacketType.Task);
+        }
+        private void ProcessObjectPropertiesPacket(Object sender, ElapsedEventArgs e)
+        {
+            ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            lock (m_propertiesPacketTimer)
+            {
+                m_propertiesPacketTimer.Stop();
+                proper.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[m_propertiesBlocks.Count];
+                int index = 0;
+                foreach (ObjectPropertiesPacket.ObjectDataBlock b in m_propertiesBlocks)
+                {
+                    proper.ObjectData[index++] = b;
+                }
+                m_propertiesBlocks.Clear();
+            }
            proper.Header.Zerocoded = true;
            OutPacket(proper, ThrottleOutPacketType.Task);
        }
@@ -5504,6 +5556,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            if (avSetStartLocationRequestPacket.AgentData.AgentID == AgentId && avSetStartLocationRequestPacket.AgentData.SessionID == SessionId)
            {
+                // Linden Client limitation..     
+                if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f
+                    || avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)
+                {
+                    ScenePresence avatar = null;
+                    if (((Scene)m_scene).TryGetAvatar(AgentId, out avatar))
+                    {
+                        if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f)
+                        {
+                            avSetStartLocationRequestPacket.StartLocationData.LocationPos.X = avatar.AbsolutePosition.X;
+                        }
+                        if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)
+                        {
+                            avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y = avatar.AbsolutePosition.Y;
+                        }
+                    }
+                }
                TeleportLocationRequest handlerSetStartLocationRequest = OnSetStartLocationRequest;
                if (handlerSetStartLocationRequest != null)
                {
@@ -13593,7 +13663,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                        if (handlerGodKickUser != null)
                        {
                            handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID,
-                                               gkupack.UserInfo.AgentID, (uint)0, gkupack.UserInfo.Reason);
+                                                   gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason,gkupack.UserInfo);
                        }
                    }
                    else
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 9856a1c..55d9c9c 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using log4net;
 using OpenSim.Framework;
 using OpenMetaverse;
@@ -430,6 +431,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                        m_udpServer.SendPacketFinal(nextPacket);
                        m_nextPackets[i] = null;
                        packetSent = true;
+                        this.PacketsSent++;
                    }
                }
                else
@@ -446,6 +448,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                            // Send the packet
                            m_udpServer.SendPacketFinal(packet);
                            packetSent = true;
+                            this.PacketsSent++;
                        }
                        else
                        {
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 98bb4f7..85961b9 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -138,6 +138,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// whether or not to sleep</summary>
        private bool m_packetSent;
+        /// <summary>Environment.TickCount of the last time that packet stats were reported to the scene</summary>
+        private int m_elapsedMSSinceLastStatReport = 0;
        /// <summary>Environment.TickCount of the last time the outgoing packet handler executed</summary>
        private int m_tickLastOutgoingPacketHandler;
        /// <summary>Keeps track of the number of elapsed milliseconds since the last time the outgoing packet handler looped</summary>
@@ -246,6 +248,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            // Start the packet processing threads
            Watchdog.StartThread(IncomingPacketHandler, "Incoming Packets (" + m_scene.RegionInfo.RegionName + ")", ThreadPriority.Normal, false);
            Watchdog.StartThread(OutgoingPacketHandler, "Outgoing Packets (" + m_scene.RegionInfo.RegionName + ")", ThreadPriority.Normal, false);
+            m_elapsedMSSinceLastStatReport = Environment.TickCount;
        }
        public new void Stop()
@@ -737,6 +740,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                // We don't need to do anything else with ping checks
                StartPingCheckPacket startPing = (StartPingCheckPacket)packet;
                CompletePing(udpClient, startPing.PingID.PingID);
+                if ((Environment.TickCount - m_elapsedMSSinceLastStatReport) >= 3000)
+                {
+                    udpClient.SendPacketStats();
+                    m_elapsedMSSinceLastStatReport = Environment.TickCount;
+                }
                return;
            }
            else if (packet.Type == PacketType.CompletePingCheck)
diff --git a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
index 273c128..7e1bed5 100644
--- a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
@@ -98,7 +98,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
        /// <param name="godID">The person doing the kicking</param>
        /// <param name="sessionID">The session of the person doing the kicking</param>
        /// <param name="agentID">the person that is being kicked</param>
-        /// <param name="kickflags">This isn't used apparently</param>
+        /// <param name="kickflags">Tells what to do to the user</param>
        /// <param name="reason">The message to send to the user after it's been turned into a field</param>
        public void KickUser(UUID godID, UUID sessionID, UUID agentID, uint kickflags, byte[] reason)
        {
@@ -110,39 +110,56 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
            {
                if (m_scene.Permissions.IsGod(godID))
                {
-                    if (agentID == kickUserID)
+                    if (kickflags == 0)
                    {
-                        string reasonStr = Utils.BytesToString(reason);
+                        if (agentID == kickUserID)
+                        {
+                            string reasonStr = Utils.BytesToString(reason);
-                        m_scene.ForEachClient(
+                            m_scene.ForEachClient(
-                            delegate(IClientAPI controller)
+                                delegate(IClientAPI controller)
-                            {
+                                                {
-                                if (controller.AgentId != godID)
+                                    if (controller.AgentId != godID)
-                                    controller.Kick(reasonStr);
+                                        controller.Kick(reasonStr);
-                            }
+                                }
-                        );
+                            );
-                        // This is a bit crude. It seems the client will be null before it actually stops the thread
+                            // This is a bit crude. It seems the client will be null before it actually stops the thread
-                        // The thread will kill itself eventually :/
+                            // The thread will kill itself eventually :/
-                        // Is there another way to make sure *all* clients get this 'inter region' message?
+                            // Is there another way to make sure *all* clients get this 'inter region' message?
-                        m_scene.ForEachScenePresence(
+                            m_scene.ForEachScenePresence(
-                            delegate(ScenePresence p)
+                                delegate(ScenePresence p)
-                            {
-                                if (p.UUID != godID && !p.IsChildAgent)
                                {
-                                    // Possibly this should really be p.Close() though that method doesn't send a close
+                                    if (p.UUID != godID && !p.IsChildAgent)
-                                    // to the client
+                                    {
-                                    p.ControllingClient.Close();
+                                        // Possibly this should really be p.Close() though that method doesn't send a close
+                                        // to the client
+                                        p.ControllingClient.Close();
+                                    }
                                }
-                            }
+                            );
-                        );
+                        }
+                        else
+                        {
+                            m_scene.SceneGraph.removeUserCount(!sp.IsChildAgent);
+                            sp.ControllingClient.Kick(Utils.BytesToString(reason));
+                            sp.ControllingClient.Close();
+                        }
                    }
-                    else
+                    
+                    if (kickflags == 1)
                    {
-                        m_scene.SceneGraph.removeUserCount(!sp.IsChildAgent);
+                        sp.AllowMovement = false;
+                        m_dialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
-                        sp.ControllingClient.Kick(Utils.BytesToString(reason));
+                        m_dialogModule.SendAlertToUser(godID, "User Frozen");
-                        sp.ControllingClient.Close();
+                    }
+                    
+                    if (kickflags == 2)
+                    {
+                        sp.AllowMovement = true;
+                        m_dialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
+                        m_dialogModule.SendAlertToUser(godID, "User Unfrozen");
                    }
                }
                else
diff --git a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
index 62500a2..c727cec 100644
--- a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
+++ b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
@@ -527,7 +527,6 @@ namespace OpenSim.Region.CoreModules.InterGrid
            userProfile.Partner = UUID.Zero;
            userProfile.PasswordHash = "$1$";
            userProfile.PasswordSalt = "";
-            userProfile.RootInventoryFolderID = UUID.Zero;
            userProfile.SurName = agentData.lastname;
            userProfile.UserAssetURI = homeScene.CommsManager.NetworkServersInfo.AssetURL;
            userProfile.UserFlags = 0;
diff --git a/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs b/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
index d4a28e2..60df2e7 100644
--- a/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/WorldComm/WorldCommModule.cs
@@ -602,9 +602,12 @@ namespace OpenSim.Region.CoreModules.Scripting.WorldComm
                ListenerInfo info =
                        ListenerInfo.FromData(localID, itemID, hostID, item);
-                if (!m_listeners.ContainsKey((int)item[2]))
+                lock (m_listeners)
-                    m_listeners.Add((int)item[2], new List<ListenerInfo>());
+                {
-                m_listeners[(int)item[2]].Add(info);
+                    if (!m_listeners.ContainsKey((int)item[2]))
+                        m_listeners.Add((int)item[2], new List<ListenerInfo>());
+                    m_listeners[(int)item[2]].Add(info);
+                }
                idx+=6;
            }
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Authorization/RemoteAuthorizationServiceConnector.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Authorization/RemoteAuthorizationServiceConnector.cs
index fca2df2..68499f3 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Authorization/RemoteAuthorizationServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Authorization/RemoteAuthorizationServiceConnector.cs
@@ -70,7 +70,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Authorization
                    IConfig authorizationConfig = source.Configs["AuthorizationService"];
                    if (authorizationConfig == null)
                    {
-                        m_log.Error("[REMOTE AUTHORIZATION CONNECTOR]: AuthorizationService missing from OpenSim.ini");
+                        m_log.Info("[REMOTE AUTHORIZATION CONNECTOR]: AuthorizationService missing from OpenSim.ini");
                        return;
                    }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
index 114dd13..3c0997c 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
@@ -453,6 +453,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
        /// <summary>
        /// Resolve path to a working FileStream
        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
        private Stream GetStream(string path)
        {
            if (File.Exists(path))
@@ -499,8 +501,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver
            WebResponse response = request.GetResponse();
            Stream file = response.GetResponseStream();
-            if (response.ContentType != "application/x-oar")
+            // justincc: gonna ignore the content type for now and just try anything
-                throw new Exception(String.Format("{0} does not identify an OAR file", uri.ToString()));
+            //if (response.ContentType != "application/x-oar")
+            //    throw new Exception(String.Format("{0} does not identify an OAR file", uri.ToString()));
            if (response.ContentLength == 0)
                throw new Exception(String.Format("{0} returned an empty file", uri.ToString()));
diff --git a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
index e3a395e..b1dcb14 100644
--- a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
@@ -471,20 +471,45 @@ namespace OpenSim.Region.CoreModules.World.Estate
            if (terr != null)
            {
                m_log.Warn("[CLIENT]: Got Request to Send Terrain in region " + m_scene.RegionInfo.RegionName);
-                if (File.Exists(Util.dataDir() + "/terrain.raw"))
-                {
-                    File.Delete(Util.dataDir() + "/terrain.raw");
-                }
                try
                {
-                    FileStream input = new FileStream(Util.dataDir() + "/terrain.raw", FileMode.CreateNew);
+                    string localfilename = "terrain.raw";
+                    if (terrainData.Length == 851968)
+                    {
+                        localfilename = Path.Combine(Util.dataDir(),"terrain.raw"); // It's a .LLRAW
+                    }
+                    if (terrainData.Length == 196662) // 24-bit 256x256 Bitmap
+                        localfilename = Path.Combine(Util.dataDir(), "terrain.bmp");
+                    if (terrainData.Length == 256 * 256 * 4) // It's a .R32
+                        localfilename = Path.Combine(Util.dataDir(), "terrain.r32");
+                    if (terrainData.Length == 256 * 256 * 8) // It's a .R64
+                        localfilename = Path.Combine(Util.dataDir(), "terrain.r64");
+                    if (File.Exists(localfilename))
+                    {
+                        File.Delete(localfilename);
+                    }
+                    FileStream input = new FileStream(localfilename, FileMode.CreateNew);
                    input.Write(terrainData, 0, terrainData.Length);
                    input.Close();
+                    FileInfo x = new FileInfo(localfilename);
+                    terr.LoadFromFile(localfilename);
+                    remoteClient.SendAlertMessage("Your terrain was loaded as a ." + x.Extension + " file. It may take a few moments to appear.");
                }
                catch (IOException e)
                {
                    m_log.ErrorFormat("[TERRAIN]: Error Saving a terrain file uploaded via the estate tools.  It gave us the following error: {0}", e.ToString());
-                    remoteClient.SendAlertMessage("There was an IO Exception loading your terrain.  Please check free space");
+                    remoteClient.SendAlertMessage("There was an IO Exception loading your terrain.  Please check free space.");
                    return;
                }
@@ -502,29 +527,16 @@ namespace OpenSim.Region.CoreModules.World.Estate
                    return;
                }
-                try
-                {
-                    terr.LoadFromFile(Util.dataDir() + "/terrain.raw");
-                    remoteClient.SendAlertMessage("Your terrain was loaded. Give it a minute or two to apply");
-                }
                catch (Exception e)
                {
                    m_log.ErrorFormat("[TERRAIN]: Error loading a terrain file uploaded via the estate tools.  It gave us the following error: {0}", e.ToString());
                    remoteClient.SendAlertMessage("There was a general error loading your terrain.  Please fix the terrain file and try again");
                }
            }
            else
            {
                remoteClient.SendAlertMessage("Unable to apply terrain.  Cannot get an instance of the terrain module");
            }
        }
        private void handleUploadTerrain(IClientAPI remote_client, string clientFileName)
diff --git a/OpenSim/Region/CoreModules/World/Meta7Windlight/Meta7WindlightModule.cs b/OpenSim/Region/CoreModules/World/Meta7Windlight/Meta7WindlightModule.cs
new file mode 100644
index 0000000..f180b47
--- /dev/null
+++ b/OpenSim/Region/CoreModules/World/Meta7Windlight/Meta7WindlightModule.cs
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) Thomas Grimshaw and Magne Metaverse Research
+ *  
+ * This module is not open source. All rights reserved.
+ * Unauthorised copying, distribution or public display is prohibited.
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Data;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Framework.InterfaceCommander;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+namespace OpenSim.Region.CoreModules.World.Meta7Windlight
+{
+    public class Meta7WindlightModule : IRegionModule, ICommandableModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private readonly Commander m_commander = new Commander("windlight");
+        private Scene m_scene;
+        private static bool m_enableWindlight;
+        #region ICommandableModule Members
+        public ICommander CommandInterface
+        {
+            get { return m_commander; }
+        }
+        #endregion
+        #region IRegionModule Members
+        public static bool EnableWindlight
+        {
+            get
+            {
+                return m_enableWindlight;
+            }
+            set
+            {
+            }
+        }
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            m_scene = scene;
+            m_scene.RegisterModuleInterface<IRegionModule>(this);
+            m_scene.EventManager.OnPluginConsole += EventManager_OnPluginConsole;
+            
+            // ini file settings
+            try
+            {
+                m_enableWindlight = config.Configs["Meta7Windlight"].GetBoolean("enable_windlight", false);
+            }
+            catch (Exception)
+            {
+                m_log.Debug("[WINDLIGHT]: ini failure for enable_windlight - using default");
+            }
+            if (m_enableWindlight)
+            {
+                m_scene.EventManager.OnMakeRootAgent += EventManager_OnMakeRootAgent;
+                m_scene.EventManager.OnSaveNewWindlightProfile += EventManager_OnSaveNewWindlightProfile;
+            }
+            InstallCommands();
+            m_log.Debug("[WINDLIGHT]: Initialised windlight module");
+        }
+        public void SendProfileToClient(ScenePresence presence)
+        {
+            if (m_enableWindlight)
+            {
+                if (presence.IsChildAgent == false)
+                {
+                    IClientAPI client = presence.ControllingClient;
+                    RegionMeta7WindlightData wl = m_scene.RegionInfo.WindlightSettings;
+                    byte[] mBlock = new Byte[249];
+                    int pos = 0;
+                    wl.waterColor.ToBytes(mBlock, 0); pos += 12;
+                    Utils.FloatToBytes(wl.waterFogDensityExponent).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.underwaterFogModifier).CopyTo(mBlock, pos); pos += 4;
+                    wl.reflectionWaveletScale.ToBytes(mBlock, pos); pos += 12;
+                    Utils.FloatToBytes(wl.fresnelScale).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.fresnelOffset).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.refractScaleAbove).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.refractScaleBelow).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.blurMultiplier).CopyTo(mBlock, pos); pos += 4;
+                    wl.bigWaveDirection.ToBytes(mBlock, pos); pos += 8;
+                    wl.littleWaveDirection.ToBytes(mBlock, pos); pos += 8;
+                    wl.normalMapTexture.ToBytes(mBlock, pos); pos += 16;
+                    wl.horizon.ToBytes(mBlock, pos); pos += 16;
+                    Utils.FloatToBytes(wl.hazeHorizon).CopyTo(mBlock, pos); pos += 4;
+                    wl.blueDensity.ToBytes(mBlock, pos); pos += 16;
+                    Utils.FloatToBytes(wl.hazeDensity).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.densityMultiplier).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.distanceMultiplier).CopyTo(mBlock, pos); pos += 4;
+                    wl.sunMoonColor.ToBytes(mBlock, pos); pos += 16;
+                    Utils.FloatToBytes(wl.sunMoonPosition).CopyTo(mBlock, pos); pos += 4;
+                    wl.ambient.ToBytes(mBlock, pos); pos += 16;
+                    Utils.FloatToBytes(wl.eastAngle).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.sunGlowFocus).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.sunGlowSize).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.sceneGamma).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.starBrightness).CopyTo(mBlock, pos); pos += 4;
+                    wl.cloudColor.ToBytes(mBlock, pos); pos += 16;
+                    wl.cloudXYDensity.ToBytes(mBlock, pos); pos += 12;
+                    Utils.FloatToBytes(wl.cloudCoverage).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.cloudScale).CopyTo(mBlock, pos); pos += 4;
+                    wl.cloudDetailXYDensity.ToBytes(mBlock, pos); pos += 12;
+                    Utils.FloatToBytes(wl.cloudScrollX).CopyTo(mBlock, pos); pos += 4;
+                    Utils.FloatToBytes(wl.cloudScrollY).CopyTo(mBlock, pos); pos += 4;
+                    Utils.UInt16ToBytes(wl.maxAltitude).CopyTo(mBlock, pos); pos += 2;
+                    mBlock[pos] = Convert.ToByte(wl.cloudScrollXLock); pos++;
+                    mBlock[pos] = Convert.ToByte(wl.cloudScrollYLock); pos++;
+                    mBlock[pos] = Convert.ToByte(wl.drawClassicClouds); pos++;
+                    List<byte[]> param = new List<byte[]>();
+                    param.Add(mBlock);
+                    client.SendGenericMessage("Windlight", param);
+                }
+            }
+            else
+            {
+                //We probably don't want to spam chat with this.. probably
+                //m_log.Debug("[WINDLIGHT]: Module disabled");
+            }
+        }
+        private void EventManager_OnMakeRootAgent(ScenePresence presence)
+        {
+            m_log.Debug("[WINDLIGHT]: Sending windlight scene to new client");
+            SendProfileToClient(presence);
+        }
+        private void EventManager_OnSaveNewWindlightProfile()
+        {
+            m_scene.ForEachScenePresence(SendProfileToClient);
+        }
+        public void PostInitialise()
+        {
+        }
+        public void Close()
+        {
+        }
+        public string Name
+        {
+            get { return "Meta7WindlightModule"; }
+        }
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+        #endregion
+        #region events
+        #endregion
+        #region ICommandableModule Members
+        private void InstallCommands()
+        {
+            Command wlload = new Command("load", CommandIntentions.COMMAND_NON_HAZARDOUS, HandleLoad, "Load windlight profile from the database and broadcast");
+            Command wlenable = new Command("enable", CommandIntentions.COMMAND_NON_HAZARDOUS, HandleEnable, "Enable the windlight plugin");
+            Command wldisable = new Command("disable", CommandIntentions.COMMAND_NON_HAZARDOUS, HandleDisable, "Enable the windlight plugin");
+            m_commander.RegisterCommand("load", wlload);
+            m_commander.RegisterCommand("enable", wlenable);
+            m_commander.RegisterCommand("disable", wldisable);
+            m_scene.RegisterModuleCommander(m_commander);
+        }
+        private void HandleLoad(Object[] args)
+        {
+            if (!m_enableWindlight)
+            {
+                m_log.InfoFormat("[WINDLIGHT]: Cannot load windlight profile, module disabled. Use 'windlight enable' first.");
+            }
+            else
+            {
+                m_log.InfoFormat("[WINDLIGHT]: Loading Windlight profile from database");
+                m_scene.LoadWindlightProfile();
+                m_log.InfoFormat("[WINDLIGHT]: Load complete");
+            }
+        }
+        private void HandleDisable(Object[] args)
+        {
+            m_log.InfoFormat("[WINDLIGHT]: Plugin now disabled");
+            m_enableWindlight=false;
+        }
+        private void HandleEnable(Object[] args)
+        {
+            m_log.InfoFormat("[WINDLIGHT]: Plugin now enabled");
+            m_enableWindlight = true;
+        }
+        /// <summary>
+        /// Processes commandline input. Do not call directly.
+        /// </summary>
+        /// <param name="args">Commandline arguments</param>
+        private void EventManager_OnPluginConsole(string[] args)
+        {
+            if (args[0] == "windlight")
+            {
+                if (args.Length == 1)
+                {
+                    m_commander.ProcessConsoleCommand("add", new string[0]);
+                    return;
+                }
+                string[] tmpArgs = new string[args.Length - 2];
+                int i;
+                for (i = 2; i < args.Length; i++)
+                {
+                    tmpArgs[i - 2] = args[i];
+                }
+                m_commander.ProcessConsoleCommand(args[1], tmpArgs);
+            }
+        }
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index 013a0ef..c9b3071 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -800,30 +800,31 @@ namespace OpenSim.Region.CoreModules.World.Permissions
        }
    
        protected bool GenericParcelOwnerPermission(UUID user, ILandObject parcel, ulong groupPowers)
-        {
+        {          
-            bool permission = false;
            if (parcel.LandData.OwnerID == user)
            {
-                permission = true;
+                // Returning immediately so that group deeded objects on group deeded land don't trigger a NRE on
+                // the subsequent redundant checks when using lParcelMediaCommandList()
+                // See http://opensimulator.org/mantis/view.php?id=3999 for more details
+                return true;
            }
            if (parcel.LandData.IsGroupOwned && IsGroupMember(parcel.LandData.GroupID, user, groupPowers))
            {
-                permission = true;
+                return true;
            }
    
            if (IsEstateManager(user))
            {
-                permission = true;
+                return true;
            }
            if (IsAdministrator(user))
            {
-                permission = true;
+                return true;
            }
-            return permission;
+            return false;
        }
        protected bool GenericParcelPermission(UUID user, Vector3 pos, ulong groupPowers)
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
index ba271fd..a40828b 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
@@ -29,6 +29,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Net;
 using log4net;
 using Nini.Config;
 using OpenMetaverse;
@@ -259,6 +260,16 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        }
        /// <summary>
+        /// Loads a terrain file from the specified URI
+        /// </summary>
+        /// <param name="filename">The name of the terrain to load</param>
+        /// <param name="pathToTerrainHeightmap">The URI to the terrain height map</param>
+        public void LoadFromStream(string filename, Uri pathToTerrainHeightmap)
+        {
+            LoadFromStream(filename, URIFetch(pathToTerrainHeightmap));
+        }
+        /// <summary>
        /// Loads a terrain file from a stream and installs it in the scene.
        /// </summary>
        /// <param name="filename">Filename to terrain file. Type is determined by extension.</param>
@@ -267,7 +278,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        {
            foreach (KeyValuePair<string, ITerrainLoader> loader in m_loaders)
            {
-                if (@filename.EndsWith(loader.Key))
+                if (filename.EndsWith(loader.Key))
                {
                    lock (m_scene)
                    {
@@ -295,6 +306,25 @@ namespace OpenSim.Region.CoreModules.World.Terrain
            throw new TerrainException(String.Format("unable to load heightmap from file {0}: no loader available for that format", filename));
        }
+        private static Stream URIFetch(Uri uri)
+        {
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
+            // request.Credentials = credentials;
+            request.ContentLength = 0;
+            request.KeepAlive = false;
+            WebResponse response = request.GetResponse();
+            Stream file = response.GetResponseStream();
+            if (response.ContentLength == 0)
+                throw new Exception(String.Format("{0} returned an empty file", uri.ToString()));
+            // return new BufferedStream(file, (int) response.ContentLength);
+            return new BufferedStream(file, 1000000);
+        }
        /// <summary>
        /// Modify Land
        /// </summary>
diff --git a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
index 9754da3..816060f 100644
--- a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
+++ b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
@@ -433,7 +433,7 @@ namespace OpenSim.Region.Examples.SimpleModule
            
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
        }
diff --git a/OpenSim/Region/Framework/Interfaces/IRegionDataStore.cs b/OpenSim/Region/Framework/Interfaces/IRegionDataStore.cs
index 78bd622..7312799 100644
--- a/OpenSim/Region/Framework/Interfaces/IRegionDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/IRegionDataStore.cs
@@ -103,6 +103,8 @@ namespace OpenSim.Region.Framework.Interfaces
        void StoreRegionSettings(RegionSettings rs);
        RegionSettings LoadRegionSettings(UUID regionUUID);
+        RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID);
+        void StoreRegionWindlightSettings(RegionMeta7WindlightData wl);
        void Shutdown();
    }
diff --git a/OpenSim/Region/Framework/Interfaces/ITerrainModule.cs b/OpenSim/Region/Framework/Interfaces/ITerrainModule.cs
index 2dcba0c..7caac55 100644
--- a/OpenSim/Region/Framework/Interfaces/ITerrainModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ITerrainModule.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Region.Framework.Interfaces
        /// </param>
        /// <param name="stream"></param>
        void LoadFromStream(string filename, Stream stream);
+        void LoadFromStream(string filename, System.Uri pathToTerrainHeightmap);
        /// <summary>
        /// Save a terrain to a stream.
        /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index b031f61..50624a1 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -448,5 +448,11 @@ namespace OpenSim.Region.Framework.Scenes.Animation
            SendAnimPack(animIDs, sequenceNums, objectIDs);
        }
+        public void Close()
+        {
+            m_animations = null;
+            m_scenePresence = null;
+        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/EntityManager.cs b/OpenSim/Region/Framework/Scenes/EntityManager.cs
index 099fcce..c246e32 100644
--- a/OpenSim/Region/Framework/Scenes/EntityManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EntityManager.cs
@@ -40,7 +40,7 @@ namespace OpenSim.Region.Framework.Scenes
        private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();
        private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();
        //private readonly Dictionary<UUID, ScenePresence> m_pres_uuid = new Dictionary<UUID, ScenePresence>();
-        private readonly Object m_lock = new Object();
+        private System.Threading.ReaderWriterLockSlim m_lock = new System.Threading.ReaderWriterLockSlim();
        [Obsolete("Use Add() instead.")]
        public void Add(UUID id, EntityBase eb)
@@ -50,7 +50,8 @@ namespace OpenSim.Region.Framework.Scenes
        public void Add(EntityBase entity)
        {
-            lock (m_lock)
+            m_lock.EnterWriteLock();
+            try
            {
                try
                {
@@ -62,11 +63,16 @@ namespace OpenSim.Region.Framework.Scenes
                    m_log.ErrorFormat("Add Entity failed: {0}", e.Message);
                }
            }
+            finally
+            {
+                m_lock.ExitWriteLock();
+            }
        }
        public void InsertOrReplace(EntityBase entity)
        {
-            lock (m_lock)
+            m_lock.EnterWriteLock();
+            try
            {
                try
                {
@@ -78,15 +84,24 @@ namespace OpenSim.Region.Framework.Scenes
                    m_log.ErrorFormat("Insert or Replace Entity failed: {0}", e.Message);
                }
            }
+            finally
+            {
+                m_lock.ExitWriteLock();
+            }
        }
        public void Clear()
        {
-            lock (m_lock)
+            m_lock.EnterWriteLock();
+            try
            {
                m_eb_uuid.Clear();
                m_eb_localID.Clear();
            }
+            finally
+            {
+                m_lock.ExitWriteLock();
+            }
        }
        public int Count
@@ -123,7 +138,8 @@ namespace OpenSim.Region.Framework.Scenes
        public bool Remove(uint localID)
        {
-            lock (m_lock)
+            m_lock.EnterWriteLock();
+            try
            {
                try
                {
@@ -141,11 +157,16 @@ namespace OpenSim.Region.Framework.Scenes
                    return false;
                }
            }
+            finally
+            {
+                m_lock.ExitWriteLock();
+            }
        }
        public bool Remove(UUID id)
        {
-            lock (m_lock)
+            m_lock.EnterWriteLock();
+            try
            {
                try 
                {
@@ -163,13 +184,18 @@ namespace OpenSim.Region.Framework.Scenes
                    return false;
                }
            }
+            finally
+            {
+                m_lock.ExitWriteLock();
+            }
        }
        public List<EntityBase> GetAllByType<T>()
        {
            List<EntityBase> tmp = new List<EntityBase>();
-            lock (m_lock)
+            m_lock.EnterReadLock();
+            try
            {
                try
                {
@@ -187,23 +213,33 @@ namespace OpenSim.Region.Framework.Scenes
                    tmp = null;
                }
            }
+            finally
+            {
+                m_lock.ExitReadLock();
+            }
            return tmp;
        }
        public List<EntityBase> GetEntities()
        {
-            lock (m_lock)
+            m_lock.EnterReadLock();
+            try
            {
                return new List<EntityBase>(m_eb_uuid.Values);
            }
+            finally
+            {
+                m_lock.ExitReadLock();
+            }
        }
        public EntityBase this[UUID id]
        {
            get
            {
-                lock (m_lock)
+                m_lock.EnterReadLock();
+                try
                {
                    EntityBase entity;
                    if (m_eb_uuid.TryGetValue(id, out entity))
@@ -211,6 +247,10 @@ namespace OpenSim.Region.Framework.Scenes
                    else
                        return null;
                }
+                finally
+                {
+                    m_lock.ExitReadLock();
+                }
            }
            set
            {
@@ -222,7 +262,8 @@ namespace OpenSim.Region.Framework.Scenes
        {
            get
            {
-                lock (m_lock)
+                m_lock.EnterReadLock();
+                try
                {
                    EntityBase entity;
                    if (m_eb_localID.TryGetValue(localID, out entity))
@@ -230,6 +271,10 @@ namespace OpenSim.Region.Framework.Scenes
                    else
                        return null;
                }
+                finally
+                {
+                    m_lock.ExitReadLock();
+                }
            }
            set
            {
@@ -239,18 +284,28 @@ namespace OpenSim.Region.Framework.Scenes
        public bool TryGetValue(UUID key, out EntityBase obj)
        {
-            lock (m_lock)
+            m_lock.EnterReadLock();
+            try
            {
                return m_eb_uuid.TryGetValue(key, out obj);
            }
+            finally
+            {
+                m_lock.ExitReadLock();
+            }
        }
        public bool TryGetValue(uint key, out EntityBase obj)
        {
-            lock (m_lock)
+            m_lock.EnterReadLock();
+            try
            {
                return m_eb_localID.TryGetValue(key, out obj);
            }
+            finally
+            {
+                m_lock.ExitReadLock();
+            }
        }
        /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 753344d..a86e263 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -193,7 +193,9 @@ namespace OpenSim.Region.Framework.Scenes
        public event OnMakeChildAgentDelegate OnMakeChildAgent;
        public delegate void OnMakeRootAgentDelegate(ScenePresence presence);
+        public delegate void OnSaveNewWindlightProfileDelegate();
        public event OnMakeRootAgentDelegate OnMakeRootAgent;
+        public event OnSaveNewWindlightProfileDelegate OnSaveNewWindlightProfile;
        public delegate void NewInventoryItemUploadComplete(UUID avatarID, UUID assetID, string name, int userlevel);
@@ -411,6 +413,7 @@ namespace OpenSim.Region.Framework.Scenes
        private IncomingInstantMessage handlerUnhandledInstantMessage = null; //OnUnhandledInstantMessage;
        private ClientClosed handlerClientClosed = null; //OnClientClosed;
        private OnMakeChildAgentDelegate handlerMakeChildAgent = null; //OnMakeChildAgent;
+        private OnSaveNewWindlightProfileDelegate handlerSaveNewWindlightProfile = null; //OnSaveNewWindlightProfile;
        private OnMakeRootAgentDelegate handlerMakeRootAgent = null; //OnMakeRootAgent;
        private OnTerrainTickDelegate handlerTerrainTick = null; // OnTerainTick;
        private RegisterCapsEvent handlerRegisterCaps = null; // OnRegisterCaps;
@@ -772,6 +775,15 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        public void TriggerOnSaveNewWindlightProfile()
+        {
+            handlerSaveNewWindlightProfile = OnSaveNewWindlightProfile;
+            if (handlerSaveNewWindlightProfile != null)
+            {
+                handlerSaveNewWindlightProfile();
+            }
+        }
        public void TriggerOnMakeRootAgent(ScenePresence presence)
        {
            handlerMakeRootAgent = OnMakeRootAgent;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 83208e9..7ca779a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -1726,10 +1726,19 @@ namespace OpenSim.Region.Framework.Scenes
                if (folderID == UUID.Zero && folder == null)
                {
-                    // Catch all. Use lost & found
+                    if (action == DeRezAction.Delete)
-                    //
+                    {
+                        // Deletes go to trash by default
+                        //
+                        folder = InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                    }
+                    else
+                    {
+                        // Catch all. Use lost & found
+                        //
-                    folder = InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                        folder = InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                    }
                }
                if (folder == null) // None of the above
@@ -2388,6 +2397,12 @@ namespace OpenSim.Region.Framework.Scenes
                InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
                item = InventoryService.GetItem(item);
                presence.Appearance.SetAttachment((int)AttachmentPt, itemID, item.AssetID /*att.UUID*/);
+                if (m_AvatarFactory != null)
+                {
+                    m_AvatarFactory.UpdateDatabase(remoteClient.AgentId, presence.Appearance);
+                }
            }
        }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 3034f9a..1b275b0 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -310,7 +310,7 @@ namespace OpenSim.Region.Framework.Scenes
        private Thread HeartbeatThread;
        private volatile bool shuttingdown;
-        private int m_lastUpdate = Environment.TickCount;
+        private int m_lastUpdate;
        private bool m_firstHeartbeat = true;
        private UpdatePrioritizationSchemes m_update_prioritization_scheme = UpdatePrioritizationSchemes.Time;
@@ -526,6 +526,7 @@ namespace OpenSim.Region.Framework.Scenes
            m_regionHandle = m_regInfo.RegionHandle;
            m_regionName = m_regInfo.RegionName;
            m_datastore = m_regInfo.DataStore;
+            m_lastUpdate = Util.EnvironmentTickCount();
            m_physicalPrim = physicalPrim;
            m_seeIntoRegionFromNeighbor = SeeIntoRegionFromNeighbor;
@@ -538,6 +539,8 @@ namespace OpenSim.Region.Framework.Scenes
            // Load region settings
            m_regInfo.RegionSettings = m_storageManager.DataStore.LoadRegionSettings(m_regInfo.RegionID);
+            m_regInfo.WindlightSettings = m_storageManager.DataStore.LoadRegionWindlightSettings(m_regInfo.RegionID);
            if (m_storageManager.EstateDataStore != null)
            {
                m_regInfo.EstateSettings = m_storageManager.EstateDataStore.LoadEstateSettings(m_regInfo.RegionID);
@@ -735,6 +738,8 @@ namespace OpenSim.Region.Framework.Scenes
            m_regInfo = regInfo;
            m_eventManager = new EventManager();
+            m_lastUpdate = Util.EnvironmentTickCount();
        }
        #endregion
@@ -1101,7 +1106,7 @@ namespace OpenSim.Region.Framework.Scenes
                HeartbeatThread.Abort();
                HeartbeatThread = null;
            }
-            m_lastUpdate = Environment.TickCount;
+            m_lastUpdate = Util.EnvironmentTickCount();
            HeartbeatThread = Watchdog.StartThread(Heartbeat, "Heartbeat for region " + RegionInfo.RegionName, ThreadPriority.Normal, false);
        }
@@ -1142,7 +1147,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                Update();
-                m_lastUpdate = Environment.TickCount;
+                m_lastUpdate = Util.EnvironmentTickCount();
                m_firstHeartbeat = false;
            }
            catch (ThreadAbortException)
@@ -1170,8 +1175,9 @@ namespace OpenSim.Region.Framework.Scenes
                TimeSpan SinceLastFrame = DateTime.UtcNow - m_lastupdate;
                physicsFPS = 0f;
-                maintc = otherMS = Environment.TickCount;
+                maintc = Util.EnvironmentTickCount();
                int tmpFrameMS = maintc;
+                tempOnRezMS = eventMS = backupMS = terrainMS = landMS = 0;
                // Increment the frame counter
                ++m_frame;
@@ -1191,16 +1197,15 @@ namespace OpenSim.Region.Framework.Scenes
                    if (m_frame % m_update_objects == 0)
                        m_sceneGraph.UpdateObjectGroups();
-                    int TempPhysicsMS2 = Environment.TickCount;
+                    int tmpPhysicsMS2 = Util.EnvironmentTickCount();
                    if ((m_frame % m_update_physics == 0) && m_physics_enabled)
                        m_sceneGraph.UpdatePreparePhysics();
-                    TempPhysicsMS2 = Environment.TickCount - TempPhysicsMS2;
+                    physicsMS2 = Util.EnvironmentTickCountSubtract(tmpPhysicsMS2);
-                    physicsMS2 = TempPhysicsMS2;
                    if (m_frame % m_update_entitymovement == 0)
                        m_sceneGraph.UpdateScenePresenceMovement();
-                    int TempPhysicsMS = Environment.TickCount;
+                    int tmpPhysicsMS = Util.EnvironmentTickCount();
                    if (m_frame % m_update_physics == 0)
                    {
                        if (m_physics_enabled)
@@ -1208,57 +1213,49 @@ namespace OpenSim.Region.Framework.Scenes
                        if (SynchronizeScene != null)
                            SynchronizeScene(this);
                    }
-                    TempPhysicsMS = Environment.TickCount - TempPhysicsMS;
+                    physicsMS = Util.EnvironmentTickCountSubtract(tmpPhysicsMS);
-                    physicsMS = TempPhysicsMS;
                    // Delete temp-on-rez stuff
                    if (m_frame % m_update_backup == 0)
                    {
-                        int tozMS = Environment.TickCount;
+                        int tmpTempOnRezMS = Util.EnvironmentTickCount();
                        CleanTempObjects();
-                        tozMS -= Environment.TickCount;
+                        tempOnRezMS = Util.EnvironmentTickCountSubtract(tmpTempOnRezMS);
-                        tempOnRezMS = tozMS;
                    }
                    if (RegionStatus != RegionStatus.SlaveScene)
                    {
                        if (m_frame % m_update_events == 0)
                        {
-                            int evMS = Environment.TickCount;
+                            int evMS = Util.EnvironmentTickCount();
                            UpdateEvents();
-                            evMS -= Environment.TickCount;
+                            eventMS = Util.EnvironmentTickCountSubtract(evMS); ;
-                            eventMS = evMS;
                        }
                        if (m_frame % m_update_backup == 0)
                        {
-                            int backMS = Environment.TickCount;
+                            int backMS = Util.EnvironmentTickCount();
                            UpdateStorageBackup();
-                            backMS -= Environment.TickCount;
+                            backupMS = Util.EnvironmentTickCountSubtract(backMS);
-                            backupMS = backMS;
                        }
                        if (m_frame % m_update_terrain == 0)
                        {
-                            int terMS = Environment.TickCount;
+                            int terMS = Util.EnvironmentTickCount();
                            UpdateTerrain();
-                            terMS -= Environment.TickCount;
+                            terrainMS = Util.EnvironmentTickCountSubtract(terMS);
-                            terrainMS = terMS;
                        }
                        if (m_frame % m_update_land == 0)
                        {
-                            int ldMS = Environment.TickCount;
+                            int ldMS = Util.EnvironmentTickCount();
                            UpdateLand();
-                            ldMS -= Environment.TickCount;
+                            landMS = Util.EnvironmentTickCountSubtract(ldMS);
-                            landMS = ldMS;
                        }
-                        int tickCount = Environment.TickCount;
+                        frameMS = Util.EnvironmentTickCountSubtract(tmpFrameMS);
-                        otherMS = tickCount - otherMS;
+                        otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
-                        tmpFrameMS -= tickCount;
+                        lastCompletedFrame = Util.EnvironmentTickCount();
-                        frameMS = tmpFrameMS;
-                        lastCompletedFrame = tickCount;
                        // if (m_frame%m_update_avatars == 0)
                        //   UpdateInWorldTime();
@@ -1311,8 +1308,8 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    m_lastupdate = DateTime.UtcNow;
                }
-                
-                maintc = Environment.TickCount - maintc;
+                maintc = Util.EnvironmentTickCountSubtract(maintc);
                maintc = (int)(m_timespan * 1000) - maintc;
                if ((maintc < (m_timespan * 1000)) && maintc > 0)
@@ -1323,6 +1320,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        
        public void AddGroupTarget(SceneObjectGroup grp)
        {
@@ -1506,6 +1504,19 @@ namespace OpenSim.Region.Framework.Scenes
        {
            m_storageManager.DataStore.StoreTerrain(Heightmap.GetDoubles(), RegionInfo.RegionID);
        }
+        
+        public void StoreWindlightProfile(RegionMeta7WindlightData wl)
+        {
+            m_regInfo.WindlightSettings = wl;
+            m_storageManager.DataStore.StoreRegionWindlightSettings(wl);
+            m_eventManager.TriggerOnSaveNewWindlightProfile();
+        }
+        public void LoadWindlightProfile()
+        {
+            m_regInfo.WindlightSettings = m_storageManager.DataStore.LoadRegionWindlightSettings(RegionInfo.RegionID);
+            m_eventManager.TriggerOnSaveNewWindlightProfile();
+        }
        /// <summary>
        /// Loads the World heightmap
@@ -2599,7 +2610,7 @@ namespace OpenSim.Region.Framework.Scenes
                }
            }
-            m_LastLogin = Environment.TickCount;
+            m_LastLogin = Util.EnvironmentTickCount();
            EventManager.TriggerOnNewClient(client);
        }
@@ -3050,6 +3061,7 @@ namespace OpenSim.Region.Framework.Scenes
                // TODO: The next line can be removed, as soon as only homeRegionID based UserServers are around.
                // TODO: The HomeRegion property can be removed then, too
                UserProfile.HomeRegion = RegionInfo.RegionHandle;
                UserProfile.HomeLocation = position;
                UserProfile.HomeLookAt = lookAt;
                CommsManager.UserService.UpdateUserProfile(UserProfile);
@@ -4410,16 +4422,6 @@ namespace OpenSim.Region.Framework.Scenes
        #endregion
-        #region Avatar Appearance Default
-        public static void GetDefaultAvatarAppearance(out AvatarWearable[] wearables, out byte[] visualParams)
-        {
-            visualParams = AvatarAppearance.GetDefaultVisualParams();
-            wearables = AvatarWearable.DefaultWearables;
-        }
-        #endregion
        public void RegionHandleRequest(IClientAPI client, UUID regionID)
        {
            ulong handle = 0;
@@ -4678,14 +4680,14 @@ namespace OpenSim.Region.Framework.Scenes
            //
            int health=1; // Start at 1, means we're up
-            if ((Environment.TickCount - m_lastUpdate) < 1000)
+            if ((Util.EnvironmentTickCountSubtract(m_lastUpdate)) < 1000)
                health+=1;
            else
                return health;
            // A login in the last 4 mins? We can't be doing too badly
            //
-            if ((Environment.TickCount - m_LastLogin) < 240000)
+            if ((Util.EnvironmentTickCountSubtract(m_LastLogin)) < 240000)
                health++;
            else
                return health;
@@ -4883,7 +4885,7 @@ namespace OpenSim.Region.Framework.Scenes
            if (m_firstHeartbeat)
                return;
-            if (System.Environment.TickCount - m_lastUpdate > 2000)
+            if (Util.EnvironmentTickCountSubtract(m_lastUpdate) > 2000)
                StartTimer();
        }
    }
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 2fdb48d..f74fd5d 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -26,6 +26,7 @@
 */
 using System;
+using System.Threading;
 using System.Collections.Generic;
 using System.Reflection;
 using OpenMetaverse;
@@ -96,6 +97,8 @@ namespace OpenSim.Region.Framework.Scenes
        protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullID = new Dictionary<UUID, SceneObjectGroup>();
        private readonly Object m_dictionary_lock = new Object();
+        private Object m_updateLock = new Object();
        #endregion
        protected internal SceneGraph(Scene parent, RegionInfo regInfo)
@@ -369,6 +372,9 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        protected internal void UpdateObjectGroups()
        {
+            if (!Monitor.TryEnter(m_updateLock))
+                return;
            List<SceneObjectGroup> updates;
            // Some updates add more updates to the updateList. 
@@ -395,6 +401,7 @@ namespace OpenSim.Region.Framework.Scenes
                        "[INNER SCENE]: Failed to update {0}, {1} - {2}", sog.Name, sog.UUID, e);
                }
            }
+            Monitor.Exit(m_updateLock);
        }
        protected internal void AddPhysicalPrim(int number)
@@ -1555,55 +1562,65 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="childPrims"></param>
        protected internal void LinkObjects(IClientAPI client, uint parentPrimId, List<uint> childPrimIds)
        {
-            SceneObjectGroup parentGroup = GetGroupByPrim(parentPrimId);
+            Monitor.Enter(m_updateLock);
+            try
-            List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
-            if (parentGroup != null)
            {
-                // We do this in reverse to get the link order of the prims correct
+                SceneObjectGroup parentGroup = GetGroupByPrim(parentPrimId);
-                for (int i = childPrimIds.Count - 1; i >= 0; i--)
+                List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
+                if (parentGroup != null)
                {
-                    SceneObjectGroup child = GetGroupByPrim(childPrimIds[i]);
+                    // We do this in reverse to get the link order of the prims correct
-                    if (child != null)
+                    for (int i = childPrimIds.Count - 1; i >= 0; i--)
                    {
-                        // Make sure no child prim is set for sale
+                        SceneObjectGroup child = GetGroupByPrim(childPrimIds[i]);
-                        // So that, on delink, no prims are unwittingly
+                        if (child != null)
-                        // left for sale and sold off
+                        {
-                        child.RootPart.ObjectSaleType = 0;
+                            // Make sure no child prim is set for sale
-                        child.RootPart.SalePrice = 10;
+                            // So that, on delink, no prims are unwittingly
-                        childGroups.Add(child);
+                            // left for sale and sold off
+                            child.RootPart.ObjectSaleType = 0;
+                            child.RootPart.SalePrice = 10;
+                            childGroups.Add(child);
+                        }
                    }
                }
-            }
+                else
-            else
+                {
-            {
+                    return; // parent is null so not in this region
-                return; // parent is null so not in this region
+                }
-            }
-            foreach (SceneObjectGroup child in childGroups)
+                foreach (SceneObjectGroup child in childGroups)
-            {
+                {
-                parentGroup.LinkToGroup(child);
+                    parentGroup.LinkToGroup(child);
-                // this is here so physics gets updated!
+                    // this is here so physics gets updated!
-                // Don't remove!  Bad juju!  Stay away! or fix physics!
+                    // Don't remove!  Bad juju!  Stay away! or fix physics!
-                child.AbsolutePosition = child.AbsolutePosition;
+                    child.AbsolutePosition = child.AbsolutePosition;
-            }
+                }
-            // We need to explicitly resend the newly link prim's object properties since no other actions
+                // We need to explicitly resend the newly link prim's object properties since no other actions
-            // occur on link to invoke this elsewhere (such as object selection)
+                // occur on link to invoke this elsewhere (such as object selection)
-            parentGroup.RootPart.AddFlag(PrimFlags.CreateSelected);
+                parentGroup.RootPart.AddFlag(PrimFlags.CreateSelected);
-            parentGroup.TriggerScriptChangedEvent(Changed.LINK);
+                parentGroup.TriggerScriptChangedEvent(Changed.LINK);
-            
+                parentGroup.HasGroupChanged = true;
-            if (client != null)
+                parentGroup.ScheduleGroupForFullUpdate();
-            {
+                
-                parentGroup.GetProperties(client);
+//                if (client != null)
+//                {
+//                    parentGroup.GetProperties(client);
+//                }
+//                else
+//                {
+//                    foreach (ScenePresence p in GetScenePresences())
+//                    {
+//                        parentGroup.GetProperties(p.ControllingClient);
+//                    }
+//                }
            }
-            else
+            finally
            {
-                foreach (ScenePresence p in GetScenePresences())
+                Monitor.Exit(m_updateLock);
-                {
-                    parentGroup.GetProperties(p.ControllingClient);
-                }
            }
        }
@@ -1618,109 +1635,120 @@ namespace OpenSim.Region.Framework.Scenes
        protected internal void DelinkObjects(List<uint> primIds, bool sendEvents)
        {
-            List<SceneObjectPart> childParts = new List<SceneObjectPart>();
+            Monitor.Enter(m_updateLock);
-            List<SceneObjectPart> rootParts = new List<SceneObjectPart>();
+            try
-            List<SceneObjectGroup> affectedGroups = new List<SceneObjectGroup>();
-            // Look them all up in one go, since that is comparatively expensive
-            //
-            foreach (uint primID in primIds)
            {
-                SceneObjectPart part = m_parentScene.GetSceneObjectPart(primID);
+                List<SceneObjectPart> childParts = new List<SceneObjectPart>();
-                if (part != null)
+                List<SceneObjectPart> rootParts = new List<SceneObjectPart>();
+                List<SceneObjectGroup> affectedGroups = new List<SceneObjectGroup>();
+                // Look them all up in one go, since that is comparatively expensive
+                //
+                foreach (uint primID in primIds)
                {
-                    if (part.LinkNum < 2) // Root or single
+                    SceneObjectPart part = m_parentScene.GetSceneObjectPart(primID);
-                        rootParts.Add(part);
+                    if (part != null)
+                    {
+                        if (part.ParentGroup.Children.Count != 1) // Skip single
+                        {
+                            if (part.LinkNum < 2) // Root
+                                rootParts.Add(part);
+                            else
+                                childParts.Add(part);
+                            SceneObjectGroup group = part.ParentGroup;
+                            if (!affectedGroups.Contains(group))
+                                affectedGroups.Add(group);
+                        }
+                    }
                    else
-                        childParts.Add(part);
+                    {
+                        m_log.ErrorFormat("Viewer requested unlink of nonexistent part {0}", primID);
-                    SceneObjectGroup group = part.ParentGroup;
+                    }
-                    if (!affectedGroups.Contains(group))
-                        affectedGroups.Add(group);
                }
-                else
+                foreach (SceneObjectPart child in childParts)
                {
-                    m_log.ErrorFormat("Viewer requested unlink of nonexistent part {0}", primID);
+                    // Unlink all child parts from their groups
+                    //
+                    child.ParentGroup.DelinkFromGroup(child, sendEvents);
                }
-            }
-            foreach (SceneObjectPart child in childParts)
-            {
-                // Unlink all child parts from their groups
-                //
-                child.ParentGroup.DelinkFromGroup(child, sendEvents);
-            }
-            foreach (SceneObjectPart root in rootParts)
-            {
-                // In most cases, this will run only one time, and the prim
-                // will be a solo prim
-                // However, editing linked parts and unlinking may be different
-                //
-                SceneObjectGroup group = root.ParentGroup;
-                List<SceneObjectPart> newSet = new List<SceneObjectPart>(group.Children.Values);
-                int numChildren = group.Children.Count;
-                // If there are prims left in a link set, but the root is
+                foreach (SceneObjectPart root in rootParts)
-                // slated for unlink, we need to do this
-                //
-                if (numChildren != 1)
                {
-                    // Unlink the remaining set
+                    // In most cases, this will run only one time, and the prim
+                    // will be a solo prim
+                    // However, editing linked parts and unlinking may be different
                    //
-                    bool sendEventsToRemainder = true;
+                    SceneObjectGroup group = root.ParentGroup;
-                    if (numChildren > 1)
+                    List<SceneObjectPart> newSet = new List<SceneObjectPart>(group.Children.Values);
-                        sendEventsToRemainder = false;
+                    int numChildren = group.Children.Count;
-                    foreach (SceneObjectPart p in newSet)
-                    {
-                        if (p != group.RootPart)
-                            group.DelinkFromGroup(p, sendEventsToRemainder);
-                    }
-                    // If there is more than one prim remaining, we
+                    // If there are prims left in a link set, but the root is
-                    // need to re-link
+                    // slated for unlink, we need to do this
                    //
-                    if (numChildren > 2)
+                    if (numChildren != 1)
                    {
-                        // Remove old root
+                        // Unlink the remaining set
                        //
-                        if (newSet.Contains(root))
+                        bool sendEventsToRemainder = true;
-                            newSet.Remove(root);
+                        if (numChildren > 1)
+                            sendEventsToRemainder = false;
-                        // Preserve link ordering
+                        foreach (SceneObjectPart p in newSet)
-                        //
-                        newSet.Sort(delegate (SceneObjectPart a, SceneObjectPart b)
                        {
-                            return a.LinkNum.CompareTo(b.LinkNum);
+                            if (p != group.RootPart)
-                        });
+                                group.DelinkFromGroup(p, sendEventsToRemainder);
+                        }
-                        // Determine new root
+                        // If there is more than one prim remaining, we
+                        // need to re-link
                        //
-                        SceneObjectPart newRoot = newSet[0];
+                        if (numChildren > 2)
-                        newSet.RemoveAt(0);
+                        {
+                            // Remove old root
+                            //
+                            if (newSet.Contains(root))
+                                newSet.Remove(root);
+                            // Preserve link ordering
+                            //
+                            newSet.Sort(delegate (SceneObjectPart a, SceneObjectPart b)
+                            {
+                                return a.LinkNum.CompareTo(b.LinkNum);
+                            });
-                        List<uint> linkIDs = new List<uint>();
+                            // Determine new root
+                            //
+                            SceneObjectPart newRoot = newSet[0];
+                            newSet.RemoveAt(0);
-                        foreach (SceneObjectPart newChild in newSet)
+                            List<uint> linkIDs = new List<uint>();
-                        {
-                            newChild.UpdateFlag = 0;
+                            foreach (SceneObjectPart newChild in newSet)
-                            linkIDs.Add(newChild.LocalId);
+                            {
-                        }
+                                newChild.UpdateFlag = 0;
+                                linkIDs.Add(newChild.LocalId);
+                            }
-                        LinkObjects(null, newRoot.LocalId, linkIDs);
+                            LinkObjects(null, newRoot.LocalId, linkIDs);
-                        if (!affectedGroups.Contains(newRoot.ParentGroup))
+                            if (!affectedGroups.Contains(newRoot.ParentGroup))
-                            affectedGroups.Add(newRoot.ParentGroup);
+                                affectedGroups.Add(newRoot.ParentGroup);
+                        }
                    }
                }
-            }
-            // Finally, trigger events in the roots
+                // Finally, trigger events in the roots
-            //
+                //
-            foreach (SceneObjectGroup g in affectedGroups)
+                foreach (SceneObjectGroup g in affectedGroups)
+                {
+                    g.TriggerScriptChangedEvent(Changed.LINK);
+                    g.HasGroupChanged = true; // Persist
+                    g.ScheduleGroupForFullUpdate();
+                }
+            }
+            finally
            {
-                g.TriggerScriptChangedEvent(Changed.LINK);
+                Monitor.Exit(m_updateLock);
-                g.HasGroupChanged = true; // Persist
-                g.ScheduleGroupForFullUpdate();
            }
        }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index f36ff1d..eacd219 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -98,6 +98,72 @@ namespace OpenSim.Region.Framework.Scenes
        private bool m_hasGroupChanged = false;
        private long timeFirstChanged;
        private long timeLastChanged;
+        private System.Threading.ReaderWriterLockSlim m_partsLock = new System.Threading.ReaderWriterLockSlim();
+        public void lockPartsForRead(bool locked)
+        {
+            if (locked)
+            {
+                if (m_partsLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Recursive read lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_partsLock.ExitReadLock();
+                }
+                if (m_partsLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Recursive read lock requested. This should not happen and means something needs to be fixed.");
+                    m_partsLock.ExitWriteLock();
+                }
+                while (!m_partsLock.TryEnterReadLock(60000))
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Thread lock detected while trying to aquire READ lock of m_parts in SceneObjectGroup. I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_partsLock.IsWriteLockHeld)
+                    {
+                        m_partsLock = new System.Threading.ReaderWriterLockSlim();
+                    }
+                }
+            }
+            else
+            {
+                if (m_partsLock.RecursiveReadCount > 0)
+                {
+                    m_partsLock.ExitReadLock();
+                }
+            }
+        }
+        public void lockPartsForWrite(bool locked)
+        {
+            if (locked)
+            {
+                if (m_partsLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Recursive write lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_partsLock.ExitReadLock();
+                }
+                if (m_partsLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Recursive write lock requested. This should not happen and means something needs to be fixed.");
+                    m_partsLock.ExitWriteLock();
+                }
+                while (!m_partsLock.TryEnterWriteLock(60000))
+                {
+                    m_log.Error("[SceneObjectGroup.m_parts] Thread lock detected while trying to aquire WRITE lock of m_scripts in XEngine. I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_partsLock.IsWriteLockHeld)
+                    {
+                        m_partsLock = new System.Threading.ReaderWriterLockSlim();
+                    }
+                }
+            }
+            else
+            {
+                if (m_partsLock.RecursiveWriteCount > 0)
+                {
+                    m_partsLock.ExitWriteLock();
+                }
+            }
+        }
        public bool HasGroupChanged
        {
@@ -243,13 +309,16 @@ namespace OpenSim.Region.Framework.Scenes
            set
            {
                m_regionHandle = value;
-                lock (m_parts)
+                lockPartsForRead(true);
                {
                    foreach (SceneObjectPart part in m_parts.Values)
                    {
+                        
                        part.RegionHandle = m_regionHandle;
+                        
                    }
                }
+                lockPartsForRead(false);
            }
        }
@@ -275,13 +344,16 @@ namespace OpenSim.Region.Framework.Scenes
                    m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
                }
-                lock (m_parts)
+                lockPartsForRead(true);
                {
                    foreach (SceneObjectPart part in m_parts.Values)
                    {
+                        
                        part.GroupPosition = val;
+                        
                    }
                }
+                lockPartsForRead(false);
                //if (m_rootPart.PhysActor != null)
                //{
@@ -432,13 +504,16 @@ namespace OpenSim.Region.Framework.Scenes
        public void SetFromItemID(UUID AssetId)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.FromItemID = AssetId;
+                    
                }
            }
+            lockPartsForRead(false);
        }
        public UUID GetFromItemID()
@@ -505,10 +580,11 @@ namespace OpenSim.Region.Framework.Scenes
            Vector3 maxScale = Vector3.Zero;
            Vector3 finalScale = new Vector3(0.5f, 0.5f, 0.5f);
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    Vector3 partscale = part.Scale;
                    Vector3 partoffset = part.OffsetPosition;
@@ -519,8 +595,11 @@ namespace OpenSim.Region.Framework.Scenes
                    maxScale.X = (partscale.X + partoffset.X > maxScale.X) ? partscale.X + partoffset.X : maxScale.X;
                    maxScale.Y = (partscale.Y + partoffset.Y > maxScale.Y) ? partscale.Y + partoffset.Y : maxScale.Y;
                    maxScale.Z = (partscale.Z + partoffset.Z > maxScale.Z) ? partscale.Z + partoffset.Z : maxScale.Z;
+                    
                }
            }
+            lockPartsForRead(false);
            finalScale.X = (minScale.X > maxScale.X) ? minScale.X : maxScale.X;
            finalScale.Y = (minScale.Y > maxScale.Y) ? minScale.Y : maxScale.Y;
            finalScale.Z = (minScale.Z > maxScale.Z) ? minScale.Z : maxScale.Z;
@@ -536,10 +615,11 @@ namespace OpenSim.Region.Framework.Scenes
            EntityIntersection result = new EntityIntersection();
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    // Temporary commented to stop compiler warning
                    //Vector3 partPosition =
                    //    new Vector3(part.AbsolutePosition.X, part.AbsolutePosition.Y, part.AbsolutePosition.Z);
@@ -567,8 +647,10 @@ namespace OpenSim.Region.Framework.Scenes
                            result.distance = inter.distance;
                        }
                    }
+                    
                }
            }
+            lockPartsForRead(false);
            return result;
        }
@@ -581,10 +663,11 @@ namespace OpenSim.Region.Framework.Scenes
        public Vector3 GetAxisAlignedBoundingBox(out float offsetHeight)
        {
            float maxX = -256f, maxY = -256f, maxZ = -256f, minX = 256f, minY = 256f, minZ = 256f;
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    Vector3 worldPos = part.GetWorldPosition();
                    Vector3 offset = worldPos - AbsolutePosition;
                    Quaternion worldRot;
@@ -643,6 +726,8 @@ namespace OpenSim.Region.Framework.Scenes
                    backBottomRight.Y = orig.Y + (part.Scale.Y / 2);
                    backBottomRight.Z = orig.Z - (part.Scale.Z / 2);
+                    
                    //m_log.InfoFormat("pre corner 1 is {0} {1} {2}", frontTopLeft.X, frontTopLeft.Y, frontTopLeft.Z);
                    //m_log.InfoFormat("pre corner 2 is {0} {1} {2}", frontTopRight.X, frontTopRight.Y, frontTopRight.Z);
                    //m_log.InfoFormat("pre corner 3 is {0} {1} {2}", frontBottomRight.X, frontBottomRight.Y, frontBottomRight.Z);
@@ -814,6 +899,7 @@ namespace OpenSim.Region.Framework.Scenes
                        minZ = backBottomLeft.Z;
                }
            }
+            lockPartsForRead(false);
            Vector3 boundingBox = new Vector3(maxX - minX, maxY - minY, maxZ - minZ);
@@ -842,17 +928,20 @@ namespace OpenSim.Region.Framework.Scenes
            Dictionary<UUID,string> states = new Dictionary<UUID,string>();
            // Capture script state while holding the lock
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    Dictionary<UUID,string> pstates = part.Inventory.GetScriptStates();
                    foreach (UUID itemid in pstates.Keys)
                    {
                        states.Add(itemid, pstates[itemid]);
                    }
+                    
                }
            }
+            lockPartsForRead(false);
            if (states.Count > 0)
            {
@@ -1014,13 +1103,16 @@ namespace OpenSim.Region.Framework.Scenes
        public override void UpdateMovement()
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.UpdateMovement();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        public ushort GetTimeDilation()
@@ -1064,7 +1156,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="part"></param>
        public void AddPart(SceneObjectPart part)
        {
-            lock (m_parts)
+            lockPartsForWrite(true);
            {
                part.SetParent(this);
                m_parts.Add(part.UUID, part);
@@ -1074,6 +1166,7 @@ namespace OpenSim.Region.Framework.Scenes
                if (part.LinkNum == 2 && RootPart != null)
                    RootPart.LinkNum = 1;
            }
+            lockPartsForWrite(false);
        }
        /// <summary>
@@ -1081,28 +1174,33 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        private void UpdateParentIDs()
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part.UUID != m_rootPart.UUID)
                    {
                        part.ParentID = m_rootPart.LocalId;
                    }
+                    
                }
            }
+            lockPartsForRead(false);
        }
        public void RegenerateFullIDs()
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.UUID = UUID.Random();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        // helper provided for parts.
@@ -1183,28 +1281,33 @@ namespace OpenSim.Region.Framework.Scenes
            DetachFromBackup();
-            lock (m_parts)
+            lockPartsForRead(true);
+            List<SceneObjectPart> values = new List<SceneObjectPart>(m_parts.Values);
+            lockPartsForRead(false);
+            
+            foreach (SceneObjectPart part in values)
            {
-                foreach (SceneObjectPart part in m_parts.Values)
-                {
 //                    part.Inventory.RemoveScriptInstances();
+                
-                    ScenePresence[] avatars = Scene.GetScenePresences();
+                ScenePresence[] avatars = Scene.GetScenePresences();
-                    for (int i = 0; i < avatars.Length; i++)
+                for (int i = 0; i < avatars.Length; i++)
+                {
+                    if (avatars[i].ParentID == LocalId)
                    {
-                        if (avatars[i].ParentID == LocalId)
+                        avatars[i].StandUp();
-                        {
+                    }
-                            avatars[i].StandUp();
-                        }
-                        if (!silent)
+                    if (!silent)
-                        {
+                    {
-                            if (part == m_rootPart)
+                        part.UpdateFlag = 0;
-                                avatars[i].ControllingClient.SendKillObject(m_regionHandle, part.LocalId);
+                        if (part == m_rootPart)
-                        }
+                            avatars[i].ControllingClient.SendKillObject(m_regionHandle, part.LocalId);
                    }
                }
+                
            }
+            
+          
        }
        public void AddScriptLPS(int count)
@@ -1229,17 +1332,20 @@ namespace OpenSim.Region.Framework.Scenes
            scriptEvents aggregateScriptEvents=0;
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part == null)
                        continue;
                    if (part != RootPart)
                        part.ObjectFlags = objectflagupdate;
                    aggregateScriptEvents |= part.AggregateScriptEvents;
+                    
                }
            }
+            lockPartsForRead(false);
            m_scriptListens_atTarget = ((aggregateScriptEvents & scriptEvents.at_target) != 0);
            m_scriptListens_notAtTarget = ((aggregateScriptEvents & scriptEvents.not_at_target) != 0);
@@ -1272,42 +1378,52 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="m_physicalPrim"></param>
        public void ApplyPhysics(bool m_physicalPrim)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
+            
+            if (m_parts.Count > 1)
            {
-                if (m_parts.Count > 1)
+                List<SceneObjectPart> values = new List<SceneObjectPart>(m_parts.Values);
+                lockPartsForRead(false);
+                m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
+                foreach (SceneObjectPart part in values)
                {
-                    m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
+                    
-                    foreach (SceneObjectPart part in m_parts.Values)
+                    if (part.LocalId != m_rootPart.LocalId)
                    {
-                        if (part.LocalId != m_rootPart.LocalId)
+                        part.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), part.VolumeDetectActive, m_physicalPrim);
-                        {
-                            part.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), part.VolumeDetectActive, m_physicalPrim);
-                        }
                    }
                    
-                    // Hack to get the physics scene geometries in the right spot
-                    ResetChildPrimPhysicsPositions();
-                }
-                else
-                {
-                    m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
                }
+                // Hack to get the physics scene geometries in the right spot
+                ResetChildPrimPhysicsPositions();
+            }
+            else
+            {
+                lockPartsForRead(false);
+                m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
            }
        }
        public void SetOwnerId(UUID userId)
        {
-            ForEachPart(delegate(SceneObjectPart part) { part.OwnerID = userId; });
+                ForEachPart(delegate(SceneObjectPart part) 
+                {
+                    
+                    part.OwnerID = userId;
+                    
+                });
        }
        public void ForEachPart(Action<SceneObjectPart> whatToDo)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
+            List<SceneObjectPart> values = new List<SceneObjectPart>(m_parts.Values);
+            lockPartsForRead(false);    
+            foreach (SceneObjectPart part in values)
            {
-                foreach (SceneObjectPart part in m_parts.Values)
+                
-                {
+                whatToDo(part);
-                    whatToDo(part);
+                
-                }
            }
        }
@@ -1406,14 +1522,17 @@ namespace OpenSim.Region.Framework.Scenes
        {
            SendPartFullUpdate(remoteClient, RootPart, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, RootPart.UUID));
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part != RootPart)
                        SendPartFullUpdate(remoteClient, part, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, part.UUID));
+                    
                }
            }
+            lockPartsForRead(false);
        }
        /// <summary>
@@ -1508,10 +1627,11 @@ namespace OpenSim.Region.Framework.Scenes
            
            List<SceneObjectPart> partList;
-            lock (m_parts)
+            lockPartsForRead(true);
-            {
+            
-                partList = new List<SceneObjectPart>(m_parts.Values);
+            partList = new List<SceneObjectPart>(m_parts.Values);
-            }
+            
+            lockPartsForRead(false);
            
            partList.Sort(delegate(SceneObjectPart p1, SceneObjectPart p2)
                {
@@ -1834,10 +1954,11 @@ namespace OpenSim.Region.Framework.Scenes
            SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed);
            newPart.SetParent(this);
-            lock (m_parts)
+            lockPartsForWrite(true);
            {
                m_parts.Add(newPart.UUID, newPart);
            }
+            lockPartsForWrite(false);
            SetPartAsNonRoot(newPart);
@@ -1900,7 +2021,7 @@ namespace OpenSim.Region.Framework.Scenes
            //if ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
            //    return;
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
@@ -1918,34 +2039,43 @@ namespace OpenSim.Region.Framework.Scenes
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.SendScheduledUpdates();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        public void ScheduleFullUpdateToAvatar(ScenePresence presence)
        {
            RootPart.AddFullUpdateToAvatar(presence);
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part != RootPart)
                        part.AddFullUpdateToAvatar(presence);
+                    
                }
            }
+            lockPartsForRead(false);
        }
        public void ScheduleTerseUpdateToAvatar(ScenePresence presence)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.AddTerseUpdateToAvatar(presence);
+                    
                }
            }
+            lockPartsForRead(false);
        }
        /// <summary>
@@ -1956,14 +2086,17 @@ namespace OpenSim.Region.Framework.Scenes
            checkAtTargets();
            RootPart.ScheduleFullUpdate();
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part != RootPart)
                        part.ScheduleFullUpdate();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        /// <summary>
@@ -1971,13 +2104,16 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void ScheduleGroupForTerseUpdate()
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    part.ScheduleTerseUpdate();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        /// <summary>
@@ -1990,14 +2126,17 @@ namespace OpenSim.Region.Framework.Scenes
            
            RootPart.SendFullUpdateToAllClients();
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
+                    
                    if (part != RootPart)
                        part.SendFullUpdateToAllClients();
+                    
                }
            }
+            lockPartsForRead(false);
        }
        /// <summary>
@@ -2028,14 +2167,15 @@ namespace OpenSim.Region.Framework.Scenes
        {
            if (IsDeleted)
                return;
-            
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
                    part.SendTerseUpdateToAllClients();
                }
            }
+            lockPartsForRead(false);
        }
        #endregion
@@ -2049,16 +2189,18 @@ namespace OpenSim.Region.Framework.Scenes
        /// <returns>null if no child part with that linknum or child part</returns>
        public SceneObjectPart GetLinkNumPart(int linknum)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
                    if (part.LinkNum == linknum)
                    {
+                        lockPartsForRead(false);
                        return part;
                    }
                }
            }
+            lockPartsForRead(false);
            return null;
        }
@@ -2086,17 +2228,19 @@ namespace OpenSim.Region.Framework.Scenes
        public SceneObjectPart GetChildPart(uint localID)
        {
            //m_log.DebugFormat("Entered looking for {0}", localID);
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
                    //m_log.DebugFormat("Found {0}", part.LocalId);
                    if (part.LocalId == localID)
                    {
+                        lockPartsForRead(false);
                        return part;
                    }
                }
            }
+            lockPartsForRead(false);
            return null;
        }
@@ -2126,17 +2270,19 @@ namespace OpenSim.Region.Framework.Scenes
        public bool HasChildPrim(uint localID)
        {
            //m_log.DebugFormat("Entered HasChildPrim looking for {0}", localID);
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
                    //m_log.DebugFormat("Found {0}", part.LocalId);
                    if (part.LocalId == localID)
                    {
+                        lockPartsForRead(false);
                        return true;
                    }
                }
            }
+            lockPartsForRead(false);
            return false;
        }
@@ -2152,14 +2298,14 @@ namespace OpenSim.Region.Framework.Scenes
        public void LinkToGroup(SceneObjectGroup objectGroup)
        {
            // Make sure we have sent any pending unlinks or stuff.
-            if (objectGroup.RootPart.UpdateFlag > 0)
+            //if (objectGroup.RootPart.UpdateFlag > 0)
-            {
+            //{
-                m_log.WarnFormat(
+            //    m_log.WarnFormat(
-                    "[SCENE OBJECT GROUP]: Forcing send of linkset {0}, {1} to {2}, {3} as its still waiting.",
+            //        "[SCENE OBJECT GROUP]: Forcing send of linkset {0}, {1} to {2}, {3} as its still waiting.",
-                    objectGroup.RootPart.Name, objectGroup.RootPart.UUID, RootPart.Name, RootPart.UUID);
+            //        objectGroup.RootPart.Name, objectGroup.RootPart.UUID, RootPart.Name, RootPart.UUID);
-                objectGroup.RootPart.SendScheduledUpdates();
+            //    objectGroup.RootPart.SendScheduledUpdates();
-            }
+            //}
 //            m_log.DebugFormat(
 //                "[SCENE OBJECT GROUP]: Linking group with root part {0}, {1} to group with root part {2}, {3}",
@@ -2186,53 +2332,57 @@ namespace OpenSim.Region.Framework.Scenes
            if (m_rootPart.LinkNum == 0)
                m_rootPart.LinkNum = 1;
-            lock (m_parts)
+            lockPartsForWrite(true);
-            {
+            
-                m_parts.Add(linkPart.UUID, linkPart);
+            m_parts.Add(linkPart.UUID, linkPart);
+            lockPartsForWrite(false);
-                // Insert in terms of link numbers, the new links
+            // Insert in terms of link numbers, the new links
-                // before the current ones (with the exception of 
+            // before the current ones (with the exception of 
-                // the root prim. Shuffle the old ones up
+            // the root prim. Shuffle the old ones up
-                foreach (KeyValuePair<UUID, SceneObjectPart> kvp in m_parts) 
+            lockPartsForRead(true);
+            foreach (KeyValuePair<UUID, SceneObjectPart> kvp in m_parts) 
+            {
+                if (kvp.Value.LinkNum != 1)
                {
-                    if (kvp.Value.LinkNum != 1)
+                    // Don't update root prim link number
-                    {
+                    kvp.Value.LinkNum += objectGroup.PrimCount;
-                        // Don't update root prim link number
-                        kvp.Value.LinkNum += objectGroup.PrimCount;
-                    }
                }
+            }
+            lockPartsForRead(false);
-                linkPart.LinkNum = 2;
+            linkPart.LinkNum = 2;
-                linkPart.SetParent(this);
+            linkPart.SetParent(this);
-                linkPart.AddFlag(PrimFlags.CreateSelected);
+            linkPart.AddFlag(PrimFlags.CreateSelected);
-                //if (linkPart.PhysActor != null)
+            //if (linkPart.PhysActor != null)
-                //{
+            //{
-                // m_scene.PhysicsScene.RemovePrim(linkPart.PhysActor);
+            // m_scene.PhysicsScene.RemovePrim(linkPart.PhysActor);
-        
+    
-                //linkPart.PhysActor = null;
+            //linkPart.PhysActor = null;
-                //}
+            //}
-                //TODO: rest of parts
+            //TODO: rest of parts
-                int linkNum = 3;
+            int linkNum = 3;
-                foreach (SceneObjectPart part in objectGroup.Children.Values)
+            foreach (SceneObjectPart part in objectGroup.Children.Values)
+            {
+                if (part.UUID != objectGroup.m_rootPart.UUID)
                {
-                    if (part.UUID != objectGroup.m_rootPart.UUID)
+                    LinkNonRootPart(part, oldGroupPosition, oldRootRotation, linkNum++);
-                    {
-                        LinkNonRootPart(part, oldGroupPosition, oldRootRotation, linkNum++);
-                    }
-                    part.ClearUndoState();
                }
+                part.ClearUndoState();
            }
            m_scene.UnlinkSceneObject(objectGroup.UUID, true);
            objectGroup.m_isDeleted = true;
+            objectGroup.lockPartsForWrite(true);
            
-            lock (objectGroup.m_parts)
+            objectGroup.m_parts.Clear();
-            {
+            
-                objectGroup.m_parts.Clear();
+            objectGroup.lockPartsForWrite(false);
-            }
            
            // Can't do this yet since backup still makes use of the root part without any synchronization
 //            objectGroup.m_rootPart = null;
@@ -2245,8 +2395,8 @@ namespace OpenSim.Region.Framework.Scenes
            // unmoved prims!
            ResetChildPrimPhysicsPositions();
-            HasGroupChanged = true;
+            //HasGroupChanged = true;
-            ScheduleGroupForFullUpdate();
+            //ScheduleGroupForFullUpdate();
        }
        /// <summary>
@@ -2291,11 +2441,12 @@ namespace OpenSim.Region.Framework.Scenes
            Quaternion worldRot = linkPart.GetWorldRotation();
            // Remove the part from this object
-            lock (m_parts)
+            lockPartsForWrite(true);
            {
                m_parts.Remove(linkPart.UUID);
            }
+            lockPartsForWrite(false);
+            lockPartsForRead(true);
            if (m_parts.Count == 1 && RootPart != null) //Single prim is left
                RootPart.LinkNum = 0;
            else
@@ -2306,6 +2457,7 @@ namespace OpenSim.Region.Framework.Scenes
                        p.LinkNum--;
                }
            }
+            lockPartsForRead(false);
            linkPart.ParentID = 0;
            linkPart.LinkNum = 0;
@@ -2337,8 +2489,8 @@ namespace OpenSim.Region.Framework.Scenes
            linkPart.Rezzed = RootPart.Rezzed;
-            HasGroupChanged = true;
+            //HasGroupChanged = true;
-            ScheduleGroupForFullUpdate();
+            //ScheduleGroupForFullUpdate();
        }
        /// <summary>
@@ -2623,22 +2775,28 @@ namespace OpenSim.Region.Framework.Scenes
            if (selectionPart != null)
            {
-                lock (m_parts)
+                lockPartsForRead(true);
+                List<SceneObjectPart> parts = new List<SceneObjectPart>(m_parts.Values);
+                lockPartsForRead(false);
+                foreach (SceneObjectPart part in parts)
                {
-                    foreach (SceneObjectPart part in m_parts.Values)
+                    if (part.Scale.X > 10.0 || part.Scale.Y > 10.0 || part.Scale.Z > 10.0)
                    {
-                        if (part.Scale.X > 10.0 || part.Scale.Y > 10.0 || part.Scale.Z > 10.0)
+                        if (part.Scale.X > m_scene.RegionInfo.PhysPrimMax || 
+                            part.Scale.Y > m_scene.RegionInfo.PhysPrimMax ||
+                            part.Scale.Z > m_scene.RegionInfo.PhysPrimMax)
                        {
                            UsePhysics = false; // Reset physics
                            break;
                        }
                    }
+                }
-                    foreach (SceneObjectPart part in m_parts.Values)
+                foreach (SceneObjectPart part in parts)
-                    {
+                {
-                        part.UpdatePrimFlags(UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
+                    part.UpdatePrimFlags(UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
-                    }
                }
+                
            }
        }
@@ -2724,11 +2882,9 @@ namespace OpenSim.Region.Framework.Scenes
                scale.Y = m_scene.m_maxNonphys;
            if (scale.Z > m_scene.m_maxNonphys)
                scale.Z = m_scene.m_maxNonphys;
            SceneObjectPart part = GetChildPart(localID);
            if (part != null)
            {
-                part.Resize(scale);
                if (part.PhysActor != null)
                {
                    if (part.PhysActor.IsPhysical)
@@ -2743,7 +2899,7 @@ namespace OpenSim.Region.Framework.Scenes
                    part.PhysActor.Size = scale;
                    m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
                }
-                //if (part.UUID != m_rootPart.UUID)
+                part.Resize(scale);
                HasGroupChanged = true;
                ScheduleGroupForFullUpdate();
@@ -2784,77 +2940,76 @@ namespace OpenSim.Region.Framework.Scenes
                float y = (scale.Y / part.Scale.Y);
                float z = (scale.Z / part.Scale.Z);
-                lock (m_parts)
+                lockPartsForRead(true);
+                if (x > 1.0f || y > 1.0f || z > 1.0f)
                {
-                    if (x > 1.0f || y > 1.0f || z > 1.0f)
+                    foreach (SceneObjectPart obPart in m_parts.Values)
                    {
-                        foreach (SceneObjectPart obPart in m_parts.Values)
+                        if (obPart.UUID != m_rootPart.UUID)
                        {
-                            if (obPart.UUID != m_rootPart.UUID)
+                            Vector3 oldSize = new Vector3(obPart.Scale);
-                            {
-                                Vector3 oldSize = new Vector3(obPart.Scale);
-                                float f = 1.0f;
+                            float f = 1.0f;
-                                float a = 1.0f;
+                            float a = 1.0f;
-                                if (part.PhysActor != null && part.PhysActor.IsPhysical)
+                            if (part.PhysActor != null && part.PhysActor.IsPhysical)
+                            {
+                                if (oldSize.X*x > m_scene.m_maxPhys)
                                {
-                                    if (oldSize.X*x > m_scene.m_maxPhys)
+                                    f = m_scene.m_maxPhys / oldSize.X;
-                                    {
+                                    a = f / x;
-                                        f = m_scene.m_maxPhys / oldSize.X;
+                                    x *= a;
-                                        a = f / x;
+                                    y *= a;
-                                        x *= a;
+                                    z *= a;
-                                        y *= a;
-                                        z *= a;
-                                    }
-                                    if (oldSize.Y*y > m_scene.m_maxPhys)
-                                    {
-                                        f = m_scene.m_maxPhys / oldSize.Y;
-                                        a = f / y;
-                                        x *= a;
-                                        y *= a;
-                                        z *= a;
-                                    }
-                                    if (oldSize.Z*z > m_scene.m_maxPhys)
-                                    {
-                                        f = m_scene.m_maxPhys / oldSize.Z;
-                                        a = f / z;
-                                        x *= a;
-                                        y *= a;
-                                        z *= a;
-                                    }
                                }
-                                else
+                                if (oldSize.Y*y > m_scene.m_maxPhys)
                                {
-                                    if (oldSize.X*x > m_scene.m_maxNonphys)
+                                    f = m_scene.m_maxPhys / oldSize.Y;
-                                    {
+                                    a = f / y;
-                                        f = m_scene.m_maxNonphys / oldSize.X;
+                                    x *= a;
-                                        a = f / x;
+                                    y *= a;
-                                        x *= a;
+                                    z *= a;
-                                        y *= a;
+                                }
-                                        z *= a;
+                                if (oldSize.Z*z > m_scene.m_maxPhys)
-                                    }
+                                {
-                                    if (oldSize.Y*y > m_scene.m_maxNonphys)
+                                    f = m_scene.m_maxPhys / oldSize.Z;
-                                    {
+                                    a = f / z;
-                                        f = m_scene.m_maxNonphys / oldSize.Y;
+                                    x *= a;
-                                        a = f / y;
+                                    y *= a;
-                                        x *= a;
+                                    z *= a;
-                                        y *= a;
+                                }
-                                        z *= a;
+                            }
-                                    }
+                            else
-                                    if (oldSize.Z*z > m_scene.m_maxNonphys)
+                            {
-                                    {
+                                if (oldSize.X*x > m_scene.m_maxNonphys)
-                                        f = m_scene.m_maxNonphys / oldSize.Z;
+                                {
-                                        a = f / z;
+                                    f = m_scene.m_maxNonphys / oldSize.X;
-                                        x *= a;
+                                    a = f / x;
-                                        y *= a;
+                                    x *= a;
-                                        z *= a;
+                                    y *= a;
-                                    }
+                                    z *= a;
+                                }
+                                if (oldSize.Y*y > m_scene.m_maxNonphys)
+                                {
+                                    f = m_scene.m_maxNonphys / oldSize.Y;
+                                    a = f / y;
+                                    x *= a;
+                                    y *= a;
+                                    z *= a;
+                                }
+                                if (oldSize.Z*z > m_scene.m_maxNonphys)
+                                {
+                                    f = m_scene.m_maxNonphys / oldSize.Z;
+                                    a = f / z;
+                                    x *= a;
+                                    y *= a;
+                                    z *= a;
                                }
                            }
                        }
                    }
                }
+                lockPartsForRead(false);
                Vector3 prevScale = part.Scale;
                prevScale.X *= x;
@@ -2862,7 +3017,7 @@ namespace OpenSim.Region.Framework.Scenes
                prevScale.Z *= z;
                part.Resize(prevScale);
-                lock (m_parts)
+                lockPartsForRead(true);
                {
                    foreach (SceneObjectPart obPart in m_parts.Values)
                    {
@@ -2881,6 +3036,7 @@ namespace OpenSim.Region.Framework.Scenes
                        }
                    }
                }
+                lockPartsForRead(false);
                if (part.PhysActor != null)
                {
@@ -2961,7 +3117,7 @@ namespace OpenSim.Region.Framework.Scenes
            axDiff *= Quaternion.Inverse(partRotation);
            diff = axDiff;
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart obPart in m_parts.Values)
                {
@@ -2971,6 +3127,7 @@ namespace OpenSim.Region.Framework.Scenes
                    }
                }
            }
+            lockPartsForRead(false);
            AbsolutePosition = newPos;
@@ -3088,7 +3245,7 @@ namespace OpenSim.Region.Framework.Scenes
                m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
            }
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart prim in m_parts.Values)
                {
@@ -3106,6 +3263,7 @@ namespace OpenSim.Region.Framework.Scenes
                    }
                }
            }
+            lockPartsForRead(false);
            m_rootPart.ScheduleTerseUpdate();
        }
@@ -3204,7 +3362,7 @@ namespace OpenSim.Region.Framework.Scenes
                    if (atTargets.Count > 0)
                    {
                        uint[] localids = new uint[0];
-                        lock (m_parts)
+                        lockPartsForRead(true);
                        {
                            localids = new uint[m_parts.Count];
                            int cntr = 0;
@@ -3214,6 +3372,7 @@ namespace OpenSim.Region.Framework.Scenes
                                cntr++;
                            }
                        }
+                        lockPartsForRead(false);
                        
                        for (int ctr = 0; ctr < localids.Length; ctr++)
                        {
@@ -3232,7 +3391,7 @@ namespace OpenSim.Region.Framework.Scenes
                    {
                        //trigger not_at_target
                        uint[] localids = new uint[0];
-                        lock (m_parts)
+                        lockPartsForRead(true);
                        {
                            localids = new uint[m_parts.Count];
                            int cntr = 0;
@@ -3242,7 +3401,8 @@ namespace OpenSim.Region.Framework.Scenes
                                cntr++;
                            }
                        }
-                        
+                        lockPartsForRead(false);    
                        for (int ctr = 0; ctr < localids.Length; ctr++)
                        {
                            m_scene.EventManager.TriggerNotAtTargetEvent(localids[ctr]);
@@ -3255,19 +3415,20 @@ namespace OpenSim.Region.Framework.Scenes
        public float GetMass()
        {
            float retmass = 0f;
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
                    retmass += part.GetMass();
                }
            }
+            lockPartsForRead(false);
            return retmass;
        }
        
        public void CheckSculptAndLoad()
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                if (!IsDeleted)
                {
@@ -3292,6 +3453,7 @@ namespace OpenSim.Region.Framework.Scenes
                    }
                }
            }
+            lockPartsForRead(false);
        }
        protected void AssetReceived(string id, Object sender, AssetBase asset)
@@ -3312,7 +3474,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="client"></param>
        public void SetGroup(UUID GroupID, IClientAPI client)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                {
@@ -3322,7 +3484,7 @@ namespace OpenSim.Region.Framework.Scenes
                HasGroupChanged = true;
            }
+            lockPartsForRead(false);
            ScheduleGroupForFullUpdate();
        }
@@ -3341,11 +3503,12 @@ namespace OpenSim.Region.Framework.Scenes
        public void SetAttachmentPoint(byte point)
        {
-            lock (m_parts)
+            lockPartsForRead(true);
            {
                foreach (SceneObjectPart part in m_parts.Values)
                    part.SetAttachmentPoint(point);
            }
+            lockPartsForRead(false);
        }
        #region ISceneObject
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index eca8588..b57d912 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -269,8 +269,9 @@ namespace OpenSim.Region.Framework.Scenes
                                   {
                                       m_log.ErrorFormat(
                                           "[PRIM INVENTORY]: " +
-                                           "Couldn't start script {0}, {1} since asset ID {2} could not be found",
+                                           "Couldn't start script {0}, {1} at {2} in {3} since asset ID {4} could not be found",
-                                           item.Name, item.ItemID, item.AssetID);
+                                           item.Name, item.ItemID, m_part.AbsolutePosition, 
+                                           m_part.ParentGroup.Scene.RegionInfo.RegionName, item.AssetID);
                                   }
                                   else
                                   {
@@ -317,9 +318,20 @@ namespace OpenSim.Region.Framework.Scenes
            m_items.LockItemsForRead(true);
            if (m_items.ContainsKey(itemId))
            {
-                TaskInventoryItem item = m_items[itemId];
+                if (m_items.ContainsKey(itemId))
-                m_items.LockItemsForRead(false);
+                {
-                CreateScriptInstance(item, startParam, postOnRez, engine, stateSource);
+                    m_items.LockItemsForRead(false);
+                    CreateScriptInstance(m_items[itemId], startParam, postOnRez, engine, stateSource);
+                }
+                else
+                {
+                    m_items.LockItemsForRead(false);
+                    m_log.ErrorFormat(
+                        "[PRIM INVENTORY]: " +
+                        "Couldn't start script with ID {0} since it couldn't be found for prim {1}, {2} at {3} in {4}",
+                        itemId, m_part.Name, m_part.UUID, 
+                        m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
+                }
            }
            else
            {
@@ -347,8 +359,9 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_log.ErrorFormat(
                    "[PRIM INVENTORY]: " +
-                    "Couldn't stop script with ID {0} since it couldn't be found for prim {1}, {2}",
+                    "Couldn't stop script with ID {0} since it couldn't be found for prim {1}, {2} at {3} in {4}",
-                    itemId, m_part.Name, m_part.UUID);
+                    itemId, m_part.Name, m_part.UUID, 
+                    m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
            }
        }
@@ -542,8 +555,9 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_log.ErrorFormat(
                    "[PRIM INVENTORY]: " +
-                    "Tried to retrieve item ID {0} from prim {1}, {2} but the item does not exist in this inventory",
+                    "Tried to retrieve item ID {0} from prim {1}, {2} at {3} in {4} but the item does not exist in this inventory",
-                    item.ItemID, m_part.Name, m_part.UUID);
+                    item.ItemID, m_part.Name, m_part.UUID, 
+                    m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
            }
            m_items.LockItemsForWrite(false);
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 5d0218f..fbc4ed5 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -791,11 +791,11 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void SendPrimUpdates()
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            m_sceneViewer.SendPrimUpdates();
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        #region Status Methods
@@ -1143,7 +1143,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="collisionPoint"></param>
        /// <param name="localid"></param>
        /// <param name="distance"></param>
-        public void RayCastCameraCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance)
+        public void RayCastCameraCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 pNormal)
        {
            const float POSITION_TOLERANCE = 0.02f;
            const float VELOCITY_TOLERANCE = 0.02f;
@@ -1185,7 +1185,8 @@ namespace OpenSim.Region.Framework.Scenes
            //    // m_log.Debug("DEBUG: HandleAgentUpdate: child agent");
            //    return;
            //}
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            ++m_movementUpdateCount;
            if (m_movementUpdateCount < 1)
@@ -1515,7 +1516,7 @@ namespace OpenSim.Region.Framework.Scenes
            m_scene.EventManager.TriggerOnClientMovement(this);
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        public void DoAutoPilot(uint not_used, Vector3 Pos, IClientAPI remote_client)
@@ -1831,7 +1832,7 @@ namespace OpenSim.Region.Framework.Scenes
                StandUp();
            }
            m_nextSitAnimation = "SIT";
+            
            //SceneObjectPart part = m_scene.GetSceneObjectPart(targetID);
            SceneObjectPart part = FindNextAvailableSitTarget(targetID);
@@ -1843,12 +1844,23 @@ namespace OpenSim.Region.Framework.Scenes
                }
                m_requestedSitTargetID = part.LocalId;
                //m_requestedSitOffset = offset;
+                //offset.X += part.Scale.X;// *offset.X;
+                //offset.Y += part.Scale.Y;// * offset.Y;
+                //offset.Z += part.Scale.Z;// * offset.Z;
+                //m_requestedSitOffset = offset;
+                m_log.DebugFormat("[SIT]: Client requested Sit Position: {0}", offset);
            }
            else
            {
                
                m_log.Warn("Sit requested on unknown object: " + targetID.ToString());
            }
+            if (m_scene.PhysicsScene.SupportsRayCast())
+            {
+                //m_scene.PhysicsScene.RaycastWorld(Vector3.Zero,Vector3.Zero, 0.01f,new RaycastCallback());
+            }
            SendSitResponse(remoteClient, targetID, offset);
        }
        
@@ -1966,7 +1978,7 @@ namespace OpenSim.Region.Framework.Scenes
            SendFullUpdateToAllClients();
        }
        
-        public void SitAltitudeCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance)       // KF: Nov 2009
+        public void SitAltitudeCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 normal)
        {
                        // KF: 091202 There appears to be a bug in Prim Edit Size - the process sometimes make a prim that RayTrace no longer
                        //     sees. Take/re-rez, or sim restart corrects the condition. Result of bug is incorrect sit height.
@@ -2046,7 +2058,7 @@ namespace OpenSim.Region.Framework.Scenes
                return;
            }
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            Rotation = rotation;
            Vector3 direc = vec * rotation;
@@ -2088,7 +2100,7 @@ namespace OpenSim.Region.Framework.Scenes
            // TODO: Add the force instead of only setting it to support multiple forces per frame?
            m_forceToApply = direc;
            m_isNudging = Nudging;
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        #endregion
@@ -2157,7 +2169,7 @@ namespace OpenSim.Region.Framework.Scenes
            // server.
            if (remoteClient.IsActive)
            {
-                m_perfMonMS = Environment.TickCount;
+                m_perfMonMS = Util.EnvironmentTickCount();
                PhysicsActor actor = m_physicsActor;
                Vector3 velocity = (actor != null) ? actor.Velocity : Vector3.Zero;
@@ -2170,7 +2182,7 @@ namespace OpenSim.Region.Framework.Scenes
                remoteClient.SendAvatarTerseUpdate(new SendAvatarTerseData(m_rootRegionHandle, (ushort)(m_scene.TimeDilation * ushort.MaxValue), LocalId,
                    pos, velocity, Vector3.Zero, m_bodyRot, CollisionPlane, m_uuid, null, GetUpdatePriority(remoteClient)));
-                m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+                m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
                m_scene.StatsReporter.AddAgentUpdates(1);
            }
        }
@@ -2180,11 +2192,11 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void SendTerseUpdateToAllClients()
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            
            m_scene.ForEachClient(SendTerseUpdateToClient);
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        public void SendCoarseLocations()
@@ -2204,7 +2216,7 @@ namespace OpenSim.Region.Framework.Scenes
        public void SendCoarseLocationsDefault(UUID sceneId, ScenePresence p)
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            List<Vector3> CoarseLocations = new List<Vector3>();
            List<UUID> AvatarUUIDs = new List<UUID>();
@@ -2240,7 +2252,7 @@ namespace OpenSim.Region.Framework.Scenes
            m_controllingClient.SendCoarseLocationUpdate(AvatarUUIDs, CoarseLocations);
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        public void CoarseLocationChange()
@@ -2277,7 +2289,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void SendInitialFullUpdateToAllClients()
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            ScenePresence[] avatars = m_scene.GetScenePresences();
@@ -2303,14 +2315,14 @@ namespace OpenSim.Region.Framework.Scenes
            }
            m_scene.StatsReporter.AddAgentUpdates(avatars.Length);
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
            //Animator.SendAnimPack();
        }
        public void SendFullUpdateToAllClients()
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            // only send update from root agents to other clients; children are only "listening posts"
            List<ScenePresence> avatars = m_scene.GetAvatars();
@@ -2320,7 +2332,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
            m_scene.StatsReporter.AddAgentUpdates(avatars.Count);
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
            Animator.SendAnimPack();
        }
@@ -2362,7 +2374,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void SendAppearanceToAllOtherAgents()
        {
-            m_perfMonMS = Environment.TickCount;
+            m_perfMonMS = Util.EnvironmentTickCount();
            m_scene.ForEachScenePresence(delegate(ScenePresence scenePresence)
                                         {
@@ -2371,8 +2383,8 @@ namespace OpenSim.Region.Framework.Scenes
                                                 SendAppearanceToOtherAgent(scenePresence);
                                             }
                                         });
-            
-            m_scene.StatsReporter.AddAgentTime(Environment.TickCount - m_perfMonMS);
+            m_scene.StatsReporter.AddAgentTime(Util.EnvironmentTickCountSubtract(m_perfMonMS));
        }
        /// <summary>
@@ -3073,7 +3085,9 @@ namespace OpenSim.Region.Framework.Scenes
            // The Physics Scene will send updates every 500 ms grep: m_physicsActor.SubscribeEvents(
            // as of this comment the interval is set in AddToPhysicalScene
-            
+            if (Animator!=null)
+                Animator.UpdateMovementAnimations();
            CollisionEventUpdate collisionData = (CollisionEventUpdate)e;
            Dictionary<uint, ContactPoint> coldata = collisionData.m_objCollisionList;
@@ -3085,7 +3099,7 @@ namespace OpenSim.Region.Framework.Scenes
                                m_lastColCount = coldata.Count;
                        }
                        
-            if (coldata.Count != 0)
+            if (coldata.Count != 0 && Animator != null)
            {
                switch (Animator.CurrentMovementAnimation)
                {
@@ -3189,11 +3203,13 @@ namespace OpenSim.Region.Framework.Scenes
            
            // I don't get it but mono crashes when you try to dispose of this timer,
            // unsetting the elapsed callback should be enough to allow for cleanup however.
-            //m_reprioritizationTimer.Dispose();
+            // m_reprioritizationTimer.Dispose(); 
            m_sceneViewer.Close();
            RemoveFromPhysicalScene();
+            m_animator.Close();
+            m_animator = null;
        }
        public ScenePresence()
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 56c6ed6..e368c2a 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -75,7 +75,7 @@ namespace OpenSim.Region.Framework.Scenes
            UnAckedBytes = 24,
        }
-        // Sending a stats update every 3 seconds
+        // Sending a stats update every 3 seconds-
        private int statsUpdatesEveryMS = 3000;
        private float statsUpdateFactor = 0;
        private float m_timeDilation = 0;
@@ -193,6 +193,9 @@ namespace OpenSim.Region.Framework.Scenes
                // / 10 divides the value by the number of times the sim heartbeat runs (10fps)
                // Then we divide the whole amount by the amount of seconds pass in between stats updates.
+                // 'statsUpdateFactor' is how often stats packets are sent in seconds. Used below to change
+                // values to X-per-second values.
                for (int i = 0; i<21;i++)
                {
                    sb[i] = new SimStatsPacket.StatBlock();
@@ -238,7 +241,7 @@ namespace OpenSim.Region.Framework.Scenes
                sb[12].StatValue = m_otherMS / statsUpdateFactor;
                sb[13].StatID = (uint)Stats.InPacketsPerSecond;
-                sb[13].StatValue = (m_inPacketsPerSecond);
+                sb[13].StatValue = (m_inPacketsPerSecond / statsUpdateFactor);
                sb[14].StatID = (uint)Stats.OutPacketsPerSecond;
                sb[14].StatValue = (m_outPacketsPerSecond / statsUpdateFactor);
@@ -285,8 +288,8 @@ namespace OpenSim.Region.Framework.Scenes
            m_fps = 0;
            m_pfps = 0;
            m_agentUpdates = 0;
-            m_inPacketsPerSecond = 0;
+            //m_inPacketsPerSecond = 0;
-            m_outPacketsPerSecond = 0;
+            //m_outPacketsPerSecond = 0;
            m_unAckedBytes = 0;
            m_scriptLinesPerSecond = 0;
@@ -373,12 +376,12 @@ namespace OpenSim.Region.Framework.Scenes
        public void AddInPackets(int numPackets)
        {
-            m_inPacketsPerSecond += numPackets;
+            m_inPacketsPerSecond = numPackets;
        }
        public void AddOutPackets(int numPackets)
        {
-            m_outPacketsPerSecond += numPackets;
+            m_outPacketsPerSecond = numPackets;
        }
        public void AddunAckedBytes(int numBytes)
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
index 8a27b7b..5abbb82 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
@@ -101,7 +101,16 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                {
                    throw new NotImplementedException();
                }
+                public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+                {
+                    //This connector doesn't support the windlight module yet
+                    //Return default LL windlight settings
+                    return new RegionMeta7WindlightData();
+                }
+                public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+                {
+                    //This connector doesn't support the windlight module yet
+                }
                public RegionSettings LoadRegionSettings(UUID regionUUID)
                {
                    return null;
diff --git a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
index 6c3e7eb..bdf1574 100644
--- a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
+++ b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
@@ -936,7 +936,7 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
            // TODO
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
            
        }
diff --git a/OpenSim/Region/OptionalModules/Avatar/Chat/IRCBridgeModule.cs b/OpenSim/Region/OptionalModules/Avatar/Chat/IRCBridgeModule.cs
index 70e80bc..e664b44 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Chat/IRCBridgeModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Chat/IRCBridgeModule.cs
@@ -69,13 +69,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
            m_config = config.Configs["IRC"];
            if (m_config == null)
            {
-                m_log.InfoFormat("[IRC-Bridge] module not configured");
+//                m_log.InfoFormat("[IRC-Bridge] module not configured");
                return;
            }
            if (!m_config.GetBoolean("enabled", false))
            {
-                m_log.InfoFormat("[IRC-Bridge] module disabled in configuration");
+//                m_log.InfoFormat("[IRC-Bridge] module disabled in configuration");
                return;
            }
@@ -85,6 +85,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
            }
            m_pluginEnabled = true;
+            m_log.InfoFormat("[IRC-Bridge]: Module enabled");
        }
        public void AddRegion(Scene scene)
@@ -143,7 +144,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
        public static XmlRpcResponse XmlRpcAdminMethod(XmlRpcRequest request, IPEndPoint remoteClient)
        {
-            m_log.Info("[IRC-Bridge]: XML RPC Admin Entry");
+            m_log.Debug("[IRC-Bridge]: XML RPC Admin Entry");
            XmlRpcResponse response = new XmlRpcResponse();
            Hashtable  responseData = new Hashtable();
@@ -188,7 +189,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
            }
            catch (Exception e)
            {
-                m_log.InfoFormat("[IRC-Bridge] XML RPC Admin request failed : {0}", e.Message);
+                m_log.ErrorFormat("[IRC-Bridge] XML RPC Admin request failed : {0}", e.Message);
                responseData["success"] = "false";
                responseData["error"]   = e.Message;
diff --git a/OpenSim/Region/OptionalModules/Python/PythonAPI/Console.cs b/OpenSim/Region/OptionalModules/Python/PythonAPI/Console.cs
deleted file mode 100644
index a823ff9..0000000
--- a/OpenSim/Region/OptionalModules/Python/PythonAPI/Console.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * 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.Reflection;
-using log4net;
-namespace OpenSim.Region.Modules.Python.PythonAPI
-{
-    class Console
-    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        public void WriteLine(string txt)
-        {
-            m_log.Info(txt);
-        }
-        public void WriteLine(string txt, params Object[] e)
-        {
-            m_log.Info(String.Format(txt, e));
-        }
-    }
-}
diff --git a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
index cf36d08..975033a 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
@@ -522,7 +522,7 @@ namespace OpenSim.Region.OptionalModules.World.NPC
            
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
        }
diff --git a/OpenSim/Region/Physics/Manager/PhysicsScene.cs b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
index 6d515e9..217d307 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsScene.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
@@ -36,7 +36,7 @@ namespace OpenSim.Region.Physics.Manager
 {
    public delegate void physicsCrash();
-    public delegate void RaycastCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance);
+    public delegate void RaycastCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 normal);
    public abstract class PhysicsScene
    {
@@ -204,7 +204,7 @@ namespace OpenSim.Region.Physics.Manager
        public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
        {
            if (retMethod != null)
-                retMethod(false, Vector3.Zero, 0, 999999999999f);
+                retMethod(false, Vector3.Zero, 0, 999999999999f, Vector3.Zero);
        }
        private class NullPhysicsScene : PhysicsScene
diff --git a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
index 905d3ba..b99baa2 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
@@ -1243,7 +1243,10 @@ namespace OpenSim.Region.Physics.OdePlugin
        {
            if (m_eventsubscription > m_requestedUpdateFrequency)
            {
-                base.SendCollisionUpdate(CollisionEventsThisFrame);
+                if (CollisionEventsThisFrame != null)
+                {
+                    base.SendCollisionUpdate(CollisionEventsThisFrame);
+                }
                CollisionEventsThisFrame = new CollisionEventUpdate();
                m_eventsubscription = 0;
            }
diff --git a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
index b0e9a91..c27c420 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
@@ -743,6 +743,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                        break;
                }
            }
+            if (returnMass > _parent_scene.maximumMassObject)
+                returnMass = _parent_scene.maximumMassObject;
            return returnMass;
        }// end CalculateMass
@@ -753,6 +755,7 @@ namespace OpenSim.Region.Physics.OdePlugin
            if (Body != (IntPtr) 0)
            {
                float newmass = CalculateMass();
                //m_log.Info("[PHYSICS]: New Mass: " + newmass.ToString());
                d.MassSetBoxTotal(out pMass, newmass, _size.X, _size.Y, _size.Z);
@@ -2158,7 +2161,10 @@ Console.WriteLine(" JointCreateFixed");
                // Re creates body on size.
                // EnableBody also does setMass()
                enableBody();
-                d.BodyEnable(Body);
+                if (Body != IntPtr.Zero)
+                {
+                    d.BodyEnable(Body);
+                }
            }
            _parent_scene.geom_name_map[prim_geom] = oldname;
diff --git a/OpenSim/Region/Physics/OdePlugin/ODERayCastRequestManager.cs b/OpenSim/Region/Physics/OdePlugin/ODERayCastRequestManager.cs
index c8ae229..732e835 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODERayCastRequestManager.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODERayCastRequestManager.cs
@@ -145,6 +145,7 @@ namespace OpenSim.Region.Physics.OdePlugin
            uint hitConsumerID = 0;
            float distance = 999999999999f;
            Vector3 closestcontact = new Vector3(99999f, 99999f, 99999f);
+            Vector3 snormal = Vector3.Zero;
            // Find closest contact and object.
            lock (m_contactResults)
@@ -157,6 +158,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                        hitConsumerID = cResult.ConsumerID;
                        distance = cResult.Depth;
                        hitYN = true;
+                        snormal = cResult.Normal;
                    }
                }
@@ -165,7 +167,7 @@ namespace OpenSim.Region.Physics.OdePlugin
            // Return results
            if (req.callbackMethod != null)
-                req.callbackMethod(hitYN, closestcontact, hitConsumerID, distance);
+                req.callbackMethod(hitYN, closestcontact, hitConsumerID, distance, snormal);
        }
        // This is the standard Near.   Uses space AABBs to speed up detection.
@@ -310,7 +312,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                        collisionresult.ConsumerID = ((OdePrim)p1).m_localID;
                        collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
                        collisionresult.Depth = contacts[i].depth;
-                        
+                        collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
+                                                             contacts[i].normal.Z);
                        lock (m_contactResults)
                            m_contactResults.Add(collisionresult);
                    }
@@ -325,6 +328,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                        collisionresult.ConsumerID = ((OdePrim)p2).m_localID;
                        collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
                        collisionresult.Depth = contacts[i].depth;
+                        collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
+                                      contacts[i].normal.Z);
                        lock (m_contactResults)
                            m_contactResults.Add(collisionresult);
@@ -358,5 +363,6 @@ namespace OpenSim.Region.Physics.OdePlugin
        public Vector3 Pos;
        public float Depth;
        public uint ConsumerID;
+        public Vector3 Normal;
    }
 }
diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
index a0aba2a..0384d6e 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -207,6 +207,7 @@ namespace OpenSim.Region.Physics.OdePlugin
        private float avMovementDivisorWalk = 1.3f;
        private float avMovementDivisorRun = 0.8f;
        private float minimumGroundFlightOffset = 3f;
+        public float maximumMassObject = 10000.01f;
        public bool meshSculptedPrim = true;
        public bool forceSimplePrimMeshing = false;
@@ -480,6 +481,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                    m_NINJA_physics_joints_enabled = physicsconfig.GetBoolean("use_NINJA_physics_joints", false);
                    minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", 3f);
+                    maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", 10000.01f);
                }
            }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs
index 9d97cb2..ee32755 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs
@@ -236,7 +236,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            iHttpReq.StopHttpRequest(localID, itemID);
            IWorldComm comms = engine.World.RequestModuleInterface<IWorldComm>();
-            comms.DeleteListener(itemID);
+            if (comms != null)
+                comms.DeleteListener(itemID);
            IXMLRPC xmlrpc = engine.World.RequestModuleInterface<IXMLRPC>();
            xmlrpc.DeleteChannels(itemID);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/CM_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/CM_Api.cs
new file mode 100644
index 0000000..4cc2f0a
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/CM_Api.cs
@@ -0,0 +1,430 @@
+using System;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Lifetime;
+using OpenMetaverse;
+using Nini.Config;
+using OpenSim;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.World.Meta7Windlight;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api.Plugins;
+using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
+using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
+using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+namespace OpenSim.Region.ScriptEngine.Shared.Api
+{
+    [Serializable]
+    public class CM_Api : MarshalByRefObject, ICM_Api, IScriptApi
+    {
+        internal IScriptEngine m_ScriptEngine;
+        internal SceneObjectPart m_host;
+        internal uint m_localID;
+        internal UUID m_itemID;
+        internal bool m_CMFunctionsEnabled = false;
+        internal IScriptModuleComms m_comms = null;
+        public void Initialize(IScriptEngine ScriptEngine, SceneObjectPart host, uint localID, UUID itemID)
+        {
+            m_ScriptEngine = ScriptEngine;
+            m_host = host;
+            m_localID = localID;
+            m_itemID = itemID;
+            if (m_ScriptEngine.Config.GetBoolean("AllowCareminsterFunctions", false))
+                m_CMFunctionsEnabled = true;
+            m_comms = m_ScriptEngine.World.RequestModuleInterface<IScriptModuleComms>();
+            if (m_comms == null)
+                m_CMFunctionsEnabled = false;
+        }
+        public override Object InitializeLifetimeService()
+        {
+            ILease lease = (ILease)base.InitializeLifetimeService();
+            if (lease.CurrentState == LeaseState.Initial)
+            {
+                lease.InitialLeaseTime = TimeSpan.FromMinutes(0);
+                //                lease.RenewOnCallTime = TimeSpan.FromSeconds(10.0);
+                //                lease.SponsorshipTimeout = TimeSpan.FromMinutes(1.0);
+            }
+            return lease;
+        }
+        public Scene World
+        {
+            get { return m_ScriptEngine.World; }
+        }
+        //
+        //Dumps an error message on the debug console.
+        //
+        internal void CMShoutError(string message)
+        {
+            if (message.Length > 1023)
+                message = message.Substring(0, 1023);
+            World.SimChat(Utils.StringToBytes(message),
+                          ChatTypeEnum.Shout, ScriptBaseClass.DEBUG_CHANNEL, m_host.ParentGroup.RootPart.AbsolutePosition, m_host.Name, m_host.UUID, true);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(ChatTypeEnum.Shout, ScriptBaseClass.DEBUG_CHANNEL, m_host.Name, m_host.UUID, message);
+        }
+        /// <summary>
+        /// Get the current Windlight scene
+        /// </summary>
+        /// <returns>List of windlight parameters</returns>
+        public LSL_List cmGetWindlightScene(LSL_List rules)
+        {
+            if (!m_CMFunctionsEnabled)
+            {
+                CMShoutError("Careminster functions are not enabled.");
+                return new LSL_List();
+            }
+            m_host.AddScriptLPS(1);
+            RegionMeta7WindlightData wl = m_host.ParentGroup.Scene.RegionInfo.WindlightSettings;
+            LSL_List values = new LSL_List();
+            int idx = 0;
+            while (idx < rules.Length)
+            {
+                uint rule = (uint)rules.GetLSLIntegerItem(idx);
+                LSL_List toadd = new LSL_List();
+                switch (rule)
+                {
+                    case (int)ScriptBaseClass.WL_AMBIENT:
+                        toadd.Add(new LSL_Rotation(wl.ambient.X, wl.ambient.Y, wl.ambient.Z, wl.ambient.W));
+                        break;
+                    case (int)ScriptBaseClass.WL_BIG_WAVE_DIRECTION:
+                        toadd.Add(new LSL_Vector(wl.bigWaveDirection.X, wl.bigWaveDirection.Y, 0.0f));
+                        break;
+                    case (int)ScriptBaseClass.WL_BLUE_DENSITY:
+                        toadd.Add(new LSL_Rotation(wl.blueDensity.X, wl.blueDensity.Y, wl.blueDensity.Z, wl.blueDensity.W));
+                        break;
+                    case (int)ScriptBaseClass.WL_BLUR_MULTIPLIER:
+                        toadd.Add(new LSL_Float(wl.blurMultiplier));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_COLOR:
+                        toadd.Add(new LSL_Rotation(wl.cloudColor.X, wl.cloudColor.Y, wl.cloudColor.Z, wl.cloudColor.W));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_COVERAGE:
+                        toadd.Add(new LSL_Float(wl.cloudCoverage));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_DETAIL_XY_DENSITY:
+                        toadd.Add(new LSL_Vector(wl.cloudDetailXYDensity.X, wl.cloudDetailXYDensity.Y, wl.cloudDetailXYDensity.Z));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_SCALE:
+                        toadd.Add(new LSL_Float(wl.cloudScale));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X:
+                        toadd.Add(new LSL_Float(wl.cloudScrollX));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK:
+                        toadd.Add(new LSL_Integer(wl.cloudScrollXLock ? 1 : 0));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y:
+                        toadd.Add(new LSL_Float(wl.cloudScrollY));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK:
+                        toadd.Add(new LSL_Integer(wl.cloudScrollYLock ? 1 : 0));
+                        break;
+                    case (int)ScriptBaseClass.WL_CLOUD_XY_DENSITY:
+                        toadd.Add(new LSL_Vector(wl.cloudXYDensity.X, wl.cloudXYDensity.Y, wl.cloudXYDensity.Z));
+                        break;
+                    case (int)ScriptBaseClass.WL_DENSITY_MULTIPLIER:
+                        toadd.Add(new LSL_Float(wl.densityMultiplier));
+                        break;
+                    case (int)ScriptBaseClass.WL_DISTANCE_MULTIPLIER:
+                        toadd.Add(new LSL_Float(wl.distanceMultiplier));
+                        break;
+                    case (int)ScriptBaseClass.WL_DRAW_CLASSIC_CLOUDS:
+                        toadd.Add(new LSL_Integer(wl.drawClassicClouds ? 1 : 0));
+                        break;
+                    case (int)ScriptBaseClass.WL_EAST_ANGLE:
+                        toadd.Add(new LSL_Float(wl.eastAngle));
+                        break;
+                    case (int)ScriptBaseClass.WL_FRESNEL_OFFSET:
+                        toadd.Add(new LSL_Float(wl.fresnelOffset));
+                        break;
+                    case (int)ScriptBaseClass.WL_FRESNEL_SCALE:
+                        toadd.Add(new LSL_Float(wl.fresnelScale));
+                        break;
+                    case (int)ScriptBaseClass.WL_HAZE_DENSITY:
+                        toadd.Add(new LSL_Float(wl.hazeDensity));
+                        break;
+                    case (int)ScriptBaseClass.WL_HAZE_HORIZON:
+                        toadd.Add(new LSL_Float(wl.hazeHorizon));
+                        break;
+                    case (int)ScriptBaseClass.WL_HORIZON:
+                        toadd.Add(new LSL_Rotation(wl.horizon.X, wl.horizon.Y, wl.horizon.Z, wl.horizon.W));
+                        break;
+                    case (int)ScriptBaseClass.WL_LITTLE_WAVE_DIRECTION:
+                        toadd.Add(new LSL_Vector(wl.littleWaveDirection.X, wl.littleWaveDirection.Y, 0.0f));
+                        break;
+                    case (int)ScriptBaseClass.WL_MAX_ALTITUDE:
+                        toadd.Add(new LSL_Integer(wl.maxAltitude));
+                        break;
+                    case (int)ScriptBaseClass.WL_NORMAL_MAP_TEXTURE:
+                        toadd.Add(new LSL_Key(wl.normalMapTexture.ToString()));
+                        break;
+                    case (int)ScriptBaseClass.WL_REFLECTION_WAVELET_SCALE:
+                        toadd.Add(new LSL_Vector(wl.reflectionWaveletScale.X, wl.reflectionWaveletScale.Y, wl.reflectionWaveletScale.Z));
+                        break;
+                    case (int)ScriptBaseClass.WL_REFRACT_SCALE_ABOVE:
+                        toadd.Add(new LSL_Float(wl.refractScaleAbove));
+                        break;
+                    case (int)ScriptBaseClass.WL_REFRACT_SCALE_BELOW:
+                        toadd.Add(new LSL_Float(wl.refractScaleBelow));
+                        break;
+                    case (int)ScriptBaseClass.WL_SCENE_GAMMA:
+                        toadd.Add(new LSL_Float(wl.sceneGamma));
+                        break;
+                    case (int)ScriptBaseClass.WL_STAR_BRIGHTNESS:
+                        toadd.Add(new LSL_Float(wl.starBrightness));
+                        break;
+                    case (int)ScriptBaseClass.WL_SUN_GLOW_FOCUS:
+                        toadd.Add(new LSL_Float(wl.sunGlowFocus));
+                        break;
+                    case (int)ScriptBaseClass.WL_SUN_GLOW_SIZE:
+                        toadd.Add(new LSL_Float(wl.sunGlowSize));
+                        break;
+                    case (int)ScriptBaseClass.WL_SUN_MOON_COLOR:
+                        toadd.Add(new LSL_Rotation(wl.sunMoonColor.X, wl.sunMoonColor.Y, wl.sunMoonColor.Z, wl.sunMoonColor.W));
+                        break;
+                    case (int)ScriptBaseClass.WL_UNDERWATER_FOG_MODIFIER:
+                        toadd.Add(new LSL_Float(wl.underwaterFogModifier));
+                        break;
+                    case (int)ScriptBaseClass.WL_WATER_COLOR:
+                        toadd.Add(new LSL_Vector(wl.waterColor.X, wl.waterColor.Y, wl.waterColor.Z));
+                        break;
+                    case (int)ScriptBaseClass.WL_WATER_FOG_DENSITY_EXPONENT:
+                        toadd.Add(new LSL_Float(wl.waterFogDensityExponent));
+                        break;
+                }
+                if (toadd.Length > 0)
+                {
+                    values.Add(rule);
+                    values.Add(toadd.Data[0]);
+                }
+                idx++;
+            }
+            return values;
+        }
+        /// <summary>
+        /// Set the current Windlight scene
+        /// </summary>
+        /// <param name="rules"></param>
+        /// <returns>success: true or false</returns>
+        public int cmSetWindlightScene(LSL_List rules)
+        {
+            if (!m_CMFunctionsEnabled)
+            {
+                CMShoutError("Careminster functions are not enabled.");
+                return 0;
+            }
+            int success = 0;
+            m_host.AddScriptLPS(1);
+            if (Meta7WindlightModule.EnableWindlight)
+            {
+                RegionMeta7WindlightData wl = m_host.ParentGroup.Scene.RegionInfo.WindlightSettings;
+                LSL_List values = new LSL_List();
+                int idx = 0;
+                success = 1;
+                while (idx < rules.Length)
+                {
+                    uint rule = (uint)rules.GetLSLIntegerItem(idx);
+                    LSL_Types.Quaternion iQ;
+                    LSL_Types.Vector3 iV;
+                    switch (rule)
+                    {
+                        case (int)ScriptBaseClass.WL_AMBIENT:
+                            idx++;
+                            iQ = rules.GetQuaternionItem(idx);
+                            wl.ambient = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
+                            break;
+                        case (int)ScriptBaseClass.WL_BIG_WAVE_DIRECTION:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.bigWaveDirection = new Vector2((float)iV.x, (float)iV.y);
+                            break;
+                        case (int)ScriptBaseClass.WL_BLUE_DENSITY:
+                            idx++;
+                            iQ = rules.GetQuaternionItem(idx);
+                            wl.blueDensity = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
+                            break;
+                        case (int)ScriptBaseClass.WL_BLUR_MULTIPLIER:
+                            idx++;
+                            wl.blurMultiplier = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_COLOR:
+                            idx++;
+                            iQ = rules.GetQuaternionItem(idx);
+                            wl.cloudColor = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_COVERAGE:
+                            idx++;
+                            wl.cloudCoverage = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_DETAIL_XY_DENSITY:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.cloudDetailXYDensity = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_SCALE:
+                            idx++;
+                            wl.cloudScale = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X:
+                            idx++;
+                            wl.cloudScrollX = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK:
+                            idx++;
+                            wl.cloudScrollXLock = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y:
+                            idx++;
+                            wl.cloudScrollY = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK:
+                            idx++;
+                            wl.cloudScrollYLock = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
+                            break;
+                        case (int)ScriptBaseClass.WL_CLOUD_XY_DENSITY:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.cloudDetailXYDensity = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
+                            break;
+                        case (int)ScriptBaseClass.WL_DENSITY_MULTIPLIER:
+                            idx++;
+                            wl.densityMultiplier = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_DISTANCE_MULTIPLIER:
+                            idx++;
+                            wl.distanceMultiplier = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_DRAW_CLASSIC_CLOUDS:
+                            idx++;
+                            wl.drawClassicClouds = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
+                            break;
+                        case (int)ScriptBaseClass.WL_EAST_ANGLE:
+                            idx++;
+                            wl.eastAngle = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_FRESNEL_OFFSET:
+                            idx++;
+                            wl.fresnelOffset = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_FRESNEL_SCALE:
+                            idx++;
+                            wl.fresnelScale = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_HAZE_DENSITY:
+                            idx++;
+                            wl.hazeDensity = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_HAZE_HORIZON:
+                            idx++;
+                            wl.hazeHorizon = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_HORIZON:
+                            idx++;
+                            iQ = rules.GetQuaternionItem(idx);
+                            wl.horizon = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
+                            break;
+                        case (int)ScriptBaseClass.WL_LITTLE_WAVE_DIRECTION:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.littleWaveDirection = new Vector2((float)iV.x, (float)iV.y);
+                            break;
+                        case (int)ScriptBaseClass.WL_MAX_ALTITUDE:
+                            idx++;
+                            wl.maxAltitude = (ushort)rules.GetLSLIntegerItem(idx).value;
+                            break;
+                        case (int)ScriptBaseClass.WL_NORMAL_MAP_TEXTURE:
+                            idx++;
+                            wl.normalMapTexture = new UUID(rules.GetLSLStringItem(idx).m_string);
+                            break;
+                        case (int)ScriptBaseClass.WL_REFLECTION_WAVELET_SCALE:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.reflectionWaveletScale = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
+                            break;
+                        case (int)ScriptBaseClass.WL_REFRACT_SCALE_ABOVE:
+                            idx++;
+                            wl.refractScaleAbove = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_REFRACT_SCALE_BELOW:
+                            idx++;
+                            wl.refractScaleBelow = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_SCENE_GAMMA:
+                            idx++;
+                            wl.sceneGamma = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_STAR_BRIGHTNESS:
+                            idx++;
+                            wl.starBrightness = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_SUN_GLOW_FOCUS:
+                            idx++;
+                            wl.sunGlowFocus = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_SUN_GLOW_SIZE:
+                            idx++;
+                            wl.sunGlowSize = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_SUN_MOON_COLOR:
+                            idx++;
+                            iQ = rules.GetQuaternionItem(idx);
+                            wl.sunMoonColor = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
+                            break;
+                        case (int)ScriptBaseClass.WL_UNDERWATER_FOG_MODIFIER:
+                            idx++;
+                            wl.underwaterFogModifier = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        case (int)ScriptBaseClass.WL_WATER_COLOR:
+                            idx++;
+                            iV = rules.GetVector3Item(idx);
+                            wl.waterColor = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
+                            break;
+                        case (int)ScriptBaseClass.WL_WATER_FOG_DENSITY_EXPONENT:
+                            idx++;
+                            wl.waterFogDensityExponent = (float)rules.GetLSLFloatItem(idx);
+                            break;
+                        default:
+                            success = 0;
+                            break;
+                    }
+                    idx++;
+                }
+                m_host.ParentGroup.Scene.StoreWindlightProfile(wl);
+            }
+            return success;
+        }
+        
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 8274fbf..e694f15 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -749,7 +749,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                          ChatTypeEnum.Whisper, channelID, m_host.ParentGroup.RootPart.AbsolutePosition, m_host.Name, m_host.UUID, false);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text);
+            if (wComm != null)
+                wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text);
        }
        public void llSay(int channelID, string text)
@@ -769,7 +770,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                              ChatTypeEnum.Say, channelID, m_host.ParentGroup.RootPart.AbsolutePosition, m_host.Name, m_host.UUID, false);
                IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-                wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text);
+                if (wComm != null)
+                    wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text);
            }
        }
@@ -784,7 +786,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                          ChatTypeEnum.Shout, channelID, m_host.ParentGroup.RootPart.AbsolutePosition, m_host.Name, m_host.UUID, true);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text);
+            if (wComm != null)
+                wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text);
        }
        public void llRegionSay(int channelID, string text)
@@ -801,7 +804,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            m_host.AddScriptLPS(1);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text);
+            if (wComm != null)
+                wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text);
        }
        public LSL_Integer llListen(int channelID, string name, string ID, string msg)
@@ -810,21 +814,26 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            UUID keyID;
            UUID.TryParse(ID, out keyID);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg);
+            if (wComm != null)
+                return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg);
+            else
+                return -1;
        }
        public void llListenControl(int number, int active)
        {
            m_host.AddScriptLPS(1);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            wComm.ListenControl(m_itemID, number, active);
+            if (wComm != null)
+                wComm.ListenControl(m_itemID, number, active);
        }
        public void llListenRemove(int number)
        {
            m_host.AddScriptLPS(1);
            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
-            wComm.ListenRemove(m_itemID, number);
+            if (wComm != null)
+                wComm.ListenRemove(m_itemID, number);
        }
        public void llSensor(string name, string id, int type, double range, double arc)
@@ -1052,7 +1061,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            return detectedParams.TouchUV;
        }
-        public void llDie()
+        public virtual void llDie()
        {
            m_host.AddScriptLPS(1);
            throw new SelfDeleteException();
@@ -2941,8 +2950,17 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            return m_host.OwnerID.ToString();
        }
+        [DebuggerNonUserCode]
        public void llInstantMessage(string user, string message)
        {
+            UUID result;
+            if (!UUID.TryParse(user, out result))
+            {
+                throw new Exception(String.Format("An invalid key of '{0} was passed to llInstantMessage", user));
+                return;
+            }
+            
            m_host.AddScriptLPS(1);
            // We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
@@ -2957,7 +2975,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            UUID friendTransactionID = UUID.Random();
            //m_pendingFriendRequests.Add(friendTransactionID, fromAgentID);
+            
            GridInstantMessage msg = new GridInstantMessage();
            msg.fromAgentID = new Guid(m_host.UUID.ToString()); // fromAgentID.Guid;
            msg.toAgentID = new Guid(user); // toAgentID.Guid;
@@ -3570,6 +3588,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                {
                    parentPrim.DelinkFromGroup(part.LocalId, true);
                }
+                parentPrim.HasGroupChanged = true;
+                parentPrim.ScheduleGroupForFullUpdate();
                parentPrim.TriggerScriptChangedEvent(Changed.LINK);
                if (parts.Count > 0)
@@ -3581,6 +3601,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                        part.UpdateFlag = 0;
                        newRoot.ParentGroup.LinkToGroup(part.ParentGroup);
                    }
+                    newRoot.ParentGroup.HasGroupChanged = true;
+                    newRoot.ParentGroup.ScheduleGroupForFullUpdate();
                }
            }
            else
@@ -3589,6 +3611,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                    return;
                parentPrim.DelinkFromGroup(childPrim.LocalId, true);
+                parentPrim.HasGroupChanged = true;
+                parentPrim.ScheduleGroupForFullUpdate();
                parentPrim.TriggerScriptChangedEvent(Changed.LINK);
            }
        }
@@ -3608,6 +3632,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                parentPrim.DelinkFromGroup(part.LocalId, true);
                parentPrim.TriggerScriptChangedEvent(Changed.LINK);
            }
+            parentPrim.HasGroupChanged = true;
+            parentPrim.ScheduleGroupForFullUpdate();
        }
        public LSL_String llGetLinkKey(int linknum)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index 7f739b1..836f276 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -1973,6 +1973,5 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                        }
                        return ret;
                }
    }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs
index 0716d45..eeb59d9 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs
@@ -166,7 +166,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
                ts.next = DateTime.Now.Ticks + (long)data[idx+1];
                idx += 2;
-                Timers.Add(MakeTimerKey(localID,itemID), ts);
+                lock (TimerListLock)
+                {
+                    Timers.Add(MakeTimerKey(localID, itemID), ts);
+                }
            }
        }
    }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ICM_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ICM_Api.cs
new file mode 100644
index 0000000..9dd0b73
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ICM_Api.cs
@@ -0,0 +1,20 @@
+using System.Collections;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
+using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
+{
+    public interface ICM_Api
+    {
+        // Windlight Functions
+        LSL_List cmGetWindlightScene(LSL_List rules);
+        int cmSetWindlightScene(LSL_List rules);
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
index 0b0dc00..c3bf7d2 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
@@ -80,7 +80,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
        // Avatar Info Commands
        string osGetAgentIP(string agent);
        LSL_List osGetAgents();
+        
        // Teleport commands
        void osTeleportAgent(string agent, string regionName, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
        void osTeleportAgent(string agent, int regionX, int regionY, LSL_Types.Vector3 position, LSL_Types.Vector3 lookat);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/CM_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/CM_Constants.cs
new file mode 100644
index 0000000..7b67fa3
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/CM_Constants.cs
@@ -0,0 +1,76 @@
+/*
+ * 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 vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+using LSLInteger = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
+{
+    public partial class ScriptBaseClass
+    {
+        // Constants for cmWindlight*
+        public const int WL_WATER_COLOR = 0;
+        public const int WL_WATER_FOG_DENSITY_EXPONENT = 1;
+        public const int WL_UNDERWATER_FOG_MODIFIER = 2;
+        public const int WL_REFLECTION_WAVELET_SCALE = 3;
+        public const int WL_FRESNEL_SCALE = 4;
+        public const int WL_FRESNEL_OFFSET = 5;
+        public const int WL_REFRACT_SCALE_ABOVE = 6;
+        public const int WL_REFRACT_SCALE_BELOW = 7;
+        public const int WL_BLUR_MULTIPLIER = 8;
+        public const int WL_BIG_WAVE_DIRECTION = 9;
+        public const int WL_LITTLE_WAVE_DIRECTION = 10;
+        public const int WL_NORMAL_MAP_TEXTURE = 11;
+        public const int WL_HORIZON = 12;
+        public const int WL_HAZE_HORIZON = 13;
+        public const int WL_BLUE_DENSITY = 14;
+        public const int WL_HAZE_DENSITY = 15;
+        public const int WL_DENSITY_MULTIPLIER = 16;
+        public const int WL_DISTANCE_MULTIPLIER = 17;
+        public const int WL_MAX_ALTITUDE = 18;
+        public const int WL_SUN_MOON_COLOR = 19;
+        public const int WL_AMBIENT = 20;
+        public const int WL_EAST_ANGLE = 21;
+        public const int WL_SUN_GLOW_FOCUS = 22;
+        public const int WL_SUN_GLOW_SIZE = 23;
+        public const int WL_SCENE_GAMMA = 24;
+        public const int WL_STAR_BRIGHTNESS = 25;
+        public const int WL_CLOUD_COLOR = 26;
+        public const int WL_CLOUD_XY_DENSITY = 27;
+        public const int WL_CLOUD_COVERAGE = 28;
+        public const int WL_CLOUD_SCALE = 29;
+        public const int WL_CLOUD_DETAIL_XY_DENSITY = 30;
+        public const int WL_CLOUD_SCROLL_X = 31;
+        public const int WL_CLOUD_SCROLL_Y = 32;
+        public const int WL_CLOUD_SCROLL_Y_LOCK = 33;
+        public const int WL_CLOUD_SCROLL_X_LOCK = 34;
+        public const int WL_DRAW_CLASSIC_CLOUDS = 35;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/Python/PythonModule.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/CM_Stub.cs
index ce35363..e85d41e 100644
--- a/OpenSim/Region/OptionalModules/Python/PythonModule.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/CM_Stub.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -26,46 +26,46 @@
 */
 using System;
-using System.Collections.Generic;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
 using System.Reflection;
-using System.Security.Policy;
+using System.Collections;
-using System.Text;
+using System.Collections.Generic;
-using IronPython.Hosting;
+using OpenSim.Framework;
-using log4net;
-using Nini.Config;
 using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+using integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+using key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
+using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
+using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
+using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
-namespace OpenSim.Region.Modules.Python
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
 {
-    class PythonModule : IRegionModule
+    public partial class ScriptBaseClass : MarshalByRefObject
    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        public ICM_Api m_CM_Functions;
-        private PythonEngine m_python;
-        public void Initialise(Scene scene, IConfigSource source)
+        public void ApiTypeCM(IScriptApi api)
        {
-        }
+            if (!(api is ICM_Api))
+                return;
-        public void PostInitialise()
+            m_CM_Functions = (ICM_Api)api;
-        {
-            m_log.Info("[PYTHON] Initialising IronPython engine.");
-            m_python = new PythonEngine();
-            m_python.AddToPath(System.Environment.CurrentDirectory + System.IO.Path.DirectorySeparatorChar + "Python");
-        }
-        public void Close()
-        {
        }
-        public string Name
+        public LSL_List cmGetWindlightScene(LSL_List rules)
        {
-            get { return "PythonModule"; }
+            return m_CM_Functions.cmGetWindlightScene(rules);
        }
-        public bool IsSharedModule
+        public int cmSetWindlightScene(LSL_List rules)
        {
-            get { return true; }
+            return m_CM_Functions.cmSetWindlightScene(rules);
        }
    }
 }
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp
index 98bbc68..23138ef 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp
@@ -17,6 +17,8 @@
    <excludeFiles />
  </DeploymentInformation>
  <Contents>
+    <File name="./CM_Constants.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./CM_Stub.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
    <File name="./Executor.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
    <File name="./LSL_Constants.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
    <File name="./LSL_Stub.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index 2fc2ea1..184af19 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -101,6 +101,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine
        private Dictionary<UUID, IScriptInstance> m_Scripts =
                new Dictionary<UUID, IScriptInstance>();
+        private OpenMetaverse.ReaderWriterLockSlim m_scriptsLock = new OpenMetaverse.ReaderWriterLockSlim();
        // Maps the asset ID to the assembly
        private Dictionary<UUID, string> m_Assemblies =
@@ -122,6 +124,71 @@ namespace OpenSim.Region.ScriptEngine.XEngine
        private ScriptCompileQueue m_CompileQueue = new ScriptCompileQueue();
        IWorkItemResult m_CurrentCompile = null;
+        private void lockScriptsForRead(bool locked)
+        {
+            if (locked)
+            {
+                if (m_scriptsLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[XEngine.m_Scripts] Recursive read lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_scriptsLock.ExitReadLock();
+                }
+                if (m_scriptsLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[XEngine.m_Scripts] Recursive write lock requested. This should not happen and means something needs to be fixed.");
+                    m_scriptsLock.ExitWriteLock();
+                }
+                while (!m_scriptsLock.TryEnterReadLock(60000))
+                {
+                    m_log.Error("[XEngine.m_Scripts] Thread lock detected while trying to aquire READ lock of m_scripts in XEngine. I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_scriptsLock.IsWriteLockHeld)
+                    {
+                        m_scriptsLock = new OpenMetaverse.ReaderWriterLockSlim();
+                    }
+                }
+            }
+            else
+            {
+                if (m_scriptsLock.RecursiveReadCount > 0)
+                {
+                    m_scriptsLock.ExitReadLock();
+                }
+            }
+        }
+        private void lockScriptsForWrite(bool locked)
+        {
+            if (locked)
+            {
+                if (m_scriptsLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[XEngine.m_Scripts] Recursive read lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_scriptsLock.ExitReadLock();
+                }
+                if (m_scriptsLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[XEngine.m_Scripts] Recursive write lock requested. This should not happen and means something needs to be fixed.");
+                    m_scriptsLock.ExitWriteLock();
+                }
+                while (!m_scriptsLock.TryEnterWriteLock(60000))
+                {
+                    m_log.Error("[XEngine.m_Scripts] Thread lock detected while trying to aquire WRITE lock of m_scripts in XEngine. I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_scriptsLock.IsWriteLockHeld)
+                    {
+                        m_scriptsLock = new OpenMetaverse.ReaderWriterLockSlim();
+                    }
+                }
+            }
+            else
+            {
+                if (m_scriptsLock.RecursiveWriteCount > 0)
+                {
+                    m_scriptsLock.ExitWriteLock();
+                }
+            }
+        }
        public string ScriptEngineName
        {
            get { return "XEngine"; }
@@ -261,43 +328,45 @@ namespace OpenSim.Region.ScriptEngine.XEngine
        public void RemoveRegion(Scene scene)
        {
-            lock (m_Scripts)
+            lockScriptsForRead(true);
+            foreach (IScriptInstance instance in m_Scripts.Values)
            {
-                foreach (IScriptInstance instance in m_Scripts.Values)
+                // Force a final state save
+                //
+                if (m_Assemblies.ContainsKey(instance.AssetID))
                {
-                    // Force a final state save
+                    string assembly = m_Assemblies[instance.AssetID];
-                    //
+                    instance.SaveState(assembly);
-                    if (m_Assemblies.ContainsKey(instance.AssetID))
+                }
-                    {
-                        string assembly = m_Assemblies[instance.AssetID];
-                        instance.SaveState(assembly);
-                    }
-                    // Clear the event queue and abort the instance thread
+                // Clear the event queue and abort the instance thread
-                    //
+                //
-                    instance.ClearQueue();
+                instance.ClearQueue();
-                    instance.Stop(0);
+                instance.Stop(0);
-                    // Release events, timer, etc
+                // Release events, timer, etc
-                    //
+                //
-                    instance.DestroyScriptInstance();
+                instance.DestroyScriptInstance();
-                    // Unload scripts and app domains
+                // Unload scripts and app domains
-                    // Must be done explicitly because they have infinite
+                // Must be done explicitly because they have infinite
-                    // lifetime
+                // lifetime
-                    //
+                //
-                    m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
+                m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
-                    if (m_DomainScripts[instance.AppDomain].Count == 0)
+                if (m_DomainScripts[instance.AppDomain].Count == 0)
-                    {
+                {
-                        m_DomainScripts.Remove(instance.AppDomain);
+                    m_DomainScripts.Remove(instance.AppDomain);
-                        UnloadAppDomain(instance.AppDomain);
+                    UnloadAppDomain(instance.AppDomain);
-                    }
                }
-                m_Scripts.Clear();
-                m_PrimObjects.Clear();
-                m_Assemblies.Clear();
-                m_DomainScripts.Clear();
            }
+            lockScriptsForRead(false);
+            lockScriptsForWrite(true);
+            m_Scripts.Clear();
+            lockScriptsForWrite(false);
+            m_PrimObjects.Clear();
+            m_Assemblies.Clear();
+            m_DomainScripts.Clear();
+           
            lock (m_ScriptEngines)
            {
                m_ScriptEngines.Remove(this);
@@ -356,22 +425,20 @@ namespace OpenSim.Region.ScriptEngine.XEngine
            List<IScriptInstance> instances = new List<IScriptInstance>();
-            lock (m_Scripts)
+            lockScriptsForRead(true);
-            {
+                 foreach (IScriptInstance instance in m_Scripts.Values)
-                foreach (IScriptInstance instance in m_Scripts.Values)
                    instances.Add(instance);
-            }
+            lockScriptsForRead(false);
            foreach (IScriptInstance i in instances)
            {
                string assembly = String.Empty;
-                lock (m_Scripts)
+                
-                {
                    if (!m_Assemblies.ContainsKey(i.AssetID))
                        continue;
                    assembly = m_Assemblies[i.AssetID];
-                }
+                
                i.SaveState(assembly);
            }
@@ -673,172 +740,183 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                return false;
            }
-            lock (m_Scripts)
+            
+            ScriptInstance instance = null;
+            // Create the object record
+            lockScriptsForRead(true);
+            if ((!m_Scripts.ContainsKey(itemID)) ||
+                (m_Scripts[itemID].AssetID != assetID))
            {
-                ScriptInstance instance = null;
+                lockScriptsForRead(false);
-                // Create the object record
-                if ((!m_Scripts.ContainsKey(itemID)) ||
+                UUID appDomain = assetID;
-                    (m_Scripts[itemID].AssetID != assetID))
-                {
-                    UUID appDomain = assetID;
-                    if (part.ParentGroup.IsAttachment)
+                if (part.ParentGroup.IsAttachment)
-                        appDomain = part.ParentGroup.RootPart.UUID;
+                    appDomain = part.ParentGroup.RootPart.UUID;
-                    if (!m_AppDomains.ContainsKey(appDomain))
+                if (!m_AppDomains.ContainsKey(appDomain))
+                {
+                    try
                    {
-                        try
+                        AppDomainSetup appSetup = new AppDomainSetup();
-                        {
+                        //                            appSetup.ApplicationBase = Path.Combine(
-                            AppDomainSetup appSetup = new AppDomainSetup();
+                        //                                    "ScriptEngines",
-//                            appSetup.ApplicationBase = Path.Combine(
+                        //                                    m_Scene.RegionInfo.RegionID.ToString());
-//                                    "ScriptEngines",
-//                                    m_Scene.RegionInfo.RegionID.ToString());
+                        Evidence baseEvidence = AppDomain.CurrentDomain.Evidence;
+                        Evidence evidence = new Evidence(baseEvidence);
-                            Evidence baseEvidence = AppDomain.CurrentDomain.Evidence;
-                            Evidence evidence = new Evidence(baseEvidence);
+                        AppDomain sandbox;
+                        if (m_AppDomainLoading)
-                            AppDomain sandbox;
+                            sandbox = AppDomain.CreateDomain(
-                            if (m_AppDomainLoading)
+                                            m_Scene.RegionInfo.RegionID.ToString(),
-                                sandbox = AppDomain.CreateDomain(
+                                            evidence, appSetup);
-                                                m_Scene.RegionInfo.RegionID.ToString(),
+                        else
-                                                evidence, appSetup);
+                            sandbox = AppDomain.CurrentDomain;
-                            else
-                                sandbox = AppDomain.CurrentDomain;
+                        //PolicyLevel sandboxPolicy = PolicyLevel.CreateAppDomainLevel();
-                            
+                        //AllMembershipCondition sandboxMembershipCondition = new AllMembershipCondition();
-                            //PolicyLevel sandboxPolicy = PolicyLevel.CreateAppDomainLevel();
+                        //PermissionSet sandboxPermissionSet = sandboxPolicy.GetNamedPermissionSet("Internet");
-                            //AllMembershipCondition sandboxMembershipCondition = new AllMembershipCondition();
+                        //PolicyStatement sandboxPolicyStatement = new PolicyStatement(sandboxPermissionSet);
-                            //PermissionSet sandboxPermissionSet = sandboxPolicy.GetNamedPermissionSet("Internet");
+                        //CodeGroup sandboxCodeGroup = new UnionCodeGroup(sandboxMembershipCondition, sandboxPolicyStatement);
-                            //PolicyStatement sandboxPolicyStatement = new PolicyStatement(sandboxPermissionSet);
+                        //sandboxPolicy.RootCodeGroup = sandboxCodeGroup;
-                            //CodeGroup sandboxCodeGroup = new UnionCodeGroup(sandboxMembershipCondition, sandboxPolicyStatement);
+                        //sandbox.SetAppDomainPolicy(sandboxPolicy);
-                            //sandboxPolicy.RootCodeGroup = sandboxCodeGroup;
-                            //sandbox.SetAppDomainPolicy(sandboxPolicy);
+                        m_AppDomains[appDomain] = sandbox;
-                            
-                            m_AppDomains[appDomain] = sandbox;
+                        m_AppDomains[appDomain].AssemblyResolve +=
+                            new ResolveEventHandler(
-                            m_AppDomains[appDomain].AssemblyResolve +=
+                                AssemblyResolver.OnAssemblyResolve);
-                                new ResolveEventHandler(
+                        m_DomainScripts[appDomain] = new List<UUID>();
-                                    AssemblyResolver.OnAssemblyResolve);
-                            m_DomainScripts[appDomain] = new List<UUID>();
-                        }
-                        catch (Exception e)
-                        {
-                            m_log.ErrorFormat("[XEngine] Exception creating app domain:\n {0}", e.ToString());
-                            m_ScriptErrorMessage += "Exception creating app domain:\n";
-                            m_ScriptFailCount++;
-                            lock (m_AddingAssemblies) 
-                            {
-                                m_AddingAssemblies[assembly]--;
-                            }
-                            return false;
-                        }
                    }
-                    m_DomainScripts[appDomain].Add(itemID);
+                    catch (Exception e)
-                    instance = new ScriptInstance(this, part,
-                                                  itemID, assetID, assembly,
-                                                  m_AppDomains[appDomain],
-                                                  part.ParentGroup.RootPart.Name,
-                                                  item.Name, startParam, postOnRez,
-                                                  stateSource, m_MaxScriptQueue);
-                    
-                    m_log.DebugFormat("[XEngine] Loaded script {0}.{1}, script UUID {2}, prim UUID {3} @ {4}",
-                            part.ParentGroup.RootPart.Name, item.Name, assetID, part.UUID, part.ParentGroup.RootPart.AbsolutePosition.ToString());
-                    if (presence != null)
                    {
-                        ShowScriptSaveResponse(item.OwnerID,
+                        m_log.ErrorFormat("[XEngine] Exception creating app domain:\n {0}", e.ToString());
-                                assetID, "Compile successful", true);
+                        m_ScriptErrorMessage += "Exception creating app domain:\n";
+                        m_ScriptFailCount++;
+                        lock (m_AddingAssemblies)
+                        {
+                            m_AddingAssemblies[assembly]--;
+                        }
+                        return false;
                    }
+                }
+                m_DomainScripts[appDomain].Add(itemID);
-                    instance.AppDomain = appDomain;
+                instance = new ScriptInstance(this, part,
-                    instance.LineMap = linemap;
+                                              itemID, assetID, assembly,
+                                              m_AppDomains[appDomain],
+                                              part.ParentGroup.RootPart.Name,
+                                              item.Name, startParam, postOnRez,
+                                              stateSource, m_MaxScriptQueue);
-                    m_Scripts[itemID] = instance;
+                m_log.DebugFormat("[XEngine] Loaded script {0}.{1}, script UUID {2}, prim UUID {3} @ {4}",
-                }
+                        part.ParentGroup.RootPart.Name, item.Name, assetID, part.UUID, part.ParentGroup.RootPart.AbsolutePosition.ToString());
-                lock (m_PrimObjects)
+                if (presence != null)
                {
-                    if (!m_PrimObjects.ContainsKey(localID))
+                    ShowScriptSaveResponse(item.OwnerID,
-                        m_PrimObjects[localID] = new List<UUID>();
+                            assetID, "Compile successful", true);
+                }
-                    if (!m_PrimObjects[localID].Contains(itemID))
+                instance.AppDomain = appDomain;
-                        m_PrimObjects[localID].Add(itemID);
+                instance.LineMap = linemap;
+                lockScriptsForWrite(true);
+                m_Scripts[itemID] = instance;
+                lockScriptsForWrite(false);
+            }
+            else
+            {
+                lockScriptsForRead(false);
+            }
+            lock (m_PrimObjects)
+            {
+                if (!m_PrimObjects.ContainsKey(localID))
+                    m_PrimObjects[localID] = new List<UUID>();
-                }
+                if (!m_PrimObjects[localID].Contains(itemID))
+                    m_PrimObjects[localID].Add(itemID);
-                if (!m_Assemblies.ContainsKey(assetID))
+            }
-                    m_Assemblies[assetID] = assembly;
-                lock (m_AddingAssemblies) 
+            if (!m_Assemblies.ContainsKey(assetID))
-                {
+                m_Assemblies[assetID] = assembly;
-                    m_AddingAssemblies[assembly]--;
-                }
-                if (instance!=null) 
+            lock (m_AddingAssemblies) 
-                    instance.Init();
+            {
+                m_AddingAssemblies[assembly]--;
            }
+            if (instance!=null) 
+                instance.Init();
+            
            return true;
        }
        public void OnRemoveScript(uint localID, UUID itemID)
        {
-            lock (m_Scripts)
+            lockScriptsForRead(true);
+            // Do we even have it?
+            if (!m_Scripts.ContainsKey(itemID))
            {
-                // Do we even have it?
+                lockScriptsForRead(false);
-                if (!m_Scripts.ContainsKey(itemID))
+                return;
-                    return;
+            }
+             
-                IScriptInstance instance=m_Scripts[itemID];
-                m_Scripts.Remove(itemID);
-                instance.ClearQueue();
+            IScriptInstance instance=m_Scripts[itemID];
-                instance.Stop(0);
+            lockScriptsForRead(false);
+            lockScriptsForWrite(true);
+            m_Scripts.Remove(itemID);
+            lockScriptsForWrite(false);
+            instance.ClearQueue();
+            instance.Stop(0);
-                SceneObjectPart part =
+            SceneObjectPart part =
-                    m_Scene.GetSceneObjectPart(localID);
+                m_Scene.GetSceneObjectPart(localID);
-                if (part != null)
+            if (part != null)
-                    part.RemoveScriptEvents(itemID);
+                part.RemoveScriptEvents(itemID);
 //                bool objectRemoved = false;
-                lock (m_PrimObjects)
+            lock (m_PrimObjects)
+            {
+                // Remove the script from it's prim
+                if (m_PrimObjects.ContainsKey(localID))
                {
-                    // Remove the script from it's prim
+                    // Remove inventory item record
-                    if (m_PrimObjects.ContainsKey(localID))
+                    if (m_PrimObjects[localID].Contains(itemID))
-                    {
+                        m_PrimObjects[localID].Remove(itemID);
-                        // Remove inventory item record
-                        if (m_PrimObjects[localID].Contains(itemID))
-                            m_PrimObjects[localID].Remove(itemID);
-                        // If there are no more scripts, remove prim
+                    // If there are no more scripts, remove prim
-                        if (m_PrimObjects[localID].Count == 0)
+                    if (m_PrimObjects[localID].Count == 0)
-                        {
+                    {
-                            m_PrimObjects.Remove(localID);
+                        m_PrimObjects.Remove(localID);
 //                            objectRemoved = true;
-                        }
                    }
                }
+            }
-                instance.RemoveState();
+            instance.RemoveState();
-                instance.DestroyScriptInstance();
+            instance.DestroyScriptInstance();
-                m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
+            m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
-                if (m_DomainScripts[instance.AppDomain].Count == 0)
+            if (m_DomainScripts[instance.AppDomain].Count == 0)
-                {
+            {
-                    m_DomainScripts.Remove(instance.AppDomain);
+                m_DomainScripts.Remove(instance.AppDomain);
-                    UnloadAppDomain(instance.AppDomain);
+                UnloadAppDomain(instance.AppDomain);
-                }
+            }
-                instance = null;
+            instance = null;
-                ObjectRemoved handlerObjectRemoved = OnObjectRemoved;
+            ObjectRemoved handlerObjectRemoved = OnObjectRemoved;
-                if (handlerObjectRemoved != null)
+            if (handlerObjectRemoved != null)
-                    handlerObjectRemoved(part.UUID);
+                handlerObjectRemoved(part.UUID);
-                CleanAssemblies();
+            CleanAssemblies();
-            }
+            
            ScriptRemoved handlerScriptRemoved = OnScriptRemoved;
            if (handlerScriptRemoved != null)
@@ -1091,12 +1169,14 @@ namespace OpenSim.Region.ScriptEngine.XEngine
        private IScriptInstance GetInstance(UUID itemID)
        {
            IScriptInstance instance;
-            lock (m_Scripts)
+            lockScriptsForRead(true);
+            if (!m_Scripts.ContainsKey(itemID))
            {
-                if (!m_Scripts.ContainsKey(itemID))
+                lockScriptsForRead(false);
-                    return null;
+                return null;
-                instance = m_Scripts[itemID];
            }
+            instance = m_Scripts[itemID];
+            lockScriptsForRead(false);
            return instance;
        }
@@ -1200,11 +1280,10 @@ namespace OpenSim.Region.ScriptEngine.XEngine
        {
            List<IScriptInstance> instances = new List<IScriptInstance>();
-            lock (m_Scripts)
+            lockScriptsForRead(true);
-            {
+            foreach (IScriptInstance instance in m_Scripts.Values)
-                foreach (IScriptInstance instance in m_Scripts.Values)
                    instances.Add(instance);
-            }
+            lockScriptsForRead(false);
            foreach (IScriptInstance i in instances)
            {
@@ -1394,7 +1473,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
            if (rootE.GetAttribute("UUID") != itemID.ToString())
                return;
-            string assetID = rootE.GetAttribute("Asset");
+//            string assetID = rootE.GetAttribute("Asset");
            XmlNodeList stateL = rootE.GetElementsByTagName("ScriptState");
diff --git a/OpenSim/Server/Base/ServicesServerBase.cs b/OpenSim/Server/Base/ServicesServerBase.cs
index 1d9eb0d..63ba673 100644
--- a/OpenSim/Server/Base/ServicesServerBase.cs
+++ b/OpenSim/Server/Base/ServicesServerBase.cs
@@ -226,6 +226,10 @@ namespace OpenSim.Server.Base
                    "quit",
                    "Quit the application", HandleQuit);
+            MainConsole.Instance.Commands.AddCommand("base", false, "shutdown",
+                    "shutdown",
+                    "Quit the application", HandleQuit);
            // Allow derived classes to perform initialization that
            // needs to be done after the console has opened
            //
diff --git a/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs b/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs
index c2ad9db..a1c032e 100644
--- a/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs
@@ -67,7 +67,7 @@ namespace OpenSim.Services.Connectors
            IConfig authorizationConfig = source.Configs["AuthorizationService"];
            if (authorizationConfig == null)
            {
-                m_log.Error("[AUTHORIZATION CONNECTOR]: AuthorizationService missing from OpenSim.ini");
+                m_log.Info("[AUTHORIZATION CONNECTOR]: AuthorizationService missing from OpenSim.ini");
                throw new Exception("Authorization connector init error");
            }
diff --git a/OpenSim/Tests/Common/Mock/TestAssetDataPlugin.cs b/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs
index 20ea18f..cc1dfbf 100644
--- a/OpenSim/Tests/Common/Mock/TestAssetDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/MockAssetDataPlugin.cs
@@ -38,10 +38,10 @@ namespace OpenSim.Tests.Common.Mock
    /// mono addin plugin system starts co-operating with the unit test system.  Currently no locking since unit
    /// tests are single threaded.
    /// </summary>
-    public class TestAssetDataPlugin : BaseAssetRepository, IAssetDataPlugin
+    public class MockAssetDataPlugin : BaseAssetRepository, IAssetDataPlugin
    {
        public string Version { get { return "0"; } }
-        public string Name { get { return "TestAssetDataPlugin"; } }
+        public string Name { get { return "MockAssetDataPlugin"; } }
        public void Initialise() {}
        public void Initialise(string connect) {}
diff --git a/OpenSim/Tests/Common/Mock/TestClient.cs b/OpenSim/Tests/Common/Mock/TestClient.cs
index 27025d9..5f172c4 100644
--- a/OpenSim/Tests/Common/Mock/TestClient.cs
+++ b/OpenSim/Tests/Common/Mock/TestClient.cs
@@ -491,7 +491,7 @@ namespace OpenSim.Tests.Common.Mock
        }
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
        {
        }
diff --git a/bin/IronMath.dll b/bin/IronMath.dll
deleted file mode 100644
index 4960cc6..0000000
--- a/bin/IronMath.dll
+++ /dev/null
Binary files differ
diff --git a/bin/IronPython.dll b/bin/IronPython.dll
deleted file mode 100644
index 2efe7ef..0000000
--- a/bin/IronPython.dll
+++ /dev/null
Binary files differ
diff --git a/bin/OpenSim.ini.example b/bin/OpenSim.ini.example
index f9d9ca6..04cf8e8 100644
--- a/bin/OpenSim.ini.example
+++ b/bin/OpenSim.ini.example
@@ -91,7 +91,7 @@
    ; Maximum total size, and maximum size where a prim can be physical
    NonPhysicalPrimMax = 256
-    PhysicalPrimMax = 10
+    PhysicalPrimMax = 10 ; (I think this was moved to the Regions.ini!)
    ClampPrimSize = false
    ; Region crossing
@@ -342,7 +342,7 @@
    ; The MessagingServer is a companion of the UserServer. It uses
    ; user_send_key and user_recv_key, too
-    ;messaging_server_url = "http://127.0.0.1:8006"
+    messaging_server_url = "http://127.0.0.1:8006"
    ; What is reported as the "X-Secondlife-Shard"
    ; Defaults to the user server url if not set
@@ -597,6 +597,9 @@
    body_motor_joint_maxforce_tensor_linux = 5
    body_motor_joint_maxforce_tensor_win = 5
+    ; Maximum mass an object can be before it is clamped
+    maximum_mass_object = 10000.01
    ; ##
    ; ## Sculpted Prim settings
    ; ##
@@ -822,6 +825,12 @@
    ; default is 1000
    cloud_update_rate = 1000
+[Meta7Windlight]
+    ; This enables the transmission of Windlight scenes to supporting clients, such as the Meta7 viewer.
+    ; It has no ill effect on viewers which do not support server-side windlight settings.
+    ; Currently we only have support for MySQL databases.
+    enable_windlight = false;
 [Trees]
    ; Enable this to allow the tree module to manage your sim trees, including growing, reproducing and dying
@@ -971,6 +980,9 @@
    ; Allow the use of os* functions (some are dangerous)
    AllowOSFunctions = false
+    
+    ; Allow the user of Careminster functions
+    AllowCareminsterFunctions = false
    ; Threat level to allow, one of None, VeryLow, Low, Moderate, High, VeryHigh, Severe
    OSFunctionThreatLevel = VeryLow
@@ -1155,7 +1167,6 @@
    safemode = false
 [VivoxVoice]
    ; The VivoxVoice module will allow you to provide voice on your
    ; region(s). It uses the same voice technology as the LL grid and
    ; works with recent LL clients (we have tested 1.22.9.110075, so
@@ -1296,6 +1307,15 @@
     RootReprioritizationDistance = 10.0
     ChildReprioritizationDistance = 20.0
+[WebStats]
+; View region statistics via a web page
+; See http://opensimulator.org/wiki/FAQ#Region_Statistics_on_a_Web_Page 
+; Use a web browser and type in the "Login URI" + "/SStats/"
+; For example- http://127.0.0.1:9000/SStats/
+; enabled=false
 ;;
 ;; These are defaults that are overwritten below in [Architecture].
 ;; These defaults allow OpenSim to work out of the box with
diff --git a/prebuild.xml b/prebuild.xml
index ad06938..9d428d1 100644
--- a/prebuild.xml
+++ b/prebuild.xml
@@ -1684,8 +1684,6 @@
      <Reference name="OpenMetaverseTypes.dll"/>
      <Reference name="OpenMetaverse.StructuredData.dll"/>
      <Reference name="OpenMetaverse.dll"/>
-      <Reference name="IronPython.dll"/>
-      <Reference name="IronMath.dll"/>
      <Reference name="PumaCode.SvnDotNet.dll"/>
      <Reference name="OpenSim.Framework"/>
      <Reference name="OpenSim.Framework.Communications"/>