src/basic/string-util.h

   1 #pragma once
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <alloca.h>
  23 #include <stdbool.h>
  24 #include <stddef.h>
  25 #include <string.h>
  26
  27 #include "macro.h"
  28
  29 /* What is interpreted as whitespace? */
  30 #define WHITESPACE        " \t\n\r"
  31 #define NEWLINE           "\n\r"
  32 #define QUOTES            "\"\'"
  33 #define COMMENTS          "#;"
  34 #define GLOB_CHARS        "*?["
  35 #define DIGITS            "0123456789"
  36 #define LOWERCASE_LETTERS "abcdefghijklmnopqrstuvwxyz"
  37 #define UPPERCASE_LETTERS "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  38 #define LETTERS           LOWERCASE_LETTERS UPPERCASE_LETTERS
  39 #define ALPHANUMERICAL    LETTERS DIGITS
  40 #define HEXDIGITS         DIGITS "abcdefABCDEF"
  41
  42 #define streq(a,b) (strcmp((a),(b)) == 0)
  43 #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
  44 #define strcaseeq(a,b) (strcasecmp((a),(b)) == 0)
  45 #define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0)
  46
  47 int strcmp_ptr(const char *a, const char *b) _pure_;
  48
  49 static inline bool streq_ptr(const char *a, const char *b) {
  50         return strcmp_ptr(a, b) == 0;
  51 }
  52
  53 static inline const char* strempty(const char *s) {
  54         return s ? s : "";
  55 }
  56
  57 static inline const char* strnull(const char *s) {
  58         return s ? s : "(null)";
  59 }
  60
  61 static inline const char *strna(const char *s) {
  62         return s ? s : "n/a";
  63 }
  64
  65 static inline bool isempty(const char *p) {
  66         return !p || !p[0];
  67 }
  68
  69 static inline const char *empty_to_null(const char *p) {
  70         return isempty(p) ? NULL : p;
  71 }
  72
  73 static inline const char *strdash_if_empty(const char *str) {
  74         return isempty(str) ? "-" : str;
  75 }
  76
  77 static inline char *startswith(const char *s, const char *prefix) {
  78         size_t l;
  79
  80         l = strlen(prefix);
  81         if (strncmp(s, prefix, l) == 0)
  82                 return (char*) s + l;
  83
  84         return NULL;
  85 }
  86
  87 static inline char *startswith_no_case(const char *s, const char *prefix) {
  88         size_t l;
  89
  90         l = strlen(prefix);
  91         if (strncasecmp(s, prefix, l) == 0)
  92                 return (char*) s + l;
  93
  94         return NULL;
  95 }
  96
  97 char *endswith(const char *s, const char *postfix) _pure_;
  98 char *endswith_no_case(const char *s, const char *postfix) _pure_;
  99
 100 char *first_word(const char *s, const char *word) _pure_;
 101
 102 const char* split(const char **state, size_t *l, const char *separator, bool quoted);
 103
 104 #define FOREACH_WORD(word, length, s, state)                            \
 105         _FOREACH_WORD(word, length, s, WHITESPACE, false, state)
 106
 107 #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)       \
 108         _FOREACH_WORD(word, length, s, separator, false, state)
 109
 110 #define FOREACH_WORD_QUOTED(word, length, s, state)                     \
 111         _FOREACH_WORD(word, length, s, WHITESPACE, true, state)
 112
 113 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
 114         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
 115
 116 char *strappend(const char *s, const char *suffix);
 117 char *strnappend(const char *s, const char *suffix, size_t length);
 118
 119 char *strjoin_real(const char *x, ...) _sentinel_;
 120 #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
 121
 122 #define strjoina(a, ...)                                                \
 123         ({                                                              \
 124                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
 125                 char *_d_, *_p_;                                        \
 126                 int _len_ = 0;                                          \
 127                 unsigned _i_;                                           \
 128                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 129                         _len_ += strlen(_appendees_[_i_]);              \
 130                 _p_ = _d_ = alloca(_len_ + 1);                          \
 131                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 132                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
 133                 *_p_ = 0;                                               \
 134                 _d_;                                                    \
 135         })
 136
 137 char *strstrip(char *s);
 138 char *delete_chars(char *s, const char *bad);
 139 char *truncate_nl(char *s);
 140
 141 char ascii_tolower(char x);
 142 char *ascii_strlower(char *s);
 143 char *ascii_strlower_n(char *s, size_t n);
 144
 145 char ascii_toupper(char x);
 146 char *ascii_strupper(char *s);
 147
 148 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
 149 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
 150
 151 bool chars_intersect(const char *a, const char *b) _pure_;
 152
 153 static inline bool _pure_ in_charset(const char *s, const char* charset) {
 154         assert(s);
 155         assert(charset);
 156         return s[strspn(s, charset)] == '\0';
 157 }
 158
 159 bool string_has_cc(const char *p, const char *ok) _pure_;
 160
 161 char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
 162 char *ellipsize(const char *s, size_t length, unsigned percent);
 163
 164 bool nulstr_contains(const char*nulstr, const char *needle);
 165
 166 char* strshorten(char *s, size_t l);
 167
 168 char *strreplace(const char *text, const char *old_string, const char *new_string);
 169
 170 char *strip_tab_ansi(char **p, size_t *l);
 171
 172 char *strextend(char **x, ...) _sentinel_;
 173
 174 char *strrep(const char *s, unsigned n);
 175
 176 int split_pair(const char *s, const char *sep, char **l, char **r);
 177
 178 int free_and_strdup(char **p, const char *s);
 179
 180 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
 181 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
 182
 183         if (needlelen <= 0)
 184                 return (void*) haystack;
 185
 186         if (haystacklen < needlelen)
 187                 return NULL;
 188
 189         assert(haystack);
 190         assert(needle);
 191
 192         return memmem(haystack, haystacklen, needle, needlelen);
 193 }
 194
 195 void* memory_erase(void *p, size_t l);
 196 char *string_erase(char *x);
 197
 198 char *string_free_erase(char *s);
 199 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
 200 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)
 201
 202 bool string_is_safe(const char *p) _pure_;