Add PW_TYPE_SIZE

Width of size_t and accepts SI unit suffixes i.e. 10M

src/include/conffile.h

@@ -82,6 +82,8 @@ typedef void _mismatch_int32;		//!< Dummy type used to indicate PW_TYPE_*/C type
 typedef void _mismatch_int32_m;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
 typedef void _mismatch_uint64;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
 typedef void _mismatch_uint64_m;	//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
+typedef void _mismatch_size;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
+typedef void _mismatch_size_m;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
 typedef void _mismatch_timeval;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
 typedef void _mismatch_timeval_m;	//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
 typedef void _mismatch_default;		//!< Dummy type used to indicate PW_TYPE_*/C type mismatch.
@@ -170,6 +172,10 @@ _Generic((_ct), \
 			_p, (_mismatch_uint64) 0), \
 	uint64_t **	: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_INTEGER64) && ((_t) & PW_TYPE_MULTI), \
 			_p, (_mismatch_uint64_m) 0), \
+	size_t *	: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SIZE) && !((_t) & PW_TYPE_MULTI), \
+			_p, (_mismatch_size) 0), \
+	size_t **	: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_SIZE) && ((_t) & PW_TYPE_MULTI), \
+			_p, (_mismatch_size) 0), \
 	_timeval_t *	: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_TIMEVAL) && !((_t) & PW_TYPE_MULTI), \
 			_p, (_mismatch_timeval) 0), \
 	_timeval_t **	: __builtin_choose_expr((PW_BASE_TYPE(_t) == PW_TYPE_TIMEVAL) && ((_t) & PW_TYPE_MULTI), \
@@ -265,6 +271,16 @@ _Generic((_ct), \
 #define PW_BASE_TYPE(_t)		(0xff & (_t))
 /* @} **/
 
+#define FR_SIZE_COND_CHECK(_name, _var, _cond, _new)\
+do {\
+	if (!(_cond)) {\
+		WARN("Ignoring \"" _name " = %zu\", forcing to \"" _name " = %zu\"", _var, _new);\
+		_var = _new;\
+	}\
+} while (0)
+
+#define FR_SIZE_BOUND_CHECK(_name, _var, _op, _bound) FR_SIZE_COND_CHECK(_name, _var, (_var _op _bound), _bound)
+
 #define FR_INTEGER_COND_CHECK(_name, _var, _cond, _new)\
 do {\
 	if (!(_cond)) {\

src/include/libradius.h

@@ -386,6 +386,8 @@ void		fr_timeval_divide(struct timeval *out, struct timeval const *in, int divis
 int		fr_timeval_cmp(struct timeval const *a, struct timeval const *b);
 void		fr_timespec_subtract(struct timespec *out, struct timespec const *end, struct timespec const *start);
 int		fr_timeval_from_str(struct timeval *out, char const *in);
+bool		fr_multiply(uintmax_t *result, uintmax_t lhs, uintmax_t rhs);
+int		fr_size_from_str(size_t *out, char const *str);
 int8_t		fr_pointer_cmp(void const *a, void const *b);
 void		fr_quick_sort(void const *to_sort[], int min_idx, int max_idx, fr_cmp_t cmp);
 /*

src/include/pair.h

@@ -76,6 +76,7 @@ struct value_data {
 		uint16_t		ushort;			//!< 16bit unsigned integer.
 		uint32_t		integer;		//!< 32bit unsigned integer.
 		uint64_t		integer64;		//!< 64bit unsigned integer.
+		size_t			size;			//!< System specific file/memory size.
 		int32_t			sinteger;		//!< 32bit signed integer.
 
 		uint8_t			ether[6];		//!< Ethernet (MAC) address.
@@ -183,6 +184,7 @@ typedef struct value_pair_raw {
 #define vp_ether	data.ether
 #define vp_signed	data.sinteger
 #define vp_integer64	data.integer64
+#define vp_size		data.size
 #define vp_ipv4prefix	data.ipv4prefix
 #define vp_decimal	data.decimal
 

src/include/radius.h

@@ -48,6 +48,8 @@ typedef enum {
 	PW_TYPE_SHORT,				//!< 16 Bit unsigned integer.
 	PW_TYPE_INTEGER,			//!< 32 Bit unsigned integer.
 	PW_TYPE_INTEGER64,			//!< 64 Bit unsigned integer.
+	PW_TYPE_SIZE,				//!< Unsigned integer capable of representing any memory
+						//!< address on the local system.
 	PW_TYPE_SIGNED,				//!< 32 Bit signed integer.
 
 	PW_TYPE_TIMEVAL,			//!< Time value (struct timeval), only for config items.
@@ -104,6 +106,7 @@ typedef enum {
 	case PW_TYPE_SHORT: \
 	case PW_TYPE_INTEGER: \
 	case PW_TYPE_INTEGER64: \
+	case PW_TYPE_SIZE: \
 	case PW_TYPE_SIGNED: \
 	case PW_TYPE_DATE
 

src/include/tmpl.h

@@ -356,6 +356,7 @@ do {\
 		 uint16_t *: PW_TYPE_SHORT, \
 		 uint32_t *: PW_TYPE_INTEGER, \
 		 uint64_t *: PW_TYPE_INTEGER64, \
+		 size_t *: PW_TYPE_SIZE, \
 		 struct timeval *: PW_TYPE_TIMEVAL)
 
 /** Expand a tmpl to a C type, using existing storage to hold variably sized types

src/lib/dict.c

@@ -109,6 +109,7 @@ const FR_NAME_NUMBER dict_attr_types[] = {
 	{ "short",		PW_TYPE_SHORT },
 	{ "integer",		PW_TYPE_INTEGER },
 	{ "integer64",		PW_TYPE_INTEGER64 },
+	{ "size",		PW_TYPE_SIZE },
 	{ "signed",        	PW_TYPE_SIGNED },
 
 	{ "decimal",		PW_TYPE_DECIMAL },
@@ -161,6 +162,7 @@ const size_t dict_attr_sizes[PW_TYPE_MAX + 1][2] = {
 	[PW_TYPE_SHORT]		= {2, 2},
 	[PW_TYPE_INTEGER]	= {4, 4},
 	[PW_TYPE_INTEGER64]	= {8, 8},
+	[PW_TYPE_SIZE]		= {sizeof(size_t), sizeof(size_t)},
 	[PW_TYPE_SIGNED]	= {4, 4},
 
 	[PW_TYPE_DATE]		= {4, 4},
@@ -1156,6 +1158,9 @@ int fr_dict_attr_add(fr_dict_t *dict, fr_dict_attr_t const *parent,
 		flags.length = 8;
 		break;
 
+	case PW_TYPE_SIZE:
+		flags.length = sizeof(size_t);
+
 	case PW_TYPE_ETHERNET:
 		flags.length = 6;
 		break;

src/lib/misc.c

@@ -1026,6 +1026,86 @@ int fr_timeval_from_str(struct timeval *out, char const *in)
 	return 0;
 }
 
+/** Multiple checking for overflow
+ *
+ * @param[out] result	of multiplication.
+ * @param[in] lhs	First operand.
+ * @param[in] rhs	Second operand.
+ *
+ * @return
+ *	- true multiplication overflowed.
+ *	- false multiplication did not overflow.
+ */
+bool fr_multiply(uint64_t *result, uint64_t lhs, uint64_t rhs)
+{
+        *result = lhs * rhs;
+
+        return rhs > 0 && (UINT64_MAX / rhs) < lhs;
+}
+
+int fr_size_from_str(size_t *out, char const *str)
+{
+	char		*q = NULL;
+	uint64_t	size;
+
+	*out = 0;
+
+	size = strtoull(str, &q, 10);
+	switch (tolower(q[0])) {
+	case 'n':		/* nibble */
+		if (size & 0x01) {
+			fr_strerror_printf("Sizes specified in nibbles must be an even number");
+			return -1;
+		}
+		size /= 2;
+		break;
+
+	case '\0':
+	case 'b':		/* byte */
+		break;
+
+	case 'k':		/* kilobyte */
+		if (fr_multiply(&size, size, 1024)) {
+		overflow:
+			fr_strerror_printf("Value must be less than %zu", (size_t)SIZE_MAX);
+			return -1;
+		}
+		break;
+
+	case 'm':		/* megabyte */
+		if (fr_multiply(&size, size, (1024 * 1024))) goto overflow;
+		break;
+
+	case 'g':		/* gigabyte */
+		if (fr_multiply(&size, size, (1024 * 1024 * 1024))) goto overflow;
+		break;
+
+	case 't':		/* terabyte */
+		if (fr_multiply(&size, size, (1024 * 1024 * 1024 * 1024))) goto overflow;
+		break;
+
+	default:
+		fr_strerror_printf("Unknown unit '%c'", *q);
+		return -1;
+	}
+
+	if ((q[0] != '\0') && (q[1] != '\0')) {
+		fr_strerror_printf("Trailing garbage in size string \"%s\"", str);
+		return -1;
+	}
+
+	if (size > SIZE_MAX) {
+		fr_strerror_printf("Value %" PRIu64 " is greater than the maximum "
+				   "file/memory size of this system (%zu)", size, (size_t)SIZE_MAX);
+
+		goto overflow;
+	}
+
+	*out = (size_t)size;
+
+	return 0;
+}
+
 /** Compares two pointers
  *
  * @param a first pointer to compare.

src/lib/pair.c

@@ -2294,6 +2294,7 @@ char *fr_pair_type_asprint(TALLOC_CTX *ctx, PW_TYPE type)
 		return talloc_typed_strdup(ctx, "_");
 
 	case PW_TYPE_INTEGER64:
+	case PW_TYPE_SIZE:
 	case PW_TYPE_SIGNED:
 	case PW_TYPE_BYTE:
 	case PW_TYPE_SHORT:

src/lib/radius_encode.c

@@ -495,6 +495,7 @@ ssize_t fr_radius_encode_value_hton(uint8_t *out, size_t outlen, VALUE_PAIR cons
 	case PW_TYPE_VENDOR:
 	case PW_TYPE_TLV:
 	case PW_TYPE_STRUCT:
+	case PW_TYPE_SIZE:
 	case PW_TYPE_TIMEVAL:
 	case PW_TYPE_DECIMAL:
 	case PW_TYPE_MAX:

src/lib/value.c

@@ -43,6 +43,7 @@ size_t const value_data_field_sizes[] = {
 	[PW_TYPE_SHORT]		= SIZEOF_MEMBER(value_data_t, ushort),
 	[PW_TYPE_INTEGER]	= SIZEOF_MEMBER(value_data_t, integer),
 	[PW_TYPE_INTEGER64]	= SIZEOF_MEMBER(value_data_t, integer64),
+	[PW_TYPE_SIZE]		= SIZEOF_MEMBER(value_data_t, size),
 	[PW_TYPE_SIGNED]	= SIZEOF_MEMBER(value_data_t, sinteger),
 	[PW_TYPE_TIMEVAL]	= SIZEOF_MEMBER(value_data_t, timeval),
 	[PW_TYPE_DECIMAL]	= SIZEOF_MEMBER(value_data_t, decimal),
@@ -71,6 +72,7 @@ size_t const value_data_offsets[] = {
 	[PW_TYPE_SHORT]		= offsetof(value_data_t, ushort),
 	[PW_TYPE_INTEGER]	= offsetof(value_data_t, integer),
 	[PW_TYPE_INTEGER64]	= offsetof(value_data_t, integer64),
+	[PW_TYPE_SIZE]		= offsetof(value_data_t, size),
 	[PW_TYPE_SIGNED]	= offsetof(value_data_t, sinteger),
 	[PW_TYPE_TIMEVAL]	= offsetof(value_data_t, timeval),
 	[PW_TYPE_DECIMAL]	= offsetof(value_data_t, decimal),
@@ -144,7 +146,6 @@ int value_data_cmp(PW_TYPE a_type, value_data_t const *a,
 		CHECK(byte);
 		break;
 
-
 	case PW_TYPE_SHORT:
 		CHECK(ushort);
 		break;
@@ -165,6 +166,10 @@ int value_data_cmp(PW_TYPE a_type, value_data_t const *a,
 		CHECK(integer64);
 		break;
 
+	case PW_TYPE_SIZE:
+		CHECK(size);
+		break;
+
 	case PW_TYPE_TIMEVAL:
 		compare = fr_timeval_cmp(&a->timeval, &b->timeval);
 		break;
@@ -469,6 +474,7 @@ int value_data_cmp_op(FR_TOKEN op,
 	case PW_TYPE_SHORT: \
 	case PW_TYPE_INTEGER: \
 	case PW_TYPE_INTEGER64: \
+	case PW_TYPE_SIZE: \
 	case PW_TYPE_DATE: \
 	case PW_TYPE_IFID: \
 	case PW_TYPE_ETHERNET: \
@@ -1021,6 +1027,17 @@ int value_data_from_str(TALLOC_CTX *ctx, value_data_t *dst,
 	}
 		break;
 
+	case PW_TYPE_SIZE:
+	{
+		size_t i;
+
+		if (sscanf(in, "%zu", &i) != 1) {
+			fr_strerror_printf("Failed parsing \"%s\" as a file or memory size", in);
+			return -1;
+		}
+		dst->size = i;
+	}
+
 	case PW_TYPE_TIMEVAL:
 		if (fr_timeval_from_str(&dst->timeval, in) < 0) return -1;
 		break;
@@ -1779,6 +1796,10 @@ char *value_data_asprint(TALLOC_CTX *ctx,
 		p = talloc_typed_asprintf(ctx, "%" PRIu64, data->integer64);
 		break;
 
+	case PW_TYPE_SIZE:
+		p = talloc_typed_asprintf(ctx, "%zu", data->size);
+		break;
+
 	case PW_TYPE_SIGNED:
 		p = talloc_typed_asprintf(ctx, "%d", data->sinteger);
 		break;
@@ -1981,6 +2002,9 @@ size_t value_data_snprint(char *out, size_t outlen,
 	case PW_TYPE_INTEGER64:
 		return snprintf(out, outlen, "%" PRIu64, data->integer64);
 
+	case PW_TYPE_SIZE:
+		return snprintf(out, outlen, "%zu", data->size);
+
 	case PW_TYPE_SIGNED: /* Damned code for 1 WiMAX attribute */
 		len = snprintf(buf, sizeof(buf), "%d", data->sinteger);
 		a = buf;

src/main/conffile.c

@@ -1775,6 +1775,18 @@ static int cf_pair_parse_value(void *out, TALLOC_CTX *ctx, CONF_SECTION *cs, CON
 		cf_log_info(cs, "%.*s\t%s = %" PRIu64, cs->depth, parse_spaces, cf_pair_attr(cp), *(uint64_t *)out);
 		break;
 
+	case PW_TYPE_SIZE:
+	{
+		if (fr_size_from_str((size_t *)out, cp->value) < 0) {
+			cf_log_err(&(cs->item), "Invalid value \"%s\" for variable %s: %s", cp->value,
+				   cf_pair_attr(cp), fr_strerror());
+			rcode = -1;
+			goto error;
+		}
+		cf_log_info(cs, "%.*s\t%s = %zu", cs->depth, parse_spaces, cf_pair_attr(cp), *(size_t *)out);
+		break;
+	}
+
 	case PW_TYPE_SIGNED:
 		*(int32_t *)out = strtol(cp->value, 0, 0);
 		cf_log_info(cs, "%.*s\t%s = %d", cs->depth, parse_spaces, cf_pair_attr(cp), *(int32_t *)out);

src/modules/rlm_python/rlm_python.c

@@ -383,6 +383,10 @@ static int mod_populate_vptuple(PyObject *pp, VALUE_PAIR *vp)
 		value = PyLong_FromUnsignedLongLong(vp->vp_integer64);
 		break;
 
+	case PW_TYPE_SIZE:
+		value = PyLong_FromUnsignedLongLong((unsigned long long)vp->vp_size);
+		break;
+
 	case PW_TYPE_DECIMAL:
 		value = PyFloat_FromDouble(vp->vp_decimal);
 		break;