CFSocketStream.c

   1 /*
   2  * Copyright (c) 2009 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*      CFSocketStream.c
  24         Copyright (c) 2000-2009, Apple Inc. All rights reserved.
  25         Responsibility: Jeremy Wyld
  26 */
  27 //      Original Author: Becky Willrich
  28 #include <CoreFoundation/CFStream.h>
  29 #include <CoreFoundation/CFNumber.h>
  30 #include "CFInternal.h"
  31 #include "CFStreamInternal.h"
  32 #include "CFStreamPriv.h"
  33
  34 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
  35 // On Mach these live in CF for historical reasons, even though they are declared in CFNetwork
  36
  37 const int kCFStreamErrorDomainSSL = 3;
  38 const int kCFStreamErrorDomainSOCKS = 5;
  39
  40 CONST_STRING_DECL(kCFStreamPropertyShouldCloseNativeSocket, "kCFStreamPropertyShouldCloseNativeSocket")
  41 CONST_STRING_DECL(kCFStreamPropertyAutoErrorOnSystemChange, "kCFStreamPropertyAutoErrorOnSystemChange");
  42
  43 CONST_STRING_DECL(kCFStreamPropertySOCKSProxy, "kCFStreamPropertySOCKSProxy")
  44 CONST_STRING_DECL(kCFStreamPropertySOCKSProxyHost, "SOCKSProxy")
  45 CONST_STRING_DECL(kCFStreamPropertySOCKSProxyPort, "SOCKSPort")
  46 CONST_STRING_DECL(kCFStreamPropertySOCKSVersion, "kCFStreamPropertySOCKSVersion")
  47 CONST_STRING_DECL(kCFStreamSocketSOCKSVersion4, "kCFStreamSocketSOCKSVersion4")
  48 CONST_STRING_DECL(kCFStreamSocketSOCKSVersion5, "kCFStreamSocketSOCKSVersion5")
  49 CONST_STRING_DECL(kCFStreamPropertySOCKSUser, "kCFStreamPropertySOCKSUser")
  50 CONST_STRING_DECL(kCFStreamPropertySOCKSPassword, "kCFStreamPropertySOCKSPassword")
  51
  52 CONST_STRING_DECL(kCFStreamPropertySocketSecurityLevel, "kCFStreamPropertySocketSecurityLevel");
  53 CONST_STRING_DECL(kCFStreamSocketSecurityLevelNone, "kCFStreamSocketSecurityLevelNone");
  54 CONST_STRING_DECL(kCFStreamSocketSecurityLevelSSLv2, "kCFStreamSocketSecurityLevelSSLv2");
  55 CONST_STRING_DECL(kCFStreamSocketSecurityLevelSSLv3, "kCFStreamSocketSecurityLevelSSLv3");
  56 CONST_STRING_DECL(kCFStreamSocketSecurityLevelTLSv1, "kCFStreamSocketSecurityLevelTLSv1");
  57 CONST_STRING_DECL(kCFStreamSocketSecurityLevelNegotiatedSSL, "kCFStreamSocketSecurityLevelNegotiatedSSL");
  58
  59 #endif
  60
  61
  62 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
  63 #elif DEPLOYMENT_TARGET_WINDOWS
  64 typedef void (*CF_SOCKET_STREAM_PAIR)(CFAllocatorRef, CFStringRef, UInt32, CFSocketNativeHandle, const CFSocketSignature*, CFReadStreamRef*, CFWriteStreamRef*);
  65 #else
  66 #error Unknown or unspecified DEPLOYMENT_TARGET
  67 #endif
  68
  69 // These are duplicated in CFNetwork, who actually externs them in its headers
  70 CONST_STRING_DECL(kCFStreamPropertySocketSSLContext, "kCFStreamPropertySocketSSLContext")
  71 CONST_STRING_DECL(_kCFStreamPropertySocketSecurityAuthenticatesServerCertificate, "_kCFStreamPropertySocketSecurityAuthenticatesServerCertificate");
  72
  73
  74 CF_EXPORT
  75 void _CFSocketStreamSetAuthenticatesServerCertificateDefault(Boolean shouldAuthenticate) {
  76     CFLog(__kCFLogAssertion, CFSTR("_CFSocketStreamSetAuthenticatesServerCertificateDefault(): This call has been deprecated.  Use SetProperty(_kCFStreamPropertySocketSecurityAuthenticatesServerCertificate, kCFBooleanTrue/False)\n"));
  77 }
  78
  79
  80 /* CF_EXPORT */ Boolean
  81 _CFSocketStreamGetAuthenticatesServerCertificateDefault(void) {
  82     CFLog(__kCFLogAssertion, CFSTR("_CFSocketStreamGetAuthenticatesServerCertificateDefault(): This call has been removed as a security risk.  Use security properties on individual streams instead.\n"));
  83     return FALSE;
  84 }
  85
  86
  87 /* CF_EXPORT */ void
  88 _CFSocketStreamPairSetAuthenticatesServerCertificate(CFReadStreamRef rStream, CFWriteStreamRef wStream, Boolean authenticates) {
  89
  90     CFBooleanRef value = (!authenticates ? kCFBooleanFalse : kCFBooleanTrue);
  91
  92     if (rStream)
  93         CFReadStreamSetProperty(rStream, _kCFStreamPropertySocketSecurityAuthenticatesServerCertificate, value);
  94     else
  95         CFWriteStreamSetProperty(wStream, _kCFStreamPropertySocketSecurityAuthenticatesServerCertificate, value);
  96 }
  97
  98
  99 // Flags for dyld loading of libraries.
 100 enum {
 101     kTriedToLoad = 0,
 102     kInitialized
 103 };
 104
 105 static struct {
 106     CFSpinLock_t lock;
 107     UInt32      flags;
 108 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 109 #elif DEPLOYMENT_TARGET_WINDOWS
 110     HMODULE     image;
 111 #else
 112 #error Unknown or unspecified DEPLOYMENT_TARGET
 113 #endif
 114     void (*_CFSocketStreamCreatePair)(CFAllocatorRef, CFStringRef, UInt32, CFSocketNativeHandle, const CFSocketSignature*, CFReadStreamRef*, CFWriteStreamRef*);
 115     CFErrorRef (*_CFErrorCreateWithStreamError)(CFAllocatorRef, CFStreamError*);
 116     CFStreamError (*_CFStreamErrorFromCFError)(CFErrorRef);
 117 } CFNetworkSupport = {
 118     CFSpinLockInit,
 119     0x0,
 120 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 121 #elif DEPLOYMENT_TARGET_WINDOWS
 122     NULL,
 123 #else
 124 #error Unknown or unspecified DEPLOYMENT_TARGET
 125 #endif
 126     NULL,
 127     NULL,
 128     NULL
 129 };
 130
 131 #define CFNETWORK_CALL(sym, args)               ((CFNetworkSupport.sym)args)
 132
 133 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 134 #define CFNETWORK_LOAD_SYM(sym)   __CFLookupCFNetworkFunction(#sym)
 135 #elif DEPLOYMENT_TARGET_WINDOWS
 136 #define CFNETWORK_LOAD_SYM(sym)   (void *)GetProcAddress(CFNetworkSupport.image, #sym)
 137 #else
 138 #error Unknown or unspecified DEPLOYMENT_TARGET
 139 #endif
 140
 141 static void initializeCFNetworkSupport(void) {
 142     __CFBitSet(CFNetworkSupport.flags, kTriedToLoad);
 143
 144 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 145     CFNetworkSupport._CFSocketStreamCreatePair = CFNETWORK_LOAD_SYM(_CFSocketStreamCreatePair);
 146     CFNetworkSupport._CFErrorCreateWithStreamError = CFNETWORK_LOAD_SYM(_CFErrorCreateWithStreamError);
 147     CFNetworkSupport._CFStreamErrorFromCFError = CFNETWORK_LOAD_SYM(_CFStreamErrorFromCFError);
 148 #elif DEPLOYMENT_TARGET_WINDOWS
 149     if (!CFNetworkSupport.image) {
 150 #if _DEBUG
 151         CFNetworkSupport.image = GetModuleHandleW(L"CFNetwork_debug.dll");
 152 #else
 153         CFNetworkSupport.image = GetModuleHandleW(L"CFNetwork.dll");
 154 #endif
 155     }
 156
 157     if (!CFNetworkSupport.image) {
 158         // not loaded yet, try to load from the filesystem
 159         char path[MAX_PATH+1];
 160         if (!CFNetworkSupport.image) {
 161             strlcpy(path, (const char *)_CFDLLPath(), sizeof(path));
 162 #if _DEBUG
 163             strlcat(path, "\\CFNetwork_debug.dll", sizeof(path));
 164 #else
 165             strlcat(path, "\\CFNetwork.dll", sizeof(path));
 166 #endif
 167             CFNetworkSupport.image = LoadLibraryA(path);
 168         }
 169     }
 170
 171     if (!CFNetworkSupport.image) {
 172         CFLog(__kCFLogAssertion, CFSTR("CoreFoundation: failed to dynamically load CFNetwork"));
 173     } else  {
 174         CFNetworkSupport._CFSocketStreamCreatePair = (CF_SOCKET_STREAM_PAIR)CFNETWORK_LOAD_SYM(_CFSocketStreamCreatePair);
 175         CFNetworkSupport._CFErrorCreateWithStreamError = (CFErrorRef(*)(CFAllocatorRef, CFStreamError *))CFNETWORK_LOAD_SYM(_CFErrorCreateWithStreamError);
 176         CFNetworkSupport._CFStreamErrorFromCFError = (CFStreamError(*)(CFErrorRef))CFNETWORK_LOAD_SYM(_CFStreamErrorFromCFError);
 177     }
 178 #else
 179 #error Unknown or unspecified DEPLOYMENT_TARGET
 180 #endif
 181
 182     if (!CFNetworkSupport._CFSocketStreamCreatePair) CFLog(__kCFLogAssertion, CFSTR("CoreFoundation: failed to dynamically link symbol _CFSocketStreamCreatePair"));
 183     if (!CFNetworkSupport._CFErrorCreateWithStreamError) CFLog(__kCFLogAssertion, CFSTR("CoreFoundation: failed to dynamically link symbol _CFErrorCreateWithStreamError"));
 184     if (!CFNetworkSupport._CFStreamErrorFromCFError) CFLog(__kCFLogAssertion, CFSTR("CoreFoundation: failed to dynamically link symbol _CFStreamErrorFromCFError"));
 185
 186     __CFBitSet(CFNetworkSupport.flags, kInitialized);
 187 }
 188
 189 static void
 190 createPair(CFAllocatorRef alloc, CFStringRef host, UInt32 port, CFSocketNativeHandle sock, const CFSocketSignature* sig, CFReadStreamRef *readStream, CFWriteStreamRef *writeStream)
 191 {
 192     if (readStream)
 193         *readStream = NULL;
 194
 195     if (writeStream)
 196         *writeStream = NULL;
 197
 198     __CFSpinLock(&(CFNetworkSupport.lock));
 199     if (!__CFBitIsSet(CFNetworkSupport.flags, kTriedToLoad)) initializeCFNetworkSupport();
 200     __CFSpinUnlock(&(CFNetworkSupport.lock));
 201
 202     CFNETWORK_CALL(_CFSocketStreamCreatePair, (alloc, host, port, sock, sig, readStream, writeStream));
 203 }
 204
 205
 206 CF_EXPORT void CFStreamCreatePairWithSocket(CFAllocatorRef alloc, CFSocketNativeHandle sock, CFReadStreamRef *readStream, CFWriteStreamRef *writeStream) {
 207     createPair(alloc, NULL, 0, sock, NULL, readStream, writeStream);
 208 }
 209
 210 CF_EXPORT void CFStreamCreatePairWithSocketToHost(CFAllocatorRef alloc, CFStringRef host, UInt32 port, CFReadStreamRef *readStream, CFWriteStreamRef *writeStream) {
 211     createPair(alloc, host, port, 0, NULL, readStream, writeStream);
 212 }
 213
 214 CF_EXPORT void CFStreamCreatePairWithPeerSocketSignature(CFAllocatorRef alloc, const CFSocketSignature* sig, CFReadStreamRef *readStream, CFWriteStreamRef *writeStream) {
 215     createPair(alloc, NULL, 0, 0, sig, readStream, writeStream);
 216 }
 217
 218 __private_extern__ CFStreamError _CFStreamErrorFromError(CFErrorRef error) {
 219     CFStreamError result;
 220     Boolean canUpCall;
 221
 222     __CFSpinLock(&(CFNetworkSupport.lock));
 223     if (!__CFBitIsSet(CFNetworkSupport.flags, kTriedToLoad)) initializeCFNetworkSupport();
 224     canUpCall = (CFNetworkSupport._CFStreamErrorFromCFError != NULL);
 225     __CFSpinUnlock(&(CFNetworkSupport.lock));
 226
 227     if (canUpCall) {
 228         result = CFNETWORK_CALL(_CFStreamErrorFromCFError, (error));
 229     } else {
 230         CFStringRef domain = CFErrorGetDomain(error);
 231         if (CFEqual(domain, kCFErrorDomainPOSIX)) {
 232             result.domain = kCFStreamErrorDomainPOSIX;
 233         } else if (CFEqual(domain, kCFErrorDomainOSStatus)) {
 234             result.domain = kCFStreamErrorDomainMacOSStatus;
 235         } else if (CFEqual(domain, kCFErrorDomainMach)) {
 236             result.domain = 11; // kCFStreamErrorDomainMach, but that symbol is in CFNetwork
 237         } else {
 238             result.domain = kCFStreamErrorDomainCustom;
 239         }
 240         result.error = CFErrorGetCode(error);
 241     }
 242     return result;
 243 }
 244
 245 __private_extern__ CFErrorRef _CFErrorFromStreamError(CFAllocatorRef alloc, CFStreamError *streamError) {
 246     CFErrorRef result;
 247     Boolean canUpCall;
 248
 249     __CFSpinLock(&(CFNetworkSupport.lock));
 250     if (!__CFBitIsSet(CFNetworkSupport.flags, kTriedToLoad)) initializeCFNetworkSupport();
 251     canUpCall = (CFNetworkSupport._CFErrorCreateWithStreamError != NULL);
 252     __CFSpinUnlock(&(CFNetworkSupport.lock));
 253
 254     if (canUpCall) {
 255         result = CFNETWORK_CALL(_CFErrorCreateWithStreamError, (alloc, streamError));
 256     } else {
 257         if (streamError->domain == kCFStreamErrorDomainPOSIX) {
 258             return CFErrorCreate(alloc, kCFErrorDomainPOSIX, streamError->error, NULL);
 259         } else if (streamError->domain == kCFStreamErrorDomainMacOSStatus) {
 260             return CFErrorCreate(alloc, kCFErrorDomainOSStatus, streamError->error, NULL);
 261         } else {
 262             CFStringRef key = CFSTR("CFStreamErrorDomainKey");
 263             CFNumberRef value = CFNumberCreate(alloc, kCFNumberCFIndexType, &streamError->domain);
 264             CFDictionaryRef dict = CFDictionaryCreate(alloc, (const void **)(&key), (const void **)(&value), 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 265             result = CFErrorCreate(alloc, CFSTR("BogusCFStreamErrorCompatibilityDomain"), streamError->error, dict);
 266             CFRelease(value);
 267             CFRelease(dict);
 268         }
 269     }
 270     return result;
 271 }