validate_messages.hpp

// Copyright (c) 2024 GoesM
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
 
#ifndef  NAV2_ROS_COMMON__VALIDATE_MESSAGES_HPP_
#define  NAV2_ROS_COMMON__VALIDATE_MESSAGES_HPP_
 
#include <array>
#include <cmath>
#include <iostream>
#include <limits>
 
#include "nav_msgs/msg/occupancy_grid.hpp"
#include "nav_msgs/msg/odometry.hpp"
#include "nav2_msgs/msg/costmap.hpp"
#include "nav2_msgs/msg/costmap_meta_data.hpp"
#include "geometry_msgs/msg/pose_with_covariance_stamped.hpp"
#include "map_msgs/msg/occupancy_grid_update.hpp"
#include "sensor_msgs/msg/range.hpp"
 
 
// @brief Validation Check
//  Check received message is safe or not for the nav2-system
//  For each msg-type known in nav2, we could check it as following:
//  if(!validateMsg()) RCLCPP_ERROR(,"malformed msg. Rejecting.")
//
//  Workflow of validateMsg():
//     if here's a sub-msg-type in the received msg,
//        the content of sub-msg would be checked as sub-msg-type
//     then, check the whole received msg.
//
//  Following conditions are involved in check:
//     1> Value Check: to avoid damaged value like like `nan`, `INF`, empty string and so on
//     2> Logic Check: to avoid value with bad logic,
//             like the size of `map` should be equal to `height*width`
//     3> Any other needed condition could be joint here in future
 
namespace nav2
{
 
 
bool validateMsg(const double & num)
{
  /*  @brief double/float value check
   *  if here'a need to check message validation
   *  it should be avoid to use double value like `nan`, `inf`
   *  otherwise, we regard it as an invalid message
   */
  if (std::isinf(num)) {return false;}
  if (std::isnan(num)) {return false;}
  return true;
}
 
const double MAX_COVARIANCE = 1e9;
const double MIN_COVARIANCE = 0;
const double MIN_MAP_RESOLUTION = 1e-6;
const double MAX_RANGE_FIELD_OF_VIEW = M_PI;
 
template<size_t N>
bool validateMsg(const std::array<double, N> & msg)
{
  /*  @brief value check for double-array
   *     like the field `covariance` used in the msg-type:
   *       geometry_msgs::msg::PoseWithCovarianceStamped
   */
  for (const auto & element : msg) {
    if (!validateMsg(element)) {return false;}
 
    if (std::abs(element) > MAX_COVARIANCE || element < MIN_COVARIANCE) {
      return false;
    }
  }
 
  return true;
}
 
constexpr int NANOSECONDS_PER_SECOND = 1e9;
bool validateMsg(const builtin_interfaces::msg::Time & msg)
{
  if (msg.nanosec >= NANOSECONDS_PER_SECOND) {
    return false;                                      // invalid nanosec-stamp
  }
  return true;
}
 
bool validateMsg(const std_msgs::msg::Header & msg)
{
  //  check sub-type
  if (!validateMsg(msg.stamp)) {return false;}
 
  /*  @brief frame_id check
   *  if here'a need to check message validation
   *  it should at least have a non-empty frame_id
   *  otherwise, we regard it as an invalid message
   */
  if (msg.frame_id.empty()) {return false;}
  return true;
}
 
bool validateMsg(const geometry_msgs::msg::Point & msg)
{
  //  check sub-type
  if (!validateMsg(msg.x)) {return false;}
  if (!validateMsg(msg.y)) {return false;}
  if (!validateMsg(msg.z)) {return false;}
  return true;
}
 
const double epsilon = 1e-4;
bool validateMsg(const geometry_msgs::msg::Quaternion & msg)
{
  //  check sub-type
  if (!validateMsg(msg.x)) {return false;}
  if (!validateMsg(msg.y)) {return false;}
  if (!validateMsg(msg.z)) {return false;}
  if (!validateMsg(msg.w)) {return false;}
 
  if (abs(msg.x * msg.x + msg.y * msg.y + msg.z * msg.z + msg.w * msg.w - 1.0) >= epsilon) {
    return false;
  }
 
  return true;
}
 
bool validateMsg(const geometry_msgs::msg::Pose & msg)
{
  // check sub-type
  if (!validateMsg(msg.position)) {return false;}
  if (!validateMsg(msg.orientation)) {return false;}
  return true;
}
 
bool validateMsg(const geometry_msgs::msg::PoseWithCovariance & msg)
{
  // check sub-type
  if (!validateMsg(msg.pose)) {return false;}
  if (!validateMsg(msg.covariance)) {return false;}
 
  return true;
}
 
bool validateMsg(const geometry_msgs::msg::PoseWithCovarianceStamped & msg)
{
  // check sub-type
  if (!validateMsg(msg.header)) {return false;}
  if (!validateMsg(msg.pose)) {return false;}
  if (!validateMsg(msg.pose.covariance)) {return false;}
  return true;
}
 
 
// Function to verify map meta information
bool validateMsg(const nav_msgs::msg::MapMetaData & msg)
{
  // check sub-type
  if (!validateMsg(msg.origin)) {return false;}
  if (!validateMsg(msg.resolution)) {return false;}
 
  if (msg.resolution < MIN_MAP_RESOLUTION) {return false;}
 
  // logic check
  // 1> we don't need an empty map
  if (msg.height == 0 || msg.width == 0) {return false;}
  return true;
}
 
// for msg-type like map, costmap and others as `OccupancyGrid`
bool validateMsg(const nav_msgs::msg::OccupancyGrid & msg)
{
  // check sub-type
  if (!validateMsg(msg.header)) {return false;}
  // msg.data :  @todo any check for it ?
  if (!validateMsg(msg.info)) {return false;}
 
  if (msg.info.width > INT16_MAX || msg.info.height > INT16_MAX) {
    // avoid overflow in nav2_amcl::convertMap()
    // because map_t size_x and size_y are int
    return false;
  }
 
  if (msg.info.width != 0 &&
    msg.info.height > std::numeric_limits<uint32_t>::max() / msg.info.width)
  {
    // avoid overflow msg.info.width * msg.info.height in nav2_amcl::convertMap()
    return false;
  }
  const uint32_t num_cells = msg.info.width * msg.info.height;
 
  // check logic
  if (msg.data.size() != static_cast<size_t>(num_cells)) {
    return false;                                                          // check map-size
  }
 
  return true;
}
 
// for partial map updates as `OccupancyGridUpdate`
bool validateMsg(const map_msgs::msg::OccupancyGridUpdate & msg)
{
  // check sub-type
  if (!validateMsg(msg.header)) {return false;}
 
  // check logic
  if (msg.data.size() != static_cast<size_t>(msg.width) * msg.height) {
    return false;  // check update-size
  }
 
  // value check: x/y are int32, negative origin is invalid
  if (msg.x < 0 || msg.y < 0) {return false;}
 
  if (msg.x > INT16_MAX || msg.y > INT16_MAX ||
    msg.width > INT16_MAX || msg.height > INT16_MAX)
  {
    // avoid integer overflow in StaticLayer::incomingUpdate()
    return false;
  }
 
  if (msg.width != 0 &&
    msg.height > std::numeric_limits<uint32_t>::max() / msg.width)
  {
    // avoid overflow msg.width * msg.height in StaticLayer::incomingUpdate()
    return false;
  }
 
  return true;
}
 
bool validateMsg(const sensor_msgs::msg::Range & msg)
{
  if (!validateMsg(msg.header)) {return false;}
  if (!validateMsg(static_cast<double>(msg.field_of_view))) {return false;}
  if (!validateMsg(static_cast<double>(msg.min_range))) {return false;}
  if (!validateMsg(static_cast<double>(msg.max_range))) {return false;}
  if (!validateMsg(static_cast<double>(msg.range))) {return false;}
 
  if (msg.field_of_view <= 0.0 || msg.field_of_view > MAX_RANGE_FIELD_OF_VIEW) {
    return false;
  }
 
  if (msg.min_range < 0.0 || msg.max_range <= msg.min_range) {
    return false;
  }
 
  return true;
}
 
bool validateMsg(const nav2_msgs::msg::CostmapMetaData & msg)
{
  if (!validateMsg(msg.origin)) {return false;}
  if (!validateMsg(msg.resolution)) {return false;}
 
  if (msg.resolution < MIN_MAP_RESOLUTION) {return false;}
  if (msg.size_x == 0 || msg.size_y == 0) {return false;}
 
  return true;
}
 
bool validateMsg(const nav2_msgs::msg::Costmap & msg)
{
  if (!validateMsg(msg.header)) {return false;}
  if (!validateMsg(msg.metadata)) {return false;}
 
  if (msg.metadata.size_x != 0 &&
    msg.metadata.size_y > std::numeric_limits<uint32_t>::max() / msg.metadata.size_x)
  {
    return false;
  }
  const uint32_t num_cells = msg.metadata.size_x * msg.metadata.size_y;
 
  if (msg.data.size() != static_cast<size_t>(num_cells)) {
    return false;
  }
 
  return true;
}
 
}  //  namespace nav2
 
#endif  // NAV2_ROS_COMMON__VALIDATE_MESSAGES_HPP_