void AuthenticatedSymmetricCipherBase::ProcessData(byte *outString, const byte *inString, size_t length) { m_totalMessageLength += length; if (m_state >= State_IVSet && m_totalMessageLength > MaxMessageLength()) throw InvalidArgument(AlgorithmName() + ": message length exceeds maximum"); reswitch: switch (m_state) { case State_Start: case State_KeySet: throw BadState(AlgorithmName(), "ProcessData", "setting key and IV"); case State_AuthFooter: throw BadState(AlgorithmName(), "ProcessData was called after footer input has started"); case State_IVSet: AuthenticateLastHeaderBlock(); m_bufferedDataLength = 0; m_state = AuthenticationIsOnPlaintext()==IsForwardTransformation() ? State_AuthUntransformed : State_AuthTransformed; goto reswitch; case State_AuthUntransformed: AuthenticateData(inString, length); AccessSymmetricCipher().ProcessData(outString, inString, length); break; case State_AuthTransformed: AccessSymmetricCipher().ProcessData(outString, inString, length); AuthenticateData(outString, length); break; default: CRYPTOPP_ASSERT(false); } }
unsigned int SimFilterWheel::currentPosition() { checkstate(); if (_currentstate != FilterWheel::idle) { throw BadState("filterwheel not idle"); } return _currentposition; }
void AuthenticatedSymmetricCipherBase::Update(const byte *input, size_t length) { if (length == 0) return; switch (m_state) { case State_Start: case State_KeySet: throw BadState(AlgorithmName(), "Update", "setting key and IV"); case State_IVSet: AuthenticateData(input, length); m_totalHeaderLength += length; break; case State_AuthUntransformed: case State_AuthTransformed: AuthenticateLastConfidentialBlock(); m_bufferedDataLength = 0; m_state = State_AuthFooter; // fall through case State_AuthFooter: AuthenticateData(input, length); m_totalFooterLength += length; break; default: CRYPTOPP_ASSERT(false); } }
/** * \brief Start a calibration for a given focal length * * The focal length is the only piece of information that we can not * get from anywhere else, so it has to be specified */ Ice::Int GuiderI::startCalibration(ControlType caltype, const Ice::Current& /* current */) { debug(LOG_DEBUG, DEBUG_LOG, 0, "start calibration, type = %s", calibrationtype2string(caltype).c_str()); // construct a tracker astro::guiding::TrackerPtr tracker = getTracker(); // start the calibration switch (caltype) { case ControlGuidePort: astro::event(EVENT_CLASS, astro::events::Event::GUIDE, astro::stringprintf("start GP %s calibration", guider->name().c_str())); return guider->startCalibration(astro::guiding::GP, tracker); case ControlAdaptiveOptics: astro::event(EVENT_CLASS, astro::events::Event::GUIDE, astro::stringprintf("start AO %s calibration", guider->name().c_str())); return guider->startCalibration(astro::guiding::AO, tracker); } debug(LOG_ERR, DEBUG_LOG, 0, "control type is invalid (should not happen)"); throw BadState("not a valid control type"); }
void GuiderStateMachine::stopGuiding() { if (!canStopGuiding()) { debug(LOG_ERR, DEBUG_LOG, 0, "cannot stop guiding in state %s", statename()); throw BadState("cannot stop guiding in this state"); } _state = Guide::calibrated; }
void GuiderStateMachine::failCalibration() { if (!canFailCalibration()) { debug(LOG_ERR, DEBUG_LOG, 0, "cannot fail calibration in state %s", statename()); throw BadState("cannot fail calibration in this state"); } _state = Guide::idle; }
void GuiderStateMachine::addCalibration() { if (!canAcceptCalibration()) { debug(LOG_ERR, DEBUG_LOG, 0, "cannot accept calibration in state %s", statename()); throw BadState("cannot accept calibration in this state"); } _state = Guide::calibrated; }
void GuiderStateMachine::configure() { if (!canConfigure()) { debug(LOG_ERR, DEBUG_LOG, 0, "cannot configured in state %s", statename()); throw BadState("cannot start calibration"); } _state = Guide::idle; }
/** * \brief Get a servant for the Guiderport */ GuiderPort_ptr Guider_impl::getGuiderPort() { astro::camera::GuiderPortPtr guiderport = _guider->guiderport(); if (!guiderport) { throw BadState("no guiderport defined"); } ServantBuilder<GuiderPort, GuiderPort_impl> servant; return servant(guiderport); }
/** * \brief Get a servant for the camera */ Camera_ptr Guider_impl::getCamera() { astro::camera::CameraPtr camera = _guider->camera(); if (!camera) { throw BadState("no camera defined"); } ServantBuilder<Camera, Camera_impl> servant; return servant(camera); }
/** * \brief Get a servant for the CCD */ Ccd_ptr Guider_impl::getCcd() { astro::camera::CcdPtr ccd = _guider->ccd(); if (!ccd) { throw BadState("no ccd defined"); } ServantBuilder<Ccd, Ccd_impl> servant; return servant(ccd); }
void setPhase(const phase_type& s) { current_state = s; if(s < CLIFF::start || s > CLIFF::goal) { std::ostringstream ostr; ostr << "Simulator::setPhase(" << s << ")"; throw BadState(ostr.str()); } }
void GuiderStateMachine::startCalibrating() { debug(LOG_DEBUG, DEBUG_LOG, 0, "start calibrating"); if (!canStartCalibrating()) { debug(LOG_ERR, DEBUG_LOG, 0, "cannot start calibrating in state %s", statename()); throw BadState("cannot start calibration"); } _state = Guide::calibrating; }
void AuthenticatedSymmetricCipherBase::Resynchronize(const byte *iv, int length) { if (m_state < State_KeySet) throw BadState(AlgorithmName(), "Resynchronize", "key is set"); m_bufferedDataLength = 0; m_totalHeaderLength = m_totalMessageLength = m_totalFooterLength = 0; m_state = State_KeySet; Resync(iv, this->ThrowIfInvalidIVLength(length)); m_state = State_IVSet; }
/** * \brief Retrieve the calibration of a device * * This method retrieves the configuration of a device. If the device is * unconfigured, it throws the BadState exception. */ Calibration GuiderI::getCalibration(ControlType calibrationtype, const Ice::Current& /* current */) { Calibration calibration; switch (calibrationtype) { case ControlGuidePort: { if (!guider->hasGuideport()) { throw BadState("no guider port present"); } if (!guider->guidePortDevice->iscalibrated()) { throw BadState("GP not calibrated"); } //debug(LOG_DEBUG, DEBUG_LOG, 0, "device has cal id %d", // guider->guidePortDevice->calibrationid()); astro::guiding::CalibrationPtr cal = guider->guidePortDevice->calibration(); calibration = convert(cal); calibration.flipped = guider->guidePortDevice->flipped(); return calibration; } case ControlAdaptiveOptics: if (!guider->hasAdaptiveoptics()) { throw BadState("no adaptive optics present"); } if (!guider->adaptiveOpticsDevice->iscalibrated()) { throw BadState("GP not calibrated"); } //debug(LOG_DEBUG, DEBUG_LOG, 0, "device has cal id %d", // guider->adaptiveOpticsDevice->calibrationid()); astro::guiding::CalibrationPtr cal = guider->adaptiveOpticsDevice->calibration(); calibration = convert(cal); calibration.flipped = guider->adaptiveOpticsDevice->flipped(); return calibration; } debug(LOG_ERR, DEBUG_LOG, 0, "control type is invalid (should not happen)"); throw BadState("not a valid control type"); }
/** * \brief build a tracker */ astro::guiding::TrackerPtr GuiderI::getTracker() { // first we must make sure the data we have is consistent astro::camera::Exposure exposure = guider->exposure(); if ((exposure.frame().size().width() <= 0) || (exposure.frame().size().height() <= 0)) { // get the frame from the ccd debug(LOG_DEBUG, DEBUG_LOG, 0, "using ccd frame"); exposure.frame(guider->imager().ccd()->getInfo().getFrame()); guider->exposure(exposure); } if ((_point.x < 0) || (_point.y < 0)) { astro::image::ImagePoint c = exposure.frame().center(); _point.x = c.x(); _point.y = c.y(); debug(LOG_DEBUG, DEBUG_LOG, 0, "using ccd center (%.1f,%.1f) as star", _point.x, _point.y); } debug(LOG_DEBUG, DEBUG_LOG, 0, "current point is (%.1f, %.1f)", _point.x, _point.y); switch (_method) { case TrackerUNDEFINED: case TrackerNULL: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a NULL tracker"); return guider->getNullTracker(); break; case TrackerSTAR: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a star tracker"); return guider->getTracker(convert(_point)); break; case TrackerPHASE: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a phase tracker"); return guider->getPhaseTracker(); break; case TrackerDIFFPHASE: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a diff tracker"); return guider->getDiffPhaseTracker(); break; case TrackerLAPLACE: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a laplace tracker"); return guider->getLaplaceTracker(); break; case TrackerLARGE: debug(LOG_DEBUG, DEBUG_LOG, 0, "construct a large tracker"); return guider->getLargeTracker(); break; } debug(LOG_ERR, DEBUG_LOG, 0, "tracking method is invalid " "(should not happen)"); throw BadState("tracking method"); }
/** * \brief Retrieve the Tracking history of a guide run * * \param guiderunid The id of the guide run for which we request * the history. The value -1 means that we want * to retrieve the currently running guide run */ Astro::TrackingHistory *Guider_impl::getTrackingHistory(::CORBA::Long guiderunid) { if (guiderunid < 0) { // verify that we really are guiding right now if (astro::guiding::Guide::guiding != _guider->state()) { throw BadState("not currently guiding"); } guiderunid = guidingrunid; } debug(LOG_DEBUG, DEBUG_LOG, 0, "get tracking history for run %d", guiderunid); // get the result from the guider factory return ServerDatabase().getTrackingHistory(guiderunid); }
void TaskQueueI::stop(const Ice::Current& /* current */) { debug(LOG_DEBUG, DEBUG_LOG, 0, "stop request"); try { taskqueue.stop(); astro::event(EVENT_CLASS, astro::events::Event::TASK, "task queue stopped"); } catch (const std::exception& x) { std::string cause = astro::stringprintf( "cannot stop: %s %s", astro::demangle(typeid(x).name()).c_str(), x.what()); debug(LOG_ERR, DEBUG_LOG, 0, "%s", cause.c_str()); throw BadState(cause); } }
TrackingHistory GuiderI::getTrackingHistoryType(Ice::Int id, ControlType type, const Ice::Current& /* current */) { debug(LOG_DEBUG, DEBUG_LOG, 0, "get tracking history %d", id); astro::guiding::TrackingStore store(database); switch (type) { case ControlGuidePort: return convert(store.get(id, astro::guiding::GP)); case ControlAdaptiveOptics: return convert(store.get(id, astro::guiding::AO)); } debug(LOG_ERR, DEBUG_LOG, 0, "control type is invalid (should not happen)"); throw BadState("not a valid control type"); }
/** * \brief Use a calibration * * This method directs the guider to use a specific calibration from the * database. The flipped argument allows to use the calibration if it was * computed on the other side of the meridian. */ void GuiderI::useCalibration(Ice::Int calid, bool /* flipped */, const Ice::Current& /* current */) { if (calid <= 0) { throw BadParameter("not a valid calibration id"); } // retrieve guider data from the database try { guider->useCalibration(calid); astro::event(EVENT_CLASS, astro::events::Event::GUIDE, astro::stringprintf("%s now uses calibration %d", guider->name().c_str(), calid)); } catch (const astro::guiding::BadState x) { throw BadState(x.what()); } catch (const astro::guiding::NotFound x) { throw NotFound(x.what()); } }
TrackingPoint GuiderI::mostRecentTrackingPoint(const Ice::Current& /* current */) { if (astro::guiding::Guide::guiding != guider->state()) { throw BadState("not currently guiding"); } // get info from the guider double lastaction; astro::Point offset; astro::Point activation; guider->lastAction(lastaction, offset, activation); // construct a tracking point TrackingPoint result; result.timeago = converttime(lastaction); result.trackingoffset = convert(offset); result.activation = convert(activation); return result; }
void AuthenticatedSymmetricCipherBase::TruncatedFinal(byte *mac, size_t macSize) { if (m_totalHeaderLength > MaxHeaderLength()) throw InvalidArgument(AlgorithmName() + ": header length of " + IntToString(m_totalHeaderLength) + " exceeds the maximum of " + IntToString(MaxHeaderLength())); if (m_totalFooterLength > MaxFooterLength()) { if (MaxFooterLength() == 0) throw InvalidArgument(AlgorithmName() + ": additional authenticated data (AAD) cannot be input after data to be encrypted or decrypted"); else throw InvalidArgument(AlgorithmName() + ": footer length of " + IntToString(m_totalFooterLength) + " exceeds the maximum of " + IntToString(MaxFooterLength())); } switch (m_state) { case State_Start: case State_KeySet: throw BadState(AlgorithmName(), "TruncatedFinal", "setting key and IV"); case State_IVSet: AuthenticateLastHeaderBlock(); m_bufferedDataLength = 0; // fall through case State_AuthUntransformed: case State_AuthTransformed: AuthenticateLastConfidentialBlock(); m_bufferedDataLength = 0; // fall through case State_AuthFooter: AuthenticateLastFooterBlock(mac, macSize); m_bufferedDataLength = 0; break; default: CRYPTOPP_ASSERT(false); } m_state = State_KeySet; }
void CCM_Base::UncheckedSpecifyDataLengths(lword headerLength, lword messageLength, lword /*footerLength*/) { if (m_state != State_IVSet) throw BadState(AlgorithmName(), "SpecifyDataLengths", "or after State_IVSet"); m_aadLength = headerLength; m_messageLength = messageLength; byte *cbcBuffer = CBC_Buffer(); const BlockCipher &cipher = GetBlockCipher(); cbcBuffer[0] = byte(64*(headerLength>0) + 8*((m_digestSize-2)/2) + (m_L-1)); // flag PutWord<word64>(true, BIG_ENDIAN_ORDER, cbcBuffer+REQUIRED_BLOCKSIZE-8, m_messageLength); memcpy(cbcBuffer+1, m_buffer+1, REQUIRED_BLOCKSIZE-1-m_L); cipher.ProcessBlock(cbcBuffer); if (headerLength>0) { CRYPTOPP_ASSERT(m_bufferedDataLength == 0); if (headerLength < ((1<<16) - (1<<8))) { PutWord<word16>(true, BIG_ENDIAN_ORDER, m_buffer, (word16)headerLength); m_bufferedDataLength = 2; } else if (headerLength < (W64LIT(1)<<32)) { m_buffer[0] = 0xff; m_buffer[1] = 0xfe; PutWord<word32>(false, BIG_ENDIAN_ORDER, m_buffer+2, (word32)headerLength); m_bufferedDataLength = 6; } else { m_buffer[0] = 0xff; m_buffer[1] = 0xff; PutWord<word64>(false, BIG_ENDIAN_ORDER, m_buffer+2, headerLength); m_bufferedDataLength = 10; } } }
/** * \brief Uncalibrate a device * * Since all configured devices are used for guiding, there must be a method * to uncalibrate a device so that it is no longer used for guiding. */ void GuiderI::unCalibrate(ControlType calibrationtype, const Ice::Current& /* current */) { // retrieve guider data from the database try { switch (calibrationtype) { case ControlGuidePort: astro::event(EVENT_CLASS, astro::events::Event::GUIDE, astro::stringprintf("GP %s uncalibrated", guider->name().c_str())); guider->unCalibrate(astro::guiding::GP); break; case ControlAdaptiveOptics: astro::event(EVENT_CLASS, astro::events::Event::GUIDE, astro::stringprintf("AO %s uncalibrated", guider->name().c_str())); guider->unCalibrate(astro::guiding::AO); break; } } catch (const astro::guiding::BadState& exception) { throw BadState(exception.what()); } }
/** * \brief Retrieve the most recent point found by the tracker */ Astro::TrackingPoint Guider_impl::mostRecentTrackingPoint() { // verify that we really are guiding right now if (astro::guiding::Guide::guiding != _guider->state()) { throw BadState("not currently guiding"); } // ok, we are guiding. Prepare a result structure Astro::TrackingPoint result; // So we query the guider for the contents of this structure double lastaction; astro::Point offset; astro::Point activation; _guider->lastAction(lastaction, offset, activation); result.timeago = astro::Timer::gettime() - lastaction; result.trackingoffset.x = offset.x(); result.trackingoffset.y = offset.y(); result.activation.x = activation.x(); result.activation.y = activation.y(); // that's it, we are read, return the structure return result; }
/** * \brief startExposure * * This method starts the thread that is */ void ThreadCcd::startExposure(const Exposure& exposure) { std::unique_lock<std::recursive_mutex> lock(_mutex); // make sure we are in the right state if (exposureStatus() != CcdState::idle) { std::string msg("not idle: start exposure in idle state"); debug(LOG_ERR, DEBUG_LOG, 0, "%s", msg.c_str()); throw BadState(msg); } // find out whether there is a joinable thread if (_thread.joinable()) { _thread.join(); } // prepare the exposure structure this->exposure = exposure; // start a thread state(CcdState::exposing); _running = true; _thread = std::thread(treadccdmain, this); }
static void FreeChannel_m(VP_cl *self, Channel_Endpoint ep ) { dcb_rw_t *rwp = RW(self); dcb_ro_t *rop = RO(self); ep_rw_t *eprw; ep_ro_t *epro; if ( ep >= rop->num_eps ) { DB(eprintf("VP$FreeChannel: invalid EP.\n")); RAISE_Channel$Invalid( ep ); } epro = DCB_EPRO(rop,ep); eprw = DCB_EPRW(rop,ep); if ( epro->peer_dcb != NULL || eprw->state == Channel_State_Free ) { DB(eprintf("VP$FreeChannel: Bad State.\n")); RAISE_Channel$BadState( ep, eprw->state ); } eprw->state = Channel_State_Free; eprw->ack = (word_t)(rwp->free_eps); rwp->free_eps = eprw; }
static void drawingPosition(int& w, int& h, phase_type p) { switch(p) { case start: w = 0; h = WIDTH; break; case goal: w = LENGTH-1; h = WIDTH; break; default: if(p<0 || p >= LENGTH*WIDTH+2) { std::ostringstream os; os << "Cliff<" << LENGTH << ',' << WIDTH << ">::drawingPosition(w,h," << p << ") : Out of bounds."; throw BadState(os.str()); } p--; w = p%LENGTH; h = WIDTH-1-p/LENGTH; break; } }