r2683: Fix a couple of compile warnings, depend on gtk+-2.4

r2682: as sambdb holds all search data, don't double free the data

metze

r2681: commit the first semi working search implementation
which exports data from a ldb.

I commit this code, so that someone can help me to find a strange
bug

metze

r2680: switched the libcli/raw/ code over to use talloc_reference(), which simplifies things quite a bit

r2679: fixed an uninitialised variable found with valgrind

r2678: from_name and to_name aren't needed in smb_iconv_t

r2677: - fixed a bug in the recursive logic talloc_free() when there are
  circular references (circular references are allowed, they just need
  to be handled carefully inside talloc)

- mark talloc_reference() pointers nicely in the --leak-report-full
  code, so you see what has a reference to what in a useful manner

r2676: add a test of the reference counting logic in the SAMR server into the
RPC-SAMR torture test. This closes the samr connection before working
on a open domain handle. The server is supposed to know that the open
domain handle still holds a reference to the connection, so the
connection remains valid even though it has been closed.

r2675: added a convenience function

  void *talloc_reference(const void *context, const void *ptr);

this function makes a secondary reference to ptr, and hangs it off the
given context. This greatly simplifies some of the current reference
counting code in the samr server and I suspect it will be widely used
in other places too.

the way you use it is like this:

domain_state->connect_state = talloc_reference(domain_state, connect_state);

that makes the element connect_state of domain_state a secondary
reference to connect_state. The connect_state structure will then only
be freed when both domain_state and the original connect_state go
away, allowing you to free them independently and in any order.

you could do this alrady using a talloc destructor, and that is what
the samr server did previously, but that meant this construct was
being reinvented in several places. So this convenience function sets
up the destructor for you, giving a much more convenient and less
error prone API.

r2674: I have realised that talloc() should have its context marked const, as
a const pointer really means that "the data pointed to by this pointer
won't change", and that is certainly true of talloc(). The fact that
some behind-the-scenes meta-data can change doesn't matter from the
point of view of const.

this fixes a number of const warnings caused by const data structures
being passed as talloc contexts. That will no longer generate a
warning.

also changed the talloc leak reporting option from --leak-check to
--leak-report, as all it does is generate a report on exit. A new
--leak-report-full option has been added that shows the complete tree
of memory allocations, which is is quite useful in tracking things down.

NOTE: I find it quite useful to insert talloc_report_full(ptr, stderr)
calls at strategic points in the code while debugging memory
allocation problems, particularly before freeing a major context (such
as the connection context). This allows you to see if that context has
been accumulating too much data, such as per-request data, which
should have been freed when the request finished.

r2673: in the rpc server, free up the old call when we decide to extend an
existing call rather than creating a new one. This prevents call
structures hanging around on the rpc connection context until it is
closed

r2672: don't call a variable "dup" as that conflicts with a standard system call name

r2671: we're getting too many errors caused by the talloc_realloc() API not
taking a context (so when you pass a NULL pointer you end up with
memory in a top level context). Fixed it by changing the API to take a
context. The context is only used if the pointer you are reallocing is
NULL.

r2670: use a destructor to auto-close the samr ldb when the last user
disconnects. Previously the ldb was always kept open.

r2669: convert make_user_info() and associated functions from malloc to talloc

r2668: steal the cli pointer into the pipe context so a single free destroys the cli context too

r2667: Remove forward declaration of static function from function. GCC 3.5 and 4.0 don't accept declarations of static functions inside other
functions, see http://gcc.gnu.org/ml/gcc-patches/2004-08/msg02514.html

r2664: fixed the final server leak for normal operation. We now get a clean report from --leak-check

r2663: fix an epmapper server leak - another talloc_realloc(NULL, ) leak

r2662: make --leak-check completely silent if not blocks are allocated

r2661: fixed a client side memory leak in the clilist code.

This sort of bug happens quite easily with the new talloc_realloc()
interface. talloc_realloc() now looks like this:

  void *talloc_realloc(void *ptr, size_t size);

and if ptr is not NULL then everything is fine. If ptr is NULL then
talloc_realloc() presumes you want to allocate in the NULL context,
which is probably not what is wanted.

For now the solution is to initialise ptr like this:
  ptr = talloc(mem_ctx, 0);
so when the realloc happens it has a context to get hold of.

I might change the interface of talloc_realloc() later to prevent this
problem in a more robust manner

r2660: - converted the libcli/raw/ library to use talloc_increase_ref_count()
  rather than manual reference counts

- properly support SMBexit in the cifs and posix backends

- added a logoff method to all backends

With these changes the RAW-CONTEXT test now passes against the posix backend

r2659: removed some extraneous debug msgs

r2658: fixed a couple of error codes found with RAW-CONTEXT

r2657: if we are already fully authenticated in session setup then the vuid is ignored

r2656: moved the seteuid configure tests into the posix backend (these tests
don't actually work yet, that will come later)

r2655: fixed an error in the shutdown of the sock->transport->session->tree
smbcli raw context handling

r2654: fixed some more server memory leaks. We are now down to a single leak
of 16 bytes, caused by the 16 byte data_blob in the smb_signing
code.

r2653: - data_blob() and data_blob_talloc() now get automatic names

- talloc_strdup() and related functions get automatic names

r2650: fixed a memory leak in make_server_info()

r2649: - used some cpp tricks to make users of talloc() and talloc_realloc()
  to get auto-naming of pointers very cheaply.

- fixed a couple of memory leaks found with the new tricks

A typical exit report for smbd is now:

talloc report on 'null_context' (total 811 bytes in 54 blocks)
        auth/auth_sam.c:334            contains     20 bytes in   1 blocks
        struct auth_serversupplied_info contains    498 bytes in  33 blocks
        UNNAMED                        contains      8 bytes in   1 blocks
        lib/data_blob.c:40             contains     16 bytes in   1 blocks
        iconv(CP850,UTF8)              contains     61 bytes in   4 blocks
        iconv(UTF8,CP850)              contains     61 bytes in   4 blocks
        iconv(UTF8,UTF-16LE)           contains     67 bytes in   4 blocks
        iconv(UTF-16LE,UTF8)           contains     67 bytes in   4 blocks
        UNNAMED                        contains     13 bytes in   1 blocks

which is much better than before

r2648: - use a destructor on struct server_connection to simplify the
  connection termination cleanup, and to ensure that the event
  contexts are properly removed for every process model

- gave auth_context the new talloc treatment, which removes another
  source of memory leaks.

r2646: - use a talloc destructor to ensure that sockets from the new socket
  library are closed on abnormal termination

- convert the service.h structures to the new talloc methods

r2645: converted the NTLMSSP code to the new style of talloc

r2644: removed an unused function

r2643: convert more of the auth subsyystem to the new talloc methods. This
also fixes a memory leak found with --leak-check.

r2642: smb_iconv_t is a pointer, so checks against -1 errors should use a cast

r2641: talloc_p() now produces a named talloc pointer, with the name
auto-derived from the type you are allocating. This is done with
basically zero overhead by relying on the stringify operator in cpp
producing string constants.

the result is that --leak-check nicely names all pointers that come
from talloc_p()

r2640: valgrind does a great job on some types of memory leaks, but is slow
and can't properly handle leaks of doubly linked lists which we use a
lot (as the memory is always reachable). Even with --show-reachable
its hard to track leaks down sometimes.

I realised that talloc does have the necessary information to track
these, and by using the cascading property of the new talloc it can
report on leaks in a much more succinct fashion than valgrind can.

I have added a new samba option --leak-check that applies to all Samba
tools. When enabled it prints a leak report summarising all top level
contexts that are present when the program exits. A typical report
looks like this:

talloc report on 'null_context' (total 1071 bytes in 52 blocks)
        iconv(CP850,UTF8)              contains     43 bytes in   3 blocks
        UNNAMED                        contains     24 bytes in   1 blocks
        UNNAMED                        contains     24 bytes in   1 blocks
        dcesrv_init                    contains    604 bytes in  26 blocks
        server_service                 contains    120 bytes in   6 blocks
        UNNAMED                        contains     24 bytes in   1 blocks
        UNNAMED                        contains     24 bytes in   1 blocks
        server_service                 contains    104 bytes in   4 blocks
        server_context                 contains     12 bytes in   2 blocks
        iconv(UTF8,UTF-16LE)           contains     46 bytes in   3 blocks
        iconv(UTF-16LE,UTF8)           contains     46 bytes in   3 blocks

the numbers are recursive summaries for all the memory hanging off each context.

this option is not thread safe when used, but the code is thread safe
if the option is not given, so I don't think thats a problem.

r2639: we doon't need the valid_table code, so get rid of it

r2638: do lazy initialisation of iconv handles, so we don't initialise a
handle unless we use it. This saves quite a bit of memory (libc chews
a lot loading a handle). Typically smbd now loads 3 handles, instead
of 36.

r2635: mem_ctx cleanups on the lsa and netlogon pipes in the rpc server

r2634: use discard_const_p() in a few places

r2633: fixed some function types in the (unused) print backend

r2632: a new approach to handling const errors. We have had huge numbers of
const warnings for a long time, and no real way to approach a
solution. Some of them are unavoidable due to the way the C standard
works (for example, any function that provides strchr() like
functionality _must_ produce a const warning)

I will be converting a bunch of places that currently produce const
warnings to use the discard_const_p(). Some of these will be
unavoidable const problems, some of them will be ones we will fix up
over time. At least this change means we will no longer be swamped
with const warnings, and we will easily be able to see when new
problems emerge.

r2631: the strchr family of functions should not return const strings.

r2630: I missed a couple of places in the gensec talloc conversion

r2629: convert gensec to the new talloc model

by making our gensec structures a talloc child of the open connection
we can be sure that it will be destroyed when the connection is
dropped.

r2628: got rid of some warnings and converted a few more places to use hierarchical memory allocation

r2627: use the new talloc capabilities in a bunch more places in the rpc
server code. This fixes a number of memory leaks I found when testing
with valgrind and smbtorture, as the cascading effect of a
talloc_free() ensures that anything derived from the top level object
is destroyed on disconnect.

r2626: the symbol gai_error is defined in /usr/include, so don't use that name in our code

r2625: use talloc_p, not talloc when possible (when allocating a structure in particular), as it gives us type checking.

r2624: - save some system calls by only trying read/write operations that select has indicated are possible

- when a socket is dead, don't try to do anything more on it

r2623: don't do pointer arithmetic on void*, as it doesn't work with non-GNU compilers

r2622: to implement the SOCKET_FLAG_BLOCK option in the socket library we
need to add MSG_WAITALL to the recv() flags. This is needed by the
current server code or sometimes it will fail with a receive error.

r2621: - now that the client code is non-blocking, we no longer need
  write_data and read_data, which are inherently blocking operations

- got rid of some old NBT keepalive routines that are not needed

r2618: before we had refererence counts in talloc I added a hack in the
server side request structure to prevent a structing being freed in
some circumstances. This change replaces this with the much more
robust mechanism of talloc_increase_ref_count().

r2617: add connect testing to the rpc test suite

r2616: the cascading nature of talloc_free() can lead to some surprises. In
this case the bug was that server_terminate_connection() destroys the
server context, which in turn cascades down to destroy all current
request contexts, so we musn't then try to destroy the request
structure a second time.

r2615: fixed a bug in the server side support for CONNECT level security

r2614: support CONNECT level DCE/RPC security in both client and
server. CONNECT security uses NTLMSSP, but does not do any signing or
sealing (or equivalently, its like signing, but with a zero filled
checksum).

r2613: use a talloc destructor to ensure that file descriptors are not leaked
on abnormal termination of a connection. As long as the top level
connection structure is freed then that should cascade down to the
file structure, and call this destructor which will close the open file descriptor.

In general I'd like to use this technique in any place in Samba4 where
we hold operating system resources that we need to make sure are
released on abnormal termination.

r2612: Ensure ntlm_auth always logs to stderr.

Add missing break;

Andrew Bartlett

r2611: Try to make Samba4's ntlm_auth more consistant with Samba 3.0.

Andrew Bartlett

r2601: avoid free()ing unallocated memory by mistake

r2597: A small program that takes SID strings on stdin and produces a marshalled
lsa_SidArray on stdout.

r2594: Remove call to Gtk+ 2.4 specific code

r2593: don't crash if the server doesn't know that 0 count searches mean 1

r2592: this fixes one of the security memory leaks in the server

r2591: fixed two errors in simple backend found with valgrind

r2590: fixed one of the server security memory leaks. There are more :(

r2589: a simple test to help find security related memory leaks. Run valgrind on smbd with
--show-leak=yes and --show-reachable=yes to track them down.

r2588: connect/disconnect is common enough that I don't think a level 0 DEBUG
is warranted to warn that it has happened :)

r2587: fixed a couple of authentication memory leaks. There are more to be
fixed - I'll commit a little test suite soon.

r2586: updated the nbench example in the README to reflect the new chaining syntax

r2583: mkproto.pl now treats "int main" as a special case and avoids it.

r2582: Merge checks for xattr and acl libraries from Samba3 so the {get,set}ntacl
programs can build on non-xattr machines.

r2581: added "hosts allow" and "hosts deny" checking in smbd. I needed this
as my box keeps getting hit by viruses spreading on my companies
internal network, which screws up my debug log badly (sigh).

metze, I'm not sure if you think access.c should go in the socket
library or not. It is closely tied to the socket functions, but you
may prefer it separate.

The access.c code is a port from Samba3, but with some cleanups to
make it (slighly) less ugly.

r2580: fixed an uninitialised byte found by valgrind

r2577: - I recently found out that charaters below 0x3F are guaranteed not to
  occur as secondary bytes in any multi-byte character set. This
  allows for a very simple optimisation in strchr_m() and
  strrchr_m(). It might be a good idea to pick this up for Samba3.

- the horrible toktocliplist() is only used in clitar.c, so move it
  there, to prevent anyone else from being tempted to use it.

r2576: Some userspace tools for getting and setting ntacls via the 'security.ntacl'
extended attribute.

r2573: - added a configure test for nanosecond time resolution in struct stat
  (recently Linux systems support this, allowing us to support the
  full resolution in NTTIME)

- use nanosecond resolution in the posix backend if available

- moved the configure tests and list of object files for the posix
  backend into ntvfs/posix/ to keep them more neatlly separated.

r2572: fixed two places where status is not initialised in the nbench backend

r2562: got rid of the "reference" backend that never happened - the code is
too stale to be of any use as a reference.

r2561: completely redid the ntvfs module chaining code, You can now do something like:

  ntvfs handler = nbench posix

and the nbench pass-thru module will be called before the posix
module. The chaining logic is now much saner, and less racy, with each
level in the chain getting its own private pointer rather than relying
on save/restore logic in the pass-thru module.

The only pass-thru module we have at the moment is the nbench one
(which records all traffic in a nbench compatibe format), but I plan
on soon writing a "unixuid" pass-thru module that will implement the
setegid()/setgroups()/seteuid() logic for standard posix uid
handling. This separation of the posix backend from the uid handling
should simplify the code, and make development easier.

I also modified the nbench module so it can do multiple chaining, so
if you want to you can do:

   ntvfs module = nbench nbench posix

and it will save 2 copies of the log file in /tmp. This is really only
useful for testing at the moment until we have more than one pass-thru
module.

r2560: Don't require structure fields that have the pidl value() property
to be set.  They can be if you want, but will be overwritten by the
pidl push code.

r2559: Python ints can't hold the full range of uint32 values so store them
as Python longs.

Also allow shorter width integer types to be initialised from long values.
Their values are truncated if they are too long.

r2556: fixed the -s one bug that jelmer pointed out

r2555: Start of a rpcclient type program.

r2554: added a test for a bug that jelmer pointed out (handling of -s one)

r2553: fixed ldbtest so it passes the ldap schema restrictions and thus can be used on the ldap backend

r2552: Character set conversion and string handling updates.

The intial motivation for this commit was to merge in some of the
bugfixes present in Samba3's chrcnv and string handling code into
Samba4.  However, along the way I found a lot of unused functions, and
decided to do a bit more...

The strlen_m code now does not use a fixed buffer, but more work is
needed to finish off other functions in str_util.c.  These fixed
length buffers hav caused very nasty, hard to chase down bugs at some
sites.

The strupper_m() function has a strupper_talloc() to replace it (we
need to go around and fix more uses, but it's a start).  Use of these
new functions will avoid bugs where the upper or lowercase version of
a string is a different length.

I have removed the push_*_allocate functions, which are replaced by
calls to push_*_talloc.  Likewise, pstring and other 'fixed length'
wrappers are removed, where possible.

I have removed the first ('base pointer') argument, used by push_ucs2,
as the Samba4 way of doing things ensures that this is always on an
even boundary anyway.  (It was used in only one place, in any case).

r2551: Add const.

Andrew Bartlett

r2550: survive our own BASE-NEGNOWAIT torture test.

Andrew Bartlett

r2547: Another place to use convert_string_talloc().

Andrew Bartlett

r2546: Remove another strupper_m() that we don't need.

Andrew Bartlett

r2545: str_charnum -> strlen_m.

These two functions do exactly the same thing, I'll be removing
str_charnum shortly.

Andrew Bartlett

r2544: (missed from the last commit)

smb_conn->socket has gone away, and the packet count is now in the
main structure.

Andrew Bartlett

r2543: Catch one more use of sub_get_remote_machine().

Andrew Bartlett

r2542: I really don't like the 'substitute' code, and I particularly don't
like it in the mainline code (outside the smb.conf magic).

We will need to have a more useful 'helper' routine for this, but for
now we at least get a reliable IP address.

Also remove the unused 'socket' structure in the smb server - it seems
to have been replaced by the socket library.

Andrew Bartlett