X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Futil.c;h=d6e470c92f55f5f041db20bf9ffd84ff46d1e275;hb=693c4a01124ec5ad9253f8cfcfd99075a9d637f6;hp=8f1892ed2c4e0566075a05afa27de5382a2b6e5f;hpb=c69ee87c10818267f991236201150b1fa51ae519;p=openvswitch diff --git a/lib/util.c b/lib/util.c index 8f1892ed..d6e470c9 100644 --- a/lib/util.c +++ b/lib/util.c @@ -21,18 +21,24 @@ #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"); } 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 +55,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 +66,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 +94,7 @@ xmemdup0(const char *p_, size_t length) } char * -xstrdup(const char *s) +xstrdup(const char *s) { return xmemdup0(s, strlen(s)); } @@ -152,7 +158,8 @@ ovs_fatal(int err_no, const char *format, ...) vfprintf(stderr, format, args); va_end(args); if (err_no != 0) - fprintf(stderr, " (%s)", strerror(err_no)); + fprintf(stderr, " (%s)", + err_no == EOF ? "end of file" : strerror(err_no)); putc('\n', stderr); exit(EXIT_FAILURE); @@ -187,7 +194,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 +360,76 @@ hexit_value(int c) 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 + * 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; + } + } +} + +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,19 +447,62 @@ 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 + * __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) { }