CFPlatform.c

   1 /*
   2  * Copyright (c) 2014 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
  24 /*      CFPlatform.c
  25         Copyright (c) 1999-2013, Apple Inc. All rights reserved.
  26         Responsibility: Tony Parker
  27 */
  28
  29 #include "CFInternal.h"
  30 #include <CoreFoundation/CFPriv.h>
  31 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
  32     #include <stdlib.h>
  33     #include <sys/stat.h>
  34     #include <string.h>
  35     #include <unistd.h>
  36     #include <fcntl.h>
  37     #include <pwd.h>
  38     #include <crt_externs.h>
  39     #include <mach-o/dyld.h>
  40     #include <pthread/tsd_private.h>
  41 #endif
  42
  43 #if DEPLOYMENT_TARGET_WINDOWS
  44 #include <shellapi.h>
  45 #include <shlobj.h>
  46 #include <WinIoCtl.h>
  47
  48 #define getcwd _NS_getcwd
  49
  50 #endif
  51
  52 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_WINDOWS
  53 #define kCFPlatformInterfaceStringEncoding      kCFStringEncodingUTF8
  54 #else
  55 #define kCFPlatformInterfaceStringEncoding      CFStringGetSystemEncoding()
  56 #endif
  57
  58 extern void __CFGetUGIDs(uid_t *euid, gid_t *egid);
  59
  60 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
  61 // CoreGraphics and LaunchServices are only projects (1 Dec 2006) that use these
  62 char **_CFArgv(void) { return *_NSGetArgv(); }
  63 int _CFArgc(void) { return *_NSGetArgc(); }
  64 #endif
  65
  66
  67 CF_PRIVATE Boolean _CFGetCurrentDirectory(char *path, int maxlen) {
  68     return getcwd(path, maxlen) != NULL;
  69 }
  70
  71 #if DEPLOYMENT_TARGET_WINDOWS
  72 // Returns the path to the CF DLL, which we can then use to find resources like char sets
  73 bool bDllPathCached = false;
  74 CF_PRIVATE const wchar_t *_CFDLLPath(void) {
  75     static wchar_t cachedPath[MAX_PATH+1];
  76
  77     if (!bDllPathCached) {
  78 #ifdef _DEBUG
  79         // might be nice to get this from the project file at some point
  80         wchar_t *DLLFileName = L"CoreFoundation_debug.dll";
  81 #else
  82         wchar_t *DLLFileName = L"CoreFoundation.dll";
  83 #endif
  84         HMODULE ourModule = GetModuleHandleW(DLLFileName);
  85
  86         CFAssert(ourModule, __kCFLogAssertion, "GetModuleHandle failed");
  87
  88         DWORD wResult = GetModuleFileNameW(ourModule, cachedPath, MAX_PATH+1);
  89         CFAssert1(wResult > 0, __kCFLogAssertion, "GetModuleFileName failed: %d", GetLastError());
  90         CFAssert1(wResult < MAX_PATH+1, __kCFLogAssertion, "GetModuleFileName result truncated: %s", cachedPath);
  91
  92         // strip off last component, the DLL name
  93         CFIndex idx;
  94         for (idx = wResult - 1; idx; idx--) {
  95             if ('\\' == cachedPath[idx]) {
  96                 cachedPath[idx] = '\0';
  97                 break;
  98             }
  99         }
 100         bDllPathCached = true;
 101     }
 102     return cachedPath;
 103 }
 104 #endif
 105
 106 static const char *__CFProcessPath = NULL;
 107 static const char *__CFprogname = NULL;
 108
 109 const char **_CFGetProgname(void) {
 110     if (!__CFprogname)
 111         _CFProcessPath();               // sets up __CFprogname as a side-effect
 112     return &__CFprogname;
 113 }
 114
 115 const char **_CFGetProcessPath(void) {
 116     if (!__CFProcessPath)
 117         _CFProcessPath();               // sets up __CFProcessPath as a side-effect
 118     return &__CFProcessPath;
 119 }
 120
 121 #if DEPLOYMENT_TARGET_WINDOWS
 122 const char *_CFProcessPath(void) {
 123     if (__CFProcessPath) return __CFProcessPath;
 124     wchar_t buf[CFMaxPathSize] = {0};
 125     DWORD rlen = GetModuleFileNameW(NULL, buf, sizeof(buf) / sizeof(buf[0]));
 126     if (0 < rlen) {
 127         char asciiBuf[CFMaxPathSize] = {0};
 128         int res = WideCharToMultiByte(CP_UTF8, 0, buf, rlen, asciiBuf, sizeof(asciiBuf) / sizeof(asciiBuf[0]), NULL, NULL);
 129         if (0 < res) {
 130             __CFProcessPath = strdup(asciiBuf);
 131             __CFprogname = strrchr(__CFProcessPath, PATH_SEP);
 132             __CFprogname = (__CFprogname ? __CFprogname + 1 : __CFProcessPath);
 133         }
 134     }
 135     if (!__CFProcessPath) {
 136         __CFProcessPath = "";
 137         __CFprogname = __CFProcessPath;
 138     }
 139     return __CFProcessPath;
 140 }
 141 #endif
 142
 143 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 144 const char *_CFProcessPath(void) {
 145     if (__CFProcessPath) return __CFProcessPath;
 146 #if DEPLOYMENT_TARGET_MACOSX
 147     if (!issetugid()) {
 148         const char *path = (char *)__CFgetenv("CFProcessPath");
 149         if (path) {
 150             __CFProcessPath = strdup(path);
 151             __CFprogname = strrchr(__CFProcessPath, PATH_SEP);
 152             __CFprogname = (__CFprogname ? __CFprogname + 1 : __CFProcessPath);
 153             return __CFProcessPath;
 154         }
 155     }
 156 #endif
 157     uint32_t size = CFMaxPathSize;
 158     char buffer[size];
 159     if (0 == _NSGetExecutablePath(buffer, &size)) {
 160         __CFProcessPath = strdup(buffer);
 161         __CFprogname = strrchr(__CFProcessPath, PATH_SEP);
 162         __CFprogname = (__CFprogname ? __CFprogname + 1 : __CFProcessPath);
 163     }
 164     if (!__CFProcessPath) {
 165         __CFProcessPath = "";
 166         __CFprogname = __CFProcessPath;
 167     }
 168     return __CFProcessPath;
 169 }
 170 #endif
 171
 172 #if DEPLOYMENT_TARGET_LINUX
 173 #include <unistd.h>
 174
 175 const char *_CFProcessPath(void) {
 176     if (__CFProcessPath) return __CFProcessPath;
 177     char buf[CFMaxPathSize + 1];
 178
 179     ssize_t res = readlink("/proc/self/exe", buf, CFMaxPathSize);
 180     if (res > 0) {
 181         // null terminate, readlink does not
 182         buf[res] = 0;
 183         __CFProcessPath = strdup(buf);
 184         __CFprogname = strrchr(__CFProcessPath, PATH_SEP);
 185         __CFprogname = (__CFprogname ? __CFprogname + 1 : __CFProcessPath);
 186     } else {
 187         __CFProcessPath = "";
 188         __CFprogname = __CFProcessPath;
 189     }
 190     return __CFProcessPath;
 191 }
 192 #endif
 193
 194 CF_PRIVATE CFStringRef _CFProcessNameString(void) {
 195     static CFStringRef __CFProcessNameString = NULL;
 196     if (!__CFProcessNameString) {
 197         const char *processName = *_CFGetProgname();
 198         if (!processName) processName = "";
 199         CFStringRef newStr = CFStringCreateWithCString(kCFAllocatorSystemDefault, processName, kCFPlatformInterfaceStringEncoding);
 200         if (!OSAtomicCompareAndSwapPtrBarrier(NULL, (void *) newStr, (void * volatile *)& __CFProcessNameString)) {
 201             CFRelease(newStr);    // someone else made the assignment, so just release the extra string.
 202         }
 203     }
 204     return __CFProcessNameString;
 205 }
 206
 207
 208 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
 209
 210 #include <pwd.h>
 211 #include <sys/param.h>
 212
 213 // Set the fallBackToHome parameter to true if we should fall back to the HOME environment variable if all else fails. Otherwise return NULL.
 214 static CFURLRef _CFCopyHomeDirURLForUser(struct passwd *upwd, bool fallBackToHome) {
 215     const char *fixedHomePath = issetugid() ? NULL : __CFgetenv("CFFIXED_USER_HOME");
 216     const char *homePath = NULL;
 217
 218     // Calculate the home directory we will use
 219     // First try CFFIXED_USER_HOME (only if not setugid), then fall back to the upwd, then fall back to HOME environment variable
 220     CFURLRef home = NULL;
 221     if (!issetugid() && fixedHomePath) home = CFURLCreateFromFileSystemRepresentation(kCFAllocatorSystemDefault, (uint8_t *)fixedHomePath, strlen(fixedHomePath), true);
 222     if (!home && upwd && upwd->pw_dir) home = CFURLCreateFromFileSystemRepresentation(kCFAllocatorSystemDefault, (uint8_t *)upwd->pw_dir, strlen(upwd->pw_dir), true);
 223     if (fallBackToHome && !home) homePath = __CFgetenv("HOME");
 224     if (fallBackToHome && !home && homePath) home = CFURLCreateFromFileSystemRepresentation(kCFAllocatorSystemDefault, (uint8_t *)homePath, strlen(homePath), true);
 225
 226     return home;
 227 }
 228
 229 #endif
 230
 231
 232 #define CFMaxHostNameLength     256
 233 #define CFMaxHostNameSize       (CFMaxHostNameLength+1)
 234
 235 CF_PRIVATE CFStringRef _CFStringCreateHostName(void) {
 236     char myName[CFMaxHostNameSize];
 237
 238     // return @"" instead of nil a la CFUserName() and Ali Ozer
 239     if (0 != gethostname(myName, CFMaxHostNameSize)) myName[0] = '\0';
 240     return CFStringCreateWithCString(kCFAllocatorSystemDefault, myName, kCFPlatformInterfaceStringEncoding);
 241 }
 242
 243 /* These are sanitized versions of the above functions. We might want to eliminate the above ones someday.
 244    These can return NULL.
 245 */
 246 CF_EXPORT CFStringRef CFGetUserName(void) {
 247     return CFCopyUserName();
 248 }
 249
 250 CF_EXPORT CFStringRef CFCopyUserName(void) {
 251     CFStringRef result = NULL;
 252 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
 253     uid_t euid;
 254     __CFGetUGIDs(&euid, NULL);
 255     struct passwd *upwd = getpwuid(euid ? euid : getuid());
 256     if (upwd && upwd->pw_name) {
 257         result = CFStringCreateWithCString(kCFAllocatorSystemDefault, upwd->pw_name, kCFPlatformInterfaceStringEncoding);
 258     } else {
 259         const char *cuser = __CFgetenv("USER");
 260         if (cuser) {
 261             result = CFStringCreateWithCString(kCFAllocatorSystemDefault, cuser, kCFPlatformInterfaceStringEncoding);
 262         }
 263     }
 264 #elif DEPLOYMENT_TARGET_WINDOWS
 265         wchar_t username[1040];
 266         DWORD size = 1040;
 267         username[0] = 0;
 268         if (GetUserNameW(username, &size)) {
 269             // discount the extra NULL by decrementing the size
 270             result = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (const UniChar *)username, size - 1);
 271         } else {
 272             const char *cname = __CFgetenv("USERNAME");
 273             if (cname) {
 274                 result = CFStringCreateWithCString(kCFAllocatorSystemDefault, cname, kCFPlatformInterfaceStringEncoding);
 275             }
 276         }
 277 #else
 278 #error Dont know how to compute user name on this platform
 279 #endif
 280     if (!result)
 281         result = (CFStringRef)CFRetain(CFSTR(""));
 282     return result;
 283 }
 284
 285 CFURLRef CFCopyHomeDirectoryURL(void) {
 286 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
 287     uid_t euid;
 288     __CFGetUGIDs(&euid, NULL);
 289     struct passwd *upwd = getpwuid(euid ? euid : getuid());
 290     return _CFCopyHomeDirURLForUser(upwd, true);
 291 #elif DEPLOYMENT_TARGET_WINDOWS
 292     CFURLRef retVal = NULL;
 293     CFIndex len = 0;
 294     CFStringRef str = NULL;
 295
 296     UniChar pathChars[MAX_PATH];
 297     if (S_OK == SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, SHGFP_TYPE_CURRENT, (wchar_t *)pathChars)) {
 298         len = (CFIndex)wcslen((wchar_t *)pathChars);
 299         str = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, pathChars, len);
 300         retVal = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, str, kCFURLWindowsPathStyle, true);
 301         CFRelease(str);
 302     }
 303
 304     if (!retVal) {
 305         // Fall back to environment variable, but this will not be unicode compatible
 306         const char *cpath = __CFgetenv("HOMEPATH");
 307         const char *cdrive = __CFgetenv("HOMEDRIVE");
 308         if (cdrive && cpath) {
 309             char fullPath[CFMaxPathSize];
 310             strlcpy(fullPath, cdrive, sizeof(fullPath));
 311             strlcat(fullPath, cpath, sizeof(fullPath));
 312             str = CFStringCreateWithCString(kCFAllocatorSystemDefault, fullPath, kCFPlatformInterfaceStringEncoding);
 313             retVal = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, str, kCFURLWindowsPathStyle, true);
 314             CFRelease(str);
 315         }
 316     }
 317
 318     if (!retVal) {
 319         // Last resort: We have to get "some" directory location, so fall-back to the processes current directory.
 320         UniChar currDir[MAX_PATH];
 321         DWORD dwChars = GetCurrentDirectoryW(MAX_PATH + 1, (wchar_t *)currDir);
 322         if (dwChars > 0) {
 323             len = (CFIndex)wcslen((wchar_t *)currDir);
 324             str = CFStringCreateWithCharacters(kCFAllocatorDefault, currDir, len);
 325             retVal = CFURLCreateWithFileSystemPath(NULL, str, kCFURLWindowsPathStyle, true);
 326             CFRelease(str);
 327         }
 328     }
 329
 330     // We could do more here (as in KB Article Q101507). If that article is to be believed, we should only run into this case on Win95, or through user error.
 331     CFStringRef testPath = CFURLCopyFileSystemPath(retVal, kCFURLWindowsPathStyle);
 332     if (CFStringGetLength(testPath) == 0) {
 333         CFRelease(retVal);
 334         retVal = NULL;
 335     }
 336     if (testPath) CFRelease(testPath);
 337
 338     return retVal;
 339 #else
 340 #error Dont know how to compute users home directories on this platform
 341 #endif
 342 }
 343
 344 CF_EXPORT CFURLRef CFCopyHomeDirectoryURLForUser(CFStringRef uName) {
 345 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
 346     if (!uName) {
 347         uid_t euid;
 348         __CFGetUGIDs(&euid, NULL);
 349         struct passwd *upwd = getpwuid(euid ? euid : getuid());
 350         return _CFCopyHomeDirURLForUser(upwd, true);
 351     } else {
 352         struct passwd *upwd = NULL;
 353         char buf[128], *user;
 354         SInt32 len = CFStringGetLength(uName), size = CFStringGetMaximumSizeForEncoding(len, kCFPlatformInterfaceStringEncoding);
 355         CFIndex usedSize;
 356         if (size < 127) {
 357             user = buf;
 358         } else {
 359             user = CFAllocatorAllocate(kCFAllocatorSystemDefault, size+1, 0);
 360         }
 361         if (CFStringGetBytes(uName, CFRangeMake(0, len), kCFPlatformInterfaceStringEncoding, 0, true, (uint8_t *)user, size, &usedSize) == len) {
 362             user[usedSize] = '\0';
 363             upwd = getpwnam(user);
 364         }
 365         if (buf != user) {
 366             CFAllocatorDeallocate(kCFAllocatorSystemDefault, user);
 367         }
 368         return _CFCopyHomeDirURLForUser(upwd, false);
 369     }
 370 #elif DEPLOYMENT_TARGET_WINDOWS
 371     // This code can only get the directory for the current user
 372     CFStringRef userName = uName ? CFCopyUserName() : NULL;
 373     if (uName && !CFEqual(uName, userName)) {
 374         CFLog(kCFLogLevelError, CFSTR("CFCopyHomeDirectoryURLForUser(): Unable to get home directory for other user"));
 375         if (userName) CFRelease(userName);
 376         return NULL;
 377     }
 378     if (userName) CFRelease(userName);
 379     return CFCopyHomeDirectoryURL();
 380 #else
 381 #error Dont know how to compute users home directories on this platform
 382 #endif
 383 }
 384
 385
 386 #undef CFMaxHostNameLength
 387 #undef CFMaxHostNameSize
 388
 389 #if DEPLOYMENT_TARGET_WINDOWS
 390 CF_INLINE CFIndex strlen_UniChar(const UniChar* p) {
 391         CFIndex result = 0;
 392         while ((*p++) != 0)
 393                 ++result;
 394         return result;
 395 }
 396
 397 //#include <shfolder.h>
 398 /*
 399  * _CFCreateApplicationRepositoryPath returns the path to the application's
 400  * repository in a CFMutableStringRef. The path returned will be:
 401  *     <nFolder_path>\Apple Computer\<bundle_name>\
 402  * or if the bundle name cannot be obtained:
 403  *     <nFolder_path>\Apple Computer\
 404  * where nFolder_path is obtained by calling SHGetFolderPath with nFolder
 405  * (for example, with CSIDL_APPDATA or CSIDL_LOCAL_APPDATA).
 406  *
 407  * The CFMutableStringRef result must be released by the caller.
 408  *
 409  * If anything fails along the way, the result will be NULL.
 410  */
 411 CF_EXPORT CFMutableStringRef _CFCreateApplicationRepositoryPath(CFAllocatorRef alloc, int nFolder) {
 412     CFMutableStringRef result = NULL;
 413     UniChar szPath[MAX_PATH];
 414
 415     // get the current path to the data repository: CSIDL_APPDATA (roaming) or CSIDL_LOCAL_APPDATA (nonroaming)
 416     if (S_OK == SHGetFolderPathW(NULL, nFolder, NULL, 0, (wchar_t *) szPath)) {
 417         CFStringRef directoryPath;
 418
 419         // make it a CFString
 420         directoryPath = CFStringCreateWithCharacters(alloc, szPath, strlen_UniChar(szPath));
 421         if (directoryPath) {
 422             CFBundleRef bundle;
 423             CFStringRef bundleName;
 424             CFStringRef completePath;
 425
 426             // attempt to get the bundle name
 427             bundle = CFBundleGetMainBundle();
 428             if (bundle) {
 429                 bundleName = (CFStringRef)CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleNameKey);
 430             }
 431             else {
 432                 bundleName = NULL;
 433             }
 434
 435             if (bundleName) {
 436                 // the path will be "<directoryPath>\Apple Computer\<bundleName>\" if there is a bundle name
 437                 completePath = CFStringCreateWithFormat(alloc, NULL, CFSTR("%@\\Apple Computer\\%@\\"), directoryPath, bundleName);
 438             }
 439             else {
 440                 // or "<directoryPath>\Apple Computer\" if there is no bundle name.
 441                 completePath = CFStringCreateWithFormat(alloc, NULL, CFSTR("%@\\Apple Computer\\"), directoryPath);
 442             }
 443
 444             CFRelease(directoryPath);
 445
 446             // make a mutable copy to return
 447             if (completePath) {
 448                 result = CFStringCreateMutableCopy(alloc, 0, completePath);
 449                 CFRelease(completePath);
 450             }
 451         }
 452     }
 453
 454     return ( result );
 455 }
 456 #endif
 457
 458 #pragma mark -
 459 #pragma mark Thread Functions
 460
 461 #if DEPLOYMENT_TARGET_WINDOWS
 462
 463 // This code from here:
 464 // http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
 465
 466 const DWORD MS_VC_EXCEPTION=0x406D1388;
 467 #pragma pack(push,8)
 468 typedef struct tagTHREADNAME_INFO
 469 {
 470     DWORD dwType; // Must be 0x1000.
 471     LPCSTR szName; // Pointer to name (in user addr space).
 472     DWORD dwThreadID; // Thread ID (-1=caller thread).
 473     DWORD dwFlags; // Reserved for future use, must be zero.
 474 } THREADNAME_INFO;
 475 #pragma pack(pop)
 476
 477 CF_EXPORT void _NS_pthread_setname_np(const char *name) {
 478     THREADNAME_INFO info;
 479     info.dwType = 0x1000;
 480     info.szName = name;
 481     info.dwThreadID = GetCurrentThreadId();
 482     info.dwFlags = 0;
 483
 484     __try
 485     {
 486         RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
 487     }
 488     __except(EXCEPTION_EXECUTE_HANDLER)
 489     {
 490     }
 491 }
 492
 493 static pthread_t __initialPthread = { NULL, 0 };
 494
 495 CF_EXPORT int _NS_pthread_main_np() {
 496     pthread_t me = pthread_self();
 497     if (NULL == __initialPthread.p) {
 498         __initialPthread.p = me.p;
 499         __initialPthread.x = me.x;
 500     }
 501     return (pthread_equal(__initialPthread, me));
 502 }
 503
 504 #endif
 505
 506 #pragma mark -
 507 #pragma mark Thread Local Data
 508
 509 // If slot >= CF_TSD_MAX_SLOTS, the SPI functions will crash at NULL + slot address.
 510 // If thread data has been torn down, these functions should crash on CF_TSD_BAD_PTR + slot address.
 511 #define CF_TSD_MAX_SLOTS 70
 512
 513 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 514 static const unsigned long CF_TSD_KEY = __PTK_FRAMEWORK_COREFOUNDATION_KEY5;
 515 #endif
 516
 517 // Windows and Linux, not sure how many times the destructor could get called; CF_TSD_MAX_DESTRUCTOR_CALLS could be 1
 518
 519 #define CF_TSD_BAD_PTR ((void *)0x1000)
 520
 521 typedef void (*tsdDestructor)(void *);
 522
 523 // Data structure to hold TSD data, cleanup functions for each
 524 typedef struct __CFTSDTable {
 525     uint32_t destructorCount;
 526     uintptr_t data[CF_TSD_MAX_SLOTS];
 527     tsdDestructor destructors[CF_TSD_MAX_SLOTS];
 528 } __CFTSDTable;
 529
 530 static void __CFTSDFinalize(void *arg);
 531
 532 #if DEPLOYMENT_TARGET_WINDOWS
 533
 534 static DWORD __CFTSDIndexKey = 0xFFFFFFFF;
 535
 536 // Called from CFRuntime's startup code, on Windows only
 537 CF_PRIVATE void __CFTSDWindowsInitialize() {
 538     __CFTSDIndexKey = TlsAlloc();
 539 }
 540
 541 // Called from CFRuntime's cleanup code, on Windows only
 542 CF_PRIVATE void __CFTSDWindowsCleanup() {
 543     TlsFree(__CFTSDIndexKey);
 544 }
 545
 546 // Called for each thread as it exits, on Windows only
 547 CF_PRIVATE void __CFFinalizeWindowsThreadData() {
 548     // Normally, this should call the finalizer several times to emulate the behavior of pthreads on Windows. However, a few bugs keep us from doing this:
 549     // <rdar://problem/8989063> REGRESSION(CF-610-CF-611): Crash closing Safari in BonjourDB destructor (Windows)
 550     // <rdar://problem/9326814> SyncUIHandler crashes after conflict is resolved and we do SyncNow
 551     //  and a bug in dispatch keeps us from using pthreadsWin32 directly, because it does not deal with the case of a dispatch_async happening during process exit (it attempts to create a thread, but that is illegal on Win32 and causes a hang).
 552     // So instead we just finalize once, which is the behavior pre-Airwolf anyway
 553     __CFTSDFinalize(TlsGetValue(__CFTSDIndexKey));
 554 }
 555
 556 #endif
 557
 558 #if DEPLOYMENT_TARGET_LINUX
 559
 560 static pthread_key_t __CFTSDIndexKey;
 561
 562 // Called from CFRuntime's startup code, on Linux only
 563 CF_PRIVATE void __CFTSDLinuxInitialize() {
 564     (void)pthread_key_create(&__CFTSDIndexKey, __CFTSDFinalize);
 565 }
 566
 567 #endif
 568
 569 static void __CFTSDSetSpecific(void *arg) {
 570 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 571     _pthread_setspecific_direct(CF_TSD_KEY, arg);
 572 #elif DEPLOYMENT_TARGET_LINUX
 573     pthread_setspecific(__CFTSDIndexKey, arg);
 574 #elif DEPLOYMENT_TARGET_WINDOWS
 575     TlsSetValue(__CFTSDIndexKey, arg);
 576 #endif
 577 }
 578
 579 static void *__CFTSDGetSpecific() {
 580 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 581     return _pthread_getspecific_direct(CF_TSD_KEY);
 582 #elif DEPLOYMENT_TARGET_LINUX
 583     return pthread_getspecific(__CFTSDIndexKey);
 584 #elif DEPLOYMENT_TARGET_WINDOWS
 585     return TlsGetValue(__CFTSDIndexKey);
 586 #endif
 587 }
 588
 589 static void __CFTSDFinalize(void *arg) {
 590     // Set our TSD so we're called again by pthreads. It will call the destructor PTHREAD_DESTRUCTOR_ITERATIONS times as long as a value is set in the thread specific data. We handle each case below.
 591     __CFTSDSetSpecific(arg);
 592
 593     if (!arg || arg == CF_TSD_BAD_PTR) {
 594         // We've already been destroyed. The call above set the bad pointer again. Now we just return.
 595         return;
 596     }
 597
 598     __CFTSDTable *table = (__CFTSDTable *)arg;
 599     table->destructorCount++;
 600
 601     // On first calls invoke destructor. Later we destroy the data.
 602     // Note that invocation of the destructor may cause a value to be set again in the per-thread data slots. The destructor count and destructors are preserved.
 603     // This logic is basically the same as what pthreads does. We just skip the 'created' flag.
 604     for (int32_t i = 0; i < CF_TSD_MAX_SLOTS; i++) {
 605         if (table->data[i] && table->destructors[i]) {
 606             uintptr_t old = table->data[i];
 607             table->data[i] = (uintptr_t)NULL;
 608             table->destructors[i]((void *)(old));
 609         }
 610     }
 611
 612     if (table->destructorCount == PTHREAD_DESTRUCTOR_ITERATIONS - 1) {    // On PTHREAD_DESTRUCTOR_ITERATIONS-1 call, destroy our data
 613         free(table);
 614
 615         // Now if the destructor is called again we will take the shortcut at the beginning of this function.
 616         __CFTSDSetSpecific(CF_TSD_BAD_PTR);
 617         return;
 618     }
 619 }
 620
 621 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 622 extern int pthread_key_init_np(int, void (*)(void *));
 623 #endif
 624
 625 // Get or initialize a thread local storage. It is created on demand.
 626 static __CFTSDTable *__CFTSDGetTable() {
 627     __CFTSDTable *table = (__CFTSDTable *)__CFTSDGetSpecific();
 628     // Make sure we're not setting data again after destruction.
 629     if (table == CF_TSD_BAD_PTR) {
 630         return NULL;
 631     }
 632     // Create table on demand
 633     if (!table) {
 634         // This memory is freed in the finalize function
 635         table = (__CFTSDTable *)calloc(1, sizeof(__CFTSDTable));
 636         // Windows and Linux have created the table already, we need to initialize it here for other platforms. On Windows, the cleanup function is called by DllMain when a thread exits. On Linux the destructor is set at init time.
 637 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 638         pthread_key_init_np(CF_TSD_KEY, __CFTSDFinalize);
 639 #endif
 640         __CFTSDSetSpecific(table);
 641     }
 642
 643     return table;
 644 }
 645
 646
 647 // For the use of CF and Foundation only
 648 CF_EXPORT void *_CFGetTSD(uint32_t slot) {
 649     if (slot > CF_TSD_MAX_SLOTS) {
 650         _CFLogSimple(kCFLogLevelError, "Error: TSD slot %d out of range (get)", slot);
 651         HALT;
 652     }
 653     __CFTSDTable *table = __CFTSDGetTable();
 654     if (!table) {
 655         // Someone is getting TSD during thread destruction. The table is gone, so we can't get any data anymore.
 656         _CFLogSimple(kCFLogLevelWarning, "Warning: TSD slot %d retrieved but the thread data has already been torn down.", slot);
 657         return NULL;
 658     }
 659     uintptr_t *slots = (uintptr_t *)(table->data);
 660     return (void *)slots[slot];
 661 }
 662
 663 // For the use of CF and Foundation only
 664 CF_EXPORT void *_CFSetTSD(uint32_t slot, void *newVal, tsdDestructor destructor) {
 665     if (slot > CF_TSD_MAX_SLOTS) {
 666         _CFLogSimple(kCFLogLevelError, "Error: TSD slot %d out of range (set)", slot);
 667         HALT;
 668     }
 669     __CFTSDTable *table = __CFTSDGetTable();
 670     if (!table) {
 671         // Someone is setting TSD during thread destruction. The table is gone, so we can't get any data anymore.
 672         _CFLogSimple(kCFLogLevelWarning, "Warning: TSD slot %d set but the thread data has already been torn down.", slot);
 673         return NULL;
 674     }
 675
 676     void *oldVal = (void *)table->data[slot];
 677
 678     table->data[slot] = (uintptr_t)newVal;
 679     table->destructors[slot] = destructor;
 680
 681     return oldVal;
 682 }
 683
 684
 685 #pragma mark -
 686 #pragma mark Windows Wide to UTF8 and UTF8 to Wide
 687
 688 #if DEPLOYMENT_TARGET_WINDOWS
 689 /* On Windows, we want to use UTF-16LE for path names to get full unicode support. Internally, however, everything remains in UTF-8 representation. These helper functions stand between CF and the Microsoft CRT to ensure that we are using the right representation on both sides. */
 690
 691 #include <sys/stat.h>
 692 #include <share.h>
 693
 694 // Creates a buffer of wchar_t to hold a UTF16LE version of the UTF8 str passed in. Caller must free the buffer when done. If resultLen is non-NULL, it is filled out with the number of characters in the string.
 695 static wchar_t *createWideFileSystemRepresentation(const char *str, CFIndex *resultLen) {
 696     // Get the real length of the string in UTF16 characters
 697     CFStringRef cfStr = CFStringCreateWithCString(kCFAllocatorSystemDefault, str, kCFStringEncodingUTF8);
 698     CFIndex strLen = CFStringGetLength(cfStr);
 699
 700     // Allocate a wide buffer to hold the converted string, including space for a NULL terminator
 701     wchar_t *wideBuf = (wchar_t *)malloc((strLen + 1) * sizeof(wchar_t));
 702
 703     // Copy the string into the buffer and terminate
 704     CFStringGetCharacters(cfStr, CFRangeMake(0, strLen), (UniChar *)wideBuf);
 705     wideBuf[strLen] = 0;
 706
 707     CFRelease(cfStr);
 708     if (resultLen) *resultLen = strLen;
 709     return wideBuf;
 710 }
 711
 712 // Copies a UTF16 buffer into a supplied UTF8 buffer.
 713 static void copyToNarrowFileSystemRepresentation(const wchar_t *wide, CFIndex dstBufSize, char *dstbuf) {
 714     // Get the real length of the wide string in UTF8 characters
 715     CFStringRef cfStr = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (const UniChar *)wide, wcslen(wide));
 716     CFIndex strLen = CFStringGetLength(cfStr);
 717     CFIndex bytesUsed;
 718
 719     // Copy the wide string into the buffer and terminate
 720     CFStringGetBytes(cfStr, CFRangeMake(0, strLen), kCFStringEncodingUTF8, 0, false, (uint8_t *)dstbuf, dstBufSize, &bytesUsed);
 721     dstbuf[bytesUsed] = 0;
 722
 723     CFRelease(cfStr);
 724 }
 725
 726 CF_EXPORT int _NS_stat(const char *name, struct _stat *st) {
 727     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 728     int res = _wstat(wide, st);
 729     free(wide);
 730     return res;
 731 }
 732
 733 CF_EXPORT int _NS_mkdir(const char *name) {
 734     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 735     int res = _wmkdir(wide);
 736     free(wide);
 737     return res;
 738 }
 739
 740 CF_EXPORT int _NS_rmdir(const char *name) {
 741     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 742     int res = _wrmdir(wide);
 743     free(wide);
 744     return res;
 745 }
 746
 747 CF_EXPORT int _NS_chmod(const char *name, int mode) {
 748     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 749
 750     // Convert mode
 751     int newMode = 0;
 752     if (mode | 0400) newMode |= _S_IREAD;
 753     if (mode | 0200) newMode |= _S_IWRITE;
 754     if (mode | 0100) newMode |= _S_IEXEC;
 755
 756     int res = _wchmod(wide, newMode);
 757     free(wide);
 758     return res;
 759 }
 760
 761 CF_EXPORT int _NS_unlink(const char *name) {
 762     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 763     int res = _wunlink(wide);
 764     free(wide);
 765     return res;
 766 }
 767
 768 // Warning: this doesn't support dstbuf as null even though 'getcwd' does
 769 CF_EXPORT char *_NS_getcwd(char *dstbuf, size_t size) {
 770     if (!dstbuf) {
 771         CFLog(kCFLogLevelWarning, CFSTR("CFPlatform: getcwd called with null buffer"));
 772         return 0;
 773     }
 774
 775     wchar_t *buf = _wgetcwd(NULL, 0);
 776     if (!buf) {
 777         return NULL;
 778     }
 779
 780     // Convert result to UTF8
 781     copyToNarrowFileSystemRepresentation(buf, (CFIndex)size, dstbuf);
 782     free(buf);
 783     return dstbuf;
 784 }
 785
 786 CF_EXPORT char *_NS_getenv(const char *name) {
 787     // todo: wide getenv
 788     // We have to be careful what happens here, because getenv is called during cf initialization, and things like cfstring may not be working yet
 789     return getenv(name);
 790 }
 791
 792 CF_EXPORT int _NS_rename(const char *oldName, const char *newName) {
 793     wchar_t *oldWide = createWideFileSystemRepresentation(oldName, NULL);
 794     wchar_t *newWide = createWideFileSystemRepresentation(newName, NULL);
 795     // _wrename on Windows does not behave exactly as rename() on Mac OS -- if the file exists, the Windows one will fail whereas the Mac OS version will replace
 796     // To simulate the Mac OS behavior, we use the Win32 API then fill out errno if something goes wrong
 797     BOOL winRes = MoveFileExW(oldWide, newWide, MOVEFILE_REPLACE_EXISTING);
 798     DWORD error = GetLastError();
 799     if (!winRes) {
 800             switch (error) {
 801             case ERROR_SUCCESS:
 802                 errno = 0;
 803                 break;
 804             case ERROR_FILE_NOT_FOUND:
 805             case ERROR_PATH_NOT_FOUND:
 806             case ERROR_OPEN_FAILED:
 807                 errno = ENOENT;
 808                 break;
 809             case ERROR_ACCESS_DENIED:
 810                 errno = EACCES;
 811                 break;
 812             default:
 813                 errno = error;
 814         }
 815     }
 816     free(oldWide);
 817     free(newWide);
 818     return (winRes ? 0 : -1);
 819 }
 820
 821 CF_EXPORT int _NS_open(const char *name, int oflag, int pmode) {
 822     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 823     int fd;
 824     _wsopen_s(&fd, wide, oflag, _SH_DENYNO, _S_IREAD | _S_IWRITE);
 825     free(wide);
 826     return fd;
 827 }
 828
 829 CF_EXPORT int _NS_chdir(const char *name) {
 830     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 831     int res = _wchdir(wide);
 832     free(wide);
 833     return res;
 834 }
 835
 836 CF_EXPORT int _NS_access(const char *name, int amode) {
 837     // execute is always true
 838     if (amode == 1) return 0;
 839
 840     wchar_t *wide = createWideFileSystemRepresentation(name, NULL);
 841     // we only care about the read-only (04) and write-only (02) bits, so mask octal 06
 842     int res = _waccess(wide, amode & 06);
 843     free(wide);
 844     return res;
 845 }
 846
 847 // This is a bit different than the standard 'mkstemp', because the size parameter is needed so we know the size of the UTF8 buffer
 848 // Also, we don't avoid the race between creating a temporary file name and opening it on Windows like we do on Mac
 849 CF_EXPORT int _NS_mkstemp(char *name, int bufSize) {
 850     CFIndex nameLen;
 851     wchar_t *wide = createWideFileSystemRepresentation(name, &nameLen);
 852
 853     // First check to see if the directory that this new temporary file will be created in exists. If not, set errno to ENOTDIR. This mimics the behavior of mkstemp on MacOS more closely.
 854     // Look for the last '\' in the path
 855     wchar_t *lastSlash = wcsrchr(wide, '\\');
 856     if (!lastSlash) {
 857         free(wide);
 858         return -1;
 859     }
 860
 861     // Set the last slash to NULL temporarily and use it for _wstat
 862     *lastSlash = 0;
 863     struct _stat dirInfo;
 864     int res = _wstat(wide, &dirInfo);
 865     if (res < 0) {
 866         if (errno == ENOENT) {
 867             errno = ENOTDIR;
 868         }
 869         free(wide);
 870         return -1;
 871     }
 872     // Restore the last slash
 873     *lastSlash = '\\';
 874
 875     errno_t err = _wmktemp_s(wide, nameLen + 1);
 876     if (err != 0) {
 877         free(wide);
 878         return 0;
 879     }
 880
 881     int fd;
 882     _wsopen_s(&fd, wide, _O_RDWR | _O_CREAT | CF_OPENFLGS, _SH_DENYNO, _S_IREAD | _S_IWRITE);
 883
 884     // Convert the wide name back into the UTF8 buffer the caller supplied
 885     copyToNarrowFileSystemRepresentation(wide, bufSize, name);
 886     free(wide);
 887     return fd;
 888 }
 889
 890
 891 // Utilities to convert from a volume name to a drive letter
 892
 893 Boolean _isAFloppy(char driveLetter)
 894 {
 895     HANDLE h;
 896     TCHAR tsz[8];
 897     Boolean retval = false;
 898     int iDrive;
 899
 900     if (driveLetter >= 'a' && driveLetter <= 'z') {
 901         driveLetter = driveLetter - 'a' + 'A';
 902     }
 903
 904     if ((driveLetter < 'A') || (driveLetter > 'Z')) {
 905         // invalid driveLetter; I guess it's not a floppy...
 906         return false;
 907     }
 908
 909     iDrive = driveLetter - 'A' + 1;
 910
 911     // On Windows NT, use the technique described in the Knowledge Base article Q115828 and in the "FLOPPY" SDK sample.
 912     wsprintf(tsz, TEXT("\\\\.\\%c:"), TEXT('@') + iDrive);
 913     h = CreateFile(tsz, 0, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
 914     if (h != INVALID_HANDLE_VALUE)
 915     {
 916         DISK_GEOMETRY Geom[20];
 917         DWORD cb;
 918
 919         if (DeviceIoControl (h, IOCTL_DISK_GET_MEDIA_TYPES, 0, 0,
 920                              Geom, sizeof(Geom), &cb, 0)
 921             && cb > 0)
 922         {
 923             switch (Geom[0].MediaType)
 924             {
 925                 case F5_1Pt2_512: // 5.25 1.2MB floppy
 926                 case F5_360_512:  // 5.25 360K  floppy
 927                 case F5_320_512:  // 5.25 320K  floppy
 928                 case F5_320_1024: // 5.25 320K  floppy
 929                 case F5_180_512:  // 5.25 180K  floppy
 930                 case F5_160_512:  // 5.25 160K  floppy
 931                 case F3_1Pt44_512: // 3.5 1.44MB floppy
 932                 case F3_2Pt88_512: // 3.5 2.88MB floppy
 933                 case F3_20Pt8_512: // 3.5 20.8MB floppy
 934                 case F3_720_512:   // 3.5 720K   floppy
 935                     retval = true;
 936                     break;
 937             }
 938         }
 939
 940         CloseHandle(h);
 941     }
 942
 943     return retval;
 944 }
 945
 946
 947 extern CFStringRef CFCreateWindowsDrivePathFromVolumeName(CFStringRef volNameStr) {
 948     if (!volNameStr) return NULL;
 949
 950     // This code is designed to match as closely as possible code from QuickTime's library
 951     CFIndex strLen = CFStringGetLength(volNameStr);
 952     if (strLen == 0) {
 953         return NULL;
 954     }
 955
 956     // Get drive names
 957     long length, result;
 958     wchar_t *driveNames = NULL;
 959
 960     // Get the size of the buffer to store the list of drives
 961     length = GetLogicalDriveStringsW(0, 0);
 962     if (!length) {
 963         return NULL;
 964     }
 965
 966     driveNames = (wchar_t *)malloc((length + 1) * sizeof(wchar_t));
 967     result = GetLogicalDriveStringsW(length, driveNames);
 968
 969     if (!result || result > length) {
 970         free(driveNames);
 971         return NULL;
 972     }
 973
 974     // Get the volume name string into a wide buffer
 975     wchar_t *theVolumeName = (wchar_t *)malloc((strLen + 1) * sizeof(wchar_t));
 976     CFStringGetCharacters(volNameStr, CFRangeMake(0, strLen), (UniChar *)theVolumeName);
 977     theVolumeName[strLen] = 0;
 978
 979     // lowercase volume name
 980     _wcslwr(theVolumeName);
 981
 982     // Iterate through the drive names, looking for something that matches
 983     wchar_t *drivePtr = driveNames;
 984     CFStringRef drivePathResult = NULL;
 985
 986     while (*drivePtr) {
 987         _wcslwr(drivePtr);
 988
 989         if (!_isAFloppy((char)*drivePtr)) {
 990             UINT                oldErrorMode;
 991             DWORD               whoCares1, whoCares2;
 992             BOOL                getVolInfoSucceeded;
 993             UniChar             thisVolumeName[MAX_PATH];
 994
 995             // Convert this drive string into a volume name
 996             oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 997             getVolInfoSucceeded = GetVolumeInformationW(drivePtr, (LPWSTR)thisVolumeName, sizeof(thisVolumeName), NULL, &whoCares1, &whoCares2, NULL, 0);
 998             SetErrorMode(oldErrorMode);
 999
1000             if (getVolInfoSucceeded) {
1001                 _wcslwr((wchar_t *)thisVolumeName);
1002
1003                 // If the volume corresponding to this drive matches the input volume
1004                 // then this drive is the winner.
1005                 if (!wcscmp((const wchar_t *)thisVolumeName, theVolumeName) ||
1006                     (*thisVolumeName == 0x00 && (CFStringCompare(volNameStr, CFSTR("NONAME"), 0) == kCFCompareEqualTo))) {
1007                     drivePathResult = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (const UniChar *)drivePtr, wcslen(drivePtr));
1008                     break;
1009                 }
1010             }
1011         }
1012
1013         drivePtr += wcslen(drivePtr) + 1;
1014     }
1015
1016
1017     free(driveNames);
1018     free(theVolumeName);
1019     return drivePathResult;
1020 }
1021
1022 struct timezone {
1023     int tz_minuteswest; /* minutes west of Greenwich */
1024     int tz_dsttime;     /* type of dst correction */
1025 };
1026
1027 CF_PRIVATE int _NS_gettimeofday(struct timeval *tv, struct timezone *tz) {
1028     if (tv) {
1029         FILETIME ft;
1030         GetSystemTimeAsFileTime(&ft);
1031         unsigned __int64 t = 0;
1032         t |= ft.dwHighDateTime;
1033         t <<= 32;
1034         t |= ft.dwLowDateTime;
1035
1036         // Convert to microseconds
1037         t /= 10;
1038
1039         // Difference between 1/1/1970 and 1/1/1601
1040         t -= 11644473600000000Ui64;
1041
1042         // Convert microseconds to seconds
1043         tv->tv_sec = (long)(t / 1000000UL);
1044         tv->tv_usec = (long)(t % 1000000UL);
1045     }
1046
1047     // We don't support tz
1048     return 0;
1049 }
1050
1051 #endif // DEPLOYMENT_TARGET_WINDOWS
1052
1053 #pragma mark -
1054 #pragma mark Linux OSAtomic
1055
1056 #if DEPLOYMENT_TARGET_LINUX
1057
1058 bool OSAtomicCompareAndSwapPtr(void *oldp, void *newp, void *volatile *dst)
1059 {
1060     return __sync_bool_compare_and_swap(dst, oldp, newp);
1061 }
1062
1063 bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst)
1064 {
1065     return __sync_val_compare_and_swap(dst, oldl, newl);
1066 }
1067
1068 bool OSAtomicCompareAndSwapPtrBarrier(void *oldp, void *newp, void *volatile *dst)
1069 {
1070     return __sync_bool_compare_and_swap(dst, oldp, newp);
1071 }
1072
1073 int32_t OSAtomicAdd32Barrier( int32_t theAmount, volatile int32_t *theValue ) {
1074     return __sync_fetch_and_add(theValue, theAmount) + theAmount;
1075 }
1076
1077 bool OSAtomicCompareAndSwap32Barrier(int32_t oldValue, int32_t newValue, volatile int32_t *theValue) {
1078     return __sync_bool_compare_and_swap(theValue, oldValue, newValue);
1079 }
1080
1081 bool OSAtomicCompareAndSwap64Barrier(int64_t oldValue, int64_t newValue, volatile int64_t *theValue) {
1082     return __sync_bool_compare_and_swap(theValue, oldValue, newValue);
1083 }
1084
1085 int32_t OSAtomicDecrement32Barrier(volatile int32_t *dst)
1086 {
1087     return OSAtomicAdd32Barrier(-1, dst);
1088 }
1089
1090 int32_t OSAtomicIncrement32Barrier(volatile int32_t *dst)
1091 {
1092     return OSAtomicAdd32Barrier(1, dst);
1093 }
1094
1095 int32_t OSAtomicAdd32( int32_t theAmount, volatile int32_t *theValue ) {
1096     return OSAtomicAdd32Barrier(theAmount, theValue);
1097 }
1098
1099 int32_t OSAtomicIncrement32(volatile int32_t *theValue) {
1100     return OSAtomicIncrement32Barrier(theValue);
1101 }
1102
1103 int32_t OSAtomicDecrement32(volatile int32_t *theValue) {
1104     return OSAtomicDecrement32Barrier(theValue);
1105 }
1106
1107 void OSMemoryBarrier() {
1108     __sync_synchronize();
1109 }
1110
1111 #include <Block_private.h>
1112
1113 void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block) {
1114     struct Block_layout *layout = (struct Block_layout *)block;
1115     pthread_once(predicate, (void (*)(void))layout->invoke);
1116 }
1117
1118 #endif // DEPLOYMENT_TARGET_LINUX
1119
1120 #pragma mark -
1121 #pragma mark Windows and Linux Helpers
1122
1123 #if DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX
1124
1125 #include <stdio.h>
1126
1127 CF_PRIVATE int asprintf(char **ret, const char *format, ...) {
1128     va_list args;
1129     size_t sz = 1024;
1130     *ret = (char *) malloc(sz * sizeof(char));
1131     if (!*ret) return -1;
1132     va_start(args, format);
1133     int cnt = vsnprintf(*ret, sz, format, args);
1134     va_end(args);
1135     if (cnt < sz - 1) return cnt;
1136     sz = cnt + 8;
1137     char *oldret = *ret;
1138     *ret = (char *) realloc(*ret, sz * sizeof(char));
1139     if (!*ret && oldret) free(oldret);
1140     if (!*ret) return -1;
1141     va_start(args, format);
1142     cnt = vsnprintf(*ret, sz, format, args);
1143     va_end(args);
1144     if (cnt < sz - 1) return cnt;
1145     free(*ret);
1146     *ret = NULL;
1147     return -1;
1148 }
1149
1150 #endif
1151