Changes in / [f5b2522:8cd8bf6] in mainline

Location:

uspace/lib/posix

Files:

• Makefile (modified) (1 diff)
• assert.h (added)
• ctype.c (modified) (1 diff)
• ctype.h (modified) (2 diffs)
• errno.c (added)
• errno.h (added)
• fcntl.c (modified) (1 diff)
• fcntl.h (modified) (2 diffs)
• fnmatch.c (modified) (2 diffs)
• fnmatch.h (modified) (1 diff)
• iso646.h (added)
• locale.c (added)
• locale.h (added)
• pwd.c (modified) (1 diff)
• signal.c (added)
• signal.h (modified) (5 diffs)
• stdbool.h (modified) (1 diff)
• stdint.h (modified) (1 diff)
• stdio.c (modified) (5 diffs)
• stdio.h (modified) (4 diffs)
• stdio/scanf.c (added)
• stdlib.c (modified) (2 diffs)
• stdlib.h (modified) (2 diffs)
• stdlib/strtol.c (modified) (1 diff)
• stdlib/strtold.c (modified) (1 diff)
• string.c (modified) (10 diffs)
• string.h (modified) (4 diffs)
• strings.c (modified) (1 diff)
• sys/stat.c (modified) (4 diffs)
• sys/types.h (modified) (2 diffs)
• time.c (modified) (7 diffs)
• time.h (modified) (2 diffs)
• unistd.c (modified) (3 diffs)
• unistd.h (modified) (2 diffs)

uspace/lib/posix/Makefile

@@ -40 +40 @@
 SOURCES = \
         ctype.c \
+        errno.c \
         fcntl.c \
         fnmatch.c \
+        locale.c \
         math.c \
         pwd.c \
+        signal.c \
         stdio.c \
+        stdio/scanf.c \
         stdlib.c \
         stdlib/strtol.c \

uspace/lib/posix/ctype.c

@@ -108 +108 @@
 }
 
+/**
+ * Checks whether character is ASCII. (obsolete)
+ *
+ * @param c
+ * @return
+ */
+extern int posix_isascii(int c)
+{
+        return c >= 0 && c < 128;
+}
+
+/**
+ * Converts argument to a 7-bit ASCII character. (obsolete)
+ *
+ * @param c
+ * @return
+ */
+extern int posix_toascii(int c)
+{
+        return c & 0x7F;
+}
+
 /** @}
  */

uspace/lib/posix/ctype.h

@@ -47 +47 @@
 extern int posix_ispunct(int c);
 
+/* Obsolete Functions and Macros */
+extern int posix_isascii(int c);
+extern int posix_toascii(int c);
+#undef _tolower
+#define _tolower(c) ((c) - 'A' + 'a')
+#undef _toupper
+#define _toupper(c) ((c) - 'a' + 'A')
+
+
 #ifndef LIBPOSIX_INTERNAL
         #define isxdigit posix_isxdigit
@@ -54 +63 @@
         #define isprint posix_isprint
         #define ispunct posix_ispunct
+        
+        #define isascii posix_isascii
+        #define toascii posix_toascii
 #endif
 

uspace/lib/posix/fcntl.c

@@ -38 +38 @@
 #include "fcntl.h"
 
+#include "libc/unistd.h"
+#include "libc/vfs/vfs.h"
+#include "errno.h"
+
 /**
- * 
- * @param fd
- * @param cmd
- * @param ...
- * @return
+ * 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, ...)
 {
-        // TODO
-        not_implemented();
+        int rc;
+        int flags;
+
+        switch (cmd) {
+        case F_DUPFD:
+        case F_DUPFD_CLOEXEC: /* FD_CLOEXEC is not supported. */
+                /* VFS does not provide means to express constraints on the new
+                 * file descriptor so the third argument is ignored. */
+
+                /* Retrieve node triplet corresponding to the file descriptor. */
+                /* Empty statement after label. */;
+                fdi_node_t node;
+                rc = fd_node(fd, &node);
+                if (rc != EOK) {
+                        errno = -rc;
+                        return -1;
+                }
+
+                /* Reopen the node so the fresh file descriptor is generated. */
+                int newfd = open_node(&node, 0);
+                if (newfd < 0) {
+                        errno = -newfd;
+                        return -1;
+                }
+
+                /* Associate the newly generated descriptor to the file description
+                 * of the old file descriptor. Just reopened node will be automatically
+                 * closed. */
+                rc = dup2(fd, newfd);
+                if (rc != EOK) {
+                        errno = -rc;
+                        return -1;
+                }
+
+                return newfd;
+        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;
+        }
 }
 

uspace/lib/posix/fcntl.h

@@ -36 +36 @@
 #define POSIX_FCNTL_H_
 
+#include "sys/types.h"
 #include "libc/fcntl.h"
+
+/* Mask for file access modes. */
+#undef O_ACCMODE
+#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 
 /* fcntl commands */
 #undef F_DUPFD
+#undef F_DUPFD_CLOEXEC
 #undef F_GETFD
 #undef F_SETFD
@@ -46 +52 @@
 #undef F_GETOWN
 #undef F_SETOWN
-#define F_DUPFD         0       /* Duplicate file descriptor. */
-#define F_GETFD         1       /* Get file descriptor flags. */
-#define F_SETFD         2       /* Set file descriptor flags. */
-#define F_GETFL         3       /* Get file status flags. */
-#define F_SETFL         4       /* Set file status flags. */
-#define F_GETOWN        5       /* Get owner. */
-#define F_SETOWN        6       /* Set owner. */
+#undef F_GETLK
+#undef F_SETLK
+#undef F_SETLKW
+#define F_DUPFD            0 /* Duplicate file descriptor. */
+#define F_DUPFD_CLOEXEC    1 /* Same as F_DUPFD but with FD_CLOEXEC flag set. */
+#define F_GETFD            2 /* Get file descriptor flags. */
+#define F_SETFD            3 /* Set file descriptor flags. */
+#define F_GETFL            4 /* Get file status and access flags. */
+#define F_SETFL            5 /* Set file status flags. */
+#define F_GETOWN           6 /* Get socket owner. */
+#define F_SETOWN           7 /* Set socket owner. */
+#define F_GETLK            8 /* Get locking information. */
+#define F_SETLK            9 /* Set locking information. */
+#define F_SETLKW          10 /* Set locking information; wait if blocked. */
 
 /* File descriptor flags used with F_GETFD and F_SETFD. */
 #undef FD_CLOEXEC
-#define FD_CLOEXEC      1       /* Close on exec. */
+#define FD_CLOEXEC         1 /* Close on exec. */
 
 extern int posix_fcntl(int fd, int cmd, ...);

uspace/lib/posix/fnmatch.c

@@ -33 +33 @@
  */
 
+// TODO: clean this up a bit
+
+#include "stdbool.h"
+#include "ctype.h"
+#include "string.h"
+#include "stdlib.h"
+#include "assert.h"
+
 #define LIBPOSIX_INTERNAL
 
 #include "internal/common.h"
 #include "fnmatch.h"
+
+#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;
+
+#define COLL_ELM_INVALID -1
+
+/** Get collating element matching a string.
+ *
+ * @param str
+ * @return
+ */
+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
+ * @return
+ */
+static _coll_elm_t _coll_elm_char(int c)
+{
+        return c;
+}
+
+/** Match collating element with a beginning of a string.
+ *
+ * @param elm
+ * @param str
+ * @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;
+}
+
+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.
+ * @return
+ */
+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 }
+};
+
+static int _class_compare(const void *key, const void *elem)
+{
+        const struct _char_class *class = elem;
+        return strcmp((const char *) key, class->name);
+}
+
+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);
+        }
+}
+
+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 ****************/
+
+static _coll_elm_t _next_coll_elm(const char **pattern, int flags)
+{
+        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 (pathname && *p == '/') {
+                return COLL_ELM_INVALID;
+        }
+
+        *pattern = p + 1;
+        return _coll_elm_char(*p);
+}
+
+/**
+ *
+ */
+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
+}
+
+/**
+ *
+ */
+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;
+}
+
+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 == '/');
+}
+
+static char *_casefold(const char *s)
+{
+        char *result = strdup(s);
+        for (char *i = result; *i != '\0'; ++i) {
+                *i = tolower(*i);
+        }
+        return result;
+}
 
 /**
@@ -48 +495 @@
 int posix_fnmatch(const char *pattern, const char *string, int flags)
 {
-        // TODO
-        not_implemented();
-}
+        // 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) {
+                free((char *) pattern);
+                free((char *) string);
+        }
+
+        return result ? 0 : FNM_NOMATCH;
+}
+
+// FIXME: put the testcases somewhere else
+
+#if 0
+
+#include <stdio.h>
+
+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
 
 /** @}

uspace/lib/posix/fnmatch.h

@@ -48 +48 @@
 #define FNM_NOESCAPE 4
 
+/* GNU Extensions */
+#undef FNM_FILE_NAME
+#undef FNM_LEADING_DIR
+#undef FNM_CASEFOLD
+#define FNM_FILE_NAME FNM_PATHNAME
+#define FNM_LEADING_DIR 8
+#define FNM_CASEFOLD 16
+
 extern int posix_fnmatch(const char *pattern, const char *string, int flags);
 

uspace/lib/posix/pwd.c

@@ -47 +47 @@
         .pw_gid = 1,
         .pw_dir = (char *) "/",
-        .pw_shell = (char *) "bdsh"
+        .pw_shell = (char *) "/app/bdsh"
 };
 

uspace/lib/posix/signal.h

@@ -39 +39 @@
 #include "sys/types.h"
 
-/* HelenOS doesn't have signals, so calls to functions of this header
- * are just replaced with their respective failure return value.
- *
- * Other macros and constants are here just to satisfy the symbol resolver
- * and have no practical value whatsoever, until HelenOS implements some
- * equivalent of signals. Maybe something neat based on IPC will be devised
- * in the future?
- */
+extern void __posix_default_signal_handler(int signo);
+extern void __posix_hold_signal_handler(int signo);
+extern void __posix_ignore_signal_handler(int signo);
 
 #undef SIG_DFL
-#define SIG_DFL ((void (*)(int)) 0)
+#define SIG_DFL ((void (*)(int)) __posix_default_signal_handler)
 #undef SIG_ERR
-#define SIG_ERR ((void (*)(int)) 0)
+#define SIG_ERR ((void (*)(int)) NULL)
 #undef SIG_HOLD
-#define SIG_HOLD ((void (*)(int)) 0)
+#define SIG_HOLD ((void (*)(int)) __posix_hold_signal_handler)
 #undef SIG_IGN
-#define SIG_IGN ((void (*)(int)) 0)
-
-#define signal(sig,func) (errno = ENOTSUP, SIG_ERR)
-#define raise(sig) ((int) -1)
-#define kill(pid,sig) (errno = ENOTSUP, (int) -1)
+#define SIG_IGN ((void (*)(int)) __posix_ignore_signal_handler)
 
 typedef int posix_sig_atomic_t;
-typedef int posix_sigset_t;
+typedef uint32_t posix_sigset_t;
 typedef struct posix_mcontext {
         // FIXME: should not be empty to avoid compiler warnings (-pedantic)
@@ -87 +78 @@
         int si_errno;
 
-        pid_t si_pid;
-        uid_t si_uid;
+        posix_pid_t si_pid;
+        posix_uid_t si_uid;
         void *si_addr;
         int si_status;
@@ -120 +111 @@
 /* Values of posix_sigevent::sigev_notify */
 #undef SIGEV_NONE
+#undef SIGEV_SIGNAL
+#undef SIGEV_THREAD
 #define SIGEV_NONE 0
-#undef SIGEV_SIGNAL
 #define SIGEV_SIGNAL 0
-#undef SIGEV_THREAD
 #define SIGEV_THREAD 0
 
 #undef SIGRT_MIN
+#undef SIGRT_MAX
 #define SIGRT_MIN 0
-#undef SIGRT_MAX
 #define SIGRT_MAX 0
 
 #undef SIG_BLOCK
+#undef SIG_UNBLOCK
+#undef SIG_SETMASK
 #define SIG_BLOCK 0
-#undef SIG_UNBLOCK
-#define SIG_UNBLOCK 0
-#undef SIG_SETMASK
-#define SIG_SETMASK 0
+#define SIG_UNBLOCK 1
+#define SIG_SETMASK 2
 
 #undef SA_NOCLDSTOP
-#define SA_NOCLDSTOP 0
 #undef SA_ONSTACK
-#define SA_ONSTACK 0
 #undef SA_RESETHAND
-#define SA_RESETHAND 0
 #undef SA_RESTART
-#define SA_RESTART 0
 #undef SA_SIGINFO
-#define SA_SIGINFO 0
 #undef SA_NOCLDWAIT
-#define SA_NOCLDWAIT 0
 #undef SA_NODEFER
-#define SA_NODEFER 0
+#define SA_NOCLDSTOP (1 << 0)
+#define SA_ONSTACK (1 << 1)
+#define SA_RESETHAND (1 << 2)
+#define SA_RESTART (1 << 3)
+#define SA_SIGINFO (1 << 4)
+#define SA_NOCLDWAIT (1 << 5)
+#define SA_NODEFER (1 << 6)
 
 #undef SS_ONSTACK
+#undef SS_DISABLE
 #define SS_ONSTACK 0
-#undef SS_DISABLE
 #define SS_DISABLE 0
 
 #undef MINSIGSTKSZ
+#undef SIGSTKSZ
 #define MINSIGSTKSZ 0
-#undef SIGSTKSZ
 #define SIGSTKSZ 0
 
 /* full POSIX set */
 enum {
+        /* Termination Signals */
         SIGABRT,
+        SIGQUIT,
+        SIGINT,
+        SIGTERM,
+        
+        /* Child Signal */
+        SIGCHLD,
+        
+        /* User signals */
+        SIGUSR1,
+        SIGUSR2,
+
+        /* Timer */
         SIGALRM,
+        SIGVTALRM,
+        SIGPROF, /* obsolete */
+
+        _TOP_CATCHABLE_SIGNAL = SIGPROF,
+
+        /* Process Scheduler Interaction - not supported */
+        SIGSTOP,
+        SIGCONT,
+
+        /* Process Termination - can't be caught */
+        SIGKILL,
+
+        _TOP_SENDABLE_SIGNAL = SIGKILL,
+
+        /* Hardware Exceptions - can't be caught or sent */
+        SIGFPE,
         SIGBUS,
-        SIGCHLD,
-        SIGCONT,
-        SIGFPE,
+        SIGILL,
+        SIGSEGV,
+
+        /* Other Exceptions - not supported */
+        SIGSYS,
+        SIGXCPU,
+        SIGXFSZ,
+
+        /* Debugging - not supported */
+        SIGTRAP,
+
+        /* Communication Signals - not supported */
         SIGHUP,
-        SIGILL,
-        SIGINT,
-        SIGKILL,
         SIGPIPE,
-        SIGQUIT,
-        SIGSEGV,
-        SIGSTOP,
-        SIGTERM,
+        SIGPOLL, /* obsolete */
+        SIGURG,
+
+        /* Terminal Signals - not supported */
         SIGTSTP,
         SIGTTIN,
         SIGTTOU,
-        SIGUSR1,
-        SIGUSR2,
-        SIGPOLL,
-        SIGPROF,
-        SIGSYS,
-        SIGTRAP,
-        SIGURG,
-        SIGVTALRM,
-        SIGXCPU,
-        SIGXFSZ
-};
-
-/* Just declared to avoid compiler warnings. */
+        
+        _TOP_SIGNAL = SIGTTOU
+};
+
+/* Values for sigaction field si_code. */
+
+enum {
+        SI_USER,
+        SI_QUEUE,
+        SI_TIMER,
+        SI_ASYNCIO,
+        SI_MESGQ,
+        ILL_ILLOPC,
+        ILL_ILLOPN,
+        ILL_ILLADR,
+        ILL_ILLTRP,
+        ILL_PRVOPC,
+        ILL_PRVREG,
+        ILL_COPROC,
+        ILL_BADSTK,
+        FPE_INTDIV,
+        FPE_INTOVF,
+        FPE_FLTDIV,
+        FPE_FLTOVF,
+        FPE_FLTUND,
+        FPE_FLTRES,
+        FPE_FLTINV,
+        FPE_FLTSUB,
+        SEGV_MAPERR,
+        SEGV_ACCERR,
+        BUS_ADRALN,
+        BUS_ADRERR,
+        BUS_OBJERR,
+        TRAP_BRKPT,
+        TRAP_TRACE,
+        CLD_EXITED,
+        CLD_KILLED,
+        CLD_DUMPED,
+        CLD_TRAPPED,
+        CLD_STOPPED,
+        CLD_CONTINUED,
+        POLL_IN,
+        POLL_OUT,
+        POLL_MSG,
+        POLL_ERR,
+        POLL_PRI,
+        POLL_HUP
+};
+
+extern int posix_sigaction(int sig, const struct posix_sigaction *restrict act,
+    struct posix_sigaction *restrict oact);
+
+extern void (*posix_signal(int sig, void (*func)(int)))(int);
+extern int posix_raise(int sig);
+extern int posix_kill(posix_pid_t pid, int sig);
+extern int posix_killpg(posix_pid_t pid, int sig);
+
+extern void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message);
+extern void posix_psignal(int signum, const char *message);
+
 extern int posix_sigemptyset(posix_sigset_t *set);
+extern int posix_sigfillset(posix_sigset_t *set);
+extern int posix_sigaddset(posix_sigset_t *set, int signo);
+extern int posix_sigdelset(posix_sigset_t *set, int signo);
+extern int posix_sigismember(const posix_sigset_t *set, int signo);
+
+extern int posix_thread_sigmask(int how, const posix_sigset_t *restrict set,
+    posix_sigset_t *restrict oset);
 extern int posix_sigprocmask(int how, const posix_sigset_t *restrict set,
     posix_sigset_t *restrict oset);
@@ -204 +284 @@
         #define sigset_t posix_sigset_t
         #define sigval posix_sigval
-        #define sigevent posix_sigevent
+        #ifndef sigevent
+                #define sigevent posix_sigevent
+        #endif
         #define sigaction posix_sigaction
         #define mcontext_t posix_mcontext_t
@@ -210 +292 @@
         #define stack_t posix_stack_t
         #define siginfo_t posix_siginfo_t
+
+        #define signal posix_signal
+        #define raise posix_raise
+        #define kill posix_kill
+        #define killpg posix_killpg
+
+        #define psiginfo posix_psiginfo
+        #define psignal posix_psignal
+
         #define sigemptyset posix_sigemptyset
+        #define sigfillset posix_sigfillset
+        #define sigaddset posix_sigaddset
+        #define sigdelset posix_sigdelset
+        #define sigismember posix_sigismember
+
+        #define pthread_sigmask posix_thread_sigmask
         #define sigprocmask posix_sigprocmask
 #endif

uspace/lib/posix/stdbool.h

@@ -40 +40 @@
 
 #ifdef LIBC_BOOL_H_
-        #error You can't include bool.h and stdbool.h at the same time.
+        #error "You can't include bool.h and stdbool.h at the same time."
 #endif
 #define LIBC_BOOL_H_

uspace/lib/posix/stdint.h

@@ -35 +35 @@
 #ifndef POSIX_STDINT_H_
 #define POSIX_STDINT_H_
+
+#include "libc/stdint.h"
 
 #undef INT8_MAX

uspace/lib/posix/stdio.c

@@ -36 +36 @@
 #define LIBPOSIX_INTERNAL
 
-#include <assert.h>
-#include <errno.h>
+/* Has to be first. */
+#include "stdbool.h"
 
 #include "internal/common.h"
 #include "stdio.h"
+
+#include "assert.h"
+#include "errno.h"
 #include "string.h"
-
-/* not the best of solutions, but freopen will eventually
+#include "sys/types.h"
+
+#include "libc/io/printf_core.h"
+#include "libc/str.h"
+#include "libc/malloc.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"
 
-/**
- * 
- * @param c
- * @param stream
- * @return 
+/** 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;
+}
+
+/**
+ * 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)
 {
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @param filename
- * @param mode
- * @param stream
- * @return
+        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(
@@ -115 +278 @@
 /**
  *
- * @param s
- */
-void posix_perror(const char *s)
+ * @param buf
+ * @param size
+ * @param mode
+ * @return
+ */
+FILE *posix_fmemopen(void *restrict buf, size_t size,
+    const char *restrict mode)
 {
         // TODO
@@ -124 +291 @@
 
 /**
- * 
- * @param stream
- * @param offset
- * @param whence
+ *
+ * @param bufp
+ * @param sizep
  * @return
  */
-int posix_fseeko(FILE *stream, posix_off_t offset, int whence)
+FILE *posix_open_memstream(char **bufp, size_t *sizep)
 {
         // TODO
@@ -137 +303 @@
 
 /**
- * 
- * @param 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) {
+                return errno;
+        }
+        pos->offset = ret;
+        return 0;
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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.
+ *
+ * @param path Pathname of the file that shall be removed.
+ * @return Zero on success, -1 otherwise.
+ */
+int posix_remove(const char *path)
+{
+        // FIXME: unlink() and rmdir() seem to be equivalent at the moment,
+        //        but that does not have to be true forever
+        return unlink(path);
+}
+
+/**
+ * 
+ * @param s
  * @return
  */
-posix_off_t posix_ftello(FILE *stream)
-{
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @param s
- * @param format
- * @param ...
- * @return
- */
-int posix_sprintf(char *s, const char *format, ...)
-{
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @param s
- * @param format
- * @param ...
- * @return
- */
-int posix_vsprintf(char *s, const char *format, va_list ap)
+char *posix_tmpnam(char *s)
 {
         // TODO: low priority, just a compile-time dependency of binutils
@@ -173 +666 @@
 }
 
-/**
- * 
- * @param s
- * @param format
- * @param ...
- * @return
- */
-int posix_sscanf(const char *s, const char *format, ...)
-{
-        // TODO
-        not_implemented();
-}
-
-/**
- *
- * @param path
- * @return
- */
-int posix_remove(const char *path)
-{
-        // TODO: low priority, just a compile-time dependency of binutils
-        not_implemented();
-}
-
-/**
- * 
- * @param s
- * @return
- */
-char *posix_tmpnam(char *s)
-{
-        // TODO: low priority, just a compile-time dependency of binutils
-        not_implemented();
-}
-
 /** @}
  */

uspace/lib/posix/stdio.h

@@ -40 +40 @@
 #include "sys/types.h"
 #include "libc/stdarg.h"
+#include "limits.h"
 
-/* Character Input/Output */
+#undef L_ctermid
+#define L_ctermid PATH_MAX
+
+extern void posix_clearerr(FILE *stream);
+extern char *posix_ctermid(char *s);
+
+/* Input/Output */
 #undef putc
 #define putc fputc
@@ -47 +54 @@
 #define getc fgetc
 extern int posix_ungetc(int c, FILE *stream);
+
+extern ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n,
+    int delimiter, FILE *restrict stream);
+extern ssize_t posix_getline(char **restrict lineptr, size_t *restrict n,
+    FILE *restrict stream);
 
 /* Opening Streams */
@@ -54 +66 @@
    FILE *restrict stream);
 
+/* Memory Streams */
+
+extern FILE *posix_fmemopen(void *restrict buf, size_t size,
+    const char *restrict mode);
+extern FILE *posix_open_memstream(char **bufp, size_t *sizep);
+
 /* Error Messages */
 extern void posix_perror(const char *s);
 
 /* File Positioning */
+
+typedef struct _posix_fpos posix_fpos_t;
+extern int posix_fsetpos(FILE *stream, const posix_fpos_t *pos);
+extern int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos);
+extern int posix_fseek(FILE *stream, long offset, int whence);
 extern int posix_fseeko(FILE *stream, posix_off_t offset, int whence);
+extern long posix_ftell(FILE *stream);
 extern posix_off_t posix_ftello(FILE *stream);
 
 /* Formatted Input/Output */
-extern int posix_sprintf(char *restrict s, const char *restrict format, ...);
+extern int posix_dprintf(int fildes, const char *restrict format, ...)
+    PRINTF_ATTRIBUTE(2, 3);
+extern int posix_vdprintf(int fildes, const char *restrict format, va_list ap);
+extern int posix_sprintf(char *restrict s, const char *restrict format, ...)
+    PRINTF_ATTRIBUTE(2, 3);
 extern int posix_vsprintf(char *restrict s, const char *restrict format, va_list ap);
-extern int posix_sscanf(const char *restrict s, const char *restrict format, ...);
+
+extern int posix_fscanf(
+    FILE *restrict stream, const char *restrict format, ...);
+extern int posix_vfscanf(
+    FILE *restrict stream, const char *restrict format, va_list arg);
+extern int posix_scanf(const char *restrict format, ...);
+extern int posix_vscanf(const char *restrict format, va_list arg);
+extern int posix_sscanf(
+    const char *restrict s, const char *restrict format, ...);
+extern int posix_vsscanf(
+    const char *restrict s, const char *restrict format, va_list arg);
+
+/* File Locking */
+
+extern void posix_flockfile(FILE *file);
+extern int posix_ftrylockfile(FILE *file);
+extern void posix_funlockfile(FILE *file);
+
+extern int posix_getc_unlocked(FILE *stream);
+extern int posix_getchar_unlocked(void);
+extern int posix_putc_unlocked(int c, FILE *stream);
+extern int posix_putchar_unlocked(int c);
 
 /* Deleting Files */
@@ -76 +125 @@
 
 #ifndef LIBPOSIX_INTERNAL
+        #define clearerr posix_clearerr
+        #define ctermid posix_ctermid
+
         #define ungetc posix_ungetc
+
+        #define getdelim posix_getdelim
+        #define getline posix_getline
 
         #define freopen posix_freopen
 
+        #define fmemopen posix_fmemopen
+        #define open_memstream posix_open_memstream
+
         #define perror posix_perror
 
+        #define fpos_t posix_fpos_t
+        #define fsetpos posix_fsetpos
+        #define fgetpos posix_fgetpos
+        #define fseek posix_fseek
         #define fseeko posix_fseeko
+        #define ftell posix_ftell
         #define ftello posix_ftello
 
+        #define dprintf posix_dprintf
+        #define vdprintf posix_vdprintf
         #define sprintf posix_sprintf
         #define vsprintf posix_vsprintf
+
+        #define fscanf posix_fscanf
+        #define vfscanf posix_vfscanf
+        #define vscanf posix_vscanf
+        #define scanf posix_scanf
         #define sscanf posix_sscanf
+        #define vsscanf posix_vsscanf
+
+        #define flockfile posix_flockfile
+        #define ftrylockfile posix_ftrylockfile
+        #define funlockfile posix_funlockfile
+
+        #define getc_unlocked posix_getc_unlocked
+        #define getchar_unlocked posix_getchar_unlocked
+        #define putc_unlocked posix_putc_unlocked
+        #define putchar_unlocked posix_putchar_unlocked
 
         #define remove posix_remove

uspace/lib/posix/stdlib.c

@@ -36 +36 @@
 #define LIBPOSIX_INTERNAL
 
+#include "internal/common.h"
 #include "stdlib.h"
+
+#include "errno.h"
+
 #include "libc/sort.h"
 #include "libc/str.h"
 #include "libc/vfs/vfs.h"
-#include "internal/common.h"
-#include <errno.h>  // FIXME: use POSIX errno
 
 /**
@@ -338 +340 @@
 }
 
+/**
+ * Should read system load statistics. Not supported. Always returns -1.
+ *
+ * @param loadavg
+ * @param nelem
+ * @return
+ */
+int bsd_getloadavg(double loadavg[], int nelem)
+{
+        return -1;
+}
+
 /** @}
  */

uspace/lib/posix/stdlib.h

@@ -120 +120 @@
 /* Legacy Declarations */
 extern char *posix_mktemp(char *tmpl);
+extern int bsd_getloadavg(double loadavg[], int nelem);
 
 #ifndef LIBPOSIX_INTERNAL
@@ -163 +164 @@
 
         #define mktemp posix_mktemp
+        #define getloadavg bsd_getloadavg
 #endif
 

uspace/lib/posix/stdlib/strtol.c

@@ -37 +37 @@
 #include "../internal/common.h"
 #include "../stdlib.h"
-#include <errno.h>  // FIXME: use POSIX errno
+
 #include "../limits.h"
 #include "../ctype.h"
+#include "../errno.h"
 
 // TODO: documentation

uspace/lib/posix/stdlib/strtold.c

@@ -35 +35 @@
 #define LIBPOSIX_INTERNAL
 
+/* Must be first. */
+#include "../stdbool.h"
+
 #include "../internal/common.h"
-
-#include "../libc/assert.h"
+#include "../stdlib.h"
+
+#include "../assert.h"
 #include "../ctype.h"
-#include <errno.h> // TODO: use POSIX errno
-#include "../libc/bool.h"
 #include "../stdint.h"
-#include "../stdlib.h"
 #include "../strings.h"
+#include "../errno.h"
 
 #ifndef HUGE_VALL

uspace/lib/posix/string.c

@@ -36 +36 @@
 #define LIBPOSIX_INTERNAL
 
+#include "internal/common.h"
 #include "string.h"
 
-#include <assert.h>
-#include <str_error.h>
-#include <stdlib.h>
-#include <errno.h>
-
-/**
- * Defined for convenience. Returns pointer to the terminating nul character.
- *
- * @param s
- * @return
- */
-static char *strzero(const char *s)
-{
-        while (*s != '\0') {
-                s++;
-        }
-
-        return (char *) s;
-}
+#include "assert.h"
+#include "errno.h"
+#include "limits.h"
+#include "stdlib.h"
+#include "signal.h"
+
+#include "libc/str_error.h"
 
 /**
@@ -183 +172 @@
         assert(src != NULL);
 
-        posix_strcpy(strzero(dest), src);
+        posix_strcpy(posix_strchr(dest, '\0'), src);
         return dest;
 }
@@ -199 +188 @@
         assert(src != NULL);
 
-        char *zeroptr = posix_strncpy(strzero(dest), src, n);
+        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';
@@ -240 +229 @@
 char *posix_strdup(const char *s)
 {
-        // FIXME: SIZE_MAX doesn't work
-        return posix_strndup(s, STR_NO_LIMIT);
+        return posix_strndup(s, SIZE_MAX);
 }
 
@@ -360 +348 @@
         assert(s != NULL);
         
-        /* special handling for the case that zero is searched for */
-        if (c == '\0') {
-                return strzero(s);
-        }
-        
-        /* otherwise just loop through the string until found */
-        while (*s != (char) c) {
-                if (*s == '\0') {
-                        return NULL;
-                }
-
-                s++;
-        }
-        
-        return (char *) s;
+        char *res = gnu_strchrnul(s, c);
+        return (*res == c) ? res : NULL;
 }
 
@@ -387 +362 @@
         assert(s != NULL);
         
-        const char *ptr = strzero(s);
+        const char *ptr = posix_strchr(s, '\0');
         
         /* the same as in strchr, except it loops in reverse direction */
@@ -399 +374 @@
 
         return (char *) ptr;
+}
+
+char *gnu_strchrnul(const char *s, int c)
+{
+        assert(s != NULL);
+        
+        while (*s != c && *s != '\0') {
+                s++;
+        }
+        
+        return (char *) s;
 }
 
@@ -524 +510 @@
 char *posix_strerror(int errnum)
 {
-        /* uses function from libc, we just have to negate errno
-         * (POSIX uses positive errorcodes, HelenOS has negative)
+        /* Uses function from libc, we just have to negate errno
+         * (POSIX uses positive errorcodes, HelenOS has negative).
          */
-        return (char *) str_error(-errnum);
+        // FIXME: not all POSIX error codes are in libc
+        return (char *) str_error(-posix_abs(errnum));
 }
 
@@ -562 +549 @@
         assert(s != NULL);
         
-        return (size_t) (strzero(s) - s);
+        return (size_t) (posix_strchr(s, '\0') - s);
 }
 
@@ -585 +572 @@
 }
 
+/**
+ *
+ * @param signum
+ * @return
+ */
+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";
+}
+
 /** @}
  */

uspace/lib/posix/string.h

@@ -85 +85 @@
 extern char *posix_strchr(const char *s, int c);
 extern char *posix_strrchr(const char *s, int c);
+extern char *gnu_strchrnul(const char *s, int c);
 extern char *posix_strpbrk(const char *s1, const char *s2);
 extern size_t posix_strcspn(const char *s1, const char *s2);
@@ -101 +102 @@
 extern size_t posix_strlen(const char *s);
 extern size_t posix_strnlen(const char *s, size_t n);
+
+/* Signal messages */
+extern char *posix_strsignal(int signum);
 
 /* Legacy declarations */
@@ -127 +131 @@
         #define strchr posix_strchr
         #define strrchr posix_strrchr
+        #define strchrnul gnu_strchrnul
         #define strpbrk posix_strpbrk
         #define strcspn posix_strcspn
@@ -141 +146 @@
         #define strnlen posix_strnlen
 
+        #define strsignal posix_strsignal
+
         #define ffs posix_ffs
         #define strcasecmp posix_strcasecmp

uspace/lib/posix/strings.c

@@ -38 +38 @@
 #include "internal/common.h"
 #include "strings.h"
+
 #include "string.h"
 #include "ctype.h"

uspace/lib/posix/sys/stat.c

@@ -36 +36 @@
 #define LIBPOSIX_INTERNAL
 
+#include "../internal/common.h"
 #include "stat.h"
-#include "../internal/common.h"
-#include <mem.h>
+
+#include "../errno.h"
+#include "../libc/mem.h"
 
 /**
- * Convert HelenOS stat struct into POSIX stat struct (if possible)
+ * Convert HelenOS stat struct into POSIX stat struct (if possible).
  *
- * @param dest
- * @param src
+ * @param dest POSIX stat struct.
+ * @param src HelenOS stat struct.
  */
 static void stat_to_posix(struct posix_stat *dest, struct stat *src)
@@ -66 +68 @@
 
 /**
+ * Retrieve file status for file associated with file descriptor.
  *
- * @param fd
- * @param st
- * @return
+ * @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;
-        if (fstat(fd, &hst) == -1) {
-                // TODO: propagate a POSIX compatible errno
+        int rc = fstat(fd, &hst);
+        if (rc < 0) {
+                /* fstat() returns negative error code instead of using errno.
+                 */
+                errno = -rc;
                 return -1;
         }
@@ -83 +89 @@
 
 /**
+ * Retrieve file status for symbolic link.
  * 
- * @param path
- * @param st
- * @return
+ * @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)
+int posix_lstat(const char *path, struct posix_stat *st)
 {
-        // TODO
-        not_implemented();
+        /* 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
- * @param st
- * @return
+ * @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 *path, struct posix_stat *st)
 {
         struct stat hst;
-        if (stat(path, &hst) == -1) {
-                // TODO: propagate a POSIX compatible errno
+        int rc = stat(path, &hst);
+        if (rc < 0) {
+                /* stat() returns negative error code instead of using errno.
+                 */
+                errno = -rc;
                 return -1;
         }
@@ -112 +123 @@
 
 /**
+ * Change permission bits for the file if possible.
  * 
- * @param path
- * @param mode
- * @return
+ * @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)
 {
-        // TODO
-        not_implemented();
+        /* HelenOS doesn't support permissions, return success. */
+        return 0;
 }
 
 /**
+ * Set the file mode creation mask of the process.
  * 
- * @param mask
- * @return
+ * @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)
 {
-        // TODO
-        not_implemented();
+        /* HelenOS doesn't support permissions, return empty mask. */
+        return 0;
 }
 

uspace/lib/posix/sys/types.h

@@ -52 +52 @@
 typedef struct posix_thread_attr posix_thread_attr_t;
 
+/* Clock types */
+typedef long posix_clock_t;
+typedef int posix_clockid_t;
+
 #ifndef LIBPOSIX_INTERNAL
         #define ino_t posix_ino_t
@@ -64 +68 @@
         
         #define pthread_attr_t posix_thread_attr_t
+        
+        #define clock_t posix_clock_t
+        #define clockid_t posix_clockid_t
 #endif
 

uspace/lib/posix/time.c

@@ -36 +36 @@
 #define LIBPOSIX_INTERNAL
 
+/* Must be first. */
+#include "stdbool.h"
+
 #include "internal/common.h"
 #include "time.h"
 
+#include "ctype.h"
+#include "errno.h"
+#include "signal.h"
+
+#include "libc/malloc.h"
+#include "libc/task.h"
+#include "libc/stats.h"
+#include "libc/sys/time.h"
+
+// TODO: documentation
+// TODO: test everything in this file
+
+/* 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)
+
+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;
+}
+
+static int _days_in_month(time_t year, time_t mon)
+{
+        assert(mon >= 0 && mon <= 11);
+        year += 1900;
+
+        static int month_days[] =
+                { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+        if (mon == 1) {
+                /* february */
+                return _is_leap_year(year) ? 29 : 28;
+        } else {
+                return month_days[mon];
+        }
+}
+
+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.
+ */
+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.
+ */
+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;
+}
+
+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);
+}
+
+/* Assumes normalized broken-down time. */
+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;
+}
+
+static int _day_of_week(time_t year, time_t mon, time_t mday)
+{
+        /* 1970-01-01 is Thursday */
+        return (_days_since_epoch(year, mon, mday) + 4) % 7;
+}
+
+struct _long_tm {
+        time_t tm_sec;
+        time_t tm_min;
+        time_t tm_hour;
+        time_t tm_mday;
+        time_t tm_mon;
+        time_t tm_year;
+        int tm_wday;
+        int tm_yday;
+        int tm_isdst;
+};
+
+static void _posix_to_long_tm(struct _long_tm *ltm, struct posix_tm *ptm)
+{
+        assert(ltm != NULL && ptm != NULL);
+        ltm->tm_sec = ptm->tm_sec;
+        ltm->tm_min = ptm->tm_min;
+        ltm->tm_hour = ptm->tm_hour;
+        ltm->tm_mday = ptm->tm_mday;
+        ltm->tm_mon = ptm->tm_mon;
+        ltm->tm_year = ptm->tm_year;
+        ltm->tm_wday = ptm->tm_wday;
+        ltm->tm_yday = ptm->tm_yday;
+        ltm->tm_isdst = ptm->tm_isdst;
+}
+
+static void _long_to_posix_tm(struct posix_tm *ptm, struct _long_tm *ltm)
+{
+        assert(ltm != NULL && ptm != NULL);
+        // FIXME: the cast should be unnecessary, libarch/common.h brain-damage
+        assert((ltm->tm_year >= (int) INT_MIN) && (ltm->tm_year <= (int) INT_MAX));
+
+        ptm->tm_sec = ltm->tm_sec;
+        ptm->tm_min = ltm->tm_min;
+        ptm->tm_hour = ltm->tm_hour;
+        ptm->tm_mday = ltm->tm_mday;
+        ptm->tm_mon = ltm->tm_mon;
+        ptm->tm_year = ltm->tm_year;
+        ptm->tm_wday = ltm->tm_wday;
+        ptm->tm_yday = ltm->tm_yday;
+        ptm->tm_isdst = ltm->tm_isdst;
+}
+
+static void _normalize_time(struct _long_tm *tm)
+{
+        // TODO: DST correction
+
+        /* Adjust time. */
+        tm->tm_min += _floor_div(tm->tm_sec, SECS_PER_MIN);
+        tm->tm_sec = _floor_mod(tm->tm_sec, SECS_PER_MIN);
+        tm->tm_hour += _floor_div(tm->tm_min, MINS_PER_HOUR);
+        tm->tm_min = _floor_mod(tm->tm_min, MINS_PER_HOUR);
+        tm->tm_mday += _floor_div(tm->tm_hour, HOURS_PER_DAY);
+        tm->tm_hour = _floor_mod(tm->tm_hour, HOURS_PER_DAY);
+
+        /* Adjust month. */
+        tm->tm_year += _floor_div(tm->tm_mon, 12);
+        tm->tm_mon = _floor_mod(tm->tm_mon, 12);
+
+        /* Now the difficult part - days of month. */
+        /* Slow, but simple. */
+        // FIXME: do this faster
+
+        while (tm->tm_mday < 1) {
+                tm->tm_mon--;
+                if (tm->tm_mon == -1) {
+                        tm->tm_mon = 11;
+                        tm->tm_year--;
+                }
+                
+                tm->tm_mday += _days_in_month(tm->tm_year, tm->tm_mon);
+        }
+
+        while (tm->tm_mday > _days_in_month(tm->tm_year, tm->tm_mon)) {
+                tm->tm_mday -= _days_in_month(tm->tm_year, tm->tm_mon);
+                
+                tm->tm_mon++;
+                if (tm->tm_mon == 12) {
+                        tm->tm_mon = 0;
+                        tm->tm_year++;
+                }
+        }
+
+        /* Calculate the remaining two fields. */
+        tm->tm_yday = _day_of_year(tm->tm_year, tm->tm_mon, tm->tm_mday);
+        tm->tm_wday = _day_of_week(tm->tm_year, tm->tm_mon, tm->tm_mday);
+}
+
+/* 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.
+ */
+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.
+ * Assumes normalized broken-down time.
+ */
+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];
+
+void posix_tzset(void)
+{
+        // TODO: read environment
+        posix_tzname[0] = (char *) "GMT";
+        posix_tzname[1] = (char *) "GMT";
+        posix_daylight = 0;
+        posix_timezone = 0;
+}
+
+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 timeptr 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
+
+        struct _long_tm ltm;
+        _posix_to_long_tm(&ltm, tm);
+        _normalize_time(&ltm);
+        _long_to_posix_tm(tm, &ltm);
+
+        return _secs_since_epoch(tm);
+}
+
+struct posix_tm *posix_gmtime(const time_t *timer)
+{
+        static struct posix_tm result;
+        return posix_gmtime_r(timer, &result);
+}
+
+struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result)
+{
+        assert(timer != NULL);
+        assert(result != NULL);
+
+        /* Set epoch and seconds to _long_tm struct and normalize to get
+         * correct values.
+         */
+        struct _long_tm ltm = {
+                .tm_sec = *timer,
+                .tm_min = 0,
+                .tm_hour = 0, /* 00:00:xx */
+                .tm_mday = 1,
+                .tm_mon = 0, /* January 1st */
+                .tm_year = 70, /* 1970 */
+        };
+        _normalize_time(&ltm);
+
+        if (ltm.tm_year < (int) INT_MIN || ltm.tm_year > (int) INT_MAX) {
+                errno = EOVERFLOW;
+                return NULL;
+        }
+
+        _long_to_posix_tm(result, &ltm);
+        return result;
+}
+
 /**
  *
@@ -44 +397 @@
  * @return
  */
-struct posix_tm *posix_localtime(const time_t *timep)
-{
-        // TODO
-        static struct posix_tm result = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        return &result;
+struct posix_tm *posix_localtime(const time_t *timer)
+{
+        static struct posix_tm result;
+        return posix_localtime_r(timer, &result);
+}
+
+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);
 }
 
@@ -56 +416 @@
  * @return
  */
-char *posix_asctime(const struct posix_tm *tm)
-{
-        // TODO
-        static char result[] = "Sun Jan 01 00:00:00 1900\n";
-        return result;
+char *posix_asctime(const struct posix_tm *timeptr)
+{
+        static char buf[ASCTIME_BUF_LEN];
+        return posix_asctime_r(timeptr, 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;
 }
 
@@ -68 +451 @@
  * @return
  */
-char *posix_ctime(const time_t *timep)
-{
-        return posix_asctime(posix_localtime(timep));
+char *posix_ctime(const time_t *timer)
+{
+        struct posix_tm *loctime = posix_localtime(timer);
+        if (loctime == NULL) {
+                return NULL;
+        }
+        return posix_asctime(loctime);
+}
+
+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);
 }
 
@@ -81 +477 @@
  * @return
  */
-size_t posix_strftime(char *s, size_t maxsize, const char *format, const struct posix_tm *tm)
+size_t posix_strftime(char *s, size_t maxsize,
+    const char *format, const struct posix_tm *tm)
+{
+        // 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;
+}
+
+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;
+        }
+}
+
+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;
+        }
+}
+
+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;
+        }
+}
+
+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;
+        }
+}
+
+#if 0
+
+struct __posix_timer {
+        posix_clockid_t clockid;
+        struct posix_sigevent evp;
+};
+
+int posix_timer_create(posix_clockid_t clockid,
+    struct posix_sigevent *restrict evp,
+    posix_timer_t *restrict timerid)
 {
         // TODO
@@ -87 +743 @@
 }
 
-/**
- * 
- * @return
- */
-posix_clock_t posix_clock(void)
+int posix_timer_delete(posix_timer_t timerid)
 {
         // TODO
@@ -97 +749 @@
 }
 
+int posix_timer_getoverrun(posix_timer_t timerid)
+{
+        // TODO
+        not_implemented();
+}
+
+int posix_timer_gettime(posix_timer_t timerid,
+    struct posix_itimerspec *value)
+{
+        // TODO
+        not_implemented();
+}
+
+int posix_timer_settime(posix_timer_t timerid, int flags,
+    const struct posix_itimerspec *restrict value,
+    struct posix_itimerspec *restrict ovalue)
+{
+        // TODO
+        not_implemented();
+}
+
+#endif
+
+/**
+ * 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;
+}
+
 /** @}
  */

uspace/lib/posix/time.h

@@ -38 +38 @@
 
 #include "libc/time.h"
+#include "sys/types.h"
 
 #ifndef NULL
         #define NULL  ((void *) 0)
 #endif
+
+#ifndef CLOCKS_PER_SEC
+        #define CLOCKS_PER_SEC (1000000L)
+#endif
+
+#ifndef __locale_t_defined
+        #define __locale_t_defined
+        typedef struct __posix_locale *posix_locale_t;
+        #ifndef LIBPOSIX_INTERNAL
+                #define locale_t posix_locale_t
+        #endif
+#endif
+
+#ifndef POSIX_SIGNAL_H_
+        struct posix_sigevent;
+        #ifndef LIBPOSIX_INTERNAL
+                #define sigevent posix_sigevent
+        #endif
+#endif
+
+#undef ASCTIME_BUF_LEN
+#define ASCTIME_BUF_LEN 26
+
+#undef CLOCK_REALTIME
+#define CLOCK_REALTIME ((posix_clockid_t) 0)
 
 struct posix_tm {
@@ -55 +81 @@
 };
 
-typedef long posix_clock_t;
+struct posix_timespec {
+        time_t tv_sec; /* Seconds. */
+        long tv_nsec; /* Nanoseconds. */
+};
+
+struct posix_itimerspec {
+        struct posix_timespec it_interval; /* Timer period. */
+        struct posix_timespec it_value; /* Timer expiration. */
+};
+
+typedef struct __posix_timer *posix_timer_t;
+
+/* Timezones */
+
+extern int posix_daylight;
+extern long posix_timezone;
+extern char *posix_tzname[2];
+
+extern void posix_tzset(void);
+
+/* time_t */
+
+extern double posix_difftime(time_t time1, time_t time0);
 
 /* Broken-down Time */
-extern struct posix_tm *posix_localtime(const time_t *timep);
+extern time_t posix_mktime(struct posix_tm *timeptr);
+extern struct posix_tm *posix_gmtime(const time_t *timer);
+extern struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result);
+extern struct posix_tm *posix_localtime(const time_t *timer);
+extern struct posix_tm *posix_localtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result);
 
 /* Formatting Calendar Time */
-extern char *posix_asctime(const struct posix_tm *tm);
-extern char *posix_ctime(const time_t *timep);
-extern size_t posix_strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct posix_tm *restrict tm);
+extern char *posix_asctime(const struct posix_tm *timeptr);
+extern char *posix_asctime_r(const struct posix_tm *restrict timeptr,
+    char *restrict buf);
+extern char *posix_ctime(const time_t *timer);
+extern char *posix_ctime_r(const time_t *timer, char *buf);
+
+extern size_t posix_strftime(char *restrict s, size_t maxsize,
+    const char *restrict format, const struct posix_tm *restrict tm);
+
+extern size_t posix_strftime_l(char *restrict s, size_t maxsize,
+    const char *restrict format, const struct posix_tm *restrict tm,
+    posix_locale_t loc);
+
+/* Clocks. */
+
+extern int posix_clock_getres(posix_clockid_t clock_id,
+    struct posix_timespec *res);
+extern int posix_clock_gettime(posix_clockid_t clock_id,
+    struct posix_timespec *tp);
+extern int posix_clock_settime(posix_clockid_t clock_id,
+    const struct posix_timespec *tp); 
+extern int posix_clock_nanosleep(posix_clockid_t clock_id, int flags,
+    const struct posix_timespec *rqtp, struct posix_timespec *rmtp);
+
+/* Timers. */
+
+#if 0
+
+extern int posix_timer_create(posix_clockid_t clockid,
+    struct posix_sigevent *restrict evp,
+    posix_timer_t *restrict timerid);
+extern int posix_timer_delete(posix_timer_t timerid);
+extern int posix_timer_getoverrun(posix_timer_t timerid);
+extern int posix_timer_gettime(posix_timer_t timerid,
+    struct posix_itimerspec *value);
+extern int posix_timer_settime(posix_timer_t timerid, int flags,
+    const struct posix_itimerspec *restrict value,
+    struct posix_itimerspec *restrict ovalue);
+
+#endif
 
 /* CPU Time */
 extern posix_clock_t posix_clock(void);
 
+
 #ifndef LIBPOSIX_INTERNAL
         #define tm posix_tm
 
-        #define clock_t posix_clock_t
-
+        #define timespec posix_timespec
+        #define itimerspec posix_itimerspec
+        #define timer_t posix_timer_t
+
+        #define difftime posix_difftime
+        #define mktime posix_mktime
+        #define gmtime posix_gmtime
+        #define gmtime_r posix_gmtime_r
         #define localtime posix_localtime
+        #define localtime_r posix_localtime_r
+
+        #define daylight posix_daylight
+        #define timezone posix_timezone
+        #define tzname posix_tzname
+        #define tzset posix_tzset
 
         #define asctime posix_asctime
+        #define asctime_r posix_asctime_r
         #define ctime posix_ctime
+        #define ctime_r posix_ctime_r
         #define strftime posix_strftime
 
+        #define clock_getres posix_clock_getres
+        #define clock_gettime posix_clock_gettime
+        #define clock_settime posix_clock_settime
+        #define clock_nanosleep posix_clock_nanosleep
+        
+        #define timer_create posix_timer_create
+        #define timer_delete posix_timer_delete
+        #define timer_getoverrun posix_timer_getoverrun
+        #define timer_gettime posix_timer_gettime
+        #define timer_settime posix_timer_settime
+        
         #define clock posix_clock
 #endif

uspace/lib/posix/unistd.c

@@ -38 +38 @@
 #include "internal/common.h"
 #include "unistd.h"
-#include <task.h>
+
+#include "errno.h"
+#include "string.h"
+#include "fcntl.h"
+
+#include "libc/task.h"
+#include "libc/stats.h"
+#include "libc/malloc.h"
 
 /* Array of environment variable strings (NAME=VALUE). */
-char **environ = NULL;
-
-/**
- * Dummy function. Always returns false, because there is no easy way to find
- * out under HelenOS.
- *
- * @param fd
- * @return Always false.
+char **posix_environ = NULL;
+
+/**
+ * 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)
 {
+        /* Always returns false, because there is no easy way to find
+     * out under HelenOS. */
         return false;
 }
 
 /**
- * 
- * @return
+ * Determine the page size of the current run of the process.
+ *
+ * @return Page size of the process.
  */
 int posix_getpagesize(void)
@@ -65 +104 @@
 
 /**
- * 
- * @return
+ * Get the process ID of the calling process.
+ *
+ * @return Process ID.
  */
 posix_pid_t posix_getpid(void)
@@ -74 +114 @@
 
 /**
- *
- * @return
+ * Get the real user ID of the calling process.
+ *
+ * @return User ID.
  */
 posix_uid_t posix_getuid(void)
 {
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @return
+        /* 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)
 {
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @param path
- * @param amode
- * @return
+        /* There is currently no support for user accounts in HelenOS. */
+        return 0;
+}
+
+/**
+ * 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)
 {
-        // TODO
-        not_implemented();
-}
-
-/**
- * 
- * @param name
- * @return
+        if (amode == F_OK) {
+                /* Check file existence by attempt to open it. */
+                int fd = open(path, O_RDONLY);
+                if (fd < 0) {
+                        /* FIXME: open() returns error code as negative retval. */
+                        errno = -fd;
+                        fd = -1;
+                } else {
+                        close(fd);
+                }
+                return fd;
+        } else if (amode & (X_OK | W_OK | R_OK)) {
+                /* HelenOS doesn't support permissions, return success. */
+                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)
 {
-        // TODO
-        not_implemented();
+        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;
+        }
+        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;
+        }
 }
 

uspace/lib/posix/unistd.h

@@ -48 +48 @@
 extern int getopt(int, char * const [], const char *);
 
-/* Environmental Variables */
+/* Environment */
 extern char **posix_environ;
+
+extern char *posix_getlogin(void);
+extern int posix_getlogin_r(char *name, size_t namesize);
 
 /* Identifying Terminals */
@@ -126 +129 @@
 #ifndef LIBPOSIX_INTERNAL
         #define environ posix_environ
+        #define getlogin posix_getlogin
+        #define getlogin_r posix_getlogin_r
 
         #define isatty posix_isatty