mirror of
https://github.com/samba-team/samba.git
synced 2025-01-12 09:18:10 +03:00
r13752: Add doxyfile and fix formatting of comments. Current output is available at http://samba.org/~jelmer/util-api/
(This used to be commit 90812203df
)
This commit is contained in:
parent
4d3cc73843
commit
aa04388943
1229
source4/lib/util/Doxyfile
Normal file
1229
source4/lib/util/Doxyfile
Normal file
File diff suppressed because it is too large
Load Diff
@ -19,6 +19,11 @@
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Capabilities functions
|
||||
**/
|
||||
|
||||
/*
|
||||
capabilities fns - will be needed when we enable kernel oplocks
|
||||
*/
|
||||
|
@ -21,10 +21,15 @@
|
||||
|
||||
#include "includes.h"
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
* @file
|
||||
* @brief Manipulation of arbitrary data blobs
|
||||
**/
|
||||
|
||||
/**
|
||||
construct a data blob, must be freed with data_blob_free()
|
||||
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 ret;
|
||||
@ -48,9 +53,9 @@ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
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 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.
|
||||
Returns a NULL DATA_BLOB on failure
|
||||
*******************************************************************/
|
||||
**/
|
||||
DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
|
||||
{
|
||||
DATA_BLOB ret = *blob;
|
||||
@ -78,11 +83,11 @@ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
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
|
||||
*******************************************************************/
|
||||
**/
|
||||
DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t 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;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
free a data blob
|
||||
*******************************************************************/
|
||||
**/
|
||||
void data_blob_free(DATA_BLOB *d)
|
||||
{
|
||||
if (d) {
|
||||
@ -102,9 +107,9 @@ void data_blob_free(DATA_BLOB *d)
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
clear a DATA_BLOB's contents
|
||||
*******************************************************************/
|
||||
**/
|
||||
void data_blob_clear(DATA_BLOB *d)
|
||||
{
|
||||
if (d->data) {
|
||||
@ -112,9 +117,9 @@ void data_blob_clear(DATA_BLOB *d)
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
free a data blob and clear its contents
|
||||
*******************************************************************/
|
||||
**/
|
||||
void data_blob_clear_free(DATA_BLOB *d)
|
||||
{
|
||||
data_blob_clear(d);
|
||||
@ -122,9 +127,9 @@ void data_blob_clear_free(DATA_BLOB *d)
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
check if two data blobs are equal
|
||||
*******************************************************************/
|
||||
**/
|
||||
BOOL data_blob_equal(const DATA_BLOB *d1, const DATA_BLOB *d2)
|
||||
{
|
||||
if (d1->length != d2->length) {
|
||||
@ -142,9 +147,9 @@ BOOL data_blob_equal(const DATA_BLOB *d1, const DATA_BLOB *d2)
|
||||
return False;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
print the data_blob as hex string
|
||||
*******************************************************************/
|
||||
**/
|
||||
char *data_blob_hex_string(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
|
||||
{
|
||||
int i;
|
||||
@ -161,10 +166,10 @@ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
|
||||
return hex_string;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
useful for constructing data blobs in test suites, while
|
||||
avoiding const warnings
|
||||
*/
|
||||
**/
|
||||
DATA_BLOB data_blob_string_const(const char *str)
|
||||
{
|
||||
DATA_BLOB blob;
|
||||
@ -182,9 +187,9 @@ DATA_BLOB data_blob_const(const void *p, size_t length)
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
realloc a data_blob
|
||||
*/
|
||||
**/
|
||||
NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t 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;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
append some data to a data blob
|
||||
*/
|
||||
**/
|
||||
NTSTATUS data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
|
||||
const void *p, size_t length)
|
||||
{
|
||||
|
@ -24,6 +24,11 @@
|
||||
#include "system/time.h"
|
||||
#include "dynconfig.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Debug logging
|
||||
**/
|
||||
|
||||
/* this global variable determines what messages are printed */
|
||||
int DEBUGLEVEL;
|
||||
|
||||
@ -74,7 +79,7 @@ void do_debug(const char *format, ...)
|
||||
free(s);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
reopen the log file (usually called because the log file name might have changed)
|
||||
*/
|
||||
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
|
||||
or a file
|
||||
*/
|
||||
@ -133,7 +138,7 @@ void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
|
||||
reopen_logs();
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return a string constant containing n tabs
|
||||
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)
|
||||
{
|
||||
@ -155,6 +160,12 @@ void log_suspicious_usage(const char *from, const char *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)
|
||||
{
|
||||
if (debug_handlers.ops.print_suspicious_usage) {
|
||||
@ -195,7 +206,7 @@ void log_task_id(void)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
register a set of debug handlers.
|
||||
*/
|
||||
void register_debug_handlers(const char *name, struct debug_ops *ops)
|
||||
|
@ -23,6 +23,11 @@
|
||||
#include "system/wait.h"
|
||||
#include "system/filesys.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Fault handling
|
||||
*/
|
||||
|
||||
/* the registered fault handler */
|
||||
static struct {
|
||||
const char *name;
|
||||
@ -38,6 +43,9 @@ static const char *progname;
|
||||
#include <libexc.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Write backtrace to debug log
|
||||
*/
|
||||
void call_backtrace(void)
|
||||
{
|
||||
#ifdef HAVE_BACKTRACE
|
||||
@ -101,9 +109,9 @@ void call_backtrace(void)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Something really nasty happened - panic !
|
||||
********************************************************************/
|
||||
**/
|
||||
void smb_panic(const char *why)
|
||||
{
|
||||
const char *cmd = lp_panic_action();
|
||||
@ -138,9 +146,9 @@ void smb_panic(const char *why)
|
||||
abort();
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
report a fault
|
||||
********************************************************************/
|
||||
**/
|
||||
static void fault_report(int sig)
|
||||
{
|
||||
static int counter;
|
||||
@ -157,9 +165,9 @@ static void fault_report(int sig)
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
catch serious errors
|
||||
****************************************************************************/
|
||||
**/
|
||||
static void sig_fault(int sig)
|
||||
{
|
||||
if (fault_handlers.fault_handler) {
|
||||
@ -170,9 +178,9 @@ static void sig_fault(int sig)
|
||||
fault_report(sig);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
setup our fault handlers
|
||||
********************************************************************/
|
||||
**/
|
||||
void fault_setup(const char *pname)
|
||||
{
|
||||
if (progname == NULL) {
|
||||
@ -192,7 +200,7 @@ void fault_setup(const char *pname)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
register a fault handler.
|
||||
Should only be called once in the execution of smbd.
|
||||
*/
|
||||
|
@ -21,6 +21,10 @@
|
||||
#include "includes.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
|
||||
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);
|
||||
}
|
||||
|
||||
/* 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
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize)
|
||||
{
|
||||
|
@ -25,15 +25,20 @@
|
||||
#include "system/filesys.h"
|
||||
#include "lib/crypto/crypto.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Random number generation
|
||||
*/
|
||||
|
||||
static unsigned char hash[258];
|
||||
static uint32_t counter;
|
||||
|
||||
static BOOL done_reseed = False;
|
||||
static void (*reseed_callback)(int *newseed);
|
||||
|
||||
/****************************************************************
|
||||
/**
|
||||
Copy any user given reseed data.
|
||||
*****************************************************************/
|
||||
**/
|
||||
|
||||
void set_rand_reseed_callback(void (*fn)(int *))
|
||||
{
|
||||
@ -196,9 +201,9 @@ static int do_reseed(BOOL use_fd, int fd)
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
Interface to the (hopefully) good crypto random number generator.
|
||||
*/
|
||||
**/
|
||||
void generate_random_buffer(uint8_t *out, int len)
|
||||
{
|
||||
static int urand_fd = -1;
|
||||
@ -242,9 +247,9 @@ void generate_random_buffer(uint8_t *out, int len)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
generate a single random uint32_t
|
||||
*/
|
||||
**/
|
||||
uint32_t generate_random(void)
|
||||
{
|
||||
uint8_t v[4];
|
||||
@ -253,9 +258,9 @@ uint32_t generate_random(void)
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
very basic password quality checker
|
||||
*/
|
||||
**/
|
||||
BOOL check_password_quality(const char *s)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
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)
|
||||
{
|
||||
|
@ -29,6 +29,10 @@
|
||||
see the section marked "public interface" below for documentation
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
*/
|
||||
|
||||
#include "includes.h"
|
||||
|
||||
#define IDR_BITS 5
|
||||
|
@ -18,6 +18,11 @@
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Module initialization function handling
|
||||
*/
|
||||
|
||||
#include "includes.h"
|
||||
#include "system/dir.h"
|
||||
|
||||
|
@ -24,6 +24,10 @@
|
||||
code now
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief MS-style Filename matching
|
||||
*/
|
||||
|
||||
#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)
|
||||
{
|
||||
return ms_fnmatch(pattern, string, PROTOCOL_NT1);
|
||||
|
@ -20,6 +20,11 @@
|
||||
*/
|
||||
#include "includes.h"
|
||||
#include "mutex.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Mutex utility functions
|
||||
*/
|
||||
|
||||
/* the registered mutex handlers */
|
||||
static struct {
|
||||
@ -30,7 +35,7 @@ static struct {
|
||||
/* read/write lock routines */
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
register a set of mutex/rwlock handlers.
|
||||
Should only be called once in the execution of smbd.
|
||||
*/
|
||||
|
@ -27,8 +27,15 @@
|
||||
#define O_NONBLOCK
|
||||
#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)
|
||||
{
|
||||
int fd;
|
||||
@ -73,7 +80,9 @@ pid_t pidfile_pid(const char *name)
|
||||
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)
|
||||
{
|
||||
int fd;
|
||||
|
@ -22,6 +22,11 @@
|
||||
#include "includes.h"
|
||||
#include "system/wait.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Signal handling
|
||||
*/
|
||||
|
||||
/****************************************************************************
|
||||
Catch child exits and reap the child zombie status.
|
||||
****************************************************************************/
|
||||
@ -61,9 +66,9 @@ static void sig_cld_leave_status(int signum)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Block sigs.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
void BlockSignals(BOOL block,int signum)
|
||||
{
|
||||
@ -88,12 +93,12 @@ void BlockSignals(BOOL block,int signum)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
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)
|
||||
{
|
||||
@ -121,18 +126,18 @@ void (*CatchSignal(int signum,void (*handler)(int )))(int)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Ignore SIGCLD via whatever means is necessary for this OS.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
void CatchChild(void)
|
||||
{
|
||||
CatchSignal(SIGCLD, sig_cld);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Catch SIGCLD but leave the child around so it's status can be reaped.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
void CatchChildLeaveStatus(void)
|
||||
{
|
||||
|
@ -22,6 +22,11 @@
|
||||
#include "includes.h"
|
||||
#include "smb_server/smb_server.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Substitution handling
|
||||
*/
|
||||
|
||||
/* 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
|
||||
argument this is needed */
|
||||
@ -66,7 +71,7 @@ void sub_set_remote_arch(const char *str)
|
||||
setup_string(&sub->remote_arch, str);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
setup the string used by %U substitution
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
FOO
|
||||
****************************************************************************/
|
||||
/**
|
||||
FIXME
|
||||
**/
|
||||
void standard_sub_basic(char *str,size_t len)
|
||||
{
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Do some standard substitutions in a string.
|
||||
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)
|
||||
{
|
||||
return talloc_strdup(mem_ctx, str);
|
||||
@ -96,10 +101,10 @@ char *alloc_sub_basic(const char *smb_name, const char *str)
|
||||
return strdup(str);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Do some specific substitutions in a string.
|
||||
This function will return an allocated string that have to be freed.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
char *talloc_sub_specified(TALLOC_CTX *mem_ctx,
|
||||
const char *input_string,
|
||||
@ -138,9 +143,9 @@ char *alloc_sub_advanced(int snum, const char *user,
|
||||
return strdup(str);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Do some standard substitutions in a string.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
Like standard_sub but by snum.
|
||||
****************************************************************************/
|
||||
/**
|
||||
Like standard_sub but by snum. FIXME
|
||||
**/
|
||||
|
||||
void standard_sub_snum(int snum, char *str, size_t len)
|
||||
{
|
||||
|
@ -23,6 +23,11 @@
|
||||
#include "includes.h"
|
||||
#include "system/time.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief time handling functions
|
||||
*/
|
||||
|
||||
#ifndef TIME_T_MIN
|
||||
/* we use 0 here, because (time_t)-1 means error */
|
||||
#define TIME_T_MIN 0
|
||||
@ -37,17 +42,17 @@
|
||||
#define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
|
||||
#endif
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
External access to time_t_min and time_t_max.
|
||||
********************************************************************/
|
||||
**/
|
||||
time_t get_time_t_max(void)
|
||||
{
|
||||
return TIME_T_MAX;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
a gettimeofday wrapper
|
||||
********************************************************************/
|
||||
**/
|
||||
void GetTimeOfDay(struct timeval *tval)
|
||||
{
|
||||
#ifdef HAVE_GETTIMEOFDAY_TZ
|
||||
@ -60,10 +65,10 @@ void GetTimeOfDay(struct timeval *tval)
|
||||
|
||||
#define TIME_FIXUP_CONSTANT 11644473600LL
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
interpret an 8 byte "filetime" structure to a time_t
|
||||
It's originally in "100ns units since jan 1st 1601"
|
||||
****************************************************************************/
|
||||
**/
|
||||
time_t nt_time_to_unix(NTTIME nt)
|
||||
{
|
||||
if (nt == 0) {
|
||||
@ -84,10 +89,10 @@ time_t nt_time_to_unix(NTTIME nt)
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
put a 8 byte filetime from a time_t
|
||||
This takes GMT as input
|
||||
****************************************************************************/
|
||||
**/
|
||||
void unix_to_nt_time(NTTIME *nt, time_t t)
|
||||
{
|
||||
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
|
||||
****************************************************************************/
|
||||
**/
|
||||
BOOL null_time(time_t t)
|
||||
{
|
||||
return t == 0 ||
|
||||
@ -120,9 +125,9 @@ BOOL null_time(time_t t)
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
check if it's a null NTTIME
|
||||
****************************************************************************/
|
||||
**/
|
||||
BOOL null_nttime(NTTIME t)
|
||||
{
|
||||
return t == 0 || t == (NTTIME)-1;
|
||||
@ -176,20 +181,20 @@ static uint32_t make_dos_date(time_t unixdate, int zone_offset)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
put a dos date into a buffer (time/date format)
|
||||
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)
|
||||
{
|
||||
uint32_t x = make_dos_date(unixdate, zone_offset);
|
||||
SIVAL(buf,offset,x);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
put a dos date into a buffer (date/time format)
|
||||
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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
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)
|
||||
********************************************************************/
|
||||
**/
|
||||
void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
create a unix date (int GMT) from a dos date (which is actually in
|
||||
localtime)
|
||||
********************************************************************/
|
||||
**/
|
||||
time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
|
||||
{
|
||||
uint32_t dos_date=0;
|
||||
@ -254,9 +259,9 @@ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
like make_unix_date() but the words are reversed
|
||||
********************************************************************/
|
||||
**/
|
||||
time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
create a unix GMT date from a dos date in 32 bit "unix like" format
|
||||
these generally arrive as localtimes, with corresponding DST
|
||||
******************************************************************/
|
||||
**/
|
||||
time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
|
||||
{
|
||||
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
|
||||
***************************************************************************/
|
||||
**/
|
||||
char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
|
||||
{
|
||||
char *buf;
|
||||
@ -308,9 +313,9 @@ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
|
||||
return buf;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Return the date and time as a string
|
||||
****************************************************************************/
|
||||
**/
|
||||
char *timestring(TALLOC_CTX *mem_ctx, time_t t)
|
||||
{
|
||||
char *TimeBuf;
|
||||
@ -338,7 +343,7 @@ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
|
||||
return TimeBuf;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return a talloced string representing a NTTIME for human consumption
|
||||
*/
|
||||
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
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
pull a NTTIME from a packet
|
||||
*/
|
||||
NTTIME pull_nttime(uint8_t *base, uint16_t offset)
|
||||
@ -369,7 +374,7 @@ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
parse a nttime as a large integer in a string and return a NTTIME
|
||||
*/
|
||||
NTTIME nttime_from_string(const char *s)
|
||||
@ -377,7 +382,7 @@ NTTIME nttime_from_string(const char *s)
|
||||
return strtoull(s, NULL, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return (tv1 - tv2) in microseconds
|
||||
*/
|
||||
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
|
||||
*/
|
||||
struct timeval timeval_zero(void)
|
||||
@ -398,7 +403,7 @@ struct timeval timeval_zero(void)
|
||||
return tv;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return True if a timeval is zero
|
||||
*/
|
||||
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 a timeval for the current time
|
||||
*/
|
||||
struct timeval timeval_current(void)
|
||||
@ -416,7 +421,7 @@ struct timeval timeval_current(void)
|
||||
return tv;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return a timeval struct with the given elements
|
||||
*/
|
||||
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
|
||||
*/
|
||||
struct timeval timeval_add(const struct timeval *tv,
|
||||
@ -443,7 +448,7 @@ struct timeval timeval_add(const struct timeval *tv,
|
||||
return tv2;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return the sum of two timeval structures
|
||||
*/
|
||||
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 a timeval secs/usecs into the future
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
compare two timeval structures.
|
||||
Return -1 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 True if a timer is in the past
|
||||
*/
|
||||
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 the number of seconds elapsed between two times
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return the number of seconds elapsed since a given time
|
||||
*/
|
||||
double timeval_elapsed(const struct timeval *tv)
|
||||
@ -505,7 +510,7 @@ double timeval_elapsed(const struct timeval *tv)
|
||||
return timeval_elapsed2(tv, &tv2);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return the lesser of two timevals
|
||||
*/
|
||||
struct timeval timeval_min(const struct timeval *tv1,
|
||||
@ -517,7 +522,7 @@ struct timeval timeval_min(const struct timeval *tv1,
|
||||
return *tv2;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return the greater of two timevals
|
||||
*/
|
||||
struct timeval timeval_max(const struct timeval *tv1,
|
||||
@ -529,7 +534,7 @@ struct timeval timeval_max(const struct timeval *tv1,
|
||||
return *tv2;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
return the difference between two timevals as a timeval
|
||||
if tv1 comes after tv2, then return a zero timeval
|
||||
(this is *tv2 - *tv1)
|
||||
@ -552,7 +557,7 @@ struct timeval timeval_until(const struct timeval *tv1,
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
convert a timeval to a NTTIME
|
||||
*/
|
||||
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 the UTC offset in seconds west of UTC, or 0 if it cannot be determined
|
||||
******************************************************************/
|
||||
*/
|
||||
int get_time_zone(time_t t)
|
||||
{
|
||||
struct tm *tm = gmtime(&t);
|
||||
|
@ -23,6 +23,11 @@
|
||||
#include "includes.h"
|
||||
#include "system/filesys.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Gaining/losing 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
|
||||
|
@ -28,10 +28,15 @@
|
||||
#include "system/iconv.h"
|
||||
#include "system/filesys.h"
|
||||
|
||||
/***************************************************************************
|
||||
/**
|
||||
* @file
|
||||
* @brief Misc utility functions
|
||||
*/
|
||||
|
||||
/**
|
||||
Find a suitable temporary directory. The result should be copied immediately
|
||||
as it may be overwritten by a subsequent call.
|
||||
****************************************************************************/
|
||||
**/
|
||||
const char *tmpdir(void)
|
||||
{
|
||||
char *p;
|
||||
@ -41,9 +46,9 @@ const char *tmpdir(void)
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Check if a file exists - call vfs_file_exist for samba files.
|
||||
********************************************************************/
|
||||
**/
|
||||
BOOL file_exist(const char *fname)
|
||||
{
|
||||
struct stat st;
|
||||
@ -55,9 +60,9 @@ BOOL file_exist(const char *fname)
|
||||
return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Check a files mod time.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
time_t file_modtime(const char *fname)
|
||||
{
|
||||
@ -69,9 +74,9 @@ time_t file_modtime(const char *fname)
|
||||
return(st.st_mtime);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Check if a directory exists.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
BOOL directory_exist(const char *dname)
|
||||
{
|
||||
@ -167,12 +172,12 @@ static void close_low_fds(BOOL stderr_too)
|
||||
#endif
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
|
||||
else
|
||||
if SYSV use O_NDELAY
|
||||
if BSD use FNDELAY
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
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.
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
void msleep(uint_t t)
|
||||
{
|
||||
@ -213,9 +218,9 @@ void msleep(uint_t t)
|
||||
select(0,NULL,NULL,NULL,&tval);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Become a daemon, discarding the controlling terminal.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
void become_daemon(BOOL Fork)
|
||||
{
|
||||
@ -244,11 +249,11 @@ void become_daemon(BOOL Fork)
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Free memory, checks for NULL.
|
||||
Use directly SAFE_FREE()
|
||||
Exists only because we need to pass a function pointer somewhere --SSS
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
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
|
||||
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.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
char* get_myname(void)
|
||||
{
|
||||
@ -311,9 +316,9 @@ char* get_myname(void)
|
||||
return hostname;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Return true if a string could be a pure IP address.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
BOOL is_ipaddress(const char *str)
|
||||
{
|
||||
@ -330,9 +335,9 @@ BOOL is_ipaddress(const char *str)
|
||||
return pure_address;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Interpret an internet address or name into an IP address in 4 byte form.
|
||||
****************************************************************************/
|
||||
**/
|
||||
uint32_t interpret_addr(const char *str)
|
||||
{
|
||||
struct hostent *hp;
|
||||
@ -375,9 +380,9 @@ uint32_t interpret_addr(const char *str)
|
||||
return(res);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
A convenient addition to interpret_addr().
|
||||
******************************************************************/
|
||||
**/
|
||||
struct ipv4_addr interpret_addr2(const char *str)
|
||||
{
|
||||
struct ipv4_addr ret;
|
||||
@ -386,18 +391,18 @@ struct ipv4_addr interpret_addr2(const char *str)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Check if an IP is the 0.0.0.0.
|
||||
******************************************************************/
|
||||
**/
|
||||
|
||||
BOOL is_zero_ip(struct ipv4_addr ip)
|
||||
{
|
||||
return ip.addr == 0;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Are two IPs on the same subnet?
|
||||
********************************************************************/
|
||||
**/
|
||||
|
||||
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?
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
BOOL process_exists(pid_t pid)
|
||||
{
|
||||
@ -423,10 +428,10 @@ BOOL process_exists(pid_t pid)
|
||||
return(kill(pid,0) == 0 || errno != ESRCH);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
|
||||
is dealt with in posix.c
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
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.
|
||||
*****************************************************************/
|
||||
**/
|
||||
|
||||
void *smb_xmalloc(size_t size)
|
||||
{
|
||||
@ -552,9 +557,9 @@ char *smb_xstrdup(const char *s)
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************
|
||||
/**
|
||||
Like strdup but for memory.
|
||||
*****************************************************************/
|
||||
**/
|
||||
|
||||
void *memdup(const void *p, size_t size)
|
||||
{
|
||||
@ -568,9 +573,9 @@ void *memdup(const void *p, size_t size)
|
||||
return p2;
|
||||
}
|
||||
|
||||
/*****************************************************************
|
||||
/**
|
||||
A useful function for returning a path in the Samba lock directory.
|
||||
*****************************************************************/
|
||||
**/
|
||||
char *lock_path(TALLOC_CTX* mem_ctx, const char *name)
|
||||
{
|
||||
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.
|
||||
*****************************************************************/
|
||||
**/
|
||||
static char *pid_path(TALLOC_CTX* mem_ctx, const char *name)
|
||||
{
|
||||
char *fname, *dname;
|
||||
@ -654,7 +659,7 @@ char *private_path(TALLOC_CTX* mem_ctx, const char *name)
|
||||
return fname;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
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
|
||||
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)
|
||||
{
|
||||
int i;
|
||||
@ -719,7 +726,7 @@ BOOL all_zero(const uint8_t *ptr, uint_t size)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
realloc an array, checking for integer overflow in the array size
|
||||
*/
|
||||
void *realloc_array(void *ptr, size_t el_size, unsigned count)
|
||||
|
@ -24,11 +24,16 @@
|
||||
#include "system/shmem.h"
|
||||
#include "system/filesys.h"
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
* @file
|
||||
* @brief File-related utility functions
|
||||
*/
|
||||
|
||||
/**
|
||||
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
|
||||
****************************************************************************/
|
||||
**/
|
||||
char *fgets_slash(char *s2,int maxlen,XFILE *f)
|
||||
{
|
||||
char *s=s2;
|
||||
@ -98,7 +103,9 @@ char *fgets_slash(char *s2,int maxlen,XFILE *f)
|
||||
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 *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.
|
||||
****************************************************************************/
|
||||
**/
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
load a file into memory
|
||||
****************************************************************************/
|
||||
**/
|
||||
char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
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
|
||||
********************************************************************/
|
||||
**/
|
||||
void *map_file(const char *fname, size_t size)
|
||||
{
|
||||
size_t s2 = 0;
|
||||
@ -228,9 +235,9 @@ void *map_file(const char *fname, size_t size)
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
parse a buffer into lines
|
||||
****************************************************************************/
|
||||
**/
|
||||
static char **file_lines_parse(char *p, size_t size, int *numlines, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
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
|
||||
must be freed with talloc_free().
|
||||
****************************************************************************/
|
||||
**/
|
||||
char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
char *p;
|
||||
@ -287,11 +294,11 @@ char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx)
|
||||
return lines;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
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.
|
||||
****************************************************************************/
|
||||
**/
|
||||
char **fd_lines_load(int fd, int *numlines, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
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
|
||||
a line
|
||||
****************************************************************************/
|
||||
**/
|
||||
void file_lines_slashcont(char **lines)
|
||||
{
|
||||
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
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
see if a file exists
|
||||
*/
|
||||
BOOL file_exists(const char *path)
|
||||
|
@ -22,6 +22,11 @@
|
||||
#include "includes.h"
|
||||
#include "system/network.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Socket utility functions
|
||||
*/
|
||||
|
||||
enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
|
||||
|
||||
static const struct {
|
||||
@ -67,9 +72,9 @@ static const struct {
|
||||
{NULL,0,0,0,0}};
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
/**
|
||||
Set user socket options.
|
||||
****************************************************************************/
|
||||
**/
|
||||
void set_socket_options(int fd, const char *options)
|
||||
{
|
||||
const char **options_list = str_list_make(NULL, options, " \t,");
|
||||
|
@ -983,10 +983,10 @@ size_t valgrind_strlen(const char *s)
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
format a string into length-prefixed dotted domain format, as used in NBT
|
||||
and in some ADS structures
|
||||
*/
|
||||
**/
|
||||
const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
|
||||
{
|
||||
char *ret;
|
||||
@ -1036,9 +1036,9 @@ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
|
||||
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
varient of strcmp() that handles NULL ptrs
|
||||
*/
|
||||
**/
|
||||
int strcmp_safe(const char *s1, const char *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
|
||||
the result includes the null termination
|
||||
limited by 'n' bytes
|
||||
********************************************************************/
|
||||
**/
|
||||
size_t ascii_len_n(const char *src, size_t n)
|
||||
{
|
||||
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.
|
||||
********************************************************************/
|
||||
**/
|
||||
char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
|
||||
{
|
||||
int i, len;
|
||||
@ -1113,11 +1113,11 @@ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/***************************************************************************
|
||||
/**
|
||||
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.
|
||||
***************************************************************************/
|
||||
**/
|
||||
|
||||
BOOL set_boolean(const char *boolean_string, BOOL *boolean)
|
||||
{
|
||||
@ -1155,7 +1155,9 @@ BOOL conv_str_bool(const char * str, BOOL * val)
|
||||
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)
|
||||
{
|
||||
char * end = NULL;
|
||||
|
@ -21,7 +21,12 @@
|
||||
|
||||
#include "includes.h"
|
||||
|
||||
/*
|
||||
/**
|
||||
* @file
|
||||
* @brief String list manipulation
|
||||
*/
|
||||
|
||||
/**
|
||||
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
|
||||
@ -71,9 +76,10 @@ const char **str_list_make(TALLOC_CTX *mem_ctx, const char *string, const char *
|
||||
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.
|
||||
Does NOT support escaping
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
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 *ret = NULL;
|
||||
@ -149,7 +157,7 @@ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator)
|
||||
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 */
|
||||
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 the number of elements in a string 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
|
||||
*/
|
||||
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 true if all the elements of the list match exactly.
|
||||
*/
|
||||
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
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
remove an entry from a string list
|
||||
*/
|
||||
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
|
||||
*/
|
||||
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 True if a string is in a list, case insensitively
|
||||
*/
|
||||
BOOL str_list_check_ci(const char **list, const char *s)
|
||||
|
@ -22,6 +22,11 @@
|
||||
#include "includes.h"
|
||||
#include "system/iconv.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Unicode string manipulation
|
||||
*/
|
||||
|
||||
/* these 2 tables define the unicode case handling. They are loaded
|
||||
at startup either via mmap() or read() from the lib directory */
|
||||
static void *upcase_table;
|
||||
@ -58,9 +63,9 @@ static void load_case_tables(void)
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Convert a codepoint_t to upper case.
|
||||
********************************************************************/
|
||||
**/
|
||||
codepoint_t toupper_w(codepoint_t val)
|
||||
{
|
||||
if (val < 128) {
|
||||
@ -78,9 +83,9 @@ codepoint_t toupper_w(codepoint_t val)
|
||||
return SVAL(upcase_table, val*2);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
Convert a codepoint_t to lower case.
|
||||
********************************************************************/
|
||||
**/
|
||||
codepoint_t tolower_w(codepoint_t val)
|
||||
{
|
||||
if (val < 128) {
|
||||
@ -98,10 +103,10 @@ codepoint_t tolower_w(codepoint_t val)
|
||||
return SVAL(lowcase_table, val*2);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
return the number of bytes occupied by a buffer in CH_UTF16 format
|
||||
the result includes the null termination
|
||||
********************************************************************/
|
||||
**/
|
||||
size_t utf16_len(const void *buf)
|
||||
{
|
||||
size_t len;
|
||||
@ -111,11 +116,11 @@ size_t utf16_len(const void *buf)
|
||||
return len + 2;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
/**
|
||||
return the number of bytes occupied by a buffer in CH_UTF16 format
|
||||
the result includes the null termination
|
||||
limited by 'n' bytes
|
||||
********************************************************************/
|
||||
**/
|
||||
size_t utf16_len_n(const void *src, size_t n)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
compare two codepoints case insensitively
|
||||
*/
|
||||
int codepoint_cmpi(codepoint_t c1, codepoint_t c2)
|
||||
|
@ -18,6 +18,11 @@
|
||||
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
|
||||
in FILE* is 8 bits, so it fails when more than 255 files are open.
|
||||
|
Loading…
Reference in New Issue
Block a user