#ifndef _H_CDSA_CLIENT_DLCLIENT
#define _H_CDSA_CLIENT_DLCLIENT 1
#include <security_cdsa_client/cssmclient.h>
#include <security_cdsa_client/dliterators.h>
#include <security_cdsa_client/aclclient.h>
#include <security_cdsa_client/DLDBList.h>
#include <security_cdsa_utilities/cssmacl.h>
#include <security_cdsa_utilities/cssmdb.h>
#include <security_cdsa_utilities/cssmdata.h>
namespace Security
{
namespace CssmClient
{
#define CSSM_DB_ATTR(ATTR) ATTR
#define CSSM_DB_ATTR_SCHEMA(ATTR) ATTR ## Schema
#define CSSM_DB_INDEX(ATTR) ATTR ## Index
#define CSSM_DB_UNIQUE(ATTR) ATTR ## Unique
#define CSSM_DB_INDEX_DECL(ATTR) static const CSSM_DB_INDEX_INFO CSSM_DB_INDEX(ATTR)
#define CSSM_DB_UNIQUE_DECL(ATTR) static const CSSM_DB_INDEX_INFO CSSM_DB_UNIQUE(ATTR)
#define CSSM_DB_INDEX_DEF(ATTR) \
const CSSM_DB_INDEX_INFO CSSM_DB_INDEX(ATTR) = \
{ \
CSSM_DB_INDEX_NONUNIQUE, \
CSSM_DB_INDEX_ON_ATTRIBUTE, \
CSSM_DB_ATTR(ATTR) \
}
#define CSSM_DB_UNIQUE_DEF(ATTR) \
const CSSM_DB_INDEX_INFO CSSM_DB_UNIQUE(ATTR) = \
{ \
CSSM_DB_INDEX_UNIQUE, \
CSSM_DB_INDEX_ON_ATTRIBUTE, \
CSSM_DB_ATTR(ATTR) \
}
#define CSSM_DB_ATTR_DECL(ATTR) \
static const CSSM_DB_ATTRIBUTE_INFO CSSM_DB_ATTR(ATTR); \
static const CSSM_DB_SCHEMA_ATTRIBUTE_INFO CSSM_DB_ATTR_SCHEMA(ATTR)
#define CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \
const CSSM_DB_SCHEMA_ATTRIBUTE_INFO CSSM_DB_ATTR_SCHEMA(ATTR) = \
{ \
INTEGER, \
NAME, \
{ OID_LEN, OID_DATA }, \
CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \
}
#define CSSM_DB_INTEGER_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \
const CSSM_DB_ATTRIBUTE_INFO ATTR = \
{ \
CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER, \
{(char *)INTEGER}, \
CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \
};\
\
CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE)
#define CSSM_DB_NAME_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \
const CSSM_DB_ATTRIBUTE_INFO ATTR = \
{ \
CSSM_DB_ATTRIBUTE_NAME_AS_STRING, \
{NAME}, \
CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \
};\
\
CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE)
#define CSSM_DB_OID_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \
const CSSM_DB_ATTRIBUTE_INFO ATTR = \
{ \
CSSM_DB_ATTRIBUTE_NAME_AS_OID, \
{{OID_LEN, OID_DATA}}, \
CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \
};\
\
CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE)
#define CSSM_DB_PRIMARKEY_ATTR(ATTR, NAME) \
const CSSM_DB_ATTRIBUTE_INFO ATTR = \
{ \
CSSM_DB_INDEX_UNIQUE, \
CSSM_DB_INDEX_ON_ATTRIBUTE, \
CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \
};\
\
CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE)
class DbImpl;
class DbMaker
{
public:
virtual ~DbMaker();
virtual DbImpl *newDb(const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation) = 0;
};
class DbCursorImpl;
class DbCursorMaker
{
public:
virtual ~DbCursorMaker();
virtual DbCursorImpl *newDbCursor(const CSSM_QUERY &query, Allocator &allocator) = 0;
virtual DbCursorImpl *newDbCursor(uint32 capacity, Allocator &allocator) = 0;
};
class DbUniqueRecordImpl;
class DbUniqueRecordMaker
{
public:
virtual ~DbUniqueRecordMaker();
virtual DbUniqueRecordImpl *newDbUniqueRecord() = 0;
};
class DLImpl : public AttachmentImpl, public DbMaker
{
public:
DLImpl(const Guid &guid);
DLImpl(const Module &module);
virtual ~DLImpl();
virtual void getDbNames(char **);
virtual void freeNameList(char **);
virtual DbImpl *newDb(const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation);
private:
};
class DL : public Attachment
{
public:
typedef DLImpl Impl;
explicit DL(Impl *impl) : Attachment(impl) {}
DL() : Attachment(NULL) {}
DL(const Guid &guid) : Attachment(new Impl(guid)) {}
DL(const Module &module) : Attachment(new Impl(module)) {}
Impl *operator ->() const { return &impl<Impl>(); }
Impl &operator *() const { return impl<Impl>(); }
operator DbMaker &() const { return impl<Impl>(); }
};
class DbAttributes;
class DbUniqueRecord;
class Db;
class DbImpl : public ObjectImpl, public AclBearer,
public DbCursorMaker, public DbUniqueRecordMaker
{
public:
DbImpl(const DL &dl, const char *inDbName = NULL, const CSSM_NET_ADDRESS *inDbLocation = NULL);
virtual ~DbImpl();
DL dl() const { return parent<DL>(); }
Module module() const { return dl()->module(); }
virtual void open();
virtual void create();
virtual void createWithBlob (CssmData &blob);
virtual void close();
virtual void deleteDb();
virtual void rename(const char *newName);
virtual void authenticate(CSSM_DB_ACCESS_TYPE inAccessRequest,
const CSSM_ACCESS_CREDENTIALS *inAccessCredentials);
virtual void name(char *&outName);
virtual void createRelation(CSSM_DB_RECORDTYPE inRelationID,
const char *inRelationName,
uint32 inNumberOfAttributes,
const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo,
uint32 inNumberOfIndexes,
const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo);
virtual void destroyRelation(CSSM_DB_RECORDTYPE inRelationID);
virtual DbUniqueRecord insert(CSSM_DB_RECORDTYPE recordType,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
const CSSM_DATA *data);
virtual DbUniqueRecord insertWithoutEncryption(CSSM_DB_RECORDTYPE recordType,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
CSSM_DATA *data);
const CSSM_DL_DB_HANDLE &handle() { activate(); return mHandle; }
const DbName &dbName() { return mDbName; }
void dbName(const DbName &dbName) { mDbName = dbName; }
const char *name();
const CSSM_NET_ADDRESS *dbLocation() const { return mDbName.dbLocation(); }
CSSM_DB_ACCESS_TYPE accessRequest() const { return mAccessRequest; }
void accessRequest(CSSM_DB_ACCESS_TYPE inAccessRequest)
{ mAccessRequest = inAccessRequest; }
const CSSM_ACCESS_CREDENTIALS *accessCredentials() const
{ return mAccessCredentials; }
void accessCredentials(const CSSM_ACCESS_CREDENTIALS *inAccessCredentials)
{ mAccessCredentials = inAccessCredentials; }
const void *openParameters() const { return mOpenParameters; }
void openParameters(const void *inOpenParameters)
{ mOpenParameters = inOpenParameters; }
const CSSM_DBINFO *dbInfo() const { return mDbInfo; }
void dbInfo(const CSSM_DBINFO *inDbInfo) { mDbInfo = inDbInfo; }
const ResourceControlContext *resourceControlContext() const
{ return mResourceControlContext; }
void resourceControlContext(const CSSM_RESOURCE_CONTROL_CONTEXT *inResourceControlContext)
{ mResourceControlContext = ResourceControlContext::overlay(inResourceControlContext); }
void passThrough(uint32 passThroughId, const void *in, void **out = NULL);
template <class TIn, class TOut>
void passThrough(uint32 passThroughId, const TIn *in, TOut *out = NULL)
{ passThrough(passThroughId, (const void *)in, (void **)out); }
virtual void lock();
virtual void unlock();
virtual void unlock(const CSSM_DATA &password);
virtual void stash();
virtual void stashCheck();
virtual void getSettings(uint32 &outIdleTimeout, bool &outLockOnSleep);
virtual void setSettings(uint32 inIdleTimeout, bool inLockOnSleep);
virtual bool isLocked();
virtual void changePassphrase(const CSSM_ACCESS_CREDENTIALS *cred);
virtual void recode(const CSSM_DATA &data, const CSSM_DATA &extraData);
virtual void copyBlob(CssmData &data);
virtual void setBatchMode(Boolean mode, Boolean rollback);
virtual DLDbIdentifier dlDbIdentifier();
virtual DbCursorImpl *newDbCursor(const CSSM_QUERY &query, Allocator &allocator);
virtual DbCursorImpl *newDbCursor(uint32 capacity, Allocator &allocator);
virtual DbUniqueRecordImpl *newDbUniqueRecord();
void getAcl(AutoAclEntryInfoList &aclInfos, const char *selectionTag = NULL) const;
void changeAcl(const CSSM_ACL_EDIT &aclEdit,
const CSSM_ACCESS_CREDENTIALS *accessCred);
void getOwner(AutoAclOwnerPrototype &owner) const;
void changeOwner(const CSSM_ACL_OWNER_PROTOTYPE &newOwner,
const CSSM_ACCESS_CREDENTIALS *accessCred = NULL);
class DefaultCredentialsMaker {
public:
virtual ~DefaultCredentialsMaker();
virtual const AccessCredentials *makeCredentials() = 0;
};
void defaultCredentials(DefaultCredentialsMaker *maker);
void activate();
protected:
void deactivate();
private:
CSSM_DL_DB_HANDLE mHandle;
DbName mDbName;
bool mUseNameFromHandle; char *mNameFromHandle; CSSM_DB_ACCESS_TYPE mAccessRequest;
const CSSM_ACCESS_CREDENTIALS *mAccessCredentials;
DefaultCredentialsMaker *mDefaultCredentials;
const void *mOpenParameters;
const CSSM_DBINFO *mDbInfo;
const ResourceControlContext *mResourceControlContext;
};
class Db : public Object, public DLAccess
{
public:
typedef DbImpl Impl;
typedef Impl::DefaultCredentialsMaker DefaultCredentialsMaker;
explicit Db(Impl *impl) : Object(impl) {}
Db() : Object(NULL) {}
Db(DbMaker &maker, const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation = NULL)
: Object(maker.newDb(inDbName, inDbLocation)) {}
Impl *operator ->() const { return &impl<Impl>(); }
Impl &operator *() const { return impl<Impl>(); }
operator DbCursorMaker &() const { return impl<Impl>(); }
operator DbUniqueRecordMaker &() const { return impl<Impl>(); }
const CSSM_DL_DB_HANDLE &handle() { return impl<Impl>().handle(); }
protected:
CSSM_HANDLE dlGetFirst(const CSSM_QUERY &query,
CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data,
CSSM_DB_UNIQUE_RECORD *&id);
bool dlGetNext(CSSM_HANDLE handle,
CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data,
CSSM_DB_UNIQUE_RECORD *&id);
void dlAbortQuery(CSSM_HANDLE handle);
void dlFreeUniqueId(CSSM_DB_UNIQUE_RECORD *id);
void dlDeleteRecord(CSSM_DB_UNIQUE_RECORD *id);
Allocator &allocator();
};
class DbCursorImpl : public ObjectImpl, public CssmAutoQuery
{
public:
DbCursorImpl(const Object &parent, const CSSM_QUERY &query, Allocator &allocator);
DbCursorImpl(const Object &parent, uint32 capacity, Allocator &allocator);
virtual Allocator &allocator() const;
virtual void allocator(Allocator &alloc);
virtual bool next(DbAttributes *attributes, ::CssmDataContainer *data, DbUniqueRecord &uniqueId) = 0;
void abort() { deactivate(); }
};
class DbCursor : public Object
{
public:
typedef DbCursorImpl Impl;
explicit DbCursor(Impl *impl) : Object(impl) {}
DbCursor() : Object(NULL) {}
DbCursor(DbCursorMaker &maker, const CSSM_QUERY &query,
Allocator &allocator = Allocator::standard())
: Object(maker.newDbCursor(query, allocator)) {}
DbCursor(DbCursorMaker &maker, uint32 capacity = 0,
Allocator &allocator = Allocator::standard())
: Object(maker.newDbCursor(capacity, allocator)) {}
Impl *operator ->() const { return &impl<Impl>(); }
Impl &operator *() const { return impl<Impl>(); }
};
class DbUniqueRecordImpl : public ObjectImpl
{
public:
DbUniqueRecordImpl(const Db &db);
virtual ~DbUniqueRecordImpl();
virtual void deleteRecord();
virtual void modify(CSSM_DB_RECORDTYPE recordType,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
const CSSM_DATA *data,
CSSM_DB_MODIFY_MODE modifyMode);
virtual void modifyWithoutEncryption (CSSM_DB_RECORDTYPE recordType,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
const CSSM_DATA *data,
CSSM_DB_MODIFY_MODE modifyMode);
virtual void get(DbAttributes *attributes, ::CssmDataContainer *data);
virtual void getWithoutEncryption(DbAttributes *attributes, ::CssmDataContainer *data);
Db database() const { return parent<Db>(); }
void free() { deactivate(); }
operator CSSM_DB_UNIQUE_RECORD_PTR *() { if (mActive) free(); return &mUniqueId; }
operator CSSM_DB_UNIQUE_RECORD *() { return mUniqueId; }
operator const CSSM_DB_UNIQUE_RECORD *() const { return mUniqueId; }
void activate();
void getRecordIdentifier(CSSM_DATA &data);
void setUniqueRecordPtr (CSSM_DB_UNIQUE_RECORD_PTR uniquePtr);
protected:
void deactivate();
CSSM_DB_UNIQUE_RECORD_PTR mUniqueId;
bool mDestroyID;
RecursiveMutex mActivateMutex;
};
class DbUniqueRecord : public Object
{
public:
typedef DbUniqueRecordImpl Impl;
explicit DbUniqueRecord(Impl *impl) : Object(impl) {}
DbUniqueRecord() : Object(NULL) {}
DbUniqueRecord(DbUniqueRecordMaker &maker) : Object(maker.newDbUniqueRecord()) {}
Impl *operator ->() { return &impl<Impl>(); }
Impl &operator *() { return impl<Impl>(); }
const Impl &operator *() const { return impl<Impl>(); }
operator CSSM_DB_UNIQUE_RECORD_PTR *() { return **this; }
operator CSSM_DB_UNIQUE_RECORD *() { return **this; }
operator const CSSM_DB_UNIQUE_RECORD *() const { return **this; }
};
class DbAttributes : public CssmAutoDbRecordAttributeData
{
public:
DbAttributes();
DbAttributes(const Db &db, uint32 capacity = 0, Allocator &allocator = Allocator::standard());
};
class DbDbCursorImpl : public DbCursorImpl
{
public:
DbDbCursorImpl(const Db &db, const CSSM_QUERY &query, Allocator &allocator);
DbDbCursorImpl(const Db &db, uint32 capacity, Allocator &allocator);
virtual ~DbDbCursorImpl();
bool next(DbAttributes *attributes, ::CssmDataContainer *data, DbUniqueRecord &uniqueId);
protected:
Db database() { return parent<Db>(); }
void activate();
void deactivate();
private:
CSSM_HANDLE mResultsHandle;
RecursiveMutex mActivateMutex;
};
}
}
#endif // _H_CDSA_CLIENT_DLCLIENT