网络编程笔记

最新推荐文章于 2024-11-01 11:27:45 发布
最新推荐文章于 2024-11-01 11:27:45 发布
阅读量1.3k 收藏 35
点赞数 11
文章标签： 网络 笔记 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjlo1/article/details/140428964
版权

网络编程

1. 概念

1.1 局域网

局域网：局域网将一定区域的各种计算机、外部设备和数据连接起来形成计算机通信的私有网络

广域网：又称广域网、外网、公网。是连接不同地区局域网或城域网计算机通信的远程公共网络

1.2 IP

本质是一个整形数，用于表示计算机在网络中的地址。IP协议版本有两个：IPV4和IPV6

  • IPV4

    1. 使用一个32位的整形数表示一个IP地址，4个字节，int型

    2. 也可以使用点分十进制字符串描述这个IP地址：192.168.10.27

    3. 分成四份，每份1字节，8bit（char），最大值255

      1. 0.0.0.0是最小的ip地址
      2. 255.255.255.255是最大的IP地址

​ 4. 按照IPV4协议计算，可以使用的IP地址有2的32次方个

  • IPV6

    1. 使用一个128位的整形数描述一个IP地址，16个字节

    2. 也可以使用一个字符串描述这个IP地址：2001:0db8:3c4d:0015:0000:0000:1a2b

    3. 分成了8份，每份2字节，每一部分以16进制的方式表示

    4. 按照协议IPV6计算，可以使用的IP地址有2的128次方个

      在这里插入图片描述

    在这里插入图片描述

1.3 端口

作用：定位到主机上的某一个进程，通过这个端口进程就可以接受对应的网络数据

端口也是一个整形数unsigned short，一个16位整型数，有效端口取值范围：0~65535

注意：一个进程不需要网络通信的话就不需要绑定端口，如果需要网络通信那么就需要绑定，一个端口对应一个进程，多个进程不能同时使用一个端口

1.4 OSI/ISO 模型

OSI，即开放式系统互联，一般都叫OSI参考模型。是ISO（国际标准化组织）在1985年研究的网络互联模型

在这里插入图片描述

2. 网络协议

TCP UDP IP 以太网

3. socket 编程

socket 对于程序员来说是一套网络通信接口，使用这套接口可以完成网络通信，网络通信主要分为两部分：客户端和服务器端。

需要了解三个概念：IP、端口、通信数据

3.1 字节序

概念：大于一个字节类型的数据在内存中的存放顺序，也就是说对于单字符来说是没有字节序问题，字符串是单字符的集合，因此字符串也没有字节序问题。

计算机通常采用的字节存储机制主要有两种：Big-endian大端存储和little-endian小端存储

  • 小端->主机字节序

    数据的低位字节存储到内存的低地址位，数据的高位字节存储到内存的高地址位

    PC机默认使用小端存储

  • 大端->网络字节序

    数据的低位字节存储到内存的高地址位，数据的高位字节存储到内存的低地址位

    套接字通过过程中操作的数据都是大端存储，包括：接收/发送数据、IP地址、端口

    4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit

​ 0x12 34 56 78

​ 小端：78 56 34 12

​ 大端：12 34 56 78

3.2 大小端转换函数

#include <arpa/inet.h>
/*
u:unsigned
16：16位
h:host,主机字节序
n:net，网络字节序
s:short
l:int
*/
uint16_t htons(uint16_t hostshort);
uint32_t htonl(uint32_t hostlong);

uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netlong);

3.3 IP地址转换

  • 字符串类型的IP地址转换为大端整型数

    int inet_pton(int af , const char *src, void *dst );
/*
af:地址族协议
AF_INET4:ipv4格式的ip地址
AF_INET6:ipv6格式的ip地址

src:传入参数，对应要转换的点分十进制的ip地址：192.168.10.27
dst:传出参数，函数调用完成，转换得到的大端整形IP被写入到这块内存中

返回值:成功1，失败0或-1
*/

  • 大端整型数转换为小端的点分十进制的IP地址

    #include <arpa/inet.h>

const char *inet_ntop(int af,const void *src,char *dst,socklen_t size);
/*
src:传入参数，指向大端整形数的地址
dst:传出参数，指向小端点分十进制的IP地址字符串
size:dst的内存大小
返回值：成功返回a non-null pointer to dst
	   失败返回NULL  with errno set to indicate the error
*/

  • 只能用于IPV4大小端转换的函数(一般不用)

    //IP->大端整形
in_addr_t inet_addr(const char *cp);

// 大端整形 -> 点分十进制ip
char *inet_ntoa(struct in_addr in);

4. TCP 通信流程

TCP报文长度

在这里插入图片描述

TCP是一个面向连接的，安全的，流式传输协议，这个协议是传输层协议

  • 面向连接：是一个双线连接，通过三次握手完成，断开连接需要通过四次挥手
  • 安全：tcp通信过程中，会对发送的每一数据包都会进行校验，如果发现数据丢失会自动重传
  • 流式传输：发送端和接收端处理数据的速度，数据的量都可以不一致

在这里插入图片描述

4.1 服务器端通信流程
int lfd = socket(int domain, int type, int protocol); //创建用于监听的socket，lfd是一个文件描述符
bind();             //将得到的监听的文件描述符和本地的IP端口进行绑定
listen();           //设置监听(成功之后开始监听，监听的是客户端的连接)
int cfd = accept(); //等待并接受客户端的连接请求，建立新的连接，会得到一个新的文件描述符(通信的)
read(); /recv();//通信读写默认都是阻塞的
write();/send();
close();//断开连接，关闭套接字  **调用一次挥手两次**
4.2 客户端通信流程

在单线程的情况下客户端通信的文件描述符有一个，没有监听的文件描述符

int cfd = socket();//创建一个通信的套接字
connect(); //连接服务器，需要知道服务器绑定的IP和端口
// 接收数据
read();/recv();
//发送数据
write();/send();

close(); //断开连接，关闭文件描述符(套接字)
4.3 socket函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
/*
domain 用于指定一个通信域；这将选择将用于通信的协议族。
TCP/IP协议来说，AF_INET\AF_INET6\AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE

type 指定套接字的类型

protocol 通常设置为 0，表示为给定的通信域和套接字类型选择默认协议。
当对同一域和套接字类型支持多个协议时，可以使用 protocol 参数选择一个
特定协议。在 AF_INET 通信域中，套接字类型为SOCK_STREAM 的默认协议是
传输控制协议（Transmission Control Protocol，TCP 协议）。
在 AF_INET 通信域中，套接字类型为 SOCK_DGRAM 的默认协议时 UDP。
*/

在这里插入图片描述

*注意*：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

4.4 bind函数
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//bind()函数用于将一个 IP 地址或端口号与一个套接字进行绑定（将套接字与地址进行关联）。

struct sockaddr{
    sa_family_t sa_family;
    char sa_data[14];
};
/*sa_data 是一个 char 类型数组，一共 14 个字节，在这 14 个字节中就包括了 IP 地址、端口
号等信息*/
typedef uint32_t in_addr_t;
struct in_addr{
    in_addr_t s_addr;
};
struct sockaddr_in {
 	sa_family_t sin_family; /* 协议族 AF_INET*/
 	in_port_t sin_port; /* 端口号   大端*/  
 	struct in_addr sin_addr; /* IP 地址    大端*/
 	unsigned char sin_zero[8];
};
/*
sin_port,sin_addr,会组成sa_data,然后传递给bind
*/

//`````````````````````````使用示例```````````````````````````````````````````

int socket_fd = socket(AF_INET, SOCK_STREAM, 0);//打开套接字
if (0 > socket_fd) {
 perror("socket error");
 exit(-1);
}

struct sockaddr_in socket_addr;
memset(&socket_addr, 0x0, sizeof(socket_addr)); //清零
//填充变量
socket_addr.sin_family = AF_INET;
socket_addr.sin_addr.s_addr = htonl(INADDR_ANY);
socket_addr.sin_port = htons(5555);
bind(socket_fd, (struct sockaddr *)&socket_addr, sizeof(socket_addr));

·····
    
close(socket_fd);
4.5 listen函数
int listen(int sockfd, int backlog);
//可以看作有一个任务队列，只能最多排128个请求
//参数 backlog 用来描述 sockfd 的等待连接队列能够达到的最大值。
4.6 accept函数

为了能够正常让客户端能正常连接到服务器，服务器必须遵循以下处理流程：

①、调用 socket()函数打开套接字；

②、调用 bind()函数将套接字与一个端口号以及 IP 地址进行绑定；

③、调用 listen()函数让服务器进程进入监听状态，监听客户端的连接请求；

④、调用 accept()函数处理到来的连接请求。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//没有连接请求时会阻塞
/*
当有客户端连接请求到达时，accept()函数与远程客户端之间建立连接，accept()函数返回一个新的套接字。这个套接字与 socket()函数返回的套接字并不同，socket()函数返回的是服务器的套接字（以服务器为例），而accept()函数返回的套接字连接到调用 connect()的客户端，服务器通过该套接字与客户端进行数据交互，譬如向客户端发送数据、或从客户端接收数据。
*/

/*
参数 addr 是一个传出参数，参数 addr 用来返回已连接的客户端的 IP 地址与端口号等这些信息。参数addrlen 应设置为 addr 所指向的对象的字节长度，如果我们对客户端的 IP 地址与端口号这些信息不感兴趣，可以把 arrd 和 addrlen 均置为空指针 NULL。
*/

关键理解新的套接字描述符，代表了服务器与客户端建立的一个连接

4.7 客户端连接服务器connect函数
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/*
参数 addr 指定了待连接的服务器的 IP 地址以及端口号等信息
参数 addrlen 指定了 addr 指向的 struct sockaddr对象的字节大小
成功返回0，失败返回-1，并设置errno
*/

客户端通过 connect()函数请求与服务器建立连接，对于 TCP 连接来说，调用该函数将发生 TCP 连接的握手过程，并最终建立一个 TCP 连接，而对于 UDP 协议来说，调用这个函数只是在 sockfd 中记录服务器IP 地址与端口号，而不发送任何数据.

4.8 客户端与服务器通信函数

通过套接字描述符来收发数据了（对于客户端使用socket()返回的套接字描述符，而对于服务器来说，需要使用 accept()返回的套接字描述符）

ssize_t read(int sockfd,void *buf,size_t size);
/*
read()函数从一个文件描述符中读取指定字节大小的数据并放入到指定的缓冲区中，read()调用成功将返回读取到的字节数，此返回值受文件剩余字节数限制，当返回值小于指定的字节数时并不意味着错误；这可能是因为当前可读取的字节数小于指定的字节数（比如已经接近文件结尾，或者正在从管道或者终端读取数据，或者 read()函数被信号中断等），出错返回-1 并设置 errno，如果在调 read 之前已到达文件末尾，则这次 read 返回 0。
*/
ssize_t recv(int sockfd,void *buf,size_t size,int flags);
/*
参数：
sockfd:用于通信的文件描述符，accept函数的返回值
buf：指向一块有效内存，用于存储接收数据
size：参数buf指向的内存的容量
flags：特殊的属性，一般不使用，0，控制如何接收数据

返回值：
大于0：实际接收的字节数
等于0：对方断开连接
-1：接收数据失败
*/

flags属性：

在这里插入图片描述

ssize_t write(int fd,const void *buf,size_t len);

ssize_t send(int fd,const void *buf,size_t len,int flags);
/*
参数
fd： 通信的文件描述符，服务器就是accpet的返回值，客户端就是socket的返回值
buf：传入参数，要发送的字符串
len：要发送的字符串长度
flags：属性

返回值：
大于0：实际发送的字节数，和参数len是相等的
-1：发送数据失败
*/

在这里插入图片描述

4.9 文件描述符在socket通信中的作用

在这里插入图片描述

服务器的文件描述符的作用：

  1. 监听新的客户端连接

  2. 接受已建立连接的客户端数据

[!CAUTION]

在服务器端用于监听的文件描述符只有一个，用于通信的文件描述符有n个，建立几个连接就有几个；客户端也是只有一类

服务端示例程序：

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

int main(){
    char ip_s[16] = "192.168.23.139";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);

    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
  
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    //监听
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }
    
    //处理连接请求
    struct sockaddr_in accept_addr;
    memset(&accept_addr, 0, sizeof(accept_addr));
    int addrlen = sizeof(accept_addr);
    int cfd = accept(fd, (struct sockaddr *)&accept_addr, &addrlen);
    if(ret == -1){
        perror("accept error\n");
        close(fd);
        exit(-1);
    }

    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&accept_addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(accept_addr.sin_port));

    while(1)
    {

        char buf[1024];
        //读数据，没有数据就阻塞等待
        int len = recv(cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client say: %s\n",buf);
            send(cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }
    close(fd);
    close(cfd);

    exit(0);
}

客户端示例程序：

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

int main(int argc, char **argv){
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    
    //连接请求
    struct sockaddr_in client_addr;
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(8080);
    //client_addr.sin_addr.s_addr = INADDR_ANY;
    inet_pton(AF_INET,"192.168.23.139",&client_addr.sin_addr.s_addr);
    int ret = connect(fd, (struct sockaddr*)&client_addr, sizeof(client_addr));
    if(ret == -1){
        perror("connect error\n");
        exit(-1);
    }

    char ip[32];
    printf("与服务器建立连接服务器IP地址:%s,\
           端口:%d\n",inet_ntop(AF_INET,&client_addr.sin_addr.s_addr,ip,sizeof(ip)),
           ntohs(client_addr.sin_port));

    int number = 0;
    while(1)
    {
        char buff[1024];
        sprintf(buff,"你好，hello world %d...\n",number++);
        send(fd, buff ,strlen(buff)+1,0);
     
        memset(buff,0,sizeof(buff));
        int len = recv(fd, buff, sizeof(buff),0);
        if(len  > 0){
            printf("sever say: %s\n",buff);
        }else if(len == 0){
            perror("sever end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
        sleep(1);
     
    }
    close(fd);
    exit(0);
}

在这里插入图片描述

在这里插入图片描述

5. 基于多线程实现服务器并发分析

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

struct addrInfo{
    struct sockaddr_in addr;
    int cfd;
    int number;
};

struct addrInfo addrInFos[50];
static void *working(void *arg){

    struct addrInfo *addrINFO = (struct addrInfo *)arg;
    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&addrINFO->addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(addrINFO->addr.sin_port));

    while(1)
    {

        char buf[1024];
        int len = recv(addrINFO->cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client %d say: %s\n",addrINFO->number,buf);
            send(addrINFO->cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }

    close(addrINFO->cfd);
    addrINFO->cfd = -1;
    return (void *)0;

}
int main(){
    char ip_s[16] = "192.168.23.139";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    int count = 0;
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }

    int max = sizeof(addrInFos) / sizeof(addrInFos[0]);
    for(int i = 0; i < max; i++){
        memset(&addrInFos[i],0,sizeof(addrInFos[i]));
        addrInFos[i].cfd = -1; 
        addrInFos[i].number = 0;  
    }

    socklen_t addrlen = sizeof(struct sockaddr_in);
    while(1){
        struct addrInfo *pinInfo;
        for(int i=0;i<max;i++){
            if(addrInFos[i].cfd == -1){
                pinInfo = &addrInFos[i];
                break;
            }
        }
   
        int cfd = accept(fd, (struct sockaddr *)&pinInfo->addr, &addrlen);
        pinInfo->cfd = cfd;
        count++;
        pinInfo->number =count;
        if(ret == -1){
            perror("accept error\n");
            break;
        }

        pthread_t tid;
        pthread_create(&tid, NULL, working, pinInfo);
        pthread_detach(tid);
    }
    
    close(fd);
    exit(0);
}

6. TCP连接三次握手四次挥手

为什么不是二次而是三次？

  • 为了实现可靠数据传输， TCP 协议的通信双方， 都必须维护一个序列号， 以标识发送出去的数据包中， 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值， 并确认对方已经收到了序列号起始值的必经步骤

  • 如果只是两次握手， 至多只有连接发起方的起始序列号能被确认， 另一方选择的序列号则得不到确认

在这里插入图片描述

⚫ 第一次握手

客户端将 TCP 报文标志位 SYN(同步序列编号) 置为 1，随机产生一个序号值 seq=J，保存在 TCP 首部的序列号(Sequence Number)字段里，指明客户端打算连接的服务器的端口，并将该数据包发送给服务器端，发送完毕后，客户端进入 SYN_SENT 状态，等待服务器端确认。

⚫ 第二次握手

服务器端收到数据包后由标志位 SYN=1 知道客户端请求建立连接，服务器端将 TCP 报文标志位 SYN和 ACK 都置为 1，ack=J+1，随机产生一个序号值 seq=K，并将该数据包发送给客户端以确认连接请求，服务器端进入 SYN_RCVD 状态。

⚫ 第三次握手

客户端收到确认后，检查 ack 是否为 J+1，ACK 是否为 1，如果正确则将标志位 ACK 置为 1，ack=K+1，并将该数据包发送给服务器端，服务器端检查 ack 是否为 K+1，ACK 是否为 1，如果正确则连接建立成功，客户端和服务器端进入 ESTABLISHED 状态，完成三次握手，随后客户端与服务器端之间可以开始传输数据了。

在这里插入图片描述

TCP连接是全双工的，因此每个方向都必须单独进行关闭。

⚫ 第一次挥手

Client 端发起挥手请求，向 Server 端发出一个 FIN 报文段主动进行关闭连接，此时报文段的 FIN 标志位被设置为 1。此时，Client 端进入 FIN_WAIT_1 状态，这表示 Client 端没有数据要发送给 Server 端了。

⚫ 第二次挥手

Server 端收到了 Client 端发送的 FIN 报文段，向 Client 端返回一个 ACK 报文段，此时报文段的 ACK标志位被设置为 1。ack 设为 seq 加 1，Client 端进入 FIN_WAIT_2 状态，Server 端告诉 Client 端，我确认并同意你的关闭请求。

⚫ 第三次挥手

Server 端向 Client 端发送一个 FIN 报文段请求关闭连接，此时报文段的 FIN 标志位被设置为 1，同时sever端进入 LAST_ACK 状态。

⚫ 第四次挥手

Client 端收到 Server 端发送的 FIN 报文段后，向 Server 端发送 ACK 报文段（此时报文段的 ACK 标志位被设置为 1），然后 Client 端进入 TIME_WAIT 状态。Server 端收到 Client 端的 ACK 报文段以后，就关闭连接。此时，Client 端等待 2MSL 的时间后依然没有收到回复，则证明 Server 端已正常关闭，那好，Client端也可以关闭连接了。这就是关闭 TCP 连接的四次挥手

7. 线程池

7.1 线程池概念

为了避免频繁创建线程进而频繁申请内存，给操作系统带来更大的压力，影响性能，所以一次申请好一定数量的线程，然后将线程的管理操作交给线程池，避免短时间内不断创建与销毁。

7.2 优势

  1. 节省创建线程时间，有任务就立刻执行
  2. 防止系统过载问题
  3. 线程池资源占用少

7.3 应用

  1. web服务器
  2. 对性能苛刻的应用，要求服务器迅速响应
  3. 突发性的大量请求

7.4 组成

线程池的组成主要分为3个部分，这三部分配合工作就可以得到一个完整的线程池：

  • 任务队列，存储需要处理的任务，由工作的线程来处理这些任务

    通过线程池提供的API函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除

    已处理的任务会被从任务队列中删除

    线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程

  • 工作的线程（任务队列任务的消费者） ，N个

    线程池中维护了一定数量的工作线程, 他们的作用是是不停的读任务队列, 从里边取出任务并处理

    工作的线程相当于是任务队列的消费者角色，

    如果任务队列为空, 工作的线程将会被阻塞 (使用条件变量/信号量阻塞)

    如果阻塞之后有了新的任务, 由生产者将阻塞解除, 工作线程开始工作

  • 管理者线程（不处理任务队列中的任务），1个

    它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测

    当任务过多的时候, 可以适当的创建一些新的工作线程

    当任务过少的时候, 可以适当的销毁一些工作的线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include "threadpool.h"

struct addrInfo{
    struct sockaddr_in addr;
    int cfd;
    int number;
};

typedef  struct poolInfo{
    ThreadPool *p;
    int fd;
}poolInfo;


void acceptConn(void *arg){
    int count = 0;
    poolInfo *info = (poolInfo*)arg;
    socklen_t addrlen = sizeof(struct sockaddr_in);
    while(1){
        struct addrInfo *pinInfo;
        pinInfo = (struct addrInfo*)malloc(sizeof(struct addrInfo));

        pinInfo->cfd = accept(info->fd, (struct sockaddr *)&pinInfo->addr, &addrlen);
        count++;
        pinInfo->number =count;
        if(pinInfo->cfd == -1){
            perror("accept error\n");
            break;
        }
        threadPoolAdd(info->p, working, pinInfo);
    }
    
    close(info->fd);

}
   
static void working(void *arg){

    struct addrInfo *addrINFO = (struct addrInfo *)arg;
    char ip[32];
    printf("建立新连接客户端IP地址:%s,端口:%d\n",inet_ntop(AF_INET,&addrINFO->addr.sin_addr.s_addr,ip,sizeof(ip)),ntohs(addrINFO->addr.sin_port));

    while(1)
    {

        char buf[1024];
        int len = recv(addrINFO->cfd, buf, sizeof(buf),0);
        if(len  > 0){
            printf("client %d say: %s\n",addrINFO->number,buf);
            send(addrINFO->cfd, buf, sizeof(buf),0);
        }else if(len == 0){
            perror("client end\n");
            break;
        }else{
            perror("recv error\n");
            break;
        }
    }

    close(addrINFO->cfd);
    addrINFO->cfd = -1;
}
int main(){
    char ip_s[16] = "192.168.23.140";
    //创建监听的套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1){
        perror("socket error\n");
        exit(-1);
    }
    //绑定端口
    struct sockaddr_in sever_addr;
    memset(&sever_addr, 0x0, sizeof(sever_addr));
    sever_addr.sin_family = AF_INET;
    sever_addr.sin_port = htons(8080);
    inet_pton(AF_INET,ip_s,&sever_addr.sin_addr.s_addr);
    //sever_addr.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(fd, (struct sockaddr*)&sever_addr,sizeof(sever_addr));
    if(ret == -1){
        perror("bind error\n");
        close(fd);
        exit(-1);
    }
    printf("sever ip:%s,port:%d\n",ip_s,8080);
    
    //监听
    ret = listen(fd, 128);
    if(ret == -1){
        perror("listen error\n");
        close(fd);
        exit(-1);
    }
	//创建线程池
    ThreadPool *pool = threadPoolCreate(3, 8, 100);
    poolInfo *info = (poolInfo*)malloc(sizeof(poolInfo));
    info->fd = fd;
    info->p = pool;
    //添加任务
    threadPoolAdd(pool, acceptConn, info);

    pthread_exit(NULL);

    return 0;
}
春树穆云
关注
Linux网络编程笔记
weixin_48591705的博客
07-06 537
笔记
C++ Socket网络编程笔记
dream_to_dream的博客
09-06 491
C++网络编程学习笔记
网络安全-自学笔记
热门推荐
关注网络安全、云原生安全
12-01 18万+
目录 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 通信安全 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 网络安全-sqlmap学习笔记 通信安全 网络-http协议学习笔记（消息结构、请求方法、状态码等） ...
Java网络编程笔记5
顾林海
01-17 1208
在Java网络编程笔记4中我们看到了客户端与服务器通信的过程，只是在前面的程序只是单个客户端与服务器通信 的例子。 接下来我们看如何实现多个客户端与服务器通信，对于服务器来说，它要为每个客户端请求的Socket建立一个线程,并通过它进行通信。 在这里创建一个线程类用来管理Socket: public class ServerThread extends Thread { private
linux网络编程笔记--inet-ntoa() 函数的返回值问题以及网络地址有效性的判断
jeason的博客
11-27 4560
今天学习了唐佐林老师的网络课程，记录一下发现的收获。 1. inet_ntoa char *inet_ntoa(struct in_addr in); // 这个函数返回的指针是一块固定的空间, 使用的时候需要注意防止覆盖 demo : #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <stdi
Java网络编程笔记4
顾林海
01-12 1582
Socket和ServerSocket，网络编程可以分为创建Socket、打开连接Socket的输入流和输出流，对Socket进行编程，关闭Socket。 创建Socket 一个功能齐全的Socket的工作过程包含以下四个步骤： 1、创建Socket。 2、打开连接到Socket的输入/输出流。 3、按照一定的协议对Socket进行读/写操作。 4、关闭Socket
Linux网络编程复习笔记
小谢的博客
12-01 5855
理论知识点 TCP协议的三次握手的触发API connect : 第一次握手信息 第二次，第三次都是被动处理，无需调用接口 accept不参与三次握手，取出三次握手成功的描述符 socket描述符的合理大小 属于linux系统描述符fd的一部分: fd∈[0,1,2……]fd\in[0,1,2……]fd∈[0,1,2……] 总之fd>=0fd>=0fd>=0 把socket状态从主动发送状态转变为被动监听状态 listen + TCP的描述符 send(sockfd, buf, 5
网络编程基础笔记
m0_57855994的博客
04-12 2752
网络编程基础笔记 持续学习更新中
B站【狂神说Java笔记】-网络编程(1)
2401_84103344的博客
05-16 878
虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。本文已被。
linux系统编程及网络编程笔记
04-12
总的来说，"Linux系统编程及网络编程笔记"会详细解析上述各个方面，包括理论知识、实际示例和最佳实践，旨在帮助学习者深入理解Linux环境下的系统编程和网络编程，为开发高效、安全的系统级应用程序和网络服务打下...
linux系统编程和网络编程笔记
07-23
linux系统编程和网络编程笔记
一部分网络编程笔记总结
08-09
这些笔记主要涵盖了Java网络编程的基础概念、核心技术以及一些实践应用。下面将详细展开讲解相关知识点。 1. **网络基础知识**：网络编程首先需要理解TCP/IP协议族，包括IP地址、端口号、传输层（TCP/UDP）以及应用...
为什么TCP（TIME_WAIT）2倍MSL
最新发布
weixin_44102162的博客
11-01 293
MSL（最大报文段生存时间）是TCP协议中定义的一个常量，表示TCP报文在网络中存活的最长时间。等待2倍MSL的原因是为了给报文提供足够的时间消失或确认。第一个MSL：等待网络中的FIN和ACK报文到达对方，确保双方完成连接关闭。第二个MSL：等待可能在网络中滞留的所有旧报文完全失效，避免与未来的新连接混淆。TIME_WAIT状态在TCP协议中扮演了确保数据完整性和网络可靠性的角色，通过2倍MSL时间的等待机制，防止ACK丢失以及旧报文干扰新连接。
如何使用SOCKS5代理提升匿名性
dailiip1的博客
10-30 774
SOCKS5代理作为一种高效的网络匿名技术，能够为使用者提供多样化的应用场景和显著的隐私保护优势。透过正确配置和合理使用SOCKS5代理，使用者可以有效提升线上安全性，规避潜在的网络监控和攻击风险，享受更安全和自由的网络体验。未来随着网络安全需求的不断增长，SOCKS5代理技术的应用和发展将更加广泛和深入，为用户创造更安全可靠的网络环境。
tcp shutdown, fin_wait1, fin_wait2, close_wait, last_ack, 谢特！
Netfilter
10-31 855
状态很奇怪，人们很难接受一个连接在非 ESTABLISHED 状态下正常传输数据，这会引来一堆咨询，但根据 TCP 状态机，这又是合理的，client 单向关闭了发送，FIN 就过去了，server 回复了 FIN，进入 CLOSE_WAIT，client 收到回复进入 FIN_WAIT_2，而 server 在 CLOSE_WAIT 下发数据，client 在 FIN_WAIT_2 下是完全合理的。但如果应用程序希望如此呢？TCP 的 RFC793 并未规定状态超时时间，为完整闭环这是合理的。
第三章 I O 输入输出简介 - Use 命令
yaoxin521123的博客
10-28 284
此命令使指定设备成为当前设备，并将特殊变量$IO设置为该设备。要使用主设备以外的设备，必须首先对其发出OPEN命令；否则，将收到错误。参数的含义与OPEN命令中的相同。
嵌入式系统中的网络链接如何实现远程监控和控制
teach2004的博客
10-31 199
随着物联网（IoT）的快速发展，嵌入式系统在各类设备中的应用日益普及。通过网络连接，嵌入式系统能够实现远程监控和控制，为用户带来极大的便利和灵活性。嵌入式系统通过网络链接实现远程监控和控制，极大地提升了设备的智能化和便利性。随着技术的不断进步，未来的嵌入式系统将在各个领域发挥更大的作用。· 数据采集：嵌入式系统定期收集传感器数据，并通过网络将数据发送到服务器。· 工业自动化：工厂通过远程监控设备的状态，实现生产过程的优化和故障预警。· 数据存储：服务器将接收到的数据存储在数据库中，方便后续分析和处理。
linux网络编程笔记
06-28
Linux网络编程是指在Linux操作系统上进行网络编程的技术，主要包括socket编程、网络协议、网络编程模型等内容。在Linux网络编程中，常用的编程语言有C、C++、Python等。Linux网络编程的应用非常广泛，可以用于开发...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值