1/*
2 * Copyright (c) 2000-2004,2006 Apple Computer, Inc. All Rights Reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24
25//
26// Miscellaneous CSSM PODWrappers
27//
28#ifndef _H_CSSMPODS
29#define _H_CSSMPODS
30
31#include <security_utilities/utilities.h>
32#include <security_cdsa_utilities/cssmdata.h>
33#include <string>
34
35
36namespace Security {
37
38
39//
40// User-friendly GUIDs
41//
42class Guid : public PodWrapper<Guid, CSSM_GUID> {
43public:
44    Guid() { /*IFDEBUG(*/ memset(this, 0, sizeof(*this)) /*)*/ ; }
45    Guid(const CSSM_GUID &rGuid) { memcpy(this, &rGuid, sizeof(*this)); }
46    Guid(const char *string);
47	Guid(const std::string &s);
48
49    Guid &operator = (const CSSM_GUID &rGuid)
50    { memcpy(this, &rGuid, sizeof(CSSM_GUID)); return *this; }
51
52    bool operator == (const CSSM_GUID &other) const
53    { return (this == &other) || !memcmp(this, &other, sizeof(CSSM_GUID)); }
54    bool operator != (const CSSM_GUID &other) const
55    { return (this != &other) && memcmp(this, &other, sizeof(CSSM_GUID)); }
56    bool operator < (const CSSM_GUID &other) const
57    { return memcmp(this, &other, sizeof(CSSM_GUID)) < 0; }
58    size_t hash() const {	//@@@ revisit this hash
59        return Data1 + (Data2 << 3) + (Data3 << 11) + (Data4[3]) + (Data4[6] << 22);
60    }
61
62    static const unsigned stringRepLength = 38;	// "{x8-x4-x4-x4-x12}"
63    char *toString(char buffer[stringRepLength+1]) const;	// will append \0
64	string toString() const;	// make std::string
65
66private:
67	void parseGuid(const char *string);
68};
69
70class CssmGuidData : public CssmData {
71public:
72	CssmGuidData(const CSSM_GUID &guid);
73
74private:
75	char buffer[Guid::stringRepLength + 1];
76};
77
78
79//
80// User-friendly CSSM_SUBSERVICE_UIDs
81//
82class CssmSubserviceUid : public PodWrapper<CssmSubserviceUid, CSSM_SUBSERVICE_UID> {
83public:
84    CssmSubserviceUid() { clearPod(); }
85    CssmSubserviceUid(const CSSM_SUBSERVICE_UID &rSSuid) { memcpy(this, &rSSuid, sizeof(*this)); }
86
87    CssmSubserviceUid &operator = (const CSSM_SUBSERVICE_UID &rSSuid)
88    { memcpy(this, &rSSuid, sizeof(CSSM_SUBSERVICE_UID)); return *this; }
89
90    bool operator == (const CSSM_SUBSERVICE_UID &other) const;
91    bool operator != (const CSSM_SUBSERVICE_UID &other) const { return !(*this == other); }
92    bool operator < (const CSSM_SUBSERVICE_UID &other) const;
93
94    CssmSubserviceUid(const CSSM_GUID &guid, const CSSM_VERSION *version = NULL,
95		uint32 subserviceId = 0,
96        CSSM_SERVICE_TYPE subserviceType = CSSM_SERVICE_DL);
97
98	const ::Guid &guid() const { return ::Guid::overlay(Guid); }
99	uint32 subserviceId() const { return SubserviceId; }
100	CSSM_SERVICE_TYPE subserviceType() const { return SubserviceType; }
101	CSSM_VERSION version() const { return Version; }
102};
103
104
105//
106// User-friendler CSSM_CRYPTO_DATA objects
107//
108class CryptoCallback {
109public:
110	CryptoCallback(CSSM_CALLBACK func, void *ctx = NULL) : mFunction(func), mCtx(ctx) { }
111	CSSM_CALLBACK function() const { return mFunction; }
112	void *context() const { return mCtx; }
113
114	CssmData operator () () const
115	{
116		CssmData output;
117		if (CSSM_RETURN err = mFunction(&output, mCtx))
118			CssmError::throwMe(err);
119		return output;
120	}
121
122private:
123	CSSM_CALLBACK mFunction;
124	void *mCtx;
125};
126
127class CssmCryptoData : public PodWrapper<CssmCryptoData, CSSM_CRYPTO_DATA> {
128public:
129	CssmCryptoData() { }
130
131	CssmCryptoData(const CssmData &param, CSSM_CALLBACK callback = NULL, void *ctx = NULL)
132	{ Param = const_cast<CssmData &>(param); Callback = callback; CallerCtx = ctx; }
133
134	CssmCryptoData(const CssmData &param, CryptoCallback &cb)
135	{ Param = const_cast<CssmData &>(param); Callback = cb.function(); CallerCtx = cb.context(); }
136
137	CssmCryptoData(CSSM_CALLBACK callback, void *ctx = NULL)
138	{ /* ignore Param */ Callback = callback; CallerCtx = ctx; }
139
140	explicit CssmCryptoData(CryptoCallback &cb)
141	{ /* ignore Param */ Callback = cb.function(); CallerCtx = cb.context(); }
142
143	// member access
144	CssmData &param() { return CssmData::overlay(Param); }
145	const CssmData &param() const { return CssmData::overlay(Param); }
146	bool hasCallback() const { return Callback != NULL; }
147	CryptoCallback callback() const { return CryptoCallback(Callback, CallerCtx); }
148
149	// get the value, whichever way is appropriate
150	CssmData operator () () const
151	{ return hasCallback() ? callback() () : param(); }
152};
153
154// a CssmCryptoContext whose callback is a virtual class member
155class CryptoDataClass : public CssmCryptoData {
156public:
157	CryptoDataClass() : CssmCryptoData(callbackShim, this) { }
158	virtual ~CryptoDataClass();
159
160protected:
161	virtual CssmData yield() = 0;	// must subclass and implement this
162
163private:
164	static CSSM_RETURN callbackShim(CSSM_DATA *output, void *ctx);
165};
166
167
168//
169// Other PodWrappers for stuff that is barely useful...
170//
171class CssmKeySize : public PodWrapper<CssmKeySize, CSSM_KEY_SIZE> {
172public:
173    CssmKeySize() { }
174    CssmKeySize(uint32 nom, uint32 eff) { LogicalKeySizeInBits = nom; EffectiveKeySizeInBits = eff; }
175    CssmKeySize(uint32 size) { LogicalKeySizeInBits = EffectiveKeySizeInBits = size; }
176
177    uint32 logical() const		{ return LogicalKeySizeInBits; }
178    uint32 effective() const	{ return EffectiveKeySizeInBits; }
179    operator uint32 () const	{ return effective(); }
180};
181
182inline bool operator == (const CSSM_KEY_SIZE &s1, const CSSM_KEY_SIZE &s2)
183{
184    return s1.LogicalKeySizeInBits == s2.LogicalKeySizeInBits
185        && s1.EffectiveKeySizeInBits == s2.EffectiveKeySizeInBits;
186}
187
188inline bool operator != (const CSSM_KEY_SIZE &s1, const CSSM_KEY_SIZE &s2)
189{ return !(s1 == s2); }
190
191
192class QuerySizeData : public PodWrapper<QuerySizeData, CSSM_QUERY_SIZE_DATA> {
193public:
194    QuerySizeData() { }
195	QuerySizeData(uint32 in) { SizeInputBlock = in; SizeOutputBlock = 0; }
196
197	uint32 inputSize() const { return SizeInputBlock; }
198	uint32 inputSize(uint32 size) { return SizeInputBlock = size; }
199	uint32 outputSize() const { return SizeOutputBlock; }
200};
201
202inline bool operator == (const CSSM_QUERY_SIZE_DATA &s1, const CSSM_QUERY_SIZE_DATA &s2)
203{
204    return s1.SizeInputBlock == s2.SizeInputBlock
205        && s1.SizeOutputBlock == s2.SizeOutputBlock;
206}
207
208inline bool operator != (const CSSM_QUERY_SIZE_DATA &s1, const CSSM_QUERY_SIZE_DATA &s2)
209{ return !(s1 == s2); }
210
211
212class CSPOperationalStatistics :
213	public PodWrapper<CSPOperationalStatistics, CSSM_CSP_OPERATIONAL_STATISTICS> {
214public:
215};
216
217
218} // end namespace Security
219
220
221#endif //_H_CSSMPODS
222