bool Connection::send( const Connections& connections, Packet& packet,
const void* data, const uint64_t dataSize,
const bool isLocked )
{
if( connections.empty( ))
return true;
if( dataSize <= 8 ) // fits in existing packet
{
if( dataSize != 0 )
memcpy( (char*)(&packet) + packet.size-8, data, dataSize );
return send( connections, packet, isLocked );
}
const uint64_t headerSize = packet.size - 8;
const uint64_t size = headerSize + dataSize;
if( size > EQ_ASSEMBLE_THRESHOLD )
{
// OPT: lock the connection and use two send() to avoid big memcpy
packet.size = size;
bool success = true;
for( Connections::const_iterator i= connections.begin();
i<connections.end(); ++i )
{
ConnectionPtr connection = *i;
if( !isLocked )
connection->lockSend();
if( !connection->send( &packet, headerSize, true ) ||
!connection->send( data, dataSize, true ))
{
success = false;
}
if( !isLocked )
connection->unlockSend();
}
return success;
}
char* buffer = (char*)alloca( size );
memcpy( buffer, &packet, packet.size-8 );
memcpy( buffer + packet.size-8, data, dataSize );
((Packet*)buffer)->size = size;
bool success = true;
for( Connections::const_iterator i = connections.begin();
i < connections.end(); ++i )
{
ConnectionPtr connection = *i;
if( !connection->send( buffer, size, isLocked ))
success = false;
}
return success;
}
void P2PConnectionsWindow::refreshConnections()
{
Connections connections;
// Effettua una copia per evitare una lock durante il check
getConnections(connections);
wxWindowUpdateLocker windowLocker(m_connectionsCtrl);
uint32 connectionsCount = static_cast<uint32>(connections.size());
uint32 connectionsLimit = getConnectionsLimit();
bool pendingRefresh = false;
for(Connections::iterator i = connections.begin(); i != connections.end(); ++i)
{
if(i->second->getRemoved())
{
if(i->second->isElapsed() || (connectionsCount > connectionsLimit))
{
doRemoveConnection(i->first);
connectionsCount--;
}
else
{
markConnectionRemoved(i->first);
}
}
else
{
refreshConnectionItem(i->first);
}
}
}
void Block(const std::string& signalnamespace){
//matching namespace? don't block global (non-namespaced) signals
if(signalnamespace == this->signalnamespace && this->signalnamespace != ""){
//signalbroker.InvokeSignal<OutputStreamView::LogHandler>("/log/output",
// "SignalSubsriber<" + childname + ">::Block("+this->signalnamespace+")");
Connections::iterator itr = connections.begin();
for(; itr!= connections.end(); itr++){
itr->second.block();
}
}
}
void ConnectionSet::_createThread( const Connections& connections )
{
Thread* thread = new Thread( this );
for ( ConnectionsCIter it = connections.begin();
it != connections.end();
++it )
{
ConnectionPtr connection = *it;
thread->set.addConnection( connection );
}
_impl->threads.push_back( thread );
thread->start();
}
void
createBlockRow(size_t i, const Connections& conn, size_t ndof) {
assert (ndof == 1); (void) ndof;
assert (i == i_prev_ + 1); (void) i ;
ISTLTypeDetails::ScalarBCRSMatrix::CreateIterator ci(mat_, i);
for (typename Connections::const_iterator
c = conn.begin(), e = conn.end(); c != e; ++c) {
ci.insert(*c);
}
++i_prev_;
++ci;
}
void removeFromConnectionTable(int socketDescriptor){
/* Remove the user with the closed socket */
Connections::iterator it = conn.begin();
while(it!=conn.end()){
if(it->second == socketDescriptor){
#ifdef __INFO__
std::cout<<"\""<<it->first<<"\" went offline on socket "<<socketDescriptor<<"."<<std::endl;
#endif
conn.erase(it);
break;
}
++it;
}
}
bool Connection::send( const Connections& connections,
const Packet& packet, const bool isLocked )
{
if( connections.empty( ))
return true;
bool success = true;
for( Connections::const_iterator i= connections.begin();
i<connections.end(); ++i )
{
ConnectionPtr connection = *i;
if( !connection->send( &packet, packet.size, isLocked ))
success = false;
}
return success;
}
/*
* Returns list of online nicknames as
* ONLINE: <user1> : <user2> : ...
*/
std::string getOnlineList(std::string curUser){
std::string response = "ONLINE: ";
Connections::iterator it = conn.begin();
while(it!=conn.end()){
if(it->first!=curUser){
bool online = isOnline(it->first);
if(online){
response += it->first;
response += ":";
}
}
++it;
}
return response;
}
bool Connection::send( const Connections& connections, Packet& packet,
const void* const* items, const uint64_t* sizes,
const size_t nItems )
{
if( connections.empty( ))
return true;
packet.size -= 8;
const uint64_t headerSize = packet.size;
for( size_t i = 0; i < nItems; ++i )
{
EQASSERT( sizes[i] > 0 );
packet.size += sizes[ i ] + sizeof( uint64_t );
}
bool success = true;
for( Connections::const_iterator i = connections.begin();
i < connections.end(); ++i )
{
ConnectionPtr connection = *i;
connection->lockSend();
if( !connection->send( &packet, headerSize, true ))
success = false;
for( size_t j = 0; j < nItems; ++j )
if( !connection->send( &sizes[j], sizeof(uint64_t), true ) ||
!connection->send( items[j], sizes[j], true ))
{
success = false;
}
connection->unlockSend();
}
return success;
}
/*
* Parse incoming data
* Types of messages and their responses are:
* NEW: <from>
* Response --> NEW: <status>
* CHNAME: <old> : <new>
* Response --> CHNAME: <status>
* QUERY: <from>
* Response --> ONLINE: <user1> : <user2> : <user3> : ....
* SEND: <from> : <to> : <message>
* Response --> SENT: <to> : <statusMessage>
* BCAST: <from> : <message>
* Response --> SENT: <from> : <status>
*
* /toclient/ RECV: <from> : <message>
*/
void processRequest(int fromSocket, char* stream){
std::vector<std::string> tokens;
char* dump = strdup(stream); /* Create a duplicate stream */
splitCharStream(dump, DELIM, 1, &tokens); /* Retrieve the kind of message */
delete dump;
std::string reqType = tokens[0];
int TYPE_FLAG = -1, delimCount=-1;
if(reqType=="CHNAME"){
TYPE_FLAG = TYPE_CHNAME;
delimCount = 1;
}
else if(reqType=="NEW"){
TYPE_FLAG = TYPE_NEW;
delimCount = 0;
}
else if(reqType=="QUERY"){
TYPE_FLAG = TYPE_QUERY;
delimCount = 0;
}
else if(reqType=="SEND"){
TYPE_FLAG = TYPE_SEND;
delimCount = 2;
}
else if(reqType=="BCAST"){
TYPE_FLAG = TYPE_BCAST;
delimCount = 1;
}
if(TYPE_FLAG==-1)
return;
#ifdef __DEBUG__
std::cout<<TYPE_FLAG<<" --- ";
#endif
splitCharStream(strdup(tokens[1].c_str()), DELIM, delimCount, &tokens); /* Based on kind retrieve other param list */
std::string fromUser = tokens[0];
std::string toUser, message;
if(TYPE_FLAG == TYPE_CHNAME){
toUser = tokens[1];
#ifdef __INFO__
std::cout<<"\""<<fromUser<<"\" changing name to \""<<toUser<<"\"."<<std::endl;
#endif
int curSock = getFromConnectionTable(fromUser);
std::string reply = "CHNAME:"+toUser+":";
if(curSock==-1){
reply += "fail";
}
else{
curSock = getFromConnectionTable(toUser);
if(curSock==-1){
removeFromConnectionTable(fromSocket);
addToConnectionTable(toUser, fromSocket);
reply += "success";
}
else{
reply += "duplicate";
}
}
int s = send(fromSocket, reply.c_str(), reply.length(), 0);
if(s<0){
ERROR = E_SEND;
error_message = "Unable to send query reply.";
#ifdef __DEBUG__
std::cout<<error_message<<std::endl;
#endif
}
}
else if(TYPE_FLAG == TYPE_NEW){
#ifdef __INFO__
std::cout<<"\""<<fromUser<<"\" new registration."<<std::endl;
#endif
int oldSock = getFromConnectionTable(fromUser);
std::string reply = "duplicate";
if(oldSock==-1){
addToConnectionTable(fromUser, fromSocket); /* Add user socket pair to table */
reply = "registered";
}
#ifdef __INFO__
std::cout<<"\""<<fromUser<<"\" reg. status: "<<reply<<"."<<std::endl;
#endif
int s = send(fromSocket, reply.c_str(), reply.length(), 0);
if(s<0){
ERROR = E_SEND;
error_message = "Unable to send query reply.";
#ifdef __DEBUG__
std::cout<<error_message<<std::endl;
#endif
}
}
else if(TYPE_FLAG == TYPE_QUERY){
#ifdef __INFO__
std::cout<<"\""<<fromUser<<"\" queried."<<std::endl;
#endif
std::string onlineList = getOnlineList(fromUser);
int s = send(fromSocket, onlineList.c_str(), onlineList.length(), 0);
if(s<0){
ERROR = E_SEND;
error_message = "Unable to send query reply.";
#ifdef __DEBUG__
std::cout<<error_message<<std::endl;
#endif
}
}
else if(TYPE_FLAG == TYPE_SEND){
toUser = tokens[1];
message = tokens[2];
#ifdef __INFO__
std::cout<<"\""<<fromUser<<"\" sending message to \""<<toUser<<"\"."<<std::endl;
#endif
/* Send message to desired target username */
int status = sendMessage(toUser, fromUser, message);
std::string reply = "SENT: "+toUser+" : ";
if(status==-1){
reply += error_message;
#ifdef __DEBUG__
std::cout<<"\""<<fromUser<<"\" could not send a message to \""<<toUser<<"\". "<<std::endl;
#endif
}
else{
reply += "success";
#ifdef __DEBUG__
std::cout<<"\""<<fromUser<<"\" sent a message to \""<<toUser<<"\"."<<std::endl;
#endif
}
/* Report back to the sender */
int s = send(fromSocket, reply.c_str(), reply.length(), 0);
if(s<0){
ERROR = E_SEND;
error_message = "Unable to send message status.";
#ifdef __DEBUG__
std::cout<<error_message<<std::endl;
#endif
}
}
else if(TYPE_FLAG == TYPE_BCAST){
message = tokens[1];
std::string bcast = "RECV:"+fromUser+":"+message;
#ifdef __INFO__
std::cout<<"Broadcast from \""+fromUser+"\" : "<<message<<std::endl;
#endif
int status;
Connections::iterator it = conn.begin();
while(it!=conn.end()){
if(it->first != fromUser){
status = send(it->second, bcast.c_str(), bcast.length(), 0 );
}
++it;
}
std::string reply = "SENT:"+fromUser+":b_success";
/* Report back to the broadcaster */
int s = send(fromSocket, reply.c_str(), reply.length(), 0);
if(s<0){
ERROR = E_SEND;
error_message = "Unable to send message status.";
#ifdef __DEBUG__
std::cout<<error_message<<std::endl;
#endif
}
}
}
