Merge "conversions.c: Add conversions for largest max sized integer"

include/asterisk/conversions.h

@@ -23,6 +23,8 @@
 #ifndef _ASTERISK_CONVERSIONS_H
 #define _ASTERISK_CONVERSIONS_H
 
+#include <stdint.h>
+
 /*!
  * \brief Convert the given string to an unsigned integer
  *
@@ -59,4 +61,22 @@ int ast_str_to_uint(const char *str, unsigned int *res);
  */
 int ast_str_to_ulong(const char *str, unsigned long *res);
 
+/*!
+ * \brief Convert the given string to an unsigned max size integer
+ *
+ * This function will return failure for the following reasons:
+ *
+ *   The given string to convert is NULL
+ *   The given string to convert is empty.
+ *   The given string to convert is negative (starts with a '-')
+ *   The given string to convert contains non numeric values
+ *   Once converted the number is out of range (greater than UINTMAX_MAX)
+ *
+ * \param str The string to convert
+ * \param res [out] The converted value
+ *
+ * \returns -1 if it fails to convert, 0 on success
+ */
+int ast_str_to_umax(const char *str, uintmax_t *res);
+
 #endif /* _ASTERISK_CONVERSIONS_H */

main/conversions.c

@@ -26,22 +26,26 @@
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
-#include <stdlib.h>
+#include <inttypes.h>
+#include <stdio.h>
 
 #include "asterisk/conversions.h"
 
-static int str_is_negative(const char *str)
+static int str_is_negative(const char **str)
 {
-	/* Ignore any preceding white space */
-	while (isspace(*str) && *++str);
-	return *str == '-';
+	/*
+	 * Ignore any preceding white space. It's okay to move the pointer here
+	 * since the converting function would do the same, i.e. skip white space.
+	 */
+	while (isspace(**str)) ++*str;
+	return **str == '-';
 }
 
 int ast_str_to_uint(const char *str, unsigned int *res)
 {
-	unsigned long val;
+	uintmax_t val;
 
-	if (ast_str_to_ulong(str, &val) || val > UINT_MAX) {
+	if (ast_str_to_umax(str, &val) || val > UINT_MAX) {
 		return -1;
 	}
 
@@ -50,16 +54,28 @@ int ast_str_to_uint(const char *str, unsigned int *res)
 }
 
 int ast_str_to_ulong(const char *str, unsigned long *res)
+{
+	uintmax_t val;
+
+	if (ast_str_to_umax(str, &val) || val > ULONG_MAX) {
+		return -1;
+	}
+
+	*res = val;
+	return 0;
+}
+
+int ast_str_to_umax(const char *str, uintmax_t *res)
 {
 	char *end;
-	unsigned long val;
+	uintmax_t val;
 
-	if (!str || str_is_negative(str)) {
+	if (!str || str_is_negative(&str)) {
 		return -1;
 	}
 
 	errno = 0;
-	val = strtoul(str, &end, 0);
+	val = strtoumax(str, &end, 0);
 
 	/*
 	 * If str equals end then no digits were found. If end is not pointing to
@@ -67,11 +83,10 @@ int ast_str_to_ulong(const char *str, unsigned long *res)
 	 * converted, but some characters that could not, which we'll consider
 	 * invalid.
 	 */
-	if ((str == end || *end != '\0' || (errno == ERANGE && val == ULONG_MAX))) {
+	if ((str == end || *end != '\0' || (errno == ERANGE && val == UINTMAX_MAX))) {
 		return -1;
 	}
 
 	*res = val;
 	return 0;
-
 }

tests/test_conversions.c

@@ -62,6 +62,7 @@ AST_TEST_DEFINE(str_to_uint)
 	}
 
 	ast_test_validate(test, ast_str_to_uint(NULL, &val));
+	ast_test_validate(test, ast_str_to_uint("\0", &val));
 	ast_test_validate(test, ast_str_to_uint(invalid, &val));
 	ast_test_validate(test, ast_str_to_uint(invalid_partial, &val));
 	ast_test_validate(test, ast_str_to_uint(negative, &val));
@@ -103,6 +104,7 @@ AST_TEST_DEFINE(str_to_ulong)
 	}
 
 	ast_test_validate(test, ast_str_to_ulong(NULL, &val));
+	ast_test_validate(test, ast_str_to_ulong("\0", &val));
 	ast_test_validate(test, ast_str_to_ulong(invalid, &val));
 	ast_test_validate(test, ast_str_to_ulong(invalid_partial, &val));
 	ast_test_validate(test, ast_str_to_ulong(negative, &val));
@@ -119,10 +121,53 @@ AST_TEST_DEFINE(str_to_ulong)
 	return AST_TEST_PASS;
 }
 
+AST_TEST_DEFINE(str_to_umax)
+{
+	const char *invalid = "abc";
+	const char *invalid_partial = "7abc";
+	const char *negative = "-7";
+	const char *negative_spaces = "  -7";
+	const char *out_of_range = "99999999999999999999999999999999999999999999999999";
+	const char *spaces = "  ";
+	const char *valid = "7";
+	const char *valid_spaces = "  7";
+	uintmax_t val;
+	char str[64];
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = __func__;
+		info->category = CATEGORY;
+		info->summary = "convert a string to an unsigned max size integer";
+		info->description = info->summary;
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	ast_test_validate(test, ast_str_to_umax(NULL, &val));
+	ast_test_validate(test, ast_str_to_umax("\0", &val));
+	ast_test_validate(test, ast_str_to_umax(invalid, &val));
+	ast_test_validate(test, ast_str_to_umax(invalid_partial, &val));
+	ast_test_validate(test, ast_str_to_umax(negative, &val));
+	ast_test_validate(test, ast_str_to_umax(negative_spaces, &val));
+	ast_test_validate(test, ast_str_to_umax(out_of_range, &val));
+	ast_test_validate(test, ast_str_to_umax(spaces, &val));
+	ast_test_validate(test, !ast_str_to_umax(valid, &val));
+	ast_test_validate(test, !ast_str_to_umax(valid_spaces, &val));
+
+	ast_test_validate(test, snprintf(str, sizeof(str), "%lu", UINTMAX_MAX) > 0);
+	ast_test_validate(test, !ast_str_to_umax(str, &val));
+	ast_test_validate(test, val == UINTMAX_MAX);
+
+	return AST_TEST_PASS;
+}
+
 static int load_module(void)
 {
 	AST_TEST_REGISTER(str_to_uint);
 	AST_TEST_REGISTER(str_to_ulong);
+	AST_TEST_REGISTER(str_to_umax);
 	return AST_MODULE_LOAD_SUCCESS;
 }
 
@@ -130,7 +175,8 @@ static int unload_module(void)
 {
 	AST_TEST_UNREGISTER(str_to_uint);
 	AST_TEST_UNREGISTER(str_to_ulong);
+	AST_TEST_UNREGISTER(str_to_umax);
 	return 0;
 }
 
-AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "URI test module");
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Conversions test module");