bool IInventoryItemServiceInterface.TryGetValue(UUID key, out InventoryItem item)
{
item = default(InventoryItem);
IValue iv;
HttpStatusCode statuscode;
using (Stream s = new HttpClient.Get($"{m_CapabilityUri}item/{key}")
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest(out statuscode))
{
if (statuscode != HttpStatusCode.OK)
{
return(false);
}
iv = LlsdXml.Deserialize(s);
}
var resmap = iv as Map;
if (resmap == null)
{
throw new InvalidDataException("Wrong response received");
}
item = new InventoryItem(resmap["item_id"].AsUUID)
{
InventoryType = (InventoryType)resmap["inv_type"].AsInt,
Description = resmap["desc"].ToString(),
Flags = (InventoryFlags)resmap["flags"].AsUInt,
CreationDate = Date.UnixTimeToDateTime(resmap["created_at"].AsULong),
AssetID = resmap["asset_id"].AsUUID,
AssetType = (AssetType)resmap["type"].AsInt,
Name = resmap["name"].ToString()
};
var saleinfo = resmap["sale_info"] as Map;
item.SaleInfo.Price = saleinfo["sale_price"].AsInt;
item.SaleInfo.Type = (InventoryItem.SaleInfoData.SaleType)saleinfo["sale_type"].AsInt;
var perminfo = resmap["permissions"] as Map;
item.Permissions.Base = (InventoryPermissionsMask)perminfo["base_mask"].AsUInt;
item.Permissions.Group = (InventoryPermissionsMask)perminfo["group_mask"].AsUInt;
item.LastOwner.ID = perminfo["last_owner_id"].AsUUID;
item.Owner.ID = perminfo["owner_id"].AsUUID;
item.Creator.ID = perminfo["creator_id"].AsUUID;
item.ParentFolderID = resmap["parent_id"].AsUUID;
item.Permissions.NextOwner = (InventoryPermissionsMask)perminfo["next_owner_mask"].AsUInt;
item.Permissions.Current = (InventoryPermissionsMask)perminfo["owner_mask"].AsUInt;
item.Group.ID = perminfo["group_id"].AsUUID;
item.Permissions.EveryOne = (InventoryPermissionsMask)perminfo["everyone_mask"].AsUInt;
return(true);
}
public HashtableApi.Hashtable CapsUpdateTaskInventory(ScriptInstance instance, string uri, LSLKey objectid, LSLKey itemid, string contentType, ByteArrayApi.ByteArray assetData)
{
HashtableApi.Hashtable res = new HashtableApi.Hashtable();
lock (instance)
{
Map result;
using (Stream s = new HttpClient.Post(uri,
new HttpClient.LlsdXmlRequest(new Map
{
{ "task_id", objectid.AsUUID },
{ "item_id", itemid.AsUUID },
}))
{
TimeoutMs = 20000
}.ExecuteStreamRequest())
{
result = (Map)LlsdXml.Deserialize(s);
}
res["result"] = result["state"].ToString();
if (result["state"].ToString() == "upload")
{
string uploader_uri = res["uploader"].ToString();
using (Stream s = new HttpClient.Post(
uploader_uri,
contentType,
assetData.Length, (Stream sd) => sd.Write(assetData.Data, 0, assetData.Length))
{
TimeoutMs = 20000
}.ExecuteStreamRequest())
{
result = (Map)LlsdXml.Deserialize(s);
}
res["result"] = result["state"].ToString();
if (result["state"].ToString() == "complete")
{
res["assetid"] = new LSLKey(result["new_asset"].AsUUID);
}
if (result.ContainsKey("compiled"))
{
res["compiled"] = ((bool)result["compiled"].AsBoolean).ToLSLBoolean();
}
if (result.ContainsKey("errors"))
{
res.Add("errors", (AnArray)result["errors"]);
}
}
}
return(res);
}
void IInventoryFolderServiceInterface.Add(InventoryFolder folder)
{
var m = new Map();
var categories = new AnArray();
m.Add("categories", categories);
var category = new Map();
categories.Add(category);
category.Add("name", folder.Name);
category.Add("type_default", (int)folder.DefaultType);
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(m, ms);
reqdata = ms.ToArray();
}
IValue res;
HttpStatusCode statuscode;
using (Stream sres = new HttpClient.Post(
$"{m_CapabilityUri}category/{folder.ParentFolderID}",
"application/llsd+xml",
reqdata.Length,
(Stream s) => s.Write(reqdata, 0, reqdata.Length))
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest(out statuscode))
{
if (statuscode != HttpStatusCode.Created)
{
throw new InventoryFolderNotFoundException(folder.ParentFolderID);
}
res = LlsdXml.Deserialize(sres);
}
var resmap = res as Map;
if (resmap == null)
{
throw new InvalidDataException();
}
var created_items = resmap["_created_categories"] as AnArray;
if (created_items == null)
{
throw new InvalidDataException();
}
folder.ID = created_items[0].AsUUID;
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
if (!reqmap.ContainsKey("verb"))
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Invalid request");
return;
}
switch (reqmap["verb"].ToString())
{
case "GET":
HandleObjectMediaRequest(httpreq, reqmap);
break;
case "UPDATE":
HandleObjectMediaUpdate(httpreq, reqmap);
break;
default:
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Invalid request");
break;
}
}
private void EnableSimCircuit(RegionInfo destinationInfo, out UUID sessionID, out uint circuitCode)
{
var reqmap = new Map
{
["to_region_id"] = destinationInfo.ID,
["from_region_id"] = ID
};
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(reqmap, ms);
reqdata = ms.ToArray();
}
/* try DNS lookup before triggering add circuit code */
IPAddress[] addresses = Dns.GetHostAddresses(destinationInfo.ServerIP);
var ep = new IPEndPoint(addresses[0], (int)destinationInfo.ServerPort);
Map resmap;
using (var responseStream = new HttpClient.Post(
destinationInfo.ServerURI + "circuit",
"application/llsd+xml",
reqdata.Length,
(Stream s) => s.Write(reqdata, 0, reqdata.Length)).ExecuteStreamRequest())
{
resmap = (Map)LlsdXml.Deserialize(responseStream);
}
circuitCode = resmap["circuit_code"].AsUInt;
sessionID = resmap["session_id"].AsUUID;
Neighbors[destinationInfo.ID].RemoteCircuit = UDPServer.UseSimCircuit(
ep,
sessionID,
this,
destinationInfo.ID,
circuitCode,
destinationInfo.Location,
destinationInfo.Location - GridPosition);
CheckAgentsForNeighbors();
}
public HashtableApi.Hashtable SeedRequest(
ScriptInstance instance,
string seedCaps,
AnArray elements)
{
lock (instance)
{
byte[] post;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(elements, ms);
post = ms.ToArray();
}
Map resdata;
try
{
using (Stream res = new HttpClient.Post(seedCaps, "application/llsd+xml", post.Length, (Stream req) => req.Write(post, 0, post.Length)).ExecuteStreamRequest())
{
resdata = LlsdXml.Deserialize(res) as Map;
}
}
catch
{
return(new HashtableApi.Hashtable());
}
if (null == resdata)
{
return(new HashtableApi.Hashtable());
}
var result = new HashtableApi.Hashtable();
foreach (KeyValuePair <string, IValue> kvp in resdata)
{
result.Add(kvp.Key, kvp.Value);
}
return(result);
}
}
public static MeshInventoryItem FromUploadFormat(string name, Stream s, UGUI creator, AssetData objectAsset = null)
{
var map = (Map)LlsdXml.Deserialize(s);
var item = new MeshInventoryItem
{
Name = name,
AssetType = AssetType.Object,
InventoryType = InventoryType.Object,
Owner = creator,
LastOwner = creator,
Creator = creator
};
item.Permissions.Base = InventoryPermissionsMask.Every;
item.Permissions.Current = InventoryPermissionsMask.Every;
ProcessTextures((AnArray)map["texture_list"], item);
ProcessMeshes((AnArray)map["mesh_list"], item);
ProcessInstances((AnArray)map["instance_list"], item, objectAsset);
return(item);
}
private void HandleRegionExperiencesPost(ViewerAgent agent, AgentCircuit circuit, HttpRequest httpreq)
{
Map reqmap;
using (Stream s = httpreq.Body)
{
reqmap = LlsdXml.Deserialize(s) as Map;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad request");
return;
}
/* process map */
/* process experience addition and authorization */
HandleRegionExperiencesGet(agent, circuit, httpreq);
}
UUID IInventoryItemServiceInterface.Copy(UUID principalID, UUID id, UUID newFolder)
{
var headers = new Dictionary <string, string>
{
["Destination"] = $"{m_CapabilityUri}category/{newFolder}"
};
Map res;
HttpStatusCode statuscode;
using (Stream s = new HttpClient.Copy($"{m_CapabilityUri}item/{id}")
{
TimeoutMs = TimeoutMs,
Headers = headers,
DisableExceptions = HttpClient.Request.DisableExceptionFlags.DisableForbidden | HttpClient.Request.DisableExceptionFlags.DisableGone
}.ExecuteStreamRequest(out statuscode))
{
switch (statuscode)
{
case HttpStatusCode.OK:
break;
case HttpStatusCode.Forbidden:
throw new InventoryItemNotCopiableException(id);
case HttpStatusCode.Gone:
throw new InventoryItemNotFoundException(id);
default:
throw new InvalidParentFolderIdException();
}
res = (Map)LlsdXml.Deserialize(s);
}
AnArray created_items;
if (!res.TryGetValue("_created_items", out created_items) || created_items.Count != 1)
{
throw new InventoryItemNotStoredException();
}
return(created_items[0].AsUUID);
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
IValue iv;
if (reqmap.TryGetValue("message", out iv) && iv.ToString() == "ViewerAppearanceChangeMetrics" &&
reqmap.TryGetValue("rez_status", out iv))
{
OwnRezStatus = iv.ToString();
}
HaveValidData = true;
httpreq.EmptyResponse();
}
public static EnvironmentSettings Deserialize(Stream input)
{
var env = new EnvironmentSettings();
var a = LlsdXml.Deserialize(input) as AnArray;
if (a == null)
{
throw new EnvironmentSettingsSerializationException();
}
var dayCycleArray = a[1] as AnArray;
var skyArray = a[2] as Map;
var waterSettings = a[3] as Map;
if (dayCycleArray != null && skyArray != null)
{
for (int i = 0; i < dayCycleArray.Count - 1; i += 2)
{
env.DayCycle.Add(new KeyValuePair <double, string>(dayCycleArray[i + 0].AsReal, dayCycleArray[i + 1].ToString()));
}
foreach (KeyValuePair <string, IValue> kvp in skyArray)
{
if (kvp.Value is Map)
{
env.SkySettings.Add(kvp.Key, new SkyEntry((Map)kvp.Value));
}
}
}
if (waterSettings != null)
{
env.WaterSettings = new WaterEntry(waterSettings);
}
return(env);
}
private void Cap_LSLSyntax(HttpRequest httpreq)
{
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
using (var res = httpreq.BeginResponse("application/llsd+xml"))
{
var compiler = CompilerRegistry.ScriptCompilers["lsl"];
var mi = compiler.GetType().GetMethod("WriteLSLSyntaxFile", new Type[] { typeof(Stream) });
using (var o = res.GetOutputStream())
{
mi.Invoke(compiler, new object[] { o });
}
}
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
var parts = httpreq.RawUrl.Substring(1).Split('/');
if (parts.Length == 3)
{
if (httpreq.ContentType != "application/llsd+xml")
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
IValue iv = LlsdXml.Deserialize(httpreq.Body);
reqmap = iv as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
UUID parcelID;
if (reqmap == null || !reqmap.TryGetValue("parcel_id", out parcelID))
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var parcelPos = new ParcelID(parcelID.GetBytes(), 0);
ParcelInfo pinfo;
if (!m_Scene.Parcels.TryGetValue(parcelPos.Location, out pinfo))
{
httpreq.ErrorResponse(HttpStatusCode.Gone, "Gone");
return;
}
var resdata = new Map
{
{ "ScriptResourceDetails", m_ServerURI + httpreq.RawUrl + "/Details/" + pinfo.ID.ToString() },
{ "ScriptResourceSummary", m_ServerURI + httpreq.RawUrl + "/Summary/" + pinfo.ID.ToString() }
};
using (HttpResponse res = httpreq.BeginResponse("application/llsd+xml"))
using (Stream s = res.GetOutputStream())
{
LlsdXml.Serialize(resdata, s);
}
}
else if (parts.Length == 5)
{
UUID parcelID;
if (!UUID.TryParse(parts[4], out parcelID))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not found");
return;
}
if (httpreq.Method != "GET")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
switch (parts[3])
{
case "Details":
HandleDetailsReport(httpreq, parcelID);
break;
case "Summary":
HandleSummaryReport(httpreq, parcelID);
break;
default:
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not found");
break;
}
}
else
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not found");
}
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
if (reqmap["agent-id"].AsUUID != m_Agent.ID)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var localID = reqmap["local-id"].AsInt; /* this is parcel local id */
var url = reqmap["url"].ToString();
ParcelInfo parcelInfo;
if (m_Scene.Parcels.TryGetValue(localID, out parcelInfo))
{
if (!m_Scene.CanEditParcelDetails(m_Agent, parcelInfo))
{
return;
}
parcelInfo.MediaURI = new URI(url);
var pmu = new ParcelMediaUpdate
{
MediaAutoScale = parcelInfo.MediaAutoScale,
MediaDesc = parcelInfo.MediaDescription,
MediaHeight = parcelInfo.MediaHeight,
MediaID = parcelInfo.MediaID,
MediaLoop = parcelInfo.MediaLoop,
MediaType = parcelInfo.MediaType,
MediaURL = url,
MediaWidth = parcelInfo.MediaWidth
};
parcelInfo.MediaAutoScale = pmu.MediaAutoScale;
parcelInfo.MediaDescription = pmu.MediaDesc;
parcelInfo.MediaHeight = pmu.MediaHeight;
parcelInfo.MediaID = pmu.MediaID;
parcelInfo.MediaType = pmu.MediaType;
parcelInfo.MediaLoop = pmu.MediaLoop;
parcelInfo.MediaURI = new URI(pmu.MediaURL);
parcelInfo.MediaWidth = pmu.MediaWidth;
m_Scene.Parcels.Store(parcelInfo.ID);
foreach (var rootAgent in m_Scene.RootAgents)
{
rootAgent.SendMessageIfRootAgent(pmu, m_Scene.ID);
}
}
var m = new Map();
using (var resp = httpreq.BeginResponse(HttpStatusCode.OK, "OK"))
{
resp.ContentType = "application/llsd+xml";
using (var s = resp.GetOutputStream())
{
LlsdXml.Serialize(m, s);
}
}
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var notecardID = reqmap["notecard-id"].AsUUID;
var objectID = reqmap["object-id"].AsUUID;
var itemID = reqmap["item-id"].AsUUID;
var destinationFolderID = reqmap["folder-id"].AsUUID;
var callbackID = reqmap["callback-id"].AsUInt;
Notecard nc = null;
InventoryFolder destinationFolder = null;
AssetData data;
AssetServiceInterface sourceAssetService = null;
InventoryItem notecarditem;
if (objectID != UUID.Zero)
{
ObjectPart part;
sourceAssetService = m_Scene.AssetService;
if (!m_Scene.Primitives.TryGetValue(objectID, out part))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound);
return;
}
ObjectPartInventoryItem objitem;
if (part.Inventory.TryGetValue(notecardID, out objitem) &&
objitem.InventoryType == InventoryType.Notecard &&
m_Scene.AssetService.TryGetValue(objitem.AssetID, out data))
{
nc = new Notecard(data);
}
notecarditem = objitem;
}
else
{
sourceAssetService = m_Agent.AssetService;
if (m_Agent.InventoryService.Item.TryGetValue(m_Agent.ID, notecardID, out notecarditem) &&
notecarditem.InventoryType == InventoryType.Notecard &&
m_Agent.AssetService.TryGetValue(notecarditem.AssetID, out data))
{
nc = new Notecard(data);
}
}
var transferItems = new List <UUID>();
var destFolder = new Dictionary <AssetType, InventoryFolder>();
InventoryFolder selectedDestFolder = null;
if (nc != null)
{
var invlist = new List <NotecardInventoryItem>();
if (itemID != UUID.Zero)
{
NotecardInventoryItem ncitem;
if (!nc.Inventory.TryGetValue(itemID, out ncitem))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound);
return;
}
else
{
invlist.Add(ncitem);
}
}
else
{
invlist.AddRange(nc.Inventory.Values);
}
foreach (var ncitem in invlist)
{
ncitem.LastOwner = notecarditem.LastOwner;
ncitem.Owner = m_Agent.Owner;
if ((notecarditem.Flags & InventoryFlags.NotecardSlamPerm) != 0)
{
ncitem.AdjustToNextOwner();
}
if ((notecarditem.Flags & InventoryFlags.NotecardSlamSale) != 0)
{
if (notecarditem.AssetType == AssetType.Object)
{
ncitem.Flags |= InventoryFlags.ObjectSlamSale;
}
if (notecarditem.AssetType == AssetType.Notecard)
{
ncitem.Flags |= InventoryFlags.NotecardSlamSale;
}
ncitem.SaleInfo.Type = InventoryItem.SaleInfoData.SaleType.NoSale;
}
try
{
if (destinationFolderID == UUID.Zero)
{
if (!destFolder.ContainsKey(ncitem.AssetType))
{
if (!m_Agent.InventoryService.Folder.TryGetDefaultFolderOrFallback(m_Agent.ID, ncitem.AssetType, out destinationFolder))
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): No Folder found for {3}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, ncitem.AssetType.ToString());
continue;
}
else
{
destFolder.Add(ncitem.AssetType, destinationFolder);
}
}
ncitem.ParentFolderID = destinationFolder.ID;
}
else if (selectedDestFolder != null ||
m_Agent.InventoryService.Folder.TryGetSpecificOrDefaultFolderOrFallback(m_Agent.ID, destinationFolderID, ncitem.AssetType, out selectedDestFolder))
{
ncitem.ParentFolderID = selectedDestFolder.ID;
}
else
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): No Folder found for {3}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, ncitem.AssetType.ToString());
continue;
}
var assetID = CreateInventoryItemFromNotecard(destinationFolder, ncitem, callbackID);
if (!transferItems.Contains(assetID))
{
transferItems.Add(assetID);
}
}
catch (Exception e)
{
m_Log.WarnFormat("Failed to copy notecard inventory {0} to agent {1} ({2}): {3}: {4}\n{5}", ncitem.Name, m_Agent.NamedOwner.FullName, m_Agent.ID, e.GetType().FullName, e.Message, e.StackTrace);
}
}
if (objectID != UUID.Zero)
{
/* no need to wait for its completion since for the sim processing it the assets are either available through sim assets or user assets
* only transfer assets if it is from prim inventory notecard to user inventory.
*/
new NotecardAssetTransfer(m_Agent.AssetService, sourceAssetService, transferItems).QueueWorkItem();
}
}
using (HttpResponse httpres = httpreq.BeginResponse())
{
httpres.ContentType = "application/llsd+xml";
using (Stream outStream = httpres.GetOutputStream())
{
LlsdXml.Serialize(new Map(), outStream);
}
}
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
IValue iv;
Map agent;
if (reqmap.TryGetValue("agent", out agent))
{
if (agent.TryGetValue("fps", out iv))
{
ViewerFps = iv.AsReal;
}
if (agent.TryGetValue("version", out iv))
{
ViewerVersion = iv.ToString();
}
if (agent.TryGetValue("agents_in_view", out iv))
{
NumAgentsInView = iv.AsInt;
}
}
Map system;
if (reqmap.TryGetValue("system", out system))
{
if (system.TryGetValue("ram", out iv))
{
ViewerPhysicalMemoryKb = iv.AsInt;
}
if (system.TryGetValue("os", out iv))
{
ViewerOs = iv.ToString();
}
if (system.TryGetValue("cpu", out iv))
{
ViewerCpu = iv.ToString();
}
if (system.TryGetValue("mac_address", out iv))
{
ViewerMacAddress = iv.ToString();
}
if (system.TryGetValue("gpu", out iv))
{
ViewerGpu = iv.ToString();
}
if (system.TryGetValue("gpu_class", out iv))
{
ViewerGpuClass = iv.ToString();
}
if (system.TryGetValue("gpu_vendor", out iv))
{
ViewerGpuVendor = iv.ToString();
}
if (system.TryGetValue("gpu_version", out iv))
{
ViewerGpuVersion = iv.ToString();
}
if (system.TryGetValue("opengl_verion", out iv))
{
OpenGlVersion = iv.ToString();
}
if (system.TryGetValue("shader_level", out iv))
{
ShaderLevel = iv.AsInt;
}
}
Map downloads;
if (reqmap.TryGetValue("downloads", out downloads))
{
if (downloads.TryGetValue("world_kbytes", out iv))
{
DownloadWorldKbytes = iv.AsReal;
}
if (downloads.TryGetValue("object_kbytes", out iv))
{
DownloadObjectKbytes = iv.AsReal;
}
if (downloads.TryGetValue("texture_kbytes", out iv))
{
DownloadTextureKbytes = iv.AsReal;
}
if (downloads.TryGetValue("mesh_kbytes", out iv))
{
DownloadMeshKbytes = iv.AsReal;
}
}
Map stats;
if (reqmap.TryGetValue("stats", out stats))
{
Map map;
if (stats.TryGetValue("in", out map))
{
if (map.TryGetValue("kbytes", out iv))
{
TotalKBytesIn = iv.AsReal;
}
if (map.TryGetValue("packets", out iv))
{
TotalPacketsIn = iv.AsInt;
}
if (map.TryGetValue("compressed_packets", out iv))
{
TotalCompressedPacketsIn = iv.AsInt;
}
if (map.TryGetValue("savings", out iv))
{
TotalSavingsKBytesIn = iv.AsReal;
}
}
if (stats.TryGetValue("out", out map))
{
if (map.TryGetValue("kbytes", out iv))
{
TotalKBytesOut = iv.AsReal;
}
if (map.TryGetValue("packets", out iv))
{
TotalPacketsOut = iv.AsInt;
}
if (map.TryGetValue("compressed_packets", out iv))
{
TotalCompressedPacketsOut = iv.AsInt;
}
if (map.TryGetValue("savings", out iv))
{
TotalSavingsKBytesOut = iv.AsReal;
}
}
if (stats.TryGetValue("failures", out map))
{
if (map.TryGetValue("send_packet", out iv))
{
Fail_SendPacket = iv.AsInt;
}
if (map.TryGetValue("dropped", out iv))
{
Fail_Dropped = iv.AsInt;
}
if (map.TryGetValue("resent", out iv))
{
Fail_Resent = iv.AsInt;
}
if (map.TryGetValue("failed_resends", out iv))
{
Fail_FailedResends = iv.AsInt;
}
if (map.TryGetValue("off_circuit", out iv))
{
Fail_OffCircuit = iv.AsInt;
}
if (map.TryGetValue("invalid", out iv))
{
Fail_Invalid = iv.AsInt;
}
}
}
HaveValidData = true;
httpreq.EmptyResponse();
}
private void HandleGroupNotice(ViewerAgent agent, SceneInterface scene, ImprovedInstantMessage m)
{
/* no validation needed with IM, that is already done in circuit */
var groupsService = scene.GroupsService;
if (groupsService == null)
{
return;
}
UGI group;
try
{
group = groupsService.Groups[agent.Owner, m.ToAgentID];
}
catch
{
return;
}
if ((GetGroupPowers(agent.Owner, groupsService, group) & GroupPowers.SendNotices) == 0)
{
return;
}
InventoryItem item = null;
if (m.BinaryBucket.Length >= 1 && m.BinaryBucket[0] > 0)
{
try
{
var iv = LlsdXml.Deserialize(new MemoryStream(m.BinaryBucket));
if (iv is Map)
{
var binBuck = (Map)iv;
var itemID = binBuck["item_id"].AsUUID;
var ownerID = binBuck["owner_id"].AsUUID;
item = agent.InventoryService.Item[ownerID, itemID];
}
}
catch
{
/* do not expose exceptions to caller */
}
}
var gn = new GroupNotice
{
ID = UUID.Random,
Group = group,
FromName = agent.NamedOwner.FullName
};
var submsg = m.Message.Split(new char[] { '|' }, 2);
gn.Subject = submsg.Length > 1 ? submsg[0] : string.Empty;
gn.Message = submsg.Length > 1 ? submsg[1] : submsg[0];
gn.HasAttachment = item != null;
gn.AttachmentType = item != null ? item.AssetType : Types.Asset.AssetType.Unknown;
gn.AttachmentName = item != null ? item.Name : string.Empty;
gn.AttachmentItemID = item != null ? item.ID : UUID.Zero;
gn.AttachmentOwner = item != null ? item.Owner : UGUI.Unknown;
var gim = new GridInstantMessage
{
FromAgent = agent.NamedOwner,
Dialog = GridInstantMessageDialog.GroupNotice,
IsFromGroup = true,
Message = m.Message,
IMSessionID = gn.ID,
BinaryBucket = m.BinaryBucket
};
try
{
groupsService.Notices.Add(agent.Owner, gn);
IMGroupNoticeQueue.Enqueue(new KeyValuePair <SceneInterface, GridInstantMessage>(scene, gim));
}
catch
{
/* do not expose exceptions to caller */
}
}
private Dictionary <UUID, KeyValuePair <InventoryFolder, InventoryFolderContent> > GetFolderContents(UUID[] folderids, bool fetch_children)
{
var folderidsreq = new AnArray();
var reqmap = new Map
{
["folder_ids"] = folderidsreq
};
foreach (UUID folderid in folderids)
{
folderidsreq.Add(new Map {
{ "folder_id", folderid }, { "fetch_folders", fetch_children }, { "fetch_items", fetch_children }
});
}
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(reqmap, ms);
reqdata = ms.ToArray();
}
Map resdata;
using (Stream s = new HttpClient.Post(m_CapabilityUri, "application/llsd+xml", reqdata.Length,
(Stream o) => o.Write(reqdata, 0, reqdata.Length))
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest())
{
resdata = LlsdXml.Deserialize(s) as Map;
}
if (resdata == null)
{
throw new InvalidDataException();
}
AnArray foldersres;
var resultset = new Dictionary <UUID, KeyValuePair <InventoryFolder, InventoryFolderContent> >();
if (!resdata.TryGetValue("folders", out foldersres))
{
return(resultset);
}
foreach (IValue folderiv in foldersres)
{
var folderdata = folderiv as Map;
if (folderdata == null)
{
continue;
}
var folder = new InventoryFolder(folderdata["folder_id"].AsUUID)
{
Owner = new UGUI(folderdata["owner_id"].AsUUID),
Version = folderdata["version"].AsInt,
ParentFolderID = folderdata["parent_id"].AsUUID,
};
var content = new InventoryFolderContent
{
Version = folderdata["version"].AsInt,
FolderID = folderdata["folder_id"].AsUUID,
Owner = new UGUI(folderdata["owner_id"].AsUUID)
};
AnArray categories;
if (folderdata.TryGetValue("categories", out categories))
{
foreach (IValue categoryiv in categories)
{
var category = categoryiv as Map;
if (category == null)
{
continue;
}
content.Folders.Add(new InventoryFolder(category["folder_id"].AsUUID)
{
Name = category["name"].ToString(),
ParentFolderID = category["parent_id"].AsUUID,
DefaultType = (AssetType)category["type"].AsInt,
Version = category["version"].AsInt
});
}
}
AnArray childitems;
if (folderdata.TryGetValue("items", out childitems))
{
foreach (IValue childiv in childitems)
{
var childdata = childiv as Map;
if (childdata == null)
{
continue;
}
if (childdata["parent_id"].AsUUID != folder.ID)
{
continue;
}
var permissions = (Map)childdata["permissions"];
var sale_info = (Map)childdata["sale_info"];
var item = new InventoryItem(childdata["item_id"].AsUUID)
{
AssetID = childdata["asset_id"].AsUUID,
CreationDate = Date.UnixTimeToDateTime(childdata["created_at"].AsULong),
Description = childdata["desc"].ToString(),
Flags = (InventoryFlags)childdata["flags"].AsInt,
InventoryType = (InventoryType)childdata["inv_type"].AsInt,
Name = childdata["name"].ToString(),
ParentFolderID = childdata["parent_id"].AsUUID,
AssetType = (AssetType)childdata["type"].AsInt,
Creator = new UGUI(permissions["creator_id"].AsUUID),
Group = new UGI(permissions["group_id"].AsUUID),
IsGroupOwned = permissions["is_owner_group"].AsBoolean,
LastOwner = new UGUI(permissions["last_owner_id"].AsUUID),
Owner = new UGUI(permissions["owner_id"].AsUUID),
SaleInfo = new InventoryItem.SaleInfoData
{
Price = sale_info["sale_price"].AsInt,
Type = (InventoryItem.SaleInfoData.SaleType)sale_info["sale_type"].AsInt
}
};
item.Permissions.Base = (InventoryPermissionsMask)permissions["base_mask"].AsInt;
item.Permissions.EveryOne = (InventoryPermissionsMask)permissions["everyone_mask"].AsInt;
item.Permissions.Group = (InventoryPermissionsMask)permissions["group_mask"].AsInt;
item.Permissions.NextOwner = (InventoryPermissionsMask)permissions["next_owner_mask"].AsInt;
item.Permissions.Current = (InventoryPermissionsMask)permissions["owner_mask"].AsInt;
content.Items.Add(item);
}
}
resultset.Add(folder.ID, new KeyValuePair <InventoryFolder, InventoryFolderContent>(folder, content));
}
return(resultset);
}
private void Cap_RenderMaterials_POST(HttpRequest httpreq)
{
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var materials = new List <Material>();
if (reqmap.ContainsKey("Zipped"))
{
AnArray zippedDataArray;
Map zippedDataMap;
try
{
using (var ms = new MemoryStream((BinaryData)reqmap["Zipped"]))
{
using (var gz = new ZlibStream(ms, CompressionMode.Decompress))
{
var inp = LlsdBinary.Deserialize(gz);
zippedDataArray = inp as AnArray;
zippedDataMap = inp as Map;
}
}
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (zippedDataArray == null && zippedDataMap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted Zipped LLSD-XML");
return;
}
if (zippedDataArray != null)
{
foreach (var v in zippedDataArray)
{
try
{
materials.Add(Scene.GetMaterial(v.AsUUID));
}
catch
{
/* adding faled due to duplicate */
}
}
}
else if (zippedDataMap?.ContainsKey("FullMaterialsPerFace") ?? false)
{
var faceData = zippedDataMap["FullMaterialsPerFace"] as AnArray;
if (faceData != null)
{
foreach (var face_iv in faceData)
{
var faceDataMap = face_iv as Map;
if (faceDataMap == null)
{
continue;
}
try
{
uint primLocalID = faceDataMap["ID"].AsUInt;
var matID = UUID.Random;
Material mat;
try
{
matID = UUID.Random;
mat = new Material(matID, faceDataMap["Material"] as Map);
}
catch
{
matID = UUID.Zero;
mat = null;
}
if (mat != null)
{
Scene.StoreMaterial(mat);
continue;
}
var p = Scene.Primitives[primLocalID];
if (faceDataMap.ContainsKey("Face"))
{
var face = faceDataMap["Face"].AsUInt;
var te = p.TextureEntry[face];
te.MaterialID = matID;
}
else
{
var te = p.TextureEntry.DefaultTexture;
te.MaterialID = matID;
p.TextureEntry.DefaultTexture = te;
}
}
catch
{
/* no action possible */
}
}
}
}
}
using (var httpres = httpreq.BeginResponse("application/llsd+xml"))
{
#if DEBUG
m_Log.DebugFormat("Responding RenderMaterials block scene={0}", Scene.ID);
#endif
var matdata = Scene.MaterialsData;
using (Stream s = httpres.GetOutputStream())
{
#if DEBUG
m_Log.DebugFormat("Sending out RenderMaterials block scene={0} length={1}", Scene.ID, matdata.Length);
#endif
s.Write(matdata, 0, matdata.Length);
}
}
}
private void Cap_EventQueueGet(HttpRequest httpreq)
{
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
try
{
LlsdXml.Deserialize(httpreq.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
var timeout = 31;
Message m = null;
while (timeout-- != 0)
{
if (!m_EventQueueEnabled)
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
return;
}
try
{
m = m_EventQueue.Dequeue(1000);
break;
}
catch
{
/* no action required */
}
}
if (m == null)
{
using (var res = httpreq.BeginResponse(HttpStatusCode.BadGateway, "Upstream error:"))
{
res.MinorVersion = 0;
using (var w = res.GetOutputStream().UTF8StreamWriter())
{
w.Write("Upstream error: ");
w.Flush();
}
}
return;
}
var eventarr = new AnArray();
int count = m_EventQueue.Count - 1;
do
{
IValue body;
string message;
try
{
message = m.NameEQG;
body = m.SerializeEQG();
}
catch (Exception e)
{
m_Log.DebugFormat("Unsupported message {0} in EventQueueGet: {1}\n{2}", m.GetType().FullName, e.Message, e.StackTrace);
using (var res = httpreq.BeginResponse(HttpStatusCode.BadGateway, "Upstream error:"))
{
res.MinorVersion = 0;
using (var w = res.GetOutputStream().UTF8StreamWriter())
{
w.Write("Upstream error: ");
w.Flush();
}
}
return;
}
var ev = new Map
{
{ "message", message },
{ "body", body }
};
eventarr.Add(ev);
if (count > 0)
{
--count;
m = m_EventQueue.Dequeue(0);
}
else
{
m = null;
}
} while (m != null);
var result = new Map
{
{ "events", eventarr },
{ "id", m_EventQueueEventId++ }
};
using (var res = httpreq.BeginResponse(HttpStatusCode.OK, "OK"))
{
res.ContentType = "application/llsd+xml";
using (var o = res.GetOutputStream())
{
LlsdXml.Serialize(result, o);
}
}
}
public void RegionSeedHandler(HttpRequest httpreq)
{
IValue o;
if (httpreq.CallerIP != RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
try
{
o = LlsdXml.Deserialize(httpreq.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var oarray = o as AnArray;
if (oarray == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
var capsUri = new Dictionary <string, string>();
foreach (IValue v in oarray)
{
UUID capsID;
string capsUriStr = string.Empty;
if (v.ToString() == "SEED")
{
/* SEED capability has no additional handling */
}
else if (v.ToString() == "ObjectAnimation")
{
/* triggers enable of objectanimation */
m_EnableObjectAnimation = true;
if (m_EnableObjectAnimation && m_EnableObjectUpdates)
{
foreach (ObjectPart p in Scene.Primitives)
{
if ((p.ExtendedMesh.Flags & ExtendedMeshParams.MeshFlags.AnimatedMeshEnabled) != 0)
{
#if DEBUG
m_Log.DebugFormat("Sending object animations for {0}", p.ID);
#endif
p.AnimationController.SendAnimationsToAgent(Agent);
}
}
}
}
else if (GetCustomCapsUri(v.ToString(), out capsUriStr))
{
if (capsUriStr.Length != 0)
{
capsUri[v.ToString()] = capsUriStr;
}
}
else if (m_RegisteredCapabilities.TryGetValue(v.ToString(), out capsID))
{
capsUri[v.ToString()] = string.Format("{0}://{1}:{2}/CAPS/{3}/{4}",
m_CapsRedirector.Scheme, m_CapsRedirector.ExternalHostName, m_CapsRedirector.Port,
v.ToString(), capsID);
}
}
using (var res = httpreq.BeginResponse())
{
res.ContentType = "application/llsd+xml";
using (var tw = res.GetOutputStream())
{
using (var text = tw.UTF8XmlTextWriter())
{
text.WriteStartElement("llsd");
text.WriteStartElement("map");
foreach (KeyValuePair <string, string> kvp in capsUri)
{
text.WriteKeyValuePair(kvp.Key, kvp.Value);
}
text.WriteEndElement();
text.WriteEndElement();
text.Flush();
}
}
}
}
public void HandleRemoteParcelRequest(ViewerAgent agent, AgentCircuit circuit, HttpRequest req)
{
if (req.CallerIP != circuit.RemoteIP)
{
req.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (req.Method != "POST")
{
req.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(req.Body) as Map;
}
catch
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad request");
return;
}
if (reqmap == null)
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad request");
return;
}
SceneInterface scene = circuit.Scene;
if (scene == null)
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad request");
return;
}
AnArray locationArray;
IValue iv_target;
var parcelid = new ParcelID();
if (reqmap.TryGetValue("location", out locationArray))
{
uint x = locationArray[0].AsUInt;
uint y = locationArray[1].AsUInt;
if (reqmap.TryGetValue("region_handle", out iv_target))
{
byte[] regHandleBytes = (BinaryData)iv_target;
var v = new GridVector(regHandleBytes, 0);
RegionInfo rInfo;
if (v == scene.GridPosition)
{
parcelid = new ParcelID(v, new Vector3(x, y, 0));
}
else if (scene.GridService.TryGetValue(v, out rInfo))
{
/* shift coordinate to actual region begin */
Vector3 offset = (Vector3)v - rInfo.Location;
offset.X += x;
offset.Y += y;
/* ensure that the position is inside region */
if (offset.X > rInfo.Size.X)
{
offset.X = rInfo.Size.X;
}
if (offset.Y > rInfo.Size.Y)
{
offset.Y = rInfo.Size.Y;
}
parcelid = new ParcelID(rInfo.Location, offset);
}
}
else if (reqmap.TryGetValue("region_id", out iv_target))
{
SceneInterface remoteSceneLocal;
RegionInfo rInfo;
if (m_Scenes.TryGetValue(iv_target.AsUUID, out remoteSceneLocal))
{
parcelid = new ParcelID(remoteSceneLocal.GridPosition, new Vector3(x, y, 0));
}
else if (scene.GridService.TryGetValue(iv_target.AsUUID, out rInfo))
{
parcelid = new ParcelID(rInfo.Location, new Vector3(x, y, 0));
}
}
}
var resmap = new Map
{
["parcel_id"] = new UUID(parcelid.GetBytes(), 0)
};
using (HttpResponse res = req.BeginResponse("application/llsd+xml"))
{
using (Stream s = res.GetOutputStream())
{
LlsdXml.Serialize(resmap, s);
}
}
}
protected static void HandleHttpRequest(HttpRequest httpreq, InventoryServiceInterface inventoryService, UUID agentID, UUID ownerID)
{
IValue o;
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
try
{
o = LlsdXml.Deserialize(httpreq.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD_XML: {0} {1}", e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
var reqmap = o as Map;
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
using (var res = httpreq.BeginResponse("application/llsd+xml"))
using (var text = res.GetOutputStream().UTF8XmlTextWriter())
{
var baditems = new List <UUID>();
text.WriteStartElement("llsd");
text.WriteStartElement("map");
text.WriteKeyValuePair("agent_id", agentID);
bool wroteheader = false;
foreach (var iv in (AnArray)reqmap["items"])
{
var itemmap = iv as Map;
if (itemmap == null)
{
continue;
}
if (!itemmap.ContainsKey("item_id"))
{
continue;
}
var itemid = itemmap["item_id"].AsUUID;
InventoryItem item;
if (itemid == UUID.Zero)
{
baditems.Add(itemid);
continue;
}
try
{
item = inventoryService.Item[ownerID, itemid];
}
catch
{
baditems.Add(itemid);
continue;
}
if (!wroteheader)
{
wroteheader = true;
text.WriteNamedValue("key", "items");
text.WriteStartElement("array");
}
text.WriteStartElement("map");
WriteInventoryItem(item, text, agentID);
text.WriteEndElement();
}
if (wroteheader)
{
text.WriteEndElement();
}
if (baditems.Count != 0)
{
text.WriteStartElement("key");
text.WriteValue("bad_items");
text.WriteEndElement();
text.WriteStartElement("array");
foreach (var id in baditems)
{
text.WriteNamedValue("uuid", id);
}
text.WriteEndElement();
}
text.WriteEndElement();
text.WriteEndElement();
}
}
public void HandleGetMetadataCapability(ViewerAgent agent, AgentCircuit circuit, HttpRequest req)
{
if (req.CallerIP != circuit.RemoteIP)
{
req.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (req.Method != "POST")
{
req.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
var scene = circuit.Scene;
if (scene == null)
{
req.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
return;
}
IValue iv;
UUID objectid;
UUID itemid;
try
{
iv = LlsdXml.Deserialize(req.Body);
}
catch (Exception e)
{
m_Log.WarnFormat("Invalid LLSD-XML received at GetMetadata", e);
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
if (!(iv is Map))
{
m_Log.WarnFormat("Invalid LLSD-XML received at GetMetadata");
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
Map m = iv as Map;
objectid = m["object-id"].AsUUID;
itemid = m["item-id"].AsUUID;
Map res = new Map();
ObjectPart part;
ObjectPartInventoryItem item;
if (scene.Primitives.TryGetValue(objectid, out part) &&
part.Inventory.TryGetValue(itemid, out item))
{
UEI id = item.ExperienceID;
if (id != UEI.Unknown)
{
res.Add("experience", item.ExperienceID.ID);
}
}
using (var httpres = req.BeginResponse("application/llsd+xml"))
{
LlsdXml.Serialize(res, httpres.GetOutputStream());
}
}
public static void HandleSimCircuitRequest(HttpRequest req, ConfigurationLoader loader)
{
if (req.ContainsHeader("X-SecondLife-Shard"))
{
req.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Request source not allowed");
return;
}
if (req.Method != "POST")
{
req.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(req.Body) as Map;
}
catch
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
if (reqmap == null)
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
var regionID = reqmap["to_region_id"].AsUUID;
var fromRegionID = reqmap["from_region_id"].AsUUID;
SceneInterface scene;
try
{
scene = loader.Scenes[regionID];
}
catch
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
var gridService = scene.GridService;
if (gridService == null)
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
RegionInfo regionInfo;
try
{
regionInfo = gridService[fromRegionID];
}
catch
{
req.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
var sessionID = UUID.Random;
uint circuitCode = NewCircuitCode;
Vector3 remoteOffset = regionInfo.Location - scene.GridPosition;
var udpServer = (UDPCircuitsManager)scene.UDPServer;
var circuit = new SimCircuit(udpServer, circuitCode, fromRegionID, sessionID, regionInfo.Location, remoteOffset);
udpServer.AddCircuit(circuit);
var resmap = new Map
{
{ "circuit_code", circuitCode },
{ "session_id", sessionID }
};
using (var res = req.BeginResponse("application/llsd+xml"))
{
using (var o = res.GetOutputStream())
{
LlsdXml.Serialize(resmap, o);
}
}
}
public void HandleUpdateExperienceCapability(ViewerAgent agent, AgentCircuit circuit, HttpRequest httpreq)
{
if (httpreq.CallerIP != circuit.RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
using (Stream s = httpreq.Body)
{
reqmap = LlsdXml.Deserialize(s) as Map;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad request");
return;
}
SceneInterface scene = circuit.Scene;
if (scene == null)
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
return;
}
ExperienceServiceInterface experienceService = scene.ExperienceService;
if (experienceService == null)
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
return;
}
UUID experienceid = reqmap["public_id"].AsUUID;
ExperienceInfo info;
Map resmap = new Map();
if (experienceService.TryGetValue(experienceid, out info))
{
IValue iv;
if (reqmap.TryGetValue("group_id", out iv))
{
UUID id = iv.AsUUID;
UGI ugi;
if (id == UUID.Zero)
{
info.Group = UGI.Unknown;
}
else if (scene.GroupsNameService != null && scene.GroupsNameService.TryGetValue(id, out ugi))
{
info.Group = ugi;
}
}
if (reqmap.TryGetValue("name", out iv))
{
info.ID.ExperienceName = iv.ToString();
}
if (reqmap.TryGetValue("description", out iv))
{
info.Description = iv.ToString();
}
if (reqmap.TryGetValue("properties", out iv))
{
info.Properties = (ExperiencePropertyFlags)iv.AsInt;
}
if (reqmap.TryGetValue("maturity", out iv))
{
info.Maturity = (RegionAccess)iv.AsInt;
}
if (reqmap.TryGetValue("extended_metadata", out iv))
{
info.ExtendedMetadata = iv.ToString();
}
if (reqmap.TryGetValue("slurl", out iv))
{
info.SlUrl = iv.ToString();
}
try
{
experienceService.Update(agent.Owner, info);
}
catch (Exception e)
{
#if DEBUG
m_Log.Debug("UpdateExperience capability", e);
#endif
resmap.Add("removed", new AnArray
{
new Map
{
{ "error-tag", "Failed to update" }
}
});
}
if (!resmap.ContainsKey("removed"))
{
var ids = new AnArray();
ids.Add(info.ToMap());
resmap.Add("experience_keys", ids);
}
}
else
{
resmap.Add("removed", new AnArray
{
new Map
{
{ "error-tag", "Not found" }
}
});
}
using (HttpResponse res = httpreq.BeginResponse("application/llsd+xml"))
{
using (Stream o = res.GetOutputStream())
{
LlsdXml.Serialize(resmap, o);
}
}
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
Map reqmap;
try
{
reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
}
catch (Exception e)
{
m_Log.ErrorFormat("Exception {0}: {1}\n{2}", e.GetType().FullName, e.Message, e.StackTrace);
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
ParcelInfo pInfo;
if (!m_Scene.Parcels.TryGetValue(reqmap["local_id"].AsInt, out pInfo))
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
if (!m_Scene.CanEditParcelDetails(m_Agent.Owner, pInfo))
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
byte[] parcelFlagsBinary = (BinaryData)reqmap["parcel_flags"];
if (BitConverter.IsLittleEndian)
{
Array.Reverse(parcelFlagsBinary);
}
uint parcelFlags = BitConverter.ToUInt32(parcelFlagsBinary, 0);
pInfo.Flags = (ParcelFlags)parcelFlags;
pInfo.Name = reqmap["name"].ToString();
pInfo.SalePrice = reqmap["sale_price"].AsInt;
pInfo.Description = reqmap["description"].ToString();
var music_uri = reqmap["music_url"].ToString();
pInfo.MusicURI = music_uri != string.Empty && Uri.IsWellFormedUriString(music_uri, UriKind.Absolute) ? new URI(music_uri) : null;
var media_uri = reqmap["media_url"].ToString();
pInfo.MediaURI = media_uri != string.Empty && Uri.IsWellFormedUriString(media_uri, UriKind.Absolute) ? new URI(media_uri) : null;
pInfo.MediaDescription = reqmap["media_desc"].ToString();
pInfo.MediaType = reqmap["media_type"].ToString();
pInfo.MediaWidth = reqmap["media_width"].AsInt;
pInfo.MediaHeight = reqmap["media_height"].AsInt;
pInfo.MediaAutoScale = reqmap["auto_scale"].AsBoolean;
pInfo.MediaLoop = reqmap["media_loop"].AsBoolean;
pInfo.ObscureMedia = reqmap["obscure_media"].AsBoolean;
pInfo.ObscureMusic = reqmap["obscure_music"].AsBoolean;
pInfo.MediaID = reqmap["media_id"].AsUUID;
pInfo.Group = new UGI(reqmap["group_id"].AsUUID);
pInfo.PassPrice = reqmap["pass_price"].AsInt;
pInfo.PassHours = reqmap["pass_hours"].AsReal;
pInfo.Category = (ParcelCategory)reqmap["category"].AsInt;
pInfo.AuthBuyer = new UGUIWithName(reqmap["auth_buyer_id"].AsUUID);
pInfo.SnapshotID = reqmap["snapshot_id"].AsUUID;
pInfo.LandingPosition = reqmap["user_location"].AsVector3;
pInfo.LandingLookAt = reqmap["user_look_at"].AsVector3;
pInfo.LandingType = (TeleportLandingType)reqmap["landing_type"].AsInt;
if (reqmap.ContainsKey("see_avs"))
{
pInfo.SeeAvatars = reqmap["see_avs"].AsBoolean;
}
if (reqmap.ContainsKey("group_av_sounds"))
{
pInfo.GroupAvatarSounds = reqmap["group_av_sounds"].AsBoolean;
}
if (reqmap.ContainsKey("any_av_sounds"))
{
pInfo.AnyAvatarSounds = reqmap["any_av_sounds"].AsBoolean;
}
if (reqmap.ContainsKey("obscure_media"))
{
pInfo.ObscureMedia = reqmap["obscure_media"].AsBoolean;
}
if (reqmap.ContainsKey("obscure_music"))
{
pInfo.ObscureMusic = reqmap["obscure_music"].AsBoolean;
}
//media_prevent_camera_zoom
//media_url_timeout
//media_allow_navigate
//media_current_url
m_Scene.TriggerParcelUpdate(pInfo);
using (var httpres = httpreq.BeginResponse())
{
httpres.ContentType = "application/llsd+xml";
using (var outStream = httpres.GetOutputStream())
{
LlsdXml.Serialize(new Map(), outStream);
}
}
}
private static void FolderLinks_PutHandler(Request req, string[] elements)
{
AnArray newlinks;
try
{
using (Stream s = req.HttpRequest.Body)
{
newlinks = (AnArray)LlsdXml.Deserialize(s);
}
}
catch
{
ErrorResponse(req, HttpStatusCode.BadRequest, AisErrorCode.InvalidRequest, "Bad request");
return;
}
InventoryFolder folder;
var folderCache = new Dictionary <UUID, InventoryFolder>();
try
{
if (!TryFindFolder(req, elements[1], out folder, folderCache))
{
ErrorResponse(req, HttpStatusCode.NotFound, AisErrorCode.NotFound, "Not Found");
return;
}
}
catch (HttpResponse.ConnectionCloseException)
{
/* we need to pass it */
throw;
}
catch (Exception e)
{
m_Log.Debug("Exception occured", e);
ErrorResponse(req, HttpStatusCode.InternalServerError, AisErrorCode.InternalError, "Internal Server Error");
return;
}
List <InventoryItem> items = req.InventoryService.Folder.GetItems(req.Agent.ID, folder.ID);
var ids = new List <UUID>();
foreach (InventoryItem item in items)
{
if (item.AssetType == AssetType.Link || item.AssetType == AssetType.LinkFolder)
{
ids.Add(item.ID);
}
}
List <UUID> deleted = req.InventoryService.Item.Delete(req.Agent.ID, ids);
var category_items_removed = new AnArray();
var updated_category_versions = new Map();
foreach (InventoryItem item in items)
{
if (!ids.Contains(item.ID))
{
continue;
}
category_items_removed.Add(item.ID);
}
var links = new Map();
var addeditems = new AnArray();
var linkedids = new Map();
foreach (IValue iv in newlinks)
{
var newlink = iv as Map;
if (newlink == null)
{
continue;
}
var item = new InventoryItem(UUID.Random)
{
AssetID = newlink["linked_id"].AsUUID,
Name = newlink["name"].ToString(),
Description = newlink["desc"].ToString(),
AssetType = (AssetType)newlink["type"].AsInt
};
InventoryItem linkeditem;
InventoryFolder linkedfolder;
Map itemdata;
if (item.AssetType == AssetType.Link && req.InventoryService.Item.TryGetValue(req.Agent.ID, item.AssetID, out linkeditem))
{
item.InventoryType = linkeditem.InventoryType;
itemdata = item.ToAisV3(req.FullPrefixUrl);
var embedded = new Map();
embedded.Add("item", linkeditem.ToAisV3(req.FullPrefixUrl));
itemdata.Add("_embedded", embedded);
links.Add(item.ID.ToString(), itemdata);
req.InventoryService.Item.Add(item);
addeditems.Add(item.ID);
linkedids.Add(item.ID.ToString(), item.AssetID.ToString());
}
else if (item.AssetType == AssetType.LinkFolder && req.InventoryService.Folder.TryGetValue(req.Agent.ID, item.AssetID, out linkedfolder))
{
item.InventoryType = InventoryType.Unknown;
itemdata = item.ToAisV3(req.FullPrefixUrl);
var embedded = new Map();
embedded.Add("category", linkedfolder.ToAisV3(req.FullPrefixUrl));
itemdata.Add("_embedded", embedded);
links.Add(item.ID.ToString(), itemdata);
req.InventoryService.Item.Add(item);
addeditems.Add(item.ID);
linkedids.Add(item.ID.ToString(), item.AssetID.ToString());
}
}
if (req.InventoryService.Folder.TryGetValue(req.Agent.ID, folder.ID, out folder))
{
updated_category_versions.Add(folder.ID.ToString(), folder.Version);
}
SuccessResponse(req, new Map
{
["_embedded"] = new Map {
{ "links", links }
},
["_linked_ids"] = linkedids,
["_created_items"] = addeditems,
["_category_items_removed"] = category_items_removed,
["_updated_category_versions"] = updated_category_versions
});
}
public void HttpRequestHandler(HttpRequest httpreq)
{
if (httpreq.CallerIP != m_RemoteIP)
{
httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
return;
}
UUID transactionID;
if (httpreq.Method != "POST")
{
httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
return;
}
var parts = httpreq.RawUrl.Substring(1).Split('/');
if (parts.Length == 3)
{
UUID uploadID;
if (httpreq.ContentType != "application/llsd+xml")
{
httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
return;
}
Map reqmap;
try
{
IValue iv = LlsdXml.Deserialize(httpreq.Body);
reqmap = iv as Map;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
if (reqmap == null)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
try
{
uploadID = GetUploaderID(reqmap);
}
catch (UploadErrorException e)
{
var llsderrorreply = new Map
{
{ "state", "error" },
{ "message", e.Message }
};
using (HttpResponse httperrorres = httpreq.BeginResponse())
{
using (Stream outErrorStream = httperrorres.GetOutputStream())
{
LlsdXml.Serialize(llsderrorreply, outErrorStream);
}
}
return;
}
catch (InsufficientFundsException)
{
var llsderrorreply = new Map
{
{ "state", "insufficient funds" }
};
using (HttpResponse httperrorres = httpreq.BeginResponse())
{
using (Stream outErrorStream = httperrorres.GetOutputStream())
{
LlsdXml.Serialize(llsderrorreply, outErrorStream);
}
}
return;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
return;
}
/* Upload start */
var llsdreply = new Map
{
{ "state", "upload" },
{ "uploader", m_ServerURI + httpreq.RawUrl + "/Upload/" + uploadID.ToString() }
};
using (HttpResponse httpres = httpreq.BeginResponse())
{
using (Stream outStream = httpres.GetOutputStream())
{
LlsdXml.Serialize(llsdreply, outStream);
}
}
}
else if (parts.Length < 5 || parts[3] != "Upload" || !UUID.TryParse(parts[4], out transactionID))
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
}
else
{
/* Upload finished */
var asset = new AssetData();
var body = httpreq.Body;
asset.Data = new byte[body.Length];
int readBytes = body.Read(asset.Data, 0, (int)body.Length);
if (body.Length != readBytes)
{
httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
return;
}
asset.Type = NewAssetType;
asset.ID = NewAssetID;
asset.Local = AssetIsLocal;
asset.Temporary = AssetIsTemporary;
asset.Name = string.Empty;
Map llsdreply;
try
{
llsdreply = UploadedData(transactionID, asset);
}
catch (UrlNotFoundException)
{
httpreq.ErrorResponse(HttpStatusCode.NotFound, "Not Found");
return;
}
catch (UploadErrorException e)
{
var llsderrorreply = new Map
{
{ "state", "error" },
{ "message", e.Message }
};
using (var httperrorres = httpreq.BeginResponse())
{
httperrorres.ContentType = "application/llsd+xml";
using (var outErrorStream = httperrorres.GetOutputStream())
{
LlsdXml.Serialize(llsderrorreply, outErrorStream);
}
}
return;
}
catch (InsufficientFundsException)
{
var llsderrorreply = new Map
{
{ "state", "insufficient funds" }
};
using (var httperrorres = httpreq.BeginResponse())
{
httperrorres.ContentType = "application/llsd+xml";
using (var outErrorStream = httperrorres.GetOutputStream())
{
LlsdXml.Serialize(llsderrorreply, outErrorStream);
}
}
return;
}
catch
{
httpreq.ErrorResponse(HttpStatusCode.InternalServerError, "Internal Server Error");
return;
}
llsdreply.Add("new_asset", asset.ID);
llsdreply.Add("state", "complete");
using (var httpres = httpreq.BeginResponse())
{
httpres.ContentType = "application/llsd+xml";
using (var outStream = httpres.GetOutputStream())
{
LlsdXml.Serialize(llsdreply, outStream);
}
}
}
}
List <InventoryItem> this[List <UUID> itemids]
{
get
{
var items = new AnArray();
var reqmap = new Map
{
["items"] = items
};
foreach (UUID itemid in itemids)
{
items.Add(itemid);
}
byte[] reqdata;
using (var ms = new MemoryStream())
{
LlsdXml.Serialize(reqmap, ms);
reqdata = ms.ToArray();
}
Map resdata;
using (Stream s = new HttpClient.Post(m_CapabilityUri, "application/llsd+xml", reqdata.Length,
(Stream o) => o.Write(reqdata, 0, reqdata.Length))
{
TimeoutMs = TimeoutMs
}.ExecuteStreamRequest())
{
resdata = LlsdXml.Deserialize(s) as Map;
}
if (resdata == null)
{
throw new InvalidDataException();
}
AnArray itemres;
if (!resdata.TryGetValue("items", out itemres))
{
throw new InvalidDataException();
}
var result = new List <InventoryItem>();
foreach (IValue item in itemres)
{
var itemdata = item as Map;
if (itemdata == null)
{
continue;
}
var permissions = (Map)itemdata["permissions"];
var sale_info = (Map)itemdata["sale_info"];
var resitem = new InventoryItem(itemdata["item_id"].AsUUID)
{
AssetID = itemdata["asset_id"].AsUUID,
CreationDate = Date.UnixTimeToDateTime(itemdata["created_at"].AsULong),
Description = itemdata["desc"].ToString(),
Flags = (InventoryFlags)itemdata["flags"].AsInt,
InventoryType = (InventoryType)itemdata["inv_type"].AsInt,
Name = itemdata["name"].ToString(),
ParentFolderID = itemdata["parent_id"].AsUUID,
AssetType = (AssetType)itemdata["type"].AsInt,
Creator = new UGUI(permissions["creator_id"].AsUUID),
Group = new UGI(permissions["group_id"].AsUUID),
IsGroupOwned = permissions["is_owner_group"].AsBoolean,
LastOwner = new UGUI(permissions["last_owner_id"].AsUUID),
Owner = new UGUI(permissions["owner_id"].AsUUID),
SaleInfo = new InventoryItem.SaleInfoData
{
Price = sale_info["sale_price"].AsInt,
Type = (InventoryItem.SaleInfoData.SaleType)sale_info["sale_type"].AsInt
}
};
resitem.Permissions.Base = (InventoryPermissionsMask)permissions["base_mask"].AsInt;
resitem.Permissions.EveryOne = (InventoryPermissionsMask)permissions["everyone_mask"].AsInt;
resitem.Permissions.Group = (InventoryPermissionsMask)permissions["group_mask"].AsInt;
resitem.Permissions.NextOwner = (InventoryPermissionsMask)permissions["next_owner_mask"].AsInt;
resitem.Permissions.Current = (InventoryPermissionsMask)permissions["owner_mask"].AsInt;
}
return(result);
}
}