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 char *startswith(const char *s, const char *prefix) {
  70         size_t l;
  71
  72         l = strlen(prefix);
  73         if (strncmp(s, prefix, l) == 0)
  74                 return (char*) s + l;
  75
  76         return NULL;
  77 }
  78
  79 static inline char *startswith_no_case(const char *s, const char *prefix) {
  80         size_t l;
  81
  82         l = strlen(prefix);
  83         if (strncasecmp(s, prefix, l) == 0)
  84                 return (char*) s + l;
  85
  86         return NULL;
  87 }
  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_QUOTED(word, length, s, state)                     \
 103         _FOREACH_WORD(word, length, s, WHITESPACE, true, state)
 104
 105 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
 106         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
 107
 108 char *strappend(const char *s, const char *suffix);
 109 char *strnappend(const char *s, const char *suffix, size_t length);
 110
 111 char *strjoin(const char *x, ...) _sentinel_;
 112
 113 #define strjoina(a, ...)                                                \
 114         ({                                                              \
 115                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
 116                 char *_d_, *_p_;                                        \
 117                 int _len_ = 0;                                          \
 118                 unsigned _i_;                                           \
 119                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 120                         _len_ += strlen(_appendees_[_i_]);              \
 121                 _p_ = _d_ = alloca(_len_ + 1);                          \
 122                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 123                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
 124                 *_p_ = 0;                                               \
 125                 _d_;                                                    \
 126         })
 127
 128 char *strstrip(char *s);
 129 char *delete_chars(char *s, const char *bad);
 130 char *truncate_nl(char *s);
 131
 132 char ascii_tolower(char x);
 133 char *ascii_strlower(char *s);
 134 char *ascii_strlower_n(char *s, size_t n);
 135
 136 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
 137 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
 138
 139 bool chars_intersect(const char *a, const char *b) _pure_;
 140
 141 static inline bool _pure_ in_charset(const char *s, const char* charset) {
 142         assert(s);
 143         assert(charset);
 144         return s[strspn(s, charset)] == '\0';
 145 }
 146
 147 bool string_has_cc(const char *p, const char *ok) _pure_;
 148
 149 char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
 150 char *ellipsize(const char *s, size_t length, unsigned percent);
 151
 152 bool nulstr_contains(const char*nulstr, const char *needle);
 153
 154 char* strshorten(char *s, size_t l);
 155
 156 char *strreplace(const char *text, const char *old_string, const char *new_string);
 157
 158 char *strip_tab_ansi(char **p, size_t *l);
 159
 160 char *strextend(char **x, ...) _sentinel_;
 161
 162 char *strrep(const char *s, unsigned n);
 163
 164 int split_pair(const char *s, const char *sep, char **l, char **r);
 165
 166 int free_and_strdup(char **p, const char *s);
 167
 168 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
 169 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
 170
 171         if (needlelen <= 0)
 172                 return (void*) haystack;
 173
 174         if (haystacklen < needlelen)
 175                 return NULL;
 176
 177         assert(haystack);
 178         assert(needle);
 179
 180         return memmem(haystack, haystacklen, needle, needlelen);
 181 }
 182
 183 void* memory_erase(void *p, size_t l);
 184 char *string_erase(char *x);
 185
 186 char *string_free_erase(char *s);
 187 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
 188 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)
 189
 190 bool string_is_safe(const char *p) _pure_;