diff --git a/domain/src/main.cpp b/domain/src/main.cpp index 7dd89df557..424416ca6c 100644 --- a/domain/src/main.cpp +++ b/domain/src/main.cpp @@ -44,10 +44,10 @@ int lastActiveCount = 0; AgentList agentList(DOMAIN_LISTEN_PORT); unsigned char * addAgentToBroadcastPacket(unsigned char *currentPosition, Agent *agentToAdd) { - *currentPosition++ = agentToAdd->type; + *currentPosition++ = agentToAdd->getType(); - currentPosition += packSocket(currentPosition, agentToAdd->publicSocket); - currentPosition += packSocket(currentPosition, agentToAdd->localSocket); + currentPosition += packSocket(currentPosition, agentToAdd->getPublicSocket()); + currentPosition += packSocket(currentPosition, agentToAdd->getLocalSocket()); // return the new unsigned char * for broadcast packet return currentPosition; @@ -73,7 +73,7 @@ int main(int argc, const char * argv[]) std::map newestSoloAgents; while (true) { - if (agentList.getAgentSocket()->receive((sockaddr *)&agentPublicAddress, packetData, &receivedBytes)) { + if (agentList.getAgentSocket().receive((sockaddr *)&agentPublicAddress, packetData, &receivedBytes)) { agentType = packetData[0]; unpackSocket(&packetData[1], (sockaddr *)&agentLocalAddress); @@ -82,24 +82,24 @@ int main(int argc, const char * argv[]) currentBufferPos = broadcastPacket + 1; startPointer = currentBufferPos; - for(std::vector::iterator agent = agentList.agents.begin(); agent != agentList.agents.end(); agent++) { + for(std::vector::iterator agent = agentList.getAgents().begin(); agent != agentList.getAgents().end(); agent++) { if (DEBUG_TO_SELF || !agent->matches((sockaddr *)&agentPublicAddress, (sockaddr *)&agentLocalAddress, agentType)) { - if (strchr(SOLO_AGENT_TYPES_STRING, (int) agent->type) == NULL) { + if (strchr(SOLO_AGENT_TYPES_STRING, (int) agent->getType()) == NULL) { // this is an agent of which there can be multiple, just add them to the packet currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, &(*agent)); } else { std::cout << "We have a solo agent: " << &(*agent) << "\n"; // solo agent, we need to only send newest - if (newestSoloAgents[agent->type] == NULL || - newestSoloAgents[agent->type]->firstRecvTimeUsecs < agent->firstRecvTimeUsecs) { + if (newestSoloAgents[agent->getType()] == NULL || + newestSoloAgents[agent->getType()]->getFirstRecvTimeUsecs() < agent->getFirstRecvTimeUsecs()) { // we have to set the newer solo agent to add it to the broadcast later - newestSoloAgents[agent->type] = &(*agent); + newestSoloAgents[agent->getType()] = &(*agent); } } } else { // this is the agent, just update last receive to now - agent->lastRecvTimeUsecs = usecTimestampNow(); + agent->setLastRecvTimeUsecs(usecTimestampNow()); } } @@ -112,7 +112,7 @@ int main(int argc, const char * argv[]) } if ((packetBytesWithoutLeadingChar = (currentBufferPos - startPointer))) { - agentList.getAgentSocket()->send((sockaddr *)&agentPublicAddress, broadcastPacket, packetBytesWithoutLeadingChar + 1); + agentList.getAgentSocket().send((sockaddr *)&agentPublicAddress, broadcastPacket, packetBytesWithoutLeadingChar + 1); } } } diff --git a/interface/src/main.cpp b/interface/src/main.cpp index 9b3ad7a39f..6d19004bfe 100644 --- a/interface/src/main.cpp +++ b/interface/src/main.cpp @@ -571,8 +571,8 @@ void display(void) // Render heads of other agents for(std::vector::iterator agent = agentList.getAgents().begin(); agent != agentList.getAgents().end(); agent++) { - if (agent->linkedData != NULL) { - Head *agentHead = (Head *)agent->linkedData; + if (agent->getLinkedData() != NULL) { + Head *agentHead = (Head *)agent->getLinkedData(); glPushMatrix(); glm::vec3 pos = agentHead->getPos(); glTranslatef(-pos.x, -pos.y, -pos.z); @@ -583,7 +583,7 @@ void display(void) if (!display_head) balls.render(); - // Render the world box + // Render the world box if (!display_head && stats_on) render_world_box(); // Render my own head @@ -851,8 +851,8 @@ void mouseoverFunc( int x, int y) } void attachNewHeadToAgent(Agent *newAgent) { - if (newAgent->linkedData == NULL) { - newAgent->linkedData = new Head(); + if (newAgent->getLinkedData() == NULL) { + newAgent->setLinkedData(new Head()); } } diff --git a/shared/src/Agent.cpp b/shared/src/Agent.cpp index 5790329c80..a635314b64 100644 --- a/shared/src/Agent.cpp +++ b/shared/src/Agent.cpp @@ -58,6 +58,75 @@ Agent& Agent::operator=(Agent otherAgent) { return *this; } +Agent::~Agent() { + delete publicSocket; + delete localSocket; + delete linkedData; +} + +char Agent::getType() { + return type; +} + +void Agent::setType(char newType) { + type = newType; +} + +double Agent::getFirstRecvTimeUsecs() { + return firstRecvTimeUsecs; +} + +void Agent::setFirstRecvTimeUsecs(double newTimeUsecs) { + firstRecvTimeUsecs = newTimeUsecs; +} + +double Agent::getLastRecvTimeUsecs() { + return lastRecvTimeUsecs; +} + +void Agent::setLastRecvTimeUsecs(double newTimeUsecs) { + lastRecvTimeUsecs = newTimeUsecs; +} + +sockaddr* Agent::getPublicSocket() { + return publicSocket; +} + +void Agent::setPublicSocket(sockaddr *newSocket) { + publicSocket = newSocket; +} + +sockaddr* Agent::getLocalSocket() { + return localSocket; +} + +void Agent::setLocalSocket(sockaddr *newSocket) { + publicSocket = newSocket; +} + +sockaddr* Agent::getActiveSocket() { + return activeSocket; +} + +void Agent::activateLocalSocket() { + activeSocket = localSocket; +} + +void Agent::activatePublicSocket() { + activeSocket = publicSocket; +} + + + +AgentData* Agent::getLinkedData() { + return linkedData; +} + +void Agent::setLinkedData(AgentData *newData) { + linkedData = newData; +} + + bool Agent::operator==(const Agent& otherAgent) { return matches(otherAgent.publicSocket, otherAgent.localSocket, otherAgent.type); } @@ -71,12 +140,6 @@ void Agent::swap(Agent &first, Agent &second) { swap(first.linkedData, second.linkedData); } -Agent::~Agent() { - delete publicSocket; - delete localSocket; - delete linkedData; -} - bool Agent::matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType) { // checks if two agent objects are the same agent (same type + local + public address) return type == otherAgentType diff --git a/shared/src/Agent.h b/shared/src/Agent.h index 90073a92b0..dafbeb768f 100644 --- a/shared/src/Agent.h +++ b/shared/src/Agent.h @@ -18,24 +18,35 @@ class Agent { Agent(); Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType); Agent(const Agent &otherAgent); + ~Agent(); Agent& operator=(Agent otherAgent); bool operator==(const Agent& otherAgent); - ~Agent(); - + bool matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType); - - sockaddr *publicSocket, *localSocket, *activeSocket; - char type; - timeval pingStarted; - int pingMsecs; - double firstRecvTimeUsecs; - double lastRecvTimeUsecs; - bool isSelf; - AgentData *linkedData; + char getType(); + void setType(char newType); + double getFirstRecvTimeUsecs(); + void setFirstRecvTimeUsecs(double newTimeUsecs); + double getLastRecvTimeUsecs(); + void setLastRecvTimeUsecs(double newTimeUsecs); + sockaddr* getPublicSocket(); + void setPublicSocket(sockaddr *newSocket); + sockaddr* getLocalSocket(); + void setLocalSocket(sockaddr *newSocket); + sockaddr* getActiveSocket(); + void activatePublicSocket(); + void activateLocalSocket(); + AgentData* getLinkedData(); + void setLinkedData(AgentData *newData); friend std::ostream& operator<<(std::ostream& os, const Agent* agent); private: void swap(Agent &first, Agent &second); + sockaddr *publicSocket, *localSocket, *activeSocket; + char type; + double firstRecvTimeUsecs; + double lastRecvTimeUsecs; + AgentData *linkedData; }; std::ostream& operator<<(std::ostream& os, const Agent* agent); diff --git a/shared/src/AgentList.cpp b/shared/src/AgentList.cpp index 0a72c3065e..d1c4db24ce 100644 --- a/shared/src/AgentList.cpp +++ b/shared/src/AgentList.cpp @@ -75,22 +75,22 @@ void AgentList::updateAgentWithData(sockaddr *senderAddress, void *packetData, s if (agentIndex != -1) { Agent *matchingAgent = &agents[agentIndex]; - matchingAgent->lastRecvTimeUsecs = usecTimestampNow(); + matchingAgent->setLastRecvTimeUsecs(usecTimestampNow()); - if (matchingAgent->linkedData == NULL) { + if (matchingAgent->getLinkedData() == NULL) { if (linkedDataCreateCallback != NULL) { linkedDataCreateCallback(matchingAgent); } } - matchingAgent->linkedData->parseData(packetData, dataBytes); + matchingAgent->getLinkedData()->parseData(packetData, dataBytes); } } int AgentList::indexOfMatchingAgent(sockaddr *senderAddress) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { - if (agent->activeSocket != NULL && socketMatch(agent->activeSocket, senderAddress)) { + if (agent->getActiveSocket() != NULL && socketMatch(agent->getActiveSocket(), senderAddress)) { return agent - agents.begin(); } } @@ -140,10 +140,10 @@ bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, if (socketMatch(publicSocket, localSocket)) { // likely debugging scenario with DS + agent on local network // set the agent active right away - newAgent.activeSocket = newAgent.localSocket; + newAgent.activatePublicSocket(); } - if (newAgent.type == 'M' && audioMixerSocketUpdate != NULL) { + if (newAgent.getType() == 'M' && audioMixerSocketUpdate != NULL) { // this is an audio mixer // for now that means we need to tell the audio class // to use the local socket information the domain server gave us @@ -160,10 +160,10 @@ bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, return true; } else { - if (agent->type == 'M') { + if (agent->getType() == 'M') { // until the Audio class also uses our agentList, we need to update // the lastRecvTimeUsecs for the audio mixer so it doesn't get killed and re-added continously - agent->lastRecvTimeUsecs = usecTimestampNow(); + agent->setLastRecvTimeUsecs(usecTimestampNow()); } // we had this agent already, do nothing for now @@ -175,9 +175,9 @@ void AgentList::broadcastToAgents(char *broadcastData, size_t dataBytes) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { // for now assume we only want to send to other interface clients // until the Audio class uses the AgentList - if (agent->activeSocket != NULL && agent->type == 'I') { + if (agent->getActiveSocket() != NULL && agent->getType() == 'I') { // we know which socket is good for this agent, send there - agentSocket.send(agent->activeSocket, broadcastData, dataBytes); + agentSocket.send(agent->getActiveSocket(), broadcastData, dataBytes); } } } @@ -186,15 +186,15 @@ void AgentList::pingAgents() { char payload[] = "P"; for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { - if (agent->type == 'I') { - if (agent->activeSocket != NULL) { + if (agent->getType() == 'I') { + if (agent->getActiveSocket() != NULL) { // we know which socket is good for this agent, send there - agentSocket.send(agent->activeSocket, payload, 1); + agentSocket.send(agent->getActiveSocket(), payload, 1); } else { // ping both of the sockets for the agent so we can figure out // which socket we can use - agentSocket.send(agent->publicSocket, payload, 1); - agentSocket.send(agent->localSocket, payload, 1); + agentSocket.send(agent->getPublicSocket(), payload, 1); + agentSocket.send(agent->getLocalSocket(), payload, 1); } } } @@ -203,19 +203,12 @@ void AgentList::pingAgents() { void AgentList::handlePingReply(sockaddr *agentAddress) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { // check both the public and local addresses for each agent to see if we find a match - // prioritize the private address so that we prune erroneous local matches - sockaddr *matchedSocket = NULL; - - if (socketMatch(agent->publicSocket, agentAddress)) { - matchedSocket = agent->publicSocket; - } else if (socketMatch(agent->localSocket, agentAddress)) { - matchedSocket = agent->localSocket; - } - - if (matchedSocket != NULL) { - // matched agent, stop checking - // update the agent's ping - agent->activeSocket = matchedSocket; + // prioritize the private address so that we prune erroneous local matches + if (socketMatch(agent->getPublicSocket(), agentAddress)) { + agent->activatePublicSocket(); + break; + } else if (socketMatch(agent->getLocalSocket(), agentAddress)) { + agent->activateLocalSocket(); break; } } @@ -229,7 +222,7 @@ void *removeSilentAgents(void *args) { checkTimeUSecs = usecTimestampNow(); for(std::vector::iterator agent = agents->begin(); agent != agents->end();) { - if ((checkTimeUSecs - agent->lastRecvTimeUsecs) > AGENT_SILENCE_THRESHOLD_USECS) { + if ((checkTimeUSecs - agent->getLastRecvTimeUsecs()) > AGENT_SILENCE_THRESHOLD_USECS) { std::cout << "Killing agent " << &(*agent) << "\n"; pthread_mutex_lock(&vectorChangeMutex); agent = agents->erase(agent);