Exemplo n.º 1
0
        private static IScriptStructure CreateComplexType(TypeReference type, IReadOnlyDictionary <GenericParameter, TypeReference> arguments)
        {
            type = GetElementType(type, arguments);
            if (IsEngineStruct(type))
            {
                return(ScriptStructure.EngineTypeToScriptStructure(type.Name));
            }

            PrimitiveType primType = ToPrimitiveType(type);

            if (primType == PrimitiveType.Complex)
            {
                if (IsEnginePointer(type))
                {
                    return(new ScriptPointer(type));
                }
                else
                {
                    return(new MonoStructure(type.Resolve(), arguments));
                }
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 2
0
        public ScriptAssemblies.IScript LoadScript(ScriptStructure script)
        {
            // Find next available AppDomain to put it in
            AppDomainStructure FreeAppDomain;

            // If we already have loaded file, then reuse that AppDomains
            if (AppDomainFiles.ContainsKey(script.AssemblyFileName))
            {
                FreeAppDomain = AppDomainFiles[script.AssemblyFileName];
            }
            else
            {
                FreeAppDomain = GetFreeAppDomain();
            }

            // Set script object AppDomain
            script.AppDomain = FreeAppDomain.CurrentAppDomain;

            // Create instance of script
            ScriptAssemblies.IScript mbrt = (ScriptAssemblies.IScript)
                                            FreeAppDomain.CurrentAppDomain.CreateInstanceFromAndUnwrap(
                script.AssemblyFileName, "ScriptAssemblies.Script");
            //, true, BindingFlags.CreateInstance, null);
            FreeAppDomain.ScriptsLoaded++;

            return(mbrt);
        }
Exemplo n.º 3
0
 public void ExecuteCommand(ref ScriptStructure scriptContainer, EventParams p)
 {
     m_log.DebugFormat("[{0}] ######################################################", Name);
     m_log.DebugFormat("[{0}] Command execution ItemID {1}: \"{2}\".", Name, scriptContainer.ItemID, p.EventName);
     scriptContainer.ExecuteEvent(p);
     m_log.DebugFormat("[{0}] ######################################################", Name);
 }
Exemplo n.º 4
0
        private static IScriptStructure CreateComplexType(TypeReference type)
        {
            TypeReference elementType = GetElementType(type);

            if (IsEngineStruct(elementType))
            {
                return(ScriptStructure.EngineTypeToScriptStructure(elementType.Name));
            }

            TypeDefinition definition = elementType.Resolve();

            if (definition.IsEnum)
            {
                return(null);
            }

            PrimitiveType primType = ToPrimitiveType(elementType);

            if (primType == PrimitiveType.Complex)
            {
                if (IsEnginePointer(elementType))
                {
                    return(new ScriptPointer(elementType));
                }
                else
                {
                    return(new MonoStructure(definition));
                }
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 5
0
        public void ExecuteCommand(EventParams p)
        {
            ScriptStructure ss = new ScriptStructure();

            if (TryGetScript(p.LocalID, p.ItemID, ref ss))
            {
                ExecuteCommand(ref ss, p);
            }
        }
        //private Dictionary<InstanceData, DetectParams[]> detparms = new Dictionary<InstanceData, DetectParams[]>();

        // Load/Unload structure


        public void AddScript(ScriptStructure script)
        {
            lock (LUQueue)
            {
                if ((LUQueue.Count >= LoadUnloadMaxQueueSize))
                {
                    m_log.ErrorFormat("[{0}] ERROR: Load queue count is at {1} of max {2}. Ignoring load request for script LocalID: {3}, ItemID: {4}.",
                                      Name, LUQueue.Count, LoadUnloadMaxQueueSize, script.LocalID, script.ItemID);
                    return;
                }

                LoadUnloadStructure ls = new LoadUnloadStructure();
                ls.Script = script;
                ls.Action = LoadUnloadStructure.LUType.Load;
                LUQueue.Enqueue(ls);
            }
        }
Exemplo n.º 7
0
        public bool TryGetScript(uint localID, UUID itemID, ref ScriptStructure script)
        {
            lock (scriptLock)
            {
                if (Scripts.ContainsKey(localID) == false)
                {
                    return(false);
                }

                Dictionary <UUID, ScriptStructure> Obj;
                if (Scripts.TryGetValue(localID, out Obj))
                {
                    if (Obj.ContainsKey(itemID) == false)
                    {
                        return(false);
                    }
                }

                // Get script
                return(Obj.TryGetValue(itemID, out script));
            }
        }
        //internal Dictionary<int, IScriptScheduler> ScriptMapping = new Dictionary<int, IScriptScheduler>();


        //
        // HANDLE EVENTS FROM SCRIPTS
        // We will handle script add, change and remove events outside of command pipeline
        //
        #region Script Add/Change/Remove
        void Events_RezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine)
        {
            // ###
            // # New script created
            // ###
            m_log.DebugFormat(
                "[{0}] NEW SCRIPT: localID: {1}, itemID: {2}, startParam: {3}, postOnRez: {4}, engine: {5}",
                Name, localID, itemID, startParam, postOnRez, engine);

            // Make a script object
            ScriptStructure scriptObject = new ScriptStructure();

            scriptObject.RegionInfo = RegionInfo;
            scriptObject.LocalID    = localID;
            scriptObject.ItemID     = itemID;
            scriptObject.Source     = script;

            //
            // Get MetaData from script header
            //
            ScriptMetaData scriptMetaData = ScriptMetaData.Extract(ref script);

            scriptObject.ScriptMetaData = scriptMetaData;
            foreach (string key in scriptObject.ScriptMetaData.Keys)
            {
                m_log.DebugFormat("[{0}] Script metadata: Key: \"{1}\", Value: \"{2}\".", Name, key, scriptObject.ScriptMetaData[key]);
            }

            //
            // Load this assembly
            //
            // TODO: Use Executor to send a command instead?
            m_log.DebugFormat("[{0}] Adding script to scheduler", Name);
            RegionInfo.FindScheduler(scriptObject.ScriptMetaData).AddScript(scriptObject);
            // Add to our internal mapping
            //ScriptMapping.Add(itemID, Schedulers[scheduler]);
        }
Exemplo n.º 9
0
        private void MemAddScript(ScriptStructure script)
        {
            lock (scriptLock)
            {
                // Create object if it doesn't exist
                if (!Scripts.ContainsKey(script.LocalID))
                {
                    Scripts.Add(script.LocalID, new Dictionary <UUID, ScriptStructure>());
                }

                // Delete script if it exists
                Dictionary <UUID, ScriptStructure> Obj;
                if (Scripts.TryGetValue(script.LocalID, out Obj))
                {
                    if (Obj.ContainsKey(script.ItemID) == true)
                    {
                        Obj.Remove(script.ItemID);
                    }
                }

                // Add to object
                Obj.Add(script.ItemID, script);
            }
        }
        public void _StopScript(uint localID, UUID itemID)
        {
            ScriptStructure ss = new ScriptStructure();

            if (!TryGetScript(localID, itemID, ref ss))
            {
                return;
            }

            m_log.DebugFormat("[{0}] Unloading script", Name);

            // Stop long command on script
            //AsyncCommandManager.RemoveScript(ss);

            try
            {
                // Get AppDomain
                // Tell script not to accept new requests
                ss.Running  = false;
                ss.Disabled = true;
                //AppDomain ad = ss.AppDomain;

                // Remove from internal structure
                MemRemoveScript(localID, itemID);

                // TODO: Tell AppDomain that we have stopped script
            }
            catch (Exception e) // LEGIT: User Scripting
            {
                m_log.Error("[" +
                            Name +
                            "]: Exception stopping script localID: " +
                            localID + " LLUID: " + itemID.ToString() +
                            ": " + e.ToString());
            }
        }
Exemplo n.º 11
0
 public void AddScript(ScriptStructure scriptStructure)
 {
     m_ScriptManager.AddScript(scriptStructure);
 }
Exemplo n.º 12
0
        public static void MakeBaseClass(ScriptStructure script)
        {
            string asmName     = "ScriptAssemblies";
            string ModuleID    = asmName;
            string ClassID     = "Script";
            string moveToDir   = "ScriptEngines";
            string asmFileName = ModuleID + "_" + ClassID + ".dll";

            if (!Directory.Exists(moveToDir))
            {
                Directory.CreateDirectory(moveToDir);
            }

            ILGenerator     ilgen;
            AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName(asmName), AssemblyBuilderAccess.RunAndSave);

            // The module builder
            ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(ModuleID, asmFileName);

            // The class builder
            TypeBuilder classBuilder = modBuilder.DefineType(ClassID, TypeAttributes.Class | TypeAttributes.Public);

            // The default constructor
            //ConstructorBuilder ctorBuilder = classBuilder.DefineDefaultConstructor(MethodAttributes.Public);


            Type[] paramsTypeArray          = new Type[] { typeof(System.ParamArrayAttribute) };
            Type[] executeFunctionTypeArray = new Type[] { typeof(string), typeof(System.ParamArrayAttribute) };
            foreach (IScriptCommandProvider cp in script.RegionInfo.CommandProviders.Values)
            {
                Type t = cp.GetType();
                foreach (MethodInfo mi in t.GetMethods())
                {
                    MethodBuilder methodBuilder = classBuilder.DefineMethod(mi.Name, mi.Attributes, mi.GetType(), Type.EmptyTypes);
                    methodBuilder.SetParameters(paramsTypeArray);
                    //ParameterBuilder paramBuilder = methodBuilder.DefineParameter(1, ParameterAttributes.None, "args");

                    ilgen = methodBuilder.GetILGenerator();
                    //ilgen.Emit(OpCodes.Nop);
                    //ilgen.Emit(OpCodes.Ldarg_0);
                    //ilgen.Emit(OpCodes.Ldc_I4_0);
                    //ilgen.Emit(OpCodes.Ldelem_Ref);
                    //ilgen.MarkSequencePoint(doc, 6, 1, 6, 100);

                    //MethodInfo ExecuteFunction = typeof(ScriptAssemblies.IScript).GetMethod(
                    // "ExecuteFunction",
                    // executeFunctionTypeArray);

                    ilgen.DeclareLocal(typeof(string));
                    ilgen.Emit(OpCodes.Nop);
                    ilgen.Emit(OpCodes.Ldstr, mi.Name);
                    ilgen.Emit(OpCodes.Stloc_0);
                    ilgen.Emit(OpCodes.Ldarg_0);
                    ilgen.Emit(OpCodes.Ldloc_0);
                    ilgen.Emit(OpCodes.Ldarg_1);

                    //                FieldInfo testInfo = classBuilder.
                    //BindingFlags.NonPublic | BindingFlags.Instance);

                    //ilgen.Emit(OpCodes.Ldfld, testInfo);

                    //ilgen.EmitCall(OpCodes.Call, ExecuteFunction, executeFunctionTypeArray);
                    ilgen.EmitCall(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine"), executeFunctionTypeArray);

                    //    // string.Format("Hello, {0} World!", toWhom)
                    //    //
                    //    ilgen.Emit(OpCodes.Ldstr, "Hello, {0} World!");
                    //    ilgen.Emit(OpCodes.Ldarg_1);
                    //    ilgen.Emit(OpCodes.Call, typeof(string).GetMethod
                    //("Format", new Type[] { typeof(string), typeof(object) }));

                    //    // m_log.Debug("Hello, World!");
                    //    //
                    //    ilgen.Emit(OpCodes.Call, typeof(Console).GetMethod
                    //    ("WriteLine", new Type[] { typeof(string) }));
                    ilgen.Emit(OpCodes.Ret);



                    //Label eom = ilgen.DefineLabel();
                    //ilgen.Emit(OpCodes.Br_S, eom);
                    //ilgen.MarkLabel(eom);
                    //ilgen.Emit(OpCodes.Ret);
                    //Type test = methodBuilder.SetParameters();


                    //methodBuilder.SetParameters(typeof (object[]));
                }
            }


            //// Two fields: m_firstname, m_lastname
            //FieldBuilder fBuilderFirstName = classBuilder.DefineField("m_firstname", typeof(string), FieldAttributes.Private);
            //FieldBuilder fBuilderLastName = classBuilder.DefineField("m_lastname", typeof(string), FieldAttributes.Private);

            //// Two properties for this object: FirstName, LastName
            //PropertyBuilder pBuilderFirstName = classBuilder.DefineProperty("FirstName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);
            //PropertyBuilder pBuilderLastName = classBuilder.DefineProperty("LastName", System.Reflection.PropertyAttributes.HasDefault, typeof(string), null);

            //// Custom attributes for get, set accessors
            //MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName;

            //// get,set accessors for FirstName
            //MethodBuilder mGetFirstNameBuilder = classBuilder.DefineMethod("get_FirstName", getSetAttr, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetFirstNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldfld, fBuilderFirstName); // returning the firstname field
            //ilgen.Emit(OpCodes.Ret);

            //MethodBuilder mSetFirstNameBuilder = classBuilder.DefineMethod("set_FirstName", getSetAttr, null, new Type[] { typeof(string) });

            //// Code generation
            //ilgen = mSetFirstNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Stfld, fBuilderFirstName); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ret);

            //// get,set accessors for LastName
            //MethodBuilder mGetLastNameBuilder = classBuilder.DefineMethod("get_LastName", getSetAttr, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetLastNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldfld, fBuilderLastName); // returning the firstname field
            //ilgen.Emit(OpCodes.Ret);

            //MethodBuilder mSetLastNameBuilder = classBuilder.DefineMethod("set_LastName", getSetAttr, null, new Type[] { typeof(string) });

            //// Code generation
            //ilgen = mSetLastNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Stfld, fBuilderLastName); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ret);

            //// Assigning get/set accessors
            //pBuilderFirstName.SetGetMethod(mGetFirstNameBuilder);
            //pBuilderFirstName.SetSetMethod(mSetFirstNameBuilder);

            //pBuilderLastName.SetGetMethod(mGetLastNameBuilder);
            //pBuilderLastName.SetSetMethod(mSetLastNameBuilder);

            //// Now, a custom method named GetFullName that concatenates FirstName and LastName properties
            //MethodBuilder mGetFullNameBuilder = classBuilder.DefineMethod("GetFullName", MethodAttributes.Public, typeof(string), Type.EmptyTypes);

            //// Code generation
            //ilgen = mGetFullNameBuilder.GetILGenerator();
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, mGetFirstNameBuilder); // getting the firstname
            //ilgen.Emit(OpCodes.Ldstr, " "); // an space
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, mGetLastNameBuilder); // getting the lastname

            //// We need the 'Concat' method from string type
            //MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });

            //ilgen.Emit(OpCodes.Call, concatMethod); // calling concat and returning the result
            //ilgen.Emit(OpCodes.Ret);

            //// Another constructor that initializes firstname and lastname
            //ConstructorBuilder ctorBuilder2 = classBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(string), typeof(string) });
            //ctorBuilder2.DefineParameter(1, ParameterAttributes.In, "firstname");
            //ctorBuilder2.DefineParameter(2, ParameterAttributes.In, "lastname");

            //// Code generation
            //ilgen = ctorBuilder2.GetILGenerator();

            //// First of all, we need to call the base constructor,
            //// the Object's constructor in this sample
            //Type objType = Type.GetType("System.Object");
            //ConstructorInfo objCtor = objType.GetConstructor(Type.EmptyTypes);

            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Call, objCtor); // calling the Object's constructor

            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_1);
            //ilgen.Emit(OpCodes.Call, mSetFirstNameBuilder); // setting the firstname field from the first argument (1)
            //ilgen.Emit(OpCodes.Ldarg_0);
            //ilgen.Emit(OpCodes.Ldarg_2);
            //ilgen.Emit(OpCodes.Call, mSetLastNameBuilder);  // setting the lastname field from the second argument (2)
            //ilgen.Emit(OpCodes.Ret);

            // Finally, create the type and save the assembly
            classBuilder.CreateType();

            asmBuilder.Save(asmFileName);
            string toFile = Path.Combine(moveToDir, asmFileName);

            if (File.Exists(toFile))
            {
                File.Delete(toFile);
            }
            File.Move(asmFileName, toFile);

            //string a = "";
        }