r24780: More work allowing libutil to be used by external users.
authorJelmer Vernooij <jelmer@samba.org>
Wed, 29 Aug 2007 13:07:03 +0000 (13:07 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 20:03:10 +0000 (15:03 -0500)
21 files changed:
source/auth/gensec/socket.c
source/dsdb/samdb/ldb_modules/password_hash.c
source/headermap.txt
source/include/core.h
source/ldap_server/ldap_server.c
source/lib/charset/charcnv.c
source/lib/charset/charset.h
source/lib/stream/packet.c
source/lib/util/config.mk
source/lib/util/data_blob.c
source/lib/util/data_blob.h [new file with mode: 0644]
source/lib/util/time.h [new file with mode: 0644]
source/lib/util/util.h
source/lib/util/xfile.h
source/libcli/smb2/create.c
source/librpc/rpc/dcerpc.c
source/librpc/rpc/dcerpc_smb2.c
source/param/loadparm.c
source/rpc_server/dcesrv_auth.c
source/web_server/http.c
source/web_server/web_server.c

index 257ea7b09485b09b98715aebd77acb2f457cd232..9bd97109fb92d72cff9f73db2715769b5b1bfa25 100644 (file)
@@ -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 */
index 61e9002439588653ded08f8501dab383e43e5f51..98061570c8ce946384def5901ff14eb2704ba323 100644 (file)
@@ -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;
        }
index 1ae677adf83942df08d48bd1559eba72fd2f674d..1b5c2d2d2d1ce56410687faed64da4aeb5d89519 100644 (file)
@@ -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
index a31b4c59c76b87d4ce2504621336067daff5399d..55e89e97614d9869fba4f3964fb790408c4ec47c 100644 (file)
 
 #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 */
index c42ad285ec3658ae463580b33a41e26d167d183d..0de76052d1c3c66398af3c95b19a76f5a1ee5945 100644 (file)
@@ -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;
                }
index 0f6e53f52c8dfc5d0879bcc2bf4ee0fec0a0eea8..fcf29d46475dd05ac048e88a59889ba9f5a2b0fe 100644 (file)
  * @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:
index e62f99a8fe894c02488a3f496304d004dc4287af..3c548192b637fb3d5e58611e16e040f27fb77a81 100644 (file)
@@ -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__ */
index 3f4fcb1ef7578ada455930ec0d8962bcd4e325de..e6cfae7bd69d0358fda46a4c94963255153f7718 100644 (file)
@@ -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 {
index 5ec110e68dce6a2b05a08fae01106138c228816a..0912c897dbdaf6dc183ba7a06a7c50a01778615c 100644 (file)
@@ -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 \
index df8e7938352f78a0432ebba27f8dabf417f2f141..117043f95c2fd0e50480a44c1f81ce3ab13e395c 100644 (file)
@@ -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/source/lib/util/data_blob.h b/source/lib/util/data_blob.h
new file mode 100644 (file)
index 0000000..acecb88
--- /dev/null
@@ -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/source/lib/util/time.h b/source/lib/util/time.h
new file mode 100644 (file)
index 0000000..a1b3fac
--- /dev/null
@@ -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_ */
index f19b243f6425a67d2657907364849d1e741c11b5..0c784d1c970f9b2f083d55514ab6c97a766b3234 100644 (file)
@@ -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_ */
index ffe4481a647c69e4ea244101d2557bdbec6e2e2d..2cc369d8d8efd749decb06530939fea97dd5c496 100644 (file)
@@ -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_ */
index 58e7a905d97ea0f0a3e89f8eeebd3c4b65a1515c..c8ac271f4496773430563ee533c7480240f1c673 100644 (file)
@@ -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);
index ed9eb7da78c67ec71b798cf4a29bf64103a2d0bd..984cc20fbc7dd80f4c4be34540854732959856d2 100644 (file)
@@ -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) {
index 53f731f8b363913fec0035b9bff51c3762ae351b..dcfee1f2235e66c03091e39ef57fceb9fe10192d 100644 (file)
@@ -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;
        }
index 4e9732630ff20af7c4224660b443ab2d5725292f..483aa1f10bee40abdb81f643ccecb0591992d612 100644 (file)
@@ -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)
index 627da844aaf5912055f41f616d107edf38b874df..49a4c3de13e381b20b2cc0274ce52d9ee8e00323 100644 (file)
@@ -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
index d5d78544e0e4043b297b4d85852a3923a93e7d3f..502d5de2d0646480290950e6a0155fd9317134b4 100644 (file)
@@ -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;
 }
 
index a5402a77f7aee3155abd6fd3417e281c1db17475..f9031433d38a5542d09fb68bd2cc48c5af0ee7b1 100644 (file)
@@ -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;