public void ChatterBoxSessionStartReply(UUID sessionID, string sessionName, int type,
bool voiceEnabled, bool voiceModerated, UUID tmpSessionID,
bool sucess, string error,
UUID toAgent)
{
osUTF8 sb = StartEvent("ChatterBoxSessionStartReply");
LLSDxmlEncode2.AddElem("session_id", sessionID, sb);
LLSDxmlEncode2.AddElem("temp_session_id", tmpSessionID, sb);
LLSDxmlEncode2.AddElem("success", sucess, sb);
if (sucess)
{
LLSDxmlEncode2.AddMap("session_info", sb);
LLSDxmlEncode2.AddMap("moderated_mode", sb);
LLSDxmlEncode2.AddElem("voice", voiceModerated, sb);
LLSDxmlEncode2.AddEndMap(sb);
LLSDxmlEncode2.AddElem("session_name", sessionName, sb);
LLSDxmlEncode2.AddElem("type", type, sb);
LLSDxmlEncode2.AddElem("voice_enabled", voiceEnabled, sb);
LLSDxmlEncode2.AddEndMap(sb);
}
else
{
LLSDxmlEncode2.AddElem("error", String.IsNullOrEmpty(error) ? "" : error, sb);
}
Enqueue(EndEventToBytes(sb), toAgent);
}
public virtual void CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
IPEndPoint newRegionExternalEndPoint,
string capsURL, UUID avatarID, UUID sessionID, int regionSizeX, int regionSizeY)
{
if (DebugLevel > 0)
{
m_log.DebugFormat("{0} CrossRegion. handle={1}, avatarID={2}, regionSize={3},{4}>",
LogHeader, handle, avatarID, regionSizeX, regionSizeY);
}
osUTF8 sb = StartEvent("CrossedRegion");
LLSDxmlEncode2.AddArrayAndMap("AgentData", sb);
LLSDxmlEncode2.AddElem("AgentID", avatarID, sb);
LLSDxmlEncode2.AddElem("SessionID", sessionID, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
LLSDxmlEncode2.AddArrayAndMap("Info", sb);
LLSDxmlEncode2.AddElem("LookAt", lookAt, sb);
LLSDxmlEncode2.AddElem("Position", pos, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
LLSDxmlEncode2.AddArrayAndMap("RegionData", sb);
LLSDxmlEncode2.AddElem("RegionHandle", handle, sb);
LLSDxmlEncode2.AddElem("SeedCapability", capsURL, sb);
LLSDxmlEncode2.AddElem("SimIP", newRegionExternalEndPoint.Address.GetAddressBytes(), sb);
LLSDxmlEncode2.AddElem("SimPort", newRegionExternalEndPoint.Port, sb);
LLSDxmlEncode2.AddElem("RegionSizeX", (uint)regionSizeX, sb);
LLSDxmlEncode2.AddElem("RegionSizeY", (uint)regionSizeY, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public void WindlightRefreshEvent(int interpolate, UUID avatarID)
{
osUTF8 sb = StartEvent("WindLightRefresh");
LLSDxmlEncode2.AddElem("Interpolate", interpolate > 0 ? 1 : 0, sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public void ChatterBoxSessionAgentListUpdates(UUID sessionID, UUID toAgent, List <GroupChatListAgentUpdateData> updates)
{
osUTF8 sb = StartEvent("ChatterBoxSessionAgentListUpdates", 1024);
LLSDxmlEncode2.AddMap("agent_updates", sb);
foreach (GroupChatListAgentUpdateData up in updates)
{
LLSDxmlEncode2.AddMap(up.agentID.ToString(), sb);
LLSDxmlEncode2.AddMap("info", sb);
LLSDxmlEncode2.AddElem("can_voice_chat", up.canVoice, sb);
LLSDxmlEncode2.AddElem("is_moderator", up.isModerator, sb);
LLSDxmlEncode2.AddMap("mutes", sb);
LLSDxmlEncode2.AddElem("text", up.mutedText, sb);
LLSDxmlEncode2.AddEndMap(sb); // mutes
LLSDxmlEncode2.AddEndMap(sb); // info
if (up.enterOrLeave)
{
LLSDxmlEncode2.AddElem("transition", "ENTER", sb);
}
else
{
LLSDxmlEncode2.AddElem("transition", "LEAVE", sb);
}
LLSDxmlEncode2.AddEndMap(sb); //agentid
}
LLSDxmlEncode2.AddEndMap(sb); // agent_updates
LLSDxmlEncode2.AddEmptyMap("updates", sb);
LLSDxmlEncode2.AddElem("session_id", sessionID, sb);
Enqueue(EndEventToBytes(sb), toAgent);
}
public void ToLLSDxml(osUTF8 lsl, uint flagsMask = 0xffffffff)
{
LLSDxmlEncode2.AddMap(lsl);
LLSDxmlEncode2.AddElem_parent_id(Folder, lsl);
LLSDxmlEncode2.AddElem("asset_id", AssetID, lsl);
LLSDxmlEncode2.AddElem("item_id", ID, lsl);
LLSDxmlEncode2.AddMap("permissions", lsl);
LLSDxmlEncode2.AddElem("creator_id", CreatorIdAsUuid, lsl);
LLSDxmlEncode2.AddElem_owner_id(Owner, lsl);
LLSDxmlEncode2.AddElem("group_id", GroupID, lsl);
LLSDxmlEncode2.AddElem("base_mask", (int)CurrentPermissions, lsl);
LLSDxmlEncode2.AddElem("owner_mask", (int)CurrentPermissions, lsl);
LLSDxmlEncode2.AddElem("group_mask", (int)GroupPermissions, lsl);
LLSDxmlEncode2.AddElem("everyone_mask", (int)EveryOnePermissions, lsl);
LLSDxmlEncode2.AddElem("next_owner_mask", (int)NextPermissions, lsl);
LLSDxmlEncode2.AddElem("is_owner_group", GroupOwned, lsl);
LLSDxmlEncode2.AddEndMap(lsl);
LLSDxmlEncode2.AddElem("type", AssetType, lsl);
LLSDxmlEncode2.AddElem("inv_type", InvType, lsl);
LLSDxmlEncode2.AddElem("flags", (int)(Flags & flagsMask), lsl);
LLSDxmlEncode2.AddMap("sale_info", lsl);
LLSDxmlEncode2.AddElem("sale_price", SalePrice, lsl);
LLSDxmlEncode2.AddElem("sale_type", SaleType, lsl);
LLSDxmlEncode2.AddEndMap(lsl);
LLSDxmlEncode2.AddElem_name(Name, lsl);
LLSDxmlEncode2.AddElem("desc", Description, lsl);
LLSDxmlEncode2.AddElem("created_at", CreationDate, lsl);
LLSDxmlEncode2.AddEndMap(lsl);
}
public void FetchInventorySimpleRequest(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap requestmap, ExpiringKey <UUID> BadRequests)
{
//m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capability request {0}", request);
if (BadRequests == null)
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
OSDArray itemsRequested = (OSDArray)requestmap["items"];
UUID[] itemIDs = new UUID[itemsRequested.Count];
int i = 0;
foreach (OSDMap osdItemId in itemsRequested)
{
UUID id = osdItemId["item_id"].AsUUID();
if (!BadRequests.ContainsKey(id))
{
itemIDs[i++] = id;
}
}
InventoryItemBase[] items = null;
try
{
// badrequests still not filled
items = m_inventoryService.GetMultipleItems(m_agentID, itemIDs);
}
catch { }
osUTF8 lsl = LLSDxmlEncode2.Start(4096);
LLSDxmlEncode2.AddMap(lsl);
LLSDxmlEncode2.AddElem("agent_id", m_agentID, lsl);
if (items == null || items.Length == 0)
{
LLSDxmlEncode2.AddEmptyArray("items", lsl);
}
else
{
LLSDxmlEncode2.AddArray("items", lsl);
foreach (InventoryItemBase item in items)
{
if (item != null)
{
item.ToLLSDxml(lsl, 0xff);
}
}
LLSDxmlEncode2.AddEndArray(lsl);
}
LLSDxmlEncode2.AddEndMap(lsl);
httpResponse.RawBuffer = LLSDxmlEncode2.EndToBytes(lsl);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
}
public void ChatterBoxForceClose(UUID toAgent, UUID sessionID, string reason)
{
osUTF8 sb = StartEvent("ForceCloseChatterBoxSession");
LLSDxmlEncode2.AddElem("session_id", sessionID, sb);
LLSDxmlEncode2.AddElem("reason", reason, sb);
Enqueue(EndEventToBytes(sb), toAgent);
}
public osUTF8 StartEvent(string eventName, int cap)
{
osUTF8 sb = OSUTF8Cached.Acquire(cap);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("message", eventName, sb);
LLSDxmlEncode2.AddMap("body", sb);
return(sb);
}
private void GetEnvironmentSettings(IOSHttpResponse response, UUID agentID)
{
// m_log.DebugFormat("[{0}]: Environment GET handle for agentID {1} in region {2}",
// Name, agentID, caps.RegionName);
ViewerEnvironment VEnv = null;
ScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null)
{
response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
response.AddHeader("Retry-After", "5");
return;
}
if (sp.Environment != null)
{
VEnv = sp.Environment;
}
else
{
if (m_scene.RegionInfo.EstateSettings.AllowEnvironmentOverride)
{
ILandObject land = m_scene.LandChannel.GetLandObject(sp.AbsolutePosition.X, sp.AbsolutePosition.Y);
if (land != null && land.LandData != null && land.LandData.Environment != null)
{
VEnv = land.LandData.Environment;
}
}
}
if (VEnv == null)
{
VEnv = GetRegionEnvironment();
}
byte[] envBytes = VEnv.ToCapWLBytes(UUID.Zero, regionID);
if (envBytes == null)
{
osUTF8 sb = LLSDxmlEncode2.Start();
LLSDxmlEncode2.AddArray(sb);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("messageID", UUID.Zero, sb);
LLSDxmlEncode2.AddElem("regionID", regionID, sb);
LLSDxmlEncode2.AddEndMap(sb);
LLSDxmlEncode2.AddEndArray(sb);
response.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
}
else
{
response.RawBuffer = envBytes;
}
response.StatusCode = (int)HttpStatusCode.OK;
}
public void SendBulkUpdateInventoryItem(InventoryItemBase item, UUID avatarID, UUID?transationID = null)
{
const uint FULL_MASK_PERMISSIONS = (uint)0x7ffffff;
osUTF8 sb = StartEvent("BulkUpdateInventory");
LLSDxmlEncode2.AddArray("AgentData", sb);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("AgentID", avatarID, sb);
LLSDxmlEncode2.AddElem("TransactionID", transationID ?? UUID.Random(), sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
LLSDxmlEncode2.AddRawElem("<key>FolderData</key><array><map><key>FolderID</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>Name</key><string></string><key>ParentID</key><uuid>00000000-0000-0000-0000-000000000000</uuid ><key>Type</key ><integer>-1</integer></map ></array>", sb);
osUTF8 osName = new osUTF8(Util.StringToBytesNoTerm(item.Name, 255));
osUTF8 osDesc = new osUTF8(Util.StringToBytesNoTerm(item.Description, 255));
LLSDxmlEncode2.AddArray("ItemData", sb);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("ItemID", item.ID, sb);
LLSDxmlEncode2.AddElem("AssetID", item.AssetID, sb);
LLSDxmlEncode2.AddElem("CreatorID", item.CreatorIdAsUuid, sb);
LLSDxmlEncode2.AddElem("BaseMask", item.BasePermissions, sb);
LLSDxmlEncode2.AddElem("CreationDate", item.CreationDate, sb);
LLSDxmlEncode2.AddElem("Description", osDesc, sb);
LLSDxmlEncode2.AddElem("EveryoneMask", item.EveryOnePermissions, sb);
LLSDxmlEncode2.AddElem("FolderID", item.Folder, sb);
LLSDxmlEncode2.AddElem("InvType", (sbyte)item.InvType, sb);
LLSDxmlEncode2.AddElem("Name", osName, sb);
LLSDxmlEncode2.AddElem("NextOwnerMask", item.NextPermissions, sb);
LLSDxmlEncode2.AddElem("GroupID", item.GroupID, sb);
LLSDxmlEncode2.AddElem("GroupMask", item.GroupPermissions, sb);
LLSDxmlEncode2.AddElem("GroupOwned", item.GroupOwned, sb);
LLSDxmlEncode2.AddElem("OwnerID", item.Owner, sb);
LLSDxmlEncode2.AddElem("OwnerMask", item.CurrentPermissions, sb);
LLSDxmlEncode2.AddElem("SalePrice", item.SalePrice, sb);
LLSDxmlEncode2.AddElem("SaleType", item.SaleType, sb);
LLSDxmlEncode2.AddElem("Type", (sbyte)item.AssetType, sb);
LLSDxmlEncode2.AddElem("CallbackID", (uint)0, sb);
LLSDxmlEncode2.AddElem("Flags", item.Flags & 0x2000ff, sb);
uint iCRC =
Helpers.InventoryCRC(1000, 0, (sbyte)item.InvType,
(sbyte)item.AssetType, item.AssetID,
item.GroupID, 100,
item.Owner, item.CreatorIdAsUuid,
item.ID, item.Folder,
FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,
FULL_MASK_PERMISSIONS);
LLSDxmlEncode2.AddElem("CRC", iCRC, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public static string KeepAliveEvent()
{
osUTF8 sb = new osUTF8(256);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("message", "FAKEEVENT", sb);
LLSDxmlEncode2.AddMap("body", sb);
LLSDxmlEncode2.AddEndMap(sb); // close body
LLSDxmlEncode2.AddEndMap(sb); // close event
return(sb.ToString());
}
public void ScriptRunningEvent(UUID objectID, UUID itemID, bool running, UUID avatarID)
{
osUTF8 sb = StartEvent("ScriptRunningReply");
LLSDxmlEncode2.AddArrayAndMap("Script", sb);
LLSDxmlEncode2.AddElem("ObjectID", objectID, sb);
LLSDxmlEncode2.AddElem("ItemID", itemID, sb);
LLSDxmlEncode2.AddElem("Running", running, sb);
LLSDxmlEncode2.AddElem("Mono", true, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public byte[] toLLSDxml(osUTF8 sb = null)
{
const float scale = 10000f;
bool fullLLSD = false;
if (sb == null)
{
sb = LLSDxmlEncode2.Start(1024, false);
fullLLSD = true;
}
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("NormMap", NormalMapID, sb);
LLSDxmlEncode2.AddElem("NormOffsetX", (int)(scale * NormalOffsetX + 0.5f), sb);
LLSDxmlEncode2.AddElem("NormOffsetY", (int)(scale * NormalOffsetY + 0.5f), sb);
LLSDxmlEncode2.AddElem("NormRepeatX", (int)(scale * NormalRepeatX + 0.5f), sb);
LLSDxmlEncode2.AddElem("NormRepeatY", (int)(scale * NormalRepeatY + 0.5f), sb);
LLSDxmlEncode2.AddElem("NormRotation", (int)(scale * NormalRotation + 0.5f), sb);
LLSDxmlEncode2.AddElem("SpecMap", SpecularMapID, sb);
LLSDxmlEncode2.AddElem("SpecOffsetX", (int)(scale * SpecularOffsetX + 0.5f), sb);
LLSDxmlEncode2.AddElem("SpecOffsetY", (int)(scale * SpecularOffsetY + 0.5f), sb);
LLSDxmlEncode2.AddElem("SpecRepeatX", (int)(scale * SpecularRepeatX + 0.5f), sb);
LLSDxmlEncode2.AddElem("SpecRepeatY", (int)(scale * SpecularRepeatY + 0.5f), sb);
LLSDxmlEncode2.AddElem("SpecRotation", (int)(scale * SpecularRotation + 0.5f), sb);
LLSDxmlEncode2.AddArray("SpecColor", sb);
LLSDxmlEncode2.AddElem(SpecularLightColorR, sb);
LLSDxmlEncode2.AddElem(SpecularLightColorG, sb);
LLSDxmlEncode2.AddElem(SpecularLightColorB, sb);
LLSDxmlEncode2.AddElem(255, sb);
LLSDxmlEncode2.AddEndArray(sb);
LLSDxmlEncode2.AddElem("SpecExp", SpecularLightExponent, sb);
LLSDxmlEncode2.AddElem("EnvIntensity", EnvironmentIntensity, sb);
LLSDxmlEncode2.AddElem("DiffuseAlphaMode", DiffuseAlphaMode, sb);
LLSDxmlEncode2.AddElem("AlphaMaskCutoff", AlphaMaskCutoff, sb);
LLSDxmlEncode2.AddEndMap(sb);
if (fullLLSD)
{
return(LLSDxmlEncode2.EndToBytes(sb));
}
else
{
return(Utils.EmptyBytes); // ignored if appending
}
}
public void partPhysicsProperties(uint localID, byte physhapetype,
float density, float friction, float bounce, float gravmod, UUID avatarID)
{
osUTF8 sb = StartEvent("ObjectPhysicsProperties");
LLSDxmlEncode2.AddArrayAndMap("ObjectData", sb);
LLSDxmlEncode2.AddElem("LocalID", (int)localID, sb);
LLSDxmlEncode2.AddElem("Density", density, sb);
LLSDxmlEncode2.AddElem("Friction", friction, sb);
LLSDxmlEncode2.AddElem("GravityMultiplier", gravmod, sb);
LLSDxmlEncode2.AddElem("Restitution", bounce, sb);
LLSDxmlEncode2.AddElem("PhysicsShapeType", (int)physhapetype, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public void ChatterboxInvitation(UUID sessionID, string sessionName,
UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
uint timeStamp, bool offline, int parentEstateID, Vector3 position,
uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
{
osUTF8 sb = StartEvent("ChatterBoxInvitation");
LLSDxmlEncode2.AddElem("session_id", sessionID, sb);
LLSDxmlEncode2.AddElem("from_name", fromName, sb);
LLSDxmlEncode2.AddElem("session_name", sessionName, sb);
LLSDxmlEncode2.AddElem("from_id", fromAgent, sb);
LLSDxmlEncode2.AddLLSD(InstantMessageBody(fromAgent, message, toAgent,
fromName, dialog, timeStamp, offline, parentEstateID, position,
ttl, transactionID, fromGroup, binaryBucket, true, 0, true), sb);
Enqueue(EndEventToBytes(sb), toAgent);
}
public void GroupMembershipData(UUID AgentID, GroupMembershipData[] data)
{
osUTF8 sb = StartEvent("AgentGroupDataUpdate");
LLSDxmlEncode2.AddArrayAndMap("AgentData", sb);
LLSDxmlEncode2.AddElem("AgentID", AgentID, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
if (data.Length == 0)
{
LLSDxmlEncode2.AddEmptyArray("GroupData", sb);
LLSDxmlEncode2.AddEmptyArray("NewGroupData", sb);
}
else
{
List <bool> lstInProfiles = new List <bool>(data.Length);
LLSDxmlEncode2.AddArray("GroupData", sb);
foreach (GroupMembershipData m in data)
{
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("GroupID", m.GroupID, sb);
LLSDxmlEncode2.AddElem("GroupPowers", m.GroupPowers, sb);
LLSDxmlEncode2.AddElem("AcceptNotices", m.AcceptNotices, sb);
LLSDxmlEncode2.AddElem("GroupInsigniaID", m.GroupPicture, sb);
LLSDxmlEncode2.AddElem("Contribution", m.Contribution, sb);
LLSDxmlEncode2.AddElem("GroupName", m.GroupName, sb);
LLSDxmlEncode2.AddEndMap(sb);
lstInProfiles.Add(m.ListInProfile);
}
LLSDxmlEncode2.AddEndArray(sb);
LLSDxmlEncode2.AddArray("NewGroupData", sb);
foreach (bool b in lstInProfiles)
{
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("ListInProfile", b, sb);
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
}
Enqueue(EndEventToBytes(sb), AgentID);
}
public virtual void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY)
{
if (DebugLevel > 0)
{
m_log.DebugFormat("{0} EnableSimulator. handle={1}, endPoint={2}, avatarID={3}",
LogHeader, handle, endPoint, avatarID, regionSizeX, regionSizeY);
}
osUTF8 sb = StartEvent("EnableSimulator");
LLSDxmlEncode2.AddArrayAndMap("SimulatorInfo", sb);
LLSDxmlEncode2.AddElem("Handle", handle, sb);
LLSDxmlEncode2.AddElem("IP", endPoint.Address.GetAddressBytes(), sb);
LLSDxmlEncode2.AddElem("Port", endPoint.Port, sb);
LLSDxmlEncode2.AddElem("RegionSizeX", (uint)regionSizeX, sb);
LLSDxmlEncode2.AddElem("RegionSizeY", (uint)regionSizeY, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public void PlacesQueryReply(UUID avatarID, UUID queryID, UUID transactionID, PlacesReplyData[] replyDataArray)
{
osUTF8 sb = new osUTF8(256);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("message", "PlacesReplyMessage", sb);
LLSDxmlEncode2.AddMap("QueryData[]", sb); LLSDxmlEncode2.AddArray(sb);
LLSDxmlEncode2.AddArray("AgentData", sb);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("AgentID", avatarID, sb);
LLSDxmlEncode2.AddElem("QueryID", queryID, sb);
LLSDxmlEncode2.AddElem("TransactionID", transactionID, sb);
LLSDxmlEncode2.AddEndMap(sb);
LLSDxmlEncode2.AddEndArray(sb);
LLSDxmlEncode2.AddArray("QueryData", sb);
for (int i = 0; i < replyDataArray.Length; ++i)
{
PlacesReplyData data = replyDataArray[i];
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("ActualArea", data.ActualArea, sb);
LLSDxmlEncode2.AddElem("BillableArea", data.BillableArea, sb);
LLSDxmlEncode2.AddElem("Description", data.Desc, sb);
LLSDxmlEncode2.AddElem("Dwell", data.Dwell, sb);
LLSDxmlEncode2.AddElem("Flags", data.Flags, sb);
LLSDxmlEncode2.AddElem("GlobalX", data.GlobalX, sb);
LLSDxmlEncode2.AddElem("GlobalY", data.GlobalY, sb);
LLSDxmlEncode2.AddElem("GlobalZ", data.GlobalZ, sb);
LLSDxmlEncode2.AddElem("Name", data.Name, sb);
LLSDxmlEncode2.AddElem("OwnerID", data.OwnerID, sb);
LLSDxmlEncode2.AddElem("SimName", data.SimName, sb);
LLSDxmlEncode2.AddElem("SnapShotID", data.SnapshotID, sb);
LLSDxmlEncode2.AddElem("ProductSku", (int)0, sb);
LLSDxmlEncode2.AddElem("Price", data.Price, sb);
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
public virtual void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, string capsPath,
ulong regionHandle, int regionSizeX, int regionSizeY)
{
if (DebugLevel > 0)
{
m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, endPoint={2}, avatarID={3}",
LogHeader, regionHandle, endPoint, avatarID, regionSizeX, regionSizeY);
}
osUTF8 sb = StartEvent("EstablishAgentCommunication");
LLSDxmlEncode2.AddElem("agent-id", avatarID, sb);
LLSDxmlEncode2.AddElem("sim-ip-and-port", endPoint.ToString(), sb);
LLSDxmlEncode2.AddElem("seed-capability", capsPath, sb);
// current viewers ignore this, also not needed its sent on enablesim
//LLSDxmlEncode2.AddElem("region-handle", regionHandle, sb);
//LLSDxmlEncode2.AddElem("region-size-x", (uint)regionSizeX, sb);
//LLSDxmlEncode2.AddElem("region-size-y", (uint)regionSizeY, sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
private static string InstantMessageBody(UUID fromAgent, string message, UUID toAgent,
string fromName, byte dialog, uint timeStamp, bool offline, int parentEstateID,
Vector3 position, uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket,
bool checkEstate, int godLevel, bool limitedToEstate)
{
osUTF8 sb = new osUTF8(512);
LLSDxmlEncode2.AddMap("instantmessage", sb);
LLSDxmlEncode2.AddMap("message_params", sb); //messageParams
LLSDxmlEncode2.AddElem("type", dialog, sb);
LLSDxmlEncode2.AddElem("position", position, sb);
LLSDxmlEncode2.AddElem("region_id", UUID.Zero, sb);
LLSDxmlEncode2.AddElem("to_id", toAgent, sb);
LLSDxmlEncode2.AddElem("source", 0, sb);
LLSDxmlEncode2.AddMap("data", sb); //messageParams data
LLSDxmlEncode2.AddElem("binary_bucket", binaryBucket, sb);
LLSDxmlEncode2.AddEndMap(sb); //messageParams data
LLSDxmlEncode2.AddElem("message", message, sb);
LLSDxmlEncode2.AddElem("id", transactionID, sb);
LLSDxmlEncode2.AddElem("from_name", fromName, sb);
LLSDxmlEncode2.AddElem("timestamp", timeStamp, sb);
LLSDxmlEncode2.AddElem("offline", (offline ? 1 : 0), sb);
LLSDxmlEncode2.AddElem("parent_estate_id", parentEstateID, sb);
LLSDxmlEncode2.AddElem("ttl", (int)ttl, sb);
LLSDxmlEncode2.AddElem("from_id", fromAgent, sb);
LLSDxmlEncode2.AddElem("from_group", fromGroup, sb);
LLSDxmlEncode2.AddEndMap(sb); //messageParams
LLSDxmlEncode2.AddMap("agent_params", sb);
LLSDxmlEncode2.AddElem("agent_id", fromAgent, sb);
LLSDxmlEncode2.AddElem("check_estate", checkEstate, sb);
LLSDxmlEncode2.AddElem("god_level", godLevel, sb);
LLSDxmlEncode2.AddElem("limited_to_estate", limitedToEstate, sb);
LLSDxmlEncode2.AddEndMap(sb); // agent params
LLSDxmlEncode2.AddEndMap(sb);
return(sb.ToString());
}
public virtual void TeleportFinishEvent(ulong regionHandle, byte simAccess,
IPEndPoint regionExternalEndPoint,
uint locationID, uint flags, string capsURL,
UUID avatarID, int regionSizeX, int regionSizeY)
{
if (DebugLevel > 0)
{
m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, endPoint={2}, avatarID={3}",
LogHeader, regionHandle, regionExternalEndPoint, avatarID, regionSizeX, regionSizeY);
}
// not sure why flags get overwritten here
if ((flags & (uint)TeleportFlags.IsFlying) != 0)
{
flags = (uint)TeleportFlags.ViaLocation | (uint)TeleportFlags.IsFlying;
}
else
{
flags = (uint)TeleportFlags.ViaLocation;
}
osUTF8 sb = StartEvent("TeleportFinish");
LLSDxmlEncode2.AddArrayAndMap("Info", sb);
LLSDxmlEncode2.AddElem("AgentID", avatarID, sb);
LLSDxmlEncode2.AddElem("LocationID", (uint)4, sb); // TODO what is this?
LLSDxmlEncode2.AddElem("SimIP", regionExternalEndPoint.Address.GetAddressBytes(), sb);
LLSDxmlEncode2.AddElem("SimPort", regionExternalEndPoint.Port, sb);
LLSDxmlEncode2.AddElem("RegionHandle", regionHandle, sb);
LLSDxmlEncode2.AddElem("SeedCapability", capsURL, sb);
LLSDxmlEncode2.AddElem("SimAccess", (int)simAccess, sb);
LLSDxmlEncode2.AddElem("TeleportFlags", flags, sb);
LLSDxmlEncode2.AddElem("RegionSizeX", (uint)regionSizeX, sb);
LLSDxmlEncode2.AddElem("RegionSizeY", (uint)regionSizeY, sb);
LLSDxmlEncode2.AddEndMapAndArray(sb);
Enqueue(EndEventToBytes(sb), avatarID);
}
private void DeleteExtEnvironmentSettings(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID)
{
int parcel = -1;
if (httpRequest.Query.Count > 0)
{
if (httpRequest.Query.ContainsKey("parcelid"))
{
Int32.TryParse((string)httpRequest.Query["parcelid"], out parcel);
}
}
if (parcel == -1)
{
StoreOnRegion(null);
WindlightRefresh(0);
}
else
{
ILandObject land = m_scene.LandChannel.GetLandObject(parcel);
if (land != null && land.LandData != null)
{
land.StoreEnvironment(null);
WindlightRefresh(0, false);
}
}
osUTF8 sb = LLSDxmlEncode2.Start();
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("messageID", UUID.Zero, sb);
LLSDxmlEncode2.AddElem("regionID", regionID, sb);
LLSDxmlEncode2.AddElem("success", true, sb);
LLSDxmlEncode2.AddEndMap(sb);
httpResponse.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
}
private void SetExtEnvironmentSettings(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID, Caps caps)
{
bool success = false;
string message = "Could not process request";
int parcel = -1;
int track = -1;
osUTF8 sb = LLSDxmlEncode2.Start();
ScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null || sp.IsChildAgent || sp.IsNPC)
{
message = "Could not locate your avatar";
goto Error;
}
if (httpRequest.Query.Count > 0)
{
if (httpRequest.Query.ContainsKey("parcelid"))
{
if (!Int32.TryParse((string)httpRequest.Query["parcelid"], out parcel))
{
message = "Failed to decode request";
goto Error;
}
}
if (httpRequest.Query.ContainsKey("trackno"))
{
if (!Int32.TryParse((string)httpRequest.Query["trackno"], out track))
{
message = "Failed to decode request";
goto Error;
}
}
if (track != -1)
{
message = "Environment Track not supported";
goto Error;
}
}
ViewerEnvironment VEnv = m_scene.RegionEnvironment;
ILandObject lchannel;
if (parcel == -1)
{
if (!m_scene.Permissions.CanIssueEstateCommand(agentID, false))
{
message = "Insufficient estate permissions, settings has not been saved.";
goto Error;
}
VEnv = m_scene.RegionEnvironment;
lchannel = null;
}
else
{
lchannel = m_landChannel.GetLandObject(parcel);
if (lchannel == null || lchannel.LandData == null)
{
message = "Could not locate requested parcel";
goto Error;
}
if (!m_scene.Permissions.CanEditParcelProperties(agentID, lchannel, GroupPowers.AllowEnvironment, true)) // wrong
{
message = "No permission to change parcel environment";
goto Error;
}
VEnv = lchannel.LandData.Environment;
}
try
{
OSD req = OSDParser.Deserialize(httpRequest.InputStream);
if (req is OSDMap)
{
OSDMap map = req as OSDMap;
if (map.TryGetValue("environment", out OSD env))
{
if (VEnv == null)
{
// need a proper clone
VEnv = m_DefaultEnv.Clone();
}
OSDMap evmap = env as OSDMap;
if (evmap.TryGetValue("day_asset", out OSD tmp) && !evmap.ContainsKey("day_cycle"))
{
string id = tmp.AsString();
AssetBase asset = m_assetService.Get(id);
if (asset == null || asset.Data == null || asset.Data.Length == 0)
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
try
{
OSD oenv = OSDParser.Deserialize(asset.Data);
evmap.TryGetValue("day_name", out tmp);
if (tmp is OSDString)
{
VEnv.FromAssetOSD(tmp.AsString(), oenv);
}
else
{
VEnv.FromAssetOSD(null, oenv);
}
}
catch
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
else
{
VEnv.FromOSD(env);
}
if (lchannel == null)
{
StoreOnRegion(VEnv);
m_log.InfoFormat("[{0}]: ExtEnvironment region {1} settings from agentID {2} saved",
Name, caps.RegionName, agentID);
}
else
{
lchannel.StoreEnvironment(VEnv);
m_log.InfoFormat("[{0}]: ExtEnvironment parcel {1} of region {2} settings from agentID {3} saved",
Name, parcel, caps.RegionName, agentID);
}
WindlightRefresh(0, lchannel == null);
success = true;
}
}
else if (req is OSDArray)
{
VEnv = new ViewerEnvironment();
VEnv.FromWLOSD(req);
StoreOnRegion(VEnv);
success = true;
WindlightRefresh(0);
m_log.InfoFormat("[{0}]: ExtEnvironment region {1} settings from agentID {2} saved",
Name, caps.RegionName, agentID);
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("messageID", UUID.Zero, sb);
LLSDxmlEncode2.AddElem("regionID", regionID, sb);
LLSDxmlEncode2.AddElem("success", success, sb);
LLSDxmlEncode2.AddEndMap(sb);
httpResponse.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
return;
}
}
catch (Exception e)
{
m_log.ErrorFormat("[{0}]: ExtEnvironment settings not saved for region {1}, Exception: {2} - {3}",
Name, caps.RegionName, e.Message, e.StackTrace);
success = false;
message = String.Format("ExtEnvironment Set for region {0} has failed, settings not saved.", caps.RegionName);
}
Error:
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("success", success, sb);
if (!success)
{
LLSDxmlEncode2.AddElem("message", message, sb);
}
LLSDxmlEncode2.AddEndMap(sb);
httpResponse.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
httpResponse.StatusCode = (int)HttpStatusCode.OK;
}
/// <summary>
/// Callback for a client request for ParcelVoiceInfo
/// </summary>
/// <param name="scene">current scene object of the client</param>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <param name="agentID"></param>
/// <param name="caps"></param>
/// <returns></returns>
public void ParcelVoiceInfoRequest(IOSHttpRequest request, IOSHttpResponse response, UUID agentID, Scene scene)
{
if (request.HttpMethod != "POST")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
response.StatusCode = (int)HttpStatusCode.OK;
m_log.DebugFormat(
"[FreeSwitchVoice][PARCELVOICE]: ParcelVoiceInfoRequest() on {0} for {1}",
scene.RegionInfo.RegionName, agentID);
ScenePresence avatar = scene.GetScenePresence(agentID);
if (avatar == null)
{
response.RawBuffer = Util.UTF8.GetBytes("<llsd>undef</llsd>");
return;
}
string avatarName = avatar.Name;
// - check whether we have a region channel in our cache
// - if not:
// create it and cache it
// - send it to the client
// - send channel_uri: as "sip:regionID@m_sipDomain"
try
{
string channelUri;
if (null == scene.LandChannel)
{
m_log.ErrorFormat("region \"{0}\": avatar \"{1}\": land data not yet available",
scene.RegionInfo.RegionName, avatarName);
response.RawBuffer = Util.UTF8.GetBytes("<llsd>undef</llsd>");
return;
}
// get channel_uri: check first whether estate
// settings allow voice, then whether parcel allows
// voice, if all do retrieve or obtain the parcel
// voice channel
LandData land = scene.GetLandData(avatar.AbsolutePosition);
//m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": request: {4}, path: {5}, param: {6}",
// scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, request, path, param);
// TODO: EstateSettings don't seem to get propagated...
if (!scene.RegionInfo.EstateSettings.AllowVoice)
{
m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": voice not enabled in estate settings",
scene.RegionInfo.RegionName);
channelUri = String.Empty;
}
else
if (!scene.RegionInfo.EstateSettings.TaxFree && (land.Flags & (uint)ParcelFlags.AllowVoiceChat) == 0)
{
// m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": voice not enabled for parcel",
// scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName);
channelUri = String.Empty;
}
else
{
channelUri = ChannelUri(scene, land);
}
// fast foward encode
osUTF8 lsl = LLSDxmlEncode2.Start(512);
LLSDxmlEncode2.AddMap(lsl);
LLSDxmlEncode2.AddElem("parcel_local_id", land.LocalID, lsl);
LLSDxmlEncode2.AddElem("region_name", scene.Name, lsl);
LLSDxmlEncode2.AddMap("voice_credentials", lsl);
LLSDxmlEncode2.AddElem("channel_uri", channelUri, lsl);
//LLSDxmlEncode2.AddElem("channel_credentials", channel_credentials, lsl);
LLSDxmlEncode2.AddEndMap(lsl);
LLSDxmlEncode2.AddEndMap(lsl);
response.RawBuffer = LLSDxmlEncode2.EndToBytes(lsl);
}
catch (Exception e)
{
m_log.ErrorFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2}, retry later",
scene.RegionInfo.RegionName, avatarName, e.Message);
m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": avatar \"{1}\": {2} failed",
scene.RegionInfo.RegionName, avatarName, e.ToString());
response.RawBuffer = Util.UTF8.GetBytes("<llsd>undef</llsd>");
}
}
/// <summary>
/// Callback for a client request for Voice Account Details
/// </summary>
/// <param name="scene">current scene object of the client</param>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <param name="agentID"></param>
/// <param name="caps"></param>
/// <returns></returns>
public void ProvisionVoiceAccountRequest(IOSHttpRequest request, IOSHttpResponse response, UUID agentID, Scene scene)
{
if (request.HttpMethod != "POST")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
m_log.DebugFormat(
"[FreeSwitchVoice][PROVISIONVOICE]: ProvisionVoiceAccountRequest() request for {0}", agentID.ToString());
response.StatusCode = (int)HttpStatusCode.OK;
ScenePresence avatar = scene.GetScenePresence(agentID);
if (avatar == null)
{
System.Threading.Thread.Sleep(2000);
avatar = scene.GetScenePresence(agentID);
if (avatar == null)
{
response.RawBuffer = Util.UTF8.GetBytes("<llsd>undef</llsd>");
return;
}
}
string avatarName = avatar.Name;
try
{
//XmlElement resp;
string agentname = "x" + Convert.ToBase64String(agentID.GetBytes());
string password = "******";//temp hack//new UUID(Guid.NewGuid()).ToString().Replace('-','Z').Substring(0,16);
// XXX: we need to cache the voice credentials, as
// FreeSwitch is later going to come and ask us for
// those
agentname = agentname.Replace('+', '-').Replace('/', '_');
lock (m_UUIDName)
{
if (m_UUIDName.ContainsKey(agentname))
{
m_UUIDName[agentname] = avatarName;
}
else
{
m_UUIDName.Add(agentname, avatarName);
}
}
string accounturl = String.Format("http://{0}:{1}{2}/", m_openSimWellKnownHTTPAddress,
m_freeSwitchServicePort, m_freeSwitchAPIPrefix);
// fast foward encode
osUTF8 lsl = LLSDxmlEncode2.Start();
LLSDxmlEncode2.AddMap(lsl);
LLSDxmlEncode2.AddElem("username", agentname, lsl);
LLSDxmlEncode2.AddElem("password", password, lsl);
LLSDxmlEncode2.AddElem("voice_sip_uri_hostname", m_freeSwitchRealm, lsl);
LLSDxmlEncode2.AddElem("voice_account_server_name", accounturl, lsl);
LLSDxmlEncode2.AddEndMap(lsl);
response.RawBuffer = LLSDxmlEncode2.EndToBytes(lsl);
}
catch (Exception e)
{
m_log.ErrorFormat("[FreeSwitchVoice][PROVISIONVOICE]: avatar \"{0}\": {1}, retry later", avatarName, e.Message);
m_log.DebugFormat("[FreeSwitchVoice][PROVISIONVOICE]: avatar \"{0}\": {1} failed", avatarName, e.ToString());
response.RawBuffer = osUTF8.GetASCIIBytes("<llsd>undef</llsd>");
}
}
public void ProcessRequest(IOSHttpRequest request, IOSHttpResponse response, UUID AgentId)
{
if (request.HttpMethod != "GET")
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
ScenePresence avatar;
if (!m_scene.TryGetScenePresence(AgentId, out avatar) || m_scene.RegionInfo == null || m_scene.RegionInfo.EstateSettings == null)
{
response.StatusCode = (int)HttpStatusCode.Gone;
return;
}
if (!m_scene.Permissions.CanIssueEstateCommand(AgentId, false))
{
response.StatusCode = (int)HttpStatusCode.Unauthorized;
return;
}
EstateSettings regionSettings = m_scene.RegionInfo.EstateSettings;
UUID[] managers = regionSettings.EstateManagers;
UUID[] allowed = regionSettings.EstateAccess;
UUID[] groups = regionSettings.EstateGroups;
EstateBan[] EstateBans = regionSettings.EstateBans;
osUTF8 sb = LLSDxmlEncode2.Start();
LLSDxmlEncode2.AddMap(sb);
if (allowed != null && allowed.Length > 0)
{
LLSDxmlEncode2.AddArray("AllowedAgents", sb);
for (int i = 0; i < allowed.Length; ++i)
{
UUID id = allowed[i];
if (id == UUID.Zero)
{
continue;
}
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("id", id, sb);
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
}
else
{
LLSDxmlEncode2.AddEmptyArray("AllowedAgents", sb);
}
if (groups != null && groups.Length > 0)
{
LLSDxmlEncode2.AddArray("AllowedGroups", sb);
for (int i = 0; i < groups.Length; ++i)
{
UUID id = groups[i];
if (id == UUID.Zero)
{
continue;
}
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("id", id, sb);
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
}
else
{
LLSDxmlEncode2.AddEmptyArray("AllowedGroups", sb);
}
if (EstateBans != null && EstateBans.Length > 0)
{
LLSDxmlEncode2.AddArray("BannedAgents", sb);
for (int i = 0; i < EstateBans.Length; ++i)
{
EstateBan ban = EstateBans[i];
UUID id = ban.BannedUserID;
if (id == UUID.Zero)
{
continue;
}
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("id", id, sb);
LLSDxmlEncode2.AddElem("banning_id", ban.BanningUserID, sb);
LLSDxmlEncode2.AddElem("last_login_date", "na", sb); // We will not have this. This information is far at grid
if (ban.BanTime == 0)
{
LLSDxmlEncode2.AddElem("ban_date", "0000-00-00 00:00", sb);
}
else
{
LLSDxmlEncode2.AddElem("ban_date", (Util.ToDateTime(ban.BanTime)).ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture), sb);
}
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
}
else
{
LLSDxmlEncode2.AddEmptyArray("BannedAgents", sb);
}
if (managers != null && managers.Length > 0)
{
LLSDxmlEncode2.AddArray("Managers", sb);
for (int i = 0; i < managers.Length; ++i)
{
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("agent_id", managers[i], sb);
LLSDxmlEncode2.AddEndMap(sb);
}
LLSDxmlEncode2.AddEndArray(sb);
}
else
{
LLSDxmlEncode2.AddEmptyArray("Managers", sb);
}
LLSDxmlEncode2.AddEndMap(sb);
response.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
response.StatusCode = (int)HttpStatusCode.OK;
}
public void FetchInventoryDescendentsRequest(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, ExpiringKey <UUID> BadRequests)
{
//m_log.DebugFormat("[XXX]: FetchInventoryDescendentsRequest in {0}, {1}", (m_Scene == null) ? "none" : m_Scene.Name, request);
List <LLSDFetchInventoryDescendents> folders = null;
List <UUID> bad_folders = new List <UUID>();
try
{
OSDArray foldersrequested = null;
OSD tmp = OSDParser.DeserializeLLSDXml(httpRequest.InputStream);
httpRequest.InputStream.Dispose();
OSDMap map = (OSDMap)tmp;
if (map.TryGetValue("folders", out tmp) && tmp is OSDArray)
{
foldersrequested = tmp as OSDArray;
}
if (foldersrequested == null || foldersrequested.Count == 0)
{
httpResponse.RawBuffer = EmptyResponse;
return;
}
folders = new List <LLSDFetchInventoryDescendents>(foldersrequested.Count);
for (int i = 0; i < foldersrequested.Count; i++)
{
OSDMap mfolder = foldersrequested[i] as OSDMap;
UUID id = mfolder["folder_id"].AsUUID();
if (BadRequests.ContainsKey(id))
{
bad_folders.Add(id);
}
else
{
LLSDFetchInventoryDescendents llsdRequest = new LLSDFetchInventoryDescendents();
try
{
llsdRequest.folder_id = id;
llsdRequest.owner_id = mfolder["owner_id"].AsUUID();
llsdRequest.sort_order = mfolder["sort_order"].AsInteger();
llsdRequest.fetch_folders = mfolder["fetch_folders"].AsBoolean();
llsdRequest.fetch_items = mfolder["fetch_items"].AsBoolean();
}
catch (Exception e)
{
m_log.Debug("[WEB FETCH INV DESC HANDLER]: caught exception doing OSD deserialize" + e.Message);
continue;
}
folders.Add(llsdRequest);
}
}
foldersrequested = null;
map.Clear();
map = null;
}
catch (Exception e)
{
m_log.ErrorFormat("[FETCH INV DESC]: fail parsing request: {0}", e.Message);
httpResponse.RawBuffer = EmptyResponse;
return;
}
if (folders == null || folders.Count == 0)
{
if (bad_folders.Count == 0)
{
httpResponse.RawBuffer = EmptyResponse;
return;
}
osUTF8 osu = OSUTF8Cached.Acquire();
osu.AppendASCII("[WEB FETCH INV DESC HANDLER]: Unable to fetch folders owned by Unknown user:"******" ...");
}
m_log.Warn(osu.ToString());
}
osu.Clear();
osu.AppendASCII("<llsd><map><key>folders</key><array /></map><map><key>bad_folders</key><array>");
foreach (UUID bad in bad_folders)
{
osu.AppendASCII("<map><key>folder_id</key><uuid>");
osu.AppendASCII(bad.ToString());
osu.AppendASCII("</uuid><key>error</key><string>Unknown</string></map>");
}
osu.AppendASCII("</array></map></llsd>");
httpResponse.RawBuffer = OSUTF8Cached.GetArrayAndRelease(osu);
return;
}
int total_folders = 0;
int total_items = 0;
UUID requester = folders[0].owner_id;
List <InventoryCollection> invcollSet = Fetch(folders, bad_folders, ref total_folders, ref total_items);
//m_log.DebugFormat("[XXX]: Got {0} folders from a request of {1}", invcollSet.Count, folders.Count);
int invcollSetCount = 0;
if (invcollSet != null)
{
invcollSetCount = invcollSet.Count;
}
int mem = 8192 + ((256 * invcollSetCount +
384 * total_folders +
1024 * total_items +
128 * bad_folders.Count) & 0x7ffff000);
osUTF8 lastresponse = LLSDxmlEncode2.Start(mem);
if (invcollSetCount > 0)
{
lastresponse.AppendASCII("<map><key>folders</key><array>");
int i = 0;
InventoryCollection thiscoll;
for (i = 0; i < invcollSetCount; i++)
{
thiscoll = invcollSet[i];
invcollSet[i] = null;
LLSDxmlEncode2.AddMap(lastresponse);
LLSDxmlEncode2.AddElem_agent_id(thiscoll.OwnerID, lastresponse);
LLSDxmlEncode2.AddElem("descendents", thiscoll.Descendents, lastresponse);
LLSDxmlEncode2.AddElem_folder_id(thiscoll.FolderID, lastresponse);
if (thiscoll.Folders == null || thiscoll.Folders.Count == 0)
{
LLSDxmlEncode2.AddEmptyArray("categories", lastresponse);
}
else
{
LLSDxmlEncode2.AddArray("categories", lastresponse);
foreach (InventoryFolderBase invFolder in thiscoll.Folders)
{
LLSDxmlEncode2.AddMap(lastresponse);
LLSDxmlEncode2.AddElem_folder_id(invFolder.ID, lastresponse);
LLSDxmlEncode2.AddElem_parent_id(invFolder.ParentID, lastresponse);
LLSDxmlEncode2.AddElem_name(invFolder.Name, lastresponse);
LLSDxmlEncode2.AddElem("type", invFolder.Type, lastresponse);
LLSDxmlEncode2.AddElem("preferred_type", (int)-1, lastresponse);
LLSDxmlEncode2.AddElem("version", invFolder.Version, lastresponse);
LLSDxmlEncode2.AddEndMap(lastresponse);
}
LLSDxmlEncode2.AddEndArray(lastresponse);
}
if (thiscoll.Items == null || thiscoll.Items.Count == 0)
{
LLSDxmlEncode2.AddEmptyArray("items", lastresponse);
}
else
{
LLSDxmlEncode2.AddArray("items", lastresponse);
foreach (InventoryItemBase invItem in thiscoll.Items)
{
invItem.ToLLSDxml(lastresponse);
}
LLSDxmlEncode2.AddEndArray(lastresponse);
}
LLSDxmlEncode2.AddElem_owner_id(thiscoll.OwnerID, lastresponse);
LLSDxmlEncode2.AddElem("version", thiscoll.Version, lastresponse);
LLSDxmlEncode2.AddEndMap(lastresponse);
invcollSet[i] = null;
}
LLSDxmlEncode2.AddEndArrayAndMap(lastresponse);
thiscoll = null;
}
else
{
lastresponse.AppendASCII("<map><key>folders</key><array /></map>");
}
if (bad_folders.Count > 0)
{
lastresponse.AppendASCII("<map><key>bad_folders</key><array>");
foreach (UUID bad in bad_folders)
{
BadRequests.Add(bad);
lastresponse.AppendASCII("<map><key>folder_id</key><uuid>");
lastresponse.AppendASCII(bad.ToString());
lastresponse.AppendASCII("</uuid><key>error</key><string>Unknown</string></map>");
}
lastresponse.AppendASCII("</array></map>");
StringBuilder sb = osStringBuilderCache.Acquire();
sb.Append("[WEB FETCH INV DESC HANDLER]: Unable to fetch folders owned by ");
sb.Append(requester.ToString());
sb.Append(" :");
int limit = 9;
foreach (UUID bad in bad_folders)
{
sb.Append(" ");
sb.Append(bad.ToString());
if (--limit < 0)
{
break;
}
}
if (limit < 0)
{
sb.Append(" ...");
}
m_log.Warn(osStringBuilderCache.GetStringAndRelease(sb));
}
httpResponse.RawBuffer = LLSDxmlEncode2.EndToBytes(lastresponse);
}
public string FetchInventoryRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
//m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capability request {0}", request);
OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
OSDArray itemsRequested = (OSDArray)requestmap["items"];
UUID[] itemIDs = new UUID[itemsRequested.Count];
int i = 0;
foreach (OSDMap osdItemId in itemsRequested)
{
itemIDs[i++] = osdItemId["item_id"].AsUUID();
}
InventoryItemBase[] items = null;
if (m_agentID != UUID.Zero)
{
items = m_inventoryService.GetMultipleItems(m_agentID, itemIDs);
}
else
{
items = new InventoryItemBase[itemsRequested.Count];
foreach (UUID id in itemIDs)
{
items[i++] = m_inventoryService.GetItem(UUID.Zero, id);
}
}
osUTF8 lsl = LLSDxmlEncode2.Start(4096);
LLSDxmlEncode2.AddMap(lsl);
if (m_agentID == UUID.Zero && items.Length > 0)
{
LLSDxmlEncode2.AddElem("agent_id", items[0].Owner, lsl);
}
else
{
LLSDxmlEncode2.AddElem("agent_id", m_agentID, lsl);
}
if (items == null || items.Length == 0)
{
LLSDxmlEncode2.AddEmptyArray("items", lsl);
}
else
{
LLSDxmlEncode2.AddArray("items", lsl);
foreach (InventoryItemBase item in items)
{
if (item != null)
{
item.ToLLSDxml(lsl, 0xff);
}
}
LLSDxmlEncode2.AddEndArray(lsl);
}
LLSDxmlEncode2.AddEndMap(lsl);
return(LLSDxmlEncode2.End(lsl));
}
public byte[] EndEventToBytes(osUTF8 sb)
{
LLSDxmlEncode2.AddEndMap(sb); // close body
LLSDxmlEncode2.AddEndMap(sb); // close event
return(OSUTF8Cached.GetArrayAndRelease(sb));
}
private void SetEnvironmentSettings(IOSHttpRequest request, IOSHttpResponse response, UUID agentID)
{
// m_log.DebugFormat("[{0}]: Environment SET handle from agentID {1} in region {2}",
// Name, agentID, caps.RegionName);
bool success = false;
string fail_reason = "";
if (!m_scene.Permissions.CanIssueEstateCommand(agentID, false))
{
fail_reason = "Insufficient estate permissions, settings has not been saved.";
goto Error;
}
ScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null || sp.IsChildAgent || sp.IsNPC)
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
if (sp.Environment != null)
{
fail_reason = "The environment you see is a forced one. Disable if on control object or tp out and back to region";
goto Error;
}
ILandObject land = m_scene.LandChannel.GetLandObject(sp.AbsolutePosition.X, sp.AbsolutePosition.Y);
if (land != null && land.LandData != null && land.LandData.Environment != null)
{
fail_reason = "The parcel where you are has own environment set. You need a updated viewer to change environment";
goto Error;
}
try
{
ViewerEnvironment VEnv = new ViewerEnvironment();
OSD env = OSDParser.Deserialize(request.InputStream);
VEnv.FromWLOSD(env);
StoreOnRegion(VEnv);
WindlightRefresh(0);
m_log.InfoFormat("[{0}]: New Environment settings has been saved from agentID {1} in region {2}",
Name, agentID, m_scene.Name);
success = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[{0}]: Environment settings has not been saved for region {1}, Exception: {2} - {3}",
Name, m_scene.Name, e.Message, e.StackTrace);
success = false;
fail_reason = String.Format("Environment Set for region {0} has failed, settings not saved.", m_scene.Name);
}
Error:
osUTF8 sb = LLSDxmlEncode2.Start();
LLSDxmlEncode2.AddMap(sb);
LLSDxmlEncode2.AddElem("messageID", UUID.Zero, sb);
LLSDxmlEncode2.AddElem("regionID", regionID, sb);
LLSDxmlEncode2.AddElem("success", success, sb);
if (!success)
{
LLSDxmlEncode2.AddElem("fail_reason", fail_reason, sb);
}
LLSDxmlEncode2.AddEndMap(sb);
response.RawBuffer = LLSDxmlEncode2.EndToBytes(sb);
response.StatusCode = (int)HttpStatusCode.OK;
}
