linux-socket编程（四）

最新推荐文章于 2024-05-30 22:51:04 发布
最新推荐文章于 2024-05-30 22:51:04 发布
阅读量508 收藏 1
点赞数 1
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ab1605014317/article/details/105950671
版权

1：流协议与粘包

TCP：基于字节流的传输服务，无边界（包与包之间没有边界），所以容易产生粘包，但是不会丢包。

粘包的含义：由于TCP在传输数据的时候是无边界的，所以数据对tcp来说就是一堆没有结构区别字节块，因此就会导致如下图所示的情况。这就是粘包。

2：粘包产生的原因

1.SQ_SNDBUF套接字本身有缓冲区（发送缓冲区，接收缓冲区）
2.tcp传送的网络数据最大值MSS大小限制
3.链路层也有MTU（最大传输单元）大小限制，如果数据包大于>MTU要在IP层进行分片，导致消息分割。（可以简单的认为MTU是MSS加包头数据）
4.tcp的流量控制和拥塞控制，也可能导致粘包
5.tacp延迟发送机制等等
结论：TCP/IP协议，在传输层没有处理粘包问题，必须由程序员处理

3：粘包处理方案

1：定包长
2：包尾加\r\n(ftp就是用了这种方式，如果包的内容就含有这些字符，那么需要使用转义字符来处理)
3：包头加上包体长度
4：其他一些比较复杂的应用层协议

对于定包长（一般编程设定可以取46~1500字节之间，低于46发送时会为你填充至46字节，超过1500传输过程中会有以太网为你分片），这个方式最大的缺陷就是它不能发挥tcp协议的高效性，而且及大地浪费网络流量，很多无效数据在网络上传输，不推荐使用。

包尾部加上\r,\n等字符，ftp(文件传输协议)就是使用的这个策略。但是这种方式限制了只能做某种特殊的服务，因为我们必须保证结束符的唯一性，在数据传输中，用户输入的是不受限制的，各种方式都有。

包头加上包体长度：是最多使用的方式，保证了tcp传输的高效性，而且不浪费网络资源，并且可以很好的解决粘包问题。工作方式就是：就是封装一个发送和接收函数，对于接收函数：首先判断数据长度，然后再接受数据，这样就可以知道实际数据的长度，不需要浪费网络资源。

4：readn writen

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;   // 剩余字节数
    ssize_t nread;   //已经读取字节数
    char *bufp = (char*) buf;

    while (nleft > 0)
    {
        nread = read(fd, bufp, nleft);  //获取读取的字节数
        if (nread < 0)
        {
            if (errno == EINTR)   //信号被打断，接下来会在后面给出参数具体功能
            {
                continue;
            }
            return  -1;
        } else if (nread == 0)   //读取到的数据为空
        {
            return count - nleft;   //返回实际读取的字节数
        }

        bufp += nread;    //移动到读取数据之后，方便再次读取数据
        nleft -= nread;   //剩余字节数的大小
    }
    return count;    //返回实际读取到字节数
}
//
ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;    //剩余需要写入的字节数
    ssize_t nwritten;        //已经写入的字节数
    char* bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return -1;
        }
        else if (nwritten == 0)
        {
            continue;
        }
        bufp += nwritten;
        nleft -= nwritten;
    }
    return count;
}

有关write和read函数的解释

write()

头文件：#include<unistd.h>

ssize_t write(int fd,const void*buf,size_t count);
参数说明：
  fd:是文件描述符（write所对应的是写，即就是1）
  buf:通常是一个字符串，需要写入的字符串
  count：是每次写入的字节数

返回值
1、返回值>0
a、等于给定字节数
b、小于给定字节数，有如下几种可能：
底层物理介质上没有足够的空间
创建的文件指定了RLIMIT_FSIZE，也就是指定了文件允许的最大字节数，不能再往其中添加数据
已经写了部分数据，但是被中断信号打断，返回中断打断前写入的字节数
2、返回值=0
如果相应的errno被设定，说明有相应失败情况。如果errno没有被设定，没有任何影响（可能是write 指定写入0字节等）。这和read返回0不一样，read返回0意味着对端close。其实这些都是为了保持与read/write文件保持一致，因为在读写文件的时候read总会读到文件结束EOF，返回0；但是只要没有磁盘等的限制，write可以一直写下去。

3、返回值<0(-1)
出错，查看errno：

EAGAIN or EWOULDBLOCK：fd被设定为非阻塞，并且write将会被阻塞，立即返回-1，errno为EAGAIN
EINTR：a、阻塞fd：被一个信号打断，但是需要强调的是，在信号打断前没有写入一个字节，才会返回-1，errno设定为EINTR。如果有写入，返回已经写入的字节数。这其实很好理解，如果写入了部分数据依然返回-1，errno设定为EINTR，处理完中断后，由于不知道被打断时写到了什么地方，也就不知道该从哪一个地方继续写入。b、非阻塞fd：调用非阻塞write，即使write被信号打断，write会会继续执行未完成的任务而不会去响应信号。因为在非阻塞调用中，没有任何理由阻止read或者wirte的执行。
EPIPE：fd是一个pipe或者socket，而对端的读端关闭。但是一般而言，写进程会收到SIGPIPE信号。（注意：和read不一样，read对端关闭使返回0）

read()函数：

头文件：#include<unistd.h>
功能：用于从文件描述符对应的文件读取数据（从打开的设备或文件中读取数据）

ssize_t read(int fd,void*buf,size_t count)
参数说明：
fd:      是文件描述符
buf:     为读出数据的缓冲区；
count:   为每次读取的字节数（是请求读取的字节数，读上来的数据保
         存在缓冲区buf中，同时文件的当前读写位置向后移）

1、返回值>0
a、等于给定字节数

b、小于给定字节数，可能原因如下：

在读到小于指定字节数时就已经收到了EOF，返回已经读到的数据
在读入部分数据时，被信号打断，返回已经读到的数据
2、返回值=0
说明读到文件尾EOF，或者socket的对端关闭。

3、返回值<0（-1）
查看errno：

EAGAIN or EWOULDBLOCK：fd设定为非阻塞，且要被阻塞时立即返回-1，设定相应的errno
EINTR：a、阻塞fd：如果在读入任何数据之前被打断，返回-1。如果被打断前读入了部分数据，返回已经读入的数据字节数。b、非阻塞fd：调用非阻塞read，即使read被信号打断，read会会继续执行未完成的任务而不会去响应信号。因为在非阻塞调用中，没有任何理由阻止read或者wirte的执行。

4：使用自定义协议的（readn，writen）回射客户/服务器模型例子：、

客户端程序：

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


using namespace std;

struct packet
{
    int len;
    char buf[1024];
};

#define ERR_EXIT(m) \
        do  \
        {   \
            perror(m);  \
            exit(EXIT_FAILURE); \
        } while(0);

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;   // 剩余字节数
    ssize_t nread;
    char *bufp = (char*) buf;

    while (nleft > 0)
    {
        nread = read(fd, bufp, nleft);
        if (nread < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return  -1;
        } else if (nread == 0)
        {
            return count - nleft;
        }

        bufp += nread;
        nleft -= nread;
    }
    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return -1;
        }
        else if (nwritten == 0)
        {
            continue;
        }
        bufp += nwritten;
        nleft -= nwritten;
    }
    return count;
}

int main(int argc, char** argv) {
    // 1. 创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        ERR_EXIT("socket");
    }

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof servaddr);
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    // servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    // 3. 请求链接
    if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof servaddr) < 0) {
        ERR_EXIT("connect");
    }

    // 4. 数据交换
//    char recvbuf[1024];
//    char sendbuf[1024];
    struct packet recvbuf;
    struct packet sendbuf;
    memset(&recvbuf, 0, sizeof recvbuf);
    memset(&sendbuf, 0, sizeof sendbuf);
    int n = 0;
    while (fgets(sendbuf.buf, sizeof sendbuf.buf, stdin) != NULL)   // 键盘输入获取
    {
        n = strlen(sendbuf.buf);
        sendbuf.len = htonl(n); // 主机字节序转换为网络字节序
        writen(sockfd, &sendbuf, 4+n); // 写入服务器

        int ret = readn(sockfd, &recvbuf.len, 4);    // 服务器读取
        if (ret == -1)
        {
            ERR_EXIT("read");
        }
        else if (ret < 4)
        {
            printf("server close\n");
            break;
        }

        n = ntohl(recvbuf.len);
        ret = readn(sockfd, &recvbuf.buf, n);
        if (ret == -1)
        {
            ERR_EXIT("read");
        }
        else if (ret < n)
        {
            printf("server close\n");
            break;
        }

        fputs(recvbuf.buf, stdout); // 服务器返回数据输出

        // 清空
        memset(&recvbuf, 0, sizeof recvbuf);
        memset(&sendbuf, 0, sizeof sendbuf);
    }

    // 5. 断开连接
    close(sockfd);


    return 0;
}

服务器端程序：

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


using namespace std;

struct packet
{
    int len;
    char buf[1024];
};

#define ERR_EXIT(m) \
        do  \
        {   \
            perror(m);  \
            exit(EXIT_FAILURE); \
        } while(0);

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;   // 剩余字节数
    ssize_t nread;
    char *bufp = (char*) buf;

    while (nleft > 0)
    {
        nread = read(fd, bufp, nleft);
        if (nread < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return  -1;
        } else if (nread == 0)
        {
            return count - nleft;
        }

        bufp += nread;
        nleft -= nread;
    }
    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char* bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            return -1;
        }
        else if (nwritten == 0)
        {
            continue;
        }
        bufp += nwritten;
        nleft -= nwritten;
    }
    return count;
}

void do_service(int connfd)
{
    // char recvbuf[1024];
    struct packet recvbuf;
    int n;
    while (1)
    {
        memset(&recvbuf, 0, sizeof recvbuf);
        int ret = readn(connfd, &recvbuf.len, 4);
        if (ret == -1)
        {
            ERR_EXIT("read");
        }
        else if (ret < 4)
        {
            printf("client close\n");
            break;
        }

        n = ntohl(recvbuf.len);
        ret = readn(connfd, recvbuf.buf, n);
        if (ret == -1)
        {
            ERR_EXIT("read");
        }
        else if (ret < n)
        {
            printf("client close\n");
            break;
        }
        fputs(recvbuf.buf, stdout);
        writen(connfd, &recvbuf, 4+n);
    }

}

int main(int argc, char** argv) {
    // 1. 创建套接字
    int listenfd;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        ERR_EXIT("socket");
    }

    // 2. 分配套接字地址
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof servaddr);
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(6666);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    // inet_aton("127.0.0.1", &servaddr.sin_addr);

    int on = 1;
    // 确保time_wait状态下同一端口仍可使用
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) < 0)
    {
        ERR_EXIT("setsockopt");
    }

    // 3. 绑定套接字地址
    if (bind(listenfd, (struct sockaddr*) &servaddr, sizeof servaddr) < 0) {
        ERR_EXIT("bind");
    }
    // 4. 等待连接请求状态
    if (listen(listenfd, SOMAXCONN) < 0) {
        ERR_EXIT("listen");
    }
    // 5. 允许连接
    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof peeraddr;


    // 6. 数据交换
    pid_t pid;
    while (1)
    {
        int connfd;
        if ((connfd = accept(listenfd, (struct sockaddr *) &peeraddr, &peerlen)) < 0) {
            ERR_EXIT("accept");
        }

        printf("id = %s, ", inet_ntoa(peeraddr.sin_addr));
        printf("port = %d\n", ntohs(peeraddr.sin_port));

        pid = fork();

        if (pid == -1)
        {
            ERR_EXIT("fork");
        }
        if (pid == 0)   // 子进程
        {
            close(listenfd);
            do_service(connfd);
            //printf("child exit\n");
            exit(EXIT_SUCCESS);
        }
        else
        {
            //printf("parent exit\n");
            close(connfd);
        }


    }
    // 7. 断开连接
    close(listenfd);



    return 0;
}

在linux下运行，在window上的话需要修改一些头文件名，函数名，用法有一些简单改变。

axiaobingqiu
关注
专栏目录
linux- socket编程-直接获取网卡-packet- sokcket和设置socket过滤函数
lyeffort的博客
11-24 412
linux- socket编程-直接获取网卡-packet- sokcket
Linux-Socket-服务器编程实例.pptx
06-07
8. `<sys/socket.h>`：包含了Socket编程的核心函数，如`socket`、`bind`、`listen`、`accept`和`connect`等。 接下来，`main`函数的参数`argc`和`argv`是C语言程序的基本输入，它们分别代表命令行参数的个数和参数...
【Linux】关于socket的fd
michaelwoshi的博客
04-26 8594
socket的fd是什么？ fd 是(file descriptor)，这种一般是BSD Socket的用法，用在Unix/Linux系统上。 fd全称是file descriptor,是进程独有的文件描述符表的索引。 在Unix/Linux系统下，一个socket句柄，可以看做是一个文件，在socket上收发数据，相当于对一个文件进行读写，所以一个socket句柄，通常也用表示文件句柄的...
linux 根据fd获取sock socket结构,【Linux】关于socket的fd
weixin_31842775的博客
05-14 347
socket的fd是什么？fd 是(file descriptor)，这种一般是BSD Socket的用法，用在Unix/Linux系统上。fd全称是file descriptor,是进程独有的文件描述符表的索引。在Unix/Linux系统下，一个socket句柄，可以看做是一个文件，在socket上收发数据，相当于对一个文件进行读写，所以一个socket句柄，通常也用表示文件句柄的fd来表示。L...
linux中fd函数,linux socket中select()函数以及FD_ZERO FD_SET FD_CLR FD_ISSET
weixin_39967938的博客
05-10 93
linux socket非阻塞编程时常见到如下的code:socket s;.....fd_set set;.....struct timeval tv;while(1){FD_ZERO(&set);//将你的套节字集合清空FD_SET(s, &set);//加入你感兴趣的套节字到集合,这里是一个读数据的套节字stv.tv_sec = 3;tv.tv_usec = 0;...
linux-socket网络编程详解.doc
01-16
在Linux环境中，Socket编程涉及到创建、配置和使用Socket对象进行数据传输。 1. **Socket基本概念** - **Socket接口**：Socket接口是一组函数，用于实现应用程序和TCP/IP网络之间的通信。它是操作系统提供的标准...
socket_linux-socket网络编程详解_
10-01
在Linux Socket编程中，我们需要定义服务器和客户端的网络地址，这通常使用`struct sockaddr_in`结构体完成。包含IP地址和端口号。 ```c struct sockaddr_in server; server.sin_family = AF_INET; server.sin_addr...
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
【Linux网络编程-网络基础-socket编程-高并发服务器】 在深入探讨Linux下的网络编程之前，我们首先要理解网络通信的基础概念——协议。协议是数据传输和解释的规则，它确保了不同设备之间的通信能顺利进行。例如，...
linux下socket和fork结合使用的例子
09-06
linux下socket和fork结合使用的例子，描述了socket的基本流程和如何采用子进程处理客户端请求
Linux内核101：fd,syscall,socket
weixin_34310127的博客
05-17 148
原视频地址：www.youtube.com/watch?v=Ftg… 本文内容概览： 文件描述符 操作系统基础 文件描述符和进程 网络和 sockets 文件描述符 相信你对"On Unix, Everything is a file"已经耳熟能详了，比如/dev目录、/proc目录等，你几乎可以通过操作文件的方式获取系统所有能够获取的data。而和文件进行交互，就需要用到文件描述符（fi...
【Linux fd 系列 — socket fd 是什么？】【转载】
j8267643的博客
02-25 1722
总结vfs 下有一个。
Linux系统编程—socket网络编程
2301_77164542的博客
04-20 524
套接字通常和同一个域中的套接字交换数据(数据交换也可能穿越域的界限，但这时一定要执行某种解释程序)，各种进程使用这个相同的域互相之间用Internet协议簇来进行通信。sockfd：文件描述符，addr：一个指针指向一个sockaddr结构体，用于存放客户端的地址信息，addrlen：一个指向socklen_t类型变量的指针，用于存放客户端地址结构体的长度。sockfd为socket函数调用返回的文件描述符，my_addr是一个指针，它指向sockfd，addrlen为sockaddr的长度大小。
Linux-socket编程
Enthusiastic_boy的博客
05-23 646
UDP特性 无连接:UDP双方在发送数据之前是不需要进行沟通的。只需要知道对方的ip地址和端口号就好。 不可靠:不保证UDP数据是可靠，有序的到达对方 面向数据报:UDP应用层/网络层递交数据的时候，都是整条数据进行交付的。 UDP-Socket编程 编程流程 服务端：创建套接字，绑定地址信息，接收数据，发送数据，关闭套接字。 客户端：创建套接字，绑定地址信息（不推荐），发送数据，接收数据，关闭套接字。 创建套接字绑定地址信息的含义：将进程与网卡绑定，进程可以从网卡中接收数据，也可以是通..
基于Linux的文件操作（socket操作）
最新发布
qq_41885018的博客
05-30 1760
在linux中，socket也被认为是文件的一种，因此在网络数据传输过程中自然可以使用文件I/O的相关函数。 而在Windows中，是要区分socket和文件的，所以在Windows中需要特殊的数据传输相关的函数。
Linux：socket通信原理
Running 仔的博客
12-06 2400
linux socket通信 引入：网络中进程之间通信 操作系统为进程间通信提供的常见方式： UNIX BSD有：管道（pipe）、命名管道（named pipe）软中断信号（signal）； UNIX system V有：消息（message）、共享存储区（shared memory）和信号量（semaphore)等. 为了唯一标识某个主机进程，可以通过TCP/IP协议族，即网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。三元组（ip地址，协议
Linux下Socket编程一 socket 基础
dayeshisir的专栏
06-13 1840
 <!-- document.body.oncopy = function() { if (window.clipboardData) { setTimeout(function() { var text = clipboardData.getDat
linux中fd的几点理解——一切皆文件
weixin_38184628的博客
01-13 2465
fd 全称是 file descriptor，文件描述符，又称句柄。当我们在打开一个文件，创建一个 socket， 创建一个 epoll 时，返回值往往都用一个变量 int fd 来表示。
Linux Socket编程实践指南
"《Linux Socket编程实战》是Warren W. Gay所著的一本关于Linux网络编程的书籍，主要关注Socket编程技术。本书通过实例详细介绍了如何在Linux环境下使用Socket进行网络通信。" Linux Socket编程是开发网络应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值