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 } } }