private void UploadBakedTextureDataHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] textureData = request.GetBody();
UUID assetID = UUID.Zero;
m_log.Debug("Received baked texture upload from " + cap.OwnerID + " (" + textureData.Length + " bytes)");
if (textureData != null && textureData.Length > 0)
{
if (!m_assetClient.StoreAsset("image/x-j2c", true, true, textureData, cap.OwnerID, out assetID))
{
m_log.WarnFormat("Failed to store uploaded texture bake ({0} bytes)", textureData.Length);
}
}
else
{
m_log.Warn("Texture bake upload contained no data");
}
UploadBakedTextureMessage reply = new UploadBakedTextureMessage();
UploaderRequestComplete replyBlock = new UploaderRequestComplete();
replyBlock.AssetID = assetID;
reply.Request = replyBlock;
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
private static PrimInventory FromPrimObjectInventory(LLPrimitive host, PrimObject.InventoryBlock objInv)
{
PrimInventory inv = new PrimInventory(host);
if (objInv == null)
{
return(inv);
}
for (int i = 0; i < objInv.Items.Length; i++)
{
PrimObject.InventoryBlock.ItemBlock objItem = objInv.Items[i];
LLInventoryTaskItem item = new LLInventoryTaskItem();
item.AssetID = objItem.AssetID;
item.ContentType = LLUtil.LLAssetTypeToContentType((int)objItem.Type);
item.CreationDate = objItem.CreationDate;
item.CreatorID = objItem.CreatorID;
item.Description = objItem.Description;
item.Flags = (uint)objItem.Flags;
item.GroupID = objItem.GroupID;
item.ID = objItem.ID;
item.Name = objItem.Name;
item.OwnerID = objItem.OwnerID;
item.Permissions = new Permissions(objItem.PermsBase, objItem.PermsEveryone, objItem.PermsGroup, objItem.PermsNextOwner, objItem.PermsOwner);
item.PermissionGranter = objItem.PermsGranterID;
inv.AddOrUpdateItem(item, true);
}
inv.InventorySerial = (short)objInv.Serial;
return(inv);
}
public InventoryType RemoveItem(UUID itemID)
{
DoubleDictionarySlim <UUID, string, LLInventoryTaskItem> items = Items;
LLInventoryTaskItem item;
if (items.TryGetValue(itemID, out item))
{
items.Remove(itemID, item.Name);
// Update the inventory serial number
++InventorySerial;
// Post a script event
// FIXME:
//m_hostObject.Scene.ScriptEngine.PostObjectEvent(hostObject.Prim.ID, "changed",
// new object[] { new ScriptTypes.LSL_Integer((uint)Changed.INVENTORY) }, new DetectParams[0]);
// FIXME: Check if this prim still classifies as "scripted"
return((InventoryType)LLUtil.ContentTypeToLLInvType(item.ContentType));
}
else
{
return(InventoryType.Unknown);
}
}
private void ObjectLoadedHandler(AssetPrim linkset, long bytesRead, long totalBytes)
{
if (m_primMesher == null)
{
return;
}
// Get the root prim
LLPrimitive parent = LLUtil.PrimObjectToLLPrim(linkset.Parent, m_scene, m_primMesher);
// Get the child prims and sort them by link order
SortedList <int, LLPrimitive> children = new SortedList <int, LLPrimitive>(linkset.Children.Count);
for (int i = 0; i < linkset.Children.Count; i++)
{
children.Add(linkset.Children[i].LinkNumber, LLUtil.PrimObjectToLLPrim(linkset.Children[i], m_scene, m_primMesher));
}
// Set the child prims as children of the root, in order
foreach (LLPrimitive child in children.Values)
{
child.SetParent(parent, false, false);
}
// Send updates for everything
m_scene.EntityAddOrUpdate(this, parent, UpdateFlags.FullUpdate, 0);
foreach (LLPrimitive child in children.Values)
{
m_scene.EntityAddOrUpdate(this, child, UpdateFlags.FullUpdate, 0);
}
PrintProgress(bytesRead, totalBytes);
}
private void NewFileAgentInventoryUploadHandler(NewFileAgentInventoryMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
UUID itemID = UUID.Zero;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
LLInventoryItem item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
item.Permissions = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (m_inventoryClient.TryCreateItem(cap.OwnerID, item))
{
itemID = item.ID;
}
else
{
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
OSDMap reply = new OSDMap
{
{ "state", OSD.FromString("complete") },
{ "new_asset", OSD.FromUUID(assetID) },
{ "new_inventory_item", OSD.FromUUID(itemID) }
};
LLUtil.SendLLSDXMLResponse(response, reply);
}
private void UploadBakedTextureHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
UploadBakedTextureMessage reply = new UploadBakedTextureMessage();
UploaderRequestUpload replyBlock = new UploaderRequestUpload();
// Create a temporary uploader capability
replyBlock.Url = m_scene.Capabilities.AddCapability(cap.OwnerID, true, m_scene.ID, "UploadBakedTextureData");
reply.Request = replyBlock;
m_log.Debug("Created baked texture upload capability " + replyBlock.Url + " for " + cap.OwnerID);
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
private void NewFileAgentInventoryHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryMessage>(request.Body, out message))
{
m_log.Error("Implement NewFileAgentInventory");
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventory");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void ParcelVoiceInfoRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ParcelVoiceInfoRequestMessage message;
if (LLUtil.TryGetMessage <ParcelVoiceInfoRequestMessage>(request.Body, out message))
{
m_log.DebugFormat("ParcelVoiceInfoRequest: RegionName={0}, ParcelID={1}, SipChannelUri={2}",
message.RegionName, message.ParcelID, message.SipChannelUri);
}
else
{
m_log.Warn("Received invalid request data for ParcelVoiceInfoRequest");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void AssetLoadedHandler(OpenMetaverse.Assets.Asset asset, long bytesRead, long totalBytes)
{
// Asynchronously filter and store the asset
bool doRelease = m_assetLoadSemaphore.WaitOne(1000 * 10);
if (!doRelease)
{
m_log.Error("Timed out waiting for the previous OAR asset load to complete");
}
m_scheduler.FireAndForget(
delegate(object o)
{
try
{
m_assetClient.StoreAsset(new Asset
{
ContentType = LLUtil.LLAssetTypeToContentType((int)asset.AssetType),
CreationDate = DateTime.UtcNow,
CreatorID = UUID.Zero,
Data = asset.AssetData,
ID = asset.AssetID
});
//m_log.DebugFormat("Loaded asset {0} ({1}), {2} bytes", asset.AssetID, asset.AssetType, asset.AssetData.Length);
}
finally
{
if (doRelease)
{
m_assetLoadSemaphore.Release();
}
}
}, null
);
PrintProgress(bytesRead, totalBytes);
}
private void NewFileAgentInventoryVariablePriceHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
NewFileAgentInventoryVariablePriceMessage message;
if (LLUtil.TryGetMessage <NewFileAgentInventoryVariablePriceMessage>(request.Body, out message))
{
NewFileAgentInventoryVariablePriceReplyMessage reply = new NewFileAgentInventoryVariablePriceReplyMessage();
reply.ResourceCost = 0;
reply.UploadPrice = 0;
// Create a one time upload capability
reply.Rsvp = m_scene.Capabilities.AddOneTimeCapability(cap.OwnerID, true,
delegate(Capability _cap, IHttpClientContext _context, IHttpRequest _request, IHttpResponse _response)
{ NewFileAgentInventoryVariablePriceUploadHandler(message, _cap, _context, _request, _response); }
);
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received invalid data for NewFileAgentInventoryVariablePrice");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void UploadObjectAssetHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
UploadObjectAssetMessage message;
if (LLUtil.TryGetMessage <UploadObjectAssetMessage>(request.Body, out message))
{
LLPrimitive parent = null;
// Build the linkset
for (int i = 0; i < message.Objects.Length; i++)
{
UploadObjectAssetMessage.Object obj = message.Objects[i];
#region Primitive Creation
Primitive prim = new Primitive();
prim.Properties = new Primitive.ObjectProperties();
prim.Sculpt = new Primitive.SculptData();
prim.Textures = new Primitive.TextureEntry(UUID.Zero);
prim.Flags = PrimFlags.CastShadows | PrimFlags.InventoryEmpty | PrimFlags.CreateSelected;
prim.ID = UUID.Random();
prim.MediaURL = String.Empty;
prim.OwnerID = cap.OwnerID;
prim.GroupID = obj.GroupID;
prim.TextColor = Color4.Black;
prim.Properties.CreationDate = DateTime.UtcNow;
prim.Properties.CreatorID = cap.OwnerID;
prim.Properties.Description = String.Empty;
prim.Properties.GroupID = obj.GroupID;
prim.Properties.LastOwnerID = cap.OwnerID;
prim.Properties.Name = obj.Name;
prim.Properties.ObjectID = prim.ID;
prim.Properties.OwnerID = prim.OwnerID;
prim.Properties.Permissions = (m_permissions != null) ?
m_permissions.GetDefaultPermissions() :
Permissions.FullPermissions;
prim.Properties.SalePrice = 10;
prim.PrimData.PCode = PCode.Prim;
prim.PrimData.Material = obj.Material;
prim.PrimData.PathBegin = obj.PathBegin;
prim.PrimData.PathCurve = (PathCurve)obj.PathCurve;
prim.PrimData.PathEnd = obj.PathEnd;
prim.PrimData.ProfileBegin = obj.ProfileBegin;
prim.PrimData.ProfileCurve = (ProfileCurve)obj.ProfileCurve;
prim.PrimData.ProfileEnd = obj.ProfileEnd;
prim.PrimData.ProfileHollow = obj.ProfileHollow;
prim.PrimData.PathRadiusOffset = obj.RadiusOffset;
prim.PrimData.PathRevolutions = obj.Revolutions;
prim.PrimData.PathScaleX = obj.ScaleX;
prim.PrimData.PathScaleY = obj.ScaleY;
prim.PrimData.PathShearX = obj.ShearX;
prim.PrimData.PathShearY = obj.ShearY;
prim.PrimData.PathSkew = obj.Skew;
prim.PrimData.PathTaperX = obj.TaperX;
prim.PrimData.PathTaperY = obj.TaperY;
prim.PrimData.PathTwist = obj.Twist;
prim.PrimData.PathTwistBegin = obj.TwistBegin;
// Extra parameters
for (int j = 0; j < obj.ExtraParams.Length; j++)
{
UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[j];
switch (extraParam.Type)
{
case ExtraParamType.Flexible:
prim.Flexible = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Light:
prim.Light = new Primitive.LightData(extraParam.ExtraParamData, 0);
break;
case ExtraParamType.Sculpt:
prim.Sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
break;
}
}
// Faces
for (int j = 0; j < obj.Faces.Length; j++)
{
UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
Primitive.TextureEntryFace primFace = prim.Textures.GetFace(0);
primFace.Bump = face.Bump;
primFace.RGBA = face.Color;
primFace.Fullbright = face.Fullbright;
primFace.Glow = face.Glow;
primFace.TextureID = face.ImageID;
primFace.Rotation = face.ImageRot;
primFace.MediaFlags = ((face.MediaFlags & MEDIA_MASK) != 0);
primFace.OffsetU = face.OffsetS;
primFace.OffsetV = face.OffsetT;
primFace.RepeatU = face.ScaleS;
primFace.RepeatV = face.ScaleT;
primFace.TexMapType = (MappingType)(face.MediaFlags & TEX_MAP_MASK);
}
prim.Sculpt.SculptTexture = obj.SculptID;
prim.Sculpt.Type = obj.SculptType;
#endregion Primitive Creation
LLPrimitive llprim = new LLPrimitive(prim, m_scene, m_primMesher);
llprim.Scale = obj.Scale;
// Link children prims to the parent
if (i == 0)
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
parent = llprim;
}
else
{
llprim.RelativePosition = obj.Position;
llprim.RelativeRotation = obj.Rotation;
llprim.SetParent(parent, true, false);
m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0);
}
}
}
else
{
m_log.Warn("Received invalid data for UploadObjectAsset");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private void NewFileAgentInventoryVariablePriceUploadHandler(NewFileAgentInventoryVariablePriceMessage message, Capability cap,
IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
byte[] assetData = request.GetBody();
UUID assetID = UUID.Zero;
LLInventoryItem item = null;
m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)");
if (assetData != null && assetData.Length > 0)
{
string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType);
// Create the asset
if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID))
{
// Create the inventory item
item = new LLInventoryItem();
item.AssetID = assetID;
item.ContentType = contentType;
item.CreationDate = DateTime.UtcNow;
item.CreatorID = cap.OwnerID;
item.Description = message.Description;
item.ID = UUID.Random();
item.Name = message.Name;
item.OwnerID = cap.OwnerID;
item.ParentID = message.FolderID;
Permissions perms = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions;
perms.EveryoneMask = message.EveryoneMask;
perms.GroupMask = message.GroupMask;
perms.NextOwnerMask = message.NextOwnerMask;
item.Permissions = perms;
item.SalePrice = 10;
item.SaleType = SaleType.Not;
if (!m_inventoryClient.TryCreateItem(cap.OwnerID, item))
{
m_log.Warn("Failed to create inventory item for uploaded asset " + assetID);
}
}
else
{
m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length);
}
}
else
{
m_log.Warn("Inventory asset upload contained no data");
}
// Build the response message
NewFileAgentInventoryUploadReplyMessage reply = new NewFileAgentInventoryUploadReplyMessage();
reply.NewAsset = assetID;
if (item != null)
{
reply.NewInventoryItem = item.ID;
reply.NewBaseMask = item.Permissions.BaseMask;
reply.NewEveryoneMask = item.Permissions.EveryoneMask;
reply.NewNextOwnerMask = item.Permissions.NextOwnerMask;
reply.NewOwnerMask = item.Permissions.OwnerMask;
}
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
private void ViewerStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ViewerStatsMessage message;
if (LLUtil.TryGetMessage <ViewerStatsMessage>(request.Body, out message))
{
DateTime timestamp = DateTime.UtcNow;
if (m_statsTracker != null)
{
// Log timestamped data points
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentFPS", message.AgentFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentMemoryUsed", message.AgentMemoryUsed);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentPing", message.AgentPing);
m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentsInView", message.AgentsInView);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresInvalid", message.FailuresInvalid);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresOffCircuit", message.FailuresOffCircuit);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresResent", message.FailuresResent);
m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresSendPacket", message.FailuresSendPacket);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InCompressedPackets", message.InCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InKbytes", message.InKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InPackets", message.InPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "InSavings", message.InSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MetersTraveled", message.MetersTraveled);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt1", message.MiscInt1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt2", message.MiscInt2);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscString1", message.MiscString1);
m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscVersion", message.MiscVersion);
m_statsTracker.LogEntry(timestamp, message.SessionID, "ObjectKbytes", message.object_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutCompressedPackets", message.OutCompressedPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutKbytes", message.OutKbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutPackets", message.OutPackets);
m_statsTracker.LogEntry(timestamp, message.SessionID, "OutSavings", message.OutSavings);
m_statsTracker.LogEntry(timestamp, message.SessionID, "RegionsVisisted", message.RegionsVisited);
m_statsTracker.LogEntry(timestamp, message.SessionID, "SimulatorFPS", message.SimulatorFPS);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsDropped", message.StatsDropped);
m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsFailedResends", message.StatsFailedResends);
m_statsTracker.LogEntry(timestamp, message.SessionID, "TextureKbytes", message.texture_kbytes);
m_statsTracker.LogEntry(timestamp, message.SessionID, "WorldKbytes", message.world_kbytes);
// Update constant values for this session
m_statsTracker.SetValue(message.SessionID, "AgentLanguage", message.AgentLanguage);
m_statsTracker.SetValue(message.SessionID, "AgentRuntime", message.AgentRuntime);
m_statsTracker.SetValue(message.SessionID, "AgentStartTime", message.AgentStartTime);
m_statsTracker.SetValue(message.SessionID, "AgentVersion", message.AgentVersion);
m_statsTracker.SetValue(message.SessionID, "SystemCPU", message.SystemCPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPU", message.SystemGPU);
m_statsTracker.SetValue(message.SessionID, "SystemGPUClass", message.SystemGPUClass);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVendor", message.SystemGPUVendor);
m_statsTracker.SetValue(message.SessionID, "SystemGPUVersion", message.SystemGPUVersion);
m_statsTracker.SetValue(message.SessionID, "SystemInstalledRam", message.SystemInstalledRam);
m_statsTracker.SetValue(message.SessionID, "SystemOS", message.SystemOS);
m_statsTracker.SetValue(message.SessionID, "VertexBuffersEnabled", message.VertexBuffersEnabled);
}
}
else
{
m_log.Warn("Received invalid data for ViewerStats");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
private static List <LLInventoryTaskItem> ParseTaskInventory(UUID parentObjectID, string taskData)
{
List <LLInventoryTaskItem> items = new List <LLInventoryTaskItem>();
int lineNum = 0;
string[] lines = taskData.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
while (lineNum < lines.Length)
{
string key, value;
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "inv_item")
{
#region Default Values
UUID itemID = UUID.Zero;
UUID assetID = UUID.Zero;
UUID parentID = UUID.Zero;
UUID creatorID = UUID.Zero;
UUID ownerID = UUID.Zero;
UUID lastOwnerID = UUID.Zero;
UUID groupID = UUID.Zero;
bool groupOwned = false;
string name = String.Empty;
string desc = String.Empty;
AssetType assetType = AssetType.Unknown;
InventoryType inventoryType = InventoryType.Unknown;
DateTime creationDate = Utils.Epoch;
uint flags = 0;
Permissions perms = Permissions.NoPermissions;
SaleType saleType = SaleType.Not;
int salePrice = 0;
#endregion Default Values
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
#region Line Parsing
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "item_id")
{
UUID.TryParse(value, out itemID);
}
else if (key == "parent_id")
{
UUID.TryParse(value, out parentID);
}
else if (key == "permissions")
{
#region permissions
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "creator_mask")
{
// Deprecated
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.BaseMask = (PermissionMask)val;
}
}
else if (key == "base_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.BaseMask = (PermissionMask)val;
}
}
else if (key == "owner_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.OwnerMask = (PermissionMask)val;
}
}
else if (key == "group_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.GroupMask = (PermissionMask)val;
}
}
else if (key == "everyone_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.EveryoneMask = (PermissionMask)val;
}
}
else if (key == "next_owner_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
{
perms.NextOwnerMask = (PermissionMask)val;
}
}
else if (key == "creator_id")
{
UUID.TryParse(value, out creatorID);
}
else if (key == "owner_id")
{
UUID.TryParse(value, out ownerID);
}
else if (key == "last_owner_id")
{
UUID.TryParse(value, out lastOwnerID);
}
else if (key == "group_id")
{
UUID.TryParse(value, out groupID);
}
else if (key == "group_owned")
{
uint val;
if (UInt32.TryParse(value, out val))
{
groupOwned = (val != 0);
}
}
}
}
#endregion permissions
}
else if (key == "sale_info")
{
#region sale_info
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "sale_type")
{
saleType = Utils.StringToSaleType(value);
}
else if (key == "sale_price")
{
Int32.TryParse(value, out salePrice);
}
}
}
#endregion sale_info
}
else if (key == "shadow_id")
{
UUID shadowID;
if (UUID.TryParse(value, out shadowID))
{
assetID = DecryptShadowID(shadowID);
}
}
else if (key == "asset_id")
{
UUID.TryParse(value, out assetID);
}
else if (key == "type")
{
assetType = Utils.StringToAssetType(value);
}
else if (key == "inv_type")
{
inventoryType = Utils.StringToInventoryType(value);
}
else if (key == "flags")
{
UInt32.TryParse(value, out flags);
}
else if (key == "name")
{
name = value.Substring(0, value.IndexOf('|'));
}
else if (key == "desc")
{
desc = value.Substring(0, value.IndexOf('|'));
}
else if (key == "creation_date")
{
uint timestamp;
if (UInt32.TryParse(value, out timestamp))
{
creationDate = Utils.UnixTimeToDateTime(timestamp);
}
else
{
Logger.Log("Failed to parse creation_date " + value, Helpers.LogLevel.Warning);
}
}
#endregion Line Parsing
}
}
LLInventoryTaskItem item = new LLInventoryTaskItem();
item.AssetID = assetID;
item.ContentType = LLUtil.LLAssetTypeToContentType((int)assetType);
item.CreationDate = creationDate;
item.CreatorID = creatorID;
item.Description = desc;
item.Flags = flags;
item.GroupID = groupID;
item.GroupOwned = groupOwned;
item.ID = itemID;
item.Name = name;
item.OwnerID = ownerID;
item.ParentID = parentID;
item.ParentObjectID = parentObjectID;
item.PermissionGranter = UUID.Zero; // TODO: We should be serializing this
item.Permissions = perms;
item.SalePrice = salePrice;
item.SaleType = saleType;
items.Add(item);
}
else
{
//m_log.Warn("Unrecognized token " + key + " in: " + Environment.NewLine + taskData);
}
}
}
return(items);
}
private void ObjectMediaHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response)
{
ObjectMediaMessage message;
if (LLUtil.TryGetMessage <ObjectMediaMessage>(request.Body, out message))
{
if (message.Request is ObjectMediaRequest)
{
ObjectMediaRequest mediaRequest = (ObjectMediaRequest)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(mediaRequest.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
ObjectMediaResponse reply = new ObjectMediaResponse();
reply.PrimID = prim.ID;
reply.FaceMedia = prim.Prim.FaceMedia ?? new MediaEntry[0];
reply.Version = prim.Prim.MediaVersion ?? String.Empty;
LLUtil.SendLLSDXMLResponse(response, reply.Serialize());
}
else
{
m_log.Warn("Received an ObjectMedia request for unknown prim " + mediaRequest.PrimID);
}
}
else if (message.Request is ObjectMediaUpdate)
{
ObjectMediaUpdate update = (ObjectMediaUpdate)message.Request;
ISceneEntity entity;
if (m_scene.TryGetEntity(update.PrimID, out entity) && entity is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)entity;
int lastVersion = ParseMediaVersion(prim.Prim.MediaVersion);
prim.Prim.FaceMedia = update.FaceMedia;
prim.Prim.MediaVersion = CreateMediaVersion(lastVersion + 1, cap.OwnerID);
// Set the CurrentURL fields
for (int i = 0; i < prim.Prim.FaceMedia.Length; i++)
{
MediaEntry entry = prim.Prim.FaceMedia[i];
if (entry != null && String.IsNullOrEmpty(entry.CurrentURL))
{
entry.CurrentURL = entry.HomeURL;
}
}
// Set the texture face media flags
for (int i = 0; i < prim.Prim.Textures.FaceTextures.Length; i++)
{
Primitive.TextureEntryFace face = prim.Prim.Textures.FaceTextures[i];
MediaEntry entry = (update.FaceMedia.Length > i) ? update.FaceMedia[i] : null;
if (entry != null)
{
if (face == null)
{
face = prim.Prim.Textures.CreateFace((uint)i);
}
face.MediaFlags = true;
}
else if (face != null)
{
face.MediaFlags = false;
}
}
m_scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0);
}
else
{
m_log.Warn("Could not update ObjectMedia for " + update.PrimID + ", prim not found");
}
}
else
{
m_log.Warn("Unrecognized ObjectMedia message: " + message.Request);
}
}
else
{
m_log.Warn("Received invalid data for ObjectMedia");
response.Status = System.Net.HttpStatusCode.BadRequest;
}
}
