← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/authorization.h

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:20:34 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114052034-b45vpdmk4a8l70c2
just a syntax fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/authorization.h
24
24
 
25
25
#include "drizzled/plugin.h"
26
26
#include "drizzled/plugin/plugin.h"
27
 
#include "drizzled/security_context.h"
28
 
#include "drizzled/table_identifier.h"
 
27
#include "drizzled/identifier.h"
29
28
 
30
29
#include <string>
31
30
#include <set>
55
54
   *
56
55
   * @returns true if the user cannot access the schema
57
56
   */
58
 
  virtual bool restrictSchema(const SecurityContext &user_ctx,
59
 
                              const std::string &schema)= 0;
 
57
  virtual bool restrictSchema(const drizzled::identifier::User &user_ctx,
 
58
                              SchemaIdentifier::const_reference schema)= 0;
60
59
 
61
60
  /**
62
61
   * Should we restrict the current user's access to this table?
67
66
   *
68
67
   * @returns true if the user cannot access the table
69
68
   */
70
 
  virtual bool restrictTable(const SecurityContext &user_ctx,
71
 
                             const std::string &schema,
72
 
                             const std::string &table);
 
69
  virtual bool restrictTable(const drizzled::identifier::User &user_ctx,
 
70
                             TableIdentifier &table);
73
71
 
74
72
  /**
75
73
   * Should we restrict the current user's access to see this process?
80
78
   *
81
79
   * @returns true if the user cannot see the process
82
80
   */
83
 
  virtual bool restrictProcess(const SecurityContext &user_ctx,
84
 
                               const SecurityContext &session_ctx);
 
81
  virtual bool restrictProcess(const drizzled::identifier::User &user_ctx,
 
82
                               const drizzled::identifier::User &session_ctx);
85
83
 
86
84
  /** Server API method for checking schema authorization */
87
 
  static bool isAuthorized(const SecurityContext &user_ctx,
88
 
                           SchemaIdentifier &schema_identifier,
 
85
  static bool isAuthorized(drizzled::identifier::User::const_shared_ptr user_ctx,
 
86
                           SchemaIdentifier::const_reference schema_identifier,
89
87
                           bool send_error= true);
90
88
 
91
89
  /** Server API method for checking table authorization */
92
 
  static bool isAuthorized(const SecurityContext &user_ctx,
93
 
                           const std::string &schema,
94
 
                           const std::string &table,
95
 
                           bool send_error= true);
96
 
 
97
 
  /** Server API method for checking process authorization */
98
 
  static bool isAuthorized(const SecurityContext &user_ctx,
 
90
  static bool isAuthorized(drizzled::identifier::User::const_shared_ptr user_ctx,
 
91
                           TableIdentifier &table_identifier,
 
92
                           bool send_error= true);
 
93
 
 
94
  /** Server API method for checking process authorization */
 
95
  static bool isAuthorized(drizzled::identifier::User::const_shared_ptr user_ctx,
 
96
                           const Session *session,
 
97
                           bool send_error= true);
 
98
 
 
99
  /** Server API method for checking process authorization */
 
100
  static bool isAuthorized(drizzled::identifier::User::const_reference user_ctx,
99
101
                           const Session *session,
100
102
                           bool send_error= true);
101
103
 
103
105
   * Server API helper method for applying authorization tests
104
106
   * to a set of schema names (for use in the context of getSchemaNames
105
107
   */
106
 
  static void pruneSchemaNames(const SecurityContext &user_ctx,
107
 
                               SchemaIdentifierList &set_of_schemas);
 
108
  static void pruneSchemaNames(drizzled::identifier::User::const_shared_ptr user_ctx,
 
109
                               SchemaIdentifier::vector &set_of_schemas);
108
110
  
109
111
  /**
110
112
   * Standard plugin system registration hooks
114
116
 
115
117
};
116
118
 
117
 
inline bool Authorization::restrictTable(const SecurityContext &user_ctx,
118
 
                                         const std::string &schema,
119
 
                                         const std::string &)
 
119
inline bool Authorization::restrictTable(const drizzled::identifier::User &user_ctx,
 
120
                                         TableIdentifier &table)
120
121
{
121
 
  return restrictSchema(user_ctx, schema);
 
122
  return restrictSchema(user_ctx, table);
122
123
}
123
124
 
124
 
inline bool Authorization::restrictProcess(const SecurityContext &,
125
 
                                           const SecurityContext &)
 
125
inline bool Authorization::restrictProcess(const drizzled::identifier::User &,
 
126
                                           const drizzled::identifier::User &)
126
127
{
127
128
  return false;
128
129
}