Part 1 start network programming:chapter two:2.1 套接字协议及其数据传输

第二章：套接字类型与协议设置

内容概览

详细讲解socket函数的参数含义，以及涉及到的套接字协议

#include <sys/socket.h>
int socket(int domain, int type, int protocol)
-> 成功时返回文件描述符，失败是返回-1
参数说明：
	domain：		套接字中使用的协议族 (Protocol Family)信息
	type：		套接字数据传输类型信息
	protocol：	计算机间通信中使用

本章涉及套接字编程的基本内容，是第4章介绍的实际网络编程的基础
本章重点是了解创建套接字时调用的socket函数。

正文

2.1 套接字协议及其数据传输

2.1.1 关于协议（Protocol）

协议就是双方对话中使用的通信规则，把上述规则概念拓展到计算机领域可以整理为"计算机见对话必备通信规则！"

2.1.2 创建套接字

使用socket函数~ 下面进行详细讲解

#include <sys/socket.h>
int socket(int domain, int type, int protocol)
-> 成功时返回文件描述符，失败是返回-1
参数说明：
	domain：		套接字中使用的协议族 (Protocol Family)信息
	type：		套接字数据传输类型信息
	protocol：	计算机间通信中使用的协议信息

2.1.3 协议族（Protocol Family）（第一个参数）int socket(int domain, int type, int protocol)

通过socket函数的第一个参数传递套接字中使用的协议分类信息，此协议分类信息成为协议族。可以分为以下几类：
（头文件 <sys/socket/h>中 声明的协议族）

####这里是一个图~~~~·

主要学习第一个 PF_INET 对应的IPv4互联网协议族。
套接字中实际采用的最终协议信息是通过socket函数的第三个参数传递的。 在指定协议族范围内通过第一个参数决定第三个参数。

2.1.4 套接字类型（Type）（第二个参数）int socket(int domain, int type, int protocol)

套接字类型指的是套接字的数据传输方式，通过socket函数的第二个参数传递，只有这样才能决定创建的套接字的数据传输方式。

这里可能会有问题，第一个参数domain不是确定了协议族了嘛~不就已经确定了数据传输方式了嘛？

其实，决定了协议族并不能同时决定数据传输方式，
换言之，socket函数第一个参数PF_INET协议族中也存在多种数据传输方式！

下面说两种：面向连接的套接字（SOCK_STREAM） && 面向消息的套接字（SOCK_DGRAM）

1. 套接字类型1：面向连接的套接字（SOCK_STREAM）

"可靠的、按顺序传递的、基于字节的、面向连接的数据传输方式 的套接字"

我们一点点看上面这句话
面向连接的套接字类似于流水线工作，其特点是：
1）传输过程中数据不会消失
2）按顺序传输数据
3）传输的数据不存在数据边界
4）一一对应（面向连接的套接字只能与相同特性的套接字连接）

我们以write和read函数为例，说明这个过程：
传输数据的计算机调用了3次write函数传输了300个字节（相当于在流水线上放置了3份商品），
接受数据的计算机通过一次read函数，将300个字节全部接收（相当于攒了3份商品一起打包了）

这个过程是通过什么实现的呢?
收发数据的套接字内部存在缓冲（buffer）可以理解成字节数组，
类似于队列的方式，先进先出，一次read读取可以读取任意长度的缓冲区。因此说面向连接的套接字是不存在数据边界的。

（有人可能会问：buffer满了怎么办？ 其实，这时套接字就无法在接收数据了，也就是无法accept数据了，但与此同时，传输端套接字也会停止传输（停止write）
又有人问了：为什么不会丢失？上面的回答能够保证数据不会因为buffer满了而丢失，同时，如果传输出错会提供重传服务。）

2. 套接字类型2：面向消息的套接字（SOCK_DGRAM）

"不可靠的、不按顺序传递的、以数据的高速传输为目的 的套接字"

面向消息的套接字（SOCK_DGRAM）更像是快递包裹的传输方式
1）强调快速传输而非传输顺序
2）传输的数据可能丢失也可能损毁
3）传输的数据有数据边界 （传输次数 = 接收数据次数，一次write就对应一次read）
4）限制每次传输的数据大小 （包裹不能太大）
5）不存在连接这一概念

2.1.5 协议的最终选择（第三个参数）int socket(int domain, int type, int protocol)

这里说说socket套接字函数的最后一个参数 protocol

其实可以说 通过前面两个参数（domain 协议族选择 type 传输方式选择）已经决定大多数的采用的协议了
所以大多数情况下可以向第三个参数传递 0 ，除非下面这种情况：
“同一协议族中存在多个数据传输方式相同的协议”（也就是说前俩参数定不下来这个协议。。）
当然，我这里是遇不到这样的。。

下面我们以之前的内容为基础，
1. 构建向socket函数传递的参数 "IPv4协议族中面向连接的套接字"

由上面内容知道：PF_INET指IPv4协议族，SOCK_STREAM是面向连接的数据传输。–》满足这2个条件的协议只有 IPPROTO_TCP（因此就算第三个选择0也是tcp协议呀~）

因此可以调用socket函数创建套接字，这种套接字成为TCP套接字

int tcp_socket = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);

2."构建IPv4协议族中面向消息的套接字"
满足上述条件的协议只有 IPPROTO_UDP

int udp_socket = socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);

上面花了这么多时间，就是为了让大家了解他们创建的套接字特性，传说中的 TCP/UDP到底是什么东西！

2.1.6 面向连接的套接字：TCP套接字示例

这里是由之前的
hello_server.c -> tcp_server:没有变化
hello_client.c -> tcp_client:更改了read函数的调用方式
目的是验证 无数据边界 这一特性，让write函数的调用次数不同于 read函数的调用次数
服务器端：hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);

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

	struct sockaddr_in serv_addr;
	struct sockaddr_in clnt_addr;
	socklen_t clnt_addr_size;

	char message[] = "Hello world";

	if(argc != 2){
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}

	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
	if(serv_sock == -1){
		error_handling("socket() error");
	}

	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(atoi(argv[1]));

	if(bind(serv_sock,(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){
		error_handling("bind() error");
	}
	
	if(listen(serv_sock, 5) == -1){
		error_handling("listen() error");
	}

	clnt_addr_size = sizeof(clnt_addr);
	clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

	if(clnt_sock == -1){
		error_handling("accept() error");
	}
	
	write(clnt_sock, message, sizeof(message));
	close(clnt_sock);
	close(serv_sock);
	return 0;
}
void error_handling(char* message)
{
	fputs(message,stderr);
	fputc('\n',stderr);
	exit(1);
}

tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sock;
	struct sockaddr_in serv_addr;
	char message[] = "Hello world";		// 这里只是为了弄一个一样大的数组
	int str_len = 0;
	int idx = 0,read_len = 0;

	if(argc != 3){
		printf("Usage: %s <IP> <port>\n", argv[0]);
		exit(1);
	}

	sock = socket(PF_INET, SOCK_STREAM, 0);
	if(sock == -1){
		error_handling("socket() error");
	}

	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
	serv_addr.sin_port = htons(atoi(argv[2]));

	if(connect(sock,(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){
		error_handling("bind() error");
	}
	
	// 这里更改！
	while(read_len = read(sock,&message[idx++],1)){
		if(read_len == -1){
			error_handling("read() error!");
		}
		str_len += read_len;
	}
	printf("message from server : %s\n",message );
	printf("Function read call count : %d\n",str_len );
	close(sock);
	return 0;
}
void error_handling(char* message)
{
	fputs(message,stderr);
	fputc('\n',stderr);
	exit(1);
}

%%%%%%%%%%%%%%%%%%%这里是结果图%%%%%%%%%%%%%

可以看出，服务器端一次性发送了12字节的数据，客户端调用了12次read函数进行读取