/**
* 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);
}
