]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
07630cea LP |
2 | #pragma once |
3 | ||
07630cea | 4 | #include <stdbool.h> |
11c3a366 | 5 | #include <stddef.h> |
07630cea LP |
6 | #include <string.h> |
7 | ||
6e9417f5 | 8 | #include "alloc-util.h" |
07630cea LP |
9 | #include "macro.h" |
10 | ||
b11d6a7b LP |
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 | |
1a7906ae | 22 | #define HEXDIGITS DIGITS "abcdefABCDEF" |
b11d6a7b | 23 | |
07630cea LP |
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_; | |
6cf3011c | 30 | int strcasecmp_ptr(const char *a, const char *b) _pure_; |
07630cea LP |
31 | |
32 | static inline bool streq_ptr(const char *a, const char *b) { | |
33 | return strcmp_ptr(a, b) == 0; | |
34 | } | |
35 | ||
4eb0c875 ZJS |
36 | static inline char* strstr_ptr(const char *haystack, const char *needle) { |
37 | if (!haystack || !needle) | |
38 | return NULL; | |
39 | return strstr(haystack, needle); | |
40 | } | |
41 | ||
07630cea | 42 | static inline const char* strempty(const char *s) { |
ad5d4b17 | 43 | return s ?: ""; |
07630cea LP |
44 | } |
45 | ||
46 | static inline const char* strnull(const char *s) { | |
ad5d4b17 | 47 | return s ?: "(null)"; |
07630cea LP |
48 | } |
49 | ||
50 | static inline const char *strna(const char *s) { | |
ad5d4b17 | 51 | return s ?: "n/a"; |
07630cea LP |
52 | } |
53 | ||
55fced5a ZJS |
54 | static inline const char* yes_no(bool b) { |
55 | return b ? "yes" : "no"; | |
56 | } | |
57 | ||
58 | static inline const char* true_false(bool b) { | |
59 | return b ? "true" : "false"; | |
60 | } | |
61 | ||
fe37e5a5 ZJS |
62 | static inline const char* plus_minus(bool b) { |
63 | return b ? "+" : "-"; | |
64 | } | |
65 | ||
55fced5a ZJS |
66 | static inline const char* one_zero(bool b) { |
67 | return b ? "1" : "0"; | |
68 | } | |
69 | ||
70 | static inline const char* enable_disable(bool b) { | |
71 | return b ? "enable" : "disable"; | |
72 | } | |
73 | ||
07630cea LP |
74 | static inline bool isempty(const char *p) { |
75 | return !p || !p[0]; | |
76 | } | |
77 | ||
3c6f7c34 LP |
78 | static inline const char *empty_to_null(const char *p) { |
79 | return isempty(p) ? NULL : p; | |
80 | } | |
81 | ||
c5984fe1 | 82 | static inline const char *empty_to_dash(const char *str) { |
07b0b339 SK |
83 | return isempty(str) ? "-" : str; |
84 | } | |
85 | ||
e7b88b7b LP |
86 | static inline bool empty_or_dash(const char *str) { |
87 | return !str || | |
88 | str[0] == 0 || | |
89 | (str[0] == '-' && str[1] == 0); | |
90 | } | |
91 | ||
dc90e0fa LP |
92 | static inline const char *empty_or_dash_to_null(const char *p) { |
93 | return empty_or_dash(p) ? NULL : p; | |
94 | } | |
95 | ||
07630cea LP |
96 | static inline char *startswith(const char *s, const char *prefix) { |
97 | size_t l; | |
98 | ||
99 | l = strlen(prefix); | |
100 | if (strncmp(s, prefix, l) == 0) | |
101 | return (char*) s + l; | |
102 | ||
103 | return NULL; | |
104 | } | |
105 | ||
106 | static inline char *startswith_no_case(const char *s, const char *prefix) { | |
107 | size_t l; | |
108 | ||
109 | l = strlen(prefix); | |
110 | if (strncasecmp(s, prefix, l) == 0) | |
111 | return (char*) s + l; | |
112 | ||
113 | return NULL; | |
114 | } | |
115 | ||
116 | char *endswith(const char *s, const char *postfix) _pure_; | |
117 | char *endswith_no_case(const char *s, const char *postfix) _pure_; | |
118 | ||
119 | char *first_word(const char *s, const char *word) _pure_; | |
120 | ||
07630cea LP |
121 | char *strnappend(const char *s, const char *suffix, size_t length); |
122 | ||
605405c6 ZJS |
123 | char *strjoin_real(const char *x, ...) _sentinel_; |
124 | #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL) | |
07630cea LP |
125 | |
126 | #define strjoina(a, ...) \ | |
127 | ({ \ | |
128 | const char *_appendees_[] = { a, __VA_ARGS__ }; \ | |
129 | char *_d_, *_p_; \ | |
9a485918 ZJS |
130 | size_t _len_ = 0; \ |
131 | size_t _i_; \ | |
07630cea LP |
132 | for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \ |
133 | _len_ += strlen(_appendees_[_i_]); \ | |
6e9417f5 | 134 | _p_ = _d_ = newa(char, _len_ + 1); \ |
07630cea LP |
135 | for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \ |
136 | _p_ = stpcpy(_p_, _appendees_[_i_]); \ | |
137 | *_p_ = 0; \ | |
138 | _d_; \ | |
139 | }) | |
140 | ||
141 | char *strstrip(char *s); | |
142 | char *delete_chars(char *s, const char *bad); | |
7546145e | 143 | char *delete_trailing_chars(char *s, const char *bad); |
07630cea LP |
144 | char *truncate_nl(char *s); |
145 | ||
7546145e | 146 | static inline char *skip_leading_chars(const char *s, const char *bad) { |
7546145e LP |
147 | if (!s) |
148 | return NULL; | |
149 | ||
150 | if (!bad) | |
151 | bad = WHITESPACE; | |
152 | ||
153 | return (char*) s + strspn(s, bad); | |
154 | } | |
155 | ||
b577e3d5 LP |
156 | char ascii_tolower(char x); |
157 | char *ascii_strlower(char *s); | |
158 | char *ascii_strlower_n(char *s, size_t n); | |
07630cea | 159 | |
846b8fc3 LP |
160 | char ascii_toupper(char x); |
161 | char *ascii_strupper(char *s); | |
162 | ||
522d85ae | 163 | int ascii_strcasecmp_n(const char *a, const char *b, size_t n); |
c1749834 | 164 | int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m); |
522d85ae | 165 | |
07630cea LP |
166 | bool chars_intersect(const char *a, const char *b) _pure_; |
167 | ||
168 | static inline bool _pure_ in_charset(const char *s, const char* charset) { | |
169 | assert(s); | |
170 | assert(charset); | |
171 | return s[strspn(s, charset)] == '\0'; | |
172 | } | |
173 | ||
174 | bool string_has_cc(const char *p, const char *ok) _pure_; | |
175 | ||
176 | char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent); | |
ae03775f ZJS |
177 | static inline char *ellipsize(const char *s, size_t length, unsigned percent) { |
178 | return ellipsize_mem(s, strlen(s), length, percent); | |
179 | } | |
180 | ||
8409f688 | 181 | char *cellescape(char *buf, size_t len, const char *s); |
07630cea | 182 | |
cca24fc3 ZJS |
183 | /* This limit is arbitrary, enough to give some idea what the string contains */ |
184 | #define CELLESCAPE_DEFAULT_LENGTH 64 | |
185 | ||
07630cea LP |
186 | char* strshorten(char *s, size_t l); |
187 | ||
188 | char *strreplace(const char *text, const char *old_string, const char *new_string); | |
189 | ||
b4766d5f | 190 | char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]); |
07630cea | 191 | |
bb8ad9ea LP |
192 | char *strextend_with_separator(char **x, const char *separator, ...) _sentinel_; |
193 | ||
194 | #define strextend(x, ...) strextend_with_separator(x, NULL, __VA_ARGS__) | |
07630cea LP |
195 | |
196 | char *strrep(const char *s, unsigned n); | |
197 | ||
198 | int split_pair(const char *s, const char *sep, char **l, char **r); | |
199 | ||
200 | int free_and_strdup(char **p, const char *s); | |
f1531db5 ZJS |
201 | static inline int free_and_strdup_warn(char **p, const char *s) { |
202 | if (free_and_strdup(p, s) < 0) | |
203 | return log_oom(); | |
204 | return 0; | |
205 | } | |
7f546026 | 206 | int free_and_strndup(char **p, const char *s, size_t l); |
07630cea | 207 | |
f3e2e81d | 208 | bool string_is_safe(const char *p) _pure_; |
7bf7ce28 LP |
209 | |
210 | static inline size_t strlen_ptr(const char *s) { | |
211 | if (!s) | |
212 | return 0; | |
213 | ||
214 | return strlen(s); | |
215 | } | |
9b8ff183 | 216 | |
6695c200 ZJS |
217 | DISABLE_WARNING_STRINGOP_TRUNCATION; |
218 | static inline void strncpy_exact(char *buf, const char *src, size_t buf_len) { | |
219 | strncpy(buf, src, buf_len); | |
220 | } | |
221 | REENABLE_WARNING; | |
222 | ||
9b8ff183 LP |
223 | /* Like startswith(), but operates on arbitrary memory blocks */ |
224 | static inline void *memory_startswith(const void *p, size_t sz, const char *token) { | |
9b8ff183 LP |
225 | assert(token); |
226 | ||
9a485918 | 227 | size_t n = strlen(token); |
9b8ff183 LP |
228 | if (sz < n) |
229 | return NULL; | |
230 | ||
231 | assert(p); | |
232 | ||
233 | if (memcmp(p, token, n) != 0) | |
234 | return NULL; | |
235 | ||
236 | return (uint8_t*) p + n; | |
237 | } | |
21224070 DP |
238 | |
239 | /* Like startswith_no_case(), but operates on arbitrary memory blocks. | |
240 | * It works only for ASCII strings. | |
241 | */ | |
242 | static inline void *memory_startswith_no_case(const void *p, size_t sz, const char *token) { | |
21224070 DP |
243 | assert(token); |
244 | ||
9a485918 | 245 | size_t n = strlen(token); |
21224070 DP |
246 | if (sz < n) |
247 | return NULL; | |
248 | ||
249 | assert(p); | |
250 | ||
9a485918 | 251 | for (size_t i = 0; i < n; i++) |
21224070 DP |
252 | if (ascii_tolower(((char *)p)[i]) != ascii_tolower(token[i])) |
253 | return NULL; | |
21224070 DP |
254 | |
255 | return (uint8_t*) p + n; | |
256 | } | |
bc28751e ZJS |
257 | |
258 | static inline char* str_realloc(char **p) { | |
259 | /* Reallocate *p to actual size */ | |
260 | ||
261 | if (!*p) | |
262 | return NULL; | |
263 | ||
264 | char *t = realloc(*p, strlen(*p) + 1); | |
265 | if (!t) | |
266 | return NULL; | |
267 | ||
268 | return (*p = t); | |
269 | } | |
53caaffd LP |
270 | |
271 | char* string_erase(char *x); | |
8dd6491e LP |
272 | |
273 | int string_truncate_lines(const char *s, size_t n_lines, char **ret); | |
f6857fa6 | 274 | int string_extract_line(const char *s, size_t i, char **ret); |
46bf625a ZJS |
275 | |
276 | int string_contains_word_strv(const char *string, const char *separators, char **words, const char **ret_word); | |
277 | static inline int string_contains_word(const char *string, const char *separators, const char *word) { | |
278 | return string_contains_word_strv(string, separators, STRV_MAKE(word), NULL); | |
279 | } |