socket编程中recv与send函数

最新推荐文章于 2020-09-05 16:10:40 发布
最新推荐文章于 2020-09-05 16:10:40 发布
阅读量2k 收藏 3
点赞数
分类专栏： linux网络编程 linux系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuehua22/article/details/25543709
版权

recv函数会将套接字缓冲区中的内容读出，但不清空，与read函数的区别在此。此函数有一个flag标志位，设为MSG_PEEK。

send函数会将缓冲区中的内容写入到套接字，也不清空，与write函数的区别在此。

用这两个函数可以先接收或发送缓冲区中的内容，然后再用readn（此时缓冲区中的内容依然存在）与write函数去继续判断换行符/n，对缓冲区内容实现换行输出。

echocli.c

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

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#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)
        {
                if ((nread = read(fd, bufp, nleft)) < 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;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        while (1)
        {
                int ret = recv(sockfd, buf, len, MSG_PEEK);
                if (ret == -1 && errno == EINTR)
                        continue;
                return ret;
        }
}


ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

void echo_cli(int sock)
{
    char sendbuf[1024] = {0};
        char recvbuf[1024] = {0};
        while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
        {
                writen(sock, sendbuf, strlen(sendbuf));

                int ret = readline(sock, recvbuf, sizeof(recvbuf));
                if (ret == -1)
                        ERR_EXIT("readline");
                else if (ret == 0)
                {
                        printf("client close\n");
                        break;
                }

                fputs(recvbuf, stdout);
                memset(sendbuf, 0, sizeof(sendbuf));
                memset(recvbuf, 0, sizeof(recvbuf));
        }

        close(sock);
}

int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect");

    struct sockaddr_in localaddr;
    socklen_t addrlen = sizeof(localaddr);
    if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
        ERR_EXIT("getsockname");

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


    echo_cli(sock);

    return 0;
}

echosrv.c

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#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)
    {
        if ((nread = read(fd, bufp, nleft)) < 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;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;
    char *bufp = buf;
    int nleft = maxline;
    while (1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if (ret < 0)
            return ret;
        else if (ret == 0)
            return ret;

        nread = ret;
        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '\n')
            {
                ret = readn(sockfd, bufp, i+1);
                if (ret != i+1)
                    exit(EXIT_FAILURE);

                return ret;
            }
        }

        if (nread > nleft)
            exit(EXIT_FAILURE);

        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
            exit(EXIT_FAILURE);

        bufp += nread;
    }

    return -1;
}

void echo_srv(int conn)
{
    char recvbuf[1024];
        while (1)
        {
                memset(recvbuf, 0, sizeof(recvbuf));
                int ret = readline(conn, recvbuf, 1024);
        if (ret == -1)
            ERR_EXIT("readline");
        if (ret == 0)
        {
            printf("client close\n");
            break;
        }
        
                fputs(recvbuf, stdout);
                writen(conn, recvbuf, strlen(recvbuf));
        }
}

void handle_sigchld(int sig)
{
/*    wait(NULL);*/
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
}

int main(void)
{
/*    signal(SIGCHLD, SIG_IGN);*/
    signal(SIGCHLD, handle_sigchld);
    int listenfd;
    if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
/*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    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;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt");

    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");

    struct sockaddr_in peeraddr;
    socklen_t peerlen = sizeof(peeraddr);
    int conn;

    pid_t pid;
    while (1)
    {
        if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
            ERR_EXIT("accept");

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

        pid = fork();
        if (pid == -1)
            ERR_EXIT("fork");
        if (pid == 0)
        {
            close(listenfd);
            echo_srv(conn);
            exit(EXIT_SUCCESS);
        }
        else
            close(conn);
    }
    
    return 0;
}

echocli2.c

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

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#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)
        {
                if ((nread = read(fd, bufp, nleft)) < 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;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        while (1)
        {
                int ret = recv(sockfd, buf, len, MSG_PEEK);
                if (ret == -1 && errno == EINTR)
                        continue;
                return ret;
        }
}


ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '\n')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

void echo_cli(int sock)
{
    char sendbuf[1024] = {0};
        char recvbuf[1024] = {0};
        while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
        {
                writen(sock, sendbuf, strlen(sendbuf));

                int ret = readline(sock, recvbuf, sizeof(recvbuf));
                if (ret == -1)
                        ERR_EXIT("readline");
                else if (ret == 0)
                {
                        printf("client close\n");
                        break;
                }

                fputs(recvbuf, stdout);
                memset(sendbuf, 0, sizeof(sendbuf));
                memset(recvbuf, 0, sizeof(recvbuf));
        }

        close(sock);
}

int main(void)
{
    int sock[5];
    int i;
    for (i=0; i<5; i++)
    {
        if ((sock[i] = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
            ERR_EXIT("socket");

        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(5188);
        servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

        if (connect(sock[i], (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
            ERR_EXIT("connect");

        struct sockaddr_in localaddr;
        socklen_t addrlen = sizeof(localaddr);
        if (getsockname(sock[i], (struct sockaddr*)&localaddr, &addrlen) < 0)
            ERR_EXIT("getsockname");

        printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
    }

    echo_cli(sock[0]);

    return 0;
}




makefile:

.PHONY:clean all
CC=gcc
CFLAGS=-Wall -g
BIN=echosrv echocli echocli2
all:$(BIN)
%.o:%.c
    $(CC) $(CFLAGS) -c $< -o $@
clean:
    rm -f *.o $(BIN)


一直在路上25
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Socket send函数和recv函数详解
03-13
不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。
recv()函数中MSG_PEEK参数的解释(转）
CHALLENG_EVERYTHING的专栏
10-17 595
recv默认最后一个flag参数是0，调用完recv，如果socket的接收缓冲区存在数据，则recv调用会从缓冲区中取走数据 但是如果flag参数设置为0，则调用完recv，不从接收缓冲区中移除读取的数据。 recv()函数中MSG_PEEK参数的解释_sinat_37372543的博客-CSDN博客 ...
recv_peek偷窥函数和UNIX域间文件描述符传递sendmsg、recvmsg
Chenk的专栏
09-25 1772
/**  * recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据  * @sockfd: 套接字  * @buf: 接收缓冲区  * @len: 长度  * 成功返回>=0，失败返回-1  */ ssize_t recv_peek(int sockfd, void *buf, size_t len) { while (1) { int ret = recv(soc
SOCKET网络编程四：SELECT单进程并发服务器
mazi的博客
02-15 716
五种IO模型： 阻塞IO：recv接收缓冲区有数据后，就会解除阻塞。 非阻塞IO：忙等待fcntl(fd,F_SETFL,flag|O_NONBLOCK) IO复用（select和poll） 信号驱动IO 异步IO ...
linux网络编程之socket编程(五)
weixin_30610755的博客
09-23 88
今天继续学习socket网络编程，最近北京阴雨连绵，降温明显，感觉是要立马转入冬季的节奏，天冷晚上得注意多盖点被子哦，言归正传，进入正题： 对于之前写的回射客户/服务器端的程序中，我们是用的read和write来读取和发送数据的，如下： 那recv相对于read有什么区别呢？先看一下man帮助： 其实它跟read函数功能一样，都可以从套接口缓冲区sockfd中取数据到buf,但是...
recv()函数中MSG_PEEK参数的解释
sinat_37372543的博客
09-01 3967
通常recv()函数的最后一个参数为0，代表从缓冲区取走数据，而当为MSG_PEEK时代表只是查看数据，而不取走数据。 举例：例如套接字缓冲区现有序列''abc'',外部缓冲区即字符数组大小为1，每次只能从套接字中缓冲区读取一个字符。当最后一个参数为0时，调用recv()，套接字缓冲区序列变为''bc''。当最后一个参数为MSG_PEEK时，调用recv(),套接字缓冲区为''abc''。 ...
对send(),recv()函数的全面理解
01-10
int send( SOCKET s, const char FAR *buf, int len, int flags );...这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲的 长度， 如果
python网络编程调用recv函数完整接收数据的三种方法
12-24
在使用socket进行网络编程中，如何判定对端发送一条报文是否接收完成，是进行socket网络开发必须要考虑的一个问题。这里，简要介绍一下判别数据接收接收完成常用的三种方法： 1.基础数据接收法： 使用基础数据接收法...
send函数 和recv函数
12-21
里面有socket函数和recv函数的详细讲解，有用
C++socket编程_socket编程_splitbnd_socket_Listen!_c++socket编程_
10-01
网络编程，当然要用到Windows Socket（套接字）技术。Socket相关的操作由一系列API函数来完成，比如socket、bind、listen、connect、accept、send、sendto、recv、recvfrom等。
recv函数MSG_PEEK|MSG_DONTWAIT|MSG_OOB选项
_llc的博客
09-05 3843
send recv函数 ssize_t send(int sockfd,const void* buf,size_t nbytes,int flags); ssize_t recv(int sockfd,void* buf,size_t nbytes,int flags); 之前一直在linux下使用read和write函数, MSG_OOB:TCP只有紧急模式,没有带外数据 MSG_DONTWAIT:调用函数时不阻塞 MSG_PEEK:只有recv能用,检测input缓冲区是否有数据,(缓冲区数据不变
socket编程点到点通信
qq_22753933的博客
09-19 446
//点到点通信 //服务器设计 #include &lt;unistd.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;netinet/in.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;signal.h&gt; #include &lt;...
recv函数的MSG_PEEK标志介绍
热门推荐
道法自然
10-17 1万+
转载自：http://www.blogbus.com/gcoder-logs/220779725.html 考虑下面的场景，server向client发送数据"_META_DATA_\r\n_USER_DATA_"，要求"\r\n"之前的数据_META_DATA_在第一次recv中接收，剩下的recv调用读取_USER_DATA_部分的数据。因为tcp是stream协议，并且
recv函数究竟是在剪切（偷取）还是复制（偷窥）？ 由0和MSG_PEEK决定！
认知 行动 坚持
01-18 9717
我们先来看MSG_PEEK的值 #include #include int main() { printf("%d\n", MSG_PEEK); // 2 return 0; } 下面， 我们来看服务端程序： #include #include // winsock接口 #pragma comment(lib, "ws2_32.lib") // winso
MSG_PEEK标志
null
06-06 8132
MSG_PEEK标志可以用来读取套接字接收队列中可读的数据，一些情况会用到它，比如为了避免不阻塞而先检查套接字接收队列中可读的数据长度，再采取相应操作。 当然，不阻塞也可采取其他的方法，例如非阻塞式I/O。 MSG_PEEK标志会将套接字接收队列中的可读的数据拷贝到缓冲区，但不会使套接子接收队列中的数据减少，常见的是：例如调用recv或read后，导致套接字接收队列中的数据被读取后而减少，
UDP通信协议-recvfrom() MSG_PEEK 参数
01-17 3129
这几天为了实现一个基于UDP的上层SIP协议，碰到一个离奇的问题，debug两天方得结果，太难受了。       问题描述：UDP客户端第一次通过sendto()发送消息给服务器端后，阻塞在recvfrom()，等待服务器返回消息。之后的第二次，第三次，第N次客户端都不会阻塞在recvfrom()函数，而是直接获得数据，不管服务器端有没有sendto()，而且每次获得的数据都是一样的。
recv()函数的参数解析--MSG_PEEK
asd_book
01-23 7167
recv()的原型是ssize_t recv(int sockfd, void *buf, size_t len, int flags);  我们在编写函数时，通常flags设置为0，此时recv()函数读取tcp 缓冲区中的数据到buf中，并从tcp 缓冲区中移除已读取的数据。如果把flags设置为MSG_PEEK，仅仅是把tcp 缓冲区中的数据读取到buf中，没有把已读取的数据从tcp
VC++的Socket中send函数和recv函数详解
最新发布
06-08
send函数和recv函数是VC++中Socket编程中最常用的两个函数，它们分别用于发送数据和接收数据。 send函数的原型如下： ```c++ int send( SOCKET s, const char* buf, int len, int flags ); ``` 参数说明： - s：需要发送数据的Socket。 - buf：指向包含要发送数据的缓冲区的指针。 - len：要发送的数据的字节数。 - flags：调用方式标志。 返回值说明： - 成功：返回实际发送的字节数。 - 失败：返回SOCKET_ERROR。 recv函数的原型如下： ```c++ int recv( SOCKET s, char* buf, int len, int flags ); ``` 参数说明： - s：需要接收数据的Socket。 - buf：指向接收数据的缓冲区的指针。 - len：要接收的数据的最大字节数。 - flags：调用方式标志。 返回值说明： - 成功：返回实际接收的字节数。 - 失败：返回SOCKET_ERROR。 send和recv函数的使用方法如下： ```c++ char sendbuf[] = "Hello, world!"; int sendbuflen = sizeof(sendbuf); int sentbytes = 0; sentbytes = send(sock, sendbuf, sendbuflen, 0); if (sentbytes == SOCKET_ERROR) { // 发送失败 } char recvbuf[1024]; int recvbuflen = sizeof(recvbuf); int receivedbytes = 0; receivedbytes = recv(sock, recvbuf, recvbuflen, 0); if (receivedbytes == SOCKET_ERROR) { // 接收失败 } ``` 使用send和recv函数时需要注意以下几点： - send和recv函数都是阻塞式的，即程序会一直等待直到发送或接收完所有数据。 - 如果发送或接收的数据量比较大，需要多次调用send或recv函数。 - 如果发送或接收的数据量比较小，建议使用TCP_NODELAY选项关闭Nagle算法，以提高发送和接收的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值