/* This needs to be exported to make it callable from Foundation. */ CF_EXPORT CFReadStreamRef CFReadStreamCreateWithData(CFAllocatorRef alloc, CFDataRef data) { _CFReadDataStreamContext ctxt; CFReadStreamRef result = NULL; CFDataRef copiedData = CFDataCreateCopy(alloc, data); ctxt.data = copiedData; result = (CFReadStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &ctxt, (struct _CFStreamCallBacks *)(&readDataCallBacks), TRUE); CFRelease(copiedData); return result; }
CFDataRef SOSRecoveryKeyCopyKeyForAccount(CFAllocatorRef allocator, SOSAccountRef account, SOSRecoveryKeyBagRef recoveryKeyBag, CFErrorRef *error) { CFDataRef retval = NULL; require_action_quiet(recoveryKeyBag && recoveryKeyBag->recoveryKeyBag && recoveryKeyBag->accountDSID, errOut, SOSCreateError(kSOSErrorDecodeFailure, CFSTR("Null recoveryKeyBag Object"), NULL, error)); CFStringRef dsid = asString(SOSAccountGetValue(account, kSOSDSIDKey, NULL), error); require_action_quiet(dsid, errOut, SOSCreateError(kSOSErrorDecodeFailure, CFSTR("No DSID in Account"), NULL, error)); require_action_quiet(CFEqual(dsid, recoveryKeyBag->accountDSID), errOut, SOSCreateError(kSOSErrorDecodeFailure, CFSTR("Account/RecoveryKeybag DSID miss-match"), NULL, error)); retval = CFDataCreateCopy(allocator, recoveryKeyBag->recoveryKeyBag); errOut: return retval; }
static CFDataRef createIVFromPassword(CFStringRef password) { CFDataRef hashedPassword, retval; CFMutableDataRef iv; if((hashedPassword = digestString(password)) == NULL) return NULL; iv = CFDataCreateMutableCopy(kCFAllocatorDefault, CFDataGetLength(hashedPassword)+1, hashedPassword); CFDataDeleteBytes(iv, CFRangeMake(IVBYTECOUNT, CFDataGetLength(iv)-IVBYTECOUNT)); retval = CFDataCreateCopy(kCFAllocatorDefault, iv); CFRelease(hashedPassword); CFRelease(iv); return retval; }
CFDataRef Preferences::create_signature(void) const { if (this->m_plist) { return get_path_signature(this->m_pspec.c_str()); } if (this->m_scpref) { CFDataRef sig; /* Copy the signature so we adhere to the get rule. */ if ((sig = SCPreferencesGetSignature(m_scpref))) { return CFDataCreateCopy(kCFAllocatorDefault, sig); } } return NULL; }
static void IPStreamCallback(CFReadStreamRef stream, CFStreamEventType eventType, void *clientCallBackInfo) { CFMutableDataRef responseData = (CFMutableDataRef)clientCallBackInfo; if(eventType & kCFStreamEventHasBytesAvailable) { UInt8 buffer[1024]; CFIndex read; do { read = CFReadStreamRead(stream, buffer, sizeof(buffer)); if(read > 0) CFDataAppendBytes(responseData, buffer, read); } while(read > 0); } if(eventType & (kCFStreamEventEndEncountered | kCFStreamEventErrorOccurred)) { if((eventType & kCFStreamEventEndEncountered) && publicIPState == IPStateFetching) { if(publicIPData) CFRelease(publicIPData); publicIPData = CFDataCreateCopy(kCFAllocatorDefault, responseData); publicIPState = IPStateFetched; } if(eventType & kCFStreamEventErrorOccurred) { if(publicIPData) CFRelease(publicIPData); publicIPData = NULL; publicIPState = IPStateInvalid; } CFReadStreamClose(stream); CFReadStreamSetClient(stream, 0, NULL, NULL); CFReadStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes); CFRelease(stream); CFRelease(responseData); } }
SOSRecoveryKeyBagRef SOSRecoveryKeyBagCreateForAccount(CFAllocatorRef allocator, SOSAccountRef account, CFDataRef pubData, CFErrorRef *error) { SOSRecoveryKeyBagRef retval = NULL; SOSGenCountRef gencount = NULL; require_action_quiet(account, errOut, SOSCreateError(kSOSErrorEncodeFailure, CFSTR("Null Account Object"), NULL, error)); CFStringRef dsid = asString(SOSAccountGetValue(account, kSOSDSIDKey, NULL), error); gencount = SOSGenerationCreate(); require_action_quiet(pubData && dsid && gencount, errOut, SOSCreateError(kSOSErrorEncodeFailure, CFSTR("Couldn't get recovery keybag components"), NULL, error)); retval = CFTypeAllocate(SOSRecoveryKeyBag, struct __OpaqueSOSRecoveryKeyBag, allocator); require_action_quiet(retval, errOut, SOSCreateError(kSOSErrorEncodeFailure, CFSTR("Couldn't get memory for recoveryKeyBag"), NULL, error)); retval->rkbVersion = CURRENT_RKB_VERSION; retval->accountDSID = CFStringCreateCopy(allocator, dsid); CFRetainAssign(retval->generation, gencount); retval->recoveryKeyBag = CFDataCreateCopy(allocator, pubData); errOut: CFReleaseNull(gencount); return retval; }
static inline TStringIRep* TSICTStringCreateWithDataOfTypeAndFormat(CFDataRef data, TSITStringTag type, TSITStringFormat format) { if (format == kTSITStringFormatDefault) { format = TSICTStringGetDefaultFormat(); } TStringIRep* rep = calloc(1, sizeof(TStringIRep)); rep->data = CFDataCreateCopy(kCFAllocatorDefault, data); rep->type = type; rep->format = format; rep->length = calloc(10, sizeof(char)); CFIndex len = CFDataGetLength(rep->data); if (snprintf(rep->length, 10, "%lu", len)) { return rep; } else { TSICTStringDestroy(rep); return NULL; } }
CFErrorRef accumulate_data(CFMutableArrayRef *a, CFDataRef d) { if (!*a) { *a = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); if (!*a) { return GetNoMemoryError(); } } CFDataRef dc = CFDataCreateCopy(NULL, d); if (!dc) { return GetNoMemoryError(); } CFIndex c = CFArrayGetCount(*a); CFArrayAppendValue(*a, dc); CFRelease(dc); if (CFArrayGetCount(*a) != c+1) { return GetNoMemoryError(); } return NULL; }
OSStatus CMPVideoFormatDescriptionCopyExtradata(CFAllocatorRef allocator, CMVideoFormatDescriptionRef formatDescription, CFDataRef *outExtradata) { const FourCharCode mediaSubType = CMFormatDescriptionGetMediaSubType(formatDescription); if(mediaSubType == kCMVideoCodecType_MPEG4Video || mediaSubType == kCMVideoCodecType_H264) { CFDictionaryRef atoms = CMFormatDescriptionGetExtension(formatDescription, kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms); CFDataRef extradata = CFDictionaryGetValue(atoms, CFSTR("avcC")); if(extradata == nil) { return CMPParameterError; } *outExtradata = CFDataCreateCopy(allocator, extradata); return noErr; } else { *outExtradata = NULL; return noErr; } }
static inline CFDataRef TSICTStringCreateDataFromIntermediateRepresentation(TStringIRep* rep) { CFIndex len = CFDataGetLength(rep->data); CFMutableDataRef buffer = CFDataCreateMutableCopy(kCFAllocatorDefault, (len + 12), rep->data); UInt8* bufferBytes = CFDataGetMutableBytePtr(buffer); size_t prefixLength = strlen(rep->length) + 1; CFDataReplaceBytes(buffer, BeginningRange, (const UInt8*)rep->length, (CFIndex)prefixLength); if (rep->format == kTSITStringFormatTNetstring) { const UInt8 ftag = (UInt8)TNetstringTypes[rep->type]; CFDataAppendBytes(buffer, &ftag, 1); bufferBytes[(prefixLength - 1)] = TNetstringSeparator; } else if (rep->format == kTSITStringFormatOTNetstring) { const UInt8 ftag = (UInt8)OTNetstringTypes[rep->type]; bufferBytes[(prefixLength - 1)] = ftag; } CFDataRef dataRep = CFDataCreateCopy(kCFAllocatorDefault, buffer); CFRelease(buffer); return dataRep; }
Status genUnlockIdent(CFDataRef& uuid) { auto chosen = IORegistryEntryFromPath(kIOMasterPortDefault, kIODeviceTreeChosenPath_); if (chosen == MACH_PORT_NULL) { return Status(1, "Could not open IOKit DeviceTree"); } CFMutableDictionaryRef properties = nullptr; auto kr = IORegistryEntryCreateCFProperties( chosen, &properties, kCFAllocatorDefault, kNilOptions); IOObjectRelease(chosen); if (kr != KERN_SUCCESS) { return Status(1, "Could not get IOKit chosen properties"); } if (properties == nullptr) { return Status(1, "Could not load IOKit properties"); } CFTypeRef unlock_ident = nullptr; if (CFDictionaryGetValueIfPresent( properties, CFSTR("efilogin-unlock-ident"), &unlock_ident)) { if (CFGetTypeID(unlock_ident) != CFDataGetTypeID()) { return Status(1, "Unexpected data type for unlock ident"); } uuid = CFDataCreateCopy(kCFAllocatorDefault, (CFDataRef)unlock_ident); if (uuid == nullptr) { return Status(1, "Could not get UUID"); } CFRelease(properties); return Status(0, "ok"); } return Status(1, "Could not get unlock ident"); }