sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-12 21:58:10 +03:00
Code

r13752: Add doxyfile and fix formatting of comments. Current output is available at http://samba.org/~jelmer/util-api/

Browse Source
This commit is contained in:
Jelmer Vernooij 2006-02-28 13:12:39 +00:00 committed by Gerald (Jerry) Carter
parent ef6e30c72c
commit 90812203df
23 changed files with 1584 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1229
source/lib/util/Doxyfile Normal file
View File

File diff suppressed because it is too large Load Diff

5
source/lib/util/capability.c
View File

@ -19,6 +19,11 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/**
* @file
* @brief Capabilities functions
**/
/* /*
capabilities fns - will be needed when we enable kernel oplocks capabilities fns - will be needed when we enable kernel oplocks
*/ */

53
source/lib/util/data_blob.c
View File

@ -21,10 +21,15 @@
#include "includes.h" #include "includes.h"
/******************************************************************* /**
* @file
* @brief Manipulation of arbitrary data blobs
**/
/**
construct a data blob, must be freed with data_blob_free() construct a data blob, must be freed with data_blob_free()
you can pass NULL for p and get a blank data blob you can pass NULL for p and get a blank data blob
*******************************************************************/ **/
DATA_BLOB data_blob_named(const void *p, size_t length, const char *name) DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
{ {
DATA_BLOB ret; DATA_BLOB ret;
@ -48,9 +53,9 @@ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
return ret; return ret;
} }
/******************************************************************* /**
construct a data blob, using supplied TALLOC_CTX construct a data blob, using supplied TALLOC_CTX
*******************************************************************/ **/
DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name) DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
{ {
DATA_BLOB ret = data_blob_named(p, length, name); DATA_BLOB ret = data_blob_named(p, length, name);
@ -62,10 +67,10 @@ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t leng
} }
/******************************************************************* /**
reference a data blob, to the supplied TALLOC_CTX. reference a data blob, to the supplied TALLOC_CTX.
Returns a NULL DATA_BLOB on failure Returns a NULL DATA_BLOB on failure
*******************************************************************/ **/
DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob) DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
{ {
DATA_BLOB ret = *blob; DATA_BLOB ret = *blob;
@ -78,11 +83,11 @@ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
return ret; return ret;
} }
/******************************************************************* /**
construct a zero data blob, using supplied TALLOC_CTX. construct a zero data blob, using supplied TALLOC_CTX.
use this sparingly as it initialises data - better to initialise use this sparingly as it initialises data - better to initialise
yourself if you want specific data in the blob yourself if you want specific data in the blob
*******************************************************************/ **/
DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length) DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length)
{ {
DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, length); DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, length);
@ -90,9 +95,9 @@ DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length)
return blob; return blob;
} }
/******************************************************************* /**
free a data blob free a data blob
*******************************************************************/ **/
void data_blob_free(DATA_BLOB *d) void data_blob_free(DATA_BLOB *d)
{ {
if (d) { if (d) {
@ -102,9 +107,9 @@ void data_blob_free(DATA_BLOB *d)
} }
} }
/******************************************************************* /**
clear a DATA_BLOB's contents clear a DATA_BLOB's contents
*******************************************************************/ **/
void data_blob_clear(DATA_BLOB *d) void data_blob_clear(DATA_BLOB *d)
{ {
if (d->data) { if (d->data) {
@ -112,9 +117,9 @@ void data_blob_clear(DATA_BLOB *d)
} }
} }
/******************************************************************* /**
free a data blob and clear its contents free a data blob and clear its contents
*******************************************************************/ **/
void data_blob_clear_free(DATA_BLOB *d) void data_blob_clear_free(DATA_BLOB *d)
{ {
data_blob_clear(d); data_blob_clear(d);
@ -122,9 +127,9 @@ void data_blob_clear_free(DATA_BLOB *d)
} }
/******************************************************************* /**
check if two data blobs are equal check if two data blobs are equal
*******************************************************************/ **/
BOOL data_blob_equal(const DATA_BLOB *d1, const DATA_BLOB *d2) BOOL data_blob_equal(const DATA_BLOB *d1, const DATA_BLOB *d2)
{ {
if (d1->length != d2->length) { if (d1->length != d2->length) {
@ -142,9 +147,9 @@ BOOL data_blob_equal(const DATA_BLOB *d1, const DATA_BLOB *d2)
return False; return False;
} }
/******************************************************************* /**
print the data_blob as hex string print the data_blob as hex string
*******************************************************************/ **/
char *data_blob_hex_string(TALLOC_CTX *mem_ctx, DATA_BLOB *blob) char *data_blob_hex_string(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
{ {
int i; int i;
@ -161,10 +166,10 @@ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
return hex_string; return hex_string;
} }
/* /**
useful for constructing data blobs in test suites, while useful for constructing data blobs in test suites, while
avoiding const warnings avoiding const warnings
*/ **/
DATA_BLOB data_blob_string_const(const char *str) DATA_BLOB data_blob_string_const(const char *str)
{ {
DATA_BLOB blob; DATA_BLOB blob;
@ -182,9 +187,9 @@ DATA_BLOB data_blob_const(const void *p, size_t length)
} }
/* /**
realloc a data_blob realloc a data_blob
*/ **/
NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length) NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length)
{ {
blob->data = talloc_realloc_size(mem_ctx, blob->data, length); blob->data = talloc_realloc_size(mem_ctx, blob->data, length);
@ -193,9 +198,9 @@ NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length)
return NT_STATUS_OK; return NT_STATUS_OK;
} }
/* /**
append some data to a data blob append some data to a data blob
*/ **/
NTSTATUS data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, NTSTATUS data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
const void *p, size_t length) const void *p, size_t length)
{ {

23
source/lib/util/debug.c
View File

@ -24,6 +24,11 @@
#include "system/time.h" #include "system/time.h"
#include "dynconfig.h" #include "dynconfig.h"
/**
* @file
* @brief Debug logging
**/
/* this global variable determines what messages are printed */ /* this global variable determines what messages are printed */
int DEBUGLEVEL; int DEBUGLEVEL;
@ -74,7 +79,7 @@ void do_debug(const char *format, ...)
free(s); free(s);
} }
/* /**
reopen the log file (usually called because the log file name might have changed) reopen the log file (usually called because the log file name might have changed)
*/ */
void reopen_logs(void) void reopen_logs(void)
@ -118,7 +123,7 @@ void reopen_logs(void)
} }
} }
/* /**
control the name of the logfile and whether logging will be to stdout, stderr control the name of the logfile and whether logging will be to stdout, stderr
or a file or a file
*/ */
@ -133,7 +138,7 @@ void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
reopen_logs(); reopen_logs();
} }
/* /**
return a string constant containing n tabs return a string constant containing n tabs
no more than 10 tabs are returned no more than 10 tabs are returned
*/ */
@ -146,8 +151,8 @@ const char *do_debug_tab(uint_t n)
} }
/* /**
log/print suspicious usage - print comments and backtrace log suspicious usage - print comments and backtrace
*/ */
void log_suspicious_usage(const char *from, const char *info) void log_suspicious_usage(const char *from, const char *info)
{ {
@ -155,6 +160,12 @@ void log_suspicious_usage(const char *from, const char *info)
debug_handlers.ops.log_suspicious_usage(from, info); debug_handlers.ops.log_suspicious_usage(from, info);
} }
} }
/**
print suspicious usage - print comments and backtrace
*/
void print_suspicious_usage(const char* from, const char* info) void print_suspicious_usage(const char* from, const char* info)
{ {
if (debug_handlers.ops.print_suspicious_usage) { if (debug_handlers.ops.print_suspicious_usage) {
@ -195,7 +206,7 @@ void log_task_id(void)
} }
} }
/* /**
register a set of debug handlers. register a set of debug handlers.
*/ */
void register_debug_handlers(const char *name, struct debug_ops *ops) void register_debug_handlers(const char *name, struct debug_ops *ops)

26
source/lib/util/fault.c
View File

@ -23,6 +23,11 @@
#include "system/wait.h" #include "system/wait.h"
#include "system/filesys.h" #include "system/filesys.h"
/**
* @file
* @brief Fault handling
*/
/* the registered fault handler */ /* the registered fault handler */
static struct { static struct {
const char *name; const char *name;
@ -38,6 +43,9 @@ static const char *progname;
#include <libexc.h> #include <libexc.h>
#endif #endif
/**
* Write backtrace to debug log
*/
void call_backtrace(void) void call_backtrace(void)
{ {
#ifdef HAVE_BACKTRACE #ifdef HAVE_BACKTRACE
@ -101,9 +109,9 @@ void call_backtrace(void)
#endif #endif
} }
/******************************************************************* /**
Something really nasty happened - panic ! Something really nasty happened - panic !
********************************************************************/ **/
void smb_panic(const char *why) void smb_panic(const char *why)
{ {
const char *cmd = lp_panic_action(); const char *cmd = lp_panic_action();
@ -138,9 +146,9 @@ void smb_panic(const char *why)
abort(); abort();
} }
/******************************************************************* /**
report a fault report a fault
********************************************************************/ **/
static void fault_report(int sig) static void fault_report(int sig)
{ {
static int counter; static int counter;
@ -157,9 +165,9 @@ static void fault_report(int sig)
exit(1); exit(1);
} }
/**************************************************************************** /**
catch serious errors catch serious errors
****************************************************************************/ **/
static void sig_fault(int sig) static void sig_fault(int sig)
{ {
if (fault_handlers.fault_handler) { if (fault_handlers.fault_handler) {
@ -170,9 +178,9 @@ static void sig_fault(int sig)
fault_report(sig); fault_report(sig);
} }
/******************************************************************* /**
setup our fault handlers setup our fault handlers
********************************************************************/ **/
void fault_setup(const char *pname) void fault_setup(const char *pname)
{ {
if (progname == NULL) { if (progname == NULL) {
@ -192,7 +200,7 @@ void fault_setup(const char *pname)
#endif #endif
} }
/* /**
register a fault handler. register a fault handler.
Should only be called once in the execution of smbd. Should only be called once in the execution of smbd.
*/ */

16
source/lib/util/fsusage.c
View File

@ -21,6 +21,10 @@
#include "includes.h" #include "includes.h"
#include "system/filesys.h" #include "system/filesys.h"
/**
* @file
* @brief Utility functions for getting the amount of free disk space
*/
/* Return the number of TOSIZE-byte blocks used by /* Return the number of TOSIZE-byte blocks used by
BLOCKS FROMSIZE-byte blocks, rounding away from zero. BLOCKS FROMSIZE-byte blocks, rounding away from zero.
@ -35,11 +39,13 @@ static uint64_t adjust_blocks(uint64_t blocks, uint64_t fromsize, uint64_t tosiz
return (blocks + 1) / (tosize / fromsize); return (blocks + 1) / (tosize / fromsize);
} }
/* 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 * Retrieve amount of free disk space.
considerably mangled for use here * 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
results are returned in *dfree and *dsize, in 512 byte units * considerably mangled for use here
*
* results are returned in *dfree and *dsize, in 512 byte units
*/ */
int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize) int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize)
{ {

25
source/lib/util/genrand.c
View File

@ -25,15 +25,20 @@
#include "system/filesys.h" #include "system/filesys.h"
#include "lib/crypto/crypto.h" #include "lib/crypto/crypto.h"
/**
* @file
* @brief Random number generation
*/
static unsigned char hash[258]; static unsigned char hash[258];
static uint32_t counter; static uint32_t counter;
static BOOL done_reseed = False; static BOOL done_reseed = False;
static void (*reseed_callback)(int *newseed); static void (*reseed_callback)(int *newseed);
/**************************************************************** /**
Copy any user given reseed data. Copy any user given reseed data.
*****************************************************************/ **/
void set_rand_reseed_callback(void (*fn)(int *)) void set_rand_reseed_callback(void (*fn)(int *))
{ {
@ -196,9 +201,9 @@ static int do_reseed(BOOL use_fd, int fd)
return -1; return -1;
} }
/* /**
Interface to the (hopefully) good crypto random number generator. Interface to the (hopefully) good crypto random number generator.
*/ **/
void generate_random_buffer(uint8_t *out, int len) void generate_random_buffer(uint8_t *out, int len)
{ {
static int urand_fd = -1; static int urand_fd = -1;
@ -242,9 +247,9 @@ void generate_random_buffer(uint8_t *out, int len)
} }
} }
/* /**
generate a single random uint32_t generate a single random uint32_t
*/ **/
uint32_t generate_random(void) uint32_t generate_random(void)
{ {
uint8_t v[4]; uint8_t v[4];
@ -253,9 +258,9 @@ uint32_t generate_random(void)
} }
/* /**
very basic password quality checker very basic password quality checker
*/ **/
BOOL check_password_quality(const char *s) BOOL check_password_quality(const char *s)
{ {
int has_digit=0, has_capital=0, has_lower=0; int has_digit=0, has_capital=0, has_lower=0;
@ -273,9 +278,9 @@ BOOL check_password_quality(const char *s)
return has_digit && has_lower && has_capital; return has_digit && has_lower && has_capital;
} }
/******************************************************************* /**
Use the random number generator to generate a random string. Use the random number generator to generate a random string.
********************************************************************/ **/
char *generate_random_str_list(TALLOC_CTX *mem_ctx, size_t len, const char *list) char *generate_random_str_list(TALLOC_CTX *mem_ctx, size_t len, const char *list)
{ {

4
source/lib/util/idtree.c
View File

@ -29,6 +29,10 @@
see the section marked "public interface" below for documentation see the section marked "public interface" below for documentation
*/ */
/**
* @file
*/
#include "includes.h" #include "includes.h"
#define IDR_BITS 5 #define IDR_BITS 5

5
source/lib/util/module.c
View File

@ -18,6 +18,11 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/**
* @file
* @brief Module initialization function handling
*/
#include "includes.h" #include "includes.h"
#include "system/dir.h" #include "system/dir.h"

6
source/lib/util/ms_fnmatch.c
View File

@ -24,6 +24,10 @@
code now code now
*/ */
/**
* @file
* @brief MS-style Filename matching
*/
#include "includes.h" #include "includes.h"
@ -212,7 +216,7 @@ int ms_fnmatch(const char *pattern, const char *string, enum protocol_types prot
} }
/* a generic fnmatch function - uses for non-CIFS pattern matching */ /** a generic fnmatch function - uses for non-CIFS pattern matching */
int gen_fnmatch(const char *pattern, const char *string) int gen_fnmatch(const char *pattern, const char *string)
{ {
return ms_fnmatch(pattern, string, PROTOCOL_NT1); return ms_fnmatch(pattern, string, PROTOCOL_NT1);

7
source/lib/util/mutex.c
View File

@ -20,6 +20,11 @@
*/ */
#include "includes.h" #include "includes.h"
#include "mutex.h" #include "mutex.h"
/**
* @file
* @brief Mutex utility functions
*/
/* the registered mutex handlers */ /* the registered mutex handlers */
static struct { static struct {
@ -30,7 +35,7 @@ static struct {
/* read/write lock routines */ /* read/write lock routines */
/* /**
register a set of mutex/rwlock handlers. register a set of mutex/rwlock handlers.
Should only be called once in the execution of smbd. Should only be called once in the execution of smbd.
*/ */

15
source/lib/util/pidfile.c
View File

@ -27,8 +27,15 @@
#define O_NONBLOCK #define O_NONBLOCK
#endif #endif
/* return the pid in a pidfile. return 0 if the process (or pidfile) /**
does not exist */ * @file
* @brief Pid file handling
*/
/**
* return the pid in a pidfile. return 0 if the process (or pidfile)
* does not exist
*/
pid_t pidfile_pid(const char *name) pid_t pidfile_pid(const char *name)
{ {
int fd; int fd;
@ -73,7 +80,9 @@ pid_t pidfile_pid(const char *name)
return 0; return 0;
} }
/* create a pid file in the pid directory. open it and leave it locked */ /**
* create a pid file in the pid directory. open it and leave it locked
*/
void pidfile_create(const char *name) void pidfile_create(const char *name)
{ {
int fd; int fd;

21
source/lib/util/signal.c
View File

@ -22,6 +22,11 @@
#include "includes.h" #include "includes.h"
#include "system/wait.h" #include "system/wait.h"
/**
* @file
* @brief Signal handling
*/
/**************************************************************************** /****************************************************************************
Catch child exits and reap the child zombie status. Catch child exits and reap the child zombie status.
****************************************************************************/ ****************************************************************************/
@ -61,9 +66,9 @@ static void sig_cld_leave_status(int signum)
#endif #endif
} }
/******************************************************************* /**
Block sigs. Block sigs.
********************************************************************/ **/
void BlockSignals(BOOL block,int signum) void BlockSignals(BOOL block,int signum)
{ {
@ -88,12 +93,12 @@ void BlockSignals(BOOL block,int signum)
#endif #endif
} }
/******************************************************************* /**
Catch a signal. This should implement the following semantics: Catch a signal. This should implement the following semantics:
1) The handler remains installed after being called. 1) The handler remains installed after being called.
2) The signal should be blocked during handler execution. 2) The signal should be blocked during handler execution.
********************************************************************/ **/
void (*CatchSignal(int signum,void (*handler)(int )))(int) void (*CatchSignal(int signum,void (*handler)(int )))(int)
{ {
@ -121,18 +126,18 @@ void (*CatchSignal(int signum,void (*handler)(int )))(int)
#endif #endif
} }
/******************************************************************* /**
Ignore SIGCLD via whatever means is necessary for this OS. Ignore SIGCLD via whatever means is necessary for this OS.
********************************************************************/ **/
void CatchChild(void) void CatchChild(void)
{ {
CatchSignal(SIGCLD, sig_cld); CatchSignal(SIGCLD, sig_cld);
} }
/******************************************************************* /**
Catch SIGCLD but leave the child around so it's status can be reaped. Catch SIGCLD but leave the child around so it's status can be reaped.
********************************************************************/ **/
void CatchChildLeaveStatus(void) void CatchChildLeaveStatus(void)
{ {

31
source/lib/util/substitute.c
View File

@ -22,6 +22,11 @@
#include "includes.h" #include "includes.h"
#include "smb_server/smb_server.h" #include "smb_server/smb_server.h"
/**
* @file
* @brief Substitution handling
*/
/* oh bugger - I really didn't want to have a top-level context /* oh bugger - I really didn't want to have a top-level context
anywhere, but until we change all lp_*() calls to take a context anywhere, but until we change all lp_*() calls to take a context
argument this is needed */ argument this is needed */
@ -66,7 +71,7 @@ void sub_set_remote_arch(const char *str)
setup_string(&sub->remote_arch, str); setup_string(&sub->remote_arch, str);
} }
/* /**
setup the string used by %U substitution setup the string used by %U substitution
*/ */
void sub_set_user_name(const char *name) void sub_set_user_name(const char *name)
@ -75,17 +80,17 @@ void sub_set_user_name(const char *name)
setup_string(&sub->user_name, name); setup_string(&sub->user_name, name);
} }
/**************************************************************************** /**
FOO FIXME
****************************************************************************/ **/
void standard_sub_basic(char *str,size_t len) void standard_sub_basic(char *str,size_t len)
{ {
} }
/**************************************************************************** /**
Do some standard substitutions in a string. Do some standard substitutions in a string.
This function will return an allocated string that have to be freed. This function will return an allocated string that have to be freed.
****************************************************************************/ **/
char *talloc_sub_basic(TALLOC_CTX *mem_ctx, const char *smb_name, const char *str) char *talloc_sub_basic(TALLOC_CTX *mem_ctx, const char *smb_name, const char *str)
{ {
return talloc_strdup(mem_ctx, str); return talloc_strdup(mem_ctx, str);
@ -96,10 +101,10 @@ char *alloc_sub_basic(const char *smb_name, const char *str)
return strdup(str); return strdup(str);
} }
/**************************************************************************** /**
Do some specific substitutions in a string. Do some specific substitutions in a string.
This function will return an allocated string that have to be freed. This function will return an allocated string that have to be freed.
****************************************************************************/ **/
char *talloc_sub_specified(TALLOC_CTX *mem_ctx, char *talloc_sub_specified(TALLOC_CTX *mem_ctx,
const char *input_string, const char *input_string,
@ -138,9 +143,9 @@ char *alloc_sub_advanced(int snum, const char *user,
return strdup(str); return strdup(str);
} }
/**************************************************************************** /**
Do some standard substitutions in a string. Do some standard substitutions in a string.
****************************************************************************/ **/
void standard_sub_tcon(struct smbsrv_tcon *tcon, char *str, size_t len) void standard_sub_tcon(struct smbsrv_tcon *tcon, char *str, size_t len)
{ {
@ -156,9 +161,9 @@ char *alloc_sub_tcon(struct smbsrv_tcon *tcon, char *str)
return strdup(str); return strdup(str);
} }
/**************************************************************************** /**
Like standard_sub but by snum. Like standard_sub but by snum. FIXME
****************************************************************************/ **/
void standard_sub_snum(int snum, char *str, size_t len) void standard_sub_snum(int snum, char *str, size_t len)
{ {

105
source/lib/util/time.c
View File

@ -23,6 +23,11 @@
#include "includes.h" #include "includes.h"
#include "system/time.h" #include "system/time.h"
/**
* @file
* @brief time handling functions
*/
#ifndef TIME_T_MIN #ifndef TIME_T_MIN
/* we use 0 here, because (time_t)-1 means error */ /* we use 0 here, because (time_t)-1 means error */
#define TIME_T_MIN 0 #define TIME_T_MIN 0
@ -37,17 +42,17 @@
#define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t)) #define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
#endif #endif
/******************************************************************* /**
External access to time_t_min and time_t_max. External access to time_t_min and time_t_max.
********************************************************************/ **/
time_t get_time_t_max(void) time_t get_time_t_max(void)
{ {
return TIME_T_MAX; return TIME_T_MAX;
} }
/******************************************************************* /**
a gettimeofday wrapper a gettimeofday wrapper
********************************************************************/ **/
void GetTimeOfDay(struct timeval *tval) void GetTimeOfDay(struct timeval *tval)
{ {
#ifdef HAVE_GETTIMEOFDAY_TZ #ifdef HAVE_GETTIMEOFDAY_TZ
@ -60,10 +65,10 @@ void GetTimeOfDay(struct timeval *tval)
#define TIME_FIXUP_CONSTANT 11644473600LL #define TIME_FIXUP_CONSTANT 11644473600LL
/**************************************************************************** /**
interpret an 8 byte "filetime" structure to a time_t interpret an 8 byte "filetime" structure to a time_t
It's originally in "100ns units since jan 1st 1601" It's originally in "100ns units since jan 1st 1601"
****************************************************************************/ **/
time_t nt_time_to_unix(NTTIME nt) time_t nt_time_to_unix(NTTIME nt)
{ {
if (nt == 0) { if (nt == 0) {
@ -84,10 +89,10 @@ time_t nt_time_to_unix(NTTIME nt)
} }
/**************************************************************************** /**
put a 8 byte filetime from a time_t put a 8 byte filetime from a time_t
This takes GMT as input This takes GMT as input
****************************************************************************/ **/
void unix_to_nt_time(NTTIME *nt, time_t t) void unix_to_nt_time(NTTIME *nt, time_t t)
{ {
uint64_t t2; uint64_t t2;
@ -109,9 +114,9 @@ void unix_to_nt_time(NTTIME *nt, time_t t)
} }
/**************************************************************************** /**
check if it's a null unix time check if it's a null unix time
****************************************************************************/ **/
BOOL null_time(time_t t) BOOL null_time(time_t t)
{ {
return t == 0 || return t == 0 ||
@ -120,9 +125,9 @@ BOOL null_time(time_t t)
} }
/**************************************************************************** /**
check if it's a null NTTIME check if it's a null NTTIME
****************************************************************************/ **/
BOOL null_nttime(NTTIME t) BOOL null_nttime(NTTIME t)
{ {
return t == 0 || t == (NTTIME)-1; return t == 0 || t == (NTTIME)-1;
@ -176,20 +181,20 @@ static uint32_t make_dos_date(time_t unixdate, int zone_offset)
return ret; return ret;
} }
/******************************************************************* /**
put a dos date into a buffer (time/date format) put a dos date into a buffer (time/date format)
This takes GMT time and puts local time in the buffer This takes GMT time and puts local time in the buffer
********************************************************************/ **/
void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset) void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
{ {
uint32_t x = make_dos_date(unixdate, zone_offset); uint32_t x = make_dos_date(unixdate, zone_offset);
SIVAL(buf,offset,x); SIVAL(buf,offset,x);
} }
/******************************************************************* /**
put a dos date into a buffer (date/time format) put a dos date into a buffer (date/time format)
This takes GMT time and puts local time in the buffer This takes GMT time and puts local time in the buffer
********************************************************************/ **/
void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset) void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
{ {
uint32_t x; uint32_t x;
@ -198,11 +203,11 @@ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
SIVAL(buf,offset,x); SIVAL(buf,offset,x);
} }
/******************************************************************* /**
put a dos 32 bit "unix like" date into a buffer. This routine takes 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 GMT and converts it to LOCAL time before putting it (most SMBs assume
localtime for this sort of date) localtime for this sort of date)
********************************************************************/ **/
void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset) void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
{ {
if (!null_time(unixdate)) { if (!null_time(unixdate)) {
@ -229,10 +234,10 @@ static void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *
*year = ((p3>>1)&0xFF) + 80; *year = ((p3>>1)&0xFF) + 80;
} }
/******************************************************************* /**
create a unix date (int GMT) from a dos date (which is actually in create a unix date (int GMT) from a dos date (which is actually in
localtime) localtime)
********************************************************************/ **/
time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset) time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
{ {
uint32_t dos_date=0; uint32_t dos_date=0;
@ -254,9 +259,9 @@ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
return ret; return ret;
} }
/******************************************************************* /**
like make_unix_date() but the words are reversed like make_unix_date() but the words are reversed
********************************************************************/ **/
time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset) time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
{ {
uint32_t x,x2; uint32_t x,x2;
@ -268,10 +273,10 @@ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
return pull_dos_date((void *)&x, zone_offset); return pull_dos_date((void *)&x, zone_offset);
} }
/******************************************************************* /**
create a unix GMT date from a dos date in 32 bit "unix like" format create a unix GMT date from a dos date in 32 bit "unix like" format
these generally arrive as localtimes, with corresponding DST these generally arrive as localtimes, with corresponding DST
******************************************************************/ **/
time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset) time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
{ {
time_t t = (time_t)IVAL(date_ptr,0); time_t t = (time_t)IVAL(date_ptr,0);
@ -282,9 +287,9 @@ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
} }
/*************************************************************************** /**
return a HTTP/1.0 time string return a HTTP/1.0 time string
***************************************************************************/ **/
char *http_timestring(TALLOC_CTX *mem_ctx, time_t t) char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
{ {
char *buf; char *buf;
@ -308,9 +313,9 @@ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
return buf; return buf;
} }
/**************************************************************************** /**
Return the date and time as a string Return the date and time as a string
****************************************************************************/ **/
char *timestring(TALLOC_CTX *mem_ctx, time_t t) char *timestring(TALLOC_CTX *mem_ctx, time_t t)
{ {
char *TimeBuf; char *TimeBuf;
@ -338,7 +343,7 @@ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
return TimeBuf; return TimeBuf;
} }
/* /**
return a talloced string representing a NTTIME for human consumption return a talloced string representing a NTTIME for human consumption
*/ */
const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt) const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
@ -352,7 +357,7 @@ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
} }
/* /**
put a NTTIME into a packet put a NTTIME into a packet
*/ */
void push_nttime(uint8_t *base, uint16_t offset, NTTIME t) void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
@ -360,7 +365,7 @@ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
SBVAL(base, offset, t); SBVAL(base, offset, t);
} }
/* /**
pull a NTTIME from a packet pull a NTTIME from a packet
*/ */
NTTIME pull_nttime(uint8_t *base, uint16_t offset) NTTIME pull_nttime(uint8_t *base, uint16_t offset)
@ -369,7 +374,7 @@ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
return ret; return ret;
} }
/* /**
parse a nttime as a large integer in a string and return a NTTIME parse a nttime as a large integer in a string and return a NTTIME
*/ */
NTTIME nttime_from_string(const char *s) NTTIME nttime_from_string(const char *s)
@ -377,7 +382,7 @@ NTTIME nttime_from_string(const char *s)
return strtoull(s, NULL, 0); return strtoull(s, NULL, 0);
} }
/* /**
return (tv1 - tv2) in microseconds return (tv1 - tv2) in microseconds
*/ */
int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2) int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
@ -387,7 +392,7 @@ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
} }
/* /**
return a zero timeval return a zero timeval
*/ */
struct timeval timeval_zero(void) struct timeval timeval_zero(void)
@ -398,7 +403,7 @@ struct timeval timeval_zero(void)
return tv; return tv;
} }
/* /**
return True if a timeval is zero return True if a timeval is zero
*/ */
BOOL timeval_is_zero(const struct timeval *tv) BOOL timeval_is_zero(const struct timeval *tv)
@ -406,7 +411,7 @@ BOOL timeval_is_zero(const struct timeval *tv)
return tv->tv_sec == 0 && tv->tv_usec == 0; return tv->tv_sec == 0 && tv->tv_usec == 0;
} }
/* /**
return a timeval for the current time return a timeval for the current time
*/ */
struct timeval timeval_current(void) struct timeval timeval_current(void)
@ -416,7 +421,7 @@ struct timeval timeval_current(void)
return tv; return tv;
} }
/* /**
return a timeval struct with the given elements return a timeval struct with the given elements
*/ */
struct timeval timeval_set(uint32_t secs, uint32_t usecs) struct timeval timeval_set(uint32_t secs, uint32_t usecs)
@ -428,7 +433,7 @@ struct timeval timeval_set(uint32_t secs, uint32_t usecs)
} }
/* /**
return a timeval ofs microseconds after tv return a timeval ofs microseconds after tv
*/ */
struct timeval timeval_add(const struct timeval *tv, struct timeval timeval_add(const struct timeval *tv,
@ -443,7 +448,7 @@ struct timeval timeval_add(const struct timeval *tv,
return tv2; return tv2;
} }
/* /**
return the sum of two timeval structures return the sum of two timeval structures
*/ */
struct timeval timeval_sum(const struct timeval *tv1, struct timeval timeval_sum(const struct timeval *tv1,
@ -452,7 +457,7 @@ struct timeval timeval_sum(const struct timeval *tv1,
return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec); return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
} }
/* /**
return a timeval secs/usecs into the future return a timeval secs/usecs into the future
*/ */
struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs) struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
@ -461,7 +466,7 @@ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
return timeval_add(&tv, secs, usecs); return timeval_add(&tv, secs, usecs);
} }
/* /**
compare two timeval structures. compare two timeval structures.
Return -1 if tv1 < tv2 Return -1 if tv1 < tv2
Return 0 if tv1 == tv2 Return 0 if tv1 == tv2
@ -476,7 +481,7 @@ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
return 0; return 0;
} }
/* /**
return True if a timer is in the past return True if a timer is in the past
*/ */
BOOL timeval_expired(const struct timeval *tv) BOOL timeval_expired(const struct timeval *tv)
@ -487,7 +492,7 @@ BOOL timeval_expired(const struct timeval *tv)
return (tv2.tv_usec >= tv->tv_usec); return (tv2.tv_usec >= tv->tv_usec);
} }
/* /**
return the number of seconds elapsed between two times return the number of seconds elapsed between two times
*/ */
double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2) double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
@ -496,7 +501,7 @@ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
(tv2->tv_usec - tv1->tv_usec)*1.0e-6; (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
} }
/* /**
return the number of seconds elapsed since a given time return the number of seconds elapsed since a given time
*/ */
double timeval_elapsed(const struct timeval *tv) double timeval_elapsed(const struct timeval *tv)
@ -505,7 +510,7 @@ double timeval_elapsed(const struct timeval *tv)
return timeval_elapsed2(tv, &tv2); return timeval_elapsed2(tv, &tv2);
} }
/* /**
return the lesser of two timevals return the lesser of two timevals
*/ */
struct timeval timeval_min(const struct timeval *tv1, struct timeval timeval_min(const struct timeval *tv1,
@ -517,7 +522,7 @@ struct timeval timeval_min(const struct timeval *tv1,
return *tv2; return *tv2;
} }
/* /**
return the greater of two timevals return the greater of two timevals
*/ */
struct timeval timeval_max(const struct timeval *tv1, struct timeval timeval_max(const struct timeval *tv1,
@ -529,7 +534,7 @@ struct timeval timeval_max(const struct timeval *tv1,
return *tv2; return *tv2;
} }
/* /**
return the difference between two timevals as a timeval return the difference between two timevals as a timeval
if tv1 comes after tv2, then return a zero timeval if tv1 comes after tv2, then return a zero timeval
(this is *tv2 - *tv1) (this is *tv2 - *tv1)
@ -552,7 +557,7 @@ struct timeval timeval_until(const struct timeval *tv1,
} }
/* /**
convert a timeval to a NTTIME convert a timeval to a NTTIME
*/ */
NTTIME timeval_to_nttime(const struct timeval *tv) NTTIME timeval_to_nttime(const struct timeval *tv)
@ -579,9 +584,9 @@ static int tm_diff(struct tm *a, struct tm *b)
return seconds; return seconds;
} }
/******************************************************************* /**
return the UTC offset in seconds west of UTC, or 0 if it cannot be determined return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
******************************************************************/ */
int get_time_zone(time_t t) int get_time_zone(time_t t)
{ {
struct tm *tm = gmtime(&t); struct tm *tm = gmtime(&t);

5
source/lib/util/unix_privs.c
View File

@ -23,6 +23,11 @@
#include "includes.h" #include "includes.h"
#include "system/filesys.h" #include "system/filesys.h"
/**
* @file
* @brief Gaining/losing root privileges
*/
/* /*
there are times when smbd needs to temporarily gain root privileges there are times when smbd needs to temporarily gain root privileges
to do some operation. To do this you call root_privileges(), which to do some operation. To do this you call root_privileges(), which

97
source/lib/util/util.c
View File

@ -28,10 +28,15 @@
#include "system/iconv.h" #include "system/iconv.h"
#include "system/filesys.h" #include "system/filesys.h"
/*************************************************************************** /**
* @file
* @brief Misc utility functions
*/
/**
Find a suitable temporary directory. The result should be copied immediately Find a suitable temporary directory. The result should be copied immediately
as it may be overwritten by a subsequent call. as it may be overwritten by a subsequent call.
****************************************************************************/ **/
const char *tmpdir(void) const char *tmpdir(void)
{ {
char *p; char *p;
@ -41,9 +46,9 @@ const char *tmpdir(void)
} }
/******************************************************************* /**
Check if a file exists - call vfs_file_exist for samba files. Check if a file exists - call vfs_file_exist for samba files.
********************************************************************/ **/
BOOL file_exist(const char *fname) BOOL file_exist(const char *fname)
{ {
struct stat st; struct stat st;
@ -55,9 +60,9 @@ BOOL file_exist(const char *fname)
return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode))); return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
} }
/******************************************************************* /**
Check a files mod time. Check a files mod time.
********************************************************************/ **/
time_t file_modtime(const char *fname) time_t file_modtime(const char *fname)
{ {
@ -69,9 +74,9 @@ time_t file_modtime(const char *fname)
return(st.st_mtime); return(st.st_mtime);
} }
/******************************************************************* /**
Check if a directory exists. Check if a directory exists.
********************************************************************/ **/
BOOL directory_exist(const char *dname) BOOL directory_exist(const char *dname)
{ {
@ -167,12 +172,12 @@ static void close_low_fds(BOOL stderr_too)
#endif #endif
} }
/**************************************************************************** /**
Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available, Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
else else
if SYSV use O_NDELAY if SYSV use O_NDELAY
if BSD use FNDELAY if BSD use FNDELAY
****************************************************************************/ **/
int set_blocking(int fd, BOOL set) int set_blocking(int fd, BOOL set)
{ {
@ -198,9 +203,9 @@ int set_blocking(int fd, BOOL set)
} }
/******************************************************************* /**
Sleep for a specified number of milliseconds. Sleep for a specified number of milliseconds.
********************************************************************/ **/
void msleep(uint_t t) void msleep(uint_t t)
{ {
@ -213,9 +218,9 @@ void msleep(uint_t t)
select(0,NULL,NULL,NULL,&tval); select(0,NULL,NULL,NULL,&tval);
} }
/**************************************************************************** /**
Become a daemon, discarding the controlling terminal. Become a daemon, discarding the controlling terminal.
****************************************************************************/ **/
void become_daemon(BOOL Fork) void become_daemon(BOOL Fork)
{ {
@ -244,11 +249,11 @@ void become_daemon(BOOL Fork)
} }
/**************************************************************************** /**
Free memory, checks for NULL. Free memory, checks for NULL.
Use directly SAFE_FREE() Use directly SAFE_FREE()
Exists only because we need to pass a function pointer somewhere --SSS Exists only because we need to pass a function pointer somewhere --SSS
****************************************************************************/ **/
void safe_free(void *p) void safe_free(void *p)
{ {
@ -256,7 +261,7 @@ void safe_free(void *p)
} }
/* /**
see if a string matches either our primary or one of our secondary see if a string matches either our primary or one of our secondary
netbios aliases. do a case insensitive match netbios aliases. do a case insensitive match
*/ */
@ -280,9 +285,9 @@ BOOL is_myname(const char *name)
} }
/**************************************************************************** /**
Get my own name, return in malloc'ed storage. Get my own name, return in malloc'ed storage.
****************************************************************************/ **/
char* get_myname(void) char* get_myname(void)
{ {
@ -311,9 +316,9 @@ char* get_myname(void)
return hostname; return hostname;
} }
/**************************************************************************** /**
Return true if a string could be a pure IP address. Return true if a string could be a pure IP address.
****************************************************************************/ **/
BOOL is_ipaddress(const char *str) BOOL is_ipaddress(const char *str)
{ {
@ -330,9 +335,9 @@ BOOL is_ipaddress(const char *str)
return pure_address; return pure_address;
} }
/**************************************************************************** /**
Interpret an internet address or name into an IP address in 4 byte form. Interpret an internet address or name into an IP address in 4 byte form.
****************************************************************************/ **/
uint32_t interpret_addr(const char *str) uint32_t interpret_addr(const char *str)
{ {
struct hostent *hp; struct hostent *hp;
@ -375,9 +380,9 @@ uint32_t interpret_addr(const char *str)
return(res); return(res);
} }
/******************************************************************* /**
A convenient addition to interpret_addr(). A convenient addition to interpret_addr().
******************************************************************/ **/
struct ipv4_addr interpret_addr2(const char *str) struct ipv4_addr interpret_addr2(const char *str)
{ {
struct ipv4_addr ret; struct ipv4_addr ret;
@ -386,18 +391,18 @@ struct ipv4_addr interpret_addr2(const char *str)
return ret; return ret;
} }
/******************************************************************* /**
Check if an IP is the 0.0.0.0. Check if an IP is the 0.0.0.0.
******************************************************************/ **/
BOOL is_zero_ip(struct ipv4_addr ip) BOOL is_zero_ip(struct ipv4_addr ip)
{ {
return ip.addr == 0; return ip.addr == 0;
} }
/******************************************************************* /**
Are two IPs on the same subnet? Are two IPs on the same subnet?
********************************************************************/ **/
BOOL same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask) BOOL same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask)
{ {
@ -411,9 +416,9 @@ 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? Check if a process exists. Does this work on all unixes?
****************************************************************************/ **/
BOOL process_exists(pid_t pid) BOOL process_exists(pid_t pid)
{ {
@ -423,10 +428,10 @@ BOOL process_exists(pid_t pid)
return(kill(pid,0) == 0 || errno != ESRCH); return(kill(pid,0) == 0 || errno != ESRCH);
} }
/**************************************************************************** /**
Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
is dealt with in posix.c is dealt with in posix.c
****************************************************************************/ **/
BOOL fcntl_lock(int fd, int op, off_t offset, off_t count, int type) BOOL fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
{ {
@ -513,9 +518,9 @@ void dump_data(int level, const uint8_t *buf,int len)
} }
} }
/***************************************************************** /**
malloc that aborts with smb_panic on fail or zero size. malloc that aborts with smb_panic on fail or zero size.
*****************************************************************/ **/
void *smb_xmalloc(size_t size) void *smb_xmalloc(size_t size)
{ {
@ -552,9 +557,9 @@ char *smb_xstrdup(const char *s)
} }
/***************************************************************** /**
Like strdup but for memory. Like strdup but for memory.
*****************************************************************/ **/
void *memdup(const void *p, size_t size) void *memdup(const void *p, size_t size)
{ {
@ -568,9 +573,9 @@ void *memdup(const void *p, size_t size)
return p2; return p2;
} }
/***************************************************************** /**
A useful function for returning a path in the Samba lock directory. A useful function for returning a path in the Samba lock directory.
*****************************************************************/ **/
char *lock_path(TALLOC_CTX* mem_ctx, const char *name) char *lock_path(TALLOC_CTX* mem_ctx, const char *name)
{ {
char *fname, *dname; char *fname, *dname;
@ -596,9 +601,9 @@ char *lock_path(TALLOC_CTX* mem_ctx, const char *name)
} }
/***************************************************************** /**
A useful function for returning a path in the Samba piddir directory. A useful function for returning a path in the Samba piddir directory.
*****************************************************************/ **/
static char *pid_path(TALLOC_CTX* mem_ctx, const char *name) static char *pid_path(TALLOC_CTX* mem_ctx, const char *name)
{ {
char *fname, *dname; char *fname, *dname;
@ -654,7 +659,7 @@ char *private_path(TALLOC_CTX* mem_ctx, const char *name)
return fname; return fname;
} }
/* /**
return a path in the smbd.tmp directory, where all temporary file return a path in the smbd.tmp directory, where all temporary file
for smbd go. If NULL is passed for name then return the directory for smbd go. If NULL is passed for name then return the directory
path itself path itself
@ -707,8 +712,10 @@ 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 */ * see if a range of memory is all zero. A NULL pointer is considered
* to be all zero
*/
BOOL all_zero(const uint8_t *ptr, uint_t size) BOOL all_zero(const uint8_t *ptr, uint_t size)
{ {
int i; int i;
@ -719,7 +726,7 @@ BOOL all_zero(const uint8_t *ptr, uint_t size)
return True; return True;
} }
/* /**
realloc an array, checking for integer overflow in the array size realloc an array, checking for integer overflow in the array size
*/ */
void *realloc_array(void *ptr, size_t el_size, unsigned count) void *realloc_array(void *ptr, size_t el_size, unsigned count)

45
source/lib/util/util_file.c
View File

@ -24,11 +24,16 @@
#include "system/shmem.h" #include "system/shmem.h"
#include "system/filesys.h" #include "system/filesys.h"
/**************************************************************************** /**
* @file
* @brief File-related utility functions
*/
/**
read a line from a file with possible \ continuation chars. read a line from a file with possible \ continuation chars.
Blanks at the start or end of a line are stripped. Blanks at the start or end of a line are stripped.
The string will be allocated if s2 is NULL The string will be allocated if s2 is NULL
****************************************************************************/ **/
char *fgets_slash(char *s2,int maxlen,XFILE *f) char *fgets_slash(char *s2,int maxlen,XFILE *f)
{ {
char *s=s2; char *s=s2;
@ -98,7 +103,9 @@ char *fgets_slash(char *s2,int maxlen,XFILE *f)
return(s); return(s);
} }
/* Read one line (data until next newline or eof) and allocate it */ /**
* Read one line (data until next newline or eof) and allocate it
*/
char *afdgets(int fd, TALLOC_CTX *mem_ctx, size_t hint) char *afdgets(int fd, TALLOC_CTX *mem_ctx, size_t hint)
{ {
char *data = NULL; char *data = NULL;
@ -146,9 +153,9 @@ char *afdgets(int fd, TALLOC_CTX *mem_ctx, size_t hint)
} }
/**************************************************************************** /**
load a file into memory from a fd. load a file into memory from a fd.
****************************************************************************/ **/
char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx) char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx)
{ {
@ -171,9 +178,9 @@ char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx)
return p; return p;
} }
/**************************************************************************** /**
load a file into memory load a file into memory
****************************************************************************/ **/
char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx) char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx)
{ {
int fd; int fd;
@ -192,9 +199,9 @@ char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx)
} }
/******************************************************************* /**
mmap (if possible) or read a file mmap (if possible) or read a file
********************************************************************/ **/
void *map_file(const char *fname, size_t size) void *map_file(const char *fname, size_t size)
{ {
size_t s2 = 0; size_t s2 = 0;
@ -228,9 +235,9 @@ void *map_file(const char *fname, size_t size)
} }
/**************************************************************************** /**
parse a buffer into lines parse a buffer into lines
****************************************************************************/ **/
static char **file_lines_parse(char *p, size_t size, int *numlines, TALLOC_CTX *mem_ctx) static char **file_lines_parse(char *p, size_t size, int *numlines, TALLOC_CTX *mem_ctx)
{ {
int i; int i;
@ -267,10 +274,10 @@ static char **file_lines_parse(char *p, size_t size, int *numlines, TALLOC_CTX *
} }
/**************************************************************************** /**
load a file into memory and return an array of pointers to lines in the file load a file into memory and return an array of pointers to lines in the file
must be freed with talloc_free(). must be freed with talloc_free().
****************************************************************************/ **/
char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx) char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx)
{ {
char *p; char *p;
@ -287,11 +294,11 @@ char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx)
return lines; return lines;
} }
/**************************************************************************** /**
load a fd into memory and return an array of pointers to lines in the file 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 must be freed with talloc_free(). If convert is true calls unix_to_dos on
the list. the list.
****************************************************************************/ **/
char **fd_lines_load(int fd, int *numlines, TALLOC_CTX *mem_ctx) char **fd_lines_load(int fd, int *numlines, TALLOC_CTX *mem_ctx)
{ {
char *p; char *p;
@ -309,10 +316,10 @@ 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 take a list of lines and modify them to produce a list where \ continues
a line a line
****************************************************************************/ **/
void file_lines_slashcont(char **lines) void file_lines_slashcont(char **lines)
{ {
int i, j; int i, j;
@ -332,7 +339,7 @@ void file_lines_slashcont(char **lines)
} }
} }
/* /**
save a lump of data into a file. Mostly used for debugging save a lump of data into a file. Mostly used for debugging
*/ */
BOOL file_save(const char *fname, const void *packet, size_t length) BOOL file_save(const char *fname, const void *packet, size_t length)
@ -349,7 +356,7 @@ BOOL file_save(const char *fname, const void *packet, size_t length)
return True; return True;
} }
/* /**
see if a file exists see if a file exists
*/ */
BOOL file_exists(const char *path) BOOL file_exists(const char *path)

9
source/lib/util/util_sock.c
View File

@ -22,6 +22,11 @@
#include "includes.h" #include "includes.h"
#include "system/network.h" #include "system/network.h"
/**
* @file
* @brief Socket utility functions
*/
enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON}; enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
static const struct { static const struct {
@ -67,9 +72,9 @@ static const struct {
{NULL,0,0,0,0}}; {NULL,0,0,0,0}};
/**************************************************************************** /**
Set user socket options. Set user socket options.
****************************************************************************/ **/
void set_socket_options(int fd, const char *options) void set_socket_options(int fd, const char *options)
{ {
const char **options_list = str_list_make(NULL, options, " \t,"); const char **options_list = str_list_make(NULL, options, " \t,");

24
source/lib/util/util_str.c
View File

@ -983,10 +983,10 @@ size_t valgrind_strlen(const char *s)
#endif #endif
/* /**
format a string into length-prefixed dotted domain format, as used in NBT format a string into length-prefixed dotted domain format, as used in NBT
and in some ADS structures and in some ADS structures
*/ **/
const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s) const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
{ {
char *ret; char *ret;
@ -1036,9 +1036,9 @@ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
/* /**
varient of strcmp() that handles NULL ptrs varient of strcmp() that handles NULL ptrs
*/ **/
int strcmp_safe(const char *s1, const char *s2) int strcmp_safe(const char *s1, const char *s2)
{ {
if (s1 == s2) { if (s1 == s2) {
@ -1051,11 +1051,11 @@ int strcmp_safe(const char *s1, const char *s2)
} }
/******************************************************************* /**
return the number of bytes occupied by a buffer in ASCII format return the number of bytes occupied by a buffer in ASCII format
the result includes the null termination the result includes the null termination
limited by 'n' bytes limited by 'n' bytes
********************************************************************/ **/
size_t ascii_len_n(const char *src, size_t n) size_t ascii_len_n(const char *src, size_t n)
{ {
size_t len; size_t len;
@ -1069,9 +1069,9 @@ size_t ascii_len_n(const char *src, size_t n)
} }
/******************************************************************* /**
Return a string representing a CIFS attribute for a file. Return a string representing a CIFS attribute for a file.
********************************************************************/ **/
char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib) char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
{ {
int i, len; int i, len;
@ -1113,11 +1113,11 @@ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
return ret; return ret;
} }
/*************************************************************************** /**
Set a boolean variable from the text value stored in the passed string. 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 Returns True in success, False if the passed string does not correctly
represent a boolean. represent a boolean.
***************************************************************************/ **/
BOOL set_boolean(const char *boolean_string, BOOL *boolean) BOOL set_boolean(const char *boolean_string, BOOL *boolean)
{ {
@ -1155,7 +1155,9 @@ BOOL conv_str_bool(const char * str, BOOL * val)
return True; return True;
} }
/* Convert a size specification like 16K into an integral number of bytes. */ /**
* Convert a size specification like 16K into an integral number of bytes.
**/
BOOL conv_str_size(const char * str, uint64_t * val) BOOL conv_str_size(const char * str, uint64_t * val)
{ {
char * end = NULL; char * end = NULL;

34
source/lib/util/util_strlist.c
View File

@ -21,7 +21,12 @@
#include "includes.h" #include "includes.h"
/* /**
* @file
* @brief String list manipulation
*/
/**
build a null terminated list of strings from a input string and a build a null terminated list of strings from a input string and a
separator list. The separator list must contain characters less than separator list. The separator list must contain characters less than
or equal to 0x2f for this to work correctly on multi-byte strings or equal to 0x2f for this to work correctly on multi-byte strings
@ -71,9 +76,10 @@ const char **str_list_make(TALLOC_CTX *mem_ctx, const char *string, const char *
return ret; return ret;
} }
/* build a null terminated list of strings from an argv-like input string /**
Entries are seperated by spaces and can be enclosed by quotes. * build a null terminated list of strings from an argv-like input string
Does NOT support escaping * Entries are seperated by spaces and can be enclosed by quotes.
* Does NOT support escaping
*/ */
const char **str_list_make_shell(TALLOC_CTX *mem_ctx, const char *string, const char *sep) const char **str_list_make_shell(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
{ {
@ -131,7 +137,9 @@ const char **str_list_make_shell(TALLOC_CTX *mem_ctx, const char *string, const
} }
/* join a list back to one string */ /**
* join a list back to one string
*/
char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator) char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator)
{ {
char *ret = NULL; char *ret = NULL;
@ -149,7 +157,7 @@ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator)
return ret; return ret;
} }
/* join a list back to one (shell-like) string; entries /** join a list back to one (shell-like) string; entries
* seperated by spaces, using quotes where necessary */ * seperated by spaces, using quotes where necessary */
char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep) char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep)
{ {
@ -174,7 +182,7 @@ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep)
return ret; return ret;
} }
/* /**
return the number of elements in a string list return the number of elements in a string list
*/ */
size_t str_list_length(const char **list) size_t str_list_length(const char **list)
@ -185,7 +193,7 @@ size_t str_list_length(const char **list)
} }
/* /**
copy a string list copy a string list
*/ */
const char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list) const char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list)
@ -205,7 +213,7 @@ const char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list)
return ret; return ret;
} }
/* /**
Return true if all the elements of the list match exactly. Return true if all the elements of the list match exactly.
*/ */
BOOL str_list_equal(const char **list1, const char **list2) BOOL str_list_equal(const char **list1, const char **list2)
@ -228,7 +236,7 @@ BOOL str_list_equal(const char **list1, const char **list2)
} }
/* /**
add an entry to a string list add an entry to a string list
*/ */
const char **str_list_add(const char **list, const char *s) const char **str_list_add(const char **list, const char *s)
@ -247,7 +255,7 @@ const char **str_list_add(const char **list, const char *s)
return ret; return ret;
} }
/* /**
remove an entry from a string list remove an entry from a string list
*/ */
void str_list_remove(const char **list, const char *s) void str_list_remove(const char **list, const char *s)
@ -265,7 +273,7 @@ void str_list_remove(const char **list, const char *s)
} }
/* /**
return True if a string is in a list return True if a string is in a list
*/ */
BOOL str_list_check(const char **list, const char *s) BOOL str_list_check(const char **list, const char *s)
@ -278,7 +286,7 @@ BOOL str_list_check(const char **list, const char *s)
return False; return False;
} }
/* /**
return True if a string is in a list, case insensitively return True if a string is in a list, case insensitively
*/ */
BOOL str_list_check_ci(const char **list, const char *s) BOOL str_list_check_ci(const char **list, const char *s)

23
source/lib/util/util_unistr.c
View File

@ -22,6 +22,11 @@
#include "includes.h" #include "includes.h"
#include "system/iconv.h" #include "system/iconv.h"
/**
* @file
* @brief Unicode string manipulation
*/
/* these 2 tables define the unicode case handling. They are loaded /* these 2 tables define the unicode case handling. They are loaded
at startup either via mmap() or read() from the lib directory */ at startup either via mmap() or read() from the lib directory */
static void *upcase_table; static void *upcase_table;
@ -58,9 +63,9 @@ static void load_case_tables(void)
} }
} }
/******************************************************************* /**
Convert a codepoint_t to upper case. Convert a codepoint_t to upper case.
********************************************************************/ **/
codepoint_t toupper_w(codepoint_t val) codepoint_t toupper_w(codepoint_t val)
{ {
if (val < 128) { if (val < 128) {
@ -78,9 +83,9 @@ codepoint_t toupper_w(codepoint_t val)
return SVAL(upcase_table, val*2); return SVAL(upcase_table, val*2);
} }
/******************************************************************* /**
Convert a codepoint_t to lower case. Convert a codepoint_t to lower case.
********************************************************************/ **/
codepoint_t tolower_w(codepoint_t val) codepoint_t tolower_w(codepoint_t val)
{ {
if (val < 128) { if (val < 128) {
@ -98,10 +103,10 @@ codepoint_t tolower_w(codepoint_t val)
return SVAL(lowcase_table, val*2); return SVAL(lowcase_table, val*2);
} }
/******************************************************************* /**
return the number of bytes occupied by a buffer in CH_UTF16 format return the number of bytes occupied by a buffer in CH_UTF16 format
the result includes the null termination the result includes the null termination
********************************************************************/ **/
size_t utf16_len(const void *buf) size_t utf16_len(const void *buf)
{ {
size_t len; size_t len;
@ -111,11 +116,11 @@ size_t utf16_len(const void *buf)
return len + 2; return len + 2;
} }
/******************************************************************* /**
return the number of bytes occupied by a buffer in CH_UTF16 format return the number of bytes occupied by a buffer in CH_UTF16 format
the result includes the null termination the result includes the null termination
limited by 'n' bytes limited by 'n' bytes
********************************************************************/ **/
size_t utf16_len_n(const void *src, size_t n) size_t utf16_len_n(const void *src, size_t n)
{ {
size_t len; size_t len;
@ -137,7 +142,7 @@ size_t ucs2_align(const void *base_ptr, const void *p, int flags)
return PTR_DIFF(p, base_ptr) & 1; return PTR_DIFF(p, base_ptr) & 1;
} }
/* /**
compare two codepoints case insensitively compare two codepoints case insensitively
*/ */
int codepoint_cmpi(codepoint_t c1, codepoint_t c2) int codepoint_cmpi(codepoint_t c1, codepoint_t c2)

5
source/lib/util/xfile.c
View File

@ -18,6 +18,11 @@
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/**
* @file
* @brief scalable FILE replacement
*/
/* /*
stdio is very convenient, but on some systems the file descriptor stdio is very convenient, but on some systems the file descriptor
in FILE* is 8 bits, so it fails when more than 255 files are open. in FILE* is 8 bits, so it fails when more than 255 files are open.