Пример #1
0
void ThreadedAssignment::setFinished(bool isFinished) {
    if (_isFinished != isFinished) {
         _isFinished = isFinished;

        if (_isFinished) {

            qCDebug(networking) << "ThreadedAssignment::setFinished(true) called - finishing up.";
            
            auto nodeList = DependencyManager::get<NodeList>();
            
            auto& packetReceiver = nodeList->getPacketReceiver();

            // we should de-register immediately for any of our packets
            packetReceiver.unregisterListener(this);

            // we should also tell the packet receiver to drop packets while we're cleaning up
            packetReceiver.setShouldDropPackets(true);
            
            // send a disconnect packet to the domain
            nodeList->getDomainHandler().disconnect();

            // stop our owned timers
            _domainServerTimer.stop();
            _statsTimer.stop();

            // call our virtual aboutToFinish method - this gives the ThreadedAssignment subclass a chance to cleanup
            aboutToFinish();

            emit finished();
        }
    }
}
Пример #2
0
MessagesClient::MessagesClient() {
    setCustomDeleter([](Dependency* dependency){
        static_cast<MessagesClient*>(dependency)->deleteLater();
    });
    auto nodeList = DependencyManager::get<NodeList>();
    auto& packetReceiver = nodeList->getPacketReceiver();
    packetReceiver.registerMessageListener(PacketType::MessagesData, this, "handleMessagesPacket");
    connect(nodeList.data(), &LimitedNodeList::nodeActivated, this, &MessagesClient::handleNodeActivated);
}
Пример #3
0
AssetClient::AssetClient() {
    
    setCustomDeleter([](Dependency* dependency){
        static_cast<AssetClient*>(dependency)->deleteLater();
    });
    
    auto nodeList = DependencyManager::get<NodeList>();
    auto& packetReceiver = nodeList->getPacketReceiver();
    packetReceiver.registerListener(PacketType::AssetGetInfoReply, this, "handleAssetGetInfoReply");
    packetReceiver.registerListener(PacketType::AssetGetReply, this, "handleAssetGetReply", true);
    packetReceiver.registerListener(PacketType::AssetUploadReply, this, "handleAssetUploadReply");

    connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &AssetClient::handleNodeKilled);
}
Пример #4
0
void ATPClientApp::finish(int exitCode) {
    auto nodeList = DependencyManager::get<NodeList>();

    // send the domain a disconnect packet, force stoppage of domain-server check-ins
    nodeList->getDomainHandler().disconnect();
    nodeList->setIsShuttingDown(true);

    // tell the packet receiver we're shutting down, so it can drop packets
    nodeList->getPacketReceiver().setShouldDropPackets(true);

    // remove the NodeList from the DependencyManager
    DependencyManager::destroy<NodeList>();

    QCoreApplication::exit(exitCode);
}
Пример #5
0
AssetClient::AssetClient() {
    _cacheDir = qApp->property(hifi::properties::APP_LOCAL_DATA_PATH).toString();
    setCustomDeleter([](Dependency* dependency){
        static_cast<AssetClient*>(dependency)->deleteLater();
    });

    auto nodeList = DependencyManager::get<NodeList>();
    auto& packetReceiver = nodeList->getPacketReceiver();

    packetReceiver.registerListener(PacketType::AssetMappingOperationReply, this, "handleAssetMappingOperationReply");
    packetReceiver.registerListener(PacketType::AssetGetInfoReply, this, "handleAssetGetInfoReply");
    packetReceiver.registerListener(PacketType::AssetGetReply, this, "handleAssetGetReply", true);
    packetReceiver.registerListener(PacketType::AssetUploadReply, this, "handleAssetUploadReply");

    connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &AssetClient::handleNodeKilled);
    connect(nodeList.data(), &LimitedNodeList::clientConnectionToNodeReset,
            this, &AssetClient::handleNodeClientConnectionReset);
}
void ccPacketHandler::acknowledge()

{

    byte sender = getPacketSender(); /// save sender

    byte receiver = getPacketReceiver(); /// save receiver

    byte ulf = ccHash(); /// hash the data

    clearPacket(); /// clear the packet

    setReceiver(sender); /// set sender as receiver

    setSender(receiver); /// set receiver as sender

    setAdminKey(ACKNOWLEDGE_REQUEST); /// set acknowlegde key

    setPackNum(ulf); /// set the hash as data

}
Пример #7
0
AudioMixer::AudioMixer(ReceivedMessage& message) :
    ThreadedAssignment(message),
    _trailingSleepRatio(1.0f),
    _minAudibilityThreshold(LOUDNESS_TO_DISTANCE_RATIO / 2.0f),
    _performanceThrottlingRatio(0.0f),
    _attenuationPerDoublingInDistance(DEFAULT_ATTENUATION_PER_DOUBLING_IN_DISTANCE),
    _noiseMutingThreshold(DEFAULT_NOISE_MUTING_THRESHOLD)
{
    auto nodeList = DependencyManager::get<NodeList>();
    auto& packetReceiver = nodeList->getPacketReceiver();

    packetReceiver.registerListenerForTypes({ PacketType::MicrophoneAudioNoEcho, PacketType::MicrophoneAudioWithEcho,
                                              PacketType::InjectAudio, PacketType::SilentAudioFrame,
                                              PacketType::AudioStreamStats },
                                            this, "handleNodeAudioPacket");
    packetReceiver.registerListener(PacketType::MuteEnvironment, this, "handleMuteEnvironmentPacket");
    packetReceiver.registerListener(PacketType::NegotiateAudioFormat, this, "handleNegotiateAudioFormat");
    packetReceiver.registerListener(PacketType::NodeIgnoreRequest, this, "handleNodeIgnoreRequestPacket");

    connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled);
}
Пример #8
0
Wallet::Wallet() {
    auto nodeList = DependencyManager::get<NodeList>();
    auto ledger = DependencyManager::get<Ledger>();
    auto& packetReceiver = nodeList->getPacketReceiver();
    _passphrase = new QString("");

    packetReceiver.registerListener(PacketType::ChallengeOwnership, this, "handleChallengeOwnershipPacket");
    packetReceiver.registerListener(PacketType::ChallengeOwnershipRequest, this, "handleChallengeOwnershipPacket");

    connect(ledger.data(), &Ledger::accountResult, this, [](QJsonObject result) {
        auto wallet = DependencyManager::get<Wallet>();
        auto walletScriptingInterface = DependencyManager::get<WalletScriptingInterface>();
        uint status;
        QString keyStatus = result.contains("data") ? result["data"].toObject()["keyStatus"].toString() : "";

        if (wallet->getKeyFilePath().isEmpty() || !wallet->getSecurityImage()) {
            if (keyStatus == "preexisting") {
                status = (uint) WalletStatus::WALLET_STATUS_PREEXISTING;
            } else {
                status = (uint) WalletStatus::WALLET_STATUS_NOT_SET_UP;
            }
        } else if (!wallet->walletIsAuthenticatedWithPassphrase()) {
            status = (uint) WalletStatus::WALLET_STATUS_NOT_AUTHENTICATED;
        } else if (keyStatus == "conflicting") {
            status = (uint) WalletStatus::WALLET_STATUS_CONFLICTING;
        } else {
            status = (uint) WalletStatus::WALLET_STATUS_READY;
        }
        walletScriptingInterface->setWalletStatus(status);
    });

    connect(ledger.data(), &Ledger::accountResult, this, &Wallet::sendChallengeOwnershipResponses);

    auto accountManager = DependencyManager::get<AccountManager>();
    connect(accountManager.data(), &AccountManager::usernameChanged, this, [&]() {
        getWalletStatus();
        clear();
    });
}
Пример #9
0
Wallet::Wallet() {
    auto nodeList = DependencyManager::get<NodeList>();
    auto ledger = DependencyManager::get<Ledger>();
    auto& packetReceiver = nodeList->getPacketReceiver();

    packetReceiver.registerListener(PacketType::ChallengeOwnership, this, "handleChallengeOwnershipPacket");
    packetReceiver.registerListener(PacketType::ChallengeOwnershipRequest, this, "handleChallengeOwnershipPacket");

    connect(ledger.data(), &Ledger::accountResult, this, [&]() {
        auto wallet = DependencyManager::get<Wallet>();
        auto walletScriptingInterface = DependencyManager::get<WalletScriptingInterface>();
        uint status;

        if (wallet->getKeyFilePath() == "" || !wallet->getSecurityImage()) {
            status = (uint)WalletStatus::WALLET_STATUS_NOT_SET_UP;
        } else if (!wallet->walletIsAuthenticatedWithPassphrase()) {
            status = (uint)WalletStatus::WALLET_STATUS_NOT_AUTHENTICATED;
        } else {
            status = (uint)WalletStatus::WALLET_STATUS_READY;
        }

        walletScriptingInterface->setWalletStatus(status);
    });

    auto accountManager = DependencyManager::get<AccountManager>();
    connect(accountManager.data(), &AccountManager::usernameChanged, this, [&]() {
        getWalletStatus();
        _publicKeys.clear();

        if (_securityImage) {
            delete _securityImage;
        }
        _securityImage = nullptr;

        // tell the provider we got nothing
        updateImageProvider();
        _passphrase->clear();
    });
}
Пример #10
0
void AssignmentClient::assignmentCompleted() {
    // we expect that to be here the previous assignment has completely cleaned up
    assert(_currentAssignment.isNull());

    // reset our current assignment pointer to null now that it has been deleted
    _currentAssignment = nullptr;

    // reset the logging target to the the CHILD_TARGET_NAME
    LogHandler::getInstance().setTargetName(ASSIGNMENT_CLIENT_TARGET_NAME);

    qCDebug(assigmnentclient) << "Assignment finished or never started - waiting for new assignment.";

    auto nodeList = DependencyManager::get<NodeList>();

    // tell the packet receiver to stop dropping packets
    nodeList->getPacketReceiver().setShouldDropPackets(false);

    // reset our NodeList by switching back to unassigned and clearing the list
    nodeList->setOwnerType(NodeType::Unassigned);
    nodeList->reset();
    nodeList->resetNodeInterestSet();
    
    _isAssigned = false;
}
Пример #11
0
NodeList::NodeList(char newOwnerType, unsigned short socketListenPort, unsigned short dtlsListenPort) :
    LimitedNodeList(socketListenPort, dtlsListenPort),
    _ownerType(newOwnerType),
    _nodeTypesOfInterest(),
    _domainHandler(this),
    _numNoReplyDomainCheckIns(0),
    _assignmentServerSocket(),
    _keepAlivePingTimer(this)
{
    setCustomDeleter([](Dependency* dependency){
        static_cast<NodeList*>(dependency)->deleteLater();
    });
    
    auto addressManager = DependencyManager::get<AddressManager>();

    // handle domain change signals from AddressManager
    connect(addressManager.data(), &AddressManager::possibleDomainChangeRequired,
            &_domainHandler, &DomainHandler::setHostnameAndPort);

    connect(addressManager.data(), &AddressManager::possibleDomainChangeRequiredViaICEForID,
            &_domainHandler, &DomainHandler::setIceServerHostnameAndID);

    // handle a request for a path change from the AddressManager
    connect(addressManager.data(), &AddressManager::pathChangeRequired, this, &NodeList::handleDSPathQuery);

    // in case we don't know how to talk to DS when a path change is requested
    // fire off any pending DS path query when we get socket information
    connect(&_domainHandler, &DomainHandler::connectedToDomain, this, &NodeList::sendPendingDSPathQuery);

    // send a domain server check in immediately once the DS socket is known
    connect(&_domainHandler, &DomainHandler::completedSocketDiscovery, this, &NodeList::sendDomainServerCheckIn);

    // send a domain server check in immediately if there is a public socket change
    connect(this, &LimitedNodeList::publicSockAddrChanged, this, &NodeList::sendDomainServerCheckIn);

    // clear our NodeList when the domain changes
    connect(&_domainHandler, &DomainHandler::disconnectedFromDomain, this, &NodeList::reset);

    // send an ICE heartbeat as soon as we get ice server information
    connect(&_domainHandler, &DomainHandler::iceSocketAndIDReceived, this, &NodeList::handleICEConnectionToDomainServer);

    // handle ping timeout from DomainHandler to establish a connection with auto networked domain-server
    connect(&_domainHandler.getICEPeer(), &NetworkPeer::pingTimerTimeout, this, &NodeList::pingPunchForDomainServer);

    // send a ping punch immediately
    connect(&_domainHandler, &DomainHandler::icePeerSocketsReceived, this, &NodeList::pingPunchForDomainServer);

    auto &accountManager = AccountManager::getInstance();
    
    // assume that we may need to send a new DS check in anytime a new keypair is generated 
    connect(&accountManager, &AccountManager::newKeypair, this, &NodeList::sendDomainServerCheckIn);

    // clear out NodeList when login is finished
    connect(&accountManager, &AccountManager::loginComplete , this, &NodeList::reset);

    // clear our NodeList when logout is requested
    connect(&accountManager, &AccountManager::logoutComplete , this, &NodeList::reset);

    // anytime we get a new node we will want to attempt to punch to it
    connect(this, &LimitedNodeList::nodeAdded, this, &NodeList::startNodeHolePunch);
    
    // setup our timer to send keepalive pings (it's started and stopped on domain connect/disconnect)
    _keepAlivePingTimer.setInterval(KEEPALIVE_PING_INTERVAL_MS);
    connect(&_keepAlivePingTimer, &QTimer::timeout, this, &NodeList::sendKeepAlivePings);
    connect(&_domainHandler, SIGNAL(connectedToDomain(QString)), &_keepAlivePingTimer, SLOT(start()));
    connect(&_domainHandler, &DomainHandler::disconnectedFromDomain, &_keepAlivePingTimer, &QTimer::stop);

    // we definitely want STUN to update our public socket, so call the LNL to kick that off
    startSTUNPublicSocketUpdate();

    auto& packetReceiver = getPacketReceiver();
    packetReceiver.registerListener(PacketType::DomainList, this, "processDomainServerList");
    packetReceiver.registerListener(PacketType::Ping, this, "processPingPacket");
    packetReceiver.registerListener(PacketType::PingReply, this, "processPingReplyPacket");
    packetReceiver.registerListener(PacketType::ICEPing, this, "processICEPingPacket");
    packetReceiver.registerListener(PacketType::DomainServerAddedNode, this, "processDomainServerAddedNode");
    packetReceiver.registerListener(PacketType::DomainServerConnectionToken, this, "processDomainServerConnectionTokenPacket");
    packetReceiver.registerListener(PacketType::DomainConnectionDenied, &_domainHandler, "processDomainServerConnectionDeniedPacket");
    packetReceiver.registerListener(PacketType::DomainSettings, &_domainHandler, "processSettingsPacketList");
    packetReceiver.registerListener(PacketType::ICEServerPeerInformation, &_domainHandler, "processICEResponsePacket");
    packetReceiver.registerListener(PacketType::DomainServerRequireDTLS, &_domainHandler, "processDTLSRequirementPacket");
    packetReceiver.registerListener(PacketType::ICEPingReply, &_domainHandler, "processICEPingReplyPacket");
    packetReceiver.registerListener(PacketType::DomainServerPathResponse, this, "processDomainServerPathResponse");
    packetReceiver.registerListener(PacketType::DomainServerRemovedNode, this, "processDomainServerRemovedNode");
}