init

Telegram/ThirdParty/dispatch/tests/dispatch_io_muxed.c

@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2019 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@
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#elif defined(_WIN32)
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <Windows.h>
+#endif
+
+#include <dispatch/dispatch.h>
+
+#include <bsdtests.h>
+#include "dispatch_test.h"
+
+#if !defined(_WIN32)
+#define closesocket(x) close(x)
+#endif
+
+static void
+test_file_muxed(void)
+{
+	printf("\nFile Muxed\n");
+
+#if defined(_WIN32)
+	const char *temp_dir = getenv("TMP");
+	if (!temp_dir) {
+		temp_dir = getenv("TEMP");
+	}
+	if (!temp_dir) {
+		test_ptr_notnull("temporary directory", temp_dir);
+		test_stop();
+	}
+	const char *path_separator = "\\";
+#else
+	const char *temp_dir = getenv("TMPDIR");
+	if (!temp_dir) {
+		temp_dir = "/tmp";
+	}
+	const char *path_separator = "/";
+#endif
+	char *path = NULL;
+	(void)asprintf(&path, "%s%sdispatchtest_io.XXXXXX", temp_dir, path_separator);
+	dispatch_fd_t fd = mkstemp(path);
+	if (fd == -1) {
+		test_errno("mkstemp", errno, 0);
+		test_stop();
+	}
+	if (unlink(path) == -1) {
+		test_errno("unlink", errno, 0);
+		test_stop();
+	}
+#if defined(_WIN32)
+	free(path);
+#endif
+	dispatch_test_fd_write(fd, "test", 4);
+	dispatch_test_fd_lseek(fd, 0, SEEK_SET);
+
+	dispatch_group_t g = dispatch_group_create();
+	dispatch_group_enter(g);
+	dispatch_group_enter(g);
+
+	dispatch_source_t reader = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ,
+			(uintptr_t)fd, 0, dispatch_get_global_queue(0, 0));
+	test_ptr_notnull("dispatch_source_create", reader);
+	assert(reader);
+	dispatch_source_set_event_handler(reader, ^{
+		dispatch_source_cancel(reader);
+	});
+	dispatch_source_set_cancel_handler(reader, ^{
+		dispatch_release(reader);
+		dispatch_group_leave(g);
+	});
+
+	dispatch_source_t writer = dispatch_source_create(
+			DISPATCH_SOURCE_TYPE_WRITE, (uintptr_t)fd, 0,
+			dispatch_get_global_queue(0, 0));
+	test_ptr_notnull("dispatch_source_create", writer);
+	assert(writer);
+	dispatch_source_set_event_handler(writer, ^{
+		dispatch_source_cancel(writer);
+	});
+	dispatch_source_set_cancel_handler(writer, ^{
+		dispatch_release(writer);
+		dispatch_group_leave(g);
+	});
+
+	dispatch_resume(reader);
+	dispatch_resume(writer);
+
+	test_group_wait(g);
+	dispatch_release(g);
+	dispatch_test_fd_close(fd);
+}
+
+static void
+test_stream_muxed(dispatch_fd_t serverfd, dispatch_fd_t clientfd)
+{
+	dispatch_group_t g = dispatch_group_create();
+	dispatch_group_enter(g);
+	dispatch_group_enter(g);
+
+	dispatch_source_t reader = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ,
+			(uintptr_t)serverfd, 0, dispatch_get_global_queue(0, 0));
+	test_ptr_notnull("dispatch_source_create", reader);
+	assert(reader);
+	dispatch_source_set_event_handler(reader, ^{
+		dispatch_source_cancel(reader);
+	});
+	dispatch_source_set_cancel_handler(reader, ^{
+		dispatch_release(reader);
+		dispatch_group_leave(g);
+	});
+
+	dispatch_source_t writer = dispatch_source_create(
+			DISPATCH_SOURCE_TYPE_WRITE, (uintptr_t)serverfd, 0,
+			dispatch_get_global_queue(0, 0));
+	test_ptr_notnull("dispatch_source_create", writer);
+	assert(writer);
+	dispatch_source_set_event_handler(writer, ^{
+		dispatch_source_cancel(writer);
+	});
+	dispatch_source_set_cancel_handler(writer, ^{
+		dispatch_release(writer);
+		dispatch_group_leave(g);
+	});
+
+	dispatch_resume(reader);
+	dispatch_resume(writer);
+
+	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 500 * NSEC_PER_MSEC),
+			dispatch_get_global_queue(0, 0), ^{
+		dispatch_group_enter(g);
+		char buf[512] = {0};
+		ssize_t n = dispatch_test_fd_write(clientfd, buf, sizeof(buf));
+		if (n < 0) {
+			test_errno("write error", errno, 0);
+			test_stop();
+		}
+		test_sizet("num written", (size_t)n, sizeof(buf));
+		dispatch_group_leave(g);
+	});
+
+	test_group_wait(g);
+	dispatch_release(g);
+}
+
+static void
+test_socket_muxed(void)
+{
+	printf("\nSocket Muxed\n");
+
+	int listenfd = -1, serverfd = -1, clientfd = -1;
+	struct sockaddr_in addr;
+	socklen_t addrlen;
+
+	listenfd = socket(AF_INET, SOCK_STREAM, 0);
+	if (listenfd == -1) {
+		test_errno("socket()", errno, 0);
+		test_stop();
+	}
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	addr.sin_port = 0;
+	addrlen = sizeof(addr);
+	if (bind(listenfd, (struct sockaddr *)&addr, addrlen) == -1) {
+		test_errno("bind()", errno, 0);
+		test_stop();
+	}
+	if (listen(listenfd, 3) == -1) {
+		test_errno("listen()", errno, 0);
+		test_stop();
+	}
+	if (getsockname(listenfd, (struct sockaddr *)&addr, &addrlen) == -1) {
+		test_errno("getsockname()", errno, 0);
+		test_stop();
+	}
+
+	clientfd = socket(AF_INET, SOCK_STREAM, 0);
+	if (clientfd == -1) {
+		test_errno("socket()", errno, 0);
+		test_stop();
+	}
+	if (connect(clientfd, (struct sockaddr *)&addr, addrlen)) {
+		test_errno("connect()", errno, 0);
+		test_stop();
+	}
+
+	serverfd = accept(listenfd, (struct sockaddr *)&addr, &addrlen);
+	if (serverfd == -1) {
+		test_errno("accept()", errno, 0);
+		test_stop();
+	}
+
+	test_stream_muxed((dispatch_fd_t)serverfd, (dispatch_fd_t)clientfd);
+
+	closesocket(clientfd);
+	closesocket(serverfd);
+	closesocket(listenfd);
+}
+
+#if defined(_WIN32)
+static void
+test_pipe_muxed(void)
+{
+	printf("\nDuplex Pipe Muxed\n");
+
+	wchar_t name[64];
+	swprintf(name, sizeof(name), L"\\\\.\\pipe\\dispatch_io_muxed_%lu",
+			GetCurrentProcessId());
+	HANDLE server = CreateNamedPipeW(name,
+			PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE, PIPE_TYPE_BYTE,
+			/* nMaxInstances */ 1, /* nOutBufferSize */ 0x1000,
+			/* nInBufferSize */ 0x1000, /* nDefaultTimeOut */ 0,
+			/* lpSecurityAttributes */ NULL);
+	if (server == INVALID_HANDLE_VALUE) {
+		test_ptr_not("CreateNamedPipe", server, INVALID_HANDLE_VALUE);
+		test_stop();
+	}
+	HANDLE client = CreateFileW(name, GENERIC_READ | GENERIC_WRITE,
+			/* dwShareMode */ 0, /* lpSecurityAttributes */ NULL, OPEN_EXISTING,
+			/* dwFlagsAndAttributes */ 0, /* hTemplateFile */ NULL);
+	if (client == INVALID_HANDLE_VALUE) {
+		test_ptr_not("CreateFile", client, INVALID_HANDLE_VALUE);
+		test_stop();
+	}
+
+	test_stream_muxed((dispatch_fd_t)server, (dispatch_fd_t)client);
+
+	CloseHandle(client);
+	CloseHandle(server);
+}
+#endif
+
+int
+main(void)
+{
+	dispatch_test_start("Dispatch IO Muxed");
+#if defined(_WIN32)
+	WSADATA wsa;
+	int err = WSAStartup(MAKEWORD(2, 2), &wsa);
+	if (err != 0) {
+		fprintf(stderr, "WSAStartup failed with %d\n", err);
+		test_stop();
+	}
+#endif
+	dispatch_async(dispatch_get_main_queue(), ^{
+		test_file_muxed();
+		test_socket_muxed();
+#if defined(_WIN32)
+		test_pipe_muxed();
+#endif
+		test_stop();
+	});
+	dispatch_main();
+}