#ifndef _SAMBA_UTIL_H_
#define _SAMBA_UTIL_H_
+#ifndef SAMBA_UTIL_CORE_ONLY
#include "lib/util/charset/charset.h"
+#else
+#include "charset_compat.h"
+#endif
+
#include "lib/util/attr.h"
/* for TALLOC_CTX */
#include <talloc.h>
+/* for struct stat */
+#include <sys/stat.h>
+
/**
* @file
* @brief Helpful macros
#include "lib/util/time.h"
#include "lib/util/data_blob.h"
-#include "lib/util/xfile.h"
#include "lib/util/byteorder.h"
#include "lib/util/talloc_stack.h"
-/**
- * assert macros
- */
-#ifdef DEVELOPER
-#define SMB_ASSERT(b) do { if (!(b)) { \
- DEBUG(0,("PANIC: assert failed at %s(%d): %s\n", \
- __FILE__, __LINE__, #b)); smb_panic("assert failed: " #b); }} while(0)
-#else
-/* redefine the assert macro for non-developer builds */
-#define SMB_ASSERT(b) do { if (!(b)) { \
- DEBUG(0,("PANIC: assert failed at %s(%d): %s\n", \
- __FILE__, __LINE__, #b)); }} while (0)
-#endif
-
#ifndef ABS
#define ABS(a) ((a)>0?(a):(-(a)))
#endif
#include "lib/util/memory.h"
-#include "lib/util/string_wrappers.h"
+#include "fault.h"
+
+#include "lib/util/util.h"
/**
* Write backtrace to debug log
*/
-_PUBLIC_ void call_backtrace(void);
-
-/**
- Something really nasty happened - panic !
-**/
-typedef void (*smb_panic_handler_t)(const char *why);
-
-_PUBLIC_ void fault_configure(smb_panic_handler_t panic_handler);
-_PUBLIC_ void fault_setup(void);
-_PUBLIC_ void fault_setup_disable(void);
_PUBLIC_ void dump_core_setup(const char *progname, const char *logfile);
-_PUBLIC_ void smb_panic(const char *reason);
-
/**
register a fault handler.
*/
_PUBLIC_ bool register_fault_handler(const char *name, void (*fault_handler)(int sig));
-/* The following definitions come from lib/util/signal.c */
-
-
-/**
- Block sigs.
-**/
-void BlockSignals(bool block, int signum);
-
-/**
- Catch a signal. This should implement the following semantics:
-
- 1) The handler remains installed after being called.
- 2) The signal should be blocked during handler execution.
-**/
-void (*CatchSignal(int signum,void (*handler)(int )))(int);
-
-/**
- Ignore SIGCLD via whatever means is necessary for this OS.
-**/
-void CatchChild(void);
-
-/**
- Catch SIGCLD but leave the child around so it's status can be reaped.
-**/
-void CatchChildLeaveStatus(void);
-
-/* The following definitions come from lib/util/system.c */
-
-void *sys_memalign( size_t align, size_t size );
-
-/**************************************************************************
-A wrapper for gethostbyname() that tries avoids looking up hostnames
-in the root domain, which can cause dial-on-demand links to come up for no
-apparent reason.
-****************************************************************************/
-_PUBLIC_ struct hostent *sys_gethostbyname(const char *name);
-_PUBLIC_ struct in_addr sys_inet_makeaddr(int net, int host);
-
-/**
- * Wrapper for fork used to invalid pid cache.
- **/
-_PUBLIC_ pid_t sys_fork(void);
-
-/**
- * Wrapper for getpid. Ensures we only do a system call *once*.
- **/
-_PUBLIC_ pid_t sys_getpid(void);
-
-_PUBLIC_ int sys_getpeereid( int s, uid_t *uid);
+#include "lib/util/signal.h" /* Avoid /usr/include/signal.h */
struct sockaddr;
char *service,
size_t servlen,
int flags);
-_PUBLIC_ int sys_connect(int fd, const struct sockaddr * addr);
/* The following definitions come from lib/util/genrand.c */
-/**
- Copy any user given reseed data.
-**/
-_PUBLIC_ void set_rand_reseed_callback(void (*fn)(void *, int *), void *);
-/**
- * Tell the random number generator it needs to reseed.
- */
-_PUBLIC_ void set_need_random_reseed(void);
-
-/**
- Interface to the (hopefully) good crypto random number generator.
- Will use our internal PRNG if more than 40 bytes of random generation
- has been requested, otherwise tries to read from /dev/random
-**/
-_PUBLIC_ void generate_random_buffer(uint8_t *out, int len);
-
-/**
- Interface to the (hopefully) good crypto random number generator.
- Will always use /dev/urandom if available.
-**/
-_PUBLIC_ void generate_secret_buffer(uint8_t *out, int len);
+#include "lib/util/genrand.h"
/**
generate a single random uint32_t
_PUBLIC_ bool check_password_quality(const char *s);
/**
- * Generate a random text password.
+ * Generate a random text password (based on printable ascii characters).
+ * This function is designed to provide a password that
+ * meats the complexity requirements of UF_NORMAL_ACCOUNT objects
+ * and they should be human readable and writeable on any keyboard layout.
+ *
+ * Characters used are:
+ * ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,@$%&!?:;<=>()[]~
*/
_PUBLIC_ char *generate_random_password(TALLOC_CTX *mem_ctx, size_t min, size_t max);
+/**
+ * Generate a random machine password
+ *
+ * min and max are the number of utf16 characters used
+ * to generate on utf8 compatible password.
+ *
+ * Note: if 'unix charset' is not 'utf8' (the default)
+ * then each utf16 character is only filled with
+ * values from 0x01 to 0x7f (ascii values without 0x00).
+ * This is important as the password neets to be
+ * a valid value as utf8 string and at the same time
+ * a valid value in the 'unix charset'.
+ *
+ * If 'unix charset' is 'utf8' (the default) then
+ * each utf16 character is a random value from 0x0000
+ * 0xFFFF (exluding the surrogate ranges from 0xD800-0xDFFF)
+ * while the translation from CH_UTF16MUNGED
+ * to CH_UTF8 replaces invalid values (see utf16_munged_pull()).
+ *
+ * Note: these passwords may not pass the complexity requirements
+ * for UF_NORMAL_ACCOUNT objects (except krbtgt accounts).
+ */
+_PUBLIC_ char *generate_random_machine_password(TALLOC_CTX *mem_ctx, size_t min, size_t max);
+
/**
Use the random number generator to generate a random string.
**/
* Characters used are: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,
*/
_PUBLIC_ char** generate_unique_strs(TALLOC_CTX *mem_ctx, size_t len,
- uint32_t num);
+ uint32_t num);
/* The following definitions come from lib/util/dprintf.c */
_PUBLIC_ _PURE_ DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex) ;
/**
- * Routine to print a buffer as HEX digits, into an allocated string.
+ * Parse a hex dump and return a data blob
*/
-_PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer);
+_PUBLIC_ _PURE_ DATA_BLOB hexdump_to_data_blob(TALLOC_CTX *mem_ctx, const char *hexdump, size_t len);
/**
- * talloc version of hex_encode()
+ * Print a buf in hex. Assumes dst is at least (srclen*2)+1 large.
*/
-_PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len);
+_PUBLIC_ void hex_encode_buf(char *dst, const uint8_t *src, size_t srclen);
/**
- Substitute a string for a pattern in another string. Make sure there is
- enough room!
-
- This routine looks for pattern in s and replaces it with
- insert. It may do multiple replacements.
-
- Any of " ; ' $ or ` in the insert string are replaced with _
- if len==0 then the string cannot be extended. This is different from the old
- use of len==0 which was for no length checks to be done.
-**/
-_PUBLIC_ void string_sub(char *s,const char *pattern, const char *insert, size_t len);
-
-_PUBLIC_ void string_sub_once(char *s, const char *pattern,
- const char *insert, size_t len);
+ * talloc version of hex_encode_buf()
+ */
+_PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len);
-_PUBLIC_ char *string_sub_talloc(TALLOC_CTX *mem_ctx, const char *s,
- const char *pattern, const char *insert);
-
-/**
- Similar to string_sub() but allows for any character to be substituted.
- Use with caution!
- if len==0 then the string cannot be extended. This is different from the old
- use of len==0 which was for no length checks to be done.
-**/
-_PUBLIC_ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len);
+#include "substitute.h"
/**
Unescape a URL encoded string, in place.
**/
_PUBLIC_ char *rfc1738_escape_part(TALLOC_CTX *mem_ctx, const char *url);
-/**
- format a string into length-prefixed dotted domain format, as used in NBT
- and in some ADS structures
-**/
-_PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s);
-
-/**
- * Add a string to an array of strings.
- *
- * num should be a pointer to an integer that holds the current
- * number of elements in strings. It will be updated by this function.
- */
-_PUBLIC_ bool add_string_to_array(TALLOC_CTX *mem_ctx,
- const char *str, const char ***strings, int *num);
-
/**
varient of strcmp() that handles NULL ptrs
**/
_PUBLIC_ size_t utf16_len_n(const void *src, size_t n);
_PUBLIC_ size_t ucs2_align(const void *base_ptr, const void *p, int flags);
+/**
+ * @brief Constant time compare to memory regions.
+ *
+ * @param[in] s1 The first memory region to compare.
+ *
+ * @param[in] s2 The second memory region to compare.
+ *
+ * @param[in] n The length of the memory to comapre.
+ *
+ * @return 0 when the memory regions are equal, 0 if not.
+ */
+_PUBLIC_ int memcmp_const_time(const void *s1, const void *s2, size_t n);
+
/**
Do a case-insensitive, whitespace-ignoring string compare.
**/
**/
_PUBLIC_ void string_replace(char *s, char oldc, char newc);
-/**
- Base64 decode a string, place into a data blob. Caller to data_blob_free() the result.
-**/
-_PUBLIC_ DATA_BLOB base64_decode_data_blob_talloc(TALLOC_CTX *mem_ctx, const char *s);
-
-/**
- Base64 decode a string, place into a data blob on NULL context.
- Caller to data_blob_free() the result.
-**/
-_PUBLIC_ DATA_BLOB base64_decode_data_blob(const char *s);
-
-
-/**
- Base64 decode a string, inplace
-**/
-_PUBLIC_ void base64_decode_inplace(char *s);
-/**
- Base64 encode a binary data blob into a string
-**/
-_PUBLIC_ char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data);
-
/**
* Compare 2 strings.
*
**/
_PUBLIC_ bool strequal(const char *s1, const char *s2);
-/* The following definitions come from lib/util/util_strlist.c */
+#include "util_strlist.h"
-/* separators for lists */
-#ifndef LIST_SEP
-#define LIST_SEP " \t,\n\r"
-#endif
+/* The following definitions come from lib/util/util_strlist_v3.c */
/**
- build an empty (only NULL terminated) list of strings (for expansion with str_list_add() etc)
-*/
-_PUBLIC_ char **str_list_make_empty(TALLOC_CTX *mem_ctx);
-
-/**
- place the only element 'entry' into a new, NULL terminated string list
-*/
-_PUBLIC_ char **str_list_make_single(TALLOC_CTX *mem_ctx,
- const char *entry);
-
-/**
- build a null terminated list of strings from a input string and a
- separator list. The separator list must contain characters less than
- or equal to 0x2f for this to work correctly on multi-byte strings
-*/
-_PUBLIC_ char **str_list_make(TALLOC_CTX *mem_ctx, const char *string,
- const char *sep);
-
-/**
- * build a null terminated list of strings from an argv-like input string
- * Entries are separated by spaces and can be enclosed by quotes.
- * Does NOT support escaping
- */
-_PUBLIC_ char **str_list_make_shell(TALLOC_CTX *mem_ctx, const char *string, const char *sep);
-
-/**
- * join a list back to one string
- */
-_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char separator);
-
-/** join a list back to one (shell-like) string; entries
- * separated by spaces, using quotes where necessary */
-_PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep);
-
-/**
- return the number of elements in a string list
-*/
-_PUBLIC_ size_t str_list_length(const char * const *list);
-
-/**
- copy a string list
-*/
-_PUBLIC_ char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list);
-
-/**
- Return true if all the elements of the list match exactly.
+ * Needed for making an "unconst" list "const"
*/
-_PUBLIC_ bool str_list_equal(const char * const *list1, const char * const *list2);
-
-/**
- add an entry to a string list
-*/
-_PUBLIC_ const char **str_list_add(const char **list, const char *s);
-
-/**
- remove an entry from a string list
-*/
-_PUBLIC_ void str_list_remove(const char **list, const char *s);
-
-/**
- return true if a string is in a list
-*/
-_PUBLIC_ bool str_list_check(const char **list, const char *s);
-
-/**
- return true if a string is in a list, case insensitively
-*/
-_PUBLIC_ bool str_list_check_ci(const char **list, const char *s);
-/**
- append one list to another - expanding list1
-*/
-_PUBLIC_ const char **str_list_append(const char **list1,
- const char * const *list2);
+_PUBLIC_ const char **const_str_list(char **list);
/**
- remove duplicate elements from a list
-*/
-_PUBLIC_ const char **str_list_unique(const char **list);
-
-/*
- very useful when debugging complex list related code
+ * str_list_make, v3 version. The v4 version does not
+ * look at quoted strings with embedded blanks, so
+ * do NOT merge this function please!
*/
-_PUBLIC_ void str_list_show(const char **list);
-
-
-/**
- append one list to another - expanding list1
- this assumes the elements of list2 are const pointers, so we can re-use them
-*/
-_PUBLIC_ const char **str_list_append_const(const char **list1,
- const char **list2);
-
-/**
- add an entry to a string list
- this assumes s will not change
-*/
-_PUBLIC_ const char **str_list_add_const(const char **list, const char *s);
-
-/**
- copy a string list
- this assumes list will not change
-*/
-_PUBLIC_ const char **str_list_copy_const(TALLOC_CTX *mem_ctx,
- const char **list);
+char **str_list_make_v3(TALLOC_CTX *mem_ctx, const char *string,
+ const char *sep);
-/**
- * Needed for making an "unconst" list "const"
- */
-_PUBLIC_ const char **const_str_list(char **list);
+const char **str_list_make_v3_const(TALLOC_CTX *mem_ctx,
+ const char *string,
+ const char *sep);
/* The following definitions come from lib/util/util_file.c */
-/**
-read a line from a file with possible \ continuation chars.
-Blanks at the start or end of a line are stripped.
-The string will be allocated if s2 is NULL
-**/
-_PUBLIC_ char *fgets_slash(char *s2,int maxlen,XFILE *f);
-
/**
* Read one line (data until next newline or eof) and allocate it
*/
_PUBLIC_ char *afdgets(int fd, TALLOC_CTX *mem_ctx, size_t hint);
+char *fgets_slash(TALLOC_CTX *mem_ctx, char *s2, int maxlen, FILE *f);
+
/**
load a file into memory from a fd.
**/
**/
_PUBLIC_ char *file_load(const char *fname, size_t *size, size_t maxsize, TALLOC_CTX *mem_ctx);
-/**
-mmap (if possible) or read a file
-**/
-_PUBLIC_ void *map_file(const char *fname, size_t size);
-
/**
load a file into memory and return an array of pointers to lines in the file
must be freed with talloc_free().
**/
_PUBLIC_ char **fd_lines_load(int fd, int *numlines, size_t maxsize, TALLOC_CTX *mem_ctx);
-/**
-take a list of lines and modify them to produce a list where \ continues
-a line
-**/
-_PUBLIC_ void file_lines_slashcont(char **lines);
-
+_PUBLIC_ bool file_save_mode(const char *fname, const void *packet,
+ size_t length, mode_t mode);
/**
save a lump of data into a file. Mostly used for debugging
*/
_PUBLIC_ bool file_save(const char *fname, const void *packet, size_t length);
_PUBLIC_ int vfdprintf(int fd, const char *format, va_list ap) PRINTF_ATTRIBUTE(2,0);
_PUBLIC_ int fdprintf(int fd, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
-_PUBLIC_ bool large_file_support(const char *path);
/*
compare two files, return true if the two files have the same content
**/
_PUBLIC_ bool directory_exist(const char *dname);
+/**
+ Check file permissions.
+**/
+_PUBLIC_ bool file_check_permissions(const char *fname,
+ uid_t uid,
+ mode_t file_perms,
+ struct stat *pst);
+
/**
* Try to create the specified directory if it didn't exist.
*
* @retval true if the directory already existed and has the right permissions
* or was successfully created.
*/
-_PUBLIC_ bool directory_create_or_exist(const char *dname, uid_t uid,
- mode_t dir_perms);
+_PUBLIC_ bool directory_create_or_exist(const char *dname, mode_t dir_perms);
-/**
- Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
- else
- if SYSV use O_NDELAY
- if BSD use FNDELAY
-**/
-_PUBLIC_ int set_blocking(int fd, bool set);
+_PUBLIC_ bool directory_create_or_exist_strict(const char *dname,
+ uid_t uid,
+ mode_t dir_perms);
-/**
- set close on exec on a file descriptor if available
- **/
-_PUBLIC_ bool smb_set_close_on_exec(int fd);
+#include "blocking.h"
/**
Sleep for a specified number of milliseconds.
**/
_PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type);
-/**
- * Write dump of binary data to a callback
- */
-void dump_data_cb(const uint8_t *buf, int len,
- bool omit_zero_bytes,
- void (*cb)(const char *buf, void *private_data),
- void *private_data);
-
-/**
- * Write dump of binary data to the log file.
- *
- * The data is only written if the log level is at least level.
- */
-_PUBLIC_ void dump_data(int level, const uint8_t *buf,int len);
-
/**
* Write dump of binary data to the log file.
*
/**
Like strdup but for memory.
**/
-_PUBLIC_ void *memdup(const void *p, size_t size);
+_PUBLIC_ void *smb_memdup(const void *p, size_t size);
/**
* Write a password to the log file.
void *malloc_array(size_t el_size, unsigned int count);
+void *memalign_array(size_t el_size, size_t align, unsigned int count);
+
+void *calloc_array(size_t size, size_t nmemb);
+
/* The following definitions come from lib/util/fsusage.c */
* @brief MS-style Filename matching
*/
-int ms_fnmatch_protocol(const char *pattern, const char *string, int protocol);
+int ms_fnmatch_protocol(const char *pattern, const char *string, int protocol,
+ bool is_case_sensitive);
/** a generic fnmatch function - uses for non-CIFS pattern matching */
int gen_fnmatch(const char *pattern, const char *string);
-/* The following definitions come from lib/util/idtree.c */
-
-
-/**
- initialise a idr tree. The context return value must be passed to
- all subsequent idr calls. To destroy the idr tree use talloc_free()
- on this context
- */
-_PUBLIC_ struct idr_context *idr_init(TALLOC_CTX *mem_ctx);
-
-/**
- allocate the next available id, and assign 'ptr' into its slot.
- you can retrieve later this pointer using idr_find()
-*/
-_PUBLIC_ int idr_get_new(struct idr_context *idp, void *ptr, int limit);
+#include "idtree.h"
+#include "idtree_random.h"
/**
- allocate a new id, giving the first available value greater than or
- equal to the given starting id
-*/
-_PUBLIC_ int idr_get_new_above(struct idr_context *idp, void *ptr, int starting_id, int limit);
-
-/**
- allocate a new id randomly in the given range
-*/
-_PUBLIC_ int idr_get_new_random(struct idr_context *idp, void *ptr, int limit);
+ Close the low 3 fd's and open dev/null in their place
+**/
+_PUBLIC_ void close_low_fds(bool stdin_too, bool stdout_too, bool stderr_too);
/**
- find a pointer value previously set with idr_get_new given an id
-*/
-_PUBLIC_ void *idr_find(struct idr_context *idp, int id);
+ Become a daemon, discarding the controlling terminal.
+**/
+_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout);
/**
- remove an id from the idr tree
-*/
-_PUBLIC_ int idr_remove(struct idr_context *idp, int id);
-
-/* The following definitions come from lib/util/become_daemon.c */
+ Exit daemon and print error message to the log at level 0
+ Optionally report failure to systemd if systemd integration is enabled
+**/
+_PUBLIC_ void exit_daemon(const char *msg, int error);
/**
- Close the low 3 fd's and open dev/null in their place
+ Report that the daemon is ready to serve connections to the log at level 0
+ Optionally report status to systemd if systemd integration is enabled
**/
-_PUBLIC_ void close_low_fds(bool stderr_too);
+_PUBLIC_ void daemon_ready(const char *daemon);
+
+/*
+ * Report the daemon status. For example if it is not ready to serve connections
+ * and is waiting for some event to happen.
+ */
+_PUBLIC_ void daemon_status(const char *name, const char *msg);
/**
- Become a daemon, discarding the controlling terminal.
-**/
-_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout);
+ * @brief Get a password from the console.
+ *
+ * You should make sure that the buffer is an empty string!
+ *
+ * You can also use this function to ask for a username. Then you can fill the
+ * buffer with the username and it is shows to the users. If the users just
+ * presses enter the buffer will be untouched.
+ *
+ * @code
+ * char username[128];
+ *
+ * snprintf(username, sizeof(username), "john");
+ *
+ * smb_getpass("Username:", username, sizeof(username), 1, 0);
+ * @endcode
+ *
+ * The prompt will look like this:
+ *
+ * Username: [john]
+ *
+ * If you press enter then john is used as the username, or you can type it in
+ * to change it.
+ *
+ * @param[in] prompt The prompt to show to ask for the password.
+ *
+ * @param[out] buf The buffer the password should be stored. It NEEDS to be
+ * empty or filled out.
+ *
+ * @param[in] len The length of the buffer.
+ *
+ * @param[in] echo Should we echo what you type.
+ *
+ * @param[in] verify Should we ask for the password twice.
+ *
+ * @return 0 on success, -1 on error.
+ */
+_PUBLIC_ int samba_getpass(const char *prompt, char *buf, size_t len,
+ bool echo, bool verify);
/**
* Load a ini-style file.
*/
bool pm_process( const char *fileName,
- bool (*sfunc)(const char *, void *),
- bool (*pfunc)(const char *, const char *, void *),
+ bool (*sfunc)(const char *, void *),
+ bool (*pfunc)(const char *, const char *, void *),
void *userdata);
-
-bool unmap_file(void *start, size_t size);
+bool pm_process_with_flags(const char *filename,
+ bool allow_empty_values,
+ bool (*sfunc)(const char *section, void *private_data),
+ bool (*pfunc)(const char *name, const char *value,
+ void *private_data),
+ void *private_data);
void print_asc(int level, const uint8_t *buf,int len);
void print_asc_cb(const uint8_t *buf, int len,
**/
const char *shlib_ext(void);
-struct server_id;
-char *server_id_str(TALLOC_CTX *mem_ctx, const struct server_id *id);
+/*
+ * Samba code should use samba_tevent_context_init() instead of
+ * tevent_context_init() in order to get the debug output.
+ */
+struct tevent_context *samba_tevent_context_init(TALLOC_CTX *mem_ctx);
+
+/*
+ * if same samba code needs to use a specific tevent backend
+ * it can use something like this:
+ *
+ * samba_tevent_set_debug(ev, "pysmb_tevent");
+ */
+void samba_tevent_set_debug(struct tevent_context *ev, const char *name);
#endif /* _SAMBA_UTIL_H_ */
git.samba.org / nivanova / samba-autobuild / .git / blobdiff