← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/slot/authentication.cc

Merged in plugin-slot-reorg patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/slot/authentication.cc
19
19
 */
20
20
 
21
21
#include "drizzled/server_includes.h"
22
 
#include "drizzled/authentication.h"
23
 
#include "drizzled/gettext.h"
 
22
#include "drizzled/slot/authentication.h"
24
23
#include "drizzled/errmsg_print.h"
25
24
#include "drizzled/plugin/registry.h"
 
25
#include "drizzled/plugin/authentication.h"
 
26
#include "drizzled/gettext.h"
26
27
 
27
28
#include <vector>
28
29
 
 
30
using namespace drizzled;
29
31
using namespace std;
30
32
 
31
 
static vector<Authentication *> all_authentication;
32
 
 
33
 
static bool are_plugins_loaded= false;
34
 
 
35
 
void add_authentication(Authentication *auth)
36
 
{
37
 
  all_authentication.push_back(auth);
38
 
}
39
 
 
40
 
void remove_authentication(Authentication *auth)
41
 
{
42
 
  all_authentication.erase(find(all_authentication.begin(),
43
 
                                all_authentication.end(),
44
 
                                auth));
45
 
}
46
 
 
47
 
class AuthenticateBy : public unary_function<Authentication *, bool>
 
33
 
 
34
void slot::Authentication::add(plugin::Authentication *auth)
 
35
{
 
36
  if (auth != NULL)
 
37
    all_authentication.push_back(auth);
 
38
}
 
39
 
 
40
void slot::Authentication::remove(plugin::Authentication *auth)
 
41
{
 
42
  if (auth != NULL)
 
43
    all_authentication.erase(find(all_authentication.begin(),
 
44
                                  all_authentication.end(),
 
45
                                  auth));
 
46
}
 
47
 
 
48
namespace drizzled
 
49
{
 
50
namespace slot
 
51
{
 
52
namespace auth_priv
 
53
{
 
54
 
 
55
class AuthenticateBy : public unary_function<plugin::Authentication *, bool>
48
56
{
49
57
  Session *session;
50
58
  const char *password;
51
59
public:
52
60
  AuthenticateBy(Session *session_arg, const char *password_arg) :
53
 
    unary_function<Authentication *, bool>(),
 
61
    unary_function<plugin::Authentication *, bool>(),
54
62
    session(session_arg), password(password_arg) {}
55
63
 
56
64
  inline result_type operator()(argument_type auth)
58
66
    return auth->authenticate(session, password);
59
67
  }
60
68
};
 
69
} /* namespace auth_priv */
 
70
} /* namespace slot */
 
71
} /* namespace drizzled */
61
72
 
62
 
bool authenticate_user(Session *session, const char *password)
 
73
bool slot::Authentication::authenticate(Session *session, const char *password)
63
74
{
64
75
  /* If we never loaded any auth plugins, just return true */
65
76
  if (are_plugins_loaded != true)
66
77
    return true;
67
78
 
68
79
  /* Use find_if instead of foreach so that we can collect return codes */
69
 
  vector<Authentication *>::iterator iter=
 
80
  vector<plugin::Authentication *>::iterator iter=
70
81
    find_if(all_authentication.begin(), all_authentication.end(),
71
 
            AuthenticateBy(session, password));
 
82
            slot::auth_priv::AuthenticateBy(session, password));
72
83
  /* If iter is == end() here, that means that all of the plugins returned
73
84
   * false, which in this case means they all succeeded. Since we want to 
74
85
   * return false on success, we return the value of the two being !=