[people/ms/libloc.git] / src / libloc / private.h

/*
	libloc - A library to determine the location of someone on the Internet

	Copyright (C) 2017 IPFire Development Team <info@ipfire.org>

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	Lesser General Public License for more details.
*/

#ifndef LIBLOC_PRIVATE_H
#define LIBLOC_PRIVATE_H

#ifdef LIBLOC_PRIVATE

#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <syslog.h>

#include <libloc/libloc.h>

static inline void __attribute__((always_inline, format(printf, 2, 3)))
loc_log_null(struct loc_ctx *ctx, const char *format, ...) {}

#define loc_log_cond(ctx, prio, arg...) \
	do { \
		if (loc_get_log_priority(ctx) >= prio) \
			loc_log(ctx, prio, __FILE__, __LINE__, __FUNCTION__, ## arg); \
	} while (0)

#ifdef ENABLE_DEBUG
#  define DEBUG(ctx, arg...) loc_log_cond(ctx, LOG_DEBUG, ## arg)
#else
#  define DEBUG(ctx, arg...) loc_log_null(ctx, ## arg)
#endif

#define INFO(ctx, arg...) loc_log_cond(ctx, LOG_INFO, ## arg)
#define ERROR(ctx, arg...) loc_log_cond(ctx, LOG_ERR, ## arg)

#ifndef HAVE_SECURE_GETENV
#  ifdef HAVE___SECURE_GETENV
#    define secure_getenv __secure_getenv
#  else
#    define secure_getenv getenv
#  endif
#endif

#define LOC_EXPORT __attribute__ ((visibility("default")))

void loc_log(struct loc_ctx *ctx,
	int priority, const char *file, int line, const char *fn,
	const char *format, ...) __attribute__((format(printf, 6, 7)));

static inline int in6_addr_cmp(const struct in6_addr* a1, const struct in6_addr* a2) {
	for (unsigned int i = 0; i < 16; i++) {
		if (a1->s6_addr[i] > a2->s6_addr[i])
			return 1;

		else if (a1->s6_addr[i] < a2->s6_addr[i])
			return -1;
	}

	return 0;
}

static inline int in6_addr_get_bit(const struct in6_addr* address, unsigned int i) {
	return ((address->s6_addr[i / 8] >> (7 - (i % 8))) & 1);
}

static inline void in6_addr_set_bit(struct in6_addr* address, unsigned int i, unsigned int val) {
	address->s6_addr[i / 8] ^= (-val ^ address->s6_addr[i / 8]) & (1 << (7 - (i % 8)));
}

static inline struct in6_addr loc_prefix_to_bitmask(const unsigned int prefix) {
	struct in6_addr bitmask;

	for (unsigned int i = 0; i < 16; i++)
		bitmask.s6_addr[i] = 0;

	for (int i = prefix, j = 0; i > 0; i -= 8, j++) {
		if (i >= 8)
			bitmask.s6_addr[j] = 0xff;
		else
			bitmask.s6_addr[j] = 0xff << (8 - i);
	}

	return bitmask;
}

static inline unsigned int loc_address_bit_length(const struct in6_addr* address) {
	unsigned int length = 128;

	for (int octet = 0; octet <= 15; octet++) {
		if (address->s6_addr[octet]) {
			length -= __builtin_clz(address->s6_addr[octet]) - 24;
			break;
		} else
			length -= 8;
	}

	return length;
}

static inline struct in6_addr loc_address_and(
		const struct in6_addr* address, const struct in6_addr* bitmask) {
	struct in6_addr a;

	// Perform bitwise AND
	for (unsigned int i = 0; i < 4; i++)
		a.s6_addr32[i] = address->s6_addr32[i] & bitmask->s6_addr32[i];

	return a;
}

static inline struct in6_addr loc_address_or(
		const struct in6_addr* address, const struct in6_addr* bitmask) {
	struct in6_addr a;

	// Perform bitwise OR
	for (unsigned int i = 0; i < 4; i++)
		a.s6_addr32[i] = address->s6_addr32[i] | ~bitmask->s6_addr32[i];

	return a;
}

static inline void hexdump(struct loc_ctx* ctx, const void* addr, size_t len) {
	char buffer_hex[16 * 3 + 6];
	char buffer_ascii[17];

	unsigned int i = 0;
	unsigned char* p = (unsigned char*)addr;

	DEBUG(ctx, "Dumping %zu byte(s)\n", len);

	// Process every byte in the data
	for (i = 0; i < len; i++) {
		// Multiple of 16 means new line (with line offset)
		if ((i % 16) == 0) {
			// Just don't print ASCII for the zeroth line
			if (i != 0)
				DEBUG(ctx, "  %s %s\n", buffer_hex, buffer_ascii);

			// Output the offset.
			sprintf(buffer_hex, "%04x ", i);
		}

		// Now the hex code for the specific character
		sprintf(buffer_hex + 5 + ((i % 16) * 3), " %02x", p[i]);

		// And store a printable ASCII character for later
		if ((p[i] < 0x20) || (p[i] > 0x7e))
			buffer_ascii[i % 16] = '.';
		else
			buffer_ascii[i % 16] = p[i];

		// Terminate string
		buffer_ascii[(i % 16) + 1] = '\0';
	}

	// Pad out last line if not exactly 16 characters
	while ((i % 16) != 0) {
		sprintf(buffer_hex + 5 + ((i % 16) * 3), "   ");
		i++;
	}

	// And print the final bit
	DEBUG(ctx, "  %s %s\n", buffer_hex, buffer_ascii);
}

#endif
#endif
Commit	Line	Data
46aded9a MT	1	/*
	2	libloc - A library to determine the location of someone on the Internet
	3
	4	Copyright (C) 2017 IPFire Development Team <info@ipfire.org>
	5
	6	This library is free software; you can redistribute it and/or
	7	modify it under the terms of the GNU Lesser General Public
	8	License as published by the Free Software Foundation; either
	9	version 2.1 of the License, or (at your option) any later version.
	10
	11	This library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	Lesser General Public License for more details.
	15	*/
	16
	17	#ifndef LIBLOC_PRIVATE_H
	18	#define LIBLOC_PRIVATE_H
	19
1a3cb1b4 MT	20	#ifdef LIBLOC_PRIVATE
1a3cb1b4 MT	21
2a30e4de	22	#include <netinet/in.h>
46aded9a	23	#include <stdbool.h>
726f9984	24	#include <stdio.h>
46aded9a MT	25	#include <syslog.h>
46aded9a MT	26
c12a1385	27	#include <libloc/libloc.h>
46aded9a MT	28
	29	static inline void __attribute__((always_inline, format(printf, 2, 3)))
	30	loc_log_null(struct loc_ctx ctx, const char format, ...) {}
	31
	32	#define loc_log_cond(ctx, prio, arg...) \
	33	do { \
	34	if (loc_get_log_priority(ctx) >= prio) \
	35	loc_log(ctx, prio, __FILE__, __LINE__, __FUNCTION__, ## arg); \
	36	} while (0)
	37
	38	#ifdef ENABLE_DEBUG
	39	# define DEBUG(ctx, arg...) loc_log_cond(ctx, LOG_DEBUG, ## arg)
	40	#else
	41	# define DEBUG(ctx, arg...) loc_log_null(ctx, ## arg)
	42	#endif
	43
	44	#define INFO(ctx, arg...) loc_log_cond(ctx, LOG_INFO, ## arg)
	45	#define ERROR(ctx, arg...) loc_log_cond(ctx, LOG_ERR, ## arg)
	46
	47	#ifndef HAVE_SECURE_GETENV
	48	# ifdef HAVE___SECURE_GETENV
	49	# define secure_getenv __secure_getenv
	50	# else
d0cef0e8	51	# define secure_getenv getenv
46aded9a MT	52	# endif
	53	#endif
	54
	55	#define LOC_EXPORT __attribute__ ((visibility("default")))
	56
	57	void loc_log(struct loc_ctx *ctx,
	58	int priority, const char file, int line, const char fn,
	59	const char *format, ...) __attribute__((format(printf, 6, 7)));
	60
2a30e4de	61	static inline int in6_addr_cmp(const struct in6_addr* a1, const struct in6_addr* a2) {
e14564aa MT	62	for (unsigned int i = 0; i < 16; i++) {
	63	if (a1->s6_addr[i] > a2->s6_addr[i])
	64	return 1;
	65
	66	else if (a1->s6_addr[i] < a2->s6_addr[i])
	67	return -1;
	68	}
	69
	70	return 0;
2a30e4de MT	71	}
	72
	73	static inline int in6_addr_get_bit(const struct in6_addr* address, unsigned int i) {
20e3a06f	74	return ((address->s6_addr[i / 8] >> (7 - (i % 8))) & 1);
2a30e4de MT	75	}
	76
	77	static inline void in6_addr_set_bit(struct in6_addr* address, unsigned int i, unsigned int val) {
20e3a06f	78	address->s6_addr[i / 8] ^= (-val ^ address->s6_addr[i / 8]) & (1 << (7 - (i % 8)));
2a30e4de MT	79	}
2a30e4de MT	80
30f0f0ed MT	81	static inline struct in6_addr loc_prefix_to_bitmask(const unsigned int prefix) {
	82	struct in6_addr bitmask;
	83
	84	for (unsigned int i = 0; i < 16; i++)
	85	bitmask.s6_addr[i] = 0;
	86
	87	for (int i = prefix, j = 0; i > 0; i -= 8, j++) {
	88	if (i >= 8)
	89	bitmask.s6_addr[j] = 0xff;
	90	else
	91	bitmask.s6_addr[j] = 0xff << (8 - i);
	92	}
	93
	94	return bitmask;
	95	}
	96
f69e0c8b MT	97	static inline unsigned int loc_address_bit_length(const struct in6_addr* address) {
	98	unsigned int length = 128;
	99
	100	for (int octet = 0; octet <= 15; octet++) {
	101	if (address->s6_addr[octet]) {
	102	length -= __builtin_clz(address->s6_addr[octet]) - 24;
	103	break;
	104	} else
	105	length -= 8;
	106	}
	107
	108	return length;
	109	}
	110
30f0f0ed MT	111	static inline struct in6_addr loc_address_and(
	112	const struct in6_addr* address, const struct in6_addr* bitmask) {
	113	struct in6_addr a;
	114
	115	// Perform bitwise AND
	116	for (unsigned int i = 0; i < 4; i++)
	117	a.s6_addr32[i] = address->s6_addr32[i] & bitmask->s6_addr32[i];
	118
	119	return a;
	120	}
	121
	122	static inline struct in6_addr loc_address_or(
	123	const struct in6_addr* address, const struct in6_addr* bitmask) {
	124	struct in6_addr a;
	125
	126	// Perform bitwise OR
	127	for (unsigned int i = 0; i < 4; i++)
	128	a.s6_addr32[i] = address->s6_addr32[i] \| ~bitmask->s6_addr32[i];
	129
	130	return a;
	131	}
	132
257626f5 MT	133	static inline void hexdump(struct loc_ctx* ctx, const void* addr, size_t len) {
	134	char buffer_hex[16 * 3 + 6];
	135	char buffer_ascii[17];
	136
	137	unsigned int i = 0;
	138	unsigned char* p = (unsigned char*)addr;
	139
356cabc1 MT	140	DEBUG(ctx, "Dumping %zu byte(s)\n", len);
356cabc1 MT	141
257626f5 MT	142	// Process every byte in the data
	143	for (i = 0; i < len; i++) {
	144	// Multiple of 16 means new line (with line offset)
	145	if ((i % 16) == 0) {
	146	// Just don't print ASCII for the zeroth line
	147	if (i != 0)
	148	DEBUG(ctx, " %s %s\n", buffer_hex, buffer_ascii);
	149
	150	// Output the offset.
	151	sprintf(buffer_hex, "%04x ", i);
	152	}
	153
	154	// Now the hex code for the specific character
	155	sprintf(buffer_hex + 5 + ((i % 16) * 3), " %02x", p[i]);
	156
	157	// And store a printable ASCII character for later
	158	if ((p[i] < 0x20) \|\| (p[i] > 0x7e))
	159	buffer_ascii[i % 16] = '.';
	160	else
	161	buffer_ascii[i % 16] = p[i];
	162
	163	// Terminate string
	164	buffer_ascii[(i % 16) + 1] = '\0';
	165	}
	166
	167	// Pad out last line if not exactly 16 characters
	168	while ((i % 16) != 0) {
	169	sprintf(buffer_hex + 5 + ((i % 16) * 3), " ");
	170	i++;
	171	}
	172
	173	// And print the final bit
	174	DEBUG(ctx, " %s %s\n", buffer_hex, buffer_ascii);
	175	}
	176
46aded9a	177	#endif
1a3cb1b4	178	#endif