Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
871 lines (786 sloc) 34.2 KB
/*
* Copyright (c) 2008-2009 Brent Fulgham <bfulgham@gmail.org>. All rights reserved.
*
* This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
* the terms of the APSL version 2.0 (see below).
*
* For information about changes from the original Apple source release can be found by reviewing the
* source control system for the project at https://sourceforge.net/svn/?group_id=246198.
*
* The original license information is as follows:
*
* Copyright (c) 2008 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/* CFConcreteStreams.c
Copyright 2000-2002, Apple, Inc. All rights reserved.
Responsibility: Becky Willrich
*/
#define _DARWIN_UNLIMITED_SELECT 1
#include "CFStreamInternal.h"
#include "CFInternal.h"
#include "CFPriv.h"
#include <CoreFoundation/CFNumber.h>
#include <sys/types.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX
#include <sys/time.h>
#include <unistd.h>
#elif DEPLOYMENT_TARGET_WINDOWS
#include <io.h>
#define lseek _lseek
#define open _open
#define read _read
#define write _write
#define close _close
#endif
// On Unix, you can schedule an fd with the RunLoop by creating a CFSocket around it. On Win32
// files and sockets are not interchangeable, and we do cheapo scheduling, where the file is
// always readable and writable until we hit EOF (similar to the way CFData streams are scheduled).
#if DEPLOYMENT_TARGET_MACOSX
#define REAL_FILE_SCHEDULING (1)
#endif
#define SCHEDULE_AFTER_WRITE (0)
#define SCHEDULE_AFTER_READ (1)
#define APPEND (3)
#define AT_EOF (4)
#define USE_RUNLOOP_ARRAY (5)
/* File callbacks */
typedef struct {
CFURLRef url;
int fd;
#ifdef REAL_FILE_SCHEDULING
union {
CFSocketRef sock; // socket created once we open and have an fd
CFMutableArrayRef rlArray; // scheduling information prior to open
} rlInfo; // If fd > 0, sock exists. Otherwise, rlArray.
#else
uint16_t scheduled; // ref count of how many times we've been scheduled
#endif
CFOptionFlags flags;
off_t offset;
} _CFFileStreamContext;
CONST_STRING_DECL(kCFStreamPropertyFileCurrentOffset, "kCFStreamPropertyFileCurrentOffset");
#ifdef REAL_FILE_SCHEDULING
static void fileCallBack(CFSocketRef s, CFSocketCallBackType type, CFDataRef address, const void *data, void *info);
static void constructCFSocket(_CFFileStreamContext *fileStream, Boolean forRead, struct _CFStream *stream) {
CFSocketContext context = {0, stream, NULL, NULL, CFCopyDescription};
CFSocketRef sock = CFSocketCreateWithNative(CFGetAllocator(stream), fileStream->fd, forRead ? kCFSocketReadCallBack : kCFSocketWriteCallBack, fileCallBack, &context);
CFSocketSetSocketFlags(sock, 0);
if (fileStream->rlInfo.rlArray) {
CFIndex i, c = CFArrayGetCount(fileStream->rlInfo.rlArray);
CFRunLoopSourceRef src = CFSocketCreateRunLoopSource(CFGetAllocator(stream), sock, 0);
for (i = 0; i+1 < c; i += 2) {
CFRunLoopRef rl = (CFRunLoopRef)CFArrayGetValueAtIndex(fileStream->rlInfo.rlArray, i);
CFStringRef mode = (CFStringRef)CFArrayGetValueAtIndex(fileStream->rlInfo.rlArray, i+1);
CFRunLoopAddSource(rl, src, mode);
}
CFRelease(fileStream->rlInfo.rlArray);
CFRelease(src);
}
fileStream->rlInfo.sock = sock;
}
#endif
static Boolean constructFD(_CFFileStreamContext *fileStream, CFStreamError *error, Boolean forRead, struct _CFStream *stream) {
UInt8 path[1024];
int flags = forRead ? O_RDONLY : (O_CREAT | O_TRUNC | O_WRONLY);
if (CFURLGetFileSystemRepresentation(fileStream->url, TRUE, path, 1024) == FALSE) {
error->error = ENOENT;
error->domain = kCFStreamErrorDomainPOSIX;
return FALSE;
}
if (__CFBitIsSet(fileStream->flags, APPEND)) {
flags |= O_APPEND;
if(_CFExecutableLinkedOnOrAfter(CFSystemVersionPanther)) flags &= ~O_TRUNC;
}
do {
fileStream->fd = open((const char *)path, flags, 0666);
if (fileStream->fd < 0)
break;
if ((fileStream->offset != -1) && (lseek(fileStream->fd, fileStream->offset, SEEK_SET) == -1))
break;
#ifdef REAL_FILE_SCHEDULING
if (fileStream->rlInfo.rlArray != NULL) {
constructCFSocket(fileStream, forRead, stream);
}
#endif
return TRUE;
} while (1);
__CFBitSet(fileStream->flags, USE_RUNLOOP_ARRAY);
error->error = errno;
error->domain = kCFStreamErrorDomainPOSIX;
return FALSE;
}
static Boolean fileOpen(struct _CFStream *stream, CFStreamError *errorCode, Boolean *openComplete, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
Boolean forRead = (CFGetTypeID(stream) == CFReadStreamGetTypeID());
*openComplete = TRUE;
if (ctxt->url) {
if (constructFD(ctxt, errorCode, forRead, stream)) {
#ifndef REAL_FILE_SCHEDULING
if (ctxt->scheduled > 0) {
if (forRead)
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);
else
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);
}
#endif
return TRUE;
} else {
return FALSE;
}
#ifdef REAL_FILE_SCHEDULING
} else if (ctxt->rlInfo.rlArray != NULL) {
constructCFSocket(ctxt, forRead, stream);
#endif
}
return TRUE;
}
__private_extern__ CFIndex fdRead(int fd, UInt8 *buffer, CFIndex bufferLength, CFStreamError *errorCode, Boolean *atEOF) {
CFIndex bytesRead = read(fd, buffer, bufferLength);
if (bytesRead < 0) {
errorCode->error = errno;
errorCode->domain = kCFStreamErrorDomainPOSIX;
return -1;
} else {
*atEOF = (bytesRead == 0) ? TRUE : FALSE;
errorCode->error = 0;
return bytesRead;
}
}
static CFIndex fileRead(CFReadStreamRef stream, UInt8 *buffer, CFIndex bufferLength, CFStreamError *errorCode, Boolean *atEOF, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
CFIndex result;
result = fdRead(ctxt->fd, buffer, bufferLength, errorCode, atEOF);
#ifdef REAL_FILE_SCHEDULING
if (__CFBitIsSet(ctxt->flags, SCHEDULE_AFTER_READ)) {
__CFBitClear(ctxt->flags, SCHEDULE_AFTER_READ);
if (ctxt->rlInfo.sock) {
CFSocketEnableCallBacks(ctxt->rlInfo.sock, kCFSocketReadCallBack);
}
}
#else
if (*atEOF)
__CFBitSet(ctxt->flags, AT_EOF);
if (ctxt->scheduled > 0 && !*atEOF) {
CFReadStreamSignalEvent(stream, kCFStreamEventHasBytesAvailable, NULL);
}
#endif
return result;
}
#ifdef REAL_FILE_SCHEDULING
__private_extern__ Boolean fdCanRead(int fd) {
struct timeval timeout = {0, 0};
fd_set *readSetPtr;
fd_set readSet;
Boolean result;
// fd_set is not a mask in Win32, so checking for an fd that's too big is not relevant
if (fd < FD_SETSIZE) {
FD_ZERO(&readSet);
readSetPtr = &readSet;
} else {
int size = howmany(fd+1, NFDBITS) * sizeof(uint32_t);
uint32_t *fds_bits = (uint32_t *)malloc(size);
memset(fds_bits, 0, size);
readSetPtr = (fd_set *)fds_bits;
}
FD_SET(fd, readSetPtr);
result = (select(fd + 1, readSetPtr, NULL, NULL, &timeout) == 1) ? TRUE : FALSE;
if (readSetPtr != &readSet) {
free(readSetPtr);
}
return result;
}
#endif
static Boolean fileCanRead(CFReadStreamRef stream, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
#ifdef REAL_FILE_SCHEDULING
return fdCanRead(ctxt->fd);
#else
return !__CFBitIsSet(ctxt->flags, AT_EOF);
#endif
}
__private_extern__ CFIndex fdWrite(int fd, const UInt8 *buffer, CFIndex bufferLength, CFStreamError *errorCode) {
CFIndex bytesWritten = write(fd, buffer, bufferLength);
if (bytesWritten < 0) {
errorCode->error = errno;
errorCode->domain = kCFStreamErrorDomainPOSIX;
return -1;
} else {
errorCode->error = 0;
return bytesWritten;
}
}
static CFIndex fileWrite(CFWriteStreamRef stream, const UInt8 *buffer, CFIndex bufferLength, CFStreamError *errorCode, void *info) {
_CFFileStreamContext *fileStream = ((_CFFileStreamContext *)info);
CFIndex result = fdWrite(fileStream->fd, buffer, bufferLength, errorCode);
#ifdef REAL_FILE_SCHEDULING
if (__CFBitIsSet(fileStream->flags, SCHEDULE_AFTER_WRITE)) {
__CFBitClear(fileStream->flags, SCHEDULE_AFTER_WRITE);
if (fileStream->rlInfo.sock) {
CFSocketEnableCallBacks(fileStream->rlInfo.sock, kCFSocketWriteCallBack);
}
}
#else
if (fileStream->scheduled > 0) {
CFWriteStreamSignalEvent(stream, kCFStreamEventCanAcceptBytes, NULL);
}
#endif
return result;
}
#ifdef REAL_FILE_SCHEDULING
__private_extern__ Boolean fdCanWrite(int fd) {
struct timeval timeout = {0, 0};
fd_set *writeSetPtr;
fd_set writeSet;
Boolean result;
if (fd < FD_SETSIZE) {
FD_ZERO(&writeSet);
writeSetPtr = &writeSet;
} else {
int size = howmany(fd+1, NFDBITS) * sizeof(uint32_t);
uint32_t *fds_bits = (uint32_t *)malloc(size);
memset(fds_bits, 0, size);
writeSetPtr = (fd_set *)fds_bits;
}
FD_SET(fd, writeSetPtr);
result = (select(fd + 1, NULL, writeSetPtr, NULL, &timeout) == 1) ? TRUE : FALSE;
if (writeSetPtr != &writeSet) {
free(writeSetPtr);
}
return result;
}
#endif
static Boolean fileCanWrite(CFWriteStreamRef stream, void *info) {
#ifdef REAL_FILE_SCHEDULING
return fdCanWrite(((_CFFileStreamContext *)info)->fd);
#else
return TRUE;
#endif
}
static void fileClose(struct _CFStream *stream, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
if (ctxt->fd >= 0) {
close(ctxt->fd);
ctxt->fd = -1;
#ifdef REAL_FILE_SCHEDULING
if (ctxt->rlInfo.sock) {
CFSocketInvalidate(ctxt->rlInfo.sock);
CFRelease(ctxt->rlInfo.sock);
ctxt->rlInfo.sock = NULL;
}
} else if (ctxt->rlInfo.rlArray) {
CFRelease(ctxt->rlInfo.rlArray);
ctxt->rlInfo.rlArray = NULL;
#endif
}
}
#ifdef REAL_FILE_SCHEDULING
static void fileCallBack(CFSocketRef s, CFSocketCallBackType type, CFDataRef address, const void *data, void *info) {
struct _CFStream *stream = (struct _CFStream *)info;
Boolean isReadStream = (CFGetTypeID(stream) == CFReadStreamGetTypeID());
_CFFileStreamContext *fileStream = (_CFFileStreamContext *)((isReadStream) ? CFReadStreamGetInfoPointer((CFReadStreamRef)stream) : CFWriteStreamGetInfoPointer((CFWriteStreamRef)stream));
if (type == kCFSocketWriteCallBack) {
__CFBitSet(fileStream->flags, SCHEDULE_AFTER_WRITE);
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);
} else {
// type == kCFSocketReadCallBack
__CFBitSet(fileStream->flags, SCHEDULE_AFTER_READ);
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);
}
}
#endif
static void fileSchedule(struct _CFStream *stream, CFRunLoopRef runLoop, CFStringRef runLoopMode, void *info) {
_CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;
Boolean isReadStream = (CFGetTypeID(stream) == CFReadStreamGetTypeID());
CFStreamStatus status = isReadStream ? CFReadStreamGetStatus((CFReadStreamRef)stream) : CFWriteStreamGetStatus((CFWriteStreamRef)stream);
if (fileStream->fd < 0 && status != kCFStreamStatusNotOpen) {
// Stream's already closed or error-ed out
return;
}
#ifdef REAL_FILE_SCHEDULING
if (status == kCFStreamStatusNotOpen) {
if (!fileStream->rlInfo.rlArray) {
fileStream->rlInfo.rlArray = CFArrayCreateMutable(CFGetAllocator(stream), 0, &kCFTypeArrayCallBacks);
}
CFArrayAppendValue(fileStream->rlInfo.rlArray, runLoop);
CFArrayAppendValue(fileStream->rlInfo.rlArray, runLoopMode);
} else {
CFRunLoopSourceRef rlSrc;
if (!fileStream->rlInfo.sock) {
constructCFSocket(fileStream, isReadStream, stream);
}
rlSrc = CFSocketCreateRunLoopSource(CFGetAllocator(stream), fileStream->rlInfo.sock, 0);
CFRunLoopAddSource(runLoop, rlSrc, runLoopMode);
CFRelease(rlSrc);
}
#else
fileStream->scheduled++;
if (fileStream->scheduled == 1 && fileStream->fd > 0 && status == kCFStreamStatusOpen) {
if (isReadStream)
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);
else
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);
}
#endif
}
static void fileUnschedule(struct _CFStream *stream, CFRunLoopRef runLoop, CFStringRef runLoopMode, void *info) {
_CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;
#ifdef REAL_FILE_SCHEDULING
Boolean isReadStream = (CFGetTypeID(stream) == CFReadStreamGetTypeID());
CFStreamStatus status = isReadStream ? CFReadStreamGetStatus((CFReadStreamRef)stream) : CFWriteStreamGetStatus((CFWriteStreamRef)stream);
if (status == kCFStreamStatusNotOpen) {
// Not opened yet
if (fileStream->rlInfo.rlArray) {
CFMutableArrayRef runloops = fileStream->rlInfo.rlArray;
CFIndex i, c;
for (i = 0, c = CFArrayGetCount(runloops); i+1 < c; i += 2) {
if (CFEqual(CFArrayGetValueAtIndex(runloops, i), runLoop) && CFEqual(CFArrayGetValueAtIndex(runloops, i+1), runLoopMode)) {
CFArrayRemoveValueAtIndex(runloops, i);
CFArrayRemoveValueAtIndex(runloops, i);
break;
}
}
}
} else if (fileStream->rlInfo.sock) {
if (__CFBitIsSet(fileStream->flags, USE_RUNLOOP_ARRAY)) {
// we know that fileStream->rlInfo.rlArray is non-NULL because it is in a union with fileStream->rlInfo.sock
CFMutableArrayRef runloops = fileStream->rlInfo.rlArray;
CFIndex i, c;
for (i = 0, c = CFArrayGetCount(runloops); i+1 < c; i += 2) {
if (CFEqual(CFArrayGetValueAtIndex(runloops, i), runLoop) && CFEqual(CFArrayGetValueAtIndex(runloops, i+1), runLoopMode)) {
CFArrayRemoveValueAtIndex(runloops, i);
CFArrayRemoveValueAtIndex(runloops, i);
break;
}
}
} else {
CFRunLoopSourceRef sockSource = CFSocketCreateRunLoopSource(CFGetAllocator(stream), fileStream->rlInfo.sock, 0);
CFRunLoopRemoveSource(runLoop, sockSource, runLoopMode);
CFRelease(sockSource);
}
}
#else
if (fileStream->scheduled > 0)
fileStream->scheduled--;
#endif
}
static CFTypeRef fileCopyProperty(struct _CFStream *stream, CFStringRef propertyName, void *info) {
CFTypeRef result = NULL;
_CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;
if (CFEqual(propertyName, kCFStreamPropertyFileCurrentOffset)) {
// NOTE that this does a lseek of 0 from the current location in
// order to populate the offset field which will then be used to
// create the resulting value.
if (!__CFBitIsSet(fileStream->flags, APPEND) && fileStream->fd != -1) {
fileStream->offset = lseek(fileStream->fd, 0, SEEK_CUR);
}
if (fileStream->offset != -1) {
result = CFNumberCreate(CFGetAllocator((CFTypeRef)stream), kCFNumberSInt64Type, &(fileStream->offset));
}
}
return result;
}
static Boolean fileSetProperty(struct _CFStream *stream, CFStringRef prop, CFTypeRef val, void *info) {
Boolean result = FALSE;
_CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;
if (CFEqual(prop, kCFStreamPropertyAppendToFile) && CFGetTypeID(stream) == CFWriteStreamGetTypeID() &&
CFWriteStreamGetStatus((CFWriteStreamRef)stream) == kCFStreamStatusNotOpen)
{
if (val == kCFBooleanTrue) {
__CFBitSet(fileStream->flags, APPEND);
fileStream->offset = -1; // Can't offset and append on the stream
} else {
__CFBitClear(fileStream->flags, APPEND);
}
result = TRUE;
}
else if (CFEqual(prop, kCFStreamPropertyFileCurrentOffset)) {
if (!__CFBitIsSet(fileStream->flags, APPEND))
{
result = CFNumberGetValue((CFNumberRef)val, kCFNumberSInt64Type, &(fileStream->offset));
}
if ((fileStream->fd != -1) && (lseek(fileStream->fd, fileStream->offset, SEEK_SET) == -1)) {
result = FALSE;
}
}
return result;
}
static void *fileCreate(struct _CFStream *stream, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
_CFFileStreamContext *newCtxt = (_CFFileStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFFileStreamContext), 0);
if (!newCtxt) return NULL;
newCtxt->url = ctxt->url;
if (newCtxt->url) {
CFRetain(newCtxt->url);
}
newCtxt->fd = ctxt->fd;
#ifdef REAL_FILE_SCHEDULING
newCtxt->rlInfo.sock = NULL;
#else
newCtxt->scheduled = 0;
#endif
newCtxt->flags = 0;
newCtxt->offset = -1;
return newCtxt;
}
static void fileFinalize(struct _CFStream *stream, void *info) {
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
if (ctxt->fd > 0) {
#ifdef REAL_FILE_SCHEDULING
if (ctxt->rlInfo.sock) {
CFSocketInvalidate(ctxt->rlInfo.sock);
CFRelease(ctxt->rlInfo.sock);
}
#endif
close(ctxt->fd);
#ifdef REAL_FILE_SCHEDULING
} else if (ctxt->rlInfo.rlArray) {
CFRelease(ctxt->rlInfo.rlArray);
#endif
}
if (ctxt->url) {
CFRelease(ctxt->url);
}
CFAllocatorDeallocate(CFGetAllocator(stream), ctxt);
}
static CFStringRef fileCopyDescription(struct _CFStream *stream, void *info) {
// This needs work
_CFFileStreamContext *ctxt = (_CFFileStreamContext *)info;
if (ctxt->url) {
return CFCopyDescription(ctxt->url);
} else {
return CFStringCreateWithFormat(CFGetAllocator(stream), NULL, CFSTR("fd = %d"), ctxt->fd);
}
}
/* CFData stream callbacks */
typedef struct {
CFDataRef data; // Mutable if the stream was constructed writable
const UInt8 *loc; // Current location in the file
Boolean scheduled;
char _padding[3];
} _CFReadDataStreamContext;
#define BUF_SIZE 1024
typedef struct _CFStreamByteBuffer {
UInt8 *bytes;
CFIndex capacity, length;
struct _CFStreamByteBuffer *next;
} _CFStreamByteBuffer;
typedef struct {
_CFStreamByteBuffer *firstBuf, *currentBuf;
CFAllocatorRef bufferAllocator;
Boolean scheduled;
char _padding[3];
} _CFWriteDataStreamContext;
static Boolean readDataOpen(struct _CFStream *stream, CFStreamError *errorCode, Boolean *openComplete, void *info) {
_CFReadDataStreamContext *dataStream = (_CFReadDataStreamContext *)info;
if (dataStream->scheduled) {
if (CFDataGetLength(dataStream->data) != 0) {
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);
} else {
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventEndEncountered, NULL);
}
}
errorCode->error = 0;
*openComplete = TRUE;
return TRUE;
}
static void readDataSchedule(struct _CFStream *stream, CFRunLoopRef rl, CFStringRef rlMode, void *info) {
_CFReadDataStreamContext *dataStream = (_CFReadDataStreamContext *)info;
if (dataStream->scheduled == FALSE) {
dataStream->scheduled = TRUE;
if (CFReadStreamGetStatus((CFReadStreamRef)stream) != kCFStreamStatusOpen)
return;
if (CFDataGetBytePtr(dataStream->data) + CFDataGetLength(dataStream->data) > dataStream->loc) {
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);
} else {
CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventEndEncountered, NULL);
}
}
}
static CFIndex dataRead(CFReadStreamRef stream, UInt8 *buffer, CFIndex bufferLength, CFStreamError *error, Boolean *atEOF, void *info) {
_CFReadDataStreamContext *dataCtxt = (_CFReadDataStreamContext *)info;
const UInt8 *bytePtr = CFDataGetBytePtr(dataCtxt->data);
CFIndex length = CFDataGetLength(dataCtxt->data);
CFIndex bytesToCopy = bytePtr + length - dataCtxt->loc;
if (bytesToCopy > bufferLength) {
bytesToCopy = bufferLength;
}
if (bytesToCopy < 0) {
bytesToCopy = 0;
}
if (bytesToCopy != 0) {
memmove(buffer, dataCtxt->loc, bytesToCopy);
dataCtxt->loc += bytesToCopy;
}
error->error = 0;
*atEOF = (dataCtxt->loc < bytePtr + length) ? FALSE : TRUE;
if (dataCtxt->scheduled && !*atEOF) {
CFReadStreamSignalEvent(stream, kCFStreamEventHasBytesAvailable, NULL);
}
return bytesToCopy;
}
static const UInt8 *dataGetBuffer(CFReadStreamRef stream, CFIndex maxBytesToRead, CFIndex *numBytesRead, CFStreamError *error, Boolean *atEOF, void *info) {
_CFReadDataStreamContext *dataCtxt = (_CFReadDataStreamContext *)info;
const UInt8 *bytes = CFDataGetBytePtr(dataCtxt->data);
if (dataCtxt->loc - bytes > maxBytesToRead) {
*numBytesRead = maxBytesToRead;
*atEOF = FALSE;
} else {
*numBytesRead = dataCtxt->loc - bytes;
*atEOF = TRUE;
}
error->error = 0;
bytes = dataCtxt->loc;
dataCtxt->loc += *numBytesRead;
if (dataCtxt->scheduled && !*atEOF) {
CFReadStreamSignalEvent(stream, kCFStreamEventHasBytesAvailable, NULL);
}
return bytes;
}
static Boolean dataCanRead(CFReadStreamRef stream, void *info) {
_CFReadDataStreamContext *dataCtxt = (_CFReadDataStreamContext *)info;
return (CFDataGetBytePtr(dataCtxt->data) + CFDataGetLength(dataCtxt->data) > dataCtxt->loc) ? TRUE : FALSE;
}
static Boolean writeDataOpen(struct _CFStream *stream, CFStreamError *errorCode, Boolean *openComplete, void *info) {
_CFWriteDataStreamContext *dataStream = (_CFWriteDataStreamContext *)info;
if (dataStream->scheduled) {
if (dataStream->bufferAllocator != kCFAllocatorNull || dataStream->currentBuf->capacity > dataStream->currentBuf->length) {
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);
} else {
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventEndEncountered, NULL);
}
}
errorCode->error = 0;
*openComplete = TRUE;
return TRUE;
}
static void writeDataSchedule(struct _CFStream *stream, CFRunLoopRef rl, CFStringRef rlMode, void *info) {
_CFWriteDataStreamContext *dataStream = (_CFWriteDataStreamContext *)info;
if (dataStream->scheduled == FALSE) {
dataStream->scheduled = TRUE;
if (CFWriteStreamGetStatus((CFWriteStreamRef)stream) != kCFStreamStatusOpen)
return;
if (dataStream->bufferAllocator != kCFAllocatorNull || dataStream->currentBuf->capacity > dataStream->currentBuf->length) {
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);
} else {
CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventEndEncountered, NULL);
}
}
}
static CFIndex dataWrite(CFWriteStreamRef stream, const UInt8 *buffer, CFIndex bufferLength, CFStreamError *errorCode, void *info) {
_CFWriteDataStreamContext *dataStream = (_CFWriteDataStreamContext *)info;
CFIndex result;
CFIndex freeSpace = dataStream->currentBuf->capacity - dataStream->currentBuf->length;
if (dataStream->bufferAllocator == kCFAllocatorNull && bufferLength > freeSpace) {
errorCode->error = ENOMEM;
errorCode->domain = kCFStreamErrorDomainPOSIX;
return -1;
} else {
result = bufferLength;
while (bufferLength > 0) {
CFIndex amountToCopy = (bufferLength > freeSpace) ? freeSpace : bufferLength;
if (freeSpace > 0) {
memmove(dataStream->currentBuf->bytes + dataStream->currentBuf->length, buffer, amountToCopy);
buffer += amountToCopy;
bufferLength -= amountToCopy;
dataStream->currentBuf->length += amountToCopy;
}
if (bufferLength > 0) {
CFIndex bufSize = BUF_SIZE > bufferLength ? BUF_SIZE : bufferLength;
_CFStreamByteBuffer *newBuf = (_CFStreamByteBuffer *)CFAllocatorAllocate(dataStream->bufferAllocator, sizeof(_CFStreamByteBuffer) + bufSize, 0);
newBuf->bytes = (UInt8 *)(newBuf + 1);
newBuf->capacity = bufSize;
newBuf->length = 0;
newBuf->next = NULL;
dataStream->currentBuf->next = newBuf;
dataStream->currentBuf = newBuf;
freeSpace = bufSize;
}
}
errorCode->error = 0;
}
if (dataStream->scheduled && (dataStream->bufferAllocator != kCFAllocatorNull || dataStream->currentBuf->capacity > dataStream->currentBuf->length)) {
CFWriteStreamSignalEvent(stream, kCFStreamEventCanAcceptBytes, NULL);
}
return result;
}
static Boolean dataCanWrite(CFWriteStreamRef stream, void *info) {
_CFWriteDataStreamContext *dataStream = (_CFWriteDataStreamContext *)info;
if (dataStream->bufferAllocator != kCFAllocatorNull) return TRUE;
if (dataStream->currentBuf->capacity > dataStream->currentBuf->length) return TRUE;
return FALSE;
}
static CFPropertyListRef dataCopyProperty(struct _CFStream *stream, CFStringRef propertyName, void *info) {
_CFWriteDataStreamContext *dataStream = (_CFWriteDataStreamContext *)info;
CFIndex size = 0;
_CFStreamByteBuffer *buf;
CFAllocatorRef alloc;
UInt8 *bytes, *currByte;
if (!CFEqual(propertyName, kCFStreamPropertyDataWritten)) return NULL;
if (dataStream->bufferAllocator == kCFAllocatorNull) return NULL;
alloc = dataStream->bufferAllocator;
for (buf = dataStream->firstBuf; buf != NULL; buf = buf->next) {
size += buf->length;
}
if (size == 0) return NULL;
bytes = (UInt8 *)CFAllocatorAllocate(alloc, size, 0);
currByte = bytes;
for (buf = dataStream->firstBuf; buf != NULL; buf = buf->next) {
memmove(currByte, buf->bytes, buf->length);
currByte += buf->length;
}
return CFDataCreateWithBytesNoCopy(alloc, bytes, size, alloc);
}
static void *readDataCreate(struct _CFStream *stream, void *info) {
_CFReadDataStreamContext *ctxt = (_CFReadDataStreamContext *)info;
_CFReadDataStreamContext *newCtxt = (_CFReadDataStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFReadDataStreamContext), 0);
if (!newCtxt) return NULL;
newCtxt->data = (CFDataRef)CFRetain(ctxt->data);
newCtxt->loc = CFDataGetBytePtr(newCtxt->data);
newCtxt->scheduled = FALSE;
return (void *)newCtxt;
}
static void readDataFinalize(struct _CFStream *stream, void *info) {
_CFReadDataStreamContext *ctxt = (_CFReadDataStreamContext *)info;
CFRelease(ctxt->data);
CFAllocatorDeallocate(CFGetAllocator(stream), ctxt);
}
static CFStringRef readDataCopyDescription(struct _CFStream *stream, void *info) {
return CFCopyDescription(((_CFReadDataStreamContext *)info)->data);
}
static void *writeDataCreate(struct _CFStream *stream, void *info) {
_CFWriteDataStreamContext *ctxt = (_CFWriteDataStreamContext *)info;
_CFWriteDataStreamContext *newCtxt;
if (ctxt->bufferAllocator != kCFAllocatorNull) {
if (ctxt->bufferAllocator == NULL) ctxt->bufferAllocator = CFAllocatorGetDefault();
CFRetain(ctxt->bufferAllocator);
newCtxt = (_CFWriteDataStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFWriteDataStreamContext) + sizeof(_CFStreamByteBuffer) + BUF_SIZE, 0);
newCtxt->firstBuf = (_CFStreamByteBuffer *)(newCtxt + 1);
newCtxt->firstBuf->bytes = (UInt8 *)(newCtxt->firstBuf + 1);
newCtxt->firstBuf->capacity = BUF_SIZE;
newCtxt->firstBuf->length = 0;
newCtxt->firstBuf->next = NULL;
newCtxt->currentBuf = newCtxt->firstBuf;
newCtxt->bufferAllocator = ctxt->bufferAllocator;
newCtxt->scheduled = FALSE;
} else {
newCtxt = (_CFWriteDataStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFWriteDataStreamContext) + sizeof(_CFStreamByteBuffer), 0);
newCtxt->firstBuf = (_CFStreamByteBuffer *)(newCtxt+1);
newCtxt->firstBuf->bytes = ctxt->firstBuf->bytes;
newCtxt->firstBuf->capacity = ctxt->firstBuf->capacity;
newCtxt->firstBuf->length = 0;
newCtxt->firstBuf->next = NULL;
newCtxt->currentBuf = newCtxt->firstBuf;
newCtxt->bufferAllocator = kCFAllocatorNull;
newCtxt->scheduled = FALSE;
}
return (void *)newCtxt;
}
static void writeDataFinalize(struct _CFStream *stream, void *info) {
_CFWriteDataStreamContext *ctxt = (_CFWriteDataStreamContext *)info;
if (ctxt->bufferAllocator != kCFAllocatorNull) {
_CFStreamByteBuffer *buf = ctxt->firstBuf->next, *next;
while (buf != NULL) {
next = buf->next;
CFAllocatorDeallocate(ctxt->bufferAllocator, buf);
buf = next;
}
CFRelease(ctxt->bufferAllocator);
}
CFAllocatorDeallocate(CFGetAllocator(stream), ctxt);
}
static CFStringRef writeDataCopyDescription(struct _CFStream *stream, void *info) {
return CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFWriteDataContext %p>"), info);
}
static const struct _CFStreamCallBacksV1 fileCallBacks = {1, fileCreate, fileFinalize, fileCopyDescription, fileOpen, NULL, fileRead, NULL, fileCanRead, fileWrite, fileCanWrite, fileClose, fileCopyProperty, fileSetProperty, NULL, fileSchedule, fileUnschedule};
static struct _CFStream *_CFStreamCreateWithFile(CFAllocatorRef alloc, CFURLRef fileURL, Boolean forReading) {
_CFFileStreamContext fileContext;
CFStringRef scheme = fileURL ? CFURLCopyScheme(fileURL) : NULL;
if (!scheme || !CFEqual(scheme, CFSTR("file"))) {
if (scheme) CFRelease(scheme);
return NULL;
}
CFRelease(scheme);
fileContext.url = fileURL;
fileContext.fd = -1;
return _CFStreamCreateWithConstantCallbacks(alloc, &fileContext, (struct _CFStreamCallBacks *)(&fileCallBacks), forReading);
}
CF_EXPORT CFReadStreamRef CFReadStreamCreateWithFile(CFAllocatorRef alloc, CFURLRef fileURL) {
return (CFReadStreamRef)_CFStreamCreateWithFile(alloc, fileURL, TRUE);
}
CF_EXPORT CFWriteStreamRef CFWriteStreamCreateWithFile(CFAllocatorRef alloc, CFURLRef fileURL) {
return (CFWriteStreamRef)_CFStreamCreateWithFile(alloc, fileURL, FALSE);
}
CFReadStreamRef _CFReadStreamCreateFromFileDescriptor(CFAllocatorRef alloc, int fd) {
_CFFileStreamContext fileContext;
fileContext.url = NULL;
fileContext.fd = fd;
return (CFReadStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &fileContext, (struct _CFStreamCallBacks *)(&fileCallBacks), TRUE);
}
CFWriteStreamRef _CFWriteStreamCreateFromFileDescriptor(CFAllocatorRef alloc, int fd) {
_CFFileStreamContext fileContext;
fileContext.url = NULL;
fileContext.fd = fd;
return (CFWriteStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &fileContext, (struct _CFStreamCallBacks *)(&fileCallBacks), FALSE);
}
static const struct _CFStreamCallBacksV1 readDataCallBacks = {1, readDataCreate, readDataFinalize, readDataCopyDescription, readDataOpen, NULL, dataRead, dataGetBuffer, dataCanRead, NULL, NULL, NULL, NULL, NULL, NULL, readDataSchedule, NULL};
static const struct _CFStreamCallBacksV1 writeDataCallBacks = {1, writeDataCreate, writeDataFinalize, writeDataCopyDescription, writeDataOpen, NULL, NULL, NULL, NULL, dataWrite, dataCanWrite, NULL, dataCopyProperty, NULL, NULL, writeDataSchedule, NULL};
CF_EXPORT CFReadStreamRef CFReadStreamCreateWithBytesNoCopy(CFAllocatorRef alloc, const UInt8 *bytes, CFIndex length, CFAllocatorRef bytesDeallocator) {
_CFReadDataStreamContext ctxt;
CFReadStreamRef result;
ctxt.data = CFDataCreateWithBytesNoCopy(alloc, bytes, length, bytesDeallocator);
result = (CFReadStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &ctxt, (struct _CFStreamCallBacks *)(&readDataCallBacks), TRUE);
CFRelease(ctxt.data);
return result;
}
/* This needs to be exported to make it callable from Foundation. */
CF_EXPORT CFReadStreamRef CFReadStreamCreateWithData(CFAllocatorRef alloc, CFDataRef data) {
_CFReadDataStreamContext ctxt;
CFReadStreamRef result = NULL;
ctxt.data = (CFDataRef)CFRetain(data);
result = (CFReadStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &ctxt, (struct _CFStreamCallBacks *)(&readDataCallBacks), TRUE);
CFRelease(data);
return result;
}
CFWriteStreamRef CFWriteStreamCreateWithBuffer(CFAllocatorRef alloc, UInt8 *buffer, CFIndex bufferCapacity) {
_CFStreamByteBuffer buf;
_CFWriteDataStreamContext ctxt;
buf.bytes = buffer;
buf.capacity = bufferCapacity;
buf.length = 0;
buf.next = NULL;
ctxt.firstBuf = &buf;
ctxt.currentBuf = ctxt.firstBuf;
ctxt.bufferAllocator = kCFAllocatorNull;
return (CFWriteStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &ctxt, (struct _CFStreamCallBacks *)(&writeDataCallBacks), FALSE);
}
CF_EXPORT CFWriteStreamRef CFWriteStreamCreateWithAllocatedBuffers(CFAllocatorRef alloc, CFAllocatorRef bufferAllocator) {
_CFWriteDataStreamContext ctxt;
ctxt.firstBuf = NULL;
ctxt.currentBuf = NULL;
ctxt.bufferAllocator = bufferAllocator;
return (CFWriteStreamRef)_CFStreamCreateWithConstantCallbacks(alloc, &ctxt, (struct _CFStreamCallBacks *)(&writeDataCallBacks), FALSE);
}
#undef BUF_SIZE