private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
// Detaching attachments doesn't work for HG visitors,
// so I'm giving that up.
//Util.FireAndForget(delegate { DetachAttachments(agentID); });
}
else
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
}
// OBSOLETE: not used now that RestHandler does ParameterSets
public OMVSD.OSD ProcessGet(Uri uri, string after)
{
OMVSD.OSDMap ret = new OMVSD.OSDMap();
if (m_comm == null)
{
m_log.Log(LogLevel.DBADERROR, "GET WITHOUT COMM CONNECTION!! URL=" + uri.ToString());
return(new OMVSD.OSD());
}
m_log.Log(LogLevel.DCOMMDETAIL, "Parameter request: {0}", uri.ToString());
string[] segments = after.Split('/');
// the after should be "/NAME/param" where "NAME" is my apiname. If 'param' is there return one
if (segments.Length > 2)
{
string paramName = segments[2];
if (m_comm.ConnectionParams.HasParameter(paramName))
{
ret.Add(paramName, new OMVSD.OSDString(m_comm.ConnectionParams.ParamString(paramName)));
}
}
else
{
// they want the whole set
ret = m_comm.ConnectionParams.GetDisplayable();
}
return(ret);
}
private OMVSD.OSDMap MapizeTheBody(string body)
{
OMVSD.OSDMap retMap = new OMVSD.OSDMap();
if (body.Length > 0 && body.Substring(0, 1).Equals("{")) // kludge test for JSON formatted body
{
try {
retMap = (OMVSD.OSDMap)OMVSD.OSDParser.DeserializeJson(body);
}
catch (Exception e) {
m_log.Log(LogLevel.DREST, "Failed parsing of JSON body: " + e.ToString());
}
}
else
{
try {
string[] amp = body.Split('&');
if (amp.Length > 0)
{
foreach (string kvp in amp)
{
string[] kvpPieces = kvp.Split('=');
if (kvpPieces.Length == 2)
{
retMap.Add(kvpPieces[0].Trim(), new OMVSD.OSDString(kvpPieces[1].Trim()));
}
}
}
}
catch (Exception e) {
m_log.Log(LogLevel.DREST, "Failed parsing of query body: " + e.ToString());
}
}
return(retMap);
}
private string HandleUntrustedSimulatorMessage(string request,
string path, string param, IOSHttpRequest httpRequest,
IOSHttpResponse httpResponse)
{
OSDMap osd = (OSDMap)OSDParser.DeserializeLLSDXml(request);
string message = osd["message"].AsString();
if (message == "GodKickUser")
{
OSDMap body = (OSDMap)osd["body"];
OSDArray userInfo = (OSDArray)body["UserInfo"];
OSDMap userData = (OSDMap)userInfo[0];
UUID agentID = userData["AgentID"].AsUUID();
UUID godID = userData["GodID"].AsUUID();
UUID godSessionID = userData["GodSessionID"].AsUUID();
uint kickFlags = userData["KickFlags"].AsUInteger();
string reason = userData["Reason"].AsString();
ScenePresence god = m_scene.GetScenePresence(godID);
if (god == null || god.ControllingClient.SessionId != godSessionID)
{
return(String.Empty);
}
KickUser(godID, godSessionID, agentID, kickFlags, Util.StringToBytes1024(reason));
}
else
{
m_log.ErrorFormat("[GOD]: Unhandled UntrustedSimulatorMessage: {0}", message);
}
return(String.Empty);
}
/// <summary>
/// Posting to this communication instance. The URI comes in as "/api/MYNAME/ACTION" where
/// ACTION is "login", "logout".
/// </summary>
/// <param name="uri"></param>
/// <param name="body"></param>
/// <returns></returns>
public OMVSD.OSD ProcessPost(RestHandler handler, Uri uri, string after, OMVSD.OSD body)
{
OMVSD.OSDMap ret = new OMVSD.OSDMap();
if (m_comm == null)
{
m_log.Log(LogLevel.DBADERROR, "POST WITHOUT COMM CONNECTION!! URL=" + uri.ToString());
return(new OMVSD.OSD());
}
m_log.Log(LogLevel.DCOMMDETAIL, "Post action: {0}", uri.ToString());
switch (after)
{
case "/login":
ret = PostActionLogin(body);
break;
case "/teleport":
ret = PostActionTeleport(body);
break;
case "/logout":
ret = PostActionLogout(body);
break;
case "/exit":
ret = PostActionExit(body);
break;
default:
m_log.Log(LogLevel.DBADERROR, "UNKNOWN ACTION: " + uri.ToString());
ret.Add(RestHandler.RESTREQUESTERRORCODE, new OMVSD.OSDInteger(1));
ret.Add(RestHandler.RESTREQUESTERRORMSG, new OMVSD.OSDString("Unknown action"));
break;
}
return(ret);
}
public ParameterSet()
{
m_params = new OMVSD.OSDMap();
m_paramDescription = new OMVSD.OSDMap();
ParamErrorMethod = paramErrorType.eNullValue;
m_runtimeValues = new Dictionary <string, ParameterSetRuntimeValue>();
}
public string FetchInventoryRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
// m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capabilty request");
OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
OSDArray itemsRequested = (OSDArray)requestmap["items"];
string reply;
LLSDFetchInventory llsdReply = new LLSDFetchInventory();
foreach (OSDMap osdItemId in itemsRequested)
{
UUID itemId = osdItemId["item_id"].AsUUID();
InventoryItemBase item = m_inventoryService.GetItem(new InventoryItemBase(itemId, m_agentID));
if (item != null)
{
// We don't know the agent that this request belongs to so we'll use the agent id of the item
// which will be the same for all items.
llsdReply.agent_id = item.Owner;
llsdReply.items.Array.Add(ConvertInventoryItem(item));
}
}
reply = LLSDHelpers.SerialiseLLSDReply(llsdReply);
return(reply);
}
public static void GetMeshVertexCount(byte[] data, out int vertex_count)
{
vertex_count = 0;
try
{
long start = 0;
OSDMap map = TryExtractOSDMapFromLLSDBinary(ref start, data);
if (map.ContainsKey("high_lod"))
{
map = (OSDMap)map["high_lod"];
OSDArray lod_data = DecodeMeshLODArray(data, start, map);
foreach (OSD subMeshOsd in lod_data)
{
// We get a list of faces. Sum each "face"
if (subMeshOsd is OSDMap)
{
vertex_count += DecodeMeshFace(subMeshOsd as OSDMap);
}
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[MESH]: exception meshing object: {0}", e);
vertex_count = 0;
}
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
if (!m_Enabled)
{
return;
}
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
}
else
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
}
/// <summary>
/// A statistics collection returns an OSD structure which is a map
/// of maps. The top level map are the individual counters and
/// their value is a map of the variables that make up the counter.
/// </summary>
/// <returns></returns>
public OMVSD.OSDMap GetDisplayable()
{
OMVSD.OSDMap values = new OMVSD.OSDMap();
foreach (ICounter cntr in m_counters)
{
try {
OMVSD.OSDMap ivals = new OMVSD.OSDMap();
ivals.Add("count", new OMVSD.OSDInteger((int)cntr.Count));
if (cntr is IIntervalCounter)
{
IIntervalCounter icntr = (IIntervalCounter)cntr;
ivals.Add("average", new OMVSD.OSDInteger((int)icntr.Average));
ivals.Add("low", new OMVSD.OSDInteger((int)icntr.Low));
ivals.Add("high", new OMVSD.OSDInteger((int)icntr.High));
ivals.Add("last", new OMVSD.OSDInteger((int)icntr.Last));
ivals.Add("total", new OMVSD.OSDInteger((int)icntr.Total));
}
values.Add(cntr.Name, ivals);
}
catch (Exception e) {
Logging.LogManager.Log.Log(LookingGlass.Framework.Logging.LogLevel.DBADERROR,
"FAILURE getting Displayable value: n={0}, {1}", cntr.Name, e.ToString());
}
}
return(values);
}
public string RenderMaterialsPostCap(string request, UUID agentID)
{
OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
OSDArray respArr = new OSDArray();
if (req.ContainsKey("Zipped"))
{
byte[] inBytes = req["Zipped"].AsBinary();
try
{
OSD osd = ZDecompressBytesToOsd(inBytes);
if (osd == null)
{
m_log.Warn("[MaterialsModule]: Decoded Materials request is empty");
}
else if (osd is OSDArray) // assume array of MaterialIDs designating requested material entries
{
ReturnRequestedMaterials(ref respArr, osd as OSDArray);
}
else if (osd is OSDMap) // request to assign a material
{
AssignRequestedMaterials(osd as OSDMap, agentID);
}
}
catch (Exception e)
{
m_log.Warn("[RenderMaterials]: exception decoding zipped CAP payload: " + e.ToString());
}
}
resp["Zipped"] = ZCompressOSD(respArr, false);
return(OSDParser.SerializeLLSDXmlString(resp));
}
private OMVSD.OSD GetHandler(RestHandler handler, Uri uri, String after)
{
OMVSD.OSDMap ret = new OMVSD.OSDMap();
string lastDate = "xx";
lock (m_chats) {
while (m_chats.Count > 0)
{
ChatEntry ce = m_chats.Dequeue();
string dateString = ce.time.ToString("yyyyMMddhhmmssfff");
OMVSD.OSDMap chat = new OMVSD.OSDMap();
chat.Add("Time", new OMVSD.OSDString(dateString));
chat.Add("From", new OMVSD.OSDString(ce.fromName));
chat.Add("Message", new OMVSD.OSDString(ce.message));
chat.Add("Type", new OMVSD.OSDString(ce.chatTypeString));
chat.Add("EntryType", new OMVSD.OSDString(ChatEntryTypeString[(int)ce.chatEntryType]));
chat.Add("Position", new OMVSD.OSDString(ce.position.ToString()));
if (ce.ownerID != null)
{
chat.Add("OwnerID", new OMVSD.OSDString(ce.ownerID.ToString()));
}
while (ret.ContainsKey(dateString))
{
dateString += "1";
}
ret.Add(dateString, chat);
lastDate = dateString;
}
}
return(ret);
}
public ParameterSet()
{
m_params = new OMVSD.OSDMap();
m_paramDescription = new OMVSD.OSDMap();
ParamErrorMethod = paramErrorType.eNullValue;
m_runtimeValues = new Dictionary<string, ParameterSetRuntimeValue>();
}
protected string GetObjectPhysicsDataHandler(string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
// m_log.DebugFormat("[ASSETCAPS] Got a GetObjectPhysicsData Packet {0}.", request);
OSDMap resp = new OSDMap();
OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
OSDArray itemsRequested = (OSDArray)requestmap["object_ids"];
foreach (OSDUUID osdItemId in itemsRequested)
{
UUID itemId = osdItemId.AsUUID();
SceneObjectPart item = m_Scene.GetSceneObjectPart(itemId);
if ((item != null) && (item.PhysActor != null))
{
Physics.Manager.IMaterial material = item.PhysActor.Properties.Material;
OSDMap object_data = new OSDMap();
object_data["PhysicsShapeType"] = (byte)item.Shape.PreferredPhysicsShape; // obj.PhysicsShapeType;
object_data["Density"] = material.Density; // obj.Density;
object_data["Friction"] = material.StaticFriction; // obj.Friction;
object_data["Restitution"] = material.Restitution; // obj.Restitution;
object_data["GravityMultiplier"] = 1.0f; // material.obj.GravityModifier;
resp[itemId.ToString()] = object_data;
}
}
string response = OSDParser.SerializeLLSDXmlString(resp);
// m_log.DebugFormat("[ASSETCAPS] Sending a GetObjectPhysicsData Response {0}.", response);
return(response);
}
public static void GetMeshLODByteCounts(byte[] mesh_data, out int hibytes, out int midbytes, out int lowbytes, out int lowestbytes)
{
hibytes = 0;
midbytes = 0;
lowbytes = 0;
lowestbytes = 0;
try
{
long start = 0;
OSDMap lodData = SceneObjectPartMeshCost.TryExtractOSDMapFromLLSDBinary(ref start, mesh_data);
// Stash the data we need to recalculate streaming cost on scale changes.
if (lodData.ContainsKey("high_lod"))
{
hibytes = ((OSDMap)lodData["high_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("medium_lod"))
{
midbytes = ((OSDMap)lodData["medium_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("low_lod"))
{
lowbytes = ((OSDMap)lodData["low_lod"])["size"].AsInteger();
}
if (lodData.ContainsKey("lowest_lod"))
{
lowestbytes = ((OSDMap)lodData["lowest_lod"])["size"].AsInteger();
}
}
catch (Exception e)
{
m_log.ErrorFormat("[MESH]: exception extracting LOD ByteCounts: {0}", e);
}
}
private static OSDArray WrapOSDMap(OSDMap wrapMe)
{
OSDArray array = new OSDArray();
array.Add(wrapMe);
return(array);
}
/// <summary>
/// A funny little static routine to read in a parameter set. You pass it the delegate
/// that is called to actually add the key/value to the ParameterSet.
/// </summary>
/// <param name="inFile"></param>
/// <param name="storeParam"></param>
public static bool ReadParameterSet(string inFile, InsertParam storeParam)
{
bool ret = true;
if (File.Exists(inFile))
{
try {
using (Stream inStream = new FileStream(inFile, FileMode.Open)) {
if (inFile.EndsWith(".json"))
{
// READ JSON
OMVSD.OSD parms = OMVSD.OSDParser.DeserializeJson(inStream);
if (parms.Type == OpenMetaverse.StructuredData.OSDType.Map)
{
OMVSD.OSDMap mapParms = (OMVSD.OSDMap)parms;
foreach (KeyValuePair <string, OMVSD.OSD> kvp in mapParms)
{
storeParam(kvp.Key, kvp.Value);
}
}
else
{
LogManager.Log.Log(LogLevel.DBADERROR, "AppParameters: CONFIG FILE WAS NOT A JSON MAP");
ret = false;
}
}
else
{
// READ INI
using (StreamReader sr = new StreamReader(inStream)) {
string inLine;
while ((inLine = sr.ReadLine()) != null)
{
int pos = inLine.IndexOf(";");
string desc = null;
if (pos >= 0)
{
desc = inLine.Substring(pos + 1).Trim();
inLine = inLine.Substring(0, pos);
}
pos = inLine.IndexOf("=");
if (pos >= 0)
{
string key = inLine.Substring(0, pos).Trim();
string value = inLine.Substring(pos + 1).Trim();
storeParam(key, new OMVSD.OSDString(value));
}
}
}
}
}
}
catch (Exception e) {
LogManager.Log.Log(LogLevel.DBADERROR, "AppParameters: FAILURE PARSING CONFIG FILE'"
+ inFile + "':" + e.ToString());
ret = false;
}
}
return(ret);
}
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"];
string reply;
LLSDFetchInventory llsdReply = new LLSDFetchInventory();
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);
if (items == null)
{
// OMG!!! One by one!!! This is fallback code, in case the backend isn't updated
m_log.WarnFormat("[FETCH INVENTORY HANDLER]: GetMultipleItems failed. Falling back to fetching inventory items one by one.");
items = new InventoryItemBase[itemsRequested.Count];
foreach (UUID id in itemIDs)
{
items[i++] = m_inventoryService.GetItem(m_agentID, id);
}
}
}
else
{
items = new InventoryItemBase[itemsRequested.Count];
foreach (UUID id in itemIDs)
{
items[i++] = m_inventoryService.GetItem(UUID.Zero, id);
}
}
foreach (InventoryItemBase item in items)
{
if (item != null)
{
// We don't know the agent that this request belongs to so we'll use the agent id of the item
// which will be the same for all items.
llsdReply.agent_id = item.Owner;
llsdReply.items.Array.Add(ConvertInventoryItem(item));
}
}
reply = LLSDHelpers.SerialiseLLSDReply(llsdReply);
return(reply);
}
public OMVSD.OSDMap GetDisplayable()
{
OMVSD.OSDMap aMap = new OMVSD.OSDMap();
aMap.Add("Name", new OMVSD.OSDString(this.Name));
aMap.Add("Total", new OMVSD.OSDInteger((int)this.TotalQueued));
aMap.Add("Current", new OMVSD.OSDInteger((int)this.CurrentQueued));
return(aMap);
}
public OSD HandleRemoteMapItemRequest(string path, OSD request, string endpoint)
{
uint xstart = 0;
uint ystart = 0;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out xstart, out ystart);
OSDMap responsemap = new OSDMap();
List <ScenePresence> avatars = m_scene.GetAvatars();
OSDArray responsearr = new OSDArray(avatars.Count);
OSDMap responsemapdata = new OSDMap();
int tc = Environment.TickCount;
/*
* foreach (ScenePresence av in avatars)
* {
* responsemapdata = new OSDMap();
* responsemapdata["X"] = OSD.FromInteger((int)(xstart + av.AbsolutePosition.X));
* responsemapdata["Y"] = OSD.FromInteger((int)(ystart + av.AbsolutePosition.Y));
* responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
* responsemapdata["Name"] = OSD.FromString("TH");
* responsemapdata["Extra"] = OSD.FromInteger(0);
* responsemapdata["Extra2"] = OSD.FromInteger(0);
* responsearr.Add(responsemapdata);
* }
* responsemap["1"] = responsearr;
*/
if (avatars.Count == 0)
{
responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + 1));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + 1));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(0);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
responsemap["6"] = responsearr;
}
else
{
responsearr = new OSDArray(avatars.Count);
foreach (ScenePresence av in avatars)
{
responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + av.AbsolutePosition.X));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + av.AbsolutePosition.Y));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(1);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
}
responsemap["6"] = responsearr;
}
return(responsemap);
}
public override void FromOSD(OpenMetaverse.StructuredData.OSDMap map)
{
GlobalPosX = map["GlobalPosX"];
GlobalPosY = map["GlobalPosY"];
LandData = new LandData();
LandData.FromOSD((OSDMap)map["LandData"]);
RegionName = map["RegionName"];
RegionType = map["RegionType"];
}
/// <summary>
/// Sends the mapitem response to the IClientAPI
/// </summary>
/// <param name="response">The OSDMap Response for the mapitem</param>
private void RequestMapItemsCompleted(IAsyncResult iar)
{
AsyncResult result = (AsyncResult)iar;
RequestMapItemsDelegate icon = (RequestMapItemsDelegate)result.AsyncDelegate;
OSDMap response = (OSDMap)icon.EndInvoke(iar);
Interlocked.Decrement(ref nAsyncRequests);
if (!response.ContainsKey("requestID"))
{
return;
}
UUID requestID = response["requestID"].AsUUID();
if (requestID != UUID.Zero)
{
MapRequestState mrs = new MapRequestState();
mrs.agentID = UUID.Zero;
lock (m_openRequests)
{
if (m_openRequests.ContainsKey(requestID))
{
mrs = m_openRequests[requestID];
m_openRequests.Remove(requestID);
}
}
if (mrs.agentID != UUID.Zero)
{
ScenePresence av = null;
m_scene.TryGetScenePresence(mrs.agentID, out av);
if (av != null)
{
if (response.ContainsKey(mrs.itemtype.ToString()))
{
List <mapItemReply> returnitems = new List <mapItemReply>();
OSDArray itemarray = (OSDArray)response[mrs.itemtype.ToString()];
for (int i = 0; i < itemarray.Count; i++)
{
OSDMap mapitem = (OSDMap)itemarray[i];
mapItemReply mi = new mapItemReply();
mi.x = (uint)mapitem["X"].AsInteger();
mi.y = (uint)mapitem["Y"].AsInteger();
mi.id = mapitem["ID"].AsUUID();
mi.Extra = mapitem["Extra"].AsInteger();
mi.Extra2 = mapitem["Extra2"].AsInteger();
mi.name = mapitem["Name"].AsString();
returnitems.Add(mi);
}
av.ControllingClient.SendMapItemReply(returnitems.ToArray(), mrs.itemtype, mrs.flags);
}
}
}
}
}
/// <summary>
/// Receive parcel voice cap
/// </summary>
/// <param name="client"></param>
/// <param name="result"></param>
/// <param name="error"></param>
void pCap_OnComplete(OpenMetaverse.Http.CapsClient client,
OpenMetaverse.StructuredData.OSD result,
Exception error)
{
parcelCap.OnComplete -=
new OpenMetaverse.Http.CapsClient.CompleteCallback(pCap_OnComplete);
parcelCap = null;
if (error != null)
{
Logger.Log("Region voice cap " + error.Message, Helpers.LogLevel.Error);
return;
}
OpenMetaverse.StructuredData.OSDMap pMap = result as OpenMetaverse.StructuredData.OSDMap;
regionName = pMap["region_name"].AsString();
ReportConnectionState(ConnectionState.RegionCapAvailable);
if (pMap.ContainsKey("voice_credentials"))
{
OpenMetaverse.StructuredData.OSDMap cred =
pMap["voice_credentials"] as OpenMetaverse.StructuredData.OSDMap;
if (cred.ContainsKey("channel_uri"))
{
spatialUri = cred["channel_uri"].AsString();
}
if (cred.ContainsKey("channel_credentials"))
{
spatialCredentials = cred["channel_credentials"].AsString();
}
}
if (spatialUri == null || spatialUri == "")
{
// "No voice chat allowed here");
return;
}
Logger.Log("Voice connecting for region " + regionName, Helpers.LogLevel.Info);
// STEP 5
int reqId = SessionCreate(
accountHandle,
spatialUri, // uri
"", // Channel name seems to be always null
spatialCredentials, // spatialCredentials, // session password
true, // Join Audio
false, // Join Text
"");
if (reqId < 0)
{
Logger.Log("Voice Session ReqID " + reqId.ToString(), Helpers.LogLevel.Error);
}
}
protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
// m_log.DebugFormat("[GET_DISPLAY_NAMES]: called {0}", httpRequest.Url.Query);
NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
string[] ids = query.GetValues("ids");
if (m_UserManagement == null)
{
m_log.Error("[GET_DISPLAY_NAMES]: Cannot fetch display names without a user management component");
httpResponse.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return(new byte[0]);
}
OSDMap osdReply = new OSDMap();
OSDArray agents = new OSDArray();
osdReply["agents"] = agents;
foreach (string id in ids)
{
UUID uuid = UUID.Zero;
if (UUID.TryParse(id, out uuid))
{
string name = m_UserManagement.GetUserName(uuid);
if (!string.IsNullOrEmpty(name))
{
string[] parts = name.Split(new char[] { ' ' });
OSDMap osdname = new OSDMap();
// a date that is valid
// osdname["display_name_next_update"] = OSD.FromDate(new DateTime(1970,1,1));
// but send one that blocks edition, since we actually don't suport this
osdname["display_name_next_update"] = OSD.FromDate(DateTime.UtcNow.AddDays(8));
osdname["display_name_expires"] = OSD.FromDate(DateTime.UtcNow.AddMonths(1));
osdname["display_name"] = OSD.FromString(name);
osdname["legacy_first_name"] = parts[0];
osdname["legacy_last_name"] = parts[1];
osdname["username"] = OSD.FromString(name);
osdname["id"] = OSD.FromUUID(uuid);
osdname["is_display_name_default"] = OSD.FromBoolean(true);
agents.Add(osdname);
}
}
}
// Full content request
httpResponse.StatusCode = (int)System.Net.HttpStatusCode.OK;
//httpResponse.ContentLength = ??;
httpResponse.ContentType = "application/llsd+xml";
string reply = OSDParser.SerializeLLSDXmlString(osdReply);
return(System.Text.Encoding.UTF8.GetBytes(reply));
}
/// <summary>
/// Assign a single material value. Based on the values passed we'll either set (or clear) the materials for a SOP.
/// </summary>
/// <param name="sop">The SOP being affected.</param>
/// <param name="face">The face to assign, or -1 if the default texture is being set.</param>
/// <param name="id">The ID assigned to this material. Setting a Zero UUID clears it.</param>
/// <param name="material">If not null, the material to set. Otherwise we are clearing.</param>
private void AssignSingleMaterial(SceneObjectPart sop, int face, OSDMap matData)
{
UUID id = UUID.Zero;
// If there is a material being set, see if we've seen it before.
// If not we'll add it to the Shape RenderMaterials and the region cache
if (matData != null)
{
RenderMaterial material = RenderMaterial.FromOSD(matData);
id = sop.Shape.RenderMaterials.AddMaterial(material);
m_scene.EventManager.TriggerRenderMaterialAddedToPrim(sop, id, material);
m_log.DebugFormat("[RenderMaterials]: SOP {0}, Face {1}, Adding RenderMaterial {2}",
sop.LocalId, face, material.ToString());
}
// If the new material is replacing one lets record it so we can clean up
UUID oldMaterialID = UUID.Zero;
/// Get a copy of the texture entry so we can make changes.
var te = new Primitive.TextureEntry(sop.Shape.TextureEntry, 0, sop.Shape.TextureEntry.Length);
// Set the Material ID in the TextureEntry. If face is ALL_SIDES then
// set the default entry, otherwise fetch the face and set it there.
if (face < 0)
{
oldMaterialID = te.DefaultTexture.MaterialID;
te.DefaultTexture.MaterialID = id;
}
else
{
var faceEntry = te.CreateFace((uint)face);
oldMaterialID = faceEntry.MaterialID;
faceEntry.MaterialID = id;
}
// Update the texture entry which will force an update to connected clients
sop.UpdateTexture(te);
// If the material has changed and it wasn't previously Zero
// Deallocate the old value if its not in use and signal the change
if ((oldMaterialID != id) &&
(oldMaterialID != UUID.Zero))
{
var currentMaterialIDs = sop.Shape.GetMaterialIDs();
if (currentMaterialIDs.Contains(oldMaterialID) == false)
{
if (sop.Shape.RenderMaterials.ContainsMaterial(oldMaterialID) == true)
{
sop.Shape.RenderMaterials.RemoveMaterial(oldMaterialID);
}
m_scene.EventManager.TriggerRenderMaterialRemovedFromPrim(sop, oldMaterialID);
}
}
}
/// <summary>
/// Fire the events registered for this event type asynchronously
/// </summary>
/// <param name="capsEvent">Capability name</param>
/// <param name="body">Decoded event body</param>
/// <param name="simulator">Reference to the simulator that
/// generated this event</param>
internal void BeginRaiseEvent(string capsEvent, StructuredData.OSD body, Simulator simulator)
{
bool specialHandler = false;
Caps.EventQueueCallback callback;
// Default handler first, if one exists
if (_EventTable.TryGetValue(String.Empty, out callback))
{
if (callback != null)
{
CapsCallbackWrapper wrapper;
wrapper.Callback = callback;
wrapper.CapsEvent = capsEvent;
wrapper.Body = body;
wrapper.Simulator = simulator;
ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
}
}
// Generic parser next, don't generic parse events we've manually registered for
if (body.Type == StructuredData.OSDType.Map && !_EventTable.ContainsKey(capsEvent))
{
StructuredData.OSDMap map = (StructuredData.OSDMap)body;
Packet packet = Packet.BuildPacket(capsEvent, map);
if (packet != null)
{
NetworkManager.IncomingPacket incomingPacket;
incomingPacket.Simulator = simulator;
incomingPacket.Packet = packet;
Logger.DebugLog("Serializing " + packet.Type.ToString() + " capability with generic handler", Client);
Client.Network.PacketInbox.Enqueue(incomingPacket);
specialHandler = true;
}
}
// Explicit handler next
if (_EventTable.TryGetValue(capsEvent, out callback) && callback != null)
{
CapsCallbackWrapper wrapper;
wrapper.Callback = callback;
wrapper.CapsEvent = capsEvent;
wrapper.Body = body;
wrapper.Simulator = simulator;
ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
specialHandler = true;
}
if (!specialHandler)
{
Logger.Log("Unhandled CAPS event " + capsEvent, Helpers.LogLevel.Warning, Client);
}
}
/// <summary>
/// Assign The requested materials to the specified part(s).
/// </summary>
/// <param name="materialsFromViewer"></param>
private void AssignRequestedMaterials(OSDMap materialsFromViewer, UUID agentID)
{
if (!(materialsFromViewer.ContainsKey("FullMaterialsPerFace") &&
(materialsFromViewer["FullMaterialsPerFace"] is OSDArray)))
{
m_log.Warn("[RenderMaterials]: AssignRequestedMaterials - FullMaterialsPerFace not defined or incorrect type");
return;
}
OSDArray mats = materialsFromViewer["FullMaterialsPerFace"] as OSDArray;
foreach (OSDMap matsMap in mats)
{
uint matLocalID = 0;
int face = -1;
OSDMap matData = null;
try
{
matLocalID = matsMap["ID"].AsUInteger();
if (matsMap.ContainsKey("Face"))
{
face = matsMap["Face"].AsInteger();
}
if (matsMap.ContainsKey("Material"))
{
matData = matsMap["Material"] as OSDMap;
}
}
catch (Exception e)
{
m_log.Warn("[RenderMaterials]: cannot decode material from matsMap: " + e.Message);
continue;
}
/// Look up the scene object this material pertains to.
var sop = m_scene.GetSceneObjectPart(matLocalID);
if (sop == null)
{
m_log.Warn("[RenderMaterials]: null SOP for localId: " + matLocalID.ToString());
continue;
}
// Make sure we can modify it
if (m_scene.Permissions.CanEditObject(sop.ParentGroup.UUID, agentID, (uint)PermissionMask.Modify) == false)
{
m_log.WarnFormat("[RenderMaterials]: User {0} can't edit object {1} {2}",
agentID, sop.ParentGroup.Name, sop.ParentGroup.UUID);
continue;
}
AssignSingleMaterial(sop, face, matData);
}
}
public override OSD ToOSDMap()
{
OSDMap map = new OSDMap();
map["reason"] = OSD.FromString(m_key);
map["message"] = OSD.FromString(m_value);
map["login"] = OSD.FromString(m_login);
return(map);
}
protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
// m_log.DebugFormat("[GET_DISPLAY_NAMES]: called {0}", httpRequest.Url.Query);
NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
string[] ids = query.GetValues("ids");
if (m_UserManagement == null)
{
m_log.Error("[GET_DISPLAY_NAMES]: Cannot fetch display names without a user management component");
httpResponse.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return new byte[0];
}
OSDMap osdReply = new OSDMap();
OSDArray agents = new OSDArray();
osdReply["agents"] = agents;
foreach (string id in ids)
{
UUID uuid = UUID.Zero;
if (UUID.TryParse(id, out uuid))
{
string name = m_UserManagement.GetUserName(uuid);
if (!string.IsNullOrEmpty(name))
{
string[] parts = name.Split(new char[] {' '});
OSDMap osdname = new OSDMap();
// a date that is valid
// osdname["display_name_next_update"] = OSD.FromDate(new DateTime(1970,1,1));
// but send one that blocks edition, since we actually don't suport this
osdname["display_name_next_update"] = OSD.FromDate(DateTime.UtcNow.AddDays(8));
osdname["display_name_expires"] = OSD.FromDate(DateTime.UtcNow.AddMonths(1));
osdname["display_name"] = OSD.FromString(name);
osdname["legacy_first_name"] = parts[0];
osdname["legacy_last_name"] = parts[1];
osdname["username"] = OSD.FromString(name);
osdname["id"] = OSD.FromUUID(uuid);
osdname["is_display_name_default"] = OSD.FromBoolean(true);
agents.Add(osdname);
}
}
}
// Full content request
httpResponse.StatusCode = (int)System.Net.HttpStatusCode.OK;
//httpResponse.ContentLength = ??;
httpResponse.ContentType = "application/llsd+xml";
string reply = OSDParser.SerializeLLSDXmlString(osdReply);
return System.Text.Encoding.UTF8.GetBytes(reply);
}
/// <summary>
/// Converts a list of primitives to an object that can be serialized
/// with the LLSD system
/// </summary>
/// <param name="prims">Primitives to convert to a serializable object</param>
/// <returns>An object that can be serialized with LLSD</returns>
public static StructuredData.OSD PrimListToOSD(List <Primitive> prims)
{
StructuredData.OSDMap map = new OpenMetaverse.StructuredData.OSDMap(prims.Count);
foreach (Primitive prim in prims)
{
map.Add(prim.LocalID.ToString(), prim.GetOSD());
}
return(map);
}
public override OSD ToOSDMap()
{
OSDMap map = new OSDMap();
map["reason"] = OSD.FromString("rsa_request");
map["key"] = OSD.FromString(m_key);
map["token"] = OSD.FromString(m_password);
map["login"] = OSD.FromString("false");
return(map);
}
/// <summary>
/// Converts a list of primitives to an object that can be serialized
/// with the LLSD system
/// </summary>
/// <param name="prims">Primitives to convert to a serializable object</param>
/// <returns>An object that can be serialized with LLSD</returns>
public static StructuredData.OSD PrimListToOSD(List <Primitive> prims)
{
StructuredData.OSDMap map = new OpenMetaverse.StructuredData.OSDMap(prims.Count);
for (int i = 0; i < prims.Count; i++)
{
map.Add(prims[i].LocalID.ToString(), prims[i].GetOSD());
}
return(map);
}
private static OSDArray DecodeMeshLODArray(byte[] data, long start, OSDMap meshMap)
{
int offset = meshMap["offset"].AsInteger() + (int)start;
int size = meshMap["size"].AsInteger();
if (offset < 0 || size == 0)
return null; // no mesh data in asset
try
{
using (MemoryStream inMs = new MemoryStream(data, offset, size))
{
/*
* Skipping past the first two bytes, which are part of the zlib specification
* (RFC 1950), not the deflate specification (RFC 1951). Those bytes contain
* information about the compression method and flags.
*/
int streamType = inMs.ReadByte();
int streamFlags = inMs.ReadByte();
using (MemoryStream outMs = new MemoryStream())
{
using (DeflateStream zOut = new DeflateStream(inMs, CompressionMode.Decompress))
{
zOut.CopyTo(outMs);
byte[] decompressedBuf = outMs.ToArray();
return OSDParser.DeserializeLLSDBinary(decompressedBuf) as OSDArray;
}
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[MESH]: exception decoding OSD: {0}", e);
}
return null;
}
/// <summary>
/// A statistics collection returns an OSD structure which is a map
/// of maps. The top level map are the individual counters and
/// their value is a map of the variables that make up the counter.
/// </summary>
/// <returns></returns>
public OMVSD.OSDMap GetDisplayable()
{
OMVSD.OSDMap values = new OMVSD.OSDMap();
foreach (ICounter cntr in m_counters) {
try {
OMVSD.OSDMap ivals = new OMVSD.OSDMap();
ivals.Add("count", new OMVSD.OSDInteger((int)cntr.Count));
if (cntr is IIntervalCounter) {
IIntervalCounter icntr = (IIntervalCounter)cntr;
ivals.Add("average", new OMVSD.OSDInteger((int)icntr.Average));
ivals.Add("low", new OMVSD.OSDInteger((int)icntr.Low));
ivals.Add("high", new OMVSD.OSDInteger((int)icntr.High));
ivals.Add("last", new OMVSD.OSDInteger((int)icntr.Last));
ivals.Add("total", new OMVSD.OSDInteger((int)icntr.Total));
}
values.Add(cntr.Name, ivals);
}
catch (Exception e) {
Logging.LogManager.Log.Log(LookingGlass.Framework.Logging.LogLevel.DBADERROR,
"FAILURE getting Displayable value: n={0}, {1}", cntr.Name, e.ToString());
}
}
return values;
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
OSD menus = new OSDMap();
if (features.ContainsKey("menus"))
menus = features["menus"];
OSDMap agent = new OSDMap();
OSDMap world = new OSDMap();
OSDMap tools = new OSDMap();
OSDMap advanced = new OSDMap();
OSDMap admin = new OSDMap();
if (((OSDMap)menus).ContainsKey("agent"))
agent = (OSDMap)((OSDMap)menus)["agent"];
if (((OSDMap)menus).ContainsKey("world"))
world = (OSDMap)((OSDMap)menus)["world"];
if (((OSDMap)menus).ContainsKey("tools"))
tools = (OSDMap)((OSDMap)menus)["tools"];
if (((OSDMap)menus).ContainsKey("advanced"))
advanced = (OSDMap)((OSDMap)menus)["advanced"];
if (((OSDMap)menus).ContainsKey("admin"))
admin = (OSDMap)((OSDMap)menus)["admin"];
if (m_menuItems.ContainsKey(UUID.Zero))
{
foreach (MenuItemData d in m_menuItems[UUID.Zero])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
continue;
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
continue;
loc[d.Title] = OSD.FromString(d.Title);
}
}
if (m_menuItems.ContainsKey(agentID))
{
foreach (MenuItemData d in m_menuItems[agentID])
{
if (d.Mode == UserMode.God && (!m_scene.Permissions.IsGod(agentID)))
continue;
OSDMap loc = null;
switch (d.Location)
{
case InsertLocation.Agent:
loc = agent;
break;
case InsertLocation.World:
loc = world;
break;
case InsertLocation.Tools:
loc = tools;
break;
case InsertLocation.Advanced:
loc = advanced;
break;
case InsertLocation.Admin:
loc = admin;
break;
}
if (loc == null)
continue;
loc[d.Title] = OSD.FromString(d.Title);
}
}
((OSDMap)menus)["agent"] = agent;
((OSDMap)menus)["world"] = world;
((OSDMap)menus)["tools"] = tools;
((OSDMap)menus)["advanced"] = advanced;
((OSDMap)menus)["admin"] = admin;
features["menus"] = menus;
}
/// <summary>
/// Does the actual remote mapitem request
/// This should be called from an asynchronous thread
/// Request failures get blacklisted until region restart so we don't
/// continue to spend resources trying to contact regions that are down.
/// </summary>
/// <param name="httpserver">blank string, we discover this in the process</param>
/// <param name="id">Agent ID that we are making this request on behalf</param>
/// <param name="flags">passed in from packet</param>
/// <param name="EstateID">passed in from packet</param>
/// <param name="godlike">passed in from packet</param>
/// <param name="itemtype">passed in from packet</param>
/// <param name="regionhandle">Region we're looking up</param>
/// <returns></returns>
private OSDMap RequestMapItemsAsync(UUID id, uint flags,
uint EstateID, bool godlike, uint itemtype, ulong regionhandle)
{
// m_log.DebugFormat("[WORLDMAP]: RequestMapItemsAsync; region handle: {0} {1}", regionhandle, itemtype);
string httpserver = "";
bool blacklisted = false;
lock (m_blacklistedregions)
{
if (m_blacklistedregions.ContainsKey(regionhandle))
{
if (Environment.TickCount > (m_blacklistedregions[regionhandle] + blacklistTimeout))
{
m_log.DebugFormat("[WORLD MAP]: Unblock blacklisted region {0}", regionhandle);
m_blacklistedregions.Remove(regionhandle);
}
else
blacklisted = true;
}
}
if (blacklisted)
return new OSDMap();
UUID requestID = UUID.Random();
lock (m_cachedRegionMapItemsAddress)
{
if (m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
httpserver = m_cachedRegionMapItemsAddress[regionhandle];
}
if (httpserver.Length == 0)
{
uint x = 0, y = 0;
Util.RegionHandleToWorldLoc(regionhandle, out x, out y);
GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
if (mreg != null)
{
httpserver = mreg.ServerURI + "MAP/MapItems/" + regionhandle.ToString();
lock (m_cachedRegionMapItemsAddress)
{
if (!m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
m_cachedRegionMapItemsAddress.Add(regionhandle, httpserver);
}
}
else
{
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
//m_log.InfoFormat("[WORLD MAP]: Blacklisted region {0}", regionhandle.ToString());
}
}
blacklisted = false;
lock (m_blacklistedurls)
{
if (m_blacklistedurls.ContainsKey(httpserver))
{
if (Environment.TickCount > (m_blacklistedurls[httpserver] + blacklistTimeout))
{
m_log.DebugFormat("[WORLD MAP]: Unblock blacklisted URL {0}", httpserver);
m_blacklistedurls.Remove(httpserver);
}
else
blacklisted = true;
}
}
// Can't find the http server
if (httpserver.Length == 0 || blacklisted)
return new OSDMap();
MapRequestState mrs = new MapRequestState();
mrs.agentID = id;
mrs.EstateID = EstateID;
mrs.flags = flags;
mrs.godlike = godlike;
mrs.itemtype=itemtype;
mrs.regionhandle = regionhandle;
lock (m_openRequests)
m_openRequests.Add(requestID, mrs);
WebRequest mapitemsrequest = null;
try
{
mapitemsrequest = WebRequest.Create(httpserver);
}
catch (Exception e)
{
m_log.DebugFormat("[WORLD MAP]: Access to {0} failed with {1}", httpserver, e);
return new OSDMap();
}
mapitemsrequest.Method = "POST";
mapitemsrequest.ContentType = "application/xml+llsd";
OSDMap RAMap = new OSDMap();
// string RAMapString = RAMap.ToString();
OSD LLSDofRAMap = RAMap; // RENAME if this works
byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap);
OSDMap responseMap = new OSDMap();
responseMap["requestID"] = OSD.FromUUID(requestID);
Stream os = null;
try
{ // send the Post
mapitemsrequest.ContentLength = buffer.Length; //Count bytes to send
os = mapitemsrequest.GetRequestStream();
os.Write(buffer, 0, buffer.Length); //Send it
//m_log.DebugFormat("[WORLD MAP]: Getting MapItems from {0}", httpserver);
}
catch (WebException ex)
{
m_log.WarnFormat("[WORLD MAP]: Bad send on GetMapItems {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
finally
{
if (os != null)
os.Dispose();
}
string response_mapItems_reply = null;
{
try
{
using (WebResponse webResponse = mapitemsrequest.GetResponse())
{
if (webResponse != null)
{
using (Stream s = webResponse.GetResponseStream())
using (StreamReader sr = new StreamReader(s))
response_mapItems_reply = sr.ReadToEnd().Trim();
}
else
{
return new OSDMap();
}
}
}
catch (WebException)
{
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
catch
{
m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
return responseMap;
}
OSD rezResponse = null;
try
{
rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply);
responseMap = (OSDMap)rezResponse;
responseMap["requestID"] = OSD.FromUUID(requestID);
}
catch (Exception ex)
{
m_log.InfoFormat("[WORLD MAP]: exception on parse of RequestMapItems reply from {0}: {1}", httpserver, ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
return responseMap;
}
}
if (!responseMap.ContainsKey(itemtype.ToString())) // remote sim doesnt have the stated region handle
{
m_log.DebugFormat("[WORLD MAP]: Remote sim does not have the stated region. Blacklisting.");
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
}
return responseMap;
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[SPECIAL UI]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
OSDMap specialUI = new OSDMap();
using (StreamReader s = new StreamReader(Path.Combine(VIEWER_SUPPORT_DIR, "panel_toolbar.xml")))
{
if (features.ContainsKey("OpenSimExtras"))
extrasMap = (OSDMap)features["OpenSimExtras"];
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
specialUI["toolbar"] = OSDMap.FromString(s.ReadToEnd());
extrasMap["special-ui"] = specialUI;
}
m_log.DebugFormat("[SPECIAL UI]: Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
if (Directory.Exists(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters")))
{
OSDMap floaters = new OSDMap();
uint n = 0;
foreach (String name in Directory.GetFiles(Path.Combine(VIEWER_SUPPORT_DIR, "Floaters"), "*.xml"))
{
using (StreamReader s = new StreamReader(name))
{
string simple_name = Path.GetFileNameWithoutExtension(name);
OSDMap floater = new OSDMap();
floaters[simple_name] = OSDMap.FromString(s.ReadToEnd());
n++;
}
}
specialUI["floaters"] = floaters;
m_log.DebugFormat("[SPECIAL UI]: Sending {0} floaters", n);
}
}
else
m_log.DebugFormat("[SPECIAL UI]: NOT Sending panel_toolbar.xml in {0}", m_scene.RegionInfo.RegionName);
}
/// <summary>
/// Converts a list of primitives to an object that can be serialized
/// with the LLSD system
/// </summary>
/// <param name="prims">Primitives to convert to a serializable object</param>
/// <returns>An object that can be serialized with LLSD</returns>
public static StructuredData.OSD PrimListToOSD(List<Primitive> prims)
{
StructuredData.OSDMap map = new OpenMetaverse.StructuredData.OSDMap(prims.Count);
for (int i = 0; i < prims.Count; i++)
map.Add(prims[i].LocalID.ToString(), prims[i].GetOSD());
return map;
}
public string GetObjectPhysicsData(string request, string path,
string param, IOSHttpRequest httpRequest,
IOSHttpResponse httpResponse)
{
OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
OSDArray object_ids = (OSDArray)req["object_ids"];
for (int i = 0 ; i < object_ids.Count ; i++)
{
UUID uuid = object_ids[i].AsUUID();
SceneObjectPart obj = m_Scene.GetSceneObjectPart(uuid);
if (obj != null)
{
OSDMap object_data = new OSDMap();
object_data["PhysicsShapeType"] = obj.PhysicsShapeType;
object_data["Density"] = obj.Density;
object_data["Friction"] = obj.Friction;
object_data["Restitution"] = obj.Restitution;
object_data["GravityMultiplier"] = obj.GravityModifier;
resp[uuid.ToString()] = object_data;
}
}
string response = OSDParser.SerializeLLSDXmlString(resp);
return response;
}
private static OSDArray WrapOSDMap(OSDMap wrapMe)
{
OSDArray array = new OSDArray();
array.Add(wrapMe);
return array;
}
public OSDArray ArrayListToOSDArray(ArrayList arrlst)
{
OSDArray llsdBack = new OSDArray();
foreach (Hashtable ht in arrlst)
{
OSDMap mp = new OSDMap();
foreach (DictionaryEntry deHt in ht)
{
mp.Add((string)deHt.Key, OSDString.FromObject(deHt.Value));
}
llsdBack.Add(mp);
}
return llsdBack;
}
public override OSD ToOSDMap()
{
try
{
OSDMap map = new OSDMap();
map["first_name"] = OSD.FromString(Firstname);
map["last_name"] = OSD.FromString(Lastname);
map["agent_access"] = OSD.FromString(agentAccess);
map["agent_access_max"] = OSD.FromString(agentAccessMax);
map["sim_port"] = OSD.FromInteger(SimPort);
map["sim_ip"] = OSD.FromString(SimAddress);
map["agent_id"] = OSD.FromUUID(AgentID);
map["session_id"] = OSD.FromUUID(SessionID);
map["secure_session_id"] = OSD.FromUUID(SecureSessionID);
map["circuit_code"] = OSD.FromInteger(CircuitCode);
map["seconds_since_epoch"] = OSD.FromInteger((int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds);
#region Login Flags
OSDMap loginFlagsLLSD = new OSDMap();
loginFlagsLLSD["daylight_savings"] = OSD.FromString(DST);
loginFlagsLLSD["stipend_since_login"] = OSD.FromString(StipendSinceLogin);
loginFlagsLLSD["gendered"] = OSD.FromString(Gendered);
loginFlagsLLSD["ever_logged_in"] = OSD.FromString(EverLoggedIn);
map["login-flags"] = WrapOSDMap(loginFlagsLLSD);
#endregion Login Flags
#region Global Textures
OSDMap globalTexturesLLSD = new OSDMap();
globalTexturesLLSD["sun_texture_id"] = OSD.FromString(SunTexture);
globalTexturesLLSD["cloud_texture_id"] = OSD.FromString(CloudTexture);
globalTexturesLLSD["moon_texture_id"] = OSD.FromString(MoonTexture);
map["global-textures"] = WrapOSDMap(globalTexturesLLSD);
#endregion Global Textures
map["seed_capability"] = OSD.FromString(seedCapability);
map["event_categories"] = ArrayListToOSDArray(eventCategories);
//map["event_notifications"] = new OSDArray(); // todo
map["classified_categories"] = ArrayListToOSDArray(classifiedCategories);
#region UI Config
OSDMap uiConfigLLSD = new OSDMap();
uiConfigLLSD["allow_first_life"] = OSD.FromString(allowFirstLife);
map["ui-config"] = WrapOSDMap(uiConfigLLSD);
#endregion UI Config
#region Inventory
map["inventory-skeleton"] = ArrayListToOSDArray(agentInventory);
map["inventory-skel-lib"] = ArrayListToOSDArray(inventoryLibrary);
map["inventory-root"] = ArrayListToOSDArray(inventoryRoot); ;
map["inventory-lib-root"] = ArrayListToOSDArray(inventoryLibRoot);
map["inventory-lib-owner"] = ArrayListToOSDArray(inventoryLibraryOwner);
#endregion Inventory
map["gestures"] = ArrayListToOSDArray(activeGestures);
map["initial-outfit"] = ArrayListToOSDArray(initialOutfit);
map["start_location"] = OSD.FromString(startLocation);
map["seed_capability"] = OSD.FromString(seedCapability);
map["home"] = OSD.FromString(home);
map["look_at"] = OSD.FromString(lookAt);
map["max-agent-groups"] = OSD.FromInteger(MaxAgentGroups);
map["message"] = OSD.FromString(welcomeMessage);
map["region_x"] = OSD.FromInteger(RegionX);
map["region_y"] = OSD.FromInteger(RegionY);
if (mapTileURL != String.Empty)
map["map-server-url"] = OSD.FromString(mapTileURL);
if (profileURL != String.Empty)
map["profile-server-url"] = OSD.FromString(profileURL);
if (openIDURL != String.Empty)
map["openid_url"] = OSD.FromString(openIDURL);
if (searchURL != String.Empty)
map["search"] = OSD.FromString(searchURL);
if (ClassifiedFee != String.Empty)
map["classified_fee"] = OSD.FromString(ClassifiedFee);
if (m_buddyList != null)
{
map["buddy-list"] = ArrayListToOSDArray(m_buddyList.ToArray());
}
map["login"] = OSD.FromString("true");
return map;
}
catch (Exception e)
{
m_log.Warn("[CLIENT]: LoginResponse: Error creating LLSD Response: " + e.Message);
return LLFailedLoginResponse.InternalError.ToOSDMap();
}
}
public override OSD ToOSDMap()
{
OSDMap map = new OSDMap();
map["reason"] = OSD.FromString(m_key);
map["message"] = OSD.FromString(m_value);
map["login"] = OSD.FromString(m_login);
return map;
}
public OSD RezAvatarMethod(string path, OSD request)
{
m_log.WarnFormat("[REZAVATAR]: {0}", request.ToString());
OSDMap responseMap = new OSDMap();
AgentCircuitData userData = null;
// Only people we've issued a cap can go further
if (TryGetAgentCircuitData(path,out userData))
{
OSDMap requestMap = (OSDMap)request;
// take these values to start. There's a few more
UUID SecureSessionID=requestMap["secure_session_id"].AsUUID();
UUID SessionID = requestMap["session_id"].AsUUID();
int circuitcode = requestMap["circuit_code"].AsInteger();
OSDArray Parameter = new OSDArray();
if (requestMap.ContainsKey("parameter"))
{
Parameter = (OSDArray)requestMap["parameter"];
}
//int version = 1;
int estateID = 1;
int parentEstateID = 1;
UUID regionID = UUID.Zero;
bool visibleToParent = true;
for (int i = 0; i < Parameter.Count; i++)
{
OSDMap item = (OSDMap)Parameter[i];
// if (item.ContainsKey("version"))
// {
// version = item["version"].AsInteger();
// }
if (item.ContainsKey("estate_id"))
{
estateID = item["estate_id"].AsInteger();
}
if (item.ContainsKey("parent_estate_id"))
{
parentEstateID = item["parent_estate_id"].AsInteger();
}
if (item.ContainsKey("region_id"))
{
regionID = item["region_id"].AsUUID();
}
if (item.ContainsKey("visible_to_parent"))
{
visibleToParent = item["visible_to_parent"].AsBoolean();
}
}
//Update our Circuit data with the real values
userData.SecureSessionID = SecureSessionID;
userData.SessionID = SessionID;
OGPState userState = GetOGPState(userData.AgentID);
// Locate a home scene suitable for the user.
Scene homeScene = null;
homeScene = GetScene(userState.teleported_into_region);
if (homeScene == null)
homeScene = GetRootScene();
if (homeScene != null)
{
// Get a referenceokay - to their Cap object so we can pull out the capobjectroot
Caps userCap
= homeScene.CapsModule.GetCapsHandlerForUser(userData.AgentID);
//Update the circuit data in the region so this user is authorized
homeScene.UpdateCircuitData(userData);
homeScene.ChangeCircuitCode(userData.circuitcode,(uint)circuitcode);
// Load state
// Keep state changes
userState.first_name = requestMap["first_name"].AsString();
userState.secure_session_id = requestMap["secure_session_id"].AsUUID();
userState.age_verified = requestMap["age_verified"].AsBoolean();
userState.region_id = homeScene.RegionInfo.originRegionID; // replace 0000000 with our regionid
userState.transacted = requestMap["transacted"].AsBoolean();
userState.agent_access = requestMap["agent_access"].AsBoolean();
userState.inventory_host = requestMap["inventory_host"].AsString();
userState.identified = requestMap["identified"].AsBoolean();
userState.session_id = requestMap["session_id"].AsUUID();
userState.god_level = (uint)requestMap["god_level"].AsInteger();
userState.last_name = requestMap["last_name"].AsString();
userState.god_overide = requestMap["god_override"].AsBoolean();
userState.circuit_code = (uint)requestMap["circuit_code"].AsInteger();
userState.limited_to_estate = requestMap["limited_to_estate"].AsInteger();
userState.src_estate_id = estateID;
userState.region_id = regionID;
userState.src_parent_estate_id = parentEstateID;
userState.visible_to_parent = visibleToParent;
// Save state changes
UpdateOGPState(userData.AgentID, userState);
// Get the region information for the home region.
RegionInfo reg = homeScene.RegionInfo;
// Dummy positional and look at info.. we don't have it.
OSDArray PositionArray = new OSDArray();
PositionArray.Add(OSD.FromInteger(128));
PositionArray.Add(OSD.FromInteger(128));
PositionArray.Add(OSD.FromInteger(40));
OSDArray LookAtArray = new OSDArray();
LookAtArray.Add(OSD.FromInteger(1));
LookAtArray.Add(OSD.FromInteger(1));
LookAtArray.Add(OSD.FromInteger(1));
// Our region's X and Y position in OpenSimulator space.
uint fooX = reg.RegionLocX;
uint fooY = reg.RegionLocY;
m_log.InfoFormat("[OGP]: region x({0}) region y({1})", fooX, fooY);
m_log.InfoFormat("[OGP]: region http {0} {1}", reg.ServerURI, reg.HttpPort);
m_log.InfoFormat("[OGO]: region UUID {0} ", reg.RegionID);
// Convert the X and Y position to LL space
responseMap["region_x"] = OSD.FromInteger(fooX * (uint)Constants.RegionSize); // convert it to LL X
responseMap["region_y"] = OSD.FromInteger(fooY * (uint)Constants.RegionSize); // convert it to LL Y
// Give em a new seed capability
responseMap["seed_capability"] = OSD.FromString("http://" + reg.ExternalHostName + ":" + reg.HttpPort + "/CAPS/" + userCap.CapsObjectPath + "0000/");
responseMap["region"] = OSD.FromUUID(reg.originRegionID);
responseMap["look_at"] = LookAtArray;
responseMap["sim_port"] = OSD.FromInteger(reg.InternalEndPoint.Port);
responseMap["sim_host"] = OSD.FromString(reg.ExternalHostName);// + ":" + reg.InternalEndPoint.Port.ToString());
// DEPRECATED
responseMap["sim_ip"] = OSD.FromString(Util.GetHostFromDNS(reg.ExternalHostName).ToString());
responseMap["session_id"] = OSD.FromUUID(SessionID);
responseMap["secure_session_id"] = OSD.FromUUID(SecureSessionID);
responseMap["circuit_code"] = OSD.FromInteger(circuitcode);
responseMap["position"] = PositionArray;
responseMap["region_id"] = OSD.FromUUID(reg.originRegionID);
responseMap["sim_access"] = OSD.FromString("Mature");
responseMap["connect"] = OSD.FromBoolean(true);
m_log.InfoFormat("[OGP]: host: {0}, IP {1}", responseMap["sim_host"].ToString(), responseMap["sim_ip"].ToString());
}
}
return responseMap;
}
public OSD HandleRemoteMapItemRequest(string path, OSD request, string endpoint)
{
uint xstart = 0;
uint ystart = 0;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle,out xstart,out ystart);
// Service 6 (MAP_ITEM_AGENTS_LOCATION; green dots)
OSDMap responsemap = new OSDMap();
int tc = Environment.TickCount;
if (m_scene.GetRootAgentCount() == 0)
{
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + 1));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + 1));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(0);
responsemapdata["Extra2"] = OSD.FromInteger(0);
OSDArray responsearr = new OSDArray();
responsearr.Add(responsemapdata);
responsemap["6"] = responsearr;
}
else
{
OSDArray responsearr = new OSDArray(m_scene.GetRootAgentCount());
m_scene.ForEachRootScenePresence(delegate(ScenePresence sp)
{
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + sp.AbsolutePosition.X));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + sp.AbsolutePosition.Y));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(1);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
});
responsemap["6"] = responsearr;
}
// Service 7 (MAP_ITEM_LAND_FOR_SALE)
ILandChannel landChannel = m_scene.LandChannel;
List<ILandObject> parcels = landChannel.AllParcels();
if ((parcels == null) || (parcels.Count == 0))
{
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + 1));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + 1));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString("");
responsemapdata["Extra"] = OSD.FromInteger(0);
responsemapdata["Extra2"] = OSD.FromInteger(0);
OSDArray responsearr = new OSDArray();
responsearr.Add(responsemapdata);
responsemap["7"] = responsearr;
}
else
{
OSDArray responsearr = new OSDArray(m_scene.GetRootAgentCount());
foreach (ILandObject parcel_interface in parcels)
{
// Play it safe
if (!(parcel_interface is LandObject))
continue;
LandObject land = (LandObject)parcel_interface;
LandData parcel = land.LandData;
// Show land for sale
if ((parcel.Flags & (uint)ParcelFlags.ForSale) == (uint)ParcelFlags.ForSale)
{
Vector3 min = parcel.AABBMin;
Vector3 max = parcel.AABBMax;
float x = (min.X+max.X)/2;
float y = (min.Y+max.Y)/2;
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + x));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + y));
// responsemapdata["Z"] = OSD.FromInteger((int)m_scene.GetGroundHeight(x,y));
responsemapdata["ID"] = OSD.FromUUID(parcel.GlobalID);
responsemapdata["Name"] = OSD.FromString(parcel.Name);
responsemapdata["Extra"] = OSD.FromInteger(parcel.Area);
responsemapdata["Extra2"] = OSD.FromInteger(parcel.SalePrice);
responsearr.Add(responsemapdata);
}
}
responsemap["7"] = responsearr;
}
if (m_scene.RegionInfo.RegionSettings.TelehubObject != UUID.Zero)
{
SceneObjectGroup sog = m_scene.GetSceneObjectGroup(m_scene.RegionInfo.RegionSettings.TelehubObject);
if (sog != null)
{
OSDArray responsearr = new OSDArray();
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + sog.AbsolutePosition.X));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + sog.AbsolutePosition.Y));
// responsemapdata["Z"] = OSD.FromInteger((int)m_scene.GetGroundHeight(x,y));
responsemapdata["ID"] = OSD.FromUUID(sog.UUID);
responsemapdata["Name"] = OSD.FromString(sog.Name);
responsemapdata["Extra"] = OSD.FromInteger(0); // color (unused)
responsemapdata["Extra2"] = OSD.FromInteger(0); // 0 = telehub / 1 = infohub
responsearr.Add(responsemapdata);
responsemap["1"] = responsearr;
}
}
return responsemap;
}
public string GetObjectCost(string request, string path,
string param, IOSHttpRequest httpRequest,
IOSHttpResponse httpResponse)
{
OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
OSDArray object_ids = (OSDArray)req["object_ids"];
for (int i = 0; i < object_ids.Count; i++)
{
UUID uuid = object_ids[i].AsUUID();
SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
SceneObjectGroup grp = null;
if (part != null)
grp = part.ParentGroup;
if (grp != null)
{
float linksetCost;
float linksetPhysCost;
float partCost;
float partPhysCost;
grp.GetResourcesCosts(part,out linksetCost,out linksetPhysCost,out partCost,out partPhysCost);
OSDMap object_data = new OSDMap();
object_data["linked_set_resource_cost"] = linksetCost;
object_data["resource_cost"] = partCost;
object_data["physics_cost"] = partPhysCost;
object_data["linked_set_physics_cost"] = linksetPhysCost;
object_data["resource_limiting_type"] = "legacy";
resp[uuid.ToString()] = object_data;
}
}
if(resp.Count == 0)
{
OSDMap object_data = new OSDMap();
object_data["linked_set_resource_cost"] = 0;
object_data["resource_cost"] = 0;
object_data["physics_cost"] = 0;
object_data["linked_set_physics_cost"] = 0;
resp[UUID.Zero.ToString()] = object_data;
}
string response = OSDParser.SerializeLLSDXmlString(resp);
return response;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public byte[] SerializeAttachment()
{
if (OwnerID == UUID.Zero || AttachmentID == UUID.Zero)
return Utils.EmptyBytes;
OpenMetaverse.StructuredData.OSDMap att = new OpenMetaverse.StructuredData.OSDMap();
att.Add("item_id", OpenMetaverse.StructuredData.OSD.FromUUID(AttachmentID));
att.Add("owner_id", OpenMetaverse.StructuredData.OSD.FromUUID(OwnerID));
return OpenMetaverse.StructuredData.OSDParser.SerializeLLSDXmlBytes(att);
/*
//I guess this is how this works, no gaurentees
string lsd = "<llsd><item_id>" + AttachmentID.ToString() + "</item_id><owner_id>"
+ OwnerID.ToString() + "</owner_id></llsd>";
return Utils.StringToBytes(lsd);
*/
}
/// <summary>
/// Sends the mapitem response to the IClientAPI
/// </summary>
/// <param name="response">The OSDMap Response for the mapitem</param>
private void RequestMapItemsCompleted(OSDMap response)
{
UUID requestID = response["requestID"].AsUUID();
if (requestID != UUID.Zero)
{
MapRequestState mrs = new MapRequestState();
mrs.agentID = UUID.Zero;
lock (m_openRequests)
{
if (m_openRequests.ContainsKey(requestID))
{
mrs = m_openRequests[requestID];
m_openRequests.Remove(requestID);
}
}
if (mrs.agentID != UUID.Zero)
{
ScenePresence av = null;
m_scene.TryGetScenePresence(mrs.agentID, out av);
if (av != null)
{
if (response.ContainsKey(mrs.itemtype.ToString()))
{
List<mapItemReply> returnitems = new List<mapItemReply>();
OSDArray itemarray = (OSDArray)response[mrs.itemtype.ToString()];
for (int i = 0; i < itemarray.Count; i++)
{
OSDMap mapitem = (OSDMap)itemarray[i];
mapItemReply mi = new mapItemReply();
mi.x = (uint)mapitem["X"].AsInteger();
mi.y = (uint)mapitem["Y"].AsInteger();
mi.id = mapitem["ID"].AsUUID();
mi.Extra = mapitem["Extra"].AsInteger();
mi.Extra2 = mapitem["Extra2"].AsInteger();
mi.name = mapitem["Name"].AsString();
returnitems.Add(mi);
}
av.ControllingClient.SendMapItemReply(returnitems.ToArray(), mrs.itemtype, mrs.flags);
}
}
}
}
}
private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
{
m_log.DebugFormat("[CAMERA-ONLY MODE]: OnSimulatorFeaturesRequest in {0}", m_scene.RegionInfo.RegionName);
if (m_Helper.ShouldSend(agentID) && m_Helper.UserLevel(agentID) <= m_UserLevel)
{
OSDMap extrasMap;
if (features.ContainsKey("OpenSimExtras"))
{
extrasMap = (OSDMap)features["OpenSimExtras"];
}
else
{
extrasMap = new OSDMap();
features["OpenSimExtras"] = extrasMap;
}
extrasMap["camera-only-mode"] = OSDMap.FromString("true");
m_log.DebugFormat("[CAMERA-ONLY MODE]: Sent in {0}", m_scene.RegionInfo.RegionName);
// Detaching attachments doesn't work for HG visitors,
// so I'm giving that up.
//Util.FireAndForget(delegate { DetachAttachments(agentID); });
}
else
m_log.DebugFormat("[CAMERA-ONLY MODE]: NOT Sending camera-only-mode in {0}", m_scene.RegionInfo.RegionName);
}
public OSD HandleRemoteMapItemRequest(string path, OSD request, string endpoint)
{
uint xstart = 0;
uint ystart = 0;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle,out xstart,out ystart);
OSDMap responsemap = new OSDMap();
int tc = Environment.TickCount;
if (m_scene.GetRootAgentCount() == 0)
{
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + 1));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + 1));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(0);
responsemapdata["Extra2"] = OSD.FromInteger(0);
OSDArray responsearr = new OSDArray();
responsearr.Add(responsemapdata);
responsemap["6"] = responsearr;
}
else
{
OSDArray responsearr = new OSDArray(m_scene.GetRootAgentCount());
m_scene.ForEachScenePresence(delegate(ScenePresence sp)
{
OSDMap responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + sp.AbsolutePosition.X));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + sp.AbsolutePosition.Y));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(1);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
});
responsemap["6"] = responsearr;
}
return responsemap;
}
public OSD HandleRemoteMapItemRequest(string path, OSD request, IPEndPoint endpoint)
{
uint xstart = 0;
uint ystart = 0;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle,out xstart,out ystart);
OSDMap responsemap = new OSDMap();
OSDMap responsemapdata = new OSDMap();
int tc = Environment.TickCount;
List<ScenePresence> avatars = m_scene.GetAvatars();
OSDArray responsearr = new OSDArray(avatars.Count);
if (avatars.Count == 0)
{
responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + 1));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + 1));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(0);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
responsemap["6"] = responsearr;
}
else
{
responsearr = new OSDArray(avatars.Count);
foreach (ScenePresence av in avatars)
{
Vector3 avpos;
if (av.HasSafePosition(out avpos))
{
responsemapdata = new OSDMap();
responsemapdata["X"] = OSD.FromInteger((int)(xstart + avpos.X));
responsemapdata["Y"] = OSD.FromInteger((int)(ystart + avpos.Y));
responsemapdata["ID"] = OSD.FromUUID(UUID.Zero);
responsemapdata["Name"] = OSD.FromString(Util.Md5Hash(m_scene.RegionInfo.RegionName + tc.ToString()));
responsemapdata["Extra"] = OSD.FromInteger(1);
responsemapdata["Extra2"] = OSD.FromInteger(0);
responsearr.Add(responsemapdata);
}
}
responsemap["6"] = responsearr;
}
return responsemap;
}
private OSDMap invokeRezAvatarCap(OSDMap responseMap, string CapAddress, OGPState userState)
{
Scene reg = GetRootScene();
WebRequest DeRezRequest = WebRequest.Create(CapAddress);
DeRezRequest.Method = "POST";
DeRezRequest.ContentType = "application/xml+llsd";
OSDMap RAMap = new OSDMap();
OSDMap AgentParms = new OSDMap();
OSDMap RegionParms = new OSDMap();
OSDArray Parameter = new OSDArray(2);
OSDMap version = new OSDMap();
version["version"] = OSD.FromInteger(userState.src_version);
Parameter.Add(version);
OSDMap SrcData = new OSDMap();
SrcData["estate_id"] = OSD.FromInteger(reg.RegionInfo.EstateSettings.EstateID);
SrcData["parent_estate_id"] = OSD.FromInteger((reg.RegionInfo.EstateSettings.ParentEstateID == 100 ? 1 : reg.RegionInfo.EstateSettings.ParentEstateID));
SrcData["region_id"] = OSD.FromUUID(reg.RegionInfo.originRegionID);
SrcData["visible_to_parent"] = OSD.FromBoolean(userState.visible_to_parent);
Parameter.Add(SrcData);
AgentParms["first_name"] = OSD.FromString(userState.first_name);
AgentParms["last_name"] = OSD.FromString(userState.last_name);
AgentParms["agent_id"] = OSD.FromUUID(userState.agent_id);
RegionParms["region_id"] = OSD.FromUUID(userState.region_id);
AgentParms["circuit_code"] = OSD.FromInteger(userState.circuit_code);
AgentParms["secure_session_id"] = OSD.FromUUID(userState.secure_session_id);
AgentParms["session_id"] = OSD.FromUUID(userState.session_id);
AgentParms["agent_access"] = OSD.FromBoolean(userState.agent_access);
AgentParms["god_level"] = OSD.FromInteger(userState.god_level);
AgentParms["god_overide"] = OSD.FromBoolean(userState.god_overide);
AgentParms["identified"] = OSD.FromBoolean(userState.identified);
AgentParms["transacted"] = OSD.FromBoolean(userState.transacted);
AgentParms["age_verified"] = OSD.FromBoolean(userState.age_verified);
AgentParms["limited_to_estate"] = OSD.FromInteger(userState.limited_to_estate);
AgentParms["inventory_host"] = OSD.FromString(userState.inventory_host);
// version 1
RAMap = AgentParms;
// Planned for version 2
// RAMap["agent_params"] = AgentParms;
RAMap["region_params"] = RegionParms;
RAMap["parameter"] = Parameter;
string RAMapString = RAMap.ToString();
m_log.InfoFormat("[OGP] RAMap string {0}", RAMapString);
OSD LLSDofRAMap = RAMap; // RENAME if this works
m_log.InfoFormat("[OGP]: LLSD of map as string was {0}", LLSDofRAMap.ToString());
//m_log.InfoFormat("[OGP]: LLSD+XML: {0}", LLSDParser.SerializeXmlString(LLSDofRAMap));
byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap);
//string bufferDump = System.Text.Encoding.ASCII.GetString(buffer);
//m_log.InfoFormat("[OGP]: buffer form is {0}",bufferDump);
//m_log.InfoFormat("[OGP]: LLSD of map was {0}",buffer.Length);
Stream os = null;
try
{ // send the Post
DeRezRequest.ContentLength = buffer.Length; //Count bytes to send
os = DeRezRequest.GetRequestStream();
os.Write(buffer, 0, buffer.Length); //Send it
os.Close();
m_log.InfoFormat("[OGP]: Derez Avatar Posted Rez Avatar request to remote sim {0}", CapAddress);
}
catch (WebException ex)
{
m_log.InfoFormat("[OGP] Bad send on de_rez_avatar {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
m_log.Info("[OGP] waiting for a reply after rez avatar send");
string rez_avatar_reply = null;
{ // get the response
try
{
WebResponse webResponse = DeRezRequest.GetResponse();
if (webResponse == null)
{
m_log.Info("[OGP:] Null reply on rez_avatar post");
}
StreamReader sr = new StreamReader(webResponse.GetResponseStream());
rez_avatar_reply = sr.ReadToEnd().Trim();
m_log.InfoFormat("[OGP]: rez_avatar reply was {0} ", rez_avatar_reply);
}
catch (WebException ex)
{
m_log.InfoFormat("[OGP]: exception on read after send of rez avatar {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
OSD rezResponse = null;
try
{
rezResponse = OSDParser.DeserializeLLSDXml(rez_avatar_reply);
responseMap = (OSDMap)rezResponse;
}
catch (Exception ex)
{
m_log.InfoFormat("[OGP]: exception on parse of rez reply {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
}
return responseMap;
}
/// <summary>
/// Does the actual remote mapitem request
/// This should be called from an asynchronous thread
/// Request failures get blacklisted until region restart so we don't
/// continue to spend resources trying to contact regions that are down.
/// </summary>
/// <param name="httpserver">blank string, we discover this in the process</param>
/// <param name="id">Agent ID that we are making this request on behalf</param>
/// <param name="flags">passed in from packet</param>
/// <param name="EstateID">passed in from packet</param>
/// <param name="godlike">passed in from packet</param>
/// <param name="itemtype">passed in from packet</param>
/// <param name="regionhandle">Region we're looking up</param>
/// <returns></returns>
private OSDMap RequestMapItemsAsync(string httpserver, UUID id, uint flags,
uint EstateID, bool godlike, uint itemtype, ulong regionhandle)
{
bool blacklisted = false;
lock (m_blacklistedregions)
{
if (m_blacklistedregions.ContainsKey(regionhandle))
blacklisted = true;
}
if (blacklisted)
return new OSDMap();
UUID requestID = UUID.Random();
lock (m_cachedRegionMapItemsAddress)
{
if (m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
httpserver = m_cachedRegionMapItemsAddress[regionhandle];
}
if (httpserver.Length == 0)
{
uint x = 0, y = 0;
Utils.LongToUInts(regionhandle, out x, out y);
GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
if (mreg != null)
{
httpserver = "http://" + mreg.ExternalEndPoint.Address.ToString() + ":" + mreg.HttpPort + "/MAP/MapItems/" + regionhandle.ToString();
lock (m_cachedRegionMapItemsAddress)
{
if (!m_cachedRegionMapItemsAddress.ContainsKey(regionhandle))
m_cachedRegionMapItemsAddress.Add(regionhandle, httpserver);
}
}
else
{
lock (m_blacklistedregions)
{
if (!m_blacklistedregions.ContainsKey(regionhandle))
m_blacklistedregions.Add(regionhandle, Environment.TickCount);
}
m_log.InfoFormat("[WORLD MAP]: Blacklisted region {0}", regionhandle.ToString());
}
}
blacklisted = false;
lock (m_blacklistedurls)
{
if (m_blacklistedurls.ContainsKey(httpserver))
blacklisted = true;
}
// Can't find the http server
if (httpserver.Length == 0 || blacklisted)
return new OSDMap();
MapRequestState mrs = new MapRequestState();
mrs.agentID = id;
mrs.EstateID = EstateID;
mrs.flags = flags;
mrs.godlike = godlike;
mrs.itemtype=itemtype;
mrs.regionhandle = regionhandle;
lock (m_openRequests)
m_openRequests.Add(requestID, mrs);
WebRequest mapitemsrequest = WebRequest.Create(httpserver);
mapitemsrequest.Method = "POST";
mapitemsrequest.ContentType = "application/xml+llsd";
OSDMap RAMap = new OSDMap();
// string RAMapString = RAMap.ToString();
OSD LLSDofRAMap = RAMap; // RENAME if this works
byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap);
OSDMap responseMap = new OSDMap();
responseMap["requestID"] = OSD.FromUUID(requestID);
Stream os = null;
try
{ // send the Post
mapitemsrequest.ContentLength = buffer.Length; //Count bytes to send
os = mapitemsrequest.GetRequestStream();
os.Write(buffer, 0, buffer.Length); //Send it
os.Close();
//m_log.DebugFormat("[WORLD MAP]: Getting MapItems from Sim {0}", httpserver);
}
catch (WebException ex)
{
m_log.WarnFormat("[WORLD MAP]: Bad send on GetMapItems {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
string response_mapItems_reply = null;
{ // get the response
try
{
WebResponse webResponse = mapitemsrequest.GetResponse();
if (webResponse != null)
{
StreamReader sr = new StreamReader(webResponse.GetResponseStream());
response_mapItems_reply = sr.ReadToEnd().Trim();
}
else
{
return new OSDMap();
}
}
catch (WebException)
{
responseMap["connect"] = OSD.FromBoolean(false);
lock (m_blacklistedurls)
{
if (!m_blacklistedurls.ContainsKey(httpserver))
m_blacklistedurls.Add(httpserver, Environment.TickCount);
}
m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver);
return responseMap;
}
OSD rezResponse = null;
try
{
rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply);
responseMap = (OSDMap)rezResponse;
responseMap["requestID"] = OSD.FromUUID(requestID);
}
catch (Exception)
{
//m_log.InfoFormat("[OGP]: exception on parse of rez reply {0}", ex.Message);
responseMap["connect"] = OSD.FromBoolean(false);
return responseMap;
}
}
return responseMap;
}
public OSD RequestRezAvatarMethod(string path, OSD request)
{
//m_log.Debug("[REQUESTREZAVATAR]: " + request.ToString());
OSDMap requestMap = (OSDMap)request;
Scene homeScene = null;
lock (m_loginToRegionState)
{
if (m_loginToRegionState.ContainsKey(path))
{
homeScene = GetScene(m_loginToRegionState[path]);
m_loginToRegionState.Remove(path);
if (homeScene == null)
homeScene = GetRootScene();
}
else
{
homeScene = GetRootScene();
}
}
// Homescene is still null, we must have no regions that are up
if (homeScene == null)
return GenerateNoHandlerMessage();
RegionInfo reg = homeScene.RegionInfo;
ulong regionhandle = GetOSCompatibleRegionHandle(reg);
//string RegionURI = reg.ServerURI;
//int RegionPort = (int)reg.HttpPort;
UUID RemoteAgentID = requestMap["agent_id"].AsUUID();
// will be used in the future. The client always connects with the aditi agentid currently
UUID LocalAgentID = RemoteAgentID;
string FirstName = requestMap["first_name"].AsString();
string LastName = requestMap["last_name"].AsString();
FirstName = FirstNamePrefix + FirstName;
LastName = LastName + LastNameSuffix;
OGPState userState = GetOGPState(LocalAgentID);
userState.first_name = requestMap["first_name"].AsString();
userState.last_name = requestMap["last_name"].AsString();
userState.age_verified = requestMap["age_verified"].AsBoolean();
userState.transacted = requestMap["transacted"].AsBoolean();
userState.agent_access = requestMap["agent_access"].AsBoolean();
userState.allow_redirect = requestMap["allow_redirect"].AsBoolean();
userState.identified = requestMap["identified"].AsBoolean();
userState.god_level = (uint)requestMap["god_level"].AsInteger();
userState.sim_access = requestMap["sim_access"].AsString();
userState.agent_id = RemoteAgentID;
userState.limited_to_estate = requestMap["limited_to_estate"].AsInteger();
userState.src_can_see_mainland = requestMap["src_can_see_mainland"].AsBoolean();
userState.src_estate_id = requestMap["src_estate_id"].AsInteger();
userState.local_agent_id = LocalAgentID;
userState.teleported_into_region = reg.RegionName.ToLower();
UpdateOGPState(LocalAgentID, userState);
OSDMap responseMap = new OSDMap();
if (RemoteAgentID == UUID.Zero)
{
responseMap["connect"] = OSD.FromBoolean(false);
responseMap["message"] = OSD.FromString("No agent ID was specified in rez_avatar/request");
m_log.Error("[OGP]: rez_avatar/request failed because no avatar UUID was provided in the request body");
return responseMap;
}
responseMap["sim_host"] = OSD.FromString(reg.ExternalHostName);
// DEPRECATED
responseMap["sim_ip"] = OSD.FromString(Util.GetHostFromDNS(reg.ExternalHostName).ToString());
responseMap["connect"] = OSD.FromBoolean(true);
responseMap["sim_port"] = OSD.FromInteger(reg.InternalEndPoint.Port);
responseMap["region_x"] = OSD.FromInteger(reg.RegionLocX * (uint)Constants.RegionSize); // LLX
responseMap["region_y"] = OSD.FromInteger(reg.RegionLocY * (uint)Constants.RegionSize); // LLY
responseMap["region_id"] = OSD.FromUUID(reg.originRegionID);
if (reg.RegionSettings.Maturity == 1)
{
responseMap["sim_access"] = OSD.FromString("Mature");
}
else if (reg.RegionSettings.Maturity == 2)
{
responseMap["sim_access"] = OSD.FromString("Adult");
}
else
{
responseMap["sim_access"] = OSD.FromString("PG");
}
// Generate a dummy agent for the user so we can get back a CAPS path
AgentCircuitData agentData = new AgentCircuitData();
agentData.AgentID = LocalAgentID;
agentData.BaseFolder = UUID.Zero;
agentData.CapsPath = CapsUtil.GetRandomCapsObjectPath();
agentData.child = false;
agentData.circuitcode = (uint)(Util.RandomClass.Next());
agentData.firstname = FirstName;
agentData.lastname = LastName;
agentData.SecureSessionID = UUID.Random();
agentData.SessionID = UUID.Random();
agentData.startpos = new Vector3(128f, 128f, 100f);
// Pre-Fill our region cache with information on the agent.
UserAgentData useragent = new UserAgentData();
useragent.AgentIP = "unknown";
useragent.AgentOnline = true;
useragent.AgentPort = (uint)0;
useragent.Handle = regionhandle;
useragent.InitialRegion = reg.originRegionID;
useragent.LoginTime = Util.UnixTimeSinceEpoch();
useragent.LogoutTime = 0;
useragent.Position = agentData.startpos;
useragent.Region = reg.originRegionID;
useragent.SecureSessionID = agentData.SecureSessionID;
useragent.SessionID = agentData.SessionID;
UserProfileData userProfile = new UserProfileData();
userProfile.AboutText = "OGP User";
userProfile.CanDoMask = (uint)0;
userProfile.Created = Util.UnixTimeSinceEpoch();
userProfile.CurrentAgent = useragent;
userProfile.CustomType = "OGP";
userProfile.FirstLifeAboutText = "I'm testing OpenGrid Protocol";
userProfile.FirstLifeImage = UUID.Zero;
userProfile.FirstName = agentData.firstname;
userProfile.GodLevel = 0;
userProfile.HomeLocation = agentData.startpos;
userProfile.HomeLocationX = agentData.startpos.X;
userProfile.HomeLocationY = agentData.startpos.Y;
userProfile.HomeLocationZ = agentData.startpos.Z;
userProfile.HomeLookAt = Vector3.Zero;
userProfile.HomeLookAtX = userProfile.HomeLookAt.X;
userProfile.HomeLookAtY = userProfile.HomeLookAt.Y;
userProfile.HomeLookAtZ = userProfile.HomeLookAt.Z;
userProfile.HomeRegion = reg.RegionHandle;
userProfile.HomeRegionID = reg.originRegionID;
userProfile.HomeRegionX = reg.RegionLocX;
userProfile.HomeRegionY = reg.RegionLocY;
userProfile.ID = agentData.AgentID;
userProfile.Image = UUID.Zero;
userProfile.LastLogin = Util.UnixTimeSinceEpoch();
userProfile.Partner = UUID.Zero;
userProfile.PasswordHash = "$1$";
userProfile.PasswordSalt = "";
userProfile.SurName = agentData.lastname;
//userProfile.UserAssetURI = homeScene.CommsManager.NetworkServersInfo.AssetURL;
userProfile.UserFlags = 0;
//userProfile.UserInventoryURI = homeScene.CommsManager.NetworkServersInfo.InventoryURL;
userProfile.WantDoMask = 0;
userProfile.WebLoginKey = UUID.Random();
// !!! REFACTORING PROBLEM. This needs to be changed for 0.7
//
//// Do caps registration
//// get seed capagentData.firstname = FirstName;agentData.lastname = LastName;
//if (homeScene.CommsManager.UserService.GetUserProfile(agentData.AgentID) == null && !GridMode)
//{
// homeScene.CommsManager.UserAdminService.AddUser(
// agentData.firstname, agentData.lastname, CreateRandomStr(7), "",
// homeScene.RegionInfo.RegionLocX, homeScene.RegionInfo.RegionLocY, agentData.AgentID);
// UserProfileData userProfile2 = homeScene.CommsManager.UserService.GetUserProfile(agentData.AgentID);
// if (userProfile2 != null)
// {
// userProfile = userProfile2;
// userProfile.AboutText = "OGP USER";
// userProfile.FirstLifeAboutText = "OGP USER";
// homeScene.CommsManager.UserService.UpdateUserProfile(userProfile);
// }
//}
//// Stick our data in the cache so the region will know something about us
//homeScene.CommsManager.UserProfileCacheService.PreloadUserCache(userProfile);
// Call 'new user' event handler
string reason;
if (!homeScene.NewUserConnection(agentData, (uint)TeleportFlags.ViaLogin, out reason))
{
responseMap["connect"] = OSD.FromBoolean(false);
responseMap["message"] = OSD.FromString(String.Format("Connection refused: {0}", reason));
m_log.ErrorFormat("[OGP]: rez_avatar/request failed: {0}", reason);
return responseMap;
}
//string raCap = string.Empty;
UUID AvatarRezCapUUID = LocalAgentID;
string rezAvatarPath = "/agent/" + AvatarRezCapUUID + "/rez_avatar/rez";
string derezAvatarPath = "/agent/" + AvatarRezCapUUID + "/rez_avatar/derez";
// Get a reference to the user's cap so we can pull out the Caps Object Path
Caps userCap
= homeScene.CapsModule.GetCapsHandlerForUser(agentData.AgentID);
string rezHttpProtocol = "http://";
string regionCapsHttpProtocol = "http://";
string httpaddr = reg.ExternalHostName;
string urlport = reg.HttpPort.ToString();
if (httpSSL)
{
rezHttpProtocol = "https://";
regionCapsHttpProtocol = "https://";
urlport = httpsslport.ToString();
if (httpsCN.Length > 0)
httpaddr = httpsCN;
}
// DEPRECATED
responseMap["seed_capability"]
= OSD.FromString(
regionCapsHttpProtocol + httpaddr + ":" + reg.HttpPort + CapsUtil.GetCapsSeedPath(userCap.CapsObjectPath));
// REPLACEMENT
responseMap["region_seed_capability"]
= OSD.FromString(
regionCapsHttpProtocol + httpaddr + ":" + reg.HttpPort + CapsUtil.GetCapsSeedPath(userCap.CapsObjectPath));
responseMap["rez_avatar"] = OSD.FromString(rezHttpProtocol + httpaddr + ":" + urlport + rezAvatarPath);
responseMap["rez_avatar/rez"] = OSD.FromString(rezHttpProtocol + httpaddr + ":" + urlport + rezAvatarPath);
responseMap["rez_avatar/derez"] = OSD.FromString(rezHttpProtocol + httpaddr + ":" + urlport + derezAvatarPath);
// Add the user to the list of CAPS that are outstanding.
// well allow the caps hosts in this dictionary
lock (CapsLoginID)
{
if (CapsLoginID.ContainsKey(rezAvatarPath))
{
CapsLoginID[rezAvatarPath] = agentData;
// This is a joke, if you didn't notice... It's so unlikely to happen, that I'll print this message if it does occur!
m_log.Error("[OGP]: Holy anomoly batman! Caps path already existed! All the UUID Duplication worries were founded!");
}
else
{
CapsLoginID.Add(rezAvatarPath, agentData);
}
}
//m_log.Debug("Response:" + responseMap.ToString());
return responseMap;
}
public string ResourceCostSelected(string request, string path,
string param, IOSHttpRequest httpRequest,
IOSHttpResponse httpResponse)
{
OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
float phys=0;
float stream=0;
float simul=0;
if (req.ContainsKey("selected_roots"))
{
OSDArray object_ids = (OSDArray)req["selected_roots"];
// should go by SOG suming costs for all parts
// ll v3 works ok with several objects select we get the list and adds ok
// FS calls per object so results are wrong guess fs bug
for (int i = 0; i < object_ids.Count; i++)
{
UUID uuid = object_ids[i].AsUUID();
float Physc;
float simulc;
float streamc;
SceneObjectGroup grp = m_Scene.GetGroupByPrim(uuid);
if (grp != null)
{
grp.GetSelectedCosts(out Physc, out streamc, out simulc);
phys += Physc;
stream += streamc;
simul += simulc;
}
}
}
else if (req.ContainsKey("selected_prims"))
{
OSDArray object_ids = (OSDArray)req["selected_prims"];
// don't see in use in any of the 2 viewers
// guess it should be for edit linked but... nothing
// should go to SOP per part
for (int i = 0; i < object_ids.Count; i++)
{
UUID uuid = object_ids[i].AsUUID();
SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
if (part != null)
{
phys += part.PhysicsCost;
stream += part.StreamingCost;
simul += part.SimulationCost;
}
}
}
OSDMap object_data = new OSDMap();
object_data["physics"] = phys;
object_data["streaming"] = stream;
object_data["simulation"] = simul;
resp["selected"] = object_data;
// resp["transaction_id"] = "undef";
string response = OSDParser.SerializeLLSDXmlString(resp);
return response;
}
public OSD DerezAvatarMethod(string path, OSD request)
{
m_log.ErrorFormat("DerezPath: {0}, Request: {1}", path, request.ToString());
//LLSD llsdResponse = null;
OSDMap responseMap = new OSDMap();
string[] PathArray = path.Split('/');
m_log.InfoFormat("[OGP]: prefix {0}, uuid {1}, suffix {2}", PathArray[1], PathArray[2], PathArray[3]);
string uuidString = PathArray[2];
m_log.InfoFormat("[OGP]: Request to Derez avatar with UUID {0}", uuidString);
UUID userUUID = UUID.Zero;
if (UUID.TryParse(uuidString, out userUUID))
{
UUID RemoteID = (UUID)uuidString;
UUID LocalID = RemoteID;
// FIXME: TODO: Routine to map RemoteUUIDs to LocalUUIds
// would be done already.. but the client connects with the Aditi UUID
// regardless over the UDP stack
OGPState userState = GetOGPState(LocalID);
if (userState.agent_id != UUID.Zero)
{
//OSDMap outboundRequestMap = new OSDMap();
OSDMap inboundRequestMap = (OSDMap)request;
string rezAvatarString = inboundRequestMap["rez_avatar"].AsString();
if (rezAvatarString.Length == 0)
{
rezAvatarString = inboundRequestMap["rez_avatar/rez"].AsString();
}
OSDArray LookAtArray = new OSDArray();
LookAtArray.Add(OSD.FromInteger(1));
LookAtArray.Add(OSD.FromInteger(1));
LookAtArray.Add(OSD.FromInteger(1));
OSDArray PositionArray = new OSDArray();
PositionArray.Add(OSD.FromInteger(128));
PositionArray.Add(OSD.FromInteger(128));
PositionArray.Add(OSD.FromInteger(40));
OSDArray lookArray = new OSDArray();
lookArray.Add(OSD.FromInteger(128));
lookArray.Add(OSD.FromInteger(128));
lookArray.Add(OSD.FromInteger(40));
responseMap["connect"] = OSD.FromBoolean(true);// it's okay to give this user up
responseMap["look_at"] = LookAtArray;
m_log.WarnFormat("[OGP]: Invoking rez_avatar on host:{0} for avatar: {1} {2}", rezAvatarString, userState.first_name, userState.last_name);
OSDMap rezResponseMap = invokeRezAvatarCap(responseMap, rezAvatarString,userState);
// If invoking it returned an error, parse and end
if (rezResponseMap.ContainsKey("connect"))
{
if (rezResponseMap["connect"].AsBoolean() == false)
{
return responseMap;
}
}
string rezRespSeedCap = "";
// DEPRECATED
if (rezResponseMap.ContainsKey("seed_capability"))
rezRespSeedCap = rezResponseMap["seed_capability"].AsString();
// REPLACEMENT
if (rezResponseMap.ContainsKey("region_seed_capability"))
rezRespSeedCap = rezResponseMap["region_seed_capability"].AsString();
// REPLACEMENT
if (rezResponseMap.ContainsKey("rez_avatar/rez"))
rezRespSeedCap = rezResponseMap["rez_avatar/rez"].AsString();
// DEPRECATED
string rezRespSim_ip = rezResponseMap["sim_ip"].AsString();
string rezRespSim_host = rezResponseMap["sim_host"].AsString();
int rrPort = rezResponseMap["sim_port"].AsInteger();
int rrX = rezResponseMap["region_x"].AsInteger();
int rrY = rezResponseMap["region_y"].AsInteger();
m_log.ErrorFormat("X:{0}, Y:{1}", rrX, rrY);
UUID rrRID = rezResponseMap["region_id"].AsUUID();
OSDArray RezResponsePositionArray = null;
string rrAccess = rezResponseMap["sim_access"].AsString();
if (rezResponseMap.ContainsKey("position"))
{
RezResponsePositionArray = (OSDArray)rezResponseMap["position"];
}
// DEPRECATED
responseMap["seed_capability"] = OSD.FromString(rezRespSeedCap);
// REPLACEMENT r3
responseMap["region_seed_capability"] = OSD.FromString(rezRespSeedCap);
// DEPRECATED
responseMap["sim_ip"] = OSD.FromString(Util.GetHostFromDNS(rezRespSim_ip).ToString());
responseMap["sim_host"] = OSD.FromString(rezRespSim_host);
responseMap["sim_port"] = OSD.FromInteger(rrPort);
responseMap["region_x"] = OSD.FromInteger(rrX);
responseMap["region_y"] = OSD.FromInteger(rrY);
responseMap["region_id"] = OSD.FromUUID(rrRID);
responseMap["sim_access"] = OSD.FromString(rrAccess);
if (RezResponsePositionArray != null)
{
responseMap["position"] = RezResponsePositionArray;
}
responseMap["look_at"] = lookArray;
responseMap["connect"] = OSD.FromBoolean(true);
ShutdownConnection(LocalID,this);
// PLEASE STOP CHANGING THIS TO an M_LOG, M_LOG DOESN'T WORK ON MULTILINE .TOSTRINGS
Console.WriteLine("RESPONSEDEREZ: " + responseMap.ToString());
return responseMap;
}
else
{
return GenerateNoStateMessage(LocalID);
}
}
else
{
return GenerateNoHandlerMessage();
}
//return responseMap;
}
public string UpdateAgentInformation(string request, string path,
string param, IOSHttpRequest httpRequest,
IOSHttpResponse httpResponse)
{
// OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
OSDMap resp = new OSDMap();
OSDMap accessPrefs = new OSDMap();
accessPrefs["max"] = "A";
resp["access_prefs"] = accessPrefs;
string response = OSDParser.SerializeLLSDXmlString(resp);
return response;
}
private OSD GenerateRezAvatarRequestMessage(string regionname)
{
Scene region = null;
bool usedroot = false;
if (regionname.Length == 0)
{
region = GetRootScene();
usedroot = true;
}
else
{
region = GetScene(HttpUtility.UrlDecode(regionname).ToLower());
}
// this shouldn't happen since we don't listen for a region that is down.. but
// it might if the region was taken down or is in the middle of restarting
if (region == null)
{
region = GetRootScene();
usedroot = true;
}
UUID statekeeper = UUID.Random();
RegionInfo reg = region.RegionInfo;
OSDMap responseMap = new OSDMap();
string rezHttpProtocol = "http://";
//string regionCapsHttpProtocol = "http://";
string httpaddr = reg.ExternalHostName;
string urlport = reg.HttpPort.ToString();
string requestpath = "/agent/" + statekeeper + "/rez_avatar/request";
if (!usedroot)
{
lock (m_loginToRegionState)
{
if (!m_loginToRegionState.ContainsKey(requestpath))
{
m_loginToRegionState.Add(requestpath, region.RegionInfo.RegionName.ToLower());
}
}
}
if (httpSSL)
{
rezHttpProtocol = "https://";
//regionCapsHttpProtocol = "https://";
urlport = httpsslport.ToString();
if (httpsCN.Length > 0)
httpaddr = httpsCN;
}
responseMap["connect"] = OSD.FromBoolean(true);
OSDMap capabilitiesMap = new OSDMap();
capabilitiesMap["rez_avatar/request"] = OSD.FromString(rezHttpProtocol + httpaddr + ":" + urlport + requestpath);
responseMap["capabilities"] = capabilitiesMap;
return responseMap;
}
