#include <string.h>
#include <unistd.h>
#include "coverage.h"
-
-#define THIS_MODULE VLM_util
#include "vlog.h"
+VLOG_DEFINE_THIS_MODULE(util);
+
+COVERAGE_DEFINE(util_xalloc);
+
const char *program_name;
void
-out_of_memory(void)
+out_of_memory(void)
{
ovs_fatal(0, "virtual memory exhausted");
}
void *
-xcalloc(size_t count, size_t size)
+xcalloc(size_t count, size_t size)
{
void *p = count && size ? calloc(count, size) : malloc(1);
COVERAGE_INC(util_xalloc);
}
void *
-xmalloc(size_t size)
+xmalloc(size_t size)
{
void *p = malloc(size ? size : 1);
COVERAGE_INC(util_xalloc);
}
void *
-xrealloc(void *p, size_t size)
+xrealloc(void *p, size_t size)
{
p = realloc(p, size ? size : 1);
COVERAGE_INC(util_xalloc);
}
char *
-xstrdup(const char *s)
+xstrdup(const char *s)
{
return xmemdup0(s, strlen(s));
}
return s;
}
+/* Similar to strlcpy() from OpenBSD, but it never reads more than 'size - 1'
+ * bytes from 'src' and doesn't return anything. */
void
ovs_strlcpy(char *dst, const char *src, size_t size)
{
if (size > 0) {
- size_t n = strlen(src);
- size_t n_copy = MIN(n, size - 1);
- memcpy(dst, src, n_copy);
- dst[n_copy] = '\0';
+ size_t len = strnlen(src, size - 1);
+ memcpy(dst, src, len);
+ dst[len] = '\0';
}
}
vfprintf(stderr, format, args);
va_end(args);
if (err_no != 0)
- fprintf(stderr, " (%s)", strerror(err_no));
+ fprintf(stderr, " (%s)", ovs_retval_to_string(err_no));
putc('\n', stderr);
exit(EXIT_FAILURE);
vfprintf(stderr, format, args);
va_end(args);
if (err_no != 0) {
- fprintf(stderr, " (%s)",
- err_no == EOF ? "end of file" : strerror(err_no));
+ fprintf(stderr, " (%s)", ovs_retval_to_string(err_no));
}
putc('\n', stderr);
errno = save_errno;
}
+/* Many OVS functions return an int which is one of:
+ * - 0: no error yet
+ * - >0: errno value
+ * - EOF: end of file (not necessarily an error; depends on the function called)
+ *
+ * Returns the appropriate human-readable string. The caller must copy the
+ * string if it wants to hold onto it, as the storage may be overwritten on
+ * subsequent function calls.
+ */
+const char *
+ovs_retval_to_string(int retval)
+{
+ static char unknown[48];
+
+ if (!retval) {
+ return "";
+ }
+ if (retval > 0) {
+ return strerror(retval);
+ }
+ if (retval == EOF) {
+ return "End of file";
+ }
+ snprintf(unknown, sizeof unknown, "***unknown return value: %d***", retval);
+ return unknown;
+}
+
/* Sets program_name based on 'argv0'. Should be called at the beginning of
* main(), as "set_program_name(argv[0]);". */
void set_program_name(const char *argv0)
/* Print the version information for the program. */
void
-ovs_print_version(char *date, char *time,
+ovs_print_version(char *date, char *time,
uint8_t min_ofp, uint8_t max_ofp)
{
printf("%s (Open vSwitch) "VERSION BUILDNR"\n", program_name);
case 'f': case 'F':
return 0xf;
+
+ default:
+ return -1;
}
+}
- NOT_REACHED();
+/* Returns the integer value of the 'n' hexadecimal digits starting at 's', or
+ * UINT_MAX if one of those "digits" is not really a hex digit. If 'ok' is
+ * nonnull, '*ok' is set to true if the conversion succeeds or to false if a
+ * non-hex digit is detected. */
+unsigned int
+hexits_value(const char *s, size_t n, bool *ok)
+{
+ unsigned int value;
+ size_t i;
+
+ value = 0;
+ for (i = 0; i < n; i++) {
+ int hexit = hexit_value(s[i]);
+ if (hexit < 0) {
+ if (ok) {
+ *ok = false;
+ }
+ return UINT_MAX;
+ }
+ value = (value << 4) + hexit;
+ }
+ if (ok) {
+ *ok = true;
+ }
+ return value;
}
/* Returns the current working directory as a malloc()'d string, or a null
}
}
+static char *
+all_slashes_name(const char *s)
+{
+ return xstrdup(s[0] == '/' && s[1] == '/' && s[2] != '/' ? "//"
+ : s[0] == '/' ? "/"
+ : ".");
+}
+
/* Returns the directory name portion of 'file_name' as a malloc()'d string,
* similar to the POSIX dirname() function but thread-safe. */
char *
while (len > 0 && file_name[len - 1] == '/') {
len--;
}
- if (!len) {
- return xstrdup((file_name[0] == '/'
- && file_name[1] == '/'
- && file_name[2] != '/') ? "//"
- : file_name[0] == '/' ? "/"
- : ".");
- } else {
- return xmemdup0(file_name, len);
+ return len ? xmemdup0(file_name, len) : all_slashes_name(file_name);
+}
+
+/* Returns the file name portion of 'file_name' as a malloc()'d string,
+ * similar to the POSIX basename() function but thread-safe. */
+char *
+base_name(const char *file_name)
+{
+ size_t end, start;
+
+ end = strlen(file_name);
+ while (end > 0 && file_name[end - 1] == '/') {
+ end--;
+ }
+
+ if (!end) {
+ return all_slashes_name(file_name);
+ }
+
+ start = end;
+ while (start > 0 && file_name[start - 1] != '/') {
+ start--;
}
+
+ return xmemdup0(file_name + start, end - start);
}
/* If 'file_name' starts with '/', returns a copy of 'file_name'. Otherwise,
/* Pass a value to this function if it is marked with
- * __attribute__((warn_unused_result)) and you genuinely want to ignore
- * its return value. (Note that every scalar type can be implicitly
+ * __attribute__((warn_unused_result)) and you genuinely want to ignore
+ * its return value. (Note that every scalar type can be implicitly
* converted to bool.) */
void ignore(bool x OVS_UNUSED) { }