2 Unix SMB/CIFS implementation.
3 Utility functions for Samba
4 Copyright (C) Andrew Tridgell 1992-1999
5 Copyright (C) Jelmer Vernooij 2005
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.
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.
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/>.
21 #ifndef _SAMBA_UTIL_H_
22 #define _SAMBA_UTIL_H_
24 #include "lib/util/charset/charset.h"
25 #include "lib/util/attr.h"
32 * @brief Helpful macros
37 extern const char *panic_action
;
39 #include "lib/util/time.h"
40 #include "lib/util/data_blob.h"
41 #include "lib/util/xfile.h"
42 #include "lib/util/byteorder.h"
43 #include "lib/util/talloc_stack.h"
49 #define SMB_ASSERT(b) do { if (!(b)) { \
50 DEBUG(0,("PANIC: assert failed at %s(%d): %s\n", \
51 __FILE__, __LINE__, #b)); smb_panic("assert failed: " #b); }} while(0)
53 /* redefine the assert macro for non-developer builds */
54 #define SMB_ASSERT(b) do { if (!(b)) { \
55 DEBUG(0,("PANIC: assert failed at %s(%d): %s\n", \
56 __FILE__, __LINE__, #b)); }} while (0)
60 #define ABS(a) ((a)>0?(a):(-(a)))
63 #include "lib/util/memory.h"
65 #include "lib/util/string_wrappers.h"
68 * Write backtrace to debug log
70 _PUBLIC_
void call_backtrace(void);
73 Something really nasty happened - panic !
75 typedef void (*smb_panic_handler_t
)(const char *why
);
77 _PUBLIC_
void fault_configure(smb_panic_handler_t panic_handler
);
78 _PUBLIC_
void fault_setup(void);
79 _PUBLIC_
void fault_setup_disable(void);
80 _PUBLIC_
void dump_core_setup(const char *progname
, const char *logfile
);
81 _PUBLIC_
void smb_panic(const char *reason
);
85 register a fault handler.
86 Should only be called once in the execution of smbd.
88 _PUBLIC_
bool register_fault_handler(const char *name
, void (*fault_handler
)(int sig
));
90 /* The following definitions come from lib/util/signal.c */
96 void BlockSignals(bool block
, int signum
);
99 Catch a signal. This should implement the following semantics:
101 1) The handler remains installed after being called.
102 2) The signal should be blocked during handler execution.
104 void (*CatchSignal(int signum
,void (*handler
)(int )))(int);
107 Ignore SIGCLD via whatever means is necessary for this OS.
109 void CatchChild(void);
112 Catch SIGCLD but leave the child around so it's status can be reaped.
114 void CatchChildLeaveStatus(void);
116 /* The following definitions come from lib/util/system.c */
118 void *sys_memalign( size_t align
, size_t size
);
120 /**************************************************************************
121 A wrapper for gethostbyname() that tries avoids looking up hostnames
122 in the root domain, which can cause dial-on-demand links to come up for no
124 ****************************************************************************/
125 _PUBLIC_
struct hostent
*sys_gethostbyname(const char *name
);
126 _PUBLIC_
struct in_addr
sys_inet_makeaddr(int net
, int host
);
129 * Wrapper for fork used to invalid pid cache.
131 _PUBLIC_ pid_t
sys_fork(void);
134 * Wrapper for getpid. Ensures we only do a system call *once*.
136 _PUBLIC_ pid_t
sys_getpid(void);
138 _PUBLIC_
int sys_getpeereid( int s
, uid_t
*uid
);
142 _PUBLIC_
int sys_getnameinfo(const struct sockaddr
*psa
,
149 _PUBLIC_
int sys_connect(int fd
, const struct sockaddr
* addr
);
151 /* The following definitions come from lib/util/genrand.c */
153 Copy any user given reseed data.
155 _PUBLIC_
void set_rand_reseed_callback(void (*fn
)(void *, int *), void *);
158 * Tell the random number generator it needs to reseed.
160 _PUBLIC_
void set_need_random_reseed(void);
163 Interface to the (hopefully) good crypto random number generator.
164 Will use our internal PRNG if more than 40 bytes of random generation
165 has been requested, otherwise tries to read from /dev/random
167 _PUBLIC_
void generate_random_buffer(uint8_t *out
, int len
);
170 Interface to the (hopefully) good crypto random number generator.
171 Will always use /dev/urandom if available.
173 _PUBLIC_
void generate_secret_buffer(uint8_t *out
, int len
);
176 generate a single random uint32_t
178 _PUBLIC_
uint32_t generate_random(void);
181 very basic password quality checker
183 _PUBLIC_
bool check_password_quality(const char *s
);
186 * Generate a random text password.
188 _PUBLIC_
char *generate_random_password(TALLOC_CTX
*mem_ctx
, size_t min
, size_t max
);
191 Use the random number generator to generate a random string.
193 _PUBLIC_
char *generate_random_str_list(TALLOC_CTX
*mem_ctx
, size_t len
, const char *list
);
196 * Generate a random text string consisting of the specified length.
197 * The returned string will be allocated.
199 * Characters used are: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,
201 _PUBLIC_
char *generate_random_str(TALLOC_CTX
*mem_ctx
, size_t len
);
204 * Generate an array of unique text strings all of the same length.
205 * The returned strings will be allocated.
206 * Returns NULL if the number of unique combinations cannot be created.
208 * Characters used are: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,
210 _PUBLIC_
char** generate_unique_strs(TALLOC_CTX
*mem_ctx
, size_t len
,
213 /* The following definitions come from lib/util/dprintf.c */
214 #if _SAMBA_BUILD_ == 4
216 _PUBLIC_
void d_set_iconv(smb_iconv_t
);
217 _PUBLIC_
int d_vfprintf(FILE *f
, const char *format
, va_list ap
) PRINTF_ATTRIBUTE(2,0);
218 _PUBLIC_
int d_fprintf(FILE *f
, const char *format
, ...) PRINTF_ATTRIBUTE(2,3);
219 _PUBLIC_
int d_printf(const char *format
, ...) PRINTF_ATTRIBUTE(1,2);
220 _PUBLIC_
void display_set_stderr(void);
223 /* The following definitions come from lib/util/util_str.c */
225 bool next_token_talloc(TALLOC_CTX
*ctx
,
231 * Get the next token from a string, return false if none found. Handles
232 * double-quotes. This version does not trim leading separator characters
233 * before looking for a token.
235 bool next_token_no_ltrim_talloc(TALLOC_CTX
*ctx
,
242 Trim the specified elements off the front and back of a string.
244 _PUBLIC_
bool trim_string(char *s
, const char *front
, const char *back
);
247 Find the number of 'c' chars in a string
249 _PUBLIC_ _PURE_
size_t count_chars(const char *s
, char c
);
252 Routine to get hex characters and turn them into a 16 byte array.
253 the array can be variable length, and any non-hex-numeric
254 characters are skipped. "0xnn" or "0Xnn" is specially catered
257 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
261 _PUBLIC_
size_t strhex_to_str(char *p
, size_t p_len
, const char *strhex
, size_t strhex_len
);
264 * Parse a hex string and return a data blob.
266 _PUBLIC_ _PURE_ DATA_BLOB
strhex_to_data_blob(TALLOC_CTX
*mem_ctx
, const char *strhex
) ;
269 * Routine to print a buffer as HEX digits, into an allocated string.
271 _PUBLIC_
void hex_encode(const unsigned char *buff_in
, size_t len
, char **out_hex_buffer
);
274 * talloc version of hex_encode()
276 _PUBLIC_
char *hex_encode_talloc(TALLOC_CTX
*mem_ctx
, const unsigned char *buff_in
, size_t len
);
279 Substitute a string for a pattern in another string. Make sure there is
282 This routine looks for pattern in s and replaces it with
283 insert. It may do multiple replacements.
285 Any of " ; ' $ or ` in the insert string are replaced with _
286 if len==0 then the string cannot be extended. This is different from the old
287 use of len==0 which was for no length checks to be done.
289 _PUBLIC_
void string_sub(char *s
,const char *pattern
, const char *insert
, size_t len
);
291 _PUBLIC_
void string_sub_once(char *s
, const char *pattern
,
292 const char *insert
, size_t len
);
294 _PUBLIC_
char *string_sub_talloc(TALLOC_CTX
*mem_ctx
, const char *s
,
295 const char *pattern
, const char *insert
);
298 Similar to string_sub() but allows for any character to be substituted.
300 if len==0 then the string cannot be extended. This is different from the old
301 use of len==0 which was for no length checks to be done.
303 _PUBLIC_
void all_string_sub(char *s
,const char *pattern
,const char *insert
, size_t len
);
306 Unescape a URL encoded string, in place.
308 _PUBLIC_
void rfc1738_unescape(char *buf
);
313 * Returns a static buffer that contains the RFC
314 * 1738 compliant, escaped version of the given url. (escapes unsafe and % characters)
316 _PUBLIC_
char *rfc1738_escape(TALLOC_CTX
*mem_ctx
, const char *url
);
319 * rfc1738_escape_unescaped
321 * Returns a static buffer that contains
322 * the RFC 1738 compliant, escaped version of the given url (escapes unsafe chars only)
324 _PUBLIC_
char *rfc1738_escape_unescaped(TALLOC_CTX
*mem_ctx
, const char *url
);
327 * rfc1738_escape_part
328 * Returns a static buffer that contains the RFC
329 * 1738 compliant, escaped version of the given url segment. (escapes
330 * unsafe, reserved and % chars) It would mangle the :// in http://,
331 * and mangle paths (because of /).
333 _PUBLIC_
char *rfc1738_escape_part(TALLOC_CTX
*mem_ctx
, const char *url
);
336 format a string into length-prefixed dotted domain format, as used in NBT
337 and in some ADS structures
339 _PUBLIC_
const char *str_format_nbt_domain(TALLOC_CTX
*mem_ctx
, const char *s
);
342 * Add a string to an array of strings.
344 * num should be a pointer to an integer that holds the current
345 * number of elements in strings. It will be updated by this function.
347 _PUBLIC_
bool add_string_to_array(TALLOC_CTX
*mem_ctx
,
348 const char *str
, const char ***strings
, int *num
);
351 varient of strcmp() that handles NULL ptrs
353 _PUBLIC_
int strcmp_safe(const char *s1
, const char *s2
);
356 return the number of bytes occupied by a buffer in ASCII format
357 the result includes the null termination
360 _PUBLIC_
size_t ascii_len_n(const char *src
, size_t n
);
363 Set a boolean variable from the text value stored in the passed string.
364 Returns true in success, false if the passed string does not correctly
367 _PUBLIC_
bool set_boolean(const char *boolean_string
, bool *boolean
);
370 * Parse a string containing a boolean value.
372 * val will be set to the read value.
374 * @retval true if a boolean value was parsed, false otherwise.
376 _PUBLIC_
bool conv_str_bool(const char * str
, bool * val
);
379 * Convert a size specification like 16K into an integral number of bytes.
381 _PUBLIC_
bool conv_str_size_error(const char * str
, uint64_t * val
);
384 * Parse a uint64_t value from a string
386 * val will be set to the value read.
388 * @retval true if parsing was successful, false otherwise
390 _PUBLIC_
bool conv_str_u64(const char * str
, uint64_t * val
);
393 return the number of bytes occupied by a buffer in CH_UTF16 format
394 the result includes the null termination
396 _PUBLIC_
size_t utf16_len(const void *buf
);
399 return the number of bytes occupied by a buffer in CH_UTF16 format
400 the result includes the null termination
403 _PUBLIC_
size_t utf16_len_n(const void *src
, size_t n
);
404 _PUBLIC_
size_t ucs2_align(const void *base_ptr
, const void *p
, int flags
);
407 Do a case-insensitive, whitespace-ignoring string compare.
409 _PUBLIC_
int strwicmp(const char *psz1
, const char *psz2
);
414 _PUBLIC_
void string_replace(char *s
, char oldc
, char newc
);
417 Base64 decode a string, place into a data blob. Caller to data_blob_free() the result.
419 _PUBLIC_ DATA_BLOB
base64_decode_data_blob(const char *s
);
421 Base64 decode a string, inplace
423 _PUBLIC_
void base64_decode_inplace(char *s
);
425 Base64 encode a binary data blob into a string
427 _PUBLIC_
char *base64_encode_data_blob(TALLOC_CTX
*mem_ctx
, DATA_BLOB data
);
432 * @note The comparison is case-insensitive.
434 _PUBLIC_
bool strequal(const char *s1
, const char *s2
);
436 /* The following definitions come from lib/util/util_strlist.c */
438 /* separators for lists */
440 #define LIST_SEP " \t,\n\r"
444 build an empty (only NULL terminated) list of strings (for expansion with str_list_add() etc)
446 _PUBLIC_
char **str_list_make_empty(TALLOC_CTX
*mem_ctx
);
449 place the only element 'entry' into a new, NULL terminated string list
451 _PUBLIC_
char **str_list_make_single(TALLOC_CTX
*mem_ctx
,
455 build a null terminated list of strings from a input string and a
456 separator list. The separator list must contain characters less than
457 or equal to 0x2f for this to work correctly on multi-byte strings
459 _PUBLIC_
char **str_list_make(TALLOC_CTX
*mem_ctx
, const char *string
,
463 * build a null terminated list of strings from an argv-like input string
464 * Entries are separated by spaces and can be enclosed by quotes.
465 * Does NOT support escaping
467 _PUBLIC_
char **str_list_make_shell(TALLOC_CTX
*mem_ctx
, const char *string
, const char *sep
);
470 * join a list back to one string
472 _PUBLIC_
char *str_list_join(TALLOC_CTX
*mem_ctx
, const char **list
, char separator
);
474 /** join a list back to one (shell-like) string; entries
475 * separated by spaces, using quotes where necessary */
476 _PUBLIC_
char *str_list_join_shell(TALLOC_CTX
*mem_ctx
, const char **list
, char sep
);
479 return the number of elements in a string list
481 _PUBLIC_
size_t str_list_length(const char * const *list
);
486 _PUBLIC_
char **str_list_copy(TALLOC_CTX
*mem_ctx
, const char **list
);
489 Return true if all the elements of the list match exactly.
491 _PUBLIC_
bool str_list_equal(const char * const *list1
, const char * const *list2
);
494 add an entry to a string list
496 _PUBLIC_
const char **str_list_add(const char **list
, const char *s
);
499 remove an entry from a string list
501 _PUBLIC_
void str_list_remove(const char **list
, const char *s
);
504 return true if a string is in a list
506 _PUBLIC_
bool str_list_check(const char **list
, const char *s
);
509 return true if a string is in a list, case insensitively
511 _PUBLIC_
bool str_list_check_ci(const char **list
, const char *s
);
513 append one list to another - expanding list1
515 _PUBLIC_
const char **str_list_append(const char **list1
,
516 const char * const *list2
);
519 remove duplicate elements from a list
521 _PUBLIC_
const char **str_list_unique(const char **list
);
524 very useful when debugging complex list related code
526 _PUBLIC_
void str_list_show(const char **list
);
530 append one list to another - expanding list1
531 this assumes the elements of list2 are const pointers, so we can re-use them
533 _PUBLIC_
const char **str_list_append_const(const char **list1
,
537 add an entry to a string list
538 this assumes s will not change
540 _PUBLIC_
const char **str_list_add_const(const char **list
, const char *s
);
544 this assumes list will not change
546 _PUBLIC_
const char **str_list_copy_const(TALLOC_CTX
*mem_ctx
,
550 * Needed for making an "unconst" list "const"
552 _PUBLIC_
const char **const_str_list(char **list
);
555 /* The following definitions come from lib/util/util_file.c */
559 read a line from a file with possible \ continuation chars.
560 Blanks at the start or end of a line are stripped.
561 The string will be allocated if s2 is NULL
563 _PUBLIC_
char *fgets_slash(char *s2
,int maxlen
,XFILE
*f
);
566 * Read one line (data until next newline or eof) and allocate it
568 _PUBLIC_
char *afdgets(int fd
, TALLOC_CTX
*mem_ctx
, size_t hint
);
571 load a file into memory from a fd.
573 _PUBLIC_
char *fd_load(int fd
, size_t *size
, size_t maxsize
, TALLOC_CTX
*mem_ctx
);
576 char **file_lines_parse(char *p
, size_t size
, int *numlines
, TALLOC_CTX
*mem_ctx
);
579 load a file into memory
581 _PUBLIC_
char *file_load(const char *fname
, size_t *size
, size_t maxsize
, TALLOC_CTX
*mem_ctx
);
584 mmap (if possible) or read a file
586 _PUBLIC_
void *map_file(const char *fname
, size_t size
);
589 load a file into memory and return an array of pointers to lines in the file
590 must be freed with talloc_free().
592 _PUBLIC_
char **file_lines_load(const char *fname
, int *numlines
, size_t maxsize
, TALLOC_CTX
*mem_ctx
);
595 load a fd into memory and return an array of pointers to lines in the file
596 must be freed with talloc_free(). If convert is true calls unix_to_dos on
599 _PUBLIC_
char **fd_lines_load(int fd
, int *numlines
, size_t maxsize
, TALLOC_CTX
*mem_ctx
);
602 take a list of lines and modify them to produce a list where \ continues
605 _PUBLIC_
void file_lines_slashcont(char **lines
);
608 save a lump of data into a file. Mostly used for debugging
610 _PUBLIC_
bool file_save(const char *fname
, const void *packet
, size_t length
);
611 _PUBLIC_
int vfdprintf(int fd
, const char *format
, va_list ap
) PRINTF_ATTRIBUTE(2,0);
612 _PUBLIC_
int fdprintf(int fd
, const char *format
, ...) PRINTF_ATTRIBUTE(2,3);
613 _PUBLIC_
bool large_file_support(const char *path
);
616 compare two files, return true if the two files have the same content
618 bool file_compare(const char *path1
, const char *path2
);
620 /* The following definitions come from lib/util/util.c */
624 Find a suitable temporary directory. The result should be copied immediately
625 as it may be overwritten by a subsequent call.
627 _PUBLIC_
const char *tmpdir(void);
630 Check if a file exists - call vfs_file_exist for samba files.
632 _PUBLIC_
bool file_exist(const char *fname
);
635 Check a files mod time.
637 _PUBLIC_
time_t file_modtime(const char *fname
);
640 Check if a directory exists.
642 _PUBLIC_
bool directory_exist(const char *dname
);
645 * Try to create the specified directory if it didn't exist.
647 * @retval true if the directory already existed and has the right permissions
648 * or was successfully created.
650 _PUBLIC_
bool directory_create_or_exist(const char *dname
, uid_t uid
,
654 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
659 _PUBLIC_
int set_blocking(int fd
, bool set
);
662 Sleep for a specified number of milliseconds.
664 _PUBLIC_
void smb_msleep(unsigned int t
);
667 Get my own name, return in talloc'ed storage.
669 _PUBLIC_
char* get_myname(TALLOC_CTX
*mem_ctx
);
672 Check if a process exists. Does this work on all unixes?
674 _PUBLIC_
bool process_exists_by_pid(pid_t pid
);
677 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
678 is dealt with in posix.c
680 _PUBLIC_
bool fcntl_lock(int fd
, int op
, off_t offset
, off_t count
, int type
);
683 * Write dump of binary data to a callback
685 void dump_data_cb(const uint8_t *buf
, int len
,
686 bool omit_zero_bytes
,
687 void (*cb
)(const char *buf
, void *private_data
),
691 * Write dump of binary data to the log file.
693 * The data is only written if the log level is at least level.
695 _PUBLIC_
void dump_data(int level
, const uint8_t *buf
,int len
);
698 * Write dump of binary data to the log file.
700 * The data is only written if the log level is at least level.
701 * 16 zero bytes in a row are omitted
703 _PUBLIC_
void dump_data_skip_zeros(int level
, const uint8_t *buf
, int len
);
706 malloc that aborts with smb_panic on fail or zero size.
708 _PUBLIC_
void *smb_xmalloc(size_t size
);
711 Memdup with smb_panic on fail.
713 _PUBLIC_
void *smb_xmemdup(const void *p
, size_t size
);
716 strdup that aborts on malloc fail.
718 _PUBLIC_
char *smb_xstrdup(const char *s
);
720 char *smb_xstrndup(const char *s
, size_t n
);
723 Like strdup but for memory.
725 _PUBLIC_
void *memdup(const void *p
, size_t size
);
728 * Write a password to the log file.
730 * @note Only actually does something if DEBUG_PASSWORD was defined during
733 _PUBLIC_
void dump_data_pw(const char *msg
, const uint8_t * data
, size_t len
);
736 * see if a range of memory is all zero. A NULL pointer is considered
739 _PUBLIC_
bool all_zero(const uint8_t *ptr
, size_t size
);
742 realloc an array, checking for integer overflow in the array size
744 _PUBLIC_
void *realloc_array(void *ptr
, size_t el_size
, unsigned count
, bool free_on_fail
);
746 void *malloc_array(size_t el_size
, unsigned int count
);
748 /* The following definitions come from lib/util/fsusage.c */
752 * Retrieve amount of free disk space.
753 * this does all of the system specific guff to get the free disk space.
754 * It is derived from code in the GNU fileutils package, but has been
755 * considerably mangled for use here
757 * results are returned in *dfree and *dsize, in 512 byte units
759 _PUBLIC_
int sys_fsusage(const char *path
, uint64_t *dfree
, uint64_t *dsize
);
761 /* The following definitions come from lib/util/ms_fnmatch.c */
766 * @brief MS-style Filename matching
769 #if _SAMBA_BUILD_ == 4
770 /* protocol types. It assumes that higher protocols include lower protocols
771 as subsets. FIXME: Move to one of the smb-specific headers */
772 enum protocol_types
{
784 int ms_fnmatch_protocol(const char *pattern
, const char *string
, int protocol
);
786 /** a generic fnmatch function - uses for non-CIFS pattern matching */
787 int gen_fnmatch(const char *pattern
, const char *string
);
789 /* The following definitions come from lib/util/idtree.c */
793 initialise a idr tree. The context return value must be passed to
794 all subsequent idr calls. To destroy the idr tree use talloc_free()
797 _PUBLIC_
struct idr_context
*idr_init(TALLOC_CTX
*mem_ctx
);
800 allocate the next available id, and assign 'ptr' into its slot.
801 you can retrieve later this pointer using idr_find()
803 _PUBLIC_
int idr_get_new(struct idr_context
*idp
, void *ptr
, int limit
);
806 allocate a new id, giving the first available value greater than or
807 equal to the given starting id
809 _PUBLIC_
int idr_get_new_above(struct idr_context
*idp
, void *ptr
, int starting_id
, int limit
);
812 allocate a new id randomly in the given range
814 _PUBLIC_
int idr_get_new_random(struct idr_context
*idp
, void *ptr
, int limit
);
817 find a pointer value previously set with idr_get_new given an id
819 _PUBLIC_
void *idr_find(struct idr_context
*idp
, int id
);
822 remove an id from the idr tree
824 _PUBLIC_
int idr_remove(struct idr_context
*idp
, int id
);
826 /* The following definitions come from lib/util/become_daemon.c */
829 Close the low 3 fd's and open dev/null in their place
831 _PUBLIC_
void close_low_fds(bool stderr_too
);
834 Become a daemon, discarding the controlling terminal.
836 _PUBLIC_
void become_daemon(bool do_fork
, bool no_process_group
, bool log_stdout
);
839 * Load a ini-style file.
841 bool pm_process( const char *fileName
,
842 bool (*sfunc
)(const char *, void *),
843 bool (*pfunc
)(const char *, const char *, void *),
846 bool unmap_file(void *start
, size_t size
);
848 void print_asc(int level
, const uint8_t *buf
,int len
);
849 void print_asc_cb(const uint8_t *buf
, int len
,
850 void (*cb
)(const char *buf
, void *private_data
),
854 * Add an id to an array of ids.
856 * num should be a pointer to an integer that holds the current
857 * number of elements in ids. It will be updated by this function.
860 bool add_uid_to_array_unique(TALLOC_CTX
*mem_ctx
, uid_t uid
,
861 uid_t
**uids
, uint32_t *num_uids
);
862 bool add_gid_to_array_unique(TALLOC_CTX
*mem_ctx
, gid_t gid
,
863 gid_t
**gids
, uint32_t *num_gids
);
866 * Allocate anonymous shared memory of the given size
868 void *anonymous_shared_allocate(size_t bufsz
);
869 void anonymous_shared_free(void *ptr
);
872 run a command as a child process, with a timeout.
874 any stdout/stderr from the child will appear in the Samba logs with
875 the specified log levels
877 If callback is set then the callback is called on completion
878 with the return code from the command
880 struct tevent_context
;
882 struct tevent_req
*samba_runcmd_send(TALLOC_CTX
*mem_ctx
,
883 struct tevent_context
*ev
,
884 struct timeval endtime
,
885 int stdout_log_level
,
886 int stderr_log_level
,
887 const char * const *argv0
, ...);
888 int samba_runcmd_recv(struct tevent_req
*req
, int *perrno
);
891 void samba_start_debugger(void);
895 * @brief Returns an absolute path to a file in the Samba modules directory.
897 * @param name File to find, relative to MODULESDIR.
899 * @retval Pointer to a string containing the full path.
901 char *modules_path(TALLOC_CTX
*mem_ctx
, const char *name
);
904 * @brief Returns an absolute path to a file in the Samba data directory.
906 * @param name File to find, relative to CODEPAGEDIR.
908 * @retval Pointer to a talloc'ed string containing the full path.
910 char *data_path(TALLOC_CTX
*mem_ctx
, const char *name
);
913 * @brief Returns the platform specific shared library extension.
915 * @retval Pointer to a const char * containing the extension.
917 const char *shlib_ext(void);
920 char *server_id_str(TALLOC_CTX
*mem_ctx
, const struct server_id
*id
);
922 #endif /* _SAMBA_UTIL_H_ */