http://git-wip-us.apache.org/repos/asf/trafficserver/blob/65477944/lib/wccp/WccpMeta.h
----------------------------------------------------------------------
diff --git a/lib/wccp/WccpMeta.h b/lib/wccp/WccpMeta.h
index a30f1c9..a2cacc2 100644
--- a/lib/wccp/WccpMeta.h
+++ b/lib/wccp/WccpMeta.h
@@ -1,5 +1,5 @@
-# if !defined(TS_WCCP_META_HEADER)
-# define TS_WCCP_META_HEADER
+#if !defined(TS_WCCP_META_HEADER)
+#define TS_WCCP_META_HEADER
/** @file
Meta programming support for WCCP.
@@ -27,54 +27,66 @@
// Various meta programming efforts. Experimental at present.
-namespace ts {
-
+namespace ts
+{
// Some support templates so we can fail to compile if the
// compile time check fails.
// This creates the actual error, depending on whether X has a valid
// nest type Result.
-template < typename X > struct TEST_RESULT { typedef typename X::Result type; };
+template <typename X> struct TEST_RESULT {
+ typedef typename X::Result type;
+};
// Bool checking - a base template then specializations to succeed or
// fail.
-template < bool VALUE > struct TEST_BOOL { };
+template <bool VALUE> struct TEST_BOOL {
+};
// Successful test defines Result.
-template <> struct TEST_BOOL<true> { typedef int Result; };
+template <> struct TEST_BOOL<true> {
+ typedef int Result;
+};
// Failing test does not define Result.
-template <> struct TEST_BOOL<false> { };
+template <> struct TEST_BOOL<false> {
+};
// Fail to compile if VALUE is not true.
-template < bool VALUE > struct TEST_IF_TRUE
- : public TEST_RESULT< TEST_BOOL< VALUE > > {
+template <bool VALUE> struct TEST_IF_TRUE : public TEST_RESULT<TEST_BOOL<VALUE> > {
};
// Helper for assigning a value to all instances in a container.
-template < typename T , typename R, typename A1 >
-struct TsAssignMember : public std::binary_function<T, A1, R> {
+template <typename T, typename R, typename A1> struct TsAssignMember : public std::binary_function<T, A1, R> {
R T::*_m;
A1 _arg1;
- TsAssignMember(R T::*m, A1 const& arg1) : _m(m), _arg1(arg1) { }
- R operator () (T& t) const { return t.*_m = _arg1; }
+ TsAssignMember(R T::*m, A1 const &arg1) : _m(m), _arg1(arg1) {}
+ R operator()(T &t) const { return t.*_m = _arg1; }
};
// Helper function to compute types for TsAssignMember.
-template < typename T, typename R, typename A1 > struct TsAssignMember<T,R,A1> assign_member(R T::*m, A1 const& arg1) { return TsAssignMember<T,R,A1>(m,arg1); }
+template <typename T, typename R, typename A1>
+struct TsAssignMember<T, R, A1>
+assign_member(R T::*m, A1 const &arg1) {
+ return TsAssignMember<T, R, A1>(m, arg1);
+}
// Overload for_each to operate on a container.
-template < typename C, typename F > void for_each(C& c, F const& f) { std::for_each(c.begin(), c.end(), f); }
+template <typename C, typename F>
+void
+for_each(C &c, F const &f)
+{
+ std::for_each(c.begin(), c.end(), f);
+}
/** Calc minimal value over a direct type container.
This handles an accessor that takes a argument.
*/
-template < typename C, typename V, typename ARG1 > V
-minima(C const& c, V (C::value_type::*ex)(ARG1) const, ARG1 const& arg1) {
+template <typename C, typename V, typename ARG1>
+V
+minima(C const &c, V (C::value_type::*ex)(ARG1) const, ARG1 const &arg1)
+{
V v = std::numeric_limits<V>::max();
- for ( typename C::const_iterator spot = c.begin(), limit = c.end();
- spot != limit;
- ++spot
- ) {
- v = std::min(v, ((*spot).*ex)(arg1) );
+ for (typename C::const_iterator spot = c.begin(), limit = c.end(); spot != limit; ++spot) {
+ v = std::min(v, ((*spot).*ex)(arg1));
}
return v;
}
@@ -82,80 +94,73 @@ minima(C const& c, V (C::value_type::*ex)(ARG1) const, ARG1 const& arg1) {
/** Calc minimal value over a paired type container.
This handles an accessor that takes a argument.
*/
-template < typename C, typename V, typename ARG1 > V
-minima(C const& c, V (C::value_type::second_type::*ex)(ARG1) const, ARG1 const& arg1) {
+template <typename C, typename V, typename ARG1>
+V
+minima(C const &c, V (C::value_type::second_type::*ex)(ARG1) const, ARG1 const &arg1)
+{
V v = std::numeric_limits<V>::max();
- for ( typename C::const_iterator spot = c.begin(), limit = c.end();
- spot != limit;
- ++spot
- ) {
- v = std::min(v, ((spot->second).*ex)(arg1) );
+ for (typename C::const_iterator spot = c.begin(), limit = c.end(); spot != limit; ++spot) {
+ v = std::min(v, ((spot->second).*ex)(arg1));
}
return v;
}
/** Apply a unary method to every object in a direct container.
*/
-template < typename C, typename V, typename ARG1 > void
-for_each(C& c, V (C::value_type::*ex)(ARG1), ARG1 const& arg1) {
- for ( typename C::iterator spot = c.begin(), limit = c.end();
- spot != limit;
- ++spot
- ) ((*spot).*ex)(arg1);
+template <typename C, typename V, typename ARG1>
+void
+for_each(C &c, V (C::value_type::*ex)(ARG1), ARG1 const &arg1)
+{
+ for (typename C::iterator spot = c.begin(), limit = c.end(); spot != limit; ++spot)
+ ((*spot).*ex)(arg1);
}
/** Apply a unary method to every object in a paired container.
*/
-template < typename C, typename V, typename ARG1 > void
-for_each(C& c, V (C::value_type::second_type::*ex)(ARG1) const, ARG1 const& arg1) {
- for ( typename C::iterator spot = c.begin(), limit = c.end();
- spot != limit;
- ++spot
- ) ((spot->second).*ex)(arg1);
+template <typename C, typename V, typename ARG1>
+void
+for_each(C &c, V (C::value_type::second_type::*ex)(ARG1) const, ARG1 const &arg1)
+{
+ for (typename C::iterator spot = c.begin(), limit = c.end(); spot != limit; ++spot)
+ ((spot->second).*ex)(arg1);
}
-template <
- typename Elt, ///< Element type.
- typename Value ///< Member value type.
-> struct MemberPredicate {
- Value const& m_value; ///< Value to test against.
- Value Elt::*m_mptr; ///< Pointer to member to test.
- MemberPredicate(Value Elt::*mptr, Value const& v)
- : m_value(v)
- , m_mptr(mptr) {
- }
- bool operator () (Elt const& elt) const {
- return elt.*m_mptr == m_value;
- }
+template <typename Elt, ///< Element type.
+ typename Value ///< Member value type.
+ >
+struct MemberPredicate {
+ Value const &m_value; ///< Value to test against.
+ Value Elt::*m_mptr; ///< Pointer to member to test.
+ MemberPredicate(Value Elt::*mptr, Value const &v) : m_value(v), m_mptr(mptr) {}
+ bool operator()(Elt const &elt) const { return elt.*m_mptr == m_value; }
};
-template < typename T, typename V > MemberPredicate<T,V>
-predicate(V T::*m, V const& v) {
- return MemberPredicate<T,V>(m, v);
+template <typename T, typename V>
+MemberPredicate<T, V>
+predicate(V T::*m, V const &v)
+{
+ return MemberPredicate<T, V>(m, v);
}
-template <
- typename Elt, ///< Element type.
- typename Value ///< Member value type.
-> struct MethodPredicate {
+template <typename Elt, ///< Element type.
+ typename Value ///< Member value type.
+ >
+struct MethodPredicate {
typedef Value (Elt::*MethodPtr)() const;
- Value const& m_value; ///< Value to test against.
- MethodPtr m_mptr; ///< Pointer to method returning value.
- MethodPredicate(MethodPtr mptr , Value const& v)
- : m_value(v)
- , m_mptr(mptr) {
- }
- bool operator () (Elt const& elt) const {
- return (elt.*m_mptr)() == m_value;
- }
+ Value const &m_value; ///< Value to test against.
+ MethodPtr m_mptr; ///< Pointer to method returning value.
+ MethodPredicate(MethodPtr mptr, Value const &v) : m_value(v), m_mptr(mptr) {}
+ bool operator()(Elt const &elt) const { return (elt.*m_mptr)() == m_value; }
};
-template < typename T, typename V > MethodPredicate<T,V>
-predicate(V (T::*m)() const, V const& v) {
- return MethodPredicate<T,V>(m, v);
+template <typename T, typename V>
+MethodPredicate<T, V>
+predicate(V (T::*m)() const, V const &v)
+{
+ return MethodPredicate<T, V>(m, v);
}
-# if 0
+#if 0
/// Accumulate a minimum value when called repeated on different objects.
template <
@@ -196,8 +201,8 @@ template <
}
};
-# endif
+#endif
} // namespace ts
-# endif // TS_WCCP_META_HEADER
+#endif // TS_WCCP_META_HEADER
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/65477944/lib/wccp/WccpMsg.cc
----------------------------------------------------------------------
diff --git a/lib/wccp/WccpMsg.cc b/lib/wccp/WccpMsg.cc
index 03d4191..c4ed4f9 100644
--- a/lib/wccp/WccpMsg.cc
+++ b/lib/wccp/WccpMsg.cc
@@ -20,29 +20,30 @@
limitations under the License.
*/
-# include "WccpLocal.h"
-# include <errno.h>
-# include <openssl/md5.h>
-# include <TsException.h>
-# include "ink_memory.h"
-# include "ink_string.h"
-
-namespace wccp {
+#include "WccpLocal.h"
+#include <errno.h>
+#include <openssl/md5.h>
+#include <TsException.h>
+#include "ink_memory.h"
+#include "ink_string.h"
+
+namespace wccp
+{
// ------------------------------------------------------
// ------------------------------------------------------
-ServiceGroup&
-ServiceGroup::setSvcType(ServiceGroup::Type t) {
+ServiceGroup &
+ServiceGroup::setSvcType(ServiceGroup::Type t)
+{
if (STANDARD == t) {
// For standard service, everything past ID must be zero.
- memset(&m_priority, 0,
- sizeof(*this) - (reinterpret_cast<char*>(&m_priority) - reinterpret_cast<char*>(this)));
+ memset(&m_priority, 0, sizeof(*this) - (reinterpret_cast<char *>(&m_priority) - reinterpret_cast<char *>(this)));
}
m_svc_type = t; // store actual type.
return *this;
}
-bool
-ServiceGroup::operator == (self const& that) const {
+bool ServiceGroup::operator==(self const &that) const
+{
if (m_svc_type == STANDARD) {
// If type are different, fail, else if both are STANDARD
// then we need only match on the ID.
@@ -53,46 +54,48 @@ ServiceGroup::operator == (self const& that) const {
// Both services are DYNAMIC, check the properties.
// Port check is technically too strict -- should ignore
// ports beyond the terminating null port. Oh well.
- return m_svc_id == that.m_svc_id
- && m_protocol == that.m_protocol
- && m_flags == that.m_flags
- && m_priority == that.m_priority
- && 0 == memcmp(m_ports, that.m_ports, sizeof(m_ports))
- ;
+ return m_svc_id == that.m_svc_id && m_protocol == that.m_protocol && m_flags == that.m_flags && m_priority == that.m_priority &&
+ 0 == memcmp(m_ports, that.m_ports, sizeof(m_ports));
}
}
// ------------------------------------------------------
// ------------------------------------------------------
-CacheHashIdElt&
-CacheHashIdElt::setBucket(int idx, bool state) {
- uint8_t& bucket = m_buckets[idx>>3];
+CacheHashIdElt &
+CacheHashIdElt::setBucket(int idx, bool state)
+{
+ uint8_t &bucket = m_buckets[idx >> 3];
uint8_t mask = 1 << (idx & 7);
- if (state) bucket |= mask;
- else bucket &= !mask;
+ if (state)
+ bucket |= mask;
+ else
+ bucket &= !mask;
return *this;
}
-CacheHashIdElt&
-CacheHashIdElt::setBuckets(bool state) {
+CacheHashIdElt &
+CacheHashIdElt::setBuckets(bool state)
+{
memset(m_buckets, state ? 0xFF : 0, sizeof(m_buckets));
return *this;
}
-CacheIdBox::CacheIdBox()
- : m_base(0)
- , m_tail(0)
- , m_size(0)
- , m_cap(0) {
+CacheIdBox::CacheIdBox() : m_base(0), m_tail(0), m_size(0), m_cap(0)
+{
}
-size_t CacheIdBox::getSize() const { return m_size; }
+size_t
+CacheIdBox::getSize() const
+{
+ return m_size;
+}
-CacheIdBox&
-CacheIdBox::require(size_t n) {
+CacheIdBox &
+CacheIdBox::require(size_t n)
+{
if (m_cap < n) {
if (m_base && m_cap)
ats_free(m_base);
- m_base = static_cast<CacheIdElt*>(ats_malloc(n));
+ m_base = static_cast<CacheIdElt *>(ats_malloc(n));
m_cap = n;
}
memset(m_base, 0, m_cap);
@@ -100,24 +103,26 @@ CacheIdBox::require(size_t n) {
return *this;
}
-CacheIdBox&
-CacheIdBox::initDefaultHash(uint32_t addr) {
+CacheIdBox &
+CacheIdBox::initDefaultHash(uint32_t addr)
+{
this->require(sizeof(CacheHashIdElt));
m_size = sizeof(CacheHashIdElt);
m_base->initHashRev().setUnassigned(true).setMask(false).setAddr(addr);
- m_tail = static_cast<CacheHashIdElt*>(m_base)->getTailPtr();
+ m_tail = static_cast<CacheHashIdElt *>(m_base)->getTailPtr();
m_tail->m_weight = htons(0);
m_tail->m_status = htons(0);
return *this;
}
-CacheIdBox&
-CacheIdBox::initDefaultMask(uint32_t addr) {
+CacheIdBox &
+CacheIdBox::initDefaultMask(uint32_t addr)
+{
// Base element plus set with 1 value plus tail.
this->require(sizeof(CacheMaskIdElt) + MaskValueSetElt::calcSize(1) + sizeof(CacheIdElt::Tail));
- CacheMaskIdElt* mid = static_cast<CacheMaskIdElt*>(m_base);
+ CacheMaskIdElt *mid = static_cast<CacheMaskIdElt *>(m_base);
mid->initHashRev().setUnassigned(true).setMask(true).setAddr(addr);
- mid->m_assign.init(0,0,0,0)->addValue(addr, 0, 0, 0, 0);
+ mid->m_assign.init(0, 0, 0, 0)->addValue(addr, 0, 0, 0, 0);
m_size = mid->getSize();
m_tail = mid->getTailPtr();
m_tail->m_weight = htons(0);
@@ -125,44 +130,44 @@ CacheIdBox::initDefaultMask(uint32_t addr) {
return *this;
}
-CacheIdBox&
-CacheIdBox::fill(self const& src) {
+CacheIdBox &
+CacheIdBox::fill(self const &src)
+{
size_t n = src.getSize();
this->require(src.getSize());
memcpy(m_base, src.m_base, n);
m_size = src.m_size;
// If tail is set in src, use the same offset here.
if (src.m_tail)
- m_tail = reinterpret_cast<CacheIdElt::Tail*>(
- reinterpret_cast<char*>(m_base) + (
- reinterpret_cast<char*>(src.m_tail)
- - reinterpret_cast<char*>(src.m_base)
- ));
- else m_tail = 0;
+ m_tail = reinterpret_cast<CacheIdElt::Tail *>(reinterpret_cast<char *>(m_base) +
+ (reinterpret_cast<char *>(src.m_tail) - reinterpret_cast<char *>(src.m_base)));
+ else
+ m_tail = 0;
return *this;
}
-CacheIdBox&
-CacheIdBox::fill(void* base, self const& src) {
+CacheIdBox &
+CacheIdBox::fill(void *base, self const &src)
+{
m_size = src.getSize();
m_cap = 0;
- m_base = static_cast<CacheIdElt*>(base);
+ m_base = static_cast<CacheIdElt *>(base);
memcpy(m_base, src.m_base, m_size);
return *this;
}
int
-CacheIdBox::parse(MsgBuffer base) {
+CacheIdBox::parse(MsgBuffer base)
+{
int zret = PARSE_SUCCESS;
- CacheIdElt* ptr = reinterpret_cast<CacheIdElt*>(base.getTail());
+ CacheIdElt *ptr = reinterpret_cast<CacheIdElt *>(base.getTail());
size_t n = base.getSpace();
m_cap = 0;
if (ptr->isMask()) {
- CacheMaskIdElt* mptr = static_cast<CacheMaskIdElt*>(ptr);
+ CacheMaskIdElt *mptr = static_cast<CacheMaskIdElt *>(ptr);
size_t size = sizeof(CacheMaskIdElt);
// Sanity check - verify enough room for empty elements.
- if (n < size
- || n < size + MaskValueSetElt::calcSize(0) * mptr->getCount()) {
+ if (n < size || n < size + MaskValueSetElt::calcSize(0) * mptr->getCount()) {
zret = PARSE_BUFFER_TOO_SMALL;
} else {
m_size = mptr->getSize();
@@ -179,107 +184,119 @@ CacheIdBox::parse(MsgBuffer base) {
logf(LVL_DEBUG, "I_SEE_YOU Cache Hash ID too small: %lu < %lu", n, sizeof(CacheHashIdElt));
} else {
m_size = sizeof(CacheHashIdElt);
- m_tail = static_cast<CacheHashIdElt*>(m_base)->getTailPtr();
+ m_tail = static_cast<CacheHashIdElt *>(m_base)->getTailPtr();
}
}
- if (PARSE_SUCCESS == zret) m_base = ptr;
+ if (PARSE_SUCCESS == zret)
+ m_base = ptr;
return zret;
}
// ------------------------------------------------------
inline CapabilityElt::Type
-CapabilityElt::getCapType() const {
+CapabilityElt::getCapType() const
+{
return static_cast<Type>(ntohs(m_cap_type));
}
-inline CapabilityElt&
-CapabilityElt::setCapType(Type cap) {
+inline CapabilityElt &
+CapabilityElt::setCapType(Type cap)
+{
m_cap_type = htons(cap);
return *this;
}
inline uint32_t
-CapabilityElt::getCapData() const {
+CapabilityElt::getCapData() const
+{
return ntohl(m_cap_data);
}
-inline CapabilityElt&
-CapabilityElt::setCapData(uint32_t data) {
+inline CapabilityElt &
+CapabilityElt::setCapData(uint32_t data)
+{
m_cap_data = htonl(data);
return *this;
}
-CapabilityElt::CapabilityElt() {
+CapabilityElt::CapabilityElt()
+{
}
-CapabilityElt::CapabilityElt(Type cap, uint32_t data) {
+CapabilityElt::CapabilityElt(Type cap, uint32_t data)
+{
this->setCapType(cap);
this->setCapData(data);
m_cap_length = htons(sizeof(uint32_t));
}
// ------------------------------------------------------
inline uint32_t
-ValueElt::getf_src_addr() const {
+ValueElt::getf_src_addr() const
+{
return ntohl(m_src_addr);
}
-inline ValueElt&
-ValueElt::setf_src_addr(uint32_t addr) {
+inline ValueElt &
+ValueElt::setf_src_addr(uint32_t addr)
+{
m_src_addr = htonl(addr);
return *this;
}
inline uint32_t
-ValueElt::getDstAddr() const {
+ValueElt::getDstAddr() const
+{
return ntohl(m_dst_addr);
}
-inline ValueElt&
-ValueElt::setf_dst_addr(uint32_t addr) {
+inline ValueElt &
+ValueElt::setf_dst_addr(uint32_t addr)
+{
m_dst_addr = htonl(addr);
return *this;
}
inline uint16_t
-ValueElt::getf_src_port() const {
+ValueElt::getf_src_port() const
+{
return ntohs(m_src_port);
}
-inline ValueElt&
-ValueElt::setf_src_port(uint16_t port) {
+inline ValueElt &
+ValueElt::setf_src_port(uint16_t port)
+{
m_src_port = htons(port);
return *this;
}
inline uint16_t
-ValueElt::getDstPort() const {
+ValueElt::getDstPort() const
+{
return ntohs(m_dst_port);
}
-inline ValueElt&
-ValueElt::setf_dst_port(uint16_t port) {
+inline ValueElt &
+ValueElt::setf_dst_port(uint16_t port)
+{
m_dst_port = htons(port);
return *this;
}
inline uint32_t
-ValueElt::getCacheAddr() const {
+ValueElt::getCacheAddr() const
+{
return ntohl(m_cache_addr);
}
-inline ValueElt&
-ValueElt::setCacheAddr(uint32_t addr) {
+inline ValueElt &
+ValueElt::setCacheAddr(uint32_t addr)
+{
m_cache_addr = htonl(addr);
return *this;
}
// ------------------------------------------------------
-MaskValueSetElt&
-MaskValueSetElt::addValue(
- uint32_t cacheAddr,
- uint32_t srcAddr,
- uint32_t dstAddr,
- uint16_t srcPort,
- uint16_t dstPort
-) {
+MaskValueSetElt &
+MaskValueSetElt::addValue(uint32_t cacheAddr, uint32_t srcAddr, uint32_t dstAddr, uint16_t srcPort, uint16_t dstPort)
+{
uint32_t idx = ntohl(m_count);
new (this->values() + idx) ValueElt(cacheAddr, srcAddr, dstAddr, srcPort, dstPort);
m_count = htonl(idx + 1);
@@ -287,45 +304,44 @@ MaskValueSetElt::addValue(
}
size_t
-MaskAssignElt::getVarSize() const {
+MaskAssignElt::getVarSize() const
+{
size_t zret = 0;
int n = this->getCount();
- MaskValueSetElt const* set = reinterpret_cast<MaskValueSetElt const*>(this+1);
+ MaskValueSetElt const *set = reinterpret_cast<MaskValueSetElt const *>(this + 1);
while (n--) {
size_t k = set->getSize();
zret += k;
- set = reinterpret_cast<MaskValueSetElt const*>(
- reinterpret_cast<char const*>(set) + k
- );
+ set = reinterpret_cast<MaskValueSetElt const *>(reinterpret_cast<char const *>(set) + k);
}
return zret;
}
-HashAssignElt&
-HashAssignElt::round_robin_assign() {
+HashAssignElt &
+HashAssignElt::round_robin_assign()
+{
uint32_t v_caches = this->getCount();
- Bucket* buckets = this->getBucketBase();
- if (1 == v_caches) memset(buckets, 0, sizeof(Bucket) * N_BUCKETS);
+ Bucket *buckets = this->getBucketBase();
+ if (1 == v_caches)
+ memset(buckets, 0, sizeof(Bucket) * N_BUCKETS);
else { // Assign round robin.
size_t x = 0;
- for ( Bucket *spot = buckets, *limit = spot + N_BUCKETS;
- spot < limit;
- ++spot
- ) {
+ for (Bucket *spot = buckets, *limit = spot + N_BUCKETS; spot < limit; ++spot) {
spot->m_idx = x;
spot->m_alt = 0;
- x = ( x + 1 ) % v_caches;
+ x = (x + 1) % v_caches;
}
}
return *this;
}
-RouterAssignListElt&
-RouterAssignListElt::updateRouterId(uint32_t addr, uint32_t rcvid, uint32_t cno) {
+RouterAssignListElt &
+RouterAssignListElt::updateRouterId(uint32_t addr, uint32_t rcvid, uint32_t cno)
+{
uint32_t n = this->getCount();
- RouterAssignElt* elt = access_array<RouterAssignElt>(this+1);
- for ( uint32_t i = 0 ; i < n ; ++i, ++elt ) {
+ RouterAssignElt *elt = access_array<RouterAssignElt>(this + 1);
+ for (uint32_t i = 0; i < n; ++i, ++elt) {
if (addr == elt->getAddr()) {
elt->setChangeNumber(cno).setRecvId(rcvid);
break;
@@ -335,45 +351,53 @@ RouterAssignListElt::updateRouterId(uint32_t addr, uint32_t rcvid, uint32_t cno)
}
// ------------------------------------------------------
message_type_t
-MsgHeaderComp::getType() {
+MsgHeaderComp::getType()
+{
return static_cast<message_type_t>(get_field(&raw_t::m_type, m_base));
}
uint16_t
-MsgHeaderComp::getVersion() {
+MsgHeaderComp::getVersion()
+{
return get_field(&raw_t::m_version, m_base);
}
uint16_t
-MsgHeaderComp::getLength() {
+MsgHeaderComp::getLength()
+{
return get_field(&raw_t::m_length, m_base);
}
-MsgHeaderComp&
-MsgHeaderComp::setType(message_type_t type) {
+MsgHeaderComp &
+MsgHeaderComp::setType(message_type_t type)
+{
set_field(&raw_t::m_type, m_base, type);
return *this;
}
-MsgHeaderComp&
-MsgHeaderComp::setVersion(uint16_t version) {
+MsgHeaderComp &
+MsgHeaderComp::setVersion(uint16_t version)
+{
set_field(&raw_t::m_version, m_base, version);
return *this;
}
-MsgHeaderComp&
-MsgHeaderComp::setLength(uint16_t length) {
+MsgHeaderComp &
+MsgHeaderComp::setLength(uint16_t length)
+{
set_field(&raw_t::m_length, m_base, length);
return *this;
}
size_t
-MsgHeaderComp::calcSize() {
+MsgHeaderComp::calcSize()
+{
return sizeof(raw_t);
}
-MsgHeaderComp&
-MsgHeaderComp::fill(MsgBuffer& buffer, message_type_t t) {
+MsgHeaderComp &
+MsgHeaderComp::fill(MsgBuffer &buffer, message_type_t t)
+{
size_t comp_size = this->calcSize();
if (buffer.getSpace() < comp_size)
throw ts::Exception(BUFFER_TOO_SMALL_FOR_COMP_TEXT);
@@ -384,7 +408,8 @@ MsgHeaderComp::fill(MsgBuffer& buffer, message_type_t t) {
}
int
-MsgHeaderComp::parse(MsgBuffer& base) {
+MsgHeaderComp::parse(MsgBuffer &base)
+{
int zret = PARSE_SUCCESS;
size_t comp_size = this->calcSize();
if (base.getSpace() < comp_size) {
@@ -394,8 +419,7 @@ MsgHeaderComp::parse(MsgBuffer& base) {
// Length field puts end of message past end of buffer.
if (this->getLength() + comp_size > base.getSpace()) {
zret = PARSE_MSG_TOO_BIG;
- } else if (INVALID_MSG_TYPE == this->toMsgType(get_field(&raw_t::m_type, m_base))
- ) {
+ } else if (INVALID_MSG_TYPE == this->toMsgType(get_field(&raw_t::m_type, m_base))) {
zret = PARSE_COMP_TYPE_INVALID;
} else {
base.use(comp_size);
@@ -408,30 +432,35 @@ SecurityComp::Key SecurityComp::m_default_key;
SecurityComp::Option SecurityComp::m_default_opt = SECURITY_NONE;
SecurityComp::Option
-SecurityComp::getOption() const {
+SecurityComp::getOption() const
+{
return static_cast<Option>(get_field(&RawNone::m_option, m_base));
}
-SecurityComp&
-SecurityComp::setOption(Option opt) {
+SecurityComp &
+SecurityComp::setOption(Option opt)
+{
set_field(&RawNone::m_option, m_base, static_cast<uint32_t>(opt));
return *this;
}
-SecurityComp&
-SecurityComp::setKey(char const* key) {
+SecurityComp &
+SecurityComp::setKey(char const *key)
+{
m_local_key = true;
strncpy(m_key, key, KEY_SIZE);
return *this;
}
void
-SecurityComp::setDefaultKey(char const* key) {
+SecurityComp::setDefaultKey(char const *key)
+{
strncpy(m_default_key, key, KEY_SIZE);
}
-SecurityComp&
-SecurityComp::fill(MsgBuffer& buffer, Option opt) {
+SecurityComp &
+SecurityComp::fill(MsgBuffer &buffer, Option opt)
+{
size_t comp_size = this->calcSize(opt);
if (buffer.getSpace() < comp_size)
@@ -439,13 +468,10 @@ SecurityComp::fill(MsgBuffer& buffer, Option opt) {
m_base = buffer.getTail();
- this->setType(COMP_TYPE)
- .setLength(comp_size - sizeof(super::raw_t))
- .setOption(opt)
- ;
+ this->setType(COMP_TYPE).setLength(comp_size - sizeof(super::raw_t)).setOption(opt);
if (SECURITY_NONE != opt) {
- RawMD5::HashData& data = access_field(&RawMD5::m_data, m_base);
+ RawMD5::HashData &data = access_field(&RawMD5::m_data, m_base);
memset(data, 0, sizeof(data));
}
@@ -453,11 +479,12 @@ SecurityComp::fill(MsgBuffer& buffer, Option opt) {
return *this;
}
-SecurityComp&
-SecurityComp::secure(MsgBuffer const& msg) {
+SecurityComp &
+SecurityComp::secure(MsgBuffer const &msg)
+{
if (SECURITY_MD5 == this->getOption()) {
MD5_CTX ctx;
- char const* key = m_local_key ? m_key : m_default_key;
+ char const *key = m_local_key ? m_key : m_default_key;
MD5_Init(&ctx);
MD5_Update(&ctx, key, KEY_SIZE);
MD5_Update(&ctx, msg.getBase(), msg.getCount());
@@ -467,13 +494,14 @@ SecurityComp::secure(MsgBuffer const& msg) {
}
bool
-SecurityComp::validate(MsgBuffer const& msg) const {
+SecurityComp::validate(MsgBuffer const &msg) const
+{
bool zret = true;
if (SECURITY_MD5 == this->getOption()) {
RawMD5::HashData save;
- RawMD5::HashData& org = const_cast<RawMD5::HashData&>(access_field(&RawMD5::m_data, m_base));
+ RawMD5::HashData &org = const_cast<RawMD5::HashData &>(access_field(&RawMD5::m_data, m_base));
MD5_CTX ctx;
- char const* key = m_local_key ? m_key : m_default_key;
+ char const *key = m_local_key ? m_key : m_default_key;
// save the original hash aside.
memcpy(save, org, sizeof(save));
// zero out the component hash area to compute the hash.
@@ -492,14 +520,15 @@ SecurityComp::validate(MsgBuffer const& msg) const {
}
int
-SecurityComp::parse(MsgBuffer& buffer) {
+SecurityComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
Option opt = this->getOption();
if (SECURITY_NONE != opt && SECURITY_MD5 != opt)
zret = PARSE_COMP_INVALID;
@@ -516,29 +545,33 @@ SecurityComp::parse(MsgBuffer& buffer) {
}
// ------------------------------------------------------
-ServiceComp&
-ServiceComp::setPort(int idx, uint16_t port) {
+ServiceComp &
+ServiceComp::setPort(int idx, uint16_t port)
+{
this->access()->setPort(idx, port);
m_port_count = std::max(m_port_count, idx);
return *this;
}
-ServiceComp&
-ServiceComp::addPort(uint16_t port) {
+ServiceComp &
+ServiceComp::addPort(uint16_t port)
+{
if (m_port_count < static_cast<int>(ServiceGroup::N_PORTS))
this->access()->setPort(m_port_count++, port);
return *this;
}
-ServiceComp&
-ServiceComp::clearPorts() {
+ServiceComp &
+ServiceComp::clearPorts()
+{
this->access()->clearPorts();
m_port_count = 0;
return *this;
}
-ServiceComp&
-ServiceComp::fill(MsgBuffer& buffer, ServiceGroup const& svc) {
+ServiceComp &
+ServiceComp::fill(MsgBuffer &buffer, ServiceGroup const &svc)
+{
size_t comp_size = this->calcSize();
if (buffer.getSpace() < comp_size)
@@ -552,17 +585,15 @@ ServiceComp::fill(MsgBuffer& buffer, ServiceGroup const& svc) {
// to get offset of that part of the serialization storage.
memcpy(
// This generates a gcc warning, but the next line doesn't. Yay.
-// static_cast<ServiceGroup*>(reinterpret_cast<raw_t*>(m_base)),
- &static_cast<ServiceGroup&>(*reinterpret_cast<raw_t*>(m_base)),
- &svc,
- sizeof(svc)
- );
+ // static_cast<ServiceGroup*>(reinterpret_cast<raw_t*>(m_base)),
+ &static_cast<ServiceGroup &>(*reinterpret_cast<raw_t *>(m_base)), &svc, sizeof(svc));
buffer.use(comp_size);
return *this;
}
int
-ServiceComp::parse(MsgBuffer& buffer) {
+ServiceComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
size_t comp_size = this->calcSize();
if (buffer.getSpace() < comp_size)
@@ -570,8 +601,8 @@ ServiceComp::parse(MsgBuffer& buffer) {
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
- ServiceGroup::Type svc = this->getSvcType();
+ if (PARSE_SUCCESS == zret) {
+ ServiceGroup::Type svc = this->getSvcType();
if (ServiceGroup::DYNAMIC != svc && ServiceGroup::STANDARD != svc)
zret = PARSE_COMP_INVALID;
else if (this->getLength() != comp_size - sizeof(super::raw_t))
@@ -583,75 +614,95 @@ ServiceComp::parse(MsgBuffer& buffer) {
return zret;
}
// ------------------------------------------------------
-RouterIdElt&
-RouterIdComp::idElt() {
+RouterIdElt &
+RouterIdComp::idElt()
+{
return access_field(&raw_t::m_id, m_base);
}
-RouterIdElt const&
-RouterIdComp::idElt() const {
+RouterIdElt const &
+RouterIdComp::idElt() const
+{
return access_field(&raw_t::m_id, m_base);
}
-RouterIdComp&
-RouterIdComp::setIdElt(uint32_t addr, uint32_t recv_id) {
+RouterIdComp &
+RouterIdComp::setIdElt(uint32_t addr, uint32_t recv_id)
+{
this->idElt().setAddr(addr).setRecvId(recv_id);
return *this;
}
-uint32_t RouterIdComp::getAddr() const { return this->idElt().getAddr(); }
+uint32_t
+RouterIdComp::getAddr() const
+{
+ return this->idElt().getAddr();
+}
-RouterIdComp&
-RouterIdComp::setAddr(uint32_t addr) {
+RouterIdComp &
+RouterIdComp::setAddr(uint32_t addr)
+{
this->idElt().setAddr(addr);
return *this;
}
-uint32_t RouterIdComp::getRecvId() const { return this->idElt().getRecvId();}
-inline RouterIdComp&
-RouterIdComp::setRecvId(uint32_t id) {
+uint32_t
+RouterIdComp::getRecvId() const
+{
+ return this->idElt().getRecvId();
+}
+inline RouterIdComp &
+RouterIdComp::setRecvId(uint32_t id)
+{
this->idElt().setRecvId(id);
return *this;
}
uint32_t
-RouterIdComp::getToAddr() const {
+RouterIdComp::getToAddr() const
+{
return access_field(&raw_t::m_to_addr, m_base);
}
-RouterIdComp&
-RouterIdComp::setToAddr(uint32_t addr) {
+RouterIdComp &
+RouterIdComp::setToAddr(uint32_t addr)
+{
access_field(&raw_t::m_to_addr, m_base) = addr;
return *this;
}
uint32_t
-RouterIdComp::getFromCount() const {
+RouterIdComp::getFromCount() const
+{
return get_field(&raw_t::m_from_count, m_base);
}
uint32_t
-RouterIdComp::getFromAddr(int idx) const {
+RouterIdComp::getFromAddr(int idx) const
+{
return access_array<uint32_t>(m_base + sizeof(raw_t))[idx];
}
-RouterIdComp&
-RouterIdComp::setFromAddr(int idx, uint32_t addr) {
- access_array<uint32_t>(m_base + sizeof(raw_t))[idx] = addr;
+RouterIdComp &
+RouterIdComp::setFromAddr(int idx, uint32_t addr)
+{
+ access_array<uint32_t>(m_base + sizeof(raw_t))[idx] = addr;
return *this;
}
int
-RouterIdComp::findFromAddr(uint32_t addr) {
+RouterIdComp::findFromAddr(uint32_t addr)
+{
int n = this->getFromCount();
- uint32_t* addrs = access_array<uint32_t>(m_base + sizeof(raw_t)) + n;
+ uint32_t *addrs = access_array<uint32_t>(m_base + sizeof(raw_t)) + n;
while (n-- != 0 && *--addrs != addr)
;
return n;
}
-RouterIdComp&
-RouterIdComp::fill(MsgBuffer& buffer, size_t n_caches) {
+RouterIdComp &
+RouterIdComp::fill(MsgBuffer &buffer, size_t n_caches)
+{
size_t comp_size = this->calcSize(n_caches);
if (buffer.getSpace() < comp_size)
throw ts::Exception(BUFFER_TOO_SMALL_FOR_COMP_TEXT);
@@ -666,14 +717,9 @@ RouterIdComp::fill(MsgBuffer& buffer, size_t n_caches) {
return *this;
}
-RouterIdComp&
-RouterIdComp::fillSingleton(
- MsgBuffer& buffer,
- uint32_t addr,
- uint32_t recv_count,
- uint32_t to_addr,
- uint32_t from_addr
-) {
+RouterIdComp &
+RouterIdComp::fillSingleton(MsgBuffer &buffer, uint32_t addr, uint32_t recv_count, uint32_t to_addr, uint32_t from_addr)
+{
size_t comp_size = this->calcSize(1);
if (buffer.getSpace() < comp_size)
@@ -681,11 +727,7 @@ RouterIdComp::fillSingleton(
m_base = buffer.getTail();
- this->setType(COMP_TYPE)
- .setIdElt(addr, recv_count)
- .setToAddr(to_addr)
- .setFromAddr(0, from_addr)
- ;
+ this->setType(COMP_TYPE).setIdElt(addr, recv_count).setToAddr(to_addr).setFromAddr(0, from_addr);
set_field(&raw_t::m_from_count, m_base, 1);
@@ -696,7 +738,8 @@ RouterIdComp::fillSingleton(
}
int
-RouterIdComp::parse(MsgBuffer& buffer) {
+RouterIdComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
@@ -714,67 +757,71 @@ RouterIdComp::parse(MsgBuffer& buffer) {
return zret;
}
// ------------------------------------------------------
-AssignmentKeyElt&
-RouterViewComp::keyElt() {
+AssignmentKeyElt &
+RouterViewComp::keyElt()
+{
return access_field(&raw_t::m_key, m_base);
}
-AssignmentKeyElt const&
-RouterViewComp::keyElt() const {
+AssignmentKeyElt const &
+RouterViewComp::keyElt() const
+{
return access_field(&raw_t::m_key, m_base);
}
uint32_t
-RouterViewComp::getChangeNumber() const {
+RouterViewComp::getChangeNumber() const
+{
return get_field(&raw_t::m_change_number, m_base);
}
-RouterViewComp&
-RouterViewComp::setChangeNumber(uint32_t n) {
+RouterViewComp &
+RouterViewComp::setChangeNumber(uint32_t n)
+{
set_field(&raw_t::m_change_number, m_base, n);
return *this;
}
uint32_t
-RouterViewComp::getCacheCount() const {
+RouterViewComp::getCacheCount() const
+{
return ntohl(*m_cache_count);
}
uint32_t
-RouterViewComp::getRouterCount() const {
+RouterViewComp::getRouterCount() const
+{
return get_field(&raw_t::m_router_count, m_base);
}
-CacheIdBox&
-RouterViewComp::cacheId(int idx) {
+CacheIdBox &
+RouterViewComp::cacheId(int idx)
+{
return m_cache_ids[idx];
}
uint32_t
-RouterViewComp::getRouterAddr(int idx) const {
+RouterViewComp::getRouterAddr(int idx) const
+{
return access_array<uint32_t>(m_base + sizeof(raw_t))[idx];
}
-RouterViewComp&
-RouterViewComp::setRouterAddr(int idx, uint32_t addr) {
+RouterViewComp &
+RouterViewComp::setRouterAddr(int idx, uint32_t addr)
+{
access_array<uint32_t>(m_base + sizeof(raw_t))[idx] = addr;
return *this;
}
-uint32_t*
-RouterViewComp::calc_cache_count_ptr() {
- return reinterpret_cast<uint32_t*>(
- m_base + sizeof(raw_t)
- + this->getRouterCount() * sizeof(uint32_t)
- );
+uint32_t *
+RouterViewComp::calc_cache_count_ptr()
+{
+ return reinterpret_cast<uint32_t *>(m_base + sizeof(raw_t) + this->getRouterCount() * sizeof(uint32_t));
}
-RouterViewComp&
-RouterViewComp::fill(
- MsgBuffer& buffer,
- int n_routers,
- int n_caches
-) {
+RouterViewComp &
+RouterViewComp::fill(MsgBuffer &buffer, int n_routers, int n_caches)
+{
// TBD: This isn't right since the upgrade to mask support
// because the size isn't a static function of the router and
// cache count anymore.
@@ -801,46 +848,49 @@ RouterViewComp::fill(
}
int
-RouterViewComp::parse(MsgBuffer& buffer) {
+RouterViewComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
uint32_t ncaches; // # of caches.
- if (this->getRouterCount() > MAX_ROUTERS) zret = PARSE_MSG_INVALID;
+ if (this->getRouterCount() > MAX_ROUTERS)
+ 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())
- )
+ 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)
zret = PARSE_MSG_INVALID;
else {
- size_t comp_size = reinterpret_cast<char*>(m_cache_count+1) - m_base;
+ size_t comp_size = reinterpret_cast<char *>(m_cache_count + 1) - m_base;
// Walk the cache ID elements.
MsgBuffer spot(buffer);
- CacheIdBox* box = m_cache_ids;
+ CacheIdBox *box = m_cache_ids;
uint32_t idx = 0;
spot.use(comp_size);
- while ( idx < ncaches && PARSE_SUCCESS == (zret = box->parse(spot))) {
+ while (idx < ncaches && PARSE_SUCCESS == (zret = box->parse(spot))) {
size_t k = box->getSize();
spot.use(k);
comp_size += k;
++box;
++idx;
}
- if (PARSE_SUCCESS == zret) buffer.use(comp_size);
+ if (PARSE_SUCCESS == zret)
+ buffer.use(comp_size);
}
}
}
return zret;
}
// ------------------------------------------------------
-CacheIdComp&
-CacheIdComp::fill(MsgBuffer& base, CacheIdBox const& src) {
+CacheIdComp &
+CacheIdComp::fill(MsgBuffer &base, CacheIdBox const &src)
+{
size_t comp_size = src.getSize() + HEADER_SIZE;
if (base.getSpace() < comp_size)
@@ -854,16 +904,17 @@ CacheIdComp::fill(MsgBuffer& base, CacheIdBox const& src) {
}
int
-CacheIdComp::parse(MsgBuffer& buffer) {
+CacheIdComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
MsgBuffer tmp(buffer);
- tmp.use(reinterpret_cast<char*>(&(access_field(&raw_t::m_id, m_base))) - m_base);
+ tmp.use(reinterpret_cast<char *>(&(access_field(&raw_t::m_id, m_base))) - m_base);
zret = m_box.parse(tmp);
if (PARSE_SUCCESS == zret) {
size_t comp_size = HEADER_SIZE + m_box.getSize();
@@ -878,72 +929,74 @@ CacheIdComp::parse(MsgBuffer& buffer) {
}
// ------------------------------------------------------
uint32_t
-CacheViewComp::getChangeNumber() const {
+CacheViewComp::getChangeNumber() const
+{
return get_field(&raw_t::m_change_number, m_base);
}
-CacheViewComp&
-CacheViewComp::setChangeNumber(uint32_t n) {
+CacheViewComp &
+CacheViewComp::setChangeNumber(uint32_t n)
+{
set_field(&raw_t::m_change_number, m_base, n);
return *this;
}
uint32_t
-CacheViewComp::getRouterCount() const {
+CacheViewComp::getRouterCount() const
+{
return get_field(&raw_t::m_router_count, m_base);
}
uint32_t
-CacheViewComp::getCacheCount() const {
+CacheViewComp::getCacheCount() const
+{
return ntohl(*m_cache_count);
}
uint32_t
-CacheViewComp::getCacheAddr(int idx) const {
- return ntohl(m_cache_count[idx+1]);
+CacheViewComp::getCacheAddr(int idx) const
+{
+ return ntohl(m_cache_count[idx + 1]);
}
-CacheViewComp&
-CacheViewComp::setCacheAddr(int idx, uint32_t addr) {
- m_cache_count[idx+1] = addr;
+CacheViewComp &
+CacheViewComp::setCacheAddr(int idx, uint32_t addr)
+{
+ m_cache_count[idx + 1] = addr;
return *this;
}
-RouterIdElt*
-CacheViewComp::atf_router_array() {
- return reinterpret_cast<RouterIdElt*>(m_base + sizeof(raw_t));
+RouterIdElt *
+CacheViewComp::atf_router_array()
+{
+ return reinterpret_cast<RouterIdElt *>(m_base + sizeof(raw_t));
}
-RouterIdElt&
-CacheViewComp::routerElt(int idx) {
+RouterIdElt &
+CacheViewComp::routerElt(int idx)
+{
return this->atf_router_array()[idx];
}
-RouterIdElt*
-CacheViewComp::findf_router_elt(uint32_t addr) {
- for ( RouterIdElt *rtr = this->atf_router_array(),
- *limit = rtr + this->getRouterCount() ;
- rtr < limit;
- ++rtr
- ) {
- if (rtr->getAddr() == addr) return rtr;
+RouterIdElt *
+CacheViewComp::findf_router_elt(uint32_t addr)
+{
+ for (RouterIdElt *rtr = this->atf_router_array(), *limit = rtr + this->getRouterCount(); rtr < limit; ++rtr) {
+ if (rtr->getAddr() == addr)
+ return rtr;
}
return 0;
}
size_t
-CacheViewComp::calcSize(int n_routers, int n_caches) {
- return sizeof(raw_t)
- + n_routers * sizeof(RouterIdElt)
- + sizeof(uint32_t) + n_caches * sizeof(uint32_t)
- ;
+CacheViewComp::calcSize(int n_routers, int n_caches)
+{
+ return sizeof(raw_t) + n_routers * sizeof(RouterIdElt) + sizeof(uint32_t) + n_caches * sizeof(uint32_t);
}
-CacheViewComp&
-CacheViewComp::fill(
- MsgBuffer& buffer,
- detail::cache::GroupData const& group
-) {
+CacheViewComp &
+CacheViewComp::fill(MsgBuffer &buffer, detail::cache::GroupData const &group)
+{
int i;
size_t n_routers = group.m_routers.size();
size_t n_caches = group.m_caches.size();
@@ -958,31 +1011,20 @@ CacheViewComp::fill(
set_field(&raw_t::m_router_count, m_base, n_routers);
// Set the pointer to the count of caches.
- m_cache_count = reinterpret_cast<uint32_t*>(
- m_base + sizeof(raw_t) + n_routers * sizeof(RouterIdElt)
- );
+ m_cache_count = reinterpret_cast<uint32_t *>(m_base + sizeof(raw_t) + n_routers * sizeof(RouterIdElt));
*m_cache_count = htonl(n_caches); // set the actual count.
// Fill routers.
i = 0;
- for ( detail::cache::RouterBag::const_iterator spot = group.m_routers.begin(),
- limit = group.m_routers.end();
- spot != limit;
- ++spot, ++i
- ) {
- this->routerElt(i)
- .setAddr(spot->m_addr)
- .setRecvId(spot->m_recv.m_sn)
- ;
+ for (detail::cache::RouterBag::const_iterator spot = group.m_routers.begin(), limit = group.m_routers.end(); spot != limit;
+ ++spot, ++i) {
+ this->routerElt(i).setAddr(spot->m_addr).setRecvId(spot->m_recv.m_sn);
}
// fill caches.
i = 0;
- for ( detail::cache::CacheBag::const_iterator spot = group.m_caches.begin(),
- limit = group.m_caches.end();
- spot != limit;
- ++spot, ++i
- ) {
+ for (detail::cache::CacheBag::const_iterator spot = group.m_caches.begin(), limit = group.m_caches.end(); spot != limit;
+ ++spot, ++i) {
this->setCacheAddr(i, spot->idAddr());
}
@@ -992,18 +1034,16 @@ CacheViewComp::fill(
}
int
-CacheViewComp::parse(MsgBuffer& buffer) {
+CacheViewComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
- m_cache_count = reinterpret_cast<uint32_t*>(
- m_base + sizeof(raw_t)
- + this->getRouterCount() * sizeof(RouterIdElt)
- );
+ if (PARSE_SUCCESS == zret) {
+ m_cache_count = reinterpret_cast<uint32_t *>(m_base + sizeof(raw_t) + this->getRouterCount() * sizeof(RouterIdElt));
size_t comp_size = this->calcSize(this->getRouterCount(), this->getCacheCount());
if (this->getLength() != comp_size - sizeof(super::raw_t))
zret = PARSE_COMP_WRONG_SIZE;
@@ -1014,92 +1054,98 @@ CacheViewComp::parse(MsgBuffer& buffer) {
return zret;
}
// ------------------------------------------------------
-AssignmentKeyElt&
-AssignInfoComp::keyElt() {
+AssignmentKeyElt &
+AssignInfoComp::keyElt()
+{
return access_field(&raw_t::m_key, m_base);
}
-AssignmentKeyElt const&
-AssignInfoComp::keyElt() const {
+AssignmentKeyElt const &
+AssignInfoComp::keyElt() const
+{
return access_field(&raw_t::m_key, m_base);
}
uint32_t
-AssignInfoComp::getKeyChangeNumber() const {
+AssignInfoComp::getKeyChangeNumber() const
+{
return access_field(&raw_t::m_key, m_base).getChangeNumber();
}
-AssignInfoComp&
-AssignInfoComp::setKeyChangeNumber(uint32_t n) {
+AssignInfoComp &
+AssignInfoComp::setKeyChangeNumber(uint32_t n)
+{
access_field(&raw_t::m_key, m_base).setChangeNumber(n);
return *this;
}
uint32_t
-AssignInfoComp::getKeyAddr() const {
+AssignInfoComp::getKeyAddr() const
+{
return access_field(&raw_t::m_key, m_base).getAddr();
}
-AssignInfoComp&
-AssignInfoComp::setKeyAddr(uint32_t addr) {
+AssignInfoComp &
+AssignInfoComp::setKeyAddr(uint32_t addr)
+{
access_field(&raw_t::m_key, m_base).setAddr(addr);
return *this;
}
uint32_t
-AssignInfoComp::getRouterCount() const {
+AssignInfoComp::getRouterCount() const
+{
return access_field(&raw_t::m_routers, m_base).getCount();
}
-RouterAssignElt&
-AssignInfoComp::routerElt(int idx) {
+RouterAssignElt &
+AssignInfoComp::routerElt(int idx)
+{
return access_field(&raw_t::m_routers, m_base).elt(idx);
}
uint32_t
-AssignInfoComp::getCacheCount() const {
+AssignInfoComp::getCacheCount() const
+{
return ntohl(*m_cache_count);
}
uint32_t
-AssignInfoComp::getCacheAddr(int idx) const {
- return m_cache_count[idx+1];
+AssignInfoComp::getCacheAddr(int idx) const
+{
+ return m_cache_count[idx + 1];
}
-AssignInfoComp&
-AssignInfoComp::setCacheAddr(int idx, uint32_t addr) {
- m_cache_count[idx+1] = addr;
+AssignInfoComp &
+AssignInfoComp::setCacheAddr(int idx, uint32_t addr)
+{
+ m_cache_count[idx + 1] = addr;
return *this;
}
size_t
-AssignInfoComp::calcSize(int n_routers, int n_caches) {
- return sizeof(raw_t)
- + RouterAssignListElt::calcVarSize(n_routers)
- + HashAssignElt::calcSize(n_caches)
- ;
+AssignInfoComp::calcSize(int n_routers, int n_caches)
+{
+ return sizeof(raw_t) + RouterAssignListElt::calcVarSize(n_routers) + HashAssignElt::calcSize(n_caches);
}
-uint32_t*
-AssignInfoComp::calcCacheCountPtr() {
- return reinterpret_cast<uint32_t*>(
- m_base + sizeof(raw_t)
- + access_field(&raw_t::m_routers, m_base).getVarSize()
- );
+uint32_t *
+AssignInfoComp::calcCacheCountPtr()
+{
+ return reinterpret_cast<uint32_t *>(m_base + sizeof(raw_t) + access_field(&raw_t::m_routers, m_base).getVarSize());
}
-AssignInfoComp::Bucket*
-AssignInfoComp::calcBucketPtr() {
- return reinterpret_cast<Bucket*>(reinterpret_cast<char*>(m_cache_count) + sizeof(uint32_t) * (1 + this->getCacheCount()));
+AssignInfoComp::Bucket *
+AssignInfoComp::calcBucketPtr()
+{
+ return reinterpret_cast<Bucket *>(reinterpret_cast<char *>(m_cache_count) + sizeof(uint32_t) * (1 + this->getCacheCount()));
}
-AssignInfoComp&
-AssignInfoComp::fill(
- MsgBuffer& buffer,
- detail::Assignment const& assign
-) {
- RouterAssignListElt const& ralist = assign.getRouterList();
- HashAssignElt const& ha = assign.getHash();
+AssignInfoComp &
+AssignInfoComp::fill(MsgBuffer &buffer, detail::Assignment const &assign)
+{
+ RouterAssignListElt const &ralist = assign.getRouterList();
+ HashAssignElt const &ha = assign.getHash();
size_t n_routers = ralist.getCount();
size_t n_caches = ha.getCount();
size_t comp_size = this->calcSize(n_routers, n_caches);
@@ -1123,14 +1169,15 @@ AssignInfoComp::fill(
}
int
-AssignInfoComp::parse(MsgBuffer& buffer) {
+AssignInfoComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < HEADER_SIZE)
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
int n_routers = this->getRouterCount();
int n_caches;
m_cache_count = this->calcCacheCountPtr();
@@ -1143,54 +1190,53 @@ AssignInfoComp::parse(MsgBuffer& buffer) {
buffer.use(comp_size);
}
}
- if (PARSE_SUCCESS != zret) m_base = 0;
+ if (PARSE_SUCCESS != zret)
+ m_base = 0;
return zret;
}
-AssignmentKeyElt&
-AltAssignComp::keyElt() {
+AssignmentKeyElt &
+AltAssignComp::keyElt()
+{
return access_field(&raw_t::m_key, m_base);
}
-AssignmentKeyElt const&
-AltAssignComp::keyElt() const {
+AssignmentKeyElt const &
+AltAssignComp::keyElt() const
+{
return access_field(&raw_t::m_key, m_base);
}
-void*
-AltAssignComp::calcVarPtr() {
- return reinterpret_cast<void*>(
- m_base + sizeof(raw_t)
- + access_field(&raw_t::m_routers, m_base).getVarSize()
- );
+void *
+AltAssignComp::calcVarPtr()
+{
+ return reinterpret_cast<void *>(m_base + sizeof(raw_t) + access_field(&raw_t::m_routers, m_base).getVarSize());
}
uint32_t
-AltAssignComp::getRouterCount() const {
+AltAssignComp::getRouterCount() const
+{
return access_field(&raw_t::m_routers, m_base).getCount();
}
uint32_t
-AltHashAssignComp::getCacheCount() const {
+AltHashAssignComp::getCacheCount() const
+{
return ntohl(*m_cache_count);
}
size_t
-AltHashAssignComp::calcSize(int n_routers, int n_caches) {
- return sizeof(raw_t)
- + RouterAssignListElt::calcVarSize(n_routers)
- + HashAssignElt::calcSize(n_caches)
- ;
+AltHashAssignComp::calcSize(int n_routers, int n_caches)
+{
+ return sizeof(raw_t) + RouterAssignListElt::calcVarSize(n_routers) + HashAssignElt::calcSize(n_caches);
}
-AltHashAssignComp&
-AltHashAssignComp::fill(
- MsgBuffer& buffer,
- detail::Assignment const& assign
-) {
- RouterAssignListElt const& ralist = assign.getRouterList();
- HashAssignElt const& ha = assign.getHash();
+AltHashAssignComp &
+AltHashAssignComp::fill(MsgBuffer &buffer, detail::Assignment const &assign)
+{
+ RouterAssignListElt const &ralist = assign.getRouterList();
+ HashAssignElt const &ha = assign.getHash();
size_t n_routers = ralist.getCount();
size_t n_caches = ha.getCount();
size_t comp_size = this->calcSize(n_routers, n_caches);
@@ -1203,12 +1249,11 @@ AltHashAssignComp::fill(
this->setType(COMP_TYPE)
.setLength(comp_size - HEADER_SIZE)
.setAssignType(ALT_HASH_ASSIGNMENT)
- .setAssignLength(comp_size - HEADER_SIZE - sizeof(local_header_t))
- ;
+ .setAssignLength(comp_size - HEADER_SIZE - sizeof(local_header_t));
this->keyElt() = assign.getKey();
memcpy(&(access_field(&raw_t::m_routers, m_base)), &ralist, ralist.getSize());
// Set the pointer to the count of caches and write the count.
- m_cache_count = static_cast<uint32_t*>(this->calcVarPtr());
+ m_cache_count = static_cast<uint32_t *>(this->calcVarPtr());
memcpy(m_cache_count, &ha, ha.getSize());
buffer.use(comp_size);
@@ -1217,17 +1262,18 @@ AltHashAssignComp::fill(
}
int
-AltHashAssignComp::parse(MsgBuffer& buffer) {
+AltHashAssignComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
int n_routers = this->getRouterCount();
int n_caches;
- m_cache_count = static_cast<uint32_t*>(this->calcVarPtr());
+ m_cache_count = static_cast<uint32_t *>(this->calcVarPtr());
n_caches = this->getCacheCount();
size_t comp_size = this->calcSize(n_routers, n_caches);
if (this->getLength() != comp_size - HEADER_SIZE)
@@ -1236,17 +1282,16 @@ AltHashAssignComp::parse(MsgBuffer& buffer) {
buffer.use(comp_size);
}
}
- if (PARSE_SUCCESS != zret) m_base = 0;
+ if (PARSE_SUCCESS != zret)
+ m_base = 0;
return zret;
}
-AltMaskAssignComp&
-AltMaskAssignComp::fill(
- MsgBuffer& buffer,
- detail::Assignment const& assign
-) {
- RouterAssignListElt const& ralist = assign.getRouterList();
- MaskAssignElt const& ma = assign.getMask();
+AltMaskAssignComp &
+AltMaskAssignComp::fill(MsgBuffer &buffer, detail::Assignment const &assign)
+{
+ RouterAssignListElt const &ralist = assign.getRouterList();
+ MaskAssignElt const &ma = assign.getMask();
size_t comp_size = sizeof(raw_t) + ralist.getVarSize() + ma.getSize();
if (buffer.getSpace() < comp_size)
@@ -1257,12 +1302,11 @@ AltMaskAssignComp::fill(
this->setType(COMP_TYPE)
.setLength(comp_size - HEADER_SIZE)
.setAssignType(ALT_MASK_ASSIGNMENT)
- .setAssignLength(comp_size - HEADER_SIZE - sizeof(local_header_t))
- ;
+ .setAssignLength(comp_size - HEADER_SIZE - sizeof(local_header_t));
this->keyElt() = assign.getKey();
memcpy(&(access_field(&raw_t::m_routers, m_base)), &ralist, ralist.getSize());
- m_mask_elt = static_cast<MaskAssignElt*>(this->calcVarPtr());
+ m_mask_elt = static_cast<MaskAssignElt *>(this->calcVarPtr());
memcpy(m_mask_elt, &ma, ma.getSize());
buffer.use(comp_size);
@@ -1271,16 +1315,17 @@ AltMaskAssignComp::fill(
}
int
-AltMaskAssignComp::parse(MsgBuffer& buffer) {
+AltMaskAssignComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
- RouterAssignListElt* ralist = &(access_field(&raw_t::m_routers, m_base));
- m_mask_elt = static_cast<MaskAssignElt*>(this->calcVarPtr());
+ if (PARSE_SUCCESS == zret) {
+ RouterAssignListElt *ralist = &(access_field(&raw_t::m_routers, m_base));
+ m_mask_elt = static_cast<MaskAssignElt *>(this->calcVarPtr());
size_t comp_size = sizeof(raw_t) + ralist->getVarSize() + m_mask_elt->getSize();
if (this->getLength() != comp_size - HEADER_SIZE)
zret = PARSE_COMP_WRONG_SIZE;
@@ -1288,40 +1333,47 @@ AltMaskAssignComp::parse(MsgBuffer& buffer) {
buffer.use(comp_size);
}
}
- if (PARSE_SUCCESS != zret) m_base = 0;
+ if (PARSE_SUCCESS != zret)
+ m_base = 0;
return zret;
}
// ------------------------------------------------------
CmdComp::cmd_t
-CmdComp::getCmd() const {
+CmdComp::getCmd() const
+{
return static_cast<cmd_t>(get_field(&raw_t::m_cmd, m_base));
}
-CmdComp&
-CmdComp::setCmd(cmd_t cmd) {
+CmdComp &
+CmdComp::setCmd(cmd_t cmd)
+{
set_field(&raw_t::m_cmd, m_base, cmd);
return *this;
}
uint32_t
-CmdComp::getCmdData() const {
+CmdComp::getCmdData() const
+{
return get_field(&raw_t::m_cmd_data, m_base);
}
-CmdComp&
-CmdComp::setCmdData(uint32_t data) {
+CmdComp &
+CmdComp::setCmdData(uint32_t data)
+{
set_field(&raw_t::m_cmd_data, m_base, data);
return *this;
}
inline size_t
-CmdComp::calcSize() {
+CmdComp::calcSize()
+{
return sizeof(raw_t);
}
-CmdComp&
-CmdComp::fill(MsgBuffer& buffer, cmd_t cmd, uint32_t data) {
+CmdComp &
+CmdComp::fill(MsgBuffer &buffer, cmd_t cmd, uint32_t data)
+{
size_t comp_size = this->calcSize();
if (buffer.getSpace() < comp_size)
@@ -1329,26 +1381,23 @@ CmdComp::fill(MsgBuffer& buffer, cmd_t cmd, uint32_t data) {
m_base = buffer.getTail();
- this->setType(COMP_TYPE)
- .setCmd(cmd)
- .setCmdData(data)
- .setLength(sizeof(raw_t) - sizeof(super::raw_t))
- ;
+ this->setType(COMP_TYPE).setCmd(cmd).setCmdData(data).setLength(sizeof(raw_t) - sizeof(super::raw_t));
// Command length is always the same.
set_field(&raw_t::m_length, m_base, sizeof(uint32_t));
-// reinterpret_cast<raw_t*>(m_base)->m_length = htons(sizeof(uint32_t));
+ // reinterpret_cast<raw_t*>(m_base)->m_length = htons(sizeof(uint32_t));
return *this;
}
int
-CmdComp::parse(MsgBuffer& buffer) {
+CmdComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
if (this->getLength() + sizeof(super::raw_t) != this->calcSize())
zret = PARSE_COMP_WRONG_SIZE;
}
@@ -1356,27 +1405,31 @@ CmdComp::parse(MsgBuffer& buffer) {
return zret;
}
// ------------------------------------------------------
-CapabilityElt&
-CapComp::elt(int idx) {
+CapabilityElt &
+CapComp::elt(int idx)
+{
return access_array<CapabilityElt>(m_base + sizeof(super::raw_t))[idx];
}
-CapabilityElt const&
-CapComp::elt(int idx) const {
+CapabilityElt const &
+CapComp::elt(int idx) const
+{
return access_array<CapabilityElt>(m_base + sizeof(super::raw_t))[idx];
}
void
-CapComp::cache() const {
+CapComp::cache() const
+{
uint32_t x; // scratch for bounds checking.
// Reset all values.
m_packet_forward = ServiceGroup::NO_PACKET_STYLE;
m_packet_return = ServiceGroup::NO_PACKET_STYLE;
m_cache_assign = ServiceGroup::NO_CACHE_ASSIGN_STYLE;
- if (!m_base) return; // No data, everything is default.
+ if (!m_base)
+ return; // No data, everything is default.
// Load from data.
- for ( uint32_t i = 0, n = this->getEltCount() ; i < n ; ++i ) {
- CapabilityElt const& elt = this->elt(i);
+ for (uint32_t i = 0, n = this->getEltCount(); i < n; ++i) {
+ CapabilityElt const &elt = this->elt(i);
switch (elt.getCapType()) {
case CapabilityElt::PACKET_FORWARD_METHOD:
x = elt.getCapData();
@@ -1401,8 +1454,9 @@ CapComp::cache() const {
m_cached = true;
}
-CapComp&
-CapComp::fill(MsgBuffer& buffer, int n) {
+CapComp &
+CapComp::fill(MsgBuffer &buffer, int n)
+{
size_t comp_size = this->calcSize(n);
m_cached = false;
@@ -1418,15 +1472,16 @@ CapComp::fill(MsgBuffer& buffer, int n) {
}
int
-CapComp::parse(MsgBuffer& buffer) {
+CapComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
m_cached = false;
- if (buffer.getSpace()< sizeof(raw_t))
+ if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
// No explicit count, compute it from length.
m_count = this->getLength() / sizeof(CapabilityElt);
buffer.use(this->getLength() + sizeof(super::raw_t));
@@ -1436,9 +1491,10 @@ CapComp::parse(MsgBuffer& buffer) {
}
// ------------------------------------------------------
int
-QueryComp::parse(MsgBuffer& buffer) {
+QueryComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
- if (buffer.getSpace()< sizeof(raw_t))
+ if (buffer.getSpace() < sizeof(raw_t))
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
@@ -1450,14 +1506,16 @@ QueryComp::parse(MsgBuffer& buffer) {
}
// ------------------------------------------------------
uint32_t
-AssignMapComp::getCount() const {
+AssignMapComp::getCount() const
+{
return access_field(&raw_t::m_assign, m_base).getCount();
}
-AssignMapComp&
-AssignMapComp::fill(MsgBuffer& buffer, detail::Assignment const& assign) {
+AssignMapComp &
+AssignMapComp::fill(MsgBuffer &buffer, detail::Assignment const &assign)
+{
size_t comp_size = sizeof(raw_t);
- MaskAssignElt const& ma = assign.getMask();
+ MaskAssignElt const &ma = assign.getMask();
size_t ma_size = ma.getSize(); // Not constant time.
// Can't be precise, but we need at least one mask/value set with
@@ -1469,41 +1527,38 @@ AssignMapComp::fill(MsgBuffer& buffer, detail::Assignment const& assign) {
memcpy(&(access_field(&raw_t::m_assign, m_base)), &ma, ma_size);
comp_size += ma_size - sizeof(ma);
- this->setType(COMP_TYPE)
- .setLength(comp_size - HEADER_SIZE)
- ;
+ this->setType(COMP_TYPE).setLength(comp_size - HEADER_SIZE);
buffer.use(comp_size);
return *this;
}
int
-AssignMapComp::parse(MsgBuffer& buffer) {
+AssignMapComp::parse(MsgBuffer &buffer)
+{
int zret = PARSE_SUCCESS;
if (buffer.getSpace() < HEADER_SIZE)
zret = PARSE_BUFFER_TOO_SMALL;
else {
m_base = buffer.getTail();
zret = this->checkHeader(buffer, COMP_TYPE);
- if (PARSE_SUCCESS == zret ) {
+ if (PARSE_SUCCESS == zret) {
// TBD - Actually check the mask/value set data !!
buffer.use(this->getLength() + HEADER_SIZE);
}
}
- if (PARSE_SUCCESS != zret) m_base = 0;
+ if (PARSE_SUCCESS != zret)
+ m_base = 0;
return zret;
}
// ------------------------------------------------------
-detail::Assignment::Assignment()
- : m_key(0,0)
- , m_active(false)
- , m_router_list(0)
- , m_hash_assign(0)
- , m_mask_assign(0) {
+detail::Assignment::Assignment() : m_key(0, 0), m_active(false), m_router_list(0), m_hash_assign(0), m_mask_assign(0)
+{
}
bool
-detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
+detail::Assignment::fill(cache::GroupData &group, uint32_t addr)
+{
// Compute the last packet received times for the routers. For each
// cache, compute how many routers mentioned it in their last
// packet. Prepare an assignment from those caches. If there are no
@@ -1511,21 +1566,18 @@ detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
// mentioned by at least one router are purged.
size_t n_routers = group.m_routers.size(); // routers in group
- size_t n_caches = group.m_caches.size(); // caches in group
+ size_t n_caches = group.m_caches.size(); // caches in group
// We need both routers and caches to do something useful.
- if (! (n_routers && n_caches)) return false;
+ if (!(n_routers && n_caches))
+ return false;
// Iteration vars.
size_t cdx, rdx;
- cache::RouterBag::iterator rspot,
- rbegin = group.m_routers.begin(),
- rend = group.m_routers.end();
- cache::CacheBag::iterator cspot,
- cbegin = group.m_caches.begin(),
- cend = group.m_caches.end();
-
- size_t nr[n_caches]; // validity check counts.
+ cache::RouterBag::iterator rspot, rbegin = group.m_routers.begin(), rend = group.m_routers.end();
+ cache::CacheBag::iterator cspot, cbegin = group.m_caches.begin(), cend = group.m_caches.end();
+
+ size_t nr[n_caches]; // validity check counts.
memset(nr, 0, sizeof(nr)); // Set counts to zero.
// Guess at size of serialization buffer. For the router list and
@@ -1544,7 +1596,7 @@ detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
// Set assignment key
m_key.setAddr(addr).setChangeNumber(group.m_generation);
- m_router_list = reinterpret_cast<RouterAssignListElt*>(m_buffer.getBase());
+ m_router_list = reinterpret_cast<RouterAssignListElt *>(m_buffer.getBase());
new (m_router_list) RouterAssignListElt(n_routers);
// For each router, update the assignment and run over the caches
@@ -1552,15 +1604,11 @@ detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
// recent packet. Note that the router data gets updated from
// ISeeYou message processing as well, this is more of an initial
// setup.
- for ( rdx = 0, rspot = rbegin ; rspot != rend ; ++rspot, ++rdx ) {
+ for (rdx = 0, rspot = rbegin; rspot != rend; ++rspot, ++rdx) {
// Update router assignment.
- m_router_list->elt(rdx)
- .setChangeNumber(rspot->m_generation)
- .setAddr(rspot->m_addr)
- .setRecvId(rspot->m_recv.m_sn)
- ;
+ m_router_list->elt(rdx).setChangeNumber(rspot->m_generation).setAddr(rspot->m_addr).setRecvId(rspot->m_recv.m_sn);
// Check cache validity.
- for ( cdx = 0, cspot = cbegin ; cspot != cend ; ++cspot, ++cdx ) {
+ for (cdx = 0, cspot = cbegin; cspot != cend; ++cspot, ++cdx) {
if (cspot->m_src[rdx].m_time == rspot->m_recv.m_time)
++(nr[cdx]);
}
@@ -1568,19 +1616,19 @@ detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
size_t k = m_router_list->getSize();
m_buffer.use(k);
- m_hash_assign = reinterpret_cast<HashAssignElt*>(m_buffer.getTail());
+ m_hash_assign = reinterpret_cast<HashAssignElt *>(m_buffer.getTail());
// If the nr value is 0, then the cache was not included in any
// last packet, so it should be discarded. A cache is valid if
// nr is n_routers, indicating that every router mentioned it.
int v_caches = 0; // valid caches
- for ( cdx = 0, cspot = cbegin ; cspot != cend ; ++cspot, ++cdx )
+ for (cdx = 0, cspot = cbegin; cspot != cend; ++cspot, ++cdx)
if (nr[cdx] == n_routers) {
m_hash_assign->setAddr(cdx, cspot->idAddr());
++v_caches;
}
- if (! v_caches) { // no valid caches.
+ if (!v_caches) { // no valid caches.
log(LVL_INFO, "Attempted to generate cache assignment but no valid caches were found.");
return false;
}
@@ -1589,41 +1637,42 @@ detail::Assignment::fill(cache::GroupData& group, uint32_t addr) {
m_hash_assign->round_robin_assign();
m_buffer.use(m_hash_assign->getSize());
- m_mask_assign = reinterpret_cast<MaskAssignElt*>(m_buffer.getTail());
+ m_mask_assign = reinterpret_cast<MaskAssignElt *>(m_buffer.getTail());
new (m_mask_assign) MaskAssignElt;
// For now, hardwire everything to first cache.
// We have plenty of space, but will need to check if we do something
// more complex here.
- m_mask_assign->init(0,0,0,0)->addValue(m_hash_assign->getAddr(0),0,0,0,0);
+ 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);
+ logf(LVL_INFO, "Generated assignment for group %d with %d routers, %d valid caches.", group.m_svc.getSvcId(), n_routers,
+ v_caches);
return true;
}
// ------------------------------------------------------
void
-BaseMsg::setBuffer(MsgBuffer const& buffer) {
+BaseMsg::setBuffer(MsgBuffer const &buffer)
+{
m_buffer = buffer;
}
void
-BaseMsg::finalize() {
+BaseMsg::finalize()
+{
m_header.setLength(m_buffer.getCount() - m_header.calcSize());
m_security.secure(m_buffer);
}
bool
-BaseMsg::validateSecurity() const {
+BaseMsg::validateSecurity() const
+{
return m_security.validate(m_buffer);
}
// ------------------------------------------------------
void
-HereIAmMsg::fill(
- detail::cache::GroupData const& group,
- CacheIdBox const& cache_id,
- SecurityOption sec_opt
-) {
+HereIAmMsg::fill(detail::cache::GroupData const &group, CacheIdBox const &cache_id, SecurityOption sec_opt)
+{
m_header.fill(m_buffer, HERE_I_AM);
m_security.fill(m_buffer, sec_opt);
m_service.fill(m_buffer, group.m_svc);
@@ -1632,54 +1681,58 @@ HereIAmMsg::fill(
}
void
-HereIAmMsg::fill_caps(
- detail::cache::RouterData const& router
-) {
+HereIAmMsg::fill_caps(detail::cache::RouterData const &router)
+{
if (router.m_send_caps) {
m_capabilities.fill(m_buffer, 3);
- m_capabilities.elt(0) =
- CapabilityElt(CapabilityElt::PACKET_FORWARD_METHOD, router.m_packet_forward);
- m_capabilities.elt(1) =
- CapabilityElt(CapabilityElt::CACHE_ASSIGNMENT_METHOD, router.m_cache_assign);
- m_capabilities.elt(2) =
- CapabilityElt(CapabilityElt::PACKET_RETURN_METHOD, router.m_packet_return);
+ m_capabilities.elt(0) = CapabilityElt(CapabilityElt::PACKET_FORWARD_METHOD, router.m_packet_forward);
+ m_capabilities.elt(1) = CapabilityElt(CapabilityElt::CACHE_ASSIGNMENT_METHOD, router.m_cache_assign);
+ m_capabilities.elt(2) = CapabilityElt(CapabilityElt::PACKET_RETURN_METHOD, router.m_packet_return);
}
}
int
-HereIAmMsg::parse(ts::Buffer const& buffer) {
+HereIAmMsg::parse(ts::Buffer const &buffer)
+{
int zret;
this->setBuffer(buffer);
- if (!m_buffer.getBase()) return -EINVAL;
+ if (!m_buffer.getBase())
+ return -EINVAL;
zret = m_header.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
- if (HERE_I_AM != m_header.getType()) return PARSE_MSG_WRONG_TYPE;
+ if (PARSE_SUCCESS != zret)
+ return zret;
+ if (HERE_I_AM != m_header.getType())
+ return PARSE_MSG_WRONG_TYPE;
// Time to look for components.
zret = m_security.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_service.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_cache_id.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_cache_view.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
// These are optional so failures can be ignored.
- if (m_buffer.getSpace()) m_capabilities.parse(m_buffer);
- if (m_buffer.getSpace()) m_command.parse(m_buffer);
+ if (m_buffer.getSpace())
+ m_capabilities.parse(m_buffer);
+ if (m_buffer.getSpace())
+ m_command.parse(m_buffer);
return m_buffer.getSpace() ? PARSE_DATA_OVERRUN : PARSE_SUCCESS;
}
// ------------------------------------------------------
void
-RedirectAssignMsg::fill(
- detail::cache::GroupData const& group,
- SecurityOption sec_opt
-) {
+RedirectAssignMsg::fill(detail::cache::GroupData const &group, SecurityOption sec_opt)
+{
m_header.fill(m_buffer, REDIRECT_ASSIGN);
m_security.fill(m_buffer, sec_opt);
m_service.fill(m_buffer, group.m_svc);
@@ -1697,15 +1750,10 @@ RedirectAssignMsg::fill(
}
// ------------------------------------------------------
void
-ISeeYouMsg::fill(
- detail::router::GroupData const& group,
- SecurityOption sec_opt,
- detail::Assignment& /* assign ATS_UNUSED */,
- size_t to_caches,
- size_t n_routers,
- size_t n_caches,
- bool /* send_capabilities ATS_UNUSED */
-) {
+ISeeYouMsg::fill(detail::router::GroupData const &group, SecurityOption sec_opt, detail::Assignment & /* assign ATS_UNUSED */,
+ size_t to_caches, size_t n_routers, size_t n_caches, bool /* send_capabilities ATS_UNUSED */
+ )
+{
m_header.fill(m_buffer, I_SEE_YOU);
m_security.fill(m_buffer, sec_opt);
m_service.fill(m_buffer, group.m_svc);
@@ -1714,26 +1762,38 @@ ISeeYouMsg::fill(
}
int
-ISeeYouMsg::parse(ts::Buffer const& buffer) {
+ISeeYouMsg::parse(ts::Buffer const &buffer)
+{
int zret;
this->setBuffer(buffer);
- if (!m_buffer.getBase()) return -EINVAL;
+ if (!m_buffer.getBase())
+ return -EINVAL;
zret = m_header.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
- if (I_SEE_YOU != m_header.getType()) return PARSE_MSG_WRONG_TYPE;
+ if (PARSE_SUCCESS != zret)
+ return zret;
+ if (I_SEE_YOU != m_header.getType())
+ return PARSE_MSG_WRONG_TYPE;
// Time to look for components.
zret = m_security.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_service.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_router_id.parse(m_buffer);
- if (PARSE_SUCCESS != zret) { logf(LVL_DEBUG, "I_SEE_YOU: Invalid %d router id", zret); return zret; }
+ if (PARSE_SUCCESS != zret) {
+ logf(LVL_DEBUG, "I_SEE_YOU: Invalid %d 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); return zret; }
+ if (PARSE_SUCCESS != zret) {
+ logf(LVL_DEBUG, "I_SEE_YOU: Invalid %d router view", zret);
+ return zret;
+ }
// Optional components.
@@ -1756,23 +1816,30 @@ ISeeYouMsg::parse(ts::Buffer const& buffer) {
}
// ------------------------------------------------------
int
-RemovalQueryMsg::parse(ts::Buffer const& buffer) {
+RemovalQueryMsg::parse(ts::Buffer const &buffer)
+{
int zret;
this->setBuffer(buffer);
- if (!m_buffer.getBase()) return -EINVAL;
+ if (!m_buffer.getBase())
+ return -EINVAL;
zret = m_header.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
- if (REMOVAL_QUERY != m_header.getType()) return PARSE_MSG_WRONG_TYPE;
+ if (PARSE_SUCCESS != zret)
+ return zret;
+ if (REMOVAL_QUERY != m_header.getType())
+ return PARSE_MSG_WRONG_TYPE;
// Get the components.
zret = m_security.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_service.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
zret = m_query.parse(m_buffer);
- if (PARSE_SUCCESS != zret) return zret;
+ if (PARSE_SUCCESS != zret)
+ return zret;
return m_buffer.getSpace() ? PARSE_DATA_OVERRUN : PARSE_SUCCESS;
}
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/65477944/lib/wccp/WccpStatic.cc
----------------------------------------------------------------------
diff --git a/lib/wccp/WccpStatic.cc b/lib/wccp/WccpStatic.cc
index db26418..d0fd91e 100644
--- a/lib/wccp/WccpStatic.cc
+++ b/lib/wccp/WccpStatic.cc
@@ -20,25 +20,26 @@
limitations under the License.
*/
-# include "WccpLocal.h"
-# include "WccpMeta.h"
-# include "ink_error.h"
-# include "ink_defs.h"
+#include "WccpLocal.h"
+#include "WccpMeta.h"
+#include "ink_error.h"
+#include "ink_defs.h"
/* Solaris considers SIOCGIFCONF obsolete and only defines it if
* BSD compatibility activated. */
-# if defined(solaris)
-# define BSD_COMP
-# endif
-# include <sys/ioctl.h>
-# include <sys/socket.h>
-# include <net/if.h>
-# include <stdarg.h>
-# include <string.h>
-# include <errno.h>
-# include <stdio.h>
-
-namespace wccp {
+#if defined(solaris)
+#define BSD_COMP
+#endif
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+namespace wccp
+{
// ------------------------------------------------------
// Compile time checks for internal consistency.
@@ -47,18 +48,19 @@ struct CompileTimeChecks {
static unsigned int const UINT8_SIZE = sizeof(uint8_t);
// A compiler error for the following line means that the size of
// an assignment bucket is incorrect. It must be exactly 1 byte.
- ts::TEST_IF_TRUE< BUCKET_SIZE == UINT8_SIZE > m_check_bucket_size;
+ ts::TEST_IF_TRUE<BUCKET_SIZE == UINT8_SIZE> m_check_bucket_size;
};
-ts::Errata::Code LVL_TMP = 1; ///< Temporary message.
+ts::Errata::Code LVL_TMP = 1; ///< Temporary message.
ts::Errata::Code LVL_FATAL = 3; ///< Fatal, cannot continue.
-ts::Errata::Code LVL_WARN = 2; ///< Significant, should be fixed.
-ts::Errata::Code LVL_INFO = 1; /// Interesting, not necessarily a problem.
+ts::Errata::Code LVL_WARN = 2; ///< Significant, should be fixed.
+ts::Errata::Code LVL_INFO = 1; /// Interesting, not necessarily a problem.
ts::Errata::Code LVL_DEBUG = 0; /// Debugging information.
// Find a valid local IP address given an open socket.
uint32_t
-Get_Local_Address(int s) {
+Get_Local_Address(int s)
+{
// If we can't find a good address in the first 255, just give up
// and make the user specify an address.
static int const N_REQ = 255;
@@ -70,52 +72,53 @@ Get_Local_Address(int s) {
conf.ifc_req = req;
if (0 == ioctl(s, SIOCGIFCONF, &conf)) {
int idx = 0;
- ifreq* ptr = req;
- ifreq* limit = req + (conf.ifc_len / sizeof(*req));
- for ( ; idx < N_REQ && ptr < limit ; ++idx, ++ptr ) {
- zret = reinterpret_cast<sockaddr_in&>(ptr->ifr_addr).sin_addr.s_addr;
- if ((zret & 0xFF) != 0x7F) return zret;
+ ifreq *ptr = req;
+ ifreq *limit = req + (conf.ifc_len / sizeof(*req));
+ for (; idx < N_REQ && ptr < limit; ++idx, ++ptr) {
+ zret = reinterpret_cast<sockaddr_in &>(ptr->ifr_addr).sin_addr.s_addr;
+ if ((zret & 0xFF) != 0x7F)
+ return zret;
}
}
return INADDR_ANY; // fail
}
// Cheap, can't even be used twice in the same argument list.
-char const* ip_addr_to_str(uint32_t addr) {
+char const *
+ip_addr_to_str(uint32_t addr)
+{
static char buff[4 * 3 + 3 + 1];
- unsigned char* octet = reinterpret_cast<unsigned char*>(&addr);
+ unsigned char *octet = reinterpret_cast<unsigned char *>(&addr);
sprintf(buff, "%d.%d.%d.%d", octet[0], octet[1], octet[2], octet[3]);
return buff;
}
// ------------------------------------------------------
-ts::Errata&
-log(ts::Errata& err, ts::Errata::Id id, ts::Errata::Code code, char const* text) {
+ts::Errata &
+log(ts::Errata &err, ts::Errata::Id id, ts::Errata::Code code, char const *text)
+{
err.push(id, code, text);
return err;
}
-ts::Errata&
-log(ts::Errata& err, ts::Errata::Code code, char const* text) {
+ts::Errata &
+log(ts::Errata &err, ts::Errata::Code code, char const *text)
+{
err.push(0, code, text);
return err;
}
ts::Errata
-log(ts::Errata::Code code, char const* text) {
+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
-) {
+ts::Errata &
+vlogf(ts::Errata &err, ts::Errata::Id id, ts::Errata::Code code, char const *format, va_list &rest)
+{
static size_t const SIZE = 8192;
char buffer[SIZE];
@@ -124,36 +127,34 @@ vlogf(
return err;
}
-ts::Errata&
-logf(
- ts::Errata& err,
- ts::Errata::Id id,
- ts::Errata::Code code,
- char const* format,
- ...
-) {
+ts::Errata &
+logf(ts::Errata &err, ts::Errata::Id id, ts::Errata::Code code, char const *format, ...)
+{
va_list rest;
va_start(rest, format);
return vlogf(err, id, code, format, rest);
}
ts::Errata
-logf(ts::Errata::Code code, char const* format, ...) {
+logf(ts::Errata::Code code, char const *format, ...)
+{
ts::Errata err;
va_list rest;
va_start(rest, format);
return vlogf(err, ts::Errata::Id(0), code, format, rest);
}
-ts::Errata&
-logf(ts::Errata& err, ts::Errata::Code code, char const* format, ...) {
+ts::Errata &
+logf(ts::Errata &err, ts::Errata::Code code, char const *format, ...)
+{
va_list rest;
va_start(rest, format);
return vlogf(err, ts::Errata::Id(0), code, format, rest);
}
ts::Errata
-log_errno(ts::Errata::Code code, char const* text) {
+log_errno(ts::Errata::Code code, char const *text)
+{
static size_t const SIZE = 1024;
char buffer[SIZE];
ATS_UNUSED_RETURN(strerror_r(errno, buffer, SIZE));
@@ -161,7 +162,8 @@ log_errno(ts::Errata::Code code, char const* text) {
}
ts::Errata
-vlogf_errno(ts::Errata::Code code, char const* format, va_list& rest) {
+vlogf_errno(ts::Errata::Code code, char const *format, va_list &rest)
+{
int e = errno; // Preserve value before making system calls.
ts::Errata err;
int n;
@@ -180,7 +182,8 @@ vlogf_errno(ts::Errata::Code code, char const* format, va_list& rest) {
}
ts::Errata
-logf_errno(ts::Errata::Code code, char const* format, ...) {
+logf_errno(ts::Errata::Code code, char const *format, ...)
+{
va_list rest;
va_start(rest, format);
return vlogf_errno(code, format, rest);
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/65477944/lib/wccp/WccpUtil.h
----------------------------------------------------------------------
diff --git a/lib/wccp/WccpUtil.h b/lib/wccp/WccpUtil.h
index 25bae9b..9e3d22c 100644
--- a/lib/wccp/WccpUtil.h
+++ b/lib/wccp/WccpUtil.h
@@ -20,22 +20,22 @@
limitations under the License.
*/
-# if !defined(ATS_WCCP_UTIL_HEADER)
-# define ATS_WCCP_UTIL_HEADER
+#if !defined(ATS_WCCP_UTIL_HEADER)
+#define ATS_WCCP_UTIL_HEADER
-# include <vector>
-
-namespace wccp {
+#include <vector>
+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_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.
-//@}
+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
@@ -48,72 +48,62 @@ extern ts::Errata::Code LVL_TMP; ///< For temporary debugging only.
//@{
/// 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.
-);
+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.
-);
+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.
-);
+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.
-);
+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.
-);
+ts::Errata log(ts::Errata::Code code, ///< Severity level.
+ char const *text ///< Message text.
+ );
/// Return an Errata populated with a printf styleformatted string.
/// Use message ID 0.
/// @return @a err.
-ts::Errata logf(
- ts::Errata::Code code, ///< Severity level.
- char const* format, ///< Message text.
- ...
-);
+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.
-);
+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.
-);
+ts::Errata logf_errno(ts::Errata::Code code, ///< Severity code.
+ char const *format, ///< Format string.
+ ... ///< Arguments for @a format.
+ );
//@}
// ------------------------------------------------------
@@ -130,61 +120,77 @@ logf_errno(
See access_field for completely unmediated access.
*/
-template < typename R>
-uint8_t get_field(uint8_t R::*M, char* buffer) {
- return reinterpret_cast<R*>(buffer)->*M;
+template <typename R>
+uint8_t
+get_field(uint8_t R::*M, char *buffer)
+{
+ return reinterpret_cast<R *>(buffer)->*M;
}
-template < typename R>
-uint16_t get_field(uint16_t R::*M, char* buffer) {
- return ntohs(reinterpret_cast<R*>(buffer)->*M);
+template <typename R>
+uint16_t
+get_field(uint16_t R::*M, char *buffer)
+{
+ return ntohs(reinterpret_cast<R *>(buffer)->*M);
}
-template < typename R>
-uint32_t get_field(uint32_t R::*M, char* buffer) {
- return ntohl(reinterpret_cast<R*>(buffer)->*M);
+template <typename R>
+uint32_t
+get_field(uint32_t R::*M, char *buffer)
+{
+ return ntohl(reinterpret_cast<R *>(buffer)->*M);
}
-template < typename R>
-void set_field(uint16_t R::*M, char* buffer, uint16_t value) {
- reinterpret_cast<R*>(buffer)->*M = htons(value);
+template <typename R>
+void
+set_field(uint16_t R::*M, char *buffer, uint16_t value)
+{
+ reinterpret_cast<R *>(buffer)->*M = htons(value);
}
-template < typename R>
-void set_field(uint32_t R::*M, char* buffer, uint32_t value) {
- reinterpret_cast<R*>(buffer)->*M = htonl(value);
+template <typename R>
+void
+set_field(uint32_t R::*M, char *buffer, uint32_t value)
+{
+ reinterpret_cast<R *>(buffer)->*M = htonl(value);
}
// IP address fields are kept locally in network order so
// we need variants without re-ordering.
// Also required for member structures.
-template < typename R, typename T >
-T& access_field(T R::*M, void* buffer) {
- return reinterpret_cast<R*>(buffer)->*M;
+template <typename R, typename T>
+T &
+access_field(T R::*M, void *buffer)
+{
+ return reinterpret_cast<R *>(buffer)->*M;
}
// Access an array @a T starting at @a buffer.
-template < typename T>
-T* access_array(void* buffer) {
- return reinterpret_cast<T*>(buffer);
+template <typename T>
+T *
+access_array(void *buffer)
+{
+ return reinterpret_cast<T *>(buffer);
}
// Access an array of @a T starting at @a buffer.
-template < typename T >
-T const* access_array(void const* buffer) {
- return reinterpret_cast<T const*>(buffer);
+template <typename T>
+T const *
+access_array(void const *buffer)
+{
+ return reinterpret_cast<T const *>(buffer);
}
/// Find an element in a vector by the value of a member.
/// @return An iterator for the element, or equal to @c end if not found.
-template <
- typename T, ///< Vector element type.
- typename V ///< Member type.
-> typename std::vector<T>::iterator
-find_by_member(
- std::vector<T>& container, ///< Vector with elements.
- V T::*member, ///< Pointer to member to compare.
- V const& value ///< Value to match.
-) {
+template <typename T, ///< Vector element type.
+ typename V ///< Member type.
+ >
+typename std::vector<T>::iterator
+find_by_member(std::vector<T> &container, ///< Vector with elements.
+ V T::*member, ///< Pointer to member to compare.
+ V const &value ///< Value to match.
+ )
+{
typename std::vector<T>::iterator spot = container.begin();
typename std::vector<T>::iterator limit = container.end();
while (spot != limit && (*spot).*member != value)
@@ -193,16 +199,14 @@ find_by_member(
}
// ------------------------------------------------------
/// Find a non-loop back IP address from an open socket.
-uint32_t Get_Local_Address(
- int s ///< Open socket.
-);
+uint32_t Get_Local_Address(int s ///< Open socket.
+ );
// ------------------------------------------------------
/// Cheap and dirty conversion to string for debugging.
/// @note Uses a static buffer so won't work across threads or
/// twice in the same argument list.
-char const* ip_addr_to_str(
- uint32_t addr ///< Address to convert.
-);
+char const *ip_addr_to_str(uint32_t addr ///< Address to convert.
+ );
/** Used for printing IP address.
@code
@@ -210,14 +214,12 @@ char const* ip_addr_to_str(
printf("IP address = " ATS_IP_PRINTF_CODE,ATS_IP_OCTETS(addr));
@endcode
*/
-# define ATS_IP_PRINTF_CODE "%d.%d.%d.%d"
-# define ATS_IP_OCTETS(x) \
- reinterpret_cast<unsigned char const*>(&(x))[0], \
- reinterpret_cast<unsigned char const*>(&(x))[1], \
- reinterpret_cast<unsigned char const*>(&(x))[2], \
- reinterpret_cast<unsigned char const*>(&(x))[3]
+#define ATS_IP_PRINTF_CODE "%d.%d.%d.%d"
+#define ATS_IP_OCTETS(x) \
+ reinterpret_cast<unsigned char const *>(&(x))[0], reinterpret_cast<unsigned char const *>(&(x))[1], \
+ reinterpret_cast<unsigned char const *>(&(x))[2], reinterpret_cast<unsigned char const *>(&(x))[3]
// ------------------------------------------------------
} // namespace Wccp
-# endif // define ATS_WCCP_UTIL_HEADER
+#endif // define ATS_WCCP_UTIL_HEADER
|