1
0
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:
Jelmer Vernooij 2006-02-28 13:12:39 +00:00 committed by Gerald (Jerry) Carter
parent 4d3cc73843
commit aa04388943
23 changed files with 1584 additions and 229 deletions

1229
source4/lib/util/Doxyfile Normal file

File diff suppressed because it is too large Load Diff

View File

@ -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
*/

View File

@ -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)
{

View File

@ -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)

View File

@ -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.
*/

View File

@ -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)
{

View File

@ -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)
{

View File

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

View File

@ -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"

View File

@ -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);

View File

@ -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.
*/

View File

@ -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;

View File

@ -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)
{

View File

@ -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)
{

View File

@ -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);

View File

@ -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

View File

@ -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)

View File

@ -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)

View File

@ -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,");

View File

@ -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;

View File

@ -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)

View File

@ -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)

View File

@ -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.