src/basic/string-util.h

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