X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Futil.c;h=19f13dddc1f3f902b9964354e49381cd2221b8ef;hb=7103dec49eb569c3196239da6c178a29c3003e2b;hp=edc24b36bc653f462b26be8ddf8c19a3cd6e443c;hpb=064af42167bf4fc9aaea2702d80ce08074b889c0;p=openvswitch diff --git a/lib/util.c b/lib/util.c index edc24b36..19f13ddd 100644 --- a/lib/util.c +++ b/lib/util.c @@ -1,17 +1,17 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ #include @@ -21,8 +21,12 @@ #include #include #include +#include #include "coverage.h" +#define THIS_MODULE VLM_util +#include "vlog.h" + const char *program_name; void @@ -42,6 +46,12 @@ xcalloc(size_t count, size_t size) return p; } +void * +xzalloc(size_t size) +{ + return xcalloc(1, size); +} + void * xmalloc(size_t size) { @@ -162,8 +172,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; @@ -294,3 +306,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) { }