dep/ACE_wrappers/ace/DLL.cpp

   1 // $Id: DLL.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/DLL.h"
   4
   5 #include "ace/Log_Msg.h"
   6 #include "ace/ACE.h"
   7 #include "ace/DLL_Manager.h"
   8 #include "ace/OS_NS_string.h"
   9 #include "ace/OS_NS_dlfcn.h"
  10 #include "ace/OS_NS_Thread.h"
  11
  12 #include <algorithm>
  13
  14 ACE_RCSID(ace, DLL, "$Id: DLL.cpp 80826 2008-03-04 14:51:23Z wotte $")
  15
  16   ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 // Default constructor. Also, by default, the object will be closed
  19 // before it is destroyed.
  20
  21 ACE_DLL::ACE_DLL (bool close_handle_on_destruction)
  22   : open_mode_ (0),
  23     dll_name_ (0),
  24     close_handle_on_destruction_ (close_handle_on_destruction),
  25     dll_handle_ (0),
  26     error_ (0)
  27 {
  28   ACE_TRACE ("ACE_DLL::ACE_DLL (int)");
  29 }
  30
  31 ACE_DLL::ACE_DLL (const ACE_DLL &rhs)
  32   : open_mode_ (0),
  33     dll_name_ (0),
  34     close_handle_on_destruction_ (false),
  35     dll_handle_ (0),
  36     error_ (0)
  37 {
  38   ACE_TRACE ("ACE_DLL::ACE_DLL (const ACE_DLL &)");
  39
  40   if (rhs.dll_name_
  41       // This will automatically up the refcount.
  42       && this->open (rhs.dll_name_,
  43                      rhs.open_mode_,
  44                      rhs.close_handle_on_destruction_) != 0
  45       && ACE::debug ())
  46     ACE_ERROR ((LM_ERROR,
  47     ACE_TEXT ("ACE_DLL::copy_ctor: error: %s\n"),
  48     this->error ()));
  49 }
  50
  51 // Assignment operator
  52
  53 ACE_DLL &
  54 ACE_DLL::operator= (const ACE_DLL &rhs)
  55 {
  56   ACE_TRACE ("ACE_DLL::operator= (const ACE_DLL &)");
  57
  58   ACE_DLL tmp (rhs);
  59
  60   std::swap (this->open_mode_, tmp.open_mode_);
  61   std::swap (this->dll_name_, tmp.dll_name_);
  62   std::swap (this->close_handle_on_destruction_,
  63              tmp.close_handle_on_destruction_);
  64   std::swap (this->dll_handle_, tmp.dll_handle_);
  65   std::swap (this->error_, tmp.error_);
  66
  67   return *this;
  68 }
  69
  70
  71 // If the library name and the opening mode are specified than on
  72 // object creation the library is implicitly opened.
  73
  74 ACE_DLL::ACE_DLL (const ACE_TCHAR *dll_name,
  75                   int open_mode,
  76                   bool close_handle_on_destruction)
  77   : open_mode_ (open_mode),
  78     dll_name_ (0),
  79     close_handle_on_destruction_ (close_handle_on_destruction),
  80     dll_handle_ (0),
  81     error_ (0)
  82 {
  83   ACE_TRACE ("ACE_DLL::ACE_DLL");
  84
  85   if (this->open (dll_name, this->open_mode_, close_handle_on_destruction) != 0
  86       && ACE::debug ())
  87     ACE_ERROR ((LM_ERROR,
  88                 ACE_TEXT ("ACE_DLL::open: error calling open: %s\n"),
  89                 this->error ()));
  90 }
  91
  92 // The library is closed before the class gets destroyed depending on
  93 // the close_handle_on_destruction value specified which is stored in
  94 // close_handle_on_destruction_.
  95
  96 ACE_DLL::~ACE_DLL (void)
  97 {
  98   ACE_TRACE ("ACE_DLL::~ACE_DLL");
  99
 100   this->close ();
 101
 102   // Normally delete()d in ACE_DLL::close().  However, that may not
 103   // occur if full ACE_DLL initialization is interrupted due to errors
 104   // (e.g. attempting to open a DSO/DLL that does not exist).  Make
 105   // sure this->dll_name_ is deallocated.
 106   delete [] this->dll_name_;
 107 }
 108
 109 // This method opens the library based on the mode specified using the
 110 // ACE_SHLIB_HANDLE which is obtained on making the ACE_OS::dlopen call.
 111 // The default mode is:
 112 // RTLD_LAZY     Only references to data symbols are relocate when the
 113 //               object is first loaded.
 114 // The other modes include:
 115 //  RTLD_NOW     All necessary relocations are performed when the
 116 //               object is first loaded.
 117 //  RTLD_GLOBAL  The object symbols are made available for the
 118 //               relocation processing of any other object.
 119
 120 int
 121 ACE_DLL::open (const ACE_TCHAR *dll_filename,
 122                int open_mode,
 123                bool close_handle_on_destruction)
 124 {
 125   ACE_TRACE ("ACE_DLL::open");
 126
 127   return open_i (dll_filename, open_mode, close_handle_on_destruction);
 128 }
 129
 130 int
 131 ACE_DLL::open_i (const ACE_TCHAR *dll_filename,
 132                  int open_mode,
 133                  bool close_handle_on_destruction,
 134                  ACE_SHLIB_HANDLE handle)
 135 {
 136   ACE_TRACE ("ACE_DLL::open_i");
 137
 138   this->error_ = 0;
 139
 140   if (!dll_filename)
 141     {
 142       if (ACE::debug ())
 143         ACE_ERROR ((LM_ERROR,
 144                     ACE_TEXT ("ACE_DLL::open_i: dll_name is %s\n"),
 145                     this->dll_name_ == 0 ? ACE_TEXT ("(null)")
 146         : this->dll_name_));
 147       return -1;
 148     }
 149
 150   if (this->dll_handle_)
 151     {
 152       // If we have a good handle and its the same name, just return.
 153       if (ACE_OS::strcmp (this->dll_name_, dll_filename) == 0)
 154         return 0;
 155       else
 156         this->close ();
 157     }
 158
 159   if (!this->dll_name_)
 160     this->dll_name_ = ACE::strnew (dll_filename);
 161
 162   this->open_mode_ = open_mode;
 163   this->close_handle_on_destruction_ = close_handle_on_destruction;
 164
 165   this->dll_handle_ = ACE_DLL_Manager::instance()->open_dll (this->dll_name_,
 166                                                              this->open_mode_,
 167                                                              handle);
 168
 169   if (!this->dll_handle_)
 170     this->error_ = 1;
 171
 172   return this->error_ ? -1 : 0;
 173 }
 174
 175 // The symbol refernce of the name specified is obtained.
 176
 177 void *
 178 ACE_DLL::symbol (const ACE_TCHAR *sym_name, int ignore_errors)
 179 {
 180   ACE_TRACE ("ACE_DLL::symbol");
 181
 182   this->error_ = 0;
 183
 184   void *sym = 0;
 185   if (this->dll_handle_)
 186     sym = this->dll_handle_->symbol (sym_name, ignore_errors);
 187
 188   if (!sym)
 189     this->error_ = 1;
 190
 191   return sym;
 192 }
 193
 194 // The library is closed using the ACE_SHLIB_HANDLE object, i.e., the
 195 // shared object is now disassociated form the current process.
 196
 197 int
 198 ACE_DLL::close (void)
 199 {
 200   ACE_TRACE ("ACE_DLL::close");
 201
 202   int retval = 0;
 203
 204   if (this->dll_handle_
 205       && this->close_handle_on_destruction_
 206       && this->dll_name_
 207       && (retval = ACE_DLL_Manager::instance ()->close_dll (this->dll_name_)) != 0)
 208     this->error_ = 1;
 209
 210   // Even if close_dll() failed, go ahead and cleanup.
 211   this->dll_handle_ = 0;
 212   delete [] this->dll_name_;
 213   this->dll_name_ = 0;
 214   this->close_handle_on_destruction_ = false;
 215
 216   return retval;
 217 }
 218
 219 // This method is used return the last error of a library operation.
 220
 221 ACE_TCHAR *
 222 ACE_DLL::error (void) const
 223 {
 224   ACE_TRACE ("ACE_DLL::error");
 225   if (this->error_)
 226     {
 227       return ACE_OS::dlerror ();
 228     }
 229
 230   return 0;
 231 }
 232
 233 // Return the handle to the user either temporarily or forever, thus
 234 // orphaning it. If 0 means the user wants the handle forever and if 1
 235 // means the user temporarily wants to take the handle.
 236
 237 ACE_SHLIB_HANDLE
 238 ACE_DLL::get_handle (int become_owner) const
 239 {
 240   ACE_TRACE ("ACE_DLL::get_handle");
 241
 242   ACE_SHLIB_HANDLE handle = ACE_SHLIB_INVALID_HANDLE;
 243
 244   if (this->dll_handle_)
 245     handle = this->dll_handle_->get_handle (become_owner);
 246
 247   return handle;
 248 }
 249
 250 // Set the handle for the DLL. By default, the object will be closed
 251 // before it is destroyed.
 252
 253 int
 254 ACE_DLL::set_handle (ACE_SHLIB_HANDLE handle,
 255                      bool close_handle_on_destruction)
 256 {
 257   ACE_TRACE ("ACE_DLL::set_handle");
 258
 259   // Create a unique name.  Note that this name is only quaranteed
 260   // to be unique for the life of this object.
 261   ACE_TCHAR temp[ACE_UNIQUE_NAME_LEN];
 262   ACE_OS::unique_name (this, temp, ACE_UNIQUE_NAME_LEN);
 263
 264   return this->open_i (temp, 1, close_handle_on_destruction, handle);
 265 }
 266
 267 ACE_END_VERSIONED_NAMESPACE_DECL