【通信协议及编码】实验1：阻塞、非阻塞和异步模式套接字客户机与服务器程序

最新推荐文章于 2022-07-06 00:02:50 发布
最新推荐文章于 2022-07-06 00:02:50 发布
阅读量372 收藏 1
点赞数 1
分类专栏： 通信协议 文章标签： 服务器 网络 winsock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45614178/article/details/122564021
版权

文章目录

一、实验目的

  1. 掌握WinSock2 API编程框架；
  2. 掌握阻塞模式和非阻赛模式套接字的原理和编程方法；
  3. 掌握异步套接字的原理和编程方法；

二、实验环境

  1. 操作系统：WINDOWS 7及以上
  2. 开发工具：Microsoft VisualBasic6.0
  3. 实验设备：PC

三、实验内容

  1. 编程实现： 设计一个可完成阻塞模式套接字通信的客户机和服务器，并完成联机调试，能要求：收到客户机的连接请求后向客户机发送一条友好消息“服务器说：有朋自远方来，不亦乐乎”。
  2. 编程实现： 设计一个可完成非阻塞模式套接字通信的客户机和服务器，并实现联机调试。
  3. 编程实现： 设计一个可完成异步模式套接字通信的客户机和服务器，并实现联机调试。

1.阻塞模式套接字通信的客户机和服务器

1.代码：
服务器:

#include<iostream>
#include<WinSock2.h>
#pragma comment(lib,"ws2_32.lib")
int main() {
	WSADATA WsaDat;
	if (WSAStartup(MAKEWORD(2, 2), &WsaDat) != 0) {
		std::cout << "WinSock服务初始化失败！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}
	SOCKET Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (Socket == INVALID_SOCKET) {
		std::cout << "创建套接字失败！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}

	SOCKADDR_IN serverInf;
	serverInf.sin_family = AF_INET;
	serverInf.sin_addr.s_addr = INADDR_ANY;
	serverInf.sin_port = htons(8888);
	if (bind(Socket, (SOCKADDR*)(&serverInf), sizeof(serverInf)) == SOCKET_ERROR)
	{
		std::cout << "不能绑定地址信息到套接字！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}
	listen(Socket, 1);
	SOCKET TempSock = SOCKET_ERROR;
	while (TempSock == SOCKET_ERROR) {
		std::cout << "服务器：正在等待来自客户机的连接!\r\n";
		TempSock = accept(Socket, NULL, NULL);
	}
	Socket = TempSock;
	std::cout << "服务器：有客户机连接到达！\r\n\r\n";
	char * szMessage = (char*) "服务器说：有朋自远方来，不亦乐乎\r\n";
	send(Socket, szMessage, strlen(szMessage), 0);
	shutdown(Socket, SD_SEND);

	closesocket(Socket);
	//关闭
	WSACleanup();
	system("pause");
	return 0;
}

客户机：

#include<iostream>
#include<WinSock2.h>
#pragma comment(lib,"ws2_32.lib")
int main()
{
	//初始化WinSock服务
	WSADATA WsaDat;
	if (WSAStartup(MAKEWORD(2, 2), &WsaDat) != 0) {
		std::cout << "WinSock错误 - WinSock服务初始化失败！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}

	//创建套接字
	SOCKET Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (Socket == INVALID_SOCKET) {
		std::cout << "套接字错误 - 创建套接字失败！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}

	//主机名解析
	struct  hostent*host;
	if ((host = gethostbyname("localhost")) == NULL)
	{
		std::cout << "主机名解析失败！\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}

	//配置套接字要访问的服务器的地址结构信息
	SOCKADDR_IN SockAddr;
	SockAddr.sin_port = htons(8888);
	SockAddr.sin_family = AF_INET;
	SockAddr.sin_addr.s_addr = *((unsigned long*)host->h_addr);

	//连接服务器
	if (connect(Socket, (SOCKADDR*)(&SockAddr), sizeof(SockAddr)) != 0) {
		std::cout << "服务器连接失败!\r\n";
		WSACleanup();
		system("pause");
		return 0;
	}

	//从服务器接收信息并显示
	char buffer[1024];
	memset(buffer, 0, 1023);
	int inDataLength = recv(Socket, buffer, 1024, 0);
	std::cout << buffer;

	//断开套接字连接
	shutdown(Socket, SD_SEND);
	//关闭套接字
	closesocket(Socket);
	WSACleanup();
	system("pause");
	return 0;
}

2.运行结果：
服务器：
在这里插入图片描述
客户机：
在这里插入图片描述
客户机服务器连接失败：
在这里插入图片描述

2.非阻塞模式套接字通信的客户机和服务器

1.代码：
服务器：

#include <iostream>
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")

int main()
{
	WSADATA WsaDat;
	if (WSAStartup(MAKEWORD(2, 2), &WsaDat) != 0)
	{
		std::cout << "Winsock服务初始化失败!\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	SOCKET Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (Socket == INVALID_SOCKET)
	{
		std::cout << "创建套接字失败！\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	SOCKADDR_IN serverInf;
	serverInf.sin_family = AF_INET;
	serverInf.sin_addr.s_addr = INADDR_ANY;
	serverInf.sin_port = htons(8888);

	if (bind(Socket, (SOCKADDR*)(&serverInf), sizeof(serverInf)) == SOCKET_ERROR)
	{
		std::cout << "套接字绑定失败!\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	listen(Socket, 1);

	SOCKET TempSock = SOCKET_ERROR;
	while (TempSock == SOCKET_ERROR)
	{
		std::cout << "服务器：正在等待客户机连接...\r\n";
		TempSock = accept(Socket, NULL, NULL);
	}

	//  iMode!=0表示阻塞模式
	u_long iMode = 1;
	ioctlsocket(Socket, FIONBIO, &iMode);

	Socket = TempSock;
	std::cout << "服务器说：有新客户机连接到达!\r\n\r\n";

	// 主循环
	for (;;)
	{
		char *szMessage = (char*)"非阻塞服务器说：有朋自远方来来，不亦乐乎\r\n";
		send(Socket, szMessage, strlen(szMessage), 0);

		int nError = WSAGetLastError();
		if (nError != WSAEWOULDBLOCK && nError != 0)
		{
			std::cout << "Winsock错误码为: " << nError << "\r\n";
			std::cout << "客户机断开连接!\r\n";

			// 断开套接字，不允许发送，可以接收
			shutdown(Socket, SD_SEND);

			// 关闭套接字
			closesocket(Socket);

			break;
		}

		Sleep(1000);
	}

	WSACleanup();
	system("PAUSE");
	return 0;
}

客户机：

#include <iostream>
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")

int main(void)
{
	WSADATA WsaDat;
	if(WSAStartup(MAKEWORD(2,2),&WsaDat)!=0)
	{
		std::cout<<"Winsock错误 - Winsock初始化失败\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	// 创建套接字

	SOCKET Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if(Socket==INVALID_SOCKET)
	{
		std::cout<<"Winsock错误 - 创建套接字失败!\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	// 解析主机名
	struct hostent *host;
	if((host=gethostbyname("localhost"))==NULL)
	{
		std::cout<<"解析主机名失败！\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	// 配置套接字地址结构信息
	SOCKADDR_IN SockAddr;
	SockAddr.sin_port=htons(8888);
	SockAddr.sin_family=AF_INET;
	SockAddr.sin_addr.s_addr=*((unsigned long*)host->h_addr);

	// 连接服务器
	if(connect(Socket,(SOCKADDR*)(&SockAddr),sizeof(SockAddr))!=0)
	{
		std::cout<<"连接服务器失败！\r\n";
		WSACleanup();
		system("PAUSE");
		return 0;
	}

	//  iMode!=0是阻塞模式
	u_long iMode=1;
	ioctlsocket(Socket,FIONBIO,&iMode);

	// 主循环
	for(;;)
	{
		// 接收服务器信息
		char buffer[1024];
		memset(buffer,0,1023);
		int inDataLength=recv(Socket,buffer,1024,0);
		std::cout<<buffer;

		int nError=WSAGetLastError();
		if(nError!=WSAEWOULDBLOCK&&nError!=0)
		{
			std::cout<<"Winsock错误码为: "<<nError<<"\r\n";
			std::cout<<"服务器断开连接!\r\n";
			// 断开套接字，只能接收不能发送
			shutdown(Socket,SD_SEND);

			// 关闭套接字
			closesocket(Socket);

			break;
		}
		Sleep(1000);
	}

	WSACleanup();
	system("PAUSE");
	return 0;
}

2.运行结果：
服务器：
在这里插入图片描述
客户机：
在这里插入图片描述
客户机服务器连接失败：
在这里插入图片描述
连接时客户机断开：
在这里插入图片描述

3.异步模式套接字通信的客户机和服务器

1.代码：
服务器：

#include <winsock2.h>
#include <windows.h>

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

#define IDC_EDIT_IN		101
#define IDC_EDIT_OUT		102
#define IDC_MAIN_BUTTON		103
#define WM_SOCKET		104

int nPort = 5555;

HWND hEditIn = NULL;
HWND hEditOut = NULL;
SOCKET Socket = NULL;
char szHistory[10000];
sockaddr sockAddrClient;

LRESULT CALLBACK WinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASSEX wClass;
	ZeroMemory(&wClass, sizeof(WNDCLASSEX));
	wClass.cbClsExtra = NULL;
	wClass.cbSize = sizeof(WNDCLASSEX);
	wClass.cbWndExtra = NULL;
	wClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
	wClass.hCursor = LoadCursor(NULL, IDC_ARROW);
	wClass.hIcon = NULL;
	wClass.hIconSm = NULL;
	wClass.hInstance = hInst;
	wClass.lpfnWndProc = (WNDPROC)WinProc;
	wClass.lpszClassName = "Window Class";
	wClass.lpszMenuName = NULL;
	wClass.style = CS_HREDRAW | CS_VREDRAW;

	if (!RegisterClassEx(&wClass))
	{
		int nResult = GetLastError();
		MessageBox(NULL,
			"窗体类注册失败！\r\n错误码:",
			"窗体类注册错误",
			MB_ICONERROR);
	}

	HWND hWnd = CreateWindowEx(NULL,
		"Window Class",
		"异步套接字服务器",
		WS_OVERLAPPEDWINDOW,
		200,
		200,
		500,
		400,
		NULL,
		NULL,
		hInst,
		NULL);

	if (!hWnd)
	{
		int nResult = GetLastError();

		MessageBox(NULL,
			"创建窗体失败\r\n错误码:",
			"窗体创建错误",
			MB_ICONERROR);
	}

	ShowWindow(hWnd, nShowCmd);

	MSG msg;
	ZeroMemory(&msg, sizeof(MSG));

	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}

LRESULT CALLBACK WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_MAIN_BUTTON:
			{
				char szBuffer[1024];
				ZeroMemory(szBuffer, sizeof(szBuffer));

				SendMessage(hEditOut,
					WM_GETTEXT,
					sizeof(szBuffer),
					reinterpret_cast<LPARAM>(szBuffer));

				send(Socket, szBuffer, strlen(szBuffer), 0);

				SendMessage(hEditOut, WM_SETTEXT, NULL, (LPARAM)"");
			}
			break;
		}
		break;
	case WM_CREATE:
		{
			ZeroMemory(szHistory, sizeof(szHistory));

			// 创建接收消息框
			hEditIn = CreateWindowEx(WS_EX_CLIENTEDGE,
				"EDIT",
				"",
				WS_CHILD | WS_VISIBLE | ES_MULTILINE |
				ES_AUTOVSCROLL | ES_AUTOHSCROLL,
				50,
				100,
				400,
				200,
				hWnd,
				(HMENU)IDC_EDIT_IN,
				GetModuleHandle(NULL),
				NULL);
			if (!hEditIn)
			{
				MessageBox(hWnd,
					"不能创建接收消息框",
					"错误",
					MB_OK | MB_ICONERROR);
			}
			HGDIOBJ hfDefault = GetStockObject(DEFAULT_GUI_FONT);
			SendMessage(hEditIn,
				WM_SETFONT,
				(WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));
			SendMessage(hEditIn,
				WM_SETTEXT,
				NULL,
				(LPARAM)"正在等待客户机连接...");

			// 创建发送消息框
			hEditOut = CreateWindowEx(WS_EX_CLIENTEDGE,
				"EDIT",
				"",
				WS_CHILD | WS_VISIBLE | ES_MULTILINE |
				ES_AUTOVSCROLL | ES_AUTOHSCROLL,
				50,
				30,
				400,
				60,
				hWnd,
				(HMENU)IDC_EDIT_IN,
				GetModuleHandle(NULL),
				NULL);
			if (!hEditOut)
			{
				MessageBox(hWnd,
					"不能创建发送消息框",
					"错误",
					MB_OK | MB_ICONERROR);
			}

			SendMessage(hEditOut,
				WM_SETFONT,
				(WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));
			SendMessage(hEditOut,
				WM_SETTEXT,
				NULL,
				(LPARAM)"在此处输入要发送的消息...");

			// 创建发送按钮
			HWND hWndButton = CreateWindow(
				"BUTTON",
				"发送",
				WS_TABSTOP | WS_VISIBLE |
				WS_CHILD | BS_DEFPUSHBUTTON,
				50,
				310,
				75,
				23,
				hWnd,
				(HMENU)IDC_MAIN_BUTTON,
				GetModuleHandle(NULL),
				NULL);

			SendMessage(hWndButton,
				WM_SETFONT,
				(WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));

			WSADATA WsaDat;
			int nResult = WSAStartup(MAKEWORD(2, 2), &WsaDat);
			if (nResult != 0)
			{
				MessageBox(hWnd,
					"Winsock服务初始化失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			if (Socket == INVALID_SOCKET)
			{
				MessageBox(hWnd,
					"创建套接字失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			SOCKADDR_IN SockAddr;
			SockAddr.sin_port = htons(nPort);
			SockAddr.sin_family = AF_INET;
			SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);

			if (bind(Socket, (LPSOCKADDR)&SockAddr, sizeof(SockAddr)) == SOCKET_ERROR)
			{
				MessageBox(hWnd, "套接字绑定失败", "错误", MB_OK);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			nResult = WSAAsyncSelect(Socket,
				hWnd,
				WM_SOCKET,
				(FD_CLOSE | FD_ACCEPT | FD_READ));
			if (nResult)
			{
				MessageBox(hWnd,
					"WSAAsyncSelect 套接字异步事件初始化失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			if (listen(Socket, (1)) == SOCKET_ERROR)
			{
				MessageBox(hWnd,
					"服务器套接字侦听失败!",
					"错误",
					MB_OK);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}
		}
		break;

	case WM_DESTROY:
		{
			PostQuitMessage(0);
			shutdown(Socket, SD_BOTH);
			closesocket(Socket);
			WSACleanup();
			return 0;
		}
		break;

	case WM_SOCKET:
		{
			switch (WSAGETSELECTEVENT(lParam))
			{
			case FD_READ:
				{
					char szIncoming[1024];
					ZeroMemory(szIncoming, sizeof(szIncoming));

					int inDataLength = recv(Socket,
						(char*)szIncoming,
						sizeof(szIncoming) / sizeof(szIncoming[0]),
						0);

					strncat(szHistory, szIncoming, inDataLength);
					strcat(szHistory, "\r\n");

					SendMessage(hEditIn,
						WM_SETTEXT,
						sizeof(szIncoming) - 1,
						reinterpret_cast<LPARAM>(&szHistory));
				}
				break;

			case FD_CLOSE:
				{
					MessageBox(hWnd,
						"客户机关闭了到服务器的连接",
						"连接关闭",
						MB_ICONINFORMATION | MB_OK);
					closesocket(Socket);
					SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				}
				break;

			case FD_ACCEPT:
				{
					int size = sizeof(sockaddr);
					Socket = accept(wParam, &sockAddrClient, &size);
					if (Socket == INVALID_SOCKET)
					{
						int nret = WSAGetLastError();
						WSACleanup();
					}
					SendMessage(hEditIn,
						WM_SETTEXT,
						NULL,
						(LPARAM)"客户机已经成功连接到服务器");
				}
				break;
			}
		}
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}

客户机：

#include <winsock2.h>
#include <windows.h>

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

#define IDC_EDIT_IN		101
#define IDC_EDIT_OUT		102
#define IDC_MAIN_BUTTON		103
#define WM_SOCKET		104

char *szServer = (char*)"localhost";
int nPort = 5555;

HWND hEditIn = NULL;
HWND hEditOut = NULL;
SOCKET Socket = NULL;
char szHistory[10000];

LRESULT CALLBACK WinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASSEX wClass;
	ZeroMemory(&wClass, sizeof(WNDCLASSEX));
	wClass.cbClsExtra = NULL;
	wClass.cbSize = sizeof(WNDCLASSEX);
	wClass.cbWndExtra = NULL;
	wClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
	wClass.hCursor = LoadCursor(NULL, IDC_ARROW);
	wClass.hIcon = NULL;
	wClass.hIconSm = NULL;
	wClass.hInstance = hInst;
	wClass.lpfnWndProc = (WNDPROC)WinProc;
	wClass.lpszClassName = "Window Class";
	wClass.lpszMenuName = NULL;
	wClass.style = CS_HREDRAW | CS_VREDRAW;

	if (!RegisterClassEx(&wClass))
	{
		int nResult = GetLastError();
		MessageBox(NULL,
			"窗体类注册失败！\r\n错误码:" + nResult,
			"窗体类错误",
			MB_ICONERROR);
	}

	HWND hWnd = CreateWindowEx(NULL,
		"Window Class",
		"异步套接字客户机",
		WS_OVERLAPPEDWINDOW,
		200,
		200,
		500,
		400,
		NULL,
		NULL,
		hInst,
		NULL);

	if (!hWnd)
	{
		int nResult = GetLastError();
		MessageBox(NULL,
			"创建窗体失败\r\n错误码：",
			"创建窗体失败",
			MB_ICONERROR);
	}

	ShowWindow(hWnd, nShowCmd);

	MSG msg;
	ZeroMemory(&msg, sizeof(MSG));

	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}

LRESULT CALLBACK WinProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_CREATE:
		{
			ZeroMemory(szHistory, sizeof(szHistory));

			// 创建接收消息框
			hEditIn = CreateWindowEx(WS_EX_CLIENTEDGE,
				"EDIT",
				"",
				WS_CHILD | WS_VISIBLE | ES_MULTILINE |
				ES_AUTOVSCROLL | ES_AUTOHSCROLL,
				50,
				100,
				400,
				200,
				hWnd,
				(HMENU)IDC_EDIT_IN,
				GetModuleHandle(NULL),
				NULL);
			if (!hEditIn)
			{
				MessageBox(hWnd,
					"不能创建接收消息框",
					"错误",
					MB_OK | MB_ICONERROR);
			}
			HGDIOBJ hfDefault = GetStockObject(DEFAULT_GUI_FONT);
			SendMessage(hEditIn,
				WM_SETFONT,
				(WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));
			SendMessage(hEditIn,
				WM_SETTEXT,
				NULL,
				(LPARAM)"正在连接服务器...");

			//创建发送消息框
			hEditOut = CreateWindowEx(WS_EX_CLIENTEDGE,
				"EDIT",
				"",
				WS_CHILD | WS_VISIBLE | ES_MULTILINE |
				ES_AUTOVSCROLL | ES_AUTOHSCROLL,
				50,
				30,
				400,
				60,
				hWnd,
				(HMENU)IDC_EDIT_IN,
				GetModuleHandle(NULL),
				NULL);
			if (!hEditOut)
			{
				MessageBox(hWnd,
					"不能创建发送消息框",
					"错误",
					MB_OK | MB_ICONERROR);
			}

			SendMessage(hEditOut,
				WM_SETFONT, (WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));
			SendMessage(hEditOut,
				WM_SETTEXT,
				NULL,
				(LPARAM)"在这里输入要发送的消息...");

			// Create a push button
			HWND hWndButton = CreateWindow(
				"BUTTON",
				"发送",
				WS_TABSTOP | WS_VISIBLE |
				WS_CHILD | BS_DEFPUSHBUTTON,
				50,
				310,
				75,
				23,
				hWnd,
				(HMENU)IDC_MAIN_BUTTON,
				GetModuleHandle(NULL),
				NULL);

			SendMessage(hWndButton,
				WM_SETFONT,
				(WPARAM)hfDefault,
				MAKELPARAM(FALSE, 0));

			// 配置Winsock套接字
			WSADATA WsaDat;
			int nResult = WSAStartup(MAKEWORD(2, 2), &WsaDat);
			if (nResult != 0)
			{
				MessageBox(hWnd,
					"Winsock初始化失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			if (Socket == INVALID_SOCKET)
			{
				MessageBox(hWnd,
					"创建套接字失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			nResult = WSAAsyncSelect(Socket, hWnd, WM_SOCKET, (FD_CLOSE | FD_READ));
			if (nResult)
			{
				MessageBox(hWnd,
					"WSAAsyncSelect异步套接字失败",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			// 主机名称解析
			struct hostent *host;
			if ((host = gethostbyname(szServer)) == NULL)
			{
				MessageBox(hWnd,
					"不能解析主机名",
					"严重错误",
					MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}

			// 配置套接字地址信息
			SOCKADDR_IN SockAddr;
			SockAddr.sin_port = htons(nPort);
			SockAddr.sin_family = AF_INET;
			SockAddr.sin_addr.s_addr = *((unsigned long*)host->h_addr);

			connect(Socket, (LPSOCKADDR)(&SockAddr), sizeof(SockAddr));
		}
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_MAIN_BUTTON:
			{
				char szBuffer[1024];

				int test = sizeof(szBuffer);
				ZeroMemory(szBuffer, sizeof(szBuffer));

				SendMessage(hEditOut,
					WM_GETTEXT,
					sizeof(szBuffer),
					reinterpret_cast<LPARAM>(szBuffer));
				send(Socket, szBuffer, strlen(szBuffer), 0);
				SendMessage(hEditOut, WM_SETTEXT, NULL, (LPARAM)"");
			}
			break;
		}
		break;

	case WM_DESTROY:
		{
			PostQuitMessage(0);
			shutdown(Socket, SD_BOTH);
			closesocket(Socket);
			WSACleanup();
			return 0;
		}
		break;

	case WM_SOCKET:
		{
			if (WSAGETSELECTERROR(lParam))
			{
				MessageBox(hWnd,
					"连接服务器失败",
					"错误",
					MB_OK | MB_ICONERROR);
				SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				break;
			}
			switch (WSAGETSELECTEVENT(lParam))
			{
			case FD_READ:
				{
					char szIncoming[1024];
					ZeroMemory(szIncoming, sizeof(szIncoming));

					int inDataLength = recv(Socket,
						(char*)szIncoming,
						sizeof(szIncoming) / sizeof(szIncoming[0]),
						0);

					strncat(szHistory, szIncoming, inDataLength);
					strcat(szHistory, "\r\n");

					SendMessage(hEditIn,
						WM_SETTEXT,
						sizeof(szIncoming) - 1,
						reinterpret_cast<LPARAM>(&szHistory));
				}
				break;

			case FD_CLOSE:
				{
					MessageBox(hWnd,
						"服务器关闭了连接",
						"连接关闭",
						MB_ICONINFORMATION | MB_OK);
					closesocket(Socket);
					SendMessage(hWnd, WM_DESTROY, NULL, NULL);
				}
				break;
			}
		}
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}

2.运行结果截图：
服务器：
在这里插入图片描述
客户机：
在这里插入图片描述
发送消息：
在这里插入图片描述
在这里插入图片描述
连接关闭：
在这里插入图片描述
在这里插入图片描述

悠哟哟
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
串口通信非阻塞
08-24
串口通信非阻塞方式，发送数据，接收数据并保存到文件（当间隔n毫秒没有再收到数据表示一次接收完毕，将数据保存到文件）
《Windows网络编程案例教程》-董相志 学习记录 异步套接字编程
qq_48235921的博客
12-11 1169
《Windows网络编程案例教程》-董相志 学习记录 异步套接字编程 2.4 异步套接字编程 异步套接字客户机编程 异步套接字服务器编程 服务器响应客户机群的并发访问 2.4.1 异步套接字客户机编程 创建步骤如下： 1.创建程序界面，显示窗体和控件 2.定义宏常量 3.异步套接字初始化 4.配置套接字地址信息 5.连接服务器 6.在窗体回调函数里处理套接字消息事件 表2.5 套接字事件列表 //程序2.9 异步套接字客户机完整代码 #include <winsock2.h> #incl
高级Socket编程技术
Sum
03-24 2576
高级Socket编程技术 实验目的 1.了解阻塞与非阻塞模式Socket编程的工作原理。 2.了解Socket编程的5种模型的工作原理和使用方法。 3.掌握Select模型和WSAAsyncSelect模型的网络应用程序编程。 二、实验内容 1．参考教材编写工作于非阻塞模式的多线程TCP服务器应用程序和工作于非阻塞模式客户端应用程序，并进行数据收发测试。 2．编写基于WSAAsyncSelect模型、工作于并发方式的基于对话框的TCP服务器程序和客户端程序，并进行数据收发测试。 基于WSAAsyncSel
socket编程中的阻塞和非阻塞 以及 I/O复用总结
qi_700的博客
03-06 1152
socket编程中的阻塞和非阻塞 以及 I/O复用总结 一、阻塞及非阻塞        阻塞：一般的I/O操作可以在新建的流中运用.在服务器回应前它等待客户端发送一个空白的行.当会话结束时,服务器关闭流和客户端socket.如果在队列中没有请示将
实验四 串行通信实验
weixin_45784275的博客
06-13 5598
1、熟练掌握Keil和Proteus软件的C51设计与仿真操作 2、锻炼算法设计能力 3、熟练掌握定时计数器、外部中断的编程设计 4、掌握串行通信编程方法
异步socket套接字服务端实例案例代码.zip
05-25
本实例案例主要关注的是异步Socket套接字服务端的实现，这种技术在高并发、实时性要求高的应用中尤为常见。异步Socket编程允许服务器处理多个连接请求而不阻塞，从而提高系统的效率和响应速度。 首先，我们需要理解...
客户与服务器程序的同步与通信机制的设计
05-31
1. **阻塞与非阻塞通信**：服务器可以选择阻塞或非阻塞模式来处理客户端的请求。阻塞模式下，服务器会等待数据完全接收或发送完毕，可能导致资源浪费；而非阻塞模式允许服务器同时处理多个请求，提高效率。 2. **多...
VC6-MFC-TCP客户机服务器程序
04-22
【VC6-MFC-TCP客户机服务器程序】是基于Visual C++ 6.0和MFC（Microsoft Foundation Classes）框架实现的一个典型网络通信应用。在这个项目中，我们主要探讨的是如何利用MFC库来构建TCP（Transmission Control ...
套接字之详解SOCKET.doc
01-24
本文将深入讲解套接字的基本概念、操作函数以及其在客户机/服务器模式中的应用。 首先，客户机/服务器模式是网络通信的基础架构。在这个模式下，服务器首先启动，监听特定端口，等待客户机的连接请求。一旦请求到达...
客户机服务器代码
07-01
本文将深入探讨“客户机服务器代码”这一主题，包括客户端和服务器端的实现，以及如何使用TCP协议进行通信。 客户端是用户与服务交互的界面，而服务器端则是处理客户端请求并返回响应的程序。在聊天工具中，客户端...
关于进程、线程、协程、同步、异步、阻塞、非阻塞、并发、并行、串行的理解
python全栈
07-06 921
二、线程 三、协程 七、非阻塞 八、并发 九、并行 十、串行
非阻塞套接字(Nonblocking Sockets) 概述
桥西居
03-19 1459
非阻塞套接字（Nonblocking sockets）,自J2SE 1.4版引入，它允许网络通信在应用程序和没有阻塞的进程中使用套接字。在这篇文章中，将详细介绍什么是Nonblocking sockets，怎样工作及其用途。由于JSR 51的面世，从Java 1.4起，程序员便能用一组新的API来进行I/O操作。自2000年一月的Java 1.4 beta版，程序员便可以使用JSR 51了。在Ja
Winsocket入门教程一：多线程阻塞式服务器和阻塞式客户端程序(TCP)
shining100的专栏
05-09 6645
      最近因为工作需要学习了Winsocket客户端服务器模型程序的设计。在学习的过程中，我发现学习Winsocket的资料不多并且十分的零散。我一直没有找到一本学习Winsocket方面的经典国外著作。而且这些资料中并没有提供源代码文件，所以我只有将这些源代码在自己敲一遍。在敲代码的过程中，我发现了这些源代码中的一些错误的地方和一些已经过时的Windows程序的输写方法(Win16?)。现
Windows Sockets2 详解3——堵塞模式
weixin_34041003的博客
11-17 77
我想真正理解windows sockets2的最好方法就是通过编程实践，只有实际去做了，才能获得形象的记忆和深刻的理解。下面我们通过代码看一下堵塞模式下是如何编程的，以一个简单的聊天室程序为例。 先分析一下：在（2）中我们已经了解了堵塞模式的特点，堵塞模式下对socket对象的任何操作都会被挂起，直到操作结束，线程才被唤醒。 因此我们需要一个单独的线程来执行Accept操作，等待客户端连接的到来...
Windows网络编程：阻塞模式下的Socket编程
liyuefeilong的专栏
07-25 2662
Windows Socket是从UNIX Socket继承发展而来，在写本博客时最新的版本是2.2。进行Windows网络编程，你需要在你的程序中包含WINSOCK2.H或MSWSOCK.H，同时你需要添加引入库WS2_32. LIB或WSOCK32.LIB。
[网络基础知识]icmp-Internet控制报文协议
超越
05-23 2244
ICMP（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。当遇到IP数据无法访问目标、IP路由器无法按当前的传输速率转发数据包等情况时...
Windows上的Socket编程（阻塞模型）
南宫封清的博客
04-12 783
Socket协议的工作原理 Socket又称套接字，它是TCP/IP网络环境下应用程序与底层通信驱动程序之间运行的开发接口，它可以将应用程序与具体的TCP/IP隔离开，使得应用程序不需要了解TCP/IP的细节，就能够实现传输。 需要包括的库 #include <WinSock2.h> #pragma comment(lib,"Ws2_32.lib ") 用到的函数 1...
Socket的阻塞模式和非阻塞模式
游侠之魂的专栏
05-04 5268
阻塞模式 　　Windows套接字在阻塞和非阻塞两种模式下执行I/O操作。在阻塞模式下，在I/O操作完成前，执行的操作函数一直等候而不会立即返回，该函数所在的线程会阻塞在这里。相反，在非阻塞模式下，套接字函数会立即返回，而不管I/O是否完成，该函数所在的线程会继续运行。
非阻塞套接字
清欢Viki的博客
08-12 6337
普通套接字的缺陷 普通套接字一次只能服务一个客户端，而且若无客户端连接，accept（）一直阻塞，无数据传输，recv一直阻塞，传输效率极低。 普通服务器的IO模型 操作系统监听用户进程的状态，若无数据，则一直等待，知道用户请求数据，操作系统才进行数据处理。 普通套接字实现的服务端的瓶颈 在没有新的套接字来之前， 不能处理已经建立连接的套接字的请求（多个客户端连接只有一个被服务）...
学习非阻塞套接字与IO多路复用的实现和应用
其中，着重介绍了基本IO模型、非阻塞IO模型与非阻塞套接字、非阻塞套接字实现并发以及IO多路复用等概念。 在学习非阻塞套接字与IO多路复用的过程中，首先了解了数据流的概念。数据流是一组有序、有起点和终点的字节...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值