MDSDictionary.cpp
1 /* 2 * Copyright (c) 2000-2001,2011-2012,2014 Apple 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 File: MDSDictionary.cpp 21 22 Contains: Internal representation of one MDS info file in the form of 23 a CFDictionary. 24 25 Copyright (c) 2001,2011-2012,2014 Apple Inc. All Rights Reserved. 26 */ 27 28 #include "MDSDictionary.h" 29 #include "MDSAttrParser.h" 30 #include "MDSAttrUtils.h" 31 #include <security_utilities/logging.h> 32 #include <security_utilities/cfutilities.h> 33 34 namespace Security 35 { 36 37 /* heavyweight constructor from file */ 38 MDSDictionary::MDSDictionary( 39 CFURLRef fileUrl, 40 CFStringRef subdir, 41 const char *fullPath) // could get from fileUrl, but very messy! 42 : mDict(NULL), 43 mWeOwnDict(false), 44 mUrlPath(NULL), 45 mFileDesc(NULL), 46 mSubdir(subdir), 47 mDefaults(NULL) 48 { 49 CFDataRef dictData = NULL; 50 CFStringRef cfErr = NULL; 51 52 assert(fileUrl != NULL); 53 mUrlPath = MDSCopyCstring(fullPath); 54 MPDebug("Creating MDSDictionary from %s", mUrlPath); 55 56 /* Load data from URL */ 57 SInt32 uerr; 58 Boolean brtn = CFURLCreateDataAndPropertiesFromResource( 59 NULL, 60 fileUrl, 61 &dictData, 62 NULL, // properties 63 NULL, // desiredProperties 64 &uerr); 65 if(!brtn) { 66 Syslog::alert("Error reading MDS file %s: %d", mUrlPath, (int)uerr); 67 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 68 } 69 70 /* if it's not a dictionary, we don't want it */ 71 mDict = reinterpret_cast<CFDictionaryRef>( 72 CFPropertyListCreateFromXMLData(NULL, 73 dictData, 74 kCFPropertyListImmutable, 75 &cfErr)); 76 CFRelease(dictData); 77 if(mDict == NULL) { 78 Syslog::alert("Malformed MDS file %s (1)", mUrlPath); 79 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 80 } 81 82 /* henceforth we must release this dictionary */ 83 mWeOwnDict = true; 84 if(CFGetTypeID(mDict) != CFDictionaryGetTypeID()) { 85 Syslog::alert("Malformed MDS file %s (2)", mUrlPath); 86 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 87 } 88 CF_RELEASE(cfErr); 89 90 /* get file description for error logging and debugging */ 91 CFStringRef cfStr = (CFStringRef)lookup(CFSTR(MDS_INFO_FILE_DESC), 92 true, CFStringGetTypeID()); 93 if(cfStr) { 94 CFIndex len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfStr), kCFStringEncodingUTF8) + 1/*nul terminator*/; 95 mFileDesc = new char[len]; 96 if(mFileDesc) { 97 CFStringGetCString(cfStr, mFileDesc, len, 98 kCFStringEncodingUTF8); 99 } 100 } 101 } 102 103 /* lightweight constructor from existing CFDictionary */ 104 MDSDictionary::MDSDictionary(CFDictionaryRef theDict) 105 : mDict(theDict), 106 mWeOwnDict(false), 107 mUrlPath(NULL), 108 mFileDesc(NULL), 109 mDefaults(NULL) 110 { 111 /* note caller owns and releases the dictionary */ 112 if(mDict == NULL) { 113 MPDebug("Malformed MDS file (3)"); 114 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 115 } 116 if(CFGetTypeID(mDict) != CFDictionaryGetTypeID()) { 117 MPDebug("Malformed MDS file (4)"); 118 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 119 } 120 } 121 122 MDSDictionary::~MDSDictionary() 123 { 124 if(mWeOwnDict) { 125 CF_RELEASE(mDict); 126 } 127 mDict = NULL; 128 delete [] mUrlPath; 129 delete [] mFileDesc; 130 } 131 132 /* lookup by either C string or CFStringRef - returns NULL on error */ 133 const void *MDSDictionary::lookup( 134 const char *key, 135 bool checkType, 136 CFTypeID type) 137 { 138 CFStringRef cfKey = CFStringCreateWithCString(NULL, 139 key, 140 kCFStringEncodingUTF8); 141 if(cfKey == NULL) { 142 MPDebug("MDSDictionary::lookup: error creating CFString for key"); 143 return NULL; 144 } 145 const void *rtn = lookup(cfKey, checkType, type); 146 CFRelease(cfKey); 147 return rtn; 148 149 } 150 151 const void *MDSDictionary::lookup( 152 CFStringRef key, 153 bool checkType, 154 CFTypeID type) 155 { 156 assert(mDict != NULL); 157 const void *rtn = CFDictionaryGetValue(mDict, key); 158 if(rtn && checkType) { 159 if(CFGetTypeID((CFTypeRef)rtn) != type) { 160 return NULL; 161 } 162 } 163 return rtn; 164 } 165 166 /* 167 * Common means to perform a lookup in a dictionary given a C-string key and 168 * placing the value - if present - in a CSSM_DB_ATTRIBUTE_DATA. Any errors 169 * are only logged via MPDebug. Returns true if the value was found and 170 * successfully placed in supplied CSSM_DB_ATTRIBUTE_DATA. 171 * 172 * For now we assume that the key in the dictionary is the same as the key 173 * in the DB to which we're writing. 174 * 175 * We're also assuming that all DB keys are of format CSSM_DB_ATTRIBUTE_NAME_AS_STRING. 176 */ 177 bool MDSDictionary::lookupToDbAttr( 178 const char *key, 179 CSSM_DB_ATTRIBUTE_DATA &attr, 180 CSSM_DB_ATTRIBUTE_FORMAT attrFormat, 181 const MDSNameValuePair *nameValues) // optional for converting strings to numbers 182 { 183 assert(mDict != NULL); 184 assert(&attr != NULL); 185 186 CFTypeRef value; // polymorphic dictionary value 187 bool ourRtn = false; 188 const void *srcPtr = NULL; // polymorphic raw source bytes 189 size_t srcLen = 0; 190 uint32 ival = 0; 191 uint32 *ivalArray = NULL; 192 uint32 numValues = 1; // the default for MDSRawValueToDbAttr 193 string stringVal; 194 195 value = (CFTypeRef)lookup(key); 196 if(value == NULL) { 197 return false; 198 } 199 CFTypeID valueType = CFGetTypeID(value); 200 201 /* 202 * We have the value; could be any type. Handle it based on caller's 203 * CSSM_DB_ATTRIBUTE_FORMAT. 204 */ 205 switch(attrFormat) { 206 case CSSM_DB_ATTRIBUTE_FORMAT_STRING: 207 { 208 if(valueType != CFStringGetTypeID()) { 209 MPDebug("lookupToDbAttr: string format mismatch"); 210 break; 211 } 212 stringVal = cfString((CFStringRef)value, false); 213 srcPtr = stringVal.c_str(); 214 srcLen = stringVal.size(); 215 if(srcLen) { 216 ourRtn = true; 217 } 218 break; 219 } 220 case CSSM_DB_ATTRIBUTE_FORMAT_UINT32: 221 { 222 bool brtn = MDSCfTypeToUInt32(value, nameValues, key, ival, srcLen); 223 if(!brtn) { 224 MPDebug("MDS lookupToDbAttr: Bad number conversion"); 225 return false; 226 } 227 srcPtr = &ival; 228 ourRtn = true; 229 break; 230 } 231 case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32: 232 { 233 /* 234 * This is expressed in the dictionary as an array of numbers. 235 * as in CSSM_DB_ATTRIBUTE_FORMAT_UINT32, each number can be 236 * expressed as either a string or a number. 237 */ 238 if(valueType != CFArrayGetTypeID()) { 239 /* 240 * Let's be extremely slick and allow one number here, either 241 * in string or number form.... 242 */ 243 bool brtn = MDSCfTypeToUInt32(value, nameValues, key, ival, srcLen); 244 if(!brtn) { 245 MPDebug("MDS lookupToDbAttr: Bad array element"); 246 return false; 247 } 248 srcPtr = &ival; 249 ourRtn = true; 250 break; 251 } 252 CFArrayRef cfArray = (CFArrayRef)value; 253 numValues = (uint32)CFArrayGetCount(cfArray); 254 if(numValues == 0) { 255 /* degenerate case, legal - right? Can AppleDatabase do this? */ 256 srcPtr = NULL; 257 srcLen = 0; 258 ourRtn = true; 259 break; 260 } 261 262 /* 263 * malloc an array of uint32s 264 * convert each element in cfArray to a uint32 265 * store as CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32 266 * 267 * Note this does not have to be endian independent; the MDS DBs 268 * are not portable across machines let alone platforms. 269 */ 270 ivalArray = new uint32[numValues]; 271 unsigned dex; 272 bool brtn; 273 for(dex=0; dex<numValues; dex++) { 274 CFTypeRef elmt = (CFTypeRef)CFArrayGetValueAtIndex(cfArray, dex); 275 if(elmt == NULL) { 276 MPDebug("MDS lookupToDbAttr: key %s: Bad array element (1)", key); 277 delete [] ivalArray; 278 return false; 279 } 280 size_t itemLen = 0; 281 brtn = MDSCfTypeToUInt32(elmt, nameValues, key, ivalArray[dex], itemLen); 282 if(!brtn) { 283 MPDebug("MDS lookupToDbAttr: key %s Bad element at index %d", 284 key, dex); 285 delete [] ivalArray; 286 return false; 287 } 288 srcLen += itemLen; 289 } 290 srcPtr = ivalArray; 291 ourRtn = true; 292 /* 293 * FIXME - numValues as used by MDSRawValueToDbAttr and placed in 294 * CSSM_DB_ATTRIBUTE_DATA.NumberOfValues, appears to need to be 295 * one even for MULTI_UINT32 format; the number of ints in inferred 296 * from Value.Length.... 297 */ 298 numValues = 1; 299 break; 300 } 301 case CSSM_DB_ATTRIBUTE_FORMAT_BLOB: // CFData 302 { 303 if(valueType != CFDataGetTypeID()) { 304 MPDebug("lookupToDbAttr: blob/CFData format mismatch"); 305 break; 306 } 307 CFDataRef cfData = (CFDataRef)value; 308 srcLen = CFDataGetLength(cfData); 309 srcPtr = CFDataGetBytePtr(cfData); 310 ourRtn = true; 311 break; 312 } 313 case CSSM_DB_ATTRIBUTE_FORMAT_SINT32: // I don't think we support this 314 default: 315 MPDebug("lookupToDbAttr: bad attrForm(%d)", (int)attrFormat); 316 return false; 317 } 318 if(ourRtn) { 319 MDSRawValueToDbAttr(srcPtr, srcLen, attrFormat, key, attr, numValues); 320 } 321 if(ivalArray) { 322 delete [] ivalArray; 323 } 324 return ourRtn; 325 } 326 327 /* 328 * Given a RelationInfo and an array of CSSM_DB_ATTRIBUTE_DATAs, fill in 329 * the CSSM_DB_ATTRIBUTE_DATA array with as many fields as we can find in 330 * the dictionary. All fields are treated as optional. 331 */ 332 void MDSDictionary::lookupAttributes( 333 const RelationInfo *relInfo, 334 CSSM_DB_ATTRIBUTE_DATA_PTR outAttrs, // filled in on return 335 uint32 &numAttrs) // RETURNED 336 { 337 unsigned dex; 338 const CSSM_DB_ATTRIBUTE_INFO *inAttr = relInfo->AttributeInfo; 339 const MDSNameValuePair **nameValues = relInfo->nameValues; 340 341 assert(relInfo != NULL); 342 numAttrs = 0; 343 for(dex=0; dex<relInfo->NumberOfAttributes; dex++) { 344 bool brtn; 345 const MDSNameValuePair *nvp; 346 347 /* the array itself, or any element in it, can be NULL */ 348 if(nameValues != NULL) { 349 nvp = nameValues[dex]; 350 } 351 else { 352 nvp = NULL; 353 } 354 brtn = lookupToDbAttr(inAttr->Label.AttributeName, 355 *outAttrs, 356 inAttr->AttributeFormat, 357 nvp); 358 if(brtn) { 359 /* successfully added to dbAttrs */ 360 outAttrs++; 361 numAttrs++; 362 } 363 inAttr++; // regardless 364 } 365 } 366 367 /* 368 * Lookup with file-based indirection. Allows multiple mdsinfo files to share commmon 369 * info from a separate plist file. 370 * 371 * Do a lookup for specified key. If not found, return NULL. If found: 372 * { 373 * if type of value matches desiredType { 374 * return the value; 375 * } 376 * else if type of value is string { 377 * if string starts with "file:" { 378 * attempt to read property list with that filename relative to 379 * specified bundle; 380 * if CFType of that propList matches desiredType { 381 * return newly read propList; 382 * } 383 * } 384 * } 385 * ...else return error; 386 */ 387 CFPropertyListRef MDSDictionary::lookupWithIndirect( 388 const char *key, 389 CFBundleRef bundle, 390 CFTypeID desiredType) 391 { 392 CFPropertyListRef ourRtn = NULL; 393 CFDataRef dictData = NULL; 394 CFStringRef cfErr = NULL; 395 SInt32 uerr; 396 Boolean brtn; 397 398 399 assert(key != NULL); 400 assert(bundle != NULL); 401 402 /* basic local lookup */ 403 CFStringRef cfKey = CFStringCreateWithCString(NULL, 404 key, 405 kCFStringEncodingUTF8); 406 if(cfKey == NULL) { 407 MPDebug("CFStringCreateWithCString error"); 408 return NULL; 409 } 410 CFCopyRef<CFStringRef> rtn = (CFStringRef)CFDictionaryGetValue(mDict, cfKey); 411 CFRelease(cfKey); 412 if(!rtn) { 413 return NULL; 414 } 415 CFTypeID foundType = CFGetTypeID(rtn); 416 if(foundType == desiredType) { 417 /* found what we're looking for; done */ 418 return (CFPropertyListRef)rtn.yield(); 419 } 420 421 /* is it a string which starts with "file:"? */ 422 if(foundType != CFStringGetTypeID()) { 423 return NULL; 424 } 425 const char *cVal = MDSCFStringToCString(rtn); 426 if(cVal == NULL) { 427 MPDebug("MDSCFStringToCString error in lookupWithIndirect"); 428 return NULL; 429 } 430 if(strstr(cVal, "file:") != cVal) { 431 delete [] cVal; 432 return NULL; 433 } 434 /* delete [] cval on return */ 435 436 /* OK, this specifies a resource file in the bundle. Fetch it. */ 437 CFURLRef fileUrl = NULL; 438 CFStringRef cfFileName = CFStringCreateWithCString(NULL, 439 cVal + 5, 440 kCFStringEncodingUTF8); 441 if(cfFileName == NULL) { 442 MPDebug("lookupWithIndirect: bad file name spec"); 443 goto abort; 444 } 445 fileUrl = CFBundleCopyResourceURL(bundle, 446 cfFileName, 447 NULL, 448 mSubdir); 449 if(fileUrl == NULL) { 450 MPDebug("lookupWithIndirect: file %s not found", cVal); 451 goto abort; 452 } 453 454 MPDebug("Fetching indirect resource %s", cVal); 455 456 /* Load data from URL */ 457 brtn = CFURLCreateDataAndPropertiesFromResource( 458 NULL, 459 fileUrl, 460 &dictData, 461 NULL, // properties 462 NULL, // desiredProperties 463 &uerr); 464 if(!brtn) { 465 MPDebug("lookupWithIndirect: error %d reading %s", (int)uerr, cVal); 466 goto abort; 467 } 468 469 /* if it's not a property list, we don't want it */ 470 ourRtn = CFPropertyListCreateFromXMLData(NULL, 471 dictData, 472 kCFPropertyListImmutable, 473 &cfErr); 474 if(ourRtn == NULL) { 475 MPDebug("lookupWithIndirect: %s malformed (not a prop list)", cVal); 476 goto abort; 477 } 478 479 /* if it doesn't match the caller's spec, we don't want it */ 480 if(CFGetTypeID(ourRtn) != desiredType) { 481 MPDebug("lookupWithIndirect: %s malformed (mismatch)", cVal); 482 CF_RELEASE(ourRtn); 483 ourRtn = NULL; 484 goto abort; 485 } 486 487 MPDebug("lookupWithIndirect: resource %s FOUND", cVal); 488 489 abort: 490 delete [] cVal; 491 CF_RELEASE(cfFileName); 492 CF_RELEASE(fileUrl); 493 CF_RELEASE(dictData); 494 CF_RELEASE(cfErr); 495 return ourRtn; 496 } 497 498 void MDSDictionary::setDefaults(const MDS_InstallDefaults *defaults) 499 { 500 mDefaults = defaults; 501 502 /* 503 * Save the values into (a new) mDict. 504 */ 505 assert(mDict != NULL); 506 CFMutableDictionaryRef tmpDict = CFDictionaryCreateMutableCopy(NULL, 0, mDict); 507 if(tmpDict == NULL) { 508 MPDebug("setDefaults: error copying old dictionary"); 509 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 510 } 511 512 CFStringRef tmpStr = NULL; 513 514 /* 515 * CFDictionaryAddValue() does nothing if the requested key is already 516 * present. If you need to call setDefaults() more than once, you'll 517 * have to add the code to remove the old key/value pairs first. 518 */ 519 if(defaults) { 520 if(defaults->guid) { 521 tmpStr = CFStringCreateWithCString(NULL, defaults->guid, kCFStringEncodingUTF8); 522 if(tmpStr) { 523 CFDictionaryAddValue(tmpDict, CFSTR("ModuleID"), tmpStr); 524 CFRelease(tmpStr); 525 } 526 else { 527 MPDebug("setDefaults: error creating CFString for GUID"); 528 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 529 } 530 } 531 532 CFNumberRef tmpNum = CFNumberCreate(NULL, kCFNumberIntType, &defaults->ssid); 533 if(tmpNum) { 534 CFDictionaryAddValue(tmpDict, CFSTR("SSID"), tmpNum); 535 CFRelease(tmpNum); 536 } 537 else { 538 MPDebug("setDefaults: error creating CFString for SSID"); 539 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 540 } 541 542 if(defaults->serial) { 543 tmpStr = CFStringCreateWithCString(NULL, defaults->serial, kCFStringEncodingUTF8); 544 if(tmpStr) { 545 CFDictionaryAddValue(tmpDict, CFSTR("ScSerialNumber"), tmpStr); 546 CFRelease(tmpStr); 547 } 548 else { 549 MPDebug("setDefaults: error creating CFString for serial number"); 550 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 551 } 552 } 553 554 if(defaults->printName) { 555 tmpStr = CFStringCreateWithCString(NULL, defaults->printName, kCFStringEncodingUTF8); 556 if(tmpStr) { 557 CFDictionaryAddValue(tmpDict, CFSTR("ScDesc"), tmpStr); 558 CFRelease(tmpStr); 559 } 560 else { 561 MPDebug("setDefaults: error creating CFString for description"); 562 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 563 } 564 } 565 } 566 567 if(mUrlPath) { 568 tmpStr = CFStringCreateWithCString(NULL, mUrlPath, kCFStringEncodingUTF8); 569 if(tmpStr) { 570 CFDictionaryAddValue(tmpDict, CFSTR("Path"), tmpStr); 571 CFRelease(tmpStr); 572 } 573 else { 574 MPDebug("setDefaults: error creating CFString for path"); 575 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 576 } 577 } 578 CFDictionaryRef oldDict = mDict; 579 mDict = CFDictionaryCreateCopy(NULL, tmpDict); 580 if(mDict == NULL) { 581 mDict = oldDict; // first do no harm 582 CFRelease(tmpDict); 583 MPDebug("setDefaults: error creating new dictionary"); 584 CssmError::throwMe(CSSMERR_CSSM_MDS_ERROR); 585 } 586 CFRelease(oldDict); 587 CFRelease(tmpDict); 588 } 589 590 591 } // end namespace Security