src/basic/string-util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8 ***/
   9
  10 #include <alloca.h>
  11 #include <stdbool.h>
  12 #include <stddef.h>
  13 #include <string.h>
  14
  15 #include "macro.h"
  16
  17 /* What is interpreted as whitespace? */
  18 #define WHITESPACE        " \t\n\r"
  19 #define NEWLINE           "\n\r"
  20 #define QUOTES            "\"\'"
  21 #define COMMENTS          "#;"
  22 #define GLOB_CHARS        "*?["
  23 #define DIGITS            "0123456789"
  24 #define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz"
  25 #define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  26 #define LETTERS           LOWERCASE_LETTERS UPPERCASE_LETTERS
  27 #define ALPHANUMERICAL    LETTERS DIGITS
  28 #define HEXDIGITS         DIGITS "abcdefABCDEF"
  29
  30 #define streq(a,b) (strcmp((a),(b)) == 0)
  31 #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
  32 #define strcaseeq(a,b) (strcasecmp((a),(b)) == 0)
  33 #define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0)
  34
  35 int strcmp_ptr(const char *a, const char *b) _pure_;
  36
  37 static inline bool streq_ptr(const char *a, const char *b) {
  38         return strcmp_ptr(a, b) == 0;
  39 }
  40
  41 static inline const char* strempty(const char *s) {
  42         return s ?: "";
  43 }
  44
  45 static inline const char* strnull(const char *s) {
  46         return s ?: "(null)";
  47 }
  48
  49 static inline const char *strna(const char *s) {
  50         return s ?: "n/a";
  51 }
  52
  53 static inline bool isempty(const char *p) {
  54         return !p || !p[0];
  55 }
  56
  57 static inline const char *empty_to_null(const char *p) {
  58         return isempty(p) ? NULL : p;
  59 }
  60
  61 #if 0 /// UNNEEDED by elogind
  62 static inline const char *empty_to_dash(const char *str) {
  63         return isempty(str) ? "-" : str;
  64 }
  65 #endif // 0
  66
  67 static inline char *startswith(const char *s, const char *prefix) {
  68         size_t l;
  69
  70         l = strlen(prefix);
  71         if (strncmp(s, prefix, l) == 0)
  72                 return (char*) s + l;
  73
  74         return NULL;
  75 }
  76
  77 #if 0 /// UNNEEDED by elogind
  78 static inline char *startswith_no_case(const char *s, const char *prefix) {
  79         size_t l;
  80
  81         l = strlen(prefix);
  82         if (strncasecmp(s, prefix, l) == 0)
  83                 return (char*) s + l;
  84
  85         return NULL;
  86 }
  87 #endif // 0
  88
  89 char *endswith(const char *s, const char *postfix) _pure_;
  90 char *endswith_no_case(const char *s, const char *postfix) _pure_;
  91
  92 char *first_word(const char *s, const char *word) _pure_;
  93
  94 const char* split(const char **state, size_t *l, const char *separator, bool quoted);
  95
  96 #define FOREACH_WORD(word, length, s, state)                            \
  97         _FOREACH_WORD(word, length, s, WHITESPACE, false, state)
  98
  99 #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)       \
 100         _FOREACH_WORD(word, length, s, separator, false, state)
 101
 102 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
 103         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
 104
 105 char *strappend(const char *s, const char *suffix);
 106 char *strnappend(const char *s, const char *suffix, size_t length);
 107
 108 char *strjoin_real(const char *x, ...) _sentinel_;
 109 #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
 110
 111 #define strjoina(a, ...)                                                \
 112         ({                                                              \
 113                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
 114                 char *_d_, *_p_;                                        \
 115                 size_t _len_ = 0;                                          \
 116                 size_t _i_;                                           \
 117                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 118                         _len_ += strlen(_appendees_[_i_]);              \
 119                 _p_ = _d_ = alloca(_len_ + 1);                          \
 120                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 121                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
 122                 *_p_ = 0;                                               \
 123                 _d_;                                                    \
 124         })
 125
 126 char *strstrip(char *s);
 127 #if 0 /// UNNEEDED by elogind
 128 char *delete_chars(char *s, const char *bad);
 129 #endif // 0
 130 char *delete_trailing_chars(char *s, const char *bad);
 131 char *truncate_nl(char *s);
 132
 133 #if 0 /// UNNEEDED by elogind
 134 static inline char *skip_leading_chars(const char *s, const char *bad) {
 135
 136         if (!s)
 137                 return NULL;
 138
 139         if (!bad)
 140                 bad = WHITESPACE;
 141
 142         return (char*) s + strspn(s, bad);
 143 }
 144
 145 char ascii_tolower(char x);
 146 char *ascii_strlower(char *s);
 147 char *ascii_strlower_n(char *s, size_t n);
 148
 149 char ascii_toupper(char x);
 150 char *ascii_strupper(char *s);
 151
 152 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
 153 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
 154
 155 bool chars_intersect(const char *a, const char *b) _pure_;
 156 #endif // 0
 157
 158 static inline bool _pure_ in_charset(const char *s, const char* charset) {
 159         assert(s);
 160         assert(charset);
 161         return s[strspn(s, charset)] == '\0';
 162 }
 163
 164 bool string_has_cc(const char *p, const char *ok) _pure_;
 165
 166 char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
 167 char *ellipsize(const char *s, size_t length, unsigned percent);
 168
 169 bool nulstr_contains(const char *nulstr, const char *needle);
 170
 171 char* strshorten(char *s, size_t l);
 172
 173 char *strreplace(const char *text, const char *old_string, const char *new_string);
 174
 175 char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]);
 176
 177 char *strextend_with_separator(char **x, const char *separator, ...) _sentinel_;
 178
 179 #define strextend(x, ...) strextend_with_separator(x, NULL, __VA_ARGS__)
 180
 181 char *strrep(const char *s, unsigned n);
 182
 183 int split_pair(const char *s, const char *sep, char **l, char **r);
 184
 185 int free_and_strdup(char **p, const char *s);
 186
 187 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
 188 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
 189
 190         if (needlelen <= 0)
 191                 return (void*) haystack;
 192
 193         if (haystacklen < needlelen)
 194                 return NULL;
 195
 196         assert(haystack);
 197         assert(needle);
 198
 199         return memmem(haystack, haystacklen, needle, needlelen);
 200 }
 201
 202 #if !HAVE_EXPLICIT_BZERO
 203 void explicit_bzero(void *p, size_t l);
 204 #endif
 205
 206 char *string_erase(char *x);
 207
 208 char *string_free_erase(char *s);
 209 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
 210 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)
 211
 212 bool string_is_safe(const char *p) _pure_;
 213
 214 static inline size_t strlen_ptr(const char *s) {
 215         if (!s)
 216                 return 0;
 217
 218         return strlen(s);
 219 }