ASockLib

ASockLib

Was

Ein einfaches und unkompliziertes plattformübergreifendes C++-Socket-Server/Client-Framework, das sich besonders gut für die Handhabung von TCP-Headern fester Länge und Textkörpern variabler Länge eignet. Natürlich werden auch UDP und Domain-Socket unterstützt.

• Das Framework ruft den vom Benutzer angegebenen Rückruf auf.
• Bei TCP wird die Gesamtgröße der Benutzerdaten über einen Rückruf an das Framework übergeben, und das Framework führt die TCP-Pufferung automatisch durch.
• Keine wiederholten Sendeaufrufe, bis alle gesendet wurden. Wenn send WSAEWOULDBLOCK / EWOULDBLOCK / EAGAIN zurückgibt, wird es der Warteschlange hinzugefügt und später gesendet.
• Linux, OS X: TCP, UDP, Domain-Socket mit Epoll und KQueue.
• Windows: TCP, UDP mit Winsock.

Abhängigkeit: CumBuffer.

Verwendung

TCP-Echo-Server

 // See the sample folder for all examples. 
// this is an inheritance usage. 
// you can find composition usage and udp, domain socket example too. 

 // msg_defines.h

// user specific data
typedef struct _ST_MY_CHAT_HEADER_
{
    char msg_len[ 10 + 1 ];

} ST_MY_HEADER ;
# define CHAT_HEADER_SIZE sizeof (ST_MY_HEADER)

 // echo_server.cpp

# include < iostream >
# include < cassert >
# include < csignal >

# include " ASock.hpp "
# include " ../../msg_defines.h "

class EchoServer : public asock ::ASock
{
  public:
    EchoServer (){this_instance_ = this ; }
# if defined __APPLE__ || defined __linux__ 
    static void sigint_handler ( int signo);
# endif
  private:
    static  EchoServer* this_instance_ ;
    size_t  OnCalculateDataLen (asock::Context* context_ptr);
    bool    OnRecvedCompleteData (asock::Context* context_ptr, char * data_ptr, size_t len ) ;
    void    OnClientConnected (asock::Context* context_ptr) ; 
    void    OnClientDisconnected (asock::Context* context_ptr) ; 
};

EchoServer* EchoServer::this_instance_ = nullptr ;

size_t EchoServer::OnCalculateDataLen (asock::Context* context_ptr)
{
    // ---------------------------------------------------
    // user specific : 
    // calculate your complete packet length here using buffer data.
    // ---------------------------------------------------
    if (context_ptr-> recv_buffer . GetCumulatedLen () < ( int )CHAT_HEADER_SIZE ) {
        return asock::MORE_TO_COME ; // more to come 
    }
    ST_MY_HEADER header ;
    context_ptr-> recv_buffer . PeekData (CHAT_HEADER_SIZE, ( char *)&header); 
    size_t supposed_total_len = std::atoi (header. msg_len ) + CHAT_HEADER_SIZE;
    assert (supposed_total_len<=context_ptr-> recv_buffer . GetCapacity ());
    return supposed_total_len ;
}

bool    EchoServer::OnRecvedCompleteData (asock::Context* context_ptr, 
                                         char * data_ptr, size_t len ) 
{
    // user specific : - your whole data has arrived.
    char packet[asock::DEFAULT_PACKET_SIZE];
    memcpy (&packet, data_ptr + CHAT_HEADER_SIZE, len - CHAT_HEADER_SIZE);
    packet[len - CHAT_HEADER_SIZE] = '  ' ;
    std::cout << " recved [ " << packet << " ] n " ;
    // this is echo server
    if (! SendData (context_ptr, data_ptr, len) ) {
        std::cerr << " [ " << __func__ << " - " <<__LINE__ << " ] error! " << GetLastErrMsg () << " n " ; 
        return false ;
    }
    return true ;
}

void EchoServer::OnClientConnected (asock::Context* context_ptr) 
{
    std::cout << " client connected : socket fd [ " << context_ptr-> socket << " ] n " ;
}

void EchoServer::OnClientDisconnected (asock::Context* context_ptr) 
{
    std::cout << " client disconnected : socket fd [ " << context_ptr-> socket << " ] n " ;
}

# if defined __APPLE__ || defined __linux__ 
void EchoServer::sigint_handler ( int signo)
{
    sigset_t sigset , oldset;
    sigfillset (& sigset );
    if ( sigprocmask (SIG_BLOCK, & sigset , &oldset) < 0 ) {
        std::cerr << " [ " << __func__ << " - " <<__LINE__ << " ] error! " << strerror (errno) << " n " ; 
    }
    std::cout << " Stop Server! n " ;
    this_instance_-> StopServer ();
}
# endif

int main ( int argc, char * argv[])
{
# if defined __APPLE__ || defined __linux__ 
    std::signal (SIGINT,EchoServer::sigint_handler);
# endif
    // max client is 100000, 
    // max message length is approximately 1024 bytes...
    EchoServer echoserver; 
    if (!echoserver. InitTcpServer ( " 127.0.0.1 " , 9990 , 1024 /* ,default=100000 */ )) {
        std::cerr << " [ " << __func__ << " - " <<__LINE__ << " ] error! " << echoserver. GetLastErrMsg () << " n " ; 
        return 1 ;
    }
    std::cout << " server started " << " n " ;
    while ( echoserver. IsServerRunning () ) {
		std::this_thread::sleep_for ( std::chrono::seconds ( 1 ));
    }
    std::cout << " server exit... n " ;
    return 0 ;
}

TCP-Echo-Client

# include < iostream >
# include < string >
# include < cstdlib >
# include < stdio.h >
# include < cassert >
# include " ASock.hpp "
# include " ../../msg_defines.h "

class EchoClient : public asock ::ASock
{
  private:
    size_t  OnCalculateDataLen (asock::Context* context_ptr); 
    bool    OnRecvedCompleteData (asock::Context* context_ptr, 
                                 char * data_ptr, size_t len); 
    void    OnDisconnectedFromServer () ; 
};

size_t EchoClient::OnCalculateDataLen (asock::Context* context_ptr)
{
    // user specific : calculate your complete packet length 
    if ( context_ptr-> recv_buffer . GetCumulatedLen () < ( int )CHAT_HEADER_SIZE ) {
        return asock::MORE_TO_COME ; // more to come 
    }
    ST_MY_HEADER header ;
    context_ptr-> recv_buffer . PeekData (CHAT_HEADER_SIZE, ( char *)&header);  
    size_t supposed_total_len = std::atoi (header. msg_len ) + CHAT_HEADER_SIZE;
    assert (supposed_total_len<=context_ptr-> recv_buffer . GetCapacity ());
    return supposed_total_len ;
}

bool EchoClient:: OnRecvedCompleteData(asock::Context* context_ptr, 
                                       char * data_ptr, size_t len) 
{
    // user specific : - your whole data has arrived.
    char packet[asock::DEFAULT_PACKET_SIZE];
    memcpy (&packet, data_ptr + CHAT_HEADER_SIZE, len - CHAT_HEADER_SIZE);
    packet[len - CHAT_HEADER_SIZE] = '  ' ;
    std::cout << " server response [ " << packet << " ] n " ;
    return true ;
}

void EchoClient::OnDisconnectedFromServer () 
{
    std::cout << " * server disconnected ! n " ;
    exit ( 1 );
}

int main ( int argc, char * argv[])
{
    EchoClient client;
    // connect timeout is 10 secs.
    // max message length is approximately 1024 bytes...
    if (!client. InitTcpClient ( " 127.0.0.1 " , 9990 , 10 , 1024 ) ) {
        std::cerr << " [ " << __func__ << " - " <<__LINE__ 
                  << " ] error! " << client. GetLastErrMsg () << " n " ; 
        return 1 ;
    }
    std::string user_msg  { " " }; 
    while ( client. IsConnected () ) {
        std::cin. clear ();
        getline (std::cin, user_msg); 
        int msg_len = user_msg. length ();
        if (msg_len> 0 ) {
            ST_MY_HEADER header;
            snprintf (header. msg_len , sizeof (header. msg_len ), " %d " , ( int )msg_len );
            char * complete_packet_data = new  char [ 1024 ] ;
            memcpy (complete_packet_data, ( char *)&header,  sizeof (ST_MY_HEADER));
            memcpy (complete_packet_data+ sizeof (ST_MY_HEADER), user_msg. c_str (),user_msg. length () );
            if (! client. SendToServer (complete_packet_data , sizeof (ST_MY_HEADER)+  user_msg. length ()) ) {
                std::cerr << " [ " << __func__ << " - " <<__LINE__ << " ] error! " << client. GetLastErrMsg () << " n " ; 
                delete [] complete_packet_data;
                return 1 ;
            }
            delete [] complete_packet_data;
        }
    } // while
    return 0 ;
}

kompilieren

 git clone https://github.com/jeremyko/ASockLib.git
cd ASockLib
git submodule init
git submodule update
mkdir build; cd build;  cmake ..
make  or msbuild(visual studio)