void SignalProxy::removeAllPeers() {
Q_ASSERT(proxyMode() == Server || _peers.count() <= 1);
// wee need to copy that list since we modify it in the loop
QList<QObject *> peers = _peers.keys();
foreach(QObject *peer, peers) {
removePeer(peer);
}
void Chord::run(string file){
read(file); // Read Command from file
// For each command, perform the repective function
for(vector<Command>::iterator c = cmd.begin(); c != cmd.end(); c++){
if (c->command.compare("init") == 0) {
init(c->peer);
}
if (c->command.compare("addpeer") == 0) {
addPeer(c->peer);
updateFinger();
}
if (c->command.compare("insert") == 0) {
insert(c->peer, c->message);
}
if (c->command.compare("print") == 0) {
print(c->peer);
}
if (c->command.compare("delete") == 0) {
Delete(c->peer, c->message);
}
if (c->command.compare("removepeer") == 0) {
removePeer(c->peer);
updateFinger();
}
}
}
///<summary> Remove the supplied service from the connection list and close it. </summary>
void removeConnection(POLYM_CONNECTION_INFO *connection_info)
{
switch (connection_info->realm)
{
case POLY_REALM_SERVICE:
// close a service control connection
removeService(connection_info->connectionID);
break;
case POLY_REALM_PEER:
// close a peer connection
removePeer(connection_info->connectionID);
break;
default:
break;
}
}
void Server::update(running_machine *machine)
{
for(
map<RakNet::RakNetGUID,vector< string > >::iterator it = unknownPeerInputs.begin();
it != unknownPeerInputs.end();
)
{
cout << "GOT UNKNOWN PEER INPUT\n";
if(peerIDs.find(it->first)!=peerIDs.end())
{
int ID = peerIDs[it->first];
for(int a=0;a<it->second.size();a++)
{
peerInputs[ID].push_back(it->second[a]);
}
map<RakNet::RakNetGUID,vector< string > >::iterator itold = it;
it++;
unknownPeerInputs.erase(itold);
}
else
{
it++;
}
}
//cout << "SERVER TIME: " << RakNet::GetTimeMS()/1000.0f/60.0f << endl;
//printf("Updating server\n");
RakNet::Packet *p;
for (p=rakInterface->Receive(); p; rakInterface->DeallocatePacket(p), p=rakInterface->Receive())
{
// We got a packet, get the identifier with our handy function
unsigned char packetIdentifier = GetPacketIdentifier(p);
//printf("GOT PACKET %d\n",int(packetIdentifier));
// Check if this is a network message packet
switch (packetIdentifier)
{
case ID_CONNECTION_LOST:
// Couldn't deliver a reliable packet - i.e. the other system was abnormally
// terminated
case ID_DISCONNECTION_NOTIFICATION:
// Connection lost normally
printf("ID_DISCONNECTION_NOTIFICATION from %s\n", p->systemAddress.ToString(true));
removePeer(p->guid,machine);
break;
case ID_NEW_INCOMING_CONNECTION:
// Somebody connected. We have their IP now
printf("ID_NEW_INCOMING_CONNECTION from %s with GUID %s\n", p->systemAddress.ToString(true), p->guid.ToString());
if(syncHappend)
{
//Sorry, too late
//rakInterface->CloseConnection(p->systemAddress,true);
}
break;
case ID_CLIENT_INFO:
cout << "GOT ID_CLIENT_INFO\n";
//This client is requesting candidacy, set their info
{
char buf[4096];
strcpy(buf,(char*)(p->data+1));
candidateNames[p->systemAddress] = buf;
}
//Find a session index for the player
{
char buf[4096];
buf[0] = ID_SETTINGS;
memcpy(buf+1,&secondsBetweenSync,sizeof(int));
strcpy(buf+1+sizeof(int),username.c_str());
rakInterface->Send(
buf,
1+sizeof(int)+username.length()+1,
HIGH_PRIORITY,
RELIABLE_ORDERED,
ORDERING_CHANNEL_SYNC,
p->guid,
false
);
}
if(acceptedPeers.size()>=maxPeerID-1)
{
//Sorry, no room
rakInterface->CloseConnection(p->systemAddress,true);
}
else if(acceptedPeers.size())
{
printf("Asking other peers to accept %s\n",p->systemAddress.ToString());
waitingForAcceptFrom[p->systemAddress] = std::vector<RakNet::RakNetGUID>();
for(int a=0; a<acceptedPeers.size(); a++)
{
RakNet::RakNetGUID guid = acceptedPeers[a];
waitingForAcceptFrom[p->systemAddress].push_back(guid);
cout << "SENDING ADVERTIZE TO " << guid.ToString() << endl;
char buf[4096];
buf[0] = ID_ADVERTISE_SYSTEM;
strcpy(buf+1,p->systemAddress.ToString(true));
rakInterface->Send(buf,1+strlen(p->systemAddress.ToString(true))+1,HIGH_PRIORITY,RELIABLE_ORDERED,ORDERING_CHANNEL_SYNC,guid,false);
}
printf("Asking other peers to accept\n");
}
else
{
//First client, automatically accept
acceptPeer(p->systemAddress,machine);
}
break;
case ID_INCOMPATIBLE_PROTOCOL_VERSION:
printf("ID_INCOMPATIBLE_PROTOCOL_VERSION\n");
break;
case ID_ACCEPT_NEW_HOST:
{
printf("Accepting new host\n");
RakNet::SystemAddress saToAccept;
saToAccept.SetBinaryAddress(((char*)p->data)+1);
for(int a=0; a<waitingForAcceptFrom[saToAccept].size(); a++)
{
if(waitingForAcceptFrom[saToAccept][a]==p->guid)
{
waitingForAcceptFrom[saToAccept].erase(waitingForAcceptFrom[saToAccept].begin()+a);
break;
}
}
if(waitingForAcceptFrom[saToAccept].empty())
{
cout << "Accepting: " << saToAccept.ToString() << endl;
waitingForAcceptFrom.erase(waitingForAcceptFrom.find(saToAccept));
acceptPeer(saToAccept,machine);
}
}
break;
case ID_REJECT_NEW_HOST:
{
RakNet::SystemAddress saToReject;
saToReject.SetBinaryAddress(((char*)p->data)+1);
printf("Rejecting new client\n");
cout << p->guid.ToString() << " REJECTS " << saToReject.ToString() << endl;
if(waitingForAcceptFrom.find(saToReject)==waitingForAcceptFrom.end())
printf("Could not find waitingForAcceptFrom for this GUID, weird");
else
waitingForAcceptFrom.erase(waitingForAcceptFrom.find(saToReject));
rakInterface->CloseConnection(saToReject,true);
}
break;
case ID_CLIENT_INPUTS:
if(peerIDs.find(p->guid)==peerIDs.end() || peerInputs.find(peerIDs[p->guid])==peerInputs.end())
{
cout << __FILE__ << ":" << __LINE__ << " OOPS!!!!\n";
}
//cout << "GOT CLIENT INPUTS\n";
peerInputs[peerIDs[p->guid]].push_back(string((char*)GetPacketData(p),(int)GetPacketSize(p)));
break;
default:
printf("UNEXPECTED PACKET ID: %d\n",int(packetIdentifier));
break;
}
}
}
void ToxGroupCall::onAudioSinkInvalidated(ToxPk peerId)
{
removePeer(peerId);
addPeer(peerId);
}
t_stat ipc (ipc_funcs fn, char *arg1, char *arg2, char *arg3, int32 UNUSED arg4)
{
// if (!checkIPC())
// return SCPE_UDIS;
switch (fn)
{
case ipcStart:
if (actor)
killIPC();
actor = zactor_new (ipc_actor, arg1);
assert (actor);
deletePeers(); // remove all peers
break;
case ipcStop:
ipc_printf("Stopping IPC ... ");
killIPC();
ipc_printf("deleted %d peers ... ", deletePeers());
ipc_printf("done\n");
break;
case ipcRestart:
ipc(ipcStop, 0, 0, 0, 0); // kill IPC
deletePeers();
ipc(ipcStart, fnpName, 0, 0, 0); // start IPC
break;
case ipcEnter:
//sim_debug (DBG_VERBOSE, &ipc_dev, "%s/%s has entered " STR(IPC_GROUP) "\n", arg1, arg2);
if (ipc_verbose)
ipc_printf("(ENTER) %s/%s has entered %s from %s\n", arg1, arg2, fnpGroup, arg3);
savePeer(arg1, arg2);
break;
case ipcExit:
//sim_debug (DBG_VERBOSE, &ipc_dev, "%s has left " STR(IPC_GROUP) "\n", arg1);
if (ipc_verbose)
ipc_printf("(EXIT) %s/%s has left %s\n", arg1, arg2, fnpGroup);
removePeer(arg1);
break;
case ipcShoutTx:
zstr_sendx (actor, "SHOUT", arg1, NULL);
break;
case ipcWhisperTx:
#if 1
if (arg1) // WHISPER msg (use last whisper peer)
{
IPC_Peer *p1 = findPeer(stripquotes(trim(arg1))); // f**k for peer named 'name'
if (p1)
strcpy(lastPeer, p1->peerID); // save Peer id
else
{
bool bGuid = isGUID(stripquotes(trim(arg1)));
if (!bGuid)
{
sim_printf("Error: '%s' is not a GUID or a known peer\n", arg1);
return SCPE_ARG;
}
strcpy(lastPeer, arg1); // Peer name not found, assume arg1 is a peerID then...
}
}
#endif
zstr_sendx (actor, "WHISPER", arg2, NULL);
break;
case ipcShoutRx: // when we receive a broadcast message
//sim_debug (DBG_VERBOSE, &ipc_dev, "%s: %s\n", arg1, arg2);
if (ipc_verbose)
ipc_printf("(RX SHOUT) %s/%s:<%s>\n", arg1, arg2, arg3);
break;
case ipcWhisperRx: // when we receive a peer-to-peer (whisper) message
//sim_debug (DBG_VERBOSE, &ipc_dev, "%s: %s\n", arg1, arg2);
if (ipc_verbose)
ipc_printf("(RX WHISPER) %s/%s:<%s>\n", arg1, arg2, arg3);
if (strncmp (arg1, "fnp-", 4) == 0)
diaCommand (arg1, arg2, arg3);
else if (strncmp (arg1, "scp", 3) == 0)
scpCommand (arg1, arg2, arg3);
else
ipc_printf ("dropping whisper from unknown source %s/%s:<%s>\n",
arg1, arg2, arg3);
break;
case ipcTest:
zyre_test(true);
break;
default:
break;
}
return SCPE_OK;
}
void mtt::FileTransfer::connectionClosed(PeerCommunication* p, int code)
{
LOG_APPEND("closed " << p->getAddressName());
removePeer(p);
}
void mtt::FileTransfer::evalCurrentPeers()
{
const uint32_t peersEvalInterval = 5;
if (peersEvalCounter-- > 0)
return;
peersEvalCounter = peersEvalInterval;
std::vector<PeerCommunication*> removePeers;
{
std::lock_guard<std::mutex> guard(peersMutex);
if ((uint32_t)activePeers.size() < mtt::config::external.maxTorrentConnections)
return;
const uint32_t minPeersTimeChance = 10;
uint32_t currentTime = (uint32_t)std::time(0);
auto minTimeToEval = currentTime - minPeersTimeChance;
const uint32_t minPeersPiecesTimeChance = 20;
auto minTimeToReceive = currentTime - minPeersPiecesTimeChance;
uint32_t slowestSpeed = -1;
PeerCommunication* slowestPeer;
uint32_t maxUploads = 5;
std::vector<ActivePeer*> currentUploads;
for (auto peer : activePeers)
{
if (peer.connectionTime > minTimeToEval)
continue;
if (peer.lastActivityTime < minTimeToReceive)
{
removePeers.push_back(peer.comm);
continue;
}
if (peer.comm->state.peerInterested)
{
currentUploads.push_back(&peer);
}
if (peer.downloadSpeed < slowestSpeed)
{
slowestSpeed = peer.downloadSpeed;
slowestPeer = peer.comm;
}
}
if (removePeers.empty())
removePeers.push_back(slowestPeer);
if (!currentUploads.empty())
{
std::sort(currentUploads.begin(), currentUploads.end(), [](const auto & l, const auto & r) { return l->uploadSpeed > r->uploadSpeed; });
currentUploads.resize(std::min((uint32_t)currentUploads.size(), maxUploads));
for (auto p : currentUploads)
{
auto it = std::find(removePeers.begin(), removePeers.end(), p->comm);
if (it != removePeers.end())
removePeers.erase(it);
}
}
}
for (auto p : removePeers)
{
removePeer(p);
}
}
static void* data_thread(void *vptr) {
struct tree_t* tree = vptr;
struct data_pack dpack;
FILE* fp = fopen (media_file, "rb");
struct alpha_queue *socks;
socks = alpha_queue_new();
if (NULL == fp) {
print_error ("error opening media file");
return NULL;
}
dpack.seqnum = 1;
for (;;) {
size_t amount = fread (dpack.data, 1, EU_PACKETLEN - sizeof (uint64_t), fp);
if (0 == amount) {
print_error ("end of file..?");
return NULL;
}
while (0 == countRootChildren(tree)) {
sleep(1); // Temporary to allow setup for tests
// do nothing.
}
uint64_t i;
for (i = 0; i < countRootChildren(tree); i++) {
struct peer_info *pi = getRootChild (tree, i);
if (NULL == pi)
break;
struct eu_socket *sock = alpha_queue_pop (socks);
if (NULL == sock) {
sock = eu_socket (EU_PUSH);
if (NULL == sock) {
print_error ("no more easy socks?");
return NULL;
}
}
if (eu_connect (sock, pi->addr, pi->port)) {
print_error ("couldn't connect??");
return NULL;
}
int rc = eu_send (sock, &dpack, amount + sizeof (uint64_t), 0);
if (rc != (amount + sizeof (uint64_t))) {
if (rc == -2)
{
int prremove = removePeer (tree, pi->pid);
if (prremove != 0) {
switch (prremove) {
case -1:
print_error ("Memory Error in removing peer\n");
break;
}
}
printTree (tree);
}
print_error ("couldn't send full packet :/");
return NULL;
}
alpha_queue_push (socks, sock);
usleep(200);
}
dpack.seqnum++;
}
}
static void* control_thread(void *vptr) {
struct tree_t* tree = vptr;
void* sock = getSocket(tree);
while (1) {
message_struct* msg = NULL;
msg = sn_rcvmsg(sock);
if (msg != NULL) {
switch (msg->type) {
case REQ_MOVE:
print_error ("Request move from %s\n", msg->node_params.pid);
;int prmve = movePeer(tree, msg->node_params.pid);
if (prmve != 0) {
switch (prmve) {
case -1:
print_error ("Memory Error in moving peer\n");
break;
case -2:
print_error ("Peer Not Found in Tree in moving peer\n");
break;
case -3:
print_error ("No Empty Slots in moving peer\n");
break;
}
}
printTree (tree);
break;
case REQ_JOIN:
print_error ("Request join from %s\n", msg->node_params.pid);
;int pradd = addPeer (tree, msg->node_params.peerbw,
msg->node_params.pid, msg->node_params.addr,
msg->node_params.port);
if (pradd != 0) {
switch (pradd) {
case -1:
print_error ("Memory Error in adding peer\n");
break;
case -2:
print_error ("No Empty Slots in adding peer\n");
break;
}
}
printTree (tree);
break;
case REM_NODE:
print_error ("Request drop node %s\n", msg->node_params.pid);
;int prremove = removePeer (tree, msg->node_params.pid);
if (pradd != 0) {
switch (pradd) {
case -1:
print_error ("Memory Error in adding peer\n");
break;
}
}
printTree (tree);
break;
case REQ_EXIT:
print_error ("Request exit from %s\n", msg->node_params.pid);
;int prrmv = removePeer (tree, msg->node_params.pid);
if (prrmv == -1) {
print_error ("Memory Error in remove peer\n");
}
printTree (tree);
}
}
}
return NULL;
}
