congestvpn/util.hpp

#pragma once

#include <exception>
#include <string>
#include <netinet/in.h>

/* Debugging -- taken from babeld */

extern int debug;

#if defined(__GNUC__) && (__GNUC__ >= 3)
#define ATTRIBUTE(x) __attribute__ (x)
#define LIKELY(_x) __builtin_expect(!!(_x), 1)
#define UNLIKELY(_x) __builtin_expect(!!(_x), 0)
#else
#define ATTRIBUTE(x) /**/
#define LIKELY(_x) !!(_x)
#define UNLIKELY(_x) !!(_x)
#endif

#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
#define debugf(...) \
    do { \
        if(UNLIKELY(debug >= 2)) do_debugf(2, __VA_ARGS__);     \
    } while(0)
#define kdebugf(...) \
    do { \
        if(UNLIKELY(debug >= 3)) do_debugf(3, __VA_ARGS__);     \
    } while(0)
#elif defined __GNUC__
#define debugf(_args...) \
    do { \
        if(UNLIKELY(debug >= 2)) do_debugf(2, _args);   \
    } while(0)
#define kdebugf(_args...) \
    do { \
        if(UNLIKELY(debug >= 3)) do_debugf(3, _args);   \
    } while(0)
#else
static inline void debugf(const char *format, ...) { return; }
static inline void kdebugf(const char *format, ...) { return; }
#endif

void do_debugf(int level, const char *format, ...);


/** format_address -- taken from babeld */
const char* format_address(const unsigned char* address);

/** turns a value into a human-readable one, eg. "21.2 kB" */
const char* human_readable_unit(double value, const char* unit);


/** remove the upper bit from a microsecond timestamp, to conform with the
 * packet header timestamp format. */
inline uint32_t to_us_timestamp(uint32_t clock_output) {
    return clock_output & 0x7fffffff;
}


/** Max seconds that can be be represented in a microseconds timestamp, on 31
 * bits. */
const uint32_t MAX_USEC_DIFF = ((1U<<31) - 1) / (1000*1000) - 1;


/** Get a `struct timespec` difference, ie `t1 - t2`, as a new `struct
 * timespec`. Assumes `t1 >= t2`. */
void timespec_diff(
        const struct timespec t1, const struct timespec t2,
        struct timespec* result);

/** Get a `struct timespec` difference, ie `t1 - t2`, expressed in
 * microseconds. Assumes `t1 >= t2`. Capped to MAX_USEC_DIFF seconds. */
uint32_t timespec_us_diff(const struct timespec t1, const struct timespec t2);

/** Get the number of microseconds ellapsed since a `struct timespec`, based on
 * the monotonic clock */
uint32_t timespec_us_ellapsed(const struct timespec ref);

/** Get the current timestamp, in microseconds */
uint32_t current_us_timestamp();



/** in6_addr hash & equality */
namespace std {
    template<>
    class hash<in6_addr> {
        public:
            size_t operator()(const in6_addr& addr) const;
    };

    template<>
    class equal_to<in6_addr> {
        public:
            bool operator()(const in6_addr& lhs, const in6_addr& rhs) const;
    };
}



/** MsgException -- an exception bearing a passed explanation message
 *
 * If `is_perror` is true, then the `strerror` corresponding message is appened
 * to the message in `what()`.
 */
class MsgException : public std::exception {
    public:
        MsgException(const std::string& msg, int code=0, bool is_perror=false);
        int errcode() const noexcept { return _code; }
        const char* what() const noexcept { return _what.c_str(); };

    private:
        std::string _msg;
        int _code;
        std::string _what;
};