Commit 09cc61bfe4

@@ -332,13 +332,24 @@ struct au_evclass_map {
 };
 typedef struct au_evclass_map   au_evclass_map_t;
 
+
+#if !defined(_KERNEL) && !defined(KERNEL)
+#include <Availability.h>
+#define __AUDIT_API_DEPRECATED __API_DEPRECATED("audit is deprecated", macos(10.4, 11.0))
+#else
+#define __AUDIT_API_DEPRECATED
+#endif
+
 /*
  * Audit system calls.
  */
 #if !defined(_KERNEL) && !defined(KERNEL)
-int     audit(const void *, int);
-int     auditon(int, void *, int);
-int     auditctl(const char *);
+int     audit(const void *, int)
+__AUDIT_API_DEPRECATED;
+int     auditon(int, void *, int)
+__AUDIT_API_DEPRECATED;
+int     auditctl(const char *)
+__AUDIT_API_DEPRECATED;
 int     getauid(au_id_t *);
 int     setauid(const au_id_t *);
 int     getaudit_addr(struct auditinfo_addr *, int);
@@ -360,8 +371,10 @@ __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8,
     __IPHONE_2_0, __IPHONE_6_0);
 #else
 
-int     getaudit(struct auditinfo *);
-int     setaudit(const struct auditinfo *);
+int     getaudit(struct auditinfo *)
+__AUDIT_API_DEPRECATED;
+int     setaudit(const struct auditinfo *)
+__AUDIT_API_DEPRECATED;
 #endif /* !__APPLE__ */
 
 #ifdef __APPLE_API_PRIVATE

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_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. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * 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_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/*
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ *
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
+ * Carnegie Mellon requests users of this software to return to
+ *
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ *
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+/*
+ *	Author: David B. Golub, Carnegie Mellon University
+ *	Date:   3/89
+ */
+
+#ifndef DEVICE_TYPES_H
+#define DEVICE_TYPES_H
+
+/*
+ * Types for device interface.
+ */
+#include <mach/std_types.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/port.h>
+
+
+
+/*
+ * IO buffer - out-of-line array of characters.
+ */
+typedef char *  io_buf_ptr_t;
+
+/*
+ * Some types for IOKit.
+ */
+
+#ifdef IOKIT
+
+/* must match device_types.defs */
+typedef char                    io_name_t[128];
+typedef char                    io_string_t[512];
+typedef char                    io_string_inband_t[4096];
+typedef char                    io_struct_inband_t[4096];
+
+#if   __LP64__
+typedef uint64_t                io_user_scalar_t;
+typedef uint64_t                io_user_reference_t;
+typedef io_user_scalar_t        io_scalar_inband_t[16];
+typedef io_user_reference_t     io_async_ref_t[8];
+typedef io_user_scalar_t        io_scalar_inband64_t[16];
+typedef io_user_reference_t     io_async_ref64_t[8];
+#else
+typedef int                     io_user_scalar_t;
+typedef natural_t               io_user_reference_t;
+typedef io_user_scalar_t        io_scalar_inband_t[16];
+typedef io_user_reference_t     io_async_ref_t[8];
+typedef uint64_t                io_scalar_inband64_t[16];
+typedef uint64_t                io_async_ref64_t[8];
+#endif // __LP64__
+
+
+#ifndef __IOKIT_PORTS_DEFINED__
+#define __IOKIT_PORTS_DEFINED__
+typedef mach_port_t     io_object_t;
+#endif  /* __IOKIT_PORTS_DEFINED__ */
+
+
+#endif  /* IOKIT */
+
+#endif  /* DEVICE_TYPES_H */

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2008-2012 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_BASE__
+#define __DISPATCH_BASE__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+#ifndef __has_include
+#define __has_include(x) 0
+#endif
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+
+#if __GNUC__
+#define DISPATCH_NORETURN __attribute__((__noreturn__))
+#define DISPATCH_NOTHROW __attribute__((__nothrow__))
+#define DISPATCH_NONNULL1 __attribute__((__nonnull__(1)))
+#define DISPATCH_NONNULL2 __attribute__((__nonnull__(2)))
+#define DISPATCH_NONNULL3 __attribute__((__nonnull__(3)))
+#define DISPATCH_NONNULL4 __attribute__((__nonnull__(4)))
+#define DISPATCH_NONNULL5 __attribute__((__nonnull__(5)))
+#define DISPATCH_NONNULL6 __attribute__((__nonnull__(6)))
+#define DISPATCH_NONNULL7 __attribute__((__nonnull__(7)))
+#if __clang__ && __clang_major__ < 3
+// rdar://problem/6857843
+#define DISPATCH_NONNULL_ALL
+#else
+#define DISPATCH_NONNULL_ALL __attribute__((__nonnull__))
+#endif
+#define DISPATCH_SENTINEL __attribute__((__sentinel__))
+#define DISPATCH_PURE __attribute__((__pure__))
+#define DISPATCH_CONST __attribute__((__const__))
+#define DISPATCH_WARN_RESULT __attribute__((__warn_unused_result__))
+#define DISPATCH_MALLOC __attribute__((__malloc__))
+#define DISPATCH_ALWAYS_INLINE __attribute__((__always_inline__))
+#define DISPATCH_UNAVAILABLE __attribute__((__unavailable__))
+#define DISPATCH_UNAVAILABLE_MSG(msg) __attribute__((__unavailable__(msg)))
+#elif defined(_MSC_VER)
+#define DISPATCH_NORETURN __declspec(noreturn)
+#define DISPATCH_NOTHROW __declspec(nothrow)
+#define DISPATCH_NONNULL1
+#define DISPATCH_NONNULL2
+#define DISPATCH_NONNULL3
+#define DISPATCH_NONNULL4
+#define DISPATCH_NONNULL5
+#define DISPATCH_NONNULL6
+#define DISPATCH_NONNULL7
+#define DISPATCH_NONNULL_ALL
+#define DISPATCH_SENTINEL
+#define DISPATCH_PURE
+#define DISPATCH_CONST
+#if (_MSC_VER >= 1700)
+#define DISPATCH_WARN_RESULT _Check_return_
+#else
+#define DISPATCH_WARN_RESULT
+#endif
+#define DISPATCH_MALLOC
+#define DISPATCH_ALWAYS_INLINE __forceinline
+#define DISPATCH_UNAVAILABLE
+#define DISPATCH_UNAVAILABLE_MSG(msg)
+#else
+/*! @parseOnly */
+#define DISPATCH_NORETURN
+/*! @parseOnly */
+#define DISPATCH_NOTHROW
+/*! @parseOnly */
+#define DISPATCH_NONNULL1
+/*! @parseOnly */
+#define DISPATCH_NONNULL2
+/*! @parseOnly */
+#define DISPATCH_NONNULL3
+/*! @parseOnly */
+#define DISPATCH_NONNULL4
+/*! @parseOnly */
+#define DISPATCH_NONNULL5
+/*! @parseOnly */
+#define DISPATCH_NONNULL6
+/*! @parseOnly */
+#define DISPATCH_NONNULL7
+/*! @parseOnly */
+#define DISPATCH_NONNULL_ALL
+/*! @parseOnly */
+#define DISPATCH_SENTINEL
+/*! @parseOnly */
+#define DISPATCH_PURE
+/*! @parseOnly */
+#define DISPATCH_CONST
+/*! @parseOnly */
+#define DISPATCH_WARN_RESULT
+/*! @parseOnly */
+#define DISPATCH_MALLOC
+/*! @parseOnly */
+#define DISPATCH_ALWAYS_INLINE
+/*! @parseOnly */
+#define DISPATCH_UNAVAILABLE
+/*! @parseOnly */
+#define DISPATCH_UNAVAILABLE_MSG(msg)
+#endif
+
+#define DISPATCH_LINUX_UNAVAILABLE()
+
+#ifdef __FreeBSD__
+#define DISPATCH_FREEBSD_UNAVAILABLE() \
+		DISPATCH_UNAVAILABLE_MSG( \
+		"This interface is unavailable on FreeBSD systems")
+#else
+#define DISPATCH_FREEBSD_UNAVAILABLE()
+#endif
+
+#ifndef DISPATCH_ALIAS_V2
+#if TARGET_OS_MAC
+#define DISPATCH_ALIAS_V2(sym)	 __asm__("_" #sym "$V2")
+#else
+#define DISPATCH_ALIAS_V2(sym)
+#endif
+#endif
+
+#if defined(_WIN32)
+#if defined(__cplusplus)
+#define DISPATCH_EXPORT extern "C" __declspec(dllimport)
+#else
+#define DISPATCH_EXPORT extern __declspec(dllimport)
+#endif
+#elif __GNUC__
+#define DISPATCH_EXPORT extern __attribute__((visibility("default")))
+#else
+#define DISPATCH_EXPORT extern
+#endif
+
+#if __GNUC__
+#define DISPATCH_INLINE static __inline__
+#else
+#define DISPATCH_INLINE static inline
+#endif
+
+#if __GNUC__
+#define DISPATCH_EXPECT(x, v) __builtin_expect((x), (v))
+#define dispatch_compiler_barrier()  __asm__ __volatile__("" ::: "memory")
+#else
+#define DISPATCH_EXPECT(x, v) (x)
+#define dispatch_compiler_barrier()  do { } while (0)
+#endif
+
+#if __has_attribute(not_tail_called)
+#define DISPATCH_NOT_TAIL_CALLED __attribute__((__not_tail_called__))
+#else
+#define DISPATCH_NOT_TAIL_CALLED
+#endif
+
+#if __has_builtin(__builtin_assume)
+#define DISPATCH_COMPILER_CAN_ASSUME(expr) __builtin_assume(expr)
+#else
+#define DISPATCH_COMPILER_CAN_ASSUME(expr) ((void)(expr))
+#endif
+
+#if __has_attribute(noescape)
+#define DISPATCH_NOESCAPE __attribute__((__noescape__))
+#else
+#define DISPATCH_NOESCAPE
+#endif
+
+#if __has_attribute(cold)
+#define DISPATCH_COLD __attribute__((__cold__))
+#else
+#define DISPATCH_COLD
+#endif
+
+#if __has_feature(assume_nonnull)
+#define DISPATCH_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
+#define DISPATCH_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
+#else
+#define DISPATCH_ASSUME_NONNULL_BEGIN
+#define DISPATCH_ASSUME_NONNULL_END
+#endif
+
+#if !__has_feature(nullability)
+#ifndef _Nullable
+#define _Nullable
+#endif
+#ifndef _Nonnull
+#define _Nonnull
+#endif
+#ifndef _Null_unspecified
+#define _Null_unspecified
+#endif
+#endif
+
+#ifndef DISPATCH_RETURNS_RETAINED_BLOCK
+#if __has_attribute(ns_returns_retained)
+#define DISPATCH_RETURNS_RETAINED_BLOCK __attribute__((__ns_returns_retained__))
+#else
+#define DISPATCH_RETURNS_RETAINED_BLOCK
+#endif
+#endif
+
+#if __has_attribute(enum_extensibility)
+#define __DISPATCH_ENUM_ATTR __attribute__((__enum_extensibility__(open)))
+#define __DISPATCH_ENUM_ATTR_CLOSED __attribute__((__enum_extensibility__(closed)))
+#else
+#define __DISPATCH_ENUM_ATTR
+#define __DISPATCH_ENUM_ATTR_CLOSED
+#endif // __has_attribute(enum_extensibility)
+
+#if __has_attribute(flag_enum)
+#define __DISPATCH_OPTIONS_ATTR __attribute__((__flag_enum__))
+#else
+#define __DISPATCH_OPTIONS_ATTR
+#endif // __has_attribute(flag_enum)
+
+
+#if __has_feature(objc_fixed_enum) || __has_extension(cxx_strong_enums) || \
+		__has_extension(cxx_fixed_enum) || defined(_WIN32)
+#define DISPATCH_ENUM(name, type, ...) \
+		typedef enum : type { __VA_ARGS__ } __DISPATCH_ENUM_ATTR name##_t
+#define DISPATCH_OPTIONS(name, type, ...) \
+		typedef enum : type { __VA_ARGS__ } __DISPATCH_OPTIONS_ATTR __DISPATCH_ENUM_ATTR name##_t
+#else
+#define DISPATCH_ENUM(name, type, ...) \
+		enum { __VA_ARGS__ } __DISPATCH_ENUM_ATTR; typedef type name##_t
+#define DISPATCH_OPTIONS(name, type, ...) \
+		enum { __VA_ARGS__ } __DISPATCH_OPTIONS_ATTR __DISPATCH_ENUM_ATTR; typedef type name##_t
+#endif // __has_feature(objc_fixed_enum) ...
+
+
+
+#if __has_feature(enumerator_attributes)
+#define DISPATCH_ENUM_API_AVAILABLE(...) API_AVAILABLE(__VA_ARGS__)
+#define DISPATCH_ENUM_API_DEPRECATED(...) API_DEPRECATED(__VA_ARGS__)
+#define DISPATCH_ENUM_API_DEPRECATED_WITH_REPLACEMENT(...) \
+		API_DEPRECATED_WITH_REPLACEMENT(__VA_ARGS__)
+#else
+#define DISPATCH_ENUM_API_AVAILABLE(...)
+#define DISPATCH_ENUM_API_DEPRECATED(...)
+#define DISPATCH_ENUM_API_DEPRECATED_WITH_REPLACEMENT(...)
+#endif
+
+#ifdef __swift__
+#define DISPATCH_SWIFT3_OVERLAY 1
+#else // __swift__
+#define DISPATCH_SWIFT3_OVERLAY 0
+#endif // __swift__
+
+#if __has_feature(attribute_availability_swift)
+#define DISPATCH_SWIFT_UNAVAILABLE(_msg) \
+		__attribute__((__availability__(swift, unavailable, message=_msg)))
+#else
+#define DISPATCH_SWIFT_UNAVAILABLE(_msg)
+#endif
+
+#if DISPATCH_SWIFT3_OVERLAY
+#define DISPATCH_SWIFT3_UNAVAILABLE(_msg) DISPATCH_SWIFT_UNAVAILABLE(_msg)
+#else
+#define DISPATCH_SWIFT3_UNAVAILABLE(_msg)
+#endif
+
+#if __has_attribute(swift_private)
+#define DISPATCH_REFINED_FOR_SWIFT __attribute__((__swift_private__))
+#else
+#define DISPATCH_REFINED_FOR_SWIFT
+#endif
+
+#if __has_attribute(swift_name)
+#define DISPATCH_SWIFT_NAME(_name) __attribute__((__swift_name__(#_name)))
+#else
+#define DISPATCH_SWIFT_NAME(_name)
+#endif
+
+#ifndef __cplusplus
+#define DISPATCH_TRANSPARENT_UNION __attribute__((__transparent_union__))
+#else
+#define DISPATCH_TRANSPARENT_UNION
+#endif
+
+typedef void (*dispatch_function_t)(void *_Nullable);
+
+#endif

@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) 2014 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_BLOCK__
+#define __DISPATCH_BLOCK__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+#ifdef __BLOCKS__
+
+/*!
+ * @group Dispatch block objects
+ */
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+
+__BEGIN_DECLS
+
+/*!
+ * @typedef dispatch_block_flags_t
+ * Flags to pass to the dispatch_block_create* functions.
+ *
+ * @const DISPATCH_BLOCK_BARRIER
+ * Flag indicating that a dispatch block object should act as a barrier block
+ * when submitted to a DISPATCH_QUEUE_CONCURRENT queue.
+ * See dispatch_barrier_async() for details.
+ * This flag has no effect when the dispatch block object is invoked directly.
+ *
+ * @const DISPATCH_BLOCK_DETACHED
+ * Flag indicating that a dispatch block object should execute disassociated
+ * from current execution context attributes such as os_activity_t
+ * and properties of the current IPC request (if any). With regard to QoS class,
+ * the behavior is the same as for DISPATCH_BLOCK_NO_QOS. If invoked directly,
+ * the block object will remove the other attributes from the calling thread for
+ * the duration of the block body (before applying attributes assigned to the
+ * block object, if any). If submitted to a queue, the block object will be
+ * executed with the attributes of the queue (or any attributes specifically
+ * assigned to the block object).
+ *
+ * @const DISPATCH_BLOCK_ASSIGN_CURRENT
+ * Flag indicating that a dispatch block object should be assigned the execution
+ * context attributes that are current at the time the block object is created.
+ * This applies to attributes such as QOS class, os_activity_t and properties of
+ * the current IPC request (if any). If invoked directly, the block object will
+ * apply these attributes to the calling thread for the duration of the block
+ * body. If the block object is submitted to a queue, this flag replaces the
+ * default behavior of associating the submitted block instance with the
+ * execution context attributes that are current at the time of submission.
+ * If a specific QOS class is assigned with DISPATCH_BLOCK_NO_QOS_CLASS or
+ * dispatch_block_create_with_qos_class(), that QOS class takes precedence over
+ * the QOS class assignment indicated by this flag.
+ *
+ * @const DISPATCH_BLOCK_NO_QOS_CLASS
+ * Flag indicating that a dispatch block object should be not be assigned a QOS
+ * class. If invoked directly, the block object will be executed with the QOS
+ * class of the calling thread. If the block object is submitted to a queue,
+ * this replaces the default behavior of associating the submitted block
+ * instance with the QOS class current at the time of submission.
+ * This flag is ignored if a specific QOS class is assigned with
+ * dispatch_block_create_with_qos_class().
+ *
+ * @const DISPATCH_BLOCK_INHERIT_QOS_CLASS
+ * Flag indicating that execution of a dispatch block object submitted to a
+ * queue should prefer the QOS class assigned to the queue over the QOS class
+ * assigned to the block (resp. associated with the block at the time of
+ * submission). The latter will only be used if the queue in question does not
+ * have an assigned QOS class, as long as doing so does not result in a QOS
+ * class lower than the QOS class inherited from the queue's target queue.
+ * This flag is the default when a dispatch block object is submitted to a queue
+ * for asynchronous execution and has no effect when the dispatch block object
+ * is invoked directly. It is ignored if DISPATCH_BLOCK_ENFORCE_QOS_CLASS is
+ * also passed.
+ *
+ * @const DISPATCH_BLOCK_ENFORCE_QOS_CLASS
+ * Flag indicating that execution of a dispatch block object submitted to a
+ * queue should prefer the QOS class assigned to the block (resp. associated
+ * with the block at the time of submission) over the QOS class assigned to the
+ * queue, as long as doing so will not result in a lower QOS class.
+ * This flag is the default when a dispatch block object is submitted to a queue
+ * for synchronous execution or when the dispatch block object is invoked
+ * directly.
+ */
+DISPATCH_OPTIONS(dispatch_block_flags, unsigned long,
+	DISPATCH_BLOCK_BARRIER
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x1,
+	DISPATCH_BLOCK_DETACHED
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x2,
+	DISPATCH_BLOCK_ASSIGN_CURRENT
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x4,
+	DISPATCH_BLOCK_NO_QOS_CLASS
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x8,
+	DISPATCH_BLOCK_INHERIT_QOS_CLASS
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x10,
+	DISPATCH_BLOCK_ENFORCE_QOS_CLASS
+			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x20,
+);
+
+/*!
+ * @function dispatch_block_create
+ *
+ * @abstract
+ * Create a new dispatch block object on the heap from an existing block and
+ * the given flags.
+ *
+ * @discussion
+ * The provided block is Block_copy'ed to the heap and retained by the newly
+ * created dispatch block object.
+ *
+ * The returned dispatch block object is intended to be submitted to a dispatch
+ * queue with dispatch_async() and related functions, but may also be invoked
+ * directly. Both operations can be performed an arbitrary number of times but
+ * only the first completed execution of a dispatch block object can be waited
+ * on with dispatch_block_wait() or observed with dispatch_block_notify().
+ *
+ * If the returned dispatch block object is submitted to a dispatch queue, the
+ * submitted block instance will be associated with the QOS class current at the
+ * time of submission, unless one of the following flags assigned a specific QOS
+ * class (or no QOS class) at the time of block creation:
+ *  - DISPATCH_BLOCK_ASSIGN_CURRENT
+ *  - DISPATCH_BLOCK_NO_QOS_CLASS
+ *  - DISPATCH_BLOCK_DETACHED
+ * The QOS class the block object will be executed with also depends on the QOS
+ * class assigned to the queue and which of the following flags was specified or
+ * defaulted to:
+ *  - DISPATCH_BLOCK_INHERIT_QOS_CLASS (default for asynchronous execution)
+ *  - DISPATCH_BLOCK_ENFORCE_QOS_CLASS (default for synchronous execution)
+ * See description of dispatch_block_flags_t for details.
+ *
+ * If the returned dispatch block object is submitted directly to a serial queue
+ * and is configured to execute with a specific QOS class, the system will make
+ * a best effort to apply the necessary QOS overrides to ensure that blocks
+ * submitted earlier to the serial queue are executed at that same QOS class or
+ * higher.
+ *
+ * @param flags
+ * Configuration flags for the block object.
+ * Passing a value that is not a bitwise OR of flags from dispatch_block_flags_t
+ * results in NULL being returned.
+ *
+ * @param block
+ * The block to create the dispatch block object from.
+ *
+ * @result
+ * The newly created dispatch block object, or NULL.
+ * When not building with Objective-C ARC, must be released with a -[release]
+ * message or the Block_release() function.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_RETURNS_RETAINED_BLOCK
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_block_t
+dispatch_block_create(dispatch_block_flags_t flags, dispatch_block_t block);
+
+/*!
+ * @function dispatch_block_create_with_qos_class
+ *
+ * @abstract
+ * Create a new dispatch block object on the heap from an existing block and
+ * the given flags, and assign it the specified QOS class and relative priority.
+ *
+ * @discussion
+ * The provided block is Block_copy'ed to the heap and retained by the newly
+ * created dispatch block object.
+ *
+ * The returned dispatch block object is intended to be submitted to a dispatch
+ * queue with dispatch_async() and related functions, but may also be invoked
+ * directly. Both operations can be performed an arbitrary number of times but
+ * only the first completed execution of a dispatch block object can be waited
+ * on with dispatch_block_wait() or observed with dispatch_block_notify().
+ *
+ * If invoked directly, the returned dispatch block object will be executed with
+ * the assigned QOS class as long as that does not result in a lower QOS class
+ * than what is current on the calling thread.
+ *
+ * If the returned dispatch block object is submitted to a dispatch queue, the
+ * QOS class it will be executed with depends on the QOS class assigned to the
+ * block, the QOS class assigned to the queue and which of the following flags
+ * was specified or defaulted to:
+ *  - DISPATCH_BLOCK_INHERIT_QOS_CLASS: default for asynchronous execution
+ *  - DISPATCH_BLOCK_ENFORCE_QOS_CLASS: default for synchronous execution
+ * See description of dispatch_block_flags_t for details.
+ *
+ * If the returned dispatch block object is submitted directly to a serial queue
+ * and is configured to execute with a specific QOS class, the system will make
+ * a best effort to apply the necessary QOS overrides to ensure that blocks
+ * submitted earlier to the serial queue are executed at that same QOS class or
+ * higher.
+ *
+ * @param flags
+ * Configuration flags for the new block object.
+ * Passing a value that is not a bitwise OR of flags from dispatch_block_flags_t
+ * results in NULL being returned.
+ *
+ * @param qos_class
+ * A QOS class value:
+ *  - QOS_CLASS_USER_INTERACTIVE
+ *  - QOS_CLASS_USER_INITIATED
+ *  - QOS_CLASS_DEFAULT
+ *  - QOS_CLASS_UTILITY
+ *  - QOS_CLASS_BACKGROUND
+ *  - QOS_CLASS_UNSPECIFIED
+ * Passing QOS_CLASS_UNSPECIFIED is equivalent to specifying the
+ * DISPATCH_BLOCK_NO_QOS_CLASS flag. Passing any other value results in NULL
+ * being returned.
+ *
+ * @param relative_priority
+ * A relative priority within the QOS class. This value is a negative
+ * offset from the maximum supported scheduler priority for the given class.
+ * Passing a value greater than zero or less than QOS_MIN_RELATIVE_PRIORITY
+ * results in NULL being returned.
+ *
+ * @param block
+ * The block to create the dispatch block object from.
+ *
+ * @result
+ * The newly created dispatch block object, or NULL.
+ * When not building with Objective-C ARC, must be released with a -[release]
+ * message or the Block_release() function.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL4 DISPATCH_RETURNS_RETAINED_BLOCK
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_block_t
+dispatch_block_create_with_qos_class(dispatch_block_flags_t flags,
+		dispatch_qos_class_t qos_class, int relative_priority,
+		dispatch_block_t block);
+
+/*!
+ * @function dispatch_block_perform
+ *
+ * @abstract
+ * Create, synchronously execute and release a dispatch block object from the
+ * specified block and flags.
+ *
+ * @discussion
+ * Behaves identically to the sequence
+ * <code>
+ * dispatch_block_t b = dispatch_block_create(flags, block);
+ * b();
+ * Block_release(b);
+ * </code>
+ * but may be implemented more efficiently internally by not requiring a copy
+ * to the heap of the specified block or the allocation of a new block object.
+ *
+ * @param flags
+ * Configuration flags for the temporary block object.
+ * The result of passing a value that is not a bitwise OR of flags from
+ * dispatch_block_flags_t is undefined.
+ *
+ * @param block
+ * The block to create the temporary block object from.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW
+void
+dispatch_block_perform(dispatch_block_flags_t flags,
+		DISPATCH_NOESCAPE dispatch_block_t block);
+
+/*!
+ * @function dispatch_block_wait
+ *
+ * @abstract
+ * Wait synchronously until execution of the specified dispatch block object has
+ * completed or until the specified timeout has elapsed.
+ *
+ * @discussion
+ * This function will return immediately if execution of the block object has
+ * already completed.
+ *
+ * It is not possible to wait for multiple executions of the same block object
+ * with this interface; use dispatch_group_wait() for that purpose. A single
+ * dispatch block object may either be waited on once and executed once,
+ * or it may be executed any number of times. The behavior of any other
+ * combination is undefined. Submission to a dispatch queue counts as an
+ * execution, even if cancellation (dispatch_block_cancel) means the block's
+ * code never runs.
+ *
+ * The result of calling this function from multiple threads simultaneously
+ * with the same dispatch block object is undefined, but note that doing so
+ * would violate the rules described in the previous paragraph.
+ *
+ * If this function returns indicating that the specified timeout has elapsed,
+ * then that invocation does not count as the one allowed wait.
+ *
+ * If at the time this function is called, the specified dispatch block object
+ * has been submitted directly to a serial queue, the system will make a best
+ * effort to apply the necessary QOS overrides to ensure that the block and any
+ * blocks submitted earlier to that serial queue are executed at the QOS class
+ * (or higher) of the thread calling dispatch_block_wait().
+ *
+ * @param block
+ * The dispatch block object to wait on.
+ * The result of passing NULL or a block object not returned by one of the
+ * dispatch_block_create* functions is undefined.
+ *
+ * @param timeout
+ * When to timeout (see dispatch_time). As a convenience, there are the
+ * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
+ *
+ * @result
+ * Returns zero on success (the dispatch block object completed within the
+ * specified timeout) or non-zero on error (i.e. timed out).
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+intptr_t
+dispatch_block_wait(dispatch_block_t block, dispatch_time_t timeout);
+
+/*!
+ * @function dispatch_block_notify
+ *
+ * @abstract
+ * Schedule a notification block to be submitted to a queue when the execution
+ * of a specified dispatch block object has completed.
+ *
+ * @discussion
+ * This function will submit the notification block immediately if execution of
+ * the observed block object has already completed.
+ *
+ * It is not possible to be notified of multiple executions of the same block
+ * object with this interface, use dispatch_group_notify() for that purpose.
+ *
+ * A single dispatch block object may either be observed one or more times
+ * and executed once, or it may be executed any number of times. The behavior
+ * of any other combination is undefined. Submission to a dispatch queue
+ * counts as an execution, even if cancellation (dispatch_block_cancel) means
+ * the block's code never runs.
+ *
+ * If multiple notification blocks are scheduled for a single block object,
+ * there is no defined order in which the notification blocks will be submitted
+ * to their associated queues.
+ *
+ * @param block
+ * The dispatch block object to observe.
+ * The result of passing NULL or a block object not returned by one of the
+ * dispatch_block_create* functions is undefined.
+ *
+ * @param queue
+ * The queue to which the supplied notification block will be submitted when
+ * the observed block completes.
+ *
+ * @param notification_block
+ * The notification block to submit when the observed block object completes.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_block_notify(dispatch_block_t block, dispatch_queue_t queue,
+		dispatch_block_t notification_block);
+
+/*!
+ * @function dispatch_block_cancel
+ *
+ * @abstract
+ * Asynchronously cancel the specified dispatch block object.
+ *
+ * @discussion
+ * Cancellation causes any future execution of the dispatch block object to
+ * return immediately, but does not affect any execution of the block object
+ * that is already in progress.
+ *
+ * Release of any resources associated with the block object will be delayed
+ * until execution of the block object is next attempted (or any execution
+ * already in progress completes).
+ *
+ * NOTE: care needs to be taken to ensure that a block object that may be
+ *       canceled does not capture any resources that require execution of the
+ *       block body in order to be released (e.g. memory allocated with
+ *       malloc(3) that the block body calls free(3) on). Such resources will
+ *       be leaked if the block body is never executed due to cancellation.
+ *
+ * @param block
+ * The dispatch block object to cancel.
+ * The result of passing NULL or a block object not returned by one of the
+ * dispatch_block_create* functions is undefined.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_block_cancel(dispatch_block_t block);
+
+/*!
+ * @function dispatch_block_testcancel
+ *
+ * @abstract
+ * Tests whether the given dispatch block object has been canceled.
+ *
+ * @param block
+ * The dispatch block object to test.
+ * The result of passing NULL or a block object not returned by one of the
+ * dispatch_block_create* functions is undefined.
+ *
+ * @result
+ * Non-zero if canceled and zero if not canceled.
+ */
+API_AVAILABLE(macos(10.10), ios(8.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
+DISPATCH_NOTHROW
+intptr_t
+dispatch_block_testcancel(dispatch_block_t block);
+
+__END_DECLS
+
+DISPATCH_ASSUME_NONNULL_END
+
+#endif // __BLOCKS__
+
+#endif // __DISPATCH_BLOCK__

@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_DATA__
+#define __DISPATCH_DATA__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+
+__BEGIN_DECLS
+
+/*! @header
+ * Dispatch data objects describe contiguous or sparse regions of memory that
+ * may be managed by the system or by the application.
+ * Dispatch data objects are immutable, any direct access to memory regions
+ * represented by dispatch objects must not modify that memory.
+ */
+
+/*!
+ * @typedef dispatch_data_t
+ * A dispatch object representing memory regions.
+ */
+DISPATCH_DATA_DECL(dispatch_data);
+
+/*!
+ * @var dispatch_data_empty
+ * @discussion The singleton dispatch data object representing a zero-length
+ * memory region.
+ */
+#define dispatch_data_empty \
+		DISPATCH_GLOBAL_OBJECT(dispatch_data_t, _dispatch_data_empty)
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT struct dispatch_data_s _dispatch_data_empty;
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_DEFAULT
+ * @discussion The default destructor for dispatch data objects.
+ * Used at data object creation to indicate that the supplied buffer should
+ * be copied into internal storage managed by the system.
+ */
+#define DISPATCH_DATA_DESTRUCTOR_DEFAULT NULL
+
+#ifdef __BLOCKS__
+/*! @parseOnly */
+#define DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(name) \
+	DISPATCH_EXPORT const dispatch_block_t _dispatch_data_destructor_##name
+#else
+#define DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(name) \
+	DISPATCH_EXPORT const dispatch_function_t \
+	_dispatch_data_destructor_##name
+#endif /* __BLOCKS__ */
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_FREE
+ * @discussion The destructor for dispatch data objects created from a malloc'd
+ * buffer. Used at data object creation to indicate that the supplied buffer
+ * was allocated by the malloc() family and should be destroyed with free(3).
+ */
+#define DISPATCH_DATA_DESTRUCTOR_FREE (_dispatch_data_destructor_free)
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(free);
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_MUNMAP
+ * @discussion The destructor for dispatch data objects that have been created
+ * from buffers that require deallocation with munmap(2).
+ */
+#define DISPATCH_DATA_DESTRUCTOR_MUNMAP (_dispatch_data_destructor_munmap)
+API_AVAILABLE(macos(10.9), ios(7.0))
+DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(munmap);
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_data_create
+ * Creates a dispatch data object from the given contiguous buffer of memory. If
+ * a non-default destructor is provided, ownership of the buffer remains with
+ * the caller (i.e. the bytes will not be copied). The last release of the data
+ * object will result in the invocation of the specified destructor on the
+ * specified queue to free the buffer.
+ *
+ * If the DISPATCH_DATA_DESTRUCTOR_FREE destructor is provided the buffer will
+ * be freed via free(3) and the queue argument ignored.
+ *
+ * If the DISPATCH_DATA_DESTRUCTOR_DEFAULT destructor is provided, data object
+ * creation will copy the buffer into internal memory managed by the system.
+ *
+ * @param buffer	A contiguous buffer of data.
+ * @param size		The size of the contiguous buffer of data.
+ * @param queue		The queue to which the destructor should be submitted.
+ * @param destructor	The destructor responsible for freeing the data when it
+ *			is no longer needed.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create(const void *buffer,
+	size_t size,
+	dispatch_queue_t _Nullable queue,
+	dispatch_block_t _Nullable destructor);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_data_get_size
+ * Returns the logical size of the memory region(s) represented by the specified
+ * dispatch data object.
+ *
+ * @param data	The dispatch data object to query.
+ * @result	The number of bytes represented by the data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_PURE DISPATCH_NONNULL1 DISPATCH_NOTHROW
+size_t
+dispatch_data_get_size(dispatch_data_t data);
+
+/*!
+ * @function dispatch_data_create_map
+ * Maps the memory represented by the specified dispatch data object as a single
+ * contiguous memory region and returns a new data object representing it.
+ * If non-NULL references to a pointer and a size variable are provided, they
+ * are filled with the location and extent of that region. These allow direct
+ * read access to the represented memory, but are only valid until the returned
+ * object is released. Under ARC, if that object is held in a variable with
+ * automatic storage, care needs to be taken to ensure that it is not released
+ * by the compiler before memory access via the pointer has been completed.
+ *
+ * @param data		The dispatch data object to map.
+ * @param buffer_ptr	A pointer to a pointer variable to be filled with the
+ *			location of the mapped contiguous memory region, or
+ *			NULL.
+ * @param size_ptr	A pointer to a size_t variable to be filled with the
+ *			size of the mapped contiguous memory region, or NULL.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_map(dispatch_data_t data,
+	const void *_Nullable *_Nullable buffer_ptr,
+	size_t *_Nullable size_ptr);
+
+/*!
+ * @function dispatch_data_create_concat
+ * Returns a new dispatch data object representing the concatenation of the
+ * specified data objects. Those objects may be released by the application
+ * after the call returns (however, the system might not deallocate the memory
+ * region(s) described by them until the newly created object has also been
+ * released).
+ *
+ * @param data1	The data object representing the region(s) of memory to place
+ *		at the beginning of the newly created object.
+ * @param data2	The data object representing the region(s) of memory to place
+ *		at the end of the newly created object.
+ * @result	A newly created object representing the concatenation of the
+ *		data1 and data2 objects.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_concat(dispatch_data_t data1, dispatch_data_t data2);
+
+/*!
+ * @function dispatch_data_create_subrange
+ * Returns a new dispatch data object representing a subrange of the specified
+ * data object, which may be released by the application after the call returns
+ * (however, the system might not deallocate the memory region(s) described by
+ * that object until the newly created object has also been released).
+ *
+ * @param data		The data object representing the region(s) of memory to
+ *			create a subrange of.
+ * @param offset	The offset into the data object where the subrange
+ *			starts.
+ * @param length	The length of the range.
+ * @result		A newly created object representing the specified
+ *			subrange of the data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_subrange(dispatch_data_t data,
+	size_t offset,
+	size_t length);
+
+#ifdef __BLOCKS__
+/*!
+ * @typedef dispatch_data_applier_t
+ * A block to be invoked for every contiguous memory region in a data object.
+ *
+ * @param region	A data object representing the current region.
+ * @param offset	The logical offset of the current region to the start
+ *			of the data object.
+ * @param buffer	The location of the memory for the current region.
+ * @param size		The size of the memory for the current region.
+ * @result		A Boolean indicating whether traversal should continue.
+ */
+typedef bool (^dispatch_data_applier_t)(dispatch_data_t region,
+	size_t offset,
+	const void *buffer,
+	size_t size);
+
+/*!
+ * @function dispatch_data_apply
+ * Traverse the memory regions represented by the specified dispatch data object
+ * in logical order and invoke the specified block once for every contiguous
+ * memory region encountered.
+ *
+ * Each invocation of the block is passed a data object representing the current
+ * region and its logical offset, along with the memory location and extent of
+ * the region. These allow direct read access to the memory region, but are only
+ * valid until the passed-in region object is released. Note that the region
+ * object is released by the system when the block returns, it is the
+ * responsibility of the application to retain it if the region object or the
+ * associated memory location are needed after the block returns.
+ *
+ * @param data		The data object to traverse.
+ * @param applier	The block to be invoked for every contiguous memory
+ *			region in the data object.
+ * @result		A Boolean indicating whether traversal completed
+ *			successfully.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+bool
+dispatch_data_apply(dispatch_data_t data,
+	DISPATCH_NOESCAPE dispatch_data_applier_t applier);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_data_copy_region
+ * Finds the contiguous memory region containing the specified location among
+ * the regions represented by the specified object and returns a copy of the
+ * internal dispatch data object representing that region along with its logical
+ * offset in the specified object.
+ *
+ * @param data		The dispatch data object to query.
+ * @param location	The logical position in the data object to query.
+ * @param offset_ptr	A pointer to a size_t variable to be filled with the
+ *			logical offset of the returned region object to the
+ *			start of the queried data object.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_copy_region(dispatch_data_t data,
+	size_t location,
+	size_t *offset_ptr);
+
+__END_DECLS
+
+DISPATCH_ASSUME_NONNULL_END
+
+#endif /* __DISPATCH_DATA__ */

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_PUBLIC__
+#define __DISPATCH_PUBLIC__
+
+#ifdef __APPLE__
+#include <Availability.h>
+#include <os/availability.h>
+#include <TargetConditionals.h>
+#include <os/base.h>
+#elif defined(_WIN32)
+#include <os/generic_win_base.h>
+#elif defined(__unix__)
+#include <os/generic_unix_base.h>
+#endif
+
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <string.h>
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#include <unistd.h>
+#endif
+#include <fcntl.h>
+#if defined(_WIN32)
+#include <time.h>
+#endif
+
+#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__has_feature)
+#if __has_feature(modules)
+#if !defined(__arm__)
+#include <stdio.h> // for off_t (to match Glibc.modulemap)
+#endif
+#endif
+#endif
+
+#define DISPATCH_API_VERSION 20181008
+
+#ifndef __DISPATCH_INDIRECT__
+#define __DISPATCH_INDIRECT__
+#endif
+
+#include <os/object.h>
+#include <os/workgroup.h>
+#include <dispatch/base.h>
+#include <dispatch/time.h>
+#include <dispatch/object.h>
+#include <dispatch/queue.h>
+#include <dispatch/block.h>
+#include <dispatch/source.h>
+#include <dispatch/group.h>
+#include <dispatch/semaphore.h>
+#include <dispatch/once.h>
+#include <dispatch/data.h>
+#include <dispatch/io.h>
+#include <dispatch/workloop.h>
+
+#undef __DISPATCH_INDIRECT__
+
+#endif

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_GROUP__
+#define __DISPATCH_GROUP__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+
+/*!
+ * @typedef dispatch_group_t
+ * @abstract
+ * A group of blocks submitted to queues for asynchronous invocation.
+ */
+DISPATCH_DECL(dispatch_group);
+
+__BEGIN_DECLS
+
+/*!
+ * @function dispatch_group_create
+ *
+ * @abstract
+ * Creates new group with which blocks may be associated.
+ *
+ * @discussion
+ * This function creates a new group with which blocks may be associated.
+ * The dispatch group may be used to wait for the completion of the blocks it
+ * references. The group object memory is freed with dispatch_release().
+ *
+ * @result
+ * The newly created group, or NULL on failure.
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
+DISPATCH_NOTHROW
+dispatch_group_t
+dispatch_group_create(void);
+
+/*!
+ * @function dispatch_group_async
+ *
+ * @abstract
+ * Submits a block to a dispatch queue and associates the block with the given
+ * dispatch group.
+ *
+ * @discussion
+ * Submits a block to a dispatch queue and associates the block with the given
+ * dispatch group. The dispatch group may be used to wait for the completion
+ * of the blocks it references.
+ *
+ * @param group
+ * A dispatch group to associate with the submitted block.
+ * The result of passing NULL in this parameter is undefined.
+ *
+ * @param queue
+ * The dispatch queue to which the block will be submitted for asynchronous
+ * invocation.
+ *
+ * @param block
+ * The block to perform asynchronously.
+ */
+#ifdef __BLOCKS__
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_group_async(dispatch_group_t group,
+	dispatch_queue_t queue,
+	dispatch_block_t block);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_group_async_f
+ *
+ * @abstract
+ * Submits a function to a dispatch queue and associates the block with the
+ * given dispatch group.
+ *
+ * @discussion
+ * See dispatch_group_async() for details.
+ *
+ * @param group
+ * A dispatch group to associate with the submitted function.
+ * The result of passing NULL in this parameter is undefined.
+ *
+ * @param queue
+ * The dispatch queue to which the function will be submitted for asynchronous
+ * invocation.
+ *
+ * @param context
+ * The application-defined context parameter to pass to the function.
+ *
+ * @param work
+ * The application-defined function to invoke on the target queue. The first
+ * parameter passed to this function is the context provided to
+ * dispatch_group_async_f().
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL2 DISPATCH_NONNULL4
+DISPATCH_NOTHROW
+void
+dispatch_group_async_f(dispatch_group_t group,
+	dispatch_queue_t queue,
+	void *_Nullable context,
+	dispatch_function_t work);
+
+/*!
+ * @function dispatch_group_wait
+ *
+ * @abstract
+ * Wait synchronously until all the blocks associated with a group have
+ * completed or until the specified timeout has elapsed.
+ *
+ * @discussion
+ * This function waits for the completion of the blocks associated with the
+ * given dispatch group, and returns after all blocks have completed or when
+ * the specified timeout has elapsed.
+ *
+ * This function will return immediately if there are no blocks associated
+ * with the dispatch group (i.e. the group is empty).
+ *
+ * The result of calling this function from multiple threads simultaneously
+ * with the same dispatch group is undefined.
+ *
+ * After the successful return of this function, the dispatch group is empty.
+ * It may either be released with dispatch_release() or re-used for additional
+ * blocks. See dispatch_group_async() for more information.
+ *
+ * @param group
+ * The dispatch group to wait on.
+ * The result of passing NULL in this parameter is undefined.
+ *
+ * @param timeout
+ * When to timeout (see dispatch_time). As a convenience, there are the
+ * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
+ *
+ * @result
+ * Returns zero on success (all blocks associated with the group completed
+ * within the specified timeout) or non-zero on error (i.e. timed out).
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+intptr_t
+dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
+
+/*!
+ * @function dispatch_group_notify
+ *
+ * @abstract
+ * Schedule a block to be submitted to a queue when all the blocks associated
+ * with a group have completed.
+ *
+ * @discussion
+ * This function schedules a notification block to be submitted to the specified
+ * queue once all blocks associated with the dispatch group have completed.
+ *
+ * If no blocks are associated with the dispatch group (i.e. the group is empty)
+ * then the notification block will be submitted immediately.
+ *
+ * The group will be empty at the time the notification block is submitted to
+ * the target queue. The group may either be released with dispatch_release()
+ * or reused for additional operations.
+ * See dispatch_group_async() for more information.
+ *
+ * @param group
+ * The dispatch group to observe.
+ * The result of passing NULL in this parameter is undefined.
+ *
+ * @param queue
+ * The queue to which the supplied block will be submitted when the group
+ * completes.
+ *
+ * @param block
+ * The block to submit when the group completes.
+ */
+#ifdef __BLOCKS__
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_group_notify(dispatch_group_t group,
+	dispatch_queue_t queue,
+	dispatch_block_t block);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_group_notify_f
+ *
+ * @abstract
+ * Schedule a function to be submitted to a queue when all the blocks
+ * associated with a group have completed.
+ *
+ * @discussion
+ * See dispatch_group_notify() for details.
+ *
+ * @param group
+ * The dispatch group to observe.
+ * The result of passing NULL in this parameter is undefined.
+ *
+ * @param context
+ * The application-defined context parameter to pass to the function.
+ *
+ * @param work
+ * The application-defined function to invoke on the target queue. The first
+ * parameter passed to this function is the context provided to
+ * dispatch_group_notify_f().
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL2 DISPATCH_NONNULL4
+DISPATCH_NOTHROW
+void
+dispatch_group_notify_f(dispatch_group_t group,
+	dispatch_queue_t queue,
+	void *_Nullable context,
+	dispatch_function_t work);
+
+/*!
+ * @function dispatch_group_enter
+ *
+ * @abstract
+ * Manually indicate a block has entered the group
+ *
+ * @discussion
+ * Calling this function indicates another block has joined the group through
+ * a means other than dispatch_group_async(). Calls to this function must be
+ * balanced with dispatch_group_leave().
+ *
+ * @param group
+ * The dispatch group to update.
+ * The result of passing NULL in this parameter is undefined.
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_group_enter(dispatch_group_t group);
+
+/*!
+ * @function dispatch_group_leave
+ *
+ * @abstract
+ * Manually indicate a block in the group has completed
+ *
+ * @discussion
+ * Calling this function indicates block has completed and left the dispatch
+ * group by a means other than dispatch_group_async().
+ *
+ * @param group
+ * The dispatch group to update.
+ * The result of passing NULL in this parameter is undefined.
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_group_leave(dispatch_group_t group);
+
+__END_DECLS
+
+DISPATCH_ASSUME_NONNULL_END
+
+#endif

@@ -0,0 +1,597 @@
+/*
+ * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_IO__
+#define __DISPATCH_IO__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+
+__BEGIN_DECLS
+
+/*! @header
+ * Dispatch I/O provides both stream and random access asynchronous read and
+ * write operations on file descriptors. One or more dispatch I/O channels may
+ * be created from a file descriptor as either the DISPATCH_IO_STREAM type or
+ * DISPATCH_IO_RANDOM type. Once a channel has been created the application may
+ * schedule asynchronous read and write operations.
+ *
+ * The application may set policies on the dispatch I/O channel to indicate the
+ * desired frequency of I/O handlers for long-running operations.
+ *
+ * Dispatch I/O also provides a memory management model for I/O buffers that
+ * avoids unnecessary copying of data when pipelined between channels. Dispatch
+ * I/O monitors the overall memory pressure and I/O access patterns for the
+ * application to optimize resource utilization.
+ */
+
+/*!
+ * @typedef dispatch_fd_t
+ * Native file descriptor type for the platform.
+ */
+#if defined(_WIN32)
+typedef intptr_t dispatch_fd_t;
+#else
+typedef int dispatch_fd_t;
+#endif
+
+/*!
+ * @functiongroup Dispatch I/O Convenience API
+ * Convenience wrappers around the dispatch I/O channel API, with simpler
+ * callback handler semantics and no explicit management of channel objects.
+ * File descriptors passed to the convenience API are treated as streams, and
+ * scheduling multiple operations on one file descriptor via the convenience API
+ * may incur more overhead than by using the dispatch I/O channel API directly.
+ */
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_read
+ * Schedule a read operation for asynchronous execution on the specified file
+ * descriptor. The specified handler is enqueued with the data read from the
+ * file descriptor when the operation has completed or an error occurs.
+ *
+ * The data object passed to the handler will be automatically released by the
+ * system when the handler returns. It is the responsibility of the application
+ * to retain, concatenate or copy the data object if it is needed after the
+ * handler returns.
+ *
+ * The data object passed to the handler will only contain as much data as is
+ * currently available from the file descriptor (up to the specified length).
+ *
+ * If an unrecoverable error occurs on the file descriptor, the handler will be
+ * enqueued with the appropriate error code along with a data object of any data
+ * that could be read successfully.
+ *
+ * An invocation of the handler with an error code of zero and an empty data
+ * object indicates that EOF was reached.
+ *
+ * The system takes control of the file descriptor until the handler is
+ * enqueued, and during this time file descriptor flags such as O_NONBLOCK will
+ * be modified by the system on behalf of the application. It is an error for
+ * the application to modify a file descriptor directly while it is under the
+ * control of the system, but it may create additional dispatch I/O convenience
+ * operations or dispatch I/O channels associated with that file descriptor.
+ *
+ * @param fd		The file descriptor from which to read the data.
+ * @param length	The length of data to read from the file descriptor,
+ *			or SIZE_MAX to indicate that all of the data currently
+ *			available from the file descriptor should be read.
+ * @param queue		The dispatch queue to which the handler should be
+ *			submitted.
+ * @param handler	The handler to enqueue when data is ready to be
+ *			delivered.
+ *		param data	The data read from the file descriptor.
+ *		param error	An errno condition for the read operation or
+ *				zero if the read was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL3 DISPATCH_NONNULL4 DISPATCH_NOTHROW
+void
+dispatch_read(dispatch_fd_t fd,
+	size_t length,
+	dispatch_queue_t queue,
+	void (^handler)(dispatch_data_t data, int error));
+
+/*!
+ * @function dispatch_write
+ * Schedule a write operation for asynchronous execution on the specified file
+ * descriptor. The specified handler is enqueued when the operation has
+ * completed or an error occurs.
+ *
+ * If an unrecoverable error occurs on the file descriptor, the handler will be
+ * enqueued with the appropriate error code along with the data that could not
+ * be successfully written.
+ *
+ * An invocation of the handler with an error code of zero indicates that the
+ * data was fully written to the channel.
+ *
+ * The system takes control of the file descriptor until the handler is
+ * enqueued, and during this time file descriptor flags such as O_NONBLOCK will
+ * be modified by the system on behalf of the application. It is an error for
+ * the application to modify a file descriptor directly while it is under the
+ * control of the system, but it may create additional dispatch I/O convenience
+ * operations or dispatch I/O channels associated with that file descriptor.
+ *
+ * @param fd		The file descriptor to which to write the data.
+ * @param data		The data object to write to the file descriptor.
+ * @param queue		The dispatch queue to which the handler should be
+ *			submitted.
+ * @param handler	The handler to enqueue when the data has been written.
+ *		param data	The data that could not be written to the I/O
+ *				channel, or NULL.
+ *		param error	An errno condition for the write operation or
+ *				zero if the write was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL3 DISPATCH_NONNULL4
+DISPATCH_NOTHROW
+void
+dispatch_write(dispatch_fd_t fd,
+	dispatch_data_t data,
+	dispatch_queue_t queue,
+	void (^handler)(dispatch_data_t _Nullable data, int error));
+#endif /* __BLOCKS__ */
+
+/*!
+ * @functiongroup Dispatch I/O Channel API
+ */
+
+/*!
+ * @typedef dispatch_io_t
+ * A dispatch I/O channel represents the asynchronous I/O policy applied to a
+ * file descriptor. I/O channels are first class dispatch objects and may be
+ * retained and released, suspended and resumed, etc.
+ */
+DISPATCH_DECL(dispatch_io);
+
+/*!
+ * @typedef dispatch_io_type_t
+ * The type of a dispatch I/O channel:
+ *
+ * @const DISPATCH_IO_STREAM	A dispatch I/O channel representing a stream of
+ * bytes. Read and write operations on a channel of this type are performed
+ * serially (in order of creation) and read/write data at the file pointer
+ * position that is current at the time the operation starts executing.
+ * Operations of different type (read vs. write) may be performed simultaneously.
+ * Offsets passed to operations on a channel of this type are ignored.
+ *
+ * @const DISPATCH_IO_RANDOM	A dispatch I/O channel representing a random
+ * access file. Read and write operations on a channel of this type may be
+ * performed concurrently and read/write data at the specified offset. Offsets
+ * are interpreted relative to the file pointer position current at the time the
+ * I/O channel is created. Attempting to create a channel of this type for a
+ * file descriptor that is not seekable will result in an error.
+ */
+#define DISPATCH_IO_STREAM 0
+#define DISPATCH_IO_RANDOM 1
+
+typedef unsigned long dispatch_io_type_t;
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_io_create
+ * Create a dispatch I/O channel associated with a file descriptor. The system
+ * takes control of the file descriptor until the channel is closed, an error
+ * occurs on the file descriptor or all references to the channel are released.
+ * At that time the specified cleanup handler will be enqueued and control over
+ * the file descriptor relinquished.
+ *
+ * While a file descriptor is under the control of a dispatch I/O channel, file
+ * descriptor flags such as O_NONBLOCK will be modified by the system on behalf
+ * of the application. It is an error for the application to modify a file
+ * descriptor directly while it is under the control of a dispatch I/O channel,
+ * but it may create additional channels associated with that file descriptor.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param fd	The file descriptor to associate with the I/O channel.
+ * @param queue	The dispatch queue to which the handler should be submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				relinquishes control over the file descriptor.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
+DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create(dispatch_io_type_t type,
+	dispatch_fd_t fd,
+	dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @function dispatch_io_create_with_path
+ * Create a dispatch I/O channel associated with a path name. The specified
+ * path, oflag and mode parameters will be passed to open(2) when the first I/O
+ * operation on the channel is ready to execute and the resulting file
+ * descriptor will remain open and under the control of the system until the
+ * channel is closed, an error occurs on the file descriptor or all references
+ * to the channel are released. At that time the file descriptor will be closed
+ * and the specified cleanup handler will be enqueued.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param path	The absolute path to associate with the I/O channel.
+ * @param oflag	The flags to pass to open(2) when opening the file at
+ *		path.
+ * @param mode	The mode to pass to open(2) when creating the file at
+ *		path (i.e. with flag O_CREAT), zero otherwise.
+ * @param queue	The dispatch queue to which the handler should be
+ *		submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				has closed the file at path.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation or opening of the
+ *				specified file failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type or non-absolute path specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create_with_path(dispatch_io_type_t type,
+	const char *path, int oflag, mode_t mode,
+	dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @function dispatch_io_create_with_io
+ * Create a new dispatch I/O channel from an existing dispatch I/O channel.
+ * The new channel inherits the file descriptor or path name associated with
+ * the existing channel, but not its channel type or policies.
+ *
+ * If the existing channel is associated with a file descriptor, control by the
+ * system over that file descriptor is extended until the new channel is also
+ * closed, an error occurs on the file descriptor, or all references to both
+ * channels are released. At that time the specified cleanup handler will be
+ * enqueued and control over the file descriptor relinquished.
+ *
+ * While a file descriptor is under the control of a dispatch I/O channel, file
+ * descriptor flags such as O_NONBLOCK will be modified by the system on behalf
+ * of the application. It is an error for the application to modify a file
+ * descriptor directly while it is under the control of a dispatch I/O channel,
+ * but it may create additional channels associated with that file descriptor.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param io	The existing channel to create the new I/O channel from.
+ * @param queue	The dispatch queue to which the handler should be submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				relinquishes control over the file descriptor
+ *				(resp. closes the file at path) associated with
+ *				the existing channel.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create_with_io(dispatch_io_type_t type,
+	dispatch_io_t io,
+	dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @typedef dispatch_io_handler_t
+ * The prototype of I/O handler blocks for dispatch I/O operations.
+ *
+ * @param done		A flag indicating whether the operation is complete.
+ * @param data		The data object to be handled.
+ * @param error		An errno condition for the operation.
+ */
+typedef void (^dispatch_io_handler_t)(bool done, dispatch_data_t _Nullable data,
+		int error);
+
+/*!
+ * @function dispatch_io_read
+ * Schedule a read operation for asynchronous execution on the specified I/O
+ * channel. The I/O handler is enqueued one or more times depending on the
+ * general load of the system and the policy specified on the I/O channel.
+ *
+ * Any data read from the channel is described by the dispatch data object
+ * passed to the I/O handler. This object will be automatically released by the
+ * system when the I/O handler returns. It is the responsibility of the
+ * application to retain, concatenate or copy the data object if it is needed
+ * after the I/O handler returns.
+ *
+ * Dispatch I/O handlers are not reentrant. The system will ensure that no new
+ * I/O handler instance is invoked until the previously enqueued handler block
+ * has returned.
+ *
+ * An invocation of the I/O handler with the done flag set indicates that the
+ * read operation is complete and that the handler will not be enqueued again.
+ *
+ * If an unrecoverable error occurs on the I/O channel's underlying file
+ * descriptor, the I/O handler will be enqueued with the done flag set, the
+ * appropriate error code and a NULL data object.
+ *
+ * An invocation of the I/O handler with the done flag set, an error code of
+ * zero and an empty data object indicates that EOF was reached.
+ *
+ * @param channel	The dispatch I/O channel from which to read the data.
+ * @param offset	The offset relative to the channel position from which
+ *			to start reading (only for DISPATCH_IO_RANDOM).
+ * @param length	The length of data to read from the I/O channel, or
+ *			SIZE_MAX to indicate that data should be read until EOF
+ *			is reached.
+ * @param queue		The dispatch queue to which the I/O handler should be
+ *			submitted.
+ * @param io_handler	The I/O handler to enqueue when data is ready to be
+ *			delivered.
+ *	param done	A flag indicating whether the operation is complete.
+ *	param data	An object with the data most recently read from the
+ *			I/O channel as part of this read operation, or NULL.
+ *	param error	An errno condition for the read operation or zero if
+ *			the read was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL4 DISPATCH_NONNULL5
+DISPATCH_NOTHROW
+void
+dispatch_io_read(dispatch_io_t channel,
+	off_t offset,
+	size_t length,
+	dispatch_queue_t queue,
+	dispatch_io_handler_t io_handler);
+
+/*!
+ * @function dispatch_io_write
+ * Schedule a write operation for asynchronous execution on the specified I/O
+ * channel. The I/O handler is enqueued one or more times depending on the
+ * general load of the system and the policy specified on the I/O channel.
+ *
+ * Any data remaining to be written to the I/O channel is described by the
+ * dispatch data object passed to the I/O handler. This object will be
+ * automatically released by the system when the I/O handler returns. It is the
+ * responsibility of the application to retain, concatenate or copy the data
+ * object if it is needed after the I/O handler returns.
+ *
+ * Dispatch I/O handlers are not reentrant. The system will ensure that no new
+ * I/O handler instance is invoked until the previously enqueued handler block
+ * has returned.
+ *
+ * An invocation of the I/O handler with the done flag set indicates that the
+ * write operation is complete and that the handler will not be enqueued again.
+ *
+ * If an unrecoverable error occurs on the I/O channel's underlying file
+ * descriptor, the I/O handler will be enqueued with the done flag set, the
+ * appropriate error code and an object containing the data that could not be
+ * written.
+ *
+ * An invocation of the I/O handler with the done flag set and an error code of
+ * zero indicates that the data was fully written to the channel.
+ *
+ * @param channel	The dispatch I/O channel on which to write the data.
+ * @param offset	The offset relative to the channel position from which
+ *			to start writing (only for DISPATCH_IO_RANDOM).
+ * @param data		The data to write to the I/O channel. The data object
+ *			will be retained by the system until the write operation
+ *			is complete.
+ * @param queue		The dispatch queue to which the I/O handler should be
+ *			submitted.
+ * @param io_handler	The I/O handler to enqueue when data has been delivered.
+ *	param done	A flag indicating whether the operation is complete.
+ *	param data	An object of the data remaining to be
+ *			written to the I/O channel as part of this write
+ *			operation, or NULL.
+ *	param error	An errno condition for the write operation or zero
+ *			if the write was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NONNULL4
+DISPATCH_NONNULL5 DISPATCH_NOTHROW
+void
+dispatch_io_write(dispatch_io_t channel,
+	off_t offset,
+	dispatch_data_t data,
+	dispatch_queue_t queue,
+	dispatch_io_handler_t io_handler);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @typedef dispatch_io_close_flags_t
+ * The type of flags you can set on a dispatch_io_close() call
+ *
+ * @const DISPATCH_IO_STOP	Stop outstanding operations on a channel when
+ *				the channel is closed.
+ */
+#define DISPATCH_IO_STOP 0x1
+
+typedef unsigned long dispatch_io_close_flags_t;
+
+/*!
+ * @function dispatch_io_close
+ * Close the specified I/O channel to new read or write operations; scheduling
+ * operations on a closed channel results in their handler returning an error.
+ *
+ * If the DISPATCH_IO_STOP flag is provided, the system will make a best effort
+ * to interrupt any outstanding read and write operations on the I/O channel,
+ * otherwise those operations will run to completion normally.
+ * Partial results of read and write operations may be returned even after a
+ * channel is closed with the DISPATCH_IO_STOP flag.
+ * The final invocation of an I/O handler of an interrupted operation will be
+ * passed an ECANCELED error code, as will the I/O handler of an operation
+ * scheduled on a closed channel.
+ *
+ * @param channel	The dispatch I/O channel to close.
+ * @param flags		The flags for the close operation.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_close(dispatch_io_t channel, dispatch_io_close_flags_t flags);
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_io_barrier
+ * Schedule a barrier operation on the specified I/O channel; all previously
+ * scheduled operations on the channel will complete before the provided
+ * barrier block is enqueued onto the global queue determined by the channel's
+ * target queue, and no subsequently scheduled operations will start until the
+ * barrier block has returned.
+ *
+ * If multiple channels are associated with the same file descriptor, a barrier
+ * operation scheduled on any of these channels will act as a barrier across all
+ * channels in question, i.e. all previously scheduled operations on any of the
+ * channels will complete before the barrier block is enqueued, and no
+ * operations subsequently scheduled on any of the channels will start until the
+ * barrier block has returned.
+ *
+ * While the barrier block is running, it may safely operate on the channel's
+ * underlying file descriptor with fsync(2), lseek(2) etc. (but not close(2)).
+ *
+ * @param channel	The dispatch I/O channel to schedule the barrier on.
+ * @param barrier	The barrier block.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_io_barrier(dispatch_io_t channel, dispatch_block_t barrier);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_io_get_descriptor
+ * Returns the file descriptor underlying a dispatch I/O channel.
+ *
+ * Will return -1 for a channel closed with dispatch_io_close() and for a
+ * channel associated with a path name that has not yet been open(2)ed.
+ *
+ * If called from a barrier block scheduled on a channel associated with a path
+ * name that has not yet been open(2)ed, this will trigger the channel open(2)
+ * operation and return the resulting file descriptor.
+ *
+ * @param channel	The dispatch I/O channel to query.
+ * @result		The file descriptor underlying the channel, or -1.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_fd_t
+dispatch_io_get_descriptor(dispatch_io_t channel);
+
+/*!
+ * @function dispatch_io_set_high_water
+ * Set a high water mark on the I/O channel for all operations.
+ *
+ * The system will make a best effort to enqueue I/O handlers with partial
+ * results as soon the number of bytes processed by an operation (i.e. read or
+ * written) reaches the high water mark.
+ *
+ * The size of data objects passed to I/O handlers for this channel will never
+ * exceed the specified high water mark.
+ *
+ * The default value for the high water mark is unlimited (i.e. SIZE_MAX).
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param high_water	The number of bytes to use as a high water mark.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_high_water(dispatch_io_t channel, size_t high_water);
+
+/*!
+ * @function dispatch_io_set_low_water
+ * Set a low water mark on the I/O channel for all operations.
+ *
+ * The system will process (i.e. read or write) at least the low water mark
+ * number of bytes for an operation before enqueueing I/O handlers with partial
+ * results.
+ *
+ * The size of data objects passed to intermediate I/O handler invocations for
+ * this channel (i.e. excluding the final invocation) will never be smaller than
+ * the specified low water mark, except if the channel has an interval with the
+ * DISPATCH_IO_STRICT_INTERVAL flag set or if EOF or an error was encountered.
+ *
+ * I/O handlers should be prepared to receive amounts of data significantly
+ * larger than the low water mark in general. If an I/O handler requires
+ * intermediate results of fixed size, set both the low and and the high water
+ * mark to that size.
+ *
+ * The default value for the low water mark is unspecified, but must be assumed
+ * to be such that intermediate handler invocations may occur.
+ * If I/O handler invocations with partial results are not desired, set the
+ * low water mark to SIZE_MAX.
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param low_water	The number of bytes to use as a low water mark.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_low_water(dispatch_io_t channel, size_t low_water);
+
+/*!
+ * @typedef dispatch_io_interval_flags_t
+ * Type of flags to set on dispatch_io_set_interval()
+ *
+ * @const DISPATCH_IO_STRICT_INTERVAL	Enqueue I/O handlers at a channel's
+ * interval setting even if the amount of data ready to be delivered is inferior
+ * to the low water mark (or zero).
+ */
+#define DISPATCH_IO_STRICT_INTERVAL 0x1
+
+typedef unsigned long dispatch_io_interval_flags_t;
+
+/*!
+ * @function dispatch_io_set_interval
+ * Set a nanosecond interval at which I/O handlers are to be enqueued on the
+ * I/O channel for all operations.
+ *
+ * This allows an application to receive periodic feedback on the progress of
+ * read and write operations, e.g. for the purposes of displaying progress bars.
+ *
+ * If the amount of data ready to be delivered to an I/O handler at the interval
+ * is inferior to the channel low water mark, the handler will only be enqueued
+ * if the DISPATCH_IO_STRICT_INTERVAL flag is set.
+ *
+ * Note that the system may defer enqueueing interval I/O handlers by a small
+ * unspecified amount of leeway in order to align with other system activity for
+ * improved system performance or power consumption.
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param interval	The interval in nanoseconds at which delivery of the I/O
+ *					handler is desired.
+ * @param flags		Flags indicating desired data delivery behavior at
+ *					interval time.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_interval(dispatch_io_t channel,
+	uint64_t interval,
+	dispatch_io_interval_flags_t flags);
+
+__END_DECLS
+
+DISPATCH_ASSUME_NONNULL_END
+
+#endif /* __DISPATCH_IO__ */