1 #ifndef foocoreutilhfoo
2 #define foocoreutilhfoo
3
4 /***
5 This file is part of PulseAudio.
6
7 Copyright 2004-2006 Lennart Poettering
8 Copyright 2006-2007 Pierre Ossman <ossman@cendio.se> for Cendio AB
9
10 PulseAudio is free software; you can redistribute it and/or modify
11 it under the terms of the GNU Lesser General Public License as
12 published by the Free Software Foundation; either version 2.1 of the
13 License, or (at your option) any later version.
14
15 PulseAudio is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public
21 License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
22 ***/
23
24 #include <sys/types.h>
25 #include <inttypes.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #ifdef HAVE_SYS_RESOURCE_H
31 #include <sys/resource.h>
32 #endif
33
34 #include <pulse/gccmacro.h>
35 #include <pulse/volume.h>
36
37 #include <pulsecore/i18n.h>
38 #include <pulsecore/macro.h>
39 #include <pulsecore/socket.h>
40
41 #ifndef PACKAGE
42 #error "Please include config.h before including this file!"
43 #endif
44
45 struct timeval;
46
47 /* These resource limits are pretty new on Linux, let's define them
48 * here manually, in case the kernel is newer than the glibc */
49 #if !defined(RLIMIT_NICE) && defined(__linux__)
50 #define RLIMIT_NICE 13
51 #endif
52 #if !defined(RLIMIT_RTPRIO) && defined(__linux__)
53 #define RLIMIT_RTPRIO 14
54 #endif
55 #if !defined(RLIMIT_RTTIME) && defined(__linux__)
56 #define RLIMIT_RTTIME 15
57 #endif
58
59 void pa_make_fd_nonblock(int fd);
60 void pa_make_fd_block(int fd);
61 bool pa_is_fd_nonblock(int fd);
62
63 void pa_make_fd_cloexec(int fd);
64
65 int pa_make_secure_dir(const char* dir, mode_t m, uid_t uid, gid_t gid, bool update_perms);
66 int pa_make_secure_parent_dir(const char *fn, mode_t, uid_t uid, gid_t gid, bool update_perms);
67
68 ssize_t pa_read(int fd, void *buf, size_t count, int *type);
69 ssize_t pa_write(int fd, const void *buf, size_t count, int *type);
70 ssize_t pa_loop_read(int fd, void*data, size_t size, int *type);
71 ssize_t pa_loop_write(int fd, const void*data, size_t size, int *type);
72
73 int pa_close(int fd);
74
75 void pa_check_signal_is_blocked(int sig);
76
77 char *pa_sprintf_malloc(const char *format, ...) PA_GCC_PRINTF_ATTR(1,2);
78 char *pa_vsprintf_malloc(const char *format, va_list ap);
79
80 char *pa_strlcpy(char *b, const char *s, size_t l);
81
82 char *pa_parent_dir(const char *fn);
83
84 int pa_raise_priority(int nice_level);
85 void pa_reset_priority(void);
86
87 int pa_parse_boolean(const char *s) PA_GCC_PURE;
88
89 int pa_parse_volume(const char *s, pa_volume_t *volume);
90
pa_yes_no(bool b)91 static inline const char *pa_yes_no(bool b) {
92 return b ? "yes" : "no";
93 }
94
pa_yes_no_localised(bool b)95 static inline const char *pa_yes_no_localised(bool b) {
96 return b ? _("yes") : _("no");
97 }
98
pa_strnull(const char * x)99 static inline const char *pa_strnull(const char *x) {
100 return x ? x : "(null)";
101 }
102
pa_strempty(const char * x)103 static inline const char *pa_strempty(const char *x) {
104 return x ? x : "";
105 }
106
pa_strna(const char * x)107 static inline const char *pa_strna(const char *x) {
108 return x ? x : "n/a";
109 }
110
111 char *pa_split(const char *c, const char *delimiters, const char **state);
112 const char *pa_split_in_place(const char *c, const char *delimiters, size_t *n, const char **state);
113 char *pa_split_spaces(const char *c, const char **state);
114 const char *pa_split_spaces_in_place(const char *c, size_t *n, const char **state);
115
116 char *pa_strip_nl(char *s);
117 char *pa_strip(char *s);
118
119 const char *pa_sig2str(int sig) PA_GCC_PURE;
120
121 int pa_own_uid_in_group(const char *name, gid_t *gid);
122 int pa_uid_in_group(uid_t uid, const char *name);
123 gid_t pa_get_gid_of_group(const char *name);
124 int pa_check_in_group(gid_t g);
125
126 int pa_lock_fd(int fd, int b);
127
128 int pa_lock_lockfile(const char *fn);
129 int pa_unlock_lockfile(const char *fn, int fd);
130
131 char *pa_hexstr(const uint8_t* d, size_t dlength, char *s, size_t slength);
132 size_t pa_parsehex(const char *p, uint8_t *d, size_t dlength);
133
134 bool pa_startswith(const char *s, const char *pfx) PA_GCC_PURE;
135 bool pa_endswith(const char *s, const char *sfx) PA_GCC_PURE;
136
137 FILE *pa_open_config_file(const char *global, const char *local, const char *env, char **result);
138 char* pa_find_config_file(const char *global, const char *local, const char *env);
139
140 char *pa_get_runtime_dir(void);
141 char *pa_get_state_dir(void);
142 char *pa_get_home_dir_malloc(void);
143 int pa_append_to_home_dir(const char *path, char **_r);
144 int pa_get_config_home_dir(char **_r);
145 int pa_append_to_config_home_dir(const char *path, char **_r);
146 char *pa_get_binary_name_malloc(void);
147 char *pa_runtime_path(const char *fn);
148 char *pa_state_path(const char *fn, bool prepend_machine_id);
149
150 int pa_atoi(const char *s, int32_t *ret_i);
151 int pa_atou(const char *s, uint32_t *ret_u);
152 int pa_atol(const char *s, long *ret_l);
153 int pa_atod(const char *s, double *ret_d);
154
155 size_t pa_snprintf(char *str, size_t size, const char *format, ...);
156 size_t pa_vsnprintf(char *str, size_t size, const char *format, va_list ap);
157
158 char *pa_truncate_utf8(char *c, size_t l);
159
160 int pa_match(const char *expr, const char *v);
161 bool pa_is_regex_valid(const char *expr);
162
163 char *pa_getcwd(void);
164 char *pa_make_path_absolute(const char *p);
165 bool pa_is_path_absolute(const char *p);
166
167 void *pa_will_need(const void *p, size_t l);
168
pa_is_power_of_two(unsigned n)169 static inline int pa_is_power_of_two(unsigned n) {
170 return !(n & (n - 1));
171 }
172
pa_ulog2(unsigned n)173 static inline unsigned pa_ulog2(unsigned n) {
174
175 if (n <= 1)
176 return 0;
177
178 #if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
179 return 8U * (unsigned) sizeof(unsigned) - (unsigned) __builtin_clz(n) - 1;
180 #else
181 {
182 unsigned r = 0;
183
184 for (;;) {
185 n = n >> 1;
186
187 if (!n)
188 return r;
189
190 r++;
191 }
192 }
193 #endif
194 }
195
pa_make_power_of_two(unsigned n)196 static inline unsigned pa_make_power_of_two(unsigned n) {
197
198 if (pa_is_power_of_two(n))
199 return n;
200
201 return 1U << (pa_ulog2(n) + 1);
202 }
203
204 void pa_close_pipe(int fds[2]);
205
206 char *pa_readlink(const char *p);
207
208 int pa_close_all(int except_fd, ...);
209 int pa_close_allv(const int except_fds[]);
210 int pa_unblock_sigs(int except, ...);
211 int pa_unblock_sigsv(const int except[]);
212 int pa_reset_sigs(int except, ...);
213 int pa_reset_sigsv(const int except[]);
214
215 void pa_set_env(const char *key, const char *value);
216 void pa_unset_env(const char *key);
217 void pa_set_env_and_record(const char *key, const char *value);
218 void pa_unset_env_recorded(void);
219
220 bool pa_in_system_mode(void);
221
222 #define pa_streq(a,b) (!strcmp((a),(b)))
223 #define pa_strneq(a,b,n) (!strncmp((a),(b),(n)))
224
225 /* Like pa_streq, but does not blow up on NULL pointers. */
pa_safe_streq(const char * a,const char * b)226 static inline bool pa_safe_streq(const char *a, const char *b) {
227 if (a == NULL || b == NULL)
228 return a == b;
229 return pa_streq(a, b);
230 }
231
232 bool pa_str_in_list_spaces(const char *needle, const char *haystack);
233 bool pa_str_in_list(const char *haystack, const char *delimiters, const char *needle);
234
235 char* pa_str_strip_suffix(const char *str, const char *suffix);
236
237 char *pa_get_host_name_malloc(void);
238 char *pa_get_user_name_malloc(void);
239
240 char *pa_machine_id(void);
241 char *pa_session_id(void);
242 char *pa_uname_string(void);
243
244 #ifdef HAVE_VALGRIND_MEMCHECK_H
245 bool pa_in_valgrind(void);
246 #else
pa_in_valgrind(void)247 static inline bool pa_in_valgrind(void) {
248 return false;
249 }
250 #endif
251
252 unsigned pa_gcd(unsigned a, unsigned b);
253 void pa_reduce(unsigned *num, unsigned *den);
254
255 unsigned pa_ncpus(void);
256
257 /* Replaces all occurrences of `a' in `s' with `b'. The caller has to free the
258 * returned string. All parameters must be non-NULL and additionally `a' must
259 * not be a zero-length string.
260 */
261 char *pa_replace(const char*s, const char*a, const char *b);
262
263 /* Escapes p by inserting backslashes in front of backslashes. chars is a
264 * regular (i.e. NULL-terminated) string containing additional characters that
265 * should be escaped. chars can be NULL. The caller has to free the returned
266 * string. */
267 char *pa_escape(const char *p, const char *chars);
268
269 /* Does regular backslash unescaping. Returns the argument p. */
270 char *pa_unescape(char *p);
271
272 char *pa_realpath(const char *path);
273
274 void pa_disable_sigpipe(void);
275
276 void pa_xfreev(void**a);
277
pa_xstrfreev(char ** a)278 static inline void pa_xstrfreev(char **a) {
279 pa_xfreev((void**) a);
280 }
281
282 char **pa_split_spaces_strv(const char *s);
283
284 char* pa_maybe_prefix_path(const char *path, const char *prefix);
285
286 /* Returns size of the specified pipe or 4096 on failure */
287 size_t pa_pipe_buf(int fd);
288
289 void pa_reset_personality(void);
290
291 bool pa_run_from_build_tree(void) PA_GCC_CONST;
292
293 const char *pa_get_temp_dir(void);
294
295 int pa_open_cloexec(const char *fn, int flags, mode_t mode);
296 int pa_socket_cloexec(int domain, int type, int protocol);
297 int pa_pipe_cloexec(int pipefd[2]);
298 int pa_accept_cloexec(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
299 FILE* pa_fopen_cloexec(const char *path, const char *mode);
300
301 void pa_nullify_stdfds(void);
302
303 char *pa_read_line_from_file(const char *fn);
304 bool pa_running_in_vm(void);
305
306 #ifdef OS_IS_WIN32
307 char *pa_win32_get_toplevel(HANDLE handle);
308 #endif
309
310 size_t pa_page_size(void);
311
312 /* Rounds down */
PA_PAGE_ALIGN_PTR(const void * p)313 static inline void* PA_PAGE_ALIGN_PTR(const void *p) {
314 return (void*) (((size_t) p) & ~(pa_page_size() - 1));
315 }
316
317 /* Rounds up */
PA_PAGE_ALIGN(size_t l)318 static inline size_t PA_PAGE_ALIGN(size_t l) {
319 size_t page_size = pa_page_size();
320 return (l + page_size - 1) & ~(page_size - 1);
321 }
322
323 #endif
324