1/* 2 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved. 3 * 4 * The contents of this file constitute Original Code as defined in and are 5 * subject to the Apple Public Source License Version 1.2 (the 'License'). 6 * You may not use this file except in compliance with the License. Please obtain 7 * a copy of the License at http://www.apple.com/publicsource and read it before 8 * using this file. 9 * 10 * This Original Code and all software distributed under the License are 11 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS 12 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT 13 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 14 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the 15 * specific language governing rights and limitations under the License. 16 */ 17 18 19// 20// DbValue.h 21// 22 23#ifndef _H_APPLEDL_DBVALUE 24#define _H_APPLEDL_DBVALUE 25 26#include "ReadWriteSection.h" 27 28#include <security_cdsa_utilities/cssmdata.h> 29#include <security_cdsa_utilities/cssmdb.h> 30#include <Security/cssmerr.h> 31#include <map> 32#include <vector> 33 34namespace Security 35{ 36 37// 38// DbValue -- A base class for all types of database values. 39// 40class DbValue 41{ 42public: 43 virtual ~DbValue(); 44}; 45 46// A collection of subclasses of DbValue that work for simple 47// data types, e.g. uint32, sint32, and double, that have 48// the usual C comparison and sizeof operations. Defining this 49// template saves typing below. 50 51template <class T> 52class BasicValue : public DbValue 53{ 54public: 55 BasicValue() {} 56 BasicValue(T value) : mValue(value) {} 57 58 bool evaluate(const BasicValue<T> &other, CSSM_DB_OPERATOR op) const 59 { 60 switch (op) { 61 62 case CSSM_DB_EQUAL: 63 return mValue == other.mValue; 64 65 case CSSM_DB_NOT_EQUAL: 66 return mValue != other.mValue; 67 68 case CSSM_DB_LESS_THAN: 69 return mValue < other.mValue; 70 71 case CSSM_DB_GREATER_THAN: 72 return mValue > other.mValue; 73 74 default: 75 CssmError::throwMe(CSSMERR_DL_UNSUPPORTED_QUERY); 76 return false; 77 } 78 } 79 80 size_t size() const { return sizeof(T); } 81 size_t size(const ReadSection &rs, uint32 offset) const { return size(); } 82 const uint8 *bytes() const { return reinterpret_cast<const uint8 *>(&mValue); } 83 84protected: 85 T mValue; 86}; 87 88// Actual useful subclasses of DbValue as instances of BasicValue. 89// Note that all of these require a constructor of the form 90// (const ReadSection &, uint32 &offset) that advances the offset 91// to just after the value. 92 93class UInt32Value : public BasicValue<uint32> 94{ 95public: 96 UInt32Value(const ReadSection &rs, uint32 &offset); 97 UInt32Value(const CSSM_DATA &data); 98 virtual ~UInt32Value(); 99 void pack(WriteSection &ws, uint32 &offset) const; 100}; 101 102class SInt32Value : public BasicValue<sint32> 103{ 104public: 105 SInt32Value(const ReadSection &rs, uint32 &offset); 106 SInt32Value(const CSSM_DATA &data); 107 virtual ~SInt32Value(); 108 void pack(WriteSection &ws, uint32 &offset) const; 109}; 110 111class DoubleValue : public BasicValue<double> 112{ 113public: 114 DoubleValue(const ReadSection &rs, uint32 &offset); 115 DoubleValue(const CSSM_DATA &data); 116 virtual ~DoubleValue(); 117 void pack(WriteSection &ws, uint32 &offset) const; 118}; 119 120// Subclasses of Value for more complex types. 121 122class BlobValue : public DbValue, public CssmData 123{ 124public: 125 BlobValue() {} 126 BlobValue(const ReadSection &rs, uint32 &offset); 127 BlobValue(const CSSM_DATA &data); 128 virtual ~BlobValue(); 129 void pack(WriteSection &ws, uint32 &offset) const; 130 bool evaluate(const BlobValue &other, CSSM_DB_OPERATOR op) const; 131 132 size_t size() const { return Length; } 133 const uint8 *bytes() const { return Data; } 134 135protected: 136 class Comparator { 137 public: 138 virtual ~Comparator(); 139 virtual int operator () (const uint8 *ptr1, const uint8 *ptr2, uint32 length); 140 }; 141 142 static bool evaluate(const CssmData &data1, const CssmData &data2, CSSM_DB_OPERATOR op, 143 Comparator compare); 144}; 145 146class TimeDateValue : public BlobValue 147{ 148public: 149 enum { kTimeDateSize = 16 }; 150 151 TimeDateValue(const ReadSection &rs, uint32 &offset); 152 TimeDateValue(const CSSM_DATA &data); 153 virtual ~TimeDateValue(); 154 void pack(WriteSection &ws, uint32 &offset) const; 155 156 bool isValidDate() const; 157 158private: 159 uint32 rangeValue(uint32 start, uint32 length) const; 160}; 161 162class StringValue : public BlobValue 163{ 164public: 165 StringValue(const ReadSection &rs, uint32 &offset); 166 StringValue(const CSSM_DATA &data); 167 virtual ~StringValue(); 168 bool evaluate(const StringValue &other, CSSM_DB_OPERATOR op) const; 169 170private: 171 class Comparator : public BlobValue::Comparator { 172 public: 173 virtual int operator () (const uint8 *ptr1, const uint8 *ptr2, uint32 length); 174 }; 175 176}; 177 178class BigNumValue : public BlobValue 179{ 180public: 181 static const uint8 kSignBit = 0x80; 182 183 BigNumValue(const ReadSection &rs, uint32 &offset); 184 BigNumValue(const CSSM_DATA &data); 185 virtual ~BigNumValue(); 186 bool evaluate(const BigNumValue &other, CSSM_DB_OPERATOR op) const; 187 188private: 189 static int compare(const uint8 *a, const uint8 *b, int length); 190}; 191 192class MultiUInt32Value : public DbValue 193{ 194public: 195 MultiUInt32Value(const ReadSection &rs, uint32 &offset); 196 MultiUInt32Value(const CSSM_DATA &data); 197 virtual ~MultiUInt32Value(); 198 void pack(WriteSection &ws, uint32 &offset) const; 199 bool evaluate(const MultiUInt32Value &other, CSSM_DB_OPERATOR op) const; 200 201 size_t size() const { return mNumValues * sizeof(uint32); } 202 const uint8 *bytes() const { return reinterpret_cast<uint8 *>(mValues); } 203 204private: 205 uint32 mNumValues; 206 uint32 *mValues; 207 bool mOwnsValues; 208}; 209 210} // end namespace Security 211 212#endif // _H_APPLEDL_DBVALUE 213 214