include/dynamic.h

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #ifndef __DLL_H
  15 #define __DLL_H
  16
  17 /** The DLLManager class is able to load a module file by filename,
  18  * and locate its init_module symbol.
  19  */
  20 class CoreExport DLLManager : public classbase
  21 {
  22  protected:
  23
  24         /** The last error string, or NULL
  25          */
  26         const char *err;
  27
  28  public:
  29         /** This constructor loads the module using dlopen()
  30          * @param fname The filename to load. This should be within
  31          * the modules dir.
  32          */
  33         DLLManager(const char *fname);
  34         virtual ~DLLManager();
  35
  36         /** Get a symbol using dynamic linking.
  37          * @param v A function pointer, pointing at an init_module function
  38          * @param sym_name The symbol name to find, usually "init_module"
  39          * @return true if the symbol can be found, also the symbol will be put into v.
  40          */
  41         bool GetSymbol(void **v, const char *sym_name);
  42
  43         /** Get the last error from dlopen() or dlsym().
  44          * @return The last error string, or NULL if no error has occured.
  45          */
  46         const char* LastError()
  47         {
  48                  return err;
  49         }
  50
  51         /** The module handle.
  52          * This is OS dependent, on POSIX platforms it is a pointer to a function
  53          * pointer (yes, really!) and on windows it is a library handle.
  54          */
  55         void *h;
  56 };
  57
  58 class CoreExport LoadModuleException : public CoreException
  59 {
  60  public:
  61         /** This constructor can be used to specify an error message before throwing.
  62          */
  63         LoadModuleException(const std::string &message)
  64         : CoreException(message, "the core")
  65         {
  66         }
  67
  68         /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
  69          * Actually no, it does nothing. Never mind.
  70          * @throws Nothing!
  71          */
  72         virtual ~LoadModuleException() throw() {};
  73 };
  74
  75 class CoreExport FindSymbolException : public CoreException
  76 {
  77  public:
  78         /** This constructor can be used to specify an error message before throwing.
  79          */
  80         FindSymbolException(const std::string &message)
  81         : CoreException(message, "the core")
  82         {
  83         }
  84
  85         /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
  86          * Actually no, it does nothing. Never mind.
  87          * @throws Nothing!
  88          */
  89         virtual ~FindSymbolException() throw() {};
  90 };
  91
  92 class Module;
  93 /** This is the highest-level class of the DLLFactory system used to load InspIRCd modules and commands.
  94  * All the dirty mucking around with dl*() is done by DLLManager, all this does it put a pretty shell on
  95  * it and make it nice to use to load modules and core commands. This class is quite specialised for these
  96  * two uses and it may not be useful more generally -- use DLLManager directly for that.
  97  */
  98 class CoreExport DLLFactory : public DLLManager
  99 {
 100  public:
 101         typedef Module* (initfunctype)();
 102
 103         /** Pointer to the init function.
 104          */
 105         initfunctype* const init_func;
 106
 107         /** Default constructor.
 108          * This constructor passes its paramerers down through DLLFactoryBase and then DLLManager
 109          * to load the module, then calls the factory function to retrieve a pointer to a ModuleFactory
 110          * class. It is then down to the core to call the ModuleFactory::CreateModule() method and
 111          * receive a Module* which it can insert into its module lists.
 112          */
 113         DLLFactory(const char *fname, const char *func_name)
 114         : DLLManager(fname), init_func(NULL)
 115         {
 116                 const char* error = LastError();
 117
 118                 if(!error)
 119                 {
 120                         if(!GetSymbol((void **)&init_func, func_name))
 121                         {
 122                                 throw FindSymbolException("Missing " + std::string(func_name) + "() entrypoint!");
 123                         }
 124                 }
 125                 else
 126                 {
 127                         throw LoadModuleException(error);
 128                 }
 129         }
 130
 131         /** The destructor deletes the ModuleFactory pointer.
 132          */
 133         ~DLLFactory()
 134         {
 135         }
 136 };
 137
 138 #endif
 139