C++ AuthenticationClient类代码示例

void AuthenticationManager::useCredentialForSingleChallenge(uint64_t challengeID, const Credential& credential, const CertificateInfo& certificateInfo)
{
    auto challenge = m_challenges.take(challengeID);
    ASSERT(!challenge.challenge.isNull());

    if (tryUseCertificateInfoForChallenge(challenge.challenge, certificateInfo))
        return;

    AuthenticationClient* coreClient = challenge.challenge.authenticationClient();
#if USE(NETWORK_SESSION)
    // If there is a completion handler, then there is no AuthenticationClient.
    // FIXME: Remove the use of AuthenticationClient in WebKit2 once NETWORK_SESSION is used for all loads.
    if (challenge.completionHandler) {
        ASSERT(!coreClient);
        challenge.completionHandler(AuthenticationChallengeDisposition::UseCredential, credential);
        return;
    }
#else
    if (!coreClient) {
        // FIXME: The authentication client is null for downloads, but it can also be null for canceled loads.
        // We should not call Download::receivedCredential in the latter case.
        Download::receivedCredential(challenge.challenge, credential);
        return;
    }
#endif

    ASSERT(coreClient);
    coreClient->receivedCredential(challenge.challenge, credential);
}

void AuthenticationManager::useCredentialForSingleChallenge(uint64_t challengeID, const Credential& credential, const CertificateInfo& certificateInfo)
{
    auto challenge = m_challenges.take(challengeID);
    ASSERT(!challenge.challenge.isNull());

#if USE(NETWORK_SESSION)
    auto completionHandler = challenge.completionHandler;
#else
    ChallengeCompletionHandler completionHandler = nullptr;
#endif
    
    if (tryUseCertificateInfoForChallenge(challenge.challenge, certificateInfo, completionHandler))
        return;

    AuthenticationClient* coreClient = challenge.challenge.authenticationClient();
#if USE(NETWORK_SESSION)
    // If there is a completion handler, then there is no AuthenticationClient.
    // FIXME: Remove the use of AuthenticationClient in WebKit2 once NETWORK_SESSION is used for all loads.
    if (completionHandler) {
        ASSERT(!coreClient);
        challenge.completionHandler(AuthenticationChallengeDisposition::UseCredential, credential);
        return;
    }
#endif

    if (coreClient)
        coreClient->receivedCredential(challenge.challenge, credential);
    else
        receivedCredential(challenge.challenge, credential);
}

void AuthenticationManager::rejectProtectionSpaceAndContinueForSingleChallenge(uint64_t challengeID)
{
    AuthenticationChallenge challenge = m_challenges.take(challengeID);
    ASSERT(!challenge.isNull());
    AuthenticationClient* coreClient = challenge.authenticationClient();
    if (!coreClient) {
        // FIXME: The authentication client is null for downloads, but it can also be null for canceled loads.
        // We should not call Download::receivedCredential in the latter case.
        Download::receivedChallengeRejection(challenge);
        return;
    }

    coreClient->receivedChallengeRejection(challenge);
}

void AuthenticationManager::cancelChallenge(uint64_t challengeID)
{
    ASSERT(RunLoop::isMain());

    AuthenticationChallenge challenge = m_challenges.take(challengeID);
    ASSERT(!challenge.isNull());
    AuthenticationClient* coreClient = challenge.authenticationClient();
    if (!coreClient) {
        // FIXME: The authentication client is null for downloads, but it can also be null for canceled loads.
        // We should not call Download::receivedCredential in the latter case.
        Download::receivedCancellation(challenge);
        return;
    }

    coreClient->receivedCancellation(challenge);
}

void AuthenticationManager::rejectProtectionSpaceAndContinueForSingleChallenge(uint64_t challengeID)
{
    auto challenge = m_challenges.take(challengeID);
    ASSERT(!challenge.challenge.isNull());

    AuthenticationClient* coreClient = challenge.challenge.authenticationClient();
#if USE(NETWORK_SESSION)
    if (challenge.completionHandler) {
        ASSERT(!coreClient);
        challenge.completionHandler(AuthenticationChallengeDisposition::RejectProtectionSpace, Credential());
        return;
    }
#endif

    if (coreClient)
        coreClient->receivedChallengeRejection(challenge.challenge);
    else
        receivedChallengeRejection(challenge.challenge);
}

void test_send_with_video()
{
    char *ident = (char *)malloc(128);
    strncpy(ident, "TEST", 128);

    VideoFeedClient *vclient = NULL;
    AuthenticationClient *auth = new AuthenticationClient(ahost, aport, std::string(ident));

    try
    {
        auth->authenticate();
    }
    catch (ConnectionError& ex)
    {
        std::cout << "Unable to connect to Firefly server" << std::endl;
        throw;
    }
    catch (...)
    {
        std::cout << "Unknown error" << std::endl;
        throw;
    }

    if (auth->is_authenticated())
    {
        vclient = new VideoFeedClient(auth->get_dyn_receiver_host(),
                                      auth->get_receiver_port(),
                                      auth->get_token());

        LeptonCamera *lep = new LeptonCamera();
        LeptonCameraContainer *lpc = new LeptonCameraContainer(lep);

        while (true)
        {
            lpc->getNextFrame();
            cv::Mat frame = lpc->getLatestFrame();
            vclient->send_frame(frame);

            cv::imshow("Lepton", frame);

            cv::waitKey(1);

//            break;
        }
    }

    getchar();

    delete auth;
    delete vclient;
}

int main(int argc, char *argv[])
{
    if (argc != 4)
    {
        std::cout << "Usage: " << argv[0] << " [auth ip] [auth port] [ident]" << std::endl;
        return 1;
    }
    ahost = argv[1];
    aport = atoi(argv[2]);
    ident = argv[3];

#ifdef TEST_MODE
    //cv::namedWindow("Lepton", cv::WINDOW_AUTOSIZE);
    // Run a test function
    //test_lepton();
    //test_send_with_video();

    //test_grayscale_jpg();
    test_pansharpen();


#else
    // ACTUAL PROGRAM HERE
    VideoFeedClient *vclient = NULL;
    AuthenticationClient *auth = new AuthenticationClient(ahost, aport, std::string(ident));

    int attempts = 1;

    do
    {
        std::cout << "Attempting to authenticate... Attempt: " << attempts++ << std::endl;

        try
        {
            auth->authenticate();
        }
        catch (ConnectionError& ex)
        {
            std::cout << "Unable to connect to Firefly server" << std::endl;
        }
        catch (...)
        {
            std::cout << "Unknown error" << std::endl;
            throw;
        }

        sleep(1);

    } while (!auth->is_authenticated);



    vclient = new VideoFeedClient(auth->get_dyn_receiver_host(),
                                  auth->get_receiver_port(),
                                  auth->get_token());

    raspicam::RaspiCam_Cv *picam = new raspicam::RaspiCam_Cv();
    picam->set(CV_CAP_PROP_FORMAT, CV_8UC3);
    picam->set(CV_CAP_PROP_FRAME_WIDTH, PICAM_FRAME_WIDTH);
    picam->set(CV_CAP_PROP_FRAME_HEIGHT, PICAM_FRAME_HEIGHT);

    PiCameraContainer *pcc = new PiCameraContainer(picam);
    try
    {
        std::cout << "Opening pi cam" << std::endl;

        if (!picam->open())
        {
            throw PiCamOpenError();
        }
        sleep(1);
    }
    catch (PiCamOpenError)
    {
        std::cout << "Unable to open Pi camera. Is it connected?" << std::endl;
        return 1;
    }

    LeptonCamera *lep;
    LeptonCameraContainer *lpc;
    try
    {
        std::cout << "Initializing lepton camera" << std::endl;

         lep = new LeptonCamera();
         lpc = new LeptonCameraContainer(lep);
    }
    catch (...)
    {
        std::cout << "Unknown error while opening Lepton camera" << std::endl;
        throw;
    }

    std::thread pi_thread(pcc->run);
    std::thread lepton_thread(lpc->run);

    cv::Mat sharpened;
    PanSharpen ps(10, 1.);
    while (true)
    {
//.........这里部分代码省略.........

void test_sending()
{
    char *ident = (char *)malloc(128);
    strncpy(ident, "TEST", 128);

    VideoFeedClient *vclient = NULL;
    AuthenticationClient *auth = new AuthenticationClient(ahost, aport, std::string(ident));

    try
    {
        auth->authenticate();
    }
    catch (ConnectionError ex)
    {
        std::cout << "Unable to authenticate" << std::endl;
        throw;
    }
    catch (...)
    {
        std::cout << "Unknown error" << std::endl;
        throw;
    }

    if (auth->is_authenticated())
    {
        vclient = new VideoFeedClient(auth->get_dyn_receiver_host(),
                                      auth->get_receiver_port(),
                                      auth->get_token());

        try
        {
            std::stringstream test;
            test << auth->get_token();
            test << '\x00';
            test << 1 << '\x00' << 1 << '\x00' << 1 << '\x00';
            test << "frame";

            std::string _test = test.str();

            char *to_send = (char *)malloc(_test.length()+1);
            memcpy(to_send, _test.c_str(), _test.length()+1);

            std::cout << "Sending frame... ";
            for (unsigned int i = 0; i < _test.length(); i++)
                std::cout << (int)_test.at(i) << " ";
            std::cout << " done" << std::endl;

            vclient->send_bytes(to_send, _test.length()+1);
            std::cout << "Frame apparently sent" << std::endl;
        }
        catch (...)
        {
            throw;
        }
    }

    getchar();

    delete auth;
    delete vclient;
}