/// <summary>
/// Called by the script task update handler. Provides a URL to which the client can upload a new asset.
/// </summary>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <param name="httpRequest">HTTP request header object</param>
/// <param name="httpResponse">HTTP response header object</param>
/// <returns></returns>
public string ScriptTaskInventory(string request, string path, string param,
IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
try
{
// m_log.Debug("[CAPS]: ScriptTaskInventory Request in region: " + m_regionName);
//m_log.DebugFormat("[CAPS]: request: {0}, path: {1}, param: {2}", request, path, param);
Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
LLSDTaskScriptUpdate llsdUpdateRequest = new LLSDTaskScriptUpdate();
LLSDHelpers.DeserialiseOSDMap(hash, llsdUpdateRequest);
string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
TaskInventoryScriptUpdater uploader =
new TaskInventoryScriptUpdater(
llsdUpdateRequest.item_id,
llsdUpdateRequest.task_id,
llsdUpdateRequest.is_script_running,
capsBase + uploaderPath,
m_HostCapsObj.HttpListener,
m_dumpAssetsToFile);
uploader.OnUpLoad += TaskScriptUpdated;
m_HostCapsObj.HttpListener.AddStreamHandler(
new BinaryStreamHandler(
"POST", capsBase + uploaderPath, uploader.uploaderCaps, "TaskInventoryScriptUpdater", null));
string protocol = "http://";
if (m_HostCapsObj.SSLCaps)
{
protocol = "https://";
}
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
// m_log.InfoFormat("[CAPS]: " +
// "ScriptTaskInventory response: {0}",
// LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
return(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
}
catch (Exception e)
{
m_log.Error("[CAPS]: " + e.ToString());
}
return(null);
}
/// <summary>
/// Called by the notecard update handler. Provides a URL to which the client can upload a new asset.
/// </summary>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <returns></returns>
public string NoteCardAgentInventory(string request, string path, string param,
IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
//m_log.Debug("[CAPS]: NoteCardAgentInventory Request in region: " + m_regionName + "\n" + request);
//m_log.Debug("[CAPS]: NoteCardAgentInventory Request is: " + request);
//OpenMetaverse.StructuredData.OSDMap hash = (OpenMetaverse.StructuredData.OSDMap)OpenMetaverse.StructuredData.LLSDParser.DeserializeBinary(Utils.StringToBytes(request));
Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
LLSDItemUpdate llsdRequest = new LLSDItemUpdate();
LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
ItemUpdater uploader =
new ItemUpdater(llsdRequest.item_id, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
uploader.OnUpLoad += ItemUpdated;
m_HostCapsObj.HttpListener.AddStreamHandler(
new BinaryStreamHandler(
"POST", capsBase + uploaderPath, uploader.uploaderCaps, "NoteCardAgentInventory", null));
string protocol = "http://";
if (m_HostCapsObj.SSLCaps)
{
protocol = "https://";
}
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
// m_log.InfoFormat("[CAPS]: " +
// "NoteCardAgentInventory response: {0}",
// LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
return(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
}
/// <summary>
/// Handle a request from the client for a Uri to upload a baked texture.
/// </summary>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <param name="httpRequest"></param>
/// <param name="httpResponse"></param>
/// <returns>The upload response if the request is successful, null otherwise.</returns>
public string UploadBakedTexture(
string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
{
try
{
m_log.DebugFormat("[UploadBakedTextureHandler]: UploadBakedTexture(request: {0}, path: {1}, param: {2} ...)", request, path, param);
string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
BakedTextureUploader uploader =
new BakedTextureUploader(capsBase + uploaderPath, m_HostCapsObj.HttpListener);
uploader.OnUpLoad += BakedTextureUploaded;
m_HostCapsObj.HttpListener.AddStreamHandler(
new BinaryStreamHandler(
"POST", capsBase + uploaderPath, uploader.uploaderCaps, "UploadBakedTexture", null));
string protocol = "http://";
if (m_HostCapsObj.SSLCaps)
{
protocol = "https://";
}
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" +
m_HostCapsObj.Port.ToString() + capsBase + uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
return(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
}
catch (Exception e)
{
m_log.ErrorFormat("[UploadBakedTextureHandler]: {0}{1}", e.Message, e.StackTrace);
}
return(null);
}
public void UploadBakedTexture(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID, Caps caps, IAssetCache cache)
{
if (httpRequest.HttpMethod != "POST")
{
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
try
{
string capsBase = "/" + UUID.Random() + "-BK";
string protocol = caps.SSLCaps ? "https://" : "http://";
string uploaderURL = protocol + caps.HostName + ":" + caps.Port.ToString() + capsBase;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
BakedTextureUploader uploader =
new BakedTextureUploader(capsBase, caps.HttpListener, agentID, cache, httpRequest.RemoteIPEndPoint.Address);
var uploaderHandler = new SimpleBinaryHandler("POST", capsBase, uploader.process);
uploaderHandler.MaxDataSize = 6000000; // change per asset type?
caps.HttpListener.AddSimpleStreamHandler(uploaderHandler);
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
httpResponse.StatusCode = (int)HttpStatusCode.OK;
return;
}
catch (Exception e)
{
m_log.ErrorFormat("[UPLOAD BAKED TEXTURE HANDLER]: {0}{1}", e.Message, e.StackTrace);
}
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
}
/// <summary>
/// Handle a request from the client for a Uri to upload a baked texture.
/// </summary>
/// <param name="request"></param>
/// <param name="path"></param>
/// <param name="param"></param>
/// <param name="httpRequest"></param>
/// <param name="httpResponse"></param>
/// <returns>The upload response if the request is successful, null otherwise.</returns>
public string UploadBakedTexture(
string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
try
{
IAssetCache assetCache = m_Scene.CommsManager.AssetCache;
IJ2KDecoder layerDecoder = m_Scene.RequestModuleInterface <IJ2KDecoder>();
String uploaderPath = m_Caps.CapsBase + "/" + UUID.Random();
BakedTextureUploader uploader = new BakedTextureUploader(m_Caps, uploaderPath, assetCache, layerDecoder);
m_Caps.HttpListener.AddStreamHandler(new BinaryStreamHandler("POST", uploaderPath, uploader.BakedTextureUploaded));
string uploaderURL = m_Caps.HttpListener.ServerURI + uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
return(LLSDHelpers.SerializeLLSDReply(uploadResponse));
}
catch (Exception e)
{
m_log.ErrorFormat("[UPLOAD BAKED TEXTURE HANDLER]: {0}{1}", e.Message, e.StackTrace);
}
return(null);
}
private void UpdateInventoryItemAsset(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap map, byte atype, bool taskSript = false)
{
m_log.Debug("[CAPS]: UpdateInventoryItemAsset Request in region: " + m_regionName + "\n");
httpResponse.StatusCode = (int)HttpStatusCode.OK;
UUID itemID = UUID.Zero;
UUID objectID = UUID.Zero;
try
{
if (map.TryGetValue("item_id", out OSD itmp))
{
itemID = itmp;
}
if (map.TryGetValue("task_id", out OSD tmp))
{
objectID = tmp;
}
}
catch { }
if (itemID == UUID.Zero)
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "failed to recode request";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
if (objectID != UUID.Zero)
{
SceneObjectPart sop = m_Scene.GetSceneObjectPart(objectID);
if (sop == null)
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "object not found";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
if (!m_Scene.Permissions.CanEditObjectInventory(objectID, m_AgentID))
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "No permissions to edit objec";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
}
string uploaderPath = GetNewCapPath();
string protocol = m_HostCapsObj.SSLCaps ? "https://" : "http://";
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
ItemUpdater uploader = new ItemUpdater(itemID, objectID, atype, uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
uploader.m_remoteAdress = httpRequest.RemoteIPEndPoint.Address;
uploader.OnUpLoad += ItemUpdated;
var uploaderHandler = new SimpleBinaryHandler("POST", uploaderPath, uploader.process);
uploaderHandler.MaxDataSize = 10000000; // change per asset type?
m_HostCapsObj.HttpListener.AddSimpleStreamHandler(uploaderHandler);
// m_log.InfoFormat("[CAPS]: UpdateAgentInventoryAsset response: {0}",
// LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
}
/// <summary>
/// Called by the script task update handler. Provides a URL to which the client can upload a new asset.
/// </summary>
/// <param name="httpRequest">HTTP request header object</param>
/// <param name="httpResponse">HTTP response header object</param>
/// <returns></returns>
public void UpdateScriptTaskInventory(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap map)
{
httpResponse.StatusCode = (int)HttpStatusCode.OK;
try
{
//m_log.Debug("[CAPS]: ScriptTaskInventory Request in region: " + m_regionName);
//m_log.DebugFormat("[CAPS]: request: {0}, path: {1}, param: {2}", request, path, param);
UUID itemID = UUID.Zero;
UUID objectID = UUID.Zero;
bool is_script_running = false;
UUID experience_key = UUID.Zero;
OSD tmp;
try
{
if (map.TryGetValue("item_id", out tmp))
{
itemID = tmp;
}
if (map.TryGetValue("task_id", out tmp))
{
objectID = tmp;
}
if (map.TryGetValue("is_script_running", out tmp))
{
is_script_running = tmp;
}
if (map.TryGetValue("experience", out tmp))
{
experience_key = tmp;
}
}
catch { }
if (itemID == UUID.Zero || objectID == UUID.Zero)
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "failed to recode request";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
SceneObjectPart sop = m_Scene.GetSceneObjectPart(objectID);
if (sop == null)
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "object not found";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
if (!m_Scene.Permissions.CanEditObjectInventory(objectID, m_AgentID))
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "No permissions to edit objec";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
if (!m_Scene.Permissions.CanEditScript(itemID, objectID, m_AgentID))
{
LLSDAssetUploadError error = new LLSDAssetUploadError();
error.message = "No permissions to edit script";
error.identifier = UUID.Zero;
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(error));
return;
}
string uploaderPath = GetNewCapPath();
string protocol = m_HostCapsObj.SSLCaps ? "https://" : "http://";
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
TaskInventoryScriptUpdater uploader = new TaskInventoryScriptUpdater(itemID, objectID, is_script_running, experience_key,
uploaderPath, m_HostCapsObj.HttpListener, httpRequest.RemoteIPEndPoint.Address, m_dumpAssetsToFile);
uploader.OnUpLoad += TaskScriptUpdated;
var uploaderHandler = new SimpleBinaryHandler("POST", uploaderPath, uploader.process);
uploaderHandler.MaxDataSize = 10000000; // change per asset type?
m_HostCapsObj.HttpListener.AddSimpleStreamHandler(uploaderHandler);
// m_log.InfoFormat("[CAPS]: " +
// "ScriptTaskInventory response: {0}",
// LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
httpResponse.RawBuffer = Util.UTF8NBGetbytes(LLSDHelpers.SerialiseLLSDReply(uploadResponse));
}
catch (Exception e)
{
m_log.Error("[UpdateScriptTaskInventory]: " + e.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="llsdRequest"></param>
/// <returns></returns>
public LLSDAssetUploadResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest)
{
//m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
//m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);
if (llsdRequest.asset_type == "texture" ||
llsdRequest.asset_type == "animation" ||
llsdRequest.asset_type == "sound")
{
ScenePresence avatar = null;
IClientAPI client = null;
m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);
// check user level
if (avatar != null)
{
client = avatar.ControllingClient;
if (avatar.UserLevel < m_levelUpload)
{
if (client != null)
{
client.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
}
LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
errorResponse.uploader = "";
errorResponse.state = "error";
return(errorResponse);
}
}
// check funds
if (client != null)
{
IMoneyModule mm = m_Scene.RequestModuleInterface <IMoneyModule>();
if (mm != null)
{
if (!mm.UploadCovered(client.AgentId, mm.UploadCharge))
{
client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
errorResponse.uploader = "";
errorResponse.state = "error";
return(errorResponse);
}
}
}
}
string assetName = llsdRequest.name;
string assetDes = llsdRequest.description;
string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
UUID newAsset = UUID.Random();
UUID newInvItem = UUID.Random();
UUID parentFolder = llsdRequest.folder_id;
string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
AssetUploader uploader =
new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
llsdRequest.asset_type, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
m_HostCapsObj.HttpListener.AddStreamHandler(
new BinaryStreamHandler(
"POST",
capsBase + uploaderPath,
uploader.uploaderCaps,
"NewAgentInventoryRequest",
m_HostCapsObj.AgentID.ToString()));
string protocol = "http://";
if (m_HostCapsObj.SSLCaps)
{
protocol = "https://";
}
string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
uploaderPath;
LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
uploadResponse.uploader = uploaderURL;
uploadResponse.state = "upload";
uploader.OnUpLoad += UploadCompleteHandler;
return(uploadResponse);
}
