Linux网络编程1-简单的CS通信程序

---

1.Socket相关API说明

1.1字节序转换函数：用于ip和port转换

网络字节序是大端字节序：低位地址存放高位数据, 高位地址存放低位数据。一般主机字节序是小端字节序：低位地址存放低位数据, 高位地址存放高位数据。

0x12345678
大端存储：12 34 56 78
小端存储: 78 56 34 12

小端字节序需要转换为大端字节序：

整形的转换函数：一般用于端口htons。

#include <arpa/inet.h>
// 主机到网络
uint32_t htonl(uint32_t hostlong); 
uint16_t htons(uint16_t hostshort);
// 网络到主机
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

IP地址转换函数：

int inet_pton(int af, const char *src, void *dst); // 点分十进制转换为网络字节序 
// inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr); 127.0.0.1 -> [100007f]

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); // 网络字节序转换为点分十进制IP地址

1.2sockaddr结构

struct sockaddr {
    typedef unsigned short int sa_family_t;
    sa_family_t sa_family; // AF_INET
    char     sa_data[14];  // 地址信息：2个字节存放port，4个字节存放ip，剩下8个字节空闲
}

使用sockaddr结构不方便，一般使用sockaddr_in结构，两个结构体大小相同。

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address.  */
typedef uint32_t in_addr_t;
struct in_addr {
    in_addr_t s_addr;
};

如果函数需要sockaddr结构，可以使用sockaddr_in变量，然后强转成sockaddr结构：

struct sockaddr_in serv;
serv.sin_family = AF_INET;
serv.sin_port = htons(6789);
// 服务器的ip地址：点分十进制ip地址转换为网络ip
inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);

int ret = connect(cfd, (struct sockaddr *)&serv, sizeof(serv));

1.3socket函数 以及两个队列

int socket(int domain, int type, int protocol);

/*
domain: 协议版本
AF_INET IPV4
AF_INET6 IPV6
AF_UNIX AF_LOCAL本地套接字使用

type:协议类型
SOCK_STREAM 流式, 默认使用的协议是TCP协议
SOCK_DGRAM  报式, 默认使用的是UDP协议

protocal: 
一般填0, 表示使用对应类型的默认协议.

成功: 返回一个大于0的文件描述符
失败: 返回-1, 并设置errno
*/
int cfd = socket(AF_INET, SOCK_STREAM, 0);

当调用socket函数以后, 返回一个文件描述符, 内核会提供与该文件描述符相对应的读和写缓冲区, 同时还有两个队列, 分别是请求连接队列和已连接队列.

1.4bind listen connect accept

bind：将socket文件描述符和IP，PORT绑定

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/*
成功: 返回0
失败: 返回-1, 并设置errno
*/
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(6789); // 主机到网络字节序
serv.sin_addr.s_addr = htonl(INADDR_ANY); // 使用本机任意有效的可用IP
int ret = bind(lfd, (struct sockaddr *) &serv, sizeof(serv));
if (ret < 0)
{
    perror("bind error");
    return -1;
}

listen：将套接字由主动态变为被动态：

int listen(int sockfd, int backlog);
/*
backlog: 同时请求连接的最大个数(还未建立连接) 

成功: 返回0
失败: 返回-1, 并设置errno
*/
ret = listen(lfd, 128); // 请求连接的最大个数128
if(ret < 0)
{
    perror("listen error");
    return -1;
}

accept：获得一个连接,，若当前没有连接则会阻塞等待.

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
/*
addr: 传出参数, 保存客户端的地址信息
addrlen: 传入传出参数,  addr变量所占内存空间大小

成功: 返回一个新的文件描述符,用于和客户端通信
失败: 返回-1, 并设置errno值.
*/
struct sockaddr_in client;
socklen_t len = sizeof(client);
int cfd = accept(lfd, (struct sockaddr *)&client, &len);
if(cfd < 0)
{
    perror("accpet error");
    return -1;
}

accept函数是一个阻塞函数, 若没有新的连接请求, 则一直阻塞。从已连接队列中获取一个新的连接, 并获得一个新的文件描述符, 该文件描述符用于和客户端通信. (内核会负责将请求队列中的连接拿到已连接队列中)

调用accept函数不是说新建一个连接，而是从已连接队列中取出一个可用连接.

connect：连接服务器

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/*
addr: 服务端的地址信息

成功: 返回0
失败: 返回-1, 并设置errno值
*/
int ret = connect(cfd, (struct sockaddr *)&serv, sizeof(serv));
if(ret<0)
{
    perror("connect error");
    return -1;
}

1.5收发数据

可以使用write和read函数进行读写操作。还可以使用recv和send函数。

// 读取数据和发送数据:
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

// 对应recv和send这两个函数flags直接填0就可以了.
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t send(int sockfd, const void *buf, size_t len, int flags);	

注意: 如果写缓冲区已满, write也会阻塞, read读操作的时候, 若读缓冲区没有数据会引起阻塞.

2.服务器和客户端程序代码流程

3.服务器端

#include <iostream>

#include <sys/types.h>
#include <sys/socket.h> // socket
#include <netinet/in.h> // sockaddr_in
#include <cstring> // bzero
#include <unistd.h> // read

int main()
{
    std::cout << "STR_TEST: " << STR_TEST << std::endl;
    // 1.创建监听套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0) {
        perror("socket error");
        return -1;
    }

    // 2.绑定本地ip和port
    struct sockaddr_in serv;
    bzero(&serv, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(6789); // 主机到网络字节序
    serv.sin_addr.s_addr = htonl(INADDR_ANY); // 使用本机任意有效的可用IP
    int ret = bind(lfd, (struct sockaddr *) &serv, sizeof(serv));
    if (ret < 0)
    {
        perror("bind error");
        return -1;
    }

    // 3.监听端口
    ret = listen(lfd, 128); // 请求连接的最大个数128
    if(ret < 0)
    {
        perror("listen error");
        return -1;
    }

    // 4.从连接队列中取出一个通信
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int cfd = accept(lfd, (struct sockaddr *)&client, &len);
    if(cfd < 0)
    {
        perror("accpet error");
        return -1;
    }

    // 5.读写数据
    while(1)
    {
        char buf[1024];
        bzero(buf, sizeof(buf));

        ssize_t n = read(cfd, buf, sizeof(buf));
        if(n <= 0)
        {
            std::cout << "read error or client close, n=" << n << std::endl;
            break;
        }
        std::cout << "n=" << n << ", buf=" << buf << std::endl;

        // 将接收的数据转为大写，然后发送给客户端
        for(int i= 0;i<n;++i)
        {
            buf[i] = toupper(buf[i]);
        }
        n = write(cfd, buf, n);
        if(n < 0)
        {
            perror("write error");
            break;
        }
    }

    close(cfd);
    close(lfd);

    return 0;
}

4.客户端

#include <iostream>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h> // inet_pton
#include <cstring>
#include <unistd.h> // read write

int main(int argc, char* argv[])
{
    std::cout << "STR_TEST: " << STR_TEST << std::endl;
    // 1.创建socket
    int cfd = socket(AF_INET, SOCK_STREAM, 0);
    if(cfd<0)
    {
        perror("socket error");
        return -1;
    }
    struct in_addr
    // 2.连接服务端
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(6789);
    // 服务器的ip地址：点分十进制ip地址转换为网络ip
    inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    //printf("[%x]\n", serv.sin_addr.s_addr); [100007f]
    int ret = connect(cfd, (struct sockaddr *)&serv, sizeof(serv));
    if(ret<0)
    {
        perror("connect error");
        return -1;
    }

    while(1)
    {
        char buf[256];
        //读标准输入数据
        bzero(buf, sizeof(buf));
        int n = read(STDIN_FILENO, buf, sizeof(buf));

        //发送数据
        write(cfd, buf, n);

        //读服务端发来的数据
        bzero(buf, sizeof(buf));
        n = read(cfd, buf, sizeof(buf));
        if(n<=0)
        {
            std::cout << "read error or server closed, n=" << n << std::endl;
            break;
        }
        std::cout << "n=" << n << ", buf=" << buf << std::endl;

    }

    //关闭套接字cfd
    close(cfd);

    return 0;
}

5.测试accept不是建立连接而是从已连接的队列中取出一个通信

测试过程中可以使用netstat命令查看监听状态和连接状态

netstat命令:

a表示显示所有,

n表示显示的时候以数字的方式来显示

p表示显示进程信息(进程名和进程PID)

accept函数是从已连接队列中取出一个通信，可以在调用accept函数之前sleep一分钟，在此期间，执行客户端连接到服务器，查看端口监听状态，sleep结束后会accept，然后再查看端口监听状态。

1.执行Server accpet前等待30s
2.执行Client
3.netstat -anp | grep 6789 查看端口状态 连接已建立。
4.30s过后
5.再次执行netstat -anp | grep 6789 查看端口状态