1165 lines
48 KiB
C#
1165 lines
48 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.Remoting.Lifetime;
|
|
using System.Security.Policy;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Text;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.ScriptEngine.Interfaces;
|
|
using OpenSim.Region.ScriptEngine.Shared;
|
|
using OpenSim.Region.ScriptEngine.Shared.Api;
|
|
using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
|
|
using OpenSim.Region.ScriptEngine.Yengine;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
using log4net;
|
|
|
|
using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
|
|
using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
|
|
using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
|
|
using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
|
|
using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
|
|
using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
|
|
using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.Yengine
|
|
{
|
|
public partial class XMRInstance
|
|
{
|
|
/****************************************************************************\
|
|
* The only method of interest to outside this module is the Initializer. *
|
|
* *
|
|
* The rest of this module contains support routines for the Initializer. *
|
|
\****************************************************************************/
|
|
|
|
/**
|
|
* @brief Initializer, loads script in memory and all ready for running.
|
|
* @param engine = YEngine instance this is part of
|
|
* @param scriptBasePath = directory name where files are
|
|
* @param stackSize = number of bytes to allocate for stacks
|
|
* @param errors = return compiler errors in this array
|
|
* @param forceRecomp = force recompile
|
|
* Throws exception if any error, so it was successful if it returns.
|
|
*/
|
|
public void Initialize(Yengine engine, string scriptBasePath,
|
|
int stackSize, int heapSize, ArrayList errors)
|
|
{
|
|
if(stackSize < 16384)
|
|
stackSize = 16384;
|
|
if(heapSize < 16384)
|
|
heapSize = 16384;
|
|
|
|
// Save all call parameters in instance vars for easy access.
|
|
m_Engine = engine;
|
|
m_ScriptBasePath = scriptBasePath;
|
|
m_StackSize = stackSize;
|
|
m_StackLeft = stackSize;
|
|
m_HeapSize = heapSize;
|
|
m_CompilerErrors = errors;
|
|
m_StateFileName = GetStateFileName(scriptBasePath, m_ItemID);
|
|
|
|
// Not in any XMRInstQueue.
|
|
m_NextInst = this;
|
|
m_PrevInst = this;
|
|
|
|
// Set up list of API calls it has available.
|
|
// This also gets the API modules ready to accept setup data, such as
|
|
// active listeners being restored.
|
|
IScriptApi scriptApi;
|
|
ApiManager am = new ApiManager();
|
|
foreach(string api in am.GetApis())
|
|
{
|
|
// Instantiate the API for this script instance.
|
|
if(api != "LSL")
|
|
scriptApi = am.CreateApi(api);
|
|
else
|
|
scriptApi = m_XMRLSLApi = new XMRLSL_Api();
|
|
|
|
// Connect it up to the instance.
|
|
InitScriptApi(engine, api, scriptApi);
|
|
}
|
|
|
|
m_XMRLSLApi.InitXMRLSLApi(this);
|
|
|
|
// Get object loaded, compiling script and reading .state file as
|
|
// necessary to restore the state.
|
|
suspendOnCheckRunHold = true;
|
|
InstantiateScript();
|
|
m_SourceCode = null;
|
|
if(m_ObjCode == null)
|
|
throw new ArgumentNullException("m_ObjCode");
|
|
if(m_ObjCode.scriptEventHandlerTable == null)
|
|
throw new ArgumentNullException("m_ObjCode.scriptEventHandlerTable");
|
|
|
|
suspendOnCheckRunHold = false;
|
|
suspendOnCheckRunTemp = false;
|
|
|
|
// Declare which events the script's current state can handle.
|
|
int eventMask = GetStateEventFlags(stateCode);
|
|
m_Part.SetScriptEvents(m_ItemID, eventMask);
|
|
}
|
|
|
|
private void InitScriptApi(Yengine engine, string api, IScriptApi scriptApi)
|
|
{
|
|
// Set up m_ApiManager_<APINAME> = instance pointer.
|
|
engine.m_XMRInstanceApiCtxFieldInfos[api].SetValue(this, scriptApi);
|
|
|
|
// Initialize the API instance.
|
|
scriptApi.Initialize(m_Engine, m_Part, m_Item);
|
|
this.InitApi(api, scriptApi);
|
|
}
|
|
|
|
|
|
/*
|
|
* Get script object code loaded in memory and all ready to run,
|
|
* ready to resume it from where the .state file says it was last
|
|
*/
|
|
private void InstantiateScript()
|
|
{
|
|
bool compiledIt = false;
|
|
ScriptObjCode objCode;
|
|
|
|
// If source code string is empty, use the asset ID as the object file name.
|
|
// Allow lines of // comments at the beginning (for such as engine selection).
|
|
int i, j, len;
|
|
if(m_SourceCode == null)
|
|
m_SourceCode = String.Empty;
|
|
for(len = m_SourceCode.Length; len > 0; --len)
|
|
{
|
|
if(m_SourceCode[len - 1] > ' ')
|
|
break;
|
|
}
|
|
for(i = 0; i < len; i++)
|
|
{
|
|
char c = m_SourceCode[i];
|
|
if(c <= ' ')
|
|
continue;
|
|
if(c != '/')
|
|
break;
|
|
if((i + 1 >= len) || (m_SourceCode[i + 1] != '/'))
|
|
break;
|
|
i = m_SourceCode.IndexOf('\n', i);
|
|
if(i < 0)
|
|
i = len - 1;
|
|
}
|
|
if((i >= len))
|
|
{
|
|
// Source consists of nothing but // comments and whitespace,
|
|
// or we are being forced to use the asset-id as the key, to
|
|
// open an already existing object code file.
|
|
m_ScriptObjCodeKey = m_Item.AssetID.ToString();
|
|
if(i >= len)
|
|
m_SourceCode = "";
|
|
}
|
|
else
|
|
{
|
|
// Make up dictionary key for the object code.
|
|
// Use the same object code for identical source code
|
|
// regardless of asset ID, so we don't care if they
|
|
// copy scripts or not.
|
|
byte[] scbytes = System.Text.Encoding.UTF8.GetBytes(m_SourceCode);
|
|
StringBuilder sb = new StringBuilder((256 + 5) / 6);
|
|
using (System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256.Create())
|
|
ByteArrayToSixbitStr(sb, sha.ComputeHash(scbytes));
|
|
m_ScriptObjCodeKey = sb.ToString();
|
|
|
|
// But source code can be just a sixbit string itself
|
|
// that identifies an already existing object code file.
|
|
if(len - i == m_ScriptObjCodeKey.Length)
|
|
{
|
|
for(j = len; --j >= i;)
|
|
{
|
|
if(sixbit.IndexOf(m_SourceCode[j]) < 0)
|
|
break;
|
|
}
|
|
if(j < i)
|
|
{
|
|
m_ScriptObjCodeKey = m_SourceCode.Substring(i, len - i);
|
|
m_SourceCode = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
// There may already be an ScriptObjCode struct in memory that
|
|
// we can use. If not, try to compile it.
|
|
lock(m_CompileLock)
|
|
{
|
|
if(!m_CompiledScriptObjCode.TryGetValue(m_ScriptObjCodeKey, out objCode) || m_ForceRecomp)
|
|
{
|
|
objCode = TryToCompile();
|
|
compiledIt = true;
|
|
}
|
|
|
|
// Loaded successfully, increment reference count.
|
|
// If we just compiled it though, reset count to 0 first as
|
|
// this is the one-and-only existance of this objCode struct,
|
|
// and we want any old ones for this source code to be garbage
|
|
// collected.
|
|
|
|
if(compiledIt)
|
|
{
|
|
m_CompiledScriptObjCode[m_ScriptObjCodeKey] = objCode;
|
|
objCode.refCount = 0;
|
|
}
|
|
objCode.refCount++;
|
|
|
|
// Now set up to decrement ref count on dispose.
|
|
m_ObjCode = objCode;
|
|
}
|
|
|
|
try
|
|
{
|
|
|
|
// Fill in script instance from object code
|
|
// Script instance is put in a "never-ever-has-run-before" state.
|
|
LoadObjCode();
|
|
|
|
// Fill in script intial state
|
|
// - either as loaded from a .state file
|
|
// - or initial default state_entry() event
|
|
LoadInitialState();
|
|
}
|
|
catch
|
|
{
|
|
|
|
// If any error loading, decrement object code reference count.
|
|
DecObjCodeRefCount();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private const string sixbit = "0123456789_abcdefghijklmnopqrstuvwxyz@ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
private static void ByteArrayToSixbitStr(StringBuilder sb, byte[] bytes)
|
|
{
|
|
int bit = 0;
|
|
int val = 0;
|
|
foreach(byte b in bytes)
|
|
{
|
|
val |= (int)((uint)b << bit);
|
|
bit += 8;
|
|
while(bit >= 6)
|
|
{
|
|
sb.Append(sixbit[val & 63]);
|
|
val >>= 6;
|
|
bit -= 6;
|
|
}
|
|
}
|
|
if(bit > 0)
|
|
sb.Append(sixbit[val & 63]);
|
|
}
|
|
|
|
// Try to create object code from source code
|
|
// If error, just throw exception
|
|
private ScriptObjCode TryToCompile()
|
|
{
|
|
m_CompilerErrors.Clear();
|
|
|
|
// If object file exists, create ScriptObjCode directly from that.
|
|
// Otherwise, compile the source to create object file then create
|
|
// ScriptObjCode from that.
|
|
string assetID = m_Item.AssetID.ToString();
|
|
m_CameFrom = "asset://" + assetID;
|
|
ScriptObjCode objCode = Compile();
|
|
if(m_CompilerErrors.Count != 0)
|
|
throw new Exception("compilation errors");
|
|
|
|
if(objCode == null)
|
|
throw new Exception("compilation failed");
|
|
|
|
return objCode;
|
|
}
|
|
|
|
/*
|
|
* Retrieve source from asset server.
|
|
*/
|
|
private string FetchSource(string cameFrom)
|
|
{
|
|
m_log.Debug("[YEngine]: fetching source " + cameFrom);
|
|
if(!cameFrom.StartsWith("asset://"))
|
|
throw new Exception("unable to retrieve source from " + cameFrom);
|
|
|
|
string assetID = cameFrom.Substring(8);
|
|
AssetBase asset = m_Engine.World.AssetService.Get(assetID);
|
|
if(asset == null)
|
|
throw new Exception("source not found " + cameFrom);
|
|
|
|
string source = Encoding.UTF8.GetString(asset.Data);
|
|
if(EmptySource(source))
|
|
throw new Exception("fetched source empty " + cameFrom);
|
|
|
|
return source;
|
|
}
|
|
|
|
/*
|
|
* Fill in script object initial contents.
|
|
* Set the initial state to "default".
|
|
*/
|
|
private void LoadObjCode()
|
|
{
|
|
// Script must leave this much stack remaining on calls to CheckRun().
|
|
this.stackLimit = m_StackSize / 2;
|
|
|
|
// This is how many total heap bytes script is allowed to use.
|
|
this.heapLimit = m_HeapSize;
|
|
|
|
// Allocate global variable arrays.
|
|
this.glblVars.AllocVarArrays(m_ObjCode.glblSizes);
|
|
|
|
// Script can handle these event codes.
|
|
m_HaveEventHandlers = new bool[m_ObjCode.scriptEventHandlerTable.GetLength(1)];
|
|
for(int i = m_ObjCode.scriptEventHandlerTable.GetLength(0); --i >= 0;)
|
|
{
|
|
for(int j = m_ObjCode.scriptEventHandlerTable.GetLength(1); --j >= 0;)
|
|
{
|
|
if(m_ObjCode.scriptEventHandlerTable[i, j] != null)
|
|
{
|
|
m_HaveEventHandlers[j] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* LoadInitialState()
|
|
* if no state XML file exists for the asset,
|
|
* post initial default state events
|
|
* else
|
|
* try to restore from .state file
|
|
* If any error, throw exception
|
|
*/
|
|
private void LoadInitialState()
|
|
{
|
|
// If no .state file exists, start from default state
|
|
// Otherwise, read initial state from the .state file
|
|
|
|
if(!File.Exists(m_StateFileName))
|
|
{
|
|
m_Running = true; // event processing is enabled
|
|
eventCode = ScriptEventCode.None; // not processing any event
|
|
|
|
// default state_entry() must initialize global variables
|
|
doGblInit = true;
|
|
stateCode = 0;
|
|
|
|
PostEvent(new EventParams("state_entry",
|
|
zeroObjectArray,
|
|
zeroDetectParams));
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
string xml;
|
|
using (FileStream fs = File.Open(m_StateFileName,
|
|
FileMode.Open,
|
|
FileAccess.Read))
|
|
{
|
|
using(StreamReader ss = new StreamReader(fs))
|
|
xml = ss.ReadToEnd();
|
|
}
|
|
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml(xml);
|
|
LoadScriptState(doc);
|
|
}
|
|
catch
|
|
{
|
|
File.Delete(m_StateFileName);
|
|
|
|
m_Running = true; // event processing is enabled
|
|
eventCode = ScriptEventCode.None; // not processing any event
|
|
|
|
// default state_entry() must initialize global variables
|
|
glblVars.AllocVarArrays(m_ObjCode.glblSizes); // reset globals
|
|
doGblInit = true;
|
|
stateCode = 0;
|
|
|
|
PostEvent(new EventParams("state_entry",
|
|
zeroObjectArray,
|
|
zeroDetectParams));
|
|
}
|
|
}
|
|
|
|
// Post event(s) saying what caused the script to start.
|
|
if(m_PostOnRez)
|
|
{
|
|
PostEvent(new EventParams("on_rez",
|
|
new Object[] { m_StartParam },
|
|
zeroDetectParams));
|
|
}
|
|
|
|
switch(m_StateSource)
|
|
{
|
|
case StateSource.AttachedRez:
|
|
PostEvent(new EventParams("attach",
|
|
new object[] { m_Part.ParentGroup.AttachedAvatar.ToString() },
|
|
zeroDetectParams));
|
|
break;
|
|
|
|
case StateSource.PrimCrossing:
|
|
PostEvent(new EventParams("changed",
|
|
sbcCR,
|
|
zeroDetectParams));
|
|
break;
|
|
|
|
case StateSource.Teleporting:
|
|
PostEvent(new EventParams("changed",
|
|
sbcCR,
|
|
zeroDetectParams));
|
|
PostEvent(new EventParams("changed",
|
|
sbcCT,
|
|
zeroDetectParams));
|
|
break;
|
|
|
|
case StateSource.RegionStart:
|
|
PostEvent(new EventParams("changed",
|
|
sbcCRS,
|
|
zeroDetectParams));
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static Object[] sbcCRS = new Object[] { ScriptBaseClass.CHANGED_REGION_START };
|
|
private static Object[] sbcCR = new Object[] { ScriptBaseClass.CHANGED_REGION };
|
|
private static Object[] sbcCT = new Object[] { ScriptBaseClass.CHANGED_TELEPORT };
|
|
|
|
/**
|
|
* @brief Save compilation error messages for later retrieval
|
|
* via GetScriptErrors().
|
|
*/
|
|
private void ErrorHandler(Token token, string message)
|
|
{
|
|
if(token != null)
|
|
{
|
|
string srcloc = token.SrcLoc;
|
|
if(srcloc.StartsWith(m_CameFrom))
|
|
srcloc = srcloc.Substring(m_CameFrom.Length);
|
|
|
|
m_CompilerErrors.Add(srcloc + " Error: " + message);
|
|
}
|
|
else if(message != null)
|
|
m_CompilerErrors.Add("(0,0) Error: " + message);
|
|
else
|
|
m_CompilerErrors.Add("(0,0) Error compiling, see exception in log");
|
|
}
|
|
|
|
/**
|
|
* @brief Load script state from the given XML doc into the script memory
|
|
* <ScriptState Engine="YEngine" Asset=...>
|
|
* <Running>...</Running>
|
|
* <DoGblInit>...</DoGblInit>
|
|
* <Permissions granted=... mask=... />
|
|
* RestoreDetectParams()
|
|
* <Plugins>
|
|
* ExtractXMLObjectArray("plugin")
|
|
* </Plugins>
|
|
* <Snapshot>
|
|
* MigrateInEventHandler()
|
|
* </Snapshot>
|
|
* </ScriptState>
|
|
*/
|
|
private void LoadScriptState(XmlDocument doc)
|
|
{
|
|
|
|
// Everything we know is enclosed in <ScriptState>...</ScriptState>
|
|
XmlElement scriptStateN = (XmlElement)doc.SelectSingleNode("ScriptState");
|
|
if(scriptStateN == null)
|
|
throw new Exception("no <ScriptState> tag");
|
|
|
|
XmlElement XvariablesN = null;
|
|
string sen = scriptStateN.GetAttribute("Engine");
|
|
if((sen == null) || (sen != m_Engine.ScriptEngineName))
|
|
{
|
|
XvariablesN = (XmlElement)scriptStateN.SelectSingleNode("Variables");
|
|
if(XvariablesN == null)
|
|
throw new Exception("<ScriptState> missing Engine=\"YEngine\" attribute");
|
|
processXstate(doc);
|
|
return;
|
|
}
|
|
|
|
// AssetID is unique for the script source text so make sure the
|
|
// state file was written for that source file
|
|
string assetID = scriptStateN.GetAttribute("Asset");
|
|
if(assetID != m_Item.AssetID.ToString())
|
|
throw new Exception("<ScriptState> assetID mismatch");
|
|
|
|
// Also match the sourceHash in case script was
|
|
// loaded via 'xmroption fetchsource' and has changed
|
|
string sourceHash = scriptStateN.GetAttribute("SourceHash");
|
|
if((sourceHash == null) || (sourceHash != m_ObjCode.sourceHash))
|
|
throw new Exception("<ScriptState> SourceHash mismatch");
|
|
|
|
// Get various attributes
|
|
XmlElement runningN = (XmlElement)scriptStateN.SelectSingleNode("Running");
|
|
m_Running = bool.Parse(runningN.InnerText);
|
|
|
|
XmlElement doGblInitN = (XmlElement)scriptStateN.SelectSingleNode("DoGblInit");
|
|
doGblInit = bool.Parse(doGblInitN.InnerText);
|
|
|
|
double minEventDelay = 0.0;
|
|
XmlElement minEventDelayN = (XmlElement)scriptStateN.SelectSingleNode("mEvtDly");
|
|
if(minEventDelayN != null)
|
|
minEventDelay = Double.Parse(minEventDelayN.InnerText);
|
|
|
|
// get values used by stuff like llDetectedGrab, etc.
|
|
DetectParams[] detParams = RestoreDetectParams(scriptStateN.SelectSingleNode("DetectArray"));
|
|
|
|
// Restore queued events
|
|
LinkedList<EventParams> eventQueue = RestoreEventQueue(scriptStateN.SelectSingleNode("EventQueue"));
|
|
|
|
// Restore timers and listeners
|
|
XmlElement pluginN = (XmlElement)scriptStateN.SelectSingleNode("Plugins");
|
|
Object[] pluginData = ExtractXMLObjectArray(pluginN, "plugin");
|
|
|
|
// Script's global variables and stack contents
|
|
XmlElement snapshotN = (XmlElement)scriptStateN.SelectSingleNode("Snapshot");
|
|
|
|
Byte[] data = Convert.FromBase64String(snapshotN.InnerText);
|
|
using(MemoryStream ms = new MemoryStream())
|
|
{
|
|
ms.Write(data, 0, data.Length);
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
MigrateInEventHandler(ms);
|
|
}
|
|
|
|
XmlElement permissionsN = (XmlElement)scriptStateN.SelectSingleNode("Permissions");
|
|
m_Item.PermsGranter = new UUID(permissionsN.GetAttribute("granter"));
|
|
m_Item.PermsMask = Convert.ToInt32(permissionsN.GetAttribute("mask"));
|
|
m_Part.Inventory.UpdateInventoryItem(m_Item, false, false);
|
|
|
|
// Restore event queues, preserving any events that queued
|
|
// whilst we were restoring the state
|
|
lock (m_QueueLock)
|
|
{
|
|
m_DetectParams = detParams;
|
|
foreach(EventParams evt in m_EventQueue)
|
|
eventQueue.AddLast(evt);
|
|
|
|
m_EventQueue = eventQueue;
|
|
for(int i = m_EventCounts.Length; --i >= 0;)
|
|
m_EventCounts[i] = 0;
|
|
foreach(EventParams evt in m_EventQueue)
|
|
{
|
|
ScriptEventCode eventCode = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
|
|
evt.EventName);
|
|
m_EventCounts[(int)eventCode]++;
|
|
}
|
|
}
|
|
|
|
// Requeue timer and listeners (possibly queuing new events)
|
|
AsyncCommandManager.CreateFromData(m_Engine,
|
|
m_LocalID, m_ItemID, m_Part.UUID,
|
|
pluginData);
|
|
|
|
MinEventDelay = minEventDelay;
|
|
}
|
|
|
|
private void processXstate(XmlDocument doc)
|
|
{
|
|
|
|
XmlNodeList rootL = doc.GetElementsByTagName("ScriptState");
|
|
if (rootL.Count != 1)
|
|
throw new Exception("Xstate <ScriptState> missing");
|
|
|
|
XmlNode rootNode = rootL[0];
|
|
if (rootNode == null)
|
|
throw new Exception("Xstate root missing");
|
|
|
|
string stateName = "";
|
|
bool running = false;
|
|
|
|
UUID permsGranter = UUID.Zero;
|
|
int permsMask = 0;
|
|
double minEventDelay = 0.0;
|
|
Object[] pluginData = new Object[0];
|
|
|
|
LinkedList<EventParams> eventQueue = new LinkedList<EventParams>();
|
|
|
|
Dictionary<string, int> intNames = new Dictionary<string, int>();
|
|
Dictionary<string, int> doubleNames = new Dictionary<string, int>();
|
|
Dictionary<string, int> stringNames = new Dictionary<string, int>();
|
|
Dictionary<string, int> vectorNames = new Dictionary<string, int>();
|
|
Dictionary<string, int> rotationNames = new Dictionary<string, int>();
|
|
Dictionary<string, int> listNames = new Dictionary<string, int>();
|
|
|
|
int nn = m_ObjCode.globalVarNames.Count;
|
|
int[] ints = null;
|
|
double[] doubles = null;
|
|
string[] strings = null;
|
|
LSL_Vector[] vectors = null;
|
|
LSL_Rotation[] rotations = null;
|
|
LSL_List[] lists = null;
|
|
|
|
if (nn > 0)
|
|
{
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarIntegers"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarIntegers"], intNames);
|
|
ints = new int[m_ObjCode.globalVarNames["iarIntegers"].Count];
|
|
}
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarFloats"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarFloats"], doubleNames);
|
|
doubles = new double[m_ObjCode.globalVarNames["iarFloats"].Count];
|
|
}
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarVectors"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarVectors"], vectorNames);
|
|
vectors = new LSL_Vector[m_ObjCode.globalVarNames["iarVectors"].Count];
|
|
}
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarRotations"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarRotations"], rotationNames);
|
|
rotations = new LSL_Rotation[m_ObjCode.globalVarNames["iarRotations"].Count];
|
|
}
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarStrings"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarStrings"], stringNames);
|
|
strings = new string[m_ObjCode.globalVarNames["iarStrings"].Count];
|
|
}
|
|
if (m_ObjCode.globalVarNames.ContainsKey("iarLists"))
|
|
{
|
|
getvarNames(m_ObjCode.globalVarNames["iarLists"], listNames);
|
|
lists = new LSL_List[m_ObjCode.globalVarNames["iarLists"].Count];
|
|
}
|
|
}
|
|
|
|
int heapsz = 0;
|
|
|
|
try
|
|
{
|
|
XmlNodeList partL = rootNode.ChildNodes;
|
|
foreach (XmlNode part in partL)
|
|
{
|
|
switch (part.Name)
|
|
{
|
|
case "State":
|
|
stateName = part.InnerText;
|
|
break;
|
|
case "Running":
|
|
running = bool.Parse(part.InnerText);
|
|
break;
|
|
case "Variables":
|
|
int indx;
|
|
XmlNodeList varL = part.ChildNodes;
|
|
foreach (XmlNode var in varL)
|
|
{
|
|
string varName;
|
|
object o = ReadXTypedValue(var, out varName);
|
|
Type otype = o.GetType();
|
|
if (otype == typeof(LSL_Integer))
|
|
{
|
|
if (intNames.TryGetValue(varName, out indx))
|
|
ints[indx] = ((LSL_Integer)o);
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_Float))
|
|
{
|
|
if (doubleNames.TryGetValue(varName, out indx))
|
|
doubles[indx] = ((LSL_Float)o);
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_String))
|
|
{
|
|
if (stringNames.TryGetValue(varName, out indx))
|
|
{
|
|
strings[indx] = ((LSL_String)o);
|
|
heapsz += ((LSL_String)o).Length;
|
|
}
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_Rotation))
|
|
{
|
|
if (rotationNames.TryGetValue(varName, out indx))
|
|
rotations[indx] = ((LSL_Rotation)o);
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_Vector))
|
|
{
|
|
if (vectorNames.TryGetValue(varName, out indx))
|
|
vectors[indx] = ((LSL_Vector)o);
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_Key))
|
|
{
|
|
if (stringNames.TryGetValue(varName, out indx))
|
|
{
|
|
strings[indx] = ((LSL_Key)o);
|
|
heapsz += ((LSL_String)o).Length;
|
|
}
|
|
continue;
|
|
}
|
|
if (otype == typeof(UUID))
|
|
{
|
|
if (stringNames.TryGetValue(varName, out indx))
|
|
{
|
|
LSL_String id = ((UUID)o).ToString();
|
|
strings[indx] = (id);
|
|
heapsz += id.Length;
|
|
}
|
|
continue;
|
|
}
|
|
if (otype == typeof(LSL_List))
|
|
{
|
|
if (listNames.TryGetValue(varName, out indx))
|
|
{
|
|
LSL_List lo = (LSL_List)o;
|
|
lists[indx] = (lo);
|
|
heapsz += lo.Size;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
case "Queue":
|
|
XmlNodeList itemL = part.ChildNodes;
|
|
foreach (XmlNode item in itemL)
|
|
{
|
|
List<Object> parms = new List<Object>();
|
|
List<DetectParams> detected = new List<DetectParams>();
|
|
|
|
string eventName = item.Attributes.GetNamedItem("event").Value;
|
|
XmlNodeList eventL = item.ChildNodes;
|
|
foreach (XmlNode evt in eventL)
|
|
{
|
|
switch (evt.Name)
|
|
{
|
|
case "Params":
|
|
XmlNodeList prms = evt.ChildNodes;
|
|
foreach (XmlNode pm in prms)
|
|
parms.Add(ReadXTypedValue(pm));
|
|
|
|
break;
|
|
case "Detected":
|
|
XmlNodeList detL = evt.ChildNodes;
|
|
foreach (XmlNode det in detL)
|
|
{
|
|
string vect = det.Attributes.GetNamedItem("pos").Value;
|
|
LSL_Vector v = new LSL_Vector(vect);
|
|
|
|
int d_linkNum = 0;
|
|
UUID d_group = UUID.Zero;
|
|
string d_name = String.Empty;
|
|
UUID d_owner = UUID.Zero;
|
|
LSL_Vector d_position = new LSL_Vector();
|
|
LSL_Rotation d_rotation = new LSL_Rotation();
|
|
int d_type = 0;
|
|
LSL_Vector d_velocity = new LSL_Vector();
|
|
|
|
try
|
|
{
|
|
string tmp;
|
|
|
|
tmp = det.Attributes.GetNamedItem("linkNum").Value;
|
|
int.TryParse(tmp, out d_linkNum);
|
|
|
|
tmp = det.Attributes.GetNamedItem("group").Value;
|
|
UUID.TryParse(tmp, out d_group);
|
|
|
|
d_name = det.Attributes.GetNamedItem("name").Value;
|
|
|
|
tmp = det.Attributes.GetNamedItem("owner").Value;
|
|
UUID.TryParse(tmp, out d_owner);
|
|
|
|
tmp = det.Attributes.GetNamedItem("position").Value;
|
|
d_position = new LSL_Types.Vector3(tmp);
|
|
|
|
tmp = det.Attributes.GetNamedItem("rotation").Value;
|
|
d_rotation = new LSL_Rotation(tmp);
|
|
|
|
tmp = det.Attributes.GetNamedItem("type").Value;
|
|
int.TryParse(tmp, out d_type);
|
|
|
|
tmp = det.Attributes.GetNamedItem("velocity").Value;
|
|
d_velocity = new LSL_Vector(tmp);
|
|
}
|
|
catch (Exception) // Old version XML
|
|
{
|
|
}
|
|
|
|
UUID uuid = new UUID();
|
|
UUID.TryParse(det.InnerText, out uuid);
|
|
|
|
DetectParams d = new DetectParams();
|
|
d.Key = uuid;
|
|
d.OffsetPos = v;
|
|
d.LinkNum = d_linkNum;
|
|
d.Group = d_group;
|
|
d.Name = d_name;
|
|
d.Owner = d_owner;
|
|
d.Position = d_position;
|
|
d.Rotation = d_rotation;
|
|
d.Type = d_type;
|
|
d.Velocity = d_velocity;
|
|
|
|
detected.Add(d);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
EventParams ep = new EventParams(
|
|
eventName, parms.ToArray(),
|
|
detected.ToArray());
|
|
eventQueue.AddLast(ep);
|
|
}
|
|
break;
|
|
case "Plugins":
|
|
List<Object> olist = new List<Object>();
|
|
XmlNodeList itemLP = part.ChildNodes;
|
|
foreach (XmlNode item in itemLP)
|
|
olist.Add(ReadXTypedValue(item));
|
|
pluginData = olist.ToArray();
|
|
break;
|
|
case "Permissions":
|
|
string tmpPerm;
|
|
int mask = 0;
|
|
tmpPerm = part.Attributes.GetNamedItem("mask").Value;
|
|
if (tmpPerm != null)
|
|
{
|
|
int.TryParse(tmpPerm, out mask);
|
|
if (mask != 0)
|
|
{
|
|
tmpPerm = part.Attributes.GetNamedItem("granter").Value;
|
|
if (tmpPerm != null)
|
|
{
|
|
UUID granter = new UUID();
|
|
UUID.TryParse(tmpPerm, out granter);
|
|
if (granter != UUID.Zero)
|
|
{
|
|
permsMask = mask;
|
|
permsGranter = granter;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case "MinEventDelay":
|
|
double.TryParse(part.InnerText, out minEventDelay);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw new Exception("Xstate fail decode");
|
|
}
|
|
|
|
int k = 0;
|
|
stateCode = 0;
|
|
foreach (string sn in m_ObjCode.stateNames)
|
|
{
|
|
if (stateName == sn)
|
|
{
|
|
stateCode = k;
|
|
break;
|
|
}
|
|
k++;
|
|
}
|
|
eventCode = ScriptEventCode.None;
|
|
m_Running = running;
|
|
doGblInit = false;
|
|
|
|
m_Item.PermsGranter = permsGranter;
|
|
m_Item.PermsMask = permsMask;
|
|
m_Part.Inventory.UpdateInventoryItem(m_Item, false, false);
|
|
|
|
lock (m_RunLock)
|
|
{
|
|
glblVars.iarIntegers = ints;
|
|
glblVars.iarFloats = doubles;
|
|
glblVars.iarVectors = vectors;
|
|
glblVars.iarRotations = rotations;
|
|
glblVars.iarStrings = strings;
|
|
glblVars.iarLists = lists;
|
|
|
|
AddHeapUse(heapsz);
|
|
CheckRunLockInvariants(true);
|
|
}
|
|
|
|
lock (m_QueueLock)
|
|
{
|
|
m_DetectParams = null;
|
|
foreach (EventParams evt in m_EventQueue)
|
|
eventQueue.AddLast(evt);
|
|
|
|
m_EventQueue = eventQueue;
|
|
for (int i = m_EventCounts.Length; --i >= 0;)
|
|
m_EventCounts[i] = 0;
|
|
foreach (EventParams evt in m_EventQueue)
|
|
{
|
|
ScriptEventCode evtCode = (ScriptEventCode)Enum.Parse(typeof(ScriptEventCode),
|
|
evt.EventName);
|
|
m_EventCounts[(int)evtCode]++;
|
|
}
|
|
}
|
|
|
|
AsyncCommandManager.CreateFromData(m_Engine,
|
|
m_LocalID, m_ItemID, m_Part.UUID, pluginData);
|
|
|
|
MinEventDelay = minEventDelay;
|
|
}
|
|
|
|
private static void getvarNames(Dictionary<int, string> s, Dictionary<string, int> d)
|
|
{
|
|
foreach(KeyValuePair<int, string> kvp in s)
|
|
d[kvp.Value] = kvp.Key;
|
|
}
|
|
|
|
private static LSL_Types.list ReadXList(XmlNode parent)
|
|
{
|
|
List<Object> olist = new List<Object>();
|
|
|
|
XmlNodeList itemL = parent.ChildNodes;
|
|
foreach (XmlNode item in itemL)
|
|
olist.Add(ReadXTypedValue(item));
|
|
|
|
return new LSL_Types.list(olist.ToArray());
|
|
}
|
|
|
|
private static object ReadXTypedValue(XmlNode tag, out string name)
|
|
{
|
|
name = tag.Attributes.GetNamedItem("name").Value;
|
|
|
|
return ReadXTypedValue(tag);
|
|
}
|
|
|
|
private static object ReadXTypedValue(XmlNode tag)
|
|
{
|
|
Object varValue;
|
|
string assembly;
|
|
|
|
string itemType = tag.Attributes.GetNamedItem("type").Value;
|
|
|
|
if (itemType == "list")
|
|
return ReadXList(tag);
|
|
|
|
if (itemType == "OpenMetaverse.UUID")
|
|
{
|
|
UUID val = new UUID();
|
|
UUID.TryParse(tag.InnerText, out val);
|
|
|
|
return val;
|
|
}
|
|
|
|
Type itemT = Type.GetType(itemType);
|
|
if (itemT == null)
|
|
{
|
|
Object[] args =
|
|
new Object[] { tag.InnerText };
|
|
|
|
assembly = itemType + ", OpenSim.Region.ScriptEngine.Shared";
|
|
itemT = Type.GetType(assembly);
|
|
if (itemT == null)
|
|
return null;
|
|
|
|
varValue = Activator.CreateInstance(itemT, args);
|
|
|
|
if (varValue == null)
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
varValue = Convert.ChangeType(tag.InnerText, itemT);
|
|
}
|
|
return varValue;
|
|
}
|
|
|
|
/**
|
|
* @brief Read llDetectedGrab, etc, values from XML
|
|
* <EventQueue>
|
|
* <DetectParams>...</DetectParams>
|
|
* .
|
|
* .
|
|
* .
|
|
* </EventQueue>
|
|
*/
|
|
private LinkedList<EventParams> RestoreEventQueue(XmlNode eventsN)
|
|
{
|
|
LinkedList<EventParams> eventQueue = new LinkedList<EventParams>();
|
|
if(eventsN != null)
|
|
{
|
|
XmlNodeList eventL = eventsN.SelectNodes("Event");
|
|
foreach(XmlNode evnt in eventL)
|
|
{
|
|
string name = ((XmlElement)evnt).GetAttribute("Name");
|
|
object[] parms = ExtractXMLObjectArray(evnt, "param");
|
|
DetectParams[] detects = RestoreDetectParams(evnt);
|
|
|
|
if(parms == null)
|
|
parms = zeroObjectArray;
|
|
if(detects == null)
|
|
detects = zeroDetectParams;
|
|
|
|
EventParams evt = new EventParams(name, parms, detects);
|
|
eventQueue.AddLast(evt);
|
|
}
|
|
}
|
|
return eventQueue;
|
|
}
|
|
|
|
/**
|
|
* @brief Read llDetectedGrab, etc, values from XML
|
|
* <DetectArray>
|
|
* <DetectParams>...</DetectParams>
|
|
* .
|
|
* .
|
|
* .
|
|
* </DetectArray>
|
|
*/
|
|
private DetectParams[] RestoreDetectParams(XmlNode detectedN)
|
|
{
|
|
if(detectedN == null)
|
|
return null;
|
|
|
|
List<DetectParams> detected = new List<DetectParams>();
|
|
XmlNodeList detectL = detectedN.SelectNodes("DetectParams");
|
|
|
|
DetectParams detprm = new DetectParams();
|
|
foreach(XmlNode detxml in detectL)
|
|
{
|
|
try
|
|
{
|
|
detprm.Group = new UUID(detxml.Attributes.GetNamedItem("group").Value);
|
|
detprm.Key = new UUID(detxml.Attributes.GetNamedItem("key").Value);
|
|
detprm.Owner = new UUID(detxml.Attributes.GetNamedItem("owner").Value);
|
|
|
|
detprm.LinkNum = Int32.Parse(detxml.Attributes.GetNamedItem("linkNum").Value);
|
|
detprm.Type = Int32.Parse(detxml.Attributes.GetNamedItem("type").Value);
|
|
|
|
detprm.Name = detxml.Attributes.GetNamedItem("name").Value;
|
|
|
|
detprm.OffsetPos = new LSL_Types.Vector3(detxml.Attributes.GetNamedItem("pos").Value);
|
|
detprm.Position = new LSL_Types.Vector3(detxml.Attributes.GetNamedItem("position").Value);
|
|
detprm.Velocity = new LSL_Types.Vector3(detxml.Attributes.GetNamedItem("velocity").Value);
|
|
|
|
detprm.Rotation = new LSL_Types.Quaternion(detxml.Attributes.GetNamedItem("rotation").Value);
|
|
|
|
detected.Add(detprm);
|
|
detprm = new DetectParams();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
m_log.Warn("[YEngine]: RestoreDetectParams bad XML: " + detxml.ToString());
|
|
m_log.Warn("[YEngine]: ... " + e.ToString());
|
|
}
|
|
}
|
|
|
|
return detected.ToArray();
|
|
}
|
|
|
|
/**
|
|
* @brief Extract elements of an array of objects from an XML parent.
|
|
* Each element is of form <tag ...>...</tag>
|
|
* @param parent = XML parent to extract them from
|
|
* @param tag = what the value's tag is
|
|
* @returns object array of the values
|
|
*/
|
|
private static object[] ExtractXMLObjectArray(XmlNode parent, string tag)
|
|
{
|
|
List<Object> olist = new List<Object>();
|
|
|
|
XmlNodeList itemL = parent.SelectNodes(tag);
|
|
foreach(XmlNode item in itemL)
|
|
{
|
|
olist.Add(ExtractXMLObjectValue(item));
|
|
}
|
|
|
|
return olist.ToArray();
|
|
}
|
|
|
|
private static object ExtractXMLObjectValue(XmlNode item)
|
|
{
|
|
string itemType = item.Attributes.GetNamedItem("type").Value;
|
|
|
|
if(itemType == "list")
|
|
{
|
|
return new LSL_List(ExtractXMLObjectArray(item, "item"));
|
|
}
|
|
|
|
if(itemType == "OpenMetaverse.UUID")
|
|
{
|
|
UUID val = new UUID();
|
|
UUID.TryParse(item.InnerText, out val);
|
|
return val;
|
|
}
|
|
|
|
Type itemT = Type.GetType(itemType);
|
|
if(itemT == null)
|
|
{
|
|
Object[] args = new Object[] { item.InnerText };
|
|
|
|
string assembly = itemType + ", OpenSim.Region.ScriptEngine.Shared";
|
|
itemT = Type.GetType(assembly);
|
|
if(itemT == null)
|
|
{
|
|
return null;
|
|
}
|
|
return Activator.CreateInstance(itemT, args);
|
|
}
|
|
|
|
return Convert.ChangeType(item.InnerText, itemT);
|
|
}
|
|
|
|
/*
|
|
* Migrate an event handler in from a stream.
|
|
*
|
|
* Input:
|
|
* stream = as generated by MigrateOutEventHandler()
|
|
*/
|
|
private void MigrateInEventHandler(Stream stream)
|
|
{
|
|
int mv = stream.ReadByte();
|
|
if(mv != migrationVersion)
|
|
throw new Exception("incoming migration version " + mv + " but accept only " + migrationVersion);
|
|
|
|
stream.ReadByte(); // ignored
|
|
|
|
/*
|
|
* Restore script variables and stack and other state from stream.
|
|
* And it also marks us busy (by setting this.eventCode) so we can't be
|
|
* started again and this event lost. If it restores this.eventCode =
|
|
* None, the the script was idle.
|
|
*/
|
|
lock(m_RunLock)
|
|
{
|
|
BinaryReader br = new BinaryReader(stream);
|
|
this.MigrateIn(br);
|
|
|
|
m_RunOnePhase = "MigrateInEventHandler finished";
|
|
CheckRunLockInvariants(true);
|
|
}
|
|
}
|
|
}
|
|
}
|