X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Futil.c;h=639424dd6ea683b915c0302e7b5c559066c99d47;hb=cbaa4ffe9b72904a7dad8ba23fa13cf2783b26c9;hp=65cb36087dc71e752e68d4cde17698aae940870a;hpb=58fda1dab104041fc693032475ec4662c1a52849;p=sliver-openvswitch.git diff --git a/lib/util.c b/lib/util.c index 65cb36087..639424dd6 100644 --- a/lib/util.c +++ b/lib/util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,23 +16,32 @@ #include #include "util.h" +#include #include +#include #include +#include #include #include #include +#include #include "coverage.h" +#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"); + ovs_abort(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); @@ -49,7 +58,7 @@ xzalloc(size_t size) } void * -xmalloc(size_t size) +xmalloc(size_t size) { void *p = malloc(size ? size : 1); COVERAGE_INC(util_xalloc); @@ -60,7 +69,7 @@ xmalloc(size_t size) } void * -xrealloc(void *p, size_t size) +xrealloc(void *p, size_t size) { p = realloc(p, size ? size : 1); COVERAGE_INC(util_xalloc); @@ -88,7 +97,7 @@ xmemdup0(const char *p_, size_t length) } char * -xstrdup(const char *s) +xstrdup(const char *s) { return xmemdup0(s, strlen(s)); } @@ -131,52 +140,143 @@ xasprintf(const char *format, ...) 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'; } } +/* Copies 'src' to 'dst'. Reads no more than 'size - 1' bytes from 'src'. + * Always null-terminates 'dst' (if 'size' is nonzero), and writes a zero byte + * to every otherwise unused byte in 'dst'. + * + * Except for performance, the following call: + * ovs_strzcpy(dst, src, size); + * is equivalent to these two calls: + * memset(dst, '\0', size); + * ovs_strlcpy(dst, src, size); + * + * (Thus, ovs_strzcpy() is similar to strncpy() without some of the pitfalls.) + */ void -ovs_fatal(int err_no, const char *format, ...) +ovs_strzcpy(char *dst, const char *src, size_t size) +{ + if (size > 0) { + size_t len = strnlen(src, size - 1); + memcpy(dst, src, len); + memset(dst + len, '\0', size - len); + } +} + +/* Prints 'format' on stderr, formatting it like printf() does. If 'err_no' is + * nonzero, then it is formatted with ovs_retval_to_string() and appended to + * the message inside parentheses. Then, terminates with abort(). + * + * This function is preferred to ovs_fatal() in a situation where it would make + * sense for a monitoring process to restart the daemon. + * + * 'format' should not end with a new-line, because this function will add one + * itself. */ +void +ovs_abort(int err_no, const char *format, ...) { va_list args; - fprintf(stderr, "%s: ", program_name); va_start(args, format); - vfprintf(stderr, format, args); + ovs_error_valist(err_no, format, args); va_end(args); - if (err_no != 0) - fprintf(stderr, " (%s)", strerror(err_no)); - putc('\n', stderr); + abort(); +} + +/* Prints 'format' on stderr, formatting it like printf() does. If 'err_no' is + * nonzero, then it is formatted with ovs_retval_to_string() and appended to + * the message inside parentheses. Then, terminates with EXIT_FAILURE. + * + * 'format' should not end with a new-line, because this function will add one + * itself. */ +void +ovs_fatal(int err_no, const char *format, ...) +{ + va_list args; + + va_start(args, format); + ovs_fatal_valist(err_no, format, args); +} + +/* Same as ovs_fatal() except that the arguments are supplied as a va_list. */ +void +ovs_fatal_valist(int err_no, const char *format, va_list args) +{ + ovs_error_valist(err_no, format, args); exit(EXIT_FAILURE); } +/* Prints 'format' on stderr, formatting it like printf() does. If 'err_no' is + * nonzero, then it is formatted with ovs_retval_to_string() and appended to + * the message inside parentheses. + * + * 'format' should not end with a new-line, because this function will add one + * itself. */ void ovs_error(int err_no, const char *format, ...) { - int save_errno = errno; va_list args; - fprintf(stderr, "%s: ", program_name); va_start(args, format); - vfprintf(stderr, format, args); + ovs_error_valist(err_no, format, args); va_end(args); +} + +/* Same as ovs_error() except that the arguments are supplied as a va_list. */ +void +ovs_error_valist(int err_no, const char *format, va_list args) +{ + int save_errno = errno; + + fprintf(stderr, "%s: ", program_name); + vfprintf(stderr, format, 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) @@ -187,7 +287,7 @@ 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); @@ -353,9 +453,76 @@ hexit_value(int c) case 'f': case 'F': return 0xf; + + default: + return -1; + } +} + +/* 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 + * pointer if the current working directory cannot be determined. */ +char * +get_cwd(void) +{ + long int path_max; + size_t size; + + /* Get maximum path length or at least a reasonable estimate. */ + path_max = pathconf(".", _PC_PATH_MAX); + size = (path_max < 0 ? 1024 + : path_max > 10240 ? 10240 + : path_max); + + /* Get current working directory. */ + for (;;) { + char *buf = xmalloc(size); + if (getcwd(buf, size)) { + return xrealloc(buf, strlen(buf) + 1); + } else { + int error = errno; + free(buf); + if (error != ERANGE) { + VLOG_WARN("getcwd failed (%s)", strerror(error)); + return NULL; + } + size *= 2; + } } +} - NOT_REACHED(); +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, @@ -373,13 +540,105 @@ dir_name(const char *file_name) while (len > 0 && file_name[len - 1] == '/') { len--; } - if (!len) { - return xstrdup((file_name[0] == '/' - && file_name[1] == '/' - && file_name[2] != '/') ? "//" - : file_name[0] == '/' ? "/" - : "."); + 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, + * returns an absolute path to 'file_name' considering it relative to 'dir', + * which itself must be absolute. 'dir' may be null or the empty string, in + * which case the current working directory is used. + * + * Returns a null pointer if 'dir' is null and getcwd() fails. */ +char * +abs_file_name(const char *dir, const char *file_name) +{ + if (file_name[0] == '/') { + return xstrdup(file_name); + } else if (dir && dir[0]) { + char *separator = dir[strlen(dir) - 1] == '/' ? "" : "/"; + return xasprintf("%s%s%s", dir, separator, file_name); } else { - return xmemdup0(file_name, len); + char *cwd = get_cwd(); + if (cwd) { + char *abs_name = xasprintf("%s/%s", cwd, file_name); + free(cwd); + return abs_name; + } else { + return NULL; + } + } +} + + +/* 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 + * converted to bool.) */ +void ignore(bool x OVS_UNUSED) { } + +/* Returns an appropriate delimiter for inserting just before the 0-based item + * 'index' in a list that has 'total' items in it. */ +const char * +english_list_delimiter(size_t index, size_t total) +{ + return (index == 0 ? "" + : index < total - 1 ? ", " + : total > 2 ? ", and " + : " and "); +} + +/* Given a 32 bit word 'n', calculates floor(log_2('n')). This is equivalent + * to finding the bit position of the most significant one bit in 'n'. It is + * an error to call this function with 'n' == 0. */ +int +log_2_floor(uint32_t n) +{ + assert(n); + +#if !defined(UINT_MAX) || !defined(UINT32_MAX) +#error "Someone screwed up the #includes." +#elif __GNUC__ >= 4 && UINT_MAX == UINT32_MAX + return 31 - __builtin_clz(n); +#else + { + int log = 0; + +#define BIN_SEARCH_STEP(BITS) \ + if (n >= (1 << BITS)) { \ + log += BITS; \ + n >>= BITS; \ + } + BIN_SEARCH_STEP(16); + BIN_SEARCH_STEP(8); + BIN_SEARCH_STEP(4); + BIN_SEARCH_STEP(2); + BIN_SEARCH_STEP(1); +#undef BIN_SEARCH_STEP + return log; } +#endif }