TCP/IP网络编程（1） 千次阅读

2021-08-21 11:58:41

1. 套接字

套接字是由操作系统提供的网络数据通信软件设备，即使对网络数据传输原理不了解，也能够使用套接字完成网络数据传输。为了与远程计算机进行数据传输，需要连接到英特网，套接字就是进行网络连接的工具。

服务端：接收连接请求的套接字创建流程如下：

1. 调用socket函数创建套接字

2. 调用bind函数分配IP地址和端口号（port）

3. 调用listen函数，套接字转为可接受请求状态

4. 调用accept函数接收连接请求

在Linux系统中，一切皆文件，因此Linux中的socket也是一种文件，因此在数据的传输过程中，可以使用文件IO相关的函数进行操作。而在Windows系统中，文件和socket是有区别的。

2. 套接字的类型：

面向连接的套接字（SOCKET_STREAM）

如果socket函数的第二个参数为SOCKET_STREAM,则会创建面向连接的的套接字，即TCP套接字。面向连接的套接字(TCP套接字)传输数据的方式与传送到传输物品类似，即只要传送带本身没有问题，就不会导致数据的丢失。且较晚传输的数据不会先到达，保证了数据的按序传递，TCP套接字的传输方式具有如下特点：

1. 传输过程中数据不会丢失

2. 数据按序传输

3. 传输的数据不存在数据边界

在收发数据的套接字内部有缓冲区，通过套接字传输的数据将保存在缓冲区中，套接字收到数据并不意味着马上调用read函数。只要不超过数组容量，则有可能在数据填充满缓冲区之后通过调用1次read函数读取全部数据。也有可能通过多次调用read函数读取所有数据。也就是说在TCP套接字中，调用read,write方法的次数并无太大意义，所以说TCP套接字不存在数据边界。

如果接收的套接字接受速度较慢，导致接收缓冲区被填满，此时发送的套接字便会停止数据发送，直到接收端调用read函数读取数据使得缓冲区中有空余位置时，发送端套接字才会继续接着发送，因此不会造成数据丢失，而且在传输过程中如果发生数据丢失，还会进行数据的重新传输。因此TCP套接字除特殊情况外不会发生数据丢失。

面向消息的套接字（SOCKET_DGRAM）

如果socket函数的第二个参数为SOCKET_DGRAM,则会创建面向消息的套接字，即UDP套接字。UDP套接字传输数据类似于高速移动的摩托快递。其传输方式具有如下的特点：

1.强调快速传输而非顺序传输（不一定保证次序）

2.传输的数据可能丢失，也可能损毁，没有数据重传机制

3. 传输的数据有边界

4. 限制每次传输的数据的大小

类似于两件包裹发送至统一目的地，只要以最快的速度交给用户即可。在输送过程中无需保证包裹的次序。包裹有大小限制且在传送的过程中存在损毁或者丢失的风险。且如果分多次发送包裹，接收者也需要分多次进行接收，即“传输的数据具有边界“，因此UDP套接字是一种”不可靠的，不按序传递的，以数据的高速传输为目的的套接字“。

-----------------------------------------分割线--------------------------------------------

简单的服务端程序：《TCP/IP网络编程》书籍中的例子做了修改

例子：基于windows的服务端/客户端简socket通信单实现

功能：客户端输入计算表达式，再通过将表达式组成消息报文，发送给服务端，由服务端计算表达式的值，计算完成后再将结果返回给客户端，客户端对结果进行相应的展示：

消息报文格式如下所示：

索引	值	含义
0	C	消息头
1	K	消息头
2	0	数据长度(第四个字节以后的数据长度)
3	0	数据长度(第四个字节以后的数据长度)
4	0	参与运算的数字个数
5	0	参与运算的数字个数
6	0	第一个运算数
7	0
8	0
9	0
10	0	第 n 个运算数
11	0
12	0
13	0
14	+ - * /	运算符
15
16
17
18

服务端代码实现：

server.cpp

/*
   简易计算器服务端代码
*/

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <WinSock2.h>

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

#define BUFF_SIZE   100         // 定义接收数据缓冲区字节大小
#define MESSAGE_HEAD_SIZE   4   // 消息头大小
#define OPERAND_SIZE   4        // 运算数所占字节大小
#define RESULT_SIZE    4        // 计算结果所占的字节数
#define RESULT_OVERFLOW  -999999    // 计算结果溢出

typedef unsigned short ushort;
typedef INT32 int32;
typedef INT16 int16;


void error_handle(char* message)
{
	printf("%s\n", message);
	system("pause");
	exit(1);
}


int main()
{
	WSADATA wsadata;
	SOCKET serverSocket, clientSocket;
	sockaddr_in serverAddr;

	ushort port = 30100;      // 定义端口号

	// 定义缓冲区
	char buffer[BUFF_SIZE];
	memset(buffer, 0, BUFF_SIZE);

	int32 result = 0;

	int recvLen   = 0;        // 接收长度
	int recvCount = 0;        // 接收数据计数

	// 初始化socket库
	if (WSAStartup(MAKEWORD(2, 2), &wsadata) != 0)
	{
		error_handle("Failed to init wsadata");
	}

	// 初始化服务端套接字
	serverSocket = socket(PF_INET, SOCK_STREAM, 0);
	
	// 服务端地址绑定
	memset(&serverAddr, 0, sizeof(serverAddr));
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_addr.s_addr = INADDR_ANY;
	serverAddr.sin_port = htons(port);
	int serverAddrSize = sizeof(serverAddr);

	// 绑定端口
	if (bind(serverSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
	{
		error_handle("Failed to bind socket");
	}

	if (listen(serverSocket, 5) == SOCKET_ERROR)
	{
		error_handle("Falied to listen");
	}

	while (true)
	{
		// 等待接收连接
		printf("Waiting for connction from client!\n");

		clientSocket = accept(serverSocket, (sockaddr*)&serverAddr, &serverAddrSize);

		if (clientSocket == INVALID_SOCKET)
		{
			printf("Failed to get connect from client!\n");
			continue;
		}

		printf("Successfully get connect from client!\n");

		recvLen = recv(clientSocket, buffer, BUFF_SIZE, 0);    // 先读取四个字节的数据

		if (recvLen < 4)
		{
			// 数据包数据缺失
			result = 0;                     // 记得result清零
			memset(buffer, 0, BUFF_SIZE);   // buffer记得清零
			continue;                       // 重新等待接收连接
		}

		// 校验消息头
		if (buffer[0] != 'C' || buffer[1] != 'K')
		{
			printf("The message header is wrong!\n");

			result = 0;     // 记得result清零
			memset(buffer, 0, BUFF_SIZE);       // buffer记得清零

			continue;
		}

		// 解析数据长度
		int dataLen = buffer[2] | (buffer[3] << 8);

		// recvLen = MESSAGE_HEAD_SIZE;

		while (recvLen < (dataLen + 2 + 2))
		{
			recvCount = recv(clientSocket, &buffer[recvLen], BUFF_SIZE-1, 0);      // 计算实际接收的数据的个数
			recvLen += recvCount;
		}

		printf("Successfully recv messgae.\n");

		int operand_count = buffer[MESSAGE_HEAD_SIZE] | (buffer[MESSAGE_HEAD_SIZE+1] << 8);      // 运算数的数量

		char caloperator = buffer[MESSAGE_HEAD_SIZE + 2 + operand_count*OPERAND_SIZE];

		if (caloperator != '+' &&
			caloperator != '-' &&
			caloperator != '*' &&
			caloperator != '/')
		{
			// error_handle("Operator is invalid!");
			printf("Operator %c is invalid!", caloperator);

			result = 0;     // 记得result清零

			memset(buffer, 0, BUFF_SIZE);       // buffer记得清零

			continue;
		}

		for (int i=0; i<operand_count; ++i)
		{
			int32 operand = *(int32*)&buffer[MESSAGE_HEAD_SIZE + 2 + i * OPERAND_SIZE];

			if (i == 0)
			{
				result = operand;
				continue;
			}

			if (caloperator == '+')
			{
				result += operand;
			}

			else if (caloperator == '-')
			{
				result -= operand;
			}

			else if (caloperator == '*')
			{
				result *= operand;
			}

			else if (caloperator == '/')
			{
				if (operand == 0)
				{
					printf("The reuslt is overflow because the number is divided by zero");
					result = RESULT_OVERFLOW;
					break;
				}

				result /= operand;
			}

		}

		// 返回结果
		send(clientSocket, (char*)&result, RESULT_SIZE, 0);

		closesocket(clientSocket);

		result = 0;     // 记得result清零

		memset(buffer, 0, BUFF_SIZE);       // buffer记得清零
	}

	WSACleanup();

	system("pause");
    return 0;
}


// 服务端/客户端通信的消息格式
/*
xx        xx              xx                 xxxx        xxxx      xxxx         x

标识符   数据长度    运算数的个数(2bytes)       操作数1     操作数2    操作数n    运算符号
*/

客户端代码：
client.cpp

/*
   建议服务器客户端代码
*/

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <WinSock2.h>

using std::cout;
using std::endl;

// 类型定义
typedef unsigned short ushort;
typedef unsigned char uchar;
typedef INT32 int32;
typedef INT16 int16;

#define BUFFER_SIZE    100      // 定义缓冲区字节大小
#define OPERAND_SIZE   4        // 定义操作数的所占字节
#define OPERATOR_SIZE  2        // 定义操作符所占字节的大小
#define RESULT_SIZE    4        // 返回结果所占的字节数
#define RESULT_OVERFLOW  -999999    // 计算结果溢出


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

//#define _WINSOCK_DEPRECATED_NO_WARNINGS
//#define _CRT_SECURE_NO_WARNINGS

void error_handle(char* message)
{
	printf("%s\n", message);
	system("pause");
	exit(1);
}


int main(int argc, char* argv[])
{
	printf("Starting the calculate client...\n");

	// 定义数据区
	char buffer[BUFFER_SIZE];  
	memset(buffer, 0, sizeof(buffer));

	WSADATA wsadata;
	SOCKET hsocket;

	SOCKADDR_IN servAddr;       // 服务器端地址

	// 服务端的地址和端口号
	char ipAddr[] = "127.0.0.1";
	ushort port = 30100;   

	if (WSAStartup(MAKEWORD(2, 2), &wsadata) != 0)       // 返回0表示初始化成功
	{
		error_handle("Failed to init socket lib.");      // 初始化套接字相关的库失败
	}

	hsocket = socket(PF_INET, SOCK_STREAM, 0);
	if (hsocket == INVALID_SOCKET)
	{
		error_handle("Failed to create socket");
	}

	// 设置服务器地址以及端口
	memset(&servAddr, 0, sizeof(servAddr));      
	servAddr.sin_family = AF_INET;
	servAddr.sin_addr.s_addr = inet_addr(ipAddr);        // inet_addr将字符串IP地址转成整数，且转成网络字节序
	servAddr.sin_port = htons(port);

	// 连接服务器
	if (connect(hsocket, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR )
	{
		error_handle("Failed to connect to server\n");
	}
	else
	{
		printf("Successfully connected to server %s: %d\n", ipAddr, port);
	}

	ushort operand_count = 0;
	printf("Plaese input operand count: ");
	scanf("%d", &operand_count);

	// 填充消息头
	buffer[0] = 'C';
	buffer[1] = 'K';

	buffer[2] = 0;
	buffer[3] = 0;

	// 填充运算数个数
	buffer[4] = (char) operand_count & 0x00ff;
	buffer[5] = (char) operand_count & 0xff00;

	for (int i=0; i<operand_count; ++i)
	{
		printf("Please input operand %d: ", i + 1);
		scanf("%d", (int32*)&buffer[i*OPERAND_SIZE + 6]);       // 操作数占用四个字节
	}

	// 填充运算符
	printf("Please Input operator: ");
	scanf(" %c", &buffer[operand_count*OPERAND_SIZE + 6]);  // 这里的%c前面必须加入空格，否则会因为前面输入按下的空格，而导致这里将前面按下的空格直接读入，导致输入值错误

	// 填充数据长度
	int dataLen = (operand_count * OPERAND_SIZE) + 2 + 1;   // 前四个字节不计入数据长度
	buffer[2] = (dataLen & 0xff);
	buffer[3] = (dataLen >> 8) & 0xff;

	// 发送数据包
	send(hsocket, buffer, sizeof(buffer), 0);

	// 接收服务端的数据
	int result;
	recv(hsocket, (char*)&result, sizeof(result), 0);       
	 
	if (result != RESULT_OVERFLOW)
	{
		printf("The calculate result is %d.\n", result);
	}
	else
	{
		printf("The calculate result is overflow!");
	}

	closesocket(hsocket);

	WSACleanup();

	// 避免控制台不出现
	system("pause");
    return 0;
}


// 服务端/客户端通信的消息格式
/*
    xx        xx              xx                 xxxx        xxxx      xxxx         x

   标识符   数据长度    运算数的个数(2bytes)       操作数1     操作数2    操作数n    运算符号
*/

运行结果如下图所示：

客户端输入以及结果展示

服务端输出：

更多相关内容

tcp/ip网络编程参考代码
2020-12-04 14:57:40

基于linux平台的tcp/ip网络编程参考代码，包括server端和client端代码，支持linux pc、嵌入式linux以及android（底层），支持gcc和ndk编译，已经验证通过，欢迎下载

收起
windows TCP/IP 网络编程（七）5种windows网络模型(5)完成端口
2022-04-12 15:09:02

windows TCP/IP 网络编程（七）5种windows网络模型(5)完成端口

收起
TCP／IP网络编程 带书签目录完整版.zip
2019-05-30 09:17:34

本书以通俗易懂的语言详细介绍了TCP/IP及其工作原理，以简单明了的编程实例全面介绍了基于Winsock的网络程序设计技术

收起
windows TCP/IP 网络编程（五）5种windows网络模型(4) 重叠IO模型(a)事件通知 DEMO
2022-04-11 23:13:38

windows TCP/IP 网络编程（五）5种windows网络模型(4) 重叠IO模型(a)事件通知 DEMO

收起