public void RegionLoaded(Scene scene)
 {
     m_scriptModule = scene.RequestModuleInterface<IScriptModule>();
     
     if (m_scriptModule != null)
         m_log.Info("[MODULE COMMANDS]: Script engine found, module active");
 }

        /// <summary>
        /// Execute code within a given module context and returns the result.
        /// The module must be local with respect to the compiled code object.
        /// </summary>
        public object Evaluate(IScriptModule module) {
            ScriptModule localModule;

            if (module == null) {
                localModule = RemoteWrapper.TryGetLocal<ScriptModule>(ScriptDomainManager.CurrentManager.Host.DefaultModule);
            } else {
                localModule = RemoteWrapper.GetLocalArgument<ScriptModule>(module, "module");
            }

            return _code.Run(localModule);
        }

 public void PublishModule(IScriptModule module, string publicName) {
     _manager.PublishModule(RemoteWrapper.GetLocalArgument<ScriptModule>(module, "module"), publicName);
 }

 public void RegionLoaded(IScene scene)
 {
     m_scriptModule = scene.RequestModuleInterface<IScriptModule>();
 }

        public UUID RequestSecureURL(IScriptModule engine, SceneObjectPart host, UUID itemID)
        {
            UUID urlcode = UUID.Random();
            string url = String.Empty;

            if (m_HttpsServer == null)
            {
                engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                return urlcode;
            }

            lock (m_UrlMap)
            {
                if (m_UrlMap.Count >= m_TotalUrls)
                {
                    engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                    return urlcode;
                }

                url = m_HttpsServer.ServerURI + "/lslhttps/" + urlcode.ToString() + "/";

                UrlData urlData = new UrlData
                {
                    hostID = host.UUID,
                    itemID = itemID,
                    engine = engine,
                    url = url,
                    urlcode = urlcode,
                    requests = new List<UUID>()
                };

                m_UrlMap[url] = urlData;
            }

            string uri = "/lslhttps/" + urlcode.ToString() + "/";
            m_HttpServer.AddStreamHandler(new AsyncRequestHandler("POST", uri, AsyncHttpRequest));
            m_HttpServer.AddStreamHandler(new AsyncRequestHandler("GET", uri, AsyncHttpRequest));

            engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_GRANTED", url });

            return urlcode;
        }

 public void ModuleCreated(IScriptModule module) {
     _host.ModuleCreated(module);
 }

        public UUID RequestSecureURL(IScriptModule engine, ISceneChildEntity host, UUID itemID)
        {
            UUID urlcode = UUID.Random();

            engine.PostScriptEvent(itemID, host.UUID, "http_request",
                                   new Object[] {urlcode.ToString(), "URL_REQUEST_DENIED", ""});

            return urlcode;
        }

 public IObjectHandle EvaluateAndWrap(IScriptModule module) {
     return _compiledCode.EvaluateAndWrap(module);
 }

 public void Execute(IScriptModule module) {
     _compiledCode.Execute(module);
 }

 public virtual void ModuleCreated(IScriptModule module)
 {
     // nop
 }

        public UUID RequestSecureURL(IScriptModule engine, SceneObjectPart host, UUID itemID, Hashtable options)
        {
            UUID urlcode = UUID.Random();

            if (m_HttpsServer == null)
            {
                engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                return urlcode;
            }

            lock (m_UrlMap)
            {
                if (m_UrlMap.Count >= TotalUrls)
                {
                    engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_DENIED", "" });
                    return urlcode;
                }
                string url = "https://" + ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + "/lslhttps/" + urlcode.ToString() + "/";

                UrlData urlData = new UrlData();
                urlData.hostID = host.UUID;
                urlData.itemID = itemID;
                urlData.engine = engine;
                urlData.url = url;
                urlData.urlcode = urlcode;
                urlData.isSsl = true;
                urlData.requests = new Dictionary<UUID, RequestData>();
                urlData.allowXss = false;

                if (options != null && options["allowXss"] != null)
                    urlData.allowXss = true;
                
                m_UrlMap[url] = urlData;
                
                string uri = "/lslhttps/" + urlcode.ToString() + "/";
               
                PollServiceEventArgs args 
                    = new PollServiceEventArgs(HttpRequestHandler, uri, HasEvents, GetEvents, NoEvents, urlcode, 25000);
                args.Type = PollServiceEventArgs.EventType.LslHttp;
                m_HttpsServer.AddPollServiceHTTPHandler(uri, args);

//                m_log.DebugFormat(
//                    "[URL MODULE]: Set up incoming secure request url {0} for {1} in {2} {3}",
//                    uri, itemID, host.Name, host.LocalId);

                engine.PostScriptEvent(itemID, "http_request", new Object[] { urlcode.ToString(), "URL_REQUEST_GRANTED", url });
            }

            return urlcode;
        }

 public void AddRegion(Scene scene)
 {
     m_scene = scene;
     m_scene.RegisterModuleInterface<IWorldComm>(this);
     m_scriptModule = scene.RequestModuleInterface<IScriptModule> ();
     m_scene.EventManager.OnChatFromClient += DeliverClientMessage;
     m_scene.EventManager.OnChatBroadcast += DeliverClientMessage;
 }

 public void PublishModule(IScriptModule module, string publicName) {
     _manager.Environment.PublishModule(module, publicName);
 }

 public CodeSenseProvider(IScriptEngine engine, IScriptModule module) {
     Contract.RequiresNotNull(engine, "engine");
     _engine = engine;
     _module = module;
 }

        /// <summary>
        /// Execute code within a given module context and returns the result.
        /// The module must be local with respect to the compiled code object.
        /// </summary>
        public object Evaluate(IScriptModule module)
        {
            IScriptModule localModule;

            if (module == null) {
                localModule = ScriptDomainManager.CurrentManager.Host.DefaultModule;
            } else {
                localModule = module;
            }

            return _code.Run((ScriptModule)localModule);
        }

 public void RegisterNewReceiver(IScriptModule scriptEngine, UUID channel, UUID objectID, UUID itemID, string uri)
 {
     scriptEngine.PostScriptEvent(itemID, objectID, "xmlrpc_uri", new Object[] {uri});
 }

 public virtual void ModuleCreated(IScriptModule module) {
     Contract.RequiresNotNull(module, "module");
     Debug.Assert(_remoteHost != null);
     _remoteHost.ModuleCreated(RemoteWrapper.WrapRemotable<IScriptModule>(module));
 }

 // throws SerializationException
 public object Evaluate(IScriptModule module) {
     return _compiledCode.Evaluate(module);
 }

 public void RegionLoaded(IScene scene)
 {
     if (IsEnabled() && !m_httpServerStarted)
     {
         m_httpServerStarted = true;
         // Start http server
         // Attach xmlrpc handlers
         MainConsole.Instance.Info("[XMLRPC MODULE]: " +
                                   "Starting up XMLRPC Server on port " + m_remoteDataPort +
                                   " for llRemoteData commands.");
         IHttpServer httpServer = new BaseHttpServer((uint) m_remoteDataPort, MainServer.Instance.HostName,
                                                     false, 1);
         httpServer.AddXmlRPCHandler("llRemoteData", XmlRpcRemoteData);
         httpServer.Start();
     }
     m_scriptModule = scene.RequestModuleInterface<IScriptModule>();
 }

        public void RegisterNewReceiver(IScriptModule scriptEngine, UUID channel, UUID objectID, UUID itemID, string uri)
        {
            if (!m_Channels.ContainsKey(itemID))
            {
                XmlRpcInfo info = new XmlRpcInfo();
                info.channel = channel;
                info.uri = uri;

                bool success = SynchronousRestObjectPoster.BeginPostObject<XmlRpcInfo, bool>(
                        "POST", m_ServerURI+"/RegisterChannel/", info);

                if (!success)
                {
                    m_log.Error("[XMLRPC GRID ROUTER] Error contacting server");
                }

                m_Channels[itemID] = channel;
            }
        }