Index: uspace/lib/posix/src/ctype.c =================================================================== --- uspace/lib/posix/src/ctype.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/ctype.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Character classification. + */ + +#include "posix/ctype.h" + +/** + * Checks whether character is ASCII. (obsolete) + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int isascii(int c) +{ + return c >= 0 && c < 128; +} + +/** + * Converts argument to a 7-bit ASCII character. (obsolete) + * + * @param c Character to convert. + * @return Coverted character. + */ +int toascii(int c) +{ + return c & 0x7F; +} + +/** @} + */ Index: uspace/lib/posix/src/dlfcn.c =================================================================== --- uspace/lib/posix/src/dlfcn.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/dlfcn.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2017 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/dlfcn.h" + +#include "libc/dlfcn.h" + +void *posix_dlopen(const char *filename, int flags) +{ + if (flags != 0) { + fprintf(stderr, "dlopen() not implemented with non-zero flags (%s:%d), something will NOT work.\n", __FILE__, __LINE__); + } + + return dlopen(filename, 0); +} + +void *posix_dlsym(void *handle, const char *symbol) +{ + return dlsym(handle, symbol); +} + +int posix_dlclose(void *handle) +{ + not_implemented(); + return 0; +} + +char *posix_dlerror(void) +{ + not_implemented(); + return (char *)"dlerror()"; +} + +/** @} + */ Index: uspace/lib/posix/src/fcntl.c =================================================================== --- uspace/lib/posix/src/fcntl.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/fcntl.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File control. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/fcntl.h" + +#include "libc/vfs/vfs.h" + +#include + +/** + * Performs set of operations on the opened files. + * + * @param fd File descriptor of the opened file. + * @param cmd Operation to carry out. + * @return Non-negative on success. Might have special meaning corresponding + * to the requested operation. + */ +int posix_fcntl(int fd, int cmd, ...) +{ + int flags; + + switch (cmd) { + case F_DUPFD: + case F_DUPFD_CLOEXEC: + /* VFS currently does not provide the functionality to duplicate + * opened file descriptor. */ + // FIXME: implement this once dup() is available + errno = ENOTSUP; + return -1; + case F_GETFD: + /* FD_CLOEXEC is not supported. There are no other flags. */ + return 0; + case F_SETFD: + /* FD_CLOEXEC is not supported. Ignore arguments and report success. */ + return 0; + case F_GETFL: + /* File status flags (i.e. O_APPEND) are currently private to the + * VFS server so it cannot be easily retrieved. */ + flags = 0; + /* File access flags are currently not supported for file descriptors. + * Provide full access. */ + flags |= O_RDWR; + return flags; + case F_SETFL: + /* File access flags are currently not supported for file descriptors. + * Ignore arguments and report success. */ + return 0; + case F_GETOWN: + case F_SETOWN: + case F_GETLK: + case F_SETLK: + case F_SETLKW: + /* Signals (SIGURG) and file locks are not supported. */ + errno = ENOTSUP; + return -1; + default: + /* Unknown command */ + errno = EINVAL; + return -1; + } +} + +/** + * Open, possibly create, a file. + * + * @param pathname Path to the file. + * @param posix_flags Access mode flags. + */ +int posix_open(const char *pathname, int posix_flags, ...) +{ + posix_mode_t posix_mode = 0; + if (posix_flags & O_CREAT) { + va_list args; + va_start(args, posix_flags); + posix_mode = va_arg(args, posix_mode_t); + va_end(args); + (void) posix_mode; + } + + if (((posix_flags & (O_RDONLY | O_WRONLY | O_RDWR)) == 0) || + ((posix_flags & (O_RDONLY | O_WRONLY)) == (O_RDONLY | O_WRONLY)) || + ((posix_flags & (O_RDONLY | O_RDWR)) == (O_RDONLY | O_RDWR)) || + ((posix_flags & (O_WRONLY | O_RDWR)) == (O_WRONLY | O_RDWR))) { + errno = EINVAL; + return -1; + } + + int flags = WALK_REGULAR; + if (posix_flags & O_CREAT) { + if (posix_flags & O_EXCL) + flags |= WALK_MUST_CREATE; + else + flags |= WALK_MAY_CREATE; + } + + int mode = + ((posix_flags & O_RDWR) ? MODE_READ | MODE_WRITE : 0) | + ((posix_flags & O_RDONLY) ? MODE_READ : 0) | + ((posix_flags & O_WRONLY) ? MODE_WRITE : 0) | + ((posix_flags & O_APPEND) ? MODE_APPEND : 0); + + int file; + + if (failed(vfs_lookup(pathname, flags, &file))) + return -1; + + if (failed(vfs_open(file, mode))) { + vfs_put(file); + return -1; + } + + if (posix_flags & O_TRUNC) { + if (posix_flags & (O_RDWR | O_WRONLY)) { + if (failed(vfs_resize(file, 0))) { + vfs_put(file); + return -1; + } + } + } + + return file; +} + +/** @} + */ + Index: uspace/lib/posix/src/fnmatch.c =================================================================== --- uspace/lib/posix/src/fnmatch.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/fnmatch.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,717 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Filename-matching. + */ + +/* This file contains an implementation of the fnmatch() pattern matching + * function. There is more code than necessary to account for the possibility + * of adding POSIX-like locale support to the system in the future. Functions + * that are only necessary for locale support currently simply use single + * characters for "collation elements". + * When (or if) locales are properly implemented, extending this implementation + * will be fairly straightforward. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "libc/stdbool.h" +#include "posix/ctype.h" +#include "posix/string.h" +#include "posix/stdlib.h" +#include + +#include "internal/common.h" +#include "posix/fnmatch.h" + +/* Returned by _match... functions. */ +#define INVALID_PATTERN -1 + +/* Type for collating element, simple identity with characters now, + * but may be extended for better locale support. + */ +typedef int coll_elm_t; + +/** Return value indicating that the element in question + * is not valid in the current locale. (That is, if locales are supported.) + */ +#define COLL_ELM_INVALID -1 + +/** + * Get collating element matching a string. + * + * @param str String representation of the element. + * @return Matching collating element or COLL_ELM_INVALID. + */ +static coll_elm_t _coll_elm_get(const char* str) +{ + if (str[0] == '\0' || str[1] != '\0') { + return COLL_ELM_INVALID; + } + return str[0]; +} + +/** + * Get collating element matching a single character. + * + * @param c Character representation of the element. + * @return Matching collating element. + */ +static coll_elm_t _coll_elm_char(int c) +{ + return c; +} + +/** + * Match collating element with a beginning of a string. + * + * @param elm Collating element to match. + * @param str String which beginning should match the element. + * @return 0 if the element doesn't match, or the number of characters matched. + */ +static int _coll_elm_match(coll_elm_t elm, const char *str) +{ + return elm == *str; +} + +/** + * Checks whether a string begins with a collating element in the given range. + * Ordering depends on the locale (if locales are supported). + * + * @param first First element of the range. + * @param second Last element of the range. + * @param str String to match. + * @return 0 if there is no match, or the number of characters matched. + */ +static int _coll_elm_between(coll_elm_t first, coll_elm_t second, + const char *str) +{ + return *str >= first && *str <= second; +} + +/** + * Read a string delimited by [? and ?]. + * + * @param pattern Pointer to the string to read from. Its position is moved + * to the first character after the closing ]. + * @param seq The character on the inside of brackets. + * @param buf Read buffer. + * @param buf_sz Read buffer's size. If the buffer is not large enough for + * the entire string, the string is cut with no error indication. + * @param flags Flags modifying the behavior. + * @return True on success, false if the pattern is invalid. + */ +static bool _get_delimited( + const char **pattern, int seq, + char *buf, size_t buf_sz, int flags) +{ + const bool noescape = (flags & FNM_NOESCAPE) != 0; + const bool pathname = (flags & FNM_PATHNAME) != 0; + + const char *p = *pattern; + assert(p[0] == '[' && p[1] == seq /* Caller should ensure this. */); + p += 2; + + while (true) { + if (*p == seq && *(p + 1) == ']') { + /* String properly ended, return. */ + *pattern = p + 2; + *buf = '\0'; + return true; + } + if (!noescape && *p == '\\') { + p++; + } + if (*p == '\0') { + /* String not ended properly, invalid pattern. */ + return false; + } + if (pathname && *p == '/') { + /* Slash in a pathname pattern is invalid. */ + return false; + } + if (buf_sz > 1) { + /* Only add to the buffer if there is space. */ + *buf = *p; + buf++; + buf_sz--; + } + p++; + } +} + +/************** CHARACTER CLASSES ****************/ + +#define MAX_CLASS_OR_COLL_LEN 6 + +struct _char_class { + const char *name; + int (*func) (int); +}; + +/* List of supported character classes. */ +static const struct _char_class _char_classes[] = { + { "alnum", isalnum }, + { "alpha", isalpha }, + { "blank", isblank }, + { "cntrl", iscntrl }, + { "digit", isdigit }, + { "graph", isgraph }, + { "lower", islower }, + { "print", isprint }, + { "punct", ispunct }, + { "space", isspace }, + { "upper", isupper }, + { "xdigit", isxdigit } +}; + +/** + * Compare function for binary search in the _char_classes array. + * + * @param key Key of the searched element. + * @param elem Element of _char_classes array. + * @return Ordering indicator (-1 less than, 0 equal, 1 greater than). + */ +static int _class_compare(const void *key, const void *elem) +{ + const struct _char_class *class = elem; + return posix_strcmp((const char *) key, class->name); +} + +/** + * Returns whether the given character belongs to the specified character class. + * + * @param cname Name of the character class. + * @param c Character. + * @return True if the character belongs to the class, false otherwise. + */ +static bool _is_in_class (const char *cname, int c) +{ + /* Search for class in the array of supported character classes. */ + const struct _char_class *class = posix_bsearch(cname, _char_classes, + sizeof(_char_classes) / sizeof(struct _char_class), + sizeof(struct _char_class), _class_compare); + + if (class == NULL) { + /* No such class supported - treat as an empty class. */ + return false; + } else { + /* Class matched. */ + return class->func(c); + } +} + +/** + * Tries to parse an initial part of the pattern as a character class pattern, + * and if successful, matches the beginning of the given string against the class. + * + * @param pattern Pointer to the pattern to match. Must begin with a class + * specifier and is repositioned to the first character after the specifier + * if successful. + * @param str String to match. + * @param flags Flags modifying the behavior (see fnmatch()). + * @return INVALID_PATTERN if the pattern doesn't start with a valid class + * specifier, 0 if the beginning of the matched string doesn't belong + * to the class, or positive number of characters matched. + */ +static int _match_char_class(const char **pattern, const char *str, int flags) +{ + char class[MAX_CLASS_OR_COLL_LEN + 1]; + + if (!_get_delimited(pattern, ':', class, sizeof(class), flags)) { + return INVALID_PATTERN; + } + + return _is_in_class(class, *str); +} + +/************** END CHARACTER CLASSES ****************/ + +/** + * Reads the next collating element in the pattern, taking into account + * locale (if supported) and flags (see fnmatch()). + * + * @param pattern Pattern. + * @param flags Flags given to fnmatch(). + * @return Collating element on success, + * or COLL_ELM_INVALID if the pattern is invalid. + */ +static coll_elm_t _next_coll_elm(const char **pattern, int flags) +{ + assert(pattern != NULL); + assert(*pattern != NULL); + assert(**pattern != '\0'); + + const char *p = *pattern; + const bool noescape = (flags & FNM_NOESCAPE) != 0; + const bool pathname = (flags & FNM_PATHNAME) != 0; + + if (*p == '[') { + if (*(p + 1) == '.') { + char buf[MAX_CLASS_OR_COLL_LEN + 1]; + if (!_get_delimited(pattern, '.', buf, sizeof(buf), flags)) { + return COLL_ELM_INVALID; + } + return _coll_elm_get(buf); + } + + if (*(p + 1) == '=') { + char buf[MAX_CLASS_OR_COLL_LEN + 1]; + if (!_get_delimited(pattern, '=', buf, sizeof(buf), flags)) { + return COLL_ELM_INVALID; + } + return _coll_elm_get(buf); + } + } + + if (!noescape && *p == '\\') { + p++; + if (*p == '\0') { + *pattern = p; + return COLL_ELM_INVALID; + } + } + if (pathname && *p == '/') { + return COLL_ELM_INVALID; + } + + *pattern = p + 1; + return _coll_elm_char(*p); +} + +/** + * Matches the beginning of the given string against a bracket expression + * the pattern begins with. + * + * @param pattern Pointer to the beginning of a bracket expression in a pattern. + * On success, the pointer is moved to the first character after the + * bracket expression. + * @param str Unmatched part of the string. + * @param flags Flags given to fnmatch(). + * @return INVALID_PATTERN if the pattern is invalid, 0 if there is no match + * or the number of matched characters on success. + */ +static int _match_bracket_expr(const char **pattern, const char *str, int flags) +{ + const bool pathname = (flags & FNM_PATHNAME) != 0; + const bool special_period = (flags & FNM_PERIOD) != 0; + const char *p = *pattern; + bool negative = false; + int matched = 0; + + #define _matched(match) { \ + int _match = match; \ + if (_match < 0) { \ + /* Invalid pattern */ \ + return _match; \ + } else if (matched == 0 && _match > 0) { \ + /* First match */ \ + matched = _match; \ + } \ + } + + assert(*p == '['); /* calling code should ensure this */ + p++; + + if (*str == '\0' || (pathname && *str == '/') || + (pathname && special_period && *str == '.' && *(str - 1) == '/')) { + /* No bracket expression matches end of string, + * slash in pathname match or initial period with FNM_PERIOD + * option. + */ + return 0; + } + + if (*p == '^' || *p == '!') { + negative = true; + p++; + } + + if (*p == ']') { + /* When ']' is first, treat it as a normal character. */ + _matched(*str == ']'); + p++; + } + + coll_elm_t current_elm = COLL_ELM_INVALID; + + while (*p != ']') { + if (*p == '-' && *(p + 1) != ']' && + current_elm != COLL_ELM_INVALID) { + /* Range expression. */ + p++; + coll_elm_t end_elm = _next_coll_elm(&p, flags); + if (end_elm == COLL_ELM_INVALID) { + return INVALID_PATTERN; + } + _matched(_coll_elm_between(current_elm, end_elm, str)); + continue; + } + + if (*p == '[' && *(p + 1) == ':') { + current_elm = COLL_ELM_INVALID; + _matched(_match_char_class(&p, str, flags)); + continue; + } + + current_elm = _next_coll_elm(&p, flags); + if (current_elm == COLL_ELM_INVALID) { + return INVALID_PATTERN; + } + _matched(_coll_elm_match(current_elm, str)); + } + + /* No error occured - update pattern pointer. */ + *pattern = p + 1; + + if (matched == 0) { + /* No match found */ + return negative; + } else { + /* Matched 'match' characters. */ + return negative ? 0 : matched; + } + + #undef _matched +} + +/** + * Matches a portion of the pattern containing no asterisks (*) against + * the given string. + * + * @param pattern Pointer to the unmatched portion of the pattern. + * On success, the pointer is moved to the first asterisk, or to the + * terminating nul character, whichever occurs first. + * @param string Pointer to the input string. On success, the pointer is moved + * to the first character that wasn't explicitly matched. + * @param flags Flags given to fnmatch(). + * @return True if the entire subpattern matched. False otherwise. + */ +static bool _partial_match(const char **pattern, const char **string, int flags) +{ + /* Only a single *-delimited subpattern is matched here. + * So in this function, '*' is understood as the end of pattern. + */ + + const bool pathname = (flags & FNM_PATHNAME) != 0; + const bool special_period = (flags & FNM_PERIOD) != 0; + const bool noescape = (flags & FNM_NOESCAPE) != 0; + const bool leading_dir = (flags & FNM_LEADING_DIR) != 0; + + const char *s = *string; + const char *p = *pattern; + + while (*p != '*') { + /* Bracket expression. */ + if (*p == '[') { + int matched = _match_bracket_expr(&p, s, flags); + if (matched == 0) { + /* Doesn't match. */ + return false; + } + if (matched != INVALID_PATTERN) { + s += matched; + continue; + } + + assert(matched == INVALID_PATTERN); + /* Fall through to match [ as an ordinary character. */ + } + + /* Wildcard match. */ + if (*p == '?') { + if (*s == '\0') { + /* No character to match. */ + return false; + } + if (pathname && *s == '/') { + /* Slash must be matched explicitly. */ + return false; + } + if (special_period && pathname && + *s == '.' && *(s - 1) == '/') { + /* Initial period must be matched explicitly. */ + return false; + } + + /* None of the above, match anything else. */ + p++; + s++; + continue; + } + + if (!noescape && *p == '\\') { + /* Escaped character. */ + p++; + } + + if (*p == '\0') { + /* End of pattern, must match end of string or + * an end of subdirectory name (optional). + */ + + if (*s == '\0' || (leading_dir && *s == '/')) { + break; + } + + return false; + } + + if (*p == *s) { + /* Exact match. */ + p++; + s++; + continue; + } + + /* Nothing matched. */ + return false; + } + + /* Entire sub-pattern matched. */ + + /* postconditions */ + assert(*p == '\0' || *p == '*'); + assert(*p != '\0' || *s == '\0' || (leading_dir && *s == '/')); + + *pattern = p; + *string = s; + return true; +} + +/** + * Match string against a pattern. + * + * @param pattern Pattern. + * @param string String to match. + * @param flags Flags given to fnmatch(). + * @return True if the string matched the pattern, false otherwise. + */ +static bool _full_match(const char *pattern, const char *string, int flags) +{ + const bool pathname = (flags & FNM_PATHNAME) != 0; + const bool special_period = (flags & FNM_PERIOD) != 0; + const bool leading_dir = (flags & FNM_LEADING_DIR) != 0; + + if (special_period && *string == '.') { + /* Initial dot must be matched by an explicit dot in pattern. */ + if (*pattern != '.') { + return false; + } + pattern++; + string++; + } + + if (*pattern != '*') { + if (!_partial_match(&pattern, &string, flags)) { + /* The initial match must succeed. */ + return false; + } + } + + while (*pattern != '\0') { + assert(*pattern == '*'); + pattern++; + + bool matched = false; + + const char *end; + if (pathname && special_period && + *string == '.' && *(string - 1) == '/') { + end = string; + } else { + end = gnu_strchrnul(string, pathname ? '/' : '\0'); + } + + /* Try to match every possible offset. */ + while (string <= end) { + if (_partial_match(&pattern, &string, flags)) { + matched = true; + break; + } + string++; + } + + if (matched) { + continue; + } + + return false; + } + + return *string == '\0' || (leading_dir && *string == '/'); +} + +/** + * Transform the entire string to lowercase. + * + * @param s Input string. + * @return Newly allocated copy of the input string with all uppercase + * characters folded to their lowercase variants. + */ +static char *_casefold(const char *s) +{ + assert(s != NULL); + char *result = posix_strdup(s); + for (char *i = result; *i != '\0'; ++i) { + *i = tolower(*i); + } + return result; +} + +/** + * Filename pattern matching. + * + * @param pattern Pattern to match the string against. + * @param string Matched string. + * @param flags Flags altering the matching of special characters + * (mainly for dot and slash). + * @return Zero if the string matches the pattern, FNM_NOMATCH otherwise. + */ +int posix_fnmatch(const char *pattern, const char *string, int flags) +{ + assert(pattern != NULL); + assert(string != NULL); + + // TODO: don't fold everything in advance, but only when needed + + if ((flags & FNM_CASEFOLD) != 0) { + /* Just fold the entire pattern and string. */ + pattern = _casefold(pattern); + string = _casefold(string); + } + + bool result = _full_match(pattern, string, flags); + + if ((flags & FNM_CASEFOLD) != 0) { + if (pattern) { + free((char *) pattern); + } + if (string) { + free((char *) string); + } + } + + return result ? 0 : FNM_NOMATCH; +} + +// FIXME: put the testcases to the app/tester after fnmatch is included into libc + +#if 0 + +#include + +void __posix_fnmatch_test() +{ + int fail = 0; + + #undef assert + #define assert(x) { if (x) printf("SUCCESS: "#x"\n"); else { printf("FAILED: "#x"\n"); fail++; } } + #define match(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == 0) + #define nomatch(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == FNM_NOMATCH) + + static_assert(FNM_PATHNAME == FNM_FILE_NAME); + match("", "", 0); + match("*", "hello", 0); + match("hello", "hello", 0); + match("hello*", "hello", 0); + nomatch("hello?", "hello", 0); + match("*hello", "prdel hello", 0); + match("he[sl]lo", "hello", 0); + match("he[sl]lo", "heslo", 0); + nomatch("he[sl]lo", "heblo", 0); + nomatch("he[^sl]lo", "hello", 0); + nomatch("he[^sl]lo", "heslo", 0); + match("he[^sl]lo", "heblo", 0); + nomatch("he[!sl]lo", "hello", 0); + nomatch("he[!sl]lo", "heslo", 0); + match("he[!sl]lo", "heblo", 0); + match("al*[c-t]a*vis*ta", "alheimer talir jehovista", 0); + match("al*[c-t]a*vis*ta", "alfons had jehovista", 0); + match("[a-ce-z]", "a", 0); + match("[a-ce-z]", "c", 0); + nomatch("[a-ce-z]", "d", 0); + match("[a-ce-z]", "e", 0); + match("[a-ce-z]", "z", 0); + nomatch("[^a-ce-z]", "a", 0); + nomatch("[^a-ce-z]", "c", 0); + match("[^a-ce-z]", "d", 0); + nomatch("[^a-ce-z]", "e", 0); + nomatch("[^a-ce-z]", "z", 0); + match("helen??", "helenos", 0); + match("****booo****", "booo", 0); + + match("hello[[:space:]]world", "hello world", 0); + nomatch("hello[[:alpha:]]world", "hello world", 0); + + match("/hoooo*", "/hooooooo/hooo", 0); + nomatch("/hoooo*", "/hooooooo/hooo", FNM_PATHNAME); + nomatch("/hoooo*/", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*/*", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*/hooo", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*", "/hooooooo/hooo", FNM_PATHNAME | FNM_LEADING_DIR); + nomatch("/hoooo*/", "/hooooooo/hooo", FNM_PATHNAME | FNM_LEADING_DIR); + nomatch("/hoooo", "/hooooooo/hooo", FNM_LEADING_DIR); + match("/hooooooo", "/hooooooo/hooo", FNM_LEADING_DIR); + + match("*", "hell", 0); + match("*?", "hell", 0); + match("?*?", "hell", 0); + match("?*??", "hell", 0); + match("??*??", "hell", 0); + nomatch("???*??", "hell", 0); + + nomatch("", "hell", 0); + nomatch("?", "hell", 0); + nomatch("??", "hell", 0); + nomatch("???", "hell", 0); + match("????", "hell", 0); + + match("*", "h.ello", FNM_PERIOD); + match("*", "h.ello", FNM_PATHNAME | FNM_PERIOD); + nomatch("*", ".hello", FNM_PERIOD); + match("h?ello", "h.ello", FNM_PERIOD); + nomatch("?hello", ".hello", FNM_PERIOD); + match("/home/user/.*", "/home/user/.hello", FNM_PATHNAME | FNM_PERIOD); + match("/home/user/*", "/home/user/.hello", FNM_PERIOD); + nomatch("/home/user/*", "/home/user/.hello", FNM_PATHNAME | FNM_PERIOD); + + nomatch("HeLlO", "hello", 0); + match("HeLlO", "hello", FNM_CASEFOLD); + + printf("Failed: %d\n", fail); +} + +#endif + +/** @} + */ Index: uspace/lib/posix/src/getopt.c =================================================================== --- uspace/lib/posix/src/getopt.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/getopt.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Command line argument parsing. + */ +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "libc/getopt.h" +#include "posix/getopt.h" + + +int posix_getopt_long(int argc, char * const argv[], + const char *opt_string, const struct option *long_opts, int *long_index) +{ + int rc = getopt_long(argc, argv, opt_string, long_opts, long_index); + posix_optarg = (char *) optarg; + return rc; +} + +int posix_getopt(int argc, char * const argv[], const char *opt_string) +{ + int rc = getopt(argc, argv, opt_string); + posix_optarg = (char *) optarg; + return rc; +} Index: uspace/lib/posix/src/internal/common.h =================================================================== --- uspace/lib/posix/src/internal/common.h (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/internal/common.h (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Helper definitions common for all libposix files. + */ + +#ifndef LIBPOSIX_COMMON_H_ +#define LIBPOSIX_COMMON_H_ + +#include +#include +#include +#include + +#define not_implemented() do { \ + static int __not_implemented_counter = 0; \ + if (__not_implemented_counter == 0) { \ + fprintf(stderr, "%s() not implemented in %s:%d, something will NOT work.\n", \ + __func__, __FILE__, __LINE__); \ + } \ + __not_implemented_counter++; \ + } while (0) + +/* Checks if the value is a failing error code. + * If so, writes the error code to errno and returns true. + */ +static inline bool failed(int rc) { + if (rc != EOK) { + errno = rc; + return true; + } + return false; +} + +extern aoff64_t posix_pos[MAX_OPEN_FILES]; + +#endif /* LIBPOSIX_COMMON_H_ */ + +/** @} + */ Index: uspace/lib/posix/src/locale.c =================================================================== --- uspace/lib/posix/src/locale.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/locale.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Locale-specific definitions. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/locale.h" + +#include + +#include "posix/limits.h" +#include "posix/string.h" + +/* Just a very basic dummy implementation. + * This should allow code using locales to work properly, but doesn't provide + * any localization functionality. + * Should be extended/rewritten when or if HelenOS supports locales natively. + */ + +struct __posix_locale { + int _dummy; +}; + +const struct posix_lconv C_LOCALE = { + .currency_symbol = (char *) "", + .decimal_point = (char *) ".", + .frac_digits = CHAR_MAX, + .grouping = (char *) "", + .int_curr_symbol = (char *) "", + .int_frac_digits = CHAR_MAX, + .int_n_cs_precedes = CHAR_MAX, + .int_n_sep_by_space = CHAR_MAX, + .int_n_sign_posn = CHAR_MAX, + .int_p_cs_precedes = CHAR_MAX, + .int_p_sep_by_space = CHAR_MAX, + .int_p_sign_posn = CHAR_MAX, + .mon_decimal_point = (char *) "", + .mon_grouping = (char *) "", + .mon_thousands_sep = (char *) "", + .negative_sign = (char *) "", + .n_cs_precedes = CHAR_MAX, + .n_sep_by_space = CHAR_MAX, + .n_sign_posn = CHAR_MAX, + .positive_sign = (char *) "", + .p_cs_precedes = CHAR_MAX, + .p_sep_by_space = CHAR_MAX, + .p_sign_posn = CHAR_MAX, + .thousands_sep = (char *) "" +}; + +/** + * Set program locale. + * + * @param category What category to set. + * @param locale Locale name. + * @return Original locale name on success, NULL on failure. + */ +char *posix_setlocale(int category, const char *locale) +{ + // TODO + if (locale == NULL || *locale == '\0' || + posix_strcmp(locale, "C") == 0) { + return (char *) "C"; + } + return NULL; +} + +/** + * Return locale-specific information. + * + * @return Information about the current locale. + */ +struct posix_lconv *posix_localeconv(void) +{ + // TODO + return (struct posix_lconv *) &C_LOCALE; +} + +/** + * Duplicate locale object. + * + * @param locobj Object to duplicate. + * @return Duplicated object. + */ +posix_locale_t posix_duplocale(posix_locale_t locobj) +{ + if (locobj == NULL) { + errno = EINVAL; + return NULL; + } + posix_locale_t copy = malloc(sizeof(struct __posix_locale)); + if (copy == NULL) { + errno = ENOMEM; + return NULL; + } + memcpy(copy, locobj, sizeof(struct __posix_locale)); + return copy; +} + +/** + * Free locale object. + * + * @param locobj Object to free. + */ +void posix_freelocale(posix_locale_t locobj) +{ + if (locobj) { + free(locobj); + } +} + +/** + * Create or modify a locale object. + * + * @param category_mask Mask of categories to be set or modified. + * @param locale Locale to be used. + * @param base Object to modify. 0 if new object is to be created. + * @return The new/modified locale object. + */ +posix_locale_t posix_newlocale(int category_mask, const char *locale, + posix_locale_t base) +{ + if (locale == NULL || + (category_mask & LC_ALL_MASK) != category_mask) { + errno = EINVAL; + return NULL; + } + // TODO + posix_locale_t new = malloc(sizeof(struct __posix_locale)); + if (new == NULL) { + errno = ENOMEM; + return NULL; + } + if (base != NULL) { + posix_freelocale(base); + } + return new; +} + +/** + * Set locale for the current thread. + * + * @param newloc Locale to use. + * @return The previously set locale or LC_GLOBAL_LOCALE + */ +posix_locale_t posix_uselocale(posix_locale_t newloc) +{ + // TODO + return LC_GLOBAL_LOCALE; +} + +/** @} + */ Index: uspace/lib/posix/src/pthread/condvar.c =================================================================== --- uspace/lib/posix/src/pthread/condvar.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/pthread/condvar.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2013 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Pthread: condition variables. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "posix/pthread.h" +#include "errno.h" +#include "../internal/common.h" + +int pthread_cond_init(pthread_cond_t *restrict condvar, + const pthread_condattr_t *restrict attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_cond_destroy(pthread_cond_t *condvar) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_cond_broadcast(pthread_cond_t *condvar) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_cond_signal(pthread_cond_t *condvar) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_cond_timedwait(pthread_cond_t *restrict condvar, + pthread_mutex_t *restrict mutex, const struct __POSIX_DEF__(timespec) *restrict timeout) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_cond_wait(pthread_cond_t *restrict condvar, + pthread_mutex_t *restrict mutex) +{ + not_implemented(); + return ENOTSUP; +} + + +int pthread_condattr_init(pthread_condattr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_condattr_destroy(pthread_condattr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + + +/** @} + */ Index: uspace/lib/posix/src/pthread/keys.c =================================================================== --- uspace/lib/posix/src/pthread/keys.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/pthread/keys.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2013 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Pthread: keys and thread-specific storage. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "posix/stdlib.h" +#include "posix/pthread.h" +#include +#include "../internal/common.h" + + +void *pthread_getspecific(pthread_key_t key) +{ + not_implemented(); + return NULL; +} + +int pthread_setspecific(pthread_key_t key, const void *data) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_key_delete(pthread_key_t key) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_key_create(pthread_key_t *key, void (*destructor)(void*)) +{ + not_implemented(); + return ENOTSUP; +} + +/** @} + */ Index: uspace/lib/posix/src/pthread/mutex.c =================================================================== --- uspace/lib/posix/src/pthread/mutex.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/pthread/mutex.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2013 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Pthread: mutexes. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "posix/pthread.h" +#include +#include "../internal/common.h" + + +int pthread_mutex_init(pthread_mutex_t *restrict mutex, + const pthread_mutexattr_t *restrict attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutex_destroy(pthread_mutex_t *mutex) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutex_lock(pthread_mutex_t *mutex) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutex_trylock(pthread_mutex_t *mutex) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutex_unlock(pthread_mutex_t *mutex) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutexattr_init(pthread_mutexattr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, + int *restrict type) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) +{ + not_implemented(); + return ENOTSUP; +} + + + +/** @} + */ Index: uspace/lib/posix/src/pthread/threads.c =================================================================== --- uspace/lib/posix/src/pthread/threads.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/pthread/threads.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2013 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Pthread: thread management. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "posix/pthread.h" +#include "errno.h" +#include "posix/stdlib.h" +#include "libc/thread.h" +#include "../internal/common.h" + +pthread_t pthread_self(void) +{ + return thread_get_id(); +} + +int pthread_equal(pthread_t thread1, pthread_t thread2) +{ + return thread1 == thread2; +} + +int pthread_create(pthread_t *thread_id, const pthread_attr_t *attributes, + void *(*start_routine)(void *), void *arg) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_join(pthread_t thread, void **ret_val) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_detach(pthread_t thread) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_attr_init(pthread_attr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + +int pthread_attr_destroy(pthread_attr_t *attr) +{ + not_implemented(); + return ENOTSUP; +} + +/** @} + */ Index: uspace/lib/posix/src/pwd.c =================================================================== --- uspace/lib/posix/src/pwd.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/pwd.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Password handling. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "libc/stdbool.h" +#include "posix/pwd.h" +#include "posix/string.h" +#include +#include + +static bool entry_read = false; + +/* dummy user account */ +static const struct posix_passwd dummy_pwd = { + .pw_name = (char *) "user", + .pw_uid = 0, + .pw_gid = 0, + .pw_dir = (char *) "/", + .pw_shell = (char *) "/app/bdsh" +}; + +/** + * Retrieve next broken-down entry from the user database. + * + * Since HelenOS doesn't have user accounts, this always returns + * the same made-up entry. + * + * @return Next user database entry or NULL if not possible. Since HelenOS + * doesn't have user accounts, this always returns the same made-up entry. + */ +struct posix_passwd *posix_getpwent(void) +{ + if (entry_read) { + return NULL; + } + + entry_read = true; + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * Rewind the user list. + */ +void posix_setpwent(void) +{ + entry_read = false; +} + +/** + * Ends enumerating and releases all resources. (Noop) + */ +void posix_endpwent(void) +{ + /* noop */ +} + +/** + * Find an entry by name. + * + * @param name Name of the entry. + * @return Either found entry or NULL if no such entry exists. + */ +struct posix_passwd *posix_getpwnam(const char *name) +{ + assert(name != NULL); + + if (posix_strcmp(name, "user") != 0) { + return NULL; + } + + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * Find an entry by name, thread safely. + * + * @param name Name of the entry. + * @param pwd Original structure. + * @param buffer Buffer for the strings referenced from the result structure. + * @param bufsize Length of the buffer. + * @param result Where to store updated structure. + * @return Zero on success (either found or not found, but without an error), + * non-zero error number if error occured. + */ +int posix_getpwnam_r(const char *name, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result) +{ + assert(name != NULL); + assert(pwd != NULL); + assert(buffer != NULL); + assert(result != NULL); + + if (posix_strcmp(name, "user") != 0) { + *result = NULL; + return 0; + } + + return posix_getpwuid_r(0, pwd, buffer, bufsize, result); +} + +/** + * Find an entry by UID. + * + * @param uid UID of the entry. + * @return Either found entry or NULL if no such entry exists. + */ +struct posix_passwd *posix_getpwuid(posix_uid_t uid) +{ + if (uid != 0) { + return NULL; + } + + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * Find an entry by UID, thread safely. + * + * @param uid UID of the entry. + * @param pwd Original structure. + * @param buffer Buffer for the strings referenced from the result structure. + * @param bufsize Length of the buffer. + * @param result Where to store updated structure. + * @return Zero on success (either found or not found, but without an error), + * non-zero error number if error occured. + */ +int posix_getpwuid_r(posix_uid_t uid, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result) +{ + assert(pwd != NULL); + assert(buffer != NULL); + assert(result != NULL); + + static const char bf[] = { 'u', 's', 'e', 'r', '\0', + '/', '\0', 'b', 'd', 's', 'h', '\0' }; + + if (uid != 0) { + *result = NULL; + return 0; + } + if (bufsize < sizeof(bf)) { + *result = NULL; + return ERANGE; + } + + memcpy(buffer, bf, sizeof(bf)); + + pwd->pw_name = (char *) bf; + pwd->pw_uid = 0; + pwd->pw_gid = 0; + pwd->pw_dir = (char *) bf + 5; + pwd->pw_shell = (char *) bf + 7; + *result = (struct posix_passwd *) pwd; + + return 0; +} + +/** @} + */ Index: uspace/lib/posix/src/signal.c =================================================================== --- uspace/lib/posix/src/signal.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/signal.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,568 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Signal handling. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "posix/signal.h" +#include "internal/common.h" +#include "posix/limits.h" +#include "posix/stdlib.h" +#include "posix/string.h" + +#include + +#include "libc/fibril_synch.h" +#include "libc/task.h" + +/* This file implements a fairly dumb and incomplete "simulation" of + * POSIX signals. Since HelenOS doesn't support signals and mostly doesn't + * have any equivalent functionality, most of the signals are useless. The + * main purpose of this implementation is thus to help port applications using + * signals with minimal modification, but if the application uses signals for + * anything non-trivial, it's quite probable it won't work properly even if + * it builds without problems. + */ + +/* Used to serialize signal handling. */ +static FIBRIL_MUTEX_INITIALIZE(_signal_mutex); + +static LIST_INITIALIZE(_signal_queue); + +static posix_sigset_t _signal_mask = 0; + +#define DEFAULT_HANDLER { .sa_handler = SIG_DFL, \ + .sa_mask = 0, .sa_flags = 0, .sa_sigaction = NULL } + +/* Actions associated with each signal number. */ +static struct posix_sigaction _signal_actions[_TOP_SIGNAL + 1] = { + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER +}; + +/** + * Default signal handler. Executes the default action for each signal, + * as reasonable within HelenOS. + * + * @param signo Signal number. + */ +void __posix_default_signal_handler(int signo) +{ + switch (signo) { + case SIGABRT: + abort(); + case SIGQUIT: + fprintf(stderr, "Quit signal raised. Exiting.\n"); + exit(EXIT_FAILURE); + case SIGINT: + fprintf(stderr, "Interrupt signal caught. Exiting.\n"); + exit(EXIT_FAILURE); + case SIGTERM: + fprintf(stderr, "Termination signal caught. Exiting.\n"); + exit(EXIT_FAILURE); + case SIGSTOP: + fprintf(stderr, "Stop signal caught, but unsupported. Ignoring.\n"); + break; + case SIGKILL: + /* This will only occur when raise or similar is called. */ + /* Commit suicide. */ + task_kill(task_get_id()); + + /* Should not be reached. */ + abort(); + case SIGFPE: + case SIGBUS: + case SIGILL: + case SIGSEGV: + posix_psignal(signo, "Hardware exception raised by user code"); + abort(); + case SIGSYS: + case SIGXCPU: + case SIGXFSZ: + case SIGTRAP: + case SIGHUP: + case SIGPIPE: + case SIGPOLL: + case SIGURG: + case SIGTSTP: + case SIGTTIN: + case SIGTTOU: + posix_psignal(signo, "Unsupported signal caught"); + abort(); + case SIGCHLD: + case SIGUSR1: + case SIGUSR2: + case SIGALRM: + case SIGVTALRM: + case SIGPROF: + case SIGCONT: + /* ignored */ + break; + } +} + +/** + * Just an empty function to get an unique pointer value for comparison. + * + * @param signo Signal number. + */ +void __posix_hold_signal_handler(int signo) +{ + /* Nothing */ +} + +/** + * Empty function to be used as ignoring handler. + * + * @param signo Signal number. + */ +void __posix_ignore_signal_handler(int signo) +{ + /* Nothing */ +} + +/** + * Clear the signal set. + * + * @param set Pointer to the signal set. + * @return Always returns zero. + */ +int posix_sigemptyset(posix_sigset_t *set) +{ + assert(set != NULL); + + *set = 0; + return 0; +} + +/** + * Fill the signal set (i.e. add all signals). + * + * @param set Pointer to the signal set. + * @return Always returns zero. + */ +int posix_sigfillset(posix_sigset_t *set) +{ + assert(set != NULL); + + *set = UINT32_MAX; + return 0; +} + +/** + * Add a signal to the set. + * + * @param set Pointer to the signal set. + * @param signo Signal number to add. + * @return Always returns zero. + */ +int posix_sigaddset(posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + *set |= (1 << signo); + return 0; +} + +/** + * Delete a signal from the set. + * + * @param set Pointer to the signal set. + * @param signo Signal number to remove. + * @return Always returns zero. + */ +int posix_sigdelset(posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + *set &= ~(1 << signo); + return 0; +} + +/** + * Inclusion test for a signal set. + * + * @param set Pointer to the signal set. + * @param signo Signal number to query. + * @return 1 if the signal is in the set, 0 otherwise. + */ +int posix_sigismember(const posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + return (*set & (1 << signo)) != 0; +} + +/** + * Unsafe variant of the sigaction() function. + * Doesn't do any checking of its arguments and + * does not deal with thread-safety. + * + * @param sig + * @param act + * @param oact + */ +static void _sigaction_unsafe(int sig, const struct posix_sigaction *restrict act, + struct posix_sigaction *restrict oact) +{ + if (oact != NULL) { + memcpy(oact, &_signal_actions[sig], + sizeof(struct posix_sigaction)); + } + + if (act != NULL) { + memcpy(&_signal_actions[sig], act, + sizeof(struct posix_sigaction)); + } +} + +/** + * Sets a new action for the given signal number. + * + * @param sig Signal number to set action for. + * @param act If not NULL, contents of this structure are + * used as the new action for the signal. + * @param oact If not NULL, the original action associated with the signal + * is stored in the structure pointer to. + * @return -1 with errno set on failure, 0 on success. + */ +int posix_sigaction(int sig, const struct posix_sigaction *restrict act, + struct posix_sigaction *restrict oact) +{ + if (sig > _TOP_SIGNAL || (act != NULL && + (sig == SIGKILL || sig == SIGSTOP))) { + errno = EINVAL; + return -1; + } + + if (sig > _TOP_CATCHABLE_SIGNAL) { + posix_psignal(sig, + "WARNING: registering handler for a partially" + " or fully unsupported signal. This handler may only be" + " invoked by the raise() function, which may not be what" + " the application developer intended"); + } + + fibril_mutex_lock(&_signal_mutex); + _sigaction_unsafe(sig, act, oact); + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * Sets a new handler for the given signal number. + * + * @param sig Signal number to set handler for. + * @param func Handler function. + * @return SIG_ERR on failure, original handler on success. + */ +void (*posix_signal(int sig, void (*func)(int)))(int) +{ + struct posix_sigaction new = { + .sa_handler = func, + .sa_mask = 0, + .sa_flags = 0, + .sa_sigaction = NULL + }; + struct posix_sigaction old; + if (posix_sigaction(sig, func == NULL ? NULL : &new, &old) == 0) { + return old.sa_handler; + } else { + return SIG_ERR; + } +} + +typedef struct { + link_t link; + int signo; + posix_siginfo_t siginfo; +} signal_queue_item; + +/** + * Queue blocked signal. + * + * @param signo Signal number. + * @param siginfo Additional information about the signal. + */ +static void _queue_signal(int signo, posix_siginfo_t *siginfo) +{ + assert(signo >= 0 && signo <= _TOP_SIGNAL); + assert(siginfo != NULL); + + signal_queue_item *item = malloc(sizeof(signal_queue_item)); + link_initialize(&(item->link)); + item->signo = signo; + memcpy(&item->siginfo, siginfo, sizeof(posix_siginfo_t)); + list_append(&(item->link), &_signal_queue); +} + + +/** + * Executes an action associated with the given signal. + * + * @param signo Signal number. + * @param siginfo Additional information about the circumstances of this raise. + * @return 0 if the action has been successfully executed. -1 if the signal is + * blocked. + */ +static int _raise_sigaction(int signo, posix_siginfo_t *siginfo) +{ + assert(signo >= 0 && signo <= _TOP_SIGNAL); + assert(siginfo != NULL); + + fibril_mutex_lock(&_signal_mutex); + + struct posix_sigaction action = _signal_actions[signo]; + + if (posix_sigismember(&_signal_mask, signo) || + action.sa_handler == SIG_HOLD) { + _queue_signal(signo, siginfo); + fibril_mutex_unlock(&_signal_mutex); + return -1; + } + + /* Modifying signal mask is unnecessary, + * signal handling is serialized. + */ + + if ((action.sa_flags & SA_RESETHAND) && signo != SIGILL && signo != SIGTRAP) { + _signal_actions[signo] = (struct posix_sigaction) DEFAULT_HANDLER; + } + + if (action.sa_flags & SA_SIGINFO) { + assert(action.sa_sigaction != NULL); + action.sa_sigaction(signo, siginfo, NULL); + } else { + assert(action.sa_handler != NULL); + action.sa_handler(signo); + } + + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * Raise all unblocked previously queued signals. + */ +static void _dequeue_unblocked_signals(void) +{ + link_t *iterator = _signal_queue.head.next; + link_t *next; + + while (iterator != &(_signal_queue).head) { + next = iterator->next; + + signal_queue_item *item = + list_get_instance(iterator, signal_queue_item, link); + + if (!posix_sigismember(&_signal_mask, item->signo) && + _signal_actions[item->signo].sa_handler != SIG_HOLD) { + list_remove(&(item->link)); + _raise_sigaction(item->signo, &(item->siginfo)); + free(item); + } + + iterator = next; + } +} + +/** + * Raise a signal for the calling process. + * + * @param sig Signal number. + * @return -1 with errno set on failure, 0 on success. + */ +int posix_raise(int sig) +{ + if (sig >= 0 && sig <= _TOP_SIGNAL) { + posix_siginfo_t siginfo = { + .si_signo = sig, + .si_code = SI_USER + }; + return _raise_sigaction(sig, &siginfo); + } else { + errno = EINVAL; + return -1; + } +} + +/** + * Raises a signal for a selected process. + * + * @param pid PID of the process for which the signal shall be raised. + * @param signo Signal to raise. + * @return -1 with errno set on failure (possible errors include unsupported + * action, invalid signal number, lack of permissions, etc.), 0 on success. + */ +int posix_kill(posix_pid_t pid, int signo) +{ + if (pid < 1) { + // TODO + errno = ENOTSUP; + return -1; + } + + if (signo > _TOP_SIGNAL) { + errno = EINVAL; + return -1; + } + + if (pid == (posix_pid_t) task_get_id()) { + return posix_raise(signo); + } + + switch (signo) { + case SIGKILL: + task_kill(pid); + break; + default: + /* Nothing else supported yet. */ + errno = ENOTSUP; + return -1; + } + + return 0; +} + +/** + * Send a signal to a process group. Always fails at the moment because of + * lack of this functionality in HelenOS. + * + * @param pid PID of the process group. + * @param sig Signal number. + * @return -1 on failure, 0 on success (see kill()). + */ +int posix_killpg(posix_pid_t pid, int sig) +{ + assert(pid > 1); + return posix_kill(-pid, sig); +} + +/** + * Outputs information about the signal to the standard error stream. + * + * @param pinfo SigInfo struct to write. + * @param message String to output alongside human-readable signal description. + */ +void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message) +{ + assert(pinfo != NULL); + posix_psignal(pinfo->si_signo, message); + // TODO: print si_code +} + +/** + * Outputs information about the signal to the standard error stream. + * + * @param signum Signal number. + * @param message String to output alongside human-readable signal description. + */ +void posix_psignal(int signum, const char *message) +{ + char *sigmsg = posix_strsignal(signum); + if (message == NULL || *message == '\0') { + fprintf(stderr, "%s\n", sigmsg); + } else { + fprintf(stderr, "%s: %s\n", message, sigmsg); + } +} + +/** + * Manipulate the signal mask of the calling thread. + * + * @param how What to do with the mask. + * @param set Signal set to work with. + * @param oset If not NULL, the original signal mask is coppied here. + * @return 0 success, errorcode on failure. + */ +int posix_thread_sigmask(int how, const posix_sigset_t *restrict set, + posix_sigset_t *restrict oset) +{ + fibril_mutex_lock(&_signal_mutex); + + if (oset != NULL) { + *oset = _signal_mask; + } + if (set != NULL) { + switch (how) { + case SIG_BLOCK: + _signal_mask |= *set; + break; + case SIG_UNBLOCK: + _signal_mask &= ~*set; + break; + case SIG_SETMASK: + _signal_mask = *set; + break; + default: + fibril_mutex_unlock(&_signal_mutex); + return EINVAL; + } + } + + _dequeue_unblocked_signals(); + + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * Manipulate the signal mask of the process. + * + * @param how What to do with the mask. + * @param set Signal set to work with. + * @param oset If not NULL, the original signal mask is coppied here. + * @return 0 on success, -1 with errno set on failure. + */ +int posix_sigprocmask(int how, const posix_sigset_t *restrict set, + posix_sigset_t *restrict oset) +{ + int result = posix_thread_sigmask(how, set, oset); + if (result != 0) { + errno = result; + return -1; + } + return 0; +} + +/** @} + */ Index: uspace/lib/posix/src/stdio.c =================================================================== --- uspace/lib/posix/src/stdio.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/stdio.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,711 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard buffered input/output. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/stdio.h" + +#include + +#include + +#include "posix/stdlib.h" +#include "posix/string.h" +#include "posix/sys/types.h" +#include "posix/unistd.h" + +#include "libc/stdio.h" +#include "libc/io/printf_core.h" +#include "libc/str.h" +#include "libc/malloc.h" +#include "libc/adt/list.h" + +/** Clears the stream's error and end-of-file indicators. + * + * @param stream Stream whose indicators shall be cleared. + */ +void posix_clearerr(FILE *stream) +{ + clearerr(stream); +} + +/** + * Generate a pathname for the controlling terminal. + * + * @param s Allocated buffer to which the pathname shall be put. + * @return Either s or static location filled with the requested pathname. + */ +char *posix_ctermid(char *s) +{ + /* Currently always returns an error value (empty string). */ + // TODO: return a real terminal path + + static char dummy_path[L_ctermid] = {'\0'}; + + if (s == NULL) { + return dummy_path; + } + + s[0] = '\0'; + return s; +} + +/** + * Put a string on the stream. + * + * @param s String to be written. + * @param stream Output stream. + * @return Non-negative on success, EOF on failure. + */ +int posix_fputs(const char *restrict s, FILE *restrict stream) +{ + return fputs(s, stream); +} + +/** + * Push byte back into input stream. + * + * @param c Byte to be pushed back. + * @param stream Stream to where the byte shall be pushed. + * @return Provided byte on success or EOF if not possible. + */ +int posix_ungetc(int c, FILE *stream) +{ + return ungetc(c, stream); +} + +/** + * Read a stream until the delimiter (or EOF) is encountered. + * + * @param lineptr Pointer to the output buffer in which there will be stored + * nul-terminated string together with the delimiter (if encountered). + * Will be resized if necessary. + * @param n Pointer to the size of the output buffer. Will be increased if + * necessary. + * @param delimiter Delimiter on which to finish reading the stream. + * @param stream Input stream. + * @return Number of fetched characters (including delimiter if encountered) + * or -1 on error (set in errno). + */ +ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n, + int delimiter, FILE *restrict stream) +{ + /* Check arguments for sanity. */ + if (!lineptr || !n) { + errno = EINVAL; + return -1; + } + + size_t alloc_step = 80; /* Buffer size gain during reallocation. */ + char *pos = *lineptr; /* Next free byte of the output buffer. */ + size_t cnt = 0; /* Number of fetched characters. */ + int c = fgetc(stream); /* Current input character. Might be EOF. */ + + do { + /* Mask EOF as NUL to terminate string. */ + if (c == EOF) { + c = '\0'; + } + + /* Ensure there is still space left in the buffer. */ + if (pos == *lineptr + *n) { + *lineptr = realloc(*lineptr, *n + alloc_step); + if (*lineptr) { + pos = *lineptr + *n; + *n += alloc_step; + } else { + errno = ENOMEM; + return -1; + } + } + + /* Store the fetched character. */ + *pos = c; + + /* Fetch the next character according to the current character. */ + if (c != '\0') { + ++pos; + ++cnt; + if (c == delimiter) { + /* Delimiter was just stored. Provide EOF as the next + * character - it will be masked as NUL and output string + * will be properly terminated. */ + c = EOF; + } else { + /* Neither delimiter nor EOF were encountered. Just fetch + * the next character from the stream. */ + c = fgetc(stream); + } + } + } while (c != '\0'); + + if (errno == EOK && cnt > 0) { + return cnt; + } else { + /* Either some error occured or the stream was already at EOF. */ + return -1; + } +} + +/** + * Read a stream until the newline (or EOF) is encountered. + * + * @param lineptr Pointer to the output buffer in which there will be stored + * nul-terminated string together with the delimiter (if encountered). + * Will be resized if necessary. + * @param n Pointer to the size of the output buffer. Will be increased if + * necessary. + * @param stream Input stream. + * @return Number of fetched characters (including newline if encountered) + * or -1 on error (set in errno). + */ +ssize_t posix_getline(char **restrict lineptr, size_t *restrict n, + FILE *restrict stream) +{ + return posix_getdelim(lineptr, n, '\n', stream); +} + +/** + * Reopen a file stream. + * + * @param filename Pathname of a file to be reopened or NULL for changing + * the mode of the stream. + * @param mode Mode to be used for reopening the file or changing current + * mode of the stream. + * @param stream Current stream associated with the opened file. + * @return On success, either a stream of the reopened file or the provided + * stream with a changed mode. NULL otherwise. + */ +FILE *posix_freopen(const char *restrict filename, + const char *restrict mode, FILE *restrict stream) +{ + return freopen(filename, mode, stream); +} + +/** + * Write error messages to standard error. + * + * @param s Error message. + */ +void posix_perror(const char *s) +{ + if (s == NULL || s[0] == '\0') { + fprintf(stderr, "%s\n", posix_strerror(errno)); + } else { + fprintf(stderr, "%s: %s\n", s, posix_strerror(errno)); + } +} + +/** Restores stream a to position previously saved with fgetpos(). + * + * @param stream Stream to restore + * @param pos Position to restore + * @return Zero on success, non-zero (with errno set) on failure + */ +int posix_fsetpos(FILE *stream, const posix_fpos_t *pos) +{ + return fseek(stream, pos->offset, SEEK_SET); +} + +/** Saves the stream's position for later use by fsetpos(). + * + * @param stream Stream to save + * @param pos Place to store the position + * @return Zero on success, non-zero (with errno set) on failure + */ +int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos) +{ + off64_t ret = ftell(stream); + if (ret != -1) { + pos->offset = ret; + return 0; + } else { + return -1; + } +} + +/** + * Reposition a file-position indicator in a stream. + * + * @param stream Stream to seek in. + * @param offset Direction and amount of bytes to seek. + * @param whence From where to seek. + * @return Zero on success, -1 otherwise. + */ +int posix_fseek(FILE *stream, long offset, int whence) +{ + return fseek(stream, (off64_t) offset, whence); +} + +/** + * Reposition a file-position indicator in a stream. + * + * @param stream Stream to seek in. + * @param offset Direction and amount of bytes to seek. + * @param whence From where to seek. + * @return Zero on success, -1 otherwise. + */ +int posix_fseeko(FILE *stream, posix_off_t offset, int whence) +{ + return fseek(stream, (off64_t) offset, whence); +} + +/** + * Discover current file offset in a stream. + * + * @param stream Stream for which the offset shall be retrieved. + * @return Current offset or -1 if not possible. + */ +long posix_ftell(FILE *stream) +{ + return (long) ftell(stream); +} + +/** + * Discover current file offset in a stream. + * + * @param stream Stream for which the offset shall be retrieved. + * @return Current offset or -1 if not possible. + */ +posix_off_t posix_ftello(FILE *stream) +{ + return (posix_off_t) ftell(stream); +} + +/** + * Discard prefetched data or write unwritten data. + * + * @param stream Stream that shall be flushed. + * @return Zero on success, EOF on failure. + */ +int posix_fflush(FILE *stream) +{ + return fflush(stream); +} + +/** + * Print formatted output to the opened file. + * + * @param fildes File descriptor of the opened file. + * @param format Format description. + * @return Either the number of printed characters or negative value on error. + */ +int posix_dprintf(int fildes, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vdprintf(fildes, format, list); + va_end(list); + return result; +} + +/** + * Write ordinary string to the opened file. + * + * @param str String to be written. + * @param size Size of the string (in bytes).. + * @param fd File descriptor of the opened file. + * @return The number of written characters. + */ +static int _dprintf_str_write(const char *str, size_t size, void *fd) +{ + const int fildes = *(int *) fd; + size_t wr; + if (failed(vfs_write(fildes, &posix_pos[fildes], str, size, &wr))) + return -1; + return str_nlength(str, wr); +} + +/** + * Write wide string to the opened file. + * + * @param str String to be written. + * @param size Size of the string (in bytes). + * @param fd File descriptor of the opened file. + * @return The number of written characters. + */ +static int _dprintf_wstr_write(const wchar_t *str, size_t size, void *fd) +{ + size_t offset = 0; + size_t chars = 0; + size_t sz; + char buf[4]; + + while (offset < size) { + sz = 0; + if (chr_encode(str[chars], buf, &sz, sizeof(buf)) != EOK) { + break; + } + + const int fildes = *(int *) fd; + size_t nwr; + if (vfs_write(fildes, &posix_pos[fildes], buf, sz, &nwr) != EOK) + break; + + chars++; + offset += sizeof(wchar_t); + } + + return chars; +} + +/** + * Print formatted output to the opened file. + * + * @param fildes File descriptor of the opened file. + * @param format Format description. + * @param ap Print arguments. + * @return Either the number of printed characters or negative value on error. + */ +int posix_vdprintf(int fildes, const char *restrict format, va_list ap) +{ + printf_spec_t spec = { + .str_write = _dprintf_str_write, + .wstr_write = _dprintf_wstr_write, + .data = &fildes + }; + + return printf_core(format, &spec, ap); +} + +/** + * Print formatted output to the string. + * + * @param s Output string. + * @param format Format description. + * @return Either the number of printed characters (excluding null byte) or + * negative value on error. + */ +int posix_sprintf(char *s, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vsprintf(s, format, list); + va_end(list); + return result; +} + +/** + * Print formatted output to the string. + * + * @param s Output string. + * @param format Format description. + * @param ap Print arguments. + * @return Either the number of printed characters (excluding null byte) or + * negative value on error. + */ +int posix_vsprintf(char *s, const char *restrict format, va_list ap) +{ + return vsnprintf(s, STR_NO_LIMIT, format, ap); +} + +/** + * Convert formatted input from the stream. + * + * @param stream Input stream. + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_fscanf(FILE *restrict stream, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vfscanf(stream, format, list); + va_end(list); + return result; +} + +/** + * Convert formatted input from the standard input. + * + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_scanf(const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vscanf(format, list); + va_end(list); + return result; +} + +/** + * Convert formatted input from the standard input. + * + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vscanf(const char *restrict format, va_list arg) +{ + return posix_vfscanf(stdin, format, arg); +} + +/** + * Convert formatted input from the string. + * + * @param s Input string. + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_sscanf(const char *restrict s, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vsscanf(s, format, list); + va_end(list); + return result; +} + +/** + * Acquire file stream for the thread. + * + * @param file File stream to lock. + */ +void posix_flockfile(FILE *file) +{ + /* dummy */ +} + +/** + * Acquire file stream for the thread (non-blocking). + * + * @param file File stream to lock. + * @return Zero for success and non-zero if the lock cannot be acquired. + */ +int posix_ftrylockfile(FILE *file) +{ + /* dummy */ + return 0; +} + +/** + * Relinquish the ownership of the locked file stream. + * + * @param file File stream to unlock. + */ +void posix_funlockfile(FILE *file) +{ + /* dummy */ +} + +/** + * Get a byte from a stream (thread-unsafe). + * + * @param stream Input file stream. + * @return Either read byte or EOF. + */ +int posix_getc_unlocked(FILE *stream) +{ + return getc(stream); +} + +/** + * Get a byte from the standard input stream (thread-unsafe). + * + * @return Either read byte or EOF. + */ +int posix_getchar_unlocked(void) +{ + return getchar(); +} + +/** + * Put a byte on a stream (thread-unsafe). + * + * @param c Byte to output. + * @param stream Output file stream. + * @return Either written byte or EOF. + */ +int posix_putc_unlocked(int c, FILE *stream) +{ + return putc(c, stream); +} + +/** + * Put a byte on the standard output stream (thread-unsafe). + * + * @param c Byte to output. + * @return Either written byte or EOF. + */ +int posix_putchar_unlocked(int c) +{ + return putchar(c); +} + +/** + * Remove a file or directory. + * + * @param path Pathname of the file that shall be removed. + * @return Zero on success, -1 (with errno set) otherwise. + */ +int posix_remove(const char *path) +{ + if (failed(vfs_unlink_path(path))) + return -1; + else + return 0; +} + +/** + * Rename a file or directory. + * + * @param old Old pathname. + * @param new New pathname. + * @return Zero on success, -1 (with errno set) otherwise. + */ +int posix_rename(const char *old, const char *new) +{ + if (failed(vfs_rename_path(old, new))) + return -1; + else + return 0; +} + +/** + * Get a unique temporary file name (obsolete). + * + * @param s Buffer for the file name. Must be at least L_tmpnam bytes long. + * @return The value of s on success, NULL on failure. + */ +char *posix_tmpnam(char *s) +{ + assert(L_tmpnam >= posix_strlen("/tmp/tnXXXXXX")); + + static char buffer[L_tmpnam + 1]; + if (s == NULL) { + s = buffer; + } + + posix_strcpy(s, "/tmp/tnXXXXXX"); + posix_mktemp(s); + + if (*s == '\0') { + /* Errno set by mktemp(). */ + return NULL; + } + + return s; +} + +/** + * Get an unique temporary file name with additional constraints (obsolete). + * + * @param dir Path to directory, where the file should be created. + * @param pfx Optional prefix up to 5 characters long. + * @return Newly allocated unique path for temporary file. NULL on failure. + */ +char *posix_tempnam(const char *dir, const char *pfx) +{ + /* Sequence number of the filename. */ + static int seq = 0; + + size_t dir_len = posix_strlen(dir); + if (dir[dir_len - 1] == '/') { + dir_len--; + } + + size_t pfx_len = posix_strlen(pfx); + if (pfx_len > 5) { + pfx_len = 5; + } + + char *result = malloc(dir_len + /* slash*/ 1 + + pfx_len + /* three-digit seq */ 3 + /* .tmp */ 4 + /* nul */ 1); + + if (result == NULL) { + errno = ENOMEM; + return NULL; + } + + char *res_ptr = result; + posix_strncpy(res_ptr, dir, dir_len); + res_ptr += dir_len; + posix_strncpy(res_ptr, pfx, pfx_len); + res_ptr += pfx_len; + + for (; seq < 1000; ++seq) { + snprintf(res_ptr, 8, "%03d.tmp", seq); + + int orig_errno = errno; + errno = EOK; + /* Check if the file exists. */ + if (posix_access(result, F_OK) == -1) { + if (errno == ENOENT) { + errno = orig_errno; + break; + } else { + /* errno set by access() */ + return NULL; + } + } + } + + if (seq == 1000) { + free(result); + errno = EINVAL; + return NULL; + } + + return result; +} + +/** + * Create and open an unique temporary file. + * The file is automatically removed when the stream is closed. + * + * @param dir Path to directory, where the file should be created. + * @param pfx Optional prefix up to 5 characters long. + * @return Newly allocated unique path for temporary file. NULL on failure. + */ +FILE *posix_tmpfile(void) +{ + char filename[] = "/tmp/tfXXXXXX"; + int fd = posix_mkstemp(filename); + if (fd == -1) { + /* errno set by mkstemp(). */ + return NULL; + } + + /* Unlink the created file, so that it's removed on close(). */ + posix_unlink(filename); + return fdopen(fd, "w+"); +} + +/** @} + */ Index: uspace/lib/posix/src/stdio/scanf.c =================================================================== --- uspace/lib/posix/src/stdio/scanf.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/stdio/scanf.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,1229 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Implementation of the scanf backend. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include + +#include + +#include "posix/stdio.h" +#include "posix/stdlib.h" +#include "posix/stddef.h" +#include "posix/string.h" +#include "posix/ctype.h" +#include "posix/sys/types.h" + +#include "../internal/common.h" +#include "libc/malloc.h" +#include "libc/stdbool.h" + +/** Unified data type for possible data sources for scanf. */ +typedef union __data_source { + FILE *stream; /**< Input file stream. */ + const char *string; /**< Input string. */ +} _data_source; + +/** Internal state of the input provider. */ +enum { + /** Partly constructed but not yet functional. */ + _PROV_CONSTRUCTED, + /** Ready to serve any request. */ + _PROV_READY, + /** Cursor is temporarily lent to the external entity. No action is + * possible until the cursor is returned. */ + _PROV_CURSOR_LENT, +}; + +/** Universal abstraction over data input for scanf. */ +typedef struct __input_provider { + /** Source of data elements. */ + _data_source source; + /** How many elements was already processed. */ + int consumed; + /** How many elements was already fetched from the source. */ + int fetched; + /** Elements are fetched from the source in batches (e.g. by getline()) + * to allow using strtol/strtod family even on streams. */ + char *window; + /** Size of the current window. */ + size_t window_size; + /** Points to the next element to be processed inside the current window. */ + const char *cursor; + /** Internal state of the provider. */ + int state; + + /** Take control over data source. Finish initialization of the internal + * structures (e.g. allocation of window). */ + void (*capture)(struct __input_provider *); + /** Get a single element from the source and update the internal structures + * accordingly (e.g. greedy update of the window). Return -1 if the + * element cannot be obtained. */ + int (*pop)(struct __input_provider *); + /** Undo the most recent not-undone pop operation. Might be necesarry to + * flush current window and seek data source backwards. Return 0 if the + * pop history is exhausted, non-zero on success. */ + int (*undo)(struct __input_provider *); + /** Lend the cursor to the caller. */ + const char * (*borrow_cursor)(struct __input_provider *); + /** Take control over possibly incremented cursor and update the internal + * structures if necessary. */ + void (*return_cursor)(struct __input_provider *, const char *); + /** Release the control over the source. That is, synchronize any + * fetched but non-consumed elements (e.g. by seeking) and destruct + * internal structures (e.g. window deallocation). */ + void (*release)(struct __input_provider *); +} _input_provider; + +/** @see __input_provider */ +static void _capture_stream(_input_provider *self) +{ + assert(self->source.stream); + assert(self->state == _PROV_CONSTRUCTED); + /* Caller could already pre-allocated the window. */ + assert((self->window == NULL && self->window_size == 0) || + (self->window && self->window_size > 0)); + + /* Initialize internal structures. */ + self->consumed = 0; + ssize_t fetched = posix_getline( + &self->window, &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched = fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->fetched = 0; + self->cursor = NULL; + } + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _capture_string(_input_provider *self) +{ + assert(self->source.string); + assert(self->state == _PROV_CONSTRUCTED); + + /* Initialize internal structures. */ + self->consumed = 0; + self->fetched = posix_strlen(self->source.string); + self->window = (char *) self->source.string; + self->window_size = self->fetched + 1; + self->cursor = self->window; + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static int _pop_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->cursor) { + int c = *self->cursor; + ++self->consumed; + ++self->cursor; + /* Do we need to fetch a new line from the source? */ + if (*self->cursor == '\0') { + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched += fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->cursor = NULL; + } + } + return c; + } else { + /* Already at EOF. */ + return -1; + } +} + +/** @see __input_provider */ +static int _pop_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (*self->cursor != '\0') { + int c = *self->cursor; + ++self->consumed; + ++self->cursor; + return c; + } else { + /* String depleted. */ + return -1; + } +} + +/** @see __input_provider */ +static int _undo_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->consumed == 0) { + /* Undo history exhausted. */ + return 0; + } + + if (!self->cursor || self->window == self->cursor) { + /* Complex case. Either at EOF (cursor == NULL) or there is no more + * place to retreat to inside the window. Seek the source backwards + * and flush the window. Regarding the scanf, this could happend only + * when matching unbounded string (%s) or unbounded scanset (%[) not + * containing newline, while at the same time newline is the character + * that breaks the matching process. */ + int rc = posix_fseek( + self->source.stream, -1, SEEK_CUR); + if (rc == -1) { + /* Seek failed. */ + return 0; + } + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + assert(fetched == 1); + self->fetched = self->consumed + 1; + self->cursor = self->window; + } else { + /* Stream is broken. */ + return 0; + } + } else { + /* Simple case. Still inside window. */ + --self->cursor; + } + --self->consumed; + return 1; /* Success. */ +} + +/** @see __input_provider */ +static int _undo_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->consumed > 0) { + --self->consumed; + --self->cursor; + } else { + /* Undo history exhausted. */ + return 0; + } + return 1; /* Success. */ +} + +/** @see __input_provider */ +static const char *_borrow_cursor_universal(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + self->state = _PROV_CURSOR_LENT; + return self->cursor; +} + +/** @see __input_provider */ +static void _return_cursor_stream(_input_provider *self, const char *cursor) +{ + assert(self->state == _PROV_CURSOR_LENT); + + /* Check how much of the window did external entity consumed. */ + self->consumed += cursor - self->cursor; + self->cursor = cursor; + if (*self->cursor == '\0') { + /* Window was completely consumed, fetch new data. */ + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched += fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->cursor = NULL; + } + } + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _return_cursor_string(_input_provider *self, const char *cursor) +{ + assert(self->state == _PROV_CURSOR_LENT); + + /* Check how much of the window did external entity consumed. */ + self->consumed += cursor - self->cursor; + self->cursor = cursor; + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _release_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + assert(self->consumed >= self->fetched); + + /* Try to correct the difference between the stream position and what was + * actually consumed. If it is not possible, continue anyway. */ + posix_fseek(self->source.stream, self->consumed - self->fetched, SEEK_CUR); + + /* Destruct internal structures. */ + self->fetched = 0; + self->cursor = NULL; + if (self->window) { + free(self->window); + self->window = NULL; + } + self->window_size = 0; + self->state = _PROV_CONSTRUCTED; +} + +/** @see __input_provider */ +static void _release_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + /* Destruct internal structures. */ + self->fetched = 0; + self->cursor = NULL; + self->window = NULL; + self->window_size = 0; + self->state = _PROV_CONSTRUCTED; +} + +/** Length modifier values. */ +enum { + LMOD_NONE, + LMOD_hh, + LMOD_h, + LMOD_l, + LMOD_ll, + LMOD_j, + LMOD_z, + LMOD_t, + LMOD_L, + LMOD_p, /* Reserved for %p conversion. */ +}; + +/** + * Decides whether provided characters specify length modifier. If so, the + * recognized modifier is stored through provider pointer. + * + * @param c Candidate on the length modifier. + * @param _c Next character (might be NUL). + * @param modifier Pointer to the modifier value. + * @return Whether the modifier was recognized or not. + */ +static inline int is_length_mod(int c, int _c, int *modifier) +{ + assert(modifier); + + switch (c) { + case 'h': + /* Check whether the modifier was not already recognized. */ + if (*modifier == LMOD_NONE) { + *modifier = _c == 'h' ? LMOD_hh : LMOD_h; + } else { + /* Format string is invalid. Notify the caller. */ + *modifier = LMOD_NONE; + } + return 1; + case 'l': + if (*modifier == LMOD_NONE) { + *modifier = _c == 'l' ? LMOD_ll : LMOD_l; + } else { + *modifier = LMOD_NONE; + } + return 1; + case 'j': + *modifier = *modifier == LMOD_NONE ? LMOD_j : LMOD_NONE; + return 1; + case 'z': + *modifier = *modifier == LMOD_NONE ? LMOD_z : LMOD_NONE; + return 1; + case 't': + *modifier = *modifier == LMOD_NONE ? LMOD_t : LMOD_NONE; + return 1; + case 'L': + *modifier = *modifier == LMOD_NONE ? LMOD_L : LMOD_NONE; + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies integer conversion. If so, the + * semantics of the conversion is stored through provided pointers.. + * + * @param c Candidate on the integer conversion. + * @param is_unsigned Pointer to store whether the conversion is signed or not. + * @param base Pointer to store the base of the integer conversion. + * @return Whether the conversion was recognized or not. + */ +static inline int is_int_conv(int c, bool *is_unsigned, int *base) +{ + assert(is_unsigned && base); + + switch (c) { + case 'd': + *is_unsigned = false; + *base = 10; + return 1; + case 'i': + *is_unsigned = false; + *base = 0; + return 1; + case 'o': + *is_unsigned = true; + *base = 8; + return 1; + case 'u': + *is_unsigned = true; + *base = 10; + return 1; + case 'p': /* According to POSIX, %p modifier is implementation defined but + * must correspond to its printf counterpart. */ + case 'x': + case 'X': + *is_unsigned = true; + *base = 16; + return 1; + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies conversion of the floating + * point number. + * + * @param c Candidate on the floating point conversion. + * @return Whether the conversion was recognized or not. + */ +static inline int is_float_conv(int c) +{ + switch (c) { + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies conversion of the character + * sequence. + * + * @param c Candidate on the character sequence conversion. + * @param modifier Pointer to store length modifier for wide chars. + * @return Whether the conversion was recognized or not. + */ +static inline int is_seq_conv(int c, int *modifier) +{ + assert(modifier); + + switch (c) { + case 'S': + *modifier = LMOD_l; + /* Fallthrough */ + case 's': + return 1; + case 'C': + *modifier = LMOD_l; + /* Fallthrough */ + case 'c': + return 1; + case '[': + return 1; + default: + return 0; + } +} + +/** + * Backend for the whole family of scanf functions. Uses input provider + * to abstract over differences between strings and streams. Should be + * POSIX compliant (apart from the not supported stuff). + * + * NOT SUPPORTED: locale (see strtold), wide chars, numbered output arguments + * + * @param in Input provider. + * @param fmt Format description. + * @param arg Output arguments. + * @return The number of converted output items or EOF on failure. + */ +static inline int _internal_scanf( + _input_provider *in, const char *restrict fmt, va_list arg) +{ + int c = -1; + int converted_cnt = 0; + bool converting = false; + bool matching_failure = false; + + bool assign_supress = false; + bool assign_alloc = false; + long width = -1; + int length_mod = LMOD_NONE; + bool int_conv_unsigned = false; + int int_conv_base = 0; + + /* Buffers allocated by scanf for optional 'm' specifier must be remembered + * to deallocaate them in case of an error. Because each of those buffers + * corresponds to one of the argument from va_list, there is an upper bound + * on the number of those arguments. In case of C99, this uppper bound is + * 127 arguments. */ + char *buffers[127]; + for (int i = 0; i < 127; ++i) { + buffers[i] = NULL; + } + int next_unused_buffer_idx = 0; + + in->capture(in); + + /* Interpret format string. Control shall prematurely jump from the cycle + * on input failure, matching failure or illegal format string. In order + * to keep error reporting simple enough and to keep input consistent, + * error condition shall be always manifested as jump from the cycle, + * not function return. Format string pointer shall be updated specifically + * for each sub-case (i.e. there shall be no loop-wide increment).*/ + while (*fmt) { + + if (converting) { + + /* Processing inside conversion specifier. Either collect optional + * parameters or execute the conversion. When the conversion + * is successfully completed, increment conversion count and switch + * back to normal mode. */ + if (*fmt == '*') { + /* Assignment-supression (optional). */ + if (assign_supress) { + /* Already set. Illegal format string. */ + break; + } + assign_supress = true; + ++fmt; + } else if (*fmt == 'm') { + /* Assignment-allocation (optional). */ + if (assign_alloc) { + /* Already set. Illegal format string. */ + break; + } + assign_alloc = true; + ++fmt; + } else if (*fmt == '$') { + /* Reference to numbered output argument. */ + // TODO + not_implemented(); + } else if (isdigit(*fmt)) { + /* Maximum field length (optional). */ + if (width != -1) { + /* Already set. Illegal format string. */ + break; + } + char *fmt_new = NULL; + width = strtol(fmt, &fmt_new, 10); + if (width != 0) { + fmt = fmt_new; + } else { + /* Since POSIX requires width to be non-zero, it is + * sufficient to interpret zero width as error without + * referring to errno. */ + break; + } + } else if (is_length_mod(*fmt, *(fmt + 1), &length_mod)) { + /* Length modifier (optional). */ + if (length_mod == LMOD_NONE) { + /* Already set. Illegal format string. The actual detection + * is carried out in the is_length_mod(). */ + break; + } + if (length_mod == LMOD_hh || length_mod == LMOD_ll) { + /* Modifier was two characters long. */ + ++fmt; + } + ++fmt; + } else if (is_int_conv(*fmt, &int_conv_unsigned, &int_conv_base)) { + /* Integer conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (assign_alloc || length_mod == LMOD_L) { + /* Illegal format string. */ + break; + } + + /* Conversion of the integer with %p specifier needs special + * handling, because it is not allowed to have arbitrary + * length modifier. */ + if (*fmt == 'p') { + if (length_mod == LMOD_NONE) { + length_mod = LMOD_p; + } else { + /* Already set. Illegal format string. */ + break; + } + } + + /* First consume any white spaces, so we can borrow cursor + * from the input provider. This way, the cursor will either + * point to the non-white space while the input will be + * prefetched up to the newline (which is suitable for strtol), + * or the input will be at EOF. */ + do { + c = in->pop(in); + } while (isspace(c)); + + /* After skipping the white spaces, can we actually continue? */ + if (c == -1) { + /* Input failure. */ + break; + } else { + /* Everything is OK, just undo the last pop, so the cursor + * can be borrowed. */ + in->undo(in); + } + + const char *cur_borrowed = NULL; + char *cur_duplicated = NULL; + const char *cur_limited = NULL; + const char *cur_updated = NULL; + + /* Borrow the cursor. Until it is returned to the provider + * we cannot jump from the cycle, because it would leave + * the input inconsistent. */ + cur_borrowed = in->borrow_cursor(in); + + /* If the width is limited, the cursor horizont must be + * decreased accordingly. Otherwise the strtol could read more + * than allowed by width. */ + if (width != -1) { + cur_duplicated = posix_strndup(cur_borrowed, width); + cur_limited = cur_duplicated; + } else { + cur_limited = cur_borrowed; + } + cur_updated = cur_limited; + + long long sres = 0; + unsigned long long ures = 0; + errno = 0; /* Reset errno to recognize error later. */ + /* Try to convert the integer. */ + if (int_conv_unsigned) { + ures = strtoull(cur_limited, (char **) &cur_updated, int_conv_base); + } else { + sres = strtoll(cur_limited, (char **) &cur_updated, int_conv_base); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (cur_duplicated != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_duplicated); + } + cur_limited = NULL; + cur_updated = NULL; + cur_duplicated = NULL; + /* Return the cursor to the provider. Input consistency is again + * the job of the provider, so we can report errors from + * now on. */ + in->return_cursor(in, cur_borrowed); + cur_borrowed = NULL; + + /* Check whether the conversion was successful. */ + if (errno != EOK) { + matching_failure = true; + break; + } + + /* If not supressed, assign the converted integer into + * the next output argument. */ + if (!assign_supress) { + if (int_conv_unsigned) { + switch (length_mod) { + case LMOD_hh: ; /* Label cannot be part of declaration. */ + unsigned char *phh = va_arg(arg, unsigned char *); + *phh = (unsigned char) ures; + break; + case LMOD_h: ; + unsigned short *ph = va_arg(arg, unsigned short *); + *ph = (unsigned short) ures; + break; + case LMOD_NONE: ; + unsigned *pdef = va_arg(arg, unsigned *); + *pdef = (unsigned) ures; + break; + case LMOD_l: ; + unsigned long *pl = va_arg(arg, unsigned long *); + *pl = (unsigned long) ures; + break; + case LMOD_ll: ; + unsigned long long *pll = va_arg(arg, unsigned long long *); + *pll = (unsigned long long) ures; + break; + case LMOD_j: ; + uintmax_t *pj = va_arg(arg, uintmax_t *); + *pj = (uintmax_t) ures; + break; + case LMOD_z: ; + size_t *pz = va_arg(arg, size_t *); + *pz = (size_t) ures; + break; + case LMOD_t: ; + // XXX: What is unsigned counterpart of the ptrdiff_t? + size_t *pt = va_arg(arg, size_t *); + *pt = (size_t) ures; + break; + case LMOD_p: ; + void **pp = va_arg(arg, void **); + *pp = (void *) (uintptr_t) ures; + break; + default: + assert(false); + } + } else { + switch (length_mod) { + case LMOD_hh: ; /* Label cannot be part of declaration. */ + signed char *phh = va_arg(arg, signed char *); + *phh = (signed char) sres; + break; + case LMOD_h: ; + short *ph = va_arg(arg, short *); + *ph = (short) sres; + break; + case LMOD_NONE: ; + int *pdef = va_arg(arg, int *); + *pdef = (int) sres; + break; + case LMOD_l: ; + long *pl = va_arg(arg, long *); + *pl = (long) sres; + break; + case LMOD_ll: ; + long long *pll = va_arg(arg, long long *); + *pll = (long long) sres; + break; + case LMOD_j: ; + intmax_t *pj = va_arg(arg, intmax_t *); + *pj = (intmax_t) sres; + break; + case LMOD_z: ; + ssize_t *pz = va_arg(arg, ssize_t *); + *pz = (ssize_t) sres; + break; + case LMOD_t: ; + ptrdiff_t *pt = va_arg(arg, ptrdiff_t *); + *pt = (ptrdiff_t) sres; + break; + default: + assert(false); + } + } + ++converted_cnt; + } + + converting = false; + ++fmt; + } else if (is_float_conv(*fmt)) { + /* Floating point number conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (assign_alloc) { + /* Illegal format string. */ + break; + } + if (length_mod != LMOD_NONE && + length_mod != LMOD_l && + length_mod != LMOD_L) { + /* Illegal format string. */ + break; + } + + /* First consume any white spaces, so we can borrow cursor + * from the input provider. This way, the cursor will either + * point to the non-white space while the input will be + * prefetched up to the newline (which is suitable for strtof), + * or the input will be at EOF. */ + do { + c = in->pop(in); + } while (isspace(c)); + + /* After skipping the white spaces, can we actually continue? */ + if (c == -1) { + /* Input failure. */ + break; + } else { + /* Everything is OK, just undo the last pop, so the cursor + * can be borrowed. */ + in->undo(in); + } + + const char *cur_borrowed = NULL; + const char *cur_limited = NULL; + char *cur_duplicated = NULL; + const char *cur_updated = NULL; + + /* Borrow the cursor. Until it is returned to the provider + * we cannot jump from the cycle, because it would leave + * the input inconsistent. */ + cur_borrowed = in->borrow_cursor(in); + + /* If the width is limited, the cursor horizont must be + * decreased accordingly. Otherwise the strtof could read more + * than allowed by width. */ + if (width != -1) { + cur_duplicated = posix_strndup(cur_borrowed, width); + cur_limited = cur_duplicated; + } else { + cur_limited = cur_borrowed; + } + cur_updated = cur_limited; + + float fres = 0.0; + double dres = 0.0; + long double ldres = 0.0; + errno = 0; /* Reset errno to recognize error later. */ + /* Try to convert the floating point nubmer. */ + switch (length_mod) { + case LMOD_NONE: + fres = posix_strtof(cur_limited, (char **) &cur_updated); + break; + case LMOD_l: + dres = posix_strtod(cur_limited, (char **) &cur_updated); + break; + case LMOD_L: + ldres = posix_strtold(cur_limited, (char **) &cur_updated); + break; + default: + assert(false); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (cur_duplicated != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_duplicated); + } + cur_limited = NULL; + cur_updated = NULL; + /* Return the cursor to the provider. Input consistency is again + * the job of the provider, so we can report errors from + * now on. */ + in->return_cursor(in, cur_borrowed); + cur_borrowed = NULL; + + /* Check whether the conversion was successful. */ + if (errno != EOK) { + matching_failure = true; + break; + } + + /* If nto supressed, assign the converted floating point number + * into the next output argument. */ + if (!assign_supress) { + switch (length_mod) { + case LMOD_NONE: ; /* Label cannot be part of declaration. */ + float *pf = va_arg(arg, float *); + *pf = fres; + break; + case LMOD_l: ; + double *pd = va_arg(arg, double *); + *pd = dres; + break; + case LMOD_L: ; + long double *pld = va_arg(arg, long double *); + *pld = ldres; + break; + default: + assert(false); + } + ++converted_cnt; + } + + converting = false; + ++fmt; + } else if (is_seq_conv(*fmt, &length_mod)) { + /* Character sequence conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (length_mod != LMOD_NONE && + length_mod != LMOD_l) { + /* Illegal format string. */ + break; + } + + if (length_mod == LMOD_l) { + /* Wide chars not supported. */ + // TODO + not_implemented(); + } + + int term_size = 1; /* Size of the terminator (0 or 1)). */ + if (*fmt == 'c') { + term_size = 0; + width = width == -1 ? 1 : width; + } + + if (*fmt == 's') { + /* Skip white spaces. */ + do { + c = in->pop(in); + } while (isspace(c)); + } else { + /* Fetch a single character. */ + c = in->pop(in); + } + + /* Check whether there is still input to read. */ + if (c == -1) { + /* Input failure. */ + break; + } + + /* Prepare scanset. */ + char terminate_on[256]; + for (int i = 0; i < 256; ++i) { + terminate_on[i] = 0; + } + if (*fmt == 'c') { + ++fmt; + } else if (*fmt == 's') { + terminate_on[' '] = 1; + terminate_on['\n'] = 1; + terminate_on['\t'] = 1; + terminate_on['\f'] = 1; + terminate_on['\r'] = 1; + terminate_on['\v'] = 1; + ++fmt; + } else { + assert(*fmt == '['); + bool not = false; + bool dash = false; + ++fmt; + /* Check for negation. */ + if (*fmt == '^') { + not = true; + ++fmt; + } + /* Check for escape sequences. */ + if (*fmt == '-' || *fmt == ']') { + terminate_on[(int) *fmt] = 1; + ++fmt; + } + /* Check for ordinary characters and ranges. */ + while (*fmt != '\0' && *fmt != ']') { + if (dash) { + for (char chr = *(fmt - 2); chr <= *fmt; ++chr) { + terminate_on[(int) chr] = 1; + } + dash = false; + } else if (*fmt == '-') { + dash = true; + } else { + terminate_on[(int) *fmt] = 1; + } + ++fmt; + } + /* Check for escape sequence. */ + if (dash == true) { + terminate_on['-'] = 1; + } + /* Check whether the specifier was correctly terminated.*/ + if (*fmt == '\0') { + /* Illegal format string. */ + break; + } else { + ++fmt; + } + /* Inverse the scanset if necessary. */ + if (not == false) { + for (int i = 0; i < 256; ++i) { + terminate_on[i] = terminate_on[i] ? 0 : 1; + } + } + } + + char * buf = NULL; + size_t buf_size = 0; + char * cur = NULL; + size_t alloc_step = 80; /* Buffer size gain during reallocation. */ + int my_buffer_idx = 0; + + /* Retrieve the buffer into which popped characters + * will be stored. */ + if (!assign_supress) { + if (assign_alloc) { + /* We must allocate our own buffer. */ + buf_size = + width == -1 ? alloc_step : (size_t) width + term_size; + buf = malloc(buf_size); + if (!buf) { + /* No memory. */ + break; + } + my_buffer_idx = next_unused_buffer_idx; + ++next_unused_buffer_idx; + buffers[my_buffer_idx] = buf; + cur = buf; + } else { + /* Caller provided its buffer. */ + buf = va_arg(arg, char *); + cur = buf; + buf_size = + width == -1 ? SIZE_MAX : (size_t) width + term_size; + } + } + + /* Match the string. The next character is already popped. */ + while ((width == -1 || width > 0) && c != -1 && !terminate_on[c]) { + + /* Check whether the buffer is still sufficiently large. */ + if (!assign_supress) { + /* Always reserve space for the null terminator. */ + if (cur == buf + buf_size - term_size) { + /* Buffer size must be increased. */ + buf = realloc(buf, buf_size + alloc_step); + if (buf) { + buffers[my_buffer_idx] = buf; + cur = buf + buf_size - term_size; + buf_size += alloc_step; + } else { + /* Break just from this tight loop. Errno will + * be checked after it. */ + break; + } + } + /* Store the input character. */ + *cur = c; + } + + width = width == -1 ? -1 : width - 1; + ++cur; + c = in->pop(in); + } + if (errno == ENOMEM) { + /* No memory. */ + break; + } + if (c != -1) { + /* There is still more input, so undo the last pop. */ + in->undo(in); + } + + /* Check for failures. */ + if (cur == buf) { + /* Matching failure. Input failure was already checked + * earlier. */ + matching_failure = true; + if (!assign_supress && assign_alloc) { + /* Roll back. */ + free(buf); + buffers[my_buffer_idx] = NULL; + --next_unused_buffer_idx; + } + break; + } + + /* Store the terminator. */ + if (!assign_supress && term_size > 0) { + /* Space for the terminator was reserved. */ + *cur = '\0'; + } + + /* Store the result if not already stored. */ + if (!assign_supress) { + if (assign_alloc) { + char **pbuf = va_arg(arg, char **); + *pbuf = buf; + } + ++converted_cnt; + } + + converting = false; + /* Format string pointer already incremented. */ + } else if (*fmt == 'n') { + /* Report the number of consumed bytes so far. */ + + /* Sanity check. */ + bool sane = + width == -1 && + length_mod == LMOD_NONE && + assign_alloc == false && + assign_supress == false; + + if (sane) { + int *pi = va_arg(arg, int *); + *pi = in->consumed; + } else { + /* Illegal format string. */ + break; + } + + /* This shall not be counted as conversion. */ + converting = false; + ++fmt; + } else { + /* Illegal format string. */ + break; + } + + } else { + + /* Processing outside conversion specifier. Either skip white + * spaces or match characters one by one. If conversion specifier + * is detected, switch to coversion mode. */ + if (isspace(*fmt)) { + /* Skip white spaces in the format string. */ + while (isspace(*fmt)) { + ++fmt; + } + /* Skip white spaces in the input. */ + do { + c = in->pop(in); + } while (isspace(c)); + if (c != -1) { + /* Input is not at EOF, so undo the last pop operation. */ + in->undo(in); + } + } else if (*fmt == '%' && *(fmt + 1) != '%') { + /* Conversion specifier detected. Switch modes. */ + converting = true; + /* Reset the conversion context. */ + assign_supress = false; + assign_alloc = false; + width = -1; + length_mod = LMOD_NONE; + int_conv_unsigned = false; + int_conv_base = 0; + ++fmt; + } else { + /* One by one matching. */ + if (*fmt == '%') { + /* Escape sequence detected. */ + ++fmt; + assert(*fmt == '%'); + } + c = in->pop(in); + if (c == -1) { + /* Input failure. */ + break; + } else if (c != *fmt) { + /* Matching failure. */ + in->undo(in); + matching_failure = true; + break; + } else { + ++fmt; + } + } + + } + + } + + in->release(in); + + /* This somewhat complicated return value decision is required by POSIX. */ + int rc; + if (matching_failure) { + rc = converted_cnt; + } else { + if (errno == EOK) { + rc = converted_cnt > 0 ? converted_cnt : EOF; + } else { + rc = EOF; + } + } + if (rc == EOF) { + /* Caller will not know how many arguments were successfully converted, + * so the deallocation of buffers is our responsibility. */ + for (int i = 0; i < next_unused_buffer_idx; ++i) { + free(buffers[i]); + buffers[i] = NULL; + } + next_unused_buffer_idx = 0; + } + return rc; +} + +/** + * Convert formatted input from the stream. + * + * @param stream Input stream. + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vfscanf( + FILE *restrict stream, const char *restrict format, va_list arg) +{ + _input_provider provider = { + { 0 }, 0, 0, NULL, 0, NULL, _PROV_CONSTRUCTED, + _capture_stream, _pop_stream, _undo_stream, + _borrow_cursor_universal, _return_cursor_stream, _release_stream + }; + provider.source.stream = stream; + return _internal_scanf(&provider, format, arg); +} + +/** + * Convert formatted input from the string. + * + * @param s Input string. + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vsscanf( + const char *restrict s, const char *restrict format, va_list arg) +{ + _input_provider provider = { + { 0 }, 0, 0, NULL, 0, NULL, _PROV_CONSTRUCTED, + _capture_string, _pop_string, _undo_string, + _borrow_cursor_universal, _return_cursor_string, _release_string + }; + provider.source.string = s; + return _internal_scanf(&provider, format, arg); +} + +/** @} + */ Index: uspace/lib/posix/src/stdlib.c =================================================================== --- uspace/lib/posix/src/stdlib.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/stdlib.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,505 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard library definitions. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/stdlib.h" + +#include + +#include "posix/fcntl.h" +#include "posix/limits.h" +#include "posix/string.h" +#include "posix/sys/stat.h" +#include "posix/unistd.h" + +#include "libc/qsort.h" +#include "libc/str.h" +#include "libc/vfs/vfs.h" +#include "libc/stats.h" + +/** + * + * @param array + * @param count + * @param size + * @param compare + */ +int posix_atexit(void (*func)(void)) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return 0; +} + +/** + * Integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +int posix_abs(int i) +{ + return i < 0 ? -i : i; +} + +/** + * Long integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +long posix_labs(long i) +{ + return i < 0 ? -i : i; +} + +/** + * Long long integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +long long posix_llabs(long long i) +{ + return i < 0 ? -i : i; +} + +/** + * Compute the quotient and remainder of an integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_div_t posix_div(int numer, int denom) +{ + return (posix_div_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Compute the quotient and remainder of a long integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_ldiv_t posix_ldiv(long numer, long denom) +{ + return (posix_ldiv_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Compute the quotient and remainder of a long long integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_lldiv_t posix_lldiv(long long numer, long long denom) +{ + return (posix_lldiv_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Array sorting utilizing the quicksort algorithm. + * + * @param array Array of elements to sort. + * @param count Number of elements in the array. + * @param size Width of each element. + * @param compare Decides relative ordering of two elements. + */ +void posix_qsort(void *array, size_t count, size_t size, + int (*compare)(const void *, const void *)) +{ + qsort(array, count, size, compare); +} + +/** + * Binary search in a sorted array. + * + * @param key Object to search for. + * @param base Pointer to the first element of the array. + * @param nmemb Number of elements in the array. + * @param size Size of each array element. + * @param compar Comparison function. + * @return Pointer to a matching element, or NULL if none can be found. + */ +void *posix_bsearch(const void *key, const void *base, + size_t nmemb, size_t size, int (*compar)(const void *, const void *)) +{ + while (nmemb > 0) { + const void *middle = base + (nmemb / 2) * size; + int cmp = compar(key, middle); + if (cmp == 0) { + return (void *) middle; + } + if (middle == base) { + /* There is just one member left to check and it + * didn't match the key. Avoid infinite loop. + */ + break; + } + if (cmp < 0) { + nmemb = nmemb / 2; + } else if (cmp > 0) { + nmemb = nmemb - (nmemb / 2); + base = middle; + } + } + + return NULL; +} + +/** + * Retrieve a value of the given environment variable. + * + * Since HelenOS doesn't support env variables at the moment, + * this function always returns NULL. + * + * @param name Name of the variable. + * @return Value of the variable or NULL if such variable does not exist. + */ +char *posix_getenv(const char *name) +{ + return NULL; +} + +/** + * + * @param name + * @param resolved + * @return + */ +int posix_putenv(char *string) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return 0; +} + +/** + * Issue a command. + * + * @param string String to be passed to a command interpreter or NULL. + * @return Termination status of the command if the command is not NULL, + * otherwise indicate whether there is a command interpreter (non-zero) + * or not (zero). + */ +int posix_system(const char *string) { + // TODO: does nothing at the moment + not_implemented(); + return 0; +} + +/** + * Resolve absolute pathname. + * + * @param name Pathname to be resolved. + * @param resolved Either buffer for the resolved absolute pathname or NULL. + * @return On success, either resolved (if it was not NULL) or pointer to the + * newly allocated buffer containing the absolute pathname (if resolved was + * NULL). Otherwise NULL. + * + */ +char *posix_realpath(const char *restrict name, char *restrict resolved) +{ + #ifndef PATH_MAX + assert(resolved == NULL); + #endif + + if (name == NULL) { + errno = EINVAL; + return NULL; + } + + // TODO: symlink resolution + + /* Function absolutize is implemented in libc and declared in vfs.h. + * No more processing is required as HelenOS doesn't have symlinks + * so far (as far as I can tell), although this function will need + * to be updated when that support is implemented. + */ + char* absolute = vfs_absolutize(name, NULL); + + if (absolute == NULL) { + /* POSIX requires some specific errnos to be set + * for some cases, but there is no way to find out from + * absolutize(). + */ + errno = EINVAL; + return NULL; + } + + if (resolved == NULL) { + return absolute; + } else { + #ifdef PATH_MAX + str_cpy(resolved, PATH_MAX, absolute); + #endif + free(absolute); + return resolved; + } +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @return Double-precision number resulting from the string conversion. + */ +double posix_atof(const char *nptr) +{ + return posix_strtod(nptr, NULL); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @return Single-precision number resulting from the string conversion. + */ +float posix_strtof(const char *restrict nptr, char **restrict endptr) +{ + return (float) posix_strtold(nptr, endptr); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @return Double-precision number resulting from the string conversion. + */ +double posix_strtod(const char *restrict nptr, char **restrict endptr) +{ + return (double) posix_strtold(nptr, endptr); +} + +/** + * Allocate memory chunk. + * + * @param size Size of the chunk to allocate. + * @return Either pointer to the allocated chunk or NULL if not possible. + */ +void *posix_malloc(size_t size) +{ + return malloc(size); +} + +/** + * Allocate memory for an array of elements. + * + * @param nelem Number of elements in the array. + * @param elsize Size of each element. + * @return Either pointer to the allocated array or NULL if not possible. + */ +void *posix_calloc(size_t nelem, size_t elsize) +{ + return calloc(nelem, elsize); +} + +/** + * Reallocate memory chunk to a new size. + * + * @param ptr Memory chunk to reallocate. Might be NULL. + * @param size Size of the reallocated chunk. Might be zero. + * @return Either NULL or the pointer to the newly reallocated chunk. + */ +void *posix_realloc(void *ptr, size_t size) +{ + if (ptr != NULL && size == 0) { + /* Native realloc does not handle this special case. */ + free(ptr); + return NULL; + } else { + return realloc(ptr, size); + } +} + +/** + * Free allocated memory chunk. + * + * @param ptr Memory chunk to be freed. + */ +void posix_free(void *ptr) +{ + if (ptr) { + free(ptr); + } +} + +/** + * Generate a pseudo random integer in the range 0 to RAND_MAX inclusive. + * + * @return The pseudo random integer. + */ +int posix_rand(void) +{ + return (int) rand(); +} + +/** + * Initialize a new sequence of pseudo-random integers. + * + * @param seed The seed of the new sequence. + */ +void posix_srand(unsigned int seed) +{ + srand(seed); +} + +/** + * Creates and opens an unique temporary file from template. + * + * @param tmpl Template. Last six characters must be XXXXXX. + * @return The opened file descriptor or -1 on error. + */ +int posix_mkstemp(char *tmpl) +{ + int fd = -1; + + char *tptr = tmpl + posix_strlen(tmpl) - 6; + + while (fd < 0) { + if (*posix_mktemp(tmpl) == '\0') { + /* Errno set by mktemp(). */ + return -1; + } + + fd = posix_open(tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR); + + if (fd == -1) { + /* Restore template to it's original state. */ + snprintf(tptr, 7, "XXXXXX"); + } + } + + return fd; +} + +/** + * Creates an unique temporary file name from template. + * + * @param tmpl Template. Last six characters must be XXXXXX. + * @return The value of tmpl. The template is modified in place. + * If no temporary file name can be created, template is + * reduced to an empty string. + */ +char *posix_mktemp(char *tmpl) +{ + int tmpl_len = posix_strlen(tmpl); + if (tmpl_len < 6) { + errno = EINVAL; + *tmpl = '\0'; + return tmpl; + } + + char *tptr = tmpl + tmpl_len - 6; + if (posix_strcmp(tptr, "XXXXXX") != 0) { + errno = EINVAL; + *tmpl = '\0'; + return tmpl; + } + + static int seq = 0; + + for (; seq < 1000000; ++seq) { + snprintf(tptr, 7, "%06d", seq); + + int orig_errno = errno; + errno = 0; + /* Check if the file exists. */ + if (posix_access(tmpl, F_OK) == -1) { + if (errno == ENOENT) { + errno = orig_errno; + break; + } else { + /* errno set by access() */ + *tmpl = '\0'; + return tmpl; + } + } + } + + if (seq == 10000000) { + errno = EEXIST; + *tmpl = '\0'; + return tmpl; + } + + return tmpl; +} + +/** + * Get system load average statistics. + * + * @param loadavg Array where the load averages shall be placed. + * @param nelem Maximum number of elements to be placed into the array. + * @return Number of elements placed into the array on success, -1 otherwise. + */ +int bsd_getloadavg(double loadavg[], int nelem) +{ + assert(nelem > 0); + + size_t count; + load_t *loads = stats_get_load(&count); + + if (loads == NULL) { + return -1; + } + + if (((size_t) nelem) < count) { + count = nelem; + } + + for (size_t i = 0; i < count; ++i) { + loadavg[i] = (double) loads[i]; + } + + free(loads); + return count; +} + +/** @} + */ Index: uspace/lib/posix/src/stdlib/strtold.c =================================================================== --- uspace/lib/posix/src/stdlib/strtold.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/stdlib/strtold.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,494 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Backend for floating point conversions. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "../internal/common.h" +#include "libc/stdbool.h" +#include "posix/stdlib.h" + +#include +#include "posix/ctype.h" +#include "posix/stdint.h" +#include "posix/strings.h" + +#include + +#include "posix/limits.h" + +#include "posix/float.h" + +#include "libc/str.h" + +#ifndef HUGE_VALL + #define HUGE_VALL (+1.0l / +0.0l) +#endif + +#ifndef abs + #define abs(x) (((x) < 0) ? -(x) : (x)) +#endif + +/* If the constants are not defined, use double precision as default. */ +#ifndef LDBL_MANT_DIG + #define LDBL_MANT_DIG 53 +#endif +#ifndef LDBL_MAX_EXP + #define LDBL_MAX_EXP 1024 +#endif +#ifndef LDBL_MIN_EXP + #define LDBL_MIN_EXP (-1021) +#endif +#ifndef LDBL_DIG + #define LDBL_DIG 15 +#endif +#ifndef LDBL_MIN + #define LDBL_MIN 2.2250738585072014E-308 +#endif + +/* power functions ************************************************************/ + +#if LDBL_MAX_EXP >= 16384 +const int MAX_POW5 = 12; +#else +const int MAX_POW5 = 8; +#endif + +/* The value at index i is approximately 5**(2**i). */ +long double pow5[] = { + 0x5p0l, + 0x19p0l, + 0x271p0l, + 0x5F5E1p0l, + 0x2386F26FC1p0l, + 0x4EE2D6D415B85ACEF81p0l, + 0x184F03E93FF9F4DAA797ED6E38ED6p36l, + 0x127748F9301D319BF8CDE66D86D62p185l, + 0x154FDD7F73BF3BD1BBB77203731FDp482l, +#if LDBL_MAX_EXP >= 16384 + 0x1C633415D4C1D238D98CAB8A978A0p1076l, + 0x192ECEB0D02EA182ECA1A7A51E316p2265l, + 0x13D1676BB8A7ABBC94E9A519C6535p4643l, + 0x188C0A40514412F3592982A7F0094p9398l, +#endif +}; + +#if LDBL_MAX_EXP >= 16384 +const int MAX_POW2 = 15; +#else +const int MAX_POW2 = 9; +#endif + +/* Powers of two. */ +long double pow2[] = { + 0x1P1l, + 0x1P2l, + 0x1P4l, + 0x1P8l, + 0x1P16l, + 0x1P32l, + 0x1P64l, + 0x1P128l, + 0x1P256l, + 0x1P512l, +#if LDBL_MAX_EXP >= 16384 + 0x1P1024l, + 0x1P2048l, + 0x1P4096l, + 0x1P8192l, +#endif +}; + +/** + * Multiplies a number by a power of five. + * The result may be inexact and may not be the best possible approximation. + * + * @param mant Number to be multiplied. + * @param exp Base 5 exponent. + * @return mant multiplied by 5**exp + */ +static long double mul_pow5(long double mant, int exp) +{ + if (mant == 0.0l || mant == HUGE_VALL) { + return mant; + } + + if (abs(exp) >> (MAX_POW5 + 1) != 0) { + /* Too large exponent. */ + errno = ERANGE; + return exp < 0 ? LDBL_MIN : HUGE_VALL; + } + + if (exp < 0) { + exp = abs(exp); + for (int bit = 0; bit <= MAX_POW5; ++bit) { + /* Multiply by powers of five bit-by-bit. */ + if (((exp >> bit) & 1) != 0) { + mant /= pow5[bit]; + if (mant == 0.0l) { + /* Underflow. */ + mant = LDBL_MIN; + errno = ERANGE; + break; + } + } + } + } else { + for (int bit = 0; bit <= MAX_POW5; ++bit) { + /* Multiply by powers of five bit-by-bit. */ + if (((exp >> bit) & 1) != 0) { + mant *= pow5[bit]; + if (mant == HUGE_VALL) { + /* Overflow. */ + errno = ERANGE; + break; + } + } + } + } + + return mant; +} + +/** + * Multiplies a number by a power of two. This is always exact. + * + * @param mant Number to be multiplied. + * @param exp Base 2 exponent. + * @return mant multiplied by 2**exp. + */ +static long double mul_pow2(long double mant, int exp) +{ + if (mant == 0.0l || mant == HUGE_VALL) { + return mant; + } + + if (exp > LDBL_MAX_EXP || exp < LDBL_MIN_EXP) { + errno = ERANGE; + return exp < 0 ? LDBL_MIN : HUGE_VALL; + } + + if (exp < 0) { + exp = abs(exp); + for (int i = 0; i <= MAX_POW2; ++i) { + if (((exp >> i) & 1) != 0) { + mant /= pow2[i]; + if (mant == 0.0l) { + mant = LDBL_MIN; + errno = ERANGE; + break; + } + } + } + } else { + for (int i = 0; i <= MAX_POW2; ++i) { + if (((exp >> i) & 1) != 0) { + mant *= pow2[i]; + if (mant == HUGE_VALL) { + errno = ERANGE; + break; + } + } + } + } + + return mant; +} + +/* end power functions ********************************************************/ + + + +/** + * Convert decimal string representation of the floating point number. + * Function expects the string pointer to be already pointed at the first + * digit (i.e. leading optional sign was already consumed by the caller). + * + * @param sptr Pointer to the storage of the string pointer. Upon successful + * conversion, the string pointer is updated to point to the first + * unrecognized character. + * @return An approximate representation of the input floating-point number. + */ +static long double parse_decimal(const char **sptr) +{ + assert(sptr != NULL); + assert (*sptr != NULL); + + const int DEC_BASE = 10; + const char DECIMAL_POINT = '.'; + const char EXPONENT_MARK = 'e'; + + const char *str = *sptr; + long double significand = 0; + long exponent = 0; + + /* number of digits parsed so far */ + int parsed_digits = 0; + bool after_decimal = false; + + while (isdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) { + if (*str == DECIMAL_POINT) { + after_decimal = true; + str++; + continue; + } + + if (parsed_digits == 0 && *str == '0') { + /* Nothing, just skip leading zeros. */ + } else if (parsed_digits < LDBL_DIG) { + significand = significand * DEC_BASE + (*str - '0'); + parsed_digits++; + } else { + exponent++; + } + + if (after_decimal) { + /* Decrement exponent if we are parsing the fractional part. */ + exponent--; + } + + str++; + } + + /* exponent */ + if (tolower(*str) == EXPONENT_MARK) { + str++; + + /* Returns MIN/MAX value on error, which is ok. */ + long exp = strtol(str, (char **) &str, DEC_BASE); + + if (exponent > 0 && exp > LONG_MAX - exponent) { + exponent = LONG_MAX; + } else if (exponent < 0 && exp < LONG_MIN - exponent) { + exponent = LONG_MIN; + } else { + exponent += exp; + } + } + + *sptr = str; + + /* Return multiplied by a power of ten. */ + return mul_pow2(mul_pow5(significand, exponent), exponent); +} + +/** + * Derive a hexadecimal digit from its character representation. + * + * @param ch Character representation of the hexadecimal digit. + * @return Digit value represented by an integer. + */ +static inline int hex_value(char ch) +{ + if (ch <= '9') { + return ch - '0'; + } else { + return 10 + tolower(ch) - 'a'; + } +} + +/** + * Convert hexadecimal string representation of the floating point number. + * Function expects the string pointer to be already pointed at the first + * digit (i.e. leading optional sign and 0x prefix were already consumed + * by the caller). + * + * @param sptr Pointer to the storage of the string pointer. Upon successful + * conversion, the string pointer is updated to point to the first + * unrecognized character. + * @return Representation of the input floating-point number. + */ +static long double parse_hexadecimal(const char **sptr) +{ + assert(sptr != NULL && *sptr != NULL); + + const int DEC_BASE = 10; + const int HEX_BASE = 16; + const char DECIMAL_POINT = '.'; + const char EXPONENT_MARK = 'p'; + + const char *str = *sptr; + long double significand = 0; + long exponent = 0; + + /* number of bits parsed so far */ + int parsed_bits = 0; + bool after_decimal = false; + + while (isxdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) { + if (*str == DECIMAL_POINT) { + after_decimal = true; + str++; + continue; + } + + if (parsed_bits == 0 && *str == '0') { + /* Nothing, just skip leading zeros. */ + } else if (parsed_bits <= LDBL_MANT_DIG) { + significand = significand * HEX_BASE + hex_value(*str); + parsed_bits += 4; + } else { + exponent += 4; + } + + if (after_decimal) { + exponent -= 4; + } + + str++; + } + + /* exponent */ + if (tolower(*str) == EXPONENT_MARK) { + str++; + + /* Returns MIN/MAX value on error, which is ok. */ + long exp = strtol(str, (char **) &str, DEC_BASE); + + if (exponent > 0 && exp > LONG_MAX - exponent) { + exponent = LONG_MAX; + } else if (exponent < 0 && exp < LONG_MIN - exponent) { + exponent = LONG_MIN; + } else { + exponent += exp; + } + } + + *sptr = str; + + /* Return multiplied by a power of two. */ + return mul_pow2(significand, exponent); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. Largely POSIX compliant, except for + * locale differences (always uses '.' at the moment) and rounding. + * Decimal strings are NOT guaranteed to be correctly rounded. This function + * should return a good enough approximation for most purposes but if you + * depend on a precise conversion, use hexadecimal representation. + * Hexadecimal strings are currently always rounded towards zero, regardless + * of the current rounding mode. + * + * @param nptr Input string. + * @param endptr If non-NULL, *endptr is set to the position of the first + * unrecognized character. + * @return An approximate representation of the input floating-point number. + */ +long double posix_strtold(const char *restrict nptr, char **restrict endptr) +{ + assert(nptr != NULL); + + const int RADIX = '.'; + + /* minus sign */ + bool negative = false; + /* current position in the string */ + int i = 0; + + /* skip whitespace */ + while (isspace(nptr[i])) { + i++; + } + + /* parse sign */ + switch (nptr[i]) { + case '-': + negative = true; + /* Fallthrough */ + case '+': + i++; + } + + /* check for NaN */ + if (posix_strncasecmp(&nptr[i], "nan", 3) == 0) { + // FIXME: return NaN + // TODO: handle the parenthesised case + + if (endptr != NULL) { + *endptr = (char *) nptr; + } + errno = EINVAL; + return 0; + } + + /* check for Infinity */ + if (posix_strncasecmp(&nptr[i], "inf", 3) == 0) { + i += 3; + if (posix_strncasecmp(&nptr[i], "inity", 5) == 0) { + i += 5; + } + + if (endptr != NULL) { + *endptr = (char *) &nptr[i]; + } + return negative ? -HUGE_VALL : +HUGE_VALL; + } + + /* check for a hex number */ + if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x' && + (isxdigit(nptr[i + 2]) || + (nptr[i + 2] == RADIX && isxdigit(nptr[i + 3])))) { + i += 2; + + const char *ptr = &nptr[i]; + /* this call sets errno if appropriate. */ + long double result = parse_hexadecimal(&ptr); + if (endptr != NULL) { + *endptr = (char *) ptr; + } + return negative ? -result : result; + } + + /* check for a decimal number */ + if (isdigit(nptr[i]) || (nptr[i] == RADIX && isdigit(nptr[i + 1]))) { + const char *ptr = &nptr[i]; + /* this call sets errno if appropriate. */ + long double result = parse_decimal(&ptr); + if (endptr != NULL) { + *endptr = (char *) ptr; + } + return negative ? -result : result; + } + + /* nothing to parse */ + if (endptr != NULL) { + *endptr = (char *) nptr; + } + errno = EINVAL; + return 0; +} + +/** @} + */ Index: uspace/lib/posix/src/string.c =================================================================== --- uspace/lib/posix/src/string.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/string.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,728 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file String manipulation. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/string.h" + +#include + +#include + +#include "posix/limits.h" +#include "posix/stdlib.h" +#include "posix/signal.h" + +#include "libc/str.h" +#include "libc/str_error.h" + +/** + * The same as strpbrk, except it returns pointer to the nul terminator + * if no occurence is found. + * + * @param s1 String in which to look for the bytes. + * @param s2 String of bytes to look for. + * @return Pointer to the found byte on success, pointer to the + * string terminator otherwise. + */ +static char *strpbrk_null(const char *s1, const char *s2) +{ + while (!posix_strchr(s2, *s1)) { + ++s1; + } + + return (char *) s1; +} + +/** + * Copy a string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @return Pointer to the destination buffer. + */ +char *posix_strcpy(char *restrict dest, const char *restrict src) +{ + posix_stpcpy(dest, src); + return dest; +} + +/** + * Copy fixed length string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @param n Number of bytes to be stored into destination buffer. + * @return Pointer to the destination buffer. + */ +char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n) +{ + posix_stpncpy(dest, src, n); + return dest; +} + +/** + * Copy a string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @return Pointer to the nul character in the destination string. + */ +char *posix_stpcpy(char *restrict dest, const char *restrict src) +{ + assert(dest != NULL); + assert(src != NULL); + + for (size_t i = 0; ; ++i) { + dest[i] = src[i]; + + if (src[i] == '\0') { + /* pointer to the terminating nul character */ + return &dest[i]; + } + } + + /* unreachable */ + return NULL; +} + +/** + * Copy fixed length string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @param n Number of bytes to be stored into destination buffer. + * @return Pointer to the first written nul character or &dest[n]. + */ +char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + for (size_t i = 0; i < n; ++i) { + dest[i] = src[i]; + + /* the standard requires that nul characters + * are appended to the length of n, in case src is shorter + */ + if (src[i] == '\0') { + char *result = &dest[i]; + for (++i; i < n; ++i) { + dest[i] = '\0'; + } + return result; + } + } + + return &dest[n]; +} + +/** + * Concatenate two strings. + * + * @param dest String to which src shall be appended. + * @param src String to be appended after dest. + * @return Pointer to destination buffer. + */ +char *posix_strcat(char *restrict dest, const char *restrict src) +{ + assert(dest != NULL); + assert(src != NULL); + + posix_strcpy(posix_strchr(dest, '\0'), src); + return dest; +} + +/** + * Concatenate a string with part of another. + * + * @param dest String to which part of src shall be appended. + * @param src String whose part shall be appended after dest. + * @param n Number of bytes to append after dest. + * @return Pointer to destination buffer. + */ +char *posix_strncat(char *restrict dest, const char *restrict src, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + char *zeroptr = posix_strncpy(posix_strchr(dest, '\0'), src, n); + /* strncpy doesn't append the nul terminator, so we do it here */ + zeroptr[n] = '\0'; + return dest; +} + +/** + * Copy limited number of bytes in memory. + * + * @param dest Destination buffer. + * @param src Source buffer. + * @param c Character after which the copying shall stop. + * @param n Number of bytes that shall be copied if not stopped earlier by c. + * @return Pointer to the first byte after c in dest if found, NULL otherwise. + */ +void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + unsigned char* bdest = dest; + const unsigned char* bsrc = src; + + for (size_t i = 0; i < n; ++i) { + bdest[i] = bsrc[i]; + + if (bsrc[i] == (unsigned char) c) { + /* pointer to the next byte */ + return &bdest[i + 1]; + } + } + + return NULL; +} + +/** + * Duplicate a string. + * + * @param s String to be duplicated. + * @return Newly allocated copy of the string. + */ +char *posix_strdup(const char *s) +{ + return posix_strndup(s, SIZE_MAX); +} + +/** + * Duplicate a specific number of bytes from a string. + * + * @param s String to be duplicated. + * @param n Maximum length of the resulting string.. + * @return Newly allocated string copy of length at most n. + */ +char *posix_strndup(const char *s, size_t n) +{ + assert(s != NULL); + + size_t len = posix_strnlen(s, n); + char *dup = malloc(len + 1); + if (dup == NULL) { + return NULL; + } + + memcpy(dup, s, len); + dup[len] = '\0'; + + return dup; +} + +/** + * Compare bytes in memory. + * + * @param mem1 First area of memory to be compared. + * @param mem2 Second area of memory to be compared. + * @param n Maximum number of bytes to be compared. + * @return Difference of the first pair of inequal bytes, + * or 0 if areas have the same content. + */ +int posix_memcmp(const void *mem1, const void *mem2, size_t n) +{ + assert(mem1 != NULL); + assert(mem2 != NULL); + + const unsigned char *s1 = mem1; + const unsigned char *s2 = mem2; + + for (size_t i = 0; i < n; ++i) { + if (s1[i] != s2[i]) { + return s1[i] - s2[i]; + } + } + + return 0; +} + +/** + * Compare two strings. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcmp(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + return posix_strncmp(s1, s2, STR_NO_LIMIT); +} + +/** + * Compare part of two strings. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @param n Maximum number of characters to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strncmp(const char *s1, const char *s2, size_t n) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + for (size_t i = 0; i < n; ++i) { + if (s1[i] != s2[i]) { + return s1[i] - s2[i]; + } + if (s1[i] == '\0') { + break; + } + } + + return 0; +} + +/** + * Find byte in memory. + * + * @param mem Memory area in which to look for the byte. + * @param c Byte to look for. + * @param n Maximum number of bytes to be inspected. + * @return Pointer to the specified byte on success, + * NULL pointer otherwise. + */ +void *posix_memchr(const void *mem, int c, size_t n) +{ + assert(mem != NULL); + + const unsigned char *s = mem; + + for (size_t i = 0; i < n; ++i) { + if (s[i] == (unsigned char) c) { + return (void *) &s[i]; + } + } + return NULL; +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_strchr(const char *s, int c) +{ + assert(s != NULL); + + char *res = gnu_strchrnul(s, c); + return (*res == c) ? res : NULL; +} + +/** + * Scan string for a last occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_strrchr(const char *s, int c) +{ + assert(s != NULL); + + const char *ptr = posix_strchr(s, '\0'); + + /* the same as in strchr, except it loops in reverse direction */ + while (*ptr != (char) c) { + if (ptr == s) { + return NULL; + } + + ptr--; + } + + return (char *) ptr; +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, pointer to the + * string terminator otherwise. + */ +char *gnu_strchrnul(const char *s, int c) +{ + assert(s != NULL); + + while (*s != c && *s != '\0') { + s++; + } + + return (char *) s; +} + +/** + * Scan a string for a first occurence of one of provided bytes. + * + * @param s1 String in which to look for the bytes. + * @param s2 String of bytes to look for. + * @return Pointer to the found byte on success, + * NULL pointer otherwise. + */ +char *posix_strpbrk(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + char *ptr = strpbrk_null(s1, s2); + return (*ptr == '\0') ? NULL : ptr; +} + +/** + * Get the length of a complementary substring. + * + * @param s1 String that shall be searched for complementary prefix. + * @param s2 String of bytes that shall not occur in the prefix. + * @return Length of the prefix. + */ +size_t posix_strcspn(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + char *ptr = strpbrk_null(s1, s2); + return (size_t) (ptr - s1); +} + +/** + * Get length of a substring. + * + * @param s1 String that shall be searched for prefix. + * @param s2 String of bytes that the prefix must consist of. + * @return Length of the prefix. + */ +size_t posix_strspn(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + const char *ptr; + for (ptr = s1; *ptr != '\0'; ++ptr) { + if (!posix_strchr(s2, *ptr)) { + break; + } + } + return ptr - s1; +} + +/** + * Find a substring. Uses Knuth-Morris-Pratt algorithm. + * + * @param s1 String in which to look for a substring. + * @param s2 Substring to look for. + * @return Pointer to the first character of the substring in s1, or NULL if + * not found. + */ +char *posix_strstr(const char *haystack, const char *needle) +{ + assert(haystack != NULL); + assert(needle != NULL); + + /* Special case - needle is an empty string. */ + if (needle[0] == '\0') { + return (char *) haystack; + } + + /* Preprocess needle. */ + size_t nlen = posix_strlen(needle); + size_t prefix_table[nlen + 1]; + + { + size_t i = 0; + ssize_t j = -1; + + prefix_table[i] = j; + + while (i < nlen) { + while (j >= 0 && needle[i] != needle[j]) { + j = prefix_table[j]; + } + i++; j++; + prefix_table[i] = j; + } + } + + /* Search needle using the precomputed table. */ + size_t npos = 0; + + for (size_t hpos = 0; haystack[hpos] != '\0'; ++hpos) { + while (npos != 0 && haystack[hpos] != needle[npos]) { + npos = prefix_table[npos]; + } + + if (haystack[hpos] == needle[npos]) { + npos++; + + if (npos == nlen) { + return (char *) (haystack + hpos - nlen + 1); + } + } + } + + return NULL; +} + +/** Split string by delimiters. + * + * @param s String to be tokenized. May not be NULL. + * @param delim String with the delimiters. + * @return Pointer to the prefix of @a s before the first + * delimiter character. NULL if no such prefix + * exists. + */ +char *posix_strtok(char *s, const char *delim) +{ + static char *next; + + return posix_strtok_r(s, delim, &next); +} + + +/** Split string by delimiters. + * + * @param s String to be tokenized. May not be NULL. + * @param delim String with the delimiters. + * @param next Variable which will receive the pointer to the + * continuation of the string following the first + * occurrence of any of the delimiter characters. + * May be NULL. + * @return Pointer to the prefix of @a s before the first + * delimiter character. NULL if no such prefix + * exists. + */ +char *posix_strtok_r(char *s, const char *delim, char **next) +{ + char *start, *end; + + if (s == NULL) + s = *next; + + /* Skip over leading delimiters. */ + while (*s && (posix_strchr(delim, *s) != NULL)) ++s; + start = s; + + /* Skip over token characters. */ + while (*s && (posix_strchr(delim, *s) == NULL)) ++s; + end = s; + *next = (*s ? s + 1 : s); + + if (start == end) { + return NULL; /* No more tokens. */ + } + + /* Overwrite delimiter with NULL terminator. */ + *end = '\0'; + return start; +} + +/** + * String comparison using collating information. + * + * Currently ignores locale and just calls strcmp. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcoll(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + return posix_strcmp(s1, s2); +} + +/** + * Transform a string in such a way that the resulting string yields the same + * results when passed to the strcmp as if the original string is passed to + * the strcoll. + * + * Since strcoll is equal to strcmp here, this just makes a copy. + * + * @param s1 Transformed string. + * @param s2 Original string. + * @param n Maximum length of the transformed string. + * @return Length of the transformed string. + */ +size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n) +{ + assert(s1 != NULL || n == 0); + assert(s2 != NULL); + + size_t len = posix_strlen(s2); + + if (n > len) { + posix_strcpy(s1, s2); + } + + return len; +} + +/** + * Get error message string. + * + * @param errnum Error code for which to obtain human readable string. + * @return Error message. + */ +char *posix_strerror(int errnum) +{ + // FIXME: move strerror() and strerror_r() to libc. + return (char *) str_error(errnum); +} + +/** + * Get error message string. + * + * @param errnum Error code for which to obtain human readable string. + * @param buf Buffer to store a human readable string to. + * @param bufsz Size of buffer pointed to by buf. + * @return Zero on success, errno otherwise. + */ +int posix_strerror_r(int errnum, char *buf, size_t bufsz) +{ + assert(buf != NULL); + + char *errstr = posix_strerror(errnum); + + if (posix_strlen(errstr) + 1 > bufsz) { + return ERANGE; + } else { + posix_strcpy(buf, errstr); + } + + return EOK; +} + +/** + * Get length of the string. + * + * @param s String which length shall be determined. + * @return Length of the string. + */ +size_t posix_strlen(const char *s) +{ + assert(s != NULL); + + return (size_t) (posix_strchr(s, '\0') - s); +} + +/** + * Get limited length of the string. + * + * @param s String which length shall be determined. + * @param n Maximum number of bytes that can be examined to determine length. + * @return The lower of either string length or n limit. + */ +size_t posix_strnlen(const char *s, size_t n) +{ + assert(s != NULL); + + for (size_t sz = 0; sz < n; ++sz) { + + if (s[sz] == '\0') { + return sz; + } + } + + return n; +} + +/** + * Get description of a signal. + * + * @param signum Signal number. + * @return Human readable signal description. + */ +char *posix_strsignal(int signum) +{ + static const char *const sigstrings[] = { + [SIGABRT] = "SIGABRT (Process abort signal)", + [SIGALRM] = "SIGALRM (Alarm clock)", + [SIGBUS] = "SIGBUS (Access to an undefined portion of a memory object)", + [SIGCHLD] = "SIGCHLD (Child process terminated, stopped, or continued)", + [SIGCONT] = "SIGCONT (Continue executing, if stopped)", + [SIGFPE] = "SIGFPE (Erroneous arithmetic operation)", + [SIGHUP] = "SIGHUP (Hangup)", + [SIGILL] = "SIGILL (Illegal instruction)", + [SIGINT] = "SIGINT (Terminal interrupt signal)", + [SIGKILL] = "SIGKILL (Kill process)", + [SIGPIPE] = "SIGPIPE (Write on a pipe with no one to read it)", + [SIGQUIT] = "SIGQUIT (Terminal quit signal)", + [SIGSEGV] = "SIGSEGV (Invalid memory reference)", + [SIGSTOP] = "SIGSTOP (Stop executing)", + [SIGTERM] = "SIGTERM (Termination signal)", + [SIGTSTP] = "SIGTSTP (Terminal stop signal)", + [SIGTTIN] = "SIGTTIN (Background process attempting read)", + [SIGTTOU] = "SIGTTOU (Background process attempting write)", + [SIGUSR1] = "SIGUSR1 (User-defined signal 1)", + [SIGUSR2] = "SIGUSR2 (User-defined signal 2)", + [SIGPOLL] = "SIGPOLL (Pollable event)", + [SIGPROF] = "SIGPROF (Profiling timer expired)", + [SIGSYS] = "SIGSYS (Bad system call)", + [SIGTRAP] = "SIGTRAP (Trace/breakpoint trap)", + [SIGURG] = "SIGURG (High bandwidth data is available at a socket)", + [SIGVTALRM] = "SIGVTALRM (Virtual timer expired)", + [SIGXCPU] = "SIGXCPU (CPU time limit exceeded)", + [SIGXFSZ] = "SIGXFSZ (File size limit exceeded)" + }; + + if (signum <= _TOP_SIGNAL) { + return (char *) sigstrings[signum]; + } + + return (char *) "ERROR, Invalid signal number"; +} + +/** @} + */ Index: uspace/lib/posix/src/strings.c =================================================================== --- uspace/lib/posix/src/strings.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/strings.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Additional string manipulation. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/strings.h" + +#include "posix/string.h" +#include "posix/ctype.h" + +#include "libc/mem.h" +#include "libc/str.h" + +/** + * Find first set bit (beginning with the least significant bit). + * + * @param i Integer in which to look for the first set bit. + * @return Index of first set bit. Bits are numbered starting at one. + */ +int posix_ffs(int i) +{ + if (i == 0) { + return 0; + } + + int result = 0; + + // XXX: assumes at most 32-bit int + if (!(i & 0xFFFF)) { + result |= 16; + i >>= 16; + } + if (!(i & 0xFF)) { + result |= 8; + i >>= 8; + } + if (!(i & 0xF)) { + result |= 4; + i >>= 4; + } + if (!(i & 0x3)) { + result |= 2; + i >>= 2; + } + if (!(i & 0x1)) { + result |= 1; + } + + return result + 1; +} + +/** + * Compare two strings (case-insensitive). + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcasecmp(const char *s1, const char *s2) +{ + return posix_strncasecmp(s1, s2, STR_NO_LIMIT); +} + +/** + * Compare part of two strings (case-insensitive). + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @param n Maximum number of characters to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strncasecmp(const char *s1, const char *s2, size_t n) +{ + for (size_t i = 0; i < n; ++i) { + int cmp = tolower(s1[i]) - tolower(s2[i]); + if (cmp != 0) { + return cmp; + } + + if (s1[i] == 0) { + return 0; + } + } + + return 0; +} + +/** + * Compare two memory areas. + * + * @param mem1 Pointer to the first area to compare. + * @param mem2 Pointer to the second area to compare. + * @param n Common size of both areas. + * @return If n is 0, return zero. If the areas match, return + * zero. Otherwise return non-zero. + */ +int posix_bcmp(const void *mem1, const void *mem2, size_t n) +{ + return memcmp(mem1, mem2, n); +} + +/** + * Copy bytes in memory with overlapping areas. + * + * @param src Source area. + * @param dest Destination area. + * @param n Number of bytes to copy. + */ +void posix_bcopy(const void *src, void *dest, size_t n) +{ + /* Note that memmove has different order of arguments. */ + memmove(dest, src, n); +} + +/** + * Reset bytes in memory area to zero. + * + * @param mem Memory area to be zeroed. + * @param n Number of bytes to reset. + */ +void posix_bzero(void *mem, size_t n) +{ + memset(mem, 0, n); +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_index(const char *s, int c) +{ + return posix_strchr(s, c); +} + +/** + * Scan string for a last occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_rindex(const char *s, int c) +{ + return posix_strrchr(s, c); +} + +/** @} + */ Index: uspace/lib/posix/src/sys/mman.c =================================================================== --- uspace/lib/posix/src/sys/mman.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/sys/mman.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "../internal/common.h" +#include +#include +#include +#include + +void *posix_mmap(void *start, size_t length, int prot, int flags, int fd, + __POSIX_DEF__(off_t) offset) +{ + if (!start) + start = AS_AREA_ANY; + +// if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE))) +// return MAP_FAILED; + + if (!(flags & MAP_ANONYMOUS)) + return MAP_FAILED; + + return as_area_create(start, length, prot, AS_AREA_UNPAGED); +} + +int posix_munmap(void *start, size_t length) +{ + int rc = as_area_destroy(start); + if (rc != EOK) { + errno = rc; + return -1; + } + return 0; +} + +/** @} + */ Index: uspace/lib/posix/src/sys/stat.c =================================================================== --- uspace/lib/posix/src/sys/stat.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/sys/stat.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File status handling. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "../internal/common.h" +#include "posix/sys/stat.h" +#include "libc/vfs/vfs.h" + +#include +#include "libc/mem.h" + +/** + * Convert HelenOS stat struct into POSIX stat struct (if possible). + * + * @param dest POSIX stat struct. + * @param src HelenOS stat struct. + * + * @return 0 on success, -1 on error. + */ +static int stat_to_posix(struct posix_stat *dest, vfs_stat_t *src) +{ + memset(dest, 0, sizeof(struct posix_stat)); + + dest->st_dev = src->service; + dest->st_ino = src->index; + + /* HelenOS doesn't support permissions, so we set them all */ + dest->st_mode = S_IRWXU | S_IRWXG | S_IRWXO; + if (src->is_file) { + dest->st_mode |= S_IFREG; + } + if (src->is_directory) { + dest->st_mode |= S_IFDIR; + } + + dest->st_nlink = src->lnkcnt; + dest->st_size = src->size; + + if (src->size > INT64_MAX) { + errno = ERANGE; + return -1; + } + + return 0; +} + +/** + * Retrieve file status for file associated with file descriptor. + * + * @param fd File descriptor of the opened file. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_fstat(int fd, struct posix_stat *st) +{ + vfs_stat_t hst; + if (failed(vfs_stat(fd, &hst))) + return -1; + return stat_to_posix(st, &hst); +} + +/** + * Retrieve file status for symbolic link. + * + * @param path Path to the symbolic link. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_lstat(const char *restrict path, struct posix_stat *restrict st) +{ + /* There are currently no symbolic links in HelenOS. */ + return posix_stat(path, st); +} + +/** + * Retrieve file status for regular file (or symbolic link target). + * + * @param path Path to the file/link. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_stat(const char *restrict path, struct posix_stat *restrict st) +{ + vfs_stat_t hst; + if (failed(vfs_stat_path(path, &hst))) + return -1; + return stat_to_posix(st, &hst); +} + +/** + * Change permission bits for the file if possible. + * + * @param path Path to the file. + * @param mode Permission bits to be set. + * @return Zero on success, -1 otherwise. + */ +int posix_chmod(const char *path, posix_mode_t mode) +{ + /* HelenOS doesn't support permissions, return success. */ + return 0; +} + +/** + * Set the file mode creation mask of the process. + * + * @param mask Set permission bits are cleared in the related creation + * functions. Non-permission bits are ignored. + * @return Previous file mode creation mask. + */ +posix_mode_t posix_umask(posix_mode_t mask) +{ + /* HelenOS doesn't support permissions, return empty mask. */ + return 0; +} + +/** + * Create a directory. + * + * @param path Path to the new directory. + * @param mode Permission bits to be set. + * @return Zero on success, -1 otherwise. + */ +int posix_mkdir(const char *path, posix_mode_t mode) +{ + if (failed(vfs_link_path(path, KIND_DIRECTORY, NULL))) + return -1; + else + return 0; +} + +/** @} + */ Index: uspace/lib/posix/src/sys/wait.c =================================================================== --- uspace/lib/posix/src/sys/wait.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/sys/wait.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Support for waiting. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "../internal/common.h" +#include "posix/sys/wait.h" + +#include "libc/task.h" +#include + +#include + +#include "posix/limits.h" +#include "posix/signal.h" + +int __posix_wifexited(int status) { + return status != INT_MIN; +} + +int __posix_wexitstatus(int status) { + assert(__posix_wifexited(status)); + return status; +} + +int __posix_wifsignaled(int status) { + return status == INT_MIN; +} + +int __posix_wtermsig(int status) { + assert(__posix_wifsignaled(status)); + /* There is no way to distinguish reason + * for unexpected termination at the moment. + */ + return SIGABRT; +} + +/** + * Wait for any child process to stop or terminate. + * + * @param stat_ptr Location of the final status code of the child process. + * @return ID of the child process for which status is reported, + * -1 on signal interrupt, (pid_t)-1 otherwise. + */ +posix_pid_t posix_wait(int *stat_ptr) +{ + /* HelenOS does not support this. */ + errno = ENOSYS; + return (posix_pid_t) -1; +} + +/** + * Wait for a child process to stop or terminate. + * + * @param pid What child process shall the caller wait for. See POSIX manual + * for details. + * @param stat_ptr Location of the final status code of the child process. + * @param options Constraints of the waiting. See POSIX manual for details. + * @return ID of the child process for which status is reported, + * -1 on signal interrupt, 0 if non-blocking wait is requested but there is + * no child process whose status can be reported, (pid_t)-1 otherwise. + */ +posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options) +{ + assert(stat_ptr != NULL); + assert(options == 0 /* None of the options are supported. */); + + task_exit_t texit; + int retval; + + if (failed(task_wait_task_id((task_id_t) pid, &texit, &retval))) { + /* Unable to retrieve status. */ + return (posix_pid_t) -1; + } + + if (texit == TASK_EXIT_NORMAL) { + // FIXME: relies on application not returning this value + assert(retval != INT_MIN); + *stat_ptr = retval; + } else { + /* Reserve the lowest value for unexpected termination. */ + *stat_ptr = INT_MIN; + } + + return pid; +} + +/** @} + */ Index: uspace/lib/posix/src/time.c =================================================================== --- uspace/lib/posix/src/time.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/time.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,346 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Time measurement support. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/time.h" + +#include "posix/ctype.h" + +#include + +#include "posix/signal.h" +#include + +#include "libc/async.h" +#include "libc/malloc.h" +#include "libc/task.h" +#include "libc/stats.h" +#include "libc/stddef.h" +#include "libc/sys/time.h" + +// TODO: test everything in this file + +/* In some places in this file, phrase "normalized broken-down time" is used. + * This means time broken down to components (year, month, day, hour, min, sec), + * in which every component is in its proper bounds. Non-normalized time could + * e.g. be 2011-54-5 29:13:-5, which would semantically mean start of year 2011 + * + 53 months + 4 days + 29 hours + 13 minutes - 5 seconds. + */ + +int posix_daylight; +long posix_timezone; +char *posix_tzname[2]; + +/** + * Set timezone conversion information. + */ +void posix_tzset(void) +{ + // TODO: read environment + posix_tzname[0] = (char *) "GMT"; + posix_tzname[1] = (char *) "GMT"; + posix_daylight = 0; + posix_timezone = 0; +} + +/** + * Get the time in seconds + * + * @param t If t is non-NULL, the return value is also stored in the memory + * pointed to by t. + * @return On success, the value of time in seconds since the Epoch + * is returned. On error, (time_t)-1 is returned. + */ +time_t posix_time(time_t *t) +{ + return time(t); +} + +/** + * Converts a time value to a broken-down UTC time. + * + * @param timer Time to convert. + * @param result Structure to store the result to. + * @return Value of result on success, NULL on overflow. + */ +struct tm *posix_gmtime_r(const time_t *restrict timer, + struct tm *restrict result) +{ + if (failed(time_utc2tm(*timer, result))) { + return NULL; + } + + return result; +} + +/** + * Converts a time value to a broken-down UTC time. + * (non reentrant version) + * + * @param timep Time to convert + * @return Pointer to a statically allocated structure that stores + * the result, NULL in case of error. + */ +struct tm *posix_gmtime(const time_t *restrict timep) +{ + static struct tm result; + + return posix_gmtime_r(timep, &result); +} + +/** + * Converts a time value to a broken-down local time. + * + * @param timer Time to convert. + * @param result Structure to store the result to. + * @return Value of result on success, NULL on overflow. + */ +struct tm *posix_localtime_r(const time_t *restrict timer, + struct tm *restrict result) +{ + // TODO: deal with timezone + // currently assumes system and all times are in GMT + return posix_gmtime_r(timer, result); +} + +/** + * Converts a time value to a broken-down local time. + * (non reentrant version) + * + * @param timep Time to convert. + * @return Pointer to a statically allocated structure that stores + * the result, NULL in case of error. + */ +struct tm *posix_localtime(const time_t *restrict timep) +{ + static struct tm result; + + return posix_localtime_r(timep, &result); +} + +/** + * Converts broken-down time to a string in format + * "Sun Jan 1 00:00:00 1970\n". (Obsolete) + * + * @param timeptr Broken-down time structure. + * @param buf Buffer to store string to, must be at least ASCTIME_BUF_LEN + * bytes long. + * @return Value of buf. + */ +char *posix_asctime_r(const struct tm *restrict timeptr, + char *restrict buf) +{ + time_tm2str(timeptr, buf); + return buf; +} + +/** + * Convers broken-down time to a string in format + * "Sun Jan 1 00:00:00 1970\n". (Obsolete) + * (non reentrant version) + * + * @param timeptr Broken-down time structure. + * @return Pointer to a statically allocated buffer that stores + * the result, NULL in case of error. + */ +char *posix_asctime(const struct tm *restrict timeptr) +{ + static char buf[ASCTIME_BUF_LEN]; + + return posix_asctime_r(timeptr, buf); +} + +/** + * Converts the calendar time to a string in format + * "Sun Jan 1 00:00:00 1970\n" (Obsolete) + * + * @param timer Time to convert. + * @param buf Buffer to store string to. Must be at least ASCTIME_BUF_LEN + * bytes long. + * @return Pointer to buf on success, NULL on failure. + */ +char *posix_ctime_r(const time_t *timer, char *buf) +{ + if (failed(time_local2str(*timer, buf))) { + return NULL; + } + + return buf; +} + +/** + * Converts the calendar time to a string in format + * "Sun Jan 1 00:00:00 1970\n" (Obsolete) + * (non reentrant version) + * + * @param timep Time to convert. + * @return Pointer to a statically allocated buffer that stores + * the result, NULL in case of error. + */ +char *posix_ctime(const time_t *timep) +{ + static char buf[ASCTIME_BUF_LEN]; + + return posix_ctime_r(timep, buf); +} + +/** + * Get clock resolution. Only CLOCK_REALTIME is supported. + * + * @param clock_id Clock ID. + * @param res Pointer to the variable where the resolution is to be written. + * @return 0 on success, -1 with errno set on failure. + */ +int posix_clock_getres(posix_clockid_t clock_id, struct posix_timespec *res) +{ + assert(res != NULL); + + switch (clock_id) { + case CLOCK_REALTIME: + res->tv_sec = 0; + res->tv_nsec = 1000; /* Microsecond resolution. */ + return 0; + default: + errno = EINVAL; + return -1; + } +} + +/** + * Get time. Only CLOCK_REALTIME is supported. + * + * @param clock_id ID of the clock to query. + * @param tp Pointer to the variable where the time is to be written. + * @return 0 on success, -1 with errno on failure. + */ +int posix_clock_gettime(posix_clockid_t clock_id, struct posix_timespec *tp) +{ + assert(tp != NULL); + + switch (clock_id) { + case CLOCK_REALTIME: + ; + struct timeval tv; + gettimeofday(&tv, NULL); + tp->tv_sec = tv.tv_sec; + tp->tv_nsec = tv.tv_usec * 1000; + return 0; + default: + errno = EINVAL; + return -1; + } +} + +/** + * Set time on a specified clock. As HelenOS doesn't support this yet, + * this function always fails. + * + * @param clock_id ID of the clock to set. + * @param tp Time to set. + * @return 0 on success, -1 with errno on failure. + */ +int posix_clock_settime(posix_clockid_t clock_id, + const struct posix_timespec *tp) +{ + assert(tp != NULL); + + switch (clock_id) { + case CLOCK_REALTIME: + // TODO: setting clock + // FIXME: HelenOS doesn't actually support hardware + // clock yet + errno = EPERM; + return -1; + default: + errno = EINVAL; + return -1; + } +} + +/** + * Sleep on a specified clock. + * + * @param clock_id ID of the clock to sleep on (only CLOCK_REALTIME supported). + * @param flags Flags (none supported). + * @param rqtp Sleep time. + * @param rmtp Remaining time is written here if sleep is interrupted. + * @return 0 on success, -1 with errno set on failure. + */ +int posix_clock_nanosleep(posix_clockid_t clock_id, int flags, + const struct posix_timespec *rqtp, struct posix_timespec *rmtp) +{ + assert(rqtp != NULL); + assert(rmtp != NULL); + + switch (clock_id) { + case CLOCK_REALTIME: + // TODO: interruptible sleep + if (rqtp->tv_sec != 0) { + async_sleep(rqtp->tv_sec); + } + if (rqtp->tv_nsec != 0) { + async_usleep(rqtp->tv_nsec / 1000); + } + return 0; + default: + errno = EINVAL; + return -1; + } +} + +/** + * Get CPU time used since the process invocation. + * + * @return Consumed CPU cycles by this process or -1 if not available. + */ +posix_clock_t posix_clock(void) +{ + posix_clock_t total_cycles = -1; + stats_task_t *task_stats = stats_get_task(task_get_id()); + if (task_stats) { + total_cycles = (posix_clock_t) (task_stats->kcycles + + task_stats->ucycles); + free(task_stats); + task_stats = 0; + } + + return total_cycles; +} + +/** @} + */ Index: uspace/lib/posix/src/unistd.c =================================================================== --- uspace/lib/posix/src/unistd.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) +++ uspace/lib/posix/src/unistd.c (revision df2e5514fa8f0044ee3ce752a6fd5cf72425718e) @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Miscellaneous standard definitions. + */ + +#define LIBPOSIX_INTERNAL +#define __POSIX_DEF__(x) posix_##x + +#include "internal/common.h" +#include "posix/unistd.h" + +#include + +#include "posix/string.h" +#include "posix/fcntl.h" + +#include "libc/task.h" +#include "libc/thread.h" +#include "libc/stats.h" +#include "libc/malloc.h" +#include "libc/vfs/vfs.h" + +#include + +// FIXME: replace with a hash table +aoff64_t posix_pos[MAX_OPEN_FILES]; + +/* Array of environment variable strings (NAME=VALUE). */ +char **posix_environ = NULL; +char *posix_optarg; + +/** + * Sleep for the specified number of seconds. + * + * Note that POSIX allows this call to be interrupted and then the return + * value represents remaining seconds for the sleep. HelenOS does not offer + * such functionality and thus always the whole sleep is taken. + * + * @param seconds Number of seconds to sleep. + * @return Always 0 on HelenOS. + */ +unsigned int posix_sleep(unsigned int seconds) +{ + return thread_sleep(seconds); +} + +/** + * Get current user name. + * + * @return User name (static) string or NULL if not found. + */ +char *posix_getlogin(void) +{ + /* There is currently no support for user accounts in HelenOS. */ + return (char *) "user"; +} + +/** + * Get current user name. + * + * @param name Pointer to a user supplied buffer. + * @param namesize Length of the buffer. + * @return Zero on success, error code otherwise. + */ +int posix_getlogin_r(char *name, size_t namesize) +{ + /* There is currently no support for user accounts in HelenOS. */ + if (namesize >= 5) { + posix_strcpy(name, (char *) "user"); + return 0; + } else { + errno = ERANGE; + return -1; + } +} + +/** + * Test whether open file descriptor is associated with a terminal. + * + * @param fd Open file descriptor to test. + * @return Boolean result of the test. + */ +int posix_isatty(int fd) +{ + // TODO + /* Always returns false, because there is no easy way to find + * out under HelenOS. */ + return 0; +} + +/** + * Get the pathname of the current working directory. + * + * @param buf Buffer into which the pathname shall be put. + * @param size Size of the buffer. + * @return Buffer pointer on success, NULL on failure. + */ +char *posix_getcwd(char *buf, size_t size) +{ + if (failed(vfs_cwd_get(buf, size))) + return NULL; + return buf; +} + +/** + * Change the current working directory. + * + * @param path New working directory. + */ +int posix_chdir(const char *path) +{ + if (failed(vfs_cwd_set(path))) + return -1; + return 0; +} + +/** + * Determine the page size of the current run of the process. + * + * @return Page size of the process. + */ +int posix_getpagesize(void) +{ + return PAGE_SIZE; +} + +/** + * Get the process ID of the calling process. + * + * @return Process ID. + */ +posix_pid_t posix_getpid(void) +{ + return task_get_id(); +} + +/** + * Get the real user ID of the calling process. + * + * @return User ID. + */ +posix_uid_t posix_getuid(void) +{ + /* There is currently no support for user accounts in HelenOS. */ + return 0; +} + +/** + * Get the real group ID of the calling process. + * + * @return Group ID. + */ +posix_gid_t posix_getgid(void) +{ + /* There is currently no support for user accounts in HelenOS. */ + return 0; +} + +/** + * Close a file. + * + * @param fildes File descriptor of the opened file. + * @return 0 on success, -1 on error. + */ +int posix_close(int fildes) +{ + posix_pos[fildes] = 0; + if (failed(vfs_put(fildes))) + return -1; + else + return 0; +} + +/** + * Read from a file. + * + * @param fildes File descriptor of the opened file. + * @param buf Buffer to which the read bytes shall be stored. + * @param nbyte Upper limit on the number of read bytes. + * @return Number of read bytes on success, -1 otherwise. + */ +ssize_t posix_read(int fildes, void *buf, size_t nbyte) +{ + size_t nread; + if (failed(vfs_read(fildes, &posix_pos[fildes], buf, nbyte, &nread))) + return -1; + return (ssize_t) nread; +} + +/** + * Write to a file. + * + * @param fildes File descriptor of the opened file. + * @param buf Buffer to write. + * @param nbyte Size of the buffer. + * @return Number of written bytes on success, -1 otherwise. + */ +ssize_t posix_write(int fildes, const void *buf, size_t nbyte) +{ + size_t nwr; + if (failed(vfs_write(fildes, &posix_pos[fildes], buf, nbyte, &nwr))) + return -1; + return nwr; +} + +/** + * Reposition read/write file offset + * + * @param fildes File descriptor of the opened file. + * @param offset New offset in the file. + * @param whence The position from which the offset argument is specified. + * @return Upon successful completion, returns the resulting offset + * as measured in bytes from the beginning of the file, -1 otherwise. + */ +posix_off_t posix_lseek(int fildes, posix_off_t offset, int whence) +{ + vfs_stat_t st; + + switch (whence) { + case SEEK_SET: + posix_pos[fildes] = offset; + break; + case SEEK_CUR: + posix_pos[fildes] += offset; + break; + case SEEK_END: + if (failed(vfs_stat(fildes, &st))) + return -1; + posix_pos[fildes] = st.size + offset; + break; + } + if (posix_pos[fildes] > INT64_MAX) { + /* The native width is too large for the POSIX interface. */ + errno = ERANGE; + return -1; + } + return posix_pos[fildes]; +} + +/** + * Requests outstanding data to be written to the underlying storage device. + * + * @param fildes File descriptor of the opened file. + * @return Zero on success, -1 otherwise. + */ +int posix_fsync(int fildes) +{ + if (failed(vfs_sync(fildes))) + return -1; + else + return 0; +} + +/** + * Truncate a file to a specified length. + * + * @param fildes File descriptor of the opened file. + * @param length New length of the file. + * @return Zero on success, -1 otherwise. + */ +int posix_ftruncate(int fildes, posix_off_t length) +{ + if (failed(vfs_resize(fildes, (aoff64_t) length))) + return -1; + else + return 0; +} + +/** + * Remove a directory. + * + * @param path Directory pathname. + * @return Zero on success, -1 otherwise. + */ +int posix_rmdir(const char *path) +{ + if (failed(vfs_unlink_path(path))) + return -1; + else + return 0; +} + +/** + * Remove a link to a file. + * + * @param path File pathname. + * @return Zero on success, -1 otherwise. + */ +int posix_unlink(const char *path) +{ + if (failed(vfs_unlink_path(path))) + return -1; + else + return 0; +} + +/** + * Duplicate an open file descriptor. + * + * @param fildes File descriptor to be duplicated. + * @return On success, new file descriptor for the same file, otherwise -1. + */ +int posix_dup(int fildes) +{ + return posix_fcntl(fildes, F_DUPFD, 0); +} + +/** + * Duplicate an open file descriptor. + * + * @param fildes File descriptor to be duplicated. + * @param fildes2 File descriptor to be paired with the same file description + * as is paired fildes. + * @return fildes2 on success, -1 otherwise. + */ +int posix_dup2(int fildes, int fildes2) +{ + int file; + if (failed(vfs_clone(fildes, fildes2, false, &file))) { + return -1; + } + return file; +} + +/** + * Determine accessibility of a file. + * + * @param path File to check accessibility for. + * @param amode Either check for existence or intended access mode. + * @return Zero on success, -1 otherwise. + */ +int posix_access(const char *path, int amode) +{ + if (amode == F_OK || (amode & (X_OK | W_OK | R_OK))) { + /* HelenOS doesn't support permissions, permission checks + * are equal to existence check. + * + * Check file existence by attempting to open it. + */ + int fd = posix_open(path, O_RDONLY); + if (fd < 0) + return -1; + posix_close(fd); + return 0; + } else { + /* Invalid amode argument. */ + errno = EINVAL; + return -1; + } +} + +/** + * Get configurable system variables. + * + * @param name Variable name. + * @return Variable value. + */ +long posix_sysconf(int name) +{ + long clk_tck = 0; + size_t cpu_count = 0; + stats_cpu_t *cpu_stats = stats_get_cpus(&cpu_count); + if (cpu_stats && cpu_count > 0) { + clk_tck = ((long) cpu_stats[0].frequency_mhz) * 1000000L; + } + if (cpu_stats) { + free(cpu_stats); + cpu_stats = 0; + } + + long phys_pages = 0; + long avphys_pages = 0; + stats_physmem_t *mem_stats = stats_get_physmem(); + if (mem_stats) { + phys_pages = (long) (mem_stats->total / posix_getpagesize()); + avphys_pages = (long) (mem_stats->free / posix_getpagesize()); + free(mem_stats); + mem_stats = 0; + } + + switch (name) { + case _SC_PHYS_PAGES: + return phys_pages; + case _SC_AVPHYS_PAGES: + return avphys_pages; + case _SC_PAGESIZE: + return posix_getpagesize(); + case _SC_CLK_TCK: + return clk_tck; + default: + errno = EINVAL; + return -1; + } +} + +/** + * + * @param path + * @param name + * @return + */ +long posix_pathconf(const char *path, int name) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return -1; +} + +/** + * + * @return + */ +posix_pid_t posix_fork(void) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return -1; +} + +/** + * + * @param path + * @param argv + * @return + */ +int posix_execv(const char *path, char *const argv[]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return -1; +} + +/** + * + * @param file + * @param argv + * @return + */ +int posix_execvp(const char *file, char *const argv[]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return -1; +} + +/** + * + * @param fildes + * @return + */ +int posix_pipe(int fildes[2]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); + return -1; +} + +unsigned int posix_alarm(unsigned int seconds) +{ + not_implemented(); + return 0; +} + +/** @} + */