C语言IOCP

C语言的IOCP example

#include <winsock2.h>
#include <ws2tcpip.h>
#include <mswsock.h>
#include <stdio.h>

#pragma comment(lib, "ws2_32.lib")

#define   Port				5000
#define   Max_Buffer_Size   4096
#define   Max_Threads		2

static GUID ax_guid = WSAID_ACCEPTEX;
static GUID as_guid = WSAID_GETACCEPTEXSOCKADDRS;

const char res_bufs[] = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\n\r\nWelcome to Server.";

LPFN_ACCEPTEX              lpfn_AcceptEx;
LPFN_GETACCEPTEXSOCKADDRS  lpfn_GetAcceptExSockAddrs;

HANDLE						iocp;
SOCKET                      listener;

typedef struct
{
	OVERLAPPED		overlapped;
	SOCKET			accept;
	WSABUF			wsa_buf;
	CHAR			buf[Max_Buffer_Size];
	DWORD			bytes_send;
	DWORD			bytes_recv;
	int				action;

} Pre_IO_Context, *LP_Pre_IO_Context;

int init(void);

DWORD WINAPI worker_thread(LPVOID iocp);

int post_accept_ex();
int post_recv(Pre_IO_Context* io_ctx);
int post_send(Pre_IO_Context* io_ctx);

int do_accept(HANDLE iocp, Pre_IO_Context* io_ctx);
int do_recv(Pre_IO_Context* io_ctx);
int do_send(Pre_IO_Context* io_ctx);

int main(void)
{
	int						i;
	DWORD					thread_id;
	HANDLE                  threads[Max_Threads];
	LINGER					linger;
	SOCKADDR_IN				inet_addr;

	int opt_val = 1;
	int opt_len = sizeof(int);

	printf("Win IOCP");

	if (-1 == init())
	{
		printf("init failed.");
		return -1;
	}

	if ((iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0)) == NULL)
	{
		printf("CreateIoCompletionPort Failed，err: %d\n", GetLastError());
		return -1;
	}

	for (i = 0; i < Max_Threads; i++)
	{
		if ((threads[i] = CreateThread(NULL, 0, worker_thread, iocp, 0, &thread_id)) == NULL)
		{
			printf("CreateThread() failed. error: %d\n", GetLastError());
			CloseHandle(iocp);
			WSACleanup();
			return -1;
		}
	}

	if ((listener = WSASocketW(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)
	{
		printf("WSASocket() failed. error: %d\n", WSAGetLastError());
		WSACleanup();
		return -1;
	}

	if (-1 == setsockopt(listener, SOL_SOCKET, SO_KEEPALIVE, (const void*)& opt_val, opt_len))
	{
		printf("setsockopt(SO_KEEPALIVE) failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	// closesocket: return immediately and send RST
	linger.l_onoff = 1;
	linger.l_linger = 0;
	if (-1 == setsockopt(listener, SOL_SOCKET, SO_LINGER, (char*)& linger, sizeof(linger)))
	{
		printf("setsockopt(SO_LINGER) failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	// Windows only support SO_REUSEADDR
	if (-1 == setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (const void*)& opt_val, opt_len))
	{
		printf("setsockopt(SO_REUSEADDR) failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	if (INVALID_HANDLE_VALUE == CreateIoCompletionPort((HANDLE)listener, iocp, 0, 0))
	{
		printf("CreateIoCompletionPort(listener) failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	printf("Associate socket with iocp. socket: %I64d, iocp: %p \n", listener, iocp);

	inet_addr.sin_family = AF_INET;
	inet_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	inet_addr.sin_port = htons(Port);
	if (SOCKET_ERROR == bind(listener, (PSOCKADDR)& inet_addr, sizeof(inet_addr)))
	{
		printf("bind() failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	if (SOCKET_ERROR == listen(listener, SOMAXCONN))
	{
		printf("listen() failed.");
		closesocket(listener);
		WSACleanup();
		CloseHandle(iocp);
		return -1;
	}

	printf("Listen on prot(%d).\n", Port);

	for (i = 0; i < Max_Threads; i++)
	{
		post_accept_ex();
	}

	// MAXIMUM_WAIT_OBJECTS
	WaitForMultipleObjects(Max_Threads, threads, FALSE, INFINITE);

	//PostQueuedCompletionStatus(iocp, 0, (DWORD)-1, NULL);

	printf("All threads exit.");

	return 0;
}

int init(void)
{
	SYSTEM_INFO		sys_info;
	WSADATA			wsa_data;

	DWORD			ret;
	SOCKET          s;

	GetSystemInfo(&sys_info);

	printf("System memery page size: %d \n", sys_info.dwPageSize);
	printf("System cpus: %d \n", sys_info.dwNumberOfProcessors);

	if ((ret = WSAStartup(0x0202, &wsa_data)) != 0)
	{
		printf("WSAStartup() failed. error: %d\n", ret);
		return -1;
	}

	if (LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2)
	{
		printf("Require Windows Socket Version 2.2 Error!\n");
		WSACleanup();
		return -1;
	}

	s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
	if (s == -1) {
		printf("socket() failed.");
		return -1;
	}

	if (-1 == WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &ax_guid, sizeof(GUID),
		&lpfn_AcceptEx, sizeof(LPFN_ACCEPTEX), &ret, NULL, NULL))
	{
		printf("WSAIoctl(LPFN_ACCEPTEX) failed.");
		return -1;
	}

	if (-1 == WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &as_guid, sizeof(GUID),
		&lpfn_GetAcceptExSockAddrs, sizeof(LPFN_GETACCEPTEXSOCKADDRS),
		&ret, NULL, NULL))
	{
		printf("WSAIoctl(LPFN_GETACCEPTEXSOCKADDRS) failed.");
		return -1;
	}

	if (-1 == closesocket(s)) {
		printf("closesocket() failed.");
		return -1;
	}

	return 0;
}

DWORD WINAPI worker_thread(LPVOID lp_iocp)
{
	DWORD				bytes;
	LP_Pre_IO_Context	io_ctx;

	DWORD				err_no = 0;
	HANDLE				iocp = (HANDLE)lp_iocp;
	PULONG_PTR			lp_completion_key = NULL;

	while (TRUE)
	{
		if (0 == GetQueuedCompletionStatus(iocp, &bytes, (PULONG_PTR)& lp_completion_key, (LPOVERLAPPED*)& io_ctx, INFINITE))
		{
			err_no = GetLastError();

			if (err_no) {

				if (WAIT_TIMEOUT == err_no) continue;

				if (ERROR_NETNAME_DELETED == err_no || ERROR_OPERATION_ABORTED == err_no)
				{
					printf("The socket was closed. error: %d\n", err_no);
					GlobalFree(io_ctx);

					continue;
				}

				printf("GetQueuedCompletionStatus() failed. error: %d\n", err_no);
				GlobalFree(io_ctx);

				return err_no;
			}
		}

		printf("GetQueuedCompletionStatus ---------------------------\n");

		if (NULL == io_ctx)
		{
			printf("GetQueuedCompletionStatus() returned no operation");
			continue;
		}

		printf("IO_Context: %p \n", io_ctx);
		printf("Bytes transferred: %d \n", bytes);
		printf("IO_Context->Action： %d\n", io_ctx->action);

		if (0 == bytes && 0 != io_ctx->action)
		{
			printf("No bytes transferred for the action.");
			GlobalFree(io_ctx);
			continue;
		}

		switch (io_ctx->action)
		{
		case 0:
			post_accept_ex();
			do_accept(iocp, io_ctx);
			post_recv(io_ctx);
			break;

		case 1:
			do_recv(io_ctx);
			post_send(io_ctx);
			break;

		case 2:
			do_send(io_ctx);
			break;

		default:
			printf("ERROR: No action match! \n");
			break;
		}
	}
}

int post_accept_ex()
{
	LP_Pre_IO_Context		io_ctx;

	printf("post_accept_ex. listner: %I64d\n", listener);

	if ((io_ctx = (LP_Pre_IO_Context)GlobalAlloc(GPTR, sizeof(Pre_IO_Context))) == NULL)
	{
		printf("GlobalAlloc() failed. error: %d\n", GetLastError());
		return -1;
	}

	ZeroMemory(&(io_ctx->overlapped), sizeof(OVERLAPPED));
	io_ctx->bytes_recv = 0;
	io_ctx->bytes_send = 0;
	io_ctx->wsa_buf.len = Max_Buffer_Size;
	io_ctx->wsa_buf.buf = io_ctx->buf;
	io_ctx->action = 0;

	io_ctx->accept = WSASocketW(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	if (INVALID_SOCKET == io_ctx->accept)
	{
		printf("WSASocketW() failed.\n");
		return -1;
	}

	if (0 == lpfn_AcceptEx(
		listener,

		io_ctx->accept,
		io_ctx->wsa_buf.buf,
		//io_ctx->wsa_buf.len - (sizeof(SOCKADDR_IN) + 16) * 2,
		0,

		sizeof(SOCKADDR_IN) + 16,
		sizeof(SOCKADDR_IN) + 16,

		&(io_ctx->bytes_recv),
		&(io_ctx->overlapped)
	)) {
		if (WSA_IO_PENDING != WSAGetLastError())
		{
			printf("LPFN_ACCEPTEX() failed. last error: %d\n", WSAGetLastError());
			return -1;
		}
	}

	printf("post_accept_ex. listner: %I64d, io_ctx: %p \n", listener, io_ctx);

	return 0;
}

int do_accept(HANDLE iocp, Pre_IO_Context* io_ctx)
{
	printf("do_accept. io_ctx: %p \n", io_ctx);

	SOCKADDR_IN* local_sock_addr = NULL;
	SOCKADDR_IN* remote_sock_addr = NULL;
	int addr_len = sizeof(SOCKADDR_IN);

	if (-1 == setsockopt(io_ctx->accept, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)& listener, sizeof(SOCKET)))
	{
		printf("setsockopt(SO_UPDATE_ACCEPT_CONTEXT) failed. error: %d\n", WSAGetLastError());
	}

	lpfn_GetAcceptExSockAddrs(
		io_ctx->wsa_buf.buf,
		io_ctx->wsa_buf.len - ((addr_len + 16) * 2),
		addr_len + 16,
		addr_len + 16,
		(SOCKADDR * *)& local_sock_addr, &addr_len,
		(SOCKADDR * *)& remote_sock_addr, &addr_len
	);

	printf("do_accept, client socket: %I64d \n", io_ctx->accept);

	if (NULL == CreateIoCompletionPort((HANDLE)io_ctx->accept, iocp, 0, 0))
	{
		printf("CreateIoCompletionPort() failed. error: %d\n", GetLastError());
		return -1;
	}

	return 0;
}

int post_recv(Pre_IO_Context* io_ctx)
{
	printf("post_recv. io_ctx: %p \n", io_ctx);

	DWORD flags = 0;
	DWORD bytes = 0;
	DWORD err_no;
	int ret;

	ZeroMemory(&(io_ctx->overlapped), sizeof(OVERLAPPED));
	io_ctx->bytes_recv = 0;
	io_ctx->bytes_send = 0;
	io_ctx->wsa_buf.len = Max_Buffer_Size;
	io_ctx->wsa_buf.buf = io_ctx->buf;
	io_ctx->action = 1;

	ret = WSARecv(io_ctx->accept, &(io_ctx->wsa_buf), 1, &bytes, &flags, &(io_ctx->overlapped), NULL);

	err_no = WSAGetLastError();
	if (-1 == ret && WSA_IO_PENDING != err_no)
	{
		if (err_no == WSAEWOULDBLOCK) printf("WSARecv() not ready");

		printf("WSARecv() faild. client socket: %I64d, error: %d\n", io_ctx->accept, err_no);

		return -1;
	}

	return 0;
}

int do_recv(Pre_IO_Context* io_ctx)
{
	printf("do_recv. io_ctx: %p \n", io_ctx);
	printf("do_recv: recv data：\n %s \n", io_ctx->wsa_buf.buf);

	ZeroMemory(&(io_ctx->overlapped), sizeof(OVERLAPPED));
	io_ctx->bytes_recv = 0;
	io_ctx->bytes_send = 0;
	io_ctx->wsa_buf.len = Max_Buffer_Size;
	io_ctx->wsa_buf.buf = io_ctx->buf;
	io_ctx->action = 10;

	return 0;
}

int post_send(Pre_IO_Context* io_ctx)
{
	printf("post_send. io_ctx: %p \n", io_ctx);

	DWORD flags = 0;
	DWORD bytes = 0;
	DWORD err_no;
	int ret;

	io_ctx->wsa_buf.buf = &res_bufs;
	io_ctx->wsa_buf.len = sizeof(res_bufs) - 1;

	//io_ctx->overlapped.hEvent = WSACreateEvent();
	io_ctx->action = 2;

	ret = WSASend(io_ctx->accept, &(io_ctx->wsa_buf), 1, &bytes, 0, &(io_ctx->overlapped), NULL);
	err_no = WSAGetLastError();

	if (-1 == ret && err_no != WSA_IO_PENDING)
	{
		printf("WSASend() faild. error: %d\n", err_no);

		//WSAResetEvent(io_ctx->overlapped.hEvent);
		return -1;
	}

	if (err_no == WSA_IO_PENDING)
	{
		printf("WSASend() posted. bytest: %d err: %d\n", bytes, err_no);
	}

	printf("WSASend send bytest: %d \n", bytes);

	/*
	WSAWaitForMultipleEvents(1, &io_ctx->overlapped.hEvent, TRUE, INFINITE, TRUE);
	printf("WSAWaitForMultipleEvents() failed. err: %d\n", WSAGetLastError());

	WSAGetOverlappedResult(io_ctx->accept, &io_ctx->overlapped, &io_ctx->bytes_send, FALSE, &flags);
	printf("WSAGetOverlappedResult() send bytes: %d\n", io_ctx->bytes_send);

	WSAResetEvent(io_ctx->overlapped.hEvent);
	printf("WSAResetEvent() err: %d\n", WSAGetLastError());
	*/

	return 0;
}

int do_send(Pre_IO_Context* io_ctx)
{
	printf("do_send. io_ctx: %p \n", io_ctx);

	shutdown(io_ctx->accept, SD_BOTH);
	GlobalFree(io_ctx);

	return 0;
}

　　

仅记录一个简单的示例，没有严谨的处理。同时谅解一下代码风格。