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;
}
tsk_size_t tnet_transport_send(const tnet_transport_handle_t *handle, tnet_fd_t from, const void* buf, tsk_size_t size)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
int numberOfBytesSent = 0;
if (!transport) {
TSK_DEBUG_ERROR("Invalid transport handle.");
goto bail;
}
const transport_socket_t* sock = getSocket(transport->context, from);
if (TNET_SOCKET_TYPE_IS_STREAM(sock->type)) {
if (!sock->cf_write_stream) {
TNET_PRINT_LAST_ERROR("No stream found.");
goto bail;
}
if (CFWriteStreamGetStatus(sock->cf_write_stream) == kCFStreamStatusNotOpen) {
CFWriteStreamOpen(sock->cf_write_stream);
}
if ((numberOfBytesSent = CFWriteStreamWrite(sock->cf_write_stream, buf, (CFIndex) size)) <= 0) {
TNET_PRINT_LAST_ERROR("Send have failed.");
goto bail;
}
} else {
if ((numberOfBytesSent = send(from, buf, size, 0)) <= 0) {
TNET_PRINT_LAST_ERROR("Send have failed.");
goto bail;
}
}
bail:
return numberOfBytesSent;
}
static ssize_t mailstream_low_cfstream_write(mailstream_low * s,
const void * buf, size_t count)
{
#if HAVE_CFNETWORK
struct mailstream_cfstream_data * cfstream_data;
int r;
cfstream_data = (struct mailstream_cfstream_data *) s->data;
cfstream_data->writeBuffer = buf;
cfstream_data->writeBufferSize = count;
if (cfstream_data->cancelled)
return -1;
if (CFWriteStreamGetStatus(cfstream_data->writeStream) == kCFStreamStatusError) {
return -1;
}
if (CFWriteStreamCanAcceptBytes(cfstream_data->writeStream)) {
writeDataToStream(s);
return cfstream_data->writeResult;
}
r = wait_runloop(s, STATE_WAIT_WRITE);
if (r != WAIT_RUNLOOP_EXIT_NO_ERROR) {
return -1;
}
return cfstream_data->writeResult;
#else
return -1;
#endif
}
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);
}
}
}
void write_buffer(CFStringRef inData)
{
#ifdef DEBUG
syslog(LOG_ERR,"Writing buffer to file.");
#endif
if (CFWriteStreamGetStatus(logStream)!=kCFStreamStatusOpen)
{
CFWriteStreamSetProperty(logStream,kCFStreamPropertyAppendToFile,kCFBooleanTrue);
CFWriteStreamOpen(logStream);
}
if (!CFBooleanGetValue(doEncrypt))
{
CFWriteStreamWrite(logStream,(const UInt8*)CFStringGetCStringPtr(inData,CFStringGetFastestEncoding(inData)),CFStringGetLength(inData));
return;
}
int buff_pos = 0;
while (1)
{
int avail_space = 8-CFDataGetLength(encrypt_buffer); //space rem in buffer
int rem_to_copy = CFStringGetLength(inData)-buff_pos; //stuff in data that needs to be copied
int to_copy = rem_to_copy<avail_space?rem_to_copy:avail_space; //amount left to encryp, or avail space
if (avail_space)
{
UInt8 tmp_buff[8];
CFStringGetBytes(inData,CFRangeMake(buff_pos,to_copy),kCFStringEncodingNonLossyASCII,0,false,tmp_buff,8,NULL);
CFDataAppendBytes(encrypt_buffer,tmp_buff,to_copy);
avail_space -= to_copy;
if (avail_space>0) // small buffer? still space left?
break;
buff_pos += to_copy; //move along the buffer
}
UInt8 enc_buff[8];
BF_ecb_encrypt(CFDataGetBytePtr(encrypt_buffer),enc_buff,&encrypt_bf_key,BF_ENCRYPT);
CFWriteStreamWrite(logStream,enc_buff,8);
CFDataDeleteBytes(encrypt_buffer,CFRangeMake(0,8));
if (buff_pos==CFStringGetLength(inData)) //just in case buffer happens to fit perfectly
break;
}
return;
}
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.cffd) {
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.cffd
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 rlSrc = CFFileDescriptorCreateRunLoopSource(CFGetAllocator(stream), fileStream->rlInfo.cffd, 0);
CFRunLoopRemoveSource(runLoop, rlSrc, runLoopMode);
CFRelease(rlSrc);
}
}
#else
if (fileStream->scheduled > 0)
fileStream->scheduled--;
#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.cffd) {
constructCFFD(fileStream, isReadStream, stream);
}
rlSrc = CFFileDescriptorCreateRunLoopSource(CFGetAllocator(stream), fileStream->rlInfo.cffd, 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
}
