private void CreateAsset(assets asset)
{
AssetType type = (AssetType)asset.assetType;
string contentType = LLUtil.SLAssetTypeToContentType((int)type);
bool isPublic = true;
// Don't bother copying temporary assets
if (asset.temporary != 0)
{
return;
}
// Distinguish public and private assets
switch (type)
{
case AssetType.CallingCard:
case AssetType.Gesture:
case AssetType.LSLBytecode:
case AssetType.LSLText:
isPublic = false;
break;
}
object[] args = new object[] { asset.id, isPublic, asset.name, contentType, asset.data };
m_semaphore.WaitOne();
ThreadPool.QueueUserWorkItem(DoCreateAsset, args);
}
private ArrayList FillInventorySkeleton(InventoryFolder rootFolder)
{
ArrayList inventory = new ArrayList(rootFolder.Children.Count + 1);
Hashtable rootFolderData = new Hashtable();
rootFolderData["name"] = rootFolder.Name;
rootFolderData["parent_id"] = rootFolder.ParentID.ToString();
rootFolderData["type_default"] = (int)LLUtil.ContentTypeToLLAssetType(rootFolder.PreferredContentType);
rootFolderData["folder_id"] = rootFolder.ID.ToString();
rootFolderData["version"] = rootFolder.Version;
inventory.Add(rootFolderData);
foreach (var child in rootFolder.Children.Values)
{
InventoryFolder folder = (InventoryFolder)child;
Hashtable folderData = new Hashtable();
folderData["name"] = folder.Name;
folderData["parent_id"] = folder.ParentID.ToString();
folderData["type_default"] = (int)LLUtil.ContentTypeToLLAssetType(folder.PreferredContentType);
folderData["folder_id"] = folder.ID.ToString();
folderData["version"] = folder.Version;
inventory.Add(folderData);
}
return(inventory);
}
public string llAvatarOnSitTarget(IScriptInstance script)
{
if (script.Host is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)script.Host;
if (prim.SitPosition != Vector3.Zero)
{
ILinkable[] children = ((ILinkable)script.Host).GetChildren();
for (int i = 0, len = children.Length; i < len; i++)
{
if (children[i] is LLAgent)
{
LLAgent childAgent = (LLAgent)children[i];
if (childAgent.RelativePosition == LLUtil.GetSitTarget(prim.SitPosition, childAgent.Scale))
{
return(childAgent.ID.ToString());
}
}
}
}
}
return(UUID.Zero.ToString());
}
private void SignalTaskInventoryChange(LLAgent agent, LLPrimitive prim)
{
// Send an ObjectPropertiesReply to inform the client that inventory has changed
ObjectPropertiesPacket props = new ObjectPropertiesPacket();
props.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[1];
props.ObjectData[0] = LLUtil.BuildEntityPropertiesBlock(prim);
m_udp.SendPacket(agent, props, ThrottleCategory.Task, false);
// Signal this prim for serialization
m_scene.EntityAddOrUpdate(this, prim, UpdateFlags.Serialize, 0);
}
private Asset CreateAsset(AssetType type, UUID assetID, DateTime creationDate, UUID creatorID, bool local, bool temporary, byte[] data)
{
Asset asset = new Asset();
asset.ID = assetID;
asset.ContentType = LLUtil.LLAssetTypeToContentType((int)type);
asset.CreationDate = creationDate;
asset.CreatorID = creatorID;
asset.Data = data;
asset.Local = local;
asset.Temporary = temporary;
//asset.SHA1 is filled in later
return(asset);
}
private void TransferRequestHandler(Packet packet, LLAgent agent)
{
TransferRequestPacket request = (TransferRequestPacket)packet;
ChannelType channel = (ChannelType)request.TransferInfo.ChannelType;
SourceType source = (SourceType)request.TransferInfo.SourceType;
if (channel == ChannelType.Asset)
{
if (source == SourceType.Asset)
{
// Parse the request
UUID assetID = new UUID(request.TransferInfo.Params, 0);
AssetType type = (AssetType)(sbyte)Utils.BytesToInt(request.TransferInfo.Params, 16);
string contentType = LLUtil.LLAssetTypeToContentType((int)type);
// Permission check
if (!CanDownloadInventory(agent, type, assetID))
{
TransferNotFound(agent, request.TransferInfo.TransferID, assetID, type);
return;
}
// Check if we have this asset
Asset asset;
if (m_assets.TryGetAsset(assetID, contentType, out asset))
{
TransferDownload(agent, request.TransferInfo.TransferID, assetID, type, asset);
}
else
{
TransferNotFound(agent, request.TransferInfo.TransferID, assetID, type);
}
}
else if (source == SourceType.SimInventoryItem)
{
//UUID agentID = new UUID(request.TransferInfo.Params, 0);
//UUID sessionID = new UUID(request.TransferInfo.Params, 16);
//UUID ownerID = new UUID(request.TransferInfo.Params, 32);
UUID taskID = new UUID(request.TransferInfo.Params, 48);
UUID itemID = new UUID(request.TransferInfo.Params, 64);
UUID assetID = new UUID(request.TransferInfo.Params, 80);
AssetType type = (AssetType)(sbyte)Utils.BytesToInt(request.TransferInfo.Params, 96);
string contentType = LLUtil.LLAssetTypeToContentType((int)type);
if (taskID != UUID.Zero)
{
// Task (prim) inventory request permission check
if (!CanDownloadTaskInventory(agent, type, taskID, itemID))
{
TransferNotFound(agent, request.TransferInfo.TransferID, assetID, type);
return;
}
}
else
{
// Agent inventory request permission check
if (!CanDownloadInventory(agent, type, assetID))
{
TransferNotFound(agent, request.TransferInfo.TransferID, assetID, type);
return;
}
}
// Check if we have this asset
Asset asset;
if (m_assets.TryGetAsset(assetID, contentType, out asset))
{
TransferDownload(agent, request.TransferInfo.TransferID, assetID, type, asset);
}
else
{
TransferNotFound(agent, request.TransferInfo.TransferID, assetID, type);
}
}
else if (source == SourceType.SimEstate)
{
//UUID agentID = new UUID(request.TransferInfo.Params, 0);
//UUID sessionID = new UUID(request.TransferInfo.Params, 16);
//EstateAssetType type = (EstateAssetType)Utils.BytesToInt(request.TransferInfo.Params, 32);
m_log.Warn("Don't know what to do with an estate asset transfer request");
}
else
{
m_log.WarnFormat(
"Received a TransferRequest that we don't know how to handle. Channel: {0}, Source: {1}",
channel, source);
}
}
else
{
m_log.WarnFormat(
"Received a TransferRequest that we don't know how to handle. Channel: {0}, Source: {1}",
channel, source);
}
}
private void TransferDownload(LLAgent agent, UUID transferID, UUID assetID, AssetType type, Asset asset)
{
const int MAX_CHUNK_SIZE = 1000;
string contentType = LLUtil.LLAssetTypeToContentType((int)type);
if (contentType == asset.ContentType)
{
m_log.Debug(String.Format("Transferring asset {0} ({1})", asset.ID, asset.ContentType));
TransferInfoPacket response = new TransferInfoPacket();
response.TransferInfo = new TransferInfoPacket.TransferInfoBlock();
response.TransferInfo.TransferID = transferID;
// Set the response channel type
response.TransferInfo.ChannelType = (int)ChannelType.Asset;
// Params
response.TransferInfo.Params = new byte[20];
assetID.ToBytes(response.TransferInfo.Params, 0);
Utils.IntToBytes((int)type, response.TransferInfo.Params, 16);
response.TransferInfo.Size = asset.Data.Length;
response.TransferInfo.Status = (int)StatusCode.OK;
response.TransferInfo.TargetType = (int)TargetType.Unknown; // Doesn't seem to be used by the client
m_udp.SendPacket(agent, response, ThrottleCategory.Asset, false);
// Transfer system does not wait for ACKs, just sends all of the
// packets for this transfer out
int processedLength = 0;
int packetNum = 0;
while (processedLength < asset.Data.Length)
{
TransferPacketPacket transfer = new TransferPacketPacket();
transfer.TransferData.ChannelType = (int)ChannelType.Asset;
transfer.TransferData.TransferID = transferID;
transfer.TransferData.Packet = packetNum++;
int chunkSize = Math.Min(asset.Data.Length - processedLength, MAX_CHUNK_SIZE);
transfer.TransferData.Data = new byte[chunkSize];
Buffer.BlockCopy(asset.Data, processedLength, transfer.TransferData.Data, 0, chunkSize);
processedLength += chunkSize;
if (processedLength >= asset.Data.Length)
{
transfer.TransferData.Status = (int)StatusCode.Done;
}
else
{
transfer.TransferData.Status = (int)StatusCode.OK;
}
m_udp.SendPacket(agent, transfer, ThrottleCategory.Asset, false);
}
}
else
{
m_log.WarnFormat("Request for asset {0} with type {1} does not match actual asset type {2}",
assetID, type, asset.ContentType);
TransferNotFound(agent, transferID, assetID, type);
}
}
private void SendXferPacketHandler(Packet packet, LLAgent agent)
{
SendXferPacketPacket xfer = (SendXferPacketPacket)packet;
uint packetID = xfer.XferID.Packet & ~LAST_PACKET_MARKER;
bool lastPacket = (xfer.XferID.Packet & LAST_PACKET_MARKER) != 0;
Asset asset;
if (currentUploads.TryGetValue(xfer.XferID.ID, out asset))
{
if (packetID == 0)
{
uint size = Utils.BytesToUInt(xfer.DataPacket.Data);
asset.Data = new byte[size];
Buffer.BlockCopy(xfer.DataPacket.Data, 4, asset.Data, 0, xfer.DataPacket.Data.Length - 4);
// Confirm the first upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
m_udp.SendPacket(agent, confirm, ThrottleCategory.Asset, false);
}
else if (asset.Data != null)
{
AssetType type = (AssetType)LLUtil.ContentTypeToLLAssetType(asset.ContentType);
Buffer.BlockCopy(xfer.DataPacket.Data, 0, asset.Data, (int)packetID * 1000, xfer.DataPacket.Data.Length);
// Confirm this upload packet
ConfirmXferPacketPacket confirm = new ConfirmXferPacketPacket();
confirm.XferID.ID = xfer.XferID.ID;
confirm.XferID.Packet = xfer.XferID.Packet;
m_udp.SendPacket(agent, confirm, ThrottleCategory.Asset, false);
if (lastPacket)
{
// Asset upload finished
lock (currentUploads)
currentUploads.Remove(xfer.XferID.ID);
if (type != AssetType.LSLBytecode)
{
// Store the uploaded asset
m_log.DebugFormat("Storing uploaded asset {0} ({1})", asset.ID, asset.ContentType);
if (!m_assets.StoreAsset(asset))
{
m_log.ErrorFormat("Failed to store uploaded asset {0} ({1})", asset.ID, asset.ContentType);
}
}
else
{
m_log.Debug("Ignoring LSL bytecode upload " + asset.ID);
}
AssetUploadCompletePacket complete = new AssetUploadCompletePacket();
complete.AssetBlock.Success = true;
complete.AssetBlock.Type = (sbyte)type;
complete.AssetBlock.UUID = asset.ID;
m_udp.SendPacket(agent, complete, ThrottleCategory.Asset, false);
}
}
else
{
m_log.Error("Received SendXferPacket #" + xfer.XferID.Packet + " when asset.AssetData is still null");
}
}
else
{
m_log.Debug("Received a SendXferPacket for an unknown upload");
}
}
private void AgentRequestSitHandler(Packet packet, LLAgent agent)
{
AgentRequestSitPacket request = (AgentRequestSitPacket)packet;
agent.RequestedSitTarget = request.TargetObject.TargetID;
agent.RequestedSitOffset = request.TargetObject.Offset;
//TODO: move to AgentSitHandler when we figure out how to make the client send AgentSit
ISceneEntity seat;
if (m_scene.TryGetEntity(agent.RequestedSitTarget, out seat) && seat is ILinkable)
{
agent.SetParent((ILinkable)seat, false, false);
AvatarSitResponsePacket response = new AvatarSitResponsePacket();
response.SitObject.ID = agent.RequestedSitTarget;
if (seat is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)seat;
if (prim.SitPosition != Vector3.Zero)
{
// llSitTarget is set
response.SitTransform.SitPosition = prim.SitPosition;
response.SitTransform.SitRotation = prim.SitRotation;
agent.RelativePosition = LLUtil.GetSitTarget(prim.SitPosition, agent.Scale);
agent.RelativeRotation = prim.SitRotation;
}
else
{
// No sit target set
Vector3 sitPos = LLUtil.GetSitTarget(agent.RequestedSitOffset, agent.Scale);
response.SitTransform.SitPosition = sitPos;
response.SitTransform.SitRotation = Quaternion.Identity;
agent.RelativePosition = sitPos;
agent.RelativeRotation = Quaternion.Identity;
}
}
m_udp.SendPacket(agent, response, ThrottleCategory.Task, false);
m_scene.EntityAddOrUpdate(this, agent, UpdateFlags.Parent, 0);
agent.Animations.SetDefaultAnimation(OpenMetaverse.Animations.SIT, 1);
m_scene.SendPresenceAnimations(this, agent);
if (m_lslScriptEngine != null)
{
m_lslScriptEngine.PostObjectEvent(seat.ID, "changed", new object[] { CHANGED_LINK }, new DetectParams[0]);
}
}
else
{
//TODO: send error message
}
}
private void CreateFolder(inventoryfolders folder)
{
++m_counter;
#region Folder Creation
string folderID = folder.folderID;
if (m_rewriteFolderIDs.ContainsKey(folderID))
{
folderID = m_rewriteFolderIDs[folderID];
}
string parentFolderID = folder.parentFolderID;
if (m_rewriteFolderIDs.ContainsKey(parentFolderID))
{
parentFolderID = m_rewriteFolderIDs[parentFolderID];
}
NameValueCollection requestArgs = new NameValueCollection
{
{ "RequestMethod", "AddInventoryFolder" },
{ "FolderID", folderID },
{ "ParentID", parentFolderID },
{ "OwnerID", folder.agentID },
{ "Name", folder.folderName },
{ "ContentType", LLUtil.SLAssetTypeToContentType(folder.type) }
};
OSDMap response = WebUtil.PostToService(m_inventoryUrl, requestArgs);
bool success = response["Success"].AsBoolean();
if (!success)
{
Console.WriteLine("Error creating folder " + folder.folderName + " for " + folder.agentID + ": " + response["Message"].AsString());
return;
}
#endregion Folder Creation
#region Child Folders
var children = from i in m_db.inventoryfolders
where (i.parentFolderID == folder.folderID)
select i;
foreach (var child in children)
{
CreateFolder(child);
if (m_counter % 10 == 0)
{
Console.Write(".");
}
}
#endregion Child Folders
#region Child Items
var items = from i in m_db.inventoryitems
where (i.parentFolderID == folder.folderID)
select i;
foreach (var item in items)
{
CreateItem(item);
if (m_counter % 10 == 0)
{
Console.Write(".");
}
}
#endregion Child Items
}
private void CreateItem(inventoryitems item)
{
++m_counter;
AssetType assetType = (item.assetType.HasValue) ? (AssetType)item.assetType.Value : AssetType.Unknown;
InventoryType inventoryType = (item.invType.HasValue) ? (InventoryType)item.invType.Value : InventoryType.Unknown;
UUID groupID;
UUID.TryParse(item.groupID, out groupID);
string parentFolderID = item.parentFolderID;
if (m_rewriteFolderIDs.ContainsKey(parentFolderID))
{
parentFolderID = m_rewriteFolderIDs[parentFolderID];
}
// Create this item
OSDMap permissions = new OSDMap
{
{ "BaseMask", OSD.FromInteger(item.inventoryBasePermissions) },
{ "EveryoneMask", OSD.FromInteger(item.inventoryEveryOnePermissions) },
{ "GroupMask", OSD.FromInteger(item.inventoryGroupPermissions) },
{ "NextOwnerMask", OSD.FromInteger(item.inventoryNextPermissions.HasValue ? item.inventoryNextPermissions.Value : item.inventoryBasePermissions) },
{ "OwnerMask", OSD.FromInteger(item.inventoryCurrentPermissions.HasValue ? item.inventoryCurrentPermissions.Value : item.inventoryBasePermissions) }
};
OSDMap extraData = new OSDMap()
{
{ "Flags", OSD.FromInteger(item.flags) },
{ "GroupID", OSD.FromUUID(groupID) },
{ "GroupOwned", OSD.FromBoolean(item.groupOwned != 0) },
{ "SalePrice", OSD.FromInteger(item.salePrice) },
{ "SaleType", OSD.FromInteger(item.saleType) },
{ "Permissions", permissions }
};
// Add different asset type only if it differs from inventory type
// (needed for links)
string invContentType = LLUtil.SLInvTypeToContentType((int)inventoryType);
string assetContentType = LLUtil.SLAssetTypeToContentType((int)assetType);
if (invContentType != assetContentType)
{
extraData["LinkedItemType"] = OSD.FromString(assetContentType);
}
string ownerID = item.avatarID;
string creatorID = item.creatorID;
// Handle OpenSim profile anchors by rewriting non-UUID creatorIDs to the ownerID
// More information on (OSPA) profile anchors @ http://opensimulator.org/wiki/OpenSim_Profile_Anchors
UUID creatorUUID;
if (!UUID.TryParse(creatorID, out creatorUUID))
{
creatorID = ownerID;
}
NameValueCollection requestArgs = new NameValueCollection
{
{ "RequestMethod", "AddInventoryItem" },
{ "ItemID", item.inventoryID },
{ "AssetID", item.assetID },
{ "ParentID", parentFolderID },
{ "OwnerID", ownerID },
{ "Name", item.inventoryName },
{ "Description", item.inventoryDescription },
{ "CreatorID", creatorID },
{ "ContentType", invContentType },
{ "ExtraData", OSDParser.SerializeJsonString(extraData) }
};
OSDMap response = WebUtil.PostToService(m_inventoryUrl, requestArgs);
bool success = response["Success"].AsBoolean();
if (success)
{
// Gesture handling
if (assetType == AssetType.Gesture)
{
UpdateGesture(UUID.Parse(item.avatarID), UUID.Parse(item.inventoryID), item.flags == 1);
}
}
else
{
Console.WriteLine("Error creating item " + item.inventoryName + " for " + item.avatarID + ": " + response["Message"].AsString());
}
}
private void RezObject(IScriptInstance script, string inventory, Vector3 position, Vector3 vel, Quaternion rot, int param, bool atRoot)
{
// TODO: Test to make sure this actually rezzes from the root, and get the atRoot param working
// Can't do this without an IAssetClient
if (m_assetClient == null)
{
return;
}
// Sanity check the input rotation
if (Single.IsNaN(rot.X) || Single.IsNaN(rot.Y) || Single.IsNaN(rot.Z) || Single.IsNaN(rot.W))
{
return;
}
// Sanity check the distance, silently fail at > 10m
float dist = Vector3.Distance(script.Host.ScenePosition, position);
if (dist > 10.0f)
{
return;
}
if (script.Host is LLPrimitive)
{
LLPrimitive obj = (LLPrimitive)script.Host;
LLInventoryTaskItem item = obj.Inventory.FindItem(delegate(LLInventoryTaskItem match) { return(match.Name == inventory); });
if (item != null)
{
// Make sure this is an object
if (item.InventoryType != InventoryType.Object)
{
llSay(script, 0, "Unable to create requested object. Object is missing from database.");
return;
}
// Fetch the serialized linkset asset
Asset linksetAsset;
if (!m_assetClient.TryGetAsset(item.AssetID, LLUtil.LLAssetTypeToContentType((int)AssetType.Object), out linksetAsset))
{
llSay(script, 0, "Unable to create requested object. Object is missing from database.");
return;
}
// Deserialize the asset to LLSD
OSDMap linksetMap = null;
try { linksetMap = OSDParser.Deserialize(linksetAsset.Data) as OSDMap; }
catch (Exception ex) { m_log.Error("Failed to deserialize linkset from asset " + linksetAsset.ID + ": " + ex.Message); }
if (linksetMap == null)
{
llSay(script, 0, "Unable to create requested object. Object is corrupted in database.");
return;
}
// Deserialize the linkset
IList <LLPrimitive> linkset = LLPrimitive.DeserializeLinkset(linksetMap, obj.Scene, m_primMesher, true);
Vector3 velocity = vel;
Quaternion rotation = rot;
float velMag = velocity.Length();
float mass = (float)llGetMass(script);
// Rez the parent(s) first
for (int i = 0; i < linkset.Count; i++)
{
LLPrimitive prim = linkset[i];
if (prim.Parent == null)
{
// Objects rezzed with this method are DieAtEdge by default
prim.Prim.Flags |= PrimFlags.DieAtEdge;
// Set the position, rotation and velocity of the root prim in the scene
prim.RelativePosition = position;
prim.RelativeRotation = rotation;
if (prim.Prim.Flags.HasFlag(PrimFlags.Physics))
{
prim.FallStart = Util.TickCount();
prim.Velocity = velocity;
}
obj.Scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0);
m_log.Debug("Deserialized root prim " + prim.ID + " (" + prim.LocalID + ") from task inventory");
}
}
// Rez the children
for (int i = 0; i < linkset.Count; i++)
{
LLPrimitive prim = linkset[i];
if (prim.Parent != null)
{
obj.Scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0);
}
}
// FIXME: Post an object_rez event
if (obj.Prim.Flags.HasFlag(PrimFlags.Physics))
{
obj.FallStart = Util.TickCount();
// FIXME: Recoil
//llApplyImpulse(script, new lsl_vector(velocity.X * mass, velocity.Y * mass, velocity.Z * mass), 0);
}
// Variable script delay (http://wiki.secondlife.com/wiki/LSL_Delay)
script.AddSleepMS((int)((mass * velMag) * 0.1f));
script.AddSleepMS(200);
}
else
{
llSay(script, 0, "Could not find object " + inventory);
}
}
}