diff --git a/include/asterisk/conversions.h b/include/asterisk/conversions.h
index 2997760a859832ed810e34ec5120977165064d2d..55906e66496545fcd367458895b91bcd43c64a26 100644
--- a/include/asterisk/conversions.h
+++ b/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 */
diff --git a/main/conversions.c b/main/conversions.c
index e73e1a2137b04e21ea988bb9f7f1509996d16c3b..2fd3146a8cc5c1814113b9f7a0c569df2345d186 100644
--- a/main/conversions.c
+++ b/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;
-
}
diff --git a/tests/test_conversions.c b/tests/test_conversions.c
index 689aba9cda53a98ba366f44502421cd3866ea551..1a765b4a9d9532fd82ba24bec5186d4267233260 100644
--- a/tests/test_conversions.c
+++ b/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");