From e5bc5f1f5ac3595bfbe77d4896d6b7b22a0310a8 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 4 Feb 2021 03:21:08 +0900 Subject: [PATCH 1/3] fundamental: move several macros and functions into src/fundamental/ sd-boot has a copy of a subset of codes from libbasic. This makes sd-boot share the code with libbasic, and dedup the code. Note, startswith_no_case() is dropped from sd-boot, as - it is not used, - the previous implementation is not correct, - gnu-efi does not have StrniCmp() or so. --- meson.build | 4 + src/basic/alloc-util.h | 9 - src/basic/macro.h | 181 +--------------- src/basic/meson.build | 1 + src/basic/string-util.c | 58 ----- src/basic/string-util.h | 48 +---- src/boot/efi/boot.c | 2 +- src/boot/efi/meson.build | 14 +- src/boot/efi/util.c | 56 ----- src/boot/efi/util.h | 21 +- .../efi-loader-features.h} | 0 src/fundamental/macro-fundamental.h | 201 ++++++++++++++++++ src/fundamental/meson.build | 22 ++ src/fundamental/string-util-fundamental.c | 76 +++++++ src/fundamental/string-util-fundamental.h | 65 ++++++ src/fundamental/type.h | 22 ++ src/shared/efi-loader-features.h | 1 - src/shared/meson.build | 1 - 18 files changed, 405 insertions(+), 377 deletions(-) rename src/{boot/efi/loader-features.h => fundamental/efi-loader-features.h} (100%) create mode 100644 src/fundamental/macro-fundamental.h create mode 100644 src/fundamental/meson.build create mode 100644 src/fundamental/string-util-fundamental.c create mode 100644 src/fundamental/string-util-fundamental.h create mode 100644 src/fundamental/type.h delete mode 120000 src/shared/efi-loader-features.h diff --git a/meson.build b/meson.build index 62b11aba2d..09d8122091 100644 --- a/meson.build +++ b/meson.build @@ -1616,6 +1616,7 @@ fuzzers = [] basic_includes = include_directories( 'src/basic', + 'src/fundamental', 'src/systemd', '.') @@ -1634,6 +1635,7 @@ includes = [libsystemd_includes, include_directories('src/shared')] subdir('po') subdir('catalog') +subdir('src/fundamental') subdir('src/basic') subdir('src/libsystemd') subdir('src/shared') @@ -1664,6 +1666,7 @@ install_libsystemd_static = static_library( libsystemd_sources, basic_sources, basic_gcrypt_sources, + fundamental_sources, disable_mempool_c, include_directories : libsystemd_includes, build_by_default : static_libsystemd != 'false', @@ -1699,6 +1702,7 @@ libudev = shared_library( install_libudev_static = static_library( 'udev', basic_sources, + fundamental_sources, shared_sources, libsystemd_sources, libudev_sources, diff --git a/src/basic/alloc-util.h b/src/basic/alloc-util.h index f3e192ddaf..5885d890b5 100644 --- a/src/basic/alloc-util.h +++ b/src/basic/alloc-util.h @@ -158,15 +158,6 @@ void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size); (void*)memset(_new_, 0, _xsize_); \ }) -/* Takes inspiration from Rust's Option::take() method: reads and returns a pointer, but at the same time - * resets it to NULL. See: https://doc.rust-lang.org/std/option/enum.Option.html#method.take */ -#define TAKE_PTR(ptr) \ - ({ \ - typeof(ptr) _ptr_ = (ptr); \ - (ptr) = NULL; \ - _ptr_; \ - }) - #if HAS_FEATURE_MEMORY_SANITIZER # define msan_unpoison(r, s) __msan_unpoison(r, s) #else diff --git a/src/basic/macro.h b/src/basic/macro.h index 2782553756..d4e3d3b8fb 100644 --- a/src/basic/macro.h +++ b/src/basic/macro.h @@ -9,6 +9,8 @@ #include #include +#include "macro-fundamental.h" + #define _printf_(a, b) __attribute__((__format__(printf, a, b))) #ifdef __clang__ # define _alloc_(...) @@ -18,10 +20,7 @@ #define _sentinel_ __attribute__((__sentinel__)) #define _section_(x) __attribute__((__section__(x))) #define _used_ __attribute__((__used__)) -#define _unused_ __attribute__((__unused__)) #define _destructor_ __attribute__((__destructor__)) -#define _pure_ __attribute__((__pure__)) -#define _const_ __attribute__((__const__)) #define _deprecated_ __attribute__((__deprecated__)) #define _packed_ __attribute__((__packed__)) #define _malloc_ __attribute__((__malloc__)) @@ -34,7 +33,6 @@ #define _align_(x) __attribute__((__aligned__(x))) #define _alignas_(x) __attribute__((__aligned__(__alignof(x)))) #define _alignptr_ __attribute__((__aligned__(sizeof(void*)))) -#define _cleanup_(x) __attribute__((__cleanup__(x))) #if __GNUC__ >= 7 #define _fallthrough_ __attribute__((__fallthrough__)) #else @@ -143,12 +141,6 @@ #define XSTRINGIFY(x) #x #define STRINGIFY(x) XSTRINGIFY(x) -#define XCONCATENATE(x, y) x ## y -#define CONCATENATE(x, y) XCONCATENATE(x, y) - -#define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq)) -#define UNIQ __COUNTER__ - /* builtins */ #if __SIZEOF_INT__ == 4 #define BUILTIN_FFS_U32(x) __builtin_ffs(x); @@ -222,18 +214,6 @@ static inline size_t GREEDY_ALLOC_ROUND_UP(size_t l) { return m; } -#ifndef __COVERITY__ -# define VOID_0 ((void)0) -#else -# define VOID_0 ((void*)0) -#endif - -#define ELEMENTSOF(x) \ - (__builtin_choose_expr( \ - !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \ - sizeof(x)/sizeof((x)[0]), \ - VOID_0)) - /* * STRLEN - return the length of a string literal, minus the trailing NUL byte. * Contrary to strlen(), this is a constant expression. @@ -254,106 +234,6 @@ static inline size_t GREEDY_ALLOC_ROUND_UP(size_t l) { (type*)( (char *)UNIQ_T(A, uniq) - offsetof(type, member) ); \ }) -#undef MAX -#define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b)) -#define __MAX(aq, a, bq, b) \ - ({ \ - const typeof(a) UNIQ_T(A, aq) = (a); \ - const typeof(b) UNIQ_T(B, bq) = (b); \ - UNIQ_T(A, aq) > UNIQ_T(B, bq) ? UNIQ_T(A, aq) : UNIQ_T(B, bq); \ - }) - -/* evaluates to (void) if _A or _B are not constant or of different types */ -#define CONST_MAX(_A, _B) \ - (__builtin_choose_expr( \ - __builtin_constant_p(_A) && \ - __builtin_constant_p(_B) && \ - __builtin_types_compatible_p(typeof(_A), typeof(_B)), \ - ((_A) > (_B)) ? (_A) : (_B), \ - VOID_0)) - -/* takes two types and returns the size of the larger one */ -#define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; })) - -#define MAX3(x, y, z) \ - ({ \ - const typeof(x) _c = MAX(x, y); \ - MAX(_c, z); \ - }) - -#define MAX4(x, y, z, a) \ - ({ \ - const typeof(x) _d = MAX3(x, y, z); \ - MAX(_d, a); \ - }) - -#undef MIN -#define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b)) -#define __MIN(aq, a, bq, b) \ - ({ \ - const typeof(a) UNIQ_T(A, aq) = (a); \ - const typeof(b) UNIQ_T(B, bq) = (b); \ - UNIQ_T(A, aq) < UNIQ_T(B, bq) ? UNIQ_T(A, aq) : UNIQ_T(B, bq); \ - }) - -/* evaluates to (void) if _A or _B are not constant or of different types */ -#define CONST_MIN(_A, _B) \ - (__builtin_choose_expr( \ - __builtin_constant_p(_A) && \ - __builtin_constant_p(_B) && \ - __builtin_types_compatible_p(typeof(_A), typeof(_B)), \ - ((_A) < (_B)) ? (_A) : (_B), \ - VOID_0)) - -#define MIN3(x, y, z) \ - ({ \ - const typeof(x) _c = MIN(x, y); \ - MIN(_c, z); \ - }) - -#define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b)) -#define __LESS_BY(aq, a, bq, b) \ - ({ \ - const typeof(a) UNIQ_T(A, aq) = (a); \ - const typeof(b) UNIQ_T(B, bq) = (b); \ - UNIQ_T(A, aq) > UNIQ_T(B, bq) ? UNIQ_T(A, aq) - UNIQ_T(B, bq) : 0; \ - }) - -#define CMP(a, b) __CMP(UNIQ, (a), UNIQ, (b)) -#define __CMP(aq, a, bq, b) \ - ({ \ - const typeof(a) UNIQ_T(A, aq) = (a); \ - const typeof(b) UNIQ_T(B, bq) = (b); \ - UNIQ_T(A, aq) < UNIQ_T(B, bq) ? -1 : \ - UNIQ_T(A, aq) > UNIQ_T(B, bq) ? 1 : 0; \ - }) - -#undef CLAMP -#define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high)) -#define __CLAMP(xq, x, lowq, low, highq, high) \ - ({ \ - const typeof(x) UNIQ_T(X, xq) = (x); \ - const typeof(low) UNIQ_T(LOW, lowq) = (low); \ - const typeof(high) UNIQ_T(HIGH, highq) = (high); \ - UNIQ_T(X, xq) > UNIQ_T(HIGH, highq) ? \ - UNIQ_T(HIGH, highq) : \ - UNIQ_T(X, xq) < UNIQ_T(LOW, lowq) ? \ - UNIQ_T(LOW, lowq) : \ - UNIQ_T(X, xq); \ - }) - -/* [(x + y - 1) / y] suffers from an integer overflow, even though the - * computation should be possible in the given type. Therefore, we use - * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the - * quotient and the remainder, so both should be equally fast. */ -#define DIV_ROUND_UP(x, y) __DIV_ROUND_UP(UNIQ, (x), UNIQ, (y)) -#define __DIV_ROUND_UP(xq, x, yq, y) \ - ({ \ - const typeof(x) UNIQ_T(X, xq) = (x); \ - const typeof(y) UNIQ_T(Y, yq) = (y); \ - (UNIQ_T(X, xq) / UNIQ_T(Y, yq) + !!(UNIQ_T(X, xq) % UNIQ_T(Y, yq))); \ - }) - #ifdef __COVERITY__ /* Use special definitions of assertion macros in order to prevent @@ -410,16 +290,6 @@ static inline int __coverity_check_and_return__(int condition) { #define assert_not_reached(t) \ log_assert_failed_unreachable(t, PROJECT_FILE, __LINE__, __PRETTY_FUNCTION__) -#if defined(static_assert) -#define assert_cc(expr) \ - static_assert(expr, #expr) -#else -#define assert_cc(expr) \ - struct CONCATENATE(_assert_struct_, __COUNTER__) { \ - char x[(expr) ? 0 : -1]; \ - } -#endif - #define assert_return(expr, r) \ do { \ if (!assert_log(expr, #expr)) \ @@ -498,53 +368,6 @@ static inline int __coverity_check_and_return__(int condition) { #define FLAGS_SET(v, flags) \ ((~(v) & (flags)) == 0) -#define CASE_F(X) case X: -#define CASE_F_1(CASE, X) CASE_F(X) -#define CASE_F_2(CASE, X, ...) CASE(X) CASE_F_1(CASE, __VA_ARGS__) -#define CASE_F_3(CASE, X, ...) CASE(X) CASE_F_2(CASE, __VA_ARGS__) -#define CASE_F_4(CASE, X, ...) CASE(X) CASE_F_3(CASE, __VA_ARGS__) -#define CASE_F_5(CASE, X, ...) CASE(X) CASE_F_4(CASE, __VA_ARGS__) -#define CASE_F_6(CASE, X, ...) CASE(X) CASE_F_5(CASE, __VA_ARGS__) -#define CASE_F_7(CASE, X, ...) CASE(X) CASE_F_6(CASE, __VA_ARGS__) -#define CASE_F_8(CASE, X, ...) CASE(X) CASE_F_7(CASE, __VA_ARGS__) -#define CASE_F_9(CASE, X, ...) CASE(X) CASE_F_8(CASE, __VA_ARGS__) -#define CASE_F_10(CASE, X, ...) CASE(X) CASE_F_9(CASE, __VA_ARGS__) -#define CASE_F_11(CASE, X, ...) CASE(X) CASE_F_10(CASE, __VA_ARGS__) -#define CASE_F_12(CASE, X, ...) CASE(X) CASE_F_11(CASE, __VA_ARGS__) -#define CASE_F_13(CASE, X, ...) CASE(X) CASE_F_12(CASE, __VA_ARGS__) -#define CASE_F_14(CASE, X, ...) CASE(X) CASE_F_13(CASE, __VA_ARGS__) -#define CASE_F_15(CASE, X, ...) CASE(X) CASE_F_14(CASE, __VA_ARGS__) -#define CASE_F_16(CASE, X, ...) CASE(X) CASE_F_15(CASE, __VA_ARGS__) -#define CASE_F_17(CASE, X, ...) CASE(X) CASE_F_16(CASE, __VA_ARGS__) -#define CASE_F_18(CASE, X, ...) CASE(X) CASE_F_17(CASE, __VA_ARGS__) -#define CASE_F_19(CASE, X, ...) CASE(X) CASE_F_18(CASE, __VA_ARGS__) -#define CASE_F_20(CASE, X, ...) CASE(X) CASE_F_19(CASE, __VA_ARGS__) - -#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME -#define FOR_EACH_MAKE_CASE(...) \ - GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ - CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ - (CASE_F,__VA_ARGS__) - -#define IN_SET(x, ...) \ - ({ \ - bool _found = false; \ - /* If the build breaks in the line below, you need to extend the case macros. (We use "long double" as \ - * type for the array, in the hope that checkers such as ubsan don't complain that the initializers for \ - * the array are not representable by the base type. Ideally we'd use typeof(x) as base type, but that \ - * doesn't work, as we want to use this on bitfields and gcc refuses typeof() on bitfields.) */ \ - static const long double __assert_in_set[] _unused_ = { __VA_ARGS__ }; \ - assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ - switch(x) { \ - FOR_EACH_MAKE_CASE(__VA_ARGS__) \ - _found = true; \ - break; \ - default: \ - break; \ - } \ - _found; \ - }) - #define SWAP_TWO(x, y) do { \ typeof(x) _t = (x); \ (x) = (y); \ diff --git a/src/basic/meson.build b/src/basic/meson.build index b3040f5cfe..0b0982d543 100644 --- a/src/basic/meson.build +++ b/src/basic/meson.build @@ -381,6 +381,7 @@ run_target( libbasic = static_library( 'basic', basic_sources, + fundamental_sources, include_directories : basic_includes, dependencies : [versiondep, threads, diff --git a/src/basic/string-util.c b/src/basic/string-util.c index 3f663e4ac0..7f7122c1f1 100644 --- a/src/basic/string-util.c +++ b/src/basic/string-util.c @@ -20,64 +20,6 @@ #include "utf8.h" #include "util.h" -int strcmp_ptr(const char *a, const char *b) { - /* Like strcmp(), but tries to make sense of NULL pointers */ - - if (a && b) - return strcmp(a, b); - return CMP(a, b); /* Direct comparison of pointers, one of which is NULL */ -} - -int strcasecmp_ptr(const char *a, const char *b) { - /* Like strcasecmp(), but tries to make sense of NULL pointers */ - - if (a && b) - return strcasecmp(a, b); - return CMP(a, b); /* Direct comparison of pointers, one of which is NULL */ -} - -char* endswith(const char *s, const char *postfix) { - size_t sl, pl; - - assert(s); - assert(postfix); - - sl = strlen(s); - pl = strlen(postfix); - - if (pl == 0) - return (char*) s + sl; - - if (sl < pl) - return NULL; - - if (memcmp(s + sl - pl, postfix, pl) != 0) - return NULL; - - return (char*) s + sl - pl; -} - -char* endswith_no_case(const char *s, const char *postfix) { - size_t sl, pl; - - assert(s); - assert(postfix); - - sl = strlen(s); - pl = strlen(postfix); - - if (pl == 0) - return (char*) s + sl; - - if (sl < pl) - return NULL; - - if (strcasecmp(s + sl - pl, postfix) != 0) - return NULL; - - return (char*) s + sl - pl; -} - char* first_word(const char *s, const char *word) { size_t sl, wl; const char *p; diff --git a/src/basic/string-util.h b/src/basic/string-util.h index 3ff21e42a4..cb2881b64d 100644 --- a/src/basic/string-util.h +++ b/src/basic/string-util.h @@ -7,6 +7,7 @@ #include "alloc-util.h" #include "macro.h" +#include "string-util-fundamental.h" /* What is interpreted as whitespace? */ #define WHITESPACE " \t\n\r" @@ -21,22 +22,6 @@ #define ALPHANUMERICAL LETTERS DIGITS #define HEXDIGITS DIGITS "abcdefABCDEF" -#define streq(a,b) (strcmp((a),(b)) == 0) -#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0) -#define strcaseeq(a,b) (strcasecmp((a),(b)) == 0) -#define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0) - -int strcmp_ptr(const char *a, const char *b) _pure_; -int strcasecmp_ptr(const char *a, const char *b) _pure_; - -static inline bool streq_ptr(const char *a, const char *b) { - return strcmp_ptr(a, b) == 0; -} - -static inline bool strcaseeq_ptr(const char *a, const char *b) { - return strcasecmp_ptr(a, b) == 0; -} - static inline char* strstr_ptr(const char *haystack, const char *needle) { if (!haystack || !needle) return NULL; @@ -55,10 +40,6 @@ static inline const char *strna(const char *s) { return s ?: "n/a"; } -static inline const char* yes_no(bool b) { - return b ? "yes" : "no"; -} - static inline const char* true_false(bool b) { return b ? "true" : "false"; } @@ -75,10 +56,6 @@ static inline const char* enable_disable(bool b) { return b ? "enable" : "disable"; } -static inline bool isempty(const char *p) { - return !p || !p[0]; -} - static inline const char *empty_to_null(const char *p) { return isempty(p) ? NULL : p; } @@ -97,29 +74,6 @@ static inline const char *empty_or_dash_to_null(const char *p) { return empty_or_dash(p) ? NULL : p; } -static inline char *startswith(const char *s, const char *prefix) { - size_t l; - - l = strlen(prefix); - if (strncmp(s, prefix, l) == 0) - return (char*) s + l; - - return NULL; -} - -static inline char *startswith_no_case(const char *s, const char *prefix) { - size_t l; - - l = strlen(prefix); - if (strncasecmp(s, prefix, l) == 0) - return (char*) s + l; - - return NULL; -} - -char *endswith(const char *s, const char *postfix) _pure_; -char *endswith_no_case(const char *s, const char *postfix) _pure_; - char *first_word(const char *s, const char *word) _pure_; char *strnappend(const char *s, const char *suffix, size_t length); diff --git a/src/boot/efi/boot.c b/src/boot/efi/boot.c index 3ba326586b..5f2e8f4b7c 100644 --- a/src/boot/efi/boot.c +++ b/src/boot/efi/boot.c @@ -7,9 +7,9 @@ #include "console.h" #include "crc32.h" #include "disk.h" +#include "efi-loader-features.h" #include "graphics.h" #include "linux.h" -#include "loader-features.h" #include "measure.h" #include "pe.h" #include "random-seed.h" diff --git a/src/boot/efi/meson.build b/src/boot/efi/meson.build index 177957e76a..fdbbed6f83 100644 --- a/src/boot/efi/meson.build +++ b/src/boot/efi/meson.build @@ -145,6 +145,8 @@ if have_gnu_efi '-Wno-missing-field-initializers', '-isystem', efi_incdir, '-isystem', join_paths(efi_incdir, gnu_efi_path_arch), + '-I', fundamental_path, + '-DSD_BOOT', '-include', efi_config_h, '-include', version_h] if efi_arch == 'x86_64' @@ -194,17 +196,17 @@ if have_gnu_efi systemd_boot_objects = [] stub_objects = [] - foreach file : common_sources + systemd_boot_sources + stub_sources - o_file = custom_target(file + '.o', + foreach file : fundamental_source_paths + common_sources + systemd_boot_sources + stub_sources + o_file = custom_target(file.split('/')[-1] + '.o', input : file, - output : file + '.o', + output : file.split('/')[-1] + '.o', command : efi_cc + ['-c', '@INPUT@', '-o', '@OUTPUT@'] + compile_args, - depend_files : efi_headers) - if (common_sources + systemd_boot_sources).contains(file) + depend_files : efi_headers + fundamental_headers) + if (fundamental_source_paths + common_sources + systemd_boot_sources).contains(file) systemd_boot_objects += o_file endif - if (common_sources + stub_sources).contains(file) + if (fundamental_source_paths + common_sources + stub_sources).contains(file) stub_objects += o_file endif endforeach diff --git a/src/boot/efi/util.c b/src/boot/efi/util.c index 74dc8de9c8..06fbd500e5 100644 --- a/src/boot/efi/util.c +++ b/src/boot/efi/util.c @@ -369,62 +369,6 @@ CHAR8 *strchra(CHAR8 *s, CHAR8 c) { return NULL; } -const CHAR16 *startswith(const CHAR16 *s, const CHAR16 *prefix) { - UINTN l; - - l = StrLen(prefix); - if (StrnCmp(s, prefix, l) == 0) - return s + l; - - return NULL; -} - -const CHAR16 *endswith(const CHAR16 *s, const CHAR16 *postfix) { - UINTN sl, pl; - - sl = StrLen(s); - pl = StrLen(postfix); - - if (pl == 0) - return s + sl; - - if (sl < pl) - return NULL; - - if (StrnCmp(s + sl - pl, postfix, pl) != 0) - return NULL; - - return s + sl - pl; -} - -const CHAR16 *startswith_no_case(const CHAR16 *s, const CHAR16 *prefix) { - UINTN l; - - l = StrLen(prefix); - if (StriCmp(s, prefix) == 0) - return s + l; - - return NULL; -} - -const CHAR16 *endswith_no_case(const CHAR16 *s, const CHAR16 *postfix) { - UINTN sl, pl; - - sl = StrLen(s); - pl = StrLen(postfix); - - if (pl == 0) - return s + sl; - - if (sl < pl) - return NULL; - - if (StriCmp(s + sl - pl, postfix) != 0) - return NULL; - - return s + sl - pl; -} - EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **ret, UINTN *ret_size) { _cleanup_(FileHandleClosep) EFI_FILE_HANDLE handle = NULL; _cleanup_freepool_ CHAR8 *buf = NULL; diff --git a/src/boot/efi/util.h b/src/boot/efi/util.h index a21e84ecdc..6fe61ac457 100644 --- a/src/boot/efi/util.h +++ b/src/boot/efi/util.h @@ -4,17 +4,14 @@ #include #include -#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) +#include "string-util-fundamental.h" + #define OFFSETOF(x,y) __builtin_offsetof(x,y) static inline UINTN ALIGN_TO(UINTN l, UINTN ali) { return ((l + ali - 1) & ~(ali - 1)); } -static inline const CHAR16 *yes_no(BOOLEAN b) { - return b ? L"yes" : L"no"; -} - EFI_STATUS parse_boolean(const CHAR8 *v, BOOLEAN *b); UINT64 ticks_read(void); @@ -39,12 +36,6 @@ CHAR8 *strchra(CHAR8 *s, CHAR8 c); CHAR16 *stra_to_path(CHAR8 *stra); CHAR16 *stra_to_str(CHAR8 *stra); -const CHAR16 *startswith(const CHAR16 *s, const CHAR16 *prefix); -const CHAR16 *endswith(const CHAR16 *s, const CHAR16 *postfix); - -const CHAR16 *startswith_no_case(const CHAR16 *s, const CHAR16 *prefix); -const CHAR16 *endswith_no_case(const CHAR16 *s, const CHAR16 *postfix); - EFI_STATUS file_read(EFI_FILE_HANDLE dir, const CHAR16 *name, UINTN off, UINTN size, CHAR8 **content, UINTN *content_size); static inline void FreePoolp(void *p) { @@ -56,7 +47,6 @@ static inline void FreePoolp(void *p) { FreePool(q); } -#define _cleanup_(x) __attribute__((__cleanup__(x))) #define _cleanup_freepool_ _cleanup_(FreePoolp) static inline void FileHandleClosep(EFI_FILE_HANDLE *handle) { @@ -78,11 +68,4 @@ static inline void FileHandleClosep(EFI_FILE_HANDLE *handle) { #define UINTN_MAX (~(UINTN)0) #define INTN_MAX ((INTN)(UINTN_MAX>>1)) -#define TAKE_PTR(ptr) \ - ({ \ - typeof(ptr) _ptr_ = (ptr); \ - (ptr) = NULL; \ - _ptr_; \ - }) - EFI_STATUS log_oom(void); diff --git a/src/boot/efi/loader-features.h b/src/fundamental/efi-loader-features.h similarity index 100% rename from src/boot/efi/loader-features.h rename to src/fundamental/efi-loader-features.h diff --git a/src/fundamental/macro-fundamental.h b/src/fundamental/macro-fundamental.h new file mode 100644 index 0000000000..790920eb23 --- /dev/null +++ b/src/fundamental/macro-fundamental.h @@ -0,0 +1,201 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +#pragma once + +#ifndef SD_BOOT +#include +#endif + +#include "type.h" + +#define _const_ __attribute__((__const__)) +#define _pure_ __attribute__((__pure__)) +#define _unused_ __attribute__((__unused__)) +#define _cleanup_(x) __attribute__((__cleanup__(x))) + +#ifndef __COVERITY__ +# define VOID_0 ((void)0) +#else +# define VOID_0 ((void*)0) +#endif + +#define ELEMENTSOF(x) \ + (__builtin_choose_expr( \ + !__builtin_types_compatible_p(typeof(x), typeof(&*(x))), \ + sizeof(x)/sizeof((x)[0]), \ + VOID_0)) + +#define XCONCATENATE(x, y) x ## y +#define CONCATENATE(x, y) XCONCATENATE(x, y) + +#ifdef SD_BOOT +#define assert(expr) do {} while (false) +#endif + +#if defined(static_assert) +#define assert_cc(expr) \ + static_assert(expr, #expr) +#else +#define assert_cc(expr) \ + struct CONCATENATE(_assert_struct_, __COUNTER__) { \ + char x[(expr) ? 0 : -1]; \ + } +#endif + +#define UNIQ_T(x, uniq) CONCATENATE(__unique_prefix_, CONCATENATE(x, uniq)) +#define UNIQ __COUNTER__ + +#undef MAX +#define MAX(a, b) __MAX(UNIQ, (a), UNIQ, (b)) +#define __MAX(aq, a, bq, b) \ + ({ \ + const typeof(a) UNIQ_T(A, aq) = (a); \ + const typeof(b) UNIQ_T(B, bq) = (b); \ + UNIQ_T(A, aq) > UNIQ_T(B, bq) ? UNIQ_T(A, aq) : UNIQ_T(B, bq); \ + }) + +/* evaluates to (void) if _A or _B are not constant or of different types */ +#define CONST_MAX(_A, _B) \ + (__builtin_choose_expr( \ + __builtin_constant_p(_A) && \ + __builtin_constant_p(_B) && \ + __builtin_types_compatible_p(typeof(_A), typeof(_B)), \ + ((_A) > (_B)) ? (_A) : (_B), \ + VOID_0)) + +/* takes two types and returns the size of the larger one */ +#define MAXSIZE(A, B) (sizeof(union _packed_ { typeof(A) a; typeof(B) b; })) + +#define MAX3(x, y, z) \ + ({ \ + const typeof(x) _c = MAX(x, y); \ + MAX(_c, z); \ + }) + +#define MAX4(x, y, z, a) \ + ({ \ + const typeof(x) _d = MAX3(x, y, z); \ + MAX(_d, a); \ + }) + +#undef MIN +#define MIN(a, b) __MIN(UNIQ, (a), UNIQ, (b)) +#define __MIN(aq, a, bq, b) \ + ({ \ + const typeof(a) UNIQ_T(A, aq) = (a); \ + const typeof(b) UNIQ_T(B, bq) = (b); \ + UNIQ_T(A, aq) < UNIQ_T(B, bq) ? UNIQ_T(A, aq) : UNIQ_T(B, bq); \ + }) + +/* evaluates to (void) if _A or _B are not constant or of different types */ +#define CONST_MIN(_A, _B) \ + (__builtin_choose_expr( \ + __builtin_constant_p(_A) && \ + __builtin_constant_p(_B) && \ + __builtin_types_compatible_p(typeof(_A), typeof(_B)), \ + ((_A) < (_B)) ? (_A) : (_B), \ + VOID_0)) + +#define MIN3(x, y, z) \ + ({ \ + const typeof(x) _c = MIN(x, y); \ + MIN(_c, z); \ + }) + +#define LESS_BY(a, b) __LESS_BY(UNIQ, (a), UNIQ, (b)) +#define __LESS_BY(aq, a, bq, b) \ + ({ \ + const typeof(a) UNIQ_T(A, aq) = (a); \ + const typeof(b) UNIQ_T(B, bq) = (b); \ + UNIQ_T(A, aq) > UNIQ_T(B, bq) ? UNIQ_T(A, aq) - UNIQ_T(B, bq) : 0; \ + }) + +#define CMP(a, b) __CMP(UNIQ, (a), UNIQ, (b)) +#define __CMP(aq, a, bq, b) \ + ({ \ + const typeof(a) UNIQ_T(A, aq) = (a); \ + const typeof(b) UNIQ_T(B, bq) = (b); \ + UNIQ_T(A, aq) < UNIQ_T(B, bq) ? -1 : \ + UNIQ_T(A, aq) > UNIQ_T(B, bq) ? 1 : 0; \ + }) + +#undef CLAMP +#define CLAMP(x, low, high) __CLAMP(UNIQ, (x), UNIQ, (low), UNIQ, (high)) +#define __CLAMP(xq, x, lowq, low, highq, high) \ + ({ \ + const typeof(x) UNIQ_T(X, xq) = (x); \ + const typeof(low) UNIQ_T(LOW, lowq) = (low); \ + const typeof(high) UNIQ_T(HIGH, highq) = (high); \ + UNIQ_T(X, xq) > UNIQ_T(HIGH, highq) ? \ + UNIQ_T(HIGH, highq) : \ + UNIQ_T(X, xq) < UNIQ_T(LOW, lowq) ? \ + UNIQ_T(LOW, lowq) : \ + UNIQ_T(X, xq); \ + }) + +/* [(x + y - 1) / y] suffers from an integer overflow, even though the + * computation should be possible in the given type. Therefore, we use + * [x / y + !!(x % y)]. Note that on "Real CPUs" a division returns both the + * quotient and the remainder, so both should be equally fast. */ +#define DIV_ROUND_UP(x, y) __DIV_ROUND_UP(UNIQ, (x), UNIQ, (y)) +#define __DIV_ROUND_UP(xq, x, yq, y) \ + ({ \ + const typeof(x) UNIQ_T(X, xq) = (x); \ + const typeof(y) UNIQ_T(Y, yq) = (y); \ + (UNIQ_T(X, xq) / UNIQ_T(Y, yq) + !!(UNIQ_T(X, xq) % UNIQ_T(Y, yq))); \ + }) + +#define CASE_F(X) case X: +#define CASE_F_1(CASE, X) CASE_F(X) +#define CASE_F_2(CASE, X, ...) CASE(X) CASE_F_1(CASE, __VA_ARGS__) +#define CASE_F_3(CASE, X, ...) CASE(X) CASE_F_2(CASE, __VA_ARGS__) +#define CASE_F_4(CASE, X, ...) CASE(X) CASE_F_3(CASE, __VA_ARGS__) +#define CASE_F_5(CASE, X, ...) CASE(X) CASE_F_4(CASE, __VA_ARGS__) +#define CASE_F_6(CASE, X, ...) CASE(X) CASE_F_5(CASE, __VA_ARGS__) +#define CASE_F_7(CASE, X, ...) CASE(X) CASE_F_6(CASE, __VA_ARGS__) +#define CASE_F_8(CASE, X, ...) CASE(X) CASE_F_7(CASE, __VA_ARGS__) +#define CASE_F_9(CASE, X, ...) CASE(X) CASE_F_8(CASE, __VA_ARGS__) +#define CASE_F_10(CASE, X, ...) CASE(X) CASE_F_9(CASE, __VA_ARGS__) +#define CASE_F_11(CASE, X, ...) CASE(X) CASE_F_10(CASE, __VA_ARGS__) +#define CASE_F_12(CASE, X, ...) CASE(X) CASE_F_11(CASE, __VA_ARGS__) +#define CASE_F_13(CASE, X, ...) CASE(X) CASE_F_12(CASE, __VA_ARGS__) +#define CASE_F_14(CASE, X, ...) CASE(X) CASE_F_13(CASE, __VA_ARGS__) +#define CASE_F_15(CASE, X, ...) CASE(X) CASE_F_14(CASE, __VA_ARGS__) +#define CASE_F_16(CASE, X, ...) CASE(X) CASE_F_15(CASE, __VA_ARGS__) +#define CASE_F_17(CASE, X, ...) CASE(X) CASE_F_16(CASE, __VA_ARGS__) +#define CASE_F_18(CASE, X, ...) CASE(X) CASE_F_17(CASE, __VA_ARGS__) +#define CASE_F_19(CASE, X, ...) CASE(X) CASE_F_18(CASE, __VA_ARGS__) +#define CASE_F_20(CASE, X, ...) CASE(X) CASE_F_19(CASE, __VA_ARGS__) + +#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME +#define FOR_EACH_MAKE_CASE(...) \ + GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ + CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ + (CASE_F,__VA_ARGS__) + +#define IN_SET(x, ...) \ + ({ \ + sd_bool _found = false; \ + /* If the build breaks in the line below, you need to extend the case macros. (We use "long double" as \ + * type for the array, in the hope that checkers such as ubsan don't complain that the initializers for \ + * the array are not representable by the base type. Ideally we'd use typeof(x) as base type, but that \ + * doesn't work, as we want to use this on bitfields and gcc refuses typeof() on bitfields.) */ \ + static const long double __assert_in_set[] _unused_ = { __VA_ARGS__ }; \ + assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ + switch(x) { \ + FOR_EACH_MAKE_CASE(__VA_ARGS__) \ + _found = true; \ + break; \ + default: \ + break; \ + } \ + _found; \ + }) + +/* Takes inspiration from Rust's Option::take() method: reads and returns a pointer, but at the same time + * resets it to NULL. See: https://doc.rust-lang.org/std/option/enum.Option.html#method.take */ +#define TAKE_PTR(ptr) \ + ({ \ + typeof(ptr) _ptr_ = (ptr); \ + (ptr) = NULL; \ + _ptr_; \ + }) diff --git a/src/fundamental/meson.build b/src/fundamental/meson.build new file mode 100644 index 0000000000..40b9ab8e2c --- /dev/null +++ b/src/fundamental/meson.build @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later + +fundamental_path = meson.current_source_dir() + +fundamental_headers = files( + 'efi-loader-features.h', + 'macro-fundamental.h', + 'string-util-fundamental.h', + 'type.h') + +sources = ''' + string-util-fundamental.c +'''.split() + +# for sd-boot +fundamental_source_paths = [] +foreach s : sources + fundamental_source_paths += join_paths(meson.current_source_dir(), s) +endforeach + +# for libbasic +fundamental_sources = files(sources) + fundamental_headers diff --git a/src/fundamental/string-util-fundamental.c b/src/fundamental/string-util-fundamental.c new file mode 100644 index 0000000000..a94bce6e3e --- /dev/null +++ b/src/fundamental/string-util-fundamental.c @@ -0,0 +1,76 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#ifndef SD_BOOT +#include "macro.h" +#endif +#include "string-util-fundamental.h" + +sd_char *startswith(const sd_char *s, const sd_char *prefix) { + sd_size_t l; + + assert(s); + assert(prefix); + + l = strlen(prefix); + if (!strneq(s, prefix, l)) + return NULL; + + return (sd_char*) s + l; +} + +#ifndef SD_BOOT +sd_char *startswith_no_case(const sd_char *s, const sd_char *prefix) { + sd_size_t l; + + assert(s); + assert(prefix); + + l = strlen(prefix); + if (!strncaseeq(s, prefix, l)) + return NULL; + + return (sd_char*) s + l; +} +#endif + +sd_char* endswith(const sd_char *s, const sd_char *postfix) { + sd_size_t sl, pl; + + assert(s); + assert(postfix); + + sl = strlen(s); + pl = strlen(postfix); + + if (pl == 0) + return (sd_char*) s + sl; + + if (sl < pl) + return NULL; + + if (strcmp(s + sl - pl, postfix) != 0) + return NULL; + + return (sd_char*) s + sl - pl; +} + +sd_char* endswith_no_case(const sd_char *s, const sd_char *postfix) { + sd_size_t sl, pl; + + assert(s); + assert(postfix); + + sl = strlen(s); + pl = strlen(postfix); + + if (pl == 0) + return (sd_char*) s + sl; + + if (sl < pl) + return NULL; + + if (strcasecmp(s + sl - pl, postfix) != 0) + return NULL; + + return (sd_char*) s + sl - pl; +} diff --git a/src/fundamental/string-util-fundamental.h b/src/fundamental/string-util-fundamental.h new file mode 100644 index 0000000000..b1f067fc56 --- /dev/null +++ b/src/fundamental/string-util-fundamental.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +#pragma once + +#ifdef SD_BOOT +#include +#include +#else +#include +#endif + +#include "macro-fundamental.h" + +#ifdef SD_BOOT +#define strlen(a) StrLen((a)) +#define strcmp(a, b) StrCmp((a), (b)) +#define strncmp(a, b, n) StrnCmp((a), (b), (n)) +#define strcasecmp(a, b) StriCmp((a), (b)) +#define STR_C(str) (L ## str) +#else +#define STR_C(str) (str) +#endif + +#define streq(a,b) (strcmp((a),(b)) == 0) +#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0) +#define strcaseeq(a,b) (strcasecmp((a),(b)) == 0) +#ifndef SD_BOOT +#define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0) +#endif + +static inline sd_int strcmp_ptr(const sd_char *a, const sd_char *b) { + if (a && b) + return strcmp(a, b); + + return CMP(a, b); +} + +static inline sd_int strcasecmp_ptr(const sd_char *a, const sd_char *b) { + if (a && b) + return strcasecmp(a, b); + + return CMP(a, b); +} + +static inline sd_bool streq_ptr(const sd_char *a, const sd_char *b) { + return strcmp_ptr(a, b) == 0; +} + +static inline sd_bool strcaseeq_ptr(const sd_char *a, const sd_char *b) { + return strcasecmp_ptr(a, b) == 0; +} + +sd_char *startswith(const sd_char *s, const sd_char *prefix) _pure_; +#ifndef SD_BOOT +sd_char *startswith_no_case(const sd_char *s, const sd_char *prefix) _pure_; +#endif +sd_char *endswith(const sd_char *s, const sd_char *postfix) _pure_; +sd_char *endswith_no_case(const sd_char *s, const sd_char *postfix) _pure_; + +static inline sd_bool isempty(const sd_char *a) { + return !a || a[0] == '\0'; +} + +static inline const sd_char *yes_no(sd_bool b) { + return b ? STR_C("yes") : STR_C("no"); +} diff --git a/src/fundamental/type.h b/src/fundamental/type.h new file mode 100644 index 0000000000..f645d2de7f --- /dev/null +++ b/src/fundamental/type.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +#pragma once + +#ifdef SD_BOOT +#include + +typedef BOOLEAN sd_bool; +typedef CHAR16 sd_char; +typedef INTN sd_int; +typedef UINTN sd_size_t; + +#define true TRUE +#define false FALSE +#else +#include +#include + +typedef bool sd_bool; +typedef char sd_char; +typedef int sd_int; +typedef size_t sd_size_t; +#endif diff --git a/src/shared/efi-loader-features.h b/src/shared/efi-loader-features.h deleted file mode 120000 index 481a053954..0000000000 --- a/src/shared/efi-loader-features.h +++ /dev/null @@ -1 +0,0 @@ -../boot/efi/loader-features.h \ No newline at end of file diff --git a/src/shared/meson.build b/src/shared/meson.build index b1a8ea9ac6..4e47e15c09 100644 --- a/src/shared/meson.build +++ b/src/shared/meson.build @@ -89,7 +89,6 @@ shared_sources = files(''' dns-domain.h dropin.c dropin.h - efi-loader-features.h efi-loader.c efi-loader.h enable-mempool.c From 87b7d9b6ff23ec10b66bf53efeabf16ad85d7ad8 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 4 Feb 2021 05:55:59 +0900 Subject: [PATCH 2/3] string-util: introduce strverscmp_improved() Unfortunately, strverscmp() from libc or str_verscmp() do not correctly handle pre-release version, e.g. 247 vs 247~rc1. This implement a new comparison function, which is based on the RPM's rpmvercmp(). --- src/fundamental/string-util-fundamental.c | 158 ++++++++++++++++++++++ src/fundamental/string-util-fundamental.h | 2 + src/test/test-string-util.c | 79 +++++++++++ 3 files changed, 239 insertions(+) diff --git a/src/fundamental/string-util-fundamental.c b/src/fundamental/string-util-fundamental.c index a94bce6e3e..9f14597fef 100644 --- a/src/fundamental/string-util-fundamental.c +++ b/src/fundamental/string-util-fundamental.c @@ -1,6 +1,8 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #ifndef SD_BOOT +#include + #include "macro.h" #endif #include "string-util-fundamental.h" @@ -74,3 +76,159 @@ sd_char* endswith_no_case(const sd_char *s, const sd_char *postfix) { return (sd_char*) s + sl - pl; } + +#ifdef SD_BOOT +static sd_bool isdigit(sd_char a) { + return a >= '0' && a <= '9'; +} +#endif + +static sd_bool is_alpha(sd_char a) { + /* Locale independent version of isalpha(). */ + return (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z'); +} + +static sd_bool is_valid_version_char(sd_char a) { + return isdigit(a) || is_alpha(a) || IN_SET(a, '~', '-', '^', '.'); +} + +sd_int strverscmp_improved(const sd_char *a, const sd_char *b) { + + /* This is based on RPM's rpmvercmp(). But this explicitly handles '-' and '.', as we usually + * want to directly compare strings which contain both version and release; e.g. + * '247.2-3.1.fc33.x86_64' or '5.11.0-0.rc5.20210128git76c057c84d28.137.fc34'. + * Unlike rpmvercmp(), this distiguishes e.g. 123a and 123.a, and 123a is newer. + * + * This splits the input strings into segments. Each segment is numeric or alpha, and may be + * prefixed with the following: + * '~' : used for pre-releases, a segment prefixed with this is the oldest, + * '-' : used for the separator between version and release, + * '^' : used for patched releases, a segment with this is newer than one with '-'. + * '.' : used for point releases. + * Note, no prefix segment is the newest. All non-supported characters are dropped, and + * handled as a separator of segments, e.g., 123_a is equivalent to 123a. + * + * By using this, version strings can be sorted like following: + * (older) 122.1 + * ^ 123~rc1-1 + * | 123 + * | 123-a + * | 123-a.1 + * | 123-1 + * | 123-1.1 + * | 123^post1 + * | 123.a-1 + * | 123.1-1 + * v 123a-1 + * (newer) 124-1 + */ + + if (isempty(a) || isempty(b)) + return strcmp_ptr(a, b); + + for (;;) { + const sd_char *aa, *bb; + sd_int r; + + /* Drop leading invalid characters. */ + while (*a != '\0' && !is_valid_version_char(*a)) + a++; + while (*b != '\0' && !is_valid_version_char(*b)) + b++; + + /* Handle '~'. Used for pre-releases, e.g. 123~rc1, or 4.5~alpha1 */ + if (*a == '~' || *b == '~') { + /* The string prefixed with '~' is older. */ + r = CMP(*a != '~', *b != '~'); + if (r != 0) + return r; + + /* Now both strings are prefixed with '~'. Compare remaining strings. */ + a++; + b++; + } + + /* If at least one string reaches the end, then longer is newer. + * Note that except for '~' prefixed segments, a string has more segments is newer. + * So, this check must be after the '~' check. */ + if (*a == '\0' || *b == '\0') + return strcmp(a, b); + + /* Handle '-', which separates version and release, e.g 123.4-3.1.fc33.x86_64 */ + if (*a == '-' || *b == '-') { + /* The string prefixed with '-' is older (e.g., 123-9 vs 123.1-1) */ + r = CMP(*a != '-', *b != '-'); + if (r != 0) + return r; + + a++; + b++; + } + + /* Handle '^'. Used for patched release. */ + if (*a == '^' || *b == '^') { + r = CMP(*a != '^', *b != '^'); + if (r != 0) + return r; + + a++; + b++; + } + + /* Handle '.'. Used for point releases. */ + if (*a == '.' || *b == '.') { + r = CMP(*a != '.', *b != '.'); + if (r != 0) + return r; + + a++; + b++; + } + + if (isdigit(*a) || isdigit(*b)) { + /* Skip leading '0', to make 00123 equivalent to 123. */ + while (*a == '0') + a++; + while (*b == '0') + b++; + + /* Find the leading numeric segments. One may be an empty string. So, + * numeric segments are always newer than alpha segments. */ + for (aa = a; *aa != '\0' && isdigit(*aa); aa++) + ; + for (bb = b; *bb != '\0' && isdigit(*bb); bb++) + ; + + /* To compare numeric segments without parsing their values, first compare the + * lengths of the segments. Eg. 12345 vs 123, longer is newer. */ + r = CMP(aa - a, bb - b); + if (r != 0) + return r; + + /* Then, compare them as strings. */ + r = strncmp(a, b, aa - a); + if (r != 0) + return r; + } else { + /* Find the leading non-numeric segments. */ + for (aa = a; *aa != '\0' && is_alpha(*aa); aa++) + ; + for (bb = b; *bb != '\0' && is_alpha(*bb); bb++) + ; + + /* Note that the segments are usually not NUL-terminated. */ + r = strncmp(a, b, MIN(aa - a, bb - b)); + if (r != 0) + return r; + + /* Longer is newer, e.g. abc vs abcde. */ + r = CMP(aa - a, bb - b); + if (r != 0) + return r; + } + + /* The current segments are equivalent. Let's compare the next one. */ + a = aa; + b = bb; + } +} diff --git a/src/fundamental/string-util-fundamental.h b/src/fundamental/string-util-fundamental.h index b1f067fc56..407cede48d 100644 --- a/src/fundamental/string-util-fundamental.h +++ b/src/fundamental/string-util-fundamental.h @@ -63,3 +63,5 @@ static inline sd_bool isempty(const sd_char *a) { static inline const sd_char *yes_no(sd_bool b) { return b ? STR_C("yes") : STR_C("no"); } + +sd_int strverscmp_improved(const sd_char *a, const sd_char *b); diff --git a/src/test/test-string-util.c b/src/test/test-string-util.c index 67f083ff93..12eafaaf22 100644 --- a/src/test/test-string-util.c +++ b/src/test/test-string-util.c @@ -886,6 +886,84 @@ static void test_string_contains_word(void) { assert_se(!string_contains_word("a:b:cc", ":#", ":cc")); } +static void test_strverscmp_improved_one(const char *newer, const char *older) { + log_info("/* %s(%s, %s) */", __func__, strnull(newer), strnull(older)); + + assert_se(strverscmp_improved(newer, newer) == 0); + assert_se(strverscmp_improved(newer, older) > 0); + assert_se(strverscmp_improved(older, newer) < 0); + assert_se(strverscmp_improved(older, older) == 0); +} + +static void test_strverscmp_improved(void) { + static const char * const versions[] = { + "", + "~1", + "ab", + "abb", + "abc", + "0001", + "002", + "12", + "122", + "122.9", + "123~rc1", + "123", + "123-a", + "123-a.1", + "123-a1", + "123-a1.1", + "123-3", + "123-3.1", + "123^patch1", + "123^1", + "123.a-1" + "123.1-1", + "123a-1", + "124", + NULL, + }; + const char * const *p, * const *q; + + STRV_FOREACH(p, versions) + STRV_FOREACH(q, p + 1) + test_strverscmp_improved_one(*q, *p); + + test_strverscmp_improved_one("123.45-67.89", "123.45-67.88"); + test_strverscmp_improved_one("123.45-67.89a", "123.45-67.89"); + test_strverscmp_improved_one("123.45-67.89", "123.45-67.ab"); + test_strverscmp_improved_one("123.45-67.89", "123.45-67.9"); + test_strverscmp_improved_one("123.45-67.89", "123.45-67"); + test_strverscmp_improved_one("123.45-67.89", "123.45-66.89"); + test_strverscmp_improved_one("123.45-67.89", "123.45-9.99"); + test_strverscmp_improved_one("123.45-67.89", "123.42-99.99"); + test_strverscmp_improved_one("123.45-67.89", "123-99.99"); + + /* '~' : pre-releases */ + test_strverscmp_improved_one("123.45-67.89", "123~rc1-99.99"); + test_strverscmp_improved_one("123-45.67.89", "123~rc1-99.99"); + test_strverscmp_improved_one("123~rc2-67.89", "123~rc1-99.99"); + test_strverscmp_improved_one("123^aa2-67.89", "123~rc1-99.99"); + test_strverscmp_improved_one("123aa2-67.89", "123~rc1-99.99"); + + /* '-' : separator between version and release. */ + test_strverscmp_improved_one("123.45-67.89", "123-99.99"); + test_strverscmp_improved_one("123^aa2-67.89", "123-99.99"); + test_strverscmp_improved_one("123aa2-67.89", "123-99.99"); + + /* '^' : patch releases */ + test_strverscmp_improved_one("123.45-67.89", "123^45-67.89"); + test_strverscmp_improved_one("123^aa2-67.89", "123^aa1-99.99"); + test_strverscmp_improved_one("123aa2-67.89", "123^aa2-67.89"); + + /* '.' : point release */ + test_strverscmp_improved_one("123aa2-67.89", "123.aa2-67.89"); + test_strverscmp_improved_one("123.ab2-67.89", "123.aa2-67.89"); + + /* invalid characters */ + assert_se(strverscmp_improved("123_aa2-67.89", "123aa+2-67.89") == 0); +} + int main(int argc, char *argv[]) { test_setup_logging(LOG_DEBUG); @@ -923,6 +1001,7 @@ int main(int argc, char *argv[]) { test_string_extract_line(); test_string_contains_word_strv(); test_string_contains_word(); + test_strverscmp_improved(); return 0; } From 8087644a134cd1ed52e81d41ee27d54c3bb7ad65 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 31 Jan 2021 01:12:27 +0900 Subject: [PATCH 3/3] tree-wide: replace strverscmp() and str_verscmp() with strverscmp_improved() --- src/basic/cgroup-util.c | 2 +- src/basic/util.c | 62 ----------------------------------------- src/basic/util.h | 2 -- src/boot/bootctl.c | 2 +- src/boot/efi/boot.c | 59 +-------------------------------------- src/shared/bootspec.c | 2 +- src/shared/condition.c | 2 +- src/sysext/sysext.c | 10 +++---- 8 files changed, 10 insertions(+), 131 deletions(-) diff --git a/src/basic/cgroup-util.c b/src/basic/cgroup-util.c index b567822b7e..bb20a12294 100644 --- a/src/basic/cgroup-util.c +++ b/src/basic/cgroup-util.c @@ -2164,7 +2164,7 @@ CGroupMask get_cpu_accounting_mask(void) { struct utsname u; assert_se(uname(&u) >= 0); - if (str_verscmp(u.release, "4.15") < 0) + if (strverscmp_improved(u.release, "4.15") < 0) needed_mask = CGROUP_MASK_CPU; else needed_mask = 0; diff --git a/src/basic/util.c b/src/basic/util.c index de04a01a75..955b18bd2a 100644 --- a/src/basic/util.c +++ b/src/basic/util.c @@ -227,68 +227,6 @@ int version(void) { return 0; } -/* This is a direct translation of str_verscmp from boot.c */ -static bool is_digit(int c) { - return c >= '0' && c <= '9'; -} - -static int c_order(int c) { - if (c == 0 || is_digit(c)) - return 0; - - if ((c >= 'a') && (c <= 'z')) - return c; - - return c + 0x10000; -} - -int str_verscmp(const char *s1, const char *s2) { - const char *os1, *os2; - - assert(s1); - assert(s2); - - os1 = s1; - os2 = s2; - - while (*s1 || *s2) { - int first; - - while ((*s1 && !is_digit(*s1)) || (*s2 && !is_digit(*s2))) { - int order; - - order = c_order(*s1) - c_order(*s2); - if (order != 0) - return order; - s1++; - s2++; - } - - while (*s1 == '0') - s1++; - while (*s2 == '0') - s2++; - - first = 0; - while (is_digit(*s1) && is_digit(*s2)) { - if (first == 0) - first = *s1 - *s2; - s1++; - s2++; - } - - if (is_digit(*s1)) - return 1; - if (is_digit(*s2)) - return -1; - - if (first != 0) - return first; - } - - return strcmp(os1, os2); -} - /* Turn off core dumps but only if we're running outside of a container. */ void disable_coredumps(void) { int r; diff --git a/src/basic/util.h b/src/basic/util.h index 942d773ff1..b6c51c036e 100644 --- a/src/basic/util.h +++ b/src/basic/util.h @@ -63,6 +63,4 @@ int container_get_leader(const char *machine, pid_t *pid); int version(void); -int str_verscmp(const char *s1, const char *s2); - void disable_coredumps(void); diff --git a/src/boot/bootctl.c b/src/boot/bootctl.c index 8d2be21dc5..7b759bcd02 100644 --- a/src/boot/bootctl.c +++ b/src/boot/bootctl.c @@ -471,7 +471,7 @@ static int compare_version(const char *a, const char *b) { b += strcspn(b, " "); b += strspn(b, " "); - return strverscmp(a, b); + return strverscmp_improved(a, b); } static int version_check(int fd_from, const char *from, int fd_to, const char *to) { diff --git a/src/boot/efi/boot.c b/src/boot/efi/boot.c index 5f2e8f4b7c..e0df0dcc48 100644 --- a/src/boot/efi/boot.c +++ b/src/boot/efi/boot.c @@ -914,63 +914,6 @@ static VOID config_entry_free(ConfigEntry *entry) { FreePool(entry); } -static BOOLEAN is_digit(CHAR16 c) { - return (c >= '0') && (c <= '9'); -} - -static UINTN c_order(CHAR16 c) { - if (c == '\0') - return 0; - if (is_digit(c)) - return 0; - else if ((c >= 'a') && (c <= 'z')) - return c; - else - return c + 0x10000; -} - -static INTN str_verscmp(CHAR16 *s1, CHAR16 *s2) { - CHAR16 *os1 = s1; - CHAR16 *os2 = s2; - - while (*s1 || *s2) { - INTN first; - - while ((*s1 && !is_digit(*s1)) || (*s2 && !is_digit(*s2))) { - INTN order; - - order = c_order(*s1) - c_order(*s2); - if (order != 0) - return order; - s1++; - s2++; - } - - while (*s1 == '0') - s1++; - while (*s2 == '0') - s2++; - - first = 0; - while (is_digit(*s1) && is_digit(*s2)) { - if (first == 0) - first = *s1 - *s2; - s1++; - s2++; - } - - if (is_digit(*s1)) - return 1; - if (is_digit(*s2)) - return -1; - - if (first != 0) - return first; - } - - return StrCmp(os1, os2); -} - static CHAR8 *line_get_key_value( CHAR8 *content, CHAR8 *sep, @@ -1535,7 +1478,7 @@ static INTN config_entry_compare(ConfigEntry *a, ConfigEntry *b) { if (a->tries_left == 0 && b->tries_left != 0) return -1; - r = str_verscmp(a->id, b->id); + r = strverscmp_improved(a->id, b->id); if (r != 0) return r; diff --git a/src/shared/bootspec.c b/src/shared/bootspec.c index e50408ab53..98b380476b 100644 --- a/src/shared/bootspec.c +++ b/src/shared/bootspec.c @@ -244,7 +244,7 @@ static int boot_loader_read_conf(const char *path, BootConfig *config) { } static int boot_entry_compare(const BootEntry *a, const BootEntry *b) { - return str_verscmp(a->id, b->id); + return strverscmp_improved(a->id, b->id); } static int boot_entries_find( diff --git a/src/shared/condition.c b/src/shared/condition.c index 41d3a16391..616e77994d 100644 --- a/src/shared/condition.c +++ b/src/shared/condition.c @@ -247,7 +247,7 @@ static int condition_test_kernel_version(Condition *c, char **env) { return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unexpected end of expression: %s", p); } - r = test_order(str_verscmp(u.release, s), order); + r = test_order(strverscmp_improved(u.release, s), order); } else /* No prefix? Then treat as glob string */ r = fnmatch(s, u.release, 0) == 0; diff --git a/src/sysext/sysext.c b/src/sysext/sysext.c index a17f4e2c02..1ce9939afb 100644 --- a/src/sysext/sysext.c +++ b/src/sysext/sysext.c @@ -395,9 +395,9 @@ static int merge_hierarchy( return 1; } -static int strverscmpp(char *const* a, char *const* b) { - /* usable in qsort() for sorting a string array with strverscmp() */ - return strverscmp(*a, *b); +static int strverscmp_improvedp(char *const* a, char *const* b) { + /* usable in qsort() for sorting a string array with strverscmp_improved() */ + return strverscmp_improved(*a, *b); } static int validate_version( @@ -623,8 +623,8 @@ static int merge_subprocess(Hashmap *images, const char *workspace) { return 0; } - /* Order by version sort (i.e. libc strverscmp()) */ - typesafe_qsort(extensions, n_extensions, strverscmpp); + /* Order by version sort with strverscmp_improved() */ + typesafe_qsort(extensions, n_extensions, strverscmp_improvedp); buf = strv_join(extensions, "', '"); if (!buf)