mirror of
https://github.com/opensim/opensim.git
synced 2026-07-16 04:25:42 +08:00
637 lines
28 KiB
C#
637 lines
28 KiB
C#
/*
|
|
* Copyright (c) 2008 Intel Corporation
|
|
* All rights reserved.
|
|
* 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 Intel Corporation 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``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 INTEL OR ITS
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using ExtensionLoader;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.StructuredData;
|
|
using HttpServer;
|
|
|
|
namespace OpenSim.Grid.AssetInventoryServer.Extensions
|
|
{
|
|
public class OpenSimInventoryFrontend : IExtension<AssetInventoryServer>
|
|
{
|
|
AssetInventoryServer server;
|
|
Utils.InventoryItemSerializer itemSerializer = new Utils.InventoryItemSerializer();
|
|
Utils.InventoryFolderSerializer folderSerializer = new Utils.InventoryFolderSerializer();
|
|
Utils.InventoryCollectionSerializer collectionSerializer = new Utils.InventoryCollectionSerializer();
|
|
|
|
public OpenSimInventoryFrontend()
|
|
{
|
|
}
|
|
|
|
public void Start(AssetInventoryServer server)
|
|
{
|
|
this.server = server;
|
|
|
|
server.HttpServer.AddHandler("post", null, @"^/GetInventory/", GetInventoryHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/CreateInventory/", CreateInventoryHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/NewFolder/", NewFolderHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/UpdateFolder/", UpdateFolderHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/MoveFolder/", MoveFolderHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/PurgeFolder/", PurgeFolderHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/NewItem/", NewItemHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/DeleteItem/", DeleteItemHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/RootFolders/", RootFoldersHandler);
|
|
server.HttpServer.AddHandler("post", null, @"^/ActiveGestures/", ActiveGesturesHandler);
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
}
|
|
|
|
bool GetInventoryHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID sessionID, agentID;
|
|
UUID ownerID = DeserializeUUID(request.Body, out agentID, out sessionID);
|
|
|
|
if (ownerID != UUID.Zero)
|
|
{
|
|
Logger.Log.Warn("GetInventory is not scalable on some inventory backends, avoid calling it wherever possible");
|
|
|
|
Uri owner = Utils.GetOpenSimUri(ownerID);
|
|
InventoryCollection inventory;
|
|
BackendResponse storageResponse = server.InventoryProvider.TryFetchInventory(owner, out inventory);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
collectionSerializer.Serialize(response.Body, inventory);
|
|
response.Body.Flush();
|
|
}
|
|
else if (storageResponse == BackendResponse.NotFound)
|
|
{
|
|
// Return an empty inventory set to mimic OpenSim.Grid.InventoryServer.exe
|
|
inventory = new InventoryCollection();
|
|
inventory.UserID = ownerID;
|
|
inventory.Folders = new Dictionary<UUID, InventoryFolder>();
|
|
inventory.Items = new Dictionary<UUID, InventoryItem>();
|
|
collectionSerializer.Serialize(response.Body, inventory);
|
|
response.Body.Flush();
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.InternalServerError;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.BadRequest;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CreateInventoryHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID ownerID = DeserializeUUID(request.Body);
|
|
|
|
if (ownerID != UUID.Zero)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(ownerID);
|
|
Logger.Log.DebugFormat("Created URI {0} for inventory creation", owner);
|
|
|
|
InventoryFolder rootFolder = new InventoryFolder("My Inventory", ownerID, UUID.Zero, (short)AssetType.Folder);
|
|
BackendResponse storageResponse = server.InventoryProvider.TryCreateInventory(owner, rootFolder);
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
CreateFolder("Animations", ownerID, rootFolder.ID, AssetType.Animation);
|
|
CreateFolder("Body Parts", ownerID, rootFolder.ID, AssetType.Bodypart);
|
|
CreateFolder("Calling Cards", ownerID, rootFolder.ID, AssetType.CallingCard);
|
|
CreateFolder("Clothing", ownerID, rootFolder.ID, AssetType.Clothing);
|
|
CreateFolder("Gestures", ownerID, rootFolder.ID, AssetType.Gesture);
|
|
CreateFolder("Landmarks", ownerID, rootFolder.ID, AssetType.Landmark);
|
|
CreateFolder("Lost and Found", ownerID, rootFolder.ID, AssetType.LostAndFoundFolder);
|
|
CreateFolder("Notecards", ownerID, rootFolder.ID, AssetType.Notecard);
|
|
CreateFolder("Objects", ownerID, rootFolder.ID, AssetType.Object);
|
|
CreateFolder("Photo Album", ownerID, rootFolder.ID, AssetType.SnapshotFolder);
|
|
CreateFolder("Scripts", ownerID, rootFolder.ID, AssetType.LSLText);
|
|
CreateFolder("Sounds", ownerID, rootFolder.ID, AssetType.Sound);
|
|
CreateFolder("Textures", ownerID, rootFolder.ID, AssetType.Texture);
|
|
CreateFolder("Trash", ownerID, rootFolder.ID, AssetType.TrashFolder);
|
|
|
|
SerializeBool(response.Body, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SerializeBool(response.Body, false);
|
|
return true;
|
|
}
|
|
|
|
bool NewFolderHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID agentID, sessionID;
|
|
InventoryFolder folder = DeserializeFolder(request.Body, out agentID, out sessionID);
|
|
|
|
if (folder != null)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(folder.Owner);
|
|
|
|
// Some calls that are moving or updating a folder instead of creating a new one
|
|
// will pass in an InventoryFolder without the name set. If this is the case we
|
|
// need to look up the name first
|
|
if (String.IsNullOrEmpty(folder.Name))
|
|
{
|
|
InventoryFolder oldFolder;
|
|
if (server.InventoryProvider.TryFetchFolder(owner, folder.ID, out oldFolder) == BackendResponse.Success)
|
|
folder.Name = oldFolder.Name;
|
|
}
|
|
|
|
BackendResponse storageResponse = server.InventoryProvider.TryCreateFolder(owner, folder);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeBool(response.Body, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SerializeBool(response.Body, false);
|
|
return true;
|
|
}
|
|
|
|
bool UpdateFolderHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
return NewFolderHandler(client, request, response);
|
|
}
|
|
|
|
bool MoveFolderHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
return NewFolderHandler(client, request, response);
|
|
}
|
|
|
|
bool PurgeFolderHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID agentID, sessionID;
|
|
InventoryFolder folder = DeserializeFolder(request.Body, out agentID, out sessionID);
|
|
|
|
if (folder != null)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(folder.Owner);
|
|
BackendResponse storageResponse = server.InventoryProvider.TryPurgeFolder(owner, folder.ID);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeBool(response.Body, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SerializeBool(response.Body, false);
|
|
return true;
|
|
}
|
|
|
|
bool NewItemHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID agentID, sessionID;
|
|
InventoryItem item = DeserializeItem(request.Body, out agentID, out sessionID);
|
|
|
|
if (item != null)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(agentID);
|
|
BackendResponse storageResponse = server.InventoryProvider.TryCreateItem(owner, item);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeBool(response.Body, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SerializeBool(response.Body, false);
|
|
return true;
|
|
}
|
|
|
|
bool DeleteItemHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID agentID, sessionID;
|
|
InventoryItem item = DeserializeItem(request.Body, out agentID, out sessionID);
|
|
|
|
if (item != null)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(item.Owner);
|
|
BackendResponse storageResponse = server.InventoryProvider.TryDeleteItem(owner, item.ID);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeBool(response.Body, true);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SerializeBool(response.Body, false);
|
|
return true;
|
|
}
|
|
|
|
bool RootFoldersHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID ownerID = DeserializeUUID(request.Body);
|
|
|
|
if (ownerID != UUID.Zero)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(ownerID);
|
|
List<InventoryFolder> skeleton;
|
|
BackendResponse storageResponse = server.InventoryProvider.TryFetchFolderList(owner, out skeleton);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeFolderList(response.Body, skeleton);
|
|
}
|
|
else if (storageResponse == BackendResponse.NotFound)
|
|
{
|
|
// Return an empty set of inventory so the requester knows that
|
|
// an inventory needs to be created for this agent
|
|
SerializeFolderList(response.Body, new List<InventoryFolder>(0));
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.InternalServerError;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.BadRequest;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ActiveGesturesHandler(IHttpClientContext client, IHttpRequest request, IHttpResponse response)
|
|
{
|
|
UUID ownerID = DeserializeUUID(request.Body);
|
|
|
|
if (ownerID != UUID.Zero)
|
|
{
|
|
Uri owner = Utils.GetOpenSimUri(ownerID);
|
|
List<InventoryItem> gestures;
|
|
BackendResponse storageResponse = server.InventoryProvider.TryFetchActiveGestures(owner, out gestures);
|
|
|
|
if (storageResponse == BackendResponse.Success)
|
|
{
|
|
SerializeItemList(response.Body, gestures);
|
|
}
|
|
else if (storageResponse == BackendResponse.NotFound)
|
|
{
|
|
// Return an empty set of gestures to match OpenSim.Grid.InventoryServer.exe behavior
|
|
SerializeItemList(response.Body, new List<InventoryItem>(0));
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.InternalServerError;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response.Status = HttpStatusCode.BadRequest;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BackendResponse CreateFolder(string name, UUID ownerID, UUID parentID, AssetType assetType)
|
|
{
|
|
InventoryFolder folder = new InventoryFolder(name, ownerID, parentID, (short)assetType);
|
|
Uri owner = Utils.GetOpenSimUri(ownerID);
|
|
return server.InventoryProvider.TryCreateFolder(owner, folder);
|
|
}
|
|
|
|
UUID DeserializeUUID(Stream stream)
|
|
{
|
|
UUID id = UUID.Zero;
|
|
|
|
try
|
|
{
|
|
using (XmlReader reader = XmlReader.Create(stream))
|
|
{
|
|
reader.MoveToContent();
|
|
UUID.TryParse(reader.ReadElementContentAsString("guid", String.Empty), out id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Log.Warn("Failed to parse POST data (expecting guid): " + ex.Message);
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
UUID DeserializeUUID(Stream stream, out UUID agentID, out UUID sessionID)
|
|
{
|
|
UUID id;
|
|
|
|
try
|
|
{
|
|
using (XmlReader reader = XmlReader.Create(stream))
|
|
{
|
|
reader.MoveToContent();
|
|
reader.ReadStartElement("RestSessionObjectOfGuid");
|
|
UUID.TryParse(reader.ReadElementContentAsString("SessionID", String.Empty), out sessionID);
|
|
UUID.TryParse(reader.ReadElementContentAsString("AvatarID", String.Empty), out agentID);
|
|
UUID.TryParse(reader.ReadElementContentAsString("Body", String.Empty), out id);
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Log.Warn("Failed to parse GetInventory POST data: " + ex.Message);
|
|
agentID = UUID.Zero;
|
|
sessionID = UUID.Zero;
|
|
return UUID.Zero;
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
InventoryFolder DeserializeFolder(Stream stream, out UUID agentID, out UUID sessionID)
|
|
{
|
|
InventoryFolder folder = new InventoryFolder();
|
|
|
|
try
|
|
{
|
|
using (XmlReader reader = XmlReader.Create(stream))
|
|
{
|
|
reader.MoveToContent();
|
|
reader.ReadStartElement("RestSessionObjectOfInventoryFolderBase");
|
|
UUID.TryParse(reader.ReadElementContentAsString("SessionID", String.Empty), out sessionID);
|
|
UUID.TryParse(reader.ReadElementContentAsString("AvatarID", String.Empty), out agentID);
|
|
reader.ReadStartElement("Body");
|
|
if (reader.Name == "Name")
|
|
folder.Name = reader.ReadElementContentAsString("Name", String.Empty);
|
|
else
|
|
folder.Name = String.Empty;
|
|
ReadUUID(reader, "Owner", out folder.Owner);
|
|
ReadUUID(reader, "ParentID", out folder.ParentID);
|
|
ReadUUID(reader, "ID", out folder.ID);
|
|
Int16.TryParse(reader.ReadElementContentAsString("Type", String.Empty), out folder.Type);
|
|
UInt16.TryParse(reader.ReadElementContentAsString("Version", String.Empty), out folder.Version);
|
|
reader.ReadEndElement();
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Log.Warn("Failed to parse POST data (expecting InventoryFolderBase): " + ex.Message);
|
|
agentID = UUID.Zero;
|
|
sessionID = UUID.Zero;
|
|
return null;
|
|
}
|
|
|
|
return folder;
|
|
}
|
|
|
|
InventoryItem DeserializeItem(Stream stream, out UUID agentID, out UUID sessionID)
|
|
{
|
|
InventoryItem item = new InventoryItem();
|
|
|
|
try
|
|
{
|
|
using (XmlReader reader = XmlReader.Create(stream))
|
|
{
|
|
reader.MoveToContent();
|
|
reader.ReadStartElement("RestSessionObjectOfInventoryItemBase");
|
|
UUID.TryParse(reader.ReadElementContentAsString("SessionID", String.Empty), out sessionID);
|
|
UUID.TryParse(reader.ReadElementContentAsString("AvatarID", String.Empty), out agentID);
|
|
reader.ReadStartElement("Body");
|
|
ReadUUID(reader, "ID", out item.ID);
|
|
Int32.TryParse(reader.ReadElementContentAsString("InvType", String.Empty), out item.InvType);
|
|
ReadUUID(reader, "Folder", out item.Folder);
|
|
ReadUUID(reader, "Owner", out item.Owner);
|
|
ReadUUID(reader, "Creator", out item.Creator);
|
|
item.Name = reader.ReadElementContentAsString("Name", String.Empty);
|
|
item.Description = reader.ReadElementContentAsString("Description", String.Empty);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("NextPermissions", String.Empty), out item.NextPermissions);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("CurrentPermissions", String.Empty), out item.CurrentPermissions);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("BasePermissions", String.Empty), out item.BasePermissions);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("EveryOnePermissions", String.Empty), out item.EveryOnePermissions);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("GroupPermissions", String.Empty), out item.GroupPermissions);
|
|
Int32.TryParse(reader.ReadElementContentAsString("AssetType", String.Empty), out item.AssetType);
|
|
ReadUUID(reader, "AssetID", out item.AssetID);
|
|
ReadUUID(reader, "GroupID", out item.GroupID);
|
|
Boolean.TryParse(reader.ReadElementContentAsString("GroupOwned", String.Empty), out item.GroupOwned);
|
|
Int32.TryParse(reader.ReadElementContentAsString("SalePrice", String.Empty), out item.SalePrice);
|
|
Byte.TryParse(reader.ReadElementContentAsString("SaleType", String.Empty), out item.SaleType);
|
|
UInt32.TryParse(reader.ReadElementContentAsString("Flags", String.Empty), out item.Flags);
|
|
Int32.TryParse(reader.ReadElementContentAsString("CreationDate", String.Empty), out item.CreationDate);
|
|
reader.ReadEndElement();
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Log.Warn("Failed to parse POST data (expecting InventoryItemBase): " + ex.Message);
|
|
agentID = UUID.Zero;
|
|
sessionID = UUID.Zero;
|
|
return null;
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
void SerializeBool(Stream stream, bool value)
|
|
{
|
|
using (XmlWriter writer = XmlWriter.Create(stream))
|
|
{
|
|
writer.WriteStartDocument();
|
|
writer.WriteStartElement("boolean");
|
|
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
|
|
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
|
|
writer.WriteString(value.ToString().ToLower());
|
|
writer.WriteEndElement();
|
|
writer.WriteEndDocument();
|
|
writer.Flush();
|
|
}
|
|
|
|
stream.Flush();
|
|
}
|
|
|
|
void SerializeFolderList(Stream stream, List<InventoryFolder> folders)
|
|
{
|
|
using (XmlWriter writer = XmlWriter.Create(stream))
|
|
{
|
|
writer.WriteStartDocument();
|
|
writer.WriteStartElement("ArrayOfInventoryFolderBase");
|
|
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
|
|
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
|
|
|
|
if (folders != null)
|
|
{
|
|
foreach (InventoryFolder folder in folders)
|
|
{
|
|
writer.WriteStartElement("InventoryFolderBase");
|
|
writer.WriteElementString("Name", folder.Name);
|
|
WriteUUID(writer, "Owner", folder.Owner);
|
|
WriteUUID(writer, "ParentID", folder.ParentID);
|
|
WriteUUID(writer, "ID", folder.ID);
|
|
writer.WriteElementString("Type", XmlConvert.ToString(folder.Type));
|
|
writer.WriteElementString("Version", XmlConvert.ToString(folder.Version));
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
writer.WriteEndDocument();
|
|
|
|
writer.Flush();
|
|
}
|
|
|
|
stream.Flush();
|
|
}
|
|
|
|
void SerializeItemList(Stream stream, List<InventoryItem> items)
|
|
{
|
|
using (XmlWriter writer = XmlWriter.Create(stream))
|
|
{
|
|
writer.WriteStartDocument();
|
|
writer.WriteStartElement("ArrayOfInventoryItemBase");
|
|
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
|
|
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
|
|
|
|
if (items != null)
|
|
{
|
|
foreach (InventoryItem item in items)
|
|
{
|
|
writer.WriteStartElement("InventoryItemBase");
|
|
WriteUUID(writer, "ID", item.ID);
|
|
writer.WriteElementString("InvType", XmlConvert.ToString(item.InvType));
|
|
WriteUUID(writer, "Folder", item.Folder);
|
|
WriteUUID(writer, "Owner", item.Owner);
|
|
WriteUUID(writer, "Creator", item.Creator);
|
|
writer.WriteElementString("Name", item.Name);
|
|
writer.WriteElementString("Description", item.Description);
|
|
writer.WriteElementString("NextPermissions", XmlConvert.ToString(item.NextPermissions));
|
|
writer.WriteElementString("CurrentPermissions", XmlConvert.ToString(item.CurrentPermissions));
|
|
writer.WriteElementString("BasePermissions", XmlConvert.ToString(item.BasePermissions));
|
|
writer.WriteElementString("EveryOnePermissions", XmlConvert.ToString(item.EveryOnePermissions));
|
|
writer.WriteElementString("GroupPermissions", XmlConvert.ToString(item.GroupPermissions));
|
|
writer.WriteElementString("AssetType", XmlConvert.ToString(item.AssetType));
|
|
WriteUUID(writer, "AssetID", item.AssetID);
|
|
WriteUUID(writer, "GroupID", item.GroupID);
|
|
writer.WriteElementString("GroupOwned", XmlConvert.ToString(item.GroupOwned));
|
|
writer.WriteElementString("SalePrice", XmlConvert.ToString(item.SalePrice));
|
|
writer.WriteElementString("SaleType", XmlConvert.ToString(item.SaleType));
|
|
writer.WriteElementString("Flags", XmlConvert.ToString(item.Flags));
|
|
writer.WriteElementString("CreationDate", XmlConvert.ToString(item.CreationDate));
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
writer.WriteEndDocument();
|
|
|
|
writer.Flush();
|
|
}
|
|
|
|
stream.Flush();
|
|
}
|
|
|
|
void WriteUUID(XmlWriter writer, string name, UUID id)
|
|
{
|
|
writer.WriteStartElement(name);
|
|
writer.WriteElementString("Guid", XmlConvert.ToString(id.Guid));
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
void ReadUUID(XmlReader reader, string name, out UUID id)
|
|
{
|
|
reader.ReadStartElement(name);
|
|
UUID.TryParse(reader.ReadElementContentAsString("Guid", String.Empty), out id);
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
#region OpenSim AssetType
|
|
|
|
/// <summary>
|
|
/// The different types of grid assets
|
|
/// </summary>
|
|
public enum AssetType : sbyte
|
|
{
|
|
/// <summary>Unknown asset type</summary>
|
|
Unknown = -1,
|
|
/// <summary>Texture asset, stores in JPEG2000 J2C stream format</summary>
|
|
Texture = 0,
|
|
/// <summary>Sound asset</summary>
|
|
Sound = 1,
|
|
/// <summary>Calling card for another avatar</summary>
|
|
CallingCard = 2,
|
|
/// <summary>Link to a location in world</summary>
|
|
Landmark = 3,
|
|
// <summary>Legacy script asset, you should never see one of these</summary>
|
|
//[Obsolete]
|
|
//Script = 4,
|
|
/// <summary>Collection of textures and parameters that can be
|
|
/// worn by an avatar</summary>
|
|
Clothing = 5,
|
|
/// <summary>Primitive that can contain textures, sounds,
|
|
/// scripts and more</summary>
|
|
Object = 6,
|
|
/// <summary>Notecard asset</summary>
|
|
Notecard = 7,
|
|
/// <summary>Holds a collection of inventory items</summary>
|
|
Folder = 8,
|
|
/// <summary>Root inventory folder</summary>
|
|
RootFolder = 9,
|
|
/// <summary>Linden scripting language script</summary>
|
|
LSLText = 10,
|
|
/// <summary>LSO bytecode for a script</summary>
|
|
LSLBytecode = 11,
|
|
/// <summary>Uncompressed TGA texture</summary>
|
|
TextureTGA = 12,
|
|
/// <summary>Collection of textures and shape parameters that can
|
|
/// be worn</summary>
|
|
Bodypart = 13,
|
|
/// <summary>Trash folder</summary>
|
|
TrashFolder = 14,
|
|
/// <summary>Snapshot folder</summary>
|
|
SnapshotFolder = 15,
|
|
/// <summary>Lost and found folder</summary>
|
|
LostAndFoundFolder = 16,
|
|
/// <summary>Uncompressed sound</summary>
|
|
SoundWAV = 17,
|
|
/// <summary>Uncompressed TGA non-square image, not to be used as a
|
|
/// texture</summary>
|
|
ImageTGA = 18,
|
|
/// <summary>Compressed JPEG non-square image, not to be used as a
|
|
/// texture</summary>
|
|
ImageJPEG = 19,
|
|
/// <summary>Animation</summary>
|
|
Animation = 20,
|
|
/// <summary>Sequence of animations, sounds, chat, and pauses</summary>
|
|
Gesture = 21,
|
|
/// <summary>Simstate file</summary>
|
|
Simstate = 22,
|
|
}
|
|
|
|
#endregion OpenSim AssetType
|
|
}
|