From dce540ad72eba405b9ec1da5f054b679b7fd3483 Mon Sep 17 00:00:00 2001 From: Elliott Hughes Date: Mon, 3 Apr 2023 16:30:39 -0700 Subject: [PATCH] Add POSIX . Now isn't any more useful on Android than is, but it is POSIX, and -- importantly -- we can implement it with just a header file, so code can use it on every existing API level. macOS does indeed only have the functions (although it does still have the header!), so potentially portable code might want on Android. (glibc/musl both have both headers.) Bug: https://github.com/landley/toybox/pull/213 Test: treehugger Change-Id: Iaa88167708182009a63e2e1a15f11186b251ed02 --- libc/NOTICE | 28 +++++++++ libc/include/utmp.h | 20 ++++--- libc/include/utmpx.h | 103 ++++++++++++++++++++++++++++++++++ tests/NOTICE | 28 +++++++++ tests/headers/posix/utmpx_h.c | 58 +++++++++++++++++++ tests/utmp_test.cpp | 12 ++++ 6 files changed, 241 insertions(+), 8 deletions(-) create mode 100644 libc/include/utmpx.h create mode 100644 tests/headers/posix/utmpx_h.c diff --git a/libc/NOTICE b/libc/NOTICE index 9d55592310..4d3a108619 100644 --- a/libc/NOTICE +++ b/libc/NOTICE @@ -894,6 +894,34 @@ SUCH DAMAGE. ------------------------------------------------------------------- +Copyright (C) 2023 The Android Open Source Project +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"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 +COPYRIGHT OWNER OR CONTRIBUTORS 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. + +------------------------------------------------------------------- + Copyright (c) 1980, 1983, 1988, 1993 The Regents of the University of California. All rights reserved. diff --git a/libc/include/utmp.h b/libc/include/utmp.h index 7aa5718d0d..d249f8af83 100644 --- a/libc/include/utmp.h +++ b/libc/include/utmp.h @@ -30,7 +30,7 @@ /** * @file utmp.h - * @brief POSIX login records. + * @brief No-op implementation of non-POSIX login records. See for the POSIX equivalents. */ #include @@ -69,12 +69,12 @@ struct lastlog { }; struct exit_status { - short int e_termination; - short int e_exit; + short e_termination; + short e_exit; }; struct utmp { - short int ut_type; + short ut_type; pid_t ut_pid; char ut_line[UT_LINESIZE]; char ut_id[4]; @@ -83,7 +83,7 @@ struct utmp { struct exit_status ut_exit; - long int ut_session; + long ut_session; struct timeval ut_tv; int32_t ut_addr_v6[4]; @@ -97,21 +97,25 @@ struct utmp { __BEGIN_DECLS /** - * Does nothing. + * Returns -1 and sets errno to ENOTSUP. */ int utmpname(const char* _Nonnull __path); + /** * Does nothing. */ void setutent(void); + /** - * Does nothing. + * Does nothing and returns null. */ struct utmp* _Nullable getutent(void); + /** - * Does nothing. + * Does nothing and returns null. */ struct utmp* _Nullable pututline(const struct utmp* _Nonnull __entry); + /** * Does nothing. */ diff --git a/libc/include/utmpx.h b/libc/include/utmpx.h new file mode 100644 index 0000000000..5ed8e1adbb --- /dev/null +++ b/libc/include/utmpx.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 + * COPYRIGHT OWNER OR CONTRIBUTORS 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. + */ + +#pragma once + +/** + * @file utmpx.h + * @brief No-op implementation of POSIX login records. + */ + +#include +#include +#include + +#define EMPTY 0 +#define RUN_LVL 1 +#define BOOT_TIME 2 +#define NEW_TIME 3 +#define OLD_TIME 4 +#define INIT_PROCESS 5 +#define LOGIN_PROCESS 6 +#define USER_PROCESS 7 +#define DEAD_PROCESS 8 +#define ACCOUNTING 9 + +struct utmpx { + short ut_type; + pid_t ut_pid; + char ut_line[32]; + char ut_id[4]; + char ut_user[32]; + char ut_host[256]; + + struct { + short e_termination; + short e_exit; + } ut_exit; + + long ut_session; + struct timeval ut_tv; + + int32_t ut_addr_v6[4]; + char unused[20]; +}; + +__BEGIN_DECLS + +/** + * Does nothing. + */ +void setutxent(void) __RENAME(setutent); + +/** + * Does nothing and returns null. + */ +struct utmpx* _Nullable getutxent(void) __RENAME(getutent); + +/** + * Does nothing and returns null. + */ +struct utmpx* _Nullable getutxid(const struct utmpx* _Nonnull __entry) __RENAME(getutent); + +/** + * Does nothing and returns null. + */ +struct utmpx* _Nullable getutxline(const struct utmpx* _Nonnull __entry) __RENAME(getutent); + +/** + * Does nothing and returns null. + */ +struct utmpx* _Nullable pututxline(const struct utmpx* _Nonnull __entry) __RENAME(pututline); + +/** + * Does nothing. + */ +void endutxent(void) __RENAME(endutent); + +__END_DECLS diff --git a/tests/NOTICE b/tests/NOTICE index 167f90bcca..cc99d2053f 100644 --- a/tests/NOTICE +++ b/tests/NOTICE @@ -426,3 +426,31 @@ SUCH DAMAGE. ------------------------------------------------------------------- +Copyright (C) 2023 The Android Open Source Project +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"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 +COPYRIGHT OWNER OR CONTRIBUTORS 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. + +------------------------------------------------------------------- + diff --git a/tests/headers/posix/utmpx_h.c b/tests/headers/posix/utmpx_h.c new file mode 100644 index 0000000000..e0b34f8da4 --- /dev/null +++ b/tests/headers/posix/utmpx_h.c @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 + * COPYRIGHT OWNER OR CONTRIBUTORS 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. + */ + +#include "header_checks.h" + +static void utmpx_h() { + TYPE(struct utmpx); + STRUCT_MEMBER(struct utmpx, char*, ut_user); + STRUCT_MEMBER(struct utmpx, char*, ut_id); + STRUCT_MEMBER(struct utmpx, char*, ut_line); + STRUCT_MEMBER(struct utmpx, pid_t, ut_pid); + STRUCT_MEMBER(struct utmpx, short, ut_type); + STRUCT_MEMBER(struct utmpx, struct timeval, ut_tv); + + TYPE(pid_t); + TYPE(struct timeval); + + MACRO(EMPTY); + MACRO(BOOT_TIME); + MACRO(OLD_TIME); + MACRO(NEW_TIME); + MACRO(USER_PROCESS); + MACRO(INIT_PROCESS); + MACRO(LOGIN_PROCESS); + MACRO(DEAD_PROCESS); + + FUNCTION(endutxent, void (*f)(void)); + FUNCTION(getutxent, struct utmpx* (*f)(void)); + FUNCTION(getutxid, struct utmpx* (*f)(const struct utmpx*)); + FUNCTION(getutxline, struct utmpx* (*f)(const struct utmpx*)); + FUNCTION(pututxline, struct utmpx* (*f)(const struct utmpx*)); + FUNCTION(setutxent, void (*f)(void)); +} diff --git a/tests/utmp_test.cpp b/tests/utmp_test.cpp index b024818a2f..fe8cbaefcc 100644 --- a/tests/utmp_test.cpp +++ b/tests/utmp_test.cpp @@ -25,6 +25,7 @@ TEST(utmp, login_tty) { } TEST(utmp, smoke) { + // The rest of is just no-op implementations, so testing is trivial. ASSERT_EQ(-1, utmpname("hello")); setutent(); ASSERT_EQ(NULL, getutent()); @@ -32,3 +33,14 @@ TEST(utmp, smoke) { utmp failure = {.ut_type = EMPTY}; ASSERT_EQ(NULL, pututline(&failure)); } + +TEST(utmpx, smoke) { + // Our utmpx "implementation" just calls the utmp no-op functions anyway. + setutxent(); + utmpx empty = {.ut_type = EMPTY}; + ASSERT_EQ(NULL, getutxent()); + ASSERT_EQ(NULL, getutxid(&empty)); + ASSERT_EQ(NULL, getutxline(&empty)); + endutxent(); + ASSERT_EQ(NULL, pututxline(&empty)); +}