Socket基础三：基于流式套接字的网络程序（服务器回射程序设计)

最新推荐文章于 2021-12-13 10:49:47 发布
最新推荐文章于 2021-12-13 10:49:47 发布
阅读量2.6k 收藏 23
点赞数 5
分类专栏： Windows Socket 文章标签： 网络 socket windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44807456/article/details/105798713
版权

作者：刘磊 2020.4.27

参考书目：《Windows网络编程》刘琰等著

  • 回射程序

回射程序是进行网络诊断的常用工具之一，例如Ping是windows系统下自带的可执行命令，利用它可以检查网络是否连通，不过ping是网络层上的，不适合传输层的应用程序测试和诊断。

 

  • 基本执行步骤

服务器：

  1. 引用头文件
  2. 创建流式套接字
  3. 捆绑服务器的指定端口到套接字
  4. 把套接字变换成监听套接字
  5. 接收客户连接
  6. 接收客户发来的数据
  7. 发送客户发来的数据
  8. 回到步骤6
  9. 如果客户端关闭连接，则终止当前连接
  10. 回到步骤5
  11. 如果终止条件到，则关闭套接字，释放资源，关闭程序。

客户机：

  1. 引用头文件
  2. 处理命令行参数
  3. 创建流式套接字
  4. 指定服务器IP地址和端口
  5. 与服务器建立连接
  6. 获得用户输入
  7. 发送回射请求
  8. 接收并输出服务器应答
  9. 回到步骤6
  10. 如果终止条件到，则关闭套接字，释放资源，终止程序

 

  • 对回射功能进行编码

1）tcp_server_fun_echo(SOCKET s)编程代码如下：

//回射函数
int tcp_server_fun_echo(SOCKET s)
{
	int iResult = 0;
	
	char recvline[MAXLINE];
	do {
		memset(recvline, 0, MAXLINE);
		//接收数据
		iResult = recv(s, recvline, MAXLINE, 0);
		if (iResult > 0)
		{
			printf("服务器接收到数据%s\n", recvline);
			//回射发送已收到的数据
			iResult = send( s, recvline, iResult, 0);
			if (iResult == SOCKET_ERROR)
			{
				printf("send 函数调用错误，错误号：%d\n", WSAGetLastError());
				return 1;
			}
			else
				printf("对方连接关闭，退出\n");
		}
		else
		{
			if (iResult == 0)
				printf("对方连接关闭，退出\n");
			else
			{
				printf("recv 函数调用错误，错误号：%d\n", WSAGetLastError());
				return 1;
			}
			break;
		}
	} while (iResult > 0);
	return iResult;
}

2）tcp_client_fun_echo(FILE *fp,SOCKET s)编程代码如下：

//回射函数
int tcp_client_fun_echo(FILE *fp, SOCKET s)
{
	int iResult;
	char sendline[MAXLINE], recvline[MAXLINE];
	memset(sendline, 0, MAXLINE);
	memset(recvline, 0, MAXLINE);

	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		if (*sendline == 'Q')
		{
			printf("input end!\n");
			iResult = shutdown(s, SD_SEND);
			if (iResult == SOCKET_ERROR)
			{
				printf("shutdown failed with error:%d\n", WSAGetLastError());
			}
			return 0;
		}
		iResult = send(s, sendline, strlen(sendline), 0);
		if (iResult == SOCKET_ERROR)
		{
			printf("send 函数调用错误，错误号：%d\n", WSAGetLastError());
			return 1;
		}
		printf("\r\n客户端发送数据：%s\r\n", sendline);
		memset(recvline,0,MAXLINE);
		iResult = recv(s,recvline,MAXLINE,0);
		if (iResult > 0)
			printf("客户端接收到数据 %s \r\n",recvline);
		else
		{
			if (iResult == 0)
				printf("服务器终止！\n");
			else
				printf("recv 函数调用错误，错误号：%d\n", WSAGetLastError());
			break;
		}
		memset(sendline, 0, MAXLINE);
	}
	return iResult;
}

  • 主函数

1、server.c

#include "mysocket.h"
#define ECHOPORT "7210"

int main(int argc, char *argv[])
{

	int iResult = 0;
	char ip[] = "127.0.0.1";
	SOCKET ListenSocket, ConnetSocket;

	start_up();
	ListenSocket = tcp_server( ip, ECHOPORT);
	if (ListenSocket == -1)
		return 1;
	printf("服务器准备好回射服务......\n");
	for (; ; )
	{
		ConnetSocket = accept(ListenSocket, NULL, NULL);
		if (ConnetSocket != INVALID_SOCKET)
		{
			printf("\r\n建立连接成功\n\n");
			iResult = tcp_server_fun_echo(ConnetSocket);
			if (iResult == -1)
				printf("当前连接已关闭或出错\n");
		}
		else
		{
			printf("accept 函数调用错误，错误号:%d\n",WSAGetLastError());
			quit(ListenSocket);
			return 1;
		}

		if(closesocket(ConnetSocket) == SOCKET_ERROR)
			printf("closesocket 函数调用错误，错误号:%d\n", WSAGetLastError());
	}
		
	quit(ListenSocket);
	return 0;

}

2、client.c

#include "mysocket.h"
#define ECHOPORT "7210"

int main(int argc, char *argv[])
{

	int iResult = 0;
	SOCKET ClientSocket;

	start_up();

	printf("连接建立成功，请输入回射字符串......\n");
	ClientSocket = tcp_client((char *)argv[1], ECHOPORT);
	if (ClientSocket == -1)
		return 1;
	iResult = tcp_client_fun_echo(stdin,ClientSocket);
	quit(ClientSocket);
	return iResult;

}

3、mysocket.h

#pragma once

#include <time.h>
#include <winsock2.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib");
using namespace std;

#define MAXLINE 4096	//接收缓冲区长度
#define LISTENQ 1024	//监听队列长度
#define SERVER_PORT 13	//时间同步服务器端口号

int start_up(void);		//初始化Windows Sockets DLL；协商版本号
int clean_up(void);		//windows sockets资源释放函数
int set_address(char *hname, char * sname, struct sockaddr_in * sap, char * protocol);		//地址转换函数
int quit(SOCKET s);		//退出处理函数

SOCKET tcp_server(char *hname, char *sname);		//服务器初始化函数（字符类型）
SOCKET tcp_server(ULONG uIP, USHORT uPort);			//服务器初始化函数（无符号长整型）
SOCKET tcp_client(char *hname, char *sname);		//客户端初始化函数（字符类型）
SOCKET tcp_client(ULONG uIP, USHORT uPort);			//客户端初始化函数（无符号长整型）

int tcp_server_fun_echo(SOCKET s);		//回射函数
int tcp_client_fun_echo(FILE *fp,SOCKET s);		//回射函数

4、mysocket.c

#include "mysocket.h"

//初始化Windows Sockets DLL；协商版本号
int start_up(void)
{
	//初始化Windows Sockets DLL；协商版本号
	WORD wVersionRequested;
	WSADATA wsaData;
	int iResult;

	//使用MAKEWORD(lowbyte, highbyte) 宏，在windef.h中声明
	wVersionRequested = MAKEWORD(2, 2);
	iResult = WSAStartup(wVersionRequested, &wsaData);
	if (iResult != 0)
	{
		printf("WSAStartup函数调用错误，错误号：%d\n", WSAGetLastError());
		return -1;
	}
	else
	{
		printf("初始化成功！\n");
	}

	return 0;
}

//windows sockets资源释放函数
int clean_up(void)
{
	int iResult;

	iResult = WSACleanup();
	if (iResult == SOCKET_ERROR)
	{
		printf(" WSACleanup函数调用错误，错误号：%d\n", WSAGetLastError());
		return 1;
	}
	else
		printf("WSACleanup 函数调用错误，错误号：%d\n", WSAGetLastError());
	
	return 0;
}

//地址转换函数
int set_address(char *hname, char * sname, struct sockaddr_in * sap, char * protocol)
{
	struct servent *sp;
	struct hostent *hp;
	char *endptr;
	unsigned short port;
	unsigned long ulAddr = INADDR_NONE;

	//将地址结构socketaddr_in初始化为0，并设置地址为AF_INET
	memset( sap, 0, sizeof( *sp));
	sap->sin_family = AF_INET;
	if (hname != NULL)
	{
		//如果hname不为空，假定给出的hname为点分十进制表示的数字地址，转换地址为sockaddr_in类型
		ulAddr = inet_addr(hname); 
		if (ulAddr == INADDR_NONE || ulAddr == INADDR_ANY)
		{
			//调用错误，表明给出的是主机名，调用gethostbyname获得主机地址
			hp = gethostbyname(hname); 
			if (hp = NULL)
			{
				printf("未知的主机名，错误号：%d\n", WSAGetLastError());
				return -1;
			}
			
			sap->sin_addr = *(struct in_addr *)hp->h_addr; 
		}
		else
			sap->sin_addr.S_un.S_addr = ulAddr;
	}
	else
		sap->sin_addr.s_addr = htonl(INADDR_ANY);
	port = (unsigned short)strtol(sname, &endptr, 0);
	if (*endptr == '\0')
	{
		sap->sin_port = htons(port);
	}
	else
	{
		sp = getservbyname(sname, protocol);
		if (sp == NULL)
		{
			printf("未知的服务，错误号;%d\n",WSAGetLastError());
			return -1;
		}
		sap->sin_port = sp->s_port;
	}
	return 0;
}

//退出处理函数
int quit(SOCKET s)
{
	int iResult = 0;
	iResult = closesocket(s);
	if (iResult == SOCKET_ERROR)
	{
		printf("closesocket 函数调用错误，错误号：%d\n", WSAGetLastError());
		return -1;
	}
	iResult = clean_up();
	return iResult;
}

//服务器初始化函数（字符类型）
SOCKET tcp_server(char *hname, char *sname)
{
	sockaddr_in local;
	SOCKET ListenSocket;
	const int on = 1;
	int iResult = 0;

	//为服务器的本地地址local设置用户输入的IP和端口号
	if (set_address(hname, sname, &local, "tcp") != 0)
		return -1;

	//创建套接字
	ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (ListenSocket == INVALID_SOCKET)
	{
		printf("socket函数调用错误，错误号：%d\n",WSAGetLastError());
		clean_up();
		return -1;
	}

	//绑定服务器地址
	iResult = bind(ListenSocket, (struct sockaddr *) & local, sizeof(local));
	if (iResult == SOCKET_ERROR)
	{
		printf("bind 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ListenSocket);
		return -1;
	}

	//设置服务器位监听状态，监听队列长度为LISTENQ
	iResult = listen(ListenSocket, SOMAXCONN);
	if (iResult == SOCKET_ERROR)
	{
		printf("listen 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ListenSocket);
		return -1;
	}
	return ListenSocket;
}

//服务器初始化函数（无符号长整型）
SOCKET tcp_server(ULONG uIP, USHORT uPort)
{
	sockaddr_in local;
	SOCKET ListenSocket;
	const int on = 1;
	int iResult = 0;

	//为服务器的本地地址local设置用户输入的IP和端口号
	memset(&local, 0, sizeof(local));
	local.sin_family = AF_INET;
	local.sin_addr.S_un.S_addr = htonl(uIP);
	local.sin_port = htons(uPort);

	//创建套接字
	ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (ListenSocket == INVALID_SOCKET)
	{
		printf("socket函数调用错误，错误号：%d\n", WSAGetLastError());
		clean_up();
		return -1;
	}

	//绑定服务器地址
	iResult = bind(ListenSocket, (struct sockaddr *) & local, sizeof(local));
	if (iResult == SOCKET_ERROR)
	{
		printf("bind 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ListenSocket);
		return -1;
	}

	//设置服务器位监听状态，监听队列长度为LISTENQ
	iResult = listen(ListenSocket, SOMAXCONN);
	if (iResult == SOCKET_ERROR)
	{
		printf("listen 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ListenSocket);
		return -1;
	}
	return ListenSocket;
}

//客户端初始化函数（字符类型）
SOCKET tcp_client(char *hname, char *sname)
{
	struct sockaddr_in peer;
	SOCKET ClientSocket;
	int iResult = 0;

	//为服务器的本地地址local设置用户输入的IP和端口号
	if (set_address(hname, sname, &peer, "tcp") != 0)
		return -1;

	//创建套接字
	ClientSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (ClientSocket == INVALID_SOCKET)
	{
		printf("socket函数调用错误，错误号：%d\n", WSAGetLastError());
		clean_up();
		return -1;
	}

	//绑定服务器地址
	iResult = connect(ClientSocket, (struct sockaddr *) & peer, sizeof(peer));
	if (iResult == SOCKET_ERROR)
	{
		printf("bind 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ClientSocket);
		return -1;
	}

	return ClientSocket;
}

//客户端初始化函数（无符号长整型）
SOCKET tcp_client(ULONG uIP, USHORT uPort)
{
	struct sockaddr_in peer;
	SOCKET ClientSocket;
	int iResult = 0;

	//为服务器的本地地址local设置用户输入的IP和端口号
	memset(&peer, 0, sizeof(peer));
	peer.sin_family = AF_INET;
	peer.sin_addr.S_un.S_addr = htonl(uIP);
	peer.sin_port = htons(uPort);

	//创建套接字
	ClientSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (ClientSocket == INVALID_SOCKET)
	{
		printf("socket函数调用错误，错误号：%d\n", WSAGetLastError());
		clean_up();
		return -1;
	}

	//绑定服务器地址
	iResult = connect(ClientSocket, (struct sockaddr *) & peer, sizeof(peer));
	if (iResult == SOCKET_ERROR)
	{
		printf("bind 函数调用错误，错误号：%d\n", WSAGetLastError());
		quit(ClientSocket);
		return -1;
	}

	return ClientSocket;
}

//回射函数
int tcp_server_fun_echo(SOCKET s)
{
	int iResult = 0;
	
	char recvline[MAXLINE];
	do {
		memset(recvline, 0, MAXLINE);
		//接收数据
		iResult = recv(s, recvline, MAXLINE, 0);
		if (iResult > 0)
		{
			printf("服务器接收到数据%s\n", recvline);
			//回射发送已收到的数据
			iResult = send( s, recvline, iResult, 0);
			if (iResult == SOCKET_ERROR)
			{
				printf("send 函数调用错误，错误号：%d\n", WSAGetLastError());
				return -1;
			}
			else
				printf("对方连接关闭，退出\n");
		}
		else
		{
			if (iResult == 0)
				printf("对方连接关闭，退出\n");
			else
			{
				printf("recv 函数调用错误，错误号：%d\n", WSAGetLastError());
				return -1;
			}
			break;
		}
	} while (iResult > 0);
	return iResult;
}

//回射函数
int tcp_client_fun_echo(FILE *fp, SOCKET s)
{
	int iResult;
	char sendline[MAXLINE], recvline[MAXLINE];
	memset(sendline, 0, MAXLINE);
	memset(recvline, 0, MAXLINE);

	while (fgets(sendline, MAXLINE, fp) != NULL)
	{
		if (*sendline == 'Q')
		{
			printf("input end!\n");
			iResult = shutdown(s, SD_SEND);
			if (iResult == SOCKET_ERROR)
			{
				printf("shutdown failed with error:%d\n", WSAGetLastError());
			}
			return 0;
		}
		iResult = send(s, sendline, strlen(sendline), 0);
		if (iResult == SOCKET_ERROR)
		{
			printf("send 函数调用错误，错误号：%d\n", WSAGetLastError());
			return -1;
		}
		printf("\r\n客户端发送数据：%s\r\n", sendline);
		memset(recvline,0,MAXLINE);
		iResult = recv(s,recvline,MAXLINE,0);
		if (iResult > 0)
			printf("客户端接收到数据 %s \r\n",recvline);
		else
		{
			if (iResult == 0)
				printf("服务器终止！\n");
			else
				printf("recv 函数调用错误，错误号：%d\n", WSAGetLastError());
			break;
		}
		memset(sendline, 0, MAXLINE);
	}
	return iResult;
}

//工作线程完成了在特定连接上接收客户端数据，并将数据发回的功能，直到客户端关闭连接或网络操作发生错误
UINT tcp_server_fun_echo(LPVOID pParam)
{
	int iResult = 0;
	char recvline[MAXLINE];
	int err;

	//将输入参数转换为连接套接字
	SOCKET s = *((SOCKET *)pParam);
	do {
		memset(recvline, 0, MAXLINE);
		//接收数据
		iResult = recv(s, recvline, MAXLINE, 0);
		if (iResult > 0)
		{
			printf("服务器接收到数据: %s\n",recvline);
			//回射发送已收到的数据
			iResult = send(s, recvline, MAXLINE, 0);
			if (iResult == SOCKET_ERROR)
			{
				printf("send 函数调用错误，错误号：%d\n", WSAGetLastError());
				err = closesocket(s);
				if(err == SOCKET_ERROR)
					printf("closesocket 函数调用错误，错误号：%d\n", WSAGetLastError());
				iResult = -1;
			}
			else
				printf("服务器发送数据: %s\n", recvline);
		}
		else
		{
			if (iResult == 0)
				printf("对方连接关闭，退出\n");
			else
			{
				printf("recv 函数调用错误，错误号：%d\n", WSAGetLastError());
				iResult = -1;
			}
			err = closesocket(s);
			if (err == SOCKET_ERROR)
				printf("closesocket 函数调用错误，错误号：%d\n", WSAGetLastError());
			break;
		}
	} while (iResult > 0);

		return iResult;
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Double. L
关注
专栏目录
初识Socket编程——基于流式套接字的服务器回射程序设计
姑苏流白
01-11 4156
实验二、基于流式套接字的服务器回射程序设计 0x00 实验内容 编写一服务器程序和客户程序，要求客户每输入一行数据，服务器接收后回送给客户程序，当客户输入“q”后退出。过程描述如下图所示： UserClientServerInput Datasend - recvrecv - sendOutput DataUserClientServer 0x01 实现过程 公共函数 // comm.h #ifn...
初识Socket编程——基于数据报套接字的服务器回射程序设计
姑苏流白
01-11 2524
实验四、基于数据报套接字的服务器回射程序设计 0x00 实验内容 编写一服务器程序和客户程序，要求客户每输入一行数据，服务器接收后加上 &quot;Echo:&quot; 后回送给客户程序，当客户输入“q”后退出。过程描述如下： UserUDP ClientUDP ServerInput Datasendto --- recvfromrecvfrom --- sendtoOutput DataUserUDP Clie...
流式套接字(基于TCP)
zhangxuelong461的博客
01-21 2128
【流式套接字的编程（基于tcp协议的】 １．TCP服务端： import socket 1.创建套接字 socket.socket(socket_family=AF_INET, socket_type=SOCK_STREAM proto=0) 功能：创建一个套接字 参数：socket_family　：　选择地址族类型AF_INET 使用IPV4 　　　　　　socket_typ...
流式套接字并发服务器【基于流式套接字的网络程序设计】
一只猫猫的博客
12-01 1305
流式套接字并发服务器 主线程： 创建套接字并将其绑定到服务器所使用的熟知地址上。 重复调用accept接收客户端的请求,并且创建子线程处理响应。 子线程： 在线程创建时接收连接请求； 用该连接与客户端进行交互：接收请求并发回应答； 关闭连接并退出。子线程在处理完来自一个客户端的所有请求后退出
初识Socket编程——基于流式套接字的多线程并发服务器回射程序设计
姑苏流白
01-11 2409
实验三、基于流式套接字的多线程并发服务器回射程序设计 0x00 实验内容 将 实验二 中的服务器改为并发服务器。 0x01 实现过程 实现方法 这个和 实验二 中的代码只差一部分——只需要让服务器开一个线程单独为当前客户服务即可。我这里是使用 pthread.h 来实现创建线程的。 公共函数中修改部分 // comm.h // 在实验二的基础上添加如下内容 #include &amp;amp;lt;pthread...
Socket基础四：基于流式套接字的网络程序（并发服务器设计）
qq_44807456的博客
05-01 1125
作者：刘磊 2020.4.27 　　　参考书目：《Windows网络编程》刘琰等著 一、并发性 并发性是TCP/IP程序的基础，服务器软件必须在程序中有专门的支持并发的硬件或专门的机制实现并发处理。 ...
Socket基础二：基于流式套接字的网络程序（时间同步服务器设计）
qq_44807456的博客
04-26 2344
作者：刘磊 2020.4.24　　　参考书目：《Windows网络编程》刘琰等著 一、流式套接字 流式套接字是基于可靠的数据流传输服务，特点是面向连接（一对一传输），可靠，流式套接字编程与TCP协议原理关系密切。适合大数据量的数据传输应用，可靠性要求高的传输应用。 二、TCP – 传输控制协议 TCP是一个面向连接的传输层协议，提供高可靠性字节流传输服务，主要用于一次传输要交换大量报文的情形。为了...
基于流式套接字的时间同步服务器设计
06-12
基于流式套接字的时间同步服务器设计 c++开发
基于tcp，编写基于流式套接字的通信程序。
12-20
基于tcp，编写基于流式套接字的通信程序。 任务一：C++版同步通信程序 客户端连接后服务器能够发送一个欢迎消息给客户端，客户端发送time，发送当前时间（字符串形式）给客户端；客户端发送date，发送当前日期...
回射程序，客户端和服务器都使用 recvn 定长数据接收【基于流式套接字的网络程序设计】
一只猫猫的博客
12-01 1218
目录设计思路客户端 recvn 定长数据接收服务器端 recvn 定长数据接收 设计思路 预先给定了接收数据的总长度，增加对数据长度的判断。 客户端 recvn 定长数据接收
基于流式套接字的并发服务器的应用程序
04-11
基于流式套接字的并发服务器的应用程序，客户端，服务器端均测试可用。
TCP_Echo流式套接字回射程序
12-03
windows网络编程，利用流式套接字编写的回射服务器和客户端，编程语言：C++。
流式套接字编程实验
06-19
1、利用流式套接字编写回射服务器和客户端。 2、完成基于流式套接字的定长数据接收功能； 3、完成基于流式套接字的变长数据接收功能； 4、在回射程序中应用定长接收和变长接收功能。
流式套接字定长变长接收回射实验报告加源码
12-01
本实验是程序设计类实验，要求用C++语言，使用流式套接字编程，基于流式套接字的网络功能框架中补充对TCP数据流定长接收和变长接收功能，并将这两个功能在基于流式套接字的回射程序中加以应用。
TCP.zip_letter4tt_purposest2_tcp_windows网络编程_基于流式套接字的客户端设计
最新发布
09-25
在本文中，我们将深入探讨如何在Windows环境下进行TCP网络编程，特别是基于流式套接字的客户端设计。TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输协议，广泛应用于互联网通信。流式套接字...
高级网络程序设计-基于流式套接字的计算程序设计
qq_53045284的博客
12-13 1396
HIT高级网络程序设计实验，windows，VS2019，
Windows下基于流式套接字的时间同步服务器设计源码
Echo_Ana的博客
12-22 2624
使用流式套接字编程，实现时间同步服务器，该服务器能够接受客户端的查询请求，获取本地时间，并将结果发送回客户端，同时开发与服务器通信的客户端，以验证双方交互的功能。这个可以实现网络中需要时间信号的设备如计算机、控制器等与标准时间源自动、定期的同步本机标准时间。 下面分别是服务器和客户端的源码： 服务器： // DayTimeServer.cpp : Defines the entry poin
基于流式套接字的回射客户端编程操作
Leng_Tianming的博客
10-09 968
Windows网络编程第五章课本完整代码（客户端） 基于流式套接字的回射客户端编程操作 // EchoTCPClientDemo.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #define WIN32_LEAN_AND_MEAN #include <windows.h> #include <winsock2.h> #include <ws2tcpip.h> #include <stdlib.h> #include
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值