/** * Send a RDM request to the widget */ bool RobeWidgetImpl::PackAndSendRDMRequest(uint8_t label, const RDMRequest *request) { ByteString frame; if (!RDMCommandSerializer::Pack(*request, &frame)) { return false; } frame.append(RDM_PADDING_BYTES, 0); return SendMessage(label, frame.data(), frame.size()); }
Result CheckCert(ByteString& certDER, IssuerChecker& checker, bool& keepGoing) { Input derCert; Result rv = derCert.Init(certDER.data(), certDER.length()); if (rv != Success) { return rv; } return checker.Check(derCert, nullptr/*additionalNameConstraints*/, keepGoing); }
void HidDevice::sendFeatureReport(uint8_t reportId, const ByteString& data) { ByteString reportBuf = ByteString(1, reportId) + data; int r = hid_send_feature_report(devHandle, reportBuf.data(), reportBuf.size()); if(r<0) { std::string errorString; utf16BufferToUtf8String(errorString, hid_error(devHandle)); throw HidDeviceError(errorString); } }
void JaRulePortHandleImpl::UnMuteAll(UnMuteDeviceCallback *unmute_complete) { auto_ptr<RDMRequest> request( ola::rdm::NewUnMuteRequest(m_uid, UID::AllDevices(), m_transaction_number.Next(), m_physical_port + 1)); ByteString frame; RDMCommandSerializer::Pack(*request, &frame); m_port->SendCommand( JARULE_CMD_RDM_BROADCAST_REQUEST, frame.data(), frame.size(), NewSingleCallback(this, &JaRulePortHandleImpl::UnMuteDeviceComplete, unmute_complete)); }
// Test that the large length of the child serial number causes // CreateEncodedOCSPRequest to fail. TEST_F(pkixocsp_CreateEncodedOCSPRequest, ChildCertLongSerialNumberTest) { static const uint8_t UNSUPPORTED_LEN = 128; // must be larger than 127 ByteString serialNumberString; // tag + length + value is 1 + 2 + UNSUPPORTED_LEN // Encoding the length takes two bytes: one byte to indicate that a // second byte follows, and the second byte to indicate the length. serialNumberString.push_back(0x80 + 1); serialNumberString.push_back(UNSUPPORTED_LEN); // value is 0x010000...00 serialNumberString.push_back(0x01); for (size_t i = 1; i < UNSUPPORTED_LEN; ++i) { serialNumberString.push_back(0x00); } ByteString issuerDER; ByteString issuerSPKI; ASSERT_NO_FATAL_FAILURE(MakeIssuerCertIDComponents("CA", issuerDER, issuerSPKI)); Input issuer; ASSERT_EQ(Success, issuer.Init(issuerDER.data(), issuerDER.length())); Input spki; ASSERT_EQ(Success, spki.Init(issuerSPKI.data(), issuerSPKI.length())); Input serialNumber; ASSERT_EQ(Success, serialNumber.Init(serialNumberString.data(), serialNumberString.length())); uint8_t ocspRequest[OCSP_REQUEST_MAX_LENGTH]; size_t ocspRequestLength; ASSERT_EQ(Result::ERROR_BAD_DER, CreateEncodedOCSPRequest(trustDomain, CertID(issuer, spki, serialNumber), ocspRequest, ocspRequestLength)); }
void JaRulePortHandleImpl::MuteDevice(const UID &target, MuteDeviceCallback *mute_complete) { auto_ptr<RDMRequest> request( ola::rdm::NewMuteRequest(m_uid, target, m_transaction_number.Next(), m_physical_port + 1)); ByteString frame; RDMCommandSerializer::Pack(*request, &frame); m_port->SendCommand( JARULE_CMD_RDM_REQUEST, frame.data(), frame.size(), NewSingleCallback(this, &JaRulePortHandleImpl::MuteDeviceComplete, mute_complete)); }
// Test that CreateEncodedOCSPRequest handles the longest serial number that // it's required to support (i.e. 20 octets). TEST_F(pkixocsp_CreateEncodedOCSPRequest, LongestSupportedSerialNumberTest) { static const uint8_t LONGEST_REQUIRED_LEN = 20; ByteString serialNumberString; // tag + length + value is 1 + 1 + LONGEST_REQUIRED_LEN serialNumberString.push_back(der::INTEGER); serialNumberString.push_back(LONGEST_REQUIRED_LEN); serialNumberString.push_back(0x01); // value is 0x010000...00 for (size_t i = 1; i < LONGEST_REQUIRED_LEN; ++i) { serialNumberString.push_back(0x00); } ByteString issuerDER; ByteString issuerSPKI; ASSERT_NO_FATAL_FAILURE(MakeIssuerCertIDComponents("CA", issuerDER, issuerSPKI)); Input issuer; ASSERT_EQ(Success, issuer.Init(issuerDER.data(), issuerDER.length())); Input spki; ASSERT_EQ(Success, spki.Init(issuerSPKI.data(), issuerSPKI.length())); Input serialNumber; ASSERT_EQ(Success, serialNumber.Init(serialNumberString.data(), serialNumberString.length())); uint8_t ocspRequest[OCSP_REQUEST_MAX_LENGTH]; size_t ocspRequestLength; ASSERT_EQ(Success, CreateEncodedOCSPRequest(trustDomain, CertID(issuer, spki, serialNumber), ocspRequest, ocspRequestLength)); }
void JaRulePortHandleImpl::Branch(const UID &lower, const UID &upper, BranchCallback *branch_complete) { auto_ptr<RDMRequest> request( ola::rdm::NewDiscoveryUniqueBranchRequest(m_uid, lower, upper, m_transaction_number.Next())); ByteString frame; RDMCommandSerializer::Pack(*request, &frame); OLA_INFO << "Sending RDM DUB: " << lower << " - " << upper; m_port->SendCommand( JARULE_CMD_RDM_DUB_REQUEST, frame.data(), frame.size(), NewSingleCallback(this, &JaRulePortHandleImpl::DUBComplete, branch_complete)); }
/** * Send a RDM Message */ void RobeWidgetImpl::SendRDMRequest(RDMRequest *request_ptr, ola::rdm::RDMCallback *on_complete) { auto_ptr<RDMRequest> request(request_ptr); if (m_rdm_request_callback) { OLA_FATAL << "Previous request hasn't completed yet, dropping request"; RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); return; } // prepare the buffer for the RDM data, we don't need to include the start // code. We need to include 4 bytes at the end, these bytes can be any value. ByteString data; unsigned int this_transaction_number = m_transaction_number++; unsigned int port_id = 1; request->SetSourceUID(m_uid); request->SetTransactionNumber(this_transaction_number); request->SetPortId(port_id); if (!RDMCommandSerializer::Pack(*request, &data)) { OLA_WARN << "Failed to pack message, dropping request"; RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); return; } // Append the extra padding bytes, which can be set to any value. data.append(RDM_PADDING_BYTES, 0); OLA_DEBUG << "Sending RDM command. CC: " << strings::ToHex(request->CommandClass()) << ", PID " << strings::ToHex(request->ParamId()) << ", TN: " << this_transaction_number; m_rdm_request_callback = on_complete; m_pending_request.reset(request.release()); const uint8_t label = m_pending_request->IsDUB() ? RDM_DISCOVERY : RDM_REQUEST; bool sent_ok = SendMessage(label, data.data(), data.size()); if (!sent_ok) { m_rdm_request_callback = NULL; m_pending_request.reset(); RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); } }
TEST_P(pkixcheck_TLSFeaturesSatisfiedInternal, TLSFeaturesSatisfiedInternal) { const TLSFeaturesTestParams& params(GetParam()); Input featuresInput; ASSERT_EQ(Success, featuresInput.Init(params.requiredTLSFeatures.data(), params.requiredTLSFeatures.length())); Input responseInput; // just create an input with any data in it ByteString stapledOCSPResponse = BS(statusRequest); ASSERT_EQ(Success, responseInput.Init(stapledOCSPResponse.data(), stapledOCSPResponse.length())); // first we omit the response ASSERT_EQ(params.expectedResultWithoutResponse, TLSFeaturesSatisfiedInternal(&featuresInput, nullptr)); // then we try again with the response ASSERT_EQ(params.expectedResultWithResponse, TLSFeaturesSatisfiedInternal(&featuresInput, &responseInput)); }
void JaRulePortHandleImpl::SendRDMRequest(RDMRequest *request, ola::rdm::RDMCallback *on_complete) { request->SetSourceUID(m_uid); request->SetPortId(m_physical_port + 1); request->SetTransactionNumber(m_transaction_number.Next()); ByteString frame; if (!RDMCommandSerializer::Pack(*request, &frame)) { RunRDMCallback(on_complete, ola::rdm::RDM_FAILED_TO_SEND); delete request; return; } m_port->SendCommand( GetCommandFromRequest(request), frame.data(), frame.size(), NewSingleCallback(this, &JaRulePortHandleImpl::RDMComplete, static_cast<const RDMRequest*>(request), on_complete)); }
virtual Result FindIssuer(Input encodedIssuerName, IssuerChecker& checker, Time) { ByteString* issuerDER = nullptr; if (InputEqualsByteString(encodedIssuerName, rootSubjectDER)) { issuerDER = &rootDER; } else if (InputEqualsByteString(encodedIssuerName, intSubjectDER)) { issuerDER = &intDER; } else { // FindIssuer just returns success if it can't find a potential issuer. return Success; } Input issuerCert; Result rv = issuerCert.Init(issuerDER->data(), issuerDER->length()); if (rv != Success) { return rv; } bool keepGoing; return checker.Check(issuerCert, nullptr, keepGoing); }
bool FileSystem::WriteFile(const char *Filename, ByteString &DataBuffer, bool Append) { return WriteFile(Filename, (void *)DataBuffer.data(), DataBuffer.size(), Append); }