diff options
Diffstat (limited to 'source4/lib')
| -rw-r--r-- | source4/lib/charset/charcnv.c | 10 | ||||
| -rw-r--r-- | source4/lib/charset/charset.h | 5 | ||||
| -rw-r--r-- | source4/lib/stream/packet.c | 15 | ||||
| -rw-r--r-- | source4/lib/util/config.mk | 3 | ||||
| -rw-r--r-- | source4/lib/util/data_blob.c | 21 | ||||
| -rw-r--r-- | source4/lib/util/data_blob.h | 108 | ||||
| -rw-r--r-- | source4/lib/util/time.h | 225 | ||||
| -rw-r--r-- | source4/lib/util/util.h | 710 | ||||
| -rw-r--r-- | source4/lib/util/xfile.h | 51 |
9 files changed, 1119 insertions, 29 deletions
diff --git a/source4/lib/charset/charcnv.c b/source4/lib/charset/charcnv.c index 0f6e53f52c..fcf29d4647 100644 --- a/source4/lib/charset/charcnv.c +++ b/source4/lib/charset/charcnv.c @@ -37,6 +37,10 @@ * @sa lib/iconv.c */ +char *unix_charset = NULL; +char *dos_charset = NULL; +char *display_charset = NULL; + /** * Return the name of a charset to give to iconv(). **/ @@ -44,9 +48,9 @@ static const char *charset_name(charset_t ch) { switch (ch) { case CH_UTF16: return "UTF-16LE"; - case CH_UNIX: return lp_unix_charset(); - case CH_DOS: return lp_dos_charset(); - case CH_DISPLAY: return lp_display_charset(); + case CH_UNIX: return unix_charset; + case CH_DOS: return dos_charset; + case CH_DISPLAY: return display_charset; case CH_UTF8: return "UTF8"; case CH_UTF16BE: return "UTF-16BE"; default: diff --git a/source4/lib/charset/charset.h b/source4/lib/charset/charset.h index e62f99a8fe..3c548192b6 100644 --- a/source4/lib/charset/charset.h +++ b/source4/lib/charset/charset.h @@ -77,4 +77,9 @@ typedef struct { #define strlower(s) strlower_m(s) #define strupper(s) strupper_m(s) +/* from lib/charset */ +extern char *dos_charset; +extern char *unix_charset; +extern char *display_charset; + #endif /* __CHARSET_H__ */ diff --git a/source4/lib/stream/packet.c b/source4/lib/stream/packet.c index 3f4fcb1ef7..e6cfae7bd6 100644 --- a/source4/lib/stream/packet.c +++ b/source4/lib/stream/packet.c @@ -281,9 +281,8 @@ _PUBLIC_ void packet_recv(struct packet_context *pc) /* possibly expand the partial packet buffer */ if (npending + pc->num_read > pc->partial.length) { - status = data_blob_realloc(pc, &pc->partial, npending+pc->num_read); - if (!NT_STATUS_IS_OK(status)) { - packet_error(pc, status); + if (!data_blob_realloc(pc, &pc->partial, npending+pc->num_read)) { + packet_error(pc, NT_STATUS_NO_MEMORY); return; } } @@ -322,9 +321,8 @@ _PUBLIC_ void packet_recv(struct packet_context *pc) next_partial: if (pc->partial.length != pc->num_read) { - status = data_blob_realloc(pc, &pc->partial, pc->num_read); - if (!NT_STATUS_IS_OK(status)) { - packet_error(pc, status); + if (!data_blob_realloc(pc, &pc->partial, pc->num_read)) { + packet_error(pc, NT_STATUS_NO_MEMORY); return; } } @@ -361,9 +359,8 @@ next_partial: return; } /* Trunate the blob sent to the caller to only the packet length */ - status = data_blob_realloc(pc, &blob, pc->packet_size); - if (!NT_STATUS_IS_OK(status)) { - packet_error(pc, status); + if (!data_blob_realloc(pc, &blob, pc->packet_size)) { + packet_error(pc, NT_STATUS_NO_MEMORY); return; } } else { diff --git a/source4/lib/util/config.mk b/source4/lib/util/config.mk index 5ec110e68d..0912c897db 100644 --- a/source4/lib/util/config.mk +++ b/source4/lib/util/config.mk @@ -2,12 +2,13 @@ #VERSION = 0.0.1 #SO_VERSION = 0 #DESCRIPTION = Generic utility functions -PUBLIC_PROTO_HEADER = util_proto.h PUBLIC_HEADERS = util.h \ byteorder.h \ + data_blob.h \ debug.h \ mutex.h \ safe_string.h \ + time.h \ xfile.h OBJ_FILES = xfile.o \ debug.o \ diff --git a/source4/lib/util/data_blob.c b/source4/lib/util/data_blob.c index df8e793835..117043f95c 100644 --- a/source4/lib/util/data_blob.c +++ b/source4/lib/util/data_blob.c @@ -196,38 +196,37 @@ _PUBLIC_ DATA_BLOB data_blob_const(const void *p, size_t length) /** realloc a data_blob **/ -_PUBLIC_ NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length) +_PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length) { blob->data = talloc_realloc_size(mem_ctx, blob->data, length); - NT_STATUS_HAVE_NO_MEMORY(blob->data); + if (blob->data == NULL) + return false; blob->length = length; - return NT_STATUS_OK; + return true; } /** append some data to a data blob **/ -_PUBLIC_ NTSTATUS data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, +_PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const void *p, size_t length) { - NTSTATUS status; size_t old_len = blob->length; size_t new_len = old_len + length; if (new_len < length || new_len < old_len) { - return NT_STATUS_NO_MEMORY; + return false; } if ((const uint8_t *)p + length < (const uint8_t *)p) { - return NT_STATUS_NO_MEMORY; + return false; } - status = data_blob_realloc(mem_ctx, blob, new_len); - if (!NT_STATUS_IS_OK(status)) { - return status; + if (!data_blob_realloc(mem_ctx, blob, new_len)) { + return false; } memcpy(blob->data + old_len, p, length); - return NT_STATUS_OK; + return true; } diff --git a/source4/lib/util/data_blob.h b/source4/lib/util/data_blob.h new file mode 100644 index 0000000000..acecb88132 --- /dev/null +++ b/source4/lib/util/data_blob.h @@ -0,0 +1,108 @@ +/* + Unix SMB/CIFS implementation. + DATA BLOB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef _SAMBA_DATABLOB_H_ +#define _SAMBA_DATABLOB_H_ + +/* used to hold an arbitrary blob of data */ +typedef struct datablob { + uint8_t *data; + size_t length; +} DATA_BLOB; + +struct data_blob_list_item { + struct data_blob_list_item *prev,*next; + DATA_BLOB blob; +}; + +#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__) +#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__) +#define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__) + +/** + construct a data blob, must be freed with data_blob_free() + you can pass NULL for p and get a blank data blob +**/ +_PUBLIC_ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name); + +/** + construct a data blob, using supplied TALLOC_CTX +**/ +_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name); + +/** + reference a data blob, to the supplied TALLOC_CTX. + Returns a NULL DATA_BLOB on failure +**/ +_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob); + +/** + construct a zero data blob, using supplied TALLOC_CTX. + use this sparingly as it initialises data - better to initialise + yourself if you want specific data in the blob +**/ +_PUBLIC_ DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length); + +/** +free a data blob +**/ +_PUBLIC_ void data_blob_free(DATA_BLOB *d); + +/** +clear a DATA_BLOB's contents +**/ +_PUBLIC_ void data_blob_clear(DATA_BLOB *d); + +/** +free a data blob and clear its contents +**/ +_PUBLIC_ void data_blob_clear_free(DATA_BLOB *d); + +/** +check if two data blobs are equal +**/ +_PUBLIC_ int data_blob_cmp(const DATA_BLOB *d1, const DATA_BLOB *d2); + +/** +print the data_blob as hex string +**/ +_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob); + +/** + useful for constructing data blobs in test suites, while + avoiding const warnings +**/ +_PUBLIC_ DATA_BLOB data_blob_string_const(const char *str); + +/** + * Create a new data blob from const data + */ +_PUBLIC_ DATA_BLOB data_blob_const(const void *p, size_t length); + +/** + realloc a data_blob +**/ +_PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length); + +/** + append some data to a data blob +**/ +_PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, + const void *p, size_t length); + +#endif /* _SAMBA_DATABLOB_H_ */ diff --git a/source4/lib/util/time.h b/source4/lib/util/time.h new file mode 100644 index 0000000000..a1b3facf24 --- /dev/null +++ b/source4/lib/util/time.h @@ -0,0 +1,225 @@ +/* + Unix SMB/CIFS implementation. + time utility functions + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef _SAMBA_TIME_H_ +#define _SAMBA_TIME_H_ + +/* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */ +typedef uint64_t NTTIME; + +/** + External access to time_t_min and time_t_max. +**/ +_PUBLIC_ time_t get_time_t_max(void); + +/** +a gettimeofday wrapper +**/ +_PUBLIC_ void GetTimeOfDay(struct timeval *tval); + +/** +interpret an 8 byte "filetime" structure to a time_t +It's originally in "100ns units since jan 1st 1601" +**/ +_PUBLIC_ time_t nt_time_to_unix(NTTIME nt); + +/** +put a 8 byte filetime from a time_t +This takes GMT as input +**/ +_PUBLIC_ void unix_to_nt_time(NTTIME *nt, time_t t); + +/** +check if it's a null unix time +**/ +_PUBLIC_ bool null_time(time_t t); + +/** +check if it's a null NTTIME +**/ +_PUBLIC_ bool null_nttime(NTTIME t); + +/** +put a dos date into a buffer (time/date format) +This takes GMT time and puts local time in the buffer +**/ +_PUBLIC_ void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset); + +/** +put a dos date into a buffer (date/time format) +This takes GMT time and puts local time in the buffer +**/ +_PUBLIC_ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset); + +/** +put a dos 32 bit "unix like" date into a buffer. This routine takes +GMT and converts it to LOCAL time before putting it (most SMBs assume +localtime for this sort of date) +**/ +_PUBLIC_ void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset); + +/** + create a unix date (int GMT) from a dos date (which is actually in + localtime) +**/ +_PUBLIC_ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset); + +/** +like make_unix_date() but the words are reversed +**/ +_PUBLIC_ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset); + +/** + create a unix GMT date from a dos date in 32 bit "unix like" format + these generally arrive as localtimes, with corresponding DST +**/ +_PUBLIC_ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset); + +/** +return a HTTP/1.0 time string +**/ +_PUBLIC_ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t); + +/** + Return the date and time as a string +**/ +_PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t); + +/** + return a talloced string representing a NTTIME for human consumption +*/ +_PUBLIC_ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt); + +/** + put a NTTIME into a packet +*/ +_PUBLIC_ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t); + +/** + pull a NTTIME from a packet +*/ +_PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset); + +/** + parse a nttime as a large integer in a string and return a NTTIME +*/ +_PUBLIC_ NTTIME nttime_from_string(const char *s); + +/** + return (tv1 - tv2) in microseconds +*/ +_PUBLIC_ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2); + +/** + return a zero timeval +*/ +_PUBLIC_ struct timeval timeval_zero(void); + +/** + return true if a timeval is zero +*/ +_PUBLIC_ bool timeval_is_zero(const struct timeval *tv); + +/** + return a timeval for the current time +*/ +_PUBLIC_ struct timeval timeval_current(void); + +/** + return a timeval struct with the given elements +*/ +_PUBLIC_ struct timeval timeval_set(uint32_t secs, uint32_t usecs); + +/** + return a timeval ofs microseconds after tv +*/ +_PUBLIC_ struct timeval timeval_add(const struct timeval *tv, + uint32_t secs, uint32_t usecs); + +/** + return the sum of two timeval structures +*/ +struct timeval timeval_sum(const struct timeval *tv1, + const struct timeval *tv2); + +/** + return a timeval secs/usecs into the future +*/ +_PUBLIC_ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs); + +/** + compare two timeval structures. + Return -1 if tv1 < tv2 + Return 0 if tv1 == tv2 + Return 1 if tv1 > tv2 +*/ +_PUBLIC_ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2); + +/** + return true if a timer is in the past +*/ +_PUBLIC_ bool timeval_expired(const struct timeval *tv); + +/** + return the number of seconds elapsed between two times +*/ +_PUBLIC_ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2); + +/** + return the number of seconds elapsed since a given time +*/ +_PUBLIC_ double timeval_elapsed(const struct timeval *tv); + +/** + return the lesser of two timevals +*/ +_PUBLIC_ struct timeval timeval_min(const struct timeval *tv1, + const struct timeval *tv2); + +/** + return the greater of two timevals +*/ +_PUBLIC_ struct timeval timeval_max(const struct timeval *tv1, + const struct timeval *tv2); + +/** + return the difference between two timevals as a timeval + if tv1 comes after tv2, then return a zero timeval + (this is *tv2 - *tv1) +*/ +_PUBLIC_ struct timeval timeval_until(const struct timeval *tv1, + const struct timeval *tv2); + +/** + convert a timeval to a NTTIME +*/ +_PUBLIC_ NTTIME timeval_to_nttime(const struct timeval *tv); + +/** + convert a NTTIME to a timeval +*/ +_PUBLIC_ void nttime_to_timeval(struct timeval *tv, NTTIME t); + +/** + return the UTC offset in seconds west of UTC, or 0 if it cannot be determined + */ +_PUBLIC_ int get_time_zone(time_t t); + + + +#endif /* _SAMBA_TIME_H_ */ diff --git a/source4/lib/util/util.h b/source4/lib/util/util.h index f19b243f64..0c784d1c97 100644 --- a/source4/lib/util/util.h +++ b/source4/lib/util/util.h @@ -34,11 +34,12 @@ struct smbsrv_tcon; extern const char *logfile; extern const char *panic_action; +#include "util/time.h" +#include "util/data_blob.h" #include "util/xfile.h" #include "util/debug.h" #include "util/mutex.h" #include "util/byteorder.h" -#include "lib/util/util_proto.h" /** this is a warning hack. The idea is to use this everywhere that we @@ -100,10 +101,6 @@ extern const char *panic_action; */ #define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count) -#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__) -#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__) -#define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__) - #if defined(VALGRIND) #define strlen(x) valgrind_strlen(x) #endif @@ -149,4 +146,707 @@ extern const char *panic_action; #define PTR_DIFF(p1,p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2))) #endif + +/** + * this global variable determines what messages are printed + */ +_PUBLIC_ void debug_schedule_reopen_logs(void); + +/** + the backend for debug messages. Note that the DEBUG() macro has already + ensured that the log level has been met before this is called +*/ +_PUBLIC_ void do_debug_header(int level, const char *location, const char *func); + +/** + the backend for debug messages. Note that the DEBUG() macro has already + ensured that the log level has been met before this is called + + @note You should never have to call this function directly. Call the DEBUG() + macro instead. +*/ +_PUBLIC_ void do_debug(const char *format, ...) _PRINTF_ATTRIBUTE(1,2); + +/** + reopen the log file (usually called because the log file name might have changed) +*/ +_PUBLIC_ void reopen_logs(void); + +/** + control the name of the logfile and whether logging will be to stdout, stderr + or a file +*/ +_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype); + +/** + return a string constant containing n tabs + no more than 10 tabs are returned +*/ +_PUBLIC_ const char *do_debug_tab(int n); + +/** + log suspicious usage - print comments and backtrace +*/ +_PUBLIC_ void log_suspicious_usage(const char *from, const char *info); + +/** + print suspicious usage - print comments and backtrace +*/ +_PUBLIC_ void print_suspicious_usage(const char* from, const char* info); +_PUBLIC_ uint32_t get_task_id(void); +_PUBLIC_ void log_task_id(void); + +/** + register a set of debug handlers. +*/ +_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops); + +/* The following definitions come from lib/util/fault.c */ + + +/** + * Write backtrace to debug log + */ +_PUBLIC_ void call_backtrace(void); + +/** + Something really nasty happened - panic ! +**/ +_PUBLIC_ _NORETURN_ void smb_panic(const char *why); + +/** +setup our fault handlers +**/ +_PUBLIC_ void fault_setup(const char *pname); + +/** + register a fault handler. + Should only be called once in the execution of smbd. +*/ +_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 */ + + +/************************************************************************** +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_ const char *sys_inet_ntoa(struct ipv4_addr in); +_PUBLIC_ struct ipv4_addr sys_inet_makeaddr(int net, int host); + +/* The following definitions come from lib/util/genrand.c */ + +/** + Copy any user given reseed data. +**/ +_PUBLIC_ void set_rand_reseed_callback(void (*fn)(int *)); + +/** + * 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. +**/ +_PUBLIC_ void generate_random_buffer(uint8_t *out, int len); + +/** + generate a single random uint32_t +**/ +_PUBLIC_ uint32_t generate_random(void); + +/** + very basic password quality checker +**/ +_PUBLIC_ bool check_password_quality(const char *s); + +/** + Use the random number generator to generate a random string. +**/ +_PUBLIC_ char *generate_random_str_list(TALLOC_CTX *mem_ctx, size_t len, const char *list); + +/** + * Generate a random text string consisting of the specified length. + * The returned string will be allocated. + * + * Characters used are: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#., + */ +_PUBLIC_ char *generate_random_str(TALLOC_CTX *mem_ctx, size_t len); + +/* The following definitions come from lib/util/dprintf.c */ + +_PUBLIC_ int d_vfprintf(FILE *f, const char *format, va_list ap) _PRINTF_ATTRIBUTE(2,0); +_PUBLIC_ int d_fprintf(FILE *f, const char *format, ...) _PRINTF_ATTRIBUTE(2,3); +_PUBLIC_ int d_printf(const char *format, ...) _PRINTF_ATTRIBUTE(1,2); +_PUBLIC_ void display_set_stderr(void); + +/* The following definitions come from lib/util/util_str.c */ + + +/** + Trim the specified elements off the front and back of a string. +**/ +_PUBLIC_ bool trim_string(char *s, const char *front, const char *back); + +/** + Find the number of 'c' chars in a string +**/ +_PUBLIC_ _PURE_ size_t count_chars(const char *s, char c); + +/** + Safe string copy into a known length string. maxlength does not + include the terminating zero. +**/ +_PUBLIC_ char *safe_strcpy(char *dest,const char *src, size_t maxlength); + +/** + Safe string cat into a string. maxlength does not + include the terminating zero. +**/ +_PUBLIC_ char *safe_strcat(char *dest, const char *src, size_t maxlength); + +/** + Routine to get hex characters and turn them into a 16 byte array. + the array can be variable length, and any non-hex-numeric + characters are skipped. "0xnn" or "0Xnn" is specially catered + for. + + valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n" + + +**/ +_PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex); + +/** + * Parse a hex string and return a data blob. + */ +_PUBLIC_ _PURE_ DATA_BLOB strhex_to_data_blob(const char *strhex) ; + +/** + * Routine to print a buffer as HEX digits, into an allocated string. + */ +_PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer); + +/** + * talloc version of hex_encode() + */ +_PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len); + +/** + Free a string value. +**/ +_PUBLIC_ void string_free(char **s); + +/** + Set a string value, deallocating any existing space, and allocing the space + for the string +**/ +_PUBLIC_ bool string_set(char **dest, const char *src); + +/** + 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); + +/** + 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); + +/** + Unescape a URL encoded string, in place. +**/ +_PUBLIC_ void rfc1738_unescape(char *buf); +size_t valgrind_strlen(const char *s); + +/** + 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_ int strcmp_safe(const char *s1, const char *s2); + +/** +return the number of bytes occupied by a buffer in ASCII format +the result includes the null termination +limited by 'n' bytes +**/ +_PUBLIC_ size_t ascii_len_n(const char *src, size_t n); + +/** + Return a string representing a CIFS attribute for a file. +**/ +_PUBLIC_ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib); + +/** + Set a boolean variable from the text value stored in the passed string. + Returns true in success, false if the passed string does not correctly + represent a boolean. +**/ +_PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean); + +/** + * Parse a string containing a boolean value. + * + * val will be set to the read value. + * + * @retval true if a boolean value was parsed, false otherwise. + */ +_PUBLIC_ bool conv_str_bool(const char * str, bool * val); + +/** + * Convert a size specification like 16K into an integral number of bytes. + **/ +_PUBLIC_ bool conv_str_size(const char * str, uint64_t * val); + +/** + * Parse a uint64_t value from a string + * + * val will be set to the value read. + * + * @retval true if parsing was successful, false otherwise + */ +_PUBLIC_ bool conv_str_u64(const char * str, uint64_t * val); + +/** +return the number of bytes occupied by a buffer in CH_UTF16 format +the result includes the null termination +**/ +_PUBLIC_ size_t utf16_len(const void *buf); + +/** +return the number of bytes occupied by a buffer in CH_UTF16 format +the result includes the null termination +limited by 'n' bytes +**/ +_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); + +/** +Do a case-insensitive, whitespace-ignoring string compare. +**/ +_PUBLIC_ int strwicmp(const char *psz1, const char *psz2); + +/** + String replace. +**/ +_PUBLIC_ void string_replace(char *s, char oldc, char newc); + +/** + * Compare 2 strings. + * + * @note The comparison is case-insensitive. + **/ +_PUBLIC_ bool strequal(const char *s1, const char *s2); + +/* The following definitions come from lib/util/util_strlist.c */ + + +/** + 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_ const 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 seperated by spaces and can be enclosed by quotes. + * Does NOT support escaping + */ +_PUBLIC_ const 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 seperator); + +/** join a list back to one (shell-like) string; entries + * seperated 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 **list); + +/** + copy a string list +*/ +_PUBLIC_ const char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list); + +/** + Return true if all the elements of the list match exactly. + */ +_PUBLIC_ bool str_list_equal(const char **list1, const char **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); + +/** + Check if a string is part of a list. +**/ +_PUBLIC_ bool in_list(const char *s, const char *list, bool casesensitive); + +/* 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); + +/** +load a file into memory from a fd. +**/ +_PUBLIC_ char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx); + +/** +load a file into memory +**/ +_PUBLIC_ char *file_load(const char *fname, size_t *size, 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 **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx); + +/** +load a fd into memory and return an array of pointers to lines in the file +must be freed with talloc_free(). If convert is true calls unix_to_dos on +the list. +**/ +_PUBLIC_ char **fd_lines_load(int fd, int *numlines, 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); + +/** + 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); + +/* The following definitions come from lib/util/util.c */ + + +/** + Find a suitable temporary directory. The result should be copied immediately + as it may be overwritten by a subsequent call. +**/ +_PUBLIC_ const char *tmpdir(void); + +/** + Check if a file exists - call vfs_file_exist for samba files. +**/ +_PUBLIC_ bool file_exist(const char *fname); + +/** + Check a files mod time. +**/ +_PUBLIC_ time_t file_modtime(const char *fname); + +/** + Check if a directory exists. +**/ +_PUBLIC_ bool directory_exist(const char *dname); + +/** + * 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); + +/** + 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); + +/** + Sleep for a specified number of milliseconds. +**/ +_PUBLIC_ void msleep(unsigned int t); + +/** + Get my own name, return in malloc'ed storage. +**/ +_PUBLIC_ char* get_myname(void); + +/** + Return true if a string could be a pure IP address. +**/ +_PUBLIC_ bool is_ipaddress(const char *str); + +/** + Interpret an internet address or name into an IP address in 4 byte form. +**/ +_PUBLIC_ uint32_t interpret_addr(const char *str); + +/** + A convenient addition to interpret_addr(). +**/ +_PUBLIC_ struct ipv4_addr interpret_addr2(const char *str); + +/** + Check if an IP is the 0.0.0.0. +**/ +_PUBLIC_ bool is_zero_ip(struct ipv4_addr ip); + +/** + Are two IPs on the same subnet? +**/ +_PUBLIC_ bool same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask); + +/** + Check if a process exists. Does this work on all unixes? +**/ +_PUBLIC_ bool process_exists(pid_t pid); + +/** + Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping + is dealt with in posix.c +**/ +_PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type); + +/** + * 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); + +/** + malloc that aborts with smb_panic on fail or zero size. +**/ +_PUBLIC_ void *smb_xmalloc(size_t size); + +/** + Memdup with smb_panic on fail. +**/ +_PUBLIC_ void *smb_xmemdup(const void *p, size_t size); + +/** + strdup that aborts on malloc fail. +**/ +_PUBLIC_ char *smb_xstrdup(const char *s); + +/** + Like strdup but for memory. +**/ +_PUBLIC_ void *memdup(const void *p, size_t size); + +/** + * Write a password to the log file. + * + * @note Only actually does something if DEBUG_PASSWORD was defined during + * compile-time. + */ +_PUBLIC_ void dump_data_pw(const char *msg, const uint8_t * data, size_t len); + +/** + * see if a range of memory is all zero. A NULL pointer is considered + * to be all zero + */ +_PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size); + +/** + realloc an array, checking for integer overflow in the array size +*/ +_PUBLIC_ void *realloc_array(void *ptr, size_t el_size, unsigned count); + +/* The following definitions come from lib/util/fsusage.c */ + + +/** + * Retrieve amount of free disk space. + * this does all of the system specific guff to get the free disk space. + * It is derived from code in the GNU fileutils package, but has been + * considerably mangled for use here + * + * results are returned in *dfree and *dsize, in 512 byte units +*/ +_PUBLIC_ int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize); + +/* The following definitions come from lib/util/ms_fnmatch.c */ + + +/** + * @file + * @brief MS-style Filename matching + */ +int ms_fnmatch(const char *pattern, const char *string, enum protocol_types protocol); + +/** 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/mutex.c */ + + +/** + register a set of mutex/rwlock handlers. + Should only be called once in the execution of smbd. +*/ +_PUBLIC_ bool register_mutex_handlers(const char *name, struct mutex_ops *ops); + +/* 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); + +/** + 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); + +/** + find a pointer value previously set with idr_get_new given an id +*/ +_PUBLIC_ void *idr_find(struct idr_context *idp, int id); + +/** + remove an id from the idr tree +*/ +_PUBLIC_ int idr_remove(struct idr_context *idp, int id); + +/* The following definitions come from lib/util/module.c */ + + +/** + * Obtain the init function from a shared library file + */ +_PUBLIC_ init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path); + +/** + * Obtain list of init functions from the modules in the specified + * directory + */ +_PUBLIC_ init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path); + +/** + * Run the specified init functions. + * + * @return true if all functions ran successfully, false otherwise + */ +_PUBLIC_ bool run_init_functions(NTSTATUS (**fns) (void)); + +/* The following definitions come from lib/util/become_daemon.c */ + + +/** + Become a daemon, discarding the controlling terminal. +**/ +_PUBLIC_ void become_daemon(bool Fork); + #endif /* _SAMBA_UTIL_H_ */ diff --git a/source4/lib/util/xfile.h b/source4/lib/util/xfile.h index ffe4481a64..2cc369d8d8 100644 --- a/source4/lib/util/xfile.h +++ b/source4/lib/util/xfile.h @@ -45,4 +45,55 @@ extern XFILE *x_stdin, *x_stdout, *x_stderr; int x_vfprintf(XFILE *f, const char *format, va_list ap) PRINTF_ATTRIBUTE(2, 0); int x_fprintf(XFILE *f, const char *format, ...) PRINTF_ATTRIBUTE(2, 3); + +/** simulate setvbuf() */ +int x_setvbuf(XFILE *f, char *buf, int mode, size_t size); + +/** this looks more like open() than fopen(), but that is quite deliberate. + I want programmers to *think* about O_EXCL, O_CREAT etc not just + get them magically added +*/ +XFILE *x_fopen(const char *fname, int flags, mode_t mode); + +/** simulate fclose() */ +int x_fclose(XFILE *f); + +/** simulate fwrite() */ +size_t x_fwrite(const void *p, size_t size, size_t nmemb, XFILE *f); + +/** thank goodness for asprintf() */ +int x_fileno(XFILE *f); + +/** simulate fflush() */ +int x_fflush(XFILE *f); + +/** simulate setbuffer() */ +void x_setbuffer(XFILE *f, char *buf, size_t size); + +/** simulate setbuf() */ +void x_setbuf(XFILE *f, char *buf); + +/** simulate setlinebuf() */ +void x_setlinebuf(XFILE *f); + +/** simulate feof() */ +int x_feof(XFILE *f); + +/** simulate ferror() */ +int x_ferror(XFILE *f); + +/** simulate fgetc() */ +int x_fgetc(XFILE *f); + +/** simulate fread */ +size_t x_fread(void *p, size_t size, size_t nmemb, XFILE *f); + +/** simulate fgets() */ +char *x_fgets(char *s, int size, XFILE *stream) ; + +/** + * trivial seek, works only for SEEK_SET and SEEK_END if SEEK_CUR is + * set then an error is returned */ +off_t x_tseek(XFILE *f, off_t offset, int whence); + #endif /* _XFILE_H_ */ |