← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/library.cc

  • Committer: Monty Taylor
  • Date: 2010-04-22 02:46:23 UTC
  • mto: (1497.3.4 enable-dtrace)
  • mto: This revision was merged to the branch mainline in revision 1527.
  • Revision ID: mordred@inaugust.com-20100422024623-4urw8fi8eraci08p
https://launchpad.net/bugs/561683
Don't overwrite the pandora_vc_revinfo file if we don't have new
authoratative information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/library.cc
24
24
#include <cerrno>
25
25
#include <string>
26
26
 
27
 
#include <boost/filesystem.hpp>
28
 
 
29
27
#include "drizzled/plugin.h"
30
28
#include "drizzled/definitions.h"
31
29
#include "drizzled/error.h"
32
30
#include "drizzled/errmsg_print.h"
33
 
#include "drizzled/module/library.h"
 
31
#include "drizzled/plugin/library.h"
34
32
 
35
33
using namespace std;
36
 
namespace fs=boost::filesystem;
37
34
 
38
35
namespace drizzled
39
36
{
40
37
 
41
 
module::Library::Library(const std::string &name_arg,
 
38
plugin::Library::Library(const std::string &name_arg,
42
39
                         void *handle_arg,
43
40
                         const Manifest *manifest_arg)
44
41
 : name(name_arg), handle(handle_arg), manifest(manifest_arg)
45
42
{}
46
43
 
47
 
module::Library::~Library()
 
44
plugin::Library::~Library()
48
45
{
49
46
  /**
50
47
   * @TODO: This breaks valgrind at the moment. 
53
50
  */
54
51
}
55
52
 
56
 
const fs::path module::Library::getLibraryPath(const string &plugin_name)
57
 
{
58
 
  string plugin_lib_name("lib");
59
 
  plugin_lib_name.append(plugin_name);
60
 
  plugin_lib_name.append("_plugin");
61
 
#if defined(TARGET_OS_OSX)
62
 
  plugin_lib_name.append(".dylib");
63
 
#else
64
 
  plugin_lib_name.append(".so");
65
 
#endif
66
 
 
67
 
  /* Compile dll path */
68
 
  return plugin_dir / plugin_lib_name;
69
 
}
70
 
 
71
 
module::Library *module::Library::loadLibrary(const string &plugin_name, bool builtin)
 
53
plugin::Library *plugin::Library::loadLibrary(const string &plugin_name)
72
54
{
73
55
  /*
74
56
    Ensure that the dll doesn't have a path.
82
64
    return NULL;
83
65
  }
84
66
 
85
 
  void *dl_handle= NULL;
86
 
  string dlpath("");
87
 
 
88
 
  if (builtin)
89
 
  {
90
 
    dlpath.assign("<builtin>");
91
 
    dl_handle= dlopen(NULL, RTLD_NOW|RTLD_LOCAL);
92
 
    if (dl_handle == NULL)
93
 
    {
94
 
      const char *errmsg= dlerror();
95
 
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY),
96
 
                    dlpath.c_str(), errno, errmsg);
97
 
      (void)dlerror();
98
 
 
99
 
      return NULL;
100
 
    }
101
 
  }
102
 
  else
103
 
  {
 
67
  /* Compile dll path */
 
68
  string dlpath;
 
69
  dlpath.reserve(FN_REFLEN);
 
70
  dlpath.append(opt_plugin_dir);
 
71
  dlpath.append("/");
 
72
  dlpath.append("lib");
 
73
  dlpath.append(plugin_name);
 
74
  dlpath.append("_plugin");
 
75
#if defined(TARGET_OS_OSX)
 
76
  dlpath.append(".dylib");
 
77
#else
 
78
  dlpath.append(".so");
 
79
#endif
 
80
 
104
81
  /* Open new dll handle */
105
 
    dlpath.assign(Library::getLibraryPath(plugin_name).file_string());
106
 
    dl_handle= dlopen(dlpath.c_str(), RTLD_NOW|RTLD_GLOBAL);
107
 
    if (dl_handle == NULL)
108
 
    {
109
 
      const char *errmsg= dlerror();
110
 
      uint32_t dlpathlen= dlpath.length();
111
 
      if (not dlpath.compare(0, dlpathlen, errmsg))
112
 
      { // if errmsg starts from dlpath, trim this prefix.
113
 
        errmsg+= dlpathlen;
114
 
        if (*errmsg == ':') errmsg++;
115
 
        if (*errmsg == ' ') errmsg++;
116
 
      }
117
 
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY),
118
 
                    dlpath.c_str(), errno, errmsg);
119
 
 
120
 
      // This, in theory, should cause dlerror() to deallocate the error
121
 
      // message. Found this via Google'ing :)
122
 
      (void)dlerror();
123
 
 
124
 
      return NULL;
 
82
  void *handle= dlopen(dlpath.c_str(), RTLD_NOW|RTLD_GLOBAL);
 
83
  if (handle == NULL)
 
84
  {
 
85
    const char *errmsg= dlerror();
 
86
    uint32_t dlpathlen= dlpath.length();
 
87
    if (!dlpath.compare(0, dlpathlen, errmsg))
 
88
    { // if errmsg starts from dlpath, trim this prefix.
 
89
      errmsg+=dlpathlen;
 
90
      if (*errmsg == ':') errmsg++;
 
91
      if (*errmsg == ' ') errmsg++;
125
92
    }
 
93
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY),
 
94
                  dlpath.c_str(), errno, errmsg);
 
95
 
 
96
    // This is, in theory, should cause dlerror() to deallocate the error
 
97
    // message. Found this via Google'ing :)
 
98
    (void)dlerror();
 
99
 
 
100
    return NULL;
126
101
  }
127
102
 
 
103
 
128
104
  string plugin_decl_sym("_drizzled_");
129
105
  plugin_decl_sym.append(plugin_name);
130
106
  plugin_decl_sym.append("_plugin_");
131
107
 
132
108
  /* Find plugin declarations */
133
 
  void *sym= dlsym(dl_handle, plugin_decl_sym.c_str());
 
109
  void *sym= dlsym(handle, plugin_decl_sym.c_str());
134
110
  if (sym == NULL)
135
111
  {
136
112
    const char* errmsg= dlerror();
138
114
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY),
139
115
                  plugin_decl_sym.c_str(), dlpath.c_str());
140
116
    (void)dlerror();
141
 
    dlclose(dl_handle);
 
117
    dlclose(handle);
142
118
    return NULL;
143
119
  }
144
120
 
145
 
  const Manifest *module_manifest= static_cast<module::Manifest *>(sym); 
146
 
  if (module_manifest->drizzle_version != DRIZZLE_VERSION_ID)
 
121
  const Manifest *manifest= static_cast<plugin::Manifest *>(sym); 
 
122
  if (manifest->drizzle_version != DRIZZLE_VERSION_ID)
147
123
  {
148
124
    errmsg_printf(ERRMSG_LVL_ERROR,
149
125
                  _("Plugin module %s was compiled for version %" PRIu64 ", "
150
126
                    "which does not match the current running version of "
151
127
                    "Drizzle: %" PRIu64"."),
152
 
                 dlpath.c_str(), module_manifest->drizzle_version,
153
 
                 static_cast<uint64_t>(DRIZZLE_VERSION_ID));
 
128
                 dlpath.c_str(), manifest->drizzle_version,
 
129
                 DRIZZLE_VERSION_ID);
154
130
    return NULL;
155
131
  }
156
132
 
157
 
  return new (nothrow) module::Library(plugin_name, dl_handle, module_manifest);
 
133
  return new (nothrow) plugin::Library(plugin_name, handle, manifest);
158
134
}
159
135
 
160
136
} /* namespace drizzled */