← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/authorization.cc

  • Committer: Andrew Hutchings
  • Date: 2010-12-09 13:44:51 UTC
  • mfrom: (1986 real-trunk)
  • mto: This revision was merged to the branch mainline in revision 2006.
  • Revision ID: andrew@linuxjedi.co.uk-20101209134451-hsu1l98ks2pwvucu
Merge trunk into branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/authorization.cc
29
29
#include "drizzled/session.h"
30
30
#include "drizzled/gettext.h"
31
31
 
32
 
using namespace std;
33
 
 
34
32
namespace drizzled
35
33
{
36
34
 
37
 
vector<plugin::Authorization *> authorization_plugins;
 
35
std::vector<plugin::Authorization *> authorization_plugins;
38
36
 
39
37
 
40
38
bool plugin::Authorization::addPlugin(plugin::Authorization *auth)
41
39
{
42
40
  if (auth != NULL)
43
41
    authorization_plugins.push_back(auth);
 
42
 
44
43
  return false;
45
44
}
46
45
 
48
47
{
49
48
  if (auth != NULL)
50
49
  {
51
 
    authorization_plugins.erase(find(authorization_plugins.begin(),
52
 
                                     authorization_plugins.end(),
53
 
                                     auth));
 
50
    authorization_plugins.erase(std::find(authorization_plugins.begin(),
 
51
                                          authorization_plugins.end(),
 
52
                                          auth));
54
53
  }
55
54
}
56
55
 
58
57
{
59
58
 
60
59
class RestrictDbFunctor :
61
 
  public unary_function<plugin::Authorization *, bool>
 
60
  public std::unary_function<plugin::Authorization *, bool>
62
61
{
63
62
  const SecurityContext &user_ctx;
64
63
  SchemaIdentifier &schema;
65
64
public:
66
65
  RestrictDbFunctor(const SecurityContext &user_ctx_arg,
67
66
                    SchemaIdentifier &schema_arg) :
68
 
    unary_function<plugin::Authorization *, bool>(),
 
67
    std::unary_function<plugin::Authorization *, bool>(),
69
68
    user_ctx(user_ctx_arg),
70
69
    schema(schema_arg)
71
70
  { }
77
76
};
78
77
 
79
78
class RestrictTableFunctor :
80
 
  public unary_function<plugin::Authorization *, bool>
 
79
  public std::unary_function<plugin::Authorization *, bool>
81
80
{
82
81
  const SecurityContext &user_ctx;
83
82
  TableIdentifier &table;
84
83
public:
85
84
  RestrictTableFunctor(const SecurityContext &user_ctx_arg,
86
85
                       TableIdentifier &table_arg) :
87
 
    unary_function<plugin::Authorization *, bool>(),
 
86
    std::unary_function<plugin::Authorization *, bool>(),
88
87
    user_ctx(user_ctx_arg),
89
88
    table(table_arg)
90
89
  { }
96
95
};
97
96
 
98
97
class RestrictProcessFunctor :
99
 
  public unary_function<plugin::Authorization *, bool>
 
98
  public std::unary_function<plugin::Authorization *, bool>
100
99
{
101
100
  const SecurityContext &user_ctx;
102
101
  const SecurityContext &session_ctx;
103
102
public:
104
103
  RestrictProcessFunctor(const SecurityContext &user_ctx_arg,
105
104
                         const SecurityContext &session_ctx_arg) :
106
 
    unary_function<plugin::Authorization *, bool>(),
 
105
    std::unary_function<plugin::Authorization *, bool>(),
107
106
    user_ctx(user_ctx_arg),
108
107
    session_ctx(session_ctx_arg)
109
108
  { }
115
114
};
116
115
 
117
116
class PruneSchemaFunctor :
118
 
  public unary_function<SchemaIdentifier&, bool>
 
117
  public std::unary_function<SchemaIdentifier&, bool>
119
118
{
120
119
  const SecurityContext &user_ctx;
121
120
public:
122
121
  PruneSchemaFunctor(const SecurityContext &user_ctx_arg) :
123
 
    unary_function<SchemaIdentifier&, bool>(),
 
122
    std::unary_function<SchemaIdentifier&, bool>(),
124
123
    user_ctx(user_ctx_arg)
125
124
  { }
126
125
 
141
140
    return true;
142
141
 
143
142
  /* Use find_if instead of foreach so that we can collect return codes */
144
 
  vector<plugin::Authorization *>::const_iterator iter=
145
 
    find_if(authorization_plugins.begin(),
146
 
            authorization_plugins.end(),
147
 
            RestrictDbFunctor(user_ctx, schema_identifier));
 
143
  std::vector<plugin::Authorization *>::const_iterator iter=
 
144
    std::find_if(authorization_plugins.begin(),
 
145
                 authorization_plugins.end(),
 
146
                 RestrictDbFunctor(user_ctx, schema_identifier));
148
147
 
149
148
 
150
149
  /*
178
177
    return true;
179
178
 
180
179
  /* Use find_if instead of foreach so that we can collect return codes */
181
 
  vector<plugin::Authorization *>::const_iterator iter=
182
 
    find_if(authorization_plugins.begin(),
 
180
  std::vector<plugin::Authorization *>::const_iterator iter=
 
181
    std::find_if(authorization_plugins.begin(),
183
182
            authorization_plugins.end(),
184
183
            RestrictTableFunctor(user_ctx, table));
185
184
 
216
215
    return true;
217
216
 
218
217
  /* Use find_if instead of foreach so that we can collect return codes */
219
 
  vector<plugin::Authorization *>::const_iterator iter=
220
 
    find_if(authorization_plugins.begin(),
221
 
            authorization_plugins.end(),
222
 
            RestrictProcessFunctor(user_ctx, session_ctx));
 
218
  std::vector<plugin::Authorization *>::const_iterator iter=
 
219
    std::find_if(authorization_plugins.begin(),
 
220
                 authorization_plugins.end(),
 
221
                 RestrictProcessFunctor(user_ctx, session_ctx));
223
222
 
224
223
  /*
225
224
   * If iter is == end() here, that means that all of the plugins returned
239
238
}
240
239
 
241
240
void plugin::Authorization::pruneSchemaNames(const SecurityContext &user_ctx,
242
 
                                             SchemaIdentifiers &set_of_schemas)
 
241
                                             SchemaIdentifier::vector &set_of_schemas)
243
242
{
244
243
  /* If we never loaded any authorization plugins, just return true */
245
244
  if (authorization_plugins.empty())
246
245
    return;
247
246
 
248
 
  set_of_schemas.erase(remove_if(set_of_schemas.begin(),
249
 
                                 set_of_schemas.end(),
250
 
                                 PruneSchemaFunctor(user_ctx)),
 
247
  set_of_schemas.erase(std::remove_if(set_of_schemas.begin(),
 
248
                                      set_of_schemas.end(),
 
249
                                      PruneSchemaFunctor(user_ctx)),
251
250
                       set_of_schemas.end());
252
251
}
253
252