Network.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// Network.cpp: implementation of the Network class.
//
//////////////////////////////////////////////////////////////////////


#include "Network.h"
#include "DataSample.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Network::Network(TCPReceiver* recv) : JThread() {
        netCheckTimeout = 5000;
        isInitialized = false;
        allowNetConnections = true;
        netProtocols = NULL;
        primaryCon = NULL;
        primaryLoc = NULL;
        preferredNetProtocol = new NetMessageProtocol();
//      preferredNetProtocol = new NetOriginalMessageProtocol();
        mySocket = NULL;
        cons = new ObjectCollection();
        cons->doDelete();
        receiverCons = new ObjectDictionary();
        receiverCons->doDelete();
        remoteReceiverCons = new ObjectDictionary();
        remoteReceiverCons->noDelete();
        port = 0;
        receiver = recv;
        shouldContinue = true;
        isDoneRunning = false;
}

Network::~Network() {
        shouldContinue = false;
        allowNetConnections = false;

        if (DEBUGLEVEL(DETAILEDSTATUS))
              printf("Network %s deleting...\n", (char*) name);
        if (isInitialized) {
                JTime t;
                // Wait 1000 ms for the thread to stop running...
                while (JTime() - t < 1000) {
                        if (isDoneRunning)
                                break;
                        wait(5);
                }
        }
        if (mySocket != NULL)
                delete(mySocket);
        if (DEBUGLEVEL(DETAILEDSTATUS))
              printf("Network %s terminating...\n", (char*) name);
        waitThread(10);
        this->terminate();
        if (DEBUGLEVEL(DETAILEDSTATUS))
          printf("Network %s deleting connections...\n", (char*) name);
                deleteConnections();
        this->removeAllProtocols();
        delete(preferredNetProtocol);
        preferredNetProtocol = NULL;
        delete(primaryLoc);
        if (DEBUGLEVEL(DETAILEDSTATUS))
              printf("Network %s deleted...\n", (char*) name);
}

bool Network::init(int portNum) {

        if (portNum > 0)
                port = portNum;
//      if (port < 0)
//              return false;

        isInitialized = false;

        if (mySocket != NULL) {
                wait(200);
                mySocket->disconnectNow();
                delete(mySocket);
                mySocket = NULL;
        }

        if (port > 0) {

                mySocket = new JSocket("", port, "");

                if (!mySocket->setUpListening()) {
                        if (DEBUGLEVEL(STATUS)) {
                                printf("\n [%s] Port %d not available.\n", (char*) name, port);
                        }
                        port = 0;
                        delete(mySocket);
                        mySocket = NULL;
                        return false;
                }
        }

        isInitialized = true;
        return true;
}

bool Network::allowConnections(bool allow) {
        allowNetConnections = allow;
        return true;
}


void Network::run()
{
        NetworkConnection* con;
        JSocket* c = NULL;
        NetProtocol* protocol;

        // JTime now;
        JTime lastCheck;
        JTime t;

        this->setPriority(90);
        while (shouldContinue) {

                while (!isInitialized) {
                        if (!shouldContinue) {
                                isDoneRunning = true;
                                return;
                        }
                        wait(50);
                }

                if (mySocket != NULL) {
                        c = mySocket->waitForConnection(100);
                        if (c != NULL) {
                                if (!allowNetConnections) {
                                        c->terminate();
                                        delete(c);
                                }
                                else if (c->isConnected()) {
                                        protocol = detectProtocol(c, MSGTIMEOUT);
                                        if (protocol != NULL) {
                                                protocol->initializeConversation(c);
                                                con = this->openIncomingConnection(c, protocol);
                                        }
                                        else {
                                                if (c->isConnected()) {
                                                        if (DEBUGLEVEL(DETAILEDSTATUS)) {
                                                                printf("[%s] Not able to identify protocol, using low level...\n", (char*)name);
                                                        }
                                                        con = this->openIncomingConnection(c, NULL);
                                                }
                                                else {
                                                        if (DEBUGLEVEL(DETAILEDSTATUS)) {
                                                                printf("[%s] Connection closed before identifying protocol...\n", (char*)name);
                                                        }
                                                        delete(c);
                                                }
                                        }
                                }
                        }
                }
                else {
                        wait(100);
                }

                // now = JTime();
                if (lastCheck.getAge() > netCheckTimeout) {
                        if (!checkPrimaryConnection()) {
                                t = JTime(netCheckTimeout);
                                if (DEBUGLEVEL(DEBUG)) {
                                        JTime now;
                                        printf("%s: Main Connection is down and reconnect failed - recheck in %s\n", (char*) now.print(), (char*) t.printDifTime());
                                }
                        }
                        checkReceivingConnections();
                        checkOpenConnections();
                        tryReconnectingLostConnections();
                        lastCheck = JTime();
                }
        }
        isDoneRunning = true;

}


void Network::deleteConnections() {
        remoteReceiverCons->removeAllNoDelete();
        
        int n;
        NetworkConnection* con;
        for (n=0; n<cons->getCount(); n++) {
                con = (NetworkConnection*) cons->get(n);
                if (con != NULL) {
                        if (DEBUGLEVEL(MOREDETAILED)) {
                                printf("Network terminating the following connection:\n  %s\n", (char*) con->print());
                        }
                        con->terminate();
                }
        }
        for (n=0; n<receiverCons->getCount(); n++) {
                con = (NetworkConnection*) receiverCons->get(n);
                if (con != NULL) {
                        if (DEBUGLEVEL(MOREDETAILED)) {
                                printf("Network terminating the following connection:\n  %s\n", (char*) con->print());
                        }
                        con->terminate();
                }
        }
        delete(cons);
        delete(receiverCons);
        if (primaryCon != NULL)
                delete(primaryCon);
        delete(remoteReceiverCons);
}

JString Network::print() {
        if ( (cons == NULL) || (cons->getCount() == 0)) {
                return JString::format("[%s] No network connections", (char*) name);
        }
        else {
                return JString::format("[%s] %d connections:\n\t%s\n",
                        (char*) name, cons->getCount(), (char*) cons->printListLine("\n\t"));
        }
}

// *************************************************************
// NetProtocols
// *************************************************************


bool Network::addProtocol(NetProtocol* protocol) {

        if (netProtocols == NULL) {
                netProtocols = protocol;
                protocol->next = protocol->prev = NULL;
        }
        else {
                NetProtocol* p = netProtocols;
                while (p->next != NULL) p = p->next;
                p->next = protocol;
                protocol->prev = p;
                protocol->next = NULL;
        }
        return true;
}

bool Network::removeProtocol(NetProtocol* protocol) {

        if (netProtocols == NULL) return true;

        NetProtocol* p = netProtocols;
        while (p != NULL) {
                if (p->equals(protocol)) {
                        if ( (p->prev == NULL) && (p->next == NULL) )
                                netProtocols = NULL;
                        else {
                                if (p->prev != NULL)
                                        p->prev->next = p->next;
                                if (p->next != NULL)
                                        p->next->prev = p->prev;
                        }
                        delete(p);
                        return true;
                }
                p = p->next;
        }

        return false;
}

bool Network::removeAllProtocols() {

        NetProtocol* p = netProtocols;

        while (netProtocols != NULL) {
                p = netProtocols->next;
                delete(netProtocols);
                netProtocols = p;
        }
        return true;
}

NetProtocol* Network::detectProtocol(JSocket* socket, long timeout) {
        if (netProtocols == NULL) return NULL;
        JTime start;
        
        NetProtocol* p = NULL;
        while (p == NULL) {
                socket->readIntoBuffer();
                if (!socket->isConnected()) {
                        if (DEBUGLEVEL(DETAILEDSTATUS))
                                printf("[%s] detectProtocol - not connected...\n", (char*)name);
                        return NULL;
                }
                p = netProtocols;
                while (p != NULL) {
                        if (p->checkBufferForCompatibility(socket->charBuffer, socket->charBufferCount)) {
                                if (DEBUGLEVEL(DETAILEDSTATUS)) {
                                        printf("[Network] Found matching protocol for new con: %s\n", (char*) p->name);
                                }
                                break;
                        }
                        p = p->next;
                }
                // now = JTime();
                if (start.getAge() > timeout)
                        break;
                if (p == NULL)
                        wait(10);
        }
        if (p == NULL) {
                if (DEBUGLEVEL(DETAILEDSTATUS)) {
                        JTime now;
                        printf("[%s] detectProtocol - timeout detecting protocol (%s - %s)...\n", (char*)name, (char*) start.printTimeMS(), (char*) now.printTimeMS());
                }
                return NULL;
        }
        else {
                if (DEBUGLEVEL(DETAILEDSTATUS))
                        printf("[%s] detectProtocol - found protocol...\n", (char*)name);
                return (NetProtocol*) p->clone();
        }
}

// *************************************************************
// Network resolution
// *************************************************************

JString Network::getLocalHostname() {

        if (localHostname.length() > 0)
                return localHostname;

        if (mySocket != NULL)
                localHostname = mySocket->getLocalHostname();
        else {
                JSocket* sock = new JSocket("", 80);
                localHostname = sock->getLocalHostname();
                delete sock;
        }
        return localHostname;
}

JString Network::getLocalIPAddress() {

        if (localIPAddress.length() > 0)
                return localIPAddress;

        if (mySocket != NULL)
                localIPAddress = mySocket->getLocalIPAddress();
        else {
                JSocket* sock = new JSocket("", 80);
                localIPAddress = sock->getLocalIPAddress();
                delete sock;
        }
        return localIPAddress;
}

Collection Network::getLocalIPAddresses() {

        if (localIPAddresses.getCount() > 0)
                return localIPAddresses;

        if (mySocket != NULL)
                localIPAddresses = mySocket->getLocalIPAddresses();
        else {
                JSocket* sock = new JSocket("", 80);
                localIPAddresses = sock->getLocalIPAddresses();
                delete sock;
        }
        if (localIPAddresses.getCount() == 0)
                localIPAddresses.add("127.0.0.1");
        return localIPAddresses;
}

JString Network::getRemoteHostname() {

        if (mySocket == NULL)
                return "";
        
//      if (!mySocket->isConnected())
//              return "";

        return mySocket->getRemoteHostname();
}

IPNumber Network::getIPNumberFromName(const JString& name) {
        IPNumber ipnum;

        if (name.length() == 0) {
                if (DEBUGLEVEL(STATUS)) {
                        printf("[%s] IPNumber for '', defaulting to 127.0.0.1...", (char*) name);
                }
                ipnum.a = 127;
                ipnum.b = 0;
                ipnum.c = 0;
                ipnum.d = 1;
                return ipnum;
        }

        if (mySocket != NULL) {
                ipnum = mySocket->getIPNumberFromName(name);
        }
        else {
                JSocket* sock = new JSocket("", 0);
                ipnum = sock->getIPNumberFromName(name);
                delete(sock);
        }
        return ipnum;
}

JString Network::getIPAddressFromName(const JString& name) {
        JString ipaddr;

        if (mySocket != NULL) {
                ipaddr = mySocket->getIPAddressFromName(name);
        }
        else {
                JSocket* sock = new JSocket("", 0);
                ipaddr = sock->getIPAddressFromName(name);
                delete(sock);
        }
        return ipaddr;
}



/////////////////////////////////////////////////////////////////


NetProtocol* Network::getPreferredNetProtocol() {
        return (NetProtocol*) preferredNetProtocol->clone();
}

bool Network::setPreferredNetProtocol(NetProtocol* prefProtocol) {
        if (preferredNetProtocol != NULL)
                delete(preferredNetProtocol);
        preferredNetProtocol = prefProtocol;
        return true;
}

NetworkConnection* Network::openConnection(const TCPLocation& loc) {

        if ((loc.netProtocolName.length() == 0) || (loc.netProtocolName.equalsIgnoreCase(preferredNetProtocol->name)))
                return openConnection(loc, getPreferredNetProtocol());
        else
                return openConnection(loc, new NetMessageProtocol());
        //      return openConnection(loc, new NetOriginalMessageProtocol());
}

NetworkConnection* Network::openConnection(const TCPLocation& loc, NetProtocol* netprotocol) {
        // OK, first we need to find out whether we should use an existing connection
        // or create a new one from scratch

        if (loc.name.equalsIgnoreCase(name)) {
        //      printf("*********** %s opening network to itself! ************\n%s\n\n", (char*) name, (char*) this->getProgramTrace().printListLine(""));
                return false;
        }

        // netprotocol->createdAsSender = true;

        // Find a connected connection
//      NetworkConnection* con = findConnectedConnection(loc, netprotocol);
        NetworkConnection* con = findConnectedConnection(loc.name);
        if (con != NULL) {
        
                if (DEBUGLEVEL(DETAILEDSTATUS)) {
                        if (con->isRemoteCallback()) {
                        //      printf("REC:\tFrom:\t%s\tTo:\t%s\n", (char*)name, (char*)loc.name); fflush(stdout);
                                printf("Found Remote Callback to send on to %s out of: %s\n\t%s\n", (char*) loc.name, (char*) con->print(), (char*) cons->printListLine("\n\t"));
                        }
                        else {
                                printf("Found own connection to send on to %s out of: %s\n\t%s\n", (char*) loc.name, (char*) con->print(), (char*) cons->printListLine("\n\t"));
                        //      printf("OWN:\tFrom:\t%s\tTo:\t%s\n", (char*)name, (char*)loc.name); fflush(stdout);
                        }
                }
                delete(netprotocol);
//              printf("*** [%s] Using existing connection to: %s\n", (char*) this->name, (char*) loc.name); 
                // ################################
                // Register use or reset timeout...
                // ################################
                return con;
        }
        if (DEBUGLEVEL(DETAILEDSTATUS)) {
                printf("[%s] Didn't find connection to send on to (%s) out of: \n\t%s\n", (char*) name, (char*) loc.asText(), (char*) cons->printListLine("\n\t"));
        //  printf("NEW:\tFrom:\t%s\tTo:\t%s\n", (char*)name, (char*)loc.name); fflush(stdout);
        }

        // Else try to find a non-connected free connection
        con = findResetConnection();

        // if we found an idle reset connection, use it
        if (con != NULL) {
//              printf("O"); fflush(stdout);
//              printf("Using existing connection to %s\n", (char*) loc.name);
//              printf("*** [%s] Opening existing connection to: %s\n", (char*) this->name, (char*) loc.name); 
// ##########################
//              con->restart(loc, netprotocol, receiver);
                con->restart(loc, netprotocol, NULL);
        }
        else {
//              printf("Creating new connection to %s\n", (char*) loc.name);
//              printf("*** [%s] Creating new connection to: %s\n", (char*) this->name, (char*) loc.name); 
//              printf("N"); fflush(stdout);
// ##########################
//              con = new NetworkConnection(loc, netprotocol, receiver);
                con = new NetworkConnection(loc, netprotocol, NULL);
                con->parent = this;
                con->name = name;
                cons->add(con);
        }

        if (con->isConnected())
                return con;
        else {
                con->reset();
                return NULL;
        }
}

NetworkConnection* Network::createNetworkConnectionTo(const TCPLocation& loc, TCPReceiver* rec) {
        // For backwards compatibility
        return openConnection(loc, NULL);
}

NetworkConnection* Network::openIncomingConnection(JSocket* sock, NetProtocol* protocol) {

        // OK, first we need to find out whether we should use an existing connection
        // or create a new one from scratch

        NetworkConnection* con = findResetConnection();

        // if we found an idle reset connection, use it
        if (con != NULL) {
                // printf("Found reset con for new incoming\n");
                con->restart(sock, protocol, receiver);
        }
        else {
                // printf("Creating new con for new incoming\n");
                con = new NetworkConnection(sock, protocol, receiver);
                con->parent = this;
                con->name = name;
                cons->add(con);
        }

        if (receiver != NULL) {
                if (!receiver->connectNotify(con->remoteName, con)) {
                        con->reset();
                        return NULL;
                }
        }

        if (con->isConnected()) {
                // Check if this is a new 'receiver' connection
                if (!con->isReceiver()) {
                        if (DEBUGLEVEL(DEBUG)) {
                                printf("### [%s] Registered Receiver: %s ###\n", (char*) name, (char*) con->remoteName);
                                fflush(stdout);
                        }

                        if (DEBUGLEVEL(DETAILEDSTATUS))
                                printf("### [%s] Now have these connections: ### \n\t%s\n", (char*) name, (char*) cons->printListLine("\n\t"));
                        
                        remoteReceiverCons->put(con->remoteName, con);
                        // go through other connections to see if an old 'receiver' from
                        // the same component is also connected
                        NetworkConnection* con2 = NULL;
                        for (int n=0; n<remoteReceiverCons->getCount(); n++) {
                                con2 = (NetworkConnection*) remoteReceiverCons->get(n);
                                if ((con2 != NULL) && (con2 != con))
                                        if (!con2->isReceiver())
                                                if (con2->isConnectedTo(con->remoteName))
                                                        if (con2->isPersistent()) {
                                                                if (DEBUGLEVEL(DEBUG)) {
                                                                        printf("### [%s] Disconnected previous receiver: %s ###\n", (char*) name, (char*) con->remoteName);
                                                                }
                                                                // and disconnect it
                                                                con2->reset();
                                                                remoteReceiverCons->removeNoDelete(n);
                                                                n--;
                                                                if (DEBUGLEVEL(DETAILEDSTATUS)) {
                                                                        printf("### [%s] Now have these connections: ### \n\t%s\n", (char*) name, (char*) cons->printListLine("\n\t"));
                                                                }
                                                        }
                        }
                }

                return con;
        }
        else {
                con->reset();
                return NULL;
        }
}

NetworkConnection* Network::openReceivingConnection(const TCPLocation& loc) {
        if ((loc.netProtocolName.length() == 0) || (loc.netProtocolName.equalsIgnoreCase(preferredNetProtocol->name)))
                return openReceivingConnection(loc, getPreferredNetProtocol());
        else
                return openReceivingConnection(loc, new NetMessageProtocol());
}

NetworkConnection* Network::openReceivingConnection(const TCPLocation& loc, NetProtocol* netprotocol) {

        if (loc.name.equalsIgnoreCase(name)) {
        //      printf("*********** %s opening network to itself! ************", (char*) name);
                return false;
        }

        NetworkConnection* con = (NetworkConnection*) receiverCons->get(loc.name);
        if (con != NULL) {
                if (con->isConnected())
                        return con;
        }

        con = new NetworkConnection(loc, netprotocol, NULL);
        con->name = name;

        if (!con->initializeAsReceiver(receiver)) {
                delete(con);
                return NULL;
        }

        con->parent = this;
        if (loc.name.length() > 0)
                receiverCons->put(loc.name, con);
        else
                receiverCons->put(loc.asText(), con);
        return con;
}

bool Network::checkReceivingConnections() {

        NetworkConnection* con = NULL;
        NetworkConnection* newcon = NULL;
        JString key;
        for (int n=0; n<receiverCons->getCount(); n++) {
                key = receiverCons->getKey(n);
                con = (NetworkConnection*) receiverCons->get(key);
                newcon = NULL;
                if (con != NULL) {
                        if (con->isConnected()) {
                                if (DEBUGLEVEL(HEARTBEAT)) {
                                        printf("[%s] Callback to '%s' still valid!\n", (char*) name, (char*) key);
                                }
                        }
                        // else if (con->isBroken()) {
                        else {
                                TCPLocation loc = con->getLastConnectedTo();
                                NetProtocol* netprot = (NetProtocol*) con->netprotocol->clone();
                                con->reset();
                                receiverCons->remove(key);
                                if (loc.isValid()) {
                                        if (netprot != NULL)
                                                newcon = openReceivingConnection(loc, netprot);
                                        else
                                                newcon = openReceivingConnection(loc);
                                }
                                if (newcon != NULL) {
                                        if (DEBUGLEVEL(STATUS)) {
                                                printf("### Lost callback to '%s' (%s), re-established successfully!\n", (char*) key, (char*) loc.print());
                                        }
                                }
                                else {
                                        if (DEBUGLEVEL(STATUS))
                                                printf("### Lost callback to '%s' (%s) and was unable to re-establish!\n", (char*) key, (char*) loc.print());
                                        lostReceiveConnections.put(key, loc.clone());
                                //      if (receiver != NULL)
                                //              receiver->disconnectNotify(key, NULL);
                                }
                                // We changed the collection, recheck from the beginning
                                return checkReceivingConnections();
                        }
                }
        }

        return true;
}

bool Network::checkOpenConnections() {

        NetworkConnection* con = NULL;
        NetworkConnection* newcon = NULL;
        TCPLocation loc;
        NetProtocol* netprot = NULL;
        JString remoteName;
        for (int n=0; n<cons->getCount(); n++) {
                con = (NetworkConnection*) cons->get(n);
                newcon = NULL;
                if (con != NULL) {
                        remoteName = con->remoteName;
                        loc = con->getLastConnectedTo();
                        if (con->isConnected()) {
                                if (DEBUGLEVEL(HEARTBEAT)) {
                                        printf("%d: [%s] Connection to '%s' still valid!\n", n, (char*) name, (char*) remoteName);
                                }
                        }
                        else if (con->isBroken()) {
                                if (DEBUGLEVEL(STATUS)) {
                                        if (con->isRemoteCallback()) {
                                                printf("%d: [%s] Callback from '%s' broken!\n", n, (char*) name, (char*) remoteName);
                                                con->reset();
                                                continue;
                                        }
                                        else
                                                printf("%d: [%s] Connection to '%s' broken!\n", n, (char*) name, (char*) remoteName);
                                }

                                if (loc.isValid()) {

                                        if (con->netprotocol == NULL)
                                                netprot = NULL;
                                        else
                                                netprot = (NetProtocol*) con->netprotocol->clone();
                                        con->reset();

                                        if (netprot != NULL)
                                                newcon = openConnection(loc, netprot);
                                        else
                                                newcon = openConnection(loc);
                                        if ( (newcon != NULL) && (!newcon->ping(name, loc.name)) ) {
                                                // delete(newcon);
                                                newcon->reset();
                                                newcon = NULL;
                                        }

                                        if (newcon != NULL) {
                                                if (DEBUGLEVEL(STATUS)) {
                                                        printf("### Lost connection to '%s' (%s), re-established successfully!\n", (char*) remoteName, (char*) loc.print());
                                                }
                                        }
                                        else {
                                        if (DEBUGLEVEL(STATUS))
                                                        printf("### Lost connection to '%s' (%s) and was unable to re-establish!\n", (char*) remoteName, (char*) loc.print());
                                                lostSendConnections.put(remoteName, loc.clone());
                                                if (receiver != NULL)
                                                        receiver->disconnectNotify(remoteName, NULL);
                                        }
                                }
                                else
                                        con->reset();
                        }
                        else {
                                if (DEBUGLEVEL(HEARTBEAT)) {
                                        printf("%d: [%s] Connection to '%s' reset!\n", n, (char*) name, (char*) remoteName);
                                }
                        }
                }
        }

        return true;
}

bool Network::tryReconnectingLostConnections() {
        int n;
        TCPLocation* loc;
        NetworkConnection* con;
        for (n=0; n<lostSendConnections.getCount(); n++) {
                loc = (TCPLocation*) lostSendConnections.get(n);
                if (loc != NULL) {
                        if ( (con = openConnection(*loc)) != NULL ) {
                                if (con->ping(name, loc->name)) {
                                        if (DEBUGLEVEL(STATUS)) {
                                                printf("### Lost connection to '%s' (%s) was reconnected successfully!\n", (char*) loc->name, (char*) loc->print());
                                        }
                                        lostSendConnections.remove(n);
                                        n--;
                                }
                                else {
                                        con->reset();
                                        // delete(con);
                                }
                        }
                }
        }

        for (n=0; n<lostReceiveConnections.getCount(); n++) {
                loc = (TCPLocation*) lostReceiveConnections.get(n);
                if (loc != NULL) {
                        if (openReceivingConnection(*loc)) {
                                if (DEBUGLEVEL(STATUS)) {
                                        printf("### Lost callback to '%s' (%s) was reconnected successfully!\n", (char*) loc->name, (char*) loc->print());
                                }
                                lostReceiveConnections.remove(n);
                                n--;
                        }
                }
        }
        return true;

}


bool Network::checkPrimaryConnection() {
        if (primaryLoc == NULL)
                return true;

        if (primaryCon == NULL) {
                if (DEBUGLEVEL(STATUS))
                        printf("### Primary connection NULL, trying to connect...\n");
                if (setPrimaryConnection(*primaryLoc)) {
                        if (DEBUGLEVEL(STATUS))
                                printf("### Primary connection reconnected after NULL...\n");
                        if (receiver != NULL)
                                receiver->primaryReconnectNotify();
                        return true;
                }
                else {
                        if (DEBUGLEVEL(STATUS))
                                printf("### Primary connection failed after NULL...\n");
                        if (receiver != NULL)
                                receiver->primaryDisconnectNotify();
                        return false;
                }
                        
        }

        if (!primaryMutex.EnterMutex(1000))
                return false;
        if (!primaryCon->isConnectedTo(primaryLoc->name)) {
                bool wasConnected = true;
                if (primaryCon->isReset()) {
                        if (DEBUGLEVEL(STATUS))
                                printf("### Primary connection no longer connected and reset...\n");
                        wasConnected = false;
                }
                else {
                        if (DEBUGLEVEL(STATUS))
                                printf("### Primary connection broken...\n");
                        primaryCon->reset();
                }
                if (primaryCon->restart(*primaryLoc, getPreferredNetProtocol(), NULL)) {
                        primaryCon->parent = this;
                        if (primaryCon->ping(name, primaryLoc->name)) {
                                if (DEBUGLEVEL(STATUS))
                                        printf("### Primary connection reconnected and ping success...\n");
                                primaryMutex.LeaveMutex();
                                if (receiver != NULL)
                                        receiver->primaryReconnectNotify();
                                return true;
                        }
                        else {
                                if (DEBUGLEVEL(STATUS))
                                        printf("### Primary connection reconnected, but ping failed, resetting......\n");
                                primaryCon->reset();
                                primaryMutex.LeaveMutex();
                                if ((receiver != NULL) && (wasConnected))
                                        receiver->primaryDisconnectNotify();
                                return false;
                        }
                }
                else {
                        if (DEBUGLEVEL(STATUS))
                                printf("### Primary connection did not reconnect...\n");
                        primaryCon->reset();
                        primaryMutex.LeaveMutex();
                        if ((receiver != NULL) && (wasConnected))
                                receiver->primaryDisconnectNotify();
                        return false;
                }
        }
        primaryMutex.LeaveMutex();
        return true;
}

bool Network::setPrimaryConnection(const JString& addr, int port, const JString& name) {
        TCPLocation loc = TCPLocation(addr, port, name);
        return setPrimaryConnection(loc);
}

bool Network::setPrimaryConnection(const TCPLocation& loc) {
        if (!loc.isValid())
                return false;
        if (primaryLoc != NULL)
                delete(primaryLoc);
        primaryLoc = (TCPLocation*) loc.clone();

        if (!primaryMutex.EnterMutex(1000))
                return false;
        if (primaryCon != NULL) {
                if (primaryCon->isConnectedTo(loc.name)) {
                        primaryMutex.LeaveMutex();
                        return true;
                }
                else {
                        primaryCon->reset();
                        primaryCon->restart(*primaryLoc, getPreferredNetProtocol(), NULL);
                }
        }
        else {
                primaryCon = new NetworkConnection(*primaryLoc, getPreferredNetProtocol(), NULL);
                primaryCon->name = name;
        }

        primaryCon->parent = this;
        if (primaryCon->ping(name, primaryLoc->name)) {
                primaryMutex.LeaveMutex();
                return true;
        }
        else {
                primaryMutex.LeaveMutex();
                return false;
        }
}

bool Network::isPrimaryConnection(const JString& name) {
        if (primaryLoc == NULL) 
                return false;
        else
                return (primaryLoc->name.equalsIgnoreCase(name));
}



bool Network::isCurrentlyConnectedTo(const JString& name) {

        if ( name.length() == 0 )
                return false;

        if ( (isPrimaryConnection(name)) && (checkPrimaryConnection()) )
                return (primaryCon != NULL);

        NetworkConnection* con = NULL;
        for (int n=cons->getCount()-1; n>=0; n--) {
                con = (NetworkConnection*) cons->get(n);
                if (con != NULL)
                        if (con->isConnectedTo(name))
                                if (!con->isReceiver())
                                        if (con->isPersistent()) {
                                                return true;
                                        }
        }

        return false;
}


NetworkConnection* Network::findConnectedConnection(const JString& name) {

        if ( name.length() == 0 )
                return NULL;

        if (DEBUGLEVEL(KITCHENSINK)) {
                printf("[%s] Trying to find connection to send on to %s out of: \n\t%s\n", (char*) this->name, (char*) name, (char*) cons->printListLine("\n\t"));
        }

        if ( (isPrimaryConnection(name)) && (checkPrimaryConnection()) )
                return primaryCon;

        NetworkConnection* con = NULL;
        for (int n=cons->getCount()-1; n>=0; n--) {
                con = (NetworkConnection*) cons->get(n);
                if (con != NULL) {
                        if (DEBUGLEVEL(DETAILEDSTATUS)) {
                        //      printf("   ??? %s == %s\n", (char*) con->print(), (char*) name);
                        }
                        if (con->isConnectedTo(name)) {
                                if (!con->isReceiver()) {
                                        if (con->isPersistent()) {
                                                if (DEBUGLEVEL(DETAILEDSTATUS)) {
                                                        printf("[%s] Found connection to send on to %s: %s\n", (char*) this->name, (char*) name, (char*) con->print());
                                                }
                                                return con;
                                        }
                                }
                        }
                }
        }

        if (DEBUGLEVEL(DETAILEDSTATUS)) {
                printf("[%s] Found no connection to send on to %s\n", (char*) this->name, (char*) name);
        }
        return NULL;

}

NetworkConnection* Network::findConnectedConnection(const TCPLocation& loc, NetProtocol* netprotocol) {

        if ( (!loc.isValid()) || (netprotocol == NULL) )
                return NULL;

        if ( (isPrimaryConnection(loc.name)) && (checkPrimaryConnection()) && (netprotocol->equals(primaryCon->netprotocol)) )
                return primaryCon;

        NetworkConnection* con = NULL;
        for (int n=cons->getCount()-1; n>=0; n--) {
                con = (NetworkConnection*) cons->get(n);
                if (con != NULL)
                        if (con->isConnectedTo(loc))
                                if (netprotocol->equals(con->netprotocol))
                                        if (!con->isReceiver())
                                                if (con->isPersistent())
                                                        return con;
        }

        return NULL;
}

NetworkConnection* Network::findResetConnection() {

        NetworkConnection* con = NULL;

        int count = cons->getCount();

//      printf("Network contains %d cons...\n", count);

        for (int n=0; n<count; n++) {
                con = (NetworkConnection*) cons->get(n);
                if (con->isReset()) {
                        return con;
                }
        }

        // Oh well, no idle ones...
        return NULL;
}


Message* Network::receiveTCPInput(Message* msg) {
        return NULL;
}

// For testing only
Message* Network::netObjectReceive(Message* msg, NetworkConnection* con) {
        
        if (msg == NULL)
                return NULL;

        bool noreply = (msg->noreply.length() > 0);

        Message* rmsg = new Message();
//      JString str = msg.toXML();
        JString type = msg->getType();
        JString content = msg->getContent();
        if ((type.equals("HTTP")) && (msg->getObject() != NULL)) {
                printf("Tester received HTTP message!\n");
        }
        else if ((type.equals("TelnetInput")) && (content.length() > 0)) {
                // printf("Tester received Telnet message!\n");
                rmsg->setContent(JString("You said: ") + msg->getContent(), "");
        }
        else {
                if (type.equalsIgnoreCase("MediaTest")) {
                        DataSample* sample = (DataSample*) msg->takeObject();
                        if (sample == NULL) {
                                printf("Tester received empty Media message!\n");
                        }
                        else if (sample->getDataLink() == NULL) {
                                printf("Tester received Media message with no data!\n");
                        }
                        else {
                                char ch = sample->getDataLink()[0];
                                memset(sample->getDataLink(), ch+1, sample->getDataSize());
                                rmsg->setType(type);
                                rmsg->setObject(sample);
                                rmsg->setType("BinaryOnly");
                        }
                }
                else if (type.equalsIgnoreCase("MediaTest2")) {
                        ObjectCollection* col = (ObjectCollection*) msg->takeObject();
                        if (col != NULL) {
                                rmsg->setType(type);
                                rmsg->setObject(col);
                        }
                        else {
                                printf("Tester received empty Media Collection Message!\n");
                        }
                }
                else {
                        rmsg->setType(type);
                        rmsg->setContent(content + "x", "");
                        // printf("Content: %s -> %s\n", (char*) content, (char*) rmsg.getContent());
                }
        }

        delete(msg);
        return rmsg;
}

JString Network::getName() {
        return name;
}

int Network::getPort() {
        return port;
}

int Network::getConnectionCount() {
        return cons->getCount();
}

int Network::getSendingConnectionCount(const JString& name) {

        if ( name.length() == 0 )
                return 0;

        if ( (isPrimaryConnection(name)) && (checkPrimaryConnection()) ) {
                if (primaryCon != NULL)
                        return 1;
                else
                        return 0;
        }

        //Collection names;
        int count = 0;
        NetworkConnection* con = NULL;
        for (int n=cons->getCount()-1; n>=0; n--) {
                con = (NetworkConnection*) cons->get(n);
                if ( (con != NULL) && (!con->isReceiver()) ) {
                        //names.add(con->remoteName);
                        if (con->remoteName.equals(name)) {
                                if (con->isConnected())
                                        count++;
                        }
                }
        }

        //printf("SendingCons [%d]: %s\n", count, (char*) names.printListLine(","));
        return count;
}

int Network::getReceivingConnectionCount(const JString& name) {

        if ( name.length() == 0 )
                return 0;

        if ( (isPrimaryConnection(name)) && (checkPrimaryConnection()) ) {
                if (primaryCon != NULL)
                        return 1;
                else
                        return 0;
        }

        //Collection names;
        int count = 0;
        NetworkConnection* con = NULL;
        for (int n=cons->getCount()-1; n>=0; n--) {
                con = (NetworkConnection*) cons->get(n);
                if ( (con != NULL) && (con->isReceiver()) ) {
                        //names.add(con->remoteName);
                        if (con->remoteName.equals(name)) {
                                if (con->isConnected())
                                        count++;
                        }
                }
        }

        //printf("SendingCons [%d]: %s\n", count, (char*) names.printListLine(","));
        return count;
}

bool Network::trainNetworkProfile(const TCPLocation& loc, ConnectionProfile* profile) {
        if ((profile == NULL) || (!loc.isValid()))
                return false;
        NetworkConnection* con = openConnection(loc);
        if (con == NULL)
                return false;
        return con->trainNetworkProfile(profile);
}


















/////////////////////////////////////////////////////////////////

bool Network::unitTest() {

        printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); fflush(stdout);


        this->receiver = this;

        this->addProtocol(new NetMessageProtocol());
        this->addProtocol(new NetOriginalMessageProtocol());
        this->addProtocol(new NetHTTPProtocol());
        this->addProtocol(new NetTelnetProtocol());


        // Testing Message Protocol

        Message* hmsg = new Message("Test", "Test", "Test", "Test", "");;
        JTime t1, t2;
        int i;

        NetworkConnection* con = NULL;
        JString str = "Test";
        JString str2 = "Test";

        int maxcount = 20;

        str = "Test";
        str2 = "Test";
        t1 = JTime();
        for (i = 0; i < maxcount; i++) {
                printf(".\b"); fflush(stdout);
                con = new NetworkConnection("localhost", port, new NetOriginalMessageProtocol(), NULL);
                con->name = name;
                printf("o\b"); fflush(stdout);
                if (con->sendObject(hmsg, false)) {
                        printf("O\b"); fflush(stdout);
                        delete(hmsg);
                        hmsg = con->receiveObject(1000);
                        if (hmsg == NULL) {
                                this->addUnitTestLog(JString("Error: No response message! "));
                                printf("[Network] Error: No response message!\n");
                                delete(con);
                                return false;
                        }
                        else {
                                str = hmsg->getContent();
                                str2 = str2 + "x";
                                if (!str.equals(str2)) {
                                        this->addUnitTestLog(JString("Error in receiving message2: ") + hmsg->getContent());
                                        printf("[Network] Error in receiving message2: %s\n", (char*) str);
                                        delete(con);
                                        delete(hmsg);
                                        return false;
                                }
                        }
                        printf(" \b"); fflush(stdout);
                }
                else {
                        delete(hmsg);
                        printf("\n [Network] Could not write data to socket, giving up...\n\n");
                }
                wait(5);
                delete(con);
        }
        t2 = JTime();
//      printf("[Network] NetOriginalMessageProtocol test success in %d ms\n", (int)((t2-t1)/i)-5);
        
        delete(hmsg);
//      con->terminate();


        hmsg = new Message("Test", "Test", "Test", "Test", "");
        str = "Test";
        str2 = "Test";
        t1 = JTime();
        for (i = 0; i < maxcount; i++) {
                printf("O.\b\b"); fflush(stdout);
//              con = new NetworkConnection("localhost", port, new NetMessageProtocol(), this);
                con = new NetworkConnection("localhost", port, new NetMessageProtocol(), NULL);
                con->name = name;
//              con = new NetworkConnection("localhost", port, new NetOriginalMessageProtocol(), this);
        //      printf("S"); fflush(stdout);
                printf("Oo\b\b"); fflush(stdout);
                if (con->sendObject(hmsg, false)) {
                        // printf("R"); fflush(stdout);
                        printf("OO\b\b"); fflush(stdout);
                        delete(hmsg);
                        hmsg = con->receiveObject(200);
                        if (hmsg == NULL) {
        //                      printf("X"); fflush(stdout);
                                this->addUnitTestLog(JString("Error: No response message! "));
                                printf("[Network] Error: No response message!\n");
                                delete(con);
                                return false;
                        }
                        else {
        //                      printf("?"); fflush(stdout);
                                str = hmsg->getContent();
                                str2 = str2 + "x";
//                              if (!str.equals(str = str + "x")) {
                                if (!str.equals(str2)) {
                                        this->addUnitTestLog(JString("Error in receiving message: ") + hmsg->getContent());
                                        printf("[Network] Error in receiving message: %s\n", (char*) str);
                                        delete(con);
                                        delete(hmsg);
                                        return false;
                                }
                        }
                        printf("O \b\b"); fflush(stdout);
                        // printf("! "); fflush(stdout);
                }
                else {
                        delete(hmsg);
                        printf("\nCould not write data to socket, giving up...\n\n");
                }
                delete(con);
                wait(5);
        }
        t2 = JTime();

//      printf("NetMessageProtocol test success in %d ms\n", (int)((t2-t1)/i)-5);

        delete(hmsg);


        // Testing Binary Messaging


        maxcount = 10;
        int datasize = 50000;
        char* data;
        DataSample* sample;
        char ch;
        ObjectCollection* datacol;
        con = new NetworkConnection("localhost", port, new NetMessageProtocol(), NULL);
        con->name = name;

        printf("OOm\b\b\b"); fflush(stdout);
        t1 = JTime();
        for (i=0; i<maxcount; i++) {

//              printf("OO.\b\b\b"); fflush(stdout);
                data = new char[datasize];
                memset(data, '1', datasize);
                sample = new DataSample("1");
                sample->giveData(data, datasize, 5);

                hmsg = new Message("", "", "MediaTest", sample);

                if (con->sendObject(hmsg, false)) {
                        // printf("R"); fflush(stdout);
                //      printf("OOm\b\b\b"); fflush(stdout);
                        delete(hmsg);
                        hmsg = con->receiveObject(2000);
                        if (hmsg == NULL) {
                                this->addUnitTestLog(JString("Error in receiving media message 1"));
                                printf("[Network] Error in receiving media message 1 [%d]\n", i);
                                delete(con);
                                return false;
                        }
                        sample = (DataSample*) hmsg->takeObject();
                        if (sample == NULL) {
                                printf("UnitTest received empty Media message!\n");
                                delete(con);
                                delete(hmsg);
                                return false;
                        }
                        else if (sample->getDataLink() == NULL) {
                                printf("UnitTest received Media message with no data!\n");
                                delete(con);
                                delete(hmsg);
                                delete(sample);
                                return false;
                        }
                        else {
                                ch = sample->getDataLink()[0];
                                if (ch != '2') {
                                        printf("UnitTest received wrong Media sample!\n");
                                        delete(con);
                                        delete(hmsg);
                                        delete(sample);
                                        return false;
                                }
                        }
                        delete(hmsg);
                        delete(sample);
                }
                else {
                        this->addUnitTestLog(JString("Error in sending media message 1"));
                        printf("[Network] Error in sending media message 1 [%d]\n", i);
                        delete(con);
                        delete(hmsg);
                        return false;
                }

                t2 = JTime();
        }

        double perf = (datasize*maxcount*2) * (1000000.0/t2.microDifference(t1));
//      JString perfStr = JString(perf,2) + "/";
//      printf("%skb/s  ", (char*) JString(perfStr,9, 1));


        printf("OOMm\b\b\b\b"); fflush(stdout);
        int chunks = 10;
        t1 = JTime();
        for (i=0; i<maxcount; i++) {

//              printf("OOM.\b\b\b\b"); fflush(stdout);

                datacol = new ObjectCollection();
                for (int q=0; q<chunks; q++) {
                        ch = 48+q;
                        data = new char[datasize];
                        memset(data, ch, datasize);
                        sample = new DataSample(JString(q));
                        sample->giveData(data, datasize, 5);
                        datacol->add(sample);
                }

                hmsg = new Message("", "", "MediaTest2", datacol);

                if (con->sendObject(hmsg, false)) {
                        // printf("R"); fflush(stdout);
                //      printf("OOMm\b\b\b\b"); fflush(stdout);
                        delete(hmsg);
                        hmsg = con->receiveObject(2000);
                        if (hmsg == NULL) {
                                this->addUnitTestLog(JString("Error in receiving media message 2"));
                                printf("[Network] Error in receiving media message 2\n");
                                delete(con);
                                delete(hmsg);
                                return false;
                        }
                        datacol = (ObjectCollection*) hmsg->takeObject();
                        if (datacol == NULL) {
                                printf("UnitTest received empty Media Collection message!\n");
                                delete(con);
                                delete(hmsg);
                                return false;
                        }
                        else {
                                for (int qq = 0; qq<datacol->getCount(); qq++) {
                                        sample = (DataSample*) datacol->get(qq);
                                        if (sample == NULL) {
                                                printf("UnitTest received no Media Collection sample!\n");
                                                delete(datacol);
                                                delete(con);
                                                delete(hmsg);
                                                return false;
                                        }
                                        else if (sample->getDataLink() == NULL) {
                                                printf("UnitTest received empty Media Collection sample!\n");
                                                delete(datacol);
                                                delete(con);
                                                delete(hmsg);
                                                return false;
                                        }
                                        else {
                                                ch = sample->getDataLink()[0];
                                                if (ch != 48+qq) {
                                                        printf("UnitTest received wrong Media Collection sample!\n");
                                                        delete(datacol);
                                                        delete(con);
                                                        delete(hmsg);
                                                        return false;
                                                }
                                        }
                                }
                        }
                        delete(datacol);
                        delete(hmsg);
                }
                else {
                        this->addUnitTestLog(JString("Error in sending media message 1"));
                        printf("[Network] Error in sending media message1\n");
                        delete(con);
                        delete(hmsg);
                        return false;
                }

                // printf("OOMM\b\b\b\b"); fflush(stdout);
        }
        t2 = JTime();
        printf("OOMM\b\b\b\b"); fflush(stdout);

        delete(con);

        JString perfStr = JString::bytifyRates(perf,
                (datasize*chunks*maxcount*2) * (1000000.0/t2.microDifference(t1)) );

        printf("%s", (char*) JString(perfStr,47, 0));

        return true;
}













} // namespace cmlabs

---