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

10 files changed, 609 insertions, 60 deletions

diff --git a/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs b/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs
new file mode 100644
index 0000000..36aaab3
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.CoreModules.Avatar.Assets
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class GetMeshModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+        private IAssetService m_assetService;
+
+        #region IRegionModuleBase Members
+
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+           
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            
+            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        #endregion
+
+
+        #region IRegionModule Members
+
+       
+
+        public void Close() { }
+
+        public string Name { get { return "GetMeshModule"; } }
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            m_log.Info("[GETMESH]: /CAPS/" + capID);
+            caps.RegisterHandler("GetMesh",
+                                 new RestHTTPHandler("GET", "/CAPS/" + capID,
+                                                       delegate(Hashtable m_dhttpMethod)
+                                                       {
+                                                           return ProcessGetMesh(m_dhttpMethod, agentID, caps);
+                                                       }));
+         
+        }
+
+        #endregion
+
+        public Hashtable ProcessGetMesh(Hashtable request, UUID AgentId, Caps cap)
+        {
+            
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+
+            string meshStr = string.Empty;
+
+            if (request.ContainsKey("mesh_id"))
+                meshStr = request["mesh_id"].ToString();
+
+
+            UUID meshID = UUID.Zero;
+            if (!String.IsNullOrEmpty(meshStr) && UUID.TryParse(meshStr, out meshID))
+            {
+                if (m_assetService == null)
+                {
+                    responsedata["int_response_code"] = 404; //501; //410; //404;
+                    responsedata["content_type"] = "text/plain";
+                    responsedata["keepalive"] = false;
+                    responsedata["str_response_string"] = "The asset service is unavailable.  So is your mesh.";
+                    return responsedata;
+                }
+
+                AssetBase mesh;
+                // Only try to fetch locally cached textures. Misses are redirected
+                mesh = m_assetService.GetCached(meshID.ToString());
+                if (mesh != null)
+                {
+                    if (mesh.Type == (SByte)AssetType.Mesh) 
+                    {
+                        responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
+                        responsedata["content_type"] = "application/vnd.ll.mesh";
+                        responsedata["int_response_code"] = 200;
+                    }
+                    // Optionally add additional mesh types here
+                    else
+                    {
+                        responsedata["int_response_code"] = 404; //501; //410; //404;
+                        responsedata["content_type"] = "text/plain";
+                        responsedata["keepalive"] = false;
+                        responsedata["str_response_string"] = "Unfortunately, this asset isn't a mesh.";
+                        return responsedata;
+                    }
+                }
+                else
+                {
+                    mesh = m_assetService.Get(meshID.ToString());
+                    if (mesh != null)
+                    {
+                        if (mesh.Type == (SByte)AssetType.Mesh) 
+                        {
+                            responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
+                            responsedata["content_type"] = "application/vnd.ll.mesh";
+                            responsedata["int_response_code"] = 200;
+                        }
+                        // Optionally add additional mesh types here
+                        else
+                        {
+                            responsedata["int_response_code"] = 404; //501; //410; //404;
+                            responsedata["content_type"] = "text/plain";
+                            responsedata["keepalive"] = false;
+                            responsedata["str_response_string"] = "Unfortunately, this asset isn't a mesh.";
+                            return responsedata;
+                        }
+                    }
+
+                    else
+                    {
+                        responsedata["int_response_code"] = 404; //501; //410; //404;
+                        responsedata["content_type"] = "text/plain";
+                        responsedata["keepalive"] = false;
+                        responsedata["str_response_string"] = "Your Mesh wasn't found.  Sorry!";
+                        return responsedata;
+                    }
+                }
+
+            }
+
+            return responsedata;
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs
new file mode 100644
index 0000000..af26b2b
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Framework.Capabilities;
+
+namespace OpenSim.Region.CoreModules.Avatar.Assets
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class NewFileAgentInventoryVariablePriceModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+        private IAssetService m_assetService;
+        private bool m_dumpAssetsToFile = false;
+
+        #region IRegionModuleBase Members
+
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+           
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            
+            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        #endregion
+
+
+        #region IRegionModule Members
+
+       
+
+        public void Close() { }
+
+        public string Name { get { return "NewFileAgentInventoryVariablePriceModule"; } }
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            m_log.Info("[GETMESH]: /CAPS/" + capID);
+            caps.RegisterHandler("NewFileAgentInventoryVariablePrice",
+
+                    new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDNewFileAngentInventoryVariablePriceReplyResponse>("POST",
+                                                                                           "/CAPS/" + capID.ToString(),
+                                                                                           delegate(LLSDAssetUploadRequest req)
+                                                       {
+                                                           return NewAgentInventoryRequest(req,agentID);
+                                                       }));
+         
+        }
+
+        #endregion
+
+        public LLSDNewFileAngentInventoryVariablePriceReplyResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest, UUID agentID)
+        {
+
+            //TODO:  The Mesh uploader uploads many types of content. If you're going to implement a Money based limit
+            // You need to be aware of this and 
+
+
+            //if (llsdRequest.asset_type == "texture" ||
+           //     llsdRequest.asset_type == "animation" ||
+           //     llsdRequest.asset_type == "sound")
+           // {
+                IClientAPI client = null;
+
+                
+                IMoneyModule mm = m_scene.RequestModuleInterface<IMoneyModule>();
+                
+                if (mm != null)
+                {
+                    if (m_scene.TryGetClient(agentID, out client))
+                    {
+                        if (!mm.UploadCovered(client, mm.UploadCharge))
+                        {
+                            if (client != null)
+                                client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+
+                            LLSDNewFileAngentInventoryVariablePriceReplyResponse errorResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
+                            errorResponse.rsvp = "";
+                            errorResponse.state = "error";
+                            return errorResponse;
+                        }
+                    }
+                }
+           // }
+            
+
+
+            string assetName = llsdRequest.name;
+            string assetDes = llsdRequest.description;
+            string capsBase = "/CAPS/NewFileAgentInventoryVariablePrice/";
+            UUID newAsset = UUID.Random();
+            UUID newInvItem = UUID.Random();
+            UUID parentFolder = llsdRequest.folder_id;
+            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000") + "/";
+
+            Caps.AssetUploader uploader =
+                new Caps.AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
+                                  llsdRequest.asset_type, capsBase + uploaderPath, MainServer.Instance, m_dumpAssetsToFile);
+            MainServer.Instance.AddStreamHandler(
+                new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+            string protocol = "http://";
+
+            if (MainServer.Instance.UseSSL)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_scene.RegionInfo.ExternalHostName + ":" + MainServer.Instance.Port.ToString() + capsBase +
+                                 uploaderPath;
+         
+
+            LLSDNewFileAngentInventoryVariablePriceReplyResponse uploadResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
+           
+            
+            uploadResponse.rsvp = uploaderURL;
+            uploadResponse.state = "upload";
+            uploadResponse.resource_cost = 0;
+            uploadResponse.upload_price = 0;
+
+            uploader.OnUpLoad += //UploadCompleteHandler;
+                
+                delegate(
+                string passetName, string passetDescription, UUID passetID,
+                UUID pinventoryItem, UUID pparentFolder, byte[] pdata, string pinventoryType,
+                string passetType)
+               {
+                   UploadCompleteHandler(passetName, passetDescription,  passetID,
+                                          pinventoryItem, pparentFolder, pdata,  pinventoryType,
+                                          passetType,agentID);
+               };
+            return uploadResponse;
+        }
+
+       
+        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
+                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
+                                          string assetType,UUID AgentID)
+        {
+            
+            sbyte assType = 0;
+            sbyte inType = 0;
+
+            if (inventoryType == "sound")
+            {
+                inType = 1;
+                assType = 1;
+            }
+            else if (inventoryType == "animation")
+            {
+                inType = 19;
+                assType = 20;
+            }
+            else if (inventoryType == "wearable")
+            {
+                inType = 18;
+                switch (assetType)
+                {
+                    case "bodypart":
+                        assType = 13;
+                        break;
+                    case "clothing":
+                        assType = 5;
+                        break;
+                }
+            }
+            else if (inventoryType == "mesh")
+            {
+                inType = (sbyte)InventoryType.Mesh; 
+                assType = (sbyte)AssetType.Mesh;
+            }
+
+            AssetBase asset;
+            asset = new AssetBase(assetID, assetName, assType, AgentID.ToString());
+            asset.Data = data;
+    
+            if (m_scene.AssetService != null)
+                m_scene.AssetService.Store(asset);
+
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = AgentID;
+            item.CreatorId = AgentID.ToString();
+            item.ID = inventoryItem;
+            item.AssetID = asset.FullID;
+            item.Description = assetDescription;
+            item.Name = assetName;
+            item.AssetType = assType;
+            item.InvType = inType;
+            item.Folder = parentFolder;
+            item.CurrentPermissions = (uint)PermissionMask.All;
+            item.BasePermissions = (uint)PermissionMask.All;
+            item.EveryOnePermissions = 0;
+            item.NextPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+            m_scene.AddInventoryItem(item);
+            
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
index 457e0bb..2a0c0b1 100644
--- a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
@@ -113,6 +113,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 if (!m_scene.Permissions.CanTakeObject(part.UUID, remoteClient.AgentId))
                     return;
 
+                // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
+                // be removed when that functionality is implemented in opensim
+                AttachmentPt &= 0x7f;
+
                 // Calls attach with a Zero position
                 if (AttachObject(remoteClient, part.ParentGroup, AttachmentPt, false))
                 {
@@ -142,6 +146,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
             if (m_scene.Permissions.CanTakeObject(group.UUID, remoteClient.AgentId))
             {
+                // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
+                // be removed when that functionality is implemented in opensim
+                AttachmentPt &= 0x7f;
+                
                 // If the attachment point isn't the same as the one previously used
                 // set it's offset position = 0 so that it appears on the attachment point
                 // and not in a weird location somewhere unknown.
@@ -228,6 +236,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 "[ATTACHMENTS MODULE]: Rezzing attachment to point {0} from item {1} for {2}", 
                 (AttachmentPoint)AttachmentPt, itemID, remoteClient.Name);
             
+            // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
+            // be removed when that functionality is implemented in opensim
+            AttachmentPt &= 0x7f;
+
             SceneObjectGroup att = RezSingleAttachmentFromInventoryInternal(remoteClient, itemID, AttachmentPt);
 
             if (updateInventoryStatus)
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
index 6b538f6..f1f5258 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
@@ -51,6 +51,12 @@ namespace OpenSim.Region.CoreModules.World.Archiver
     public class ArchiveReadRequest
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        /// <summary>
+        /// The maximum major version of OAR that we can read.  Minor versions shouldn't need a number since version
+        /// bumps here should be compatible.
+        /// </summary>
+        public static int MAX_MAJOR_VERSION = 0;
 
         protected Scene m_scene;
         protected Stream m_loadStream;
@@ -497,6 +503,22 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             {
                 if (xtr.NodeType == XmlNodeType.Element) 
                 {
+                    if (xtr.Name.ToString() == "archive")
+                    {
+                        int majorVersion = int.Parse(xtr["major_version"]);
+                        int minorVersion = int.Parse(xtr["minor_version"]);
+                        string version = string.Format("{0}.{1}", majorVersion, minorVersion);
+                        
+                        if (majorVersion > MAX_MAJOR_VERSION)
+                        {
+                            throw new Exception(
+                                string.Format(
+                                    "The OAR you are trying to load has major version number of {0} but this version of OpenSim can only load OARs with major version number {1} and below",
+                                    majorVersion, MAX_MAJOR_VERSION));
+                        }
+                        
+                        m_log.InfoFormat("[ARCHIVER]: Loading OAR with version {0}", version);
+                    }
                     if (xtr.Name.ToString() == "datetime") 
                     {
                         int value;
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
index 586d98e..c062833 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestExecution.cs
@@ -60,6 +60,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         protected Scene m_scene;
         protected TarArchiveWriter m_archiveWriter;
         protected Guid m_requestId;
+        protected Dictionary<string, object> m_options;
 
         public ArchiveWriteRequestExecution(
              List<SceneObjectGroup> sceneObjects,
@@ -67,7 +68,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
              IRegionSerialiserModule serialiser,
              Scene scene,
              TarArchiveWriter archiveWriter,
-             Guid requestId)
+             Guid requestId,
+             Dictionary<string, object> options)
         {
             m_sceneObjects = sceneObjects;
             m_terrainModule = terrainModule;
@@ -75,6 +77,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             m_scene = scene;
             m_archiveWriter = archiveWriter;
             m_requestId = requestId;
+            m_options = options;
         }
 
         protected internal void ReceivedAllAssets(
@@ -105,12 +108,6 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 //                "[ARCHIVER]: Received {0} of {1} assets requested",
 //                assetsFoundUuids.Count, assetsFoundUuids.Count + assetsNotFoundUuids.Count);
 
-            m_log.InfoFormat("[ARCHIVER]: Creating archive file.  This may take some time.");
-
-            // Write out control file
-            m_archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, Create0p2ControlFile());
-            m_log.InfoFormat("[ARCHIVER]: Added control file to archive.");
-
             // Write out region settings
             string settingsPath
                 = String.Format("{0}{1}.xml", ArchiveConstants.SETTINGS_PATH, m_scene.RegionInfo.RegionName);
@@ -140,47 +137,22 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
             m_log.InfoFormat("[ARCHIVER]: Added terrain information to archive.");
 
+            Dictionary<string, object> serializationOptions = new Dictionary<string, object>();
+//            if (m_options.ContainsKey("version") && (string)m_options["version"] == "0")
+//                serializationOptions["old-guids"] = true;
+            
             // Write out scene object metadata
             foreach (SceneObjectGroup sceneObject in m_sceneObjects)
             {
                 //m_log.DebugFormat("[ARCHIVER]: Saving {0} {1}, {2}", entity.Name, entity.UUID, entity.GetType());
 
-                string serializedObject = m_serialiser.SerializeGroupToXml2(sceneObject);
+                string serializedObject = m_serialiser.SerializeGroupToXml2(sceneObject, serializationOptions);
                 m_archiveWriter.WriteFile(ArchiveHelpers.CreateObjectPath(sceneObject), serializedObject);
             }
 
             m_log.InfoFormat("[ARCHIVER]: Added scene objects to archive.");
         }
 
-        /// <summary>
-        /// Create the control file for a 0.2 version archive
-        /// </summary>
-        /// <returns></returns>
-        public static string Create0p2ControlFile()
-        {
-            StringWriter sw = new StringWriter();
-            XmlTextWriter xtw = new XmlTextWriter(sw);
-            xtw.Formatting = Formatting.Indented;
-            xtw.WriteStartDocument();
-            xtw.WriteStartElement("archive");
-            xtw.WriteAttributeString("major_version", "0");
-            xtw.WriteAttributeString("minor_version", "3");
-
-            xtw.WriteStartElement("creation_info");
-            DateTime now = DateTime.UtcNow;
-            TimeSpan t = now - new DateTime(1970, 1, 1);
-            xtw.WriteElementString("datetime", ((int)t.TotalSeconds).ToString());
-            xtw.WriteElementString("id", UUID.Random().ToString());
-            xtw.WriteEndElement();
-            xtw.WriteEndElement();
-
-            xtw.Flush();
-            xtw.Close();
-
-            String s = sw.ToString();
-            sw.Close();
-
-            return s;
-        }
+
     }
 }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
index 283b33b..43789af 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs
@@ -32,6 +32,7 @@ using System.IO.Compression;
 using System.Reflection;
 using System.Text.RegularExpressions;
 using System.Threading;
+using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
@@ -98,7 +99,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// Archive the region requested.
         /// </summary>
         /// <exception cref="System.IO.IOException">if there was an io problem with creating the file</exception>
-        public void ArchiveRegion()
+        public void ArchiveRegion(Dictionary<string, object> options)
         {
             Dictionary<UUID, AssetType> assetUuids = new Dictionary<UUID, AssetType>();
 
@@ -165,11 +166,71 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     m_scene.RequestModuleInterface<IRegionSerialiserModule>(),
                     m_scene,
                     archiveWriter,
-                    m_requestId);
+                    m_requestId,
+                    options);
+
+            m_log.InfoFormat("[ARCHIVER]: Creating archive file.  This may take some time.");
+
+            // Write out control file
+            archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, Create0p2ControlFile(options));
+            m_log.InfoFormat("[ARCHIVER]: Added control file to archive.");
             
             new AssetsRequest(
                 new AssetsArchiver(archiveWriter), assetUuids, 
                 m_scene.AssetService, awre.ReceivedAllAssets).Execute();
         }
+        
+        /// <summary>
+        /// Create the control file for the most up to date archive
+        /// </summary>
+        /// <returns></returns>
+        public static string Create0p2ControlFile(Dictionary<string, object> options)
+        {
+            int majorVersion = 0, minorVersion = 4;
+            
+            /*
+            if (options.ContainsKey("version") && (string)options["version"] == "0")
+            {
+                majorVersion = 0;
+                minorVersion = 3;
+            }
+            else
+            {
+                majorVersion = 1;
+                minorVersion = 0;
+            }  
+            */
+            
+            m_log.InfoFormat("[ARCHIVER]: Creating version {0}.{1} OAR", majorVersion, minorVersion);
+//            if (majorVersion == 1)
+//            {
+//                m_log.WarnFormat("[ARCHIVER]: Please be aware that version 1.0 OARs are not compatible with OpenSim 0.7.0.2 and earlier.  Please use the --version=0 option if you want to produce a compatible OAR");                
+//            }
+            
+            
+            StringWriter sw = new StringWriter();
+            XmlTextWriter xtw = new XmlTextWriter(sw);
+            xtw.Formatting = Formatting.Indented;
+            xtw.WriteStartDocument();
+            xtw.WriteStartElement("archive");
+            xtw.WriteAttributeString("major_version", majorVersion.ToString());
+            xtw.WriteAttributeString("minor_version", minorVersion.ToString());
+
+            xtw.WriteStartElement("creation_info");
+            DateTime now = DateTime.UtcNow;
+            TimeSpan t = now - new DateTime(1970, 1, 1);
+            xtw.WriteElementString("datetime", ((int)t.TotalSeconds).ToString());
+            xtw.WriteElementString("id", UUID.Random().ToString());
+            xtw.WriteEndElement();
+            xtw.WriteEndElement();
+
+            xtw.Flush();
+            xtw.Close();
+
+            String s = sw.ToString();
+            sw.Close();
+
+            return s;
+        }        
     }
 }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
index 82ede01..e0ad71e 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
@@ -122,37 +122,44 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <param name="cmdparams"></param>
         public void HandleSaveOarConsoleCommand(string module, string[] cmdparams)
         {
+            Dictionary<string, object> options = new Dictionary<string, object>();
+
+            OptionSet ops = new OptionSet();
+            ops.Add("v|version=", delegate(string v) { options["version"] = v; });
+
+            List<string> mainParams = ops.Parse(cmdparams);
+
             if (cmdparams.Length > 2)
             {
-                ArchiveRegion(cmdparams[2]);
+                ArchiveRegion(mainParams[2], options);
             }
             else
             {
-                ArchiveRegion(DEFAULT_OAR_BACKUP_FILENAME);
+                ArchiveRegion(DEFAULT_OAR_BACKUP_FILENAME, options);
             }
         }
         
-        public void ArchiveRegion(string savePath)
+        public void ArchiveRegion(string savePath, Dictionary<string, object> options)
         {
-            ArchiveRegion(savePath, Guid.Empty);
+            ArchiveRegion(savePath, Guid.Empty, options);
         }
-        
-        public void ArchiveRegion(string savePath, Guid requestId)
+
+        public void ArchiveRegion(string savePath, Guid requestId, Dictionary<string, object> options)
         {
             m_log.InfoFormat(
                 "[ARCHIVER]: Writing archive for region {0} to {1}", m_scene.RegionInfo.RegionName, savePath);
             
-            new ArchiveWriteRequestPreparation(m_scene, savePath, requestId).ArchiveRegion();
+            new ArchiveWriteRequestPreparation(m_scene, savePath, requestId).ArchiveRegion(options);
         }
-        
+
         public void ArchiveRegion(Stream saveStream)
         {
             ArchiveRegion(saveStream, Guid.Empty);
         }
-        
+
         public void ArchiveRegion(Stream saveStream, Guid requestId)
         {
-            new ArchiveWriteRequestPreparation(m_scene, saveStream, requestId).ArchiveRegion();
+            new ArchiveWriteRequestPreparation(m_scene, saveStream, requestId).ArchiveRegion(new Dictionary<string, object>());
         }
 
         public void DearchiveRegion(string loadPath)
diff --git a/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs b/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
index 3342164..04bdc4f 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
@@ -230,7 +230,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             // upset load
             tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
             
-            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestExecution.Create0p2ControlFile());
+            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestPreparation.Create0p2ControlFile(new Dictionary<string, Object>()));
 
             SceneObjectPart part1 = CreateSceneObjectPart1();
             SceneObjectGroup object1 = new SceneObjectGroup(part1);
@@ -329,7 +329,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             TarArchiveWriter tar = new TarArchiveWriter(archiveWriteStream);
             
             tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
-            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestExecution.Create0p2ControlFile());
+            tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestPreparation.Create0p2ControlFile(new Dictionary<string, Object>()));
 
             RegionSettings rs = new RegionSettings();
             rs.AgentLimit = 17;
diff --git a/OpenSim/Region/CoreModules/World/Serialiser/SerialiserModule.cs b/OpenSim/Region/CoreModules/World/Serialiser/SerialiserModule.cs
index 04062b0..ec97acd 100644
--- a/OpenSim/Region/CoreModules/World/Serialiser/SerialiserModule.cs
+++ b/OpenSim/Region/CoreModules/World/Serialiser/SerialiserModule.cs
@@ -160,9 +160,9 @@ namespace OpenSim.Region.CoreModules.World.Serialiser
             return SceneXmlLoader.DeserializeGroupFromXml2(xmlString);
         }
 
-        public string SerializeGroupToXml2(SceneObjectGroup grp)
+        public string SerializeGroupToXml2(SceneObjectGroup grp, Dictionary<string, object> options)
         {
-            return SceneXmlLoader.SaveGroupToXml2(grp);
+            return SceneXmlLoader.SaveGroupToXml2(grp, options);
         }
 
         public void SavePrimListToXml2(EntityBase[] entityList, string fileName)
diff --git a/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs b/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
index 799a448..f10e848 100644
--- a/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
+++ b/OpenSim/Region/CoreModules/World/Serialiser/Tests/SerialiserTests.cs
@@ -25,6 +25,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
 using log4net.Config;
 using NUnit.Framework;
 using NUnit.Framework.SyntaxHelpers;
@@ -34,8 +37,6 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Setup;
-using System.IO;
-using System.Xml;
 
 namespace OpenSim.Region.CoreModules.World.Serialiser.Tests
 {
@@ -302,15 +303,19 @@ namespace OpenSim.Region.CoreModules.World.Serialiser.Tests
                 {
                     case "UUID":
                         xtr.ReadStartElement("UUID");
-                        uuid = UUID.Parse(xtr.ReadElementString("Guid"));
-                        xtr.ReadEndElement();
+                        try
+                        {
+                            uuid = UUID.Parse(xtr.ReadElementString("UUID"));
+                            xtr.ReadEndElement();
+                        }
+                        catch { } // ignore everything but <UUID><UUID>...</UUID></UUID>
                         break;
                     case "Name":
                         name = xtr.ReadElementContentAsString();
                         break;
                     case "CreatorID":
                         xtr.ReadStartElement("CreatorID");
-                        creatorId = UUID.Parse(xtr.ReadElementString("Guid"));
+                        creatorId = UUID.Parse(xtr.ReadElementString("UUID"));
                         xtr.ReadEndElement();
                         break;
                 }
@@ -369,7 +374,9 @@ namespace OpenSim.Region.CoreModules.World.Serialiser.Tests
             // Need to add the object to the scene so that the request to get script state succeeds
             m_scene.AddSceneObject(so);
 
-            string xml2 = m_serialiserModule.SerializeGroupToXml2(so);
+            Dictionary<string, object> options = new Dictionary<string, object>();
+            options["old-guids"] = true;
+            string xml2 = m_serialiserModule.SerializeGroupToXml2(so, options);
 
             XmlTextReader xtr = new XmlTextReader(new StringReader(xml2));
             xtr.ReadStartElement("SceneObjectGroup");