TCP/IP 网络编程入门（一）

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

基于 Linux 中的文件操作

打开文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char * path, int flag) //成功时返回文件描述符，失败返回 -1

~ path: 文件名的字符串地址
~ flag: 文件打开模式信息

关闭文件

#include <unistd.h>

int close(int fd); //成功返回0， 失败返回 -1

将数据写入文件

#include <unistd.h>
ssize_t write(int fd, const void * buf, size_t nbytes);

~ fd: 要写入的文件描述符
~ buf: 保存要传输数据的缓冲地址值
~ nbytes: 要传输数据的字节数

读取文件中的数据

#include <unistd.h>
ssize_t read(int fd, void * buf, size_t nbytes); //成功时返回接收的字节数（遇到文件结束符返回0），失败返回 -1

套接字类型和协议设置

创建套接字

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

~ domin: 套接字使用的协议族信息,PF_INET(IPv4)  PF_INET6(IPv6)
~ type: 数据传输类型， 面向连接(SOCK_STREAM)  面向消息(SOCK_DGRAM)
~ protocol: 计算机间通信中使用的协议信息

地址族与数据序列

表示IPv4地址的结构体

struct sockaddr_in
{
    sa_family_t       sin_family; // 地址族
    uint16_t          sin_port;   // 16位端口号
    struct in_addr    sin_addr;   // 32位IP地址
    char              sin_zero[8];// 不使用
}

struct in_addr
{
    In_addr_t         s_addr;     // 32 位IPv4 地址
}

sin_zero只为了是结构体sockaddr_in的大小和sockaddr一致而插入的成员。

struct sockaddr
{
    sa_family_t     sin_family;
    char            sa_data[14]; //地址信息
}

网络字节序和地址转换

1. 小端法(Little-Endian)就是低位字节(0x78)排放在内存的低地址端即该值的起始地址，高位字节排放在内存的高地址端。
2. 大端法(Big-Endian)就是高位字节排放在内存的低地址端即该值的起始地址，低位字节排放在内存的高地址端。

检测计算机是大字节序还是小字节序：

#include <stdio.h>
#include <netinet/in.h>
int main()
{
int i_num = 0x12345678;
printf("[0]:0x%x\n", *((char *)&i_num + 0));
printf("[1]:0x%x\n", *((char *)&i_num + 1));
printf("[2]:0x%x\n", *((char *)&i_num + 2));
printf("[3]:0x%x\n", *((char *)&i_num + 3));
i_num = htonl(i_num);
printf("[0]:0x%x\n", *((char *)&i_num + 0));
printf("[1]:0x%x\n", *((char *)&i_num + 1));
printf("[2]:0x%x\n", *((char *)&i_num + 2));
printf("[3]:0x%x\n", *((char *)&i_num + 3));

return 0;
}

每种CPU的保存方式都不相同，因此经过网络转换也必须保证信息字节序的正确性。

在网络传输的时候统一为大端序

以下是字节序转换的函数：

unsigned short htons(unsigned short);
unsigned short ntohs(unsigned short);
unsigned long htosl(unsigned long);
unsigned long ntohl(unsigned long);

h 代表主机(host)字节序；n 代表网络字节序；s 指 short(两字节，端口);l 指 long(四字节，IP);

htons: 把 short 型数据从主机字节序转换为网络字节序

地址格式的转换

sockaddr_in中保存地址信息的成员为32位整数，因此需要将IP地址保存为32位整数型数据。

#include <arpa/inet.h>

in_addr_t inet_addr(const char * string); //将点分十进制转换成32位整数,失败时返回 INADDR_NONE

#include <arpa/inet.h>

int inet_aton(const char * string, struct in_addr * addr); //跟上面的函数作用相同，只不过是填充到结构体中.成功返回1 ，失败返回0

#include <arpa/inet.h>

char * inet_ntoa(struct in_addr adr); //相反的转化，32位整数转换成点分十进制

网络地址初始化

初始化结构体sockaddr_in（上面提到过），在后面的代码中在解释。

每次创建服务器端的套接字都输入IP很麻烦，可以使用常数INADDR_ANY分配服务器端的IP。对于多IP的服务器，只要端口号一致，就可以从不同的IP地址接收数据。

向套接字分配网络地址

把初始化的地址信息分配给套接字。

#include <sys/socket.h>

int bind(int sockfd, struct sockaddr * myaddr, socklen_t addrlen); //成功时返回0， 失败时返回-1

~ sockfd: 要分配地址信息的套接字的文件描述符
~ myaddr: 存有地址信息的结构体变量地址值
~ addrlen: 结构体变量的长度

#include <sys/socket.h>

int listen(int sock, int backlog); 

~ sock: 希望进入等待连接请求状态的套接字文件描述符
~ backlog: 请求队列的长度

受理客户端连接请求

#include <sys/socket.h>

int accept(int sock, struct sockaddr * addr, socklen_t * addrlen);// 成功时返回创建的文件描述符， 失败返回 -1

~ sock: 服务器套接字文件描述符
~ addr: 保存发起连接请求的客户端地址信息的变量地址值，向这个地址的结构体写入客户端地址信息
~ addrlen: 上述结构体的长度，函数向这个变量写入值，因此使用指针

每次调用这个函数都会生成一个新的客户端套接字。这是一个比较重要的概念。

请求连接的客户端

#include <sys/socket.h>

int connect(int sock, struct sockaddr * servaddr, socklen_t addrlen); // 成功返回0， 失败返回-1

~ sock: 客户端套接字文件描述符
~ servaddr: 保存目标服务器端地址信息的变量地址值
~ addrlen: 上述结构体的字节长度

只有在服务器端接收连接请求或者网络异常导致的中断才会使上述函数返回

服务器端完整代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void err_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock; //服务器端套接字，用于“守门”
    int clnt_sock; //客户端套接字，循环使用
    char message[BUF_SIZE]; //消息缓存
    int str_len, i;

    struct sockaddr_in serv_addr; //保存服务器端的地址信息
    struct sockaddr_in clnt_addr; //保存客户端的地址信息
    socklen_t clnt_addr_size;     //地址结构体的长度

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

    serv_sock = socket(PF_INET, SOCK_STREAM, 0); //分配套接字

    if(serv_sock == -1)
        err_handling("socket() error");

    memset(&serv_addr, 0, sizeof(serv_addr)); //将服务器端地址结构体全置为0，将sin_zero置为0
    serv_addr.sin_family = AF_INET; // 地址族
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //本地IP转换为网络字节序
    serv_addr.sin_port = htons(atoi(argv[1])); //绑定端口号

    if(bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) // 取serv_addr(sockaddr_in)的前部分代码初始化 sockaddr 的部分，是一种有效且危险的转换
        err_handling("shenmecuoel bind() error");

    if(listen(serv_sock, 5) == -1)
        err_handling("listen() error");

    clnt_addr_size = sizeof(clnt_addr);
    for(i=0; i<5; i++) //只接受这么多的连接请求
    {
        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size); //将接受到的请求的客户端地址信息写入 clnt_addr
        if(clnt_sock == -1)
            err_handling("accept() error");
        else
            printf("Connected client. %d \n", i+1);

        while((str_len = read(clnt_sock, message, BUF_SIZE)) != 0)
            write(clnt_sock, message, str_len); //回显

        close(clnt_sock); //关闭客户端套接字，文件结束时候read返回0
    }

    close(serv_sock);
    return 0;
}

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

客户端代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char * message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len, recv_len, recv_cnt;
    struct sockaddr_in serv_addr;

    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) //向服务器端发起请求，函数返回也就是连接成功，向sock 写入信息也就是向服务器发送信息
        error_handling("connec() error");
    else
        puts("Connected ... ... ");
 while(1)
    {
        fputs("Inputs message(Q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);

        if(!strcmp(message, "Q\n"))
            break;

        str_len = write(sock, message, strlen(message));

        recv_len = 0;
        while(recv_len < str_len) //知道发送了多少数据，接收的数据要相等
        {
            recv_cnt = read(sock, &message[recv_len], BUF_SIZE - 1);
            if(recv_cnt == -1) // 面向连接的流，不存在数据边界
                error_handling("read() erroe");
            recv_len += recv_cnt;
        }

        message[recv_len] = 0;
        printf("message from server : %s \n", message);
    }
    close(sock);
    return 0;
}
void error_handling(char * message)
{
    fputs(message, stderr);
    fputc(‘\n‘, stderr);
    exit(1);
}

上述客户端解决收到字符串数据时立即读取并输出。

TCP套接字中的 I/O 缓冲

write函数调用后并非立即传输数据，read函数调用后并非马上接受数据。

• 每个套接字都存在输入缓冲和输出缓冲
• 缓冲区在创建套接字时自动生成
• 即使关闭套接字也会继续传输输出缓冲区中的数据
• 关闭套接字将丢失输入缓冲区中的数据