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

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

本小节主要是了解套接字创建时调用的socket函数。

2.1套接字协议及数据传输特性

2.1.1 创建套接字

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

2.1.2 协议族（protocol Family）

通过socket函数的第一个参数传递套接字中使用的协议分类信息。此协议分类信息成为协议族，可分为如下几类：

头文件 sys/socket.h中声明的协议族

名称	协议族
PF_INET	IPV4互联网协议族
PF_INET6	IPV6互联网协议族
PF_LOCAL	本地通信Unix协议族
PF_PACKET	底层套接字的协议族
PF_IPX	IPX Novel 协议族

PF_INET对应的IPV4比较常见，重点理解，其他协议不常用。另外，套接字中采用的最终协议信息是通过socket函数的第三个参数传递的。

2.1.3 套接字类型（Type）

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

​ 已经通过第一个参数传递了协议族信息，为什么还要决定数据传输方式呢？

​ 问题就在于，决定了协议族并不能同时决定数据的传输方式。换言之，socket函数的第一个参数PF_INET协议族中也存在多种数据传输方式。

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

​ 如果socket函数的第二个参数传递SOCK_STREAM，将创建面向连接的套接字。

传输方式的特征：

• 传输过程中数据不会消失
• 按序传输数据
• 传输的数据不存在边界（Boundary）

这种情形适用于之前说过的write和read函数

传输数据的计算机通过调用3次write函数传递100字节的数据，但是接收数据的计算机只需要调用一次read函数就能把100字节数据全部接收。

收发数据的套接字内部有缓冲区，简言之就是字节数组，只要不超过数组的容量 ，那么数据填满缓冲区之后1次read函数调用就能把全部读取出来，也可以多次调用来完成读取。

套接字缓冲已满是否意味者数据丢失？

​ 缓冲并不总是满的。如果读取速度比传入速度慢，则缓冲可能会被填满，但是数据也不会丢失，因为传输套接字会停止数据传输，所以面向连接的套接字不会发生数据丢失。

2.1.3.2 面向消息的套接字（SOCK_DGAM）

如果socket函数的第二个参数传递SOCK_DGARAM,则将创建面向消息的套接字。面向消息的套接字可以比喻成高速移动的摩托车队。特点如下：

• 强调快速传输而非传输有序
• 传输的数据可能丢失也可能损毁
• 传输的数据有边界
• 限制每次传输数据的大小

面向消息的套接字比面向连接的套接字更具有传输速度，但是可能丢失。

2.1.4协议的最终选择

socket函数的第三个参数决定最终的采用协议。前面已经通过两个参数传递了协议族信息和套接字数据传输方式，有这些信息还不够吗？为什么还要传输第三个参数呢？

可以应对同一协议族中存在的多个数据传输方式相同的协议，但是协议不同，需要第三个参数指定具体的协议信息。

IPV4协议族，面向连接的数据传输，同时满足这两个条件的协议只有IPPROTO_TCP，因此可以如下调用socket函数创建套接字，这种套接字称为TCP套接字。

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

SOCK_DGRAM指的是面向消息的数据传输方式，满足上述条件的协议只有IPPROTO_UDP。这种套接字被称为UDP套接字。

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

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

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_adr;
    char message[30];
    int str_len = 0;
    int idx = 0; read_len = 0;
    
    if(argc != 3)
    {
        printf("Usage : %s <IP> <port>\n",argv[0]);
        exit(0);
    }
    //创建套接字，此时套接字不会立马区分客户端和服务器端，如果紧接着bind，listen 函数，将成为服务器套接字
    //如果调用connect函数 将会成为客户端
    //如果前两个使用PF_INET 和 SOCK_STREAM,则可以省略第三个单数IPPROTO_TCP
    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]));
    
    //调用connect函数向服务器发送请求
    if(connect(sock, (struct sockaddr *)&serv_addr,sizeof(serv_addr)) == -1)
    {
        error_handling("connect() error");
    }
    
    //当read函数返回0的时候条件为假，跳出循环。
    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 conut : %d \n",str_len);
    close(sock);
    
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

tcp_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);
    }
    //调用 socket 函数创建套接字
    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]));
    //调用 bind 函数分配ip地址和端口号
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("bind() error");
    //调用 listen 函数将套接字转为可接受连接状态
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    clnt_addr_size = sizeof(clnt_addr);
    //调用 accept 函数受理连接请求。如果在没有连接请求的情况下调用该函数，则不会返回，直到有连接请求为止
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
    if (clnt_sock == -1)
        error_handling("accept() error");
    //稍后要将介绍的 write 函数用于传输数据，若程序经过 accept 这一行执行到本行，则说明已经有了连接请求
    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);
}

编译：

gcc tcp_client.c -o hclient
gcc tcp_server.c -o hserver

运行：

./hserver 9190
./hclient 127.0.0.1 9190

结果：

Message from server : Hello World!
Function read call count: 13

从运行结果来看服务器端发送了13个字节的数据，客户端调用了13次read函数读取数据。