第一章 理解网络编程和套接字

第一章 理解网络编程和套接字

1.1 理解网络编程和套接字

1.1.1 构建打电话的套接字

以电话机打电话的方式来理解套接字。

调用socket函数（安装电话机）时进行的对话：

问：接电话需要准备什么？

答：当然是电话机。

有电话机才能够通电话，于是需要准备一个电话机，下面的函数相当于电话机的套接字。

#include <sys/socket.h>
int socket(int domain, int type, int protocol);
//成功时返回文件描述符，失败返回-1

调用bind函数（分配电话号码）时进行的对话：

问：请问我的电话号码是多少

答：我的电话号码是123-1234

套接字同样如此，就像给电话机分配电话号码一样，利用以下函数给创建好的套接字分配地址信息（IP地址和端口号）：

#include <sys/socket.h>
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);
//成功时返回0，失败时返回-1

调用bind函数给套接字分配地址之后，就完成了所有的准备工作。接下来就是需要连接电话线并且等待来电。

调用listen函数（连接电话线）时进行的对话：

问：已架设完的电话机是否只需要连接电话线？

答：对，只需要连接就能接听电话。

连接电话线后，电话机就可以转换为可接听的状态，这时其他人可以拨打电话请求连接到该机。同样，需要把套接字转换成可接受连接到状态。

#include <sys/socket.h>
int listen(int sockfd, int backlog);
//成功时返回0，失败时返回-1

连接好电话线之后，如果有人拨打电话就响铃，拿起话筒才能接听。

调用accept函数（拿起话筒）时进行的对话：

问：电话铃响了，该怎么办：

答：当然是接听啊。

#include <sys/socket.h>
int accept(int sockfd, struct *addr, socklen_t *addrlen);
//成功是返回文件描述符，失败是返回-1

套接字创建和连接的过程可以整理为：

1. 调用socket函数创建套接字。
2. 调用bind函数分配ip地址和端口号。
3. 调用listen函数转换为可接受请求状态。
4. 调用accept函数受理套接字请求。

1.1.2编写Hello World套接字程序

服务端：

服务器端（server）是能够受理连接请求的程序。下面构建的服务器端以验证之前提到的函数调用过程，该服务器收到连接请求后向请求者返回Hello World!答复。除各种函数的调用顺序外，我们还未涉及任何实际编程。因此，阅读代码时请重点关注套接字相关的函数调用过程，不必理解全过程。

服务端代码：如下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;
    socklent_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(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);
}

客户端：

客户端程序只有调用socket函数创建套接字和调用connect函数向服务器端发送连接请求两个步骤。

1. 调用socket函数和connect函数
2. 与服务器端共同运行来收发数据

客户端代码：如下hello 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[30];
    int str_len;
    if(argc != 3)
    {
        printf("Usage ：%s <IP> <port>\n",argv[0]);
        exit(1);
    }
    
    //创建套接字，此时套接字并不会马上分为服务算和客户端，如果紧接着调用bind，listen函数，将成为服务器端套接字
    //如果调用connect函数，将成为客户端套接字
    socket = 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!");
    }
    str_len = read(sock,message,sizeof(message)-1);
    if(str_len == -1)
    {
        error_handling("connect() error!");
    }
    printf("Message from server : %s\n",message);
    close(sock);
    return 0;
}

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

编译：

分别对客户端和服务器端进行编译：

gcc hello_server.c -o hserver
gcc hello_client.c -o hclient

运行：

./hserver 9190
./hclient 127.0.0.1  9190

运行的时候，首先在9190端口启动服务，然后hserver就会一直等待客户端响应，当客户端监听位于本地的IP地址为127.0.0.1的地址端口时，客户端就会收到服务器端的回应，输出Hello World

1.2基于Linux的文件操作

​ 讨论套接字的过程中突然谈论文件也许有些奇怪。但是对于Linux而言，socket操作与文件操作没有区别，因而有必要详细了解文件。在Linux世界里，socket也被认为是文件的一种，因此在网络数据传输过程中自然可以使用i/o的相关函数。 而Windos与Linux不同，要区分socket和文件。因此在Windos中需要调用特殊的数据传输相关函数。

1.2.1底层访问和文件描述符

分配给标准输入输出及标准错误的文件描述符。

文件描述符	对象
0	标准输入：Standard Input
1	标准输出：Standard OutPut
2	标准错误：Standard Error

文件和套接字一般经过创建过程才会被分配文件描述符。

1.12.2 打开文件：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *path, int flag);
/*
成功时返回文件描述符，失败时返回-1
path：文件名的字符串地址
flag：文件的打开模式信息
*/

文件打开模式如下表：

打开模式	含义
O_CREAT	必要时创建文件
O_TRUNC	删除全部现有收据
O_APPEND	维持现有数据，追加到后面
O_RDONLY	只读打开
O_WRONLY	只写打开
O_RDWR	读写打开

1.2.3关闭文件：

#include <unistd.h>
int close(int fd);
/*
	成功时返回0，失败时返回-1
	fd ：需要关闭的文件或者套接字的文件描述符
*/

若调用此函数的同时传递文件描述符参数，则关闭（终止）响应文件。另外需要注意的是，此函数不仅可以关闭文件，还可以关闭套接字。再次证明了Linux操作系统不区分文件与套接字的特点。

1.2.4 将数据写入文件：

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t nbytes);
/*
成功时返回写入到字节数，失败时返回-1
fd：显示数据传输对象的文件描述符
buf：保存要传输数据的缓冲值地址
nbytes:要传输数据的字节数
*/

在此函数的定义中，size_t是通过typedef声明的unsigned int 类型。对于ssize_t 来说，ssize_t前面多加的s代表signed，即ssize_t是通过typedef声明的signed int类型。

创建新文件并保存数据：

代码：如下

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void error_handling(char *message);

int main()
{
    int fd;
    char buf[] = "Let's go!\n";
    // O_CREAT | O_WRONLY | O_TRUNC 是文件打开模式，将创建新文件，并且只能写,以清空文件中的全部数据。
    fd = open("file.txt",O_CREAT|O_WRONLY|O_TRUNC);
    if(fd == -1)
    {
        error_handling("open() error!");
    }
    printf("file descriptor: %d\n",fd);
    //向对应fd中保存文件描述符的文件传输 buf 中保存的数据。
    
    if(write(fd,buf,sizeof(buf)) == -1)
    {
        error_handling("write() error!");
    }
    close(fd);
    return 0;
}

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

编译运行：

gcc low_open.c -o lopen
./lopen

然后会生成一个data.txt文件，里面有Let's go!

1.2.5 读取文件中的数据：

与之前的write() 函数相对应，read() 用来输入（接受）数据。

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t nbytes);
/*
成功时返回接收的字节数（但是遇到文件结尾则返回0），失败返回-1
fd：显示数据接收对象的文件描述符
buf：要保存接收的数据的缓冲地址值
nbytes：要接收数据的最大字数
*/

下面示例通过read() 函数读取data.txt中保存的数据。

代码：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define BUF_SIZE 100

void error_handling(char *message);

int main()
{
    int fd;
    char buf[BUF_SIZE];
    
    fd = open("data.txt",O_RDONLY);
    if(fd == -1)
    {
        error_handling("open() error!");
    }
    printf("file descriptor: %d \n",fd);
    
    if(read(fd,buf,sizeof(buf)) == -1)
    {
        error_handling("read() error!");
    }
    printf("file data: %s ",buf);
    close(fd);
    return 0;
}

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

编译运行：

gcc low_read.c -o lread
./lread

在上一步的data.txt文件没有删除的情况下，会输出：

file descriptor:3
file data: Let's go!

关于文件描述符的i/o操作到此结束，要明白，这些内容同样适用于套接字。

1.2.6 文件描述符与套接字

下面将同时创建文件和套接字，并用整数型态比较返回的文件描述符的值。

代码：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>

int mian()
{
    int fd1,fd2,fd3;
    //创建一个文件和两个套接字
    fd1 = socket(PF_INET,SOCK_STREAM,0);
    fd2 = open("test.dat",O_CREAT|O_WRONLY|O_TRUNC);
    fd3 = socket(PF_INET,SOCK_GGARM,0);
    
    //输出之前创建的文件描述符的整数值
    printf("file descriptor 1:%d\n",fd1);
    printf("file descriptor 2:%d\n",fd2);
    printf("file descriptor 3:%d\n",fd3);
    
    close(fd1);
    close(fd2);
    close(fd3);
    
    return 0;
}

编译运行：

gcc fd_seri.c  -o fds
./fds

输出结果：

file descriptor 1:3
file descriptor 2:15
file descriptor 3:16