}
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);
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;
}
* 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_NO_MEMORY;
+ }
+
talloc_free(mem_ctx);
- return nt_status;
+ return NT_STATUS_OK;
}
/* when the data is sent, we know we have not been interrupted */
* 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;
}
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
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
#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
ANNOUNCE_AS_NT_WORKSTATION=4
};
-
#endif /* _SAMBA_CORE_H */
/* 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)) {
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;
}
* @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().
**/
{
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:
#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__ */
/* 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;
}
}
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;
}
}
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 {
#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 \
/**
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;
}
--- /dev/null
+/*
+ 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_ */
--- /dev/null
+/*
+ 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_ */
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
*/
#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
#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_ */
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_ */
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);
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) {
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) {
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;
}
static BOOL defaults_saved = False;
-
struct param_opt {
struct param_opt *prev, *next;
char *key;
int server_role;
char **smb_ports;
- char *dos_charset;
- char *unix_charset;
char *ncalrpc_dir;
- char *display_charset;
char *szLockDir;
char *szModulesDir;
char *szPidDir;
int bLanmanAuth;
int bNTLMAuth;
int bUseSpnego;
- int server_signing;
- int client_signing;
+ int server_signing;
+ int client_signing;
int bClientPlaintextAuth;
int bClientLanManAuth;
int bClientNTLMv2Auth;
{"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},
_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)
_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)
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
&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
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;
}
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;
git.samba.org / kai / samba.git / commitdiff