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

static void perform_request__file(    SG_context* pCtx,    CFHTTPMessageRef myRequest,    CFHTTPMessageRef* pmyResponse,    SG_pathname* pPath,    SG_bool b_progress){    CFReadStreamRef myReadStream = NULL;    CFHTTPMessageRef myResponse = NULL;    SG_ERR_CHECK(  send_request(pCtx, myRequest, &myReadStream)  );    SG_ERR_CHECK(  read_entire_stream__file(pCtx, myReadStream, pPath, &myResponse, b_progress)  );    *pmyResponse = myResponse;    myResponse = NULL;fail:    if (myReadStream)    {        CFReadStreamClose(myReadStream);        CFRelease(myReadStream);        myReadStream = NULL;    }    if (myResponse)    {        CFRelease(myResponse);        myResponse = NULL;    }}

static void asynchttp_complete(asynchttp_t *http) {    secdebug("http", "http: %p", http);    /* Shutdown streams and timer, we're about to invoke our client callback. */    if (http->stream) {        CFReadStreamSetClient(http->stream, kCFStreamEventNone, NULL, NULL);        CFReadStreamSetDispatchQueue(http->stream, NULL);        CFReadStreamClose(http->stream);        CFReleaseNull(http->stream);    }    if (http->timer) {        dispatch_source_cancel(http->timer);        dispatch_release_null(http->timer);    }    if (http->completed) {        /* This should probably move to our clients. */        CFTimeInterval maxAge = NULL_TIME;        if (http->response) {            CFStringRef cacheControl = CFHTTPMessageCopyHeaderFieldValue(                http->response, CFSTR("cache-control"));            if (cacheControl) {                CFStringRef maxAgeValue = copyParseMaxAge(cacheControl);                CFRelease(cacheControl);                if (maxAgeValue) {                    secdebug("http", "http header max-age: %@", maxAgeValue);                    maxAge = CFStringGetDoubleValue(maxAgeValue);                    CFRelease(maxAgeValue);                }            }        }        http->completed(http, maxAge);    }}

void SocketStreamHandle::platformClose(){    LOG(Network, "SocketStreamHandle %p platformClose", this);    if (m_pacRunLoopSource)         removePACRunLoopSource();    ASSERT(!m_readStream == !m_writeStream);    if (!m_readStream) {        if (m_connectingSubstate == New || m_connectingSubstate == ExecutingPACFile)            m_client->didCloseSocketStream(this);        return;    }#if PLATFORM(WIN)    CFReadStreamUnscheduleFromRunLoop(m_readStream.get(), loaderRunLoop(), kCFRunLoopDefaultMode);    CFWriteStreamUnscheduleFromRunLoop(m_writeStream.get(), loaderRunLoop(), kCFRunLoopDefaultMode);#else    CFReadStreamUnscheduleFromRunLoop(m_readStream.get(), CFRunLoopGetCurrent(), kCFRunLoopCommonModes);    CFWriteStreamUnscheduleFromRunLoop(m_writeStream.get(), CFRunLoopGetCurrent(), kCFRunLoopCommonModes);#endif    CFReadStreamClose(m_readStream.get());    CFWriteStreamClose(m_writeStream.get());        m_readStream = 0;    m_writeStream = 0;    m_client->didCloseSocketStream(this);}

void updateKeymap(){	CFReadStreamRef	readStream;	if (!fileExists(CFSTR(KEYMAP_PATH)))	{		stamp_file(CFSTR("Error: Keymap file is missing"));		keymap = NULL;		return;	}		readStream = CFReadStreamCreateWithFile(kCFAllocatorDefault,CFURLCreateWithFileSystemPath(kCFAllocatorDefault,CFSTR(KEYMAP_PATH),kCFURLPOSIXPathStyle,false));	if (!readStream||!(CFReadStreamOpen(readStream)))	{		stamp_file(CFSTR("Error: Can't open keymap file"));		keymap = NULL;		return;	}	keymap = (CFDictionaryRef)CFPropertyListCreateFromStream(kCFAllocatorDefault,readStream,0,kCFPropertyListImmutable,NULL,NULL);	CFReadStreamClose(readStream);	if (!keymap)	{		stamp_file(CFSTR("Error: Can't read keymap file"));		return;	}		Boolean validKey;	showMods = (CFPreferencesGetAppBooleanValue(CFSTR("Mods"),PREF_DOMAIN,&validKey))?kCFBooleanTrue:kCFBooleanFalse;	if (!validKey)	{		showMods = kCFBooleanTrue;		CFPreferencesSetAppValue(CFSTR("Mods"),showMods,PREF_DOMAIN);	}}

extern CFDictionaryRef GPPropertyListCopyLocalizableStringsDictionary(CFURLRef fileURL) {	CFReadStreamRef stream = CFReadStreamCreateWithFile(NULL, fileURL);	if (stream == NULL)		return NULL;	if (!CFReadStreamOpen(stream)) {		CFRelease(stream);		return NULL;	}	CFDictionaryRef dict = CFPropertyListCreateFromStream(NULL, stream, 0, kCFPropertyListImmutable, NULL, NULL);	CFReadStreamClose(stream);	CFRelease(stream);	if (dict == NULL)		return NULL;	if (CFGetTypeID(dict) != CFDictionaryGetTypeID()) {		CFRelease(dict);		return NULL;	}	CFDictionaryRef localizedStringsDict = CFDictionaryGetValue(dict, CFSTR("Localizations"));	if (localizedStringsDict == NULL || CFGetTypeID(localizedStringsDict) != CFDictionaryGetTypeID()) {		CFRelease(dict);		return NULL;	}	CFIndex langCount = CFDictionaryGetCount(localizedStringsDict);	CFStringRef keys[langCount];	// assume we don't have 4000 languages :p	CFDictionaryGetKeysAndValues(localizedStringsDict, (const void**)keys, NULL);	CFArrayCallBacks languagesCallbacks = {0, NULL, NULL, NULL, &CFEqual};	CFArrayRef languages = CFArrayCreate(NULL, (const void**)keys, langCount, &languagesCallbacks);	CFArrayRef preferedLanguages = CFBundleCopyPreferredLocalizationsFromArray(languages);	CFDictionaryRef retval = CFRetain(CFDictionaryGetValue(localizedStringsDict, CFArrayGetValueAtIndex(preferedLanguages, 0)));	CFRelease(languages);	CFRelease(preferedLanguages);	CFRelease(dict);		return retval;}

CFDataRef WebApiClientMD5DigestCreateWithFilePath(CFStringRef filePath, size_t bufferSize) {		// Declare needed variables	CFDataRef result = NULL;	CFReadStreamRef readStream = NULL;		// Get the file URL	CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)filePath, kCFURLPOSIXPathStyle, (Boolean)false);	if ( fileURL ) {		// Create and open the read stream		readStream = CFReadStreamCreateWithFile(kCFAllocatorDefault, fileURL);		if ( readStream ) {			Boolean didSucceed = CFReadStreamOpen(readStream);			if ( didSucceed ) {				// Initialize the hash object				CC_MD5_CTX hashObject;				CC_MD5_Init(&hashObject);								// Make sure chunkSizeForReadingData is valid				if ( bufferSize < 1 ) {					bufferSize = FileHashDefaultChunkSizeForReadingData;				}								// Feed the data to the hash object				bool hasMoreData = true;				while ( hasMoreData ) {					uint8_t buffer[bufferSize];					CFIndex readBytesCount = CFReadStreamRead(readStream, (UInt8 *)buffer, (CFIndex)sizeof(buffer));					if ( readBytesCount == -1 ) break;					if ( readBytesCount == 0 ) {						hasMoreData = false;						continue;					}					CC_MD5_Update(&hashObject, (const void *)buffer, (CC_LONG)readBytesCount);				}								// Check if the read operation succeeded				didSucceed = !hasMoreData;								// Compute the hash digest				unsigned char digest[CC_MD5_DIGEST_LENGTH];				CC_MD5_Final(digest, &hashObject);								// Abort if the read operation failed				if ( didSucceed ) {					result = CFDataCreate(kCFAllocatorDefault, digest, CC_MD5_DIGEST_LENGTH);				}			}		}	}		if ( readStream ) {		CFReadStreamClose(readStream);		CFRelease(readStream);	}	if ( fileURL ) {		CFRelease(fileURL);	}	return result;}

    void TCPStream_CFNetwork::close()    {        if (state == Stream::State::Closed) {            return;        }        state = Stream::State::Closed;        if (secureLayerContext != nullptr) {            SSLClose(secureLayerContext);        }        if (inputStream != nullptr) {            CFReadStreamUnscheduleFromRunLoop(inputStream, CFRunLoopGetMain(), kCFRunLoopDefaultMode);            CFReadStreamClose(inputStream);            CFRelease(inputStream);            inputStream = nullptr;        }        if (outputStream != nullptr) {            CFWriteStreamClose(outputStream);            CFRelease(outputStream);            outputStream= nullptr;        }        if (secureLayerContext != nullptr) {            CFRelease(secureLayerContext);            secureLayerContext = nullptr;        }        handleClosedEvent();    }

/* MyStreamInfoDestroy destroys a MyStreamInfo 'object', cleaning up any resources that it owns. */                                       static voidMyStreamInfoDestroy(MyStreamInfo * info){    assert(info != NULL);        if (info->readStream) {        CFReadStreamUnscheduleFromRunLoop(info->readStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);        (void) CFReadStreamSetClient(info->readStream, kCFStreamEventNone, NULL, NULL);                /* CFReadStreamClose terminates the stream. */        CFReadStreamClose(info->readStream);        CFRelease(info->readStream);    }    if (info->writeStream) {        CFWriteStreamUnscheduleFromRunLoop(info->writeStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);        (void) CFWriteStreamSetClient(info->writeStream, kCFStreamEventNone, NULL, NULL);                /* CFWriteStreamClose terminates the stream. */        CFWriteStreamClose(info->writeStream);        CFRelease(info->writeStream);    }    if (info->proxyDict) {        CFRelease(info->proxyDict);             // see discussion of <rdar://problem/3745574> below    }        free(info);}

static void activesock_destroy_iphone_os_stream(pj_activesock_t *asock){    if (asock->readStream) {	CFReadStreamClose(asock->readStream);	CFRelease(asock->readStream);	asock->readStream = NULL;    }}

void closeAndRelease(CFReadStreamRef readStream, CFURLRef fileURL) {    if (readStream) {        CFReadStreamClose(readStream);        CFRelease(readStream);    }    if (fileURL) {        CFRelease(fileURL);    }}

void HTTP_Stream::close(){    /* The stream has been already closed */    if (!m_readStream) {        return;    }        CFReadStreamSetClient(m_readStream, 0, NULL, NULL);    setScheduledInRunLoop(false);    CFReadStreamClose(m_readStream);    CFRelease(m_readStream), m_readStream = 0;}

static void closeCurrentStream(FormStreamFields* form){    if (form->currentStream) {        CFReadStreamClose(form->currentStream);        CFReadStreamSetClient(form->currentStream, kCFStreamEventNone, 0, 0);        CFRelease(form->currentStream);        form->currentStream = 0;        form->currentStreamRangeLength = BlobDataItem::toEndOfFile;    }    form->currentData = nullptr;}

static void closeCurrentStream(FormStreamFields *form){    if (form->currentStream) {        CFReadStreamClose(form->currentStream);        CFReadStreamSetClient(form->currentStream, kCFStreamEventNone, NULL, NULL);        CFRelease(form->currentStream);        form->currentStream = NULL;    }    if (form->currentData) {        fastFree(form->currentData);        form->currentData = 0;    }}

static void cfstream_data_close(struct mailstream_cfstream_data * cfstream_data){  if (cfstream_data->writeStream != NULL) {    CFWriteStreamClose(cfstream_data->writeStream);    CFRelease(cfstream_data->writeStream);    cfstream_data->writeStream = NULL;  }  if (cfstream_data->readStream != NULL) {    CFReadStreamClose(cfstream_data->readStream);    CFRelease(cfstream_data->readStream);    cfstream_data->readStream = NULL;  }}

CFStringRef copy_disk_app_identifier(CFURLRef disk_app_url) {    CFURLRef plist_url = CFURLCreateCopyAppendingPathComponent(NULL, disk_app_url, CFSTR("Info.plist"), false);    CFReadStreamRef plist_stream = CFReadStreamCreateWithFile(NULL, plist_url);    CFReadStreamOpen(plist_stream);    CFPropertyListRef plist = CFPropertyListCreateWithStream(NULL, plist_stream, 0, kCFPropertyListImmutable, NULL, NULL);    CFStringRef bundle_identifier = CFRetain(CFDictionaryGetValue(plist, CFSTR("CFBundleIdentifier")));    CFReadStreamClose(plist_stream);	    CFRelease(plist_url);    CFRelease(plist_stream);    CFRelease(plist);	    return bundle_identifier;}

static void CloseStreams(MyStreamInfoPtr myInfoPtr){	assert(myInfoPtr != NULL);	if (myInfoPtr->rStreamRef)	{		CFReadStreamClose(myInfoPtr->rStreamRef);		myInfoPtr->rStreamRef = NULL;	}	if (myInfoPtr->wStreamRef)	{		CFWriteStreamClose(myInfoPtr->wStreamRef);		myInfoPtr->wStreamRef = NULL;	}}

static void closeCurrentStream(FormStreamFields* form){    ASSERT(form->streamIsBeingOpenedOrClosedLock.isHeld());    if (form->currentStream) {        CFReadStreamClose(form->currentStream);        CFReadStreamSetClient(form->currentStream, kCFStreamEventNone, 0, 0);        CFRelease(form->currentStream);        form->currentStream = 0;        form->currentStreamRangeLength = BlobDataItem::toEndOfFile;    }    form->currentData = nullptr;}

static void cfstream_data_close(struct mailstream_cfstream_data * cfstream_data){  if (cfstream_data->writeStream != NULL) {    CFWriteStreamSetClient(cfstream_data->writeStream, kCFStreamEventNone, NULL, NULL);    CFWriteStreamClose(cfstream_data->writeStream);    CFRelease(cfstream_data->writeStream);    cfstream_data->writeStream = NULL;  }  if (cfstream_data->readStream != NULL) {    CFReadStreamSetClient(cfstream_data->readStream, kCFStreamEventNone, NULL, NULL);    CFReadStreamClose(cfstream_data->readStream);    CFRelease(cfstream_data->readStream);    cfstream_data->readStream = NULL;  }}

sdmmd_return_t SDMMD_ServiceReceiveStream(SocketConnection handle, CFPropertyListRef *data) {	CFDataRef dataBuffer = NULL;	if (SDM_MD_CallSuccessful(SDMMD_ServiceReceive(handle, &dataBuffer))) {		if (dataBuffer && CFDataGetLength(dataBuffer)) {			CFReadStreamRef read = CFReadStreamCreateWithBytesNoCopy(kCFAllocatorDefault, CFDataGetBytePtr(dataBuffer), CFDataGetLength(dataBuffer), kCFAllocatorNull);			CFReadStreamOpen(read);			*data = CFPropertyListCreateWithStream(kCFAllocatorDefault, read, CFDataGetLength(dataBuffer), 0x2, 0, NULL);			CFReadStreamClose(read);			if (read)				CFRelease(read);		}		return kAMDSuccess;	} else {		return kAMDNotConnectedError;	}}

CFStringRef get_bundle_id(const char *app_path){  CFURLRef app_url = get_absolute_file_url(app_path);  if (app_url == NULL)  {    return NULL;  }  CFURLRef url = CFURLCreateCopyAppendingPathComponent(NULL, app_url,                                                       CFSTR("Info.plist"), false);  CFRelease(app_url);  if (url == NULL)  {    return NULL;  }  CFReadStreamRef stream = CFReadStreamCreateWithFile(NULL, url);  CFRelease(url);  if (stream == NULL)  {    return NULL;  }  CFPropertyListRef plist = NULL;  if (CFReadStreamOpen(stream) == TRUE)  {    plist = CFPropertyListCreateWithStream(NULL, stream, 0,                                           kCFPropertyListImmutable, NULL, NULL);  }  CFReadStreamClose(stream);  CFRelease(stream);  if (plist == NULL)  {    return NULL;  }  const void *value = CFDictionaryGetValue(plist, CFSTR("CFBundleIdentifier"));  CFStringRef bundle_id = NULL;  if (value != NULL)  {    bundle_id = CFRetain(value);  }  CFRelease(plist);  return bundle_id;}

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);	}}

sdmmd_return_t SDMMD_ServiceReceiveStream(SocketConnection handle, CFPropertyListRef *data) {	CFDataRef dataBuffer = NULL;	sdmmd_return_t result = SDMMD_ServiceReceive(handle, &dataBuffer);	CheckErrorAndReturn(result);		if (dataBuffer && CFDataGetLength(dataBuffer)) {		CFReadStreamRef read = CFReadStreamCreateWithBytesNoCopy(kCFAllocatorDefault, CFDataGetBytePtr(dataBuffer), CFDataGetLength(dataBuffer), kCFAllocatorNull);		CFReadStreamOpen(read);		*data = CFPropertyListCreateWithStream(kCFAllocatorDefault, read, CFDataGetLength(dataBuffer), kCFPropertyListMutableContainersAndLeaves, NULL, NULL);		CFReadStreamClose(read);		CFSafeRelease(read);	}	result = kAMDSuccess;		CFSafeRelease(dataBuffer);	ExitLabelAndReturn(result);}

CFDictionaryRef download_file(int socket, CFDictionaryRef dict){    UInt8 buffer[8192];    CFIndex bytesRead;    CFStringRef path = CFDictionaryGetValue(dict, CFSTR("Path"));    if(path == NULL || CFGetTypeID(path) != CFStringGetTypeID())        return NULL;    CFMutableDictionaryRef out  = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);	    CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path, kCFURLPOSIXPathStyle, FALSE);    CFReadStreamRef stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, fileURL);    CFRelease(fileURL);    if(!CFReadStreamOpen(stream))    {        CFErrorRef error = CFReadStreamCopyError(stream);        if (error != NULL)        {            CFStringRef errorDesc = CFErrorCopyDescription(error);            CFDictionaryAddValue(out, CFSTR("Error"), errorDesc);            CFRelease(errorDesc);            CFRelease(error);        }        CFRelease(stream);        return out;    }    CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0);    while(CFReadStreamHasBytesAvailable(stream))    {        if((bytesRead = CFReadStreamRead(stream, buffer, 8192)) <= 0)            break;        CFDataAppendBytes(data, buffer, bytesRead);    }    CFReadStreamClose(stream);    CFRelease(stream);    CFDictionaryAddValue(out, CFSTR("Data"), data);    CFRelease(data);    return out;}

CFPropertyListRef createPropertyListFromURL(CFURLRef file, u_int32_t mutability, CFPropertyListFormat *outFormat, CFStringRef *outErrorString) {	CFPropertyListRef plist = NULL;	if (!file)		NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: cannot read from a NULL URL"));	else {		CFReadStreamRef stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, file);		if (!stream)			NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not create stream for reading from URL %@"), file);		else {			if (!CFReadStreamOpen(stream))				NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not open stream for reading from URL %@"), file);			else {				CFPropertyListFormat format;				CFStringRef errorString = NULL;				plist = CFPropertyListCreateFromStream(kCFAllocatorDefault,													   stream,													   /*streamLength*/ 0,													   mutability,													   &format,													   &errorString);				if (!plist)					NSLog(CFSTR("in createPropertyListFromURL in CFGrowlAdditions: could not read property list from URL %@ (error string: %@)"), file, errorString);				if (outFormat) *outFormat = format;				if (errorString) {					if (outErrorString)						*outErrorString = errorString;					else						CFRelease(errorString);				}				CFReadStreamClose(stream);			}			CFRelease(stream);		}	}	return plist;}

/* extern */ voidHttpContextClose(HttpContextRef context) {	CFRunLoopRef runLoop = CFRunLoopGetCurrent();	// Check if the read stream exists.	if (context->_inStream) {				// Unschedule, close, and release it.		CFReadStreamSetClient(context->_inStream, 0, NULL, NULL);		CFReadStreamUnscheduleFromRunLoop(context->_inStream, runLoop, kCFRunLoopCommonModes);		CFReadStreamClose(context->_inStream);		CFRelease(context->_inStream);				// Remove the reference.		context->_inStream = NULL;	}	// Check if the write stream exists.	if (context->_outStream) {				// Unschedule, close, and release it.		CFWriteStreamSetClient(context->_outStream, 0, NULL, NULL);		CFWriteStreamUnscheduleFromRunLoop(context->_outStream, runLoop, kCFRunLoopCommonModes);		CFWriteStreamClose(context->_outStream);		CFRelease(context->_outStream);				// Remove the reference.		context->_outStream = NULL;	}    // Get rid of the timer, if it still exists    if (context->_timer != NULL) {        CFRunLoopTimerInvalidate(context->_timer);        CFRelease(context->_timer);        context->_timer = NULL;    }}

static RetainPtr<CFPropertyListRef> readFontPlist(){    CString plistPath = fontsPlistPath().utf8();    RetainPtr<CFURLRef> url(AdoptCF, CFURLCreateFromFileSystemRepresentation(0, reinterpret_cast<const UInt8*>(plistPath.data()), plistPath.length(), false));    if (!url)        return 0;    RetainPtr<CFReadStreamRef> stream(AdoptCF, CFReadStreamCreateWithFile(0, url.get()));    if (!stream)        return 0;    if (!CFReadStreamOpen(stream.get()))        return 0;    CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0;    RetainPtr<CFPropertyListRef> plist(AdoptCF, CFPropertyListCreateFromStream(0, stream.get(), 0, kCFPropertyListMutableContainersAndLeaves, &format, 0));    CFReadStreamClose(stream.get());    return plist;}

void SSLImpl::shutdown(void *storage){    ssl_data_t *data = (ssl_data_t*)storage;    if (!data)        return;    CFReadStreamScheduleWithRunLoop(    data->readStream,                                    CFRunLoopGetCurrent(),                                    kCFRunLoopCommonModes);    CFWriteStreamScheduleWithRunLoop(    data->writeStream,                                     CFRunLoopGetCurrent(),                                     kCFRunLoopCommonModes);    if (data->readStream) {        CFReadStreamRef readStream = (CFReadStreamRef)data->readStream;        CFReadStreamClose(readStream);        data->readStream = NULL;    }    if (data->writeStream) {        CFWriteStreamRef writeStream = (CFWriteStreamRef)data->writeStream;        CFWriteStreamClose(writeStream);        data->writeStream = NULL;    }}

CFDataRef createDataFromURL( CFURLRef url ){	CFMutableDataRef fileContent = CFDataCreateMutable(kCFAllocatorDefault, 0);    CFReadStreamRef stream = CFReadStreamCreateWithFile(kCFAllocatorDefault, url);    if (stream) {        if (CFReadStreamOpen(stream)) {            UInt8 buffer[BUFFERSIZE];            CFIndex bytesRead;            do {                bytesRead = CFReadStreamRead(stream, buffer, sizeof(buffer));                if (bytesRead > 0) {                    CFDataAppendBytes(fileContent, buffer, bytesRead);                }            } while (bytesRead > 0);            CFReadStreamClose(stream);        }        CFRelease(stream);    }    	return fileContent;}

static void send_upload_request(    SG_context* pCtx,    CFHTTPMessageRef myRequest,    CFReadStreamRef upload,    CFReadStreamRef* pp){    CFReadStreamRef myReadStream = NULL;    myReadStream = CFReadStreamCreateForStreamedHTTPRequest(kCFAllocatorDefault, myRequest, upload);    if (!CFReadStreamOpen(myReadStream))    {        CFStreamError myErr = CFReadStreamGetError(myReadStream);        if (myErr.domain == kCFStreamErrorDomainPOSIX)        {            // Interpret myErr.error as a UNIX errno.            SG_ERR_THROW(  SG_ERR_ERRNO(myErr.error)  );        }        else if (myErr.domain == kCFStreamErrorDomainMacOSStatus)        {            // Interpret myErr.error as a MacOS error code.            // TODO SG_ERR_THROW(  SG_ERR_MAC((OSStatus) myErr.error)  );            SG_ERR_THROW(  SG_ERR_UNSPECIFIED  );        }    }    *pp = myReadStream;    myReadStream = NULL;fail:    if (myReadStream)    {        CFReadStreamClose(myReadStream);        CFRelease(myReadStream);        myReadStream = NULL;    }}