/**************************************************************************
Try and abstract process capabilities (for systems that have them).
****************************************************************************/
-static BOOL set_process_capability( uint32_t cap_flag, BOOL enable )
+static bool set_process_capability( uint32_t cap_flag, bool enable )
{
if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
cap_t cap = cap_get_proc();
if (cap == NULL) {
DEBUG(0,("set_process_capability: cap_get_proc failed. Error was %s\n",
strerror(errno)));
- return False;
+ return false;
}
if(enable)
DEBUG(0,("set_process_capability: cap_set_proc failed. Error was %s\n",
strerror(errno)));
cap_free(cap);
- return False;
+ return false;
}
cap_free(cap);
DEBUG(10,("set_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
}
- return True;
+ return true;
}
/**************************************************************************
Try and abstract inherited process capabilities (for systems that have them).
****************************************************************************/
-static BOOL set_inherited_process_capability( uint32_t cap_flag, BOOL enable )
+static bool set_inherited_process_capability( uint32_t cap_flag, bool enable )
{
if(cap_flag == KERNEL_OPLOCK_CAPABILITY) {
cap_t cap = cap_get_proc();
if (cap == NULL) {
DEBUG(0,("set_inherited_process_capability: cap_get_proc failed. Error was %s\n",
strerror(errno)));
- return False;
+ return false;
}
if(enable)
DEBUG(0,("set_inherited_process_capability: cap_set_proc failed. Error was %s\n",
strerror(errno)));
cap_free(cap);
- return False;
+ return false;
}
cap_free(cap);
DEBUG(10,("set_inherited_process_capability: Set KERNEL_OPLOCK_CAPABILITY.\n"));
}
- return True;
+ return true;
}
#endif
const char *prog_name;
} state;
-static BOOL reopen_logs_scheduled;
-static BOOL check_reopen_logs(void)
+static bool reopen_logs_scheduled;
+static bool check_reopen_logs(void)
{
if (state.fd == 0 || reopen_logs_scheduled) {
- reopen_logs_scheduled = False;
+ reopen_logs_scheduled = false;
reopen_logs();
}
- if (state.fd <= 0) return False;
+ if (state.fd <= 0)
+ return false;
- return True;
+ return true;
}
_PUBLIC_ void debug_schedule_reopen_logs(void)
{
- reopen_logs_scheduled = True;
+ reopen_logs_scheduled = true;
}
static void log_timestring(int level, const char *location, const char *func)
/**
* Write to the debug log.
*/
-#define DEBUG(level, body) _DEBUG(level, body, True)
+#define DEBUG(level, body) _DEBUG(level, body, true)
/**
* Add data to an existing debug log entry.
*/
-#define DEBUGADD(level, body) _DEBUG(level, body, False)
+#define DEBUGADD(level, body) _DEBUG(level, body, false)
/**
* Obtain indentation string for the debug log.
register a fault handler.
Should only be called once in the execution of smbd.
*/
-_PUBLIC_ BOOL register_fault_handler(const char *name, void (*fault_handler)(int sig))
+_PUBLIC_ bool register_fault_handler(const char *name, void (*fault_handler)(int sig))
{
if (fault_handlers.name != NULL) {
/* it's already registered! */
DEBUG(2,("fault handler '%s' already registered - failed '%s'\n",
fault_handlers.name, name));
- return False;
+ return false;
}
fault_handlers.name = name;
fault_handlers.fault_handler = fault_handler;
DEBUG(2,("fault handler '%s' registered\n", name));
- return True;
+ return true;
}
static unsigned char hash[258];
static uint32_t counter;
-static BOOL done_reseed = False;
+static bool done_reseed = false;
static void (*reseed_callback)(int *newseed);
/**
*/
_PUBLIC_ void set_need_random_reseed(void)
{
- done_reseed = False;
+ done_reseed = false;
}
static void get_rand_reseed_data(int *reseed_data)
above...
**************************************************************/
-static int do_reseed(BOOL use_fd, int fd)
+static int do_reseed(bool use_fd, int fd)
{
unsigned char seed_inbuf[40];
uint32_t v1, v2; struct timeval tval; pid_t mypid;
unsigned char *p;
if(!done_reseed) {
- urand_fd = do_reseed(True, urand_fd);
- done_reseed = True;
+ urand_fd = do_reseed(true, urand_fd);
+ done_reseed = true;
}
if (urand_fd != -1 && len > 0) {
/* Read of urand error, drop back to non urand method. */
close(urand_fd);
urand_fd = -1;
- do_reseed(False, -1);
- done_reseed = True;
+ do_reseed(false, -1);
+ done_reseed = true;
}
/*
/**
very basic password quality checker
**/
-_PUBLIC_ BOOL check_password_quality(const char *s)
+_PUBLIC_ bool check_password_quality(const char *s)
{
int has_digit=0, has_capital=0, has_lower=0, has_special=0, has_high=0;
while (*s) {
/**
* Run the specified init functions.
*
- * @return True if all functions ran successfully, False otherwise
+ * @return true if all functions ran successfully, false otherwise
*/
-_PUBLIC_ BOOL run_init_functions(NTSTATUS (**fns) (void))
+_PUBLIC_ bool run_init_functions(NTSTATUS (**fns) (void))
{
int i;
- BOOL ret = True;
+ bool ret = true;
if (fns == NULL)
- return True;
+ return true;
- for (i = 0; fns[i]; i++) { ret &= (BOOL)NT_STATUS_IS_OK(fns[i]()); }
+ for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i]()); }
return ret;
}
register a set of mutex/rwlock handlers.
Should only be called once in the execution of smbd.
*/
-_PUBLIC_ BOOL register_mutex_handlers(const char *name, struct mutex_ops *ops)
+_PUBLIC_ bool register_mutex_handlers(const char *name, struct mutex_ops *ops)
{
if (mutex_handlers.name != NULL) {
/* it's already registered! */
DEBUG(2,("mutex handler '%s' already registered - failed '%s'\n",
mutex_handlers.name, name));
- return False;
+ return false;
}
mutex_handlers.name = name;
mutex_handlers.ops = *ops;
DEBUG(2,("mutex handler '%s' registered\n", name));
- return True;
+ return true;
}
Block sigs.
**/
-void BlockSignals(BOOL block,int signum)
+void BlockSignals(bool block, int signum)
{
#ifdef HAVE_SIGPROCMASK
sigset_t set;
{
const char *data = test_data;
const char **ret1, **ret2, *tmp;
- BOOL match = True;
+ bool match = true;
TALLOC_CTX *mem_ctx = tctx;
ret1 = str_list_make_shell(mem_ctx, data, " ");
ret2 = str_list_make_shell(mem_ctx, tmp, " ");
if ((ret1 == NULL || ret2 == NULL) && ret2 != ret1) {
- match = False;
+ match = false;
} else {
int j;
for (j = 0; ret1[j] && ret2[j]; j++) {
if (strcmp(ret1[j], ret2[j]) != 0) {
- match = False;
+ match = false;
break;
}
}
if (ret1[j] || ret2[j])
- match = False;
+ match = false;
}
torture_assert(tctx, match, talloc_asprintf(tctx,
/**
check if it's a null unix time
**/
-_PUBLIC_ BOOL null_time(time_t t)
+_PUBLIC_ bool null_time(time_t t)
{
return t == 0 ||
t == (time_t)0xFFFFFFFF ||
/**
check if it's a null NTTIME
**/
-_PUBLIC_ BOOL null_nttime(NTTIME t)
+_PUBLIC_ bool null_nttime(NTTIME t)
{
return t == 0 || t == (NTTIME)-1;
}
}
/**
- return True if a timeval is zero
+ return true if a timeval is zero
*/
-_PUBLIC_ BOOL timeval_is_zero(const struct timeval *tv)
+_PUBLIC_ bool timeval_is_zero(const struct timeval *tv)
{
return tv->tv_sec == 0 && tv->tv_usec == 0;
}
}
/**
- return True if a timer is in the past
+ return true if a timer is in the past
*/
-_PUBLIC_ BOOL timeval_expired(const struct timeval *tv)
+_PUBLIC_ bool timeval_expired(const struct timeval *tv)
{
struct timeval tv2 = timeval_current();
- if (tv2.tv_sec > tv->tv_sec) return True;
- if (tv2.tv_sec < tv->tv_sec) return False;
+ if (tv2.tv_sec > tv->tv_sec) return true;
+ if (tv2.tv_sec < tv->tv_sec) return false;
return (tv2.tv_usec >= tv->tv_usec);
}
/**
Check if a file exists - call vfs_file_exist for samba files.
**/
-_PUBLIC_ BOOL file_exist(const char *fname)
+_PUBLIC_ bool file_exist(const char *fname)
{
struct stat st;
if (stat(fname, &st) != 0) {
- return False;
+ return false;
}
return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
Check if a directory exists.
**/
-_PUBLIC_ BOOL directory_exist(const char *dname)
+_PUBLIC_ bool directory_exist(const char *dname)
{
struct stat st;
- BOOL ret;
+ bool ret;
if (stat(dname,&st) != 0) {
- return False;
+ return false;
}
ret = S_ISDIR(st.st_mode);
/**
* Try to create the specified directory if it didn't exist.
*
- * @retval True if the directory already existed and has the right permissions
+ * @retval true if the directory already existed and has the right permissions
* or was successfully created.
*/
-_PUBLIC_ BOOL directory_create_or_exist(const char *dname, uid_t uid,
+_PUBLIC_ bool directory_create_or_exist(const char *dname, uid_t uid,
mode_t dir_perms)
{
mode_t old_umask;
"%s: %s\n", dname,
strerror(errno)));
umask(old_umask);
- return False;
+ return false;
}
} else {
DEBUG(0, ("lstat failed on directory %s: %s\n",
dname, strerror(errno)));
umask(old_umask);
- return False;
+ return false;
}
} else {
/* Check ownership and permission on existing directory */
DEBUG(0, ("directory %s isn't a directory\n",
dname));
umask(old_umask);
- return False;
+ return false;
}
if ((st.st_uid != uid) ||
((st.st_mode & 0777) != dir_perms)) {
DEBUG(0, ("invalid permissions on directory "
"%s\n", dname));
umask(old_umask);
- return False;
+ return false;
}
}
- return True;
+ return true;
}
if BSD use FNDELAY
**/
-_PUBLIC_ int set_blocking(int fd, BOOL set)
+_PUBLIC_ int set_blocking(int fd, bool set)
{
int val;
#ifdef O_NONBLOCK
Return true if a string could be a pure IP address.
**/
-_PUBLIC_ BOOL is_ipaddress(const char *str)
+_PUBLIC_ bool is_ipaddress(const char *str)
{
- BOOL pure_address = True;
+ bool pure_address = true;
int i;
- if (str == NULL) return False;
+ if (str == NULL) return false;
for (i=0; pure_address && str[i]; i++)
if (!(isdigit((int)str[i]) || str[i] == '.'))
- pure_address = False;
+ pure_address = false;
/* Check that a pure number is not misinterpreted as an IP */
pure_address = pure_address && (strchr(str, '.') != NULL);
Check if an IP is the 0.0.0.0.
**/
-_PUBLIC_ BOOL is_zero_ip(struct ipv4_addr ip)
+_PUBLIC_ bool is_zero_ip(struct ipv4_addr ip)
{
return ip.addr == 0;
}
Are two IPs on the same subnet?
**/
-_PUBLIC_ BOOL same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask)
+_PUBLIC_ bool same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask)
{
uint32_t net1,net2,nmask;
Check if a process exists. Does this work on all unixes?
**/
-_PUBLIC_ BOOL process_exists(pid_t pid)
+_PUBLIC_ bool process_exists(pid_t pid)
{
/* Doing kill with a non-positive pid causes messages to be
* sent to places we don't want. */
is dealt with in posix.c
**/
-_PUBLIC_ BOOL fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
+_PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
{
struct flock lock;
int ret;
(lock.l_pid != 0) &&
(lock.l_pid != getpid())) {
DEBUG(3,("fcntl_lock: fd %d is locked by pid %d\n",fd,(int)lock.l_pid));
- return(True);
+ return true;
}
/* it must be not locked or locked by me */
- return(False);
+ return false;
}
/* a lock set or unset */
if (ret == -1) {
DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
(double)offset,(double)count,op,type,strerror(errno)));
- return(False);
+ return false;
}
/* everything went OK */
DEBUG(8,("fcntl_lock: Lock call successful\n"));
- return(True);
+ return true;
}
* see if a range of memory is all zero. A NULL pointer is considered
* to be all zero
*/
-_PUBLIC_ BOOL all_zero(const uint8_t *ptr, size_t size)
+_PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size)
{
int i;
- if (!ptr) return True;
+ if (!ptr) return true;
for (i=0;i<size;i++) {
- if (ptr[i]) return False;
+ if (ptr[i]) return false;
}
- return True;
+ return true;
}
/**
char *s=s2;
int len = 0;
int c;
- BOOL start_of_line = True;
+ bool start_of_line = true;
if (x_feof(f))
return(NULL);
if (len > 0 && s[len-1] == '\\')
{
s[--len] = 0;
- start_of_line = True;
+ start_of_line = true;
break;
}
return(s);
break;
/* fall through */
default:
- start_of_line = False;
+ start_of_line = false;
s[len++] = c;
s[len] = 0;
}
/**
save a lump of data into a file. Mostly used for debugging
*/
-_PUBLIC_ BOOL file_save(const char *fname, const void *packet, size_t length)
+_PUBLIC_ bool file_save(const char *fname, const void *packet, size_t length)
{
int fd;
fd = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (fd == -1) {
- return False;
+ return false;
}
if (write(fd, packet, length) != (size_t)length) {
- return False;
+ return false;
}
close(fd);
- return True;
+ return true;
}
_PUBLIC_ int vfdprintf(int fd, const char *format, va_list ap) _PRINTF_ATTRIBUTE(2,0)
/**
Set a string value, allocing the space for the string
**/
-static BOOL string_init(char **dest,const char *src)
+static bool string_init(char **dest,const char *src)
{
if (!src) src = "";
(*dest) = strdup(src);
if ((*dest) == NULL) {
DEBUG(0,("Out of memory in string_init\n"));
- return False;
+ return false;
}
- return True;
+ return true;
}
/**
Set a string value, deallocating any existing space, and allocing the space
for the string
**/
-_PUBLIC_ BOOL string_set(char **dest, const char *src)
+_PUBLIC_ bool string_set(char **dest, const char *src)
{
string_free(dest);
return string_init(dest,src);
* num should be a pointer to an integer that holds the current
* number of elements in strings. It will be updated by this function.
*/
-_PUBLIC_ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
+_PUBLIC_ bool add_string_to_array(TALLOC_CTX *mem_ctx,
const char *str, const char ***strings, int *num)
{
char *dup_str = talloc_strdup(mem_ctx, str);
const char *, ((*num)+1));
if ((*strings == NULL) || (dup_str == NULL))
- return False;
+ return false;
(*strings)[*num] = dup_str;
*num += 1;
- return True;
+ return true;
}
/**
Set a boolean variable from the text value stored in the passed string.
- Returns True in success, False if the passed string does not correctly
+ Returns true in success, false if the passed string does not correctly
represent a boolean.
**/
-_PUBLIC_ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
+_PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean)
{
if (strwicmp(boolean_string, "yes") == 0 ||
strwicmp(boolean_string, "true") == 0 ||
strwicmp(boolean_string, "on") == 0 ||
strwicmp(boolean_string, "1") == 0) {
- *boolean = True;
- return True;
+ *boolean = true;
+ return true;
} else if (strwicmp(boolean_string, "no") == 0 ||
strwicmp(boolean_string, "false") == 0 ||
strwicmp(boolean_string, "off") == 0 ||
strwicmp(boolean_string, "0") == 0) {
- *boolean = False;
- return True;
+ *boolean = false;
+ return true;
}
- return False;
+ return false;
}
/**
*
* val will be set to the read value.
*
- * @retval True if a boolean value was parsed, False otherwise.
+ * @retval true if a boolean value was parsed, false otherwise.
*/
-_PUBLIC_ BOOL conv_str_bool(const char * str, BOOL * val)
+_PUBLIC_ bool conv_str_bool(const char * str, bool * val)
{
char * end = NULL;
long lval;
if (str == NULL || *str == '\0') {
- return False;
+ return false;
}
lval = strtol(str, &end, 10 /* base */);
return set_boolean(str, val);
}
- *val = (lval) ? True : False;
- return True;
+ *val = (lval) ? true : false;
+ return true;
}
/**
* Convert a size specification like 16K into an integral number of bytes.
**/
-_PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
+_PUBLIC_ bool conv_str_size(const char * str, uint64_t * val)
{
char * end = NULL;
unsigned long long lval;
if (str == NULL || *str == '\0') {
- return False;
+ return false;
}
lval = strtoull(str, &end, 10 /* base */);
if (end == NULL || end == str) {
- return False;
+ return false;
}
if (*end) {
} else if (strwicmp(end, "P") == 0) {
lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL);
} else {
- return False;
+ return false;
}
}
*val = (uint64_t)lval;
- return True;
+ return true;
}
/**
*
* val will be set to the value read.
*
- * @retval True if parsing was successful, False otherwise
+ * @retval true if parsing was successful, false otherwise
*/
-_PUBLIC_ BOOL conv_str_u64(const char * str, uint64_t * val)
+_PUBLIC_ bool conv_str_u64(const char * str, uint64_t * val)
{
char * end = NULL;
unsigned long long lval;
if (str == NULL || *str == '\0') {
- return False;
+ return false;
}
lval = strtoull(str, &end, 10 /* base */);
if (end == NULL || *end != '\0' || end == str) {
- return False;
+ return false;
}
*val = (uint64_t)lval;
- return True;
+ return true;
}
/**
*
* @note The comparison is case-insensitive.
**/
-_PUBLIC_ BOOL strequal(const char *s1, const char *s2)
+_PUBLIC_ bool strequal(const char *s1, const char *s2)
{
if (s1 == s2)
- return(True);
+ return true;
if (!s1 || !s2)
- return(False);
+ return false;
return strcasecmp(s1,s2) == 0;
}
/**
Return true if all the elements of the list match exactly.
*/
-_PUBLIC_ BOOL str_list_equal(const char **list1, const char **list2)
+_PUBLIC_ bool str_list_equal(const char **list1, const char **list2)
{
int i;
for (i=0;list1[i] && list2[i];i++) {
if (strcmp(list1[i], list2[i]) != 0) {
- return False;
+ return false;
}
}
if (list1[i] || list2[i]) {
- return False;
+ return false;
}
- return True;
+ return true;
}
/**
- return True if a string is in a list
+ return true if a string is in a list
*/
-_PUBLIC_ BOOL str_list_check(const char **list, const char *s)
+_PUBLIC_ bool str_list_check(const char **list, const char *s)
{
int i;
for (i=0;list[i];i++) {
- if (strcmp(list[i], s) == 0) return True;
+ if (strcmp(list[i], s) == 0) return true;
}
- return False;
+ return false;
}
/**
- return True if a string is in a list, case insensitively
+ return true if a string is in a list, case insensitively
*/
-_PUBLIC_ BOOL str_list_check_ci(const char **list, const char *s)
+_PUBLIC_ bool str_list_check_ci(const char **list, const char *s)
{
int i;
for (i=0;list[i];i++) {
- if (strcasecmp(list[i], s) == 0) return True;
+ if (strcasecmp(list[i], s) == 0) return true;
}
- return False;
+ return false;
}
/**
Check if a string is part of a list.
**/
-_PUBLIC_ BOOL in_list(const char *s, const char *list, BOOL casesensitive)
+_PUBLIC_ bool in_list(const char *s, const char *list, bool casesensitive)
{
pstring tok;
const char *p=list;
if (!list)
- return(False);
+ return false;
while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
if (casesensitive) {
if (strcmp(tok,s) == 0)
- return(True);
+ return true;
} else {
if (strcasecmp_m(tok,s) == 0)
- return(True);
+ return true;
}
}
- return(False);
+ return false;
}
Output is uint32_t in native byte order.
****************************************************************************/
-BOOL tdb_fetch_uint32_byblob(struct tdb_context *tdb, const char *keyval, size_t len, uint32_t *value)
+bool tdb_fetch_uint32_byblob(struct tdb_context *tdb, const char *keyval, size_t len, uint32_t *value)
{
TDB_DATA key = make_tdb_data(keyval, len);
TDB_DATA data;
data = tdb_fetch(tdb, key);
if (!data.dptr || data.dsize != sizeof(uint32_t)) {
SAFE_FREE(data.dptr);
- return False;
+ return false;
}
*value = IVAL(data.dptr,0);
SAFE_FREE(data.dptr);
- return True;
+ return true;
}
/****************************************************************************
Output is uint32_t in native byte order.
****************************************************************************/
-BOOL tdb_fetch_uint32(struct tdb_context *tdb, const char *keystr, uint32_t *value)
+bool tdb_fetch_uint32(struct tdb_context *tdb, const char *keystr, uint32_t *value)
{
return tdb_fetch_uint32_byblob(tdb, keystr, strlen(keystr) + 1, value);
}
Input is uint32_t in native byte order. Output in tdb is in little-endian.
****************************************************************************/
-BOOL tdb_store_uint32_byblob(struct tdb_context *tdb, const char *keystr, size_t len, uint32_t value)
+bool tdb_store_uint32_byblob(struct tdb_context *tdb, const char *keystr, size_t len, uint32_t value)
{
TDB_DATA key = make_tdb_data(keystr, len);
TDB_DATA data;
uint32_t v_store;
- BOOL ret = True;
+ bool ret = true;
SIVAL(&v_store, 0, value);
data.dptr = (void *)&v_store;
data.dsize = sizeof(uint32_t);
if (tdb_store(tdb, key, data, TDB_REPLACE) == -1)
- ret = False;
+ ret = false;
return ret;
}
Input is uint32_t in native byte order. Output in tdb is in little-endian.
****************************************************************************/
-BOOL tdb_store_uint32(struct tdb_context *tdb, const char *keystr, uint32_t value)
+bool tdb_store_uint32(struct tdb_context *tdb, const char *keystr, uint32_t value)
{
return tdb_store_uint32_byblob(tdb, keystr, strlen(keystr) + 1, value);
}
Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval.
****************************************************************************/
-BOOL tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val)
+bool tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val)
{
uint32_t val;
- BOOL ret = False;
+ bool ret = false;
if (tdb_lock_bystring(tdb, keystr) == -1)
- return False;
+ return false;
if (!tdb_fetch_uint32(tdb, keystr, &val)) {
/* It failed */
if (!tdb_store_uint32(tdb, keystr, val))
goto err_out;
- ret = True;
+ ret = true;
err_out:
git.samba.org / ira / wip.git / commitdiff