diff options
| -rw-r--r-- | source4/auth/gensec/socket.c | 19 | ||||
| -rw-r--r-- | source4/dsdb/samdb/ldb_modules/password_hash.c | 3 | ||||
| -rw-r--r-- | source4/headermap.txt | 3 | ||||
| -rw-r--r-- | source4/include/core.h | 15 | ||||
| -rw-r--r-- | source4/ldap_server/ldap_server.c | 5 | ||||
| -rw-r--r-- | source4/lib/charset/charcnv.c | 10 | ||||
| -rw-r--r-- | source4/lib/charset/charset.h | 5 | ||||
| -rw-r--r-- | source4/lib/stream/packet.c | 15 | ||||
| -rw-r--r-- | source4/lib/util/config.mk | 3 | ||||
| -rw-r--r-- | source4/lib/util/data_blob.c | 21 | ||||
| -rw-r--r-- | source4/lib/util/data_blob.h | 108 | ||||
| -rw-r--r-- | source4/lib/util/time.h | 225 | ||||
| -rw-r--r-- | source4/lib/util/util.h | 710 | ||||
| -rw-r--r-- | source4/lib/util/xfile.h | 51 | ||||
| -rw-r--r-- | source4/libcli/smb2/create.c | 5 | ||||
| -rw-r--r-- | source4/librpc/rpc/dcerpc.c | 14 | ||||
| -rw-r--r-- | source4/librpc/rpc/dcerpc_smb2.c | 7 | ||||
| -rw-r--r-- | source4/param/loadparm.c | 20 | ||||
| -rw-r--r-- | source4/rpc_server/dcesrv_auth.c | 10 | ||||
| -rw-r--r-- | source4/web_server/http.c | 5 | ||||
| -rw-r--r-- | source4/web_server/web_server.c | 4 |
21 files changed, 1167 insertions, 91 deletions
diff --git a/source4/auth/gensec/socket.c b/source4/auth/gensec/socket.c index 257ea7b094..9bd97109fb 100644 --- a/source4/auth/gensec/socket.c +++ b/source4/auth/gensec/socket.c @@ -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_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 */ diff --git a/source4/dsdb/samdb/ldb_modules/password_hash.c b/source4/dsdb/samdb/ldb_modules/password_hash.c index 61e9002439..98061570c8 100644 --- a/source4/dsdb/samdb/ldb_modules/password_hash.c +++ b/source4/dsdb/samdb/ldb_modules/password_hash.c @@ -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; } diff --git a/source4/headermap.txt b/source4/headermap.txt index 1ae677adf8..1b5c2d2d2d 100644 --- a/source4/headermap.txt +++ b/source4/headermap.txt @@ -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 diff --git a/source4/include/core.h b/source4/include/core.h index a31b4c59c7..55e89e9761 100644 --- a/source4/include/core.h +++ b/source4/include/core.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 */ diff --git a/source4/ldap_server/ldap_server.c b/source4/ldap_server/ldap_server.c index c42ad285ec..0de76052d1 100644 --- a/source4/ldap_server/ldap_server.c +++ b/source4/ldap_server/ldap_server.c @@ -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; } diff --git a/source4/lib/charset/charcnv.c b/source4/lib/charset/charcnv.c index 0f6e53f52c..fcf29d4647 100644 --- a/source4/lib/charset/charcnv.c +++ b/source4/lib/charset/charcnv.c @@ -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: diff --git a/source4/lib/charset/charset.h b/source4/lib/charset/charset.h index e62f99a8fe..3c548192b6 100644 --- a/source4/lib/charset/charset.h +++ b/source4/lib/charset/charset.h @@ -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__ */ diff --git a/source4/lib/stream/packet.c b/source4/lib/stream/packet.c index 3f4fcb1ef7..e6cfae7bd6 100644 --- a/source4/lib/stream/packet.c +++ b/source4/lib/stream/packet.c @@ -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 { diff --git a/source4/lib/util/config.mk b/source4/lib/util/config.mk index 5ec110e68d..0912c897db 100644 --- a/source4/lib/util/config.mk +++ b/source4/lib/util/config.mk @@ -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 \ diff --git a/source4/lib/util/data_blob.c b/source4/lib/util/data_blob.c index df8e793835..117043f95c 100644 --- a/source4/lib/util/data_blob.c +++ b/source4/lib/util/data_blob.c @@ -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; } diff --git a/source4/lib/util/data_blob.h b/source4/lib/util/data_blob.h new file mode 100644 index 0000000000..acecb88132 --- /dev/null +++ b/source4/lib/util/data_blob.h @@ -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_ */ diff --git a/source4/lib/util/time.h b/source4/lib/util/time.h new file mode 100644 index 0000000000..a1b3facf24 --- /dev/null +++ b/source4/lib/util/time.h @@ -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_ */ diff --git a/source4/lib/util/util.h b/source4/lib/util/util.h index f19b243f64..0c784d1c97 100644 --- a/source4/lib/util/util.h +++ b/source4/lib/util/util.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_ */ diff --git a/source4/lib/util/xfile.h b/source4/lib/util/xfile.h index ffe4481a64..2cc369d8d8 100644 --- a/source4/lib/util/xfile.h +++ b/source4/lib/util/xfile.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_ */ diff --git a/source4/libcli/smb2/create.c b/source4/libcli/smb2/create.c index 58e7a905d9..c8ac271f44 100644 --- a/source4/libcli/smb2/create.c +++ b/source4/libcli/smb2/create.c @@ -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); diff --git a/source4/librpc/rpc/dcerpc.c b/source4/librpc/rpc/dcerpc.c index ed9eb7da78..984cc20fbc 100644 --- a/source4/librpc/rpc/dcerpc.c +++ b/source4/librpc/rpc/dcerpc.c @@ -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) { diff --git a/source4/librpc/rpc/dcerpc_smb2.c b/source4/librpc/rpc/dcerpc_smb2.c index 53f731f8b3..dcfee1f223 100644 --- a/source4/librpc/rpc/dcerpc_smb2.c +++ b/source4/librpc/rpc/dcerpc_smb2.c @@ -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; } diff --git a/source4/param/loadparm.c b/source4/param/loadparm.c index 4e9732630f..483aa1f10b 100644 --- a/source4/param/loadparm.c +++ b/source4/param/loadparm.c @@ -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; @@ -178,8 +174,8 @@ typedef struct int bLanmanAuth; int bNTLMAuth; int bUseSpnego; - int server_signing; - int client_signing; + int server_signing; + int client_signing; int bClientPlaintextAuth; int bClientLanManAuth; int bClientNTLMv2Auth; @@ -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) diff --git a/source4/rpc_server/dcesrv_auth.c b/source4/rpc_server/dcesrv_auth.c index 627da844aa..49a4c3de13 100644 --- a/source4/rpc_server/dcesrv_auth.c +++ b/source4/rpc_server/dcesrv_auth.c @@ -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 diff --git a/source4/web_server/http.c b/source4/web_server/http.c index d5d78544e0..502d5de2d0 100644 --- a/source4/web_server/http.c +++ b/source4/web_server/http.c @@ -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; } diff --git a/source4/web_server/web_server.c b/source4/web_server/web_server.c index a5402a77f7..f9031433d3 100644 --- a/source4/web_server/web_server.c +++ b/source4/web_server/web_server.c @@ -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; |