/*
Unix SMB / CIFS implementation .
tdb utility functions
Copyright ( C ) Andrew Tridgell 1992 - 1998
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 2 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 , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
/* these are little tdb utility functions that are meant to make
dealing with a tdb database a little less cumbersome in Samba */
/****************************************************************************
Lock a chain by string .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_lock_bystring ( TDB_CONTEXT * tdb , char * keyval )
{
TDB_DATA key ;
key . dptr = keyval ;
key . dsize = strlen ( keyval ) + 1 ;
return tdb_chainlock ( tdb , key ) ;
}
/****************************************************************************
Unlock a chain by string .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void tdb_unlock_bystring ( TDB_CONTEXT * tdb , char * keyval )
{
TDB_DATA key ;
key . dptr = keyval ;
key . dsize = strlen ( keyval ) + 1 ;
tdb_chainunlock ( tdb , key ) ;
}
/****************************************************************************
Fetch a int32 value by a arbitrary blob key , return - 1 if not found .
Output is int32 in native byte order .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 tdb_fetch_int32_byblob ( TDB_CONTEXT * tdb , char * keyval , size_t len )
{
TDB_DATA key , data ;
int32 ret ;
key . dptr = keyval ;
key . dsize = len ;
data = tdb_fetch ( tdb , key ) ;
if ( ! data . dptr | | data . dsize ! = sizeof ( int32 ) )
return - 1 ;
ret = IVAL ( data . dptr , 0 ) ;
SAFE_FREE ( data . dptr ) ;
return ret ;
}
/****************************************************************************
Fetch a int32 value by string key , return - 1 if not found .
Output is int32 in native byte order .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 tdb_fetch_int32 ( TDB_CONTEXT * tdb , char * keystr )
{
return tdb_fetch_int32_byblob ( tdb , keystr , strlen ( keystr ) + 1 ) ;
}
/****************************************************************************
Store a int32 value by an arbitary blob key , return 0 on success , - 1 on failure .
Input is int32 in native byte order . Output in tdb is in little - endian .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_store_int32_byblob ( TDB_CONTEXT * tdb , char * keystr , size_t len , int32 v )
{
TDB_DATA key , data ;
int32 v_store ;
key . dptr = keystr ;
key . dsize = len ;
SIVAL ( & v_store , 0 , v ) ;
data . dptr = ( void * ) & v_store ;
data . dsize = sizeof ( int32 ) ;
return tdb_store ( tdb , key , data , TDB_REPLACE ) ;
}
/****************************************************************************
Store a int32 value by string key , return 0 on success , - 1 on failure .
Input is int32 in native byte order . Output in tdb is in little - endian .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_store_int32 ( TDB_CONTEXT * tdb , char * keystr , int32 v )
{
return tdb_store_int32_byblob ( tdb , keystr , strlen ( keystr ) + 1 , v ) ;
}
/****************************************************************************
Fetch a uint32 value by a arbitrary blob key , return - 1 if not found .
Output is uint32 in native byte order .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL tdb_fetch_uint32_byblob ( TDB_CONTEXT * tdb , char * keyval , size_t len , uint32 * value )
{
TDB_DATA key , data ;
key . dptr = keyval ;
key . dsize = len ;
data = tdb_fetch ( tdb , key ) ;
if ( ! data . dptr | | data . dsize ! = sizeof ( uint32 ) )
return False ;
* value = IVAL ( data . dptr , 0 ) ;
SAFE_FREE ( data . dptr ) ;
return True ;
}
/****************************************************************************
Fetch a uint32 value by string key , return - 1 if not found .
Output is uint32 in native byte order .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL tdb_fetch_uint32 ( TDB_CONTEXT * tdb , char * keystr , uint32 * value )
{
return tdb_fetch_uint32_byblob ( tdb , keystr , strlen ( keystr ) + 1 , value ) ;
}
/****************************************************************************
Store a uint32 value by an arbitary blob key , return 0 on success , - 1 on failure .
Input is uint32 in native byte order . Output in tdb is in little - endian .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL tdb_store_uint32_byblob ( TDB_CONTEXT * tdb , char * keystr , size_t len , uint32 value )
{
TDB_DATA key , data ;
uint32 v_store ;
BOOL ret = True ;
key . dptr = keystr ;
key . dsize = len ;
SIVAL ( & v_store , 0 , value ) ;
data . dptr = ( void * ) & v_store ;
data . dsize = sizeof ( uint32 ) ;
if ( tdb_store ( tdb , key , data , TDB_REPLACE ) = = - 1 )
ret = False ;
return ret ;
}
/****************************************************************************
Store a uint32 value by string key , return 0 on success , - 1 on failure .
Input is uint32 in native byte order . Output in tdb is in little - endian .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL tdb_store_uint32 ( TDB_CONTEXT * tdb , char * keystr , uint32 value )
{
return tdb_store_uint32_byblob ( tdb , keystr , strlen ( keystr ) + 1 , value ) ;
}
/****************************************************************************
Store a buffer by a null terminated string key . Return 0 on success , - 1
on failure .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_store_by_string ( TDB_CONTEXT * tdb , char * keystr , void * buffer , int len )
{
TDB_DATA key , data ;
key . dptr = keystr ;
key . dsize = strlen ( keystr ) + 1 ;
data . dptr = buffer ;
data . dsize = len ;
return tdb_store ( tdb , key , data , TDB_REPLACE ) ;
}
/****************************************************************************
Fetch a buffer using a null terminated string key . Don ' t forget to call
free ( ) on the result dptr .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
TDB_DATA tdb_fetch_by_string ( TDB_CONTEXT * tdb , char * keystr )
{
TDB_DATA key ;
key . dptr = keystr ;
key . dsize = strlen ( keystr ) + 1 ;
return tdb_fetch ( tdb , key ) ;
}
/****************************************************************************
Atomic integer change . Returns old value . To create , set initial value in * oldval .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 tdb_change_int32_atomic ( TDB_CONTEXT * tdb , char * keystr , int32 * oldval , int32 change_val )
{
int32 val ;
int32 ret = - 1 ;
if ( tdb_lock_bystring ( tdb , keystr ) = = - 1 )
return - 1 ;
if ( ( val = tdb_fetch_int32 ( tdb , keystr ) ) = = - 1 ) {
/* The lookup failed */
if ( tdb_error ( tdb ) ! = TDB_ERR_NOEXIST ) {
/* but not becouse it didn't exist */
goto err_out ;
}
/* Start with 'old' value */
val = * oldval ;
} else {
/* It worked, set return value (oldval) to tdb data */
* oldval = val ;
}
/* Increment value for storage and return next time */
val + = change_val ;
if ( tdb_store_int32 ( tdb , keystr , val ) = = - 1 )
goto err_out ;
ret = 0 ;
err_out :
tdb_unlock_bystring ( tdb , keystr ) ;
return ret ;
}
/****************************************************************************
Atomic unsigned integer change . Returns old value . To create , set initial value in * oldval .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL tdb_change_uint32_atomic ( TDB_CONTEXT * tdb , char * keystr , uint32 * oldval , uint32 change_val )
{
uint32 val ;
BOOL ret = False ;
if ( tdb_lock_bystring ( tdb , keystr ) = = - 1 )
return False ;
if ( ! tdb_fetch_uint32 ( tdb , keystr , & val ) ) {
/* It failed */
if ( tdb_error ( tdb ) ! = TDB_ERR_NOEXIST ) {
/* and not becouse it didn't exist */
goto err_out ;
}
/* Start with 'old' value */
val = * oldval ;
} else {
/* it worked, set return value (oldval) to tdb data */
* oldval = val ;
}
/* get a new value to store */
val + = change_val ;
if ( ! tdb_store_uint32 ( tdb , keystr , val ) )
goto err_out ;
ret = True ;
err_out :
tdb_unlock_bystring ( tdb , keystr ) ;
return ret ;
}
/****************************************************************************
Useful pair of routines for packing / unpacking data consisting of
integers and strings .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
size_t tdb_pack ( char * buf , int bufsize , char * fmt , . . . )
{
va_list ap ;
uint16 w ;
uint32 d ;
int i ;
void * p ;
int len ;
char * s ;
char c ;
char * buf0 = buf ;
char * fmt0 = fmt ;
int bufsize0 = bufsize ;
va_start ( ap , fmt ) ;
while ( * fmt ) {
switch ( ( c = * fmt + + ) ) {
case ' w ' :
len = 2 ;
w = ( uint16 ) va_arg ( ap , int ) ;
if ( bufsize > = len )
SSVAL ( buf , 0 , w ) ;
break ;
case ' d ' :
len = 4 ;
d = va_arg ( ap , uint32 ) ;
if ( bufsize > = len )
SIVAL ( buf , 0 , d ) ;
break ;
case ' p ' :
len = 4 ;
p = va_arg ( ap , void * ) ;
d = p ? 1 : 0 ;
if ( bufsize > = len )
SIVAL ( buf , 0 , d ) ;
break ;
case ' P ' :
s = va_arg ( ap , char * ) ;
w = strlen ( s ) ;
len = w + 1 ;
if ( bufsize > = len )
memcpy ( buf , s , len ) ;
break ;
case ' f ' :
s = va_arg ( ap , char * ) ;
w = strlen ( s ) ;
len = w + 1 ;
if ( bufsize > = len )
memcpy ( buf , s , len ) ;
break ;
case ' B ' :
i = va_arg ( ap , int ) ;
s = va_arg ( ap , char * ) ;
len = 4 + i ;
if ( bufsize > = len ) {
SIVAL ( buf , 0 , i ) ;
memcpy ( buf + 4 , s , i ) ;
}
break ;
default :
DEBUG ( 0 , ( " Unknown tdb_pack format %c in %s \n " ,
c , fmt ) ) ;
len = 0 ;
break ;
}
buf + = len ;
bufsize - = len ;
}
va_end ( ap ) ;
DEBUG ( 18 , ( " tdb_pack(%s, %d) -> %d \n " ,
fmt0 , bufsize0 , ( int ) PTR_DIFF ( buf , buf0 ) ) ) ;
return PTR_DIFF ( buf , buf0 ) ;
}
/****************************************************************************
Useful pair of routines for packing / unpacking data consisting of
integers and strings .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_unpack ( char * buf , int bufsize , char * fmt , . . . )
{
va_list ap ;
uint16 * w ;
uint32 * d ;
int len ;
int * i ;
void * * p ;
char * s , * * b ;
char c ;
char * buf0 = buf ;
char * fmt0 = fmt ;
int bufsize0 = bufsize ;
va_start ( ap , fmt ) ;
while ( * fmt ) {
switch ( ( c = * fmt + + ) ) {
case ' w ' :
len = 2 ;
w = va_arg ( ap , uint16 * ) ;
if ( bufsize < len )
goto no_space ;
* w = SVAL ( buf , 0 ) ;
break ;
case ' d ' :
len = 4 ;
d = va_arg ( ap , uint32 * ) ;
if ( bufsize < len )
goto no_space ;
* d = IVAL ( buf , 0 ) ;
break ;
case ' p ' :
len = 4 ;
p = va_arg ( ap , void * * ) ;
if ( bufsize < len )
goto no_space ;
* p = ( void * ) IVAL ( buf , 0 ) ;
break ;
case ' P ' :
s = va_arg ( ap , char * ) ;
len = strlen ( buf ) + 1 ;
if ( bufsize < len | | len > sizeof ( pstring ) )
goto no_space ;
memcpy ( s , buf , len ) ;
break ;
case ' f ' :
s = va_arg ( ap , char * ) ;
len = strlen ( buf ) + 1 ;
if ( bufsize < len | | len > sizeof ( fstring ) )
goto no_space ;
memcpy ( s , buf , len ) ;
break ;
case ' B ' :
i = va_arg ( ap , int * ) ;
b = va_arg ( ap , char * * ) ;
len = 4 ;
if ( bufsize < len )
goto no_space ;
* i = IVAL ( buf , 0 ) ;
if ( ! * i ) {
* b = NULL ;
break ;
}
len + = * i ;
if ( bufsize < len )
goto no_space ;
* b = ( char * ) malloc ( * i ) ;
if ( ! * b )
goto no_space ;
memcpy ( * b , buf + 4 , * i ) ;
break ;
default :
DEBUG ( 0 , ( " Unknown tdb_unpack format %c in %s \n " ,
c , fmt ) ) ;
len = 0 ;
break ;
}
buf + = len ;
bufsize - = len ;
}
va_end ( ap ) ;
DEBUG ( 18 , ( " tdb_unpack(%s, %d) -> %d \n " ,
fmt0 , bufsize0 , ( int ) PTR_DIFF ( buf , buf0 ) ) ) ;
return PTR_DIFF ( buf , buf0 ) ;
no_space :
return - 1 ;
}
/****************************************************************************
Log tdb messages via DEBUG ( ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void tdb_log ( TDB_CONTEXT * tdb , int level , const char * format , . . . )
{
va_list ap ;
char * ptr = NULL ;
va_start ( ap , format ) ;
vasprintf ( & ptr , format , ap ) ;
va_end ( ap ) ;
if ( ! ptr | | ! * ptr )
return ;
DEBUG ( level , ( " tdb(%s): %s " , tdb - > name ? tdb - > name : " unnamed " , ptr ) ) ;
SAFE_FREE ( ptr ) ;
}
/****************************************************************************
Like tdb_open ( ) but also setup a logging function that redirects to
the samba DEBUG ( ) system .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
This is another *BIG* change...
Samba now features a pluggable passdb interface, along the same lines as the
one in use in the auth subsystem. In this case, only one backend may be active
at a time by the 'normal' interface, and only one backend per passdb_context is
permitted outside that.
This pluggable interface is designed to allow any number of passdb backends to
be compiled in, with the selection at runtime. The 'passdb backend' paramater
has been created (and documented!) to support this.
As such, configure has been modfied to allow (for example) --with-ldap and the
old smbpasswd to be selected at the same time.
This patch also introduces two new backends: smbpasswd_nua and tdbsam_nua.
These two backends accept 'non unix accounts', where the user does *not* exist
in /etc/passwd. These accounts' don't have UIDs in the unix sense, but to
avoid conflicts in the algroitmic mapping of RIDs, they use the values
specified in the 'non unix account range' paramter - in the same way as the
winbind ranges are specifed.
While I was at it, I cleaned up some of the code in pdb_tdb (code copied
directly from smbpasswd and not really considered properly). Most of this was
to do with % macro expansion on stored data. It isn't easy to get the macros
into the tdb, and the first password change will 'expand' them. tdbsam needs
to use a similar system to pdb_ldap in this regard.
This patch only makes minor adjustments to pdb_nisplus and pdb_ldap, becouse I
don't have the test facilities for these. I plan to incoroprate at least
pdb_ldap into this scheme after consultation with Jerry.
Each (converted) passdb module now no longer has any 'static' variables, and
only exports 1 init function outside its .c file.
The non-unix-account support in this patch has been proven! It is now possible
to join a win2k machine to a Samba PDC without an account in /etc/passwd!
Other changes:
Minor interface adjustments:
pdb_delete_sam_account() now takes a SAM_ACCOUNT, not a char*.
pdb_update_sam_account() no longer takes the 'override' argument that was being
ignored so often (every other passdb backend). Extra checks have been added in
some places.
Minor code changes:
smbpasswd no longer attempts to initialise the passdb at startup, this is
now done on first use.
pdbedit has lost some of its 'machine account' logic, as this behaviour is now
controlled by the passdb subsystem directly.
The samr subsystem no longer calls 'local password change', but does the pdb
interactions directly. This allow the ACB_ flags specifed to be transferred
direct to the backend, without interference.
Doco:
I've updated the doco to reflect some of the changes, and removed some paramters
no longer applicable to HEAD.
-
TDB_CONTEXT * tdb_open_log ( const char * name , int hash_size , int tdb_flags ,
int open_flags , mode_t mode )
{
TDB_CONTEXT * tdb ;
if ( ! lp_use_mmap ( ) )
tdb_flags | = TDB_NOMMAP ;
tdb = tdb_open_ex ( name , hash_size , tdb_flags ,
open_flags , mode , tdb_log ) ;
if ( ! tdb )
return NULL ;
return tdb ;
}
/****************************************************************************
Allow tdb_delete to be used as a tdb_traversal_fn .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int tdb_traverse_delete_fn ( TDB_CONTEXT * the_tdb , TDB_DATA key , TDB_DATA dbuf ,
void * state )
{
return tdb_delete ( the_tdb , key ) ;
}
