网络编程 -------- 3、TCP_UDP_UNIX

最新推荐文章于 2024-11-15 13:54:59 发布
最新推荐文章于 2024-11-15 13:54:59 发布
阅读量924 收藏 18
点赞数 16
文章标签： 网络 tcp/ip udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzskkd/article/details/140855864
版权

1、基于TCP的套接字编程流程 

    Server.c 
        socket 
        bind  （服务器的ip+端口）
        listen
        accept
        recv / send
        close

    Client.c 
        socket 
        connect （服务器的ip+端口）
        send / recv
        close

扩展：

        (1) 三路握手： TCP建立连接时
                1）SYN请求 (客户端-->服务器) 
                2）SYN+ACK应答 (服务器-->客户端) 
                3）ACK确认 (客户端-->服务器)


        (2) 四次挥手： TCP断开连接时 
                1）FIN请求 (客户端-->服务器)
                2）ACK应答 (服务器-->客户端)
                3）FIN请求 (服务器-->客户端)
                4）ACK应答 (客户端-->服务器)

2、基于UDP的套接字编程流程 

    Server.c 
        socket  
        bind  （服务器的ip+端口）
        recvfrom / sendto
        close

    Client.c 
        socket 
        //设置服务器的ip和端口
        sendto / recvfrom
        close


            利用UDP 实现简单的通信   UDP ---> SOCK_DGRAM 数据报套接字类型
                udp_server.c   接收数据 

                    int main( int argc, char *argv[] )
                    {
                        //1.创建套接字 UDP ---> SOCK_DGRAM 数据报套接字
                        int server_fd = socket( AF_INET, SOCK_DGRAM, 0 );
                        if( server_fd == -1 )
                        {
                            perror("socket server error ");
                            return -1;
                        }
                        printf("server_fd = %d\n", server_fd );

                        //2.绑定服务器的ip和端口
                        struct sockaddr_in  server_addr;
                        server_addr.sin_family = AF_INET;           //协议族 
                        server_addr.sin_port = htons( atoi(argv[2]) );    //端口号
                        inet_aton( argv[1], &server_addr.sin_addr );  //IP地址

                        int re = bind( server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr) );
                        if( re == -1 )
                        {
                            perror("bind server error ");
                            return -1;
                        }
                        printf("bind server success\n");

                        //3.通信 
                        while( 1 )
                        {
                            //接收数据 
                            char buf[128] = {0};
                            struct sockaddr_in  client_addr;
                            socklen_t len = sizeof(client_addr);

                            re = recvfrom( server_fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &len );
                            if( re >= 0 )
                            {
                                printf("%s : %s\n", inet_ntoa(client_addr.sin_addr), buf );
                            }
                            else 
                            {
                                perror("recvfrom server error ");
                                break;
                            }

                            //人为定义退出条件
                            if( buf[0] == '#' )
                            {
                                break;
                            }
                        }

                        //4.关闭套接字
                        close( server_fd );
                    }

                udp_client.c   发送数据  

                    int main( int argc, char *argv[] )
                    {
                        //1.创建套接字 UDP ---> SOCK_DGRAM 数据报套接字
                        int client_fd = socket( AF_INET, SOCK_DGRAM, 0 );
                        if( client_fd == -1 )
                        {
                            perror("socket client error ");
                            return -1;
                        }
                        printf("client_fd = %d\n", client_fd );

                        //2.设置服务器的ip和端口
                        struct sockaddr_in  server_addr;
                        server_addr.sin_family = AF_INET;           //协议族 
                        server_addr.sin_port = htons( atoi(argv[2]) );    //端口号
                        inet_aton( argv[1], &server_addr.sin_addr );  //IP地址

                        //3.通信 
                        while(1)
                        {
                            //发送数据 
                            char buf[128] = {0};
                            printf("input data : ");
                            fgets(buf, sizeof(buf), stdin);

                            int re = sendto( client_fd, buf, strlen(buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr) );
                            if( re == -1 )
                            {
                                perror("sendto error ");
                                break;
                            }

                            //人为定义退出条件
                            if( buf[0] == '#' )
                            {
                                break;
                            }
                        }

                        //4.关闭套接字
                        close( client_fd );
                    }

            

3、UNIX域协议

        UNIX域协议是利用socket编程接口 来实现 本地进程之间(客户端/服务器)的通信，它是进程间通信(IPC)的一种方式。它使用文件系统中的路径名来标识服务器和客户端。

        UNIX域协议的套接字： 
            SOCK_STREAM     --->  TCP 面向字节流 
            SOCK_DGRAM      --->  UDP 面向数据报  

        其编程接口 和 流程 与 ipv4协议族是一样的
        只不过 协议族为 AF_UNIX , 对应的地址结构体为 

            UNIX域协议地址结构体 ( man 7 unix )
                    #include <sys/un.h>

                struct sockaddr_un 
                {
                    sa_family_t  sun_family;        /* 协议族 AF_UNIX */
                    char         sun_path[108];     /* UNIX域协议的地址，在本地文件系统中的“绝对路径名” pathname */
                };

            #define UNIX_PATH  "/home/china/unix2418F"

        实现方法：  UDP / TCP 
       

练习： 
            利用UNIX域协议 实现简单的通信 (以UDP为例)

                unix_server.c   接收数据 

                    int main( int argc, char *argv[] )
                    {
                        //删除 
                        unlink( UNIX_PATH );

                        //1.创建套接字 AF_UNIX  
                        int server_fd = socket( AF_UNIX, SOCK_DGRAM, 0 );
                        if( server_fd == -1 )
                        {
                            perror("socket server error ");
                            return -1;
                        }

                        //2.绑定 服务器的地址 
                        struct sockaddr_un  server_addr;
                        server_addr.sun_family = AF_UNIX;           //协议族 
                        strcpy( server_addr.sun_path, UNIX_PATH );  //unix域协议的地址

                        int re = bind( server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr) );
                        if( re == -1 )
                        {
                            perror("bind server error ");
                            close( server_fd );
                            return -1;
                        }
                        printf("bind server success\n");

                        struct sockaddr_un  client_addr;
                        socklen_t len = sizeof(client_addr);

                        //3.通信 
                        while(1)
                        {
                            //接收数据 
                            char buf[128] = {0};
                            re = recvfrom( server_fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &len );
                            if( re >= 0 )
                            {
                                printf("recv : %s\n", buf );
                            }
                            else 
                            {
                                perror("recvfrom server error ");
                                break;
                            }
                            
                            if( buf[0] == '#' )
                            {
                                break;
                            }
                        }

                        //4.关闭套接字
                        close( server_fd );
                    }


                unix_client.c   发送数据  

                    //1.创建套接字 
                    //2.设置服务器的地址 
                    //3.通信 
                    //4.关闭套接字


4、套接字选项  

    套接字选项是用来设置或获取套接字的一些特性的选项。

        每个套接字在不同的层次上(级别) 有不同的行为属性(选项) 

        有两个接口函数用来 获取和设置 套接字的选项： 

            getsockopt 
            setsockopt  

                NAME
                    getsockopt, setsockopt - get and set options on sockets
                SYNOPSIS
                    #include <sys/types.h>          /* See NOTES */
                    #include <sys/socket.h>

                    int getsockopt(int sockfd, int level, int optname,
                                    void *optval, socklen_t *optlen);
                    int setsockopt(int sockfd, int level, int optname,
                                    const void *optval, socklen_t optlen); 
                        功能：获取/设置套接字的选项 
                        参数： 
                            sockfd：指定要操作的套接字描述符 
                            level：级别，不同的选择在不同的级别上(查看资料)
                            optname：选项名 
                            optval: 通用指针 
                                        get 用来保存获取到的选项值 
                                        set 用来保存要设置的选项值 
                                             不同的选项 对应的类型是不一样的 
                                                如果为 int  ---> 0  禁用选项 
                                                            --> 非0 使能选项 
                            optlen： 
                                    get 指针，指向空间保存选项值的空间的长度 
                                    set 变量，用来指定要设置的选项值的长度 
                        返回值： 
                            成功，返回0
                            失败，返回-1，同时errno被设置                     


            设置 端口号重用 

                 选项名： SO_REUSEPORT 
                 级别：  SOL_SOCKET
                 值的类型： int 

                 /设置端口号重用 
                 int n = 1;
                 setsockopt( server_sock, SOL_SOCKET, SO_REUSEPORT, &n, sizeof(n) );

5、UDP的例子 （拓展）

    1）DNS ： Domain Name System 域名系统  

            www.baidu.com  ----> 域名  

            DNS：是把一个域名 转换成 相应的ip地址的服务  

            DNS协议 传输层用到UDP协议 
                    DNS Server  
                        ip： 114.114.114.114 
                        端口  53

  
    2）NTP ： Network Time Protocol 网络时间协议

  
            基于UDP的传输层协议 

                服务器： 
                    阿里云 :  182.92.12.11
                    端口： 123      

        利用TCP 写一个网络传输文件的程序  
            file_tcp_server.c   服务器 接收文件  
            file_tcp_client.c   客户端 发送文件  

                注意： 
                    通信双方 发送和接收的 数据、大小、顺序 要保持一致 
                    遵守通信双向的约定 ---> "协议"

                file_tcp_server.c   服务器 接收文件  

                    int recv_file( int sock_fd )
                    {
                        //切换路径 
                        chdir("../");

                        //接收文件名的长度大小 
                        int name_len = 0;
                        int re = recv( sock_fd, &name_len, sizeof(name_len), 0 );
                        if( re == -1 )
                        {
                            perror("recv name_len error "); 
                            return -1;
                        }
                        printf("recv name_len success , len = %d\n", name_len );

                        //接收文件名
                        char filename[128] = {0};
                        re = recv( sock_fd, filename, name_len, 0 );
                        if( re == -1 )
                        {
                            perror("recv filename error ");
                            return -1;
                        }
                        printf("recv filename success , filename = %s\n", filename );
                        

                        //接收文件的大小 
                        int file_size = 0;
                        re = recv( sock_fd, &file_size, sizeof(file_size), 0 );
                        if( re == -1 )
                        {
                            perror("recv file_size error ");
                            return -1;
                        }
                        printf("recv file_size success , file_size = %d\n", file_size );

                        /* 接收文件的内容
                            创建并打开文件
                            接收数据
                            写入文件
                            关闭文件
                        */
                        //创建并打开文件
                        int fd = open( filename, O_RDWR | O_CREAT | O_EXCL, 0666 );
                        if( fd == -1 )
                        {
                            if( errno == EEXIST )  //文件已经存在,就直接打开即可
                            {
                                fd = open( filename, O_RDWR | O_TRUNC );
                            }
                            else 
                            {
                                perror("open file error ");
                                return -1;
                            }
                        }

                        int write_size = 0;      //已经写入的字节数
                        while( write_size < file_size )
                        {
                            //先接收数据 
                            char buf[128] = {0};
                            re = recv( sock_fd, buf, 100, 0 );
                            if( re > 0 )
                            {
                                //写入文件 
                                write( fd, buf, re );
                                write_size += re;
                            }
                            else 
                            {
                                perror("recv file error ");
                                break;
                            }
                        }

                        if( write_size == file_size )
                        {
                            printf("recv file success\n");
                        }
                        else 
                        {
                            printf("recv file failed \n");
                        }
                        
                        //关闭文件 
                        close( fd );
                    }

                    int main( int argc, char *argv[] )
                    {
                        //1.创建套接字 
                        int server_fd = socket( AF_INET, SOCK_STREAM, 0 );
                        if( server_fd == -1 )
                        {
                            perror("socket server error ");
                            return -1;
                        }
                        printf("server_fd = %d\n", server_fd );

                        //2.绑定 服务器的ip和端口
                        struct sockaddr_in  server_addr;
                        server_addr.sin_family = AF_INET;                   //协议族 
                        server_addr.sin_port = htons( atoi(argv[2]) );    //端口号
                        inet_aton( argv[1], &server_addr.sin_addr );     //IP地址

                        //设置端口号重用
                        int n = 1;
                        setsockopt( server_fd, SOL_SOCKET, SO_REUSEPORT, &n, sizeof(n) );

                        int re = bind( server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr) );
                        if( re == -1 )
                        {
                            perror("bind server error ");
                            close( server_fd );
                            return -1;
                        }
                        printf("bind server success\n");

                        //3.监听 
                        re = listen( server_fd, 5 );
                        if( re == -1 )
                        {
                            perror("listen server error ");
                            close( server_fd ); 
                            return -1;
                        }
                        printf("listen server success\n");

                        //4.接受连接 
                        struct sockaddr_in  client_addr;
                        socklen_t len = sizeof(client_addr);

                        int client_fd = accept( server_fd, (struct sockaddr *)&client_addr, &len );
                        if( client_fd == -1 )
                        {
                            perror("accept error ");
                            close( server_fd );
                            return -1;
                        }
                        printf("client_fd = %d\n", client_fd );
                        printf("client_ip = %s\n", inet_ntoa(client_addr.sin_addr) );


                        //5.通信 -->接收文件 
                        recv_file( client_fd );


                        //6.关闭套接字 
                        close( server_fd );
                    }

                file_tcp_client.c   客户端 发送文件  

                    int send_file( int sock_fd, char * filename )
                    {
                        //发送文件名的长度大小 
                        int name_len = strlen(filename);
                        int re = send( sock_fd, &name_len, sizeof(name_len), 0 );
                        if( re == -1 )
                        {
                            perror("send name_len error ");
                            return -1;
                        }
                        printf("send name_len success , len = %d\n", name_len );

                        //发送文件名 
                        re = send( sock_fd, filename, name_len, 0 );
                        if( re == -1 )
                        {
                            perror("send filename error ");
                            return -1;
                        }
                        printf("send filename success , filename = %s\n", filename );

                        //发送文件的大小
                        struct stat  st;
                        stat( filename, &st );  //获取文件属性-->文件大小 
                        int file_size = st.st_size;

                        re = send( sock_fd, &file_size, sizeof(file_size), 0 );
                        if( re == -1 )
                        {
                            perror("send file_size error ");
                            return -1;
                        }
                        printf("send file_size success , file_size = %d\n", file_size );

                        /* 发送文件的内容 
                            打开文件
                            读取
                            发送 
                            关闭文件 
                        */
                        //打开文件
                        int fd = open( filename, O_RDONLY );
                        if( fd == -1 )
                        {
                            perror("open file error ");
                            return -1;
                        }

                        int read_size = 0;      //已经读取到的字节数
                        while( read_size < file_size )
                        {
                            //先读取文件内容 
                            char buf[128] = {0};
                            re = read( fd, buf, 100 );
                            if( re > 0 )
                            {
                                //发送数据 
                                send( sock_fd, buf, re, 0 );
                                read_size += re;
                            }
                            else 
                            {
                                perror("read file error ");
                                break;
                            }
                        }

                        if( read_size == file_size )
                        {
                            printf("send file success\n");
                        }
                        else 
                        {
                            printf("send file failed \n");
                        }

                        //关闭文件 
                        close( fd );

                    }


                    int main( int argc, char *argv[] )
                    {
                        //1.创建套接字 
                        int client_fd = socket( AF_INET, SOCK_STREAM, 0 );
                        if( client_fd == -1 )
                        {
                            perror("socket client error "); 
                            return -1;
                        }
                        printf("client_fd = %d\n", client_fd );

                        //2.设置服务器的ip和端口
                        struct sockaddr_in  server_addr;
                        server_addr.sin_family = AF_INET;                   //协议族 
                        server_addr.sin_port = htons( atoi(argv[2]) );    //端口号
                        inet_aton( argv[1], &server_addr.sin_addr );     //IP地址

                        //3.连接服务器 
                        int re = connect( client_fd, (struct sockaddr *)&server_addr, sizeof(server_addr) );
                        if( re == -1 )
                        {
                            perror("connect error ");
                            close( client_fd );
                            return -1;
                        }
                        printf("connect success\n");


                        //4.通信 --> 发送文件 
                        send_file( client_fd, argv[3] );
                        

                        //5.关闭套接字
                        close( client_fd );
                    }

zzzskkd
关注
网络编程-TCP/IP
weixin_67273669的博客
07-10 1317
TCP：流式套接字，面向连接的，可靠的通信 UDP：数据报套接字，无连接的，不可靠的通信 TCP（即传输控制协议）：是一种面向连接的传输层协议，它能提供高可靠性通信(即数据无误、数据无丢失、数据无失序、数据无重复到达的通信)。 UDP（User Datagram Protocol）用户数据报协议，是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。
Linux网络编程---UDP服务器
qq_51647149的博客
04-29 2543
UDP通信与TCP通信的对比及实现、网络/本地套接字通信的对比
Unix网络编程-使用select执行TCP和UDP业务
NINE_world的博客
05-07 447
/** * @file server-select-TCP-UDP.c * 使用select同时处理TCP和UDP */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/select.h> #include <arpa/inet.h&
Socket编程---UDP篇
小白成长之路
08-30 1838
UDP代码实现。一篇即懂！
Linux基础-socket详解、TCP/UDP
weixin_37553721的博客
04-29 4433
所谓socket通常也称作 “套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过 “套接字” 向网络发出请求或者应答网络请求。Socket 是计算机网络编程中一个重要的概念，它是在应用层和传输层之间提供的一种抽象接口，用于实现应用程序之间的数据交换。Socket 允许程序员使用一种通用的接口来访问底层传输协议，如 TCP 和 UDP，以便进行网络通信。Socket 是一种编程接口，它提供了一种标准化的方式来创建网络连接，并允许应用程序在网络上发送和接收数据。
UDP_Demo.rar_UDP_socket-udp通讯_socket编程_udp 通讯_udp通讯
09-20
在Unix/Linux系统中，socket分为流式（SOCK_STREAM，对应TCP）和数据报式（SOCK_DGRAM，对应UDP）两种类型。 2. **UDP套接字创建**：在C/C++中，使用`socket()`函数创建一个UDP套接字，指定协议族（AF_INET）和套接...
tcp_udp.rar_LINUX TCP _Linux/Unix编程_TCP UDP Linux_tcp udp 互联网
09-20
在Linux系统环境下，TCP（传输控制协议）和UDP（用户数据报协议）是两种主要的网络通信协议，它们在互联网编程中扮演着至关重要的角色。本文将深入探讨这两种协议的基本概念、工作原理以及如何在Linux上进行编程实现...
cli-ser.zip_网络编程_Unix_Linux_
08-11
在IT行业中，网络编程是构建分布式系统和互联网应用程序的基础，特别是在Unix和Linux操作系统环境下。`cli-ser.zip`这个压缩包包含的资源显然与网络编程有关，特别是涉及到客户端（Client）和服务器（Server）之间的...
winsock-api.rar_网络编程_Windows_Unix_
08-11
尽管Winsock是Windows特有的，但它的设计灵感来源于Unix的Berkeley Sockets，因此很多Unix/Linux下的网络编程经验可以直接应用于Winsock。这使得开发跨平台的网络应用成为可能。 **五、Winsock的错误处理** ...
套接字socket编程文档.rar_MultiGet-1.1.4_linux_linux socket_linux 编程_soc
09-23
在IT行业中，套接字（Socket）编程是网络通信的核心技术之一，特别是在Unix/Linux系统中。本文档将深入探讨Linux下的Socket编程，包括基础概念、API接口、多线程及多进程的并发处理，以及MultiGet-1.1.4项目在Linux...
C网络编程-基本理论(共17张PPT).pptx
11-14
**Winsock2**是Windows操作系统中的网络编程接口，它允许开发者访问各种网络协议，其设计灵感来源于Unix平台的Berkeley套接字。Winsock2在Win32环境下提供了“与协议无关”的接口，使得开发者能够编写跨平台的网络...
TCP-server-and-TCP-client-.zip_TCP client_TCP server c++_c tcp_
09-24
在IT行业中，网络编程是构建分布式系统和互联网应用程序的基础，而TCP（传输控制协议）作为其核心组件之一，扮演着至关重要的角色。本资源“TCP-server-and-TCP-client-.zip”提供了一组C++和C语言编写的TCP客户端与...
AnaTraf | 巧用网络流量分析技术，守护网络 “健康”
Johnstons的博客
11-13 274
这时候，借助流量分析工具查看流量情况，若是发现某条链路的流量出现了异常的高峰，远超正常的带宽承载能力，那很可能就是这条链路出现了拥塞问题，或许是有设备在疯狂发送大量无用的数据，导致网络 “交通堵塞”。比如，长期观察发现某个区域的网络节点总是出现流量高峰，而当前的网络带宽配置又不足以应对这样的高峰，那我们就可以针对性地进行带宽升级，或者调整网络拓扑结构，进行流量的合理分流，让数据能够更加顺畅地在网络中 “流淌”。网络流量分析技术，简单来说，就是对网络中流动的数据进行监测、收集、解析以及统计的技术手段。
字节序（Byte Order）
weixin_50993868的博客
11-11 264
字节序与平台字节序转换字节序（Byte Order）是指数据在内存中存储时字节的排列顺序。由于不同的计算机体系结构可能采用不同的字节序，因此理解字节序非常重要，特别是在处理多平台数据传输或存储时。
UNIX 域套接字
weixin_50993868的博客
11-12 410
UNIX 域套接字（UNIX Domain Socket，简称 UDS）是一种在同一台机器上的进程间通信（IPC，Inter-Process Communication）机制，允许不同的进程通过文件系统中的特殊文件进行数据交换，而不需要通过网络协议栈。这使得 UNIX 域套接字在本地通信中比传统的 TCP/IP 套接字更高效。流式数据：和 TCP 套接字类似，UNIX 域套接字也支持面向流的通信（SOCK_STREAM），以及无连接的报文通信（SOCK_DGRAM）。// 套接字文件的路径。
【网络安全 | 漏洞挖掘】隐藏的 DOS 技术
等风来
11-11 525
我调查了这些参数的用途，发现它们被传递给了第三方服务，且该服务的文档说明这些参数是安全的。你可以试试这样做：前往https://ash-speed.hetzner.com/并找到一个测试文件（大小大约1到10 GB），如果服务器等待URL请求完成，你可以通过大量此类请求来淹没服务器，从而导致它最终崩溃。于是我发送了一个包含1000个UUID的列表，结果网站在60秒后超时，并出现了显著的延迟。在我的案例中，这导致了客户网站的DOS攻击，问题被发现并快速修复，甚至在我报告漏洞之前。
WIFI 基础知识总结
m0_57053438的博客
11-14 220
所谓的互通性就是，不同芯片厂商，产品商的WIFI产品可以基于IEEE802.11标准之下无障碍，流畅的进行通信交互，为了达到这个目的，WIFI联盟提出市面上流通的WIFI产品需要去他们指定的认证实验室进行认证测试。WLAN 技术的出现是为了弥补有线网络的不足，已达到网络延伸的目的，实现无网线，无距离限制的通信网络，目前常用的WLAN实现技术有蓝牙 ，zigbee ， wifi 等；STA（station）：无线工作站，任何wireless设备都可以叫STA，比如正在使用无线网络的平板，手机，电脑等；
渗透测试之信息收集 DNS主机发现探测方式&&NetBIOS 协议发现主机&& 以及相关PorCheck scanline工具的使用哟
最新发布
zhzx123aa的专栏
11-15 559
在实际应用中，NetBIOS协议对各种IDS（人侵检测系统）、IPS（入侵防御系统）、杀毒软件的规避效果比其他协议更好，因为利用NetBIOS是正常的机器名解析查询应答的过程，推荐优先使用。【2】gobusterdns是爆破二级域名工具gobuster的精简版，该工具只用于子域名爆破，支持自定义DNS服务器运行，在进行单端口扫描时，可以对需要扫描的IP段进行随机扫描，避免顺序扫描触发规则，引起告警。，建议每次在尽量小的范围（如一个C段）内单线程扫描单端口，并且在扫描。在控制的人口点权限不足的情况下，
蓝队基础5 -- 安全策略与防护技术
CrossProblems的博客
11-14 509
该手册详细规定了在不同安全事件发生时应执行的标准操作程序，涵盖了扫描、托管威胁、入侵、可用性、信息、欺诈、恶意内容、恶意软件检测、技术诚信和盗窃等多个安全事件类别。每个类别下都包含了具体的应急处理流程和操作规范。编写应急响应报告：详细记录事件的经过、处理过程和结果，以及后续的调查计划和改进建议。经验总结与改进建议：对事件处理过程中的经验和教训进行总结，并提出针对性的改进建议。Snort作为一种知名的开源入侵检测与防御系统，能够对网络流量进行实时监控和分析。
C语言入门到精通（第六版）——第十六章
qq_63485530的博客
11-14 683
3、本地网络上的其他主机接收到ARP请求帧后，检查是否与自己的IP地址匹配，如果不匹配，则丢弃APR请求帧，如果主机B发现与自己的IP地址匹配，则将主机A的物理地址和IP地址添加到自己的ARP缓存中，然后主机B将自己的物理地址和IP地址发送给主机A，当主机A接收到主机B发来的信息后，将用这些信息更新ARP缓存。在发送数据时，应用层的数据传输到传输层，加上TCP的首部，数据就构成了报文。简单来说，套接字就是一个假想的连接装置，其作用类似于插座，插座用于连接电器和电线，套接字用于连接程序和网络，完成通信功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值