Index: uspace/lib/posix/source/ctype.c =================================================================== --- uspace/lib/posix/source/ctype.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/ctype.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,131 @@ +/* + * 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. + */ + +#define LIBPOSIX_INTERNAL + +#include "posix/ctype.h" + +/** + * Checks whether character is a hexadecimal digit. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isxdigit(int c) +{ + return isdigit(c) || + (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F'); +} + +/** + * Checks whether character is a word separator. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isblank(int c) +{ + return c == ' ' || c == '\t'; +} + +/** + * Checks whether character is a control character. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_iscntrl(int c) +{ + return c < 0x20 || c == 0x7E; +} + +/** + * Checks whether character is any printing character except space. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isgraph(int c) +{ + return posix_isprint(c) && c != ' '; +} + +/** + * Checks whether character is a printing character. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isprint(int c) +{ + return posix_isascii(c) && !posix_iscntrl(c); +} + +/** + * Checks whether character is a punctuation. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_ispunct(int c) +{ + return !isspace(c) && !isalnum(c) && posix_isprint(c); +} + +/** + * Checks whether character is ASCII. (obsolete) + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_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 posix_toascii(int c) +{ + return c & 0x7F; +} + +/** @} + */ Index: uspace/lib/posix/source/errno.c =================================================================== --- uspace/lib/posix/source/errno.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/errno.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,52 @@ +/* + * 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 System error numbers. + */ + +#include "posix/errno.h" + +#include "posix/stdlib.h" +#include "libc/fibril.h" + +static fibril_local int _posix_errno; + +int *__posix_errno(void) +{ + if (*__errno() != 0) { + _posix_errno = abs(*__errno()); + *__errno() = 0; + } + return &_posix_errno; +} + +/** @} + */ Index: uspace/lib/posix/source/fcntl.c =================================================================== --- uspace/lib/posix/source/fcntl.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/fcntl.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,98 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/fcntl.h" + +#include "libc/unistd.h" +#include "libc/vfs/vfs.h" +#include "posix/errno.h" + +/** + * 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; + } +} + +/** @} + */ Index: uspace/lib/posix/source/fnmatch.c =================================================================== --- uspace/lib/posix/source/fnmatch.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/fnmatch.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,716 @@ +/* + * 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. + */ + +#include "posix/stdbool.h" +#include "posix/ctype.h" +#include "posix/string.h" +#include "posix/stdlib.h" +#include "posix/assert.h" + +#define LIBPOSIX_INTERNAL + +#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 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 = 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 = 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 = 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) + + 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/source/getopt.c =================================================================== --- uspace/lib/posix/source/getopt.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/getopt.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,54 @@ +/* + * 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 + +#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/source/internal/common.h =================================================================== --- uspace/lib/posix/source/internal/common.h (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/internal/common.h (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,58 @@ +/* + * 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 + +#define not_implemented() (fprintf(stderr, \ + "Function %s() in file %s at line %d is not implemented\n", \ + __func__, __FILE__, __LINE__), abort()) + +/* A little helper macro to avoid typing this over and over. */ +#define errnify(func, ...) ({ \ + int rc = func(__VA_ARGS__); \ + if (rc < 0) { \ + errno = -rc; \ + rc = -1; \ + } \ + rc; \ +}) + +#endif /* LIBPOSIX_COMMON_H_ */ + +/** @} + */ Index: uspace/lib/posix/source/locale.c =================================================================== --- uspace/lib/posix/source/locale.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/locale.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,183 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/locale.h" + +#include "posix/errno.h" +#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/source/math.c =================================================================== --- uspace/lib/posix/source/math.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/math.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,65 @@ +/* + * 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 Mathematical operations. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "posix/math.h" + +/** + * + * @param x + * @param exp + * @return + */ +double posix_ldexp(double x, int exp) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param num + * @param exp + * @return + */ +double posix_frexp(double num, int *exp) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */ Index: uspace/lib/posix/source/pwd.c =================================================================== --- uspace/lib/posix/source/pwd.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/pwd.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,190 @@ +/* + * 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 + +#include "posix/pwd.h" +#include "posix/string.h" +#include "posix/errno.h" +#include "posix/assert.h" + +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/source/signal.c =================================================================== --- uspace/lib/posix/source/signal.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/signal.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,566 @@ +/* + * 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 + +#include "posix/signal.h" +#include "internal/common.h" +#include "posix/limits.h" +#include "posix/stdlib.h" +#include "posix/string.h" +#include "posix/errno.h" + +#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() +{ + 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/source/stdio.c =================================================================== --- uspace/lib/posix/source/stdio.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/stdio.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,807 @@ +/* + * 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 + +/* Has to be first. */ +#include "posix/stdbool.h" + +#include "internal/common.h" +#include "posix/stdio.h" + +#include "posix/assert.h" +#include "posix/errno.h" +#include "posix/stdlib.h" +#include "posix/string.h" +#include "posix/sys/types.h" +#include "posix/unistd.h" + +#include "libc/io/printf_core.h" +#include "libc/str.h" +#include "libc/malloc.h" +#include "libc/adt/list.h" +#include "libc/sys/stat.h" + + +/* not the best of solutions, but freopen and ungetc will eventually + * need to be implemented in libc anyway + */ +#include "../../c/generic/private/stdio.h" + +/** Clears the stream's error and end-of-file indicators. + * + * @param stream Stream whose indicators shall be cleared. + */ +void posix_clearerr(FILE *stream) +{ + stream->error = 0; + stream->eof = 0; +} + +/** + * 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) +{ + int rc = fputs(s, stream); + if (rc == 0) { + return EOF; + } else { + return 0; + } +} + +/** + * 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) +{ + uint8_t b = (uint8_t) c; + + bool can_unget = + /* Provided character is legal. */ + c != EOF && + /* Stream is consistent. */ + !stream->error && + /* Stream is buffered. */ + stream->btype != _IONBF && + /* Last operation on the stream was a read operation. */ + stream->buf_state == _bs_read && + /* Stream buffer is already allocated (i.e. there was already carried + * out either write or read operation on the stream). This is probably + * redundant check but let's be safe. */ + stream->buf != NULL && + /* There is still space in the stream to retreat. POSIX demands the + * possibility to unget at least 1 character. It should be always + * possible, assuming the last operation on the stream read at least 1 + * character, because the buffer is refilled in the lazily manner. */ + stream->buf_tail > stream->buf; + + if (can_unget) { + --stream->buf_tail; + stream->buf_tail[0] = b; + stream->eof = false; + return (int) b; + } else { + return EOF; + } +} + +/** + * 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) +{ + assert(mode != NULL); + assert(stream != NULL); + + if (filename == NULL) { + /* POSIX allows this to be imlementation-defined. HelenOS currently + * does not support changing the mode. */ + // FIXME: handle mode change once it is supported + return stream; + } + + /* Open a new stream. */ + FILE* new = fopen(filename, mode); + if (new == NULL) { + fclose(stream); + /* errno was set by fopen() */ + return NULL; + } + + /* Close the original stream without freeing it (ignoring errors). */ + if (stream->buf != NULL) { + fflush(stream); + } + if (stream->sess != NULL) { + async_hangup(stream->sess); + } + if (stream->fd >= 0) { + close(stream->fd); + } + list_remove(&stream->link); + + /* Move the new stream to the original location. */ + memcpy(stream, new, sizeof (FILE)); + free(new); + + /* Update references in the file list. */ + stream->link.next->prev = &stream->link; + stream->link.prev->next = &stream->link; + + return 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)); + } +} + +struct _posix_fpos { + off64_t offset; +}; + +/** 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) +{ + int rc = fflush(stream); + if (rc < 0) { + errno = -rc; + return EOF; + } else { + return 0; + } +} + +/** + * 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) +{ + ssize_t wr = write(*(int *) fd, str, size); + 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; + } + + if (write(*(int *) fd, buf, sz) != (ssize_t) sz) { + 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) +{ + struct stat st; + int rc = stat(path, &st); + + if (rc != EOK) { + errno = -rc; + return -1; + } + + if (st.is_directory) { + rc = rmdir(path); + } else { + rc = unlink(path); + } + + if (rc != EOK) { + errno = -rc; + return -1; + } + 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) +{ + return errnify(rename, old, new); +} + +/** + * 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 = 0; + /* 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/source/stdio/scanf.c =================================================================== --- uspace/lib/posix/source/stdio/scanf.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/stdio/scanf.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,1339 @@ +/* + * 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 + +/* Must be first. */ +#include "posix/stdbool.h" + +#include "posix/assert.h" +#include "posix/errno.h" + +#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" + +/** 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 = posix_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; + const char *cur_limited = NULL; + 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_limited = posix_strndup(cur_borrowed, width); + } else { + cur_limited = cur_borrowed; + } + cur_updated = (char *) 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 = posix_strtoull(cur_limited, &cur_updated, int_conv_base); + } else { + sres = posix_strtoll(cur_limited, &cur_updated, int_conv_base); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (width != -1 && cur_limited != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_limited); + } + 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 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: ; + posix_uintmax_t *pj = va_arg(arg, posix_uintmax_t *); + *pj = (posix_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: ; + posix_intmax_t *pj = va_arg(arg, posix_intmax_t *); + *pj = (posix_intmax_t) sres; + break; + case LMOD_z: ; + ssize_t *pz = va_arg(arg, ssize_t *); + *pz = (ssize_t) sres; + break; + case LMOD_t: ; + posix_ptrdiff_t *pt = va_arg(arg, posix_ptrdiff_t *); + *pt = (posix_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_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_limited = posix_strndup(cur_borrowed, width); + } else { + cur_limited = cur_borrowed; + } + cur_updated = (char *) 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, &cur_updated); + break; + case LMOD_l: + dres = posix_strtod(cur_limited, &cur_updated); + break; + case LMOD_L: + ldres = posix_strtold(cur_limited, &cur_updated); + break; + default: + assert(false); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (width != -1 && cur_limited != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_limited); + } + 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); +} + +// FIXME: put the testcases to the app/tester after scanf is included into libc + +#if 0 + +//#include +//#include +//#include + +#define test_val(fmt, exp_val, act_val) \ + if (exp_val == act_val) { \ + printf("succ, expected "fmt", actual "fmt"\n", exp_val, act_val); \ + } else { \ + printf("fail, expected "fmt", actual "fmt"\n", exp_val, act_val); \ + ++fail; \ + } + +#define test_str(fmt, exp_str, act_str) \ + if (posix_strcmp(exp_str, act_str) == 0) { \ + printf("succ, expected "fmt", actual "fmt"\n", exp_str, act_str); \ + } else { \ + printf("fail, expected "fmt", actual "fmt"\n", exp_str, act_str); \ + ++fail; \ + } + +void __posix_scanf_test(void); +void __posix_scanf_test(void) +{ + int fail = 0; + + int ret; + + unsigned char uhh; + signed char shh; + unsigned short uh; + short sh; + unsigned udef; + int sdef; + unsigned long ul; + long sl; + unsigned long long ull; + long long sll; + void *p; + + float f; + double d; + long double ld; + + char str[20]; + char seq[20]; + char scanset[20]; + + char *pstr; + char *pseq; + char *pscanset; + + ret = posix_sscanf( + "\n j tt % \t -121314 98765 aqw 0765 0x77 0xABCDEF88 -99 884", + " j tt %%%3hhd%1hhu%3hd %3hu%u aqw%n %lo%llx %p %li %lld", + &shh, &uhh, &sh, &uh, &udef, &sdef, &ul, &ull, &p, &sl, &sll); + test_val("%d", -12, shh); + test_val("%u", 1, uhh); + test_val("%d", 314, sh); + test_val("%u", 987, uh); + test_val("%u", 65, udef); + test_val("%d", 28, sdef); + test_val("%lo", (unsigned long) 0765, ul); + test_val("%llx", (unsigned long long) 0x77, ull); + test_val("%p", (void *) 0xABCDEF88, p); + test_val("%ld", (long) -99, sl); + test_val("%lld", (long long) 884, sll); + test_val("%d", 10, ret); + + ret = posix_sscanf( + "\n \t\t1.0 -0x555.AP10 1234.5678e12", + "%f %lf %Lf", + &f, &d, &ld); + test_val("%f", 1.0, f); + test_val("%lf", (double) -0x555.AP10, d); + test_val("%Lf", (long double) 1234.5678e12, ld); + test_val("%d", 3, ret); + + ret = posix_sscanf( + "\n\n\thello world \n", + "%5s %ms", + str, &pstr); + test_str("%s", "hello", str); + test_str("%s", "world", pstr); + test_val("%d", 2, ret); + free(pstr); + + ret = posix_sscanf( + "\n\n\thello world \n", + " %5c %mc", + seq, &pseq); + seq[5] = '\0'; + pseq[1] = '\0'; + test_str("%s", "hello", seq); + test_str("%s", "w", pseq); + test_val("%d", 2, ret); + free(pseq); + + ret = posix_sscanf( + "\n\n\th-e-l-l-o world-] \n", + " %9[-eh-o] %m[^]-]", + scanset, &pscanset); + test_str("%s", "h-e-l-l-o", scanset); + test_str("%s", "world", pscanset); + test_val("%d", 2, ret); + free(pscanset); + + printf("Failed: %d\n", fail); +} + +#endif + +/** @} + */ Index: uspace/lib/posix/source/stdlib.c =================================================================== --- uspace/lib/posix/source/stdlib.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/stdlib.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,504 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/stdlib.h" + +#include "posix/errno.h" +#include "posix/fcntl.h" +#include "posix/limits.h" +#include "posix/string.h" +#include "posix/sys/stat.h" +#include "posix/unistd.h" + +#include "libc/sort.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(); +} + +/** + * 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 }; +} + +/** + * Private helper function that serves as a compare function for qsort(). + * + * @param elem1 First element to compare. + * @param elem2 Second element to compare. + * @param compare Comparison function without userdata parameter. + * @return Relative ordering of the elements. + */ +static int sort_compare_wrapper(void *elem1, void *elem2, void *userdata) +{ + int (*compare)(const void *, const void *) = userdata; + int ret = compare(elem1, elem2); + + /* Native qsort internals expect this. */ + if (ret < 0) { + return -1; + } else if (ret > 0) { + return 1; + } else { + return 0; + } +} + +/** + * 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 *)) +{ + /* Implemented in libc with one extra argument. */ + qsort(array, count, size, sort_compare_wrapper, 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(); +} + +/** + * 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 + 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 = 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); + } +} + +/** + * 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 = 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/source/stdlib/strtol.c =================================================================== --- uspace/lib/posix/source/stdlib/strtol.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/stdlib/strtol.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,399 @@ +/* + * 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 integer conversions. + */ + +#define LIBPOSIX_INTERNAL + +#include "../internal/common.h" +#include "posix/stdlib.h" + +#include "posix/ctype.h" +#include "posix/errno.h" +#include "posix/inttypes.h" +#include "posix/limits.h" + +#define intmax_t posix_intmax_t +#define uintmax_t posix_uintmax_t + +/** + * Decides whether a digit belongs to a particular base. + * + * @param c Character representation of the digit. + * @param base Base against which the digit shall be tested. + * @return True if the digit belongs to the base, false otherwise. + */ +static inline bool is_digit_in_base(int c, int base) +{ + if (base <= 10) { + return c >= '0' && c < '0' + base; + } else { + return isdigit(c) || + (tolower(c) >= 'a' && tolower(c) < ('a' + base - 10)); + } +} + +/** + * Derive a digit from its character representation. + * + * @param c Character representation of the digit. + * @return Digit value represented by an integer. + */ +static inline int digit_value(int c) +{ + if (c <= '9') { + return c - '0'; + } else { + return 10 + tolower(c) - 'a'; + } +} + +/** + * Generic function for parsing an integer from it's string representation. + * Different variants differ in lower and upper bounds. + * The parsed string returned by this function is always positive, sign + * information is provided via a dedicated parameter. + * + * @param nptr Input string. + * @param endptr If non-NULL, *endptr is set to the position of the first + * unrecognized character. If no digit has been parsed, value of + * nptr is stored there (regardless of any skipped characters at the + * beginning). + * @param base Expected base of the string representation. If 0, base is + * determined to be decimal, octal or hexadecimal using the same rules + * as C syntax. Otherwise, value must be between 2 and 36, inclusive. + * @param min_value Lower bound for the resulting conversion. + * @param max_value Upper bound for the resulting conversion. + * @param out_negative Either NULL for unsigned conversion or a pointer to the + * bool variable into which shall be placed the negativity of the resulting + * converted value. + * @return The absolute value of the parsed value, or the closest in-range value + * if the parsed value is out of range. If the input is invalid, zero is + * returned and errno is set to EINVAL. + */ +static inline uintmax_t internal_strtol( + const char *restrict nptr, char **restrict endptr, int base, + const intmax_t min_value, const uintmax_t max_value, + bool *restrict out_negative) +{ + if (nptr == NULL) { + errno = EINVAL; + return 0; + } + + if (base < 0 || base == 1 || base > 36) { + errno = EINVAL; + return 0; + } + + /* The maximal absolute value that can be returned in this run. + * Depends on sign. + */ + uintmax_t real_max_value = max_value; + + /* Current index in the input string. */ + size_t i = 0; + bool negative = false; + + /* Skip whitespace. */ + while (isspace(nptr[i])) { + i++; + } + + /* Parse sign. */ + switch (nptr[i]) { + case '-': + negative = true; + + /* The strange computation is are there to avoid a corner case + * where -min_value can't be represented in intmax_t. + * (I'm not exactly sure what the semantics are in such a + * case, but this should be safe for any case.) + */ + real_max_value = (min_value == 0) + ? 0 + :(((uintmax_t) -(min_value + 1)) + 1); + + /* fallthrough */ + case '+': + i++; + } + + /* Figure out the base. */ + switch (base) { + case 0: + if (nptr[i] == '0') { + if (tolower(nptr[i + 1]) == 'x') { + /* 0x... is hex. */ + base = 16; + i += 2; + } else { + /* 0... is octal. */ + base = 8; + } + } else { + /* Anything else is decimal by default. */ + base = 10; + } + break; + case 16: + /* Allow hex number to be prefixed with "0x". */ + if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x') { + i += 2; + } + break; + } + + if (!is_digit_in_base(nptr[i], base)) { + /* No digits to parse, invalid input. */ + + errno = EINVAL; + if (endptr != NULL) { + *endptr = (char *) nptr; + } + return 0; + } + + /* Maximal value to which a digit can be added without a risk + * of overflow. + */ + uintmax_t max_safe_value = (real_max_value - base + 1) / base; + + uintmax_t result = 0; + + if (real_max_value == 0) { + /* Special case when a negative number is parsed as + * unsigned integer. Only -0 is accepted. + */ + + while (is_digit_in_base(nptr[i], base)) { + if (nptr[i] != '0') { + errno = ERANGE; + result = 0; + } + i++; + } + } + + while (is_digit_in_base(nptr[i], base)) { + int digit = digit_value(nptr[i]); + + if (result > max_safe_value) { + /* corner case, check for overflow */ + + uintmax_t boundary = (real_max_value - digit) / base; + + if (result > boundary) { + /* overflow */ + errno = ERANGE; + result = real_max_value; + break; + } + } + + result = result * base + digit; + i++; + } + + if (endptr != NULL) { + /* Move the pointer to the end of the number, + * in case it isn't there already. + */ + while (is_digit_in_base(nptr[i], base)) { + i++; + } + + *endptr = (char *) &nptr[i]; + } + if (out_negative != NULL) { + *out_negative = negative; + } + return result; +} + +/** + * Convert a string to an integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +int posix_atoi(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, INT_MIN, INT_MAX, &neg); + + return (neg ? ((int) -result) : (int) result); +} + +/** + * Convert a string to a long integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +long posix_atol(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, LONG_MIN, LONG_MAX, &neg); + + return (neg ? ((long) -result) : (long) result); +} + +/** + * Convert a string to a long long integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +long long posix_atoll(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, LLONG_MIN, LLONG_MAX, &neg); + + return (neg ? ((long long) -result) : (long long) result); +} + +/** + * Convert a string to a long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +long posix_strtol(const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, LONG_MIN, LONG_MAX, &neg); + + return (neg ? ((long) -result) : ((long) result)); +} + +/** + * Convert a string to a long long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +long long posix_strtoll( + const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &neg); + + return (neg ? ((long long) -result) : (long long) result); +} + +/** + * Convert a string to a largest signed integer type. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +intmax_t posix_strtoimax( + const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &neg); + + return (neg ? ((intmax_t) -result) : (intmax_t) result); +} + +/** + * Convert a string to an unsigned long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +unsigned long posix_strtoul( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, ULONG_MAX, NULL); + + return (unsigned long) result; +} + +/** + * Convert a string to an unsigned long long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +unsigned long long posix_strtoull( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL); + + return (unsigned long long) result; +} + +/** + * Convert a string to a largest unsigned integer type. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +uintmax_t posix_strtoumax( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, UINTMAX_MAX, NULL); + + return result; +} + +/** @} + */ Index: uspace/lib/posix/source/stdlib/strtold.c =================================================================== --- uspace/lib/posix/source/stdlib/strtold.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/stdlib/strtold.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,491 @@ +/* + * 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 + +/* Must be first. */ +#include "posix/stdbool.h" + +#include "../internal/common.h" +#include "posix/stdlib.h" + +#include "posix/assert.h" +#include "posix/ctype.h" +#include "posix/stdint.h" +#include "posix/strings.h" +#include "posix/errno.h" +#include "posix/limits.h" + +#include "posix/float.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 (posix_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' && + (posix_isxdigit(nptr[i + 2]) || + (nptr[i + 2] == RADIX && posix_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/source/string.c =================================================================== --- uspace/lib/posix/source/string.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/string.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,754 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/string.h" + +#include "posix/assert.h" +#include "posix/errno.h" +#include "posix/limits.h" +#include "posix/stdlib.h" +#include "posix/signal.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; +} + +/** + * 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) +{ + static const char *error_msgs[] = { + [E2BIG] = "[E2BIG] Argument list too long", + [EACCES] = "[EACCES] Permission denied", + [EADDRINUSE] = "[EADDRINUSE] Address in use", + [EADDRNOTAVAIL] = "[EADDRNOTAVAIL] Address not available", + [EAFNOSUPPORT] = "[EAFNOSUPPORT] Address family not supported", + [EAGAIN] = "[EAGAIN] Resource unavailable, try again", + [EALREADY] = "[EALREADY] Connection already in progress", + [EBADF] = "[EBADF] Bad file descriptor", + [EBADMSG] = "[EBADMSG] Bad message", + [EBUSY] = "[EBUSY] Device or resource busy", + [ECANCELED] = "[ECANCELED] Operation canceled", + [ECHILD] = "[ECHILD] No child processes", + [ECONNABORTED] = "[ECONNABORTED] Connection aborted", + [ECONNREFUSED] = "[ECONNREFUSED] Connection refused", + [ECONNRESET] = "[ECONNRESET] Connection reset", + [EDEADLK] = "[EDEADLK] Resource deadlock would occur", + [EDESTADDRREQ] = "[EDESTADDRREQ] Destination address required", + [EDOM] = "[EDOM] Mathematics argument out of domain of function", + [EDQUOT] = "[EDQUOT] Reserved", + [EEXIST] = "[EEXIST] File exists", + [EFAULT] = "[EFAULT] Bad address", + [EFBIG] = "[EFBIG] File too large", + [EHOSTUNREACH] = "[EHOSTUNREACH] Host is unreachable", + [EIDRM] = "[EIDRM] Identifier removed", + [EILSEQ] = "[EILSEQ] Illegal byte sequence", + [EINPROGRESS] = "[EINPROGRESS] Operation in progress", + [EINTR] = "[EINTR] Interrupted function", + [EINVAL] = "[EINVAL] Invalid argument", + [EIO] = "[EIO] I/O error", + [EISCONN] = "[EISCONN] Socket is connected", + [EISDIR] = "[EISDIR] Is a directory", + [ELOOP] = "[ELOOP] Too many levels of symbolic links", + [EMFILE] = "[EMFILE] File descriptor value too large", + [EMLINK] = "[EMLINK] Too many links", + [EMSGSIZE] = "[EMSGSIZE] Message too large", + [EMULTIHOP] = "[EMULTIHOP] Reserved", + [ENAMETOOLONG] = "[ENAMETOOLONG] Filename too long", + [ENETDOWN] = "[ENETDOWN] Network is down", + [ENETRESET] = "[ENETRESET] Connection aborted by network", + [ENETUNREACH] = "[ENETUNREACH] Network unreachable", + [ENFILE] = "[ENFILE] Too many files open in system", + [ENOBUFS] = "[ENOBUFS] No buffer space available", + [ENODATA] = "[ENODATA] No message is available on the STREAM head read queue", + [ENODEV] = "[ENODEV] No such device", + [ENOENT] = "[ENOENT] No such file or directory", + [ENOEXEC] = "[ENOEXEC] Executable file format error", + [ENOLCK] = "[ENOLCK] No locks available", + [ENOLINK] = "[ENOLINK] Reserved", + [ENOMEM] = "[ENOMEM] Not enough space", + [ENOMSG] = "[ENOMSG] No message of the desired type", + [ENOPROTOOPT] = "[ENOPROTOOPT] Protocol not available", + [ENOSPC] = "[ENOSPC] No space left on device", + [ENOSR] = "[ENOSR] No STREAM resources.", + [ENOSTR] = "[ENOSTR] Not a STREAM", + [ENOSYS] = "[ENOSYS] Function not supported", + [ENOTCONN] = "[ENOTCONN] The socket is not connected", + [ENOTDIR] = "[ENOTDIR] Not a directory", + [ENOTEMPTY] = "[ENOTEMPTY] Directory not empty", + [ENOTRECOVERABLE] = "[ENOTRECOVERABLE] State not recoverable", + [ENOTSOCK] = "[ENOTSOCK] Not a socket", + [ENOTSUP] = "[ENOTSUP] Not supported", + [ENOTTY] = "[ENOTTY] Inappropriate I/O control operation", + [ENXIO] = "[ENXIO] No such device or address", + [EOPNOTSUPP] = "[EOPNOTSUPP] Operation not supported", + [EOVERFLOW] = "[EOVERFLOW] Value too large to be stored in data type", + [EOWNERDEAD] = "[EOWNERDEAD] Previous owned died", + [EPERM] = "[EPERM] Operation not permitted", + [EPIPE] = "[EPIPE] Broken pipe", + [EPROTO] = "[EPROTO] Protocol error", + [EPROTONOSUPPORT] = "[EPROTONOSUPPORT] Protocol not supported", + [EPROTOTYPE] = "[EPROTOTYPE] Protocol wrong type for socket", + [ERANGE] = "[ERANGE] Result too large", + [EROFS] = "[EROFS] Read-only file system", + [ESPIPE] = "[ESPIPE] Invalid seek", + [ESRCH] = "[ESRCH] No such process", + [ESTALE] = "[ESTALE] Reserved", + [ETIME] = "[ETIME] Stream ioctl() timeout", + [ETIMEDOUT] = "[ETIMEDOUT] Connection timed out", + [ETXTBSY] = "[ETXTBSY] Text file busy", + [EWOULDBLOCK] = "[EWOULDBLOCK] Operation would block", + [EXDEV] = "[EXDEV] Cross-device link", + }; + + return (char *) error_msgs[posix_abs(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 0; +} + +/** + * 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/source/strings.c =================================================================== --- uspace/lib/posix/source/strings.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/strings.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,187 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/strings.h" + +#include "posix/string.h" +#include "posix/ctype.h" + +#include "libc/mem.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 bcmp(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) +{ + bzero(mem, 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/source/sys/stat.c =================================================================== --- uspace/lib/posix/source/sys/stat.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/sys/stat.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,150 @@ +/* + * 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 + +#include "../internal/common.h" +#include "posix/sys/stat.h" + +#include "posix/errno.h" +#include "libc/mem.h" + +/** + * Convert HelenOS stat struct into POSIX stat struct (if possible). + * + * @param dest POSIX stat struct. + * @param src HelenOS stat struct. + */ +static void stat_to_posix(struct posix_stat *dest, struct stat *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; +} + +/** + * 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) +{ + struct stat hst; + int rc = fstat(fd, &hst); + if (rc < 0) { + /* fstat() returns negative error code instead of using errno. */ + errno = -rc; + return -1; + } + stat_to_posix(st, &hst); + return 0; +} + +/** + * 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) +{ + struct stat hst; + int rc = stat(path, &hst); + if (rc < 0) { + /* stat() returns negative error code instead of using errno. */ + errno = -rc; + return -1; + } + stat_to_posix(st, &hst); + return 0; +} + +/** + * 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, 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. + */ +mode_t posix_umask(mode_t mask) +{ + /* HelenOS doesn't support permissions, return empty mask. */ + return 0; +} + +/** @} + */ Index: uspace/lib/posix/source/sys/wait.c =================================================================== --- uspace/lib/posix/source/sys/wait.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/sys/wait.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -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 + +#include "../internal/common.h" +#include "posix/sys/wait.h" + +#include "libc/task.h" +#include "posix/assert.h" +#include "posix/errno.h" +#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; + + int rc = task_wait((task_id_t) pid, &texit, &retval); + + if (rc < 0) { + /* Unable to retrieve status. */ + errno = -rc; + 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/source/time.c =================================================================== --- uspace/lib/posix/source/time.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/time.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,905 @@ +/* + * 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 + +/* Must be first. */ +#include "posix/stdbool.h" + +#include "internal/common.h" +#include "posix/time.h" + +#include "posix/ctype.h" +#include "posix/errno.h" +#include "posix/signal.h" +#include "posix/assert.h" + +#include "libc/malloc.h" +#include "libc/task.h" +#include "libc/stats.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. + */ + + + +/* Helper functions ***********************************************************/ + +#define HOURS_PER_DAY (24) +#define MINS_PER_HOUR (60) +#define SECS_PER_MIN (60) +#define MINS_PER_DAY (MINS_PER_HOUR * HOURS_PER_DAY) +#define SECS_PER_HOUR (SECS_PER_MIN * MINS_PER_HOUR) +#define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY) + +/** + * Checks whether the year is a leap year. + * + * @param year Year since 1900 (e.g. for 1970, the value is 70). + * @return true if year is a leap year, false otherwise + */ +static bool _is_leap_year(time_t year) +{ + year += 1900; + + if (year % 400 == 0) + return true; + if (year % 100 == 0) + return false; + if (year % 4 == 0) + return true; + return false; +} + +/** + * Returns how many days there are in the given month of the given year. + * Note that year is only taken into account if month is February. + * + * @param year Year since 1900 (can be negative). + * @param mon Month of the year. 0 for January, 11 for December. + * @return Number of days in the specified month. + */ +static int _days_in_month(time_t year, time_t mon) +{ + assert(mon >= 0 && mon <= 11); + + static int month_days[] = + { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; + + if (mon == 1) { + year += 1900; + /* february */ + return _is_leap_year(year) ? 29 : 28; + } else { + return month_days[mon]; + } +} + +/** + * For specified year, month and day of month, returns which day of that year + * it is. + * + * For example, given date 2011-01-03, the corresponding expression is: + * _day_of_year(111, 0, 3) == 2 + * + * @param year Year (year 1900 = 0, can be negative). + * @param mon Month (January = 0). + * @param mday Day of month (First day is 1). + * @return Day of year (First day is 0). + */ +static int _day_of_year(time_t year, time_t mon, time_t mday) +{ + static int mdays[] = + { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; + static int leap_mdays[] = + { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }; + + return (_is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1; +} + +/** + * Integer division that rounds to negative infinity. + * Used by some functions in this file. + * + * @param op1 Divident. + * @param op2 Divisor. + * @return Rounded quotient. + */ +static time_t _floor_div(time_t op1, time_t op2) +{ + if (op1 >= 0 || op1 % op2 == 0) { + return op1 / op2; + } else { + return op1 / op2 - 1; + } +} + +/** + * Modulo that rounds to negative infinity. + * Used by some functions in this file. + * + * @param op1 Divident. + * @param op2 Divisor. + * @return Remainder. + */ +static time_t _floor_mod(time_t op1, time_t op2) +{ + int div = _floor_div(op1, op2); + + /* (a / b) * b + a % b == a */ + /* thus, a % b == a - (a / b) * b */ + + int result = op1 - div * op2; + + /* Some paranoid checking to ensure I didn't make a mistake here. */ + assert(result >= 0); + assert(result < op2); + assert(div * op2 + result == op1); + + return result; +} + +/** + * Number of days since the Epoch. + * Epoch is 1970-01-01, which is also equal to day 0. + * + * @param year Year (year 1900 = 0, may be negative). + * @param mon Month (January = 0). + * @param mday Day of month (first day = 1). + * @return Number of days since the Epoch. + */ +static time_t _days_since_epoch(time_t year, time_t mon, time_t mday) +{ + return (year - 70) * 365 + _floor_div(year - 69, 4) - + _floor_div(year - 1, 100) + _floor_div(year + 299, 400) + + _day_of_year(year, mon, mday); +} + +/** + * Seconds since the Epoch. see also _days_since_epoch(). + * + * @param tm Normalized broken-down time. + * @return Number of seconds since the epoch, not counting leap seconds. + */ +static time_t _secs_since_epoch(const struct posix_tm *tm) +{ + return _days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) * + SECS_PER_DAY + tm->tm_hour * SECS_PER_HOUR + + tm->tm_min * SECS_PER_MIN + tm->tm_sec; +} + +/** + * Which day of week the specified date is. + * + * @param year Year (year 1900 = 0). + * @param mon Month (January = 0). + * @param mday Day of month (first = 1). + * @return Day of week (Sunday = 0). + */ +static int _day_of_week(time_t year, time_t mon, time_t mday) +{ + /* 1970-01-01 is Thursday */ + return _floor_mod((_days_since_epoch(year, mon, mday) + 4), 7); +} + +/** + * Normalizes the broken-down time and optionally adds specified amount of + * seconds. + * + * @param tm Broken-down time to normalize. + * @param sec_add Seconds to add. + * @return 0 on success, -1 on overflow + */ +static int _normalize_time(struct posix_tm *tm, time_t sec_add) +{ + // TODO: DST correction + + /* Set initial values. */ + time_t sec = tm->tm_sec + sec_add; + time_t min = tm->tm_min; + time_t hour = tm->tm_hour; + time_t day = tm->tm_mday - 1; + time_t mon = tm->tm_mon; + time_t year = tm->tm_year; + + /* Adjust time. */ + min += _floor_div(sec, SECS_PER_MIN); + sec = _floor_mod(sec, SECS_PER_MIN); + hour += _floor_div(min, MINS_PER_HOUR); + min = _floor_mod(min, MINS_PER_HOUR); + day += _floor_div(hour, HOURS_PER_DAY); + hour = _floor_mod(hour, HOURS_PER_DAY); + + /* Adjust month. */ + year += _floor_div(mon, 12); + mon = _floor_mod(mon, 12); + + /* Now the difficult part - days of month. */ + + /* First, deal with whole cycles of 400 years = 146097 days. */ + year += _floor_div(day, 146097) * 400; + day = _floor_mod(day, 146097); + + /* Then, go in one year steps. */ + if (mon <= 1) { + /* January and February. */ + while (day > 365) { + day -= _is_leap_year(year) ? 366 : 365; + year++; + } + } else { + /* Rest of the year. */ + while (day > 365) { + day -= _is_leap_year(year + 1) ? 366 : 365; + year++; + } + } + + /* Finally, finish it off month per month. */ + while (day >= _days_in_month(year, mon)) { + day -= _days_in_month(year, mon); + mon++; + if (mon >= 12) { + mon -= 12; + year++; + } + } + + /* Calculate the remaining two fields. */ + tm->tm_yday = _day_of_year(year, mon, day + 1); + tm->tm_wday = _day_of_week(year, mon, day + 1); + + /* And put the values back to the struct. */ + tm->tm_sec = (int) sec; + tm->tm_min = (int) min; + tm->tm_hour = (int) hour; + tm->tm_mday = (int) day + 1; + tm->tm_mon = (int) mon; + + /* Casts to work around libc brain-damage. */ + if (year > ((int)INT_MAX) || year < ((int)INT_MIN)) { + tm->tm_year = (year < 0) ? ((int)INT_MIN) : ((int)INT_MAX); + return -1; + } + + tm->tm_year = (int) year; + return 0; +} + +/** + * Which day the week-based year starts on, relative to the first calendar day. + * E.g. if the year starts on December 31st, the return value is -1. + * + * @param Year since 1900. + * @return Offset of week-based year relative to calendar year. + */ +static int _wbyear_offset(int year) +{ + int start_wday = _day_of_week(year, 0, 1); + return _floor_mod(4 - start_wday, 7) - 3; +} + +/** + * Returns week-based year of the specified time. + * + * @param tm Normalized broken-down time. + * @return Week-based year. + */ +static int _wbyear(const struct posix_tm *tm) +{ + int day = tm->tm_yday - _wbyear_offset(tm->tm_year); + if (day < 0) { + /* Last week of previous year. */ + return tm->tm_year - 1; + } + if (day > 364 + _is_leap_year(tm->tm_year)) { + /* First week of next year. */ + return tm->tm_year + 1; + } + /* All the other days are in the calendar year. */ + return tm->tm_year; +} + +/** + * Week number of the year, assuming weeks start on sunday. + * The first Sunday of January is the first day of week 1; + * days in the new year before this are in week 0. + * + * @param tm Normalized broken-down time. + * @return The week number (0 - 53). + */ +static int _sun_week_number(const struct posix_tm *tm) +{ + int first_day = (7 - _day_of_week(tm->tm_year, 0, 1)) % 7; + return (tm->tm_yday - first_day + 7) / 7; +} + +/** + * Week number of the year, assuming weeks start on monday. + * If the week containing January 1st has four or more days in the new year, + * then it is considered week 1. Otherwise, it is the last week of the previous + * year, and the next week is week 1. Both January 4th and the first Thursday + * of January are always in week 1. + * + * @param tm Normalized broken-down time. + * @return The week number (1 - 53). + */ +static int _iso_week_number(const struct posix_tm *tm) +{ + int day = tm->tm_yday - _wbyear_offset(tm->tm_year); + if (day < 0) { + /* Last week of previous year. */ + return 53; + } + if (day > 364 + _is_leap_year(tm->tm_year)) { + /* First week of next year. */ + return 1; + } + /* All the other days give correct answer. */ + return (day / 7 + 1); +} + +/** + * Week number of the year, assuming weeks start on monday. + * The first Monday of January is the first day of week 1; + * days in the new year before this are in week 0. + * + * @param tm Normalized broken-down time. + * @return The week number (0 - 53). + */ +static int _mon_week_number(const struct posix_tm *tm) +{ + int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7; + return (tm->tm_yday - first_day + 7) / 7; +} + +/******************************************************************************/ + +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; +} + +/** + * Calculate the difference between two times, in seconds. + * + * @param time1 First time. + * @param time0 Second time. + * @return Time in seconds. + */ +double posix_difftime(time_t time1, time_t time0) +{ + return (double) (time1 - time0); +} + +/** + * This function first normalizes the provided broken-down time + * (moves all values to their proper bounds) and then tries to + * calculate the appropriate time_t representation. + * + * @param tm Broken-down time. + * @return time_t representation of the time, undefined value on overflow. + */ +time_t posix_mktime(struct posix_tm *tm) +{ + // TODO: take DST flag into account + // TODO: detect overflow + + _normalize_time(tm, 0); + return _secs_since_epoch(tm); +} + +/** + * Converts a time value to a broken-down UTC time. + * + * @param timer Time to convert. + * @return Normalized broken-down time in UTC, NULL on overflow. + */ +struct posix_tm *posix_gmtime(const time_t *timer) +{ + assert(timer != NULL); + + static struct posix_tm result; + return posix_gmtime_r(timer, &result); +} + +/** + * 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 posix_tm *posix_gmtime_r(const time_t *restrict timer, + struct posix_tm *restrict result) +{ + assert(timer != NULL); + assert(result != NULL); + + /* Set result to epoch. */ + result->tm_sec = 0; + result->tm_min = 0; + result->tm_hour = 0; + result->tm_mday = 1; + result->tm_mon = 0; + result->tm_year = 70; /* 1970 */ + + if (_normalize_time(result, *timer) == -1) { + errno = EOVERFLOW; + return NULL; + } + + return result; +} + +/** + * Converts a time value to a broken-down local time. + * + * @param timer Time to convert. + * @return Normalized broken-down time in local timezone, NULL on overflow. + */ +struct posix_tm *posix_localtime(const time_t *timer) +{ + static struct posix_tm result; + return posix_localtime_r(timer, &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 posix_tm *posix_localtime_r(const time_t *restrict timer, + struct posix_tm *restrict result) +{ + // TODO: deal with timezone + // currently assumes system and all times are in GMT + return posix_gmtime_r(timer, 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. + * @return Pointer to a statically allocated string. + */ +char *posix_asctime(const struct posix_tm *timeptr) +{ + static char buf[ASCTIME_BUF_LEN]; + return posix_asctime_r(timeptr, buf); +} + +/** + * 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 posix_tm *restrict timeptr, + char *restrict buf) +{ + assert(timeptr != NULL); + assert(buf != NULL); + + static const char *wday[] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + static const char *mon[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" + }; + + snprintf(buf, ASCTIME_BUF_LEN, "%s %s %2d %02d:%02d:%02d %d\n", + wday[timeptr->tm_wday], + mon[timeptr->tm_mon], + timeptr->tm_mday, timeptr->tm_hour, + timeptr->tm_min, timeptr->tm_sec, + 1900 + timeptr->tm_year); + + return buf; +} + +/** + * Equivalent to asctime(localtime(clock)). + * + * @param timer Time to convert. + * @return Pointer to a statically allocated string holding the date. + */ +char *posix_ctime(const time_t *timer) +{ + struct posix_tm *loctime = posix_localtime(timer); + if (loctime == NULL) { + return NULL; + } + return posix_asctime(loctime); +} + +/** + * Reentrant variant of ctime(). + * + * @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 falure. + */ +char *posix_ctime_r(const time_t *timer, char *buf) +{ + struct posix_tm loctime; + if (posix_localtime_r(timer, &loctime) == NULL) { + return NULL; + } + return posix_asctime_r(&loctime, buf); +} + +/** + * Convert time and date to a string, based on a specified format and + * current locale. + * + * @param s Buffer to write string to. + * @param maxsize Size of the buffer. + * @param format Format of the output. + * @param tm Broken-down time to format. + * @return Number of bytes written. + */ +size_t posix_strftime(char *restrict s, size_t maxsize, + const char *restrict format, const struct posix_tm *restrict tm) +{ + assert(s != NULL); + assert(format != NULL); + assert(tm != NULL); + + // TODO: use locale + static const char *wday_abbr[] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + static const char *wday[] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday" + }; + static const char *mon_abbr[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" + }; + static const char *mon[] = { + "January", "February", "March", "April", "May", "June", "July", + "August", "September", "October", "November", "December" + }; + + if (maxsize < 1) { + return 0; + } + + char *ptr = s; + size_t consumed; + size_t remaining = maxsize; + + #define append(...) { \ + /* FIXME: this requires POSIX-correct snprintf */ \ + /* otherwise it won't work with non-ascii chars */ \ + consumed = snprintf(ptr, remaining, __VA_ARGS__); \ + if (consumed >= remaining) { \ + return 0; \ + } \ + ptr += consumed; \ + remaining -= consumed; \ + } + + #define recurse(fmt) { \ + consumed = posix_strftime(ptr, remaining, fmt, tm); \ + if (consumed == 0) { \ + return 0; \ + } \ + ptr += consumed; \ + remaining -= consumed; \ + } + + #define TO_12H(hour) (((hour) > 12) ? ((hour) - 12) : \ + (((hour) == 0) ? 12 : (hour))) + + while (*format != '\0') { + if (*format != '%') { + append("%c", *format); + format++; + continue; + } + + format++; + if (*format == '0' || *format == '+') { + // TODO: padding + format++; + } + while (isdigit(*format)) { + // TODO: padding + format++; + } + if (*format == 'O' || *format == 'E') { + // TODO: locale's alternative format + format++; + } + + switch (*format) { + case 'a': + append("%s", wday_abbr[tm->tm_wday]); break; + case 'A': + append("%s", wday[tm->tm_wday]); break; + case 'b': + append("%s", mon_abbr[tm->tm_mon]); break; + case 'B': + append("%s", mon[tm->tm_mon]); break; + case 'c': + // TODO: locale-specific datetime format + recurse("%Y-%m-%d %H:%M:%S"); break; + case 'C': + append("%02d", (1900 + tm->tm_year) / 100); break; + case 'd': + append("%02d", tm->tm_mday); break; + case 'D': + recurse("%m/%d/%y"); break; + case 'e': + append("%2d", tm->tm_mday); break; + case 'F': + recurse("%+4Y-%m-%d"); break; + case 'g': + append("%02d", _wbyear(tm) % 100); break; + case 'G': + append("%d", _wbyear(tm)); break; + case 'h': + recurse("%b"); break; + case 'H': + append("%02d", tm->tm_hour); break; + case 'I': + append("%02d", TO_12H(tm->tm_hour)); break; + case 'j': + append("%03d", tm->tm_yday); break; + case 'k': + append("%2d", tm->tm_hour); break; + case 'l': + append("%2d", TO_12H(tm->tm_hour)); break; + case 'm': + append("%02d", tm->tm_mon); break; + case 'M': + append("%02d", tm->tm_min); break; + case 'n': + append("\n"); break; + case 'p': + append("%s", tm->tm_hour < 12 ? "AM" : "PM"); break; + case 'P': + append("%s", tm->tm_hour < 12 ? "am" : "PM"); break; + case 'r': + recurse("%I:%M:%S %p"); break; + case 'R': + recurse("%H:%M"); break; + case 's': + append("%ld", _secs_since_epoch(tm)); break; + case 'S': + append("%02d", tm->tm_sec); break; + case 't': + append("\t"); break; + case 'T': + recurse("%H:%M:%S"); break; + case 'u': + append("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday); break; + case 'U': + append("%02d", _sun_week_number(tm)); break; + case 'V': + append("%02d", _iso_week_number(tm)); break; + case 'w': + append("%d", tm->tm_wday); break; + case 'W': + append("%02d", _mon_week_number(tm)); break; + case 'x': + // TODO: locale-specific date format + recurse("%Y-%m-%d"); break; + case 'X': + // TODO: locale-specific time format + recurse("%H:%M:%S"); break; + case 'y': + append("%02d", tm->tm_year % 100); break; + case 'Y': + append("%d", 1900 + tm->tm_year); break; + case 'z': + // TODO: timezone + break; + case 'Z': + // TODO: timezone + break; + case '%': + append("%%"); + break; + default: + /* Invalid specifier, print verbatim. */ + while (*format != '%') { + format--; + } + append("%%"); + break; + } + format++; + } + + #undef append + #undef recurse + + return maxsize - remaining; +} + +/** + * 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) { + sleep(rqtp->tv_sec); + } + if (rqtp->tv_nsec != 0) { + 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/source/unistd.c =================================================================== --- uspace/lib/posix/source/unistd.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) +++ uspace/lib/posix/source/unistd.c (revision a3da2b2ee2ac5f4fadec2282a5f5974b52b2a6f3) @@ -0,0 +1,424 @@ +/* + * 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 + +#include "internal/common.h" +#include "posix/unistd.h" + +#include "posix/errno.h" +#include "posix/string.h" +#include "posix/fcntl.h" + +#include "libc/task.h" +#include "libc/stats.h" +#include "libc/malloc.h" + +/* Array of environment variable strings (NAME=VALUE). */ +char **posix_environ = NULL; +char *posix_optarg; + +/** + * 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) +{ + /* Native getcwd() does not set any errno despite the fact that general + * usage pattern of this function depends on it (caller is repeatedly + * guessing the required size of the buffer by checking for ERANGE on + * failure). */ + if (size == 0) { + errno = EINVAL; + return NULL; + } + + /* Save the original value to comply with the "no modification on + * success" semantics. + */ + int orig_errno = errno; + errno = EOK; + + char *ret = getcwd(buf, size); + if (ret == NULL) { + /* Check errno to avoid shadowing other possible errors. */ + if (errno == EOK) { + errno = ERANGE; + } + } else { + /* Success, restore previous errno value. */ + errno = orig_errno; + } + + return ret; +} + +/** + * Change the current working directory. + * + * @param path New working directory. + */ +int posix_chdir(const char *path) +{ + return errnify(chdir, path); +} + +/** + * Determine the page size of the current run of the process. + * + * @return Page size of the process. + */ +int posix_getpagesize(void) +{ + return getpagesize(); +} + +/** + * 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) +{ + return errnify(close, fildes); +} + +/** + * 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) +{ + return errnify(read, fildes, buf, nbyte); +} + +/** + * 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) +{ + return errnify(write, fildes, buf, nbyte); +} + +/** + * 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) +{ + return errnify(fsync, fildes); +} + +/** + * 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) +{ + return errnify(ftruncate, fildes, (aoff64_t) length); +} + +/** + * Remove a directory. + * + * @param path Directory pathname. + * @return Zero on success, -1 otherwise. + */ +int posix_rmdir(const char *path) +{ + return errnify(rmdir, path); +} + +/** + * Remove a link to a file. + * + * @param path File pathname. + * @return Zero on success, -1 otherwise. + */ +int posix_unlink(const char *path) +{ + return errnify(unlink, path); +} + +/** + * 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) +{ + return errnify(dup2, fildes, fildes2); +} + +/** + * 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 = open(path, O_RDONLY); + if (fd < 0) { + errno = -fd; + return -1; + } + 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 / getpagesize()); + avphys_pages = (long) (mem_stats->free / 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 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 + */ +posix_pid_t posix_fork(void) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @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(); +} + +/** + * + * @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(); +} + +/** + * + * @param fildes + * @return + */ +int posix_pipe(int fildes[2]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */