Socket 封装类

//
// File:   client.h
// Author: root
//
// Created on February 19, 2008, 9:36 AM
//

#ifndef _CLIENT_H
#define    _CLIENT_H

#include <sys/socket.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdio.h>
#include <string>
#include <iostream>

using namespace std;

class client{
public:
    enum {BUFFERSIZE = 1024};
    client(int fd,struct sockaddr_in sinaddr,int timeout);
    ~client();
    bool update();
    string _value;
private:
    int _fd;
    int _timeout;
    char *buffer;
};


#endif    /* _CLIENT_H */

#include "client.h"
client::client(int fd, sockaddr_in sinaddr, int timeout){
    _fd = fd;
    _timeout = timeout;
    fcntl( _fd, F_SETFL, fcntl( _fd, F_GETFL ) | O_NONBLOCK );
    buffer = NULL;
    buffer = new char[BUFFERSIZE];
}
client::~client(){
    close(_fd);
    delete buffer;
    buffer = NULL;
}

bool client::update(){
    fd_set fdClient;
   
    FD_ZERO( &fdClient );
    FD_SET( _fd, &fdClient );
   
    struct timeval tv;
   
    tv.tv_sec = _timeout;
    tv.tv_usec = 0;
   
   
    if( select( _fd + 1, &fdClient, NULL, NULL, &tv ) == -1 ) {
        return true;
    }
   
    if( FD_ISSET( _fd, &fdClient ) ) {
        memset( buffer, 0, sizeof( char ) * BUFFERSIZE );
       
        int c = recv( _fd, buffer, BUFFERSIZE, 0 );
       
        if( c == -1 && errno != EWOULDBLOCK ) {
            if( errno != ECONNRESET )
                cout << "peer reset the connection" << endl;
            return true;
        }
        else if( c == 0 )
            return true;
        else if( c > 0 ) {
            _value = string( buffer, c );
            cout << _value << endl;
        }
        else {
            return true;
        }
    }
    return false;
}
//
// File:   server.h
// Author: root
//
// Created on February 19, 2008, 9:34 AM
//

#ifndef _SERVER_H
#define    _SERVER_H

#include <vector>
#include <iostream>
#include <string>

#include "client.h"

using namespace std;

class server{
public:
    server(int port);
    ~server();
    bool update(bool block);
    vector<client *> clients;
    enum {MAXCLIENTS = 11};
    void kill(){
        _kill = true;
    }
private:
    int _fd;
    bool _kill;
};

#endif    /* _SERVER_H */

#include "server.h"
server::server(int port = 10000){
    _kill = false;
    struct sockaddr_in sin;
   
    memset( &sin, 0, sizeof( sin ) );
   
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
   
    sin.sin_port = htons(port);
    _fd = socket( PF_INET, SOCK_STREAM, 0 );
   
    int optval = 1;
   
    setsockopt( _fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof( int ) );
    if( bind( _fd, (struct sockaddr *)&sin, sizeof( sin ) ) == -1 ) {
        cout << "bind error" << endl;
    }
   
    // listen, queue length 8
   
    if( listen( _fd, 8 ) == -1 ) {
        cout << "listen error" << endl;
        //exit( 1 );
    }
}
server::~server(){
    close(_fd);
   
    for( vector<client *> :: iterator i = clients.begin( ); i != clients.end( ); i++ )
        delete *i;
   
    clients.clear( );
   
}

bool server::update(bool block){
    if( clients.size( ) < MAXCLIENTS ) {
        fd_set fdServer;
       
        FD_ZERO( &fdServer );
        FD_SET( _fd, &fdServer );
       
        struct timeval tv;
       
        if( block ) {
            // block for 100 ms to keep from eating up all cpu time
           
            tv.tv_sec = 0;
            tv.tv_usec = 100000;
        }
        else {
            tv.tv_sec = 0;
            tv.tv_usec = 0;
        }
       
        if( select( _fd + 1, &fdServer, NULL, NULL, &tv ) == -1 )
           
        {
            FD_ZERO( &fdServer );
           
            usleep( 100 );
        }
       
        if( FD_ISSET( _fd, &fdServer ) ) {
            struct sockaddr_in adrFrom;
           
            int iAddrLen = sizeof( adrFrom );
           
            int sckClient;
           
            if( ( sckClient = accept( _fd, (struct sockaddr *)&adrFrom, (socklen_t *)&iAddrLen ) ) == -1 )
                cout << "accept error" << endl;
            else{
                clients.push_back( new client( sckClient, adrFrom, 0) );
                cout << "clients comes" << endl;
            }
        }
    }
    else {
        // maximum connections reached
       
        usleep( 100 );
    }
   
    // process
   
    for( vector<client *> :: iterator i = clients.begin( ); i != clients.end( ); ) {
        if( (*i)->update( ) ) {
            delete *i;
           
            i = clients.erase( i );
            cout << "clients exit" << endl;
        }
        else
            i++;
    }
    return _kill;
}