Esempio n. 1
0
        /// <summary>
        /// Loads all the available plugins from the Dll files located in the specified directory
        /// </summary>
        /// <param name="pluginDirectoryPath">The path to the directory where the files which contains plugins are</param>
        /// <param name="pluginExtension">The extension of the plugin files</param>
        public void LoadPlugins(string pluginDirectoryPath, string pluginExtension)
        {
            string[] files;
            DllInfo  dllInfo;

            lock (lockObject)
            {
                if (!pluginExtension.StartsWith("*."))
                {
                    pluginExtension = "*." + pluginExtension;
                }
                files = Directory.GetFiles(pluginDirectoryPath, pluginExtension);

                for (int i = 0; i < files.Length; ++i)
                {
                    try
                    {
                        Assembly assembly = Assembly.LoadFrom(files[i]);
                        dllInfo = DllInfo.GetDllInfo(files[i]);
                        //if (IntPtr.Size != dllInfo.PointerSize)
                        //{
                        //    message += "File: " + files[i] + ", Ptr: " + dllInfo.PointerSize + "\r\n";
                        //    continue;
                        //}
                        this.rwPluginsLock.AcquireWriterLock(-1);
                        if (dllInfo.IsManagedAssembly)
                        {
                            LoadPluginsFromManagedDll(dllInfo);
                        }
                        else
                        {
                            LoadPluginsFromUnmanagedDll(dllInfo);
                        }
                        this.rwPluginsLock.ReleaseWriterLock();
                    }
                    //catch (BadImageFormatException)
                    //{
                    //    plugin = LoadUnmanagedPlugin(files[i]);
                    //    if(plugin != null)
                    //        plugins.Add(plugin);
                    //}
                    catch { }
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Loads plugins from a managed Dll file
        /// </summary>
        /// <param name="dll">A DllInfo object which contains information about the file which contains the plugins to load</param>
        protected virtual void LoadPluginsFromManagedDll(DllInfo dll)
        {
            Assembly assembly;

            Type[] types;
            Plugin instance;

            assembly = Assembly.LoadFile(dll.FilePath);

            if (assembly.ManifestModule.Name == "Robotics.dll")
            {
                return;
            }
            types = assembly.GetTypes();

            foreach (Type type in types)
            {
                if ((type.GetInterface(pluginTypeName) == null) || type.IsAbstract)
                {
                    continue;
                }

                try
                {
                    instance = (Plugin)assembly.CreateInstance(type.FullName);

                    if (String.IsNullOrEmpty(instance.Name) || plugins.ContainsKey(instance.Name))
                    {
                        continue;
                    }
                    this.plugins.Add(instance.Name, instance);
                    this.pluginsInitialized = false;
                }
                catch { continue; }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// GEts information about a Dll
        /// </summary>
        /// <param name="fileName">Path of the dll file</param>
        /// <returns>A DllInfo object which contains information about the Dll</returns>
        public static DllInfo GetDllInfo(string fileName)
        {
            // Code from
            // http://stackoverflow.com/questions/367761/how-to-determine-whether-a-dll-is-a-managed-assembly-or-native-prevent-loading
            // Enhanced with code from
            // http://stackoverflow.com/questions/8593264/determining-if-a-dll-is-a-valid-clr-dll-by-reading-the-pe-directly-64bit-issue

            uint   peHeader;
            uint   peHeaderSignature;
            ushort dataDictionaryStart;
            int    dataDirectoriesOffset;

            Stream       fs      = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            BinaryReader reader  = new BinaryReader(fs);
            DllInfo      dllInfo = new DllInfo();

            dllInfo.filePath = (new FileInfo(fileName)).FullName;

            //PE Header starts at 0x3C (60). Its a 4 byte header.
            fs.Position = 0x3C;
            peHeader    = reader.ReadUInt32();

            //Moving to PE Header start location...
            fs.Position       = peHeader;
            peHeaderSignature = reader.ReadUInt32();

            // Number identifying type of target machine.
            // Section 3.3.1 of the PE format specification.
            dllInfo.machine = reader.ReadUInt16();
            // Number of sections; indicates size of the Section Table,
            // which immediately follows the headers.
            dllInfo.sections = reader.ReadUInt16();
            // Time and date the file was created.
            dllInfo.timestamp = reader.ReadUInt32();
            // File offset of the COFF symbol table or 0 if none is present.
            dllInfo.pSymbolTable = reader.ReadUInt32();
            // Number of entries in the symbol table.
            // This data can be used in locating the string table, which immediately follows the symbol table
            dllInfo.noOfSymbol = reader.ReadUInt32();
            // Size of the optional header, which is required for executable files but not for object files
            dllInfo.optionalHeaderSize = reader.ReadUInt16();
            //
            dllInfo.characteristics = reader.ReadUInt16();

            dataDirectoriesOffset = GetDataDirectoriesOffset(fs, reader);

            // Now we are at the end of the PE Header and from here,
            // the PE Optional Headers starts...
            // To go directly to the datadictionary, we'll increase the stream’s
            // current position to with 96 (0x60).
            // 96 because, 28 for Standard fields 68 for NT-specific fields
            // From here DataDictionary starts...and its of total 128 bytes.
            //
            // DataDictionay has 16 directories in total, doing simple maths 128/16 = 8.
            // So each directory is of 8 bytes. In this 8 bytes, 4 bytes is of RVA and 4 bytes of Size.
            // By the way, the 15th directory consist of CLR header! if its 0, its not a CLR file :)
            dataDictionaryStart = Convert.ToUInt16(Convert.ToUInt16(fs.Position) + dataDirectoriesOffset);
            fs.Position         = dataDictionaryStart;
            for (int i = 0; i < 15; i++)
            {
                dllInfo.directories[i] = new DataDictionay(reader.ReadUInt32(), reader.ReadUInt32());
            }
            fs.Close();

            return(dllInfo);
        }
Esempio n. 4
0
 /// <summary>
 /// When overriden in a derived class, it allows the PLuginManager to load plugins from an unmanaged Dll file.
 /// By default no unmanaged plugins are loaded.
 /// </summary>
 /// <param name="dll">A DllInfo object which contains information about the file which contains the plugins to load</param>
 protected virtual void LoadPluginsFromUnmanagedDll(DllInfo dll)
 {
 }