要停止服务器->如何验证线程是否已停止-> pthread

Question

MAIN task -> to STOP Server as soon as client has disconnected.

Overview of a problem: I have very large application and within that application, I have implemented a small server code which accept connection and receive packets from client.
All I wanted is As long as client is connected and is sending packets, the server should not disconnect but as soon as client has disconnected , the server should also stop running.

To Achieve this I have created a seperate thread that receive packets from client and this thread automatically terminates as soon as client disconnect istself from server.

Now my next target is to find out if the detached thread has finished and if yes then close the "accept socket" ( from below code its nsk variable). For this to achieve how would I know that detached process has finished? I havn't got much information from net. secondly, someone suggested to use pthreadkill but for that how would I find pid ?

Can someone please bail me out .
Thanks

   static int sco_listen()
{
printf(" we are in sco_listen_function\n" );
    struct sockaddr_sco addr;
    struct sco_conninfo conn;
    socklen_t optlen;
    int sk, nsk;
    char ba[18];
    int *new_sock;

    /* Create socket */
    sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
    if (sk < 0) {
        syslog(LOG_ERR, "Can't create socket: %s (%d)",
                            strerror(errno), errno);
        exit(1);
    }

    /* Bind to local address */
    memset(&addr, 0, sizeof(addr));
    addr.sco_family = AF_BLUETOOTH;
    bacpy(&addr.sco_bdaddr, &bdaddr);

    if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        syslog(LOG_ERR, "Can't bind socket: %s (%d)",
                            strerror(errno), errno);
        goto error;
    }

    /* Listen for connections */
    if (listen(sk, 10)) {
        syslog(LOG_ERR,"Can not listen on the socket: %s (%d)",
                            strerror(errno), errno);
        goto error;
    }

    syslog(LOG_INFO,"Waiting for connection ...");
    while (1) 
    {
        memset(&addr, 0, sizeof(addr));
        optlen = sizeof(addr);

        nsk = accept(sk, (struct sockaddr *) &addr, &optlen);
        if (nsk < 0) 
        {
            syslog(LOG_ERR,"Accept failed: %s (%d)",
                            strerror(errno), errno);
            goto error;
        }
        if( fcntl( nsk, F_SETFL, O_NONBLOCK ) < 0 )
        {
         printf(" failed to set non blocking ...\n");
         close( nsk );
         goto error;

        }

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

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

        ba2str(&addr.sco_bdaddr, ba);
        syslog(LOG_INFO, "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 = malloc(1);
        *new_sock = nsk;

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

        }

        // HERE CHECK IF SNIFFER_THREAD IS RUNNING OR NOT. 
//IF SINIFFER THREAD IS NOT RUNNING THEN CLOSE NSK?
// ANd that will terminate the server?
        puts (" handler assigned");

    }

    return 0 ;

error:
    close(sk);
    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");
 }

 printf(" before memeory freee\n");
 free( socket_desc );

 return 0;

}

Answer 1

Put the entire server functionality into a single thread, both the accept() and the recv() loop. The accept() will then only ever be called once, so can only return once, so only one connection will ever be accepted. When the client disconnects, (ie. recv() returns 0), clean up by closing the listening socket and terminating the thread. If the connection half-closes, (eg. power fail at client), the thread may hang around forever, stuck on the recv(), but hey, who cares? You could use KEEPALIVE to eventually close the sockets and terminate the thread, but there's no real need for it - it's code and stack will eventually get paged out, and it's orphaned and lost in space, (mehh..sob..).

Oh - and get rid of the NON_BLOCKING. I don't understand why you set it in the first place? You're soaking up one core for next-to-nothing, except in the case of a half-close, in which case you're soaking up one core for absolutely nothing.