使用计时器来关闭服务器以及连接

Question

的问题：
1）要关闭服务器，请在10秒后说如果请求接受连接不是来自客户端。

2）如果没有收到来自客户端的数据包说10秒，也断开连接并关闭服务器。

概述：我有一个应用程序可以打开RFcomm服务器连接，DUT（被测设备）连接到它。一旦建立了与Rfcomm的连接，应用程序就会创建SCO服务器并监听sco连接。如果在RFcomm或SCO端没有收到连接请求，我想要的就是关闭服务器。如果DUT未能以10秒的速度发送任何数据包，也会关闭连接和服务器。

正如论坛成员指出我使用KEEPALIVE但我的应用程序崩溃，因为我认为KEEPALIVE不适用于SOL_SCO。

以下是示例代码

int ScoServerListen(void( *handler )( int sco_listen_sock ) )
{
    printf(" start sco_listen connection\n" );
    struct sockaddr_sco addr;
    struct sco_conninfo conn;
    socklen_t optlen;
    int sco_listen_sock, sco_accept_sock;
    char ba[18];
    int *new_sock;

    // Create socket //
    sco_listen_sock = socket( PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO );
    if( sco_listen_sock < 0 )
    {
        printf( "Can't create socket: %s (%d)\n", strerror( errno ), errno );
        exit(1);
    }
    printf(" start sco_listen connection .. socket created....  yeeee \n" );
    // Bind to local address //
    memset( &addr, 0, sizeof( addr ) );
    addr.sco_family = AF_BLUETOOTH;
    bacpy( &addr.sco_bdaddr, &bdaddr );

    if( bind( sco_listen_sock, ( struct sockaddr * ) &addr, sizeof( addr ) ) < 0)
    {
        printf("Can't bind socket: %s (%d)\n", strerror(errno), errno );
        goto error;
    }
    printf(" start sco_listen connection .. bind done....  yeeee \n" );
    // Listen for connections //
    if( listen( sco_listen_sock, no_of_connect_listen ) )
    {
        printf("Can not listen on the socket: %s (%d)\n", strerror( errno ), errno );
        goto error;
    }
    std::cout << "Waiting for connection ...\n";

    while( 1 )
    {
        memset(&addr, 0, sizeof(addr));
        optlen = sizeof(addr);
        sco_accept_sock = accept( sco_listen_sock, ( struct sockaddr * ) &addr, &optlen );
        if( sco_accept_sock < 0 )
        {
            printf("Accept for SCO failed: %s (%d)\n", strerror( errno ), errno );
            goto error;
        }

        //using socketoption 
        //Get connection information //
        memset( &conn, 0, sizeof( conn ) );
        optlen = sizeof( conn );

        if( getsockopt( sco_accept_sock, SOL_SCO, SCO_CONNINFO, &conn, &optlen ) < 0)
        {
            printf( "Can't get SCO connection information: %s (%d)\n", strerror(errno), errno);
            close( sco_accept_sock );
            goto error;
        }

        ba2str( &addr.sco_bdaddr, ba );
        printf( "Connect from %s [handle %d, class 0x%02x%02x%02x]",ba, conn.hci_handle, conn.dev_class[2], conn.dev_class[1], conn.dev_class[0]);
        pthread_t sniffer_thread;
        new_sock = (int*)malloc(1);
        *new_sock = sco_accept_sock;

        if( pthread_create( &sniffer_thread, NULL, connection_handler, (void*)new_sock )< 0 )
        {
            perror(" could not create thread");
            return 1;

        }
        ( void )pthread_join( sniffer_thread, NULL );
        puts (" handler assigned");
        close( sco_accept_sock );
        close( sco_listen_sock );

        printf( "Disconnect");
        //close( sco_listen_sock );
        exit(0);
    }

    return 0;

error:
    close( sco_listen_sock );
    exit( 1 );
}


void *connection_handler( void *socket_desc)
    {
      // get socket descriptor
     int sock = *(int*)socket_desc;

     int read_size;

     char*message, message_client[ 200 ];

      //receive messgae from client
     while( read_size = recv( sock, message_client, 200, 0 ) > 0 )
     {
       printf(" very good\n");
     }
     if( read_size == 0 )
     {
      printf("clinet disconnected \n");
      fflush( stdout);
     }
     else if( read_size == -1 )
     {
      printf("received failed \n");
      perror( " recv fialed");
     }
     free( socket_desc );
     int rel = 200;
     pthread_exit(&rel);
     return 0;

    }

int RfcommListen( uint8_t channel )
{
    printf(" rfcomm --> we are at that start\n");
    int rfcomm_sock;                        // socket descriptor for local listener
    int rfcomm_client;                      // socket descriptor for remote client
    socklen_t len = sizeof(struct sockaddr_rc);

    struct sockaddr_rc remote;      // local rfcomm socket address
    struct sockaddr_rc local;       // remote rfcomm socket address
    char pszremote[20]={ 0 };

    // initialize a bluetooth socket
    rfcomm_sock = socket( PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM );
    if( rfcomm_sock < 0 )
    {
        printf( "RFComm socket Error \n" );
        return  BtSocketError;
    }

    memset(&local, 0, sizeof(local));
    local.rc_family = AF_BLUETOOTH;
    local.rc_bdaddr = *BDADDR_ANY_INITIALIZER;
    local.rc_channel = channel;

    // bind the socket to a bluetooth device
    if( bind( rfcomm_sock, ( struct sockaddr * )&local, sizeof( local ) ) < 0 )
    {
        close( rfcomm_sock );
        return  BtSocketError;
    }

    printf(" rfcomm --> bind successful\n");

    // set the listening queue length
    if( listen( rfcomm_sock, 1 ) < 0 )
    {
        printf(" we are in SCO Configure where listen failed  \n");
        return  BtSocketError;
    }

    printf("accepting connections on channel: %d\n", channel);

    // accept incoming connections; this is a blocking call
    rfcomm_client = accept( rfcomm_sock, (struct sockaddr *)&remote, &len );

    ba2str( &remote.rc_bdaddr, pszremote );

    printf("received connection from: %s\n", pszremote);
    // turn off blocking
    if ( fcntl( rfcomm_client, F_SETFL, O_NONBLOCK ) < 0 )
    {
        printf("Failed non blocking\n");
        return  BtSocketError;
    }
    // return the client socket descriptor
    return rfcomm_client;
}