Branch data Line data Source code
1 : : /*
2 : : Authors:
3 : : Simo Sorce <ssorce@redhat.com>
4 : :
5 : : Copyright (C) 2009 Red Hat
6 : :
7 : : This program is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3 of the License, or
10 : : (at your option) any later version.
11 : :
12 : : This program is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
19 : : */
20 : :
21 : : #ifndef __SSSD_UTIL_H__
22 : : #define __SSSD_UTIL_H__
23 : :
24 : : #include "config.h"
25 : : #include <stdio.h>
26 : : #include <stdint.h>
27 : : #include <stdbool.h>
28 : : #include <unistd.h>
29 : : #include <string.h>
30 : : #include <strings.h>
31 : : #include <ctype.h>
32 : : #include <errno.h>
33 : : #include <libintl.h>
34 : : #include <limits.h>
35 : : #include <locale.h>
36 : : #include <time.h>
37 : : #include <pcre.h>
38 : : #include <sys/types.h>
39 : : #include <sys/stat.h>
40 : :
41 : : #include <talloc.h>
42 : : #include <tevent.h>
43 : : #include <ldb.h>
44 : : #include <dhash.h>
45 : :
46 : : #include "util/atomic_io.h"
47 : :
48 : : #ifndef HAVE_ERRNO_T
49 : : #define HAVE_ERRNO_T
50 : : typedef int errno_t;
51 : : #endif
52 : :
53 : : #define _(STRING) gettext (STRING)
54 : :
55 : : #define ENUM_INDICATOR "*"
56 : :
57 : : #define CLEAR_MC_FLAG "clear_mc_flag"
58 : :
59 : : extern const char *debug_prg_name;
60 : : extern int debug_level;
61 : : extern int debug_timestamps;
62 : : extern int debug_microseconds;
63 : : extern int debug_to_file;
64 : : extern const char *debug_log_file;
65 : : void debug_fn(const char *format, ...);
66 : : int debug_get_level(int old_level);
67 : : int debug_convert_old_level(int old_level);
68 : : errno_t set_debug_file_from_fd(const int fd);
69 : :
70 : : #define SSSDBG_FATAL_FAILURE 0x0010 /* level 0 */
71 : : #define SSSDBG_CRIT_FAILURE 0x0020 /* level 1 */
72 : : #define SSSDBG_OP_FAILURE 0x0040 /* level 2 */
73 : : #define SSSDBG_MINOR_FAILURE 0x0080 /* level 3 */
74 : : #define SSSDBG_CONF_SETTINGS 0x0100 /* level 4 */
75 : : #define SSSDBG_FUNC_DATA 0x0200 /* level 5 */
76 : : #define SSSDBG_TRACE_FUNC 0x0400 /* level 6 */
77 : : #define SSSDBG_TRACE_LIBS 0x1000 /* level 7 */
78 : : #define SSSDBG_TRACE_INTERNAL 0x2000 /* level 8 */
79 : : #define SSSDBG_TRACE_ALL 0x4000 /* level 9 */
80 : : #define SSSDBG_IMPORTANT_INFO SSSDBG_OP_FAILURE
81 : :
82 : : #define SSSDBG_INVALID -1
83 : : #define SSSDBG_UNRESOLVED 0
84 : : #define SSSDBG_MASK_ALL 0xFFF0 /* enable all debug levels */
85 : : #define SSSDBG_DEFAULT SSSDBG_FATAL_FAILURE
86 : :
87 : : #define SSSDBG_TIMESTAMP_UNRESOLVED -1
88 : : #define SSSDBG_TIMESTAMP_DEFAULT 1
89 : :
90 : : #define SSSDBG_MICROSECONDS_UNRESOLVED -1
91 : : #define SSSDBG_MICROSECONDS_DEFAULT 0
92 : :
93 : : #define SSSD_DEBUG_OPTS \
94 : : {"debug-level", 'd', POPT_ARG_INT, &debug_level, 0, \
95 : : _("Debug level"), NULL}, \
96 : : {"debug-to-files", 'f', POPT_ARG_NONE, &debug_to_file, 0, \
97 : : _("Send the debug output to files instead of stderr"), NULL }, \
98 : : {"debug-timestamps", 0, POPT_ARG_INT, &debug_timestamps, 0, \
99 : : _("Add debug timestamps"), NULL}, \
100 : : {"debug-microseconds", 0, POPT_ARG_INT, &debug_microseconds, 0, \
101 : : _("Show timestamps with microseconds"), NULL},
102 : :
103 : : /** \def DEBUG(level, body)
104 : : \brief macro to generate debug messages
105 : :
106 : : \param level the debug level, please use one of the SSSDBG_* macros
107 : : Old format:
108 : : - 1 is for critical errors users may find it difficult to understand but
109 : : are still quite clear
110 : : - 2-4 is for stuff developers are interested in in general, but
111 : : shouldn't fill the screen with useless low level verbose stuff
112 : : - 5-6 is for errors you may want to track, but only if you explicitly
113 : : looking for additional clues
114 : : - 7-10 is for informational stuff
115 : :
116 : : \param body the debug message you want to send, should end with \n
117 : : */
118 : : #define DEBUG(level, body) do { \
119 : : int __debug_macro_newlevel = debug_get_level(level); \
120 : : if (DEBUG_IS_SET(__debug_macro_newlevel)) { \
121 : : if (debug_timestamps) { \
122 : : struct timeval __debug_macro_tv; \
123 : : struct tm *__debug_macro_tm; \
124 : : char __debug_macro_datetime[20]; \
125 : : int __debug_macro_year; \
126 : : gettimeofday(&__debug_macro_tv, NULL); \
127 : : __debug_macro_tm = localtime(&__debug_macro_tv.tv_sec); \
128 : : __debug_macro_year = __debug_macro_tm->tm_year + 1900; \
129 : : /* get date time without year */ \
130 : : memcpy(__debug_macro_datetime, ctime(&__debug_macro_tv.tv_sec), 19); \
131 : : __debug_macro_datetime[19] = '\0'; \
132 : : if (debug_microseconds) { \
133 : : debug_fn("(%s:%.6d %d) [%s] [%s] (%#.4x): ", \
134 : : __debug_macro_datetime, __debug_macro_tv.tv_usec, \
135 : : __debug_macro_year, debug_prg_name, \
136 : : __FUNCTION__, __debug_macro_newlevel); \
137 : : } else { \
138 : : debug_fn("(%s %d) [%s] [%s] (%#.4x): ", \
139 : : __debug_macro_datetime, __debug_macro_year, \
140 : : debug_prg_name, __FUNCTION__, __debug_macro_newlevel); \
141 : : } \
142 : : } else { \
143 : : debug_fn("[%s] [%s] (%#.4x): ", \
144 : : debug_prg_name, __FUNCTION__, __debug_macro_newlevel); \
145 : : } \
146 : : debug_fn body; \
147 : : } \
148 : : } while(0)
149 : :
150 : : /** \def DEBUG_MSG(level, function, message)
151 : : \brief macro to generate debug messages with message from variable
152 : :
153 : : \param level the debug level, please use one of the SSSDBG_* macros
154 : :
155 : : \param function name of the function where DEBUG_MSG is called
156 : :
157 : : \param message message to be send (should not end with \n)
158 : : */
159 : : #define DEBUG_MSG(level, function, message) do { \
160 : : int __debug_macro_newlevel = debug_get_level(level); \
161 : : if (DEBUG_IS_SET(__debug_macro_newlevel)) { \
162 : : if (debug_timestamps) { \
163 : : struct timeval __debug_macro_tv; \
164 : : struct tm *__debug_macro_tm; \
165 : : char __debug_macro_datetime[20]; \
166 : : int __debug_macro_year; \
167 : : gettimeofday(&__debug_macro_tv, NULL); \
168 : : __debug_macro_tm = localtime(&__debug_macro_tv.tv_sec); \
169 : : __debug_macro_year = __debug_macro_tm->tm_year + 1900; \
170 : : /* get date time without year */ \
171 : : memcpy(__debug_macro_datetime, ctime(&__debug_macro_tv.tv_sec), 19); \
172 : : __debug_macro_datetime[19] = '\0'; \
173 : : if (debug_microseconds) { \
174 : : debug_fn("(%s:%.6d %d) [%s] [%s] (%#.4x): %s\n", \
175 : : __debug_macro_datetime, __debug_macro_tv.tv_usec, \
176 : : __debug_macro_year, debug_prg_name, \
177 : : function, __debug_macro_newlevel, message); \
178 : : } else { \
179 : : debug_fn("(%s %d) [%s] [%s] (%#.4x): %s\n", \
180 : : __debug_macro_datetime, __debug_macro_year, \
181 : : debug_prg_name, function, __debug_macro_newlevel, \
182 : : message); \
183 : : } \
184 : : } else { \
185 : : debug_fn("[%s] [%s] (%#.4x): %s\n", \
186 : : debug_prg_name, function, __debug_macro_newlevel, message); \
187 : : } \
188 : : } \
189 : : } while(0)
190 : :
191 : : /** \def DEBUG_IS_SET(level)
192 : : \brief checks whether level (must be in new format) is set in debug_level
193 : :
194 : : \param level the debug level, please use one of the SSSDBG*_ macros
195 : : */
196 : : #define DEBUG_IS_SET(level) (debug_level & (level) || \
197 : : (debug_level == SSSDBG_UNRESOLVED && \
198 : : (level & (SSSDBG_FATAL_FAILURE | \
199 : : SSSDBG_CRIT_FAILURE))))
200 : :
201 : : #define DEBUG_INIT(dbg_lvl) do { \
202 : : if (dbg_lvl != SSSDBG_INVALID) { \
203 : : debug_level = debug_convert_old_level(dbg_lvl); \
204 : : } else { \
205 : : debug_level = SSSDBG_UNRESOLVED; \
206 : : } \
207 : : \
208 : : talloc_set_log_fn(talloc_log_fn); \
209 : : } while (0)
210 : :
211 : : #define PRINT(fmt, ...) fprintf(stdout, gettext(fmt), ##__VA_ARGS__)
212 : : #define ERROR(fmt, ...) fprintf(stderr, gettext(fmt), ##__VA_ARGS__)
213 : :
214 : : #ifndef discard_const
215 : : #define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
216 : : #endif
217 : :
218 : : #ifndef NULL
219 : : #define NULL 0
220 : : #endif
221 : :
222 : : #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
223 : :
224 : : #define EOK 0
225 : :
226 : : #define SSSD_MAIN_OPTS SSSD_DEBUG_OPTS
227 : :
228 : : #define FLAGS_NONE 0x0000
229 : : #define FLAGS_DAEMON 0x0001
230 : : #define FLAGS_INTERACTIVE 0x0002
231 : : #define FLAGS_PID_FILE 0x0004
232 : :
233 : : #ifndef talloc_zfree
234 : : #define talloc_zfree(ptr) do { talloc_free(discard_const(ptr)); ptr = NULL; } while(0)
235 : : #endif
236 : :
237 : : #ifndef discard_const_p
238 : : #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
239 : : # define discard_const_p(type, ptr) ((type *)((intptr_t)(ptr)))
240 : : #else
241 : : # define discard_const_p(type, ptr) ((type *)(ptr))
242 : : #endif
243 : : #endif
244 : :
245 : : /* TODO: remove later
246 : : * These functions are available in the latest tevent and are the ones that
247 : : * should be used as tevent_req is rightfully opaque there */
248 : : #ifndef tevent_req_data
249 : : #define tevent_req_data(req, type) ((type *)req->private_state)
250 : : #define tevent_req_set_callback(req, func, data) \
251 : : do { req->async.fn = func; req->async.private_data = data; } while(0)
252 : : #define tevent_req_callback_data(req, type) ((type *)req->async.private_data)
253 : : #define tevent_req_notify_callback(req) \
254 : : do { \
255 : : if (req->async.fn != NULL) { \
256 : : req->async.fn(req); \
257 : : } \
258 : : } while(0)
259 : :
260 : : /* noop */
261 : : #define tevent_loop_allow_nesting(x)
262 : : #endif
263 : :
264 : : #define TEVENT_REQ_RETURN_ON_ERROR(req) do { \
265 : : enum tevent_req_state TRROEstate; \
266 : : uint64_t TRROEerr; \
267 : : \
268 : : if (tevent_req_is_error(req, &TRROEstate, &TRROEerr)) { \
269 : : if (TRROEstate == TEVENT_REQ_USER_ERROR) { \
270 : : return TRROEerr; \
271 : : } \
272 : : return EIO; \
273 : : } \
274 : : } while (0)
275 : :
276 : : #define OUT_OF_ID_RANGE(id, min, max) \
277 : : (id == 0 || (min && (id < min)) || (max && (id > max)))
278 : :
279 : : #define SIZE_T_MAX ((size_t) -1)
280 : :
281 : : #define SIZE_T_OVERFLOW(current, add) \
282 : : (((size_t)(add)) > (SIZE_T_MAX - ((size_t)(current))))
283 : :
284 : : static inline void
285 : 83 : safealign_memcpy(void *dest, const void *src, size_t n, size_t *counter)
286 : : {
287 : 83 : memcpy(dest, src, n);
288 [ + - ]: 83 : if (counter) {
289 : 83 : *counter += n;
290 : : }
291 : 83 : }
292 : :
293 : : #define SAFEALIGN_SET_VALUE(dest, value, type, pctr) do { \
294 : : type CV_MACRO_val = (type)(value); \
295 : : safealign_memcpy(dest, &CV_MACRO_val, sizeof(type), pctr); \
296 : : } while(0)
297 : :
298 : : #define SAFEALIGN_COPY_INT64(dest, src, pctr) \
299 : : safealign_memcpy(dest, src, sizeof(int64_t), pctr)
300 : :
301 : : #define SAFEALIGN_SET_INT64(dest, value, pctr) \
302 : : SAFEALIGN_SET_VALUE(dest, value, int64_t, pctr)
303 : :
304 : : #define SAFEALIGN_COPY_UINT32(dest, src, pctr) \
305 : : safealign_memcpy(dest, src, sizeof(uint32_t), pctr)
306 : :
307 : : #define SAFEALIGN_SET_UINT32(dest, value, pctr) \
308 : : SAFEALIGN_SET_VALUE(dest, value, uint32_t, pctr)
309 : :
310 : : #define SAFEALIGN_COPY_INT32(dest, src, pctr) \
311 : : safealign_memcpy(dest, src, sizeof(int32_t), pctr)
312 : :
313 : : #define SAFEALIGN_SET_INT32(dest, value, pctr) \
314 : : SAFEALIGN_SET_VALUE(dest, value, int32_t, pctr)
315 : :
316 : : #define SAFEALIGN_COPY_UINT16(dest, src, pctr) \
317 : : safealign_memcpy(dest, src, sizeof(uint16_t), pctr)
318 : :
319 : : #define SAFEALIGN_SET_UINT16(dest, value, pctr) \
320 : : SAFEALIGN_SET_VALUE(dest, value, uint16_t, pctr)
321 : :
322 : : #define SAFEALIGN_COPY_UINT32_CHECK(dest, src, len, pctr) do { \
323 : : if ((*(pctr) + sizeof(uint32_t)) > (len) || \
324 : : SIZE_T_OVERFLOW(*(pctr), sizeof(uint32_t))) return EINVAL; \
325 : : safealign_memcpy(dest, src, sizeof(uint32_t), pctr); \
326 : : } while(0)
327 : :
328 : : #define SAFEALIGN_COPY_INT32_CHECK(dest, src, len, pctr) do { \
329 : : if ((*(pctr) + sizeof(int32_t)) > (len) || \
330 : : SIZE_T_OVERFLOW(*(pctr), sizeof(int32_t))) return EINVAL; \
331 : : safealign_memcpy(dest, src, sizeof(int32_t), pctr); \
332 : : } while(0)
333 : :
334 : : #define SAFEALIGN_COPY_UINT16_CHECK(dest, src, len, pctr) do { \
335 : : if ((*(pctr) + sizeof(uint16_t)) > (len) || \
336 : : SIZE_T_OVERFLOW(*(pctr), sizeof(uint16_t))) return EINVAL; \
337 : : safealign_memcpy(dest, src, sizeof(uint16_t), pctr); \
338 : : } while(0)
339 : :
340 : : #include "util/dlinklist.h"
341 : :
342 : : /* From debug.c */
343 : : void ldb_debug_messages(void *context, enum ldb_debug_level level,
344 : : const char *fmt, va_list ap);
345 : : int open_debug_file_ex(const char *filename, FILE **filep);
346 : : int open_debug_file(void);
347 : : int rotate_debug_files(void);
348 : : void talloc_log_fn(const char *msg);
349 : :
350 : : /* From sss_log.c */
351 : : #define SSS_LOG_EMERG 0 /* system is unusable */
352 : : #define SSS_LOG_ALERT 1 /* action must be taken immediately */
353 : : #define SSS_LOG_CRIT 2 /* critical conditions */
354 : : #define SSS_LOG_ERR 3 /* error conditions */
355 : : #define SSS_LOG_WARNING 4 /* warning conditions */
356 : : #define SSS_LOG_NOTICE 5 /* normal but significant condition */
357 : : #define SSS_LOG_INFO 6 /* informational */
358 : : #define SSS_LOG_DEBUG 7 /* debug-level messages */
359 : :
360 : : void sss_log(int priority, const char *format, ...);
361 : :
362 : : /* from server.c */
363 : : struct main_context {
364 : : struct tevent_context *event_ctx;
365 : : struct confdb_ctx *confdb_ctx;
366 : : pid_t parent_pid;
367 : : };
368 : :
369 : : int die_if_parent_died(void);
370 : : int pidfile(const char *path, const char *name);
371 : : int server_setup(const char *name, int flags,
372 : : const char *conf_entry,
373 : : struct main_context **main_ctx);
374 : : void server_loop(struct main_context *main_ctx);
375 : : void sig_term(int sig);
376 : :
377 : : /* from signal.c */
378 : : #include <signal.h>
379 : : void BlockSignals(bool block, int signum);
380 : : void (*CatchSignal(int signum,void (*handler)(int )))(int);
381 : : void CatchChild(void);
382 : : void CatchChildLeaveStatus(void);
383 : :
384 : : /* from memory.c */
385 : : typedef int (void_destructor_fn_t)(void *);
386 : :
387 : : struct mem_holder {
388 : : void *mem;
389 : : void_destructor_fn_t *fn;
390 : : };
391 : :
392 : : void *sss_mem_attach(TALLOC_CTX *mem_ctx,
393 : : void *ptr,
394 : : void_destructor_fn_t *fn);
395 : :
396 : : int password_destructor(void *memctx);
397 : :
398 : : /* from usertools.c */
399 : : char *get_username_from_uid(TALLOC_CTX *mem_ctx, uid_t uid);
400 : :
401 : : char *get_uppercase_realm(TALLOC_CTX *memctx, const char *name);
402 : :
403 : : struct sss_names_ctx {
404 : : char *re_pattern;
405 : : char *fq_fmt;
406 : :
407 : : pcre *re;
408 : : };
409 : :
410 : : int sss_names_init(TALLOC_CTX *mem_ctx,
411 : : struct confdb_ctx *cdb,
412 : : const char *domain,
413 : : struct sss_names_ctx **out);
414 : :
415 : : int sss_parse_name(TALLOC_CTX *memctx,
416 : : struct sss_names_ctx *snctx,
417 : : const char *orig, char **domain, char **name);
418 : :
419 : : char *
420 : : sss_get_cased_name(TALLOC_CTX *mem_ctx, const char *orig_name,
421 : : bool case_sensitive);
422 : :
423 : : errno_t
424 : : sss_get_cased_name_list(TALLOC_CTX *mem_ctx, const char * const *orig,
425 : : bool case_sensitive, const char ***_cased);
426 : :
427 : : /* from backup-file.c */
428 : : int backup_file(const char *src, int dbglvl);
429 : :
430 : : /* from check_and_open.c */
431 : : enum check_file_type {
432 : : CHECK_DONT_CHECK_FILE_TYPE = -1,
433 : : CHECK_REG,
434 : : CHECK_DIR,
435 : : CHECK_CHR,
436 : : CHECK_BLK,
437 : : CHECK_FIFO,
438 : : CHECK_LNK,
439 : : CHECK_SOCK
440 : : };
441 : :
442 : : /* check_file()
443 : : * Verify that a file has certain permissions and/or is of a certain
444 : : * file type. This function can be used to determine if a file is a
445 : : * symlink.
446 : : * Warning: use of this function implies a potential race condition
447 : : * Opening a file before or after checking it does NOT guarantee that
448 : : * it is still the same file. Additional checks should be performed
449 : : * on the caller_stat_buf to ensure that it has the same device and
450 : : * inode to minimize impact. Permission changes may have occurred,
451 : : * however.
452 : : */
453 : : errno_t check_file(const char *filename, const int uid, const int gid,
454 : : const int mode, enum check_file_type type,
455 : : struct stat *caller_stat_buf, bool follow_symlink);
456 : :
457 : : /* check_fd()
458 : : * Verify that an open file descriptor has certain permissions and/or
459 : : * is of a certain file type. This function CANNOT detect symlinks,
460 : : * as the file is already open and symlinks have been traversed. This
461 : : * is the safer way to perform file checks and should be preferred
462 : : * over check_file for nearly all situations.
463 : : */
464 : : errno_t check_fd(int fd, const int uid, const int gid,
465 : : const int mode, enum check_file_type type,
466 : : struct stat *caller_stat_buf);
467 : :
468 : : /* check_and_open_readonly()
469 : : * Utility function to open a file and verify that it has certain
470 : : * permissions and is of a certain file type. This function wraps
471 : : * check_fd(), and is considered race-condition safe.
472 : : */
473 : : errno_t check_and_open_readonly(const char *filename, int *fd, const uid_t uid,
474 : : const gid_t gid, const mode_t mode,
475 : : enum check_file_type type);
476 : :
477 : : /* from util.c */
478 : : int split_on_separator(TALLOC_CTX *mem_ctx, const char *str,
479 : : const char sep, bool trim, char ***_list, int *size);
480 : :
481 : : char **parse_args(const char *str);
482 : :
483 : : errno_t sss_hash_create(TALLOC_CTX *mem_ctx,
484 : : unsigned long count,
485 : : hash_table_t **tbl);
486 : :
487 : : errno_t sss_hash_create_ex(TALLOC_CTX *mem_ctx,
488 : : unsigned long count,
489 : : hash_table_t **tbl,
490 : : unsigned int directory_bits,
491 : : unsigned int segment_bits,
492 : : unsigned long min_load_factor,
493 : : unsigned long max_load_factor,
494 : : hash_delete_callback *delete_callback,
495 : : void *delete_private_data);
496 : :
497 : : /* Copy a NULL-terminated string list
498 : : * Returns NULL on out of memory error or invalid input
499 : : */
500 : : char **dup_string_list(TALLOC_CTX *memctx, const char **str_list);
501 : :
502 : : /* Take two string lists (terminated on a NULL char*)
503 : : * and return up to three arrays of strings based on
504 : : * shared ownership.
505 : : *
506 : : * Pass NULL to any return type you don't care about
507 : : */
508 : : errno_t diff_string_lists(TALLOC_CTX *memctx,
509 : : char **string1,
510 : : char **string2,
511 : : char ***string1_only,
512 : : char ***string2_only,
513 : : char ***both_strings);
514 : :
515 : : /* Sanitize an input string (e.g. a username) for use in
516 : : * an LDAP/LDB filter
517 : : * Returns a newly-constructed string attached to mem_ctx
518 : : * It will fail only on an out of memory condition, where it
519 : : * will return ENOMEM.
520 : : */
521 : : errno_t sss_filter_sanitize(TALLOC_CTX *mem_ctx,
522 : : const char *input,
523 : : char **sanitized);
524 : :
525 : : char *
526 : : sss_escape_ip_address(TALLOC_CTX *mem_ctx, int family, const char *addr);
527 : :
528 : : /* This function only removes first and last
529 : : * character if the first character was '['.
530 : : *
531 : : * NOTE: This means, that ipv6addr must NOT be followed
532 : : * by port number.
533 : : */
534 : : errno_t
535 : : remove_ipv6_brackets(char *ipv6addr);
536 : :
537 : :
538 : : errno_t add_string_to_list(TALLOC_CTX *mem_ctx, const char *string,
539 : : char ***list_p);
540 : :
541 : : bool string_in_list(const char *string, char **list, bool case_sensitive);
542 : :
543 : : /* from sss_tc_utf8.c */
544 : : char *
545 : : sss_tc_utf8_str_tolower(TALLOC_CTX *mem_ctx, const char *s);
546 : : uint8_t *
547 : : sss_tc_utf8_tolower(TALLOC_CTX *mem_ctx, const uint8_t *s, size_t len, size_t *_nlen);
548 : : bool sss_string_equal(bool cs, const char *s1, const char *s2);
549 : :
550 : : /* len includes terminating '\0' */
551 : : struct sized_string {
552 : : const char *str;
553 : : size_t len;
554 : : };
555 : :
556 : : void to_sized_string(struct sized_string *out, const char *in);
557 : :
558 : : /* form domain_info.c */
559 : : struct sss_domain_info *new_subdomain(TALLOC_CTX *mem_ctx,
560 : : struct sss_domain_info *parent,
561 : : const char *name,
562 : : const char *flat_name,
563 : : const char *id);
564 : : struct sss_domain_info *copy_subdomain(TALLOC_CTX *mem_ctx,
565 : : struct sss_domain_info *subdomain);
566 : :
567 : : /* from util_lock.c */
568 : : errno_t sss_br_lock_file(int fd, size_t start, size_t len,
569 : : int num_tries, useconds_t wait);
570 : :
571 : : /* Endianness-compatibility for systems running older versions of glibc */
572 : :
573 : : #ifndef le32toh
574 : : #include <byteswap.h>
575 : :
576 : : /* Copied from endian.h on glibc 2.15 */
577 : : #ifdef __USE_BSD
578 : : /* Conversion interfaces. */
579 : : # if __BYTE_ORDER == __LITTLE_ENDIAN
580 : : # define le32toh(x) (x)
581 : : # define htole32(x) (x)
582 : : # else
583 : : # define le32toh(x) __bswap_32 (x)
584 : : # define htole32(x) __bswap_32 (x)
585 : : # endif
586 : : #endif /* __USE_BSD */
587 : :
588 : : #endif /* le32toh */
589 : :
590 : : #ifdef HAVE_PAC_RESPONDER
591 : : #define BUILD_WITH_PAC_RESPONDER true
592 : : #else
593 : : #define BUILD_WITH_PAC_RESPONDER false
594 : : #endif
595 : :
596 : : #endif /* __SSSD_UTIL_H__ */
|
