自学教程：C++ CFDataCreate函数代码示例

CFDataRef SharedBuffer::createCFData(){    if (m_cfData) {        CFRetain(m_cfData.get());        return m_cfData.get();    }    // Internal data in SharedBuffer can be segmented. We need to get the contiguous buffer.    const Vector<char>& contiguousBuffer = buffer();    return CFDataCreate(0, reinterpret_cast<const UInt8*>(contiguousBuffer.data()), contiguousBuffer.size());}

NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name) {    //notice("psst: GetStringIdentifier '%s'", name);    CFDataRef data = CFDataCreate(NULL, (unsigned char *) name, strlen(name));    CFDataRef ret = CFSetGetValue(identifier_set, data);    if(!ret) {        CFSetAddValue(identifier_set, data);        ret = data;    }    CFRelease(data);    return (NPIdentifier) ret;}

void GraphicsContext::drawWindowsBitmap(WindowsBitmap* image, const IntPoint& point){    RetainPtr<CGColorSpaceRef> deviceRGB(AdoptCF, CGColorSpaceCreateDeviceRGB());    // FIXME: Creating CFData is non-optimal, but needed to avoid crashing when printing.  Ideally we should     // make a custom CGDataProvider that controls the WindowsBitmap lifetime.  see <rdar://6394455>    RetainPtr<CFDataRef> imageData(AdoptCF, CFDataCreate(kCFAllocatorDefault, image->buffer(), image->bufferLength()));    RetainPtr<CGDataProviderRef> dataProvider(AdoptCF, CGDataProviderCreateWithCFData(imageData.get()));    RetainPtr<CGImageRef> cgImage(AdoptCF, CGImageCreate(image->size().width(), image->size().height(), 8, 32, image->bytesPerRow(), deviceRGB.get(),                                                         kCGBitmapByteOrder32Little | kCGImageAlphaFirst, dataProvider.get(), 0, true, kCGRenderingIntentDefault));    CGContextDrawImage(m_data->m_cgContext.get(), CGRectMake(point.x(), point.y(), image->size().width(), image->size().height()), cgImage.get());   }

void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength){    LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %i for '%s'", (int)data.size(), m_coreLoader->url().string().utf8().data());#if USE(QUICK_LOOK)    if (QuickLookHandle* quickLookHandle = m_coreLoader->documentLoader()->quickLookHandle()) {        if (quickLookHandle->didReceiveData(adoptCF(CFDataCreate(kCFAllocatorDefault, data.data(), data.size())).get()))            return;    }#endif    m_coreLoader->didReceiveData(reinterpret_cast<const char*>(data.data()), data.size(), encodedDataLength, DataPayloadBytes);}

static OSStatus BIMSendMessageToUIServer( BasicMessageID inMessageID ){    OSStatus result;    CFDataRef sendData;    CFDataRef replyData;    CFMessagePortRef serverPortRef;    BasicMessageHeader header;    result = noErr;    sendData = NULL;    replyData = NULL;    serverPortRef = NULL;    //  Create a reference to the remote message port. We identify the port using a unique,    //  system-wide name, in this case defined by kBasicServerPortName.    serverPortRef = CFMessagePortCreateRemote( NULL, CFSTR( kBasicServerPortName ) );    if( serverPortRef == NULL )        result = -1;            //  Create our message header.    if( result == noErr )        result = GetCurrentProcess( &header.fProcessSerialNumber );    if( result == noErr ) {        sendData = CFDataCreate( NULL, (UInt8 *) &header, sizeof( BasicMessageHeader ) );        if (sendData == NULL)            result = memFullErr;    }    //  Send the message specified in iMessageID to the server. We send the message header    //  as data.    if( result == noErr ) {        if( CFMessagePortSendRequest( serverPortRef, inMessageID, sendData,                                      10, 10, NULL, &replyData ) != kCFMessagePortSuccess )            result = -2;    }    //	Release everything.    if( sendData )	CFRelease( sendData );    if( replyData )	CFRelease( replyData );    if( serverPortRef )	CFRelease( serverPortRef );      //  Return an error code to the caller.     return result;}

__private_extern__voidinterface_update_link_issues(const char		*if_name,			     uint64_t		timestamp,			     uint8_t		*modid,			     size_t		modid_size,			     uint8_t		*info,			     size_t		info_size){	CFDataRef		infoData;	CFStringRef		key;	CFDataRef		modidData;	CFMutableDictionaryRef	newDict;	CFDateRef		timeStamp;	key = create_link_issues_key(if_name);	newDict = copy_entity(key);	modidData = CFDataCreate(NULL, modid, modid_size);	CFDictionarySetValue(newDict, kSCPropNetLinkIssuesModuleID, modidData);	CFRelease(modidData);	if (info_size != 0) {		infoData = CFDataCreate(NULL, info, info_size);		CFDictionarySetValue(newDict, kSCPropNetLinkIssuesInfo, infoData);		CFRelease(infoData);	} else {		CFDictionaryRemoveValue(newDict, kSCPropNetLinkIssuesInfo);	}	timeStamp = CFDateCreate(NULL, timestamp);	CFDictionarySetValue(newDict, kSCPropNetLinkIssuesTimeStamp, timeStamp);	CFRelease(timeStamp);	cache_SCDynamicStoreSetValue(store, key, newDict);	CFRelease(newDict);	CFRelease(key);	return;}

void SavePrefs (void){	CFMutableStringRef	mref;	CFStringRef			sref;	CFDataRef			data;	for (unsigned int i = 0; i < kPrefListSize; i++)	{		mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_"));		if (mref)		{			sref = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *) &(prefList[i].itemName), sizeof(OSType), kCFStringEncodingMacRoman, false);			if (sref)			{				CFStringAppend(mref, sref);				data = CFDataCreate(kCFAllocatorDefault, (UInt8 *) prefList[i].itemPointer, prefList[i].size);				if (data)				{					CFPreferencesSetAppValue(mref, data, kCFPreferencesCurrentApplication);					CFRelease(data);				}				CFRelease(sref);			}			CFRelease(mref);		}	}	mref = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFSTR("Preferences_SaveFolder"));	if (mref)	{		if (saveFolderPath)		{			CFPreferencesSetAppValue(mref, saveFolderPath, kCFPreferencesCurrentApplication);			CFRelease(saveFolderPath);		}		else			CFPreferencesSetAppValue(mref, NULL, kCFPreferencesCurrentApplication);		CFRelease(mref);	}	sref = (CFStringRef) CFDictionaryGetValue(CFBundleGetInfoDictionary(CFBundleGetMainBundle()), CFSTR("CFBundleShortVersionString"));	if (sref)	{		CFPreferencesSetAppValue(CFSTR("LastVersionUsed"), sref, kCFPreferencesCurrentApplication);	}	CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);}

sdmmd_return_t SDMMD_MB2SendEndStream(SDMMD_AMConnectionRef conn) {	sdmmd_return_t result = kAMDSuccess;		uint32_t zero_stream = 0x0;	CFDataRef stream_end = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)&zero_stream, sizeof(uint32_t));	result = SDMMD_DirectServiceSend(SDMMD_TranslateConnectionToSocket(conn), stream_end);	CFSafeRelease(stream_end);		CFMutableArrayRef status_response = SDMMD_MB2StatusResponseMessage();	result = SDMMD_ServiceSendMessage(SDMMD_TranslateConnectionToSocket(conn), status_response, kCFPropertyListBinaryFormat_v1_0);	return result;}

JNIEXPORT jintLong JNICALL WebKit_win32_NATIVE(CFDataCreate)	(JNIEnv *env, jclass that, jintLong arg0, jbyteArray arg1, jint arg2){	jbyte *lparg1=NULL;	jintLong rc = 0;	WebKit_win32_NATIVE_ENTER(env, that, CFDataCreate_FUNC);	if (arg1) if ((lparg1 = env->GetByteArrayElements(arg1, NULL)) == NULL) goto fail;	rc = (jintLong)CFDataCreate((CFAllocatorRef)arg0, (const UInt8 *)lparg1, (CFIndex)arg2);fail:	if (arg1 && lparg1) env->ReleaseByteArrayElements(arg1, lparg1, 0);	WebKit_win32_NATIVE_EXIT(env, that, CFDataCreate_FUNC);	return rc;}

static inline CFDataRef stream_buffer_read_cfdata(stream_buffer_t *sb, size_t size){  CFDataRef cfdata;  if (sb->cursor + size > sb->size) {    return NULL;  }  cfdata = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)(sb->bytes + sb->cursor), size);  sb->cursor += size;  return cfdata;}

static bool decodeCFData(Decoder& decoder, RetainPtr<CFDataRef>& data){    uint64_t size = 0;    if (!decoder.decode(size))        return false;    Vector<uint8_t> vector(size);    if (!decoder.decodeFixedLengthData(vector.data(), vector.size()))        return false;    data = adoptCF(CFDataCreate(nullptr, vector.data(), vector.size()));    return true;}

extern int trust_settings_import(int argc, char * const *argv){	extern char *optarg;	extern int optind;	OSStatus ortn;	int arg;	char *settingsFile = NULL;	unsigned char *settingsData = NULL;	size_t settingsLen = 0;	CFDataRef settings = NULL;	SecTrustSettingsDomain domain = kSecTrustSettingsDomainUser;	int rtn;	if(argc < 2) {		return 2; /* @@@ Return 2 triggers usage message. */	}	optind = 1;	while ((arg = getopt(argc, argv, "dh")) != -1) {		switch (arg) {			case 'd':				domain = kSecTrustSettingsDomainAdmin;				break;			default:				return 2;		}	}	if(optind != (argc - 1)) {		/* no args left for settings file */		return 2;	}	settingsFile = argv[optind];	rtn = readFileSizet(settingsFile, &settingsData, &settingsLen);	if(rtn) {		fprintf(stderr, "Error (%d) reading %s./n", rtn, settingsFile);		return 1;	}	settings = CFDataCreate(NULL, (const UInt8 *)settingsData, settingsLen);	free(settingsData);	ortn = SecTrustSettingsImportExternalRepresentation(domain, settings);	CFRelease(settings);	if(ortn) {		cssmPerror("SecTrustSettingsImportExternalRepresentation", ortn);		rtn = 1;	}	else if(!do_quiet) {		fprintf(stdout, "...Trust Settings imported successfully./n");		rtn = 0;	}	return rtn;}

static void tests(void){	CFDataRef attached_signed_data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, attached_signed_data_der, attached_signed_data_der_len, kCFAllocatorNull);	CFDataRef detached_signed_data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, detached_signed_data_der, detached_signed_data_der_len, kCFAllocatorNull);	CFDataRef attached_no_data_signed_data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, attached_no_data_signed_data_der, attached_no_data_signed_data_der_len, kCFAllocatorNull);	CFDataRef detached_data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, detached_content, detached_content_len, kCFAllocatorNull);	CFDataRef no_data = CFDataCreate(kCFAllocatorDefault, NULL, 0);	SecPolicyRef policy = SecPolicyCreateBasicX509();	SecTrustRef trust = NULL;	ok_status(SecCMSVerifyCopyDataAndAttributes(attached_signed_data, NULL, policy, &trust, NULL, NULL), "verify attached data");	CFRelease(trust);	ok_status(SecCMSVerifyCopyDataAndAttributes(detached_signed_data, detached_data, policy, &trust, NULL, NULL), "verify detached data");	CFRelease(trust);	ok_status(SecCMSVerifyCopyDataAndAttributes(attached_no_data_signed_data, NULL, policy, &trust, NULL, NULL), "verify attached no data");	CFRelease(trust);	ok_status(SecCMSVerifyCopyDataAndAttributes(attached_no_data_signed_data, no_data, policy, &trust, NULL, NULL), "verify attached no data");	CFRelease(trust);    SecCertificateRef cert = NULL;    SecKeyRef privKey = NULL;    SecIdentityRef identity = NULL;    isnt(cert = SecCertificateCreateWithBytes(NULL, signer_der, signer_der_len), NULL, "create certificate");    isnt(privKey = SecKeyCreateRSAPrivateKey(NULL, privkey_der, privkey_der_len, kSecKeyEncodingPkcs1), NULL, "create private key");    isnt(identity = SecIdentityCreate(NULL, cert, privKey), NULL, "create identity");    CFReleaseSafe(privKey);	CFMutableDataRef cms_data = CFDataCreateMutable(kCFAllocatorDefault, 0);	ok_status(SecCMSCreateSignedData(identity, detached_data, NULL, NULL, cms_data), "create attached data");	//write_data("/var/tmp/attached", cms_data);	CFDataSetLength(cms_data, 0);	CFDictionaryRef detached_cms_dict = CFDictionaryCreate(kCFAllocatorDefault, (const void **)&kSecCMSSignDetached, (const void **)&kCFBooleanTrue, 1, NULL, NULL);	ok_status(SecCMSCreateSignedData(identity, detached_data, detached_cms_dict, NULL, cms_data), "create attached data");	CFRelease(detached_cms_dict);	//write_data("/var/tmp/detached", cms_data);	CFDataSetLength(cms_data, 0);	ok_status(SecCMSCreateSignedData(identity, NULL, NULL, NULL, cms_data), "create attached data");	//write_data("/var/tmp/empty_attached", cms_data);	CFReleaseSafe(cms_data);	CFReleaseSafe(cert);	CFReleaseNull(identity);	CFRelease(attached_signed_data);	CFRelease(detached_signed_data);	CFRelease(attached_no_data_signed_data);	CFRelease(detached_data);	CFRelease(no_data);	CFRelease(policy);}

void setHTTPBody(CFMutableURLRequestRef request, PassRefPtr<FormData> formData){    if (!formData) {        wkCFURLRequestSetHTTPRequestBodyParts(request, 0);        return;    }    size_t count = formData->elements().size();    if (count == 0)        return;    // Handle the common special case of one piece of form data, with no files.    if (count == 1) {        const FormDataElement& element = formData->elements()[0];        if (element.m_type == FormDataElement::data) {            CFDataRef data = CFDataCreate(0, reinterpret_cast<const UInt8 *>(element.m_data.data()), element.m_data.size());   //         CFURLRequestSetHTTPRequestBody(request, data); //Ricardo: comentando por error            CFRelease(data);            return;        }    }    RetainPtr<CFMutableArrayRef> array(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));    for (size_t i = 0; i < count; ++i) {        const FormDataElement& element = formData->elements()[i];        if (element.m_type == FormDataElement::data) {            RetainPtr<CFDataRef> data(AdoptCF, CFDataCreate(0, reinterpret_cast<const UInt8*>(element.m_data.data()), element.m_data.size()));            CFArrayAppendValue(array.get(), data.get());        } else {            RetainPtr<CFStringRef> filename(AdoptCF, element.m_filename.createCFString());            CFArrayAppendValue(array.get(), filename.get());        }    }    wkCFURLRequestSetHTTPRequestBodyParts(request, array.get());}

void testInvalidLicenseFile(void){	CFDataRef invalidLicenseFileData = CFDataCreate(NULL,													(const UInt8 *)invalidLicenseFileContents,													(CFIndex)strlen(invalidLicenseFileContents));	Boolean licenseIsValid = APVerifyLicenseData(invalidLicenseFileData);	CFRelease(invalidLicenseFileData);		if (!licenseIsValid) {		CFShow(CFSTR("Test OK: Invalid file recognised as invalid"));	} else {		CFShow(CFSTR("Test FAILED: Invalid file not recognised as invalid"));	}}

CFDataRefSecRandomCopyData(SecRandomRef rnd, size_t count){    uint8_t *bytes;    CFDataRef retval = NULL;        if (rnd != kSecRandomDefault) return NULL;    if((bytes = malloc(count)) == NULL) return NULL;    if(CCRandomCopyBytes(kCCRandomDefault, bytes, count) == kCCSuccess)        retval = CFDataCreate(kCFAllocatorDefault, bytes, count);    bzero(bytes, count);    free(bytes);    return retval;}

void setHTTPBody(CFMutableURLRequestRef request, FormData* formData){    if (!formData)        return;            size_t count = formData->elements().size();    // Handle the common special case of one piece of form data, with no files.    if (count == 1 && !formData->alwaysStream()) {        const FormDataElement& element = formData->elements()[0];        if (element.m_type == FormDataElement::Type::Data) {            RetainPtr<CFDataRef> data = adoptCF(CFDataCreate(0, reinterpret_cast<const UInt8 *>(element.m_data.data()), element.m_data.size()));            CFURLRequestSetHTTPRequestBody(request, data.get());            return;        }    }    Ref<FormData> newFormData = formData->resolveBlobReferences();    count = newFormData->elements().size();    // Precompute the content length so NSURLConnection doesn't use chunked mode.    unsigned long long length = 0;    for (size_t i = 0; i < count; ++i) {        const FormDataElement& element = newFormData->elements()[i];        if (element.m_type == FormDataElement::Type::Data)            length += element.m_data.size();        else {            // If we're sending the file range, use the existing range length for now. We will detect if the file has been changed right before we read the file and abort the operation if necessary.            if (element.m_fileLength != BlobDataItem::toEndOfFile) {                length += element.m_fileLength;                continue;            }            long long fileSize;            if (getFileSize(element.m_shouldGenerateFile ? element.m_generatedFilename : element.m_filename, fileSize))                length += fileSize;        }    }    // Create and set the stream.    // Pass the length along with the formData so it does not have to be recomputed.    FormCreationContext formContext = {WTFMove(newFormData), length};    CFReadStreamCallBacksV1 callBacks = { 1, formCreate, formFinalize, 0, formOpen, 0, formRead, 0, formCanRead, formClose, formCopyProperty, 0, 0, formSchedule, formUnschedule    };    RetainPtr<CFReadStreamRef> stream = adoptCF(CFReadStreamCreate(0, static_cast<const void*>(&callBacks), &formContext));    CFURLRequestSetHTTPRequestBodyStream(request, stream.get());}

bool test2(){	CFStringRef password = CFSTR("queeg");	unsigned char salt_bytes[] = { 0x05,0xDE,0xC9,0x59,0xAC,0xFF,0x72,0xF7 };	CFDataRef salt = CFDataCreate(NULL, salt_bytes, sizeof(salt_bytes));	unsigned char correct_result[] = { 0xED,0x20,0x34,0xE3,0x63,0x28,0x83,0x0F,0xF0,0x9D,0xF1,0xE1,0xA0,0x7D,0xD3,0x57,0x18,0x5D,0xAC,0x0D,0x4F,0x9E,0xB3,0xD4 };	unsigned char result[24];	p12PbeGen(password, salt, 1000, PBE_ID_Key, result, sizeof(result));	if (memcmp(correct_result, result, sizeof(correct_result))) {		printf("test failure/n");		return false;	}	return true;}

CFDataRef	HP_IOCycleTelemetry::GetTelemetry(const CACFDictionary& /*inMessageData*/){    CFDataRef theAnswer = NULL;    if(mIsEnabled)    {        CAGuard::Locker theItemGuard(mItemGuard);        CAHALIOCycleRawTelemetryEvent* theItemBuffer = NULL;        UInt32 theNumberItems = kNumberItemsPerBuffer;        if(mDevice->IsIOEngineRunning())        {            if(mCurrentReadBuffer != mCurrentWriteBuffer)            {                theItemBuffer = mItemBuffers[mCurrentReadBuffer];                ++mCurrentReadBuffer;                if(mCurrentReadBuffer >= kNumberBuffers)                {                    mCurrentReadBuffer = 0;                }            }        }        else        {            if((mCurrentReadBuffer == mCurrentWriteBuffer) && (mCurrentWriteItem > 0))            {                theItemBuffer = mItemBuffers[mCurrentReadBuffer];                theNumberItems = mCurrentWriteItem;                mCurrentWriteItem = 0;            }            else if(mCurrentReadBuffer != mCurrentWriteBuffer)            {                theItemBuffer = mItemBuffers[mCurrentReadBuffer];                ++mCurrentReadBuffer;                if(mCurrentReadBuffer > kNumberBuffers)                {                    mCurrentReadBuffer = 0;                }            }        }        //	make a CFData out of the buffer        if((theItemBuffer != NULL) && (theNumberItems > 0))        {            theAnswer = CFDataCreate(NULL, reinterpret_cast<const UInt8*>(theItemBuffer), theNumberItems * sizeof(CAHALIOCycleRawTelemetryEvent));        }    }    return theAnswer;}

  virtual void SetUp() {    std::string raw;    CFDataRef data;    raw = base64Decode(getCACertificateContent());    data =        CFDataCreate(nullptr, (const UInt8 *)raw.c_str(), (CFIndex)raw.size());    cert = SecCertificateCreateWithData(nullptr, data);    cert_der_data = SecCertificateCopyData(cert);    auto bytes = CFDataGetBytePtr(cert_der_data);    x_cert = d2i_X509(nullptr, &bytes, CFDataGetLength(cert_der_data));    CFRelease(data);  }

void setHTTPBody(CFMutableURLRequestRef request, PassRefPtr<FormData> formData){    if (!formData)        return;    size_t count = formData->elements().size();    if (count == 0)        return;    // Handle the common special case of one piece of form data, with no files.    if (count == 1) {        const FormDataElement& element = formData->elements()[0];        if (element.m_type == FormDataElement::data) {            CFDataRef data = CFDataCreate(0, reinterpret_cast<const UInt8 *>(element.m_data.data()), element.m_data.size());            CFURLRequestSetHTTPRequestBody(request, data);            CFRelease(data);            return;        }    }    // Precompute the content length so CFURLConnection doesn't use chunked mode.    bool haveLength = true;    long long length = 0;    for (size_t i = 0; i < count; ++i) {        const FormDataElement& element = formData->elements()[i];        if (element.m_type == FormDataElement::data)            length += element.m_data.size();        else {            long long size;            if (fileSize(element.m_filename, size))                length += size;            else                haveLength = false;        }    }    if (haveLength) {        CFStringRef lengthStr = CFStringCreateWithFormat(0, 0, CFSTR("%lld"), length);        CFURLRequestSetHTTPHeaderFieldValue(request, CFSTR("Content-Length"), lengthStr);        CFRelease(lengthStr);    }    static WCReadStreamCallBacks formDataStreamCallbacks =         { 1, formCreate, formFinalize, 0, formOpen, 0, formRead, 0, formCanRead, formClose, 0, 0, 0, formSchedule, formUnschedule };    CFReadStreamRef stream = CFReadStreamCreate(0, (CFReadStreamCallBacks *)&formDataStreamCallbacks, formData.releaseRef());    CFURLRequestSetHTTPRequestBodyStream(request, stream);    CFRelease(stream);}

	voidCOSXClipboard::add(EFormat format, const CString & data){	bool emptied = false;	if (m_pboard == NULL)		return;	LOG((CLOG_DEBUG "add %d bytes to clipboard format: %d", data.size(), format));	if(format == IClipboard::kText) {		LOG((CLOG_DEBUG " format of data to be added to clipboard was kText"));	}	else if(format == IClipboard::kBitmap) {		LOG((CLOG_DEBUG " format of data to be added to clipboard was kBitmap"));	}	else if(format == IClipboard::kHTML) {		LOG((CLOG_DEBUG " format of data to be added to clipboard was kHTML"));	}	for (ConverterList::const_iterator index = m_converters.begin();			index != m_converters.end(); ++index) {		IOSXClipboardConverter* converter = *index;		// skip converters for other formats		if (converter->getFormat() == format) {			CString osXData = converter->fromIClipboard(data);			CFStringRef flavorType = converter->getOSXFormat();			CFDataRef dataRef = CFDataCreate(kCFAllocatorDefault, (UInt8 *)osXData.data(), osXData.size());			// integ tests showed that if you call add(...) twice, then the			// second call will actually fail to set clipboard data. calling			// empty() seems to solve this problem. but, only clear the clipboard			// for the first converter, otherwise further converters will wipe out			// what we just added.			if (!emptied) {				empty();				emptied = true;			}						PasteboardPutItemFlavor(					m_pboard,					(PasteboardItemID) 0,					flavorType,					dataRef, 					kPasteboardFlavorNoFlags);			LOG((CLOG_DEBUG "added %d bytes to clipboard format: %d", data.size(), format));		}	}}

/* *  Call from CoreMIDI IO threaded callback, *  we can't call Wine debug channels, critical section or anything using NtCurrentTeb here. */void MIDIIn_SendMessage(MIDIMessage msg){    CFDataRef data;    CFMessagePortRef messagePort;    messagePort = CFMessagePortCreateRemote(kCFAllocatorDefault, MIDIInThreadPortName);    data = CFDataCreate(kCFAllocatorDefault, (UInt8 *) &msg, sizeof(msg));    if (data)    {        CFMessagePortSendRequest(messagePort, 0, data, 0.0, 0.0, NULL, NULL);        CFRelease(data);        CFRelease(messagePort);    }}

/** * Creates a context for a notification, which will be sent back by Growl * when a notification is clicked. * * /param receiver the receiving object which will be signaled when the *	notification is clicked. May be NULL. * /param clicked_slot the slot to be signaled when the notification is clicked. * /param timeout_slot the slot to be signaled when the notification isn't clicked. * /param context the context which will be passed back to the slot *	May be NULL. * /return the context */CFPropertyListRef createContext( GrowlNotifierSignaler* signaler, const QObject* receiver, const char* clicked_slot, const char* timeout_slot, void* qcontext /*, pid_t pid*/){	CFDataRef context[5];	context[0] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &signaler, sizeof(GrowlNotifierSignaler*));	context[1] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &receiver, sizeof(const QObject *));	context[2] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &clicked_slot, sizeof(const char*));	context[3] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &timeout_slot, sizeof(const char*));	context[4] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &qcontext, sizeof(void*));	//context[5] = CFDataCreate(kCFAllocatorDefault, (const UInt8*) &pid, sizeof(pid_t));	CFArrayRef array = CFArrayCreate( kCFAllocatorDefault,                 (const void **)context, 5, &kCFTypeArrayCallBacks );	// Cleaning up	CFRelease(context[0]);	CFRelease(context[1]);	CFRelease(context[2]);	CFRelease(context[3]);	CFRelease(context[4]);	//CFRelease(context[5]);	return array;}

static CFDataRefgetRandomBytes(size_t len){	uint8_t *buffer;    CFDataRef randData = NULL; 	int fdrand;       if((buffer = malloc(len)) == NULL) return NULL;	if((fdrand = open("/dev/random", O_RDONLY)) == -1) return NULL;    if(read(fdrand, buffer, len) == len) randData = CFDataCreate(kCFAllocatorDefault, (const UInt8 *) buffer, len);	close(fdrand);    	free(buffer);	return randData;}

int QuartzWindow::put_scrap_text(const char* s, int len) {  // See Pasteboard Manager Programming guide  PasteboardRef clipboard;  OSStatus      err;  CFDataRef     textData = CFDataCreate(kCFAllocatorDefault,                                         (const UInt8*)s, len);  if (textData == NULL) return -1;  if ((err = PasteboardCreate(kPasteboardClipboard, &clipboard)) != noErr) return err;  if ((err = PasteboardClear(clipboard)) != noErr) return err;  return PasteboardPutItemFlavor(clipboard, (PasteboardItemID)s,                                  kUTTypeOldMacText, textData,                                  kPasteboardFlavorNoFlags);  }

SecurityTokenPointer Sandbox::openTokenFromBookmark(const QString& canonicalPath,                                                    const QString& bookmarkBase64) {#ifdef Q_OS_MAC#if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7    QByteArray bookmarkBA = QByteArray::fromBase64(bookmarkBase64.toLatin1());    if (!bookmarkBA.isEmpty()) {        CFDataRef bookmarkData = CFDataCreate(                kCFAllocatorDefault, reinterpret_cast<const UInt8*>(bookmarkBA.constData()),                bookmarkBA.length());        Boolean stale;        CFErrorRef error = NULL;        CFURLRef url = CFURLCreateByResolvingBookmarkData(                kCFAllocatorDefault, bookmarkData,                kCFURLBookmarkResolutionWithSecurityScope, NULL, NULL,                &stale, &error);        if (error != NULL) {            if (sDebug) {                qDebug() << "Error creating URL from bookmark data:"                         << CFStringToQString(CFErrorCopyDescription(error));            }        }        CFRelease(bookmarkData);        if (url != NULL) {            if (!CFURLStartAccessingSecurityScopedResource(url)) {                if (sDebug) {                    qDebug() << "CFURLStartAccessingSecurityScopedResource failed for"                             << canonicalPath;                }            } else {                SecurityTokenPointer pToken = SecurityTokenPointer(                    new SandboxSecurityToken(canonicalPath, url));                s_activeTokens[canonicalPath] = pToken;                return pToken;            }        } else {            if (sDebug) {                qDebug() << "Cannot resolve security-scoped bookmark for" << canonicalPath;            }        }    }#endif#else    Q_UNUSED(canonicalPath);    Q_UNUSED(bookmarkBase64);#endif    return SecurityTokenPointer();}

CFDataRef copyIconData(CFStringRef path){	CFDataRef data = NULL;	CFURLRef URL = CFURLCreateWithFileSystemPath( kCFAllocatorDefault,																	              path,       // file path name																	              kCFURLPOSIXPathStyle,    // interpret as POSIX path																	              false );                 // is it a directory?		if (URL) {		FSRef ref;		if (CFURLGetFSRef(URL, &ref)) {			IconRef icon = NULL;			SInt16 label_noOneCares;			OSStatus err = GetIconRefFromFileInfo(&ref,												  /*inFileNameLength*/ 0U, /*inFileName*/ NULL,												  kFSCatInfoNone, /*inCatalogInfo*/ NULL,												  kIconServicesNoBadgeFlag | kIconServicesUpdateIfNeededFlag,												  &icon,												  &label_noOneCares);			if (err != noErr) {				printf("Could not get icon/n");			} else {				IconFamilyHandle fam = NULL;				// err = IconRefToIconFamily(icon, kSelectorAllAvailableData, &fam);				err = ReadIconFromFSRef(&ref, &fam);								if (err != noErr) {					printf("Could not get icon/n");				} else {					HLock((Handle)fam);					data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)*(Handle)fam, GetHandleSize((Handle)fam));					HUnlock((Handle)fam);					DisposeHandle((Handle)fam);				}				ReleaseIconRef(icon);			}		}	}		CFSafeRelease(URL);		return data;	}

void_appleputsnarf(char *s){	CFDataRef cfdata;	PasteboardSyncFlags flags;/*	fprint(2, "appleputsnarf/n"); */	if(strlen(s) >= SnarfSize)		return;	qlock(&clip.lk);	strcpy(clip.buf, s);	runesnprint(clip.rbuf, nelem(clip.rbuf), "%s", s);	if(clip.apple == nil){		if(PasteboardCreate(kPasteboardClipboard, &clip.apple) != noErr){			fprint(2, "apple pasteboard create failed/n");			qunlock(&clip.lk);			return;		}	}	if(PasteboardClear(clip.apple) != noErr){		fprint(2, "apple pasteboard clear failed/n");		qunlock(&clip.lk);		return;	}	flags = PasteboardSynchronize(clip.apple);	if((flags&kPasteboardModified) || !(flags&kPasteboardClientIsOwner)){		fprint(2, "apple pasteboard cannot assert ownership/n");		qunlock(&clip.lk);		return;	}	cfdata = CFDataCreate(kCFAllocatorDefault, 		(uchar*)clip.rbuf, runestrlen(clip.rbuf)*2);	if(cfdata == nil){		fprint(2, "apple pasteboard cfdatacreate failed/n");		qunlock(&clip.lk);		return;	}	if(PasteboardPutItemFlavor(clip.apple, (PasteboardItemID)1,		CFSTR("public.utf16-plain-text"), cfdata, 0) != noErr){		fprint(2, "apple pasteboard putitem failed/n");		CFRelease(cfdata);		qunlock(&clip.lk);		return;	}	/* CFRelease(cfdata); ??? */	qunlock(&clip.lk);}