TCP中 recv和sendf函数

recv和send函数：

#include<sys/socket.h>

ssize_t recv(int sockfd, void *buff, size_t nbytes, int flags);

ssize_t recv(int sockfd, const void *buff, size_t nbytes, int flags);

flags的值中 MSG_OOB和MSG_PEEK比较重要。

read和recv函数的区别在于：

read函数读取缓冲区的数据之后，会将缓冲区的数据删除，而recv不会删除缓冲区的数据。

因此，可以将falgs设置为MSG_PEEK，在此模式下，先查看发送过来的字符的个数，然后用read函数读取数据。

例子服务端代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<sys/wait.h>      //*进程用的头文件*/
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#define MAXLINE  1024  //通信内容的最大长度

ssize_t readn(int fd, void *buf, size_t count)
{
    ssize_t nleft=count;
    ssize_t nread;
    char *charbuf=(char*) buf;

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

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

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

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

        }
       return count;
}

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

 ssize_t readline(int sockfd, void *buf, size_t len)
{
        ssize_t nleft=len,nread;
        int ret;
        char* bufchar=buf;
        while(1)
        {
                ret=recv_peek(sockfd,bufchar,len);
                if(ret<0||ret==0)
                        return ret;
                nread=ret;
                int i;
                for(i=0;i<nread;i++)
                {
                        if(bufchar[i]==‘\n‘)
                        {
                                ret=readn(sockfd,bufchar,i+1);
                                if(ret!=i+1)
                                        exit(EXIT_FAILURE);
                                return ret;
                        }
                }
                if(nread>nleft)
                        exit(EXIT_FAILURE);
                nleft-=nread;
                ret=readn(sockfd,bufchar,nread);
                if(ret!=nread)
                        exit(EXIT_FAILURE);
                bufchar+=nread;

        }
        return -1;

}

int main()
{
    int sock_fd,new_fd;//sock_fd用于监听，new_fd用于连接
    struct sockaddr_in srv_addr;//服务器的地址信息
    struct sockaddr_in client_addr;//客户机的地址信息
    int size; //地址结构数据的长度
    pid_t  pid;  //子进程id
    ssize_t n,ret;
    char buf[MAXLINE]; //用于存放通信的内容

        char sendbuf[1024],recvbuf[1024];
    memset(sendbuf,0,sizeof(sendbuf));
    memset(recvbuf,0,sizeof(recvbuf));

    /*创建套接字*/
    sock_fd=socket(AF_INET,SOCK_STREAM,0);//采用IPv4协议
    if(sock_fd==-1)
    {
        perror("creat socket failed");
        exit(1);
    }

    /*服务器地址参数*/
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_port=htons(3490);
    srv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    bzero(&srv_addr.sin_zero,sizeof(struct sockaddr_in));//bzero位清零函数，将sin_zero清零，sin_zero为填充字段，必须全部为零

    int on=1; //表示开启reuseaddr
    if(setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)  //打开地址、端口重用
        perror("setsockopt");

    /*绑定地址和端口*/
    if(bind(sock_fd,(struct sockaddr*)&srv_addr,sizeof(struct sockaddr))==-1)
    {
        perror("bind failed");
        exit(1);
    }

    /*连接到服务器
    if(connect(sock_fd,(struct sockaddr*)&srv_addr,sizeof(sock_fd))==-1)
    {
        perror("bind failed");
        exit(1);
    }*/

    /*设置监听模式，等待客户机的监听*/
    if((listen(sock_fd,5))==-1)
    {
        perror("listen failed");
        exit(1);
    }

    /*接受连接,采用非阻塞是的模式调用accep*/
    //while(1)
    //{
        size=sizeof(struct sockaddr_in);
        new_fd=accept(sock_fd,(struct sockaddr*)&client_addr,&size);
        if(new_fd==-1)
        {
            perror("accept failed");
            //continue;//restart accept when EINTR
        }

        printf("server:got connection from IP= %s prot= %d \n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));//连接成功，打印客户机IP地址和端口号
        /*char *inet_nota(struct sockaddr_in in);
        头文件：
        arpa/inet.h
        Winsock2.h
        参数：
        一个网络上的IP地址
        返回值：
          如果正确，返回一个字符指针，指向一块存储着点分格式IP地址的静态缓冲区（同一线程内共享此内存）；错误，返回NULL。
        uint31_t ntohs(uint32_t net32bitvalue);
        头文件：
        #include<netinet/in.h>
        把net32bitvalue有网络字节序转换为主机字节序。
        */
        if(send(new_fd,"Hello client,I am 192.168.229.125!\n",50,0)==-1)  //192.168.229.125为子进程IP，可更改
            perror("send failed");

        pid=fork();  //父进程建立套接字的连接之后，创建子进程用于通信
        if(pid<0)
               perror("fork error\n");
        if(!pid)//创建新的子进程,用于发送数据
        {
         //  close(sock_fd);//子进程不需要监听，所以子进程关闭监
            while(fgets(sendbuf,sizeof(sendbuf),stdin)!=NULL)
            {
                writen(new_fd,sendbuf,strlen(sendbuf));
                memset(sendbuf,0,sizeof(sendbuf));   //清空，以免和下一次混淆
           // exit(EXIT_SUCCESS);
                    }
            exit(EXIT_SUCCESS);
        }
        //close(new_fd);//父进程不需要连接，所以关闭连接套接字
           else
        {
            while(1)
                {
                memset(recvbuf,0,sizeof(recvbuf));
                ret=readline(new_fd,recvbuf,1024);
                                if(ret<0)
                                        perror("read from client error");
                                else if(ret==0)
                                {
                                        printf("peer closed\n");
                                        break;
                                }
                               fputs(recvbuf,stdout);
            }
             exit(EXIT_SUCCESS);
        }
        //while(waitpid(-1,NULL,WNOHANG)>0);//等待子进程结束，进行新的连接
    //}
    return 0;
}

客户端代码

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<sys/wait.h>      //*进程用的头文件*/
#include<netinet/in.h>
#include<arpa/inet.h>

#define MAXBYTEMUN   1024

ssize_t readn(int fd, void *buf, size_t count)
{
        ssize_t nleft=count;
        ssize_t nread;
        char *charbuf=(char*) buf;

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

                charbuf +=nread;
                nleft=count-nread;
        }

        return count;
}

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

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

         charbuf +=nwrite;
                nleft=count-nwrite;
    }
    return count;
}

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

 ssize_t readline(int sockfd, void *buf, size_t len)
{
    ssize_t nleft=len,nread;
    int ret;
    char* bufchar=buf;
    while(1)
    {
         ret=recv_peek(sockfd,bufchar,len);
        if(ret<0||ret==0)
            return ret;
        nread=ret;
        int i;
        for(i=0;i<nread;i++)
        {
            if(bufchar[i]==‘\n‘)
            {
                ret=readn(sockfd,bufchar,i+1);
                if(ret!=i+1)
                    exit(EXIT_FAILURE);
                return ret;
            }
        }
        if(nread>nleft)
            exit(EXIT_FAILURE);
        nleft-=nread;
        ret=readn(sockfd,bufchar,nread);
        if(ret!=nread)
            exit(EXIT_FAILURE);
        bufchar+=nread;

    }
    return -1;

}

int main(int argc,char *argv[])
{
    int sock_fd,numbytes;
    char buf[MAXBYTEMUN];
    struct hostent *he;
    struct sockaddr_in client_addr;//客户机的地址信息
    ssize_t n,ret;
    char recvbuf[1024]={‘0‘},sendbuf[1024]={‘0‘};

    if(argc!=2)
    {
        fprintf(stderr,"usage: client IPAddress\n");   //执行客户端程序时，输入客户端程序名称和其IP地址
        exit(1);
    }

    /*创建套接字*/
    sock_fd=socket(AF_INET,SOCK_STREAM,0);//采用IPv4协议
    if(sock_fd==-1)
    {
        perror("creat socket failed");
        exit(1);
    }

    /*服务器地址参数*/
    client_addr.sin_family=AF_INET;
    client_addr.sin_port=htons(3490);
    client_addr.sin_addr.s_addr=inet_addr(argv[1]);
    bzero(&client_addr.sin_zero,sizeof(struct sockaddr_in));//bzero位清零函数，将sin_zero清零，sin_zero为填充字段，必须全部为零

    /*连接到服务器*/
    if(connect(sock_fd,(struct sockaddr*)&client_addr,sizeof(struct sockaddr))==-1)
    {
        perror("connect failed");
        exit(1);
    }
    if((numbytes=recv(sock_fd,buf,MAXBYTEMUN,0))==-1)
        {
            perror("receive failed");
             exit(1);
        }
    buf[numbytes]=‘\0‘;//在字符串末尾加上\0，否则字符串无法输出
    printf("Received: %s\n",buf);

    pid_t pid;
    pid=fork();
    if(!pid)//创建新的子进程,用于接收数据
        {
            while(1)
            {
                memset(recvbuf,0,sizeof(recvbuf));
                ret=readline(sock_fd,recvbuf,1024);
                if(ret<0)
                                        perror("read from server error");
                else if(ret==0)
                {
                    printf("peer closed\n");
                    break;
                }
                fputs(recvbuf,stdout);
            }
            close(sock_fd);
        }
        else   //f=父进程用于发送数据
        {
            //close(sock_fd);//父进程不需要连接，所以关闭连接套接字
            while(fgets(sendbuf,sizeof(sendbuf),stdin)!=NULL)
            {
                writen(sock_fd,sendbuf,strlen(sendbuf));
                memset(sendbuf,0,sizeof(sendbuf));    //清空，以免和下一次混淆
            }
             close(sock_fd);
        }
    return 0;
}
时间： 2024-11-10 02:05:04

TCP中 recv和sendf函数的相关文章

socket编程中recv与send函数

recv函数会将套接字缓冲区中的内容读出,但不清空,与read函数的区别在此.此函数有一个flag标志位,设为MSG_PEEK. send函数会将缓冲区中的内容写入到套接字,也不清空,与write函数的区别在此. 用这两个函数可以先接收或发送缓冲区中的内容,然后再用readn(此时缓冲区中的内容依然存在)与write函数去继续判断换行符/n,对缓冲区内容实现换行输出. echocli.c #include <unistd.h> #include <sys/types.h> #inc

/proc/net/tcp中各项参数说明

/proc/net/tcp中的内容由tcp4_seq_show()函数打印,该函数中有三种打印形式,我们这里这只列出状态是TCP_SEQ_STATE_LISTENING或TCP_SEQ_STATE_ESTABLISHED的情况,如下所示: netstat 的结果是读取/proc/net/tcp文件而来的 如何查看一个连接的创建时间 1.nestat -apn | grep xxx查看到对应的连接的进程pid和端口 2. 将上下游端口,转换为16进制xxxa xxxb 3.然后cat /proc/

Linux操作系统中的系统调用接口函数

在分析病毒样本时发现有些系统函数是必用,有些超常用,现在都列出来,希望和大家交流 转载请注明出处:http://blog.csdn.net/u010484477     O(∩_∩)O谢谢 进程控制 fork 创建一个新进程 clone 按指定条件创建子进程 execve 运行可执行文件 exit 中止进程 _exit 立即中止当前进程 getdtablesize 进程所能打开的最大文件数 getpgid 获取指定进程组标识号 setpgid 设置指定进程组标志号 getpgrp 获取当前进程组

用sql语句导出oracle中的存储过程和函数

用sql语句导出oracle中的存储过程和函数: SET echo off ; SET heading off ; SET feedback off ; SPOOL 'C:/PRC.SQL' replace SELECT CASE WHEN LINE = 1 THEN 'CREATE OR REPLACE ' || TEXT WHEN LINE = MAX_LINE THEN TEXT || CHR(10 ) || '/' ELSE TEXT END FROM USER_SOURCE A LEF

javascript中的立即执行函数(function(){…})()

javascript中的立即执行函数(function(){…})() 深入理解javascript中的立即执行函数,立即执行函数也叫立即调用函数,通常它的写法是用(function(){…})()包住业务代码,使用jquery时比较常见. ( function(){…} )()和( function (){…} () )是两种javascript立即执行函数的常见写法,最初我以为是一个括号包裹匿名函数,再在后面加个括号调用函数,最后达到函数定义后立即执行的目的,后来发现加括号的原因并非如此.要

（转）驱动开发中使用安全字符串函数

参考链接:http://www.cppblog.com/aurain/archive/2009/09/27/97363.html 一.前言 大量的系统安全问题是由于薄弱的缓冲处理以及由此产生的缓冲区溢出造成的,而薄弱的缓冲区处理常常与字符串操作相关.c/c++语言运行库提供的标准字符串操作函数(strcpy, strcat, sprintf等)不能阻止在超出字符串尾端的写入. 基于Windows XP SP1以及随后的操作系统的Windows DDK版本提供了安全字符串函数(safe strin

JavaScript 中对变量和函数声明的提前示例

如题所示,看下面的示例(可以使用Chrome浏览器,然后F12/或者右键,审查元素.调出开发者工具,进入控制台console输入)(使用技巧: 控制台输入时Shift+Enter可以中途代码换行) var name = "xiaoming"; (function(){ var name = name || "小张"; console.info(name); })();// 小张 (function(){ name = name || "小张";

C++面试题1：构造函数和虚构函数中能否调用虚函数？

C++面试题1:构造函数和虚构函数中能否调用虚函数? 构造函数跟虚构函数里面都可以调用虚函数,编译器不会报错. C++ primer中说到最好别用 由于类的构造次序是由基类到派生类,所以在构造函数中调用虚函数,虚函数是不会呈现出多态的 类的析构是从派生类到基类,当调用继承层次中某一层次的类的析构函数时意味着其派生类部分已经析构掉,所以也不会呈现多态 因此如果在基类中声明的纯虚函数并且在基类的析构函数中调用之,编译器会发生错误. class Base { public: Base() { Fuct

项目开发中常用的PHP函数

日期操作 为了便于存储.比较和传递,我们通常需要使用strtotime()函数将日期转换成UNIX时间戳,只有在显示给用户看的时候才使用date()函数将日期转换成常用的时间格式. strtotime()  函数将任何英文文本的日期时间描述解析为 Unix 时间戳 eg: <?php echo(strtotime("now")); echo(strtotime("3 October 2005")); echo(strtotime("+5 hours&