]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
07630cea LP |
2 | #pragma once |
3 | ||
4 | /*** | |
5 | This file is part of systemd. | |
6 | ||
7 | Copyright 2010 Lennart Poettering | |
07630cea LP |
8 | ***/ |
9 | ||
11c3a366 | 10 | #include <alloca.h> |
07630cea | 11 | #include <stdbool.h> |
11c3a366 | 12 | #include <stddef.h> |
07630cea LP |
13 | #include <string.h> |
14 | ||
15 | #include "macro.h" | |
16 | ||
b11d6a7b LP |
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 | |
1a7906ae | 28 | #define HEXDIGITS DIGITS "abcdefABCDEF" |
b11d6a7b | 29 | |
07630cea LP |
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) { | |
ad5d4b17 | 42 | return s ?: ""; |
07630cea LP |
43 | } |
44 | ||
45 | static inline const char* strnull(const char *s) { | |
ad5d4b17 | 46 | return s ?: "(null)"; |
07630cea LP |
47 | } |
48 | ||
49 | static inline const char *strna(const char *s) { | |
ad5d4b17 | 50 | return s ?: "n/a"; |
07630cea LP |
51 | } |
52 | ||
53 | static inline bool isempty(const char *p) { | |
54 | return !p || !p[0]; | |
55 | } | |
56 | ||
3c6f7c34 LP |
57 | static inline const char *empty_to_null(const char *p) { |
58 | return isempty(p) ? NULL : p; | |
59 | } | |
60 | ||
c5984fe1 | 61 | static inline const char *empty_to_dash(const char *str) { |
07b0b339 SK |
62 | return isempty(str) ? "-" : str; |
63 | } | |
64 | ||
07630cea LP |
65 | static inline char *startswith(const char *s, const char *prefix) { |
66 | size_t l; | |
67 | ||
68 | l = strlen(prefix); | |
69 | if (strncmp(s, prefix, l) == 0) | |
70 | return (char*) s + l; | |
71 | ||
72 | return NULL; | |
73 | } | |
74 | ||
75 | static inline char *startswith_no_case(const char *s, const char *prefix) { | |
76 | size_t l; | |
77 | ||
78 | l = strlen(prefix); | |
79 | if (strncasecmp(s, prefix, l) == 0) | |
80 | return (char*) s + l; | |
81 | ||
82 | return NULL; | |
83 | } | |
84 | ||
85 | char *endswith(const char *s, const char *postfix) _pure_; | |
86 | char *endswith_no_case(const char *s, const char *postfix) _pure_; | |
87 | ||
88 | char *first_word(const char *s, const char *word) _pure_; | |
89 | ||
90 | const char* split(const char **state, size_t *l, const char *separator, bool quoted); | |
91 | ||
92 | #define FOREACH_WORD(word, length, s, state) \ | |
93 | _FOREACH_WORD(word, length, s, WHITESPACE, false, state) | |
94 | ||
95 | #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state) \ | |
96 | _FOREACH_WORD(word, length, s, separator, false, state) | |
97 | ||
07630cea LP |
98 | #define _FOREACH_WORD(word, length, s, separator, quoted, state) \ |
99 | for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted))) | |
100 | ||
101 | char *strappend(const char *s, const char *suffix); | |
102 | char *strnappend(const char *s, const char *suffix, size_t length); | |
103 | ||
605405c6 ZJS |
104 | char *strjoin_real(const char *x, ...) _sentinel_; |
105 | #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL) | |
07630cea LP |
106 | |
107 | #define strjoina(a, ...) \ | |
108 | ({ \ | |
109 | const char *_appendees_[] = { a, __VA_ARGS__ }; \ | |
110 | char *_d_, *_p_; \ | |
35207e25 | 111 | size_t _len_ = 0; \ |
da6053d0 | 112 | size_t _i_; \ |
07630cea LP |
113 | for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \ |
114 | _len_ += strlen(_appendees_[_i_]); \ | |
115 | _p_ = _d_ = alloca(_len_ + 1); \ | |
116 | for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \ | |
117 | _p_ = stpcpy(_p_, _appendees_[_i_]); \ | |
118 | *_p_ = 0; \ | |
119 | _d_; \ | |
120 | }) | |
121 | ||
122 | char *strstrip(char *s); | |
123 | char *delete_chars(char *s, const char *bad); | |
7546145e | 124 | char *delete_trailing_chars(char *s, const char *bad); |
07630cea LP |
125 | char *truncate_nl(char *s); |
126 | ||
7546145e LP |
127 | static inline char *skip_leading_chars(const char *s, const char *bad) { |
128 | ||
129 | if (!s) | |
130 | return NULL; | |
131 | ||
132 | if (!bad) | |
133 | bad = WHITESPACE; | |
134 | ||
135 | return (char*) s + strspn(s, bad); | |
136 | } | |
137 | ||
b577e3d5 LP |
138 | char ascii_tolower(char x); |
139 | char *ascii_strlower(char *s); | |
140 | char *ascii_strlower_n(char *s, size_t n); | |
07630cea | 141 | |
846b8fc3 LP |
142 | char ascii_toupper(char x); |
143 | char *ascii_strupper(char *s); | |
144 | ||
522d85ae | 145 | int ascii_strcasecmp_n(const char *a, const char *b, size_t n); |
c1749834 | 146 | int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m); |
522d85ae | 147 | |
07630cea LP |
148 | bool chars_intersect(const char *a, const char *b) _pure_; |
149 | ||
150 | static inline bool _pure_ in_charset(const char *s, const char* charset) { | |
151 | assert(s); | |
152 | assert(charset); | |
153 | return s[strspn(s, charset)] == '\0'; | |
154 | } | |
155 | ||
156 | bool string_has_cc(const char *p, const char *ok) _pure_; | |
157 | ||
158 | char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent); | |
159 | char *ellipsize(const char *s, size_t length, unsigned percent); | |
8409f688 | 160 | char *cellescape(char *buf, size_t len, const char *s); |
07630cea | 161 | |
2d5dece8 | 162 | bool nulstr_contains(const char *nulstr, const char *needle); |
07630cea LP |
163 | |
164 | char* strshorten(char *s, size_t l); | |
165 | ||
166 | char *strreplace(const char *text, const char *old_string, const char *new_string); | |
167 | ||
b4766d5f | 168 | char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]); |
07630cea | 169 | |
bb8ad9ea LP |
170 | char *strextend_with_separator(char **x, const char *separator, ...) _sentinel_; |
171 | ||
172 | #define strextend(x, ...) strextend_with_separator(x, NULL, __VA_ARGS__) | |
07630cea LP |
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 | ||
4b9545f1 | 195 | #if !HAVE_EXPLICIT_BZERO |
2d26d8e0 ZJS |
196 | void explicit_bzero(void *p, size_t l); |
197 | #endif | |
198 | ||
9fe4ea21 | 199 | char *string_erase(char *x); |
07630cea LP |
200 | |
201 | char *string_free_erase(char *s); | |
202 | DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase); | |
203 | #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep) | |
f3e2e81d LP |
204 | |
205 | bool string_is_safe(const char *p) _pure_; | |
7bf7ce28 LP |
206 | |
207 | static inline size_t strlen_ptr(const char *s) { | |
208 | if (!s) | |
209 | return 0; | |
210 | ||
211 | return strlen(s); | |
212 | } | |
9b8ff183 LP |
213 | |
214 | /* Like startswith(), but operates on arbitrary memory blocks */ | |
215 | static inline void *memory_startswith(const void *p, size_t sz, const char *token) { | |
216 | size_t n; | |
217 | ||
218 | assert(token); | |
219 | ||
220 | n = strlen(token); | |
221 | if (sz < n) | |
222 | return NULL; | |
223 | ||
224 | assert(p); | |
225 | ||
226 | if (memcmp(p, token, n) != 0) | |
227 | return NULL; | |
228 | ||
229 | return (uint8_t*) p + n; | |
230 | } |