Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(55)

Side by Side Diff: crypto/mock_keychain_mac.cc

Issue 10738003: src/crypto should build on the x86_64 architecture. (Closed) Base URL: https://src.chromium.org/chrome/trunk/src/
Patch Set: A single typedef and kDummySearchRef of type SecKeychainSearchRef. Created 8 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« crypto/mock_keychain_mac.h ('K') | « crypto/mock_keychain_mac.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/logging.h" 5 #include "base/logging.h"
6 #include "base/time.h" 6 #include "base/time.h"
7 #include "crypto/mock_keychain_mac.h" 7 #include "crypto/mock_keychain_mac.h"
8 8
9 namespace crypto { 9 namespace crypto {
10 10
11 const SecKeychainSearchRef MockKeychain::kDummySearchRef =
12 (SecKeychainSearchRef) 1000;
wtc 2012/07/23 18:22:02 Please use C++ reinterpret_cast<SecKeychainSearchR
13
11 MockKeychain::MockKeychain() 14 MockKeychain::MockKeychain()
12 : next_item_key_(0), 15 : next_item_key_(0),
13 search_copy_count_(0), 16 search_copy_count_(0),
14 keychain_item_copy_count_(0), 17 keychain_item_copy_count_(0),
15 attribute_data_copy_count_(0), 18 attribute_data_copy_count_(0),
16 find_generic_result_(noErr), 19 find_generic_result_(noErr),
17 called_add_generic_(false), 20 called_add_generic_(false),
18 password_data_count_(0) {} 21 password_data_count_(0) {}
19 22
20 void MockKeychain::InitializeKeychainData(unsigned int key) const { 23 void MockKeychain::InitializeKeychainData(MockKeychainKeyType key) const {
21 UInt32 tags[] = { kSecAccountItemAttr, 24 UInt32 tags[] = { kSecAccountItemAttr,
22 kSecServerItemAttr, 25 kSecServerItemAttr,
23 kSecPortItemAttr, 26 kSecPortItemAttr,
24 kSecPathItemAttr, 27 kSecPathItemAttr,
25 kSecProtocolItemAttr, 28 kSecProtocolItemAttr,
26 kSecAuthenticationTypeItemAttr, 29 kSecAuthenticationTypeItemAttr,
27 kSecSecurityDomainItemAttr, 30 kSecSecurityDomainItemAttr,
28 kSecCreationDateItemAttr, 31 kSecCreationDateItemAttr,
29 kSecNegativeItemAttr, 32 kSecNegativeItemAttr,
30 kSecCreatorItemAttr }; 33 kSecCreatorItemAttr };
(...skipping 23 matching lines...) Expand all
54 break; 57 break;
55 } 58 }
56 if (data_size > 0) { 59 if (data_size > 0) {
57 keychain_attr_list_[key].attr[i].length = data_size; 60 keychain_attr_list_[key].attr[i].length = data_size;
58 keychain_attr_list_[key].attr[i].data = calloc(1, data_size); 61 keychain_attr_list_[key].attr[i].data = calloc(1, data_size);
59 } 62 }
60 } 63 }
61 } 64 }
62 65
63 MockKeychain::~MockKeychain() { 66 MockKeychain::~MockKeychain() {
64 for (std::map<unsigned int, SecKeychainAttributeList>::iterator it = 67 for (std::map<MockKeychainKeyType, SecKeychainAttributeList>::iterator it =
65 keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) { 68 keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) {
66 for (unsigned int i = 0; i < it->second.count; ++i) { 69 for (unsigned int i = 0; i < it->second.count; ++i) {
67 if (it->second.attr[i].data) 70 if (it->second.attr[i].data)
68 free(it->second.attr[i].data); 71 free(it->second.attr[i].data);
69 } 72 }
70 free(it->second.attr); 73 free(it->second.attr);
71 if (keychain_data_[it->first].data) 74 if (keychain_data_[it->first].data)
72 free(keychain_data_[it->first].data); 75 free(keychain_data_[it->first].data);
73 } 76 }
74 keychain_attr_list_.clear(); 77 keychain_attr_list_.clear();
(...skipping 10 matching lines...) Expand all
85 break; 88 break;
86 } 89 }
87 } 90 }
88 if (attribute_index == -1) { 91 if (attribute_index == -1) {
89 NOTREACHED() << "Unsupported attribute: " << tag; 92 NOTREACHED() << "Unsupported attribute: " << tag;
90 return NULL; 93 return NULL;
91 } 94 }
92 return &(attribute_list.attr[attribute_index]); 95 return &(attribute_list.attr[attribute_index]);
93 } 96 }
94 97
95 void MockKeychain::SetTestDataBytes(int item, 98 void MockKeychain::SetTestDataBytes(MockKeychainKeyType item,
96 UInt32 tag, 99 UInt32 tag,
97 const void* data, 100 const void* data,
98 size_t length) { 101 size_t length) {
99 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item], 102 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
100 tag); 103 tag);
101 attribute->length = length; 104 attribute->length = length;
102 if (length > 0) { 105 if (length > 0) {
103 if (attribute->data) 106 if (attribute->data)
104 free(attribute->data); 107 free(attribute->data);
105 attribute->data = malloc(length); 108 attribute->data = malloc(length);
106 CHECK(attribute->data); 109 CHECK(attribute->data);
107 memcpy(attribute->data, data, length); 110 memcpy(attribute->data, data, length);
108 } else { 111 } else {
109 attribute->data = NULL; 112 attribute->data = NULL;
110 } 113 }
111 } 114 }
112 115
113 void MockKeychain::SetTestDataString(int item, UInt32 tag, const char* value) { 116 void MockKeychain::SetTestDataString(
117 MockKeychainKeyType item,
118 UInt32 tag,
119 const char* value) {
114 SetTestDataBytes(item, tag, value, value ? strlen(value) : 0); 120 SetTestDataBytes(item, tag, value, value ? strlen(value) : 0);
115 } 121 }
116 122
117 void MockKeychain::SetTestDataPort(int item, UInt32 value) { 123 void MockKeychain::SetTestDataPort(MockKeychainKeyType item, UInt32 value) {
118 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item], 124 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
119 kSecPortItemAttr); 125 kSecPortItemAttr);
120 UInt32* data = static_cast<UInt32*>(attribute->data); 126 UInt32* data = static_cast<UInt32*>(attribute->data);
121 *data = value; 127 *data = value;
122 } 128 }
123 129
124 void MockKeychain::SetTestDataProtocol(int item, SecProtocolType value) { 130 void MockKeychain::SetTestDataProtocol(MockKeychainKeyType item,
131 SecProtocolType value) {
125 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item], 132 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
126 kSecProtocolItemAttr); 133 kSecProtocolItemAttr);
127 SecProtocolType* data = static_cast<SecProtocolType*>(attribute->data); 134 SecProtocolType* data = static_cast<SecProtocolType*>(attribute->data);
128 *data = value; 135 *data = value;
129 } 136 }
130 137
131 void MockKeychain::SetTestDataAuthType(int item, SecAuthenticationType value) { 138 void MockKeychain::SetTestDataAuthType(
139 MockKeychainKeyType item,
140 SecAuthenticationType value) {
132 SecKeychainAttribute* attribute = AttributeWithTag( 141 SecKeychainAttribute* attribute = AttributeWithTag(
133 keychain_attr_list_[item], kSecAuthenticationTypeItemAttr); 142 keychain_attr_list_[item], kSecAuthenticationTypeItemAttr);
134 SecAuthenticationType* data = static_cast<SecAuthenticationType*>( 143 SecAuthenticationType* data = static_cast<SecAuthenticationType*>(
135 attribute->data); 144 attribute->data);
136 *data = value; 145 *data = value;
137 } 146 }
138 147
139 void MockKeychain::SetTestDataNegativeItem(int item, Boolean value) { 148 void MockKeychain::SetTestDataNegativeItem(MockKeychainKeyType item,
149 Boolean value) {
140 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item], 150 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
141 kSecNegativeItemAttr); 151 kSecNegativeItemAttr);
142 Boolean* data = static_cast<Boolean*>(attribute->data); 152 Boolean* data = static_cast<Boolean*>(attribute->data);
143 *data = value; 153 *data = value;
144 } 154 }
145 155
146 void MockKeychain::SetTestDataCreator(int item, OSType value) { 156 void MockKeychain::SetTestDataCreator(MockKeychainKeyType item, OSType value) {
147 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item], 157 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[item],
148 kSecCreatorItemAttr); 158 kSecCreatorItemAttr);
149 OSType* data = static_cast<OSType*>(attribute->data); 159 OSType* data = static_cast<OSType*>(attribute->data);
150 *data = value; 160 *data = value;
151 } 161 }
152 162
153 void MockKeychain::SetTestDataPasswordBytes(int item, const void* data, 163 void MockKeychain::SetTestDataPasswordBytes(MockKeychainKeyType item,
164 const void* data,
154 size_t length) { 165 size_t length) {
155 keychain_data_[item].length = length; 166 keychain_data_[item].length = length;
156 if (length > 0) { 167 if (length > 0) {
157 if (keychain_data_[item].data) 168 if (keychain_data_[item].data)
158 free(keychain_data_[item].data); 169 free(keychain_data_[item].data);
159 keychain_data_[item].data = malloc(length); 170 keychain_data_[item].data = malloc(length);
160 memcpy(keychain_data_[item].data, data, length); 171 memcpy(keychain_data_[item].data, data, length);
161 } else { 172 } else {
162 keychain_data_[item].data = NULL; 173 keychain_data_[item].data = NULL;
163 } 174 }
164 } 175 }
165 176
166 void MockKeychain::SetTestDataPasswordString(int item, const char* value) { 177 void MockKeychain::SetTestDataPasswordString(
178 MockKeychainKeyType item,
179 const char* value) {
167 SetTestDataPasswordBytes(item, value, value ? strlen(value) : 0); 180 SetTestDataPasswordBytes(item, value, value ? strlen(value) : 0);
168 } 181 }
169 182
170 OSStatus MockKeychain::ItemCopyAttributesAndData( 183 OSStatus MockKeychain::ItemCopyAttributesAndData(
171 SecKeychainItemRef itemRef, 184 SecKeychainItemRef itemRef,
172 SecKeychainAttributeInfo* info, 185 SecKeychainAttributeInfo* info,
173 SecItemClass* itemClass, 186 SecItemClass* itemClass,
174 SecKeychainAttributeList** attrList, 187 SecKeychainAttributeList** attrList,
175 UInt32* length, 188 UInt32* length,
176 void** outData) const { 189 void** outData) const {
177 DCHECK(itemRef); 190 DCHECK(itemRef);
178 unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1; 191 MockKeychainKeyType key = reinterpret_cast<MockKeychainKeyType>(itemRef) - 1;
179 if (keychain_attr_list_.find(key) == keychain_attr_list_.end()) 192 if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
180 return errSecInvalidItemRef; 193 return errSecInvalidItemRef;
181 194
182 DCHECK(!itemClass); // itemClass not implemented in the Mock. 195 DCHECK(!itemClass); // itemClass not implemented in the Mock.
183 if (attrList) 196 if (attrList)
184 *attrList = &(keychain_attr_list_[key]); 197 *attrList = &(keychain_attr_list_[key]);
185 if (outData) { 198 if (outData) {
186 *outData = keychain_data_[key].data; 199 *outData = keychain_data_[key].data;
187 DCHECK(length); 200 DCHECK(length);
188 *length = keychain_data_[key].length; 201 *length = keychain_data_[key].length;
189 } 202 }
190 203
191 ++attribute_data_copy_count_; 204 ++attribute_data_copy_count_;
192 return noErr; 205 return noErr;
193 } 206 }
194 207
195 OSStatus MockKeychain::ItemModifyAttributesAndData( 208 OSStatus MockKeychain::ItemModifyAttributesAndData(
196 SecKeychainItemRef itemRef, 209 SecKeychainItemRef itemRef,
197 const SecKeychainAttributeList* attrList, 210 const SecKeychainAttributeList* attrList,
198 UInt32 length, 211 UInt32 length,
199 const void* data) const { 212 const void* data) const {
200 DCHECK(itemRef); 213 DCHECK(itemRef);
201 const char* fail_trigger = "fail_me"; 214 const char* fail_trigger = "fail_me";
202 if (length == strlen(fail_trigger) && 215 if (length == strlen(fail_trigger) &&
203 memcmp(data, fail_trigger, length) == 0) { 216 memcmp(data, fail_trigger, length) == 0) {
204 return errSecAuthFailed; 217 return errSecAuthFailed;
205 } 218 }
206 219
207 unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1; 220 MockKeychainKeyType key = reinterpret_cast<MockKeychainKeyType>(itemRef) - 1;
208 if (keychain_attr_list_.find(key) == keychain_attr_list_.end()) 221 if (keychain_attr_list_.find(key) == keychain_attr_list_.end())
209 return errSecInvalidItemRef; 222 return errSecInvalidItemRef;
210 223
211 MockKeychain* mutable_this = const_cast<MockKeychain*>(this); 224 MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
212 if (attrList) { 225 if (attrList) {
213 for (UInt32 change_attr = 0; change_attr < attrList->count; ++change_attr) { 226 for (UInt32 change_attr = 0; change_attr < attrList->count; ++change_attr) {
214 if (attrList->attr[change_attr].tag == kSecCreatorItemAttr) { 227 if (attrList->attr[change_attr].tag == kSecCreatorItemAttr) {
215 void* data = attrList->attr[change_attr].data; 228 void* data = attrList->attr[change_attr].data;
216 mutable_this->SetTestDataCreator(key, *(static_cast<OSType*>(data))); 229 mutable_this->SetTestDataCreator(key, *(static_cast<OSType*>(data)));
217 } else { 230 } else {
218 NOTIMPLEMENTED(); 231 NOTIMPLEMENTED();
219 } 232 }
220 } 233 }
221 } 234 }
222 if (data) 235 if (data)
223 mutable_this->SetTestDataPasswordBytes(key, data, length); 236 mutable_this->SetTestDataPasswordBytes(key, data, length);
224 return noErr; 237 return noErr;
225 } 238 }
226 239
227 OSStatus MockKeychain::ItemFreeAttributesAndData( 240 OSStatus MockKeychain::ItemFreeAttributesAndData(
228 SecKeychainAttributeList* attrList, 241 SecKeychainAttributeList* attrList,
229 void* data) const { 242 void* data) const {
230 --attribute_data_copy_count_; 243 --attribute_data_copy_count_;
231 return noErr; 244 return noErr;
232 } 245 }
233 246
234 OSStatus MockKeychain::ItemDelete(SecKeychainItemRef itemRef) const { 247 OSStatus MockKeychain::ItemDelete(SecKeychainItemRef itemRef) const {
235 unsigned int key = reinterpret_cast<unsigned int>(itemRef) - 1; 248 MockKeychainKeyType key = reinterpret_cast<MockKeychainKeyType>(itemRef) - 1;
236 249
237 for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) { 250 for (unsigned int i = 0; i < keychain_attr_list_[key].count; ++i) {
238 if (keychain_attr_list_[key].attr[i].data) 251 if (keychain_attr_list_[key].attr[i].data)
239 free(keychain_attr_list_[key].attr[i].data); 252 free(keychain_attr_list_[key].attr[i].data);
240 } 253 }
241 free(keychain_attr_list_[key].attr); 254 free(keychain_attr_list_[key].attr);
242 if (keychain_data_[key].data) 255 if (keychain_data_[key].data)
243 free(keychain_data_[key].data); 256 free(keychain_data_[key].data);
244 257
245 keychain_attr_list_.erase(key); 258 keychain_attr_list_.erase(key);
246 keychain_data_.erase(key); 259 keychain_data_.erase(key);
247 added_via_api_.erase(key); 260 added_via_api_.erase(key);
248 return noErr; 261 return noErr;
249 } 262 }
250 263
251 OSStatus MockKeychain::SearchCreateFromAttributes( 264 OSStatus MockKeychain::SearchCreateFromAttributes(
252 CFTypeRef keychainOrArray, 265 CFTypeRef keychainOrArray,
253 SecItemClass itemClass, 266 SecItemClass itemClass,
254 const SecKeychainAttributeList* attrList, 267 const SecKeychainAttributeList* attrList,
255 SecKeychainSearchRef* searchRef) const { 268 SecKeychainSearchRef* searchRef) const {
256 // Figure out which of our mock items matches, and set up the array we'll use 269 // Figure out which of our mock items matches, and set up the array we'll use
257 // to generate results out of SearchCopyNext. 270 // to generate results out of SearchCopyNext.
258 remaining_search_results_.clear(); 271 remaining_search_results_.clear();
259 for (std::map<unsigned int, SecKeychainAttributeList>::const_iterator it = 272 for (std::map<MockKeychainKeyType, SecKeychainAttributeList>
260 keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) { 273 ::const_iterator it = keychain_attr_list_.begin();
274 it != keychain_attr_list_.end(); ++it) {
261 bool mock_item_matches = true; 275 bool mock_item_matches = true;
262 for (UInt32 search_attr = 0; search_attr < attrList->count; ++search_attr) { 276 for (UInt32 search_attr = 0; search_attr < attrList->count; ++search_attr) {
263 SecKeychainAttribute* mock_attribute = 277 SecKeychainAttribute* mock_attribute =
264 AttributeWithTag(it->second, attrList->attr[search_attr].tag); 278 AttributeWithTag(it->second, attrList->attr[search_attr].tag);
265 if (mock_attribute->length != attrList->attr[search_attr].length || 279 if (mock_attribute->length != attrList->attr[search_attr].length ||
266 memcmp(mock_attribute->data, attrList->attr[search_attr].data, 280 memcmp(mock_attribute->data, attrList->attr[search_attr].data,
267 attrList->attr[search_attr].length) != 0) { 281 attrList->attr[search_attr].length) != 0) {
268 mock_item_matches = false; 282 mock_item_matches = false;
269 break; 283 break;
270 } 284 }
271 } 285 }
272 if (mock_item_matches) 286 if (mock_item_matches)
273 remaining_search_results_.push_back(it->first); 287 remaining_search_results_.push_back(it->first);
274 } 288 }
275 289
276 DCHECK(searchRef); 290 DCHECK(searchRef);
277 *searchRef = reinterpret_cast<SecKeychainSearchRef>(kDummySearchRef); 291 *searchRef = kDummySearchRef;
278 ++search_copy_count_; 292 ++search_copy_count_;
279 return noErr; 293 return noErr;
280 } 294 }
281 295
282 bool MockKeychain::AlreadyContainsInternetPassword( 296 bool MockKeychain::AlreadyContainsInternetPassword(
283 UInt32 serverNameLength, 297 UInt32 serverNameLength,
284 const char* serverName, 298 const char* serverName,
285 UInt32 securityDomainLength, 299 UInt32 securityDomainLength,
286 const char* securityDomain, 300 const char* securityDomain,
287 UInt32 accountNameLength, 301 UInt32 accountNameLength,
288 const char* accountName, 302 const char* accountName,
289 UInt32 pathLength, 303 UInt32 pathLength,
290 const char* path, 304 const char* path,
291 UInt16 port, 305 UInt16 port,
292 SecProtocolType protocol, 306 SecProtocolType protocol,
293 SecAuthenticationType authenticationType) const { 307 SecAuthenticationType authenticationType) const {
294 for (std::map<unsigned int, SecKeychainAttributeList>::const_iterator it = 308 for (std::map<MockKeychainKeyType, SecKeychainAttributeList>
295 keychain_attr_list_.begin(); it != keychain_attr_list_.end(); ++it) { 309 ::const_iterator it = keychain_attr_list_.begin();
310 it != keychain_attr_list_.end(); ++it) {
296 SecKeychainAttribute* attribute; 311 SecKeychainAttribute* attribute;
297 attribute = AttributeWithTag(it->second, kSecServerItemAttr); 312 attribute = AttributeWithTag(it->second, kSecServerItemAttr);
298 if ((attribute->length != serverNameLength) || 313 if ((attribute->length != serverNameLength) ||
299 (attribute->data == NULL && *serverName != '\0') || 314 (attribute->data == NULL && *serverName != '\0') ||
300 (attribute->data != NULL && *serverName == '\0') || 315 (attribute->data != NULL && *serverName == '\0') ||
301 strncmp(serverName, 316 strncmp(serverName,
302 (const char*) attribute->data, 317 (const char*) attribute->data,
303 serverNameLength) != 0) { 318 serverNameLength) != 0) {
304 continue; 319 continue;
305 } 320 }
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after
378 if (AlreadyContainsInternetPassword(serverNameLength, serverName, 393 if (AlreadyContainsInternetPassword(serverNameLength, serverName,
379 securityDomainLength, securityDomain, 394 securityDomainLength, securityDomain,
380 accountNameLength, accountName, 395 accountNameLength, accountName,
381 pathLength, path, 396 pathLength, path,
382 port, protocol, 397 port, protocol,
383 authenticationType)) { 398 authenticationType)) {
384 return errSecDuplicateItem; 399 return errSecDuplicateItem;
385 } 400 }
386 401
387 // Pick the next unused slot. 402 // Pick the next unused slot.
388 unsigned int key = next_item_key_++; 403 MockKeychainKeyType key = next_item_key_++;
389 404
390 // Initialize keychain data storage at the target location. 405 // Initialize keychain data storage at the target location.
391 InitializeKeychainData(key); 406 InitializeKeychainData(key);
392 407
393 MockKeychain* mutable_this = const_cast<MockKeychain*>(this); 408 MockKeychain* mutable_this = const_cast<MockKeychain*>(this);
394 mutable_this->SetTestDataBytes(key, kSecServerItemAttr, serverName, 409 mutable_this->SetTestDataBytes(key, kSecServerItemAttr, serverName,
395 serverNameLength); 410 serverNameLength);
396 mutable_this->SetTestDataBytes(key, kSecSecurityDomainItemAttr, 411 mutable_this->SetTestDataBytes(key, kSecSecurityDomainItemAttr,
397 securityDomain, securityDomainLength); 412 securityDomain, securityDomainLength);
398 mutable_this->SetTestDataBytes(key, kSecAccountItemAttr, accountName, 413 mutable_this->SetTestDataBytes(key, kSecAccountItemAttr, accountName,
(...skipping 18 matching lines...) Expand all
417 *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1); 432 *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
418 ++keychain_item_copy_count_; 433 ++keychain_item_copy_count_;
419 } 434 }
420 return noErr; 435 return noErr;
421 } 436 }
422 437
423 OSStatus MockKeychain::SearchCopyNext(SecKeychainSearchRef searchRef, 438 OSStatus MockKeychain::SearchCopyNext(SecKeychainSearchRef searchRef,
424 SecKeychainItemRef* itemRef) const { 439 SecKeychainItemRef* itemRef) const {
425 if (remaining_search_results_.empty()) 440 if (remaining_search_results_.empty())
426 return errSecItemNotFound; 441 return errSecItemNotFound;
427 unsigned int key = remaining_search_results_.front(); 442 MockKeychainKeyType key = remaining_search_results_.front();
428 remaining_search_results_.erase(remaining_search_results_.begin()); 443 remaining_search_results_.erase(remaining_search_results_.begin());
429 *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1); 444 *itemRef = reinterpret_cast<SecKeychainItemRef>(key + 1);
430 ++keychain_item_copy_count_; 445 ++keychain_item_copy_count_;
431 return noErr; 446 return noErr;
432 } 447 }
433 448
434 OSStatus MockKeychain::FindGenericPassword(CFTypeRef keychainOrArray, 449 OSStatus MockKeychain::FindGenericPassword(CFTypeRef keychainOrArray,
435 UInt32 serviceNameLength, 450 UInt32 serviceNameLength,
436 const char* serviceName, 451 const char* serviceName,
437 UInt32 accountNameLength, 452 UInt32 accountNameLength,
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
476 add_generic_password_ = 491 add_generic_password_ =
477 std::string(const_cast<char*>(static_cast<const char*>(passwordData)), 492 std::string(const_cast<char*>(static_cast<const char*>(passwordData)),
478 passwordLength); 493 passwordLength);
479 return noErr; 494 return noErr;
480 } 495 }
481 496
482 void MockKeychain::Free(CFTypeRef ref) const { 497 void MockKeychain::Free(CFTypeRef ref) const {
483 if (!ref) 498 if (!ref)
484 return; 499 return;
485 500
486 if (reinterpret_cast<int>(ref) == kDummySearchRef) { 501 if (ref == kDummySearchRef) {
487 --search_copy_count_; 502 --search_copy_count_;
488 } else { 503 } else {
489 --keychain_item_copy_count_; 504 --keychain_item_copy_count_;
490 } 505 }
491 } 506 }
492 507
493 int MockKeychain::UnfreedSearchCount() const { 508 int MockKeychain::UnfreedSearchCount() const {
494 return search_copy_count_; 509 return search_copy_count_;
495 } 510 }
496 511
497 int MockKeychain::UnfreedKeychainItemCount() const { 512 int MockKeychain::UnfreedKeychainItemCount() const {
498 return keychain_item_copy_count_; 513 return keychain_item_copy_count_;
499 } 514 }
500 515
501 int MockKeychain::UnfreedAttributeDataCount() const { 516 int MockKeychain::UnfreedAttributeDataCount() const {
502 return attribute_data_copy_count_; 517 return attribute_data_copy_count_;
503 } 518 }
504 519
505 bool MockKeychain::CreatorCodesSetForAddedItems() const { 520 bool MockKeychain::CreatorCodesSetForAddedItems() const {
506 for (std::set<unsigned int>::const_iterator i = added_via_api_.begin(); 521 for (std::set<MockKeychainKeyType>::const_iterator i = added_via_api_.begin();
507 i != added_via_api_.end(); ++i) { 522 i != added_via_api_.end(); ++i) {
508 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[*i], 523 SecKeychainAttribute* attribute = AttributeWithTag(keychain_attr_list_[*i],
509 kSecCreatorItemAttr); 524 kSecCreatorItemAttr);
510 OSType* data = static_cast<OSType*>(attribute->data); 525 OSType* data = static_cast<OSType*>(attribute->data);
511 if (*data == 0) 526 if (*data == 0)
512 return false; 527 return false;
513 } 528 }
514 return true; 529 return true;
515 } 530 }
516 531
517 void MockKeychain::AddTestItem(const KeychainTestData& item_data) { 532 void MockKeychain::AddTestItem(const KeychainTestData& item_data) {
518 unsigned int key = next_item_key_++; 533 MockKeychainKeyType key = next_item_key_++;
519 534
520 InitializeKeychainData(key); 535 InitializeKeychainData(key);
521 SetTestDataAuthType(key, item_data.auth_type); 536 SetTestDataAuthType(key, item_data.auth_type);
522 SetTestDataString(key, kSecServerItemAttr, item_data.server); 537 SetTestDataString(key, kSecServerItemAttr, item_data.server);
523 SetTestDataProtocol(key, item_data.protocol); 538 SetTestDataProtocol(key, item_data.protocol);
524 SetTestDataString(key, kSecPathItemAttr, item_data.path); 539 SetTestDataString(key, kSecPathItemAttr, item_data.path);
525 SetTestDataPort(key, item_data.port); 540 SetTestDataPort(key, item_data.port);
526 SetTestDataString(key, kSecSecurityDomainItemAttr, 541 SetTestDataString(key, kSecSecurityDomainItemAttr,
527 item_data.security_domain); 542 item_data.security_domain);
528 SetTestDataString(key, kSecCreationDateItemAttr, item_data.creation_date); 543 SetTestDataString(key, kSecCreationDateItemAttr, item_data.creation_date);
529 SetTestDataString(key, kSecAccountItemAttr, item_data.username); 544 SetTestDataString(key, kSecAccountItemAttr, item_data.username);
530 SetTestDataPasswordString(key, item_data.password); 545 SetTestDataPasswordString(key, item_data.password);
531 SetTestDataNegativeItem(key, item_data.negative_item); 546 SetTestDataNegativeItem(key, item_data.negative_item);
532 } 547 }
533 548
534 } // namespace crypto 549 } // namespace crypto
OLDNEW
« crypto/mock_keychain_mac.h ('K') | « crypto/mock_keychain_mac.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698