sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added error checking to functions called from Communication

checksum-failure-logging
EricLiu2000 2019-06-12 14:29:03 -04:00
parent a16f2843d8
commit 519e64fb17
12 changed files with 77 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
api/icsneocpp/error.cpp
View File

@ -65,11 +65,15 @@ static constexpr const char* ERROR_CANFD_SETTINGS_NOT_AVAILABLE = "CANFD setting
static constexpr const char* ERROR_LSFTCAN_SETTINGS_NOT_AVAILABLE = "LSFTCAN settings are not available for this device.";
static constexpr const char* ERROR_SWCAN_SETTINGS_NOT_AVAILABLE = "SWCAN settings are not available for this device.";
static constexpr const char* ERROR_BAUDRATE_NOT_FOUND = "The baudrate was not found.";
static constexpr const char* ERROR_BAD_NETWORK_TYPE = "The network type was not found.";
static constexpr const char* ERROR_UNEXPECTED_NETWORK_TYPE = "The network type was not found.";
static constexpr const char* ERROR_DEVICE_FIRMWARE_OUT_OF_DATE = "The device firmware is out of date. New API functionality may not be supported.";
static constexpr const char* ERROR_SETTINGS_STRUCTURE_MISMATCH = "Unexpected settings structure for this device.";
static constexpr const char* ERROR_SETTINGS_STRUCTURE_TRUNCATED = "Settings structure is longer than the device supports and will be truncated.";
static constexpr const char* ERROR_NO_DEVICE_RESPONSE = "Expected a response from the device but none were found.";
static constexpr const char* ERROR_MESSAGE_FORMATTING = "The message was not properly formed.";
static constexpr const char* ERROR_MESSAGE_DATA_OVER_CAPACITY = "The message has too much data for the protocol.";
static constexpr const char* ERROR_CANFD_NOT_SUPPORTED = "This device does not support CANFD.";
static constexpr const char* ERROR_RTR_NOT_SUPPORTED = "RTR is not supported with CANFD.";
// Transport Errors
static constexpr const char* ERROR_FAILED_TO_READ = "A read operation failed.";
@ -131,6 +135,8 @@ const char* APIError::DescriptionForType(ErrorType type) {
return ERROR_SWCAN_SETTINGS_NOT_AVAILABLE;
case BaudrateNotFound:
return ERROR_BAUDRATE_NOT_FOUND;
case UnexpectedNetworkType:
return ERROR_UNEXPECTED_NETWORK_TYPE;
case DeviceFirmwareOutOfDate:
return ERROR_DEVICE_FIRMWARE_OUT_OF_DATE;
case SettingsStructureMismatch:
@ -139,6 +145,14 @@ const char* APIError::DescriptionForType(ErrorType type) {
return ERROR_SETTINGS_STRUCTURE_TRUNCATED;
case NoDeviceResponse:
return ERROR_NO_DEVICE_RESPONSE;
case MessageFormattingError:
return ERROR_MESSAGE_FORMATTING;
case MessageDataOverCapacity:
return ERROR_MESSAGE_DATA_OVER_CAPACITY;
case CANFDNotSupported:
return ERROR_CANFD_NOT_SUPPORTED;
case RTRNotSupported:
return ERROR_RTR_NOT_SUPPORTED;
// Transport Errors
case FailedToRead:
@ -203,8 +217,14 @@ APIError::Severity APIError::SeverityForType(ErrorType type) {
case LSFTCANSettingsNotAvailable:
case SWCANSettingsNotAvailable:
case BaudrateNotFound:
case UnexpectedNetworkType:
case SettingsStructureMismatch:
case NoDeviceResponse:
case MessageFormattingError:
case MessageDataOverCapacity:
case CANFDNotSupported:
case RTRNotSupported:
// Transport Errors
case FailedToRead:
case FailedToWrite:

11
communication/communication.cpp
View File

@ -73,12 +73,16 @@ bool Communication::getSettingsSync(std::vector<uint8_t>& data, std::chrono::mil
return false;
std::shared_ptr<ReadSettingsMessage> gsmsg = std::dynamic_pointer_cast<ReadSettingsMessage>(msg);
if(!gsmsg)
if(!gsmsg) {
err(APIError::Unknown);
return false;
}
if(gsmsg->response != ReadSettingsMessage::Response::OK)
if(gsmsg->response != ReadSettingsMessage::Response::OK) {
err(APIError::Unknown);
return false;
}
data = std::move(msg->data);
return true;
}
@ -108,6 +112,7 @@ bool Communication::removeMessageCallback(int id) {
messageCallbacks.erase(id);
return true;
} catch(...) {
err(APIError::Unknown);
return false;
}
}

19
communication/encoder.cpp
View File

@ -13,11 +13,13 @@ bool Encoder::encode(std::vector<uint8_t>& result, const std::shared_ptr<Message
switch(message->network.getType()) {
case Network::Type::Ethernet: {
auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
if(!ethmsg)
if(!ethmsg) {
err(APIError::MessageFormattingError);
return false; // The message was not a properly formed EthernetMessage
}
useResultAsBuffer = true;
if(!HardwareEthernetPacket::EncodeFromMessage(*ethmsg, result))
if(!HardwareEthernetPacket::EncodeFromMessage(*ethmsg, result, err))
return false;
break;
@ -26,14 +28,18 @@ bool Encoder::encode(std::vector<uint8_t>& result, const std::shared_ptr<Message
case Network::Type::SWCAN:
case Network::Type::LSFTCAN: {
auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
if(!canmsg)
if(!canmsg) {
err(APIError::MessageFormattingError);
return false; // The message was not a properly formed CANMessage
}
if(!supportCANFD && canmsg->isCANFD)
if(!supportCANFD && canmsg->isCANFD) {
err(APIError::CANFDNotSupported);
return false; // This device does not support CAN FD
}
useResultAsBuffer = true;
if(!HardwareCANPacket::EncodeFromMessage(*canmsg, result))
if(!HardwareCANPacket::EncodeFromMessage(*canmsg, result, err))
return false; // The CANMessage was malformed
break;
@ -69,6 +75,7 @@ bool Encoder::encode(std::vector<uint8_t>& result, const std::shared_ptr<Message
break;
}
default:
err(APIError::UnexpectedNetworkType);
return false;
}
}

7
communication/icommunication.cpp
View File

@ -50,5 +50,10 @@ bool ICommunication::write(const std::vector<uint8_t>& bytes) {
return false;
}
}
return writeQueue.enqueue(WriteOperation(bytes));
bool ret = writeQueue.enqueue(WriteOperation(bytes));
if(!ret) {
err(APIError::Unknown);
}
return ret;
}

19
communication/packet/canpacket.cpp
View File

@ -79,13 +79,17 @@ std::shared_ptr<CANMessage> HardwareCANPacket::DecodeToMessage(const std::vector
return msg;
}
bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector<uint8_t>& result) {
if(message.isCANFD && message.isRemote)
bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector<uint8_t>& result, const device_errorhandler_t& err) {
if(message.isCANFD && message.isRemote) {
err(APIError::RTRNotSupported);
return false; // RTR frames can not be used with CAN FD
}
const size_t dataSize = message.data.size();
if(dataSize > 64 || (dataSize > 8 && !message.isCANFD))
if(dataSize > 64 || (dataSize > 8 && !message.isCANFD)) {
err(APIError::MessageDataOverCapacity);
return false; // Too much data for the protocol
}
uint8_t lengthNibble = uint8_t(message.data.size());
uint8_t paddingBytes = 0;
@ -162,6 +166,7 @@ bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector
lengthNibble = 0xF;
break;
default:
err(APIError::Unknown);
return false; // CAN FD frame may have had an incorrect byte count
}
}
@ -176,8 +181,10 @@ bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector
// Next 2-4 bytes are ArbID
if(message.isExtended) {
if(message.arbid >= 0x20000000) // Extended messages use 29-bit arb IDs
if(message.arbid >= 0x20000000) {// Extended messages use 29-bit arb IDs
err(APIError::MessageFormattingError);
return false;
}
result.insert(result.end(), {
(uint8_t)(message.arbid >> 21),
@ -186,8 +193,10 @@ bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector
(uint8_t)message.arbid
});
} else {
if(message.arbid >= 0x800) // Standard messages use 11-bit arb IDs
if(message.arbid >= 0x800) {// Standard messages use 11-bit arb IDs
err(APIError::MessageFormattingError);
return false;
}
result.insert(result.end(), {
(uint8_t)(message.arbid >> 3),

2
communication/packet/ethernetpacket.cpp
View File

@ -53,7 +53,7 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
return messagePtr;
}
bool HardwareEthernetPacket::EncodeFromMessage(const EthernetMessage& message, std::vector<uint8_t>& bytestream) {
bool HardwareEthernetPacket::EncodeFromMessage(const EthernetMessage& message, std::vector<uint8_t>& bytestream, const device_errorhandler_t& err) {
const size_t unpaddedSize = message.data.size();
size_t paddedSize = unpaddedSize;

4
device/device.cpp
View File

@ -171,7 +171,6 @@ bool Device::open() {
handleInternalMessage(message);
}));
opened = true;
return true;
}
@ -185,8 +184,7 @@ bool Device::close() {
com->removeMessageCallback(internalHandlerCallbackID);
goOffline();
opened = !com->close();
return !opened;
return com->close();
}
bool Device::goOnline() {

8
device/idevicesettings.cpp
View File

@ -347,7 +347,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
return baudrate;
}
default:
err(APIError::BadNetworkType);
err(APIError::UnexpectedNetworkType);
return -1;
}
}
@ -426,7 +426,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
return true;
}
default:
err(APIError::BadNetworkType);
err(APIError::UnexpectedNetworkType);
return false;
}
}
@ -458,7 +458,7 @@ int64_t IDeviceSettings::getFDBaudrateFor(Network net) const {
return baudrate;
}
default:
err(APIError::BadNetworkType);
err(APIError::UnexpectedNetworkType);
return -1;
}
}
@ -496,7 +496,7 @@ bool IDeviceSettings::setFDBaudrateFor(Network net, int64_t baudrate) {
return true;
}
default:
err(APIError::BadNetworkType);
err(APIError::UnexpectedNetworkType);
return false;
}
}

6
include/icsneo/api/error.h
View File

@ -56,11 +56,15 @@ public:
LSFTCANSettingsNotAvailable = 0x2011,
SWCANSettingsNotAvailable = 0x2012,
BaudrateNotFound = 0x2013,
BadNetworkType = 0x2014,
UnexpectedNetworkType = 0x2014,
DeviceFirmwareOutOfDate = 0x2015,
SettingsStructureMismatch = 0x2016,
SettingsStructureTruncated = 0x2017,
NoDeviceResponse = 0x2018,
MessageFormattingError = 0x2019,
MessageDataOverCapacity = 0x2020,
CANFDNotSupported = 0x2021,
RTRNotSupported = 0x2022,
// Transport Errors
FailedToRead = 0x3000,

3
include/icsneo/communication/packet/canpacket.h
View File

@ -2,6 +2,7 @@
#define __CANPACKET_H__
#include "icsneo/communication/message/canmessage.h"
#include "icsneo/api/errormanager.h"
#include <cstdint>
#include <memory>
@ -11,7 +12,7 @@ typedef uint16_t icscm_bitfield;
struct HardwareCANPacket {
static std::shared_ptr<CANMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
static bool EncodeFromMessage(const CANMessage& message, std::vector<uint8_t>& bytestream);
static bool EncodeFromMessage(const CANMessage& message, std::vector<uint8_t>& bytestream, const device_errorhandler_t& err);
struct {
icscm_bitfield IDE : 1;

3
include/icsneo/communication/packet/ethernetpacket.h
View File

@ -2,6 +2,7 @@
#define __ETHERNETPACKET_H__
#include "icsneo/communication/message/ethernetmessage.h"
#include "icsneo/api/errormanager.h"
#include <cstdint>
#include <memory>
@ -11,7 +12,7 @@ typedef uint16_t icscm_bitfield;
struct HardwareEthernetPacket {
static std::shared_ptr<EthernetMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
static bool EncodeFromMessage(const EthernetMessage& message, std::vector<uint8_t>& bytestream);
static bool EncodeFromMessage(const EthernetMessage& message, std::vector<uint8_t>& bytestream, const device_errorhandler_t& err);
struct {
icscm_bitfield FCS_AVAIL : 1;

1
include/icsneo/device/device.h
View File

@ -84,7 +84,6 @@ public:
protected:
uint16_t productId = 0;
bool online = false;
bool opened = false;
int messagePollingCallbackID = 0;
int internalHandlerCallbackID = 0;
device_errorhandler_t err;