[apple/xnu.git] / tests / system_version_compat.c

#include <darwintest.h>
#include <darwintest_utils.h>
#include <dispatch/dispatch.h>
#include <fcntl.h>
#include <stdio.h>
#include <TargetConditionals.h>
#include <unistd.h>
#include <xpc/private.h>

#define SYSTEM_VERSION_COMPAT_PLIST_PATH "/System/Library/CoreServices/SystemVersionCompat.plist"
#define IOS_SYSTEM_VERSION_PLIST_PATH "/System/Library/CoreServices/iOSSystemVersion.plist"

#define SYSTEM_VERSION_PLIST_FILENAME "SystemVersion.plist"
#define SYSTEM_VERSION_PLIST_PATH ("/System/Library/CoreServices/" SYSTEM_VERSION_PLIST_FILENAME)

#define PRODUCT_VERSION_KEY "ProductVersion"
#define IOS_SUPPORT_VERSION_KEY "iOSSupportVersion"

#define PRODUCT_VERSION_SYSCTL "kern.osproductversion"
#define PRODUCT_VERSION_COMPAT_SYSCTL "kern.osproductversioncompat"

T_GLOBAL_META(T_META_CHECK_LEAKS(false));

#if TARGET_OS_OSX
static void
check_system_version_compat_plist_exists(void)
{
	struct stat buf;

	int ret = stat(SYSTEM_VERSION_COMPAT_PLIST_PATH, &buf);
	int error = errno;
	if (ret != 0) {
		if (error == ENOENT) {
			T_SKIP("no SystemVersionCompat.plist on this system in %s, skipping test...",
			    SYSTEM_VERSION_COMPAT_PLIST_PATH);
		} else {
			T_ASSERT_FAIL("failed to find SystemVersionCompat.plist at " IOS_SYSTEM_VERSION_PLIST_PATH "with error: %s",
			    strerror(error));
		}
	}
}

static void
check_ios_version_plist_exists(void)
{
	struct stat buf;

	int ret = stat(IOS_SYSTEM_VERSION_PLIST_PATH, &buf);
	int error = errno;
	if (ret != 0) {
		if (errno == ENOENT) {
			T_SKIP("no iOSSystemVersion.plist on this system in %s, skipping test...",
			    IOS_SYSTEM_VERSION_PLIST_PATH);
		} else {
			T_ASSERT_FAIL("failed to find iOSSystemVersion.plist at " IOS_SYSTEM_VERSION_PLIST_PATH "with error: %s",
			    strerror(error));
		}
	}
}

static void
read_plist_version_info(char **version_plist_vers, char **compat_version_plist_vers, bool expect_shim)
{
	char opened_path[MAXPATHLEN] = { '\0' };

	int version_plist_fd = open(SYSTEM_VERSION_PLIST_PATH, O_RDONLY);
	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(version_plist_fd, 0, "opened %s", SYSTEM_VERSION_PLIST_PATH);

	// Resolve the full path of the file we've opened, verify it was either shimmed or not (as expected)
	int ret = fcntl(version_plist_fd, F_GETPATH, opened_path);
	T_QUIET; T_WITH_ERRNO; T_EXPECT_NE(ret, -1, "F_GETPATH on opened SystemVersion.plist");
	if (ret != -1) {
		size_t opened_path_strlen = strlen(opened_path);
		if (expect_shim) {
			T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(SYSTEM_VERSION_COMPAT_PLIST_PATH), "opened path string length");
			T_EXPECT_EQ_STR(SYSTEM_VERSION_COMPAT_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(SYSTEM_VERSION_COMPAT_PLIST_PATH))],
			    "opened file path shimmed (Mac OS)");
		} else {
			T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(SYSTEM_VERSION_PLIST_PATH), "opened path string length");
			T_EXPECT_EQ_STR(SYSTEM_VERSION_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(SYSTEM_VERSION_PLIST_PATH))],
			    "opened file path not shimmed");
		}
	}

	// Read and parse the plists
	dispatch_semaphore_t sema = dispatch_semaphore_create(0);
	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
	xpc_create_from_plist_descriptor(version_plist_fd, queue, ^(xpc_object_t object) {
		if (object == NULL) {
		        T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_PLIST_PATH);
		}
		if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
		        T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_PLIST_PATH);
		}

		const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
		if (plist_version) {
		        T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
		        *version_plist_vers = strdup(plist_version);
		}
		dispatch_semaphore_signal(sema);
	});
	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

	close(version_plist_fd);
	version_plist_fd = -1;

	int compat_version_plist_fd = open(SYSTEM_VERSION_COMPAT_PLIST_PATH, O_RDONLY);
	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(compat_version_plist_fd, 0, "opened %s", SYSTEM_VERSION_COMPAT_PLIST_PATH);

	xpc_create_from_plist_descriptor(compat_version_plist_fd, queue, ^(xpc_object_t object) {
		if (object == NULL) {
		        T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_COMPAT_PLIST_PATH);
		}
		if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
		        T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_COMPAT_PLIST_PATH);
		}

		const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
		if (plist_version) {
		        T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_COMPAT_PLIST_PATH);
		        *compat_version_plist_vers = strdup(plist_version);
		}
		dispatch_semaphore_signal(sema);
	});
	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

	close(compat_version_plist_fd);
	compat_version_plist_fd = -1;

	return;
}

static void
read_sysctl_version_info(char **vers, char **compat_vers)
{
	char version[16] = { '\0' }, compat_version[16] = { '\0' };
	size_t version_len = sizeof(version), compat_version_len = sizeof(compat_version);

	T_QUIET; T_ASSERT_POSIX_ZERO(sysctlbyname(PRODUCT_VERSION_SYSCTL, version, &version_len, NULL, 0), "read %s", PRODUCT_VERSION_SYSCTL);
	T_LOG("Foundd %s from %s", version, PRODUCT_VERSION_SYSCTL);

	T_QUIET; T_ASSERT_POSIX_ZERO(sysctlbyname(PRODUCT_VERSION_COMPAT_SYSCTL, compat_version, &compat_version_len, NULL, 0),
	    "read %s", PRODUCT_VERSION_COMPAT_SYSCTL);
	T_LOG("Found %s from %s", compat_version, PRODUCT_VERSION_COMPAT_SYSCTL);

	*vers = strdup(version);
	*compat_vers = strdup(compat_version);

	return;
}
#endif // TARGET_OS_OSX

T_DECL(test_system_version_compat_disabled,
    "Tests reading system product information without system version compat enabled")
{
#if TARGET_OS_OSX
	check_system_version_compat_plist_exists();
	char *plist_vers = NULL, *plist_compat_vers = NULL;
	char *sysctl_vers = NULL, *sysctl_compat_vers = NULL;

	// Read plist version data
	read_plist_version_info(&plist_vers, &plist_compat_vers, false);

	// Read sysctl version data
	read_sysctl_version_info(&sysctl_vers, &sysctl_compat_vers);

	// Verify the normal data matches
	T_EXPECT_EQ_STR(plist_vers, sysctl_vers, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
	    PRODUCT_VERSION_KEY, PRODUCT_VERSION_SYSCTL);

	// Verify that the compatibility data matches
	T_EXPECT_EQ_STR(plist_compat_vers, sysctl_compat_vers, "%s %s matches %s value", SYSTEM_VERSION_COMPAT_PLIST_PATH,
	    PRODUCT_VERSION_KEY, PRODUCT_VERSION_COMPAT_SYSCTL);


	free(plist_vers);
	free(plist_compat_vers);
	free(sysctl_vers);
	free(sysctl_compat_vers);

	T_PASS("verified version information without system version compat");
#else // TARGET_OS_OSX
	T_SKIP("system version compat only supported on macOS");
#endif // TARGET_OS_OSX
}

T_DECL(test_system_version_compat_enabled,
    "Tests reading system product information with system version compat enabled",
    T_META_ENVVAR("SYSTEM_VERSION_COMPAT=1"))
{
#if TARGET_OS_OSX
	check_system_version_compat_plist_exists();
	char *plist_vers = NULL, *plist_compat_vers = NULL;
	char *sysctl_vers = NULL, *sysctl_compat_vers = NULL;

	// Read plist version data
	read_plist_version_info(&plist_vers, &plist_compat_vers, true);

	// Read sysctl version data
	read_sysctl_version_info(&sysctl_vers, &sysctl_compat_vers);

	// The version information should match from all sources with the shim enabled

	// Verify the normal data matches
	T_EXPECT_EQ_STR(plist_vers, sysctl_vers, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
	    PRODUCT_VERSION_KEY, PRODUCT_VERSION_SYSCTL);

	// Verify that the compatibility data matches
	T_EXPECT_EQ_STR(plist_compat_vers, sysctl_compat_vers, "%s %s matches %s value", SYSTEM_VERSION_COMPAT_PLIST_PATH,
	    PRODUCT_VERSION_KEY, PRODUCT_VERSION_COMPAT_SYSCTL);

	// Verify the normal data matches the compatibility data
	T_EXPECT_EQ_STR(plist_vers, plist_compat_vers, "%s matches in both %s and %s", PRODUCT_VERSION_KEY,
	    SYSTEM_VERSION_PLIST_PATH, SYSTEM_VERSION_COMPAT_PLIST_PATH);

	free(plist_vers);
	free(plist_compat_vers);
	free(sysctl_vers);
	free(sysctl_compat_vers);

	T_PASS("verified version information with Mac OS X shim enabled");
#else // TARGET_OS_OSX
	T_SKIP("system version compat only supported on macOS");
#endif // TARGET_OS_OSX
}

T_DECL(test_system_version_compat_enabled_ios,
    "Tests reading system product information with the iOS system version compat shim enabled",
    T_META_ENVVAR("SYSTEM_VERSION_COMPAT=2"))
{
#if TARGET_OS_OSX
	char opened_path[MAXPATHLEN] = { '\0' };

	check_ios_version_plist_exists();

	// Read out the ProductVersion from SystemVersion.plist and ensure that it contains the same value as the
	// iOSSupportVersion key

	__block char *read_plist_vers = NULL, *read_ios_support_version = NULL;

	int version_plist_fd = open(SYSTEM_VERSION_PLIST_PATH, O_RDONLY);
	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(version_plist_fd, 0, "opened %s", SYSTEM_VERSION_PLIST_PATH);

	// Resolve the full path of the file we've opened, verify it was shimmed as expected
	int ret = fcntl(version_plist_fd, F_GETPATH, opened_path);
	T_QUIET; T_WITH_ERRNO; T_EXPECT_NE(ret, -1, "F_GETPATH on opened SystemVersion.plist");
	if (ret != -1) {
		size_t opened_path_strlen = strlen(opened_path);
		T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(IOS_SYSTEM_VERSION_PLIST_PATH), "opened path string length");
		T_EXPECT_EQ_STR(IOS_SYSTEM_VERSION_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(IOS_SYSTEM_VERSION_PLIST_PATH))],
		    "opened file path shimmed (iOS)");
	}

	// Read and parse the attributes from the SystemVersion plist
	dispatch_semaphore_t sema = dispatch_semaphore_create(0);
	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
	xpc_create_from_plist_descriptor(version_plist_fd, queue, ^(xpc_object_t object) {
		if (object == NULL) {
		        T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_PLIST_PATH);
		}
		if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
		        T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_PLIST_PATH);
		}

		const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
		if (plist_version) {
		        T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
		        read_plist_vers = strdup(plist_version);
		}

		const char *ios_support_version = xpc_dictionary_get_string(object, IOS_SUPPORT_VERSION_KEY);
		if (ios_support_version) {
		        T_LOG("Found %s for %s from %s", ios_support_version, IOS_SUPPORT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
		        read_ios_support_version = strdup(ios_support_version);
		}

		dispatch_semaphore_signal(sema);
	});
	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

	close(version_plist_fd);
	version_plist_fd = -1;

	// Verify the data matches
	T_EXPECT_EQ_STR(read_plist_vers, read_ios_support_version, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
	    PRODUCT_VERSION_KEY, IOS_SUPPORT_VERSION_KEY);

	T_PASS("verified version information with iOS shim enabled");

#else // TARGET_OS_OSX
	T_SKIP("iOS system version shim only supported on macOS");
#endif // TARGET_OS_OSX
}
Commit	Line	Data
f427ee49 A	1	#include <darwintest.h>
	2	#include <darwintest_utils.h>
	3	#include <dispatch/dispatch.h>
	4	#include <fcntl.h>
	5	#include <stdio.h>
	6	#include <TargetConditionals.h>
	7	#include <unistd.h>
	8	#include <xpc/private.h>
	9
	10	#define SYSTEM_VERSION_COMPAT_PLIST_PATH "/System/Library/CoreServices/SystemVersionCompat.plist"
	11	#define IOS_SYSTEM_VERSION_PLIST_PATH "/System/Library/CoreServices/iOSSystemVersion.plist"
	12
	13	#define SYSTEM_VERSION_PLIST_FILENAME "SystemVersion.plist"
	14	#define SYSTEM_VERSION_PLIST_PATH ("/System/Library/CoreServices/" SYSTEM_VERSION_PLIST_FILENAME)
	15
	16	#define PRODUCT_VERSION_KEY "ProductVersion"
	17	#define IOS_SUPPORT_VERSION_KEY "iOSSupportVersion"
	18
	19	#define PRODUCT_VERSION_SYSCTL "kern.osproductversion"
	20	#define PRODUCT_VERSION_COMPAT_SYSCTL "kern.osproductversioncompat"
	21
	22	T_GLOBAL_META(T_META_CHECK_LEAKS(false));
	23
	24	#if TARGET_OS_OSX
	25	static void
	26	check_system_version_compat_plist_exists(void)
	27	{
	28	struct stat buf;
	29
	30	int ret = stat(SYSTEM_VERSION_COMPAT_PLIST_PATH, &buf);
	31	int error = errno;
	32	if (ret != 0) {
	33	if (error == ENOENT) {
	34	T_SKIP("no SystemVersionCompat.plist on this system in %s, skipping test...",
	35	SYSTEM_VERSION_COMPAT_PLIST_PATH);
	36	} else {
	37	T_ASSERT_FAIL("failed to find SystemVersionCompat.plist at " IOS_SYSTEM_VERSION_PLIST_PATH "with error: %s",
	38	strerror(error));
	39	}
	40	}
	41	}
	42
	43	static void
	44	check_ios_version_plist_exists(void)
	45	{
	46	struct stat buf;
	47
	48	int ret = stat(IOS_SYSTEM_VERSION_PLIST_PATH, &buf);
	49	int error = errno;
	50	if (ret != 0) {
	51	if (errno == ENOENT) {
	52	T_SKIP("no iOSSystemVersion.plist on this system in %s, skipping test...",
	53	IOS_SYSTEM_VERSION_PLIST_PATH);
	54	} else {
	55	T_ASSERT_FAIL("failed to find iOSSystemVersion.plist at " IOS_SYSTEM_VERSION_PLIST_PATH "with error: %s",
	56	strerror(error));
	57	}
	58	}
	59	}
	60
	61	static void
	62	read_plist_version_info(char version_plist_vers, char compat_version_plist_vers, bool expect_shim)
	63	{
	64	char opened_path[MAXPATHLEN] = { '\0' };
65
66	int version_plist_fd = open(SYSTEM_VERSION_PLIST_PATH, O_RDONLY);
67	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(version_plist_fd, 0, "opened %s", SYSTEM_VERSION_PLIST_PATH);
68
69	// Resolve the full path of the file we've opened, verify it was either shimmed or not (as expected)
70	int ret = fcntl(version_plist_fd, F_GETPATH, opened_path);
71	T_QUIET; T_WITH_ERRNO; T_EXPECT_NE(ret, -1, "F_GETPATH on opened SystemVersion.plist");
72	if (ret != -1) {
73	size_t opened_path_strlen = strlen(opened_path);
74	if (expect_shim) {
75	T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(SYSTEM_VERSION_COMPAT_PLIST_PATH), "opened path string length");
76	T_EXPECT_EQ_STR(SYSTEM_VERSION_COMPAT_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(SYSTEM_VERSION_COMPAT_PLIST_PATH))],
77	"opened file path shimmed (Mac OS)");
78	} else {
79	T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(SYSTEM_VERSION_PLIST_PATH), "opened path string length");
80	T_EXPECT_EQ_STR(SYSTEM_VERSION_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(SYSTEM_VERSION_PLIST_PATH))],
81	"opened file path not shimmed");
82	}
83	}
84
85	// Read and parse the plists
86	dispatch_semaphore_t sema = dispatch_semaphore_create(0);
87	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
88	xpc_create_from_plist_descriptor(version_plist_fd, queue, ^(xpc_object_t object) {
89	if (object == NULL) {
90	T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_PLIST_PATH);
91	}
92	if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
93	T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_PLIST_PATH);
94	}
95
96	const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
97	if (plist_version) {
98	T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
99	*version_plist_vers = strdup(plist_version);
100	}
101	dispatch_semaphore_signal(sema);
102	});
103	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
104
105	close(version_plist_fd);
106	version_plist_fd = -1;
107
108	int compat_version_plist_fd = open(SYSTEM_VERSION_COMPAT_PLIST_PATH, O_RDONLY);
109	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(compat_version_plist_fd, 0, "opened %s", SYSTEM_VERSION_COMPAT_PLIST_PATH);
110
111	xpc_create_from_plist_descriptor(compat_version_plist_fd, queue, ^(xpc_object_t object) {
112	if (object == NULL) {
113	T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_COMPAT_PLIST_PATH);
114	}
115	if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
116	T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_COMPAT_PLIST_PATH);
117	}
118
119	const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
120	if (plist_version) {
121	T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_COMPAT_PLIST_PATH);
122	*compat_version_plist_vers = strdup(plist_version);
123	}
124	dispatch_semaphore_signal(sema);
125	});
126	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
127
128	close(compat_version_plist_fd);
129	compat_version_plist_fd = -1;
130
131	return;
132	}
133
134	static void
135	read_sysctl_version_info(char vers, char compat_vers)
136	{
137	char version[16] = { '\0' }, compat_version[16] = { '\0' };
138	size_t version_len = sizeof(version), compat_version_len = sizeof(compat_version);
139
140	T_QUIET; T_ASSERT_POSIX_ZERO(sysctlbyname(PRODUCT_VERSION_SYSCTL, version, &version_len, NULL, 0), "read %s", PRODUCT_VERSION_SYSCTL);
141	T_LOG("Foundd %s from %s", version, PRODUCT_VERSION_SYSCTL);
142
143	T_QUIET; T_ASSERT_POSIX_ZERO(sysctlbyname(PRODUCT_VERSION_COMPAT_SYSCTL, compat_version, &compat_version_len, NULL, 0),
144	"read %s", PRODUCT_VERSION_COMPAT_SYSCTL);
145	T_LOG("Found %s from %s", compat_version, PRODUCT_VERSION_COMPAT_SYSCTL);
146
147	*vers = strdup(version);
148	*compat_vers = strdup(compat_version);
149
150	return;
151	}
152	#endif // TARGET_OS_OSX
153
154	T_DECL(test_system_version_compat_disabled,
155	"Tests reading system product information without system version compat enabled")
156	{
157	#if TARGET_OS_OSX
158	check_system_version_compat_plist_exists();
159	char plist_vers = NULL, plist_compat_vers = NULL;
160	char sysctl_vers = NULL, sysctl_compat_vers = NULL;
161
162	// Read plist version data
163	read_plist_version_info(&plist_vers, &plist_compat_vers, false);
164
165	// Read sysctl version data
166	read_sysctl_version_info(&sysctl_vers, &sysctl_compat_vers);
167
168	// Verify the normal data matches
169	T_EXPECT_EQ_STR(plist_vers, sysctl_vers, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
170	PRODUCT_VERSION_KEY, PRODUCT_VERSION_SYSCTL);
171
172	// Verify that the compatibility data matches
173	T_EXPECT_EQ_STR(plist_compat_vers, sysctl_compat_vers, "%s %s matches %s value", SYSTEM_VERSION_COMPAT_PLIST_PATH,
174	PRODUCT_VERSION_KEY, PRODUCT_VERSION_COMPAT_SYSCTL);
175
176
177	free(plist_vers);
178	free(plist_compat_vers);
179	free(sysctl_vers);
180	free(sysctl_compat_vers);
181
182	T_PASS("verified version information without system version compat");
183	#else // TARGET_OS_OSX
184	T_SKIP("system version compat only supported on macOS");
185	#endif // TARGET_OS_OSX
186	}
187
188	T_DECL(test_system_version_compat_enabled,
189	"Tests reading system product information with system version compat enabled",
190	T_META_ENVVAR("SYSTEM_VERSION_COMPAT=1"))
191	{
192	#if TARGET_OS_OSX
193	check_system_version_compat_plist_exists();
194	char plist_vers = NULL, plist_compat_vers = NULL;
195	char sysctl_vers = NULL, sysctl_compat_vers = NULL;
196
197	// Read plist version data
198	read_plist_version_info(&plist_vers, &plist_compat_vers, true);
199
200	// Read sysctl version data
201	read_sysctl_version_info(&sysctl_vers, &sysctl_compat_vers);
202
203	// The version information should match from all sources with the shim enabled
204
205	// Verify the normal data matches
206	T_EXPECT_EQ_STR(plist_vers, sysctl_vers, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
207	PRODUCT_VERSION_KEY, PRODUCT_VERSION_SYSCTL);
208
209	// Verify that the compatibility data matches
210	T_EXPECT_EQ_STR(plist_compat_vers, sysctl_compat_vers, "%s %s matches %s value", SYSTEM_VERSION_COMPAT_PLIST_PATH,
211	PRODUCT_VERSION_KEY, PRODUCT_VERSION_COMPAT_SYSCTL);
212
213	// Verify the normal data matches the compatibility data
214	T_EXPECT_EQ_STR(plist_vers, plist_compat_vers, "%s matches in both %s and %s", PRODUCT_VERSION_KEY,
215	SYSTEM_VERSION_PLIST_PATH, SYSTEM_VERSION_COMPAT_PLIST_PATH);
216
217	free(plist_vers);
218	free(plist_compat_vers);
219	free(sysctl_vers);
220	free(sysctl_compat_vers);
221
222	T_PASS("verified version information with Mac OS X shim enabled");
223	#else // TARGET_OS_OSX
224	T_SKIP("system version compat only supported on macOS");
225	#endif // TARGET_OS_OSX
226	}
227
228	T_DECL(test_system_version_compat_enabled_ios,
229	"Tests reading system product information with the iOS system version compat shim enabled",
230	T_META_ENVVAR("SYSTEM_VERSION_COMPAT=2"))
231	{
232	#if TARGET_OS_OSX
233	char opened_path[MAXPATHLEN] = { '\0' };
234
235	check_ios_version_plist_exists();
236
237	// Read out the ProductVersion from SystemVersion.plist and ensure that it contains the same value as the
238	// iOSSupportVersion key
239
240	__block char read_plist_vers = NULL, read_ios_support_version = NULL;
241
242	int version_plist_fd = open(SYSTEM_VERSION_PLIST_PATH, O_RDONLY);
243	T_QUIET; T_WITH_ERRNO; T_ASSERT_GT(version_plist_fd, 0, "opened %s", SYSTEM_VERSION_PLIST_PATH);
244
245	// Resolve the full path of the file we've opened, verify it was shimmed as expected
246	int ret = fcntl(version_plist_fd, F_GETPATH, opened_path);
247	T_QUIET; T_WITH_ERRNO; T_EXPECT_NE(ret, -1, "F_GETPATH on opened SystemVersion.plist");
248	if (ret != -1) {
249	size_t opened_path_strlen = strlen(opened_path);
250	T_QUIET; T_EXPECT_GE(opened_path_strlen, strlen(IOS_SYSTEM_VERSION_PLIST_PATH), "opened path string length");
251	T_EXPECT_EQ_STR(IOS_SYSTEM_VERSION_PLIST_PATH, (const char *)&opened_path[(opened_path_strlen - strlen(IOS_SYSTEM_VERSION_PLIST_PATH))],
252	"opened file path shimmed (iOS)");
253	}
254
255	// Read and parse the attributes from the SystemVersion plist
256	dispatch_semaphore_t sema = dispatch_semaphore_create(0);
257	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
258	xpc_create_from_plist_descriptor(version_plist_fd, queue, ^(xpc_object_t object) {
259	if (object == NULL) {
260	T_ASSERT_FAIL("Failed to parse dictionary from %s", SYSTEM_VERSION_PLIST_PATH);
261	}
262	if (xpc_get_type(object) != XPC_TYPE_DICTIONARY) {
263	T_ASSERT_FAIL("%s does not contain dictionary plist", SYSTEM_VERSION_PLIST_PATH);
264	}
265
266	const char *plist_version = xpc_dictionary_get_string(object, PRODUCT_VERSION_KEY);
267	if (plist_version) {
268	T_LOG("Found %s for %s from %s", plist_version, PRODUCT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
269	read_plist_vers = strdup(plist_version);
270	}
271
272	const char *ios_support_version = xpc_dictionary_get_string(object, IOS_SUPPORT_VERSION_KEY);
273	if (ios_support_version) {
274	T_LOG("Found %s for %s from %s", ios_support_version, IOS_SUPPORT_VERSION_KEY, SYSTEM_VERSION_PLIST_PATH);
275	read_ios_support_version = strdup(ios_support_version);
276	}
277
278	dispatch_semaphore_signal(sema);
279	});
280	dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
281
282	close(version_plist_fd);
283	version_plist_fd = -1;
284
285	// Verify the data matches
286	T_EXPECT_EQ_STR(read_plist_vers, read_ios_support_version, "%s %s matches %s value", SYSTEM_VERSION_PLIST_PATH,
287	PRODUCT_VERSION_KEY, IOS_SUPPORT_VERSION_KEY);
288
289	T_PASS("verified version information with iOS shim enabled");
290
291	#else // TARGET_OS_OSX
292	T_SKIP("iOS system version shim only supported on macOS");
293	#endif // TARGET_OS_OSX
294	}