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::cancelChallenge(uint64_t challengeID)
{
AuthenticationChallenge challenge = m_challenges.take(challengeID);
ASSERT(!challenge.isNull());
AuthenticationClient* coreClient = challenge.authenticationClient();
if (!coreClient) {
// This authentication challenge comes from a download.
Download::receivedCancellation(challenge);
return;
}
coreClient->receivedCancellation(challenge);
}
void AuthenticationManager::continueWithoutCredentialForChallenge(uint64_t challengeID)
{
AuthenticationChallenge challenge = m_challenges.take(challengeID);
ASSERT(!challenge.isNull());
AuthenticationClient* coreClient = challenge.authenticationClient();
if (!coreClient) {
// This authentication challenge comes from a download.
Download::receivedRequestToContinueWithoutCredential(challenge);
return;
}
coreClient->receivedRequestToContinueWithoutCredential(challenge);
}
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::performDefaultHandlingForSingleChallenge(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::receivedRequestToPerformDefaultHandling(challenge);
return;
}
coreClient->receivedRequestToPerformDefaultHandling(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::useCredentialForChallenge(uint64_t challengeID, const Credential& credential, const PlatformCertificateInfo& certificateInfo)
{
AuthenticationChallenge challenge = m_challenges.take(challengeID);
ASSERT(!challenge.isNull());
if (tryUsePlatformCertificateInfoForChallenge(challenge, certificateInfo))
return;
AuthenticationClient* coreClient = challenge.authenticationClient();
if (!coreClient) {
// This authentication challenge comes from a download.
Download::receivedCredential(challenge, credential);
return;
}
coreClient->receivedCredential(challenge, credential);
}
void AuthenticationManager::useCredentialForSingleChallenge(uint64_t challengeID, const Credential& credential, const CertificateInfo& certificateInfo)
{
AuthenticationChallenge challenge = m_challenges.take(challengeID);
ASSERT(!challenge.isNull());
if (tryUseCertificateInfoForChallenge(challenge, certificateInfo))
return;
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::receivedCredential(challenge, credential);
return;
}
coreClient->receivedCredential(challenge, credential);
}
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 AuthenticationManager::performDefaultHandlingForSingleChallenge(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::PerformDefaultHandling, Credential());
return;
}
#endif
if (coreClient)
coreClient->receivedRequestToPerformDefaultHandling(challenge.challenge);
else
receivedRequestToPerformDefaultHandling(challenge.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;
}
#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::receivedChallengeRejection(challenge.challenge);
return;
}
#endif
ASSERT(coreClient);
coreClient->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)
{
cv::Mat thermal_frame = lpc->getLatestFrame();
cv::Mat visual_frame = pcc->getLatestFrame();
ps.sharpen(thermal_frame, visual_frame, sharpened);
vclient->send_frame(sharpened);
cv::imshow("LIVE FEED", sharpened);
cv::waitKey(1);
}
#endif
return 0;
}
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;
}
