OLD | NEW |
---|---|
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 |
OLD | NEW |