void Communication::handle_receive_message(QByteArray &data)
{
QDataStream stream(&data, QIODevice::ReadOnly);
stream.setVersion(QDataStream::Qt_5_0);
quint32 command;
QString nickname;
QString message;
stream >> command >> nickname >> message;
switch (command) {
case IM::Command::Message:
emit received_message(nickname, message);
break;
case IM::Command::KeepAlive:
emit received_keepalive(nickname);
break;
case IM::Command::CallOutEvent:
case IM::Command::HostEvent:
// take message as "Event" (as both messages are the same format)
emit received_event(message);
break;
default:
qDebug() << "unknown message received";
break;
}
}
/**
* The mane loop, manage daemons
*
* @return The return value for `main`
*/
static int mane_loop(void)
{
struct { long mtype; char* mtext; } mqueue_buf;
struct msqid_ds mqueue_info;
ssize_t msg_size;
int r;
if (msgctl(mqueue_id, IPC_STAT, &mqueue_info) < 0)
return perror(*argv), 1;
mqueue_buf.mtype = 0;
mqueue_buf.mtext = malloc(mqueue_info.msg_qbytes * sizeof(char));
if (mqueue_buf.mtext == NULL)
return perror(*argv), 1;
for (;;)
{
msg_size = msgrcv(mqueue_id, &mqueue_buf, mqueue_info.msg_qbytes, 1, 0);
if ((msg_size < 0) && (errno != EINTR))
return perror(*argv), free(mqueue_buf.mtext), 1;
else if (msg_size < 0)
r = reap();
else
r = received_message(mqueue_buf.mtext, (size_t)msg_size / sizeof(char));
if (r >= 0)
return free(mqueue_buf.mtext), r;
}
}
void Communication::handle_received_datagramm(QByteArray & datagram)
{
QDataStream stream(&datagram, QIODevice::ReadOnly);
quint32 cmd;
QString name;
stream.setVersion(QDataStream::Qt_5_0);
stream >> cmd;
stream >> name;
switch (cmd)
{
case Command::KeepAlive:
emit received_keep_alive(name);
break;
case Command::Message:
{
QString message_data;
stream >> message_data;
emit received_message(name, message_data);
}
break;
case Command::HostEvent:
{
QString message_data;
stream >> message_data;
emit received_host_event(name, message_data);
}
break;
}
qDebug() << "Received: " << cmd << name;
}
void peer_connection::read_loop()
{
ilog( "read loop" );
try
{
auto one_time_key = fc::ecc::private_key::generate();
fc::ecc::public_key pub = one_time_key.get_public_key();
auto s = pub.serialize();
_socket.write( (char*)&s, sizeof(s) );
fc::ecc::public_key_data remote_one_time_key;
_socket.read( (char*)&remote_one_time_key, sizeof(remote_one_time_key) );
_shared_secret = one_time_key.get_shared_secret( remote_one_time_key );
elog( "${ss}", ("ss",_shared_secret) );
if( _send_queue.size() && !_send_queue_complete.valid() )
_send_queue_complete = fc::async( [=](){ process_send_queue(); } );
message next_message;
next_message.data.resize( BTS_NETWORK_MAX_MESSAGE_SIZE );
while( !_read_loop.canceled() )
{
// read a message
_socket.read( (char*)&next_message.size, sizeof(next_message.size) );
wlog( " read message of size ${s} ", ("s", next_message.size) );
if( next_message.size > BTS_NETWORK_MAX_MESSAGE_SIZE )
{
send_message( goodbye_message( message_too_large() ) );
_socket.close();
FC_CAPTURE_AND_THROW( message_too_large, (next_message.size) );
}
_socket.read( (char*)&next_message.type, sizeof(next_message.type) );
wlog( " read message of size ${s} type ${t}", ("s", next_message.size)("t",int(next_message.type)) );
_socket.read( next_message.data.data(), next_message.size );
wlog( "read body of message" );
received_message( shared_from_this(), next_message );
}
}
catch ( const fc::exception& e )
{
ilog( "closed: ${e}", ("e", e.to_detail_string()) );
connection_closed( shared_from_this(), e );
return;
}
ilog( "closed!" );
connection_closed( shared_from_this(), optional<fc::exception>() );
}
void IdentServerConnection::worker_main()
{
try
{
std::string input_message;
while (true)
{
std::unique_lock<std::mutex> lock(mutex);
if (stop_flag)
break;
char buffer[1024];
int bytes_read = connection.read(buffer, 1024);
if (bytes_read != -1)
{
lock.unlock();
int start = 0;
for (int i = 0; i < bytes_read; i++)
{
if (buffer[i] == '\n')
{
input_message.append(buffer, i - start);
if (!input_message.empty() && input_message[input_message.length() - 1] == '\r')
input_message.erase(input_message.begin() + (input_message.length() - 1));
if (!received_message(input_message))
return;
input_message.clear();
start = i + 1;
}
}
input_message.append(buffer + start, bytes_read - start);
if (input_message.length() > 1024)
throw clan::Exception("Invalid request");
}
else
{
clan::NetworkEvent *events[] = { &connection };
if (!change_event.wait(lock, 1, events, 60 * 1000))
return;
}
}
}
catch (clan::Exception &)
{
}
}
