Add GatewayKnxTpIpRouter implementation for handling KNXnet/IP services
- Implemented handleUdpDatagram to process incoming UDP datagrams and route them to appropriate handlers based on service type. - Added methods for handling various KNXnet/IP requests including search, description, tunneling, device configuration, connection state, and disconnect requests. - Introduced TunnelClient management for handling multiple tunnel connections, including allocation, resetting, and pruning stale clients. - Implemented secure service handling with appropriate logging for unsupported secure sessions. - Enhanced logging for better traceability of incoming requests and responses. Signed-off-by: Tony <tonylu@tony-cloud.com>
This commit is contained in:
Tony
@@ -0,0 +1,319 @@
|
||||
#include "gateway_knx_private.hpp"
|
||||
|
||||
namespace gateway {
|
||||
|
||||
void GatewayKnxTpIpRouter::selectOpenKnxNetworkInterface(const sockaddr_in& remote) {
|
||||
const auto netif = SelectKnxNetifForRemote(remote);
|
||||
SemaphoreGuard guard(openknx_lock_);
|
||||
if (ets_device_ != nullptr) {
|
||||
ets_device_->setNetworkInterface(netif.has_value() ? netif->netif : nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::handleOpenKnxTunnelFrame(const uint8_t* data, size_t len,
|
||||
TunnelClient* response_client,
|
||||
uint16_t response_service,
|
||||
const uint8_t* suppress_routing_echo,
|
||||
size_t suppress_routing_echo_len) {
|
||||
SemaphoreGuard guard(openknx_lock_);
|
||||
if (ets_device_ == nullptr) {
|
||||
return false;
|
||||
}
|
||||
std::vector<uint8_t> tunnel_confirmation;
|
||||
const bool needs_tunnel_confirmation =
|
||||
response_client != nullptr && response_client->connected &&
|
||||
response_service == kServiceTunnellingRequest &&
|
||||
BuildTunnelConfirmationFrame(data, len, &tunnel_confirmation);
|
||||
bool sent_tunnel_confirmation = false;
|
||||
const bool consumed = ets_device_->handleTunnelFrame(
|
||||
data, len,
|
||||
[this, response_client, response_service, needs_tunnel_confirmation,
|
||||
&tunnel_confirmation, &sent_tunnel_confirmation,
|
||||
suppress_routing_echo, suppress_routing_echo_len](const uint8_t* response,
|
||||
size_t response_len) {
|
||||
if (response == nullptr || response_len == 0) {
|
||||
return;
|
||||
}
|
||||
const bool routing_context =
|
||||
response_client == nullptr && response_service == kServiceRoutingIndication;
|
||||
const auto message_code = CemiMessageCode(response, response_len);
|
||||
if (routing_context && suppress_routing_echo != nullptr &&
|
||||
IsLocalRoutingEchoIndication(response, response_len, suppress_routing_echo,
|
||||
suppress_routing_echo_len)) {
|
||||
return;
|
||||
}
|
||||
if (needs_tunnel_confirmation && !sent_tunnel_confirmation &&
|
||||
message_code.has_value() && message_code.value() != L_data_con) {
|
||||
sent_tunnel_confirmation = sendCemiFrameToClient(
|
||||
*response_client, kServiceTunnellingRequest,
|
||||
tunnel_confirmation.data(), tunnel_confirmation.size());
|
||||
}
|
||||
|
||||
const uint16_t service = KnxIpServiceForCemi(response, response_len, response_service);
|
||||
if (service == kServiceDeviceConfigurationRequest) {
|
||||
if (response_client != nullptr && response_client->connected) {
|
||||
sendCemiFrameToClient(*response_client, service, response, response_len);
|
||||
} else if (routing_context) {
|
||||
sendRoutingIndication(response, response_len);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (message_code.has_value() && message_code.value() == L_data_con) {
|
||||
if (routing_context) {
|
||||
return;
|
||||
}
|
||||
if (response_client != nullptr && response_client->connected) {
|
||||
sent_tunnel_confirmation =
|
||||
sendCemiFrameToClient(*response_client, service, response, response_len) ||
|
||||
sent_tunnel_confirmation;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (routing_context) {
|
||||
sendRoutingIndication(response, response_len);
|
||||
return;
|
||||
}
|
||||
if (response_client != nullptr && response_client->connected) {
|
||||
sendCemiFrameToClient(*response_client, service, response, response_len);
|
||||
return;
|
||||
}
|
||||
sendTunnelIndication(response, response_len);
|
||||
});
|
||||
if (needs_tunnel_confirmation && consumed && !sent_tunnel_confirmation) {
|
||||
sendCemiFrameToClient(*response_client, kServiceTunnellingRequest,
|
||||
tunnel_confirmation.data(), tunnel_confirmation.size());
|
||||
}
|
||||
syncOpenKnxConfigFromDevice();
|
||||
return consumed;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::transmitOpenKnxTpFrame(const uint8_t* data, size_t len) {
|
||||
SemaphoreGuard guard(openknx_lock_);
|
||||
if (ets_device_ == nullptr) {
|
||||
return false;
|
||||
}
|
||||
const bool sent = ets_device_->transmitTpFrame(data, len);
|
||||
tp_uart_online_ = ets_device_->tpUartOnline();
|
||||
return sent;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::handleOpenKnxBusFrame(const uint8_t* data, size_t len) {
|
||||
SemaphoreGuard guard(openknx_lock_);
|
||||
if (ets_device_ == nullptr) {
|
||||
return false;
|
||||
}
|
||||
const bool consumed = ets_device_->handleBusFrame(data, len);
|
||||
syncOpenKnxConfigFromDevice();
|
||||
return consumed;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::routeOpenKnxGroupWrite(const uint8_t* data, size_t len,
|
||||
const char* context) {
|
||||
const auto decoded = DecodeOpenKnxGroupWrite(data, len);
|
||||
if (!decoded.has_value()) {
|
||||
return false;
|
||||
}
|
||||
if (!shouldRouteDaliApplicationFrames()) {
|
||||
return true;
|
||||
}
|
||||
const DaliBridgeResult result = group_write_handler_
|
||||
? group_write_handler_(decoded->group_address,
|
||||
decoded->data.data(),
|
||||
decoded->data.size())
|
||||
: bridge_.handleGroupWrite(decoded->group_address,
|
||||
decoded->data.data(),
|
||||
decoded->data.size());
|
||||
if (!result.ok && !result.error.empty()) {
|
||||
ESP_LOGD(kTag, "%s not routed to DALI: %s", context == nullptr ? "KNX group write" : context,
|
||||
result.error.c_str());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::handleFunctionPropertyExtCommand(
|
||||
uint16_t object_type, uint8_t object_instance, uint8_t property_id,
|
||||
const uint8_t* data, size_t len, std::vector<uint8_t>* response) {
|
||||
if (response == nullptr || object_type != kGroupObjectTableObjectType ||
|
||||
property_id != kPidGoDiagnostics) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto decoded = DecodeGoDiagnosticsGroupWrite(data, len);
|
||||
if (!decoded.has_value()) {
|
||||
const std::string payload = HexBytes(data, len);
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics write malformed objType=0x%04X objInst=%u property=0x%02X len=%u payload=%s",
|
||||
static_cast<unsigned>(object_type), static_cast<unsigned>(object_instance),
|
||||
static_cast<unsigned>(property_id), static_cast<unsigned>(len), payload.c_str());
|
||||
*response = {ReturnCodes::DataVoid};
|
||||
return true;
|
||||
}
|
||||
|
||||
const std::string group_address_text =
|
||||
GatewayKnxGroupAddressString(decoded->group_address);
|
||||
const std::string payload = HexBytes(decoded->payload, decoded->payload_len);
|
||||
ESP_LOGI(kTag,
|
||||
"OpenKNX GO diagnostics group write ga=0x%04X (%s) len=%u payload=%s",
|
||||
static_cast<unsigned>(decoded->group_address), group_address_text.c_str(),
|
||||
static_cast<unsigned>(decoded->payload_len), payload.c_str());
|
||||
|
||||
if (!shouldRouteDaliApplicationFrames()) {
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics group write ga=0x%04X (%s) blocked by commissioning-only routing state",
|
||||
static_cast<unsigned>(decoded->group_address), group_address_text.c_str());
|
||||
*response = {ReturnCodes::TemporarilyNotAvailable};
|
||||
return true;
|
||||
}
|
||||
|
||||
const DaliBridgeResult result =
|
||||
group_write_handler_ ? group_write_handler_(decoded->group_address, decoded->payload,
|
||||
decoded->payload_len)
|
||||
: bridge_.handleGroupWrite(decoded->group_address,
|
||||
decoded->payload,
|
||||
decoded->payload_len);
|
||||
const uint8_t return_code = GoDiagnosticsReturnCode(result);
|
||||
if (return_code == ReturnCodes::AddressVoid) {
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics group write ga=0x%04X (%s) returning AddressVoid: %s",
|
||||
static_cast<unsigned>(decoded->group_address), group_address_text.c_str(),
|
||||
result.error.empty() ? "unmapped KNX group address"
|
||||
: result.error.c_str());
|
||||
} else if (!result.ok) {
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics group write ga=0x%04X (%s) failed rc=0x%02X: %s",
|
||||
static_cast<unsigned>(decoded->group_address), group_address_text.c_str(),
|
||||
static_cast<unsigned>(return_code),
|
||||
result.error.empty() ? "command routing failed" : result.error.c_str());
|
||||
}
|
||||
response->assign(1, return_code);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::handleFunctionPropertyExtState(
|
||||
uint16_t object_type, uint8_t object_instance, uint8_t property_id,
|
||||
const uint8_t* data, size_t len, std::vector<uint8_t>* response) {
|
||||
if (response == nullptr || object_type != kGroupObjectTableObjectType ||
|
||||
property_id != kPidGoDiagnostics) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto decoded = DecodeGoDiagnosticsGroupWrite(data, len);
|
||||
if (!decoded.has_value()) {
|
||||
const std::string payload = HexBytes(data, len);
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics state request malformed objType=0x%04X objInst=%u property=0x%02X len=%u payload=%s",
|
||||
static_cast<unsigned>(object_type), static_cast<unsigned>(object_instance),
|
||||
static_cast<unsigned>(property_id), static_cast<unsigned>(len), payload.c_str());
|
||||
*response = {ReturnCodes::DataVoid};
|
||||
return true;
|
||||
}
|
||||
|
||||
const std::string group_address_text =
|
||||
GatewayKnxGroupAddressString(decoded->group_address);
|
||||
ESP_LOGW(kTag,
|
||||
"OpenKNX GO diagnostics state request unsupported ga=0x%04X (%s)",
|
||||
static_cast<unsigned>(decoded->group_address), group_address_text.c_str());
|
||||
*response = {ReturnCodes::InvalidCommand};
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::emitOpenKnxGroupValue(uint16_t group_object_number,
|
||||
const uint8_t* data, size_t len) {
|
||||
SemaphoreGuard guard(openknx_lock_);
|
||||
if (ets_device_ == nullptr) {
|
||||
return false;
|
||||
}
|
||||
const bool emitted = ets_device_->emitGroupValue(
|
||||
group_object_number, data, len, [this](const uint8_t* frame_data, size_t frame_len) {
|
||||
sendRoutingIndication(frame_data, frame_len);
|
||||
sendTunnelIndication(frame_data, frame_len);
|
||||
if (ets_device_ != nullptr) {
|
||||
const bool sent_to_tp = ets_device_->transmitTpFrame(frame_data, frame_len);
|
||||
tp_uart_online_ = sent_to_tp || ets_device_->tpUartOnline();
|
||||
}
|
||||
});
|
||||
syncOpenKnxConfigFromDevice();
|
||||
return emitted;
|
||||
}
|
||||
|
||||
bool GatewayKnxTpIpRouter::shouldRouteDaliApplicationFrames() const {
|
||||
if (!commissioning_only_) {
|
||||
return true;
|
||||
}
|
||||
return openknx_configured_.load();
|
||||
}
|
||||
|
||||
uint8_t GatewayKnxTpIpRouter::advertisedMedium() const {
|
||||
return (config_.tunnel_enabled || tp_uart_online_) ? kKnxMediumTp1 : kKnxMediumIp;
|
||||
}
|
||||
|
||||
void GatewayKnxTpIpRouter::syncOpenKnxConfigFromDevice() {
|
||||
if (ets_device_ == nullptr) {
|
||||
return;
|
||||
}
|
||||
const auto snapshot = ets_device_->snapshot();
|
||||
openknx_configured_.store(snapshot.configured);
|
||||
bool changed = false;
|
||||
GatewayKnxConfig updated = config_;
|
||||
if (snapshot.individual_address != 0 && snapshot.individual_address != 0xffff &&
|
||||
snapshot.individual_address != updated.individual_address) {
|
||||
updated.individual_address = snapshot.individual_address;
|
||||
changed = true;
|
||||
}
|
||||
if (snapshot.configured || !snapshot.associations.empty()) {
|
||||
std::vector<GatewayKnxEtsAssociation> associations;
|
||||
associations.reserve(snapshot.associations.size());
|
||||
for (const auto& association : snapshot.associations) {
|
||||
associations.push_back(GatewayKnxEtsAssociation{association.group_address,
|
||||
association.group_object_number});
|
||||
}
|
||||
if (associations.size() != updated.ets_associations.size() ||
|
||||
!std::equal(associations.begin(), associations.end(), updated.ets_associations.begin(),
|
||||
[](const GatewayKnxEtsAssociation& lhs,
|
||||
const GatewayKnxEtsAssociation& rhs) {
|
||||
return lhs.group_address == rhs.group_address &&
|
||||
lhs.group_object_number == rhs.group_object_number;
|
||||
})) {
|
||||
updated.ets_associations = std::move(associations);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
if (!changed) {
|
||||
return;
|
||||
}
|
||||
config_ = updated;
|
||||
bridge_.setConfig(config_);
|
||||
}
|
||||
|
||||
uint16_t GatewayKnxTpIpRouter::effectiveIpInterfaceIndividualAddress() const {
|
||||
if (config_.ip_interface_individual_address != 0 &&
|
||||
config_.ip_interface_individual_address != 0xffff) {
|
||||
return config_.ip_interface_individual_address;
|
||||
}
|
||||
return 0xff01;
|
||||
}
|
||||
|
||||
uint16_t GatewayKnxTpIpRouter::effectiveKnxDeviceIndividualAddress() const {
|
||||
if (ets_device_ != nullptr) {
|
||||
const uint16_t address = ets_device_->individualAddress();
|
||||
if (address != 0 && address != 0xffff) {
|
||||
return address;
|
||||
}
|
||||
}
|
||||
return config_.individual_address;
|
||||
}
|
||||
|
||||
uint16_t GatewayKnxTpIpRouter::effectiveTunnelAddress() const {
|
||||
const uint16_t interface_address = effectiveIpInterfaceIndividualAddress();
|
||||
uint16_t device = static_cast<uint16_t>((interface_address & 0x00ff) + 1);
|
||||
if (device == 0 || device > 0xff) {
|
||||
device = 1;
|
||||
}
|
||||
uint16_t address = static_cast<uint16_t>((interface_address & 0xff00) | device);
|
||||
if (address == 0xffff) {
|
||||
address = static_cast<uint16_t>((interface_address & 0xff00) | 0x0001);
|
||||
}
|
||||
return address;
|
||||
}
|
||||
|
||||
} // namespace gateway
|
||||
Reference in New Issue
Block a user