1 files changed, 144 insertions, 0 deletions
diff --git a/util.c b/util.c
new file mode 100644
index 0000000..8645889
--- /dev/null
+++ b/util.c
@@ -0,0 +1,144 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#include "tf.h"
+
+DEFINE_TF_ERRLIST;
+
+int atoi64(const char *str, int64_t *value)
+{
+	char *endptr;
+	long long tmp;
+
+	errno = 0; /* To distinguish success/failure after call */
+	tmp = strtoll(str, &endptr, 10);
+	if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN))
+		return -E_ATOI_OVERFLOW;
+	/*
+	 * If there were no digits at all, strtoll() stores the original value
+	 * of str in *endptr.
+	 */
+	if (endptr == str)
+		return -E_ATOI_NO_DIGITS;
+	/*
+	 * The implementation may also set errno and return 0 in case no
+	 * conversion was performed.
+	 */
+	if (errno != 0 && tmp == 0)
+		return -E_ATOI_NO_DIGITS;
+	if (*endptr != '\0') /* Further characters after number */
+		return -E_ATOI_JUNK_AT_END;
+	*value = tmp;
+	return 1;
+}
+
+__attribute__ ((warn_unused_result))
+void *xrealloc(void *p, size_t size)
+{
+	/*
+	 * No need to check for NULL pointers: If p is NULL, the call
+	 * to realloc is equivalent to malloc(size)
+	 */
+	assert(size);
+	if (!(p = realloc(p, size))) {
+		EMERG_LOG("realloc failed (size = %zu), aborting\n", size);
+		exit(EXIT_FAILURE);
+	}
+	return p;
+}
+
+__attribute__ ((warn_unused_result))
+void *xmalloc(size_t size)
+{
+	return xrealloc(NULL, size);
+}
+
+__attribute__ ((warn_unused_result))
+void *xcalloc(size_t size)
+{
+	void *p = xmalloc(size);
+	memset(p, 0, size);
+	return p;
+}
+
+/*
+ * Print a formated message to a dynamically allocated string.
+ *
+ * This function is similar to vasprintf(), a GNU extension which is not in C
+ * or POSIX. It allocates a string large enough to hold the output including
+ * the terminating null byte. The allocated string is returned via the first
+ * argument and must be freed by the caller. However, unlike vasprintf(), this
+ * function calls exit() if insufficient memory is available, while vasprintf()
+ * returns -1 in this case.
+ *
+ * It returns the number of bytes written, not including the terminating \p
+ * NULL character.
+ */
+__attribute__ ((format (printf, 2, 0)))
+unsigned xvasprintf(char **result, const char *fmt, va_list ap)
+{
+	int ret;
+	size_t size = 150;
+	va_list aq;
+
+	*result = xmalloc(size + 1);
+	va_copy(aq, ap);
+	ret = vsnprintf(*result, size, fmt, aq);
+	va_end(aq);
+	assert(ret >= 0);
+	if ((size_t)ret < size)
+		return ret;
+	size = ret + 1;
+	*result = xrealloc(*result, size);
+	va_copy(aq, ap);
+	ret = vsnprintf(*result, size, fmt, aq);
+	va_end(aq);
+	assert(ret >= 0 && (size_t)ret < size);
+	return ret;
+}
+
+__attribute__ ((format (printf, 2, 3)))
+/* Print to a dynamically allocated string, variable number of arguments.  */
+unsigned xasprintf(char **result, const char *fmt, ...)
+{
+	va_list ap;
+	unsigned ret;
+
+	va_start(ap, fmt);
+	ret = xvasprintf(result, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+/*
+ * Compile a regular expression.
+ *
+ * This simple wrapper calls regcomp(3) and logs a message on errors.
+ */
+int xregcomp(regex_t *preg, const char *regex, int cflags)
+{
+	char *buf;
+	size_t size;
+	int ret = regcomp(preg, regex, cflags);
+
+	if (ret == 0)
+		return 1;
+	size = regerror(ret, preg, NULL, 0);
+	buf = xmalloc(size);
+	regerror(ret, preg, buf, size);
+	ERROR_LOG("%s\n", buf);
+	free(buf);
+	return -E_REGEX;
+}
+
+static int loglevel_arg_val;
+
+__attribute__ ((format (printf, 2, 3)))
+void txp_log(int ll, const char* fmt,...)
+{
+	va_list argp;
+	if (ll < loglevel_arg_val)
+		return;
+	va_start(argp, fmt);
+	vfprintf(stderr, fmt, argp);
+	va_end(argp);
+}