Linux网络编程套接字

Linux 网络编程套接字 在每一个IP数据包的首部(Header)中,包含两个关键字段:源IP地址(Source IP Address) 和 目标IP地址(Destination IP Address),它们共同标识了数据包的发送方和接收方。UDP(用户数据报协议)是一个轻量级的传输层协议,它和 TCP 一样,也建立在 IP 协议之上。网络编程中的地址转换函数主要用于 字符串地址(如 "127.0.0.1") 和二进制地址(如 in_addr 结构体)之间的相互转换,它们常用于设置 socket 地址和打印对端地址。 阅读详情

目录

一.预备知识

二.网络字节序

三.socket结构

四.socket编程接口

 五.UDP协议实践

六.tcp协议实践 

七.TCP协议通讯流程 


一.预备知识

认识端口号:

1.端口号(port)是传输层协议的内容;
2.端口号是一个2字节16位的整数;
3.端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
4.IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
5.一个端口号只能被一个进程占用;

理解 "端口号" 和 "进程ID"

我们之前在学习系统编程的时候, 学习了 pid 表示唯一一个进程; 此处我们的端口号也是唯一表示一个进程. 那么这两者之间是怎样的关系?
两者没有关系,因为是两个不同的模块,没必要绑定在一起,因为一个是网络层次的,另一个是操作系统层次的,另外, 一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定,10086,你打这个电话,并不是同一个人给你服务,就说明了,一个进程可以绑定多个端口号。

理解源端口号和目的端口号:

传输层协议(TCP和UDP)的数据段中有两个端口号, 分别叫做源端口号和目的端口号。就是在描述 “数据是谁发的, 要发给谁”

源端口号: 表示该条信息来源于哪个进程。
目的端口号: 表示该条信息去往于哪个机器。

认识TCP协议

此处我们先对TCP(Transmission Control Protocol 传输控制协议)有一个直观的认识; 后面我们再详细讨论TCP的一些细节问题。

1.传输层协议
2.有连接: 双方在发送网络数据之前必须建立连接,再进行发送
3.可靠传输: 保证数据是可靠并且有序的到达对端,例如发送123、456时123数据先到达,456数据后到达。即使456数据先到达传输层,也会阻塞等待前面的数据123先到达。
4.面向字节流: TCP发送数据的单位是以字节为单位,并且数据没有明显的边界例如:123456数据不会分开

认识UDP协议 

这里我们也先对UDP(User Datagram Protocol 用户数据报协议)有一个直观的认识;,后面再详细讨论。

1.传输层协议

2.无连接: 双方在发送网络数据之前不需要建立连接,直接发送,客服端不用管服务端是否在线

3.不可靠传输: UDP并不会保证数据有序的到达对端

4.面向数据报: UDP不管向应用层还是网络层传递数据都是整条数据

对比一下TCP和UDP

TCP是可靠传输,有连接,字节流
UDP是不可靠传输,无连接,数据报

二.网络字节序

我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分, 网络数据流同样有大端小端之分. 那么如何定义网络数据流的地址呢?

1.发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出
2.接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存
3.因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址
4.TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节
5.不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据
6.如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可

为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络字节序和主机字节序的转换。

这些函数名很好记,h表示host,n表示network,l表示32位长整数,s表示16位短整数。例如htonl表示将32位的长整数从主机字节序转换为网络字节序,将IP地址转换后准备发送。如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回;如果主机是大端字节序,这些函数不做转换,将参数原封不动地返回。 

三.socket结构

socket常见API(接口) 

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);
// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr * address,socklen_t address_len);*
// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);
// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);
// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr*addr,socklen_t addrlen);

常见的套接字有三种,分别为,域间socket,原始socket,网络socket,理论上,是三种应用场景,对应的应该是三套接口,但是不想设计太多接口,就将所有的接口进行统一。

sockaddr结构
socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、 IPv6,以及后面要讲的UNIX DomainSocket. 然而, 各种网络协议的地址格式并不相同.

Sockaddr_in是网络socket,Sockaddr_un是域间socket,统一使用sockaddr,根据前两个字节分辨是哪一个(Sockaddr_in,Sockaddr_un)。

1.IPv4和IPv6的地址格式定义在netinet/in.h中,IPv4地址用sockaddr_in结构体表示,包括16位地址类型, 16位端口号和32位IP地址.

2.IPv4、 IPv6地址类型分别定义为常数AF_INET、 AF_INET6. 这样,只要取得某种sockaddr结构体的首地址,不需要知道具体是哪种类型的sockaddr结构体,就可以根据地址类型字段确定结构体中的内容.
3.socket API可以都用struct sockaddr *类型表示, 在使用的时候需要强制转化成sockaddr_in; 这样的好处是程序的通用性, 可以接收IPv4, IPv6, 以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数;

 sockaddr 结构

sockaddr 结构用于存储参与(IP)Windows/linux套接字通信的计算机上的一个internet协议(IP)地址。为了统一地址结构的表示方法 ,统一接口函数,使得不同的地址结构可以被bind()、connect()、recvfrom()、sendto()等函数调用。但一般的编程中并不直接对此数据结构进行操作,而使用另一个与之等价的数据结构sockaddr_in。这是由于Microsoft TCP/IP套接字开发人员的工具箱仅支持internet地址字段,而实际填充字段的每一部分则遵循sockaddr_in数据结构,两者大小都是16字节,所以二者之间可以进行切换。

sockaddr_in 结构

虽然socket api的接口是sockaddr, 但是我们真正在基于IPv4编程时, 使用的数据结构是sockaddr_in; 这个结构里主要有三部分信息: 地址类型, 端口号, IP地址。

in_addr结构

in_addr用来表示一个IPv4的IP地址. 其实就是一个32位的整数。

四.socket编程接口

 

功能: 打开一个网络通讯端口,打开后应用程序可以像读写文件一样用read/write在网络上收发数据,说白了就是,创建一个套接字,返回值是文件描述符,失败返回-1。

参数:

domain:协议域,对于IPv4, family参数指定为AF_INET。
type:socket的类型,流格式套接字(SOCK_STREAM)、数据报格式套接字(SOCK_DGRAM)。
protocol:协议,当protocol为0时,会自动选择type类型对应的默认协议。

功能: 服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接; 服务器需要调用bind绑定一个固定的网络地址和端号,bind函数的功能就是将参数sockfd和addr绑定在一起,返回值是成功0,失败-1。

参数:

sockfd:创建的套接字,即socket函数返回的文件描述符,唯一标识一个socket
addr:sockaddr结构体
addrlen:struct sockaddr *是一个通用指针类型,addr参数实际上可以接受多种协议的sockaddr结构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度

 接下来需要详细的讲一下addr这个参数,

bzero (&local sizeof(local)) ;// 将整个结构体清零
local.sin_family = AF_INET;// 设置地址类型为AF_INET

local.sin_port = htons(_port);// 端口号为_port
local.sin_addr.s _addr= _ip.empty()?INADDR_ANY:inet_addr(_ip.c_str());// 网络地址IP为_ip,因为我们一般是不bind固定ip的,所以这里如果没有具体IP就使用INADDR_ANY,这个宏表示本地的任意IP地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个IP 地址, 这样设置可以在所有的IP地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个IP 地址

功能:声明sockfd处于监听状态, 并且最多允许有backlog个客户端处于连接等待状态, 如果接收到更多的连接请求就忽略,返回值:成功返回0,失败返回-1。 

参数:

sockfd:创建的套接字

backlog:最多允许客户端处于连接等待状态的个数(通常设置为5)

 功能: 在一个套接口接受一个连接,三次握手完成后, 服务器调用accept()接受连接,如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来,返回值: 成功返回非负值,失败返回-1。

参数:

sockfd:创建的套接字
addr:addr是一个传出参数,accept()返回时传出客户端的地址和端口号,如果给addr 参数传NULL,表示不关心客户端的地址
addrlen:是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区addr的长度以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)

 

功能: 客户端需要调用connect()连接服务器,返回值: connect()成功返回0,出错返回-1。

参数:

sockfd:创建的套接字,即socket函数返回的文件描述符,唯一标识一个socket
addr:sockaddr结构体
addrlen:struct sockaddr *是一个通用指针类型,addr参数实际上可以接受多种协议的sockaddr结构体,而它们的长度各不相同,所以需要第三个参数addrlen指定结构体的长度

功能:读取数据,返回值,读取来数据的长度

参数:

sockfd:创建的套接字,即socket函数返回的文件描述符,唯一标识一个socket

buf:一段缓冲区

len:缓冲区长度

flags:默认0,阻塞读取

src_addr:sockaddr结构体,输出型参数,因为我们要关注是谁发给我们的

addrlen:src_addr的大小

 功能:发送数据

参数:

sockfd:创建的套接字,即socket函数返回的文件描述符,唯一标识一个socket

buf:一段缓冲区

len:缓冲区长度

flags:默认0

src_addr:sockaddr结构体,存的是你要发给的人的信息

addrlen:src_addr的大小

 五.UDP协议实践

首先一个简单的网络通信程序分为服务端和客户端,接下来我们就分别看一下服务端和客户端是如何实现的。

日志文件

#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <string>

// 日志是有日志级别的
#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"
};

#define LOGFILE "./threadpool.log"

// 完整的日志功能,至少: 日志等级 时间 支持用户自定义(日志内容, 文件行,文件名)
void logMessage(int level, const char *format, ...)
{
#ifndef DEBUG_SHOW
    if(level== DEBUG) return;
#endif
    // va_list ap;
    // va_start(ap, format);
    // while()
    // int x = va_arg(ap, int);
    // va_end(ap); //ap=nullptr
    char stdBuffer[1024]; //标准部分
    time_t timestamp = time(nullptr);
    // struct tm *localtime = localtime(&timestamp);
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp);

    char logBuffer[1024]; //自定义部分
    va_list args;
    va_start(args, format);
    // vprintf(format, args);
    vsnprintf(logBuffer, sizeof logBuffer, format, args);
    va_end(args);

    // FILE *fp = fopen(LOGFILE, "a");
    printf("%s%s\n", stdBuffer, logBuffer);
    // fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
    // fclose(fp);
}

服务端udp_server.cc

#include "log.hpp"
#include <iostream>
#include <cstdio>
#include <string>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <memory>
#include <cstdlib>
using namespace std;


class UdpServer
{
public:
    UdpServer(uint16_t port,string ip=""):_port(port),_ip(ip),_sock(-1)
    {}
    bool initServer()
    {
        _sock= socket(AF_INET,SOCK_DGRAM,0);
        if(_sock<0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        struct sockaddr_in local;
        bzero(&local,sizeof(local));
        local.sin_family=AF_INET;
        local.sin_port=htons(_port);
        local.sin_addr.s_addr=_ip.empty()?INADDR_ANY:inet_addr(_ip.c_str());
        if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "init udp server done ... %s", strerror(errno));
        //done
        return true;
    }
    void Start()
    {
        char buffer[1024];
        for(;;)
        {
            //注意:
            // peer,纯输出型参数
            struct sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            // 输入: peer 缓冲区大小
            // 输出: 实际读到的peer
            socklen_t len = sizeof(peer);
            //start. 读取数据
            ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
            if(s > 0)
            {
                buffer[s] = 0; // 我们目前数据当做字符串
                //1. 输出发送的数据信息
                //2. 是谁??
                uint16_t cli_port = ntohs(peer.sin_port); //从网络中来的!
                std::string cli_ip = inet_ntoa(peer.sin_addr); //4字节的网络序列的IP->本主机的字符串风格的IP,方便显示
                printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);
            }
            //分析和处理数据,TODO
            //end. 写回数据
            sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
        }
    }
    ~UdpServer()
    {
        if(_sock >= 0) close(_sock);
    }
private:
    uint16_t _port;
    string _ip;
    int _sock;
};


static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}


int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    // std::string ip = argv[1];
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<UdpServer> svr(new UdpServer(port));
    svr->initServer();
    svr->Start();
    return 0;
}

接下来我就一步一步地讲解一下上面的代码:

首先说一下UdpServer这个类

类的三个成员:分别是_port端口号,_ipIP地址,_sock套接字

构造函数:UdpServer(uint16_t port,string ip=""),这里主要就是ip给缺省,因为服务器一般不绑定固定ip,这样我们可以从任意IP中获取数据

析构函数:这个就是关闭套接字

initServer()函数:这个函数的作用就是创建套接字并且绑定IP和port,创建套接字就是使用socket这个函数,绑定是使用bind这个函数(函数如何使用在上面都有介绍)

Start()函数:这个函数的作用就是读取数据和发送数据,因为服务器一般是不退出的,所以这里我们是写成死循环的,读取数据使用的是recvfrom,发送数据使用的是sendto

主函数:首先usage函数就是一个手册,告诉用户如何使用,然后就是创建一个UdpServer的类对象,然后调用initServer()函数和Start()函数即可

客户端udp_client.cc

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
              << std::endl;
}

uint16_t serverport = 0;
std::string serverip;
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }
    serverport = atoi(argv[2]);
    serverip = argv[1];
     std::string message;
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    char buffer[1024];
    while(true)
    {
        std::cout << "请输入你的信息# ";
        std::getline(std::cin, message);
        if(message == "quit") break;
        // 当client首次发送消息给服务器的时候,OS会自动给client bind他的IP和PORT
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof server);

        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr*)&temp, &len);
        if(s > 0)
        {
            buffer[s] = 0;
            std::cout << "server echo# " << buffer << std::endl;
        }
    }
    return 0;
}

 代码讲解:

主函数:第一步有一个usage()函数,就是使用手册,然后就是创建套接字,然后就是客户端一般也是不退出的,在一个死循环里发送消息给服务器,并且接收服务器发来的消息。

多线程版:

thread.hpp:

#include <iostream>
#include <string>
#include <functional>
#include <cstdio>

// typedef std::function<void* (void*)> fun_t;
typedef void *(*fun_t)(void *);

class ThreadData
{
public:
    void *args_;
    std::string name_;
};

class Thread
{
public:
    Thread(int num, fun_t callback, void *args) : func_(callback)
    {
        char nameBuffer[64];
        snprintf(nameBuffer, sizeof nameBuffer, "Thread-%d", num);
        name_ = nameBuffer;

        tdata_.args_ = args;
        tdata_.name_ = name_;
    }
    void start()
    {
        pthread_create(&tid_, nullptr, func_, (void*)&tdata_);
    }
    void join()
    {
        pthread_join(tid_, nullptr);
    }
    std::string name()
    {
        return name_;
    }
    ~Thread()
    {
    }

private:
    std::string name_;
    fun_t func_;
    ThreadData tdata_;
    pthread_t tid_;
};

客户端:

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include "thread.hpp"

// 发现:无论是多线程读还是写,用的sock都是一个,sock代表就是文件,UDP是全双工的-> 可以同时进行收发而不受干扰

uint16_t serverport = 0;
std::string serverip;

static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
              << std::endl;
}

static void *udpSend(void *args)
{
    int sock = *(int *)((ThreadData *)args)->args_;
    std::string name = ((ThreadData *)args)->name_;

    std::string message;
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    while (true)
    {
        std::cerr << "请输入你的信息# "; //标准错误 2打印
        std::getline(std::cin, message);
        if (message == "quit")
            break;
        // 当client首次发送消息给服务器的时候,OS会自动给client bind他的IP和PORT
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof server);
    }

    return nullptr;
}

static void *udpRecv(void *args)
{
    int sock = *(int *)((ThreadData *)args)->args_;
    std::string name = ((ThreadData *)args)->name_;

    char buffer[1024];
    while (true)
    {
        memset(buffer, 0, sizeof(buffer));
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout  << buffer << std::endl;
        }
    }
}

// ./udp_client 127.0.0.1 8080
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }
    serverport = atoi(argv[2]);
    serverip = argv[1];
    // client要不要bind??要,但是一般client不会显示的bind,程序员不会自己bind
    // client是一个客户端 -> 普通人下载安装启动使用的-> 如果程序员自己bind了->
    // client 一定bind了一个固定的ip和port,万一,其他的客户端提前占用了这个port呢??
    // client一般不需要显示的bind指定port,而是让OS自动随机选择(什么时候做的呢?)

    std::unique_ptr<Thread> sender(new Thread(1, udpSend, (void *)&sock));
    std::unique_ptr<Thread> recver(new Thread(2, udpRecv, (void *)&sock));
    // sender->name();
    sender->start();
    recver->start();

    sender->join();
    recver->join();

    close(sock);

    return 0;
}

六.tcp协议实践 

客户端:tcp_client.cc

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>

void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[1]);
        return 0;
    }
    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    int sock = 0;
    bool alive = false;
    std::string line;
    while (true)
    {
        if (!alive)
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if (sock < 0)
            {
            }
            struct sockaddr_in server;
            bzero(&server, sizeof server);
            server.sin_family = AF_INET;
            server.sin_port = htons(serverport);
            server.sin_addr.s_addr = inet_addr(serverip.c_str());
            // client 要不要bind呢?不需要显示的bind,但是一定是需要port
            // 需要让os自动进行port选择
            // 连接别人的能力!
            // conect连接
            if (connect(sock, (struct sockaddr *)&server, sizeof server))
            {
                // 连接失败
                exit(2);
            }
            // 连接到了
            alive = true;
        }
        std::cout << "请输入# ";
        std::getline(std::cin, line);
        if (line == "quit")
            break;
        // send recv和udp中的sendto recvfrom 是一样的
        ssize_t s = send(sock, line.c_str(), line.size(), 0);
        if (s > 0)
        {
            char buffer[1024];
            ssize_t s = recv(sock, buffer, sizeof buffer - 1, 0);
            if (s > 0)
            {
                buffer[s] = 0;
                std::cout << "server 回显#" << buffer << std::endl;
            }
            else if (s == 0)
            {
                alive = false;
                close(sock);
            }
        }
        else
        {
            alive = false;
            close(sock);
        }
    }
    return 0;
}

服务端:tcp_server.cc tcp_server.hpp

#include"tcp_server.hpp"

static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}

int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        usage(argv[1]);
        return 0;
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<TcpServer> svr(new TcpServer(port));
    svr->initServer();
    svr->start();
    return 0;
}
#pragma once

#include <iostream>
#include <string>
#include <unordered_map>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <signal.h>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <pthread.h>
#include <ctype.h>

// static void service(int sock, const std::string &clientip,
//                     const uint16_t &clientport, const std::string &thread_name)
static void service(int sock, const std::string &clientip,
                    const uint16_t &clientport)
{
    // echo server
    //  同时在线10人
    //  所以,我们一般服务器进程业务处理,如果是从连上,到断开,要一直保持这个链接, 长连接
    //  后面有其他方案!
    char buffer[1024];
    while (true)
    {
        // read && write 可以直接被使用!
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的数据当做字符串
            // std::cout << thread_name << "|" << clientip << ":" << clientport << "# " << buffer << std::endl;
            std::cout << clientip << ":" << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0) // 对端关闭连接
        {
            // logMessage(NORMAL, "%s:%d shutdown, me too!", clientip.c_str(), clientport);
            break;
        }
        else
        {
            // logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
            break;
        }

        write(sock, buffer, strlen(buffer));
    }
    close(sock);
}

class TcpServer
{
private:
    // listen函数第二个参数
    const static int gbacklog = 20;

public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port), _ip(ip), _listensock(-1)
    {
    }
    void initServer()
    {
        // 1.创建套接字
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            // 创建失败
        }
        // 2.bind绑定
        struct sockaddr_in local;
        bzero(&local, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        inet_pton(AF_INET, _ip.c_str(), &local.sin_addr);
        if (bind(_listensock, (struct sockaddr *)&local, sizeof local))
        {
            // bind失败
        }
        // 因为tcp是面向连接的,所以需要使用listen,先建立连接
        if (listen(_listensock, gbacklog) < 0)
        {
            // listen连接失败
        }
        return;
    }
    void start()
    {
        while (true)
        {
            // 4.获取连接
            struct sockaddr_in src;
            bzero(&src, sizeof src);
            socklen_t len = sizeof src;
            int servicesock = accept(_listensock, (struct sockaddr *)&src, &len);
            if (servicesock < 0)
            {
                // 没有获取到
                continue;
            }
            // 获取连接成功
            uint16_t client_port = ntohs(src.sin_port);
            std::string client_ip = inet_ntoa(src.sin_addr);
            // 执行任务
            //  开始进行通信服务啦
            //  version 1 -- 单进程循环版 -- 只能够进行一次处理一个客户端,处理完了一个,才能处理下一个
            //  很显然,是不能够直接被使用的! -- 为什么? 单进程
            service(servicesock, client_ip, client_port);
            // version 2.0 -- 多进程版 --- 创建子进程
            // 让子进程给新的连接提供服务,子进程能不能打开父进程曾经打开的文件fd呢?1 0
            // pid_t id = fork();
            // assert(id != -1);
            // if(id == 0)
            // {
            //     // 子进程, 子进程会不会继承父进程打开的文件与文件fd呢?1, 0
            //     // 子进程是来进行提供服务的,需不需要知道监听socket呢?
            //     close(_listensock);
            //     service(servicesock, client_ip, client_port);
            //     exit(0); // 僵尸状态
            // }
            // close(servicesock); // 如果父进程关闭servicesock,会不会影响子进程??下节课
            // 父进程
            // waitpid();
        }
        return;
    }
    ~TcpServer()
    {
        if (_listensock >= 0)
        {
            close(_listensock);
        }
    }

private:
    uint16_t _port;
    std::string _ip;
    int _listensock;
};

因为tcp和udp大致一样,所以就不过多解释了。

七.TCP协议通讯流程 

TCP协议通讯的前提是先将客户端和服务端连接起来,这里的连接是指什么呢?

客户端连接服务器的时候,本质上是连接了服务器的操作系统(协议栈)模块。服务端和客户端是1:n的关系,所以一定会有多个客户端去连接一个服务器OS。
此时服务器OS上会有大量的客户端连接。服务器OS需要将所有连接管理起来(先描述,再组织)。
所谓的连接本质就是在双方OS内,维护对应的数据结构,建立了连接,后序也要维护连接,所以,建立连接是有成本的,消耗了时间和空间。

断开连接的本质:释放双方建立好的数据结构

下图是基于TCP协议的客户端/服务器程序的一般流程:

服务器初始化:

  • 调用socket, 创建文件描述符;
  • 调用bind, 将当前的文件描述符和ip/port绑定在一起; 如果这个端口已经被其他进程占用了, 就会bind失败;
  • 调用listen, 声明当前这个文件描述符作为一个服务器的文件描述符, 为后面的accept做好准备;
  • 调用accecpt, 并阻塞, 等待客户端连接过来;

建立连接的过程:

  • 调用socket, 创建文件描述符;
  • 调用connect, 向服务器发起连接请求;
  • connect会发出SYN段并阻塞等待服务器应答; (第一次)
  • 服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立连接"; (第二次)
  • 客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段; (第三次) 
  • 这个建立连接的过程, 通常称为 三次握手;

数据传输的过程:

  • 建立连接后,TCP协议提供全双工的通信服务; 所谓全双工的意思是, 在同一条连接中, 同一时刻, 通信双方可以同时写数据; 相对的概念叫做半双工, 同一条连接在同一时刻, 只能由一方来写数据;
  • 服务器从accept()返回后立刻调 用read(), 读socket就像读管道一样, 如果没有数据到达就阻塞等待;
  • 这时客户端调用write()发送请求给服务器, 服务器收到后从read()返回,对客户端的请求进行处理, 在此期间客户端调用read()阻塞等待服务器的应答;
  • 服务器调用write()将处理结果发回给客户端, 再次调用read()阻塞等待下一条请求;
  • 客户端收到后从read()返回, 发送下一条请求,如此循环下去;

断开连接的过程:

  • 如果客户端没有更多的请求了, 就调用close()关闭连接, 客户端会向服务器发送FIN段(第一次);
  • 此时服务器收到FIN后, 会回应一个ACK, 同时read会返回0 (第二次);
  • read返回之后, 服务器就知道客户端关闭了连接, 也调用close关闭连接, 这个时候服务器会向客户端发送一个FIN; (第三次)
  • 客户端收到FIN, 再返回一个ACK给服务器; (第四次)
  • 这个断开连接的过程, 通常称为 四次挥手

在学习socket API时要注意应用程序和TCP协议层是如何交互的:

  • 应用程序调用某个socket函数时TCP协议层完成什么动作,比如调用connect()会发出SYN段
  • 应用程序如何知道TCP协议层的状态变化,比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段,再比如read()返回0就表明收到了FIN段

TCP 和 UDP 对比:

  • 可靠传输 vs 不可靠传输
  • 有连接 vs 无连接
  • 字节流 vs 数据报 
Linux C 网络编程(socket 套接字) Linux C 网络编程功能套接字 功能 前面我们学习了系统编程,通过管道等我们可以将一个系统中的资源和信息调用起来,但这是远远不够的,我们还可以通过网络编程和其他的的系统来交互信息。 为了相互通信,国际制定了TCP/IP协议,通过IP地址和端口好进行通信。 套接字 ... 阅读详情

相关推荐

Linux网络编程 | 基本套接字(Socket)编程

网络中进程如何通信、Socket简介、socket套接字、套接字描述符、Socket基础API、创建socket、命名socket、监听socket、接受连接、发起连接、关闭连接、TCP数据读写、UDP数据读写、主机字节序和网络字节序、客户端 / 服务器模式及编程流程

ZY-JIMMY 2481

linux套接字

套接字(Socket)是一种用于在计算机之间进行通信的软件组件或接口。它提供了一种标准化的方式,使得应用程序能够通过网络连接进行相互之间的通信。在计算机网络中,每台计算机都有一个唯一的IP地址,用于标识这台计算机。当应用程序需要在网络上进行通信时,它们可以使用套接字来建立连接并进行数据交换。套接字可以使用不同的传输协议,例如TCP和UDP,以实现不同的通信需求。套接字有两种类型:客户端套接字和服务器套接字。客户端套接字通常用于向服务器请求服务,而服务器套接字则用于接受客户端的请求并提供服务。

封茗世香 2209

第8章 Stata主成分分析与因子分析

在进行数据统计分析时,还往往会遇见变量特别多的情况,而且很多时候这些变量之间还存在着很强的相关关系或者说变量之间存在着很强的信息重叠,如果我们直接对数据进行分析,一方面会带来工作量的无畏的加大,另一方面还会出现一些模型应用的错误,于是主成分分析与因子分析应运而生。这两种分析方法的基本思想都是在不损失大量信息的前提下,利用较少的独立变量来替代原来的变量进行进一步的分析。 8.1主成分分析 基本思想是将众多的初始变量整合成少数几个互相无关的主成分变量,而这些新变量尽可能地包含...

qq_45112156的博客 5万+

【Linux】详解套接字编程

套接字编程,TCP/UDP服务器

qq_53893431的博客 2444

CH582低功耗实战:从1.2mA降到5uA,我的蓝牙广播功耗优化笔记

本文详细记录了沁恒CH582蓝牙芯片从1.2mA降至5μA的功耗优化全过程。通过建立基准测试环境、分层排查软件配置与IO状态、精细调优射频参数以及硬件层面的电源管理,实现了极致的低功耗表现。文章还提供了实用的功耗测量方法和典型问题排查指南,为蓝牙设备开发者提供了宝贵的参考经验。

weixin_30368405的博客 575

银河麒麟v10装Docker实战:在线离线安装与容器部署指南

容器技术作为现代软件交付的核心方式,通过将应用与依赖打包成镜像,实现了环境的一致性与快速部署。Docker作为最流行的容器引擎,其安装与配置是上云和国产化转型中的基础技能。在国产操作系统银河麒麟v10环境中,由于系统兼容性和网络环境的差异,Docker的部署需要特别注意在线与离线两种模式的选择。本文从基础概念出发,结合麒麟v10的实际环境,详细梳理了Docker引擎的安装、镜像加速、存储配置以及MySQL、Redis等常用容器的部署方法,并针对SELinux、cgroup驱动等常见问题给出了解决方案,帮助开

weixin_30431445的博客 150

Linux网络编程——套接字socket

网络编程???套接字??拿来吧你!!!

wzh18907434168的博客 1885

深度强化学习在足式机器人中的应用 (一):基础原理与仿真环境

我们将首先深入探讨其背后的核心挑战与技术栈,然后详细推导机器人学和强化学习的基本数学原理,特别是剖析在机器人控制领域表现卓越的PPO算法。下面的独立Python脚本展示了Isaac Gym的基本API用法,加载一个Go1机器人(假设URDF已准备好),并让它执行一个简单的预设动作(正弦波运动),以此来熟悉仿真流程。:代码的核心是直接操作GPU上的PyTorch张量,避免了CPU和GPU之间的数据拷贝,这是实现高性能的关键。:所有计算(如伪策略中的正弦波计算)都应该是向量化的,一次性为所有。

VectorShift的博客 228

Linux套接字编程详解

前16位是标志,是数据结构的名字。通用数据类型sockaddr,sockaddr_in和sockaddr_un是sockaddr是他们的统一形式,为了方便传参。

qq_45849625的博客 991

DLMS/COSEM协议的理解体会

DLMS是通信协议,COSEM是电表建模规范。HDLC帧基本格式为0x7e......

一个bug是bug,多个bug能work 8318

汽车UDS诊断详解及Vector相关工具链使用说明——总述

1.什么是诊断 车辆在运行过程中,不可避免地会发生一些故障,为了确保行车安全,我们要求车上的ECU能够实时监测部件的运行状态,一旦发现异常情况,能通过点亮报警灯等方式提示驾驶员。但是,点亮报警灯只能告诉驾驶员车辆发生了故障,最多只能定位到故障ECU,比如ABS报警灯亮说明ABS系统出现故障,但具体是什么部件发生故障并不能通过报警灯显示出来。这时就需要ECU在本地存储一个与故障相对应的故障代码,在进行维修的时候,可以通过车上的OBD接口连接诊断仪,把这个存储的故障代码读取出来,从而进一步定位到更加具体的故障部

weixin_42967006的博客 2万+

Linux套接字编程

本片博客首先大致讲述的UDP和TCP的内容和区别,然后讲述了UDP协议的操作流程和操作接口,以及字节序在网络通信中进行转换时的相关接口,最后编写代码进行了统一实践。

m0_56821563的博客 1101

【OpenClaw从入门到精通】第20篇:OpenClaw实战—从零搭建教育自动化助教系统(作业批改+智能答疑+学情分析)【2026实测】

本文基于OpenClaw开源框架,聚焦教育行业“答疑重复、批改耗时、学情模糊”三大核心痛点,提供从环境部署到功能落地的全流程实操方案。通过整合QQ群交互、代码分析、数据可视化等技能,构建“智能答疑+作业批改+学情分析”的自动化助教系统。系统支持7×24小时群聊答疑、多语言作业自动评审、学情数据周报生成,经实测可使助教工作时间减少60%、作业批改效率提升5-10倍、学情问题识别提前5周。文中包含完整配置步骤、可直接运行的代码示例及避坑指南,兼顾新手入门与进阶实操,帮助教育工作者快速落地自动化工具,从重复劳动中

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1455

[Linux网络编程]Socket套接字

socket 的原意是“插座”,在计算机通信领域,socket 被翻译为“套接字”,它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定,一台计算机可以接收其他计算机的数据,也可以向其他计算机发送数据。本文归纳整理Socket的使用

weixin_44972997的博客 3674

Python爬虫实战:基于异步爬虫与机器学习的数据采集——以电商平台在线评论有用性分析为例

内容涵盖爬虫原理、反爬虫策略应对、数据清洗、数据存储以及简单的数据分析预览,并为后续利用机器学习模型(如逻辑回归、随机森林)分析评论有用性打下坚实的数据基础。特别是在电子商务领域,在线评论作为UGC的一种主要形式,深刻影响着消费者的购买决策和商家的信誉体系。然而,平台上的评论质量参差不齐,充斥着大量无意义的灌水、广告甚至虚假评论。因此,如何自动识别和筛选出“有用”的评论,成为了学术界和工业界共同关注的焦点。我们选择目前Python爬虫领域最前沿、效率最高的技术组合,以确保爬虫的稳定性、速度和可扩展性。

2201_76125261的博客 109

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Linux网络编程 套接字

Linux网络编程 套接字    一:概述    Socket 的英文原意就是“孔”或“插座”,现在,作为BSD UNIX 的进程通讯机制,取其后一种意义。日常生活中常见的插座,有的是信号插座,有的是电源插座,有的可以接受信号(或能量),有的可以发送信号(或能量)。假如电话线与电话机之间安放一个插座(相当于二者之间的接口,这一部分装置物理上是存在的)则Socket 非常相似于电话插座。

mazidao2008的专栏 3648

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Linux网络编程之套接字选项设置

1.介绍 在Linux网络编程中,有时需要设置地址复用,允许发送广播包,将主机加入某个多播组,设置发送与接收缓冲区的大小,设置发送与接收的超时时间,将套接字绑定到某个接口上,发送TCP探测包查看客户端是否保持连接等,这些都需要对套接字选项进行设置.而对套接字选项进行操作的主要有以下两个函数,setsockopt与getsockopt. 这两个函数不仅能够操作套接字层,而且能够操作IP层与TCP层

3688

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

【Linux】Linux下使用套接字进行网络编程

🔥❤️在自定义的头文件中重新声明一个函数,函数名与接口函数不同,返回值、参数均与接口函数相同。在相应的源文件中定义我们的函数,将逻辑判断的过程放在函数中。这样在调用函数时就省去大量的if else判断int# endifint# endifintprotocol);

代码兴国 1669

Linux UDP网络编程套接字sockets

在学校我们用学号,相比于身份证更简便,假如我的学号是2211211023,这样就能看到我是22级的,方便阅读信息。但是,这两个结构体都不用,我们用 sockaddr。网络通信的本质是进程间通信,有了 IP 就可以标识公网内唯一的一台主机,想要完成网络通信我们还需要一个东西来标识一台主机上的某个进程,这个标识就是端口号(port)。三种应用场景:网络套接字主要运用于跨主机之间的通信,也能支持本地通信,而域间套接字只能在本地通信,而原始套接字可以跨过传输层(TCP/IP 协议)访问底层的数据。

puppy_1mo的博客 1126

【Linux | 网络】网络编程套接字

本篇文章先讲解 IP 地址、端口号、网络套接字等基础概念,讲解端口号与进程 ID在网络中的作用,介绍 TCP、UDP 协议及网络字节序。再详述 socket 编程接口,包括 socket、bind 等常见 API,主机与网络字节序转换函数,IP 地址形式转换函数,数据收发函数及 sockaddr 结构。

是阿建吖! 2334

linux网络编程socket套接字

因此,服务器从accept()返回后立刻调用read(),读socket就像读管道一样,如果没有数据到达就阻塞等待,这时客户端调用write()发送请求给服务器,服务器收到后从read()返回,对客户端的请求进行处理,在此期间客户端调用read()阻塞等待服务器的应答,服务器调用write()将处理结果发回给客户端,再次调用read()阻塞等待下一条请求,客户端收到后从read()返回,发送下一条请求,如此循环下去。同样地,接收主机如果是小端字节序的,接到16位的源端口号也要做字节序的转换。

qq_44729609的博客 1276

Linux网络编程:套接字

上篇文章主要介绍的是网络通信方面的一些知识,也算是为以后的学习先做一下铺垫。从本章开始我们就要正式进入网络编程的学习了。在开始网络编程之前,我们还需要进行一些准备工作,需要先了解一些概念。

2301_79927432的博客 1103

【linux网络编程】套接字socket

的端点,是应用程序访问网络的接口,用于在不同计算机或同一计算机的进程之间通信。:在应用程序和网络协议之间建立连接,允许数据收发。,它允许不同计算机或同一计算机上的进程通过。

m0_49106549的博客 1054

【Linux网络编程】网络编程套接字(UDP服务器)

初步接触UDP网络应用编程

m0_74215144的博客 1261

Linux——网络编程套接字

1.UDP协议 UDP:用户数据报协议,不可靠的传输通信协议,应用于实时性要求大于安全性的场景——视频/音频数据传输 特点:无连接,不可靠,面向数据报 简单的UDP网络程序实现以及接口 网络通信程序的编写都使用的是套接字接口——socket接口 客户端:主动发起请求的一方,用户的一端 服务端:被动接受请求的一方,向用户提供服务的一端 在通信时,客户端的主要工作为: (1)创建套接字,使进程与网卡之间建立联系 (2)为套接字绑定地址信息,每条数据中都有源端地址和对端地址,绑定的地址信息就是源

m0_46657980的博客 372
上一篇: Linux网络基础
下一篇: Linux网络基础二
pythoncjavac++
博客等级 码龄5年 718粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pythoncjavac++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值