Programming

$ ulimit -aS
time(seconds)        unlimited
file(blocks)         unlimited
data(kb)             unlimited
stack(kb)            8192
coredump(blocks)     0
memory(kb)           unlimited
locked memory(kb)    64
process              4096
nofiles              1024
vmemory(kb)          unlimited
locks                unlimited

$  ulimit -aH
time(seconds)        unlimited
file(blocks)         unlimited
data(kb)             unlimited
stack(kb)            unlimited
coredump(blocks)     0
memory(kb)           unlimited
locked memory(kb)    64
process              4096
nofiles              1024
vmemory(kb)          unlimited
locks                unlimited

socket = socket( ... );
while ( 1 ) {
        /* Wait until messages come. */
        Pthread_mutex_lock( &node->mutex );
        while ( QSize == 0 ) {
            Pthread_cond_wait( &node->isEmpty, &node->mutex );
             ....
            if ( Qsize == 0 )
                continue;
            break;
        }
         data = QPop( ... );
        Pthread_cond_signal( &node->isFull );
        Pthread_mutex_unlock( &node->mutex );

        Writen( sockfd, data, strlen( data ) );
}

void Client_Pend ( ... ) {
        /* Blocking if the queue is full. */
        Pthread_mutex_lock( &node->mutex );
        while ( MAX_SIZE <= qSize ) {
            Pthread_cond_wait( &node->isFull, &node->mutex );
            if ( MAX_SIZE <= qSize )
                continue;   /* If the Queue is full, then blocking. */
            break;
        }
        .....
        Insert data into the queue
    
        /* Let the consumer read the inserted item. */
        Pthread_cond_signal( &node->isEmpty );
        Pthread_mutex_unlock( &node->mutex );
}

void Server () {
    ssize_t n;
    int i, maxi, maxfd, listenfd, connfd, sockfd;
    int nready, client[ FD_SETSIZE ];
    fd_set rset, allset;
    char buf[ TCP_MAXLINE ];
    struct sockaddr_in cliaddr, srvAddr;
    socklen_t clilen;

    if ( ( listenfd = Socket( AF_INET, SOCK_STREAM, 0) ) == -1 )
        return; /* Fail to create a socket. */
    i = 1;
    Setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof( int ) );  /* Reuse the socket. */

    /* Initiate server's address. */
    bzero( &srvAddr, sizeof( srvAddr ) );
    srvAddr.sin_family      = AF_INET;
    srvAddr.sin_addr.s_addr = htonl( INADDR_ANY );
    srvAddr.sin_port        = htons( TCP_PORT );

    if ( Bind( listenfd, ( struct sockaddr* )&srvAddr, sizeof( srvAddr ) ) == -1 )
        return; /* Fail to bind the socket. */
    if ( Listen( listenfd, TCP_MAX_PENGING ) == -1 )
        return; /* Fail to listen to the socket. */

    /* Initiate select. */
    maxfd = listenfd;   /* Initialize. */
    maxi  = -1;         /* Index into client[] array. */
    for ( i = 0; i < FD_SETSIZE; client[ i ] = -1, i++ );   /* -1 indicates available entry. */
    FD_ZERO( &allset );
    FD_SET( listenfd, &allset );

    for ( ; ; ) {
        rset = allset;      /* Structure assignment. */
        nready = Select( maxfd + 1, &rset, NULL, NULL, NULL );
        if ( FD_ISSET( listenfd, &rset ) ) {    /* New client connection. */
            clilen = sizeof( cliaddr );
            if ( ( connfd = Accept( listenfd, ( struct sockaddr* )&cliaddr, &clilen ) ) == -1 )
                continue;

            for ( i = 0; i < FD_SETSIZE ; i++ )
                if ( client[ i ] < 0 ) {
                    client[ i ] = connfd; /* save descriptor. */
                    break;
                }

            if ( i == FD_SETSIZE ) 
                return;

            FD_SET( connfd, &allset );              /* Add new descriptor to set. */
            if ( connfd > maxfd ) maxfd = connfd;   /* For select. */
            if ( i > maxi ) maxi = i;               /* Max index in client[] array. */
            if ( --nready <= 0 ) continue;          /* No more readable descriptors. */
        }

        /* Check all clients for data. */
        for ( i = 0; i <= maxi ; i++ ) {
            if ( ( sockfd = client[ i ] ) < 0 )
                continue;
            if ( FD_ISSET( sockfd, &rset ) ) {
                if ( readable_timeo( sockfd, 1 ) <= 0 ) {
                    sprintf( returnBuf, "%s(%d) -> Unable read!");
                } else if ( ( n = Readline( sockfd, buf, TCP_MAXLINE ) ) <= 0 ) {  /* For connection closed by client. */
                        fprintf( stderr, "[SERVER] Client closed!" ); This statement always true after a connection from client. Is it no data from client since I used cond_wait()?
                    Close( sockfd );
                    FD_CLR( sockfd, &allset );
                    client[ i ] = -1;
                } else {
                    PacketHandler( sockfd, buf, n );
                }
                if ( --nready <= 0 )  break;    /* No more readable descriptors. */
            }
        }
    }
}