Index: uspace/lib/c/arch/abs32le/include/types.h =================================================================== --- uspace/lib/c/arch/abs32le/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/abs32le/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/amd64/include/types.h =================================================================== --- uspace/lib/c/arch/amd64/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/amd64/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -51,4 +51,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/c/arch/arm32/include/types.h =================================================================== --- uspace/lib/c/arch/arm32/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/arm32/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -52,4 +52,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ia32/include/atomic.h =================================================================== --- uspace/lib/c/arch/ia32/include/atomic.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/ia32/include/atomic.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -43,6 +43,6 @@ { asm volatile ( - "lock incl %[count]\n" - : [count] "+m" (val->count) + "lock incl %0\n" + : "+m" (val->count) ); } @@ -51,6 +51,6 @@ { asm volatile ( - "lock decl %[count]\n" - : [count] "+m" (val->count) + "lock decl %0\n" + : "+m" (val->count) ); } @@ -61,7 +61,7 @@ asm volatile ( - "lock xaddl %[r], %[count]\n" - : [count] "+m" (val->count), - [r] "+r" (r) + "lock xaddl %1, %0\n" + : "+m" (val->count), + "+r" (r) ); @@ -74,7 +74,7 @@ asm volatile ( - "lock xaddl %[r], %[count]\n" - : [count] "+m" (val->count), - [r] "+r" (r) + "lock xaddl %1, %0\n" + : "+m" (val->count), + "+r" (r) ); Index: uspace/lib/c/arch/ia32/include/ddi.h =================================================================== --- uspace/lib/c/arch/ia32/include/ddi.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/ia32/include/ddi.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -44,7 +44,7 @@ asm volatile ( - "inb %w[port], %b[val]\n" - : [val] "=a" (val) - : [port] "d" (port) + "inb %w1, %b0\n" + : "=a" (val) + : "d" (port) ); @@ -57,7 +57,7 @@ asm volatile ( - "inw %w[port], %w[val]\n" - : [val] "=a" (val) - : [port] "d" (port) + "inw %w1, %w0\n" + : "=a" (val) + : "d" (port) ); @@ -70,7 +70,7 @@ asm volatile ( - "inl %w[port], %[val]\n" - : [val] "=a" (val) - : [port] "d" (port) + "inl %w1, %0\n" + : "=a" (val) + : "d" (port) ); @@ -81,6 +81,6 @@ { asm volatile ( - "outb %b[val], %w[port]\n" - :: [val] "a" (val), [port] "d" (port) + "outb %b0, %w1\n" + :: "a" (val), "d" (port) ); } @@ -89,6 +89,6 @@ { asm volatile ( - "outw %w[val], %w[port]\n" - :: [val] "a" (val), [port] "d" (port) + "outw %w0, %w1\n" + :: "a" (val), "d" (port) ); } @@ -97,6 +97,6 @@ { asm volatile ( - "outl %[val], %w[port]\n" - :: [val] "a" (val), [port] "d" (port) + "outl %0, %w1\n" + :: "a" (val), "d" (port) ); } Index: uspace/lib/c/arch/ia32/include/types.h =================================================================== --- uspace/lib/c/arch/ia32/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/ia32/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ia64/include/types.h =================================================================== --- uspace/lib/c/arch/ia64/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/ia64/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -61,4 +61,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/c/arch/mips32/include/types.h =================================================================== --- uspace/lib/c/arch/mips32/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/mips32/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -52,4 +52,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ppc32/include/types.h =================================================================== --- uspace/lib/c/arch/ppc32/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/ppc32/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/sparc64/include/types.h =================================================================== --- uspace/lib/c/arch/sparc64/include/types.h (revision 75aa59afaf341ef369f9275528ff77e04017f4f4) +++ uspace/lib/c/arch/sparc64/include/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -51,4 +51,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/posix/Makefile =================================================================== --- uspace/lib/posix/Makefile (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/Makefile (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,64 @@ +# +# Copyright (c) 2011 Petr Koupy +# Copyright (c) 2011 Jiri Zarevucky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libposix +SLIBRARY = libposix.so.0.0 +LSONAME = libposix.so0 + +INCLUDE_LIBC = ./libc + +PRE_DEPEND = $(INCLUDE_LIBC) +EXTRA_CLEAN = $(INCLUDE_LIBC) + +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 \ + stdlib/strtold.c \ + string.c \ + strings.c \ + sys/stat.c \ + sys/wait.c \ + time.c \ + unistd.c + +include $(USPACE_PREFIX)/Makefile.common + +$(INCLUDE_LIBC): ../c/include + ln -s -f -n $^ $@ Index: uspace/lib/posix/assert.h =================================================================== --- uspace/lib/posix/assert.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/assert.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Program assertion. + */ + +/* NO include guard on purpose. */ + +#include "libc/assert.h" + +#undef assert + +#ifndef NDEBUG + #define assert(expr) \ + do { \ + if (!(expr)) { \ + assert_abort(#expr, __FILE__, __LINE__); \ + } \ + } while (0) +#else + #define assert(expr) ((void) 0) +#endif + +/** @} + */ Index: uspace/lib/posix/ctype.c =================================================================== --- uspace/lib/posix/ctype.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/ctype.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Character classification. + */ + +#define LIBPOSIX_INTERNAL + +#include "ctype.h" + +// TODO: propose for inclusion in libc + +/** + * Checks whether character is a hexadecimal digit. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isxdigit(int c) +{ + return isdigit(c) || + (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F'); +} + +/** + * Checks whether character is a word separator. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isblank(int c) +{ + return c == ' ' || c == '\t'; +} + +/** + * Checks whether character is a control character. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_iscntrl(int c) +{ + return c < 0x20 || c == 0x7E; +} + +/** + * Checks whether character is any printing character except space. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isgraph(int c) +{ + return posix_isprint(c) && c != ' '; +} + +/** + * Checks whether character is a printing character. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_isprint(int c) +{ + return !posix_iscntrl(c); +} + +/** + * Checks whether character is a punctuation. + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +int posix_ispunct(int c) +{ + return !isspace(c) && !isalnum(c) && posix_isprint(c); +} + +/** + * Checks whether character is ASCII. (obsolete) + * + * @param c Character to inspect. + * @return Non-zero if character match the definition, zero otherwise. + */ +extern int posix_isascii(int c) +{ + return c >= 0 && c < 128; +} + +/** + * Converts argument to a 7-bit ASCII character. (obsolete) + * + * @param c Character to convert. + * @return Coverted character. + */ +extern int posix_toascii(int c) +{ + return c & 0x7F; +} + +/** @} + */ Index: uspace/lib/posix/ctype.h =================================================================== --- uspace/lib/posix/ctype.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/ctype.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Character classification. + */ + +#ifndef POSIX_CTYPE_H_ +#define POSIX_CTYPE_H_ + +#include "libc/ctype.h" + +/* Classification of Characters */ +extern int posix_isxdigit(int c); +extern int posix_isblank(int c); +extern int posix_iscntrl(int c); +extern int posix_isgraph(int c); +extern int posix_isprint(int c); +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 + #define isblank posix_isblank + #define iscntrl posix_iscntrl + #define isgraph posix_isgraph + #define isprint posix_isprint + #define ispunct posix_ispunct + + #define isascii posix_isascii + #define toascii posix_toascii +#endif + +#endif /* POSIX_CTYPE_H_ */ + +/** @} + */ Index: uspace/lib/posix/errno.c =================================================================== --- uspace/lib/posix/errno.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/errno.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file System error numbers. + */ + +#include "errno.h" + +#include "stdlib.h" +#include "libc/fibril.h" + +static fibril_local int _posix_errno; + +int *__posix_errno(void) +{ + if (*__errno() != 0) { + _posix_errno = abs(*__errno()); + *__errno() = 0; + } + return &_posix_errno; +} + +/** @} + */ Index: uspace/lib/posix/errno.h =================================================================== --- uspace/lib/posix/errno.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/errno.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file System error numbers. + */ + +#ifndef POSIX_ERRNO_H_ +#define POSIX_ERRNO_H_ + +#include "libc/errno.h" + +/* IMPORTANT: + * Since libc uses negative errorcodes, some sort of conversion is necessary to + * keep POSIX programs and libraries from breaking. This file maps POSIX error + * codes to absolute values of corresponding libc codes where available, and + * assigns new code where there is no prior definition in libc. + * + * A new errno variable is defined. When accessed, the function first looks at + * libc errno and iff it is != 0, sets the POSIX errno to absolute value of + * libc errno. Given that no library function sets errno to 0 and that all + * POSIX libraries will be used solely by POSIX programs (thus, there only needs + * to be one way correspondence between errno and posix_errno), this approach + * should work as expected in most cases and does not require any wrappers for + * libc routines that would just change errno values. + * + * There is no conditioning by LIBPOSIX_INTERNAL for redefinitions of macros. + * If there is a need to check errno for a value not defined by POSIX, it's + * necessary to compare errno against abs(ECODE), because there is no + * redefinition for such error codes. + * + * FIXME: maybe all HOS error codes should be redefined + * + * NOTE: This redefinition is slightly POSIX incompatible, since the + * specification requires the macro values to be usable in preprocessing + * directives. I don't think that's very important, though. + */ + +#undef errno +#define errno (*__posix_errno()) + +extern int *__posix_errno(void); + +#define __TOP_ERRNO (-NO_DATA) + +enum { + POSIX_E2BIG = __TOP_ERRNO + 1, + POSIX_EACCES = __TOP_ERRNO + 2, + POSIX_EADDRINUSE = -EADDRINUSE, + POSIX_EADDRNOTAVAIL = -EADDRNOTAVAIL, + POSIX_EAFNOSUPPORT = -EAFNOSUPPORT, + POSIX_EAGAIN = -EAGAIN, + POSIX_EALREADY = __TOP_ERRNO + 3, + POSIX_EBADF = -EBADF, + POSIX_EBADMSG = __TOP_ERRNO + 4, + POSIX_EBUSY = -EBUSY, + POSIX_ECANCELED = __TOP_ERRNO + 5, + POSIX_ECHILD = __TOP_ERRNO + 6, + POSIX_ECONNABORTED = __TOP_ERRNO + 7, + POSIX_ECONNREFUSED = __TOP_ERRNO + 8, + POSIX_ECONNRESET = __TOP_ERRNO + 9, + POSIX_EDEADLK = __TOP_ERRNO + 10, + POSIX_EDESTADDRREQ = -EDESTADDRREQ, + POSIX_EDOM = __TOP_ERRNO + 11, + POSIX_EDQUOT = __TOP_ERRNO + 12, + POSIX_EEXIST = -EEXIST, + POSIX_EFAULT = __TOP_ERRNO + 13, + POSIX_EFBIG = __TOP_ERRNO + 14, + POSIX_EHOSTUNREACH = __TOP_ERRNO + 15, + POSIX_EIDRM = __TOP_ERRNO + 16, + POSIX_EILSEQ = __TOP_ERRNO + 17, + POSIX_EINPROGRESS = -EINPROGRESS, + POSIX_EINTR = -EINTR, + POSIX_EINVAL = -EINVAL, + POSIX_EIO = -EIO, + POSIX_EISCONN = __TOP_ERRNO + 18, + POSIX_EISDIR = -EISDIR, + POSIX_ELOOP = __TOP_ERRNO + 19, + POSIX_EMFILE = -EMFILE, + POSIX_EMLINK = -EMLINK, + POSIX_EMSGSIZE = __TOP_ERRNO + 20, + POSIX_EMULTIHOP = __TOP_ERRNO + 21, + POSIX_ENAMETOOLONG = -ENAMETOOLONG, + POSIX_ENETDOWN = __TOP_ERRNO + 22, + POSIX_ENETRESET = __TOP_ERRNO + 23, + POSIX_ENETUNREACH = __TOP_ERRNO + 24, + POSIX_ENFILE = __TOP_ERRNO + 25, + POSIX_ENOBUFS = __TOP_ERRNO + 26, + POSIX_ENODATA = -NO_DATA, + POSIX_ENODEV = __TOP_ERRNO + 27, + POSIX_ENOENT = -ENOENT, + POSIX_ENOEXEC = __TOP_ERRNO + 28, + POSIX_ENOLCK = __TOP_ERRNO + 29, + POSIX_ENOLINK = __TOP_ERRNO + 30, + POSIX_ENOMEM = -ENOMEM, + POSIX_ENOMSG = __TOP_ERRNO + 31, + POSIX_ENOPROTOOPT = __TOP_ERRNO + 32, + POSIX_ENOSPC = -ENOSPC, + POSIX_ENOSR = __TOP_ERRNO + 33, + POSIX_ENOSTR = __TOP_ERRNO + 34, + POSIX_ENOSYS = __TOP_ERRNO + 35, + POSIX_ENOTCONN = -ENOTCONN, + POSIX_ENOTDIR = -ENOTDIR, + POSIX_ENOTEMPTY = -ENOTEMPTY, + POSIX_ENOTRECOVERABLE = __TOP_ERRNO + 36, + POSIX_ENOTSOCK = -ENOTSOCK, + POSIX_ENOTSUP = -ENOTSUP, + POSIX_ENOTTY = __TOP_ERRNO + 37, + POSIX_ENXIO = __TOP_ERRNO + 38, + POSIX_EOPNOTSUPP = POSIX_ENOTSUP, + POSIX_EOVERFLOW = -EOVERFLOW, + POSIX_EOWNERDEAD = __TOP_ERRNO + 39, + POSIX_EPERM = -EPERM, + POSIX_EPIPE = __TOP_ERRNO + 40, + POSIX_EPROTO = __TOP_ERRNO + 41, + POSIX_EPROTONOSUPPORT = -EPROTONOSUPPORT, + POSIX_EPROTOTYPE = __TOP_ERRNO + 42, + POSIX_ERANGE = -ERANGE, + POSIX_EROFS = __TOP_ERRNO + 43, + POSIX_ESPIPE = __TOP_ERRNO + 44, + POSIX_ESRCH = __TOP_ERRNO + 45, + POSIX_ESTALE = __TOP_ERRNO + 46, + POSIX_ETIME = __TOP_ERRNO + 47, + POSIX_ETIMEDOUT = __TOP_ERRNO + 48, + POSIX_ETXTBSY = __TOP_ERRNO + 49, + POSIX_EWOULDBLOCK = POSIX_EAGAIN, + POSIX_EXDEV = -EXDEV, +}; + +#undef __TOP_ERRNO + +#undef E2BIG +#undef EACCES +#undef EADDRINUSE +#undef EADDRNOTAVAIL +#undef EAFNOSUPPORT +#undef EAGAIN +#undef EALREADY +#undef EBADF +#undef EBADMSG +#undef EBUSY +#undef ECANCELED +#undef ECHILD +#undef ECONNABORTED +#undef ECONNREFUSED +#undef ECONNRESET +#undef EDEADLK +#undef EDESTADDRREQ +#undef EDOM +#undef EDQUOT +#undef EEXIST +#undef EFAULT +#undef EFBIG +#undef EHOSTUNREACH +#undef EIDRM +#undef EILSEQ +#undef EINPROGRESS +#undef EINTR +#undef EINVAL +#undef EIO +#undef EISCONN +#undef EISDIR +#undef ELOOP +#undef EMFILE +#undef EMLINK +#undef EMSGSIZE +#undef EMULTIHOP +#undef ENAMETOOLONG +#undef ENETDOWN +#undef ENETRESET +#undef ENETUNREACH +#undef ENFILE +#undef ENOBUFS +#undef ENODATA +#undef ENODEV +#undef ENOENT +#undef ENOEXEC +#undef ENOLCK +#undef ENOLINK +#undef ENOMEM +#undef ENOMSG +#undef ENOPROTOOPT +#undef ENOSPC +#undef ENOSR +#undef ENOSTR +#undef ENOSYS +#undef ENOTCONN +#undef ENOTDIR +#undef ENOTEMPTY +#undef ENOTRECOVERABLE +#undef ENOTSOCK +#undef ENOTSUP +#undef ENOTTY +#undef ENXIO +#undef EOPNOTSUPP +#undef EOVERFLOW +#undef EOWNERDEAD +#undef EPERM +#undef EPIPE +#undef EPROTO +#undef EPROTONOSUPPORT +#undef EPROTOTYPE +#undef ERANGE +#undef EROFS +#undef ESPIPE +#undef ESRCH +#undef ESTALE +#undef ETIME +#undef ETIMEDOUT +#undef ETXTBSY +#undef EWOULDBLOCK +#undef EXDEV + +#define E2BIG POSIX_E2BIG +#define EACCES POSIX_EACCES +#define EADDRINUSE POSIX_EADDRINUSE +#define EADDRNOTAVAIL POSIX_EADDRNOTAVAIL +#define EAFNOSUPPORT POSIX_EAFNOSUPPORT +#define EAGAIN POSIX_EAGAIN +#define EALREADY POSIX_EALREADY +#define EBADF POSIX_EBADF +#define EBADMSG POSIX_EBADMSG +#define EBUSY POSIX_EBUSY +#define ECANCELED POSIX_ECANCELED +#define ECHILD POSIX_ECHILD +#define ECONNABORTED POSIX_ECONNABORTED +#define ECONNREFUSED POSIX_ECONNREFUSED +#define ECONNRESET POSIX_ECONNRESET +#define EDEADLK POSIX_EDEADLK +#define EDESTADDRREQ POSIX_EDESTADDRREQ +#define EDOM POSIX_EDOM +#define EDQUOT POSIX_EDQUOT +#define EEXIST POSIX_EEXIST +#define EFAULT POSIX_EFAULT +#define EFBIG POSIX_EFBIG +#define EHOSTUNREACH POSIX_EHOSTUNREACH +#define EIDRM POSIX_EIDRM +#define EILSEQ POSIX_EILSEQ +#define EINPROGRESS POSIX_EINPROGRESS +#define EINTR POSIX_EINTR +#define EINVAL POSIX_EINVAL +#define EIO POSIX_EIO +#define EISCONN POSIX_EISCONN +#define EISDIR POSIX_EISDIR +#define ELOOP POSIX_ELOOP +#define EMFILE POSIX_EMFILE +#define EMLINK POSIX_EMLINK +#define EMSGSIZE POSIX_EMSGSIZE +#define EMULTIHOP POSIX_EMULTIHOP +#define ENAMETOOLONG POSIX_ENAMETOOLONG +#define ENETDOWN POSIX_ENETDOWN +#define ENETRESET POSIX_ENETRESET +#define ENETUNREACH POSIX_ENETUNREACH +#define ENFILE POSIX_ENFILE +#define ENOBUFS POSIX_ENOBUFS +#define ENODATA POSIX_ENODATA +#define ENODEV POSIX_ENODEV +#define ENOENT POSIX_ENOENT +#define ENOEXEC POSIX_ENOEXEC +#define ENOLCK POSIX_ENOLCK +#define ENOLINK POSIX_ENOLINK +#define ENOMEM POSIX_ENOMEM +#define ENOMSG POSIX_ENOMSG +#define ENOPROTOOPT POSIX_ENOPROTOOPT +#define ENOSPC POSIX_ENOSPC +#define ENOSR POSIX_ENOSR +#define ENOSTR POSIX_ENOSTR +#define ENOSYS POSIX_ENOSYS +#define ENOTCONN POSIX_ENOTCONN +#define ENOTDIR POSIX_ENOTDIR +#define ENOTEMPTY POSIX_ENOTEMPTY +#define ENOTRECOVERABLE POSIX_ENOTRECOVERABLE +#define ENOTSOCK POSIX_ENOTSOCK +#define ENOTSUP POSIX_ENOTSUP +#define ENOTTY POSIX_ENOTTY +#define ENXIO POSIX_ENXIO +#define EOPNOTSUPP POSIX_EOPNOTSUPP +#define EOVERFLOW POSIX_EOVERFLOW +#define EOWNERDEAD POSIX_EOWNERDEAD +#define EPERM POSIX_EPERM +#define EPIPE POSIX_EPIPE +#define EPROTO POSIX_EPROTO +#define EPROTONOSUPPORT POSIX_EPROTONOSUPPORT +#define EPROTOTYPE POSIX_EPROTOTYPE +#define ERANGE POSIX_ERANGE +#define EROFS POSIX_EROFS +#define ESPIPE POSIX_ESPIPE +#define ESRCH POSIX_ESRCH +#define ESTALE POSIX_ESTALE +#define ETIME POSIX_ETIME +#define ETIMEDOUT POSIX_ETIMEDOUT +#define ETXTBSY POSIX_ETXTBSY +#define EWOULDBLOCK POSIX_EWOULDBLOCK +#define EXDEV POSIX_EXDEV + +#endif /* POSIX_ERRNO_H_ */ + +/** @} + */ Index: uspace/lib/posix/fcntl.c =================================================================== --- uspace/lib/posix/fcntl.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/fcntl.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File control. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "fcntl.h" + +#include "libc/unistd.h" +#include "libc/vfs/vfs.h" +#include "errno.h" + +/** + * Performs set of operations on the opened files. + * + * @param fd File descriptor of the opened file. + * @param cmd Operation to carry out. + * @return Non-negative on success. Might have special meaning corresponding + * to the requested operation. + */ +int posix_fcntl(int fd, int cmd, ...) +{ + int 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; + } +} + +/** @} + */ Index: uspace/lib/posix/fcntl.h =================================================================== --- uspace/lib/posix/fcntl.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/fcntl.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File control. + */ + +#ifndef POSIX_FCNTL_H_ +#define POSIX_FCNTL_H_ + +#include "sys/types.h" +#include "libc/fcntl.h" +#include "errno.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 +#undef F_GETFL +#undef F_SETFL +#undef F_GETOWN +#undef F_SETOWN +#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. */ + +#undef open +#define open(path, ...) \ + ({ \ + int rc = open(path, ##__VA_ARGS__); \ + if (rc < 0) { \ + errno = -rc; \ + rc = -1; \ + } \ + rc; \ + }) + +extern int posix_fcntl(int fd, int cmd, ...); + +#ifndef LIBPOSIX_INTERNAL + #define fcntl posix_fcntl +#endif + +#endif /* POSIX_FCNTL_H_ */ + +/** @} + */ Index: uspace/lib/posix/float.h =================================================================== --- uspace/lib/posix/float.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/float.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Floating type support. + */ + +#ifndef POSIX_FLOAT_H_ +#define POSIX_FLOAT_H_ + +/* Empty. Just to satisfy preprocessor. */ + +#endif /* POSIX_FLOAT_H_ */ + +/** @} + */ Index: uspace/lib/posix/fnmatch.c =================================================================== --- uspace/lib/posix/fnmatch.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/fnmatch.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,656 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Filename-matching. + */ + +// 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" + +// TODO: documentation + +#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 } +}; + +/** + * + * @param key + * @param elem + * @return + */ +static int _class_compare(const void *key, const void *elem) +{ + const struct _char_class *class = elem; + return strcmp((const char *) key, class->name); +} + +/** + * + * @param cname + * @param c + * @return + */ +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); + } +} + +/** + * + * @param pattern + * @param str + * @param flags + * @return + */ +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 ****************/ + +/** + * + * @param pattern + * @param flags + * @return + */ +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); +} + +/** + * + * @param pattern + * @param str + * @param flags + * @return + */ +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 +} + +/** + * + * @param pattern + * @param string + * @param flags + * @return + */ +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; +} + +/** + * + * @param pattern + * @param string + * @param flags + * @return + */ +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 == '/'); +} + +/** + * + * @param s + * @return + */ +static char *_casefold(const char *s) +{ + char *result = strdup(s); + for (char *i = result; *i != '\0'; ++i) { + *i = tolower(*i); + } + return result; +} + +/** + * Filename pattern matching. + * + * @param pattern + * @param string + * @param flags + * @return + */ +int posix_fnmatch(const char *pattern, const char *string, int flags) +{ + // TODO: don't fold everything in advance, but only when needed + + if ((flags & FNM_CASEFOLD) != 0) { + /* Just fold the entire pattern and string. */ + pattern = _casefold(pattern); + string = _casefold(string); + } + + bool result = _full_match(pattern, string, flags); + + if ((flags & FNM_CASEFOLD) != 0) { + if (pattern) { + free((char *) pattern); + } + if (string) { + free((char *) string); + } + } + + return result ? 0 : FNM_NOMATCH; +} + +// FIXME: put the testcases somewhere else + +#if 0 + +#include + +void __posix_fnmatch_test() +{ + int fail = 0; + + #undef assert + #define assert(x) { if (x) printf("SUCCESS: "#x"\n"); else { printf("FAILED: "#x"\n"); fail++; } } + #define match(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == 0) + #define nomatch(s1, s2, flags) assert(posix_fnmatch(s1, s2, flags) == FNM_NOMATCH) + + assert(FNM_PATHNAME == FNM_FILE_NAME); + match("", "", 0); + match("*", "hello", 0); + match("hello", "hello", 0); + match("hello*", "hello", 0); + nomatch("hello?", "hello", 0); + match("*hello", "prdel hello", 0); + match("he[sl]lo", "hello", 0); + match("he[sl]lo", "heslo", 0); + nomatch("he[sl]lo", "heblo", 0); + nomatch("he[^sl]lo", "hello", 0); + nomatch("he[^sl]lo", "heslo", 0); + match("he[^sl]lo", "heblo", 0); + nomatch("he[!sl]lo", "hello", 0); + nomatch("he[!sl]lo", "heslo", 0); + match("he[!sl]lo", "heblo", 0); + match("al*[c-t]a*vis*ta", "alheimer talir jehovista", 0); + match("al*[c-t]a*vis*ta", "alfons had jehovista", 0); + match("[a-ce-z]", "a", 0); + match("[a-ce-z]", "c", 0); + nomatch("[a-ce-z]", "d", 0); + match("[a-ce-z]", "e", 0); + match("[a-ce-z]", "z", 0); + nomatch("[^a-ce-z]", "a", 0); + nomatch("[^a-ce-z]", "c", 0); + match("[^a-ce-z]", "d", 0); + nomatch("[^a-ce-z]", "e", 0); + nomatch("[^a-ce-z]", "z", 0); + match("helen??", "helenos", 0); + match("****booo****", "booo", 0); + + match("hello[[:space:]]world", "hello world", 0); + nomatch("hello[[:alpha:]]world", "hello world", 0); + + match("/hoooo*", "/hooooooo/hooo", 0); + nomatch("/hoooo*", "/hooooooo/hooo", FNM_PATHNAME); + nomatch("/hoooo*/", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*/*", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*/hooo", "/hooooooo/hooo", FNM_PATHNAME); + match("/hoooo*", "/hooooooo/hooo", FNM_PATHNAME | FNM_LEADING_DIR); + nomatch("/hoooo*/", "/hooooooo/hooo", FNM_PATHNAME | FNM_LEADING_DIR); + nomatch("/hoooo", "/hooooooo/hooo", FNM_LEADING_DIR); + match("/hooooooo", "/hooooooo/hooo", FNM_LEADING_DIR); + + match("*", "hell", 0); + match("*?", "hell", 0); + match("?*?", "hell", 0); + match("?*??", "hell", 0); + match("??*??", "hell", 0); + nomatch("???*??", "hell", 0); + + nomatch("", "hell", 0); + nomatch("?", "hell", 0); + nomatch("??", "hell", 0); + nomatch("???", "hell", 0); + match("????", "hell", 0); + + match("*", "h.ello", FNM_PERIOD); + match("*", "h.ello", FNM_PATHNAME | FNM_PERIOD); + nomatch("*", ".hello", FNM_PERIOD); + match("h?ello", "h.ello", FNM_PERIOD); + nomatch("?hello", ".hello", FNM_PERIOD); + match("/home/user/.*", "/home/user/.hello", FNM_PATHNAME | FNM_PERIOD); + match("/home/user/*", "/home/user/.hello", FNM_PERIOD); + nomatch("/home/user/*", "/home/user/.hello", FNM_PATHNAME | FNM_PERIOD); + + nomatch("HeLlO", "hello", 0); + match("HeLlO", "hello", FNM_CASEFOLD); + + printf("Failed: %d\n", fail); +} + +#endif + +/** @} + */ Index: uspace/lib/posix/fnmatch.h =================================================================== --- uspace/lib/posix/fnmatch.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/fnmatch.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Filename-matching. + */ + +#ifndef POSIX_FNMATCH_H_ +#define POSIX_FNMATCH_H_ + +/* Error Values */ +#undef FNM_NOMATCH +#define FNM_NOMATCH 1 + +/* Flags */ +#undef FNM_PATHNAME +#undef FNM_PERIOD +#undef FNM_NOESCAPE +#define FNM_PATHNAME 1 +#define FNM_PERIOD 2 +#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); + +#ifndef LIBPOSIX_INTERNAL + #define fnmatch posix_fnmatch +#endif + +#endif /* POSIX_FNMATCH_H_ */ + +/** @} + */ Index: uspace/lib/posix/internal/common.h =================================================================== --- uspace/lib/posix/internal/common.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/internal/common.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Helper definitions common for all libposix files. + */ + +#ifndef LIBPOSIX_COMMON_H_ +#define LIBPOSIX_COMMON_H_ + +#include +#include + +#define not_implemented() (fprintf(stderr, \ + "Function %s() in file %s at line %d is not implemented\n", \ + __func__, __FILE__, __LINE__), abort()) + +#endif /* LIBPOSIX_COMMON_H_ */ + +/** @} + */ Index: uspace/lib/posix/inttypes.h =================================================================== --- uspace/lib/posix/inttypes.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/inttypes.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Fixed size integer types. + */ + +#ifndef POSIX_INTTYPES_H_ +#define POSIX_INTTYPES_H_ + +#include "stdint.h" +#include "libc/inttypes.h" + +extern posix_intmax_t posix_strtoimax(const char *restrict nptr, + char **restrict endptr, int base); +extern posix_uintmax_t posix_strtoumax(const char *restrict nptr, + char **restrict endptr, int base); + +#ifndef LIBPOSIX_INTERNAL + #define strtoimax posix_strtoimax + #define strtoumax posix_strtoumax +#endif + +#endif /* POSIX_INTTYPES_H_ */ + +/** @} + */ Index: uspace/lib/posix/iso646.h =================================================================== --- uspace/lib/posix/iso646.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/iso646.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Alternative spellings. + */ + +#ifndef POSIX_ISO646_H_ +#define POSIX_ISO646_H_ + +#define and && +#define and_eq &= +#define bitand & +#define bitor | +#define compl ˜ +#define not ! +#define not_eq != +#define or || +#define or_eq |= +#define xor ^ +#define xor_eq ^= + +#endif /* POSIX_ISO646_H_ */ + +/** @} + */ Index: uspace/lib/posix/limits.h =================================================================== --- uspace/lib/posix/limits.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/limits.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Implementation-defined limit constants. + */ + +#ifndef POSIX_LIMITS_H_ +#define POSIX_LIMITS_H_ + +#include "stdint.h" +#include "libc/sys/types.h" + +#undef SHRT_MIN +#undef SHRT_MAX +#undef USHRT_MAX +#define SHRT_MIN SHORT_MIN +#define SHRT_MAX SHORT_MAX +#define USHRT_MAX USHORT_MAX + +#undef PATH_MAX +#define PATH_MAX 256 + +#endif /* POSIX_LIMITS_H_ */ + +/** @} + */ Index: uspace/lib/posix/locale.c =================================================================== --- uspace/lib/posix/locale.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/locale.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Locale-specific definitions. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "locale.h" + +#include "errno.h" +#include "limits.h" +#include "string.h" + +// TODO: documentation + +struct __posix_locale { + int _dummy; +}; + +const struct posix_lconv C_LOCALE = { + .currency_symbol = (char *) "", + .decimal_point = (char *) ".", + .frac_digits = CHAR_MAX, + .grouping = (char *) "", + .int_curr_symbol = (char *) "", + .int_frac_digits = CHAR_MAX, + .int_n_cs_precedes = CHAR_MAX, + .int_n_sep_by_space = CHAR_MAX, + .int_n_sign_posn = CHAR_MAX, + .int_p_cs_precedes = CHAR_MAX, + .int_p_sep_by_space = CHAR_MAX, + .int_p_sign_posn = CHAR_MAX, + .mon_decimal_point = (char *) "", + .mon_grouping = (char *) "", + .mon_thousands_sep = (char *) "", + .negative_sign = (char *) "", + .n_cs_precedes = CHAR_MAX, + .n_sep_by_space = CHAR_MAX, + .n_sign_posn = CHAR_MAX, + .positive_sign = (char *) "", + .p_cs_precedes = CHAR_MAX, + .p_sep_by_space = CHAR_MAX, + .p_sign_posn = CHAR_MAX, + .thousands_sep = (char *) "" +}; + +/** + * + * @param category + * @param locale + * @return + */ +char *posix_setlocale(int category, const char *locale) +{ + // TODO + if (locale == NULL || *locale == '\0' || + posix_strcmp(locale, "C") == 0) { + return (char *) "C"; + } + return NULL; +} + +/** + * + * @return + */ +struct posix_lconv *posix_localeconv(void) +{ + // TODO + return (struct posix_lconv *) &C_LOCALE; +} + +/** + * + * @param locobj + * @return + */ +posix_locale_t posix_duplocale(posix_locale_t locobj) +{ + if (locobj == NULL) { + errno = EINVAL; + return NULL; + } + posix_locale_t copy = malloc(sizeof(struct __posix_locale)); + if (copy == NULL) { + errno = ENOMEM; + return NULL; + } + memcpy(copy, locobj, sizeof(struct __posix_locale)); + return copy; +} + +/** + * + * @param locobj + */ +void posix_freelocale(posix_locale_t locobj) +{ + if (locobj) { + free(locobj); + } +} + +/** + * + * @param category_mask + * @param locale + * @param base + * @return + */ +posix_locale_t posix_newlocale(int category_mask, const char *locale, + posix_locale_t base) +{ + if (locale == NULL || + (category_mask & LC_ALL_MASK) != category_mask) { + errno = EINVAL; + return NULL; + } + // TODO + posix_locale_t new = malloc(sizeof(struct __posix_locale)); + if (new == NULL) { + errno = ENOMEM; + return NULL; + } + if (base != NULL) { + posix_freelocale(base); + } + return new; +} + +/** + * + * @param newloc + * @return + */ +posix_locale_t posix_uselocale(posix_locale_t newloc) +{ + // TODO + return NULL; +} + +/** @} + */ Index: uspace/lib/posix/locale.h =================================================================== --- uspace/lib/posix/locale.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/locale.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Locale-specific definitions. + */ + +#ifndef POSIX_LOCALE_H_ +#define POSIX_LOCALE_H_ + +// TODO: documentation + +#ifndef NULL + #define NULL ((void *) 0) +#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 + +#undef LC_ALL +#undef LC_COLLATE +#undef LC_CTYPE +#undef LC_MESSAGES +#undef LC_MONETARY +#undef LC_NUMERIC +#undef LC_TIME +#define LC_ALL 0 +#define LC_COLLATE 1 +#define LC_CTYPE 2 +#define LC_MESSAGES 3 +#define LC_MONETARY 4 +#define LC_NUMERIC 5 +#define LC_TIME 6 + +#undef LC_COLLATE_MASK +#undef LC_CTYPE_MASK +#undef LC_MESSAGES_MASK +#undef LC_MONETARY_MASK +#undef LC_NUMERIC_MASK +#undef LC_TIME_MASK +#undef LC_ALL_MASK +#define LC_COLLATE_MASK (1 << 0) +#define LC_CTYPE_MASK (1 << 1) +#define LC_MESSAGES_MASK (1 << 2) +#define LC_MONETARY_MASK (1 << 3) +#define LC_NUMERIC_MASK (1 << 4) +#define LC_TIME_MASK (1 << 5) +#define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | \ + LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK) + +#undef LC_GLOBAL_LOCALE +#define LC_GLOBAL_LOCALE NULL + +struct posix_lconv { + char *currency_symbol; + char *decimal_point; + char frac_digits; + char *grouping; + char *int_curr_symbol; + char int_frac_digits; + char int_n_cs_precedes; + char int_n_sep_by_space; + char int_n_sign_posn; + char int_p_cs_precedes; + char int_p_sep_by_space; + char int_p_sign_posn; + char *mon_decimal_point; + char *mon_grouping; + char *mon_thousands_sep; + char *negative_sign; + char n_cs_precedes; + char n_sep_by_space; + char n_sign_posn; + char *positive_sign; + char p_cs_precedes; + char p_sep_by_space; + char p_sign_posn; + char *thousands_sep; +}; + +extern char *posix_setlocale(int category, const char *locale); +extern struct posix_lconv *posix_localeconv(void); + +/* POSIX Extensions */ +extern posix_locale_t posix_duplocale(posix_locale_t locobj); +extern void posix_freelocale(posix_locale_t locobj); +extern posix_locale_t posix_newlocale(int category_mask, const char *locale, + posix_locale_t base); +extern posix_locale_t posix_uselocale(posix_locale_t newloc); + +#ifndef LIBPOSIX_INTERNAL + #define lconv posix_lconv + + #define setlocale posix_setlocale + #define localeconv posix_localeconv + + #define newlocale posix_newlocale + #define uselocale posix_uselocale + #define duplocale posix_duplocale + #define freelocale posix_freelocale +#endif + +#endif /* POSIX_LOCALE_H_ */ + +/** @} + */ Index: uspace/lib/posix/math.c =================================================================== --- uspace/lib/posix/math.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/math.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Mathematical operations. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "math.h" + +/** + * + * @param x + * @param exp + * @return + */ +double posix_ldexp(double x, int exp) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param num + * @param exp + * @return + */ +double posix_frexp(double num, int *exp) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */ Index: uspace/lib/posix/math.h =================================================================== --- uspace/lib/posix/math.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/math.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Mathematical operations. + */ + +#ifndef POSIX_MATH_H_ +#define POSIX_MATH_H_ + +/* Normalization Functions */ +extern double posix_ldexp(double x, int exp); +extern double posix_frexp(double num, int *exp); + +#ifndef LIBPOSIX_INTERNAL + #define ldexp posix_ldexp + #define frexp posix_frexp +#endif + +#endif /* POSIX_MATH_H_ */ + +/** @} + */ Index: uspace/lib/posix/pwd.c =================================================================== --- uspace/lib/posix/pwd.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/pwd.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Password handling. + */ + +#define LIBPOSIX_INTERNAL + +#include "pwd.h" +#include "string.h" +#include "errno.h" + +// TODO: documentation + +static bool entry_read = false; + +/* dummy user account */ +static const struct posix_passwd dummy_pwd = { + .pw_name = (char *) "user", + .pw_uid = 1, + .pw_gid = 1, + .pw_dir = (char *) "/", + .pw_shell = (char *) "/app/bdsh" +}; + +/** + * Since HelenOS doesn't have user accounts, this always returns + * the same made-up entry. + * + * @return + */ +struct posix_passwd *posix_getpwent(void) +{ + if (entry_read) { + return NULL; + } + + entry_read = true; + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * "Rewind the user list". + */ +void posix_setpwent(void) +{ + entry_read = false; +} + +/** + * Ends enumerating and releases all resources. (Noop) + */ +void posix_endpwent(void) +{ + /* noop */ +} + +/** + * Find an entry by name. + * + * @param name Name of the entry. + * @return + */ +struct posix_passwd *posix_getpwnam(const char *name) +{ + assert(name != NULL); + + if (posix_strcmp(name, "user") != 0) { + return NULL; + } + + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * Find an entry by name, thread safely. + * + * @param name Name of the entry. + * @param pwd + * @param buffer + * @param bufsize + * @param result + * @return + */ +int posix_getpwnam_r(const char *name, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result) +{ + assert(name != NULL); + + if (posix_strcmp(name, "user") != 0) { + *result = NULL; + return 0; + } + + return posix_getpwuid_r(1, pwd, buffer, bufsize, result); +} + +/** + * Find an entry by UID. + * + * @param uid UID of the entry. + * @return + */ +struct posix_passwd *posix_getpwuid(posix_uid_t uid) +{ + if (uid != 1) { + return NULL; + } + + return (struct posix_passwd *) &dummy_pwd; +} + +/** + * Find an entry by UID, thread safely. + * + * @param uid UID of the entry. + * @param pwd + * @param buffer + * @param bufsize + * @param result + * @return + */ +int posix_getpwuid_r(posix_uid_t uid, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result) +{ + assert(pwd != NULL); + assert(buffer != NULL); + assert(result != NULL); + + static const char bf[] = { 'u', 's', 'e', 'r', '\0', + '/', '\0', 'b', 'd', 's', 'h', '\0' }; + + if (uid != 1) { + *result = NULL; + return 0; + } + if (bufsize < sizeof(bf)) { + *result = NULL; + return ERANGE; + } + + memcpy(buffer, bf, sizeof(bf)); + + pwd->pw_name = (char *) bf; + pwd->pw_uid = 1; + pwd->pw_gid = 1; + pwd->pw_dir = (char *) bf + 5; + pwd->pw_shell = (char *) bf + 7; + *result = (struct posix_passwd *) pwd; + + return 0; +} + +/** @} + */ Index: uspace/lib/posix/pwd.h =================================================================== --- uspace/lib/posix/pwd.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/pwd.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Password handling. + */ + +#ifndef POSIX_PWD_H_ +#define POSIX_PWD_H_ + +// TODO: documentation + +#include "sys/types.h" + +struct posix_passwd { + char *pw_name; + posix_uid_t pw_uid; + posix_gid_t pw_gid; + char *pw_dir; + char *pw_shell; +}; + +extern struct posix_passwd *posix_getpwent(void); +extern void posix_setpwent(void); +extern void posix_endpwent(void); + +extern struct posix_passwd *posix_getpwnam(const char *name); +extern int posix_getpwnam_r(const char *name, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result); + +extern struct posix_passwd *posix_getpwuid(posix_uid_t uid); +extern int posix_getpwuid_r(posix_uid_t uid, struct posix_passwd *pwd, + char *buffer, size_t bufsize, struct posix_passwd **result); + +#ifndef LIBPOSIX_INTERNAL + #define passwd posix_passwd + + #define getpwent posix_getpwent + #define setpwent posix_setpwent + #define endpwent posix_endpwent + + #define getpwnam posix_getpwnam + #define getpwnam_r posix_getpwnam_r + + #define getpwuid posix_getpwuid + #define getpwuid_r posix_getpwuid_r +#endif + +#endif /* POSIX_PWD_H_ */ + +/** @} + */ Index: uspace/lib/posix/signal.c =================================================================== --- uspace/lib/posix/signal.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/signal.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,479 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Signal handling. + */ + +#define LIBPOSIX_INTERNAL + +#include "signal.h" +#include "internal/common.h" +#include "limits.h" +#include "stdlib.h" +#include "string.h" +#include "errno.h" + +#include "libc/fibril_synch.h" +#include "libc/task.h" + +// TODO: documentation + +/* Used to serialize signal handling. */ +static FIBRIL_MUTEX_INITIALIZE(_signal_mutex); + +static posix_sigset_t _signal_mask = 0; + +#define DEFAULT_HANDLER { .sa_handler = SIG_DFL, \ + .sa_mask = 0, .sa_flags = 0, .sa_sigaction = NULL } + +static struct posix_sigaction _signal_actions[_TOP_SIGNAL + 1] = { + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, + DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER, DEFAULT_HANDLER +}; + +/** + * + * @param signo + */ +void __posix_default_signal_handler(int signo) +{ + switch (signo) { + case SIGABRT: + abort(); + case SIGQUIT: + fprintf(stderr, "Quit signal raised. Exiting."); + exit(EXIT_FAILURE); + case SIGINT: + fprintf(stderr, "Interrupt signal caught. Exiting."); + exit(EXIT_FAILURE); + case SIGTERM: + fprintf(stderr, "Termination signal caught. Exiting."); + exit(EXIT_FAILURE); + case SIGSTOP: + fprintf(stderr, "Stop signal caught, but unsupported. Ignoring."); + break; + case SIGKILL: + /* This will only occur when raise or similar is called. */ + /* Commit suicide. */ + task_kill(task_get_id()); + + /* Should not be reached. */ + abort(); + case SIGFPE: + case SIGBUS: + case SIGILL: + case SIGSEGV: + posix_psignal(signo, "Hardware exception raised by user code"); + abort(); + case SIGSYS: + case SIGXCPU: + case SIGXFSZ: + case SIGTRAP: + case SIGHUP: + case SIGPIPE: + case SIGPOLL: + case SIGURG: + case SIGTSTP: + case SIGTTIN: + case SIGTTOU: + posix_psignal(signo, "Unsupported signal caught"); + abort(); + case SIGCHLD: + case SIGUSR1: + case SIGUSR2: + case SIGALRM: + case SIGVTALRM: + case SIGPROF: + case SIGCONT: + /* ignored */ + break; + } +} + +/** + * + * @param signo + */ +void __posix_hold_signal_handler(int signo) +{ + /* Nothing */ +} + +/** + * + * @param signo + */ +void __posix_ignore_signal_handler(int signo) +{ + /* Nothing */ +} + +/** + * + * @param set + * @return + */ +int posix_sigemptyset(posix_sigset_t *set) +{ + assert(set != NULL); + + *set = 0; + return 0; +} + +/** + * + * @param set + * @return + */ +int posix_sigfillset(posix_sigset_t *set) +{ + assert(set != NULL); + + *set = UINT32_MAX; + return 0; +} + +/** + * + * @param set + * @param signo + * @return + */ +int posix_sigaddset(posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + *set |= (1 << signo); + return 0; +} + +/** + * + * @param set + * @param signo + * @return + */ +int posix_sigdelset(posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + *set &= ~(1 << signo); + return 0; +} + +/** + * + * @param set + * @param signo + * @return + */ +int posix_sigismember(const posix_sigset_t *set, int signo) +{ + assert(set != NULL); + + return (*set & (1 << signo)) != 0; +} + +/** + * + * @param sig + * @param act + * @param oact + */ +static void _sigaction_unsafe(int sig, const struct posix_sigaction *restrict act, + struct posix_sigaction *restrict oact) +{ + if (oact != NULL) { + memcpy(oact, &_signal_actions[sig], + sizeof(struct posix_sigaction)); + } + + if (act != NULL) { + memcpy(&_signal_actions[sig], act, + sizeof(struct posix_sigaction)); + } +} + +/** + * + * @param sig + * @param act + * @param oact + * @return + */ +int posix_sigaction(int sig, const struct posix_sigaction *restrict act, + struct posix_sigaction *restrict oact) +{ + if (sig > _TOP_SIGNAL || (act != NULL && + (sig == SIGKILL || sig == SIGSTOP))) { + errno = EINVAL; + return -1; + } + + if (sig > _TOP_CATCHABLE_SIGNAL) { + posix_psignal(sig, + "WARNING: registering handler for a partially" + " or fully unsupported signal. This handler may only be" + " invoked by the raise() function, which may not be what" + " the application developer intended.\nSignal name"); + } + + fibril_mutex_lock(&_signal_mutex); + _sigaction_unsafe(sig, act, oact); + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * + * @param sig + * @param func + * @return + */ +void (*posix_signal(int sig, void (*func)(int)))(int) +{ + struct posix_sigaction new = { + .sa_handler = func, + .sa_mask = 0, + .sa_flags = 0, + .sa_sigaction = NULL + }; + struct posix_sigaction old; + if (posix_sigaction(sig, func == NULL ? NULL : &new, &old) == 0) { + return old.sa_handler; + } else { + return SIG_ERR; + } +} + +/** + * + * @param signo + * @param siginfo + * @return + */ +static int _raise_sigaction(int signo, posix_siginfo_t *siginfo) +{ + assert(signo >= 0 && signo <= _TOP_SIGNAL); + assert(siginfo != NULL); + + fibril_mutex_lock(&_signal_mutex); + + struct posix_sigaction action = _signal_actions[signo]; + + if (posix_sigismember(&_signal_mask, signo) || + action.sa_handler == SIG_HOLD) { + // TODO: queue signal + fibril_mutex_unlock(&_signal_mutex); + return -1; + } + + /* Modifying signal mask is unnecessary, + * signal handling is serialized. + */ + + if ((action.sa_flags & SA_RESETHAND) && signo != SIGILL && signo != SIGTRAP) { + _signal_actions[signo] = (struct posix_sigaction) DEFAULT_HANDLER; + }; + + if (action.sa_flags & SA_SIGINFO) { + assert(action.sa_sigaction != NULL); + action.sa_sigaction(signo, siginfo, NULL); + } else { + assert(action.sa_handler != NULL); + action.sa_handler(signo); + } + + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * + * @param sig + * @return + */ +int posix_raise(int sig) +{ + if (sig >= 0 && sig <= _TOP_SIGNAL) { + posix_siginfo_t siginfo = { + .si_signo = sig, + .si_code = SI_USER + }; + return _raise_sigaction(sig, &siginfo); + } else { + errno = EINVAL; + return -1; + } +} + +/** + * + * @param pid + * @param signo + * @return + */ +int posix_kill(posix_pid_t pid, int signo) +{ + if (pid < 1) { + // TODO + errno = ENOTSUP; + return -1; + } + + if (pid == (posix_pid_t) task_get_id()) { + return posix_raise(signo); + } + + if (pid > _TOP_SIGNAL) { + errno = EINVAL; + return -1; + } + + switch (signo) { + case SIGKILL: + task_kill(pid); + break; + default: + /* Nothing else supported yet. */ + errno = ENOTSUP; + return -1; + } + + return 0; +} + +/** + * + * @param pid + * @param sig + * @return + */ +int posix_killpg(posix_pid_t pid, int sig) +{ + assert(pid > 1); + return posix_kill(-pid, sig); +} + +/** + * + * @param pinfo + * @param message + */ +void posix_psiginfo(const posix_siginfo_t *pinfo, const char *message) +{ + assert(pinfo != NULL); + posix_psignal(pinfo->si_signo, message); + // TODO: print si_code +} + +/** + * + * @param signum + * @param message + */ +void posix_psignal(int signum, const char *message) +{ + char *sigmsg = posix_strsignal(signum); + if (message == NULL || *message == '\0') { + fprintf(stderr, "%s\n", sigmsg); + } else { + fprintf(stderr, "%s: %s\n", message, sigmsg); + } +} + +/** + * + * @param how + * @param set + * @param oset + * @return + */ +int posix_thread_sigmask(int how, const posix_sigset_t *restrict set, + posix_sigset_t *restrict oset) +{ + fibril_mutex_lock(&_signal_mutex); + + if (oset != NULL) { + *oset = _signal_mask; + } + if (set != NULL) { + switch (how) { + case SIG_BLOCK: + _signal_mask |= *set; + break; + case SIG_UNBLOCK: + _signal_mask &= ~*set; + break; + case SIG_SETMASK: + _signal_mask = *set; + break; + default: + fibril_mutex_unlock(&_signal_mutex); + return EINVAL; + } + } + + // TODO: queued signal handling + + fibril_mutex_unlock(&_signal_mutex); + + return 0; +} + +/** + * + * @param how + * @param set + * @param oset + * @return + */ +int posix_sigprocmask(int how, const posix_sigset_t *restrict set, + posix_sigset_t *restrict oset) +{ + int result = posix_thread_sigmask(how, set, oset); + if (result != 0) { + errno = result; + return -1; + } + return 0; +} + +/** @} + */ Index: uspace/lib/posix/signal.h =================================================================== --- uspace/lib/posix/signal.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/signal.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Signal handling. + */ + +#ifndef POSIX_SIGNAL_H_ +#define POSIX_SIGNAL_H_ + +// TODO: documentation + +#include "libc/errno.h" +#include "sys/types.h" + +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)) __posix_default_signal_handler) +#undef SIG_ERR +#define SIG_ERR ((void (*)(int)) NULL) +#undef SIG_HOLD +#define SIG_HOLD ((void (*)(int)) __posix_hold_signal_handler) +#undef SIG_IGN +#define SIG_IGN ((void (*)(int)) __posix_ignore_signal_handler) + +typedef int posix_sig_atomic_t; +typedef uint32_t posix_sigset_t; +typedef struct posix_mcontext { + // FIXME: should not be empty to avoid compiler warnings (-pedantic) + int dummy; +} posix_mcontext_t; + +union posix_sigval { + int sival_int; + void *sival_ptr; +}; + +struct posix_sigevent { + int sigev_notify; /* Notification type. */ + int sigev_signo; /* Signal number. */ + union posix_sigval sigev_value; /* Signal value. */ + void (*sigev_notify_function)(union posix_sigval); /* Notification function. */ + posix_thread_attr_t *sigev_notify_attributes; /* Notification attributes. */ +}; + +typedef struct { + int si_signo; + int si_code; + + int si_errno; + + posix_pid_t si_pid; + posix_uid_t si_uid; + void *si_addr; + int si_status; + + long si_band; + + union posix_sigval si_value; +} posix_siginfo_t; + +struct posix_sigaction { + void (*sa_handler)(int); + posix_sigset_t sa_mask; + int sa_flags; + void (*sa_sigaction)(int, posix_siginfo_t *, void *); +}; + +typedef struct { + void *ss_sp; + size_t ss_size; + int ss_flags; +} posix_stack_t; + +typedef struct posix_ucontext { + struct posix_ucontext *uc_link; + posix_sigset_t uc_sigmask; + posix_stack_t uc_stack; + posix_mcontext_t uc_mcontext; +} posix_ucontext_t; + +/* Values of posix_sigevent::sigev_notify */ +#undef SIGEV_NONE +#undef SIGEV_SIGNAL +#undef SIGEV_THREAD +#define SIGEV_NONE 0 +#define SIGEV_SIGNAL 0 +#define SIGEV_THREAD 0 + +#undef SIGRT_MIN +#undef SIGRT_MAX +#define SIGRT_MIN 0 +#define SIGRT_MAX 0 + +#undef SIG_BLOCK +#undef SIG_UNBLOCK +#undef SIG_SETMASK +#define SIG_BLOCK 0 +#define SIG_UNBLOCK 1 +#define SIG_SETMASK 2 + +#undef SA_NOCLDSTOP +#undef SA_ONSTACK +#undef SA_RESETHAND +#undef SA_RESTART +#undef SA_SIGINFO +#undef SA_NOCLDWAIT +#undef SA_NODEFER +#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 +#define SS_DISABLE 0 + +#undef MINSIGSTKSZ +#undef SIGSTKSZ +#define MINSIGSTKSZ 0 +#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, + SIGILL, + SIGSEGV, + + /* Other Exceptions - not supported */ + SIGSYS, + SIGXCPU, + SIGXFSZ, + + /* Debugging - not supported */ + SIGTRAP, + + /* Communication Signals - not supported */ + SIGHUP, + SIGPIPE, + SIGPOLL, /* obsolete */ + SIGURG, + + /* Terminal Signals - not supported */ + SIGTSTP, + SIGTTIN, + SIGTTOU, + + _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); + +#ifndef LIBPOSIX_INTERNAL + #define sig_atomic_t posix_sig_atomic_t + #define sigset_t posix_sigset_t + #define sigval posix_sigval + #ifndef sigevent + #define sigevent posix_sigevent + #endif + #define mcontext_t posix_mcontext_t + #define ucontext_t posix_ucontext_t + #define stack_t posix_stack_t + #define siginfo_t posix_siginfo_t + + #define sigaction posix_sigaction + + #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 + +#endif /* POSIX_SIGNAL_H_ */ + +/** @} + */ Index: uspace/lib/posix/stdbool.h =================================================================== --- uspace/lib/posix/stdbool.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdbool.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Boolean type and values. + */ + +#ifndef POSIX_STDBOOL_H_ +#define POSIX_STDBOOL_H_ + +// TODO: propose for inclusion in libc and drop bool.h, +// it's a very silly incompatibility with standard C + +#ifdef LIBC_BOOL_H_ + #error "You can't include bool.h and stdbool.h at the same time." +#endif +#define LIBC_BOOL_H_ + +#define bool _Bool +#define true 1 +#define false 0 +#define __bool_true_false_are_defined 1 + +#endif /* POSIX_STDBOOL_H_ */ Index: uspace/lib/posix/stddef.h =================================================================== --- uspace/lib/posix/stddef.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stddef.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard type definitions. + */ + +#ifndef POSIX_STDDEF_H_ +#define POSIX_STDDEF_H_ + +#include "libc/stddef.h" + +#ifndef NULL + #define NULL ((void *) 0) +#endif + +#define offsetof(type,member) ((size_t) &(((type *) 0)->member)) + +typedef ssize_t posix_ptrdiff_t; + +#ifndef LIBPOSIX_INTERNAL + #define ptrdiff_t posix_ptrdiff_t +#endif + +#endif /* POSIX_STDDEF_H_ */ + +/** @} + */ Index: uspace/lib/posix/stdint.h =================================================================== --- uspace/lib/posix/stdint.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdint.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Integer types. + */ + +#ifndef POSIX_STDINT_H_ +#define POSIX_STDINT_H_ + +#include "libc/stdint.h" + +#undef INT8_MAX +#undef INT8_MIN +#define INT8_MAX 127 +#define INT8_MIN (-128) + +#undef UINT8_MAX +#undef UINT8_MIN +#define UINT8_MAX 255 +#define UINT8_MIN 0 + +#undef INT16_MAX +#undef INT16_MIN +#define INT16_MAX 32767 +#define INT16_MIN (-32768) + +#undef UINT16_MAX +#undef UINT16_MIN +#define UINT16_MAX 65535 +#define UINT16_MIN 0 + +#undef INT32_MAX +#undef INT32_MIN +#define INT32_MAX 2147483647 +#define INT32_MIN (-INT32_MAX - 1) + +#undef UINT32_MAX +#undef UINT32_MIN +#define UINT32_MAX 4294967295U +#define UINT32_MIN 0U + +#undef INT64_MAX +#undef INT64_MIN +#define INT64_MAX 9223372036854775807LL +#define INT64_MIN (-INT64_MAX - 1LL) + +#undef UINT64_MAX +#undef UINT64_MIN +#define UINT64_MAX 18446744073709551615ULL +#define UINT64_MIN 0ULL + +#undef OFF64_MAX +#undef OFF64_MIN +#define OFF64_MAX INT64_MAX +#define OFF64_MIN INT64_MIN + +#undef AOFF64_MAX +#undef AOFF64_MIN +#define AOFF64_MAX UINT64_MAX +#define AOFF64_MIN UINT64_MIN + +#undef INTMAX_MIN +#undef INTMAX_MAX +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX + +#undef UINTMAX_MIN +#undef UINTMAX_MAX +#define UINTMAX_MIN UINT64_MIN +#define UINTMAX_MAX UINT64_MAX + +#include "libc/sys/types.h" + +typedef int64_t posix_intmax_t; +typedef uint64_t posix_uintmax_t; + +// FIXME: should be integrated into build process similarly to uintptr_t +typedef ssize_t posix_intptr_t; + +#ifndef LIBPOSIX_INTERNAL + #define intmax_t posix_intmax_t + #define uintmax_t posix_uintmax_t + + #define intptr_t posix_intptr_t +#endif + +#endif /* POSIX_STDINT_H_ */ + +/** @} + */ Index: uspace/lib/posix/stdio.c =================================================================== --- uspace/lib/posix/stdio.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdio.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,702 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard buffered input/output. + */ + +#define LIBPOSIX_INTERNAL + +/* Has to be first. */ +#include "stdbool.h" + +#include "internal/common.h" +#include "stdio.h" + +#include "assert.h" +#include "errno.h" +#include "string.h" +#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" + +/** Clears the stream's error and end-of-file indicators. + * + * @param stream Stream whose indicators shall be cleared. + */ +void posix_clearerr(FILE *stream) +{ + stream->error = 0; + stream->eof = 0; +} + +/** + * Generate a pathname for the controlling terminal. + * + * @param s Allocated buffer to which the pathname shall be put. + * @return Either s or static location filled with the requested pathname. + */ +char *posix_ctermid(char *s) +{ + /* Currently always returns an error value (empty string). */ + // TODO: return a real terminal path + + static char dummy_path[L_ctermid] = {'\0'}; + + if (s == NULL) { + return dummy_path; + } + + s[0] = '\0'; + return s; +} + +/** + * Put a string on the stream. + * + * @param s String to be written. + * @param stream Output stream. + * @return Non-negative on success, EOF on failure. + */ +int posix_fputs(const char *restrict s, FILE *restrict stream) +{ + int rc = fputs(s, stream); + if (rc == 0) { + return EOF; + } else { + return 0; + } +} + +/** + * Push byte back into input stream. + * + * @param c Byte to be pushed back. + * @param stream Stream to where the byte shall be pushed. + * @return Provided byte on success or EOF if not possible. + */ +int posix_ungetc(int c, FILE *stream) +{ + uint8_t b = (uint8_t) c; + + bool can_unget = + /* Provided character is legal. */ + c != EOF && + /* Stream is consistent. */ + !stream->error && + /* Stream is buffered. */ + stream->btype != _IONBF && + /* Last operation on the stream was a read operation. */ + stream->buf_state == _bs_read && + /* Stream buffer is already allocated (i.e. there was already carried + * out either write or read operation on the stream). This is probably + * redundant check but let's be safe. */ + stream->buf != NULL && + /* There is still space in the stream to retreat. POSIX demands the + * possibility to unget at least 1 character. It should be always + * possible, assuming the last operation on the stream read at least 1 + * character, because the buffer is refilled in the lazily manner. */ + stream->buf_tail > stream->buf; + + if (can_unget) { + --stream->buf_tail; + stream->buf_tail[0] = b; + stream->eof = false; + return (int) b; + } else { + return EOF; + } +} + +/** + * Read a stream until the delimiter (or EOF) is encountered. + * + * @param lineptr Pointer to the output buffer in which there will be stored + * nul-terminated string together with the delimiter (if encountered). + * Will be resized if necessary. + * @param n Pointer to the size of the output buffer. Will be increased if + * necessary. + * @param delimiter Delimiter on which to finish reading the stream. + * @param stream Input stream. + * @return Number of fetched characters (including delimiter if encountered) + * or -1 on error (set in errno). + */ +ssize_t posix_getdelim(char **restrict lineptr, size_t *restrict n, + int delimiter, FILE *restrict stream) +{ + /* Check arguments for sanity. */ + if (!lineptr || !n) { + errno = EINVAL; + return -1; + } + + size_t alloc_step = 80; /* Buffer size gain during reallocation. */ + char *pos = *lineptr; /* Next free byte of the output buffer. */ + size_t cnt = 0; /* Number of fetched characters. */ + int c = fgetc(stream); /* Current input character. Might be EOF. */ + + do { + /* Mask EOF as NUL to terminate string. */ + if (c == EOF) { + c = '\0'; + } + + /* Ensure there is still space left in the buffer. */ + if (pos == *lineptr + *n) { + *lineptr = realloc(*lineptr, *n + alloc_step); + if (*lineptr) { + pos = *lineptr + *n; + *n += alloc_step; + } else { + errno = ENOMEM; + return -1; + } + } + + /* Store the fetched character. */ + *pos = c; + + /* Fetch the next character according to the current character. */ + if (c != '\0') { + ++pos; + ++cnt; + if (c == delimiter) { + /* Delimiter was just stored. Provide EOF as the next + * character - it will be masked as NUL and output string + * will be properly terminated. */ + c = EOF; + } else { + /* Neither delimiter nor EOF were encountered. Just fetch + * the next character from the stream. */ + c = fgetc(stream); + } + } + } while (c != '\0'); + + if (errno == EOK && cnt > 0) { + return cnt; + } else { + /* Either some error occured or the stream was already at EOF. */ + return -1; + } +} + +/** + * Read a stream until the newline (or EOF) is encountered. + * + * @param lineptr Pointer to the output buffer in which there will be stored + * nul-terminated string together with the delimiter (if encountered). + * Will be resized if necessary. + * @param n Pointer to the size of the output buffer. Will be increased if + * necessary. + * @param stream Input stream. + * @return Number of fetched characters (including newline if encountered) + * or -1 on error (set in errno). + */ +ssize_t posix_getline(char **restrict lineptr, size_t *restrict n, + FILE *restrict stream) +{ + return posix_getdelim(lineptr, n, '\n', stream); +} + +/** + * Reopen a file stream. + * + * @param filename Pathname of a file to be reopened or NULL for changing + * the mode of the stream. + * @param mode Mode to be used for reopening the file or changing current + * mode of the stream. + * @param stream Current stream associated with the opened file. + * @return On success, either a stream of the reopened file or the provided + * stream with a changed mode. NULL otherwise. + */ +FILE *posix_freopen(const char *restrict filename, + const char *restrict mode, FILE *restrict stream) +{ + assert(mode != NULL); + assert(stream != NULL); + + if (filename == NULL) { + // TODO + + /* print error to stderr as well, to avoid hard to find problems + * with buggy apps that expect this to work + */ + fprintf(stderr, + "ERROR: Application wants to use freopen() to change mode of opened stream.\n" + " libposix does not support that yet, the application may function improperly.\n"); + errno = ENOTSUP; + return NULL; + } + + FILE* copy = malloc(sizeof(FILE)); + if (copy == NULL) { + errno = ENOMEM; + return NULL; + } + memcpy(copy, stream, sizeof(FILE)); + fclose(copy); /* copy is now freed */ + + copy = fopen(filename, mode); /* open new stream */ + if (copy == NULL) { + /* fopen() sets errno */ + return NULL; + } + + /* move the new stream to the original location */ + memcpy(stream, copy, sizeof (FILE)); + free(copy); + + /* update references in the file list */ + stream->link.next->prev = &stream->link; + stream->link.prev->next = &stream->link; + + return stream; +} + +/** + * + * @param buf + * @param size + * @param mode + * @return + */ +FILE *posix_fmemopen(void *restrict buf, size_t size, + const char *restrict mode) +{ + // TODO + not_implemented(); +} + +/** + * + * @param bufp + * @param sizep + * @return + */ +FILE *posix_open_memstream(char **bufp, size_t *sizep) +{ + // TODO + not_implemented(); +} + +/** + * Write error messages to standard error. + * + * @param s Error message. + */ +void posix_perror(const char *s) +{ + if (s == NULL || s[0] == '\0') { + fprintf(stderr, "%s\n", posix_strerror(errno)); + } else { + fprintf(stderr, "%s: %s\n", s, posix_strerror(errno)); + } +} + +struct _posix_fpos { + off64_t offset; +}; + +/** Restores stream a to position previously saved with fgetpos(). + * + * @param stream Stream to restore + * @param pos Position to restore + * @return Zero on success, non-zero (with errno set) on failure + */ +int posix_fsetpos(FILE *stream, const posix_fpos_t *pos) +{ + return fseek(stream, pos->offset, SEEK_SET); +} + +/** Saves the stream's position for later use by fsetpos(). + * + * @param stream Stream to save + * @param pos Place to store the position + * @return Zero on success, non-zero (with errno set) on failure + */ +int posix_fgetpos(FILE *restrict stream, posix_fpos_t *restrict pos) +{ + off64_t ret = ftell(stream); + if (ret != -1) { + pos->offset = ret; + return 0; + } else { + return -1; + } +} + +/** + * Reposition a file-position indicator in a stream. + * + * @param stream Stream to seek in. + * @param offset Direction and amount of bytes to seek. + * @param whence From where to seek. + * @return Zero on success, -1 otherwise. + */ +int posix_fseek(FILE *stream, long offset, int whence) +{ + return fseek(stream, (off64_t) offset, whence); +} + +/** + * Reposition a file-position indicator in a stream. + * + * @param stream Stream to seek in. + * @param offset Direction and amount of bytes to seek. + * @param whence From where to seek. + * @return Zero on success, -1 otherwise. + */ +int posix_fseeko(FILE *stream, posix_off_t offset, int whence) +{ + return fseek(stream, (off64_t) offset, whence); +} + +/** + * Discover current file offset in a stream. + * + * @param stream Stream for which the offset shall be retrieved. + * @return Current offset or -1 if not possible. + */ +long posix_ftell(FILE *stream) +{ + return (long) ftell(stream); +} + +/** + * Discover current file offset in a stream. + * + * @param stream Stream for which the offset shall be retrieved. + * @return Current offset or -1 if not possible. + */ +posix_off_t posix_ftello(FILE *stream) +{ + return (posix_off_t) ftell(stream); +} + +/** + * Discard prefetched data or write unwritten data. + * + * @param stream Stream that shall be flushed. + * @return Zero on success, EOF on failure. + */ +int posix_fflush(FILE *stream) +{ + int rc = fflush(stream); + if (rc < 0) { + errno = -rc; + return EOF; + } else { + return 0; + } +} + +/** + * Print formatted output to the opened file. + * + * @param fildes File descriptor of the opened file. + * @param format Format description. + * @return Either the number of printed characters or negative value on error. + */ +int posix_dprintf(int fildes, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vdprintf(fildes, format, list); + va_end(list); + return result; +} + +/** + * Write ordinary string to the opened file. + * + * @param str String to be written. + * @param size Size of the string (in bytes).. + * @param fd File descriptor of the opened file. + * @return The number of written characters. + */ +static int _dprintf_str_write(const char *str, size_t size, void *fd) +{ + ssize_t wr = write(*(int *) fd, str, size); + return str_nlength(str, wr); +} + +/** + * Write wide string to the opened file. + * + * @param str String to be written. + * @param size Size of the string (in bytes). + * @param fd File descriptor of the opened file. + * @return The number of written characters. + */ +static int _dprintf_wstr_write(const wchar_t *str, size_t size, void *fd) +{ + size_t offset = 0; + size_t chars = 0; + size_t sz; + char buf[4]; + + while (offset < size) { + sz = 0; + if (chr_encode(str[chars], buf, &sz, sizeof(buf)) != EOK) { + break; + } + + if (write(*(int *) fd, buf, sz) != (ssize_t) sz) { + break; + } + + chars++; + offset += sizeof(wchar_t); + } + + return chars; +} + +/** + * Print formatted output to the opened file. + * + * @param fildes File descriptor of the opened file. + * @param format Format description. + * @param ap Print arguments. + * @return Either the number of printed characters or negative value on error. + */ +int posix_vdprintf(int fildes, const char *restrict format, va_list ap) +{ + printf_spec_t spec = { + .str_write = _dprintf_str_write, + .wstr_write = _dprintf_wstr_write, + .data = &fildes + }; + + return printf_core(format, &spec, ap); +} + +/** + * Print formatted output to the string. + * + * @param s Output string. + * @param format Format description. + * @return Either the number of printed characters (excluding null byte) or + * negative value on error. + */ +int posix_sprintf(char *s, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vsprintf(s, format, list); + va_end(list); + return result; +} + +/** + * Print formatted output to the string. + * + * @param s Output string. + * @param format Format description. + * @param ap Print arguments. + * @return Either the number of printed characters (excluding null byte) or + * negative value on error. + */ +int posix_vsprintf(char *s, const char *restrict format, va_list ap) +{ + return vsnprintf(s, STR_NO_LIMIT, format, ap); +} + +/** + * Convert formatted input from the stream. + * + * @param stream Input stream. + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_fscanf(FILE *restrict stream, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vfscanf(stream, format, list); + va_end(list); + return result; +} + +/** + * Convert formatted input from the standard input. + * + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_scanf(const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vscanf(format, list); + va_end(list); + return result; +} + +/** + * Convert formatted input from the standard input. + * + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vscanf(const char *restrict format, va_list arg) +{ + return posix_vfscanf(stdin, format, arg); +} + +/** + * Convert formatted input from the string. + * + * @param s Input string. + * @param format Format description. + * @return The number of converted output items or EOF on failure. + */ +int posix_sscanf(const char *restrict s, const char *restrict format, ...) +{ + va_list list; + va_start(list, format); + int result = posix_vsscanf(s, format, list); + va_end(list); + return result; +} + +/** + * Acquire file stream for the thread. + * + * @param file File stream to lock. + */ +void posix_flockfile(FILE *file) +{ + /* dummy */ +} + +/** + * Acquire file stream for the thread (non-blocking). + * + * @param file File stream to lock. + * @return Zero for success and non-zero if the lock cannot be acquired. + */ +int posix_ftrylockfile(FILE *file) +{ + /* dummy */ + return 0; +} + +/** + * Relinquish the ownership of the locked file stream. + * + * @param file File stream to unlock. + */ +void posix_funlockfile(FILE *file) +{ + /* dummy */ +} + +/** + * Get a byte from a stream (thread-unsafe). + * + * @param stream Input file stream. + * @return Either read byte or EOF. + */ +int posix_getc_unlocked(FILE *stream) +{ + return getc(stream); +} + +/** + * Get a byte from the standard input stream (thread-unsafe). + * + * @return Either read byte or EOF. + */ +int posix_getchar_unlocked(void) +{ + return getchar(); +} + +/** + * Put a byte on a stream (thread-unsafe). + * + * @param c Byte to output. + * @param stream Output file stream. + * @return Either written byte or EOF. + */ +int posix_putc_unlocked(int c, FILE *stream) +{ + return putc(c, stream); +} + +/** + * Put a byte on the standard output stream (thread-unsafe). + * + * @param c Byte to output. + * @return Either written byte or EOF. + */ +int posix_putchar_unlocked(int c) +{ + return putchar(c); +} + +/** + * Remove a file. + * + * @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 + */ +char *posix_tmpnam(char *s) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */ Index: uspace/lib/posix/stdio.h =================================================================== --- uspace/lib/posix/stdio.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdio.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard buffered input/output. + */ + +#ifndef POSIX_STDIO_H_ +#define POSIX_STDIO_H_ + +#include "libc/stdio.h" +#include "sys/types.h" +#include "libc/stdarg.h" +#include "limits.h" + +/* Identifying the Terminal */ +#undef L_ctermid +#define L_ctermid PATH_MAX +extern char *posix_ctermid(char *s); + +/* Error Recovery */ +extern void posix_clearerr(FILE *stream); + +/* Input/Output */ +#undef putc +#define putc fputc +extern int posix_fputs(const char *restrict s, FILE *restrict stream); +#undef getc +#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 */ +extern FILE *posix_freopen(const char *restrict filename, + const char *restrict mode, FILE *restrict stream); +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); + +/* Flushing Buffers */ +extern int posix_fflush(FILE *stream); + +/* Formatted Output */ +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); + +/* Formatted Input */ +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 */ +extern int posix_remove(const char *path); + +/* Temporary Files */ +#undef L_tmpnam +#define L_tmpnam PATH_MAX +extern char *posix_tmpnam(char *s); + +#ifndef LIBPOSIX_INTERNAL + #define ctermid posix_ctermid + + #define clearerr posix_clearerr + + #define fputs posix_fputs + #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 fflush posix_fflush + + #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 + + #define tmpnam posix_tmpnam +#endif + +#endif /* POSIX_STDIO_H_ */ + +/** @} + */ Index: uspace/lib/posix/stdio/scanf.c =================================================================== --- uspace/lib/posix/stdio/scanf.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdio/scanf.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,1339 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Implementation of the scanf backend. + */ + +#define LIBPOSIX_INTERNAL + +/* Must be first. */ +#include "../stdbool.h" + +#include "../assert.h" +#include "../errno.h" + +#include "../stdio.h" +#include "../stdlib.h" +#include "../stddef.h" +#include "../string.h" +#include "../ctype.h" +#include "../sys/types.h" + +#include "../internal/common.h" +#include "../libc/malloc.h" + +/** Unified data type for possible data sources for scanf. */ +typedef union __data_source { + FILE *stream; /**< Input file stream. */ + const char *string; /**< Input string. */ +} _data_source; + +/** Internal state of the input provider. */ +enum { + /** Partly constructed but not yet functional. */ + _PROV_CONSTRUCTED, + /** Ready to serve any request. */ + _PROV_READY, + /** Cursor is temporarily lent to the external entity. No action is + * possible until the cursor is returned. */ + _PROV_CURSOR_LENT, +}; + +/** Universal abstraction over data input for scanf. */ +typedef struct __input_provider { + /** Source of data elements. */ + _data_source source; + /** How many elements was already processed. */ + int consumed; + /** How many elements was already fetched from the source. */ + int fetched; + /** Elements are fetched from the source in batches (e.g. by getline()) + * to allow using strtol/strtod family even on streams. */ + char *window; + /** Size of the current window. */ + size_t window_size; + /** Points to the next element to be processed inside the current window. */ + const char *cursor; + /** Internal state of the provider. */ + int state; + + /** Take control over data source. Finish initialization of the internal + * structures (e.g. allocation of window). */ + void (*capture)(struct __input_provider *); + /** Get a single element from the source and update the internal structures + * accordingly (e.g. greedy update of the window). Return -1 if the + * element cannot be obtained. */ + int (*pop)(struct __input_provider *); + /** Undo the most recent not-undone pop operation. Might be necesarry to + * flush current window and seek data source backwards. Return 0 if the + * pop history is exhausted, non-zero on success. */ + int (*undo)(struct __input_provider *); + /** Lend the cursor to the caller. */ + const char * (*borrow_cursor)(struct __input_provider *); + /** Take control over possibly incremented cursor and update the internal + * structures if necessary. */ + void (*return_cursor)(struct __input_provider *, const char *); + /** Release the control over the source. That is, synchronize any + * fetched but non-consumed elements (e.g. by seeking) and destruct + * internal structures (e.g. window deallocation). */ + void (*release)(struct __input_provider *); +} _input_provider; + +/** @see __input_provider */ +static void _capture_stream(_input_provider *self) +{ + assert(self->source.stream); + assert(self->state == _PROV_CONSTRUCTED); + /* Caller could already pre-allocated the window. */ + assert((self->window == NULL && self->window_size == 0) || + (self->window && self->window_size > 0)); + + /* Initialize internal structures. */ + self->consumed = 0; + ssize_t fetched = posix_getline( + &self->window, &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched = fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->fetched = 0; + self->cursor = NULL; + } + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _capture_string(_input_provider *self) +{ + assert(self->source.string); + assert(self->state == _PROV_CONSTRUCTED); + + /* Initialize internal structures. */ + self->consumed = 0; + self->fetched = posix_strlen(self->source.string); + self->window = (char *) self->source.string; + self->window_size = self->fetched + 1; + self->cursor = self->window; + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static int _pop_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->cursor) { + int c = *self->cursor; + ++self->consumed; + ++self->cursor; + /* Do we need to fetch a new line from the source? */ + if (*self->cursor == '\0') { + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched += fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->cursor = NULL; + } + } + return c; + } else { + /* Already at EOF. */ + return -1; + } +} + +/** @see __input_provider */ +static int _pop_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (*self->cursor != '\0') { + int c = *self->cursor; + ++self->consumed; + ++self->cursor; + return c; + } else { + /* String depleted. */ + return -1; + } +} + +/** @see __input_provider */ +static int _undo_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->consumed == 0) { + /* Undo history exhausted. */ + return 0; + } + + if (!self->cursor || self->window == self->cursor) { + /* Complex case. Either at EOF (cursor == NULL) or there is no more + * place to retreat to inside the window. Seek the source backwards + * and flush the window. Regarding the scanf, this could happend only + * when matching unbounded string (%s) or unbounded scanset (%[) not + * containing newline, while at the same time newline is the character + * that breaks the matching process. */ + int rc = posix_fseek( + self->source.stream, -1, SEEK_CUR); + if (rc == -1) { + /* Seek failed. */ + return 0; + } + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + assert(fetched == 1); + self->fetched = self->consumed + 1; + self->cursor = self->window; + } else { + /* Stream is broken. */ + return 0; + } + } else { + /* Simple case. Still inside window. */ + --self->cursor; + } + --self->consumed; + return 1; /* Success. */ +} + +/** @see __input_provider */ +static int _undo_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + if (self->consumed > 0) { + --self->consumed; + --self->cursor; + } else { + /* Undo history exhausted. */ + return 0; + } + return 1; /* Success. */ +} + +/** @see __input_provider */ +static const char *_borrow_cursor_universal(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + self->state = _PROV_CURSOR_LENT; + return self->cursor; +} + +/** @see __input_provider */ +static void _return_cursor_stream(_input_provider *self, const char *cursor) +{ + assert(self->state == _PROV_CURSOR_LENT); + + /* Check how much of the window did external entity consumed. */ + self->consumed += cursor - self->cursor; + self->cursor = cursor; + if (*self->cursor == '\0') { + /* Window was completely consumed, fetch new data. */ + ssize_t fetched = posix_getline(&self->window, + &self->window_size, self->source.stream); + if (fetched != -1) { + self->fetched += fetched; + self->cursor = self->window; + } else { + /* EOF encountered. */ + self->cursor = NULL; + } + } + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _return_cursor_string(_input_provider *self, const char *cursor) +{ + assert(self->state == _PROV_CURSOR_LENT); + + /* Check how much of the window did external entity consumed. */ + self->consumed += cursor - self->cursor; + self->cursor = cursor; + self->state = _PROV_READY; +} + +/** @see __input_provider */ +static void _release_stream(_input_provider *self) +{ + assert(self->state == _PROV_READY); + assert(self->consumed >= self->fetched); + + /* Try to correct the difference between the stream position and what was + * actually consumed. If it is not possible, continue anyway. */ + posix_fseek(self->source.stream, self->consumed - self->fetched, SEEK_CUR); + + /* Destruct internal structures. */ + self->fetched = 0; + self->cursor = NULL; + if (self->window) { + free(self->window); + self->window = NULL; + } + self->window_size = 0; + self->state = _PROV_CONSTRUCTED; +} + +/** @see __input_provider */ +static void _release_string(_input_provider *self) +{ + assert(self->state == _PROV_READY); + + /* Destruct internal structures. */ + self->fetched = 0; + self->cursor = NULL; + self->window = NULL; + self->window_size = 0; + self->state = _PROV_CONSTRUCTED; +} + +/** Length modifier values. */ +enum { + LMOD_NONE, + LMOD_hh, + LMOD_h, + LMOD_l, + LMOD_ll, + LMOD_j, + LMOD_z, + LMOD_t, + LMOD_L, + LMOD_p, /* Reserved for %p conversion. */ +}; + +/** + * Decides whether provided characters specify length modifier. If so, the + * recognized modifier is stored through provider pointer. + * + * @param c Candidate on the length modifier. + * @param _c Next character (might be NUL). + * @param modifier Pointer to the modifier value. + * @return Whether the modifier was recognized or not. + */ +static inline int is_length_mod(int c, int _c, int *modifier) +{ + assert(modifier); + + switch (c) { + case 'h': + /* Check whether the modifier was not already recognized. */ + if (*modifier == LMOD_NONE) { + *modifier = _c == 'h' ? LMOD_hh : LMOD_h; + } else { + /* Format string is invalid. Notify the caller. */ + *modifier = LMOD_NONE; + } + return 1; + case 'l': + if (*modifier == LMOD_NONE) { + *modifier = _c == 'l' ? LMOD_ll : LMOD_l; + } else { + *modifier = LMOD_NONE; + } + return 1; + case 'j': + *modifier = *modifier == LMOD_NONE ? LMOD_j : LMOD_NONE; + return 1; + case 'z': + *modifier = *modifier == LMOD_NONE ? LMOD_z : LMOD_NONE; + return 1; + case 't': + *modifier = *modifier == LMOD_NONE ? LMOD_t : LMOD_NONE; + return 1; + case 'L': + *modifier = *modifier == LMOD_NONE ? LMOD_L : LMOD_NONE; + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies integer conversion. If so, the + * semantics of the conversion is stored through provided pointers.. + * + * @param c Candidate on the integer conversion. + * @param is_unsigned Pointer to store whether the conversion is signed or not. + * @param base Pointer to store the base of the integer conversion. + * @return Whether the conversion was recognized or not. + */ +static inline int is_int_conv(int c, bool *is_unsigned, int *base) +{ + assert(is_unsigned && base); + + switch (c) { + case 'd': + *is_unsigned = false; + *base = 10; + return 1; + case 'i': + *is_unsigned = false; + *base = 0; + return 1; + case 'o': + *is_unsigned = true; + *base = 8; + return 1; + case 'u': + *is_unsigned = true; + *base = 10; + return 1; + case 'p': /* According to POSIX, %p modifier is implementation defined but + * must correspond to its printf counterpart. */ + case 'x': + case 'X': + *is_unsigned = true; + *base = 16; + return 1; + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies conversion of the floating + * point number. + * + * @param c Candidate on the floating point conversion. + * @return Whether the conversion was recognized or not. + */ +static inline int is_float_conv(int c) +{ + switch (c) { + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + return 1; + default: + return 0; + } +} + +/** + * Decides whether provided character specifies conversion of the character + * sequence. + * + * @param c Candidate on the character sequence conversion. + * @param modifier Pointer to store length modifier for wide chars. + * @return Whether the conversion was recognized or not. + */ +static inline int is_seq_conv(int c, int *modifier) +{ + assert(modifier); + + switch (c) { + case 'S': + *modifier = LMOD_l; + /* fallthrough */ + case 's': + return 1; + case 'C': + *modifier = LMOD_l; + /* fallthrough */ + case 'c': + return 1; + case '[': + return 1; + default: + return 0; + } +} + +/** + * Backend for the whole family of scanf functions. Uses input provider + * to abstract over differences between strings and streams. Should be + * POSIX compliant (apart from the not supported stuff). + * + * NOT SUPPORTED: locale (see strtold), wide chars, numbered output arguments + * + * @param in Input provider. + * @param fmt Format description. + * @param arg Output arguments. + * @return The number of converted output items or EOF on failure. + */ +static inline int _internal_scanf( + _input_provider *in, const char *restrict fmt, va_list arg) +{ + int c = -1; + int converted_cnt = 0; + bool converting = false; + bool matching_failure = false; + + bool assign_supress = false; + bool assign_alloc = false; + long width = -1; + int length_mod = LMOD_NONE; + bool int_conv_unsigned = false; + int int_conv_base = 0; + + /* Buffers allocated by scanf for optional 'm' specifier must be remembered + * to deallocaate them in case of an error. Because each of those buffers + * corresponds to one of the argument from va_list, there is an upper bound + * on the number of those arguments. In case of C99, this uppper bound is + * 127 arguments. */ + char *buffers[127]; + for (int i = 0; i < 127; ++i) { + buffers[i] = NULL; + } + int next_unused_buffer_idx = 0; + + in->capture(in); + + /* Interpret format string. Control shall prematurely jump from the cycle + * on input failure, matching failure or illegal format string. In order + * to keep error reporting simple enough and to keep input consistent, + * error condition shall be always manifested as jump from the cycle, + * not function return. Format string pointer shall be updated specifically + * for each sub-case (i.e. there shall be no loop-wide increment).*/ + while (*fmt) { + + if (converting) { + + /* Processing inside conversion specifier. Either collect optional + * parameters or execute the conversion. When the conversion + * is successfully completed, increment conversion count and switch + * back to normal mode. */ + if (*fmt == '*') { + /* Assignment-supression (optional). */ + if (assign_supress) { + /* Already set. Illegal format string. */ + break; + } + assign_supress = true; + ++fmt; + } else if (*fmt == 'm') { + /* Assignment-allocation (optional). */ + if (assign_alloc) { + /* Already set. Illegal format string. */ + break; + } + assign_alloc = true; + ++fmt; + } else if (*fmt == '$') { + /* Reference to numbered output argument. */ + // TODO + not_implemented(); + } else if (isdigit(*fmt)) { + /* Maximum field length (optional). */ + if (width != -1) { + /* Already set. Illegal format string. */ + break; + } + char *fmt_new = NULL; + width = posix_strtol(fmt, &fmt_new, 10); + if (width != 0) { + fmt = fmt_new; + } else { + /* Since POSIX requires width to be non-zero, it is + * sufficient to interpret zero width as error without + * referring to errno. */ + break; + } + } else if (is_length_mod(*fmt, *(fmt + 1), &length_mod)) { + /* Length modifier (optional). */ + if (length_mod == LMOD_NONE) { + /* Already set. Illegal format string. The actual detection + * is carried out in the is_length_mod(). */ + break; + } + if (length_mod == LMOD_hh || length_mod == LMOD_ll) { + /* Modifier was two characters long. */ + ++fmt; + } + ++fmt; + } else if (is_int_conv(*fmt, &int_conv_unsigned, &int_conv_base)) { + /* Integer conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (assign_alloc || length_mod == LMOD_L) { + /* Illegal format string. */ + break; + } + + /* Conversion of the integer with %p specifier needs special + * handling, because it is not allowed to have arbitrary + * length modifier. */ + if (*fmt == 'p') { + if (length_mod == LMOD_NONE) { + length_mod = LMOD_p; + } else { + /* Already set. Illegal format string. */ + break; + } + } + + /* First consume any white spaces, so we can borrow cursor + * from the input provider. This way, the cursor will either + * point to the non-white space while the input will be + * prefetched up to the newline (which is suitable for strtol), + * or the input will be at EOF. */ + do { + c = in->pop(in); + } while (isspace(c)); + + /* After skipping the white spaces, can we actually continue? */ + if (c == -1) { + /* Input failure. */ + break; + } else { + /* Everything is OK, just undo the last pop, so the cursor + * can be borrowed. */ + in->undo(in); + } + + const char *cur_borrowed = NULL; + const char *cur_limited = NULL; + char *cur_updated = NULL; + + /* Borrow the cursor. Until it is returned to the provider + * we cannot jump from the cycle, because it would leave + * the input inconsistent. */ + cur_borrowed = in->borrow_cursor(in); + + /* If the width is limited, the cursor horizont must be + * decreased accordingly. Otherwise the strtol could read more + * than allowed by width. */ + if (width != -1) { + cur_limited = posix_strndup(cur_borrowed, width); + } else { + cur_limited = cur_borrowed; + } + cur_updated = (char *) cur_limited; + + long long sres = 0; + unsigned long long ures = 0; + errno = 0; /* Reset errno to recognize error later. */ + /* Try to convert the integer. */ + if (int_conv_unsigned) { + ures = posix_strtoull(cur_limited, &cur_updated, int_conv_base); + } else { + sres = posix_strtoll(cur_limited, &cur_updated, int_conv_base); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (width != -1 && cur_limited != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_limited); + } + cur_limited = NULL; + cur_updated = NULL; + /* Return the cursor to the provider. Input consistency is again + * the job of the provider, so we can report errors from + * now on. */ + in->return_cursor(in, cur_borrowed); + cur_borrowed = NULL; + + /* Check whether the conversion was successful. */ + if (errno != EOK) { + matching_failure = true; + break; + } + + /* If not supressed, assign the converted integer into + * the next output argument. */ + if (!assign_supress) { + if (int_conv_unsigned) { + switch (length_mod) { + case LMOD_hh: ; /* Label cannot be part of declaration. */ + unsigned char *phh = va_arg(arg, unsigned char *); + *phh = (unsigned char) ures; + break; + case LMOD_h: ; + unsigned short *ph = va_arg(arg, unsigned short *); + *ph = (unsigned short) ures; + break; + case LMOD_NONE: ; + unsigned *pdef = va_arg(arg, unsigned *); + *pdef = (unsigned) ures; + break; + case LMOD_l: ; + unsigned long *pl = va_arg(arg, unsigned long *); + *pl = (unsigned long) ures; + break; + case LMOD_ll: ; + unsigned long long *pll = va_arg(arg, unsigned long long *); + *pll = (unsigned long long) ures; + break; + case LMOD_j: ; + posix_uintmax_t *pj = va_arg(arg, posix_uintmax_t *); + *pj = (posix_uintmax_t) ures; + break; + case LMOD_z: ; + size_t *pz = va_arg(arg, size_t *); + *pz = (size_t) ures; + break; + case LMOD_t: ; + // FIXME: What is unsigned counterpart of the ptrdiff_t? + size_t *pt = va_arg(arg, size_t *); + *pt = (size_t) ures; + break; + case LMOD_p: ; + void **pp = va_arg(arg, void **); + *pp = (void *) (uintptr_t) ures; + break; + default: + assert(false); + } + } else { + switch (length_mod) { + case LMOD_hh: ; /* Label cannot be part of declaration. */ + signed char *phh = va_arg(arg, signed char *); + *phh = (signed char) sres; + break; + case LMOD_h: ; + short *ph = va_arg(arg, short *); + *ph = (short) sres; + break; + case LMOD_NONE: ; + int *pdef = va_arg(arg, int *); + *pdef = (int) sres; + break; + case LMOD_l: ; + long *pl = va_arg(arg, long *); + *pl = (long) sres; + break; + case LMOD_ll: ; + long long *pll = va_arg(arg, long long *); + *pll = (long long) sres; + break; + case LMOD_j: ; + posix_intmax_t *pj = va_arg(arg, posix_intmax_t *); + *pj = (posix_intmax_t) sres; + break; + case LMOD_z: ; + ssize_t *pz = va_arg(arg, ssize_t *); + *pz = (ssize_t) sres; + break; + case LMOD_t: ; + posix_ptrdiff_t *pt = va_arg(arg, posix_ptrdiff_t *); + *pt = (posix_ptrdiff_t) sres; + break; + default: + assert(false); + } + } + ++converted_cnt; + } + + converting = false; + ++fmt; + } else if (is_float_conv(*fmt)) { + /* Floating point number conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (assign_alloc) { + /* Illegal format string. */ + break; + } + if (length_mod != LMOD_NONE && + length_mod != LMOD_l && + length_mod != LMOD_L) { + /* Illegal format string. */ + break; + } + + /* First consume any white spaces, so we can borrow cursor + * from the input provider. This way, the cursor will either + * point to the non-white space while the input will be + * prefetched up to the newline (which is suitable for strtof), + * or the input will be at EOF. */ + do { + c = in->pop(in); + } while (isspace(c)); + + /* After skipping the white spaces, can we actually continue? */ + if (c == -1) { + /* Input failure. */ + break; + } else { + /* Everything is OK, just undo the last pop, so the cursor + * can be borrowed. */ + in->undo(in); + } + + const char *cur_borrowed = NULL; + const char *cur_limited = NULL; + char *cur_updated = NULL; + + /* Borrow the cursor. Until it is returned to the provider + * we cannot jump from the cycle, because it would leave + * the input inconsistent. */ + cur_borrowed = in->borrow_cursor(in); + + /* If the width is limited, the cursor horizont must be + * decreased accordingly. Otherwise the strtof could read more + * than allowed by width. */ + if (width != -1) { + cur_limited = posix_strndup(cur_borrowed, width); + } else { + cur_limited = cur_borrowed; + } + cur_updated = (char *) cur_limited; + + float fres = 0.0; + double dres = 0.0; + long double ldres = 0.0; + errno = 0; /* Reset errno to recognize error later. */ + /* Try to convert the floating point nubmer. */ + switch (length_mod) { + case LMOD_NONE: + fres = posix_strtof(cur_limited, &cur_updated); + break; + case LMOD_l: + dres = posix_strtod(cur_limited, &cur_updated); + break; + case LMOD_L: + ldres = posix_strtold(cur_limited, &cur_updated); + break; + default: + assert(false); + } + + /* Update the cursor so it can be returned to the provider. */ + cur_borrowed += cur_updated - cur_limited; + if (width != -1 && cur_limited != NULL) { + /* Deallocate duplicated part of the cursor view. */ + free(cur_limited); + } + cur_limited = NULL; + cur_updated = NULL; + /* Return the cursor to the provider. Input consistency is again + * the job of the provider, so we can report errors from + * now on. */ + in->return_cursor(in, cur_borrowed); + cur_borrowed = NULL; + + /* Check whether the conversion was successful. */ + if (errno != EOK) { + matching_failure = true; + break; + } + + /* If nto supressed, assign the converted floating point number + * into the next output argument. */ + if (!assign_supress) { + switch (length_mod) { + case LMOD_NONE: ; /* Label cannot be part of declaration. */ + float *pf = va_arg(arg, float *); + *pf = fres; + break; + case LMOD_l: ; + double *pd = va_arg(arg, double *); + *pd = dres; + break; + case LMOD_L: ; + long double *pld = va_arg(arg, long double *); + *pld = ldres; + break; + default: + assert(false); + } + ++converted_cnt; + } + + converting = false; + ++fmt; + } else if (is_seq_conv(*fmt, &length_mod)) { + /* Character sequence conversion. */ + + /* Check sanity of optional parts of conversion specifier. */ + if (length_mod != LMOD_NONE && + length_mod != LMOD_l) { + /* Illegal format string. */ + break; + } + + if (length_mod == LMOD_l) { + /* Wide chars not supported. */ + // TODO + not_implemented(); + } + + int term_size = 1; /* Size of the terminator (0 or 1)). */ + if (*fmt == 'c') { + term_size = 0; + width = width == -1 ? 1 : width; + } + + if (*fmt == 's') { + /* Skip white spaces. */ + do { + c = in->pop(in); + } while (isspace(c)); + } else { + /* Fetch a single character. */ + c = in->pop(in); + } + + /* Check whether there is still input to read. */ + if (c == -1) { + /* Input failure. */ + break; + } + + /* Prepare scanset. */ + char terminate_on[256]; + for (int i = 0; i < 256; ++i) { + terminate_on[i] = 0; + } + if (*fmt == 'c') { + ++fmt; + } else if (*fmt == 's') { + terminate_on[' '] = 1; + terminate_on['\n'] = 1; + terminate_on['\t'] = 1; + terminate_on['\f'] = 1; + terminate_on['\r'] = 1; + terminate_on['\v'] = 1; + ++fmt; + } else { + assert(*fmt == '['); + bool not = false; + bool dash = false; + ++fmt; + /* Check for negation. */ + if (*fmt == '^') { + not = true; + ++fmt; + } + /* Check for escape sequences. */ + if (*fmt == '-' || *fmt == ']') { + terminate_on[(int) *fmt] = 1; + ++fmt; + } + /* Check for ordinary characters and ranges. */ + while (*fmt != '\0' && *fmt != ']') { + if (dash) { + for (char chr = *(fmt - 2); chr <= *fmt; ++chr) { + terminate_on[(int) chr] = 1; + } + dash = false; + } else if (*fmt == '-') { + dash = true; + } else { + terminate_on[(int) *fmt] = 1; + } + ++fmt; + } + /* Check for escape sequence. */ + if (dash == true) { + terminate_on['-'] = 1; + } + /* Check whether the specifier was correctly terminated.*/ + if (*fmt == '\0') { + /* Illegal format string. */ + break; + } else { + ++fmt; + } + /* Inverse the scanset if necessary. */ + if (not == false) { + for (int i = 0; i < 256; ++i) { + terminate_on[i] = terminate_on[i] ? 0 : 1; + } + } + } + + char * buf = NULL; + size_t buf_size = 0; + char * cur = NULL; + size_t alloc_step = 80; /* Buffer size gain during reallocation. */ + int my_buffer_idx = 0; + + /* Retrieve the buffer into which popped characters + * will be stored. */ + if (!assign_supress) { + if (assign_alloc) { + /* We must allocate our own buffer. */ + buf_size = + width == -1 ? alloc_step : (size_t) width + term_size; + buf = malloc(buf_size); + if (!buf) { + /* No memory. */ + break; + } + my_buffer_idx = next_unused_buffer_idx; + ++next_unused_buffer_idx; + buffers[my_buffer_idx] = buf; + cur = buf; + } else { + /* Caller provided its buffer. */ + buf = va_arg(arg, char *); + cur = buf; + buf_size = + width == -1 ? SIZE_MAX : (size_t) width + term_size; + } + } + + /* Match the string. The next character is already popped. */ + while ((width == -1 || width > 0) && c != -1 && !terminate_on[c]) { + + /* Check whether the buffer is still sufficiently large. */ + if (!assign_supress) { + /* Always reserve space for the null terminator. */ + if (cur == buf + buf_size - term_size) { + /* Buffer size must be increased. */ + buf = realloc(buf, buf_size + alloc_step); + if (buf) { + buffers[my_buffer_idx] = buf; + cur = buf + buf_size - term_size; + buf_size += alloc_step; + } else { + /* Break just from this tight loop. Errno will + * be checked after it. */ + break; + } + } + /* Store the input character. */ + *cur = c; + } + + width = width == -1 ? -1 : width - 1; + ++cur; + c = in->pop(in); + } + if (errno == ENOMEM) { + /* No memory. */ + break; + } + if (c != -1) { + /* There is still more input, so undo the last pop. */ + in->undo(in); + } + + /* Check for failures. */ + if (cur == buf) { + /* Matching failure. Input failure was already checked + * earlier. */ + matching_failure = true; + if (!assign_supress && assign_alloc) { + /* Roll back. */ + free(buf); + buffers[my_buffer_idx] = NULL; + --next_unused_buffer_idx; + } + break; + } + + /* Store the terminator. */ + if (!assign_supress && term_size > 0) { + /* Space for the terminator was reserved. */ + *cur = '\0'; + } + + /* Store the result if not already stored. */ + if (!assign_supress) { + if (assign_alloc) { + char **pbuf = va_arg(arg, char **); + *pbuf = buf; + } + ++converted_cnt; + } + + converting = false; + /* Format string pointer already incremented. */ + } else if (*fmt == 'n') { + /* Report the number of consumed bytes so far. */ + + /* Sanity check. */ + bool sane = + width == -1 && + length_mod == LMOD_NONE && + assign_alloc == false && + assign_supress == false; + + if (sane) { + int *pi = va_arg(arg, int *); + *pi = in->consumed; + } else { + /* Illegal format string. */ + break; + } + + /* This shall not be counted as conversion. */ + converting = false; + ++fmt; + } else { + /* Illegal format string. */ + break; + } + + } else { + + /* Processing outside conversion specifier. Either skip white + * spaces or match characters one by one. If conversion specifier + * is detected, switch to coversion mode. */ + if (isspace(*fmt)) { + /* Skip white spaces in the format string. */ + while (isspace(*fmt)) { + ++fmt; + } + /* Skip white spaces in the input. */ + do { + c = in->pop(in); + } while (isspace(c)); + if (c != -1) { + /* Input is not at EOF, so undo the last pop operation. */ + in->undo(in); + } + } else if (*fmt == '%' && *(fmt + 1) != '%') { + /* Conversion specifier detected. Switch modes. */ + converting = true; + /* Reset the conversion context. */ + assign_supress = false; + assign_alloc = false; + width = -1; + length_mod = LMOD_NONE; + int_conv_unsigned = false; + int_conv_base = 0; + ++fmt; + } else { + /* One by one matching. */ + if (*fmt == '%') { + /* Escape sequence detected. */ + ++fmt; + assert(*fmt == '%'); + } + c = in->pop(in); + if (c == -1) { + /* Input failure. */ + break; + } else if (c != *fmt) { + /* Matching failure. */ + in->undo(in); + matching_failure = true; + break; + } else { + ++fmt; + } + } + + } + + } + + in->release(in); + + /* This somewhat complicated return value decision is required by POSIX. */ + int rc; + if (matching_failure) { + rc = converted_cnt; + } else { + if (errno == EOK) { + rc = converted_cnt > 0 ? converted_cnt : EOF; + } else { + rc = EOF; + } + } + if (rc == EOF) { + /* Caller will not know how many arguments were successfully converted, + * so the deallocation of buffers is our responsibility. */ + for (int i = 0; i < next_unused_buffer_idx; ++i) { + free(buffers[i]); + buffers[i] = NULL; + } + next_unused_buffer_idx = 0; + } + return rc; +} + +/** + * Convert formatted input from the stream. + * + * @param stream Input stream. + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vfscanf( + FILE *restrict stream, const char *restrict format, va_list arg) +{ + _input_provider provider = { + { 0 }, 0, 0, NULL, 0, NULL, _PROV_CONSTRUCTED, + _capture_stream, _pop_stream, _undo_stream, + _borrow_cursor_universal, _return_cursor_stream, _release_stream + }; + provider.source.stream = stream; + return _internal_scanf(&provider, format, arg); +} + +/** + * Convert formatted input from the string. + * + * @param s Input string. + * @param format Format description. + * @param arg Output items. + * @return The number of converted output items or EOF on failure. + */ +int posix_vsscanf( + const char *restrict s, const char *restrict format, va_list arg) +{ + _input_provider provider = { + { 0 }, 0, 0, NULL, 0, NULL, _PROV_CONSTRUCTED, + _capture_string, _pop_string, _undo_string, + _borrow_cursor_universal, _return_cursor_string, _release_string + }; + provider.source.string = s; + return _internal_scanf(&provider, format, arg); +} + +// FIXME: put the testcases somewhere else + +#if 0 + +//#include +//#include +//#include + +#define test_val(fmt, exp_val, act_val) \ + if (exp_val == act_val) { \ + printf("succ, expected "fmt", actual "fmt"\n", exp_val, act_val); \ + } else { \ + printf("fail, expected "fmt", actual "fmt"\n", exp_val, act_val); \ + ++fail; \ + } + +#define test_str(fmt, exp_str, act_str) \ + if (posix_strcmp(exp_str, act_str) == 0) { \ + printf("succ, expected "fmt", actual "fmt"\n", exp_str, act_str); \ + } else { \ + printf("fail, expected "fmt", actual "fmt"\n", exp_str, act_str); \ + ++fail; \ + } + +void __posix_scanf_test(void); +void __posix_scanf_test(void) +{ + int fail = 0; + + int ret; + + unsigned char uhh; + signed char shh; + unsigned short uh; + short sh; + unsigned udef; + int sdef; + unsigned long ul; + long sl; + unsigned long long ull; + long long sll; + void *p; + + float f; + double d; + long double ld; + + char str[20]; + char seq[20]; + char scanset[20]; + + char *pstr; + char *pseq; + char *pscanset; + + ret = posix_sscanf( + "\n j tt % \t -121314 98765 aqw 0765 0x77 0xABCDEF88 -99 884", + " j tt %%%3hhd%1hhu%3hd %3hu%u aqw%n %lo%llx %p %li %lld", + &shh, &uhh, &sh, &uh, &udef, &sdef, &ul, &ull, &p, &sl, &sll); + test_val("%d", -12, shh); + test_val("%u", 1, uhh); + test_val("%d", 314, sh); + test_val("%u", 987, uh); + test_val("%u", 65, udef); + test_val("%d", 28, sdef); + test_val("%lo", (unsigned long) 0765, ul); + test_val("%llx", (unsigned long long) 0x77, ull); + test_val("%p", (void *) 0xABCDEF88, p); + test_val("%ld", (long) -99, sl); + test_val("%lld", (long long) 884, sll); + test_val("%d", 10, ret); + + ret = posix_sscanf( + "\n \t\t1.0 -0x555.AP10 1234.5678e12", + "%f %lf %Lf", + &f, &d, &ld); + test_val("%f", 1.0, f); + test_val("%lf", (double) -0x555.AP10, d); + test_val("%Lf", (long double) 1234.5678e12, ld); + test_val("%d", 3, ret); + + ret = posix_sscanf( + "\n\n\thello world \n", + "%5s %ms", + str, &pstr); + test_str("%s", "hello", str); + test_str("%s", "world", pstr); + test_val("%d", 2, ret); + free(pstr); + + ret = posix_sscanf( + "\n\n\thello world \n", + " %5c %mc", + seq, &pseq); + seq[5] = '\0'; + pseq[1] = '\0'; + test_str("%s", "hello", seq); + test_str("%s", "w", pseq); + test_val("%d", 2, ret); + free(pseq); + + ret = posix_sscanf( + "\n\n\th-e-l-l-o world-] \n", + " %9[-eh-o] %m[^]-]", + scanset, &pscanset); + test_str("%s", "h-e-l-l-o", scanset); + test_str("%s", "world", pscanset); + test_val("%d", 2, ret); + free(pscanset); + + printf("Failed: %d\n", fail); +} + +#endif + +/** @} + */ Index: uspace/lib/posix/stdlib.c =================================================================== --- uspace/lib/posix/stdlib.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdlib.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,412 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard library definitions. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "stdlib.h" + +#include "errno.h" +#include "limits.h" + +#include "libc/sort.h" +#include "libc/str.h" +#include "libc/vfs/vfs.h" + +/** + * + * @param array + * @param count + * @param size + * @param compare + */ +int posix_atexit(void (*func)(void)) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * Integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +int posix_abs(int i) +{ + return i < 0 ? -i : i; +} + +/** + * Long integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +long posix_labs(long i) +{ + return i < 0 ? -i : i; +} + +/** + * Long long integer absolute value. + * + * @param i Input value. + * @return Absolute value of the parameter. + */ +long long posix_llabs(long long i) +{ + return i < 0 ? -i : i; +} + +/** + * Compute the quotient and remainder of an integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_div_t posix_div(int numer, int denom) +{ + return (posix_div_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Compute the quotient and remainder of a long integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_ldiv_t posix_ldiv(long numer, long denom) +{ + return (posix_ldiv_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Compute the quotient and remainder of a long long integer division. + * + * @param numer Numerator. + * @param denom Denominator. + * @return Quotient and remainder packed into structure. + */ +posix_lldiv_t posix_lldiv(long long numer, long long denom) +{ + return (posix_lldiv_t) { .quot = numer / denom, .rem = numer % denom }; +} + +/** + * Private helper function that serves as a compare function for qsort(). + * + * @param elem1 First element to compare. + * @param elem2 Second element to compare. + * @param compare Comparison function without userdata parameter. + * @return Relative ordering of the elements. + */ +static int sort_compare_wrapper(void *elem1, void *elem2, void *userdata) +{ + int (*compare)(const void *, const void *) = userdata; + int ret = compare(elem1, elem2); + + /* Native qsort internals expect this. */ + if (ret < 0) { + return -1; + } else if (ret > 0) { + return 1; + } else { + return 0; + } +} + +/** + * Array sorting utilizing the quicksort algorithm. + * + * @param array Array of elements to sort. + * @param count Number of elements in the array. + * @param size Width of each element. + * @param compare Decides relative ordering of two elements. + */ +void posix_qsort(void *array, size_t count, size_t size, + int (*compare)(const void *, const void *)) +{ + /* Implemented in libc with one extra argument. */ + qsort(array, count, size, sort_compare_wrapper, compare); +} + +/** + * Binary search in a sorted array. + * + * @param key Object to search for. + * @param base Pointer to the first element of the array. + * @param nmemb Number of elements in the array. + * @param size Size of each array element. + * @param compar Comparison function. + * @return Pointer to a matching element, or NULL if none can be found. + */ +void *posix_bsearch(const void *key, const void *base, + size_t nmemb, size_t size, int (*compar)(const void *, const void *)) +{ + while (nmemb > 0) { + const void *middle = base + (nmemb / 2) * size; + int cmp = compar(key, middle); + if (cmp == 0) { + return (void *) middle; + } + if (middle == base) { + /* There is just one member left to check and it + * didn't match the key. Avoid infinite loop. + */ + break; + } + if (cmp < 0) { + nmemb = nmemb / 2; + } else if (cmp > 0) { + nmemb = nmemb - (nmemb / 2); + base = middle; + } + } + + return NULL; +} + +/** + * Retrieve a value of the given environment variable. + * + * Since HelenOS doesn't support env variables at the moment, + * this function always returns NULL. + * + * @param name Name of the variable. + * @return Value of the variable or NULL if such variable does not exist. + */ +char *posix_getenv(const char *name) +{ + return NULL; +} + +/** + * + * @param name + * @param resolved + * @return + */ +int posix_putenv(char *string) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * Issue a command. + * + * @param string String to be passed to a command interpreter or NULL. + * @return Termination status of the command if the command is not NULL, + * otherwise indicate whether there is a command interpreter (non-zero) + * or not (zero). + */ +int posix_system(const char *string) { + // TODO: does nothing at the moment + return 0; +} + +/** + * Resolve absolute pathname. + * + * @param name Pathname to be resolved. + * @param resolved Either buffer for the resolved absolute pathname or NULL. + * @return On success, either resolved (if it was not NULL) or pointer to the + * newly allocated buffer containing the absolute pathname (if resolved was + * NULL). Otherwise NULL. + * + */ +char *posix_realpath(const char *restrict name, char *restrict resolved) +{ + #ifndef PATH_MAX + assert(resolved == NULL); + #endif + + if (name == NULL) { + errno = EINVAL; + return NULL; + } + + // TODO: symlink resolution + + /* Function absolutize is implemented in libc and declared in vfs.h. + * No more processing is required as HelenOS doesn't have symlinks + * so far (as far as I can tell), although this function will need + * to be updated when that support is implemented. + */ + char* absolute = absolutize(name, NULL); + + if (absolute == NULL) { + /* POSIX requires some specific errnos to be set + * for some cases, but there is no way to find out from + * absolutize(). + */ + errno = EINVAL; + return NULL; + } + + if (resolved == NULL) { + return absolute; + } else { + #ifdef PATH_MAX + str_cpy(resolved, PATH_MAX, absolute); + #endif + free(absolute); + return resolved; + } +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @return Double-precision number resulting from the string conversion. + */ +double posix_atof(const char *nptr) +{ + return posix_strtod(nptr, NULL); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @return Single-precision number resulting from the string conversion. + */ +float posix_strtof(const char *restrict nptr, char **restrict endptr) +{ + return (float) posix_strtold(nptr, endptr); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. See posix_strtold(). + * + * @param nptr String representation of a floating-point number. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @return Double-precision number resulting from the string conversion. + */ +double posix_strtod(const char *restrict nptr, char **restrict endptr) +{ + return (double) posix_strtold(nptr, endptr); +} + +/** + * Allocate memory chunk. + * + * @param size Size of the chunk to allocate. + * @return Either pointer to the allocated chunk or NULL if not possible. + */ +void *posix_malloc(size_t size) +{ + return malloc(size); +} + +/** + * Allocate memory for an array of elements. + * + * @param nelem Number of elements in the array. + * @param elsize Size of each element. + * @return Either pointer to the allocated array or NULL if not possible. + */ +void *posix_calloc(size_t nelem, size_t elsize) +{ + return calloc(nelem, elsize); +} + +/** + * Reallocate memory chunk to a new size. + * + * @param ptr Memory chunk to reallocate. Might be NULL. + * @param size Size of the reallocated chunk. Might be zero. + * @return Either NULL or the pointer to the newly reallocated chunk. + */ +void *posix_realloc(void *ptr, size_t size) +{ + if (ptr != NULL && size == 0) { + /* Native realloc does not handle this special case. */ + free(ptr); + return NULL; + } else { + return realloc(ptr, size); + } +} + +/** + * Free allocated memory chunk. + * + * @param ptr Memory chunk to be freed. + */ +void posix_free(void *ptr) +{ + if (ptr) { + free(ptr); + } +} + +/** + * + * @param tmpl + * @return + */ +char *posix_mktemp(char *tmpl) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * Get system load average statistics. + * + * Not supported. Always returns -1. + * + * @param loadavg Array where the load averages shall be placed. + * @param nelem Maximum number of elements to be placed into the array. + * @return Number of elements placed into the array on success, -1 otherwise. + */ +int bsd_getloadavg(double loadavg[], int nelem) +{ + return -1; +} + +/** @} + */ Index: uspace/lib/posix/stdlib.h =================================================================== --- uspace/lib/posix/stdlib.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdlib.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Standard library definitions. + */ + +#ifndef POSIX_STDLIB_H_ +#define POSIX_STDLIB_H_ + +#include "libc/stdlib.h" + +#ifndef NULL + #define NULL ((void *) 0) +#endif + +/* Process Termination */ +#undef EXIT_FAILURE +#define EXIT_FAILURE 1 +#undef EXIT_SUCCESS +#define EXIT_SUCCESS 0 +#define _Exit exit +extern int posix_atexit(void (*func)(void)); + +/* Absolute Value */ +extern int posix_abs(int i); +extern long posix_labs(long i); +extern long long posix_llabs(long long i); + +/* Integer Division */ + +typedef struct { + int quot, rem; +} posix_div_t; + +typedef struct { + long quot, rem; +} posix_ldiv_t; + +typedef struct { + long long quot, rem; +} posix_lldiv_t; + +extern posix_div_t posix_div(int numer, int denom); +extern posix_ldiv_t posix_ldiv(long numer, long denom); +extern posix_lldiv_t posix_lldiv(long long numer, long long denom); + +/* Array Functions */ +extern void posix_qsort(void *array, size_t count, size_t size, + int (*compare)(const void *, const void *)); +extern void *posix_bsearch(const void *key, const void *base, + size_t nmemb, size_t size, int (*compar)(const void *, const void *)); + +/* Environment Access */ +extern char *posix_getenv(const char *name); +extern int posix_putenv(char *string); +extern int posix_system(const char *string); + +/* Symbolic Links */ +extern char *posix_realpath(const char *restrict name, char *restrict resolved); + +/* Floating Point Conversion */ +extern double posix_atof(const char *nptr); +extern float posix_strtof(const char *restrict nptr, char **restrict endptr); +extern double posix_strtod(const char *restrict nptr, char **restrict endptr); +extern long double posix_strtold(const char *restrict nptr, char **restrict endptr); + +/* Integer Conversion */ +extern int posix_atoi(const char *nptr); +extern long int posix_atol(const char *nptr); +extern long long int posix_atoll(const char *nptr); +extern long int posix_strtol(const char *restrict nptr, + char **restrict endptr, int base); +extern long long int posix_strtoll(const char *restrict nptr, + char **restrict endptr, int base); +extern unsigned long int posix_strtoul(const char *restrict nptr, + char **restrict endptr, int base); +extern unsigned long long int posix_strtoull( + const char *restrict nptr, char **restrict endptr, int base); + +/* Memory Allocation */ +extern void *posix_malloc(size_t size); +extern void *posix_calloc(size_t nelem, size_t elsize); +extern void *posix_realloc(void *ptr, size_t size); +extern void posix_free(void *ptr); + +/* Legacy Declarations */ +extern char *posix_mktemp(char *tmpl); +extern int bsd_getloadavg(double loadavg[], int nelem); + +#ifndef LIBPOSIX_INTERNAL + #define atexit posix_atexit + + #define abs posix_abs + #define labs posix_labs + #define llabs posix_llabs + + #define div_t posix_div_t + #define ldiv_t posix_ldiv_t + #define lldiv_t posix_lldiv_t + #define div posix_div + #define ldiv posix_ldiv + #define lldiv posix_lldiv + + #define qsort posix_qsort + #define bsearch posix_bsearch + + #define getenv posix_getenv + #define putenv posix_putenv + #define system posix_system + + #define realpath posix_realpath + + #define atof posix_atof + #define strtof posix_strtof + #define strtod posix_strtod + #define strtold posix_strtold + + #define atoi posix_atoi + #define atol posix_atol + #define atoll posix_atoll + #define strtol posix_strtol + #define strtoll posix_strtoll + #define strtoul posix_strtoul + #define strtoull posix_strtoull + + #define malloc posix_malloc + #define calloc posix_calloc + #define realloc posix_realloc + #define free posix_free + + #define mktemp posix_mktemp + #define getloadavg bsd_getloadavg +#endif + +#endif // POSIX_STDLIB_H_ + +/** @} + */ Index: uspace/lib/posix/stdlib/strtol.c =================================================================== --- uspace/lib/posix/stdlib/strtol.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdlib/strtol.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,399 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Backend for integer conversions. + */ + +#define LIBPOSIX_INTERNAL + +#include "../internal/common.h" +#include "../stdlib.h" + +#include "../ctype.h" +#include "../errno.h" +#include "../inttypes.h" +#include "../limits.h" + +#define intmax_t posix_intmax_t +#define uintmax_t posix_uintmax_t + +/** + * Decides whether a digit belongs to a particular base. + * + * @param c Character representation of the digit. + * @param base Base against which the digit shall be tested. + * @return True if the digit belongs to the base, false otherwise. + */ +static inline bool is_digit_in_base(int c, int base) +{ + if (base <= 10) { + return c >= '0' && c < '0' + base; + } else { + return isdigit(c) || + (tolower(c) >= 'a' && tolower(c) < ('a' + base - 10)); + } +} + +/** + * Derive a digit from its character representation. + * + * @param c Character representation of the digit. + * @return Digit value represented by an integer. + */ +static inline int digit_value(int c) +{ + if (c <= '9') { + return c - '0'; + } else { + return 10 + tolower(c) - 'a'; + } +} + +/** + * Generic function for parsing an integer from it's string representation. + * Different variants differ in lower and upper bounds. + * The parsed string returned by this function is always positive, sign + * information is provided via a dedicated parameter. + * + * @param nptr Input string. + * @param endptr If non-NULL, *endptr is set to the position of the first + * unrecognized character. If no digit has been parsed, value of + * nptr is stored there (regardless of any skipped characters at the + * beginning). + * @param base Expected base of the string representation. If 0, base is + * determined to be decimal, octal or hexadecimal using the same rules + * as C syntax. Otherwise, value must be between 2 and 36, inclusive. + * @param min_value Lower bound for the resulting conversion. + * @param max_value Upper bound for the resulting conversion. + * @param out_negative Either NULL for unsigned conversion or a pointer to the + * bool variable into which shall be placed the negativity of the resulting + * converted value. + * @return The absolute value of the parsed value, or the closest in-range value + * if the parsed value is out of range. If the input is invalid, zero is + * returned and errno is set to EINVAL. + */ +static inline uintmax_t internal_strtol( + const char *restrict nptr, char **restrict endptr, int base, + const intmax_t min_value, const uintmax_t max_value, + bool *restrict out_negative) +{ + if (nptr == NULL) { + errno = EINVAL; + return 0; + } + + if (base < 0 || base == 1 || base > 36) { + errno = EINVAL; + return 0; + } + + /* The maximal absolute value that can be returned in this run. + * Depends on sign. + */ + uintmax_t real_max_value = max_value; + + /* Current index in the input string. */ + size_t i = 0; + bool negative = false; + + /* Skip whitespace. */ + while (isspace(nptr[i])) { + i++; + } + + /* Parse sign. */ + switch (nptr[i]) { + case '-': + negative = true; + + /* The strange computation is are there to avoid a corner case + * where -min_value can't be represented in intmax_t. + * (I'm not exactly sure what the semantics are in such a + * case, but this should be safe for any case.) + */ + real_max_value = (min_value == 0) + ? 0 + :(((uintmax_t) -(min_value + 1)) + 1); + + /* fallthrough */ + case '+': + i++; + } + + /* Figure out the base. */ + switch (base) { + case 0: + if (nptr[i] == '0') { + if (tolower(nptr[i + 1]) == 'x') { + /* 0x... is hex. */ + base = 16; + i += 2; + } else { + /* 0... is octal. */ + base = 8; + } + } else { + /* Anything else is decimal by default. */ + base = 10; + } + break; + case 16: + /* Allow hex number to be prefixed with "0x". */ + if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x') { + i += 2; + } + break; + } + + if (!is_digit_in_base(nptr[i], base)) { + /* No digits to parse, invalid input. */ + + errno = EINVAL; + if (endptr != NULL) { + *endptr = (char *) nptr; + } + return 0; + } + + /* Maximal value to which a digit can be added without a risk + * of overflow. + */ + uintmax_t max_safe_value = (real_max_value - base + 1) / base; + + uintmax_t result = 0; + + if (real_max_value == 0) { + /* Special case when a negative number is parsed as + * unsigned integer. Only -0 is accepted. + */ + + while (is_digit_in_base(nptr[i], base)) { + if (nptr[i] != '0') { + errno = ERANGE; + result = 0; + } + i++; + } + } + + while (is_digit_in_base(nptr[i], base)) { + int digit = digit_value(nptr[i]); + + if (result > max_safe_value) { + /* corner case, check for overflow */ + + uintmax_t boundary = (real_max_value - digit) / base; + + if (result > boundary) { + /* overflow */ + errno = ERANGE; + result = real_max_value; + break; + } + } + + result = result * base + digit; + i++; + } + + if (endptr != NULL) { + /* Move the pointer to the end of the number, + * in case it isn't there already. + */ + while (is_digit_in_base(nptr[i], base)) { + i++; + } + + *endptr = (char *) &nptr[i]; + } + if (out_negative != NULL) { + *out_negative = negative; + } + return result; +} + +/** + * Convert a string to an integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +int posix_atoi(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, INT_MIN, INT_MAX, &neg); + + return (neg ? ((int) -result) : (int) result); +} + +/** + * Convert a string to a long integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +long posix_atol(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, LONG_MIN, LONG_MAX, &neg); + + return (neg ? ((long) -result) : (long) result); +} + +/** + * Convert a string to a long long integer. + * + * @param nptr Input string. + * @return Result of the conversion. + */ +long long posix_atoll(const char *nptr) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, NULL, 10, LLONG_MIN, LLONG_MAX, &neg); + + return (neg ? ((long long) -result) : (long long) result); +} + +/** + * Convert a string to a long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +long posix_strtol(const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, LONG_MIN, LONG_MAX, &neg); + + return (neg ? ((long) -result) : ((long) result)); +} + +/** + * Convert a string to a long long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +long long posix_strtoll( + const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, LLONG_MIN, LLONG_MAX, &neg); + + return (neg ? ((long long) -result) : (long long) result); +} + +/** + * Convert a string to a largest signed integer type. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +intmax_t posix_strtoimax( + const char *restrict nptr, char **restrict endptr, int base) +{ + bool neg = false; + uintmax_t result = + internal_strtol(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX, &neg); + + return (neg ? ((intmax_t) -result) : (intmax_t) result); +} + +/** + * Convert a string to an unsigned long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +unsigned long posix_strtoul( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, ULONG_MAX, NULL); + + return (unsigned long) result; +} + +/** + * Convert a string to an unsigned long long integer. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +unsigned long long posix_strtoull( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, ULLONG_MAX, NULL); + + return (unsigned long long) result; +} + +/** + * Convert a string to a largest unsigned integer type. + * + * @param nptr Input string. + * @param endptr Pointer to the final part of the string which + * was not used for conversion. + * @param base Expected base of the string representation. + * @return Result of the conversion. + */ +uintmax_t posix_strtoumax( + const char *restrict nptr, char **restrict endptr, int base) +{ + uintmax_t result = + internal_strtol(nptr, endptr, base, 0, UINTMAX_MAX, NULL); + + return result; +} + +/** @} + */ Index: uspace/lib/posix/stdlib/strtold.c =================================================================== --- uspace/lib/posix/stdlib/strtold.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/stdlib/strtold.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,491 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Backend for floating point conversions. + */ + +#define LIBPOSIX_INTERNAL + +/* Must be first. */ +#include "../stdbool.h" + +#include "../internal/common.h" +#include "../stdlib.h" + +#include "../assert.h" +#include "../ctype.h" +#include "../stdint.h" +#include "../strings.h" +#include "../errno.h" +#include "../limits.h" + +// FIXME: #include + +#ifndef HUGE_VALL + #define HUGE_VALL (+1.0l / +0.0l) +#endif + +#ifndef abs + #define abs(x) (((x) < 0) ? -(x) : (x)) +#endif + +/* If the constants are not defined, use double precision as default. */ +#ifndef LDBL_MANT_DIG + #define LDBL_MANT_DIG 53 +#endif +#ifndef LDBL_MAX_EXP + #define LDBL_MAX_EXP 1024 +#endif +#ifndef LDBL_MIN_EXP + #define LDBL_MIN_EXP (-1021) +#endif +#ifndef LDBL_DIG + #define LDBL_DIG 15 +#endif +#ifndef LDBL_MIN + #define LDBL_MIN 2.2250738585072014E-308 +#endif + +/* power functions ************************************************************/ + +#if LDBL_MAX_EXP >= 16384 +const int MAX_POW5 = 12; +#else +const int MAX_POW5 = 8; +#endif + +/* The value at index i is approximately 5**(2**i). */ +long double pow5[] = { + 0x5p0l, + 0x19p0l, + 0x271p0l, + 0x5F5E1p0l, + 0x2386F26FC1p0l, + 0x4EE2D6D415B85ACEF81p0l, + 0x184F03E93FF9F4DAA797ED6E38ED6p36l, + 0x127748F9301D319BF8CDE66D86D62p185l, + 0x154FDD7F73BF3BD1BBB77203731FDp482l, +#if LDBL_MAX_EXP >= 16384 + 0x1C633415D4C1D238D98CAB8A978A0p1076l, + 0x192ECEB0D02EA182ECA1A7A51E316p2265l, + 0x13D1676BB8A7ABBC94E9A519C6535p4643l, + 0x188C0A40514412F3592982A7F0094p9398l, +#endif +}; + +#if LDBL_MAX_EXP >= 16384 +const int MAX_POW2 = 15; +#else +const int MAX_POW2 = 9; +#endif + +/* Powers of two. */ +long double pow2[] = { + 0x1P1l, + 0x1P2l, + 0x1P4l, + 0x1P8l, + 0x1P16l, + 0x1P32l, + 0x1P64l, + 0x1P128l, + 0x1P256l, + 0x1P512l, +#if LDBL_MAX_EXP >= 16384 + 0x1P1024l, + 0x1P2048l, + 0x1P4096l, + 0x1P8192l, +#endif +}; + +/** + * Multiplies a number by a power of five. + * The result may be inexact and may not be the best possible approximation. + * + * @param mant Number to be multiplied. + * @param exp Base 5 exponent. + * @return mant multiplied by 5**exp + */ +static long double mul_pow5(long double mant, int exp) +{ + if (mant == 0.0l || mant == HUGE_VALL) { + return mant; + } + + if (abs(exp) >> (MAX_POW5 + 1) != 0) { + /* Too large exponent. */ + errno = ERANGE; + return exp < 0 ? LDBL_MIN : HUGE_VALL; + } + + if (exp < 0) { + exp = abs(exp); + for (int bit = 0; bit <= MAX_POW5; ++bit) { + /* Multiply by powers of five bit-by-bit. */ + if (((exp >> bit) & 1) != 0) { + mant /= pow5[bit]; + if (mant == 0.0l) { + /* Underflow. */ + mant = LDBL_MIN; + errno = ERANGE; + break; + } + } + } + } else { + for (int bit = 0; bit <= MAX_POW5; ++bit) { + /* Multiply by powers of five bit-by-bit. */ + if (((exp >> bit) & 1) != 0) { + mant *= pow5[bit]; + if (mant == HUGE_VALL) { + /* Overflow. */ + errno = ERANGE; + break; + } + } + } + } + + return mant; +} + +/** + * Multiplies a number by a power of two. This is always exact. + * + * @param mant Number to be multiplied. + * @param exp Base 2 exponent. + * @return mant multiplied by 2**exp. + */ +static long double mul_pow2(long double mant, int exp) +{ + if (mant == 0.0l || mant == HUGE_VALL) { + return mant; + } + + if (exp > LDBL_MAX_EXP || exp < LDBL_MIN_EXP) { + errno = ERANGE; + return exp < 0 ? LDBL_MIN : HUGE_VALL; + } + + if (exp < 0) { + exp = abs(exp); + for (int i = 0; i <= MAX_POW2; ++i) { + if (((exp >> i) & 1) != 0) { + mant /= pow2[i]; + if (mant == 0.0l) { + mant = LDBL_MIN; + errno = ERANGE; + break; + } + } + } + } else { + for (int i = 0; i <= MAX_POW2; ++i) { + if (((exp >> i) & 1) != 0) { + mant *= pow2[i]; + if (mant == HUGE_VALL) { + errno = ERANGE; + break; + } + } + } + } + + return mant; +} + +/* end power functions ********************************************************/ + + + +/** + * Convert decimal string representation of the floating point number. + * Function expects the string pointer to be already pointed at the first + * digit (i.e. leading optional sign was already consumed by the caller). + * + * @param sptr Pointer to the storage of the string pointer. Upon successful + * conversion, the string pointer is updated to point to the first + * unrecognized character. + * @return An approximate representation of the input floating-point number. + */ +static long double parse_decimal(const char **sptr) +{ + assert(sptr != NULL); + assert (*sptr != NULL); + + const int DEC_BASE = 10; + const char DECIMAL_POINT = '.'; + const char EXPONENT_MARK = 'e'; + + const char *str = *sptr; + long double significand = 0; + long exponent = 0; + + /* number of digits parsed so far */ + int parsed_digits = 0; + bool after_decimal = false; + + while (isdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) { + if (*str == DECIMAL_POINT) { + after_decimal = true; + str++; + continue; + } + + if (parsed_digits == 0 && *str == '0') { + /* Nothing, just skip leading zeros. */ + } else if (parsed_digits < LDBL_DIG) { + significand = significand * DEC_BASE + (*str - '0'); + parsed_digits++; + } else { + exponent++; + } + + if (after_decimal) { + /* Decrement exponent if we are parsing the fractional part. */ + exponent--; + } + + str++; + } + + /* exponent */ + if (tolower(*str) == EXPONENT_MARK) { + str++; + + /* Returns MIN/MAX value on error, which is ok. */ + long exp = strtol(str, (char **) &str, DEC_BASE); + + if (exponent > 0 && exp > LONG_MAX - exponent) { + exponent = LONG_MAX; + } else if (exponent < 0 && exp < LONG_MIN - exponent) { + exponent = LONG_MIN; + } else { + exponent += exp; + } + } + + *sptr = str; + + /* Return multiplied by a power of ten. */ + return mul_pow2(mul_pow5(significand, exponent), exponent); +} + +/** + * Derive a hexadecimal digit from its character representation. + * + * @param ch Character representation of the hexadecimal digit. + * @return Digit value represented by an integer. + */ +static inline int hex_value(char ch) +{ + if (ch <= '9') { + return ch - '0'; + } else { + return 10 + tolower(ch) - 'a'; + } +} + +/** + * Convert hexadecimal string representation of the floating point number. + * Function expects the string pointer to be already pointed at the first + * digit (i.e. leading optional sign and 0x prefix were already consumed + * by the caller). + * + * @param sptr Pointer to the storage of the string pointer. Upon successful + * conversion, the string pointer is updated to point to the first + * unrecognized character. + * @return Representation of the input floating-point number. + */ +static long double parse_hexadecimal(const char **sptr) +{ + assert(sptr != NULL && *sptr != NULL); + + const int DEC_BASE = 10; + const int HEX_BASE = 16; + const char DECIMAL_POINT = '.'; + const char EXPONENT_MARK = 'p'; + + const char *str = *sptr; + long double significand = 0; + long exponent = 0; + + /* number of bits parsed so far */ + int parsed_bits = 0; + bool after_decimal = false; + + while (posix_isxdigit(*str) || (!after_decimal && *str == DECIMAL_POINT)) { + if (*str == DECIMAL_POINT) { + after_decimal = true; + str++; + continue; + } + + if (parsed_bits == 0 && *str == '0') { + /* Nothing, just skip leading zeros. */ + } else if (parsed_bits <= LDBL_MANT_DIG) { + significand = significand * HEX_BASE + hex_value(*str); + parsed_bits += 4; + } else { + exponent += 4; + } + + if (after_decimal) { + exponent -= 4; + } + + str++; + } + + /* exponent */ + if (tolower(*str) == EXPONENT_MARK) { + str++; + + /* Returns MIN/MAX value on error, which is ok. */ + long exp = strtol(str, (char **) &str, DEC_BASE); + + if (exponent > 0 && exp > LONG_MAX - exponent) { + exponent = LONG_MAX; + } else if (exponent < 0 && exp < LONG_MIN - exponent) { + exponent = LONG_MIN; + } else { + exponent += exp; + } + } + + *sptr = str; + + /* Return multiplied by a power of two. */ + return mul_pow2(significand, exponent); +} + +/** + * Converts a string representation of a floating-point number to + * its native representation. Largely POSIX compliant, except for + * locale differences (always uses '.' at the moment) and rounding. + * Decimal strings are NOT guaranteed to be correctly rounded. This function + * should return a good enough approximation for most purposes but if you + * depend on a precise conversion, use hexadecimal representation. + * Hexadecimal strings are currently always rounded towards zero, regardless + * of the current rounding mode. + * + * @param nptr Input string. + * @param endptr If non-NULL, *endptr is set to the position of the first + * unrecognized character. + * @return An approximate representation of the input floating-point number. + */ +long double posix_strtold(const char *restrict nptr, char **restrict endptr) +{ + assert(nptr != NULL); + + const int RADIX = '.'; + + /* minus sign */ + bool negative = false; + /* current position in the string */ + int i = 0; + + /* skip whitespace */ + while (isspace(nptr[i])) { + i++; + } + + /* parse sign */ + switch (nptr[i]) { + case '-': + negative = true; + /* fallthrough */ + case '+': + i++; + } + + /* check for NaN */ + if (posix_strncasecmp(&nptr[i], "nan", 3) == 0) { + // FIXME: return NaN + // TODO: handle the parenthesised case + + if (endptr != NULL) { + *endptr = (char *) nptr; + } + errno = EINVAL; + return 0; + } + + /* check for Infinity */ + if (posix_strncasecmp(&nptr[i], "inf", 3) == 0) { + i += 3; + if (posix_strncasecmp(&nptr[i], "inity", 5) == 0) { + i += 5; + } + + if (endptr != NULL) { + *endptr = (char *) &nptr[i]; + } + return negative ? -HUGE_VALL : +HUGE_VALL; + } + + /* check for a hex number */ + if (nptr[i] == '0' && tolower(nptr[i + 1]) == 'x' && + (posix_isxdigit(nptr[i + 2]) || + (nptr[i + 2] == RADIX && posix_isxdigit(nptr[i + 3])))) { + i += 2; + + const char *ptr = &nptr[i]; + /* this call sets errno if appropriate. */ + long double result = parse_hexadecimal(&ptr); + if (endptr != NULL) { + *endptr = (char *) ptr; + } + return negative ? -result : result; + } + + /* check for a decimal number */ + if (isdigit(nptr[i]) || (nptr[i] == RADIX && isdigit(nptr[i + 1]))) { + const char *ptr = &nptr[i]; + /* this call sets errno if appropriate. */ + long double result = parse_decimal(&ptr); + if (endptr != NULL) { + *endptr = (char *) ptr; + } + return negative ? -result : result; + } + + /* nothing to parse */ + if (endptr != NULL) { + *endptr = (char *) nptr; + } + errno = EINVAL; + return 0; +} + +/** @} + */ Index: uspace/lib/posix/string.c =================================================================== --- uspace/lib/posix/string.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/string.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,667 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file String manipulation. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "string.h" + +#include "assert.h" +#include "errno.h" +#include "limits.h" +#include "stdlib.h" +#include "signal.h" + +#include "libc/str_error.h" + +/** + * Decides whether s2 is a prefix of s1. + * + * @param s1 String in which to look for a prefix. + * @param s2 Prefix string to look for. + * @return True if s2 is a prefix of s1, false otherwise. + */ +static bool begins_with(const char *s1, const char *s2) +{ + while (*s1 == *s2 && *s2 != '\0') { + s1++; + s2++; + } + + /* true if the end was reached */ + return *s2 == '\0'; +} + +/** + * The same as strpbrk, except it returns pointer to the nul terminator + * if no occurence is found. + * + * @param s1 String in which to look for the bytes. + * @param s2 String of bytes to look for. + * @return Pointer to the found byte on success, pointer to the + * string terminator otherwise. + */ +static char *strpbrk_null(const char *s1, const char *s2) +{ + while (!posix_strchr(s2, *s1)) { + ++s1; + } + + return (char *) s1; +} + +/** + * Copy a string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @return Pointer to the destination buffer. + */ +char *posix_strcpy(char *restrict dest, const char *restrict src) +{ + posix_stpcpy(dest, src); + return dest; +} + +/** + * Copy fixed length string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @param n Number of bytes to be stored into destination buffer. + * @return Pointer to the destination buffer. + */ +char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n) +{ + posix_stpncpy(dest, src, n); + return dest; +} + +/** + * Copy a string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @return Pointer to the nul character in the destination string. + */ +char *posix_stpcpy(char *restrict dest, const char *restrict src) +{ + assert(dest != NULL); + assert(src != NULL); + + for (size_t i = 0; ; ++i) { + dest[i] = src[i]; + + if (src[i] == '\0') { + /* pointer to the terminating nul character */ + return &dest[i]; + } + } + + /* unreachable */ + return NULL; +} + +/** + * Copy fixed length string. + * + * @param dest Destination pre-allocated buffer. + * @param src Source string to be copied. + * @param n Number of bytes to be stored into destination buffer. + * @return Pointer to the first written nul character or &dest[n]. + */ +char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + for (size_t i = 0; i < n; ++i) { + dest[i] = src[i]; + + /* the standard requires that nul characters + * are appended to the length of n, in case src is shorter + */ + if (src[i] == '\0') { + char *result = &dest[i]; + for (++i; i < n; ++i) { + dest[i] = '\0'; + } + return result; + } + } + + return &dest[n]; +} + +/** + * Concatenate two strings. + * + * @param dest String to which src shall be appended. + * @param src String to be appended after dest. + * @return Pointer to destination buffer. + */ +char *posix_strcat(char *restrict dest, const char *restrict src) +{ + assert(dest != NULL); + assert(src != NULL); + + posix_strcpy(posix_strchr(dest, '\0'), src); + return dest; +} + +/** + * Concatenate a string with part of another. + * + * @param dest String to which part of src shall be appended. + * @param src String whose part shall be appended after dest. + * @param n Number of bytes to append after dest. + * @return Pointer to destination buffer. + */ +char *posix_strncat(char *restrict dest, const char *restrict src, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + char *zeroptr = posix_strncpy(posix_strchr(dest, '\0'), src, n); + /* strncpy doesn't append the nul terminator, so we do it here */ + zeroptr[n] = '\0'; + return dest; +} + +/** + * Copy limited number of bytes in memory. + * + * @param dest Destination buffer. + * @param src Source buffer. + * @param c Character after which the copying shall stop. + * @param n Number of bytes that shall be copied if not stopped earlier by c. + * @return Pointer to the first byte after c in dest if found, NULL otherwise. + */ +void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n) +{ + assert(dest != NULL); + assert(src != NULL); + + unsigned char* bdest = dest; + const unsigned char* bsrc = src; + + for (size_t i = 0; i < n; ++i) { + bdest[i] = bsrc[i]; + + if (bsrc[i] == (unsigned char) c) { + /* pointer to the next byte */ + return &bdest[i + 1]; + } + } + + return NULL; +} + +/** + * Duplicate a string. + * + * @param s String to be duplicated. + * @return Newly allocated copy of the string. + */ +char *posix_strdup(const char *s) +{ + return posix_strndup(s, SIZE_MAX); +} + +/** + * Duplicate a specific number of bytes from a string. + * + * @param s String to be duplicated. + * @param n Maximum length of the resulting string.. + * @return Newly allocated string copy of length at most n. + */ +char *posix_strndup(const char *s, size_t n) +{ + assert(s != NULL); + + size_t len = posix_strnlen(s, n); + char *dup = malloc(len + 1); + if (dup == NULL) { + return NULL; + } + + memcpy(dup, s, len); + dup[len] = '\0'; + + return dup; +} + +/** + * Compare bytes in memory. + * + * @param mem1 First area of memory to be compared. + * @param mem2 Second area of memory to be compared. + * @param n Maximum number of bytes to be compared. + * @return Difference of the first pair of inequal bytes, + * or 0 if areas have the same content. + */ +int posix_memcmp(const void *mem1, const void *mem2, size_t n) +{ + assert(mem1 != NULL); + assert(mem2 != NULL); + + const unsigned char *s1 = mem1; + const unsigned char *s2 = mem2; + + for (size_t i = 0; i < n; ++i) { + if (s1[i] != s2[i]) { + return s1[i] - s2[i]; + } + } + + return 0; +} + +/** + * Compare two strings. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcmp(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + return posix_strncmp(s1, s2, STR_NO_LIMIT); +} + +/** + * Compare part of two strings. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @param n Maximum number of characters to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strncmp(const char *s1, const char *s2, size_t n) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + for (size_t i = 0; i < n; ++i) { + if (s1[i] != s2[i]) { + return s1[i] - s2[i]; + } + if (s1[i] == '\0') { + break; + } + } + + return 0; +} + +/** + * Find byte in memory. + * + * @param mem Memory area in which to look for the byte. + * @param c Byte to look for. + * @param n Maximum number of bytes to be inspected. + * @return Pointer to the specified byte on success, + * NULL pointer otherwise. + */ +void *posix_memchr(const void *mem, int c, size_t n) +{ + assert(mem != NULL); + + const unsigned char *s = mem; + + for (size_t i = 0; i < n; ++i) { + if (s[i] == (unsigned char) c) { + return (void *) &s[i]; + } + } + return NULL; +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_strchr(const char *s, int c) +{ + assert(s != NULL); + + char *res = gnu_strchrnul(s, c); + return (*res == c) ? res : NULL; +} + +/** + * Scan string for a last occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_strrchr(const char *s, int c) +{ + assert(s != NULL); + + const char *ptr = posix_strchr(s, '\0'); + + /* the same as in strchr, except it loops in reverse direction */ + while (*ptr != (char) c) { + if (ptr == s) { + return NULL; + } + + ptr--; + } + + return (char *) ptr; +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, pointer to the + * string terminator otherwise. + */ +char *gnu_strchrnul(const char *s, int c) +{ + assert(s != NULL); + + while (*s != c && *s != '\0') { + s++; + } + + return (char *) s; +} + +/** + * Scan a string for a first occurence of one of provided bytes. + * + * @param s1 String in which to look for the bytes. + * @param s2 String of bytes to look for. + * @return Pointer to the found byte on success, + * NULL pointer otherwise. + */ +char *posix_strpbrk(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + char *ptr = strpbrk_null(s1, s2); + return (*ptr == '\0') ? NULL : ptr; +} + +/** + * Get the length of a complementary substring. + * + * @param s1 String that shall be searched for complementary prefix. + * @param s2 String of bytes that shall not occur in the prefix. + * @return Length of the prefix. + */ +size_t posix_strcspn(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + char *ptr = strpbrk_null(s1, s2); + return (size_t) (ptr - s1); +} + +/** + * Get length of a substring. + * + * @param s1 String that shall be searched for prefix. + * @param s2 String of bytes that the prefix must consist of. + * @return Length of the prefix. + */ +size_t posix_strspn(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + const char *ptr; + for (ptr = s1; *ptr != '\0'; ++ptr) { + if (!posix_strchr(s2, *ptr)) { + break; + } + } + return ptr - s1; +} + +/** + * Find a substring. + * + * @param s1 String in which to look for a substring. + * @param s2 Substring to look for. + * @return Pointer to the first character of the substring in s1, or NULL if + * not found. + */ +char *posix_strstr(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + /* special case - needle is an empty string */ + if (*s2 == '\0') { + return (char *) s1; + } + + // TODO: use faster algorithm + /* check for prefix from every position - quadratic complexity */ + while (*s1 != '\0') { + if (begins_with(s1, s2)) { + return (char *) s1; + } + + s1++; + } + + return NULL; +} + +/** + * String comparison using collating information. + * + * Currently ignores locale and just calls strcmp. + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcoll(const char *s1, const char *s2) +{ + assert(s1 != NULL); + assert(s2 != NULL); + + return posix_strcmp(s1, s2); +} + +/** + * Transform a string in such a way that the resulting string yields the same + * results when passed to the strcmp as if the original string is passed to + * the strcoll. + * + * Since strcoll is equal to strcmp here, this just makes a copy. + * + * @param s1 Transformed string. + * @param s2 Original string. + * @param n Maximum length of the transformed string. + * @return Length of the transformed string. + */ +size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n) +{ + assert(s1 != NULL || n == 0); + assert(s2 != NULL); + + size_t len = posix_strlen(s2); + + if (n > len) { + posix_strcpy(s1, s2); + } + + return len; +} + +/** + * Get error message string. + * + * @param errnum Error code for which to obtain human readable string. + * @return Error message. + */ +char *posix_strerror(int errnum) +{ + /* Uses function from libc, we just have to negate errno + * (POSIX uses positive errorcodes, HelenOS has negative). + */ + // FIXME: not all POSIX error codes are in libc + return (char *) str_error(-posix_abs(errnum)); +} + +/** + * Get error message string. + * + * @param errnum Error code for which to obtain human readable string. + * @param buf Buffer to store a human readable string to. + * @param bufsz Size of buffer pointed to by buf. + * @return Zero on success, errno otherwise. + */ +int posix_strerror_r(int errnum, char *buf, size_t bufsz) +{ + assert(buf != NULL); + + char *errstr = posix_strerror(errnum); + /* HelenOS str_error can't fail */ + + if (posix_strlen(errstr) + 1 > bufsz) { + return -ERANGE; + } else { + posix_strcpy(buf, errstr); + } + + return 0; +} + +/** + * Get length of the string. + * + * @param s String which length shall be determined. + * @return Length of the string. + */ +size_t posix_strlen(const char *s) +{ + assert(s != NULL); + + return (size_t) (posix_strchr(s, '\0') - s); +} + +/** + * Get limited length of the string. + * + * @param s String which length shall be determined. + * @param n Maximum number of bytes that can be examined to determine length. + * @return The lower of either string length or n limit. + */ +size_t posix_strnlen(const char *s, size_t n) +{ + assert(s != NULL); + + for (size_t sz = 0; sz < n; ++sz) { + + if (s[sz] == '\0') { + return sz; + } + } + + return n; +} + +/** + * Get description of a signal. + * + * @param signum Signal number. + * @return Human readable signal description. + */ +char *posix_strsignal(int signum) +{ + static const char *const sigstrings[] = { + [SIGABRT] = "SIGABRT (Process abort signal)", + [SIGALRM] = "SIGALRM (Alarm clock)", + [SIGBUS] = "SIGBUS (Access to an undefined portion of a memory object)", + [SIGCHLD] = "SIGCHLD (Child process terminated, stopped, or continued)", + [SIGCONT] = "SIGCONT (Continue executing, if stopped)", + [SIGFPE] = "SIGFPE (Erroneous arithmetic operation)", + [SIGHUP] = "SIGHUP (Hangup)", + [SIGILL] = "SIGILL (Illegal instruction)", + [SIGINT] = "SIGINT (Terminal interrupt signal)", + [SIGKILL] = "SIGKILL (Kill process)", + [SIGPIPE] = "SIGPIPE (Write on a pipe with no one to read it)", + [SIGQUIT] = "SIGQUIT (Terminal quit signal)", + [SIGSEGV] = "SIGSEGV (Invalid memory reference)", + [SIGSTOP] = "SIGSTOP (Stop executing)", + [SIGTERM] = "SIGTERM (Termination signal)", + [SIGTSTP] = "SIGTSTP (Terminal stop signal)", + [SIGTTIN] = "SIGTTIN (Background process attempting read)", + [SIGTTOU] = "SIGTTOU (Background process attempting write)", + [SIGUSR1] = "SIGUSR1 (User-defined signal 1)", + [SIGUSR2] = "SIGUSR2 (User-defined signal 2)", + [SIGPOLL] = "SIGPOLL (Pollable event)", + [SIGPROF] = "SIGPROF (Profiling timer expired)", + [SIGSYS] = "SIGSYS (Bad system call)", + [SIGTRAP] = "SIGTRAP (Trace/breakpoint trap)", + [SIGURG] = "SIGURG (High bandwidth data is available at a socket)", + [SIGVTALRM] = "SIGVTALRM (Virtual timer expired)", + [SIGXCPU] = "SIGXCPU (CPU time limit exceeded)", + [SIGXFSZ] = "SIGXFSZ (File size limit exceeded)" + }; + + if (signum <= _TOP_SIGNAL) { + return (char *) sigstrings[signum]; + } + + return (char *) "ERROR, Invalid signal number"; +} + +/** @} + */ Index: uspace/lib/posix/string.h =================================================================== --- uspace/lib/posix/string.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/string.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file String manipulation. + */ + +#ifndef POSIX_STRING_H_ +#define POSIX_STRING_H_ + +#include +#include + +/* available in str.h + * + * char *strtok(char *restrict, const char *restrict); + * char *strtok_r(char *restrict, const char *restrict, char **restrict); + * + * available in mem.h + * + * void *memset(void *, int, size_t); + * void *memcpy(void *, const void *, size_t); + * void *memmove(void *, const void *, size_t); + * + * unimplemented due to missing locales + * + * int strcoll_l(const char *, const char *, locale_t); + * char *strerror_l(int, locale_t); + * size_t strxfrm_l(char *restrict, const char *restrict, size_t, locale_t); + * + */ + +// TODO: provide *_l once there is locale.h + +#ifndef NULL + #define NULL ((void *) 0) +#endif + +/* Copying and Concatenation */ +extern char *posix_strcpy(char *restrict dest, const char *restrict src); +extern char *posix_strncpy(char *restrict dest, const char *restrict src, size_t n); +extern char *posix_stpcpy(char *restrict dest, const char *restrict src); +extern char *posix_stpncpy(char *restrict dest, const char *restrict src, size_t n); +extern char *posix_strcat(char *restrict dest, const char *restrict src); +extern char *posix_strncat(char *restrict dest, const char *restrict src, size_t n); +extern void *posix_memccpy(void *restrict dest, const void *restrict src, int c, size_t n); +extern char *posix_strdup(const char *s); +extern char *posix_strndup(const char *s, size_t n); + +/* String/Array Comparison */ +extern int posix_memcmp(const void *mem1, const void *mem2, size_t n); +extern int posix_strcmp(const char *s1, const char *s2); +extern int posix_strncmp(const char *s1, const char *s2, size_t n); + +/* Search Functions */ +extern void *posix_memchr(const void *mem, int c, size_t n); +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); +extern size_t posix_strspn(const char *s1, const char *s2); +extern char *posix_strstr(const char *s1, const char *s2); + +/* Collation Functions */ +extern int posix_strcoll(const char *s1, const char *s2); +extern size_t posix_strxfrm(char *restrict s1, const char *restrict s2, size_t n); + +/* Error Messages */ +extern char *posix_strerror(int errnum); +extern int posix_strerror_r(int errnum, char *buf, size_t bufsz); + +/* String Length */ +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 */ +#ifndef POSIX_STRINGS_H_ +extern int posix_ffs(int i); +extern int posix_strcasecmp(const char *s1, const char *s2); +extern int posix_strncasecmp(const char *s1, const char *s2, size_t n); +#endif + +#ifndef LIBPOSIX_INTERNAL + #define strcpy posix_strcpy + #define strncpy posix_strncpy + #define stpcpy posix_stpcpy + #define stpncpy posix_stpncpy + #define strcat posix_strcat + #define strncat posix_strncat + #define memccpy posix_memccpy + #define strdup posix_strdup + #define strndup posix_strndup + + #define memcmp posix_memcmp + #define strcmp posix_strcmp + #define strncmp posix_strncmp + + #define memchr posix_memchr + #define strchr posix_strchr + #define strrchr posix_strrchr + #define strchrnul gnu_strchrnul + #define strpbrk posix_strpbrk + #define strcspn posix_strcspn + #define strspn posix_strspn + #define strstr posix_strstr + + #define strcoll posix_strcoll + #define strxfrm posix_strxfrm + + #define strerror posix_strerror + #define strerror_r posix_strerror_r + + #define strlen posix_strlen + #define strnlen posix_strnlen + + #define strsignal posix_strsignal + + #define ffs posix_ffs + #define strcasecmp posix_strcasecmp + #define strncasecmp posix_strncasecmp +#endif + +#endif // POSIX_STRING_H_ + +/** @} + */ Index: uspace/lib/posix/strings.c =================================================================== --- uspace/lib/posix/strings.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/strings.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Additional string manipulation. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "strings.h" + +#include "string.h" +#include "ctype.h" + +#include "libc/mem.h" + +/** + * Find first set bit (beginning with the least significant bit). + * + * @param i Integer in which to look for the first set bit. + * @return Index of first set bit. Bits are numbered starting at one. + */ +int posix_ffs(int i) +{ + if (i == 0) { + return 0; + } + + int result = 0; + + // XXX: assumes at most 32-bit int + if (!(i & 0xFFFF)) { + result |= 16; + i >>= 16; + } + if (!(i & 0xFF)) { + result |= 8; + i >>= 8; + } + if (!(i & 0xF)) { + result |= 4; + i >>= 4; + } + if (!(i & 0x3)) { + result |= 2; + i >>= 2; + } + if (!(i & 0x1)) { + result |= 1; + } + + return result + 1; +} + +/** + * Compare two strings (case-insensitive). + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strcasecmp(const char *s1, const char *s2) +{ + return posix_strncasecmp(s1, s2, STR_NO_LIMIT); +} + +/** + * Compare part of two strings (case-insensitive). + * + * @param s1 First string to be compared. + * @param s2 Second string to be compared. + * @param n Maximum number of characters to be compared. + * @return Difference of the first pair of inequal characters, + * or 0 if strings have the same content. + */ +int posix_strncasecmp(const char *s1, const char *s2, size_t n) +{ + for (size_t i = 0; i < n; ++i) { + int cmp = tolower(s1[i]) - tolower(s2[i]); + if (cmp != 0) { + return cmp; + } + + if (s1[i] == 0) { + return 0; + } + } + + return 0; +} + +/** + * Compare two memory areas. + * + * @param mem1 Pointer to the first area to compare. + * @param mem2 Pointer to the second area to compare. + * @param n Common size of both areas. + * @return If n is 0, return zero. If the areas match, return + * zero. Otherwise return non-zero. + */ +int posix_bcmp(const void *mem1, const void *mem2, size_t n) +{ + return bcmp(mem1, mem2, n); +} + +/** + * Copy bytes in memory with overlapping areas. + * + * @param src Source area. + * @param dest Destination area. + * @param n Number of bytes to copy. + */ +void posix_bcopy(const void *src, void *dest, size_t n) +{ + /* Note that memmove has different order of arguments. */ + memmove(dest, src, n); +} + +/** + * Reset bytes in memory area to zero. + * + * @param mem Memory area to be zeroed. + * @param n Number of bytes to reset. + */ +void posix_bzero(void *mem, size_t n) +{ + bzero(mem, n); +} + +/** + * Scan string for a first occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_index(const char *s, int c) +{ + return posix_strchr(s, c); +} + +/** + * Scan string for a last occurence of a character. + * + * @param s String in which to look for the character. + * @param c Character to look for. + * @return Pointer to the specified character on success, + * NULL pointer otherwise. + */ +char *posix_rindex(const char *s, int c) +{ + return posix_strrchr(s, c); +} + +/** @} + */ Index: uspace/lib/posix/strings.h =================================================================== --- uspace/lib/posix/strings.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/strings.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Additional string manipulation. + */ + +#ifndef POSIX_STRINGS_H_ +#define POSIX_STRINGS_H_ + +/* Search Functions */ +#ifndef POSIX_STRING_H_ +extern int posix_ffs(int i); +#endif + +/* String/Array Comparison */ +#ifndef POSIX_STRING_H_ +extern int posix_strcasecmp(const char *s1, const char *s2); +extern int posix_strncasecmp(const char *s1, const char *s2, size_t n); +#endif + +/* TODO: not implemented due to missing locale.h + * + * int strcasecmp_l(const char *, const char *, locale_t); + * int strncasecmp_l(const char *, const char *, size_t, locale_t); + */ + +/* Legacy Functions */ +extern int posix_bcmp(const void *mem1, const void *mem2, size_t n); +extern void posix_bcopy(const void *src, void *dest, size_t n); +extern void posix_bzero(void *mem, size_t n); +extern char *posix_index(const char *s, int c); +extern char *posix_rindex(const char *s, int c); + +#ifndef LIBPOSIX_INTERNAL + #define ffs posix_ffs + + #define strcasecmp posix_strcasecmp + #define strncasecmp posix_strncasecmp + + #define bcmp posix_bcmp + #define bcopy posix_bcopy + #undef bzero + #define bzero posix_bzero + #define index posix_index + #define rindex posix_rindex +#endif + +#endif // POSIX_STRINGS_H_ + +/** @} + */ Index: uspace/lib/posix/sys/mman.h =================================================================== --- uspace/lib/posix/sys/mman.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/mman.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Memory management declarations. + */ + +#ifndef POSIX_SYS_MMAN_H_ +#define POSIX_SYS_MMAN_H_ + +#include "../libc/sys/mman.h" + +#undef PROT_NONE +#undef PROT_READ +#undef PROT_WRITE +#undef PROT_EXEC +#define PROT_NONE 0 +#define PROT_READ PROTO_READ +#define PROT_WRITE PROTO_WRITE +#define PROT_EXEC PROTO_EXEC + +#endif /* POSIX_SYS_MMAN_H_ */ + +/** @} + */ Index: uspace/lib/posix/sys/stat.c =================================================================== --- uspace/lib/posix/sys/stat.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/stat.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File status handling. + */ + +#define LIBPOSIX_INTERNAL + +#include "../internal/common.h" +#include "stat.h" + +#include "../errno.h" +#include "../libc/mem.h" + +/** + * Convert HelenOS stat struct into POSIX stat struct (if possible). + * + * @param dest POSIX stat struct. + * @param src HelenOS stat struct. + */ +static void stat_to_posix(struct posix_stat *dest, struct stat *src) +{ + memset(dest, 0, sizeof(struct posix_stat)); + + dest->st_dev = src->device; + dest->st_ino = src->index; + + /* HelenOS doesn't support permissions, so we set them all */ + dest->st_mode = S_IRWXU | S_IRWXG | S_IRWXO; + if (src->is_file) { + dest->st_mode |= S_IFREG; + } + if (src->is_directory) { + dest->st_mode |= S_IFDIR; + } + + dest->st_nlink = src->lnkcnt; + dest->st_size = src->size; +} + +/** + * Retrieve file status for file associated with file descriptor. + * + * @param fd File descriptor of the opened file. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_fstat(int fd, struct posix_stat *st) +{ + struct stat hst; + int rc = fstat(fd, &hst); + if (rc < 0) { + /* fstat() returns negative error code instead of using errno. */ + errno = -rc; + return -1; + } + stat_to_posix(st, &hst); + return 0; +} + +/** + * Retrieve file status for symbolic link. + * + * @param path Path to the symbolic link. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_lstat(const char *restrict path, struct posix_stat *restrict st) +{ + /* There are currently no symbolic links in HelenOS. */ + return posix_stat(path, st); +} + +/** + * Retrieve file status for regular file (or symbolic link target). + * + * @param path Path to the file/link. + * @param st Status structure to be filled with information. + * @return Zero on success, -1 otherwise. + */ +int posix_stat(const char *restrict path, struct posix_stat *restrict st) +{ + struct stat hst; + int rc = stat(path, &hst); + if (rc < 0) { + /* stat() returns negative error code instead of using errno. */ + errno = -rc; + return -1; + } + stat_to_posix(st, &hst); + return 0; +} + +/** + * Change permission bits for the file if possible. + * + * @param path Path to the file. + * @param mode Permission bits to be set. + * @return Zero on success, -1 otherwise. + */ +int posix_chmod(const char *path, mode_t mode) +{ + /* HelenOS doesn't support permissions, return success. */ + return 0; +} + +/** + * Set the file mode creation mask of the process. + * + * @param mask Set permission bits are cleared in the related creation + * functions. Non-permission bits are ignored. + * @return Previous file mode creation mask. + */ +mode_t posix_umask(mode_t mask) +{ + /* HelenOS doesn't support permissions, return empty mask. */ + return 0; +} + +/** @} + */ Index: uspace/lib/posix/sys/stat.h =================================================================== --- uspace/lib/posix/sys/stat.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/stat.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file File status handling. + */ + +#ifndef POSIX_SYS_STAT_H_ +#define POSIX_SYS_STAT_H_ + +#include "../libc/sys/stat.h" +#include "types.h" +#include "../time.h" + +/* values are the same as on Linux */ + +#undef S_IFMT +#undef S_IFSOCK +#undef S_IFLNK +#undef S_IFREG +#undef S_IFBLK +#undef S_IFDIR +#undef S_IFCHR +#undef S_IFIFO +#define S_IFMT 0170000 /* all file types */ +#define S_IFSOCK 0140000 /* socket */ +#define S_IFLNK 0120000 /* symbolic link */ +#define S_IFREG 0100000 /* regular file */ +#define S_IFBLK 0060000 /* block device */ +#define S_IFDIR 0040000 /* directory */ +#define S_IFCHR 0020000 /* character device */ +#define S_IFIFO 0010000 /* FIFO */ + +#undef S_ISUID +#undef S_ISGID +#undef S_ISVTX +#define S_ISUID 0004000 /* SUID */ +#define S_ISGID 0002000 /* SGID */ +#define S_ISVTX 0001000 /* sticky */ + +#undef S_IRWXU +#undef S_IRUSR +#undef S_IWUSR +#undef S_IXUSR +#define S_IRWXU 00700 /* owner permissions */ +#define S_IRUSR 00400 +#define S_IWUSR 00200 +#define S_IXUSR 00100 + +#undef S_IRWXG +#undef S_IRGRP +#undef S_IWGRP +#undef S_IXGRP +#define S_IRWXG 00070 /* group permissions */ +#define S_IRGRP 00040 +#define S_IWGRP 00020 +#define S_IXGRP 00010 + +#undef S_IRWXO +#undef S_IROTH +#undef S_IWOTH +#undef S_IXOTH +#define S_IRWXO 00007 /* other permissions */ +#define S_IROTH 00004 +#define S_IWOTH 00002 +#define S_IXOTH 00001 + +#undef S_ISREG +#undef S_ISDIR +#undef S_ISCHR +#undef S_ISBLK +#undef S_ISFIFO +#undef S_ISLNK +#undef S_ISSOCK +#define S_ISREG(m) ((m & S_IFREG) != 0) +#define S_ISDIR(m) ((m & S_IFDIR) != 0) +#define S_ISCHR(m) ((m & S_IFCHR) != 0) +#define S_ISBLK(m) ((m & S_IFBLK) != 0) +#define S_ISFIFO(m) ((m & S_IFIFO) != 0) +#define S_ISLNK(m) ((m & S_IFLNK) != 0) /* symbolic link? (Not in POSIX.1-1996.) */ +#define S_ISSOCK(m) ((m & S_IFSOCK) != 0) /* socket? (Not in POSIX.1-1996.) */ + +struct posix_stat { + posix_dev_t st_dev; /* ID of device containing file */ + posix_ino_t st_ino; /* inode number */ + mode_t st_mode; /* protection */ + posix_nlink_t st_nlink; /* number of hard links */ + posix_uid_t st_uid; /* user ID of owner */ + posix_gid_t st_gid; /* group ID of owner */ + posix_dev_t st_rdev; /* device ID (if special file) */ + posix_off_t st_size; /* total size, in bytes */ + posix_blksize_t st_blksize; /* blocksize for file system I/O */ + posix_blkcnt_t st_blocks; /* number of 512B blocks allocated */ + time_t st_atime; /* time of last access */ + time_t st_mtime; /* time of last modification */ + time_t st_ctime; /* time of last status change */ +}; + +extern int posix_fstat(int fd, struct posix_stat *st); +extern int posix_lstat(const char *restrict path, struct posix_stat *restrict st); +extern int posix_stat(const char *restrict path, struct posix_stat *restrict st); +extern int posix_chmod(const char *path, mode_t mode); +extern mode_t posix_umask(mode_t mask); + +#ifndef LIBPOSIX_INTERNAL + #define fstat posix_fstat + #define lstat posix_lstat + #define stat posix_stat + #define chmod posix_chmod + #define umask posix_umask +#endif + +#endif /* POSIX_SYS_STAT_H */ + +/** @} + */ Index: uspace/lib/posix/sys/types.h =================================================================== --- uspace/lib/posix/sys/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/types.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Data types definitions. + */ + +#ifndef POSIX_SYS_TYPES_H_ +#define POSIX_SYS_TYPES_H_ + +#include "../libc/sys/types.h" + +typedef unsigned int posix_ino_t; +typedef unsigned int posix_nlink_t; +typedef unsigned int posix_uid_t; +typedef unsigned int posix_gid_t; +typedef off64_t posix_off_t; +typedef long posix_blksize_t; +typedef long posix_blkcnt_t; +typedef int64_t posix_pid_t; +typedef sysarg_t posix_dev_t; + +/* PThread Types */ +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 + #define nlink_t posix_nlink_t + #define uid_t posix_uid_t + #define gid_t posix_gid_t + #define off_t posix_off_t + #define blksize_t posix_blksize_t + #define blkcnt_t posix_blkcnt_t + #define pid_t posix_pid_t + #define dev_t posix_dev_t + + #define pthread_attr_t posix_thread_attr_t + + #define clock_t posix_clock_t + #define clockid_t posix_clockid_t +#endif + +#endif /* POSIX_SYS_TYPES_H_ */ + +/** @} + */ Index: uspace/lib/posix/sys/wait.c =================================================================== --- uspace/lib/posix/sys/wait.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/wait.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Support for waiting. + */ + +#define LIBPOSIX_INTERNAL + +#include "../internal/common.h" +#include "wait.h" + +/** + * + * @param stat_ptr + * @return + */ +posix_pid_t posix_wait(int *stat_ptr) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param pid + * @param stat_ptr + * @param options + * @return + */ +posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */ Index: uspace/lib/posix/sys/wait.h =================================================================== --- uspace/lib/posix/sys/wait.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/sys/wait.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Support for waiting. + */ + +#ifndef POSIX_SYS_WAIT_H_ +#define POSIX_SYS_WAIT_H_ + +#include "types.h" + +extern posix_pid_t posix_wait(int *stat_ptr); +extern posix_pid_t posix_waitpid(posix_pid_t pid, int *stat_ptr, int options); + +#ifndef LIBPOSIX_INTERNAL + #define wait posix_wait + #define waitpid posix_waitpid +#endif + +#endif /* POSIX_SYS_WAIT_H_ */ + +/** @} + */ Index: uspace/lib/posix/time.c =================================================================== --- uspace/lib/posix/time.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/time.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,978 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Time measurement support. + */ + +#define LIBPOSIX_INTERNAL + +/* Must be first. */ +#include "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) + +/** + * + * @param year + * @return + */ +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; +} + +/** + * + * @param year + * @param mon + * @return + */ +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]; + } +} + +/** + * + * @param year + * @param mon + * @param mday + * @return + */ +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. + * + * @param op1 + * @param op2 + * @return + */ +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. + * + * @param op1 + * @param op2 + * @return + */ +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; +} + +/** + * + * @param year + * @param mon + * @param mday + * @return + */ +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. + * + * @param tm + * @return + */ +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; +} + +/** + * + * @param year + * @param mon + * @param mday + * @return + */ +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; +}; + +/** + * + * @param ltm + * @param ptm + */ +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; +} + +/** + * + * @param ptm + * @param ltm + */ +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; +} + +/** + * + * @param tm + */ +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. + * + * @param year + * @return + */ +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. + * + * @param tm + * @return + */ +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; +} + +/** + * + * @param time1 + * @param time0 + * @return + */ +double posix_difftime(time_t time1, time_t time0) +{ + return (double) (time1 - time0); +} + +/** + * This function first normalizes the provided broken-down time + * (moves all values to their proper bounds) and then tries to + * calculate the appropriate time_t representation. + * + * @param tm Broken-down time. + * @return time_t representation of the time, undefined value on overflow + */ +time_t posix_mktime(struct posix_tm *tm) +{ + // TODO: take DST flag into account + // TODO: detect overflow + + struct _long_tm ltm; + _posix_to_long_tm(<m, tm); + _normalize_time(<m); + _long_to_posix_tm(tm, <m); + + return _secs_since_epoch(tm); +} + +/** + * + * @param timer + * @return + */ +struct posix_tm *posix_gmtime(const time_t *timer) +{ + static struct posix_tm result; + return posix_gmtime_r(timer, &result); +} + +/** + * + * @param timer + * @param result + * @return + */ +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(<m); + + if (ltm.tm_year < (int) INT_MIN || ltm.tm_year > (int) INT_MAX) { + errno = EOVERFLOW; + return NULL; + } + + _long_to_posix_tm(result, <m); + return result; +} + +/** + * + * @param timer + * @return + */ +struct posix_tm *posix_localtime(const time_t *timer) +{ + static struct posix_tm result; + return posix_localtime_r(timer, &result); +} + +/** + * + * @param timer + * @param result + * @return + */ +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); +} + +/** + * + * @param timeptr + * @return + */ +char *posix_asctime(const struct posix_tm *timeptr) +{ + static char buf[ASCTIME_BUF_LEN]; + return posix_asctime_r(timeptr, buf); +} + +/** + * + * @param timeptr + * @param buf + * @return + */ +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; +} + +/** + * + * @param timer + * @return + */ +char *posix_ctime(const time_t *timer) +{ + struct posix_tm *loctime = posix_localtime(timer); + if (loctime == NULL) { + return NULL; + } + return posix_asctime(loctime); +} + +/** + * + * @param timer + * @param buf + * @return + */ +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); +} + +/** + * + * @param s + * @param maxsize + * @param format + * @param tm + * @return + */ +size_t posix_strftime(char *restrict s, size_t maxsize, + const char *restrict format, const struct posix_tm *restrict 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; +} + +/** + * + * @param s + * @param maxsize + * @param format + * @param tm + * @param loc + * @return + */ +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) +{ + // TODO + not_implemented(); +} + +/** + * + * @param clock_id + * @param res + * @return + */ +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; + } +} + +/** + * + * @param clock_id + * @param tp + * @return + */ +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; + } +} + +/** + * + * @param clock_id + * @param tp + * @return + */ +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; + } +} + +/** + * + * @param clock_id + * @param flags + * @param rqtp + * @param rmtp + * @return + */ +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; +}; + +/** + * + * @param clockid + * @param evp + * @param timerid + * @return + */ +int posix_timer_create(posix_clockid_t clockid, + struct posix_sigevent *restrict evp, + posix_timer_t *restrict timerid) +{ + // TODO + not_implemented(); +} + +/** + * + * @param timerid + * @return + */ +int posix_timer_delete(posix_timer_t timerid) +{ + // TODO + not_implemented(); +} + +/** + * + * @param timerid + * @return + */ +int posix_timer_getoverrun(posix_timer_t timerid) +{ + // TODO + not_implemented(); +} + +/** + * + * @param timerid + * @param value + * @return + */ +int posix_timer_gettime(posix_timer_t timerid, + struct posix_itimerspec *value) +{ + // TODO + not_implemented(); +} + +/** + * + * @param timerid + * @param flags + * @param value + * @param ovalue + * @return + */ +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; +} + +/** @} + */ Index: uspace/lib/posix/time.h =================================================================== --- uspace/lib/posix/time.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/time.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Time measurement support. + */ + +#ifndef POSIX_TIME_H_ +#define POSIX_TIME_H_ + +#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 { + int tm_sec; /* Seconds [0,60]. */ + int tm_min; /* Minutes [0,59]. */ + int tm_hour; /* Hour [0,23]. */ + int tm_mday; /* Day of month [1,31]. */ + int tm_mon; /* Month of year [0,11]. */ + int tm_year; /* Years since 1900. */ + int tm_wday; /* Day of week [0,6] (Sunday = 0). */ + int tm_yday; /* Day of year [0,365]. */ + int tm_isdst; /* Daylight Savings flag. */ +}; + +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); + +/* Elapsed Time */ +extern double posix_difftime(time_t time1, time_t time0); + +/* Broken-down Time */ +extern time_t posix_mktime(struct posix_tm *tm); +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 *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); + +#if 0 + +/* Timers */ +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 timespec posix_timespec + #define itimerspec posix_itimerspec + #define timer_t posix_timer_t + + #define daylight posix_daylight + #define timezone posix_timezone + #define tzname posix_tzname + #define tzset posix_tzset + + #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 asctime posix_asctime + #define asctime_r posix_asctime_r + #define ctime posix_ctime + #define ctime_r posix_ctime_r + #define strftime posix_strftime + #define strftime_l posix_strftime_l + + #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 + +#endif // POSIX_TIME_H_ + +/** @} + */ Index: uspace/lib/posix/unistd.c =================================================================== --- uspace/lib/posix/unistd.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/unistd.c (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Miscellaneous standard definitions. + */ + +#define LIBPOSIX_INTERNAL + +#include "internal/common.h" +#include "unistd.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 **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 0; +} + +/** + * Get the pathname of the current working directory. + * + * @param buf Buffer into which the pathname shall be put. + * @param size Size of the buffer. + * @return Buffer pointer on success, NULL on failure. + */ +char *posix_getcwd(char *buf, size_t size) +{ + /* Native getcwd() does not set any errno despite the fact that general + * usage pattern of this function depends on it (caller is repeatedly + * guessing the required size of the buffer by checking for ERANGE on + * failure). */ + if (size == 0) { + errno = EINVAL; + return NULL; + } + char *ret = getcwd(buf, size); + if (ret == NULL && errno == EOK) { + errno = ERANGE; + } + return ret; +} + +/** + * Determine the page size of the current run of the process. + * + * @return Page size of the process. + */ +int posix_getpagesize(void) +{ + return getpagesize(); +} + +/** + * Get the process ID of the calling process. + * + * @return Process ID. + */ +posix_pid_t posix_getpid(void) +{ + return task_get_id(); +} + +/** + * Get the real user ID of the calling process. + * + * @return User ID. + */ +posix_uid_t posix_getuid(void) +{ + /* There is currently no support for user accounts in HelenOS. */ + return 0; +} + +/** + * Get the real group ID of the calling process. + * + * @return Group ID. + */ +posix_gid_t posix_getgid(void) +{ + /* There is currently no support for user accounts in HelenOS. */ + return 0; +} + +/** + * Read from a file. + * + * @param fildes File descriptor of the opened file. + * @param buf Buffer to which the read bytes shall be stored. + * @param nbyte Upper limit on the number of read bytes. + * @return Number of read bytes on success, -1 otherwise. + */ +ssize_t posix_read(int fildes, void *buf, size_t nbyte) +{ + int rc = read(fildes, buf, nbyte); + if (rc < 0) { + errno = -rc; + return -1; + } else { + return rc; + } +} + +/** + * Remove a link to a file. + * + * @param path File pathname. + * @return Zero on success, -1 otherwise. + */ +int posix_unlink(const char *path) +{ + int rc = unlink(path); + if (rc < 0) { + errno = -rc; + return -1; + } else { + return rc; + } +} + +/** + * Determine accessibility of a file. + * + * @param path File to check accessibility for. + * @param amode Either check for existence or intended access mode. + * @return Zero on success, -1 otherwise. + */ +int posix_access(const char *path, int amode) +{ + if (amode == F_OK) { + /* Check file existence by attempt to open it. */ + int fd = open(path, O_RDONLY); + if (fd != -1) { + 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) +{ + long clk_tck = 0; + size_t cpu_count = 0; + stats_cpu_t *cpu_stats = stats_get_cpus(&cpu_count); + if (cpu_stats && cpu_count > 0) { + clk_tck = ((long) cpu_stats[0].frequency_mhz) * 1000000L; + } + if (cpu_stats) { + free(cpu_stats); + cpu_stats = 0; + } + + long phys_pages = 0; + long avphys_pages = 0; + stats_physmem_t *mem_stats = stats_get_physmem(); + if (mem_stats) { + phys_pages = (long) (mem_stats->total / getpagesize()); + avphys_pages = (long) (mem_stats->free / getpagesize()); + free(mem_stats); + mem_stats = 0; + } + + switch (name) { + case _SC_PHYS_PAGES: + return phys_pages; + case _SC_AVPHYS_PAGES: + return avphys_pages; + case _SC_PAGESIZE: + return getpagesize(); + case _SC_CLK_TCK: + return clk_tck; + default: + errno = EINVAL; + return -1; + } +} + +/** + * + * @param path + * @param name + * @return + */ +long posix_pathconf(const char *path, int name) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @return + */ +posix_pid_t posix_fork(void) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param path + * @param argv + * @return + */ +int posix_execv(const char *path, char *const argv[]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param file + * @param argv + * @return + */ +int posix_execvp(const char *file, char *const argv[]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** + * + * @param fildes + * @return + */ +int posix_pipe(int fildes[2]) +{ + // TODO: low priority, just a compile-time dependency of binutils + not_implemented(); +} + +/** @} + */ Index: uspace/lib/posix/unistd.h =================================================================== --- uspace/lib/posix/unistd.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) +++ uspace/lib/posix/unistd.h (revision 4912d01aefd57ed8d949700cf5d989f5b60cba61) @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2011 Jiri Zarevucky + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libposix + * @{ + */ +/** @file Miscellaneous standard definitions. + */ + +#ifndef POSIX_UNISTD_H_ +#define POSIX_UNISTD_H_ + +#include "libc/unistd.h" +#include "sys/types.h" + +/* Process Termination */ +#define _exit exit + +/* Option Arguments */ +extern char *optarg; +extern int optind, opterr, optopt; +extern int getopt(int, char * const [], const char *); + +/* Environment */ +extern char **posix_environ; + +/* Login Information */ +extern char *posix_getlogin(void); +extern int posix_getlogin_r(char *name, size_t namesize); + +/* Identifying Terminals */ +extern int posix_isatty(int fd); + +/* Working Directory */ +extern char *posix_getcwd(char *buf, size_t size); + +/* Query Memory Parameters */ +extern int posix_getpagesize(void); + +/* Process Identification */ +extern posix_pid_t posix_getpid(void); +extern posix_uid_t posix_getuid(void); +extern posix_gid_t posix_getgid(void); + +/* File Input/Output */ +extern ssize_t posix_read(int fildes, void *buf, size_t nbyte); + +/* Deleting Files */ +extern int posix_unlink(const char *path); + +/* Standard Streams */ +#undef STDIN_FILENO +#define STDIN_FILENO (fileno(stdin)) +#undef STDOUT_FILENO +#define STDOUT_FILENO (fileno(stdout)) +#undef STDERR_FILENO +#define STDERR_FILENO (fileno(stderr)) + +/* File Accessibility */ +#undef F_OK +#undef X_OK +#undef W_OK +#undef R_OK +#define F_OK 0 /* Test for existence. */ +#define X_OK 1 /* Test for execute permission. */ +#define W_OK 2 /* Test for write permission. */ +#define R_OK 4 /* Test for read permission. */ +extern int posix_access(const char *path, int amode); + +/* System Parameters */ +enum { + _SC_PHYS_PAGES, + _SC_AVPHYS_PAGES, + _SC_PAGESIZE, + _SC_CLK_TCK +}; +extern long posix_sysconf(int name); + +/* Path Configuration Parameters */ +enum { + _PC_2_SYMLINKS, + _PC_ALLOC_SIZE_MIN, + _PC_ASYNC_IO, + _PC_CHOWN_RESTRICTED, + _PC_FILESIZEBITS, + _PC_LINK_MAX, + _PC_MAX_CANON, + _PC_MAX_INPUT, + _PC_NAME_MAX, + _PC_NO_TRUNC, + _PC_PATH_MAX, + _PC_PIPE_BUF, + _PC_PRIO_IO, + _PC_REC_INCR_XFER_SIZE, + _PC_REC_MIN_XFER_SIZE, + _PC_REC_XFER_ALIGN, + _PC_SYMLINK_MAX, + _PC_SYNC_IO, + _PC_VDISABLE +}; +extern long posix_pathconf(const char *path, int name); + +/* Creating a Process */ +extern posix_pid_t posix_fork(void); + +/* Executing a File */ +extern int posix_execv(const char *path, char *const argv[]); +extern int posix_execvp(const char *file, char *const argv[]); + +/* Creating a Pipe */ +extern int posix_pipe(int fildes[2]); + +#ifndef LIBPOSIX_INTERNAL + #define environ posix_environ + + #define getlogin posix_getlogin + #define getlogin_r posix_getlogin_r + + #define getcwd posix_getcwd + + #define isatty posix_isatty + + #undef getpagesize + #define getpagesize posix_getpagesize + + #define getpid posix_getpid + #define getuid posix_getuid + #define getgid posix_getgid + + #define read posix_read + + #define unlink posix_unlink + + #define access posix_access + + #define sysconf posix_sysconf + + #define pathconf posix_pathconf + + #define fork posix_fork + + #define execv posix_execv + #define execvp posix_execvp + + #define pipe posix_pipe +#endif + +#endif /* POSIX_UNISTD_H_ */ + +/** @} + */