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;
}

　　

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

转载于:https://www.cnblogs.com/view85/p/11497064.html