mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
r24780: More work allowing libutil to be used by external users.
This commit is contained in:
Jelmer Vernooij
Gerald (Jerry) Carter
parent
1c2729228a
commit
31993cf67b
@ -86,13 +86,11 @@ _PUBLIC_ NTSTATUS gensec_wrap_packets(struct gensec_security *gensec_security,
|
||||
}
|
||||
RSIVAL(out->data, 0, wrapped.length);
|
||||
|
||||
nt_status = data_blob_append(mem_ctx, out, wrapped.data, wrapped.length);
|
||||
|
||||
if (!NT_STATUS_IS_OK(nt_status)) {
|
||||
return nt_status;
|
||||
if (!data_blob_append(mem_ctx, out, wrapped.data, wrapped.length)) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
}
|
||||
*len_processed = unwrapped.length;
|
||||
return nt_status;
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
return gensec_security->ops->wrap_packets(gensec_security, mem_ctx, in, out,
|
||||
len_processed);
|
||||
@ -311,6 +309,7 @@ static NTSTATUS gensec_socket_unwrap(void *private, DATA_BLOB blob)
|
||||
|
||||
if (packet_size != blob.length) {
|
||||
DEBUG(0, ("gensec_socket_unwrap: Did not consume entire packet!\n"));
|
||||
talloc_free(mem_ctx);
|
||||
return NT_STATUS_INTERNAL_ERROR;
|
||||
}
|
||||
|
||||
@ -318,10 +317,14 @@ static NTSTATUS gensec_socket_unwrap(void *private, DATA_BLOB blob)
|
||||
* gensec_socket_recv() and gensec_socket_pending() walk the
|
||||
* linked list */
|
||||
|
||||
nt_status = data_blob_append(gensec_socket, &gensec_socket->read_buffer,
|
||||
unwrapped.data, unwrapped.length);
|
||||
if (!data_blob_append(gensec_socket, &gensec_socket->read_buffer,
|
||||
unwrapped.data, unwrapped.length)) {
|
||||
talloc_free(mem_ctx);
|
||||
return nt_status;
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
talloc_free(mem_ctx);
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
/* when the data is sent, we know we have not been interrupted */
|
||||
|
||||
@ -924,8 +924,7 @@ static int setup_supplemental_field(struct setup_password_fields_io *io)
|
||||
* This is ugly, but we want to generate the same blob as
|
||||
* w2k and w2k3...we should handle this in the idl
|
||||
*/
|
||||
status = data_blob_append(io->ac, &pkb_blob, zero16, sizeof(zero16));
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
if (!data_blob_append(io->ac, &pkb_blob, zero16, sizeof(zero16))) {
|
||||
ldb_oom(io->ac->module->ldb);
|
||||
return LDB_ERR_OPERATIONS_ERROR;
|
||||
}
|
||||
|
||||
@ -4,7 +4,6 @@ lib/talloc/talloc.h: talloc.h
|
||||
lib/util/util.h: util.h
|
||||
lib/util/debug.h: util/debug.h
|
||||
lib/util/mutex.h: util/mutex.h
|
||||
lib/util/util_proto.h: util/proto.h
|
||||
nt_status.h: core/nt_status.h
|
||||
lib/util/byteorder.h: util/byteorder.h
|
||||
lib/util/safe_string.h: util/safe_string.h
|
||||
@ -91,6 +90,8 @@ librpc/gen_ndr/ndr_svcctl.h: dcerpc/ndr_svcctl.h
|
||||
librpc/gen_ndr/ndr_svcctl_c.h: dcerpc/ndr_svcctl_c.h
|
||||
lib/cmdline/popt_common.h: samba/popt.h
|
||||
lib/util/dlinklist.h: dlinklist.h
|
||||
lib/util/data_blob.h: data_blob.h
|
||||
lib/util/time.h: time.h
|
||||
version.h: samba/version.h
|
||||
param/proto.h: param/proto.h
|
||||
param/param.h: param.h
|
||||
|
||||
@ -27,24 +27,10 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* used to hold an arbitrary blob of data */
|
||||
typedef struct datablob {
|
||||
uint8_t *data;
|
||||
size_t length;
|
||||
} DATA_BLOB;
|
||||
|
||||
struct data_blob_list_item {
|
||||
struct data_blob_list_item *prev,*next;
|
||||
DATA_BLOB blob;
|
||||
};
|
||||
|
||||
/* by making struct ldb_val and DATA_BLOB the same, we can simplify
|
||||
a fair bit of code */
|
||||
#define ldb_val datablob
|
||||
|
||||
/* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */
|
||||
typedef uint64_t NTTIME;
|
||||
|
||||
/*
|
||||
we use struct ipv4_addr to avoid having to include all the
|
||||
system networking headers everywhere
|
||||
@ -104,5 +90,4 @@ enum announce_as {/* Types of machine we can announce as. */
|
||||
ANNOUNCE_AS_NT_WORKSTATION=4
|
||||
};
|
||||
|
||||
|
||||
#endif /* _SAMBA_CORE_H */
|
||||
|
||||
@ -98,6 +98,7 @@ static void ldapsrv_process_message(struct ldapsrv_connection *conn,
|
||||
/* build all the replies into a single blob */
|
||||
while (call->replies) {
|
||||
DATA_BLOB b;
|
||||
bool ret;
|
||||
|
||||
msg = call->replies->msg;
|
||||
if (!ldap_encode(msg, &b, call)) {
|
||||
@ -106,12 +107,12 @@ static void ldapsrv_process_message(struct ldapsrv_connection *conn,
|
||||
return;
|
||||
}
|
||||
|
||||
status = data_blob_append(call, &blob, b.data, b.length);
|
||||
ret = data_blob_append(call, &blob, b.data, b.length);
|
||||
data_blob_free(&b);
|
||||
|
||||
talloc_set_name_const(blob.data, "Outgoing, encoded LDAP packet");
|
||||
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
if (!ret) {
|
||||
talloc_free(call);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -37,6 +37,10 @@
|
||||
* @sa lib/iconv.c
|
||||
*/
|
||||
|
||||
char *unix_charset = NULL;
|
||||
char *dos_charset = NULL;
|
||||
char *display_charset = NULL;
|
||||
|
||||
/**
|
||||
* Return the name of a charset to give to iconv().
|
||||
**/
|
||||
@ -44,9 +48,9 @@ static const char *charset_name(charset_t ch)
|
||||
{
|
||||
switch (ch) {
|
||||
case CH_UTF16: return "UTF-16LE";
|
||||
case CH_UNIX: return lp_unix_charset();
|
||||
case CH_DOS: return lp_dos_charset();
|
||||
case CH_DISPLAY: return lp_display_charset();
|
||||
case CH_UNIX: return unix_charset;
|
||||
case CH_DOS: return dos_charset;
|
||||
case CH_DISPLAY: return display_charset;
|
||||
case CH_UTF8: return "UTF8";
|
||||
case CH_UTF16BE: return "UTF-16BE";
|
||||
default:
|
||||
|
||||
@ -77,4 +77,9 @@ typedef struct {
|
||||
#define strlower(s) strlower_m(s)
|
||||
#define strupper(s) strupper_m(s)
|
||||
|
||||
/* from lib/charset */
|
||||
extern char *dos_charset;
|
||||
extern char *unix_charset;
|
||||
extern char *display_charset;
|
||||
|
||||
#endif /* __CHARSET_H__ */
|
||||
|
||||
@ -281,9 +281,8 @@ _PUBLIC_ void packet_recv(struct packet_context *pc)
|
||||
|
||||
/* possibly expand the partial packet buffer */
|
||||
if (npending + pc->num_read > pc->partial.length) {
|
||||
status = data_blob_realloc(pc, &pc->partial, npending+pc->num_read);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
packet_error(pc, status);
|
||||
if (!data_blob_realloc(pc, &pc->partial, npending+pc->num_read)) {
|
||||
packet_error(pc, NT_STATUS_NO_MEMORY);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -322,9 +321,8 @@ _PUBLIC_ void packet_recv(struct packet_context *pc)
|
||||
|
||||
next_partial:
|
||||
if (pc->partial.length != pc->num_read) {
|
||||
status = data_blob_realloc(pc, &pc->partial, pc->num_read);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
packet_error(pc, status);
|
||||
if (!data_blob_realloc(pc, &pc->partial, pc->num_read)) {
|
||||
packet_error(pc, NT_STATUS_NO_MEMORY);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -361,9 +359,8 @@ next_partial:
|
||||
return;
|
||||
}
|
||||
/* Trunate the blob sent to the caller to only the packet length */
|
||||
status = data_blob_realloc(pc, &blob, pc->packet_size);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
packet_error(pc, status);
|
||||
if (!data_blob_realloc(pc, &blob, pc->packet_size)) {
|
||||
packet_error(pc, NT_STATUS_NO_MEMORY);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
|
||||
@ -2,12 +2,13 @@
|
||||
#VERSION = 0.0.1
|
||||
#SO_VERSION = 0
|
||||
#DESCRIPTION = Generic utility functions
|
||||
PUBLIC_PROTO_HEADER = util_proto.h
|
||||
PUBLIC_HEADERS = util.h \
|
||||
byteorder.h \
|
||||
data_blob.h \
|
||||
debug.h \
|
||||
mutex.h \
|
||||
safe_string.h \
|
||||
time.h \
|
||||
xfile.h
|
||||
OBJ_FILES = xfile.o \
|
||||
debug.o \
|
||||
|
||||
@ -196,38 +196,37 @@ _PUBLIC_ DATA_BLOB data_blob_const(const void *p, size_t length)
|
||||
/**
|
||||
realloc a data_blob
|
||||
**/
|
||||
_PUBLIC_ NTSTATUS data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length)
|
||||
_PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length)
|
||||
{
|
||||
blob->data = talloc_realloc_size(mem_ctx, blob->data, length);
|
||||
NT_STATUS_HAVE_NO_MEMORY(blob->data);
|
||||
if (blob->data == NULL)
|
||||
return false;
|
||||
blob->length = length;
|
||||
return NT_STATUS_OK;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
append some data to a data blob
|
||||
**/
|
||||
_PUBLIC_ NTSTATUS data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
|
||||
_PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
|
||||
const void *p, size_t length)
|
||||
{
|
||||
NTSTATUS status;
|
||||
size_t old_len = blob->length;
|
||||
size_t new_len = old_len + length;
|
||||
if (new_len < length || new_len < old_len) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((const uint8_t *)p + length < (const uint8_t *)p) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
return false;
|
||||
}
|
||||
|
||||
status = data_blob_realloc(mem_ctx, blob, new_len);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
return status;
|
||||
if (!data_blob_realloc(mem_ctx, blob, new_len)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(blob->data + old_len, p, length);
|
||||
return NT_STATUS_OK;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
108
source/lib/util/data_blob.h
Normal file
108
source/lib/util/data_blob.h
Normal file
@ -0,0 +1,108 @@
|
||||
/*
|
||||
Unix SMB/CIFS implementation.
|
||||
DATA BLOB
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef _SAMBA_DATABLOB_H_
|
||||
#define _SAMBA_DATABLOB_H_
|
||||
|
||||
/* used to hold an arbitrary blob of data */
|
||||
typedef struct datablob {
|
||||
uint8_t *data;
|
||||
size_t length;
|
||||
} DATA_BLOB;
|
||||
|
||||
struct data_blob_list_item {
|
||||
struct data_blob_list_item *prev,*next;
|
||||
DATA_BLOB blob;
|
||||
};
|
||||
|
||||
#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__)
|
||||
#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__)
|
||||
#define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__)
|
||||
|
||||
/**
|
||||
construct a data blob, must be freed with data_blob_free()
|
||||
you can pass NULL for p and get a blank data blob
|
||||
**/
|
||||
_PUBLIC_ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name);
|
||||
|
||||
/**
|
||||
construct a data blob, using supplied TALLOC_CTX
|
||||
**/
|
||||
_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name);
|
||||
|
||||
/**
|
||||
reference a data blob, to the supplied TALLOC_CTX.
|
||||
Returns a NULL DATA_BLOB on failure
|
||||
**/
|
||||
_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob);
|
||||
|
||||
/**
|
||||
construct a zero data blob, using supplied TALLOC_CTX.
|
||||
use this sparingly as it initialises data - better to initialise
|
||||
yourself if you want specific data in the blob
|
||||
**/
|
||||
_PUBLIC_ DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length);
|
||||
|
||||
/**
|
||||
free a data blob
|
||||
**/
|
||||
_PUBLIC_ void data_blob_free(DATA_BLOB *d);
|
||||
|
||||
/**
|
||||
clear a DATA_BLOB's contents
|
||||
**/
|
||||
_PUBLIC_ void data_blob_clear(DATA_BLOB *d);
|
||||
|
||||
/**
|
||||
free a data blob and clear its contents
|
||||
**/
|
||||
_PUBLIC_ void data_blob_clear_free(DATA_BLOB *d);
|
||||
|
||||
/**
|
||||
check if two data blobs are equal
|
||||
**/
|
||||
_PUBLIC_ int data_blob_cmp(const DATA_BLOB *d1, const DATA_BLOB *d2);
|
||||
|
||||
/**
|
||||
print the data_blob as hex string
|
||||
**/
|
||||
_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
|
||||
|
||||
/**
|
||||
useful for constructing data blobs in test suites, while
|
||||
avoiding const warnings
|
||||
**/
|
||||
_PUBLIC_ DATA_BLOB data_blob_string_const(const char *str);
|
||||
|
||||
/**
|
||||
* Create a new data blob from const data
|
||||
*/
|
||||
_PUBLIC_ DATA_BLOB data_blob_const(const void *p, size_t length);
|
||||
|
||||
/**
|
||||
realloc a data_blob
|
||||
**/
|
||||
_PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length);
|
||||
|
||||
/**
|
||||
append some data to a data blob
|
||||
**/
|
||||
_PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
|
||||
const void *p, size_t length);
|
||||
|
||||
#endif /* _SAMBA_DATABLOB_H_ */
|
||||
225
source/lib/util/time.h
Normal file
225
source/lib/util/time.h
Normal file
@ -0,0 +1,225 @@
|
||||
/*
|
||||
Unix SMB/CIFS implementation.
|
||||
time utility functions
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef _SAMBA_TIME_H_
|
||||
#define _SAMBA_TIME_H_
|
||||
|
||||
/* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */
|
||||
typedef uint64_t NTTIME;
|
||||
|
||||
/**
|
||||
External access to time_t_min and time_t_max.
|
||||
**/
|
||||
_PUBLIC_ time_t get_time_t_max(void);
|
||||
|
||||
/**
|
||||
a gettimeofday wrapper
|
||||
**/
|
||||
_PUBLIC_ void GetTimeOfDay(struct timeval *tval);
|
||||
|
||||
/**
|
||||
interpret an 8 byte "filetime" structure to a time_t
|
||||
It's originally in "100ns units since jan 1st 1601"
|
||||
**/
|
||||
_PUBLIC_ time_t nt_time_to_unix(NTTIME nt);
|
||||
|
||||
/**
|
||||
put a 8 byte filetime from a time_t
|
||||
This takes GMT as input
|
||||
**/
|
||||
_PUBLIC_ void unix_to_nt_time(NTTIME *nt, time_t t);
|
||||
|
||||
/**
|
||||
check if it's a null unix time
|
||||
**/
|
||||
_PUBLIC_ bool null_time(time_t t);
|
||||
|
||||
/**
|
||||
check if it's a null NTTIME
|
||||
**/
|
||||
_PUBLIC_ bool null_nttime(NTTIME t);
|
||||
|
||||
/**
|
||||
put a dos date into a buffer (time/date format)
|
||||
This takes GMT time and puts local time in the buffer
|
||||
**/
|
||||
_PUBLIC_ void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset);
|
||||
|
||||
/**
|
||||
put a dos date into a buffer (date/time format)
|
||||
This takes GMT time and puts local time in the buffer
|
||||
**/
|
||||
_PUBLIC_ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset);
|
||||
|
||||
/**
|
||||
put a dos 32 bit "unix like" date into a buffer. This routine takes
|
||||
GMT and converts it to LOCAL time before putting it (most SMBs assume
|
||||
localtime for this sort of date)
|
||||
**/
|
||||
_PUBLIC_ void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset);
|
||||
|
||||
/**
|
||||
create a unix date (int GMT) from a dos date (which is actually in
|
||||
localtime)
|
||||
**/
|
||||
_PUBLIC_ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset);
|
||||
|
||||
/**
|
||||
like make_unix_date() but the words are reversed
|
||||
**/
|
||||
_PUBLIC_ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset);
|
||||
|
||||
/**
|
||||
create a unix GMT date from a dos date in 32 bit "unix like" format
|
||||
these generally arrive as localtimes, with corresponding DST
|
||||
**/
|
||||
_PUBLIC_ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset);
|
||||
|
||||
/**
|
||||
return a HTTP/1.0 time string
|
||||
**/
|
||||
_PUBLIC_ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t);
|
||||
|
||||
/**
|
||||
Return the date and time as a string
|
||||
**/
|
||||
_PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t);
|
||||
|
||||
/**
|
||||
return a talloced string representing a NTTIME for human consumption
|
||||
*/
|
||||
_PUBLIC_ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt);
|
||||
|
||||
/**
|
||||
put a NTTIME into a packet
|
||||
*/
|
||||
_PUBLIC_ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t);
|
||||
|
||||
/**
|
||||
pull a NTTIME from a packet
|
||||
*/
|
||||
_PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset);
|
||||
|
||||
/**
|
||||
parse a nttime as a large integer in a string and return a NTTIME
|
||||
*/
|
||||
_PUBLIC_ NTTIME nttime_from_string(const char *s);
|
||||
|
||||
/**
|
||||
return (tv1 - tv2) in microseconds
|
||||
*/
|
||||
_PUBLIC_ int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return a zero timeval
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_zero(void);
|
||||
|
||||
/**
|
||||
return true if a timeval is zero
|
||||
*/
|
||||
_PUBLIC_ bool timeval_is_zero(const struct timeval *tv);
|
||||
|
||||
/**
|
||||
return a timeval for the current time
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_current(void);
|
||||
|
||||
/**
|
||||
return a timeval struct with the given elements
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_set(uint32_t secs, uint32_t usecs);
|
||||
|
||||
/**
|
||||
return a timeval ofs microseconds after tv
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_add(const struct timeval *tv,
|
||||
uint32_t secs, uint32_t usecs);
|
||||
|
||||
/**
|
||||
return the sum of two timeval structures
|
||||
*/
|
||||
struct timeval timeval_sum(const struct timeval *tv1,
|
||||
const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return a timeval secs/usecs into the future
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs);
|
||||
|
||||
/**
|
||||
compare two timeval structures.
|
||||
Return -1 if tv1 < tv2
|
||||
Return 0 if tv1 == tv2
|
||||
Return 1 if tv1 > tv2
|
||||
*/
|
||||
_PUBLIC_ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return true if a timer is in the past
|
||||
*/
|
||||
_PUBLIC_ bool timeval_expired(const struct timeval *tv);
|
||||
|
||||
/**
|
||||
return the number of seconds elapsed between two times
|
||||
*/
|
||||
_PUBLIC_ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return the number of seconds elapsed since a given time
|
||||
*/
|
||||
_PUBLIC_ double timeval_elapsed(const struct timeval *tv);
|
||||
|
||||
/**
|
||||
return the lesser of two timevals
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_min(const struct timeval *tv1,
|
||||
const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return the greater of two timevals
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_max(const struct timeval *tv1,
|
||||
const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
return the difference between two timevals as a timeval
|
||||
if tv1 comes after tv2, then return a zero timeval
|
||||
(this is *tv2 - *tv1)
|
||||
*/
|
||||
_PUBLIC_ struct timeval timeval_until(const struct timeval *tv1,
|
||||
const struct timeval *tv2);
|
||||
|
||||
/**
|
||||
convert a timeval to a NTTIME
|
||||
*/
|
||||
_PUBLIC_ NTTIME timeval_to_nttime(const struct timeval *tv);
|
||||
|
||||
/**
|
||||
convert a NTTIME to a timeval
|
||||
*/
|
||||
_PUBLIC_ void nttime_to_timeval(struct timeval *tv, NTTIME t);
|
||||
|
||||
/**
|
||||
return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
|
||||
*/
|
||||
_PUBLIC_ int get_time_zone(time_t t);
|
||||
|
||||
|
||||
|
||||
#endif /* _SAMBA_TIME_H_ */
|
||||
@ -34,11 +34,12 @@ struct smbsrv_tcon;
|
||||
extern const char *logfile;
|
||||
extern const char *panic_action;
|
||||
|
||||
#include "util/time.h"
|
||||
#include "util/data_blob.h"
|
||||
#include "util/xfile.h"
|
||||
#include "util/debug.h"
|
||||
#include "util/mutex.h"
|
||||
#include "util/byteorder.h"
|
||||
#include "lib/util/util_proto.h"
|
||||
|
||||
/**
|
||||
this is a warning hack. The idea is to use this everywhere that we
|
||||
@ -100,10 +101,6 @@ extern const char *panic_action;
|
||||
*/
|
||||
#define realloc_p(p, type, count) (type *)realloc_array(p, sizeof(type), count)
|
||||
|
||||
#define data_blob(ptr, size) data_blob_named(ptr, size, "DATA_BLOB: "__location__)
|
||||
#define data_blob_talloc(ctx, ptr, size) data_blob_talloc_named(ctx, ptr, size, "DATA_BLOB: "__location__)
|
||||
#define data_blob_dup_talloc(ctx, blob) data_blob_talloc_named(ctx, (blob)->data, (blob)->length, "DATA_BLOB: "__location__)
|
||||
|
||||
#if defined(VALGRIND)
|
||||
#define strlen(x) valgrind_strlen(x)
|
||||
#endif
|
||||
@ -149,4 +146,707 @@ extern const char *panic_action;
|
||||
#define PTR_DIFF(p1,p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* this global variable determines what messages are printed
|
||||
*/
|
||||
_PUBLIC_ void debug_schedule_reopen_logs(void);
|
||||
|
||||
/**
|
||||
the backend for debug messages. Note that the DEBUG() macro has already
|
||||
ensured that the log level has been met before this is called
|
||||
*/
|
||||
_PUBLIC_ void do_debug_header(int level, const char *location, const char *func);
|
||||
|
||||
/**
|
||||
the backend for debug messages. Note that the DEBUG() macro has already
|
||||
ensured that the log level has been met before this is called
|
||||
|
||||
@note You should never have to call this function directly. Call the DEBUG()
|
||||
macro instead.
|
||||
*/
|
||||
_PUBLIC_ void do_debug(const char *format, ...) _PRINTF_ATTRIBUTE(1,2);
|
||||
|
||||
/**
|
||||
reopen the log file (usually called because the log file name might have changed)
|
||||
*/
|
||||
_PUBLIC_ void reopen_logs(void);
|
||||
|
||||
/**
|
||||
control the name of the logfile and whether logging will be to stdout, stderr
|
||||
or a file
|
||||
*/
|
||||
_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
|
||||
|
||||
/**
|
||||
return a string constant containing n tabs
|
||||
no more than 10 tabs are returned
|
||||
*/
|
||||
_PUBLIC_ const char *do_debug_tab(int n);
|
||||
|
||||
/**
|
||||
log suspicious usage - print comments and backtrace
|
||||
*/
|
||||
_PUBLIC_ void log_suspicious_usage(const char *from, const char *info);
|
||||
|
||||
/**
|
||||
print suspicious usage - print comments and backtrace
|
||||
*/
|
||||
_PUBLIC_ void print_suspicious_usage(const char* from, const char* info);
|
||||
_PUBLIC_ uint32_t get_task_id(void);
|
||||
_PUBLIC_ void log_task_id(void);
|
||||
|
||||
/**
|
||||
register a set of debug handlers.
|
||||
*/
|
||||
_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
|
||||
|
||||
/* The following definitions come from lib/util/fault.c */
|
||||
|
||||
|
||||
/**
|
||||
* Write backtrace to debug log
|
||||
*/
|
||||
_PUBLIC_ void call_backtrace(void);
|
||||
|
||||
/**
|
||||
Something really nasty happened - panic !
|
||||
**/
|
||||
_PUBLIC_ _NORETURN_ void smb_panic(const char *why);
|
||||
|
||||
/**
|
||||
setup our fault handlers
|
||||
**/
|
||||
_PUBLIC_ void fault_setup(const char *pname);
|
||||
|
||||
/**
|
||||
register a fault handler.
|
||||
Should only be called once in the execution of smbd.
|
||||
*/
|
||||
_PUBLIC_ bool register_fault_handler(const char *name, void (*fault_handler)(int sig));
|
||||
|
||||
/* The following definitions come from lib/util/signal.c */
|
||||
|
||||
|
||||
/**
|
||||
Block sigs.
|
||||
**/
|
||||
void BlockSignals(bool block, int signum);
|
||||
|
||||
/**
|
||||
Catch a signal. This should implement the following semantics:
|
||||
|
||||
1) The handler remains installed after being called.
|
||||
2) The signal should be blocked during handler execution.
|
||||
**/
|
||||
void (*CatchSignal(int signum,void (*handler)(int )))(int);
|
||||
|
||||
/**
|
||||
Ignore SIGCLD via whatever means is necessary for this OS.
|
||||
**/
|
||||
void CatchChild(void);
|
||||
|
||||
/**
|
||||
Catch SIGCLD but leave the child around so it's status can be reaped.
|
||||
**/
|
||||
void CatchChildLeaveStatus(void);
|
||||
|
||||
/* The following definitions come from lib/util/system.c */
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
A wrapper for gethostbyname() that tries avoids looking up hostnames
|
||||
in the root domain, which can cause dial-on-demand links to come up for no
|
||||
apparent reason.
|
||||
****************************************************************************/
|
||||
_PUBLIC_ struct hostent *sys_gethostbyname(const char *name);
|
||||
_PUBLIC_ const char *sys_inet_ntoa(struct ipv4_addr in);
|
||||
_PUBLIC_ struct ipv4_addr sys_inet_makeaddr(int net, int host);
|
||||
|
||||
/* The following definitions come from lib/util/genrand.c */
|
||||
|
||||
/**
|
||||
Copy any user given reseed data.
|
||||
**/
|
||||
_PUBLIC_ void set_rand_reseed_callback(void (*fn)(int *));
|
||||
|
||||
/**
|
||||
* Tell the random number generator it needs to reseed.
|
||||
*/
|
||||
_PUBLIC_ void set_need_random_reseed(void);
|
||||
|
||||
/**
|
||||
Interface to the (hopefully) good crypto random number generator.
|
||||
**/
|
||||
_PUBLIC_ void generate_random_buffer(uint8_t *out, int len);
|
||||
|
||||
/**
|
||||
generate a single random uint32_t
|
||||
**/
|
||||
_PUBLIC_ uint32_t generate_random(void);
|
||||
|
||||
/**
|
||||
very basic password quality checker
|
||||
**/
|
||||
_PUBLIC_ bool check_password_quality(const char *s);
|
||||
|
||||
/**
|
||||
Use the random number generator to generate a random string.
|
||||
**/
|
||||
_PUBLIC_ char *generate_random_str_list(TALLOC_CTX *mem_ctx, size_t len, const char *list);
|
||||
|
||||
/**
|
||||
* Generate a random text string consisting of the specified length.
|
||||
* The returned string will be allocated.
|
||||
*
|
||||
* Characters used are: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,
|
||||
*/
|
||||
_PUBLIC_ char *generate_random_str(TALLOC_CTX *mem_ctx, size_t len);
|
||||
|
||||
/* The following definitions come from lib/util/dprintf.c */
|
||||
|
||||
_PUBLIC_ int d_vfprintf(FILE *f, const char *format, va_list ap) _PRINTF_ATTRIBUTE(2,0);
|
||||
_PUBLIC_ int d_fprintf(FILE *f, const char *format, ...) _PRINTF_ATTRIBUTE(2,3);
|
||||
_PUBLIC_ int d_printf(const char *format, ...) _PRINTF_ATTRIBUTE(1,2);
|
||||
_PUBLIC_ void display_set_stderr(void);
|
||||
|
||||
/* The following definitions come from lib/util/util_str.c */
|
||||
|
||||
|
||||
/**
|
||||
Trim the specified elements off the front and back of a string.
|
||||
**/
|
||||
_PUBLIC_ bool trim_string(char *s, const char *front, const char *back);
|
||||
|
||||
/**
|
||||
Find the number of 'c' chars in a string
|
||||
**/
|
||||
_PUBLIC_ _PURE_ size_t count_chars(const char *s, char c);
|
||||
|
||||
/**
|
||||
Safe string copy into a known length string. maxlength does not
|
||||
include the terminating zero.
|
||||
**/
|
||||
_PUBLIC_ char *safe_strcpy(char *dest,const char *src, size_t maxlength);
|
||||
|
||||
/**
|
||||
Safe string cat into a string. maxlength does not
|
||||
include the terminating zero.
|
||||
**/
|
||||
_PUBLIC_ char *safe_strcat(char *dest, const char *src, size_t maxlength);
|
||||
|
||||
/**
|
||||
Routine to get hex characters and turn them into a 16 byte array.
|
||||
the array can be variable length, and any non-hex-numeric
|
||||
characters are skipped. "0xnn" or "0Xnn" is specially catered
|
||||
for.
|
||||
|
||||
valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
|
||||
|
||||
|
||||
**/
|
||||
_PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex);
|
||||
|
||||
/**
|
||||
* Parse a hex string and return a data blob.
|
||||
*/
|
||||
_PUBLIC_ _PURE_ DATA_BLOB strhex_to_data_blob(const char *strhex) ;
|
||||
|
||||
/**
|
||||
* Routine to print a buffer as HEX digits, into an allocated string.
|
||||
*/
|
||||
_PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer);
|
||||
|
||||
/**
|
||||
* talloc version of hex_encode()
|
||||
*/
|
||||
_PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len);
|
||||
|
||||
/**
|
||||
Free a string value.
|
||||
**/
|
||||
_PUBLIC_ void string_free(char **s);
|
||||
|
||||
/**
|
||||
Set a string value, deallocating any existing space, and allocing the space
|
||||
for the string
|
||||
**/
|
||||
_PUBLIC_ bool string_set(char **dest, const char *src);
|
||||
|
||||
/**
|
||||
Substitute a string for a pattern in another string. Make sure there is
|
||||
enough room!
|
||||
|
||||
This routine looks for pattern in s and replaces it with
|
||||
insert. It may do multiple replacements.
|
||||
|
||||
Any of " ; ' $ or ` in the insert string are replaced with _
|
||||
if len==0 then the string cannot be extended. This is different from the old
|
||||
use of len==0 which was for no length checks to be done.
|
||||
**/
|
||||
_PUBLIC_ void string_sub(char *s,const char *pattern, const char *insert, size_t len);
|
||||
|
||||
/**
|
||||
Similar to string_sub() but allows for any character to be substituted.
|
||||
Use with caution!
|
||||
if len==0 then the string cannot be extended. This is different from the old
|
||||
use of len==0 which was for no length checks to be done.
|
||||
**/
|
||||
_PUBLIC_ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len);
|
||||
|
||||
/**
|
||||
Unescape a URL encoded string, in place.
|
||||
**/
|
||||
_PUBLIC_ void rfc1738_unescape(char *buf);
|
||||
size_t valgrind_strlen(const char *s);
|
||||
|
||||
/**
|
||||
format a string into length-prefixed dotted domain format, as used in NBT
|
||||
and in some ADS structures
|
||||
**/
|
||||
_PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s);
|
||||
|
||||
/**
|
||||
* Add a string to an array of strings.
|
||||
*
|
||||
* num should be a pointer to an integer that holds the current
|
||||
* number of elements in strings. It will be updated by this function.
|
||||
*/
|
||||
_PUBLIC_ bool add_string_to_array(TALLOC_CTX *mem_ctx,
|
||||
const char *str, const char ***strings, int *num);
|
||||
|
||||
/**
|
||||
varient of strcmp() that handles NULL ptrs
|
||||
**/
|
||||
_PUBLIC_ int strcmp_safe(const char *s1, const char *s2);
|
||||
|
||||
/**
|
||||
return the number of bytes occupied by a buffer in ASCII format
|
||||
the result includes the null termination
|
||||
limited by 'n' bytes
|
||||
**/
|
||||
_PUBLIC_ size_t ascii_len_n(const char *src, size_t n);
|
||||
|
||||
/**
|
||||
Return a string representing a CIFS attribute for a file.
|
||||
**/
|
||||
_PUBLIC_ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib);
|
||||
|
||||
/**
|
||||
Set a boolean variable from the text value stored in the passed string.
|
||||
Returns true in success, false if the passed string does not correctly
|
||||
represent a boolean.
|
||||
**/
|
||||
_PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean);
|
||||
|
||||
/**
|
||||
* Parse a string containing a boolean value.
|
||||
*
|
||||
* val will be set to the read value.
|
||||
*
|
||||
* @retval true if a boolean value was parsed, false otherwise.
|
||||
*/
|
||||
_PUBLIC_ bool conv_str_bool(const char * str, bool * val);
|
||||
|
||||
/**
|
||||
* Convert a size specification like 16K into an integral number of bytes.
|
||||
**/
|
||||
_PUBLIC_ bool conv_str_size(const char * str, uint64_t * val);
|
||||
|
||||
/**
|
||||
* Parse a uint64_t value from a string
|
||||
*
|
||||
* val will be set to the value read.
|
||||
*
|
||||
* @retval true if parsing was successful, false otherwise
|
||||
*/
|
||||
_PUBLIC_ bool conv_str_u64(const char * str, uint64_t * val);
|
||||
|
||||
/**
|
||||
return the number of bytes occupied by a buffer in CH_UTF16 format
|
||||
the result includes the null termination
|
||||
**/
|
||||
_PUBLIC_ size_t utf16_len(const void *buf);
|
||||
|
||||
/**
|
||||
return the number of bytes occupied by a buffer in CH_UTF16 format
|
||||
the result includes the null termination
|
||||
limited by 'n' bytes
|
||||
**/
|
||||
_PUBLIC_ size_t utf16_len_n(const void *src, size_t n);
|
||||
_PUBLIC_ size_t ucs2_align(const void *base_ptr, const void *p, int flags);
|
||||
|
||||
/**
|
||||
Do a case-insensitive, whitespace-ignoring string compare.
|
||||
**/
|
||||
_PUBLIC_ int strwicmp(const char *psz1, const char *psz2);
|
||||
|
||||
/**
|
||||
String replace.
|
||||
**/
|
||||
_PUBLIC_ void string_replace(char *s, char oldc, char newc);
|
||||
|
||||
/**
|
||||
* Compare 2 strings.
|
||||
*
|
||||
* @note The comparison is case-insensitive.
|
||||
**/
|
||||
_PUBLIC_ bool strequal(const char *s1, const char *s2);
|
||||
|
||||
/* The following definitions come from lib/util/util_strlist.c */
|
||||
|
||||
|
||||
/**
|
||||
build a null terminated list of strings from a input string and a
|
||||
separator list. The separator list must contain characters less than
|
||||
or equal to 0x2f for this to work correctly on multi-byte strings
|
||||
*/
|
||||
_PUBLIC_ const char **str_list_make(TALLOC_CTX *mem_ctx, const char *string, const char *sep);
|
||||
|
||||
/**
|
||||
* build a null terminated list of strings from an argv-like input string
|
||||
* Entries are seperated by spaces and can be enclosed by quotes.
|
||||
* Does NOT support escaping
|
||||
*/
|
||||
_PUBLIC_ const char **str_list_make_shell(TALLOC_CTX *mem_ctx, const char *string, const char *sep);
|
||||
|
||||
/**
|
||||
* join a list back to one string
|
||||
*/
|
||||
_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator);
|
||||
|
||||
/** join a list back to one (shell-like) string; entries
|
||||
* seperated by spaces, using quotes where necessary */
|
||||
_PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep);
|
||||
|
||||
/**
|
||||
return the number of elements in a string list
|
||||
*/
|
||||
_PUBLIC_ size_t str_list_length(const char **list);
|
||||
|
||||
/**
|
||||
copy a string list
|
||||
*/
|
||||
_PUBLIC_ const char **str_list_copy(TALLOC_CTX *mem_ctx, const char **list);
|
||||
|
||||
/**
|
||||
Return true if all the elements of the list match exactly.
|
||||
*/
|
||||
_PUBLIC_ bool str_list_equal(const char **list1, const char **list2);
|
||||
|
||||
/**
|
||||
add an entry to a string list
|
||||
*/
|
||||
_PUBLIC_ const char **str_list_add(const char **list, const char *s);
|
||||
|
||||
/**
|
||||
remove an entry from a string list
|
||||
*/
|
||||
_PUBLIC_ void str_list_remove(const char **list, const char *s);
|
||||
|
||||
/**
|
||||
return true if a string is in a list
|
||||
*/
|
||||
_PUBLIC_ bool str_list_check(const char **list, const char *s);
|
||||
|
||||
/**
|
||||
return true if a string is in a list, case insensitively
|
||||
*/
|
||||
_PUBLIC_ bool str_list_check_ci(const char **list, const char *s);
|
||||
|
||||
/**
|
||||
Check if a string is part of a list.
|
||||
**/
|
||||
_PUBLIC_ bool in_list(const char *s, const char *list, bool casesensitive);
|
||||
|
||||
/* The following definitions come from lib/util/util_file.c */
|
||||
|
||||
|
||||
/**
|
||||
read a line from a file with possible \ continuation chars.
|
||||
Blanks at the start or end of a line are stripped.
|
||||
The string will be allocated if s2 is NULL
|
||||
**/
|
||||
_PUBLIC_ char *fgets_slash(char *s2,int maxlen,XFILE *f);
|
||||
|
||||
/**
|
||||
* Read one line (data until next newline or eof) and allocate it
|
||||
*/
|
||||
_PUBLIC_ char *afdgets(int fd, TALLOC_CTX *mem_ctx, size_t hint);
|
||||
|
||||
/**
|
||||
load a file into memory from a fd.
|
||||
**/
|
||||
_PUBLIC_ char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx);
|
||||
|
||||
/**
|
||||
load a file into memory
|
||||
**/
|
||||
_PUBLIC_ char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx);
|
||||
|
||||
/**
|
||||
mmap (if possible) or read a file
|
||||
**/
|
||||
_PUBLIC_ void *map_file(const char *fname, size_t size);
|
||||
|
||||
/**
|
||||
load a file into memory and return an array of pointers to lines in the file
|
||||
must be freed with talloc_free().
|
||||
**/
|
||||
_PUBLIC_ char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx);
|
||||
|
||||
/**
|
||||
load a fd into memory and return an array of pointers to lines in the file
|
||||
must be freed with talloc_free(). If convert is true calls unix_to_dos on
|
||||
the list.
|
||||
**/
|
||||
_PUBLIC_ char **fd_lines_load(int fd, int *numlines, TALLOC_CTX *mem_ctx);
|
||||
|
||||
/**
|
||||
take a list of lines and modify them to produce a list where \ continues
|
||||
a line
|
||||
**/
|
||||
_PUBLIC_ void file_lines_slashcont(char **lines);
|
||||
|
||||
/**
|
||||
save a lump of data into a file. Mostly used for debugging
|
||||
*/
|
||||
_PUBLIC_ bool file_save(const char *fname, const void *packet, size_t length);
|
||||
_PUBLIC_ int vfdprintf(int fd, const char *format, va_list ap) _PRINTF_ATTRIBUTE(2,0);
|
||||
_PUBLIC_ int fdprintf(int fd, const char *format, ...) _PRINTF_ATTRIBUTE(2,3);
|
||||
_PUBLIC_ bool large_file_support(const char *path);
|
||||
|
||||
/* The following definitions come from lib/util/util.c */
|
||||
|
||||
|
||||
/**
|
||||
Find a suitable temporary directory. The result should be copied immediately
|
||||
as it may be overwritten by a subsequent call.
|
||||
**/
|
||||
_PUBLIC_ const char *tmpdir(void);
|
||||
|
||||
/**
|
||||
Check if a file exists - call vfs_file_exist for samba files.
|
||||
**/
|
||||
_PUBLIC_ bool file_exist(const char *fname);
|
||||
|
||||
/**
|
||||
Check a files mod time.
|
||||
**/
|
||||
_PUBLIC_ time_t file_modtime(const char *fname);
|
||||
|
||||
/**
|
||||
Check if a directory exists.
|
||||
**/
|
||||
_PUBLIC_ bool directory_exist(const char *dname);
|
||||
|
||||
/**
|
||||
* Try to create the specified directory if it didn't exist.
|
||||
*
|
||||
* @retval true if the directory already existed and has the right permissions
|
||||
* or was successfully created.
|
||||
*/
|
||||
_PUBLIC_ bool directory_create_or_exist(const char *dname, uid_t uid,
|
||||
mode_t dir_perms);
|
||||
|
||||
/**
|
||||
Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
|
||||
else
|
||||
if SYSV use O_NDELAY
|
||||
if BSD use FNDELAY
|
||||
**/
|
||||
_PUBLIC_ int set_blocking(int fd, bool set);
|
||||
|
||||
/**
|
||||
Sleep for a specified number of milliseconds.
|
||||
**/
|
||||
_PUBLIC_ void msleep(unsigned int t);
|
||||
|
||||
/**
|
||||
Get my own name, return in malloc'ed storage.
|
||||
**/
|
||||
_PUBLIC_ char* get_myname(void);
|
||||
|
||||
/**
|
||||
Return true if a string could be a pure IP address.
|
||||
**/
|
||||
_PUBLIC_ bool is_ipaddress(const char *str);
|
||||
|
||||
/**
|
||||
Interpret an internet address or name into an IP address in 4 byte form.
|
||||
**/
|
||||
_PUBLIC_ uint32_t interpret_addr(const char *str);
|
||||
|
||||
/**
|
||||
A convenient addition to interpret_addr().
|
||||
**/
|
||||
_PUBLIC_ struct ipv4_addr interpret_addr2(const char *str);
|
||||
|
||||
/**
|
||||
Check if an IP is the 0.0.0.0.
|
||||
**/
|
||||
_PUBLIC_ bool is_zero_ip(struct ipv4_addr ip);
|
||||
|
||||
/**
|
||||
Are two IPs on the same subnet?
|
||||
**/
|
||||
_PUBLIC_ bool same_net(struct ipv4_addr ip1,struct ipv4_addr ip2,struct ipv4_addr mask);
|
||||
|
||||
/**
|
||||
Check if a process exists. Does this work on all unixes?
|
||||
**/
|
||||
_PUBLIC_ bool process_exists(pid_t pid);
|
||||
|
||||
/**
|
||||
Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
|
||||
is dealt with in posix.c
|
||||
**/
|
||||
_PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type);
|
||||
|
||||
/**
|
||||
* Write dump of binary data to the log file.
|
||||
*
|
||||
* The data is only written if the log level is at least level.
|
||||
*/
|
||||
_PUBLIC_ void dump_data(int level, const uint8_t *buf,int len);
|
||||
|
||||
/**
|
||||
malloc that aborts with smb_panic on fail or zero size.
|
||||
**/
|
||||
_PUBLIC_ void *smb_xmalloc(size_t size);
|
||||
|
||||
/**
|
||||
Memdup with smb_panic on fail.
|
||||
**/
|
||||
_PUBLIC_ void *smb_xmemdup(const void *p, size_t size);
|
||||
|
||||
/**
|
||||
strdup that aborts on malloc fail.
|
||||
**/
|
||||
_PUBLIC_ char *smb_xstrdup(const char *s);
|
||||
|
||||
/**
|
||||
Like strdup but for memory.
|
||||
**/
|
||||
_PUBLIC_ void *memdup(const void *p, size_t size);
|
||||
|
||||
/**
|
||||
* Write a password to the log file.
|
||||
*
|
||||
* @note Only actually does something if DEBUG_PASSWORD was defined during
|
||||
* compile-time.
|
||||
*/
|
||||
_PUBLIC_ void dump_data_pw(const char *msg, const uint8_t * data, size_t len);
|
||||
|
||||
/**
|
||||
* see if a range of memory is all zero. A NULL pointer is considered
|
||||
* to be all zero
|
||||
*/
|
||||
_PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size);
|
||||
|
||||
/**
|
||||
realloc an array, checking for integer overflow in the array size
|
||||
*/
|
||||
_PUBLIC_ void *realloc_array(void *ptr, size_t el_size, unsigned count);
|
||||
|
||||
/* The following definitions come from lib/util/fsusage.c */
|
||||
|
||||
|
||||
/**
|
||||
* Retrieve amount of free disk space.
|
||||
* this does all of the system specific guff to get the free disk space.
|
||||
* It is derived from code in the GNU fileutils package, but has been
|
||||
* considerably mangled for use here
|
||||
*
|
||||
* results are returned in *dfree and *dsize, in 512 byte units
|
||||
*/
|
||||
_PUBLIC_ int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize);
|
||||
|
||||
/* The following definitions come from lib/util/ms_fnmatch.c */
|
||||
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief MS-style Filename matching
|
||||
*/
|
||||
int ms_fnmatch(const char *pattern, const char *string, enum protocol_types protocol);
|
||||
|
||||
/** a generic fnmatch function - uses for non-CIFS pattern matching */
|
||||
int gen_fnmatch(const char *pattern, const char *string);
|
||||
|
||||
/* The following definitions come from lib/util/mutex.c */
|
||||
|
||||
|
||||
/**
|
||||
register a set of mutex/rwlock handlers.
|
||||
Should only be called once in the execution of smbd.
|
||||
*/
|
||||
_PUBLIC_ bool register_mutex_handlers(const char *name, struct mutex_ops *ops);
|
||||
|
||||
/* The following definitions come from lib/util/idtree.c */
|
||||
|
||||
|
||||
/**
|
||||
initialise a idr tree. The context return value must be passed to
|
||||
all subsequent idr calls. To destroy the idr tree use talloc_free()
|
||||
on this context
|
||||
*/
|
||||
_PUBLIC_ struct idr_context *idr_init(TALLOC_CTX *mem_ctx);
|
||||
|
||||
/**
|
||||
allocate the next available id, and assign 'ptr' into its slot.
|
||||
you can retrieve later this pointer using idr_find()
|
||||
*/
|
||||
_PUBLIC_ int idr_get_new(struct idr_context *idp, void *ptr, int limit);
|
||||
|
||||
/**
|
||||
allocate a new id, giving the first available value greater than or
|
||||
equal to the given starting id
|
||||
*/
|
||||
_PUBLIC_ int idr_get_new_above(struct idr_context *idp, void *ptr, int starting_id, int limit);
|
||||
|
||||
/**
|
||||
allocate a new id randomly in the given range
|
||||
*/
|
||||
_PUBLIC_ int idr_get_new_random(struct idr_context *idp, void *ptr, int limit);
|
||||
|
||||
/**
|
||||
find a pointer value previously set with idr_get_new given an id
|
||||
*/
|
||||
_PUBLIC_ void *idr_find(struct idr_context *idp, int id);
|
||||
|
||||
/**
|
||||
remove an id from the idr tree
|
||||
*/
|
||||
_PUBLIC_ int idr_remove(struct idr_context *idp, int id);
|
||||
|
||||
/* The following definitions come from lib/util/module.c */
|
||||
|
||||
|
||||
/**
|
||||
* Obtain the init function from a shared library file
|
||||
*/
|
||||
_PUBLIC_ init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path);
|
||||
|
||||
/**
|
||||
* Obtain list of init functions from the modules in the specified
|
||||
* directory
|
||||
*/
|
||||
_PUBLIC_ init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path);
|
||||
|
||||
/**
|
||||
* Run the specified init functions.
|
||||
*
|
||||
* @return true if all functions ran successfully, false otherwise
|
||||
*/
|
||||
_PUBLIC_ bool run_init_functions(NTSTATUS (**fns) (void));
|
||||
|
||||
/* The following definitions come from lib/util/become_daemon.c */
|
||||
|
||||
|
||||
/**
|
||||
Become a daemon, discarding the controlling terminal.
|
||||
**/
|
||||
_PUBLIC_ void become_daemon(bool Fork);
|
||||
|
||||
#endif /* _SAMBA_UTIL_H_ */
|
||||
|
||||
@ -45,4 +45,55 @@ extern XFILE *x_stdin, *x_stdout, *x_stderr;
|
||||
|
||||
int x_vfprintf(XFILE *f, const char *format, va_list ap) PRINTF_ATTRIBUTE(2, 0);
|
||||
int x_fprintf(XFILE *f, const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
|
||||
|
||||
/** simulate setvbuf() */
|
||||
int x_setvbuf(XFILE *f, char *buf, int mode, size_t size);
|
||||
|
||||
/** this looks more like open() than fopen(), but that is quite deliberate.
|
||||
I want programmers to *think* about O_EXCL, O_CREAT etc not just
|
||||
get them magically added
|
||||
*/
|
||||
XFILE *x_fopen(const char *fname, int flags, mode_t mode);
|
||||
|
||||
/** simulate fclose() */
|
||||
int x_fclose(XFILE *f);
|
||||
|
||||
/** simulate fwrite() */
|
||||
size_t x_fwrite(const void *p, size_t size, size_t nmemb, XFILE *f);
|
||||
|
||||
/** thank goodness for asprintf() */
|
||||
int x_fileno(XFILE *f);
|
||||
|
||||
/** simulate fflush() */
|
||||
int x_fflush(XFILE *f);
|
||||
|
||||
/** simulate setbuffer() */
|
||||
void x_setbuffer(XFILE *f, char *buf, size_t size);
|
||||
|
||||
/** simulate setbuf() */
|
||||
void x_setbuf(XFILE *f, char *buf);
|
||||
|
||||
/** simulate setlinebuf() */
|
||||
void x_setlinebuf(XFILE *f);
|
||||
|
||||
/** simulate feof() */
|
||||
int x_feof(XFILE *f);
|
||||
|
||||
/** simulate ferror() */
|
||||
int x_ferror(XFILE *f);
|
||||
|
||||
/** simulate fgetc() */
|
||||
int x_fgetc(XFILE *f);
|
||||
|
||||
/** simulate fread */
|
||||
size_t x_fread(void *p, size_t size, size_t nmemb, XFILE *f);
|
||||
|
||||
/** simulate fgets() */
|
||||
char *x_fgets(char *s, int size, XFILE *stream) ;
|
||||
|
||||
/**
|
||||
* trivial seek, works only for SEEK_SET and SEEK_END if SEEK_CUR is
|
||||
* set then an error is returned */
|
||||
off_t x_tseek(XFILE *f, off_t offset, int whence);
|
||||
|
||||
#endif /* _XFILE_H_ */
|
||||
|
||||
@ -34,11 +34,10 @@ NTSTATUS smb2_create_blob_add(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
|
||||
uint32_t tag,
|
||||
DATA_BLOB add, BOOL last)
|
||||
{
|
||||
NTSTATUS status;
|
||||
uint32_t ofs = blob->length;
|
||||
uint8_t pad = smb2_padding_size(add.length, 8);
|
||||
status = data_blob_realloc(mem_ctx, blob, blob->length + 0x18 + add.length + pad);
|
||||
NT_STATUS_NOT_OK_RETURN(status);
|
||||
if (!data_blob_realloc(mem_ctx, blob, blob->length + 0x18 + add.length + pad))
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
|
||||
if (last) {
|
||||
SIVAL(blob->data, ofs+0x00, 0);
|
||||
|
||||
@ -429,10 +429,9 @@ static NTSTATUS ncacn_push_request_sign(struct dcerpc_connection *c,
|
||||
return status;
|
||||
}
|
||||
blob->length -= c->security_state.auth_info->credentials.length;
|
||||
status = data_blob_append(mem_ctx, blob,
|
||||
creds2.data, creds2.length);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
return status;
|
||||
if (!data_blob_append(mem_ctx, blob,
|
||||
creds2.data, creds2.length)) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
}
|
||||
dcerpc_set_auth_length(blob, creds2.length);
|
||||
if (c->security_state.auth_info->credentials.length == 0) {
|
||||
@ -457,10 +456,9 @@ static NTSTATUS ncacn_push_request_sign(struct dcerpc_connection *c,
|
||||
return status;
|
||||
}
|
||||
blob->length -= c->security_state.auth_info->credentials.length;
|
||||
status = data_blob_append(mem_ctx, blob,
|
||||
creds2.data, creds2.length);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
return status;
|
||||
if (!data_blob_append(mem_ctx, blob,
|
||||
creds2.data, creds2.length)) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
}
|
||||
dcerpc_set_auth_length(blob, creds2.length);
|
||||
if (c->security_state.auth_info->credentials.length == 0) {
|
||||
|
||||
@ -92,10 +92,9 @@ static void smb2_read_callback(struct smb2_request *req)
|
||||
return;
|
||||
}
|
||||
|
||||
status = data_blob_append(state, &state->data,
|
||||
io.out.data.data, io.out.data.length);
|
||||
if (NT_STATUS_IS_ERR(status)) {
|
||||
pipe_dead(state->c, status);
|
||||
if (!data_blob_append(state, &state->data,
|
||||
io.out.data.data, io.out.data.length)) {
|
||||
pipe_dead(state->c, NT_STATUS_NO_MEMORY);
|
||||
talloc_free(state);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -76,7 +76,6 @@ static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...);
|
||||
|
||||
static BOOL defaults_saved = False;
|
||||
|
||||
|
||||
struct param_opt {
|
||||
struct param_opt *prev, *next;
|
||||
char *key;
|
||||
@ -92,10 +91,7 @@ typedef struct
|
||||
int server_role;
|
||||
|
||||
char **smb_ports;
|
||||
char *dos_charset;
|
||||
char *unix_charset;
|
||||
char *ncalrpc_dir;
|
||||
char *display_charset;
|
||||
char *szLockDir;
|
||||
char *szModulesDir;
|
||||
char *szPidDir;
|
||||
@ -383,10 +379,10 @@ static struct parm_struct parm_table[] = {
|
||||
|
||||
{"server role", P_ENUM, P_GLOBAL, &Globals.server_role, NULL, enum_server_role, FLAG_BASIC},
|
||||
|
||||
{"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"dos charset", P_STRING, P_GLOBAL, &dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"unix charset", P_STRING, P_GLOBAL, &unix_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"ncalrpc dir", P_STRING, P_GLOBAL, &Globals.ncalrpc_dir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"display charset", P_STRING, P_GLOBAL, &display_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
|
||||
{"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
|
||||
{"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
|
||||
{"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
|
||||
@ -841,7 +837,7 @@ _PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, &Globals.cldap_port)
|
||||
_PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, &Globals.krb5_port)
|
||||
_PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, &Globals.kpasswd_port)
|
||||
_PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, &Globals.web_port)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, &dos_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_webapps_directory, &Globals.webapps_directory)
|
||||
_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, &Globals.tls_enabled)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_tls_keyfile, &Globals.tls_keyfile)
|
||||
@ -849,8 +845,8 @@ _PUBLIC_ FN_GLOBAL_STRING(lp_tls_certfile, &Globals.tls_certfile)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_tls_cafile, &Globals.tls_cafile)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_tls_crlfile, &Globals.tls_crlfile)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_tls_dhpfile, &Globals.tls_dhpfile)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, &unix_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, &display_charset)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, &Globals.szShareBackend)
|
||||
_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, &Globals.szSAM_URL)
|
||||
|
||||
@ -471,7 +471,10 @@ BOOL dcesrv_auth_response(struct dcesrv_call_state *call,
|
||||
|
||||
if (NT_STATUS_IS_OK(status)) {
|
||||
blob->length -= dce_conn->auth_state.auth_info->credentials.length;
|
||||
status = data_blob_append(call, blob, creds2.data, creds2.length);
|
||||
if (!data_blob_append(call, blob, creds2.data, creds2.length))
|
||||
status = NT_STATUS_NO_MEMORY;
|
||||
else
|
||||
status = NT_STATUS_OK;
|
||||
}
|
||||
|
||||
/* If we did AEAD signing of the packet headers, then we hope
|
||||
@ -491,7 +494,10 @@ BOOL dcesrv_auth_response(struct dcesrv_call_state *call,
|
||||
&creds2);
|
||||
if (NT_STATUS_IS_OK(status)) {
|
||||
blob->length -= dce_conn->auth_state.auth_info->credentials.length;
|
||||
status = data_blob_append(call, blob, creds2.data, creds2.length);
|
||||
if (!data_blob_append(call, blob, creds2.data, creds2.length))
|
||||
status = NT_STATUS_NO_MEMORY;
|
||||
else
|
||||
status = NT_STATUS_OK;
|
||||
}
|
||||
|
||||
/* If we did AEAD signing of the packet headers, then we hope
|
||||
|
||||
@ -196,9 +196,8 @@ static int http_mapToStorage(EspHandle handle, char *path, int len, const char *
|
||||
static int http_writeBlock(EspHandle handle, const char *buf, int size)
|
||||
{
|
||||
struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
|
||||
NTSTATUS status;
|
||||
status = data_blob_append(web, &web->output.content, buf, size);
|
||||
if (!NT_STATUS_IS_OK(status)) return -1;
|
||||
if (!data_blob_append(web, &web->output.content, buf, size))
|
||||
return -1;
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
@ -78,8 +78,8 @@ static void websrv_recv(struct stream_connection *conn, uint16_t flags)
|
||||
if (NT_STATUS_IS_ERR(status)) goto failed;
|
||||
if (!NT_STATUS_IS_OK(status)) return;
|
||||
|
||||
status = data_blob_append(web, &web->input.partial, buf, nread);
|
||||
if (!NT_STATUS_IS_OK(status)) goto failed;
|
||||
if (!data_blob_append(web, &web->input.partial, buf, nread))
|
||||
goto failed;
|
||||
|
||||
/* parse any lines that are available */
|
||||
b = web->input.partial;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user