linux下非阻塞模式网络通讯模型示例分享

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <sysexits.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#ifdef __enabled_debug_info_output__
    #define debug_output(format) printf( "\nfile: %s : line: %d ->function: %s\n"format"\n", __base_file__, __line__, __function__ )
    #define debug_output_para(format,...) printf( "\nfile: %s : line: %d ->function: %s\n"format"\n", __base_file__, __line__, __function__, __va_args__ )
#else
    #define debug_output(format)
    #define debug_output_para(format,...)
#endif

// @brief 非阻塞等待套接字是否可读/写
// @param[in] sockfd 套接字描述符
// @param[in] bwhichset true - 可读集； false - 可写集；
// @param[in] uitimeoutms 超时时长(单位：微秒)；
// @pre scokfd 有效套接字描述符，即大于等于零(>=0)
// @return 此函数执行结果
// @return  0 - 可以读/写；
//         -1 - 参数不合法；
//         -2 - 检测已超时；
// @note uitimeoutms 超时时长，设为零(0)，则不等待超时
static inline int
wait_rw_able( int          sockfd,
              bool         bwhichset,
              unsigned int uitimeoutms )
{
    // 默认为检测已超时
    int ireturnvalue = -2;

    // 可读描述符集
    fd_set rset;
    // 可写描述符集
    fd_set wset;

    // select 将等待的时间
    timeval tv;

    do // 非循环，只是为了保证函数只有一个返回点
    {
        // 参数不合法
        if ( 0 > sockfd )
        {
            ireturnvalue = -1;
            break;
        }

        // 注：每次调用 select 之前都要重设一次！
        tv.tv_sec  = 0;
        tv.tv_usec = uitimeoutms;

        // 检测是否可读
        if ( true == bwhichset )
        {
            // 清除其所有位
            fd_zero( &rset );
            // 设置关心的描述符
            fd_set( sockfd, &rset );

            // 大于零(0) - 有套接字可读，零(0) - 没有，负数 - 出错
            if ( 0 < select( sockfd + 1, // 从描述符零(0)开始搜索，故此要对套接字描述符加壹(1)
                             &rset,      // 可读描述符集
                             null,       // 可写描述符集
                             null,       // 异常描述符集
                             &tv ) )     // 等待时间
            {
                // 可读描述符是我们的套接字
                if ( fd_isset( sockfd, &rset ) )
                {
                    ireturnvalue = 0;
                    break;
                }
            }
        }
        // 检测是否可写
        else
        {
            // 清除其所有位
            fd_zero( &wset );
            // 设置关心的描述符
            fd_set( sockfd, &wset );

            // 大于零(0) - 有套接字可读，零(0) - 没有，负数 - 出错
            if ( 0 < select( sockfd + 1, // 从描述符零(0)开始搜索，故此要对套接字描述符加壹(1)
                             null,       // 可读描述符集
                             &wset,      // 可写描述符集
                             null,       // 异常描述符集
                             &tv ) )     // 等待时间
            {
                // 可读描述符是我们的套接字
                if ( fd_isset( sockfd,
                               &wset ) )
                {
                    ireturnvalue = 0;
                    break;
                }
            }
        }

    }while( 0 );

    return ireturnvalue;
}

// @brief 发送且接收通讯协议
// @param[int][out] pucsrbuffer 发送且接收协议字符缓冲区指针
// @param[int] usbufferlen 发送且接收协议字符缓冲区大小
// @pre pucsrbuffer 有效的协议字符缓冲区指针，且字符串长度大于零(0)
// @return 此函数执行结果
// @retval   0 成功
// @retval  -1 参数不合法
// @retval  -2 创建连接服务端的套接字失败
// @retval  -3 设置连接服务端的套接字为非阻塞模式失败
// @retval  -4 套按字非阻塞模式下也不可写
// @retval  -5 调用 getsockopt 函数失败
// @retval  -6 调用 connect 函数失败
// @retval  -7 设置连接服务端的套接字为阻塞模式失败
// @retval  -8 发送协议数据失败
// @retval  -9 等待服务端返回数据超时
// @retval -10 调用 recv 函数出错
// @retval -11 pucsrbuffer 指向的缓冲区空间不足
int
send_receive_data( unsigned char* const pucsrbuffer,
                   const unsigned short usbufferlen )
{
    // 本函数执行结果返回值
    int         iresult = 0; // 默认为零(0) 表示成功

    // 连接服务端的 tcp 套接字
    int         iserversocket = -1;
    // 服务端ip与端口
    sockaddr_in sserveraddr;

    // i/o 状态标识值
    int ivalue = 1;

    // 获取套接字错误状态码
    int       iso_error = 0;
    socklen_t so_error_len = sizeof( iso_error );

    // 接收到的通讯协议数据长度
    unsigned short usrealreceiveddata = 0;

    do // 非循环，只是为了减少分支缩进和保证进出口唯一
    {
        // 1.检查参数是否合法
        if ( ( null == pucsrbuffer ) ||
             (    0 >= usbufferlen ) ||
             (    0 == pucsrbuffer[0] ) )
        {
            debug_output( "invalid parameter" );

            iresult = -1;
            break;
        }

        // 2.创建连接服务端的套接字
        iserversocket = socket( af_inet,     // ipv4 协议
                                sock_stream, // tcp  套接字协议类型
                                0 );         // 默认协议，通常设置为零(0)
        if ( 0 > iserversocket )
        {
            debug_output( "create socket is failed" );

            iresult = -2;
            break;
        }

        // 3.为了调用 connect 函数不阻塞，设置连接服务端的套接字为非阻塞模式
        ivalue = 1; //
        iresult = ioctl( iserversocket, // 服务端收发套接字
                         fionbio,       // 设置或清除非阻塞i/o标志
                         &ivalue );     // 零(0) - 清除，非零(0) - 设置
        if ( 0 > iresult )
        {
            debug_output_para( "call ioctl to set i/o asynchronization is failed, return %d",
                               iresult );

            iresult = -3;
            break;
        }

        sserveraddr.sin_family = af_inet;
        inet_pton( af_inet,
                   m_caserverip,
                   &sserveraddr.sin_addr );
        sserveraddr.sin_port = htons( m_usserverport );

        // 4.连接服务端
        iresult = connect( iserversocket,
                           (sockaddr*)&sserveraddr,
                           sizeof( sserveraddr ) );
        // 调用 connect 函数，正常情况下，因为 tcp 三次握手需要一些时间，
        // 而非阻塞调用只要不能立即完成就会返回错误，所以这里会返回 einprogress ，
        // 表示在建立连接但还没有完成。
        if ( 0 != iresult ) // 成功则返回零(0)
        {
            // 内核中对 connect 有超时限制是 75 秒，为了加快反应速度此处设为750毫秒。
            // 注：无论连接与否，都会返回可写，除非有错误发生，这里仅是缩短等待连接的时间而已。
            iresult = wait_rw_able( iserversocket,
                                    false,     // 是否可写
                                    750000  ); // 750毫秒
            if ( 0 != iresult )
            {
                debug_output( "can't write in asynchronization" );

                iresult = -4;
                break;
            }

            if ( 0 > getsockopt( iserversocket,
                                 sol_socket,
                                 so_error,
                                 &iso_error,
                                 &so_error_len ) )
            {
                debug_output( "call getsockopt is failed" );

                iresult = -5;
                break;
            }

            // 为零(0)才说明连接成功
            if ( 0 != iso_error )
            {
                debug_output( "call connect is failed" );

                iresult = -6;
                break;
            }
        }

        // 5.调用 connect 函数连接服务端成功，再设置套接字为阻塞模式(便于管理)
        ivalue = 0;
        iresult = ioctl( iserversocket, // 服务端收发套接字
                         fionbio,       // 设置或清除非阻塞i/o标志
                         &ivalue );     // 零(0) - 清除，非零(0) - 设置
        if ( 0 > iresult )
        {
            debug_output_para( "call ioctl to set i/o synchronization is failed, return %d",
                               iresult );

            iresult = -7;
            break;
        }

        // 6.发送协议数据
        iresult = send( iserversocket,
                        (const char*)pucsrbuffer,
                        strlen( (const char*)pucsrbuffer ),
                        0 );
        // 发送异常则停止收发
        if ( iresult != (int)strlen( (const char*)pucsrbuffer ) )
        {
            debug_output( "call send is failed" );

            iresult = -8;
            break;
        }

        // 7.判断是否可读 - 即服务端是否返回数据
        iresult = wait_rw_able( iserversocket, // 服务端收发套接字
                                true,          // 是否可读
                                750000  );     // 750毫秒
        if ( 0 != iresult )
        {
            debug_output( "waitting for recevie data has time out" );

            iresult = -9;
            break;
        }

        // 清零(0)，方便调用者计算收到的通讯协议数据长度
        memset( pucsrbuffer, 0, usbufferlen );
        do
        {
            // 8.从客户端接收数据
            iresult = recv( iserversocket,                        // 服务端收发套接字
                            pucsrbuffer + usrealreceiveddata,     // 存放数据的缓冲区地址
                            usbufferlen - usrealreceiveddata - 1, // 每次读出的字节
                            0 );                                  // 默认为零(0)，无特殊要求
            // 返回负数为出错了，直接跳出不再等待尝试接收新数据
            if ( 0 > iresult )
            {
                debug_output_para( "call recv is failed, return %d", iresult );

                iresult = -10;
                break;
            }

              // 接收数据时网络中断就会返回零(0)
              if ( 0 == iresult )
              {
                  break;
              }

            usrealreceiveddata += iresult;

            // 传出参数所指缓冲区空间不足矣放下全部应签数据
            if ( usbufferlen <= usrealreceiveddata )
            {
                debug_output( "pucsrbuffer is not superfluous space" );

                iresult = -11;
                break;
            }

        }while( 0 == wait_rw_able( iserversocket,
                                   true,        // 是否可读
                                   750000  ) ); // 750毫秒

        // 收数据时出错了，则直接跳出返回
        if ( 0 > iresult )
        {
            break;
        }

        // 执行至此发收通讯数据完毕
        iresult = 0;
        break;

    }while( 0 );

    // 套接字创建成功，则要释放资源
    if ( -1 != iserversocket )
    {
        close( iserversocket );
    }

    return iresult;
}