Download do tubus - Download do código -fonte tubus

tubus

Outras categorias

v1.2.1

Baixar

Readme

Este repositório contém a biblioteca C ++ Tubus de plataforma cruzada, que implementa um protocolo de transporte de streaming com base no UDP . O protocolo foi originalmente desenvolvido como parte da utilidade do buraco de minhoca. Pode ser usado nos casos em que o uso do TCP é difícil, por exemplo, para aplicativos que exibem o NAT. Opcionalmente, para aumentar a segurança da conexão, os pacotes tubus podem ser ofuscados por uma chave pré-compartilhada.

Para a conveniência do desenvolvimento de aplicativos baseados no boost::asio , são oferecidos primitivos do tipo tubus::socket e tubus::acceptor . O tubus::socket primitivo implementa os conceitos assíncreados , assíncirados , fluxo , syncreadstream e syncwriteStream , para que possa ser usado como a camada inferior dos boost::asio::ssl::stream .

Essencial

Interface do tubo.

 namespace tubus {
...
struct channel
{
    virtual ~channel () noexcept ( true ) {}
    virtual void close () noexcept ( true ) = 0;
    virtual void open ( const endpoint& local) noexcept ( false ) = 0;
    virtual void connect ( const endpoint& remote, const callback& handle) noexcept ( true ) = 0;
    virtual void accept ( const endpoint& remote, const callback& handle) noexcept ( true ) = 0;
    virtual void read ( const mutable_buffer& buffer, const io_callback& handle) noexcept ( true ) = 0;
    virtual void write ( const const_buffer& buffer, const io_callback& handle) noexcept ( true ) = 0;
    virtual void shutdown ( const callback& handle) noexcept ( true ) = 0;
    virtual size_t writable () const noexcept ( true ) = 0;
    virtual size_t readable () const noexcept ( true ) = 0;
    virtual endpoint host () const noexcept ( false ) = 0;
    virtual endpoint peer () const noexcept ( false ) = 0;
};
...
channel_ptr create_channel (boost::asio::io_context& io, uint64_t /* pre-shared key */ secret = 0 ) noexcept ( true );
}

Open - abre um canal no terminal especificado
Fechar - fecha o canal sem notificar o lado remoto, interrompe todas as operações assíncronas pendentes
desligamento - fecha o canal com a notificação do lado remoto, interrompe todas as operações assíncronas pendentes
aceitar - espera de forma assíncrona pela conexão do par especificado
Connect - inicia a conexão de forma assíncrona ao par especificado
Leia - Anexa a operação de leitura assíncrona, chamadas de volta quando o buffer passado está cheio ou ocorreu um erro
Escreva - anexa a operação de gravação assíncrona, chamadas de volta quando o buffer passado é transmitido ou ocorreu um erro
gravável - retorna o número de bytes que podem ser transmitidos imediatamente
Legável - Retornos Número de bytes disponíveis para leitura
host - retorna terminal local do canal
par - retorna terminal remoto do canal

Exemplos

O consumidor de dados implementou usando tubus::channel .

# include < tubus/channel.h >
...
auto consumer = tubus::create_channel(io_service, key);
consumer-> open (local_endpoint);
consumer-> connect (remote_endpoint, [&]( const boost::system::error_code& error)
{
    ...
    tubus::mutable_buffer buffer (consumer-> readable ()); 
    
    // if the buffer is empty, the callback will be called when all previously
    // pended read operations are completed and more data can be read
    
    consumer-> read (buffer, [&]( const boost:: system ::error_code& error, size_t size)
    {
        ...
        consumer-> shutdown ();
    };
});

Produtor de dados implementado usando tubus::socket .

# include < tubus/socket.h >
...
tubus::socket producer (io_service, key);
producer.open(local_endpoint);
producer.async_accept(remote_endpoint, [&]( const boost::system::error_code& error)
{
    ...
    tubus::const_buffer buffer ( " hello, world! " );
    producer. async_write_some (buffer, [&]( const boost:: system ::error_code& error, size_t size)
    {
        ...
        producer. shutdown ();
    };
});

Servidor implementado usando tubus::acceptor (somente Linux ).

# include < tubus/acceptor.h >
...
tubus::acceptor server (io_service, key);
server.open(local_endpoint);

tubus::socket peer1 (io_service);
server.accept(peer1);

peer1.read_some(...);
peer1.write_some(...);

tubus::socket peer2 (io_service);
server.accept(peer2);

peer2.read_some(...);
peer2.write_some(...);

peer1.shutdown();
peer2.shutdown();

server.close();

Fluxo criptografado implementado usando boost::asio::ssl::stream e tubus::socket .

# include < boost/asio/ssl.hpp >
# include < tubus/socket.h >
...
boost::asio::ssl::stream<tubus::socket> client (tubus::socket(io_service, key), ssl_ctx);

client.lowest_layer().open(local_endpoint);
client.lowest_layer().connect(remote_endpoint);
client.handshake(boost::asio::ssl::stream_base::client);

boost::asio::read (client, ...);
boost::asio::write (client, ...);

client.shutdown();

Construir

Você pode baixar pacotes de pré -construção para plataformas Debian e Windows.

A biblioteca depende do boost . Para criar testes, o openssl é necessário.

 cd ~
git clone https://github.com/novemus/tubus.git
cd ~/tubus
cmake -B ./build [-DBOOST_ROOT=...] [-DBUILD_TESTING=ON [-DOPENSSL_ROOT_DIR=...]]
cmake --build ./build --config Release --target tubus_shared tubus_static [tubus_ut]
cmake --build ./build --target install

Variáveis de importação CMake .

tubus_use_shared_lib = ON - Importar Biblioteca Dynamic para o seu projeto CMake, pesquise uma biblioteca estática por padrão
Tubus_include_dir - diretório de arquivos de cabeçalho do tubo
tubus_library_dir - diretório de biblioteca tubus
tubus_dll - o caminho para o arquivo da biblioteca Tubus.dll
tubus_lib - o caminho para o arquivo de biblioteca Tubus static.lib, Tubus.lib, Libbtubus.A ou Libtubus.so

Colaboração

Relatar bugs e sugerir melhorias.

Licença

O Tubus é licenciado sob a licença Apache 2.0, o que significa que você está livre para obtê-lo e usá-lo para fins comerciais e não comerciais, desde que cumpra suas condições. Consulte o arquivo License.txt para obter mais detalhes.