学步园

while (!done) {
    if (CFReadStreamHasBytesAvailable(myReadStream)) {
        UInt8 buf[BUFSIZE];
        CFIndex bytesRead = CFReadStreamRead(myReadStream, buf, BUFSIZE);
        if (bytesRead < 0) {
            CFStreamError error = CFReadStreamGetError(myReadStream);
            reportError(error);
        } else if (bytesRead == 0) {
            if (CFReadStreamGetStatus(myReadStream) == kCFStreamStatusAtEnd) {
                done = TRUE;
            }
        } else {
            handleBytes(buf, bytesRead);
        }
    } else {
        // ...do something else while you wait...
    }
}

UInt8 buf[] = “Hello, world”;
UInt32 bufLen = strlen(buf);
 
while (!done) {
    if (CFWriteStreamCanAcceptBytes(myWriteStream)) {
        int bytesWritten = CFWriteStreamWrite(myWriteStream, buf, strlen(buf));
        if (bytesWritten < 0) {
            CFStreamError error = CFWriteStreamGetError(myWriteStream);
            reportError(error);
        } else if (bytesWritten == 0) {
            if (CFWriteStreamGetStatus(myWriteStream) == kCFStreamStatusAtEnd)
            {
                done = TRUE;
            }
        } else if (bytesWritten != strlen(buf)) {
            // Determine how much has been written and adjust the buffer
            bufLen = bufLen - bytesWritten;
            memmove(buf, buf + bytesWritten, bufLen);
 
            // Figure out what went wrong with the write stream
            CFStreamError error = CFWriteStreamGetError(myWriteStream);
            reportError(error);
        }
    } else {
        // ...do something else while you wait...
    }
}

CFStreamCreatePairWithSocketToCFHost(kCFAllocatorDefault, host, port,
                                   &myReadStream, NULL);

CFStreamClientContext myContext = {0, myPtr, myRetain, myRelease, myCopyDesc};

CFOptionsFlags registeredEvents = kCFStreamEventHasBytesAvailable |
        kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered;
if (CFReadStreamSetClient(myReadStream, registeredEvents, myCallBack, &myContext)
{
    CFReadStreamScheduleWithRunLoop(myReadStream, CFRunLoopGetCurrent(),
                                    kCFRunLoopCommonModes);
}

if (!CFReadStreamOpen(myReadStream)) {
    CFStreamError myErr = CFReadStreamGetError(myReadStream);
    if (myErr.error != 0) {
    // An error has occurred.
        if (myErr.domain == kCFStreamErrorDomainPOSIX) {
        // Interpret myErr.error as a UNIX errno.
            strerror(myErr.error);
        } else if (myErr.domain == kCFStreamErrorDomainMacOSStatus) {
            OSStatus macError = (OSStatus)myErr.error;
            }
        // Check other domains.
    } else
        // start the run loop
        CFRunLoopRun();
}

void myCallBack (CFReadStreamRef stream, CFStreamEventType event, void *myPtr) {
    switch(event) {
        case kCFStreamEventHasBytesAvailable: 
            // It is safe to call CFReadStreamRead; it won’t block because bytes
            // are available.
            UInt8 buf[BUFSIZE];
            CFIndex bytesRead = CFReadStreamRead(stream, buf, BUFSIZE);
            if (bytesRead > 0) {
                handleBytes(buf, bytesRead);
            }
            // It is safe to ignore a value of bytesRead that is less than or
            // equal to zero because these cases will generate other events.
            break;
        case kCFStreamEventErrorOccurred: 
            CFStreamError error = CFReadStreamGetError(stream);
            reportError(error);
            CFReadStreamClose(stream);
            CFRelease(stream);
            break;
        case kCFStreamEventEndEncountered:
            reportCompletion();
            CFReadStreamClose(stream);
            CFRelease(stream);
            break;
    }
}

利用防火墙

有两种方式设置操作流的防火墙。对大多数流来说，可以通过 SCDynamicStoreCopyProxies 函数获取代理设置，然后通过设置kCFStreamHTTPProxy (或者 kCFStreamFTPProxy)
参数将结果设置到操作流上。SCDynamicStoreCopyProxies 函数是系统配置框架的一部分，因此需要在项目中包含 <SystemConfiguration/SystemConfiguration.h> ，这样才能使用该函数。接着在使用之后把代理词典引用释放调。这个过程看起来类似列表
2-11 中的例子。

列表 2-11  通过代理服务器浏览一个操作流

CFDictionaryRef proxyDict = SCDynamicStoreCopyProxies(NULL); 
CFReadStreamSetProperty(readStream, kCFStreamPropertyHTTPProxy, proxyDict);

不过，如果你需要在多个操作流中使用代理设置的话，就会稍微复杂一点。这种情况下，获取用户机器的防火墙设置需要5个步骤：

1. 创建一个指向动态存储会话的单独持久性句柄，比如 SCDynamicStoreRef。

2. 把指向动态存储会话的句柄放入循环当中，使它能够得到代理变化的通知。

3. 利用 SCDynamicStoreCopyProxies 获取最新的代理设置。

4. 在得到变动通知后更新代理的拷贝。

5. 在使用完毕后清除 SCDynamicStoreRef 。

可以使用函数 SCDynamicStoreCreate 来创建一个指向动态存储会话的句柄，并向它传递一个定位器、一个描述过程的名称、一个回调函数和一个动态存储上下文 SCDynamicStoreContext。在你的应用进行初始化的时候就会执行这个步骤。具体代码类似列表 2-12。

列表 2-12  创建一个指向动态存储会话的句柄

SCDynamicStoreContext context = {0, self, NULL, NULL, NULL};
systemDynamicStore = SCDynamicStoreCreate(NULL,
                                          CFSTR("SampleApp"),
                                          proxyHasChanged,
                                          &context);

在创建了指向动态存储的引用之后，你需要把它加入循环当中。首先，对这个动态存储引用进行设置，使它能够监控代理的任何变化。这个可以通过函数 SCDynamicStoreKeyCreateProxies 和 SCDynamicStoreSetNotificationKeys 来实现。接着，你可以利用函数SCDynamicStoreCreateRunLoopSource 和 CFRunLoopAddSource 把动态存储引用加入到循环当中。你的代码应该类似列表 2-13。

列表 2-13  把一个动态存储引用加入循环

// Set up the store to monitor any changes to the proxies
CFStringRef proxiesKey = SCDynamicStoreKeyCreateProxies(NULL);
CFArrayRef keyArray = CFArrayCreate(NULL,
                                    (const void **)(&proxiesKey),
                                    1,
                                    &kCFTypeArrayCallBacks);
SCDynamicStoreSetNotificationKeys(systemDynamicStore, keyArray, NULL);
CFRelease(keyArray);
CFRelease(proxiesKey);
 
// Add the dynamic store to the run loop
CFRunLoopSourceRef storeRLSource =
    SCDynamicStoreCreateRunLoopSource(NULL, systemDynamicStore, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), storeRLSource, kCFRunLoopCommonModes);
CFRelease(storeRLSource);

一旦动态存储引用被加入了循环，可以利用它调用函数 SCDynamicStoreCopyProxies 加载代理词典的当前代理设置，如何做请参考列表2-14 。

列表 2-14  加载代理词典

gProxyDict = SCDynamicStoreCopyProxies(systemDynamicStore);

一旦把动态存储引用加入了循环当中，每当代理发生变化，你的回调函数就会被调用。当前的代理词典会被释放掉

，并利用新的代理设置重新载入这个代理词典。列表 2-15 中是一个回调数的范例。

列表 2-15  代理回调函数

void proxyChanged() {
    CFRelease(gProxyDict);
    gProxyDict = SCDynamicStoreCopyProxies(systemDynamicStore);
}

由于所有的代理信息都是最新的，这样就可以使用这些代理。在创建了您的读写操作流之后， 调用函数 CFReadStreamSetProperty 或者CFWriteStreamSetProperty 设置 kCFStreamPropertyHTTPProxy 代理。如果你的操作流是一个读操作流，名称为 readStream，那么你的函数调用将如列表 2-16
所示。

列表 2-16  把代理信息加入一个操作流

CFReadStreamSetProperty(readStream, kCFStreamPropertyHTTPProxy, gProxyDict);

在使用完毕代理设置信息之后，请确保释放了词典和动态存储引用，并将动态存储引用从循环中清除。请参考列表 2-17。

列表 2-17  清理代理信息

if (gProxyDict) {
    CFRelease(gProxyDict);
}
 
// Invalidate the dynamic store's run loop source
// to get the store out of the run loop
CFRunLoopSourceRef rls = SCDynamicStoreCreateRunLoopSource(NULL, systemDynamicStore, 0);
CFRunLoopSourceInvalidate(rls);
CFRelease(rls);
CFRelease(systemDynmaicStore);