This is an automated email from the ASF dual-hosted git repository.
amc pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new ad17bbd612 libswoc: Update WCCP use of Errata. (#9875)
ad17bbd612 is described below
commit ad17bbd612f280f519b4e1f2cfab314c2e830785
Author: Alan M. Carroll <[email protected]>
AuthorDate: Tue Jul 18 17:20:04 2023 -0500
libswoc: Update WCCP use of Errata. (#9875)
---
include/tscpp/util/ts_errata.h | 26 +++
include/wccp/Wccp.h | 18 +-
src/traffic_wccp/Makefile.inc | 8 +-
src/traffic_wccp/wccp_client.cc | 23 +-
src/wccp/WccpConfig.cc | 503 +++++++++++++++++++++-------------------
src/wccp/WccpEndPoint.cc | 196 ++++++++--------
src/wccp/WccpLocal.h | 50 ++--
src/wccp/WccpMsg.cc | 29 +--
src/wccp/WccpStatic.cc | 48 +++-
src/wccp/WccpUtil.h | 79 -------
10 files changed, 491 insertions(+), 489 deletions(-)
diff --git a/include/tscpp/util/ts_errata.h b/include/tscpp/util/ts_errata.h
index e9b6d7d2ae..8ac508e5ae 100644
--- a/include/tscpp/util/ts_errata.h
+++ b/include/tscpp/util/ts_errata.h
@@ -21,6 +21,8 @@ limitations under the License.
#pragma once
+#include <utility>
+
#include "tscpp/util/ts_diag_levels.h"
#include "swoc/TextView.h"
#include "swoc/Errata.h"
@@ -35,6 +37,23 @@ static constexpr swoc::Errata::Severity
ERRATA_FATAL{DL_Fatal};
static constexpr swoc::Errata::Severity ERRATA_ALERT{DL_Alert};
static constexpr swoc::Errata::Severity ERRATA_EMERGENCY{DL_Emergency};
+inline DiagsLevel
+diags_level_of(swoc::Errata::Severity s)
+{
+ return static_cast<DiagsLevel>(static_cast<int>(s));
+}
+
+inline std::error_code
+ec_for()
+{
+ return std::error_code(errno, std::system_category());
+}
+inline std::error_code
+ec_for(int e)
+{
+ return std::error_code(e, std::system_category());
+}
+
// This is treated as an array so must numerically match with @c DiagsLevel
static constexpr std::array<swoc::TextView, 9> Severity_Names{
{"Diag", "Debug", "Status", "Note", "Warn", "Error", "Fatal", "Alert",
"Emergency"}
@@ -53,3 +72,10 @@ make_errno_code(int err)
// Temporary string for formatting.
inline thread_local std::string bw_dbg;
+
+template <typename... Args>
+void
+bw_log(DiagsLevel lvl, swoc::TextView fmt, Args &&...args)
+{
+ swoc::bwprint_v(bw_dbg, fmt, std::forward_as_tuple(args...));
+}
diff --git a/include/wccp/Wccp.h b/include/wccp/Wccp.h
index ffba07bad8..aa156c09d7 100644
--- a/include/wccp/Wccp.h
+++ b/include/wccp/Wccp.h
@@ -24,14 +24,14 @@
#include <memory.h>
#include <string_view>
-
// INADDR_ANY
#include <netinet/in.h>
+#include "tscpp/util/ts_errata.h"
+
#include "tscore/ink_defs.h"
#include "tscore/ink_memory.h"
#include "tscore/IntrusivePtr.h"
-#include "tscore/Errata.h"
// Nasty, defining this with no prefix. The value is still available
// in TS_VERSION_STRING.
@@ -88,6 +88,9 @@ struct ServiceConstants {
};
};
+swoc::BufferWriter &bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const
&spec, ServiceConstants::PacketStyle);
+swoc::BufferWriter &bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const
&spec, ServiceConstants::CacheAssignmentStyle);
+
/** Service group definition.
Also used as serialized layout internally by ServiceGroupElt. This is kept
@@ -121,7 +124,7 @@ public:
static uint8_t const RESERVED = 50;
/// Number of ports in component (defined by protocol).
- static size_t const N_PORTS = 8;
+ static constexpr size_t const N_PORTS = 8;
/// @name Flag mask values.
//@{
@@ -240,8 +243,7 @@ public:
@return 0 on success, -ERRNO on failure.
@see setAddr
*/
- int open(uint32_t addr = INADDR_ANY ///< Local IP address for socket.
- );
+ swoc::Errata open(uint32_t addr = INADDR_ANY);
/// Get the internal socket.
/// Useful primarily for socket options and using
@@ -257,7 +259,7 @@ public:
/// Receive and process a message on the socket.
/// @return 0 for success, -ERRNO on system error.
- ts::Rv<int> handleMessage();
+ swoc::Errata handleMessage();
protected:
/// Default constructor.
@@ -295,8 +297,8 @@ public:
~Cache() override;
/// Define services from a configuration file.
- ts::Errata loadServicesFromFile(char const *path ///< Path to file.
- );
+ /// @param path Path to configuration file.
+ swoc::Errata loadServicesFromFile(char const *path);
/** Define a service group.
diff --git a/src/traffic_wccp/Makefile.inc b/src/traffic_wccp/Makefile.inc
index 1e2150c478..5298ca77b7 100644
--- a/src/traffic_wccp/Makefile.inc
+++ b/src/traffic_wccp/Makefile.inc
@@ -25,11 +25,13 @@ traffic_wccp_traffic_wccp_CPPFLAGS = \
-I$(abs_top_srcdir)/include \
-I$(abs_top_srcdir)/lib \
$(TS_INCLUDES) \
- @OPENSSL_INCLUDES@
+ @SWOC_INCLUDES@ \
+ @OPENSSL_INCLUDES@
traffic_wccp_traffic_wccp_LDFLAGS = \
$(AM_LDFLAGS) \
- @OPENSSL_LDFLAGS@
+ @SWOC_LDFLAGS@ \
+ @OPENSSL_LDFLAGS@
traffic_wccp_traffic_wccp_SOURCES = \
traffic_wccp/wccp_client.cc
@@ -38,4 +40,4 @@ traffic_wccp_traffic_wccp_LDADD = \
$(top_builddir)/src/wccp/libwccp.a \
$(top_builddir)/src/tscore/libtscore.a \
$(top_builddir)/src/tscpp/util/libtscpputil.la \
- @OPENSSL_LIBS@
+ @SWOC_LIBS@ @OPENSSL_LIBS@
diff --git a/src/traffic_wccp/wccp_client.cc b/src/traffic_wccp/wccp_client.cc
index 17ceee648f..535fd8039f 100644
--- a/src/traffic_wccp/wccp_client.cc
+++ b/src/traffic_wccp/wccp_client.cc
@@ -56,28 +56,17 @@ static const char USAGE_TEXT[] = "%s\n"
"--help Print usage and exit.\n";
static void
-PrintErrata(ts::Errata const &err)
+PrintErrata(swoc::Errata const &err)
{
- size_t n;
- static size_t const SIZE = 4096;
- char buff[SIZE];
- if (err.size()) {
- ts::Errata::Code code = err.top().getCode();
- if (do_debug || code >= wccp::LVL_WARN) {
- n = err.write(buff, SIZE, 1, 0, 2, "> ");
- // strip trailing newlines.
- while (n && (buff[n - 1] == '\n' || buff[n - 1] == '\r')) {
- buff[--n] = 0;
- }
- printf("%s\n", buff);
- }
+ if (err.length()) {
+ bw_log(diags_level_of(err.severity()), "{}", err);
}
}
static void
Init_Errata_Logging()
{
- ts::Errata::registerSink(&PrintErrata);
+ swoc::Errata::register_sink(&PrintErrata);
}
static void
@@ -165,7 +154,7 @@ main(int argc, char **argv)
}
break;
case OPT_SERVICE: {
- ts::Errata status = wcp.loadServicesFromFile(optarg);
+ auto status = wcp.loadServicesFromFile(optarg);
if (!status) {
fail = true;
}
@@ -185,7 +174,7 @@ main(int argc, char **argv)
return 1;
}
- if (0 > wcp.open(ip_addr.s_addr)) {
+ if (auto result = wcp.open(ip_addr.s_addr); !result.is_ok()) {
fprintf(stderr, "Failed to open or bind socket.\n");
return 2;
}
diff --git a/src/wccp/WccpConfig.cc b/src/wccp/WccpConfig.cc
index c10490b514..1f10eb6ffe 100644
--- a/src/wccp/WccpConfig.cc
+++ b/src/wccp/WccpConfig.cc
@@ -27,8 +27,43 @@
#include <errno.h>
#include <stdlib.h>
+#include "swoc/Lexicon.h"
+
#include <yaml-cpp/yaml.h>
+using swoc::TextView;
+using swoc::Errata;
+
+using namespace swoc::literals;
+
+namespace wccp
+{
+swoc::BufferWriter &
+bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec,
ServiceGroup::Type type)
+{
+ return bwformat(w, spec, type == wccp::ServiceGroup::STANDARD ?
"STANDARD"_tv : "DYNAMIC"_tv);
+}
+} // namespace wccp
+
+namespace YAML
+{
+swoc::Lexicon<NodeType::value> YamlNodeTypeNames{
+ {{NodeType::Undefined, "Undefined"},
+ {NodeType::Null, "NULL"},
+ {NodeType::Scalar, "Scalar"},
+ {NodeType::Sequence, "Sequence"},
+ {NodeType::Map, "Map"}},
+ "Unknown"
+};
+
+swoc::BufferWriter &
+bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec, NodeType::value v)
+{
+ return bwformat(w, spec, YamlNodeTypeNames[v]);
+}
+
+} // namespace YAML
+
// WCCP related things that are file local.
namespace
{
@@ -40,28 +75,28 @@ using namespace wccp;
std::vector<uint32_t> Seed_Router;
// Names used for various elements and properties.
-static const char *const SVC_NAME = "service";
+static constexpr TextView SVC_NAME = "service";
const std::string SVCS_NAME = "services";
const std::string WCCP_NAME = "wccp";
-static const char *const SVC_PROP_ID = "id";
-static const char *const SVC_PROP_TYPE = "type";
-static const char *const SVC_PROP_PRIORITY = "priority";
-static const char *const SVC_PROP_PROTOCOL = "protocol";
-static const char *const SVC_PROP_PRIMARY_HASH = "primary-hash";
-static const char *const SVC_PROP_ALT_HASH = "alt-hash";
-static const char *const SVC_PROP_PORTS = "ports";
-static const char *const SVC_PROP_PORT_TYPE = "port-type";
-static const char *const SVC_PROP_SECURITY = "security";
-static const char *const SVC_PROP_ROUTERS = "routers";
-static const char *const SVC_PROP_FORWARD = "forward";
-static const char *const SVC_PROP_RETURN = "return";
-static const char *const SVC_PROP_ASSIGN = "assignment";
-static const char *const SVC_PROP_PROC = "proc-name";
-
-static const char *const SECURITY_PROP_OPTION = "option";
-static const char *const SECURITY_PROP_KEY = "key";
+static constexpr TextView SVC_PROP_ID = "id";
+static const char *const SVC_PROP_TYPE = "type";
+static constexpr TextView SVC_PROP_PRIORITY = "priority";
+static constexpr TextView SVC_PROP_PROTOCOL = "protocol";
+static constexpr TextView SVC_PROP_PRIMARY_HASH = "primary-hash";
+static constexpr TextView SVC_PROP_ALT_HASH = "alt-hash";
+static constexpr TextView SVC_PROP_PORTS = "ports";
+static const char *const SVC_PROP_PORT_TYPE = "port-type";
+static constexpr TextView SVC_PROP_SECURITY = "security";
+static const char *const SVC_PROP_ROUTERS = "routers";
+static constexpr TextView SVC_PROP_FORWARD = "forward";
+static constexpr TextView SVC_PROP_RETURN = "return";
+static constexpr TextView SVC_PROP_ASSIGN = "assignment";
+static const char *const SVC_PROP_PROC = "proc-name";
+
+static constexpr TextView SECURITY_PROP_OPTION = "option";
+static constexpr TextView SECURITY_PROP_KEY = "key";
/// Helper structure for processing configuration strings.
struct CfgString {
@@ -96,189 +131,188 @@ CfgString HASH_OPTS[] = {
{"dst_port", false}
};
-ts::Errata::Code
-code_max(ts::Errata const &err)
+inline Errata
+Unable_To_Create_Service_Group(int line)
{
- ts::Errata::Code zret =
std::numeric_limits<ts::Errata::Code::raw_type>::min();
- ts::Errata::const_iterator spot = err.begin();
- ts::Errata::const_iterator limit = err.end();
- for (; spot != limit; ++spot)
- zret = std::max(zret, spot->getCode());
- return zret;
+ return Errata(ec_for(EINVAL), ERRATA_FATAL, "Unable to create service group
at line {} of configuration.", line);
}
-ts::Errata::Message
-Unable_To_Create_Service_Group(int line)
+inline Errata &
+Note_Services_Not_Found(Errata &errata)
{
- std::ostringstream out;
- out << "Unable to create service group at line " << line << " because of
configuration errors.";
- return ts::Errata::Message(23, LVL_FATAL, out.str());
+ return errata.note(ERRATA_NOTE, "No services found in configuration.");
}
-ts::Errata::Message
+inline Errata
Services_Not_Found()
{
- return ts::Errata::Message(3, LVL_INFO, "No services found in
configuration.");
+ Errata errata;
+ errata.note(ERRATA_NOTE, "No services found in configuration.");
+ return errata;
}
-ts::Errata::Message
+inline Errata
Services_Not_A_Sequence()
{
- return ts::Errata::Message(4, LVL_INFO, "The 'services' setting was not a
list nor array.");
+ return Errata(ec_for(EINVAL), ERRATA_NOTE, "The 'services' setting was not a
list nor array.");
}
-ts::Errata::Message
+inline Errata &
+Note_Service_Type_Defaulted(Errata &errata, wccp::ServiceGroup::Type type, int
line)
+{
+ return errata.note(ERRATA_NOTE, "'type' keyword not found in {} at line {}
-- defaulting to {}", SVC_NAME, line, type);
+}
+
+inline Errata
Service_Type_Defaulted(wccp::ServiceGroup::Type type, int line)
{
- std::ostringstream out;
- out << "'type' not found in " << SVC_NAME << " at line " << line << "' --
defaulting to "
- << (type == wccp::ServiceGroup::STANDARD ? "STANDARD" : "DYNAMIC");
- return ts::Errata::Message(6, LVL_INFO, out.str());
+ Errata errata;
+ Note_Service_Type_Defaulted(errata.assign(ec_for(ENOENT)), type, line);
+ return errata;
+}
+
+inline Errata &
+Note_Service_Type_Invalid(Errata &errata, TextView text, int line)
+{
+ return errata.note(ERRATA_WARN, R"(Service type "{}" at line {} is invalid.
Must be "STANDARD" or "DYNAMIC".)");
+}
+
+inline Errata
+Service_Type_Invalid(TextView text, int line)
+{
+ Errata errata;
+ Note_Service_Type_Invalid(errata, text, line);
+ errata.assign(ec_for(EINVAL));
+ return errata;
}
-ts::Errata::Message
-Service_Type_Invalid(const std::string &text, int line)
+inline Errata &
+Note_Prop_Not_Found(Errata &errata, TextView prop_name, TextView group_name,
int line)
{
- std::ostringstream out;
- out << "Service type '" << text << "' at line " << line << " invalid. Must
be \"STANDARD\" or \"DYNAMIC\"";
- return ts::Errata::Message(7, LVL_WARN, out.str());
+ return errata.note(ERRATA_WARN, R"(Required property "{}" not found in "{}"
at line {})", prop_name, group_name, line);
}
-ts::Errata::Message
-Prop_Not_Found(const std::string &prop_name, const std::string &group_name,
int line)
+inline Errata
+Prop_Not_Found(TextView prop_name, TextView group_name, int line)
{
- std::ostringstream out;
- out << "Required '" << prop_name << "' property not found in '" <<
group_name << "' at line " << line << ".";
- return ts::Errata::Message(8, LVL_WARN, out.str());
+ Errata errata;
+ Note_Prop_Not_Found(errata, prop_name, group_name, line);
+ return errata;
}
-ts::Errata::Message
-Prop_Invalid_Type(const std::string &prop_name, const YAML::Node &prop_cfg,
YAML::NodeType::value expected)
+inline Errata
+Prop_Invalid_Type(TextView prop_name, const YAML::Node &prop_cfg,
YAML::NodeType::value expected)
{
- std::ostringstream out;
- out << "'" << prop_name << "' is of type '" << prop_cfg.Type() << "' instead
of required type '" << expected << "'.";
- return ts::Errata::Message(9, LVL_WARN, out.str());
+ return {ec_for(EINVAL), ERRATA_WARN, R"("{}" is not of type "{}" instead
of required type "{}".)",
+ prop_name, prop_cfg.Type(), expected};
}
-ts::Errata::Message
-Svc_Prop_Out_Of_Range(const std::string &name, int line, int v, int min, int
max)
+inline swoc::Errata &
+Note_Svc_Prop_Out_Of_Range(Errata &errata, TextView name, int line, int v, int
min, int max)
{
- std::ostringstream out;
- out << "Service property '" << name << "' at line " << line << " has a value
" << v << " that is not in the allowed range of "
- << min << ".." << max << ".";
- return ts::Errata::Message(10, LVL_WARN, out.str());
+ return errata.note(ERRATA_WARN,
+ R"(Service property "{}" at line {} has a value "{}" that
is not in the allowed range of {}..{} .)", name,
+ line, v, min, max);
}
-ts::Errata::Message
-Svc_Prop_Ignored(const char *name, int line)
+inline Errata &
+Note_Svc_Prop_Ignored(Errata &errata, TextView name, int line)
{
- std::ostringstream out;
- out << "Service property '" << name << "' at line " << line << " ignored
because the service is of type standard.";
- return ts::Errata::Message(11, LVL_INFO, out.str());
+ errata.note(ERRATA_NOTE, R"(Service property "{}" at line {} ignored because
the service is of type standard.)", name, line);
+ return errata;
}
-ts::Errata::Message
-Svc_Ports_Too_Many(int line, int n)
+inline Errata &
+Note_Svc_Ports_Too_Many(Errata &errata, int line, int n)
{
- std::ostringstream out;
- out << "Excess ports ignored at line " << line << ". " << n << " ports
specified, only" << wccp::ServiceGroup::N_PORTS
- << " supported.";
- return ts::Errata::Message(14, LVL_INFO, out.str());
+ errata.note(ERRATA_NOTE, "Excess ports ignored at line {}. {} ports
specified, only {} supported.", line, n,
+ wccp::ServiceGroup::N_PORTS);
+ return errata;
}
-ts::Errata::Message
-Svc_Ports_None_Valid(int line)
+inline Errata &
+Note_Svc_Ports_None_Valid(Errata &errata, int line)
{
- std::ostringstream out;
- out << "A '" << SVC_PROP_PORTS << "' property was found at line " << line <<
" but none of the ports were valid.";
- return ts::Errata::Message(17, LVL_WARN, out.str());
+ errata.note(ERRATA_WARN, R"(A "{}" property was found at line {} but none of
the ports were valid.)", SVC_PROP_PORTS, line);
+ return errata;
}
-ts::Errata::Message
-Svc_Ports_Not_Found(int line)
+inline Errata &
+Note_Svc_Ports_Not_Found(Errata &errata, int line)
{
- std::ostringstream out;
- out << "Ports not found in service at line " << line << ". Ports must be
defined for a dynamic service.";
- return ts::Errata::Message(18, LVL_WARN, out.str());
+ return errata.note("Ports not found in service at line {]. Ports must be
defined for a dynamic service.", line);
}
-ts::Errata::Message
-Svc_Prop_Ignored_In_Standard(const std::string &name, int line)
+Errata &
+Note_Svc_Prop_Ignored_In_Standard(Errata &errata, TextView name, int line)
{
- std::ostringstream out;
- out << "Service property '" << name << "' at line " << line << " ignored
because the service is of type STANDARD.";
- return ts::Errata::Message(19, LVL_INFO, out.str());
+ return errata.note(R"(Service property "{}" at line {} ignored because the
service is of type STANDARD.)", name, line);
}
-ts::Errata::Message
-Security_Opt_Invalid(const std::string &text, int line)
+inline Errata
+Security_Opt_Invalid(TextView text, int line)
{
- std::ostringstream out;
- out << "Security option '" << text << "' at line " << line << " is invalid.
It must be 'none' or 'md5'.";
- return ts::Errata::Message(20, LVL_WARN, out.str());
+ return {ERRATA_WARN, R"(Security option "{}" at line {} is invalid. It must
be 'none' or 'md5'.)", text};
}
-ts::Errata::Message
-Value_Malformed(const std::string &name, const std::string &text, int line)
+inline Errata &
+Note_Value_Malformed(Errata &errata, const std::string &name, const
std::string &text, int line)
{
- std::ostringstream out;
- out << "'" << name << "' value '" << text << "' malformed at line " << line
<< ".";
- return ts::Errata::Message(21, LVL_WARN, out.str());
+ return errata.note(ERRATA_WARN, R"("{}" value "{}" malformed at line {})",
name, text, line);
}
-ts::Errata::Message
-No_Valid_Routers(int line)
+inline Errata &
+Note_No_Valid_Routers(Errata &errata, int line)
{
- std::ostringstream out;
- out << "No valid IP address for routers found for Service Group at line " <<
line << ".";
- return ts::Errata::Message(22, LVL_WARN, out.str());
+ return errata.note(ERRATA_WARN, "No valid IP address for routers found for
Service Group at line {}.", line);
}
-ts::Errata::Message
-Ignored_Option_Value(const std::string &text, const std::string &name, int
line)
+inline Errata &
+Note_Ignored_Option_Value(Errata &errata, TextView text, TextView name, int
line)
{
- std::ostringstream out;
- out << "Value '" << text << "' at line " << line << " was ignored because it
is not a valid option for '" << name << "'.";
- return ts::Errata::Message(24, LVL_INFO, out.str());
+ return errata.note(ERRATA_NOTE, "Value \"{}\" at line {} was ignored because
it is not a valid option for \"{}\".", text, line,
+ name);
}
-ts::Errata::Message
-Ignored_Opt_Errors(const std::string &name, int line)
+inline Errata &
+Note_Ignored_Opt_Errors(Errata &errata, TextView name, int line)
{
- std::ostringstream out;
- out << "Errors in '" << name << "' were ignored.";
- return ts::Errata::Message(28, LVL_INFO, out.str());
+ return errata.note(ERRATA_NOTE, "Errors in \"{}\" were ignored.", name);
}
-ts::Errata::Message
-List_Valid_Opts(const std::string &name, int line, CfgString *values, size_t n)
+Errata &
+Note_List_Valid_Opts(Errata &errata, TextView name, int line, CfgString
*values, size_t n)
{
- std::ostringstream out;
- out << "Valid values for the '" << name << "' property at line " << line <<
" are: ";
- out << '"' << values[0].m_text << '"';
- for (size_t i = 1; i < n; ++i)
- out << ", \"" << values[i].m_text << '"';
- out << '.';
- return ts::Errata::Message(29, LVL_INFO, out.str());
+ swoc::LocalBufferWriter<2048> w;
+ w.print("Valid values for the \"{}\" property at line {} are:", name, line);
+ for (size_t i = 0; i < n; ++i) {
+ w.print("{}", values[i].m_text);
+ }
+ return errata.note(ERRATA_NOTE, w.view());
}
-ts::Errata::Message
-Port_Type_Invalid(const std::string &text, int line)
+inline Errata &
+Note_Port_Type_Invalid(Errata &errata, TextView text, int line)
{
- std::ostringstream out;
- out << "Value '" << text << "' at line " << line << "for property '" <<
SVC_PROP_PORT_TYPE
- << "' is invalid. It must be 'src' or 'dst'.";
- return ts::Errata::Message(30, LVL_WARN, out.str());
+ return errata.note(ERRATA_WARN, R"(Value "{}" at line {} for property "{}"
is invalid. It must be 'src' or 'dst'.)", text, line,
+ SVC_PROP_PORT_TYPE);
+}
+
+inline Errata
+Port_Type_Invalid(TextView text, int line)
+{
+ Errata errata;
+ Note_Port_Type_Invalid(errata, text, line);
+ return errata;
}
} // namespace
namespace wccp
{
-ts::Errata
-load_option_set(const YAML::Node &setting, const char *name, CfgString *opts,
size_t count)
+Errata
+load_option_set(const YAML::Node &setting, TextView name, CfgString *opts,
size_t count)
{
- ts::Errata zret;
CfgString *spot;
CfgString *limit = opts + count;
int src_line = setting.Mark().line;
@@ -289,14 +323,14 @@ load_option_set(const YAML::Node &setting, const char
*name, CfgString *opts, si
// Walk through the strings in the setting.
if (!setting.IsSequence()) {
- zret.push(Prop_Invalid_Type(name, setting, YAML::NodeType::Sequence));
- return zret;
+ return Prop_Invalid_Type(name, setting, YAML::NodeType::Sequence);
}
+ Errata errata;
bool list_opts = false;
for (auto it = setting.begin(); it != setting.end(); ++it) {
- YAML::Node item = *it;
- std::string text = item.as<std::string>();
+ YAML::Node item = *it;
+ std::string_view text = item.Scalar();
for (spot = opts; spot < limit; ++spot) {
if (spot->m_text == text) {
spot->m_found = true;
@@ -304,77 +338,69 @@ load_option_set(const YAML::Node &setting, const char
*name, CfgString *opts, si
}
}
if (spot >= limit) {
- zret.push(Ignored_Option_Value(text, name, item.Mark().line));
+ Note_Ignored_Option_Value(errata, text, name, item.Mark().line);
list_opts = true;
}
}
if (list_opts) {
- zret.push(List_Valid_Opts(name, src_line, opts, count));
+ Note_List_Valid_Opts(errata, name, src_line, opts, count);
}
- return zret;
+ return errata;
}
-/** On success this returns a non @c NULL pointer if the MD5 option is
- set. In that case the pointer points at the MD5 key. Otherwise
- the option was none and the pointer is @c NULL
- */
-ts::Rv<std::string>
-load_security(const YAML::Node &setting ///< Security setting.
-)
+/// If successful, the string contains the MD5 key is present, otherwise it's
empty.
+swoc::Rv<std::string>
+load_security(const YAML::Node &setting)
{
- ts::Rv<std::string> zret;
-
- auto opt = setting[SECURITY_PROP_OPTION];
+ auto opt = setting[SECURITY_PROP_OPTION.data()];
if (!opt) {
- zret.push(Prop_Not_Found(SECURITY_PROP_OPTION, SVC_PROP_SECURITY,
setting.Mark().line));
- return zret;
+ return Prop_Not_Found(SECURITY_PROP_OPTION, SVC_PROP_SECURITY,
setting.Mark().line);
}
- std::string text = opt.as<std::string>();
+ TextView text = opt.Scalar();
if ("none" == text) {
} else if ("md5" == text) {
- YAML::Node key = setting[SECURITY_PROP_KEY];
+ YAML::Node key = setting[SECURITY_PROP_KEY.data()];
if (key) {
- zret = key.as<std::string>();
+ return key.as<std::string>();
} else {
- zret.push(Prop_Not_Found(SECURITY_PROP_KEY, SVC_PROP_SECURITY,
opt.Mark().line));
+ return Prop_Not_Found(SECURITY_PROP_KEY, SVC_PROP_SECURITY,
opt.Mark().line);
}
} else {
- zret.push(Security_Opt_Invalid(text, opt.Mark().line));
+ return Security_Opt_Invalid(text, opt.Mark().line);
}
- return zret;
+ return {};
}
/// Process a router address list.
-ts::Errata
+Errata
load_routers(const YAML::Node &setting, ///< Source of addresses.
std::vector<uint32_t> &addrs ///< Output list
)
{
- ts::Errata zret;
static const char *const NAME = "IPv4 Address";
if (!setting.IsSequence()) {
- zret.push(Prop_Invalid_Type("routers", setting, YAML::NodeType::Sequence));
- return zret;
+ return Prop_Invalid_Type("routers", setting, YAML::NodeType::Sequence);
}
+ Errata errata;
for (auto const &addr_cfg : setting) {
in_addr addr;
std::string text = addr_cfg.as<std::string>();
if (inet_aton(text.c_str(), &addr)) {
addrs.push_back(addr.s_addr);
} else {
- zret.push(Value_Malformed(NAME, text, addr_cfg.Mark().line));
+ Note_Value_Malformed(errata, NAME, text, addr_cfg.Mark().line);
}
}
- return zret;
+ return errata;
}
-ts::Errata
+Errata
CacheImpl::loadServicesFromFile(const char *path)
{
try {
@@ -385,22 +411,20 @@ CacheImpl::loadServicesFromFile(const char *path)
YAML::Node wccp_node = cfg[WCCP_NAME];
if (!wccp_node) {
- return ts::Errata::Message(3, LVL_INFO, "No 'wccp' node found in
configuration.");
+ return Errata(ec_for(ENOENT), ERRATA_NOTE, "No 'wccp' node found in
configuration.");
}
return loader(wccp_node);
} catch (std::exception &ex) {
- return ts::Errata::Message(1, 1, ex.what());
+ return Errata(ec_for(EINVAL), ERRATA_ERROR, ex.what());
}
- return ts::Errata();
+ return {};
}
-ts::Errata
+Errata
CacheImpl::loader(const YAML::Node &cfg)
{
- ts::Errata zret;
-
YAML::Node svc_list = cfg[SVCS_NAME];
// No point in going on from here.
@@ -412,21 +436,24 @@ CacheImpl::loader(const YAML::Node &cfg)
return Services_Not_A_Sequence();
}
+ Errata errata;
+
// Check for global (default) security setting.
- YAML::Node prop_sec = cfg[SVC_PROP_SECURITY];
+ YAML::Node prop_sec = cfg[SVC_PROP_SECURITY.data()];
if (prop_sec) {
- ts::Rv<std::string> rv = load_security(prop_sec);
- if (rv.isOK() && rv.result().size() > 0) {
- std::string md5_key = rv.result();
- this->useMD5Security(md5_key);
+ auto rv = load_security(prop_sec);
+ if (rv.is_ok()) {
+ if (rv.result().size() > 0) {
+ this->useMD5Security(rv.result());
+ }
} else {
- zret.pull(rv.errata());
+ errata.note(rv);
}
}
auto prop_routers = cfg[SVC_PROP_ROUTERS];
if (prop_routers) {
- zret.pull(load_routers(prop_routers, Seed_Router).doNotLog());
+ errata.note(load_routers(prop_routers, Seed_Router));
}
for (auto it = svc_list.begin(); it != svc_list.end(); ++it) {
@@ -438,16 +465,17 @@ CacheImpl::loader(const YAML::Node &cfg)
ServiceGroup svc_info;
// Get the service ID.
- YAML::Node propId = svc_cfg[SVC_PROP_ID];
+ YAML::Node propId = svc_cfg[SVC_PROP_ID.data()];
if (propId) {
int x = propId.as<int>();
if (0 <= x && x <= 255) {
svc_info.setSvcId(x);
} else {
- zret.push(Svc_Prop_Out_Of_Range(SVC_PROP_ID, propId.Mark().line, x, 0,
255));
+ Note_Svc_Prop_Out_Of_Range(errata, SVC_PROP_ID, propId.Mark().line, x,
0, 255);
}
} else {
- zret.push(Prop_Not_Found(SVC_PROP_ID, SVC_NAME, svc_cfg.Mark().line));
+ errata.note(ERRATA_WARN, R"(Required property "{}" not found in "{}" at
line {})", SVC_PROP_ID, SVC_NAME,
+ svc_cfg.Mark().line);
}
// Service type.
@@ -459,54 +487,54 @@ CacheImpl::loader(const YAML::Node &cfg)
} else if ("STANDARD" == text) {
svc_info.setSvcType(ServiceGroup::STANDARD);
} else {
- zret.push(Service_Type_Invalid(text, propType.Mark().line));
+ Note_Service_Type_Invalid(errata, text, propType.Mark().line);
}
} else { // default type based on ID.
ServiceGroup::Type svc_type = svc_info.getSvcId() <=
ServiceGroup::RESERVED ? ServiceGroup::STANDARD : ServiceGroup::DYNAMIC;
svc_info.setSvcType(svc_type);
- zret.push(Service_Type_Defaulted(svc_type, it->Mark().line));
+ Note_Service_Type_Defaulted(errata, svc_type, it->Mark().line);
}
// Get the protocol.
- YAML::Node protocol = svc_cfg[SVC_PROP_PROTOCOL];
+ YAML::Node protocol = svc_cfg[SVC_PROP_PROTOCOL.data()];
if (protocol) {
if (svc_info.getSvcType() == ServiceGroup::STANDARD) {
- zret.push(Svc_Prop_Ignored(SVC_PROP_PROTOCOL, protocol.Mark().line));
+ Note_Svc_Prop_Ignored(errata, SVC_PROP_PROTOCOL, protocol.Mark().line);
} else {
int x = protocol.as<int>();
if (0 <= x && x <= 255) {
svc_info.setProtocol(x);
} else {
- zret.push(Svc_Prop_Out_Of_Range(SVC_PROP_ID, protocol.Mark().line,
x, 0, 255));
+ Note_Svc_Prop_Out_Of_Range(errata, SVC_PROP_ID,
protocol.Mark().line, x, 0, 255);
}
}
} else if (svc_info.getSvcType() != ServiceGroup::STANDARD) {
// Required if it's not standard / predefined.
- zret.push(Prop_Not_Found(SVC_PROP_PROTOCOL, SVC_NAME, it->Mark().line));
+ Note_Prop_Not_Found(errata, SVC_PROP_PROTOCOL, SVC_NAME,
it->Mark().line);
}
// Get the priority.
svc_info.setPriority(0); // OK to default to this value.
- YAML::Node priority = svc_cfg[SVC_PROP_PRIORITY];
+ YAML::Node priority = svc_cfg[SVC_PROP_PRIORITY.data()];
if (priority) {
if (svc_info.getSvcType() == ServiceGroup::STANDARD) {
- zret.push(Svc_Prop_Ignored(SVC_PROP_PRIORITY, priority.Mark().line));
+ Note_Svc_Prop_Ignored(errata, SVC_PROP_PRIORITY, priority.Mark().line);
} else {
int x = priority.as<int>();
if (0 <= x && x <= 255) {
svc_info.setPriority(x);
} else {
- zret.push(Svc_Prop_Out_Of_Range(SVC_PROP_ID, priority.Mark().line,
x, 0, 255));
+ Note_Svc_Prop_Out_Of_Range(errata, SVC_PROP_ID,
priority.Mark().line, x, 0, 255);
}
}
}
// Service flags.
svc_info.setFlags(0);
- YAML::Node primaryHash = svc_cfg[SVC_PROP_PRIMARY_HASH];
+ YAML::Node primaryHash = svc_cfg[SVC_PROP_PRIMARY_HASH.data()];
if (primaryHash) {
- ts::Errata status = load_option_set(primaryHash, SVC_PROP_PRIMARY_HASH,
HASH_OPTS, N_OPTS(HASH_OPTS));
- uint32_t f = 0;
+ Errata status = load_option_set(primaryHash, SVC_PROP_PRIMARY_HASH,
HASH_OPTS, N_OPTS(HASH_OPTS));
+ uint32_t f = 0;
for (size_t i = 0; i < N_OPTS(HASH_OPTS); ++i) {
if (HASH_OPTS[i].m_found) {
f |= ServiceGroup::SRC_IP_HASH << i;
@@ -516,19 +544,19 @@ CacheImpl::loader(const YAML::Node &cfg)
if (f) {
svc_info.enableFlags(f);
if (!status) {
- zret.push(Ignored_Opt_Errors(SVC_PROP_PRIMARY_HASH,
primaryHash.Mark().line).set(status));
+ Note_Ignored_Opt_Errors(errata, SVC_PROP_PRIMARY_HASH,
primaryHash.Mark().line).note(status);
}
} else {
- zret.push(List_Valid_Opts(SVC_PROP_PRIMARY_HASH,
primaryHash.Mark().line, HASH_OPTS, N_OPTS(HASH_OPTS)).set(status));
+ Note_List_Valid_Opts(errata, SVC_PROP_PRIMARY_HASH,
primaryHash.Mark().line, HASH_OPTS, N_OPTS(HASH_OPTS)).note(status);
}
} else {
- zret.push(Prop_Not_Found(SVC_PROP_PRIMARY_HASH, SVC_NAME,
primaryHash.Mark().line));
+ Note_Prop_Not_Found(errata, SVC_PROP_PRIMARY_HASH, SVC_NAME,
primaryHash.Mark().line);
}
- YAML::Node altHash = svc_cfg[SVC_PROP_ALT_HASH];
+ YAML::Node altHash = svc_cfg[SVC_PROP_ALT_HASH.data()];
if (altHash) {
- ts::Errata status = load_option_set(altHash, SVC_PROP_ALT_HASH,
HASH_OPTS, N_OPTS(HASH_OPTS));
- uint32_t f = 0;
+ auto status = load_option_set(altHash, SVC_PROP_ALT_HASH, HASH_OPTS,
N_OPTS(HASH_OPTS));
+ uint32_t f = 0;
for (size_t i = 0; i < N_OPTS(HASH_OPTS); ++i) {
if (HASH_OPTS[i].m_found) {
f |= ServiceGroup::SRC_IP_ALT_HASH << i;
@@ -540,7 +568,7 @@ CacheImpl::loader(const YAML::Node &cfg)
}
if (!status) {
- zret.push(Ignored_Opt_Errors(SVC_PROP_ALT_HASH,
altHash.Mark().line).set(status));
+ Note_Ignored_Opt_Errors(errata, SVC_PROP_ALT_HASH,
altHash.Mark().line).note(status);
}
}
@@ -552,17 +580,17 @@ CacheImpl::loader(const YAML::Node &cfg)
} else if ("dst" == text) {
svc_info.disableFlags(ServiceGroup::PORTS_SOURCE);
} else {
- zret.push(Port_Type_Invalid(text, portType.Mark().line));
+ Note_Port_Type_Invalid(errata, text, portType.Mark().line);
}
}
// Ports for service.
svc_info.clearPorts();
- YAML::Node ports = svc_cfg[SVC_PROP_PORTS];
+ YAML::Node ports = svc_cfg[SVC_PROP_PORTS.data()];
if (ports) {
if (ServiceGroup::STANDARD == svc_info.getSvcType()) {
- zret.push(Svc_Prop_Ignored_In_Standard(SVC_PROP_PORTS,
ports.Mark().line));
+ Note_Svc_Prop_Ignored_In_Standard(errata, SVC_PROP_PORTS,
ports.Mark().line);
} else {
size_t sidx = 0;
if (ports.IsSequence()) {
@@ -570,7 +598,7 @@ CacheImpl::loader(const YAML::Node &cfg)
// Clip to maximum protocol allowed ports.
if (nport > ServiceGroup::N_PORTS) {
- zret.push(Svc_Ports_Too_Many(ports.Mark().line, nport));
+ Note_Svc_Ports_Too_Many(errata, ports.Mark().line, nport);
nport = ServiceGroup::N_PORTS;
}
@@ -581,14 +609,14 @@ CacheImpl::loader(const YAML::Node &cfg)
if (0 <= x && x <= 65535) {
svc_info.setPort(sidx++, x);
} else {
- zret.push(Svc_Prop_Out_Of_Range(SVC_PROP_PORTS,
ports.Mark().line, x, 0, 65535));
+ Note_Svc_Prop_Out_Of_Range(errata, SVC_PROP_PORTS,
ports.Mark().line, x, 0, 65535);
}
}
if (sidx) {
svc_info.enableFlags(ServiceGroup::PORTS_DEFINED);
} else {
- zret.push(Svc_Ports_None_Valid(ports.Mark().line));
+ Note_Svc_Ports_None_Valid(errata, ports.Mark().line);
}
} else {
// port is a scalar
@@ -598,14 +626,14 @@ CacheImpl::loader(const YAML::Node &cfg)
}
}
} else if (ServiceGroup::STANDARD != svc_info.getSvcType()) {
- zret.push(Svc_Ports_Not_Found(ports.Mark().line));
+ Note_Svc_Ports_Not_Found(errata, ports.Mark().line);
}
// Security option for this service group.
- YAML::Node sec_prop = svc_cfg[SVC_PROP_SECURITY];
+ YAML::Node sec_prop = svc_cfg[SVC_PROP_SECURITY.data()];
if (sec_prop) {
- ts::Rv<std::string> security = load_security(sec_prop);
- if (security.isOK()) {
+ swoc::Rv<std::string> security = load_security(sec_prop);
+ if (security.is_ok()) {
use_group_local_security = true;
if (!security.result().empty()) {
md5_key = security.result();
@@ -614,27 +642,24 @@ CacheImpl::loader(const YAML::Node &cfg)
security_style = SECURITY_NONE;
}
}
- zret.pull(security.errata());
+ errata.note(security.errata());
}
// Get any group specific routers.
std::vector<uint32_t> routers;
YAML::Node routers_prop = svc_cfg[SVC_PROP_ROUTERS];
if (routers_prop) {
- ts::Errata status = load_routers(routers_prop, routers);
+ auto status = load_routers(routers_prop, routers);
if (!status)
- zret.push(ts::Errata::Message(23, LVL_INFO, "Router specification
invalid.").set(status));
+ errata.note(status);
}
if (!routers.size() && !Seed_Router.size()) {
- zret.push(No_Valid_Routers(routers_prop.Mark().line));
+ Note_No_Valid_Routers(errata, routers_prop.Mark().line);
}
- // See if can proceed with service group creation.
- ts::Errata::Code code = code_max(zret);
- if (code >= LVL_WARN) {
- zret = Unable_To_Create_Service_Group(svc_cfg.Mark().line).set(zret);
- return zret;
+ if (errata.severity() >= ERRATA_WARN) {
+ return
std::move(Unable_To_Create_Service_Group(svc_cfg.Mark().line).note(errata));
}
// Properties after this are optional so we can proceed if they fail.
@@ -663,55 +688,55 @@ CacheImpl::loader(const YAML::Node &cfg)
// Look for optional properties.
svc.m_packet_forward = ServiceGroup::GRE; // default
- YAML::Node forward = svc_cfg[SVC_PROP_FORWARD];
+ YAML::Node forward = svc_cfg[SVC_PROP_FORWARD.data()];
if (forward) {
- ts::Errata status = load_option_set(forward, SVC_PROP_FORWARD,
FORWARD_OPTS, N_FORWARD_OPTS);
- bool gre = FORWARD_OPTS[0].m_found;
- bool l2 = FORWARD_OPTS[1].m_found;
+ auto status = load_option_set(forward, SVC_PROP_FORWARD, FORWARD_OPTS,
N_FORWARD_OPTS);
+ bool gre = FORWARD_OPTS[0].m_found;
+ bool l2 = FORWARD_OPTS[1].m_found;
if (gre || l2) {
svc.m_packet_forward = gre ? l2 ? ServiceGroup::GRE_OR_L2 :
ServiceGroup::GRE : ServiceGroup::L2;
- if (!status.isOK()) {
- zret.push(Ignored_Opt_Errors(SVC_PROP_FORWARD,
forward.Mark().line).set(status));
+ if (!status.is_ok()) {
+ Note_Ignored_Opt_Errors(errata, SVC_PROP_FORWARD,
forward.Mark().line).note(status);
}
} else {
- zret.push(ts::Errata::Message(26, LVL_INFO, "Defaulting to GRE
forwarding.").set(status));
+ errata.note(ERRATA_NOTE, "Defaulting to GRE forwarding").note(status);
}
}
svc.m_packet_return = ServiceGroup::GRE; // default.
- YAML::Node prop_return = svc_cfg[SVC_PROP_RETURN];
+ YAML::Node prop_return = svc_cfg[SVC_PROP_RETURN.data()];
if (prop_return) {
- ts::Errata status = load_option_set(prop_return, SVC_PROP_RETURN,
RETURN_OPTS, N_RETURN_OPTS);
- bool gre = RETURN_OPTS[0].m_found;
- bool l2 = RETURN_OPTS[1].m_found;
+ auto status = load_option_set(prop_return, SVC_PROP_RETURN, RETURN_OPTS,
N_RETURN_OPTS);
+ bool gre = RETURN_OPTS[0].m_found;
+ bool l2 = RETURN_OPTS[1].m_found;
if (gre || l2) {
svc.m_packet_return = gre ? l2 ? ServiceGroup::GRE_OR_L2 :
ServiceGroup::GRE : ServiceGroup::L2;
- if (!status.isOK()) {
- zret.push(Ignored_Opt_Errors(SVC_PROP_RETURN,
prop_return.Mark().line).set(status));
+ if (!status.is_ok()) {
+ Note_Ignored_Opt_Errors(errata, SVC_PROP_RETURN,
prop_return.Mark().line).note(status);
}
} else {
- zret.push(ts::Errata::Message(26, LVL_INFO, "Defaulting to GRE
return.").set(status));
+ errata.note(ERRATA_NOTE, "Defaulting to GRE return.").note(status);
}
}
svc.m_cache_assign = ServiceGroup::HASH_ONLY; // default
- YAML::Node assign = svc_cfg[SVC_PROP_ASSIGN];
+ YAML::Node assign = svc_cfg[SVC_PROP_ASSIGN.data()];
if (assign) {
- ts::Errata status = load_option_set(assign, SVC_PROP_ASSIGN,
ASSIGN_OPTS, N_OPTS(ASSIGN_OPTS));
- bool hash = ASSIGN_OPTS[0].m_found;
- bool mask = ASSIGN_OPTS[1].m_found;
+ auto status = load_option_set(assign, SVC_PROP_ASSIGN, ASSIGN_OPTS,
N_OPTS(ASSIGN_OPTS));
+ bool hash = ASSIGN_OPTS[0].m_found;
+ bool mask = ASSIGN_OPTS[1].m_found;
if (hash || mask) {
svc.m_cache_assign = hash ? mask ? ServiceGroup::HASH_OR_MASK :
ServiceGroup::HASH_ONLY : ServiceGroup::MASK_ONLY;
- if (!status.isOK())
- zret.push(Ignored_Opt_Errors(SVC_PROP_ASSIGN,
assign.Mark().line).set(status));
+ if (!status.is_ok())
+ Note_Ignored_Opt_Errors(errata, SVC_PROP_ASSIGN,
assign.Mark().line).note(status);
} else {
- status.push(ts::Errata::Message(26, LVL_INFO, "Defaulting to hash
assignment only."));
- zret.push(List_Valid_Opts(SVC_PROP_ASSIGN, assign.Mark().line,
ASSIGN_OPTS, N_OPTS(ASSIGN_OPTS)).set(status));
+ errata.note(ERRATA_NOTE, "Defaulting to hash assignment only.");
+ Note_List_Valid_Opts(errata, SVC_PROP_ASSIGN, assign.Mark().line,
ASSIGN_OPTS, N_OPTS(ASSIGN_OPTS)).note(status);
}
}
}
- return zret;
+ return errata;
}
} // namespace wccp
diff --git a/src/wccp/WccpEndPoint.cc b/src/wccp/WccpEndPoint.cc
index 4bf3b6da85..a058052d6f 100644
--- a/src/wccp/WccpEndPoint.cc
+++ b/src/wccp/WccpEndPoint.cc
@@ -19,12 +19,20 @@
limitations under the License.
*/
+#include <errno.h>
+
+#include "swoc/bwf_base.h"
+#include "swoc/bwf_ex.h"
+#include "swoc/IPAddr.h"
+#include "swoc/bwf_ip.h"
+
#include "WccpLocal.h"
#include "WccpUtil.h"
#include "WccpMeta.h"
-#include <errno.h>
#include "tscore/ink_string.h"
#include "tscore/ink_defs.h"
+
+using swoc::Errata;
// ------------------------------------------------------
namespace wccp
{
@@ -63,7 +71,7 @@ Impl::~Impl()
this->close();
}
-int
+Errata
Impl::open(uint addr)
{
struct sockaddr saddr;
@@ -71,13 +79,11 @@ Impl::open(uint addr)
ats_scoped_fd fd;
if (ts::NO_FD != m_fd) {
- log(LVL_INFO, "Attempted to open already open WCCP Endpoint");
- return -EALREADY;
+ return {ERRATA_NOTE, "Attempted to open already open WCCP Endpoint"};
}
if (ts::NO_FD == (fd = socket(PF_INET, SOCK_DGRAM, 0))) {
- log_errno(LVL_FATAL, "Failed to create socket");
- return -errno;
+ return {ERRATA_FATAL, "Failed to create socket - {}", swoc::bwf::Errno()};
}
if (INADDR_ANY != addr)
@@ -88,26 +94,26 @@ Impl::open(uint addr)
in_addr.sin_addr.s_addr = m_addr;
int zret = bind(fd, &saddr, sizeof(saddr));
if (-1 == zret) {
- log_errno(LVL_FATAL, "Failed to bind socket to port");
+ swoc::bwf::Errno e; // save this over closing.
this->close();
- return -errno;
+ return {ERRATA_FATAL, "Failed to bind socket to port - {}", e};
}
- logf(LVL_INFO, "Socket bound to %s:%d", ip_addr_to_str(m_addr),
DEFAULT_PORT);
+ bw_log(DL_Note, "Socket bound to {}:{}", swoc::IP4Addr(m_addr),
DEFAULT_PORT);
// Now get the address. Usually the same but possibly different,
// certainly if addr was INADDR_ANY.
if (INADDR_ANY == m_addr && INADDR_ANY == (m_addr = Get_Local_Address(fd))) {
- log_errno(LVL_FATAL, "Failed to get local address for socket");
+ swoc::bwf::Errno e; // save this over closing.
this->close();
- return -errno;
+ return {ERRATA_FATAL, "Failed to get local address for socket - {}", e};
}
// Enable retrieval of destination address on packets.
int ip_pktinfo_flag = 1;
if (-1 == setsockopt(fd, IPPROTO_IP, DSTADDR_SOCKOPT, &ip_pktinfo_flag,
sizeof(ip_pktinfo_flag))) {
- log_errno(LVL_FATAL, "Failed to enable destination address retrieval");
+ swoc::bwf::Errno e; // save this over closing.
this->close();
- return -errno;
+ return {ERRATA_FATAL, "Failed to enable destination address retrieval -
{}", e};
}
#if defined IP_MTU_DISCOVER
@@ -116,14 +122,14 @@ Impl::open(uint addr)
/// identifier is 0, which is the value used when PMTU is enabled.
int pmtu = IP_PMTUDISC_DONT;
if (-1 == setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu))) {
- log_errno(LVL_FATAL, "Failed to disable PMTU on WCCP socket.");
+ swoc::bwf::Errno e; // save this over closing.
this->close();
- return -errno;
+ return {ERRATA_FATAL, "Failed to disable PMTU on WCCP socket - {}", e};
}
#endif
m_fd = fd.release();
- return 0;
+ return {};
}
void
@@ -182,10 +188,9 @@ Impl::validateSecurity(BaseMsg &msg, GroupData const
&group)
return true;
}
-ts::Rv<int>
+swoc::Errata
Impl::handleMessage()
{
- ts::Rv<int> zret;
ssize_t n; // recv byte count.
struct sockaddr src_addr; // sender's address.
msghdr recv_hdr;
@@ -196,8 +201,9 @@ Impl::handleMessage()
static size_t const ANC_BUFFER_SIZE = DSTADDR_DATASIZE;
char anc_buffer[ANC_BUFFER_SIZE];
- if (ts::NO_FD == m_fd)
- return -ENOTCONN;
+ if (ts::NO_FD == m_fd) {
+ return {ec_for(ENOTCONN), ERRATA_NOTE, "No open socket."};
+ }
recv_buffer.iov_base = buffer;
recv_buffer.iov_len = BUFFER_SIZE;
@@ -213,9 +219,9 @@ Impl::handleMessage()
// coverity[uninit_use_in_call]
n = recvmsg(m_fd, &recv_hdr, MSG_TRUNC);
if (n > BUFFER_SIZE)
- return -EMSGSIZE;
+ return {ec_for(EMSGSIZE), ERRATA_ERROR, "Internal buffer is too small"};
else if (n < 0)
- return -errno;
+ return {ec_for(), ERRATA_ERROR, "Network error"};
// Extract the original destination address.
ip_header.m_src = access_field(&sockaddr_in::sin_addr, &src_addr).s_addr;
@@ -253,31 +259,31 @@ Impl::handleMessage()
} else {
fprintf(stderr, "Malformed message ignored.\n");
}
- return zret;
+ return {};
}
-ts::Errata
+Errata
Impl::handleHereIAm(IpHeader const &, buffer_type const &)
{
- return log(LVL_INFO, "Unanticipated WCCP2_HERE_I_AM message ignored");
+ return {ERRATA_NOTE, "Unanticipated WCCP2_HERE_I_AM message ignored"};
}
-ts::Errata
+Errata
Impl::handleISeeYou(IpHeader const &, buffer_type const & /* data ATS_UNUSED
*/)
{
- return log(LVL_INFO, "Unanticipated WCCP2_I_SEE_YOU message ignored.");
+ return {ERRATA_NOTE, "Unanticipated WCCP2_I_SEE_YOU message ignored."};
}
-ts::Errata
+Errata
Impl::handleRedirectAssign(IpHeader const &, buffer_type const & /* data
ATS_UNUSED */)
{
- return log(LVL_INFO, "Unanticipated WCCP2_REDIRECT_ASSIGN message ignored.");
+ return {ERRATA_NOTE, "Unanticipated WCCP2_REDIRECT_ASSIGN message ignored."};
}
-ts::Errata
+Errata
Impl::handleRemovalQuery(IpHeader const &, buffer_type const & /* data
ATS_UNUSED */)
{
- return log(LVL_INFO, "Unanticipated WCCP2_REMOVAL_QUERY message ignored.");
+ return {ERRATA_NOTE, "Unanticipated WCCP2_REMOVAL_QUERY message ignored."};
}
// ------------------------------------------------------
-CacheImpl::GroupData::GroupData() : m_proc_name(NULL),
m_assignment_pending(false) {}
+CacheImpl::GroupData::GroupData() : m_proc_name(nullptr),
m_assignment_pending(false) {}
CacheImpl::GroupData &
CacheImpl::GroupData::seedRouter(uint32_t addr)
@@ -467,7 +473,7 @@ CacheImpl::GroupData::cullRouters(time_t now)
// Put it back in the seeds.
this->seedRouter(addr);
zret = true; // Router was culled, report it to caller.
- logf(LVL_INFO, "Router " ATS_IP_PRINTF_CODE " timed out and was removed
from the active list.", ATS_IP_OCTETS(addr));
+ bw_log(DL_Note, "Router {:x} timed out and was removed from the active
list.", swoc::IP4Addr(addr));
} else {
++idx; // move to next router.
}
@@ -486,7 +492,7 @@ CacheImpl::GroupData::viewChanged(time_t now)
m_assignment_pending = m_routers.size() && m_caches.size();
// Cancel any pending assignment transmissions.
ts::for_each(m_routers, ts::assign_member(&RouterData::m_assign, false));
- logf(LVL_DEBUG, "Service group %d view change (%d)", m_svc.getSvcId(),
m_generation);
+ bw_log(DL_Debug, "Service group {} view change ({})", m_svc.getSvcId(),
m_generation);
return *this;
}
@@ -520,13 +526,13 @@ CacheImpl::isConfigured() const
return INADDR_ANY != m_addr && m_groups.size() > 0;
}
-int
+Errata
CacheImpl::open(uint32_t addr)
{
- int zret = this->super_type::open(addr);
+ auto zret = this->super_type::open(addr);
// If the socket was successfully opened, go through the
// services and update the local service descriptor.
- if (0 <= zret) {
+ if (zret.is_ok()) {
for (GroupMap::iterator spot = m_groups.begin(), limit = m_groups.end();
spot != limit; ++spot) {
spot->second.m_id.setAddr(m_addr);
}
@@ -568,19 +574,18 @@ CacheImpl::generateRedirectAssign(RedirectAssignMsg &msg,
GroupData &group)
msg.finalize();
}
-ts::Errata
+Errata
CacheImpl::checkRouterAssignment(GroupData const &group, RouterViewComp const
&comp) const
{
detail::Assignment const &ainfo = group.m_assign_info;
// If group doesn't have an active assignment, always match w/o checking.
- ts::Errata zret; // default is success.
+ Errata zret; // default is success.
// if active assignment and data we can check, then check.
if (ainfo.isActive() && !comp.isEmpty()) {
// Validate the assignment key.
if (ainfo.getKey().getAddr() != comp.getKeyAddr() ||
ainfo.getKey().getChangeNumber() != comp.getKeyChangeNumber()) {
- log(zret, LVL_INFO, "Router assignment key did not match.");
- ;
+ zret.note(ERRATA_NOTE, "Router assignment key did not match.");
} else if (ServiceGroup::HASH_ONLY == group.m_cache_assign) {
// Still not sure how much checking we really want or should
// do here. For now, we'll just leave the checks validating
@@ -642,12 +647,12 @@ CacheImpl::housekeeping()
if (0 <= zret) {
rspot->m_xmit.set(now, group.m_generation);
rspot->m_send_caps = false;
- logf(LVL_DEBUG, "Sent HERE_I_AM for service group %d to router
%s%s[#%d,%lu].", group.m_svc.getSvcId(),
- ip_addr_to_str(rspot->m_addr), rspot->m_rapid ? " [rapid] " :
" ", group.m_generation, now);
+ bw_log(DL_Debug, "Sent HERE_I_AM for service group {} to router {}
{}[#{},{}].", group.m_svc.getSvcId(),
+ swoc::IP4Addr(rspot->m_addr), swoc::bwf::If(rspot->m_rapid,
"[rapid] "), group.m_generation, now);
if (rspot->m_rapid)
--(rspot->m_rapid);
} else {
- logf_errno(LVL_WARN, "Failed to send to router "
ATS_IP_PRINTF_CODE " - ", ATS_IP_OCTETS(rspot->m_addr));
+ bw_log(DL_Warning, "Failed to send to router {:x} - {}",
swoc::IP4Addr(rspot->m_addr), swoc::bwf::Errno());
}
} else if (rspot->m_assign) {
RedirectAssignMsg redirect_assign;
@@ -676,23 +681,23 @@ CacheImpl::housekeeping()
dst_addr.sin_addr.s_addr = sspot->m_addr;
zret = sendto(m_fd, msg_data,
here_i_am.getCount(), 0, addr_ptr, sizeof(dst_addr));
if (0 <= zret) {
- logf(LVL_DEBUG, "Sent HERE_I_AM for SG %d to seed router %s
[gen=#%d,t=%lu,n=%lu].", group.m_svc.getSvcId(),
- ip_addr_to_str(sspot->m_addr), group.m_generation, now,
here_i_am.getCount());
+ bw_log(DL_Debug, "Sent HERE_I_AM for SG {} to seed router {:x}
[gen=#{},t={},n={}].", group.m_svc.getSvcId(),
+ swoc::IP4Addr(sspot->m_addr), group.m_generation, now,
here_i_am.getCount());
sspot->m_xmit = now;
sspot->m_count += 1;
} else
- logf(LVL_DEBUG, "Error [%d:%s] sending HERE_I_AM for SG %d to seed
router %s [#%d,%lu].", zret, strerror(errno),
- group.m_svc.getSvcId(), ip_addr_to_str(sspot->m_addr),
group.m_generation, now);
+ bw_log(DL_Debug, "Error [{}] sending HERE_I_AM for SG %d to seed
router {} [#{},{}].", swoc::bwf::Errno(zret),
+ group.m_svc.getSvcId(), swoc::IP4Addr(sspot->m_addr),
group.m_generation, now);
}
}
}
return zret;
}
-ts::Errata
+Errata
CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr ATS_UNUSED */, buffer_type
const &chunk)
{
- ts::Errata zret;
+ Errata zret;
ISeeYouMsg msg;
// Set if our view of the group changes enough to bump the
// generation number.
@@ -701,31 +706,31 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
int parse = msg.parse(chunk);
if (PARSE_SUCCESS != parse)
- return logf(LVL_INFO, "Ignored malformed [%d] WCCP2_I_SEE_YOU message.",
parse);
+ return {ERRATA_NOTE, "Ignored malformed [%d] WCCP2_I_SEE_YOU message.",
parse};
ServiceGroup svc(msg.m_service);
GroupMap::iterator spot = m_groups.find(svc.getSvcId());
if (spot == m_groups.end())
- return logf(LVL_INFO, "WCCP2_I_SEE_YOU ignored - service group %d not
found.", svc.getSvcId());
+ return {ERRATA_NOTE, "WCCP2_I_SEE_YOU ignored - service group %d not
found.", svc.getSvcId()};
GroupData &group = spot->second;
if (!this->validateSecurity(msg, group))
- return log(LVL_INFO, "Ignored WCCP2_I_SEE_YOU with invalid security.\n");
+ return {ERRATA_NOTE, "Ignored WCCP2_I_SEE_YOU with invalid security."};
if (svc != group.m_svc)
- return logf(LVL_INFO, "WCCP2_I_SEE_YOU ignored - service group definition
%d does not match.\n", svc.getSvcId());
+ return {ERRATA_NOTE, "WCCP2_I_SEE_YOU ignored - service group definition
{} does not match.", svc.getSvcId()};
if (-1 == msg.m_router_id.findFromAddr(m_addr))
- return logf(LVL_INFO, "WCCP2_I_SEE_YOU ignored -- cache not in from
list.\n");
+ return {ERRATA_NOTE, "WCCP2_I_SEE_YOU ignored -- cache not in from list."};
- logf(LVL_DEBUG, "Received WCCP2_I_SEE_YOU for group %d.",
group.m_svc.getSvcId());
+ bw_log(DL_Debug, "Received WCCP2_I_SEE_YOU for group {}.",
group.m_svc.getSvcId());
// Preferred address for router.
- uint32_t router_addr = msg.m_router_id.idElt().getAddr();
+ in_addr_t router_addr = msg.m_router_id.idElt().getAddr();
// Where we sent our packet.
- uint32_t to_addr = msg.m_router_id.getToAddr();
- uint32_t recv_id = msg.m_router_id.idElt().getRecvId();
+ in_addr_t to_addr = msg.m_router_id.getToAddr();
+ in_addr_t recv_id = msg.m_router_id.idElt().getRecvId();
RouterBag::iterator ar_spot; // active router
int router_idx; // index in active routers.
@@ -754,7 +759,7 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
else if (ServiceGroup::L2 & ps & group.m_packet_forward)
r.m_packet_forward = ServiceGroup::L2;
else
- logf(zret, LVL_WARN, "Packet forwarding (config=%d, %s=%d) did not
match.", group.m_packet_forward, caps_tag, ps);
+ zret.note(ERRATA_WARN, "Packet forwarding (config={}, {}={}) did not
match.", group.m_packet_forward, caps_tag, ps);
// No caps -> use GRE return.
ps = caps.isEmpty() ? ServiceGroup::GRE : caps.getPacketReturnStyle();
@@ -763,7 +768,7 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
else if (ServiceGroup::L2 & ps & group.m_packet_return)
r.m_packet_return = ServiceGroup::L2;
else
- logf(zret, LVL_WARN, "Packet return (local=%d, %s=%d) did not match.",
group.m_packet_return, caps_tag, ps);
+ zret.note(ERRATA_WARN, "Packet return (local={}, {}={}) did not match.",
group.m_packet_return, caps_tag, ps);
// No caps -> use HASH assignment.
as = caps.isEmpty() ? ServiceGroup::HASH_ONLY :
caps.getCacheAssignmentStyle();
@@ -773,27 +778,26 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
r.m_cache_assign = ServiceGroup::MASK_ONLY;
group.m_id.initDefaultMask(m_addr); // switch to MASK style ID.
} else
- logf(zret, LVL_WARN, "Cache assignment (local=%d, %s=%d) did not
match.", group.m_cache_assign, caps_tag, as);
+ zret.note(ERRATA_WARN, "Cache assignment (local={}, {}={}) did not
match.", group.m_cache_assign, caps_tag, as);
if (!zret) {
// cancel out, can't use this packet because we reject the router.
- return logf(zret, LVL_WARN, "Router %s rejected because of capabilities
mismatch.", ip_addr_to_str(router_addr));
+ return std::move(zret.note(ERRATA_WARN, "Router {} rejected because of
capabilities mismatch.", swoc::IP4Addr(router_addr)));
}
group.m_routers.push_back(r);
ar_spot = group.m_routers.end() - 1;
view_changed = true;
- logf(LVL_INFO, "Added source router %s to view %d",
ip_addr_to_str(router_addr), group.m_svc.getSvcId());
+ bw_log(DL_Note, "Added source router {} to view {}",
swoc::IP4Addr(router_addr), group.m_svc.getSvcId());
} else {
// Existing router. Update the receive ID in the assignment object.
group.m_assign_info.updateRouterId(router_addr, recv_id,
msg.m_router_view.getChangeNumber());
// Check the assignment to see if we need to send it again.
- ts::Errata status = this->checkRouterAssignment(group, msg.m_router_view);
- if (status.size()) {
+ Errata status = this->checkRouterAssignment(group, msg.m_router_view);
+ if (!status.empty()) {
ar_spot->m_assign = true; // schedule an assignment message.
- logf(status, LVL_INFO,
- "Router assignment reported from " ATS_IP_PRINTF_CODE " did not
match local assignment. Resending assignment.\n ",
- ATS_IP_OCTETS(router_addr));
+ bw_log(DL_Note, "Router assignment reported from {:x} did not match
local assignment. Resending assignment.\n{}",
+ swoc::IP4Addr(router_addr), status);
}
}
time_t then = ar_spot->m_recv.m_time; // used for comparisons later.
@@ -826,7 +830,7 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
group.m_caches.push_back(CacheData());
ac_spot = group.m_caches.end() - 1;
ac_spot->m_src.resize(group.m_routers.size());
- logf(LVL_INFO, "Added cache %s to view %d",
ip_addr_to_str(cache.getAddr()), group.m_svc.getSvcId());
+ bw_log(DL_Note, "Added cache {} to view {}",
swoc::IP4Addr(cache.getAddr()), group.m_svc.getSvcId());
view_changed = true;
} else {
// Check if the cache wasn't reported last time but was reported
@@ -848,29 +852,29 @@ CacheImpl::handleISeeYou(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_type c
return zret;
}
-ts::Errata
+Errata
CacheImpl::handleRemovalQuery(IpHeader const & /* ip_hdr ATS_UNUSED */,
buffer_type const &chunk)
{
- ts::Errata zret;
+ Errata zret;
RemovalQueryMsg msg;
time_t now = time(0);
int parse = msg.parse(chunk);
if (PARSE_SUCCESS != parse)
- return log(LVL_INFO, "Ignored malformed WCCP2_REMOVAL_QUERY message.");
+ return {ERRATA_NOTE, "Ignored malformed WCCP2_REMOVAL_QUERY message."};
ServiceGroup svc(msg.m_service);
GroupMap::iterator spot = m_groups.find(svc.getSvcId());
if (spot == m_groups.end())
- return logf(LVL_INFO, "WCCP2_REMOVAL_QUERY ignored - service group %d not
found.", svc.getSvcId());
+ return {ERRATA_NOTE, "WCCP2_REMOVAL_QUERY ignored - service group {} not
found.", svc.getSvcId()};
GroupData &group = spot->second;
if (!this->validateSecurity(msg, group))
- return log(LVL_INFO, "Ignored WCCP2_REMOVAL_QUERY with invalid
security.\n");
+ return {ERRATA_NOTE, "Ignored WCCP2_REMOVAL_QUERY with invalid security."};
if (svc != group.m_svc)
- return logf(LVL_INFO, "WCCP2_REMOVAL_QUERY ignored - service group
definition %d does not match.\n", svc.getSvcId());
+ return {ERRATA_NOTE, "WCCP2_REMOVAL_QUERY ignored - service group
definition {} does not match.", svc.getSvcId()};
uint32_t target_addr = msg.m_query.getCacheAddr(); // intended cache
if (m_addr == target_addr) {
@@ -879,19 +883,17 @@ CacheImpl::handleRemovalQuery(IpHeader const & /* ip_hdr
ATS_UNUSED */, buffer_t
if (group.m_routers.end() != router) {
router->m_rapid = true; // do rapid responses.
router->m_recv.set(now, msg.m_query.getRecvId());
- logf(LVL_INFO, "WCCP2_REMOVAL_QUERY from router " ATS_IP_PRINTF_CODE
".\n", ATS_IP_OCTETS(raddr));
+ bw_log(DL_Note, "WCCP2_REMOVAL_QUERY from router {:x}",
swoc::IP4Addr(raddr));
} else {
- logf(LVL_INFO, "WCCP2_REMOVAL_QUERY from unknown router "
ATS_IP_PRINTF_CODE ".\n", ATS_IP_OCTETS(raddr));
+ bw_log(DL_Note, "WCCP2_REMOVAL_QUERY from unknown router {:x}",
swoc::IP4Addr(raddr));
}
} else {
// Not an error in the multi-cast case, so just log under debug.
- logf(LVL_DEBUG,
- "WCCP2_REMOVAL_QUERY ignored -- target cache address "
ATS_IP_PRINTF_CODE
- " did not match local address " ATS_IP_PRINTF_CODE "\n.",
- ATS_IP_OCTETS(target_addr), ATS_IP_OCTETS(m_addr));
+ bw_log(DL_Debug, "WCCP2_REMOVAL_QUERY ignored -- target cache address {}
did not match local address {}",
+ swoc::IP4Addr(target_addr), swoc::IP4Addr(m_addr));
}
- logf(LVL_DEBUG, "Received WCCP2_REMOVAL_QUERY for group %d.",
group.m_svc.getSvcId());
+ bw_log(DL_Debug, "Received WCCP2_REMOVAL_QUERY for group {}.",
group.m_svc.getSvcId());
return zret;
}
@@ -936,10 +938,10 @@ RouterImpl::GroupData::resizeRouterSources()
ts::for_each(m_routers, &RouterData::resize, m_caches.size());
}
-ts::Errata
+Errata
RouterImpl::handleHereIAm(IpHeader const &ip_hdr, buffer_type const &chunk)
{
- ts::Errata zret;
+ Errata zret;
HereIAmMsg msg;
static GroupData nil_group; // scratch until I clean up the security.
// Set if our view of the group changes enough to bump the
@@ -950,18 +952,18 @@ RouterImpl::handleHereIAm(IpHeader const &ip_hdr,
buffer_type const &chunk)
int parse = msg.parse(chunk);
if (PARSE_SUCCESS != parse)
- return log(LVL_INFO, "Ignored malformed WCCP2_HERE_I_AM message.\n");
+ return {ERRATA_NOTE, "Ignored malformed WCCP2_HERE_I_AM message."};
if (!this->validateSecurity(msg, nil_group))
- return log(LVL_INFO, "Ignored WCCP2_HERE_I_AM with invalid security.\n");
+ return {ERRATA_NOTE, "Ignored WCCP2_HERE_I_AM with invalid security."};
ServiceGroup svc(msg.m_service);
ServiceGroup::Result r;
GroupData &group = this->defineServiceGroup(svc, &r);
if (ServiceGroup::CONFLICT == r)
- return logf(LVL_INFO, "WCCP2_HERE_I_AM ignored - service group %d
definition does not match.\n", svc.getSvcId());
+ return {ERRATA_NOTE, "WCCP2_HERE_I_AM ignored - service group {}
definition does not match.", svc.getSvcId()};
else if (ServiceGroup::DEFINED == r)
- return logf(LVL_INFO, "Service group %d defined by WCCP2_HERE_I_AM.\n",
svc.getSvcId());
+ return {ERRATA_NOTE, "Service group {} defined by WCCP2_HERE_I_AM.",
svc.getSvcId()};
// Check if this cache is already known.
uint32_t cache_addr = msg.m_cache_id.getAddr();
@@ -980,7 +982,7 @@ RouterImpl::handleHereIAm(IpHeader const &ip_hdr,
buffer_type const &chunk)
// If so, make sure the sequence # is correct.
RouterIdElt *me = msg.m_cache_view.findf_router_elt(m_addr);
if (me && me->getRecvId() != cache->m_recv_count)
- return logf(LVL_INFO, "Discarded out of date (recv=%d, local=%ld)
WCCP2_HERE_I_AM.\n", me->getRecvId(), cache->m_recv_count);
+ return {ERRATA_NOTE, "Discarded out of date (recv={}, local={})
WCCP2_HERE_I_AM.", me->getRecvId(), cache->m_recv_count};
}
cache_gen = msg.m_cache_view.getChangeNumber();
@@ -1077,9 +1079,9 @@ RouterImpl::xmitISeeYou()
cache->m_xmit.set(now, group.m_generation);
cache->m_pending = false;
cache->m_recv_count = msg.m_router_id.getRecvId();
- logf(LVL_DEBUG, "I_SEE_YOU -> %s\n",
ip_addr_to_str(cache->m_id.getAddr()));
+ bw_log(DL_Debug, "I_SEE_YOU -> {}",
swoc::IP4Addr(cache->m_id.getAddr()));
} else {
- log_errno(LVL_WARN, "Router transmit failed -");
+ bw_log(DL_Warning, "Router transmit failed - {}", swoc::bwf::Errno());
return zret;
}
}
@@ -1115,7 +1117,7 @@ EndPoint &
EndPoint::setAddr(uint32_t addr)
{
this->instance()->m_addr = addr;
- logf(LVL_DEBUG, "Endpoint address set to %s\n", ip_addr_to_str(addr));
+ bw_log(DL_Debug, "Endpoint address set to {}", swoc::IP4Addr(addr));
return *this;
}
@@ -1125,7 +1127,7 @@ EndPoint::isConfigured() const
return m_ptr && m_ptr->isConfigured();
}
-int
+Errata
EndPoint::open(uint32_t addr)
{
return this->instance()->open(addr);
@@ -1151,11 +1153,11 @@ EndPoint::housekeeping()
return m_ptr && ts::NO_FD != m_ptr->m_fd ? m_ptr->housekeeping() : -ENOTCONN;
}
-ts::Rv<int>
+swoc::Errata
EndPoint::handleMessage()
{
return m_ptr ? m_ptr->handleMessage() :
- ts::Rv<int>(-ENOTCONN, log(LVL_INFO, "EndPoint::handleMessage
called on unconnected instance"));
+ swoc::Errata(ec_for(ENOTCONN), ERRATA_NOTE,
"EndPoint::handleMessage called on unconnected instance");
}
// ------------------------------------------------------
Cache::Cache() {}
@@ -1206,7 +1208,7 @@ Cache::addSeedRouter(uint8_t id, uint32_t addr)
return *this;
}
-ts::Errata
+swoc::Errata
Cache::loadServicesFromFile(const char *path)
{
return this->instance()->loadServicesFromFile(path);
diff --git a/src/wccp/WccpLocal.h b/src/wccp/WccpLocal.h
index 7c0322dc73..b25ca6f287 100644
--- a/src/wccp/WccpLocal.h
+++ b/src/wccp/WccpLocal.h
@@ -360,6 +360,8 @@ protected:
uint32_t m_cap_data = 0; ///< Capability data.
};
+swoc::BufferWriter &bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const
&spec, CapabilityElt::Type);
+
/// Sect 5.7.7: Mask element
class MaskElt
{
@@ -2205,7 +2207,7 @@ public:
/// Open a socket for communications.
/// @return 0 on success, -ERRNO on failure.
- virtual int open(uint32_t addr ///< Local IP address.
+ virtual swoc::Errata open(uint32_t addr ///< Local IP address.
);
/// Use MD5 security.
@@ -2218,7 +2220,7 @@ public:
/// Receive and process a message.
/// @return 0 for success, -ERRNO on system error.
- virtual ts::Rv<int> handleMessage();
+ virtual swoc::Errata handleMessage();
/// Check if endpoint is configured.
/// @return @c true if ready to operate, @c false otherwise.
@@ -2231,20 +2233,20 @@ public:
to process relevant messages.
*/
/// Process HERE_I_AM message.
- virtual ts::Errata handleHereIAm(IpHeader const &header, ///< IP packet data.
- buffer_type const &data ///< Buffer with
message data.
+ virtual swoc::Errata handleHereIAm(IpHeader const &header, ///< IP packet
data.
+ buffer_type const &data ///< Buffer with
message data.
);
/// Process I_SEE_YOU message.
- virtual ts::Errata handleISeeYou(IpHeader const &header, ///< IP packet data.
- buffer_type const &data ///< Buffer with
message data.
+ virtual swoc::Errata handleISeeYou(IpHeader const &header, ///< IP packet
data.
+ buffer_type const &data ///< Buffer with
message data.
);
/// Process REDIRECT_ASSIGN message.
- virtual ts::Errata handleRedirectAssign(IpHeader const &header, ///< IP
packet data.
- buffer_type const &data ///< Buffer
with message data.
+ virtual swoc::Errata handleRedirectAssign(IpHeader const &header, ///< IP
packet data.
+ buffer_type const &data ///<
Buffer with message data.
);
/// Process REMOVAL_QUERY message.
- virtual ts::Errata handleRemovalQuery(IpHeader const &header, ///< IP packet
data.
- buffer_type const &data ///< Buffer
with message data.
+ virtual swoc::Errata handleRemovalQuery(IpHeader const &header, ///< IP
packet data.
+ buffer_type const &data ///< Buffer
with message data.
);
protected:
@@ -2479,10 +2481,10 @@ public:
);
/// Define services from a configuration file.
- ts::Errata loadServicesFromFile(const char *path ///< Path to file.
+ swoc::Errata loadServicesFromFile(const char *path ///< Path to file.
);
- int open(uint32_t addr) override;
+ swoc::Errata open(uint32_t addr) override;
/// Time until next scheduled event.
time_t waitTime() const;
@@ -2497,8 +2499,8 @@ public:
/** Check cache assignment reported by a router against internal assign.
@return @c true if they are the same, @c false otherwise.
*/
- virtual ts::Errata checkRouterAssignment(GroupData const &group, ///<
Group with assignment.
- RouterViewComp const &comp ///<
Assignment reported by router.
+ virtual swoc::Errata checkRouterAssignment(GroupData const &group, ///<
Group with assignment.
+ RouterViewComp const &comp ///<
Assignment reported by router.
) const;
protected:
@@ -2516,13 +2518,13 @@ protected:
GroupData &group ///< Group with data for
message.
);
/// Process HERE_I_AM message.
- ts::Errata handleISeeYou(IpHeader const &header, ///< IP packet data.
- buffer_type const &data ///< Buffer with message
data.
- ) override;
+ swoc::Errata handleISeeYou(IpHeader const &header, ///< IP packet data.
+ buffer_type const &data ///< Buffer with message
data.
+ ) override;
/// Process REMOVAL_QUERY message.
- ts::Errata handleRemovalQuery(IpHeader const &header, ///< IP packet data.
- buffer_type const &data ///< Message data.
- ) override;
+ swoc::Errata handleRemovalQuery(IpHeader const &header, ///< IP packet data.
+ buffer_type const &data ///< Message data.
+ ) override;
/// Map Service Group ID to Service Group Data.
using GroupMap = std::map<uint8_t, GroupData>;
@@ -2530,7 +2532,7 @@ protected:
GroupMap m_groups;
private:
- ts::Errata loader(const YAML::Node &node);
+ swoc::Errata loader(const YAML::Node &node);
};
// ------------------------------------------------------
@@ -2628,9 +2630,9 @@ public:
using RouterBag = detail::router::RouterBag;
/// Process HERE_I_AM message.
- ts::Errata handleHereIAm(IpHeader const &header, ///< IP packet data.
- buffer_type const &data ///< Buffer with message
data.
- ) override;
+ swoc::Errata handleHereIAm(IpHeader const &header, ///< IP packet data.
+ buffer_type const &data ///< Buffer with message
data.
+ ) override;
/// Perform all scheduled housekeeping functions.
int housekeeping() override;
/// Send pending I_SEE_YOU messages.
diff --git a/src/wccp/WccpMsg.cc b/src/wccp/WccpMsg.cc
index 9fd215c51d..8df52bd0c7 100644
--- a/src/wccp/WccpMsg.cc
+++ b/src/wccp/WccpMsg.cc
@@ -170,7 +170,7 @@ CacheIdBox::parse(MsgBuffer base)
m_size = mptr->getSize();
if (n < m_size) {
zret = PARSE_BUFFER_TOO_SMALL;
- logf(LVL_DEBUG, "I_SEE_YOU Cache Mask ID too small: %lu < %lu", n,
m_size);
+ bw_log(DL_Note, "I_SEE_YOU Cache Mask ID too small: {} < {}", n,
m_size);
} else {
m_tail = mptr->getTailPtr();
}
@@ -178,7 +178,7 @@ CacheIdBox::parse(MsgBuffer base)
} else {
if (n < sizeof(CacheHashIdElt)) {
zret = PARSE_BUFFER_TOO_SMALL;
- logf(LVL_DEBUG, "I_SEE_YOU Cache Hash ID too small: %lu < %lu", n,
sizeof(CacheHashIdElt));
+ bw_log(DL_Debug, "I_SEE_YOU Cache Hash ID too small: {} < {}", n,
sizeof(CacheHashIdElt));
} else {
m_size = sizeof(CacheHashIdElt);
m_tail = static_cast<CacheHashIdElt *>(m_base)->getTailPtr();
@@ -863,11 +863,12 @@ RouterViewComp::parse(MsgBuffer &buffer)
zret = PARSE_MSG_INVALID;
// check if cache count is past end of buffer
else if (static_cast<void *>(m_cache_count =
this->calc_cache_count_ptr()) >=
- static_cast<void *>(buffer.getBase() + buffer.getSize()))
- zret = PARSE_COMP_WRONG_SIZE, log(LVL_DEBUG, "I_SEE_YOU: cache counter
past end of buffer");
- else if ((ncaches = this->getCacheCount()) > MAX_CACHES)
+ static_cast<void *>(buffer.getBase() + buffer.getSize())) {
+ zret = PARSE_COMP_WRONG_SIZE;
+ bw_log(DL_Debug, "I_SEE_YOU: cache counter past end of buffer");
+ } else if ((ncaches = this->getCacheCount()) > MAX_CACHES) {
zret = PARSE_MSG_INVALID;
- else {
+ } else {
size_t comp_size = reinterpret_cast<char *>(m_cache_count + 1) -
m_base;
// Walk the cache ID elements.
MsgBuffer spot(buffer);
@@ -1447,7 +1448,7 @@ CapComp::cache() const
m_cache_assign = static_cast<ServiceGroup::CacheAssignmentStyle>(x);
break;
default:
- logf(LVL_INFO, "Invalid capability type %d in packet.",
elt.getCapType());
+ bw_log(DL_Note, "Invalid capability type {} in packet.",
elt.getCapType());
break;
}
}
@@ -1627,7 +1628,7 @@ detail::Assignment::fill(cache::GroupData &group,
uint32_t addr)
}
if (!v_caches) { // no valid caches.
- log(LVL_INFO, "Attempted to generate cache assignment but no valid caches
were found.");
+ bw_log(DL_Note, "Attempted to generate cache assignment but no valid
caches were found.");
return false;
}
// Just sets the cache count.
@@ -1643,8 +1644,8 @@ detail::Assignment::fill(cache::GroupData &group,
uint32_t addr)
// more complex here.
m_mask_assign->init(0, 0, 0, 0)->addValue(m_hash_assign->getAddr(0), 0, 0,
0, 0);
- logf(LVL_INFO, "Generated assignment for group %d with %d routers, %d valid
caches.", group.m_svc.getSvcId(), n_routers,
- v_caches);
+ bw_log(DL_Note, "Generated assignment for group {} with {} routers, {} valid
caches.", group.m_svc.getSvcId(), n_routers,
+ v_caches);
return true;
}
@@ -1742,7 +1743,7 @@ RedirectAssignMsg::fill(detail::cache::GroupData const
&group, SecurityOption se
m_alt_mask_assign.fill(m_buffer, group.m_assign_info);
break;
default:
- logf(LVL_WARN, "Bad assignment type [%d] for REDIRECT_ASSIGN",
group.m_cache_assign);
+ bw_log(DL_Warning, "Bad assignment type [{}] for REDIRECT_ASSIGN",
group.m_cache_assign);
break;
}
}
@@ -1783,13 +1784,13 @@ ISeeYouMsg::parse(buffer_type const &buffer)
zret = m_router_id.parse(m_buffer);
if (PARSE_SUCCESS != zret) {
- logf(LVL_DEBUG, "I_SEE_YOU: Invalid %d router id", zret);
+ bw_log(DL_Debug, "I_SEE_YOU: Invalid {} router id", zret);
return zret;
}
zret = m_router_view.parse(m_buffer);
if (PARSE_SUCCESS != zret) {
- logf(LVL_DEBUG, "I_SEE_YOU: Invalid %d router view", zret);
+ bw_log(DL_Debug, "I_SEE_YOU: Invalid {} router view", zret);
return zret;
}
@@ -1807,7 +1808,7 @@ ISeeYouMsg::parse(buffer_type const &buffer)
if (m_buffer.getSpace()) {
zret = PARSE_DATA_OVERRUN;
- logf(LVL_DEBUG, "I_SEE_YOU: Data overrun %lu", m_buffer.getSpace());
+ bw_log(DL_Debug, "I_SEE_YOU: Data overrun {}", m_buffer.getSpace());
}
return zret;
diff --git a/src/wccp/WccpStatic.cc b/src/wccp/WccpStatic.cc
index fd483b33fc..20b04b62d2 100644
--- a/src/wccp/WccpStatic.cc
+++ b/src/wccp/WccpStatic.cc
@@ -25,6 +25,8 @@
#include "tscore/ink_error.h"
#include "tscore/ink_defs.h"
+#include "swoc/Lexicon.h"
+
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
@@ -35,6 +37,28 @@
namespace wccp
{
+using swoc::TextView;
+// ------------------------------------------------------
+swoc::Lexicon<ServiceConstants::PacketStyle> PacketStyleNames{
+ {{ServiceConstants::PacketStyle::NO_PACKET_STYLE, "None"},
+ {ServiceConstants::PacketStyle::GRE, "GRE"},
+ {ServiceConstants::PacketStyle::GRE_OR_L2, "GRE_OR_L2"},
+ {ServiceConstants::PacketStyle::L2, "L2"}}
+};
+
+swoc::Lexicon<ServiceConstants::CacheAssignmentStyle> CacheStyleNames{
+ {{ServiceConstants::CacheAssignmentStyle::NO_CACHE_ASSIGN_STYLE, "None"},
+ {ServiceConstants::CacheAssignmentStyle::HASH_ONLY, "HASH"},
+ {ServiceConstants::CacheAssignmentStyle::MASK_ONLY, "MASK"},
+ {ServiceConstants::CacheAssignmentStyle::HASH_OR_MASK, "HASH_OR_MASK"}}
+};
+
+swoc::Lexicon<CapabilityElt::Type> CapabilityEltNames{
+ {{CapabilityElt::Type::NO_METHOD, "None"},
+ {CapabilityElt::Type::CACHE_ASSIGNMENT_METHOD, "CACHE"},
+ {CapabilityElt::Type::PACKET_FORWARD_METHOD, "FORWARD"},
+ {CapabilityElt::Type::PACKET_RETURN_METHOD, "RETURN"}}
+};
// ------------------------------------------------------
// Compile time checks for internal consistency.
@@ -103,14 +127,6 @@ log(ts::Errata &err, ts::Errata::Code code, char const
*text)
return err;
}
-ts::Errata
-log(ts::Errata::Code code, char const *text)
-{
- ts::Errata err;
- err.push(0, code, text);
- return err;
-}
-
ts::Errata &
vlogf(ts::Errata &err, ts::Errata::Id id, ts::Errata::Code code, char const
*format, va_list &rest)
{
@@ -187,4 +203,20 @@ logf_errno(ts::Errata::Code code, char const *format, ...)
return vlogf_errno(code, format, rest);
}
// ------------------------------------------------------
+swoc::BufferWriter &
+bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec,
ServiceConstants::PacketStyle style)
+{
+ return bwformat(w, spec, PacketStyleNames[style]);
+}
+swoc::BufferWriter &
+bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec,
ServiceConstants::CacheAssignmentStyle style)
+{
+ return bwformat(w, spec, CacheStyleNames[style]);
+}
+swoc::BufferWriter &
+bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec,
CapabilityElt::Type type)
+{
+ return bwformat(w, spec, CapabilityEltNames[type]);
+}
+// ------------------------------------------------------
} // namespace wccp
diff --git a/src/wccp/WccpUtil.h b/src/wccp/WccpUtil.h
index 2c5d5f2d33..a0858d530f 100644
--- a/src/wccp/WccpUtil.h
+++ b/src/wccp/WccpUtil.h
@@ -28,85 +28,6 @@
namespace wccp
{
-/// @name Message severity levels.
-//@{
-extern ts::Errata::Code LVL_FATAL; ///< Fatal, cannot continue.
-extern ts::Errata::Code LVL_WARN; ///< Significant, function degraded.
-extern ts::Errata::Code LVL_INFO; ///< Interesting, not necessarily a problem.
-extern ts::Errata::Code LVL_DEBUG; ///< Debugging information.
-extern ts::Errata::Code LVL_TMP; ///< For temporary debugging only.
- // Handy so that temporary debugging
messages can be located by grep.
- //@}
-
-/** Logging / reporting support.
- We build on top of @c Errata but we want to be able to prevent
- message generation / allocation for messages with severity levels
- less than a run time controllable value.
-
- @internal Far from complete but serving as a prototype / experiment
- to learn what's actually useful.
-*/
-//@{
-/// Report literal string to an Errata.
-/// @return @a err.
-ts::Errata &log(ts::Errata &err, ///< Target errata.
- ts::Errata::Id id, ///< Message ID.
- ts::Errata::Code code, ///< Severity level.
- char const *text ///< Message text.
-);
-/// Report literal string to an Errata.
-/// Use message ID 0.
-/// @return @a err.
-ts::Errata &log(ts::Errata &err, ///< Target errata.
- ts::Errata::Code code, ///< Severity level.
- char const *text ///< Message text.
-);
-/// printf style log to Errata.
-/// @return @a err.
-ts::Errata &logf(ts::Errata &err, ///< Target errata.
- ts::Errata::Id id, ///< Message ID.
- ts::Errata::Code code, ///< Severity level.
- char const *format, ///< Format string.
- ... ///< Format string parameters.
-);
-/// printf style log to Errata.
-/// The message id is set to zero.
-/// @return @a err.
-ts::Errata &logf(ts::Errata &err, ///< Target errata.
- ts::Errata::Code code, ///< Severity level.
- char const *format, ///< Format string.
- ... ///< Format string parameters.
-);
-/// Return an Errata populated with a literal string.
-/// Use message ID 0.
-/// @return @a err.
-ts::Errata log(ts::Errata::Code code, ///< Severity level.
- char const *text ///< Message text.
-);
-/// Return an Errata populated with a printf style formatted string.
-/// Use message ID 0.
-/// @return @a err.
-ts::Errata logf(ts::Errata::Code code, ///< Severity level.
- char const *format, ///< Message text.
- ...);
-/** Return an Errata based on @c errno.
- The literal string is combined with the system text for the current
- value of @c errno. This is modeled on @c perror. Message ID 0 is used.
- @return @a err.
- */
-ts::Errata log_errno(ts::Errata::Code code, ///< Severity level.
- char const *text ///< Message text.
-);
-/** Return an @c Errata based on @c errno.
- @c errno and the corresponding system error string are appended to
- the results from the @a format and following arguments.
- */
-ts::Errata logf_errno(ts::Errata::Code code, ///< Severity code.
- char const *format, ///< Format string.
- ... ///< Arguments for @a format.
-);
-//@}
-
// ------------------------------------------------------
/* Template support for access to raw message fields.
We have three overloads, one for each size of field.
