X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Futil.c;h=e8f3adb78a22b23094e4d26561bacbb38c948fcf;hb=0cc96e48ab2fc573c3b7b69fe5a034bb29dde578;hp=cecd58253aa55f3616f21e93734ff47b82e1cb9a;hpb=ec6fde61c85ff6a57b05d422a9d8b5ef679ad928;p=openvswitch diff --git a/lib/util.c b/lib/util.c index cecd5825..e8f3adb7 100644 --- a/lib/util.c +++ b/lib/util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,18 +21,22 @@ #include #include #include +#include #include "coverage.h" +#include "vlog.h" + +VLOG_DEFINE_THIS_MODULE(util) 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 +53,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 +64,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 +92,7 @@ xmemdup0(const char *p_, size_t length) } char * -xstrdup(const char *s) +xstrdup(const char *s) { return xmemdup0(s, strlen(s)); } @@ -152,7 +156,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); @@ -168,8 +173,10 @@ ovs_error(int err_no, const char *format, ...) va_start(args, format); vfprintf(stderr, format, args); va_end(args); - if (err_no != 0) - fprintf(stderr, " (%s)", strerror(err_no)); + if (err_no != 0) { + fprintf(stderr, " (%s)", + err_no == EOF ? "end of file" : strerror(err_no)); + } putc('\n', stderr); errno = save_errno; @@ -185,7 +192,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); @@ -300,3 +307,148 @@ str_to_ullong(const char *s, int base, unsigned long long *ull) { return str_to_llong(s, base, (long long *) ull); } + +/* Converts floating-point string 's' into a double. If successful, stores + * the double in '*d' and returns true; on failure, stores 0 in '*d' and + * returns false. + * + * Underflow (e.g. "1e-9999") is not considered an error, but overflow + * (e.g. "1e9999)" is. */ +bool +str_to_double(const char *s, double *d) +{ + int save_errno = errno; + char *tail; + errno = 0; + *d = strtod(s, &tail); + if (errno == EINVAL || (errno == ERANGE && *d != 0) + || tail == s || *tail != '\0') { + errno = save_errno; + *d = 0; + return false; + } else { + errno = save_errno; + return true; + } +} + +/* Returns the value of 'c' as a hexadecimal digit. */ +int +hexit_value(int c) +{ + switch (c) { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + return c - '0'; + + case 'a': case 'A': + return 0xa; + + case 'b': case 'B': + return 0xb; + + case 'c': case 'C': + return 0xc; + + case 'd': case 'D': + return 0xd; + + case 'e': case 'E': + return 0xe; + + case 'f': case 'F': + return 0xf; + } + + NOT_REACHED(); +} + +/* 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; + } + } +} + +/* Returns the directory name portion of 'file_name' as a malloc()'d string, + * similar to the POSIX dirname() function but thread-safe. */ +char * +dir_name(const char *file_name) +{ + size_t len = strlen(file_name); + while (len > 0 && file_name[len - 1] == '/') { + len--; + } + while (len > 0 && file_name[len - 1] != '/') { + len--; + } + 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); + } +} + +/* 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 { + 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) { }