[Date Prev][Date Next]
[Chronological]
[Thread]
[Top]
patched slapd for binding to ip
Hi,
Seem like Kurt D. Zeilenga is doing the work for
implementing binding to ip addresses for the cvs
code.
I've expanded the 1.2.9 stable to it can handle
ANYINETADDR or {GIVEN IP}, it's not as flexible
as Kurt's work. I needed this functionality soon,
so I decided not to wait and to implement it right
away.
bye,
jarl
/* Revision history
*
* 5-Jun-96 hodges
* Added locking of new_conn_mutex when traversing the c[] array.
*/
#include "portable.h"
#include <stdio.h>
#include <ac/ctype.h>
#include <ac/errno.h>
#include <ac/signal.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>
#include <ac/unistd.h>
#include "ldapconfig.h"
#include "slap.h"
#ifdef HAVE_SYS_FILIO_H
#include <sys/filio.h>
#elif HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#ifdef HAVE_TCPD
#include <tcpd.h>
int allow_severity = LOG_INFO;
int deny_severity = LOG_NOTICE;
#endif /* TCP Wrappers */
int dtblsize;
Connection *c;
static int slapd_shutdown = 0;
/* a link to the slapd.conf configuration parameters */
extern char *slapd_pid_file;
extern char *slapd_args_file;
void *
slapd_daemon(
void *userdata
)
{
Operation *o;
BerElement ber;
unsigned long len, tag, msgid;
int i;
int tcps, ns;
struct sockaddr_in addr;
fd_set readfds;
fd_set writefds;
FILE *fp;
int on = 1;
portAddr *portaddr = userdata;
int port = 0;
const char *inetaddr = NULL;
port = portaddr->port;
inetaddr = portaddr->inetaddr;
#ifdef HAVE_SYSCONF
dtblsize = sysconf( _SC_OPEN_MAX );
#elif HAVE_GETDTABLESIZE
dtblsize = getdtablesize();
#else
dtblsize = FD_SETSIZE
#endif
#ifdef FD_SETSIZE
if(dtblsize > FD_SETSIZE) {
dtblsize = FD_SETSIZE;
}
#endif /* !FD_SETSIZE */
c = (Connection *) ch_calloc( 1, dtblsize * sizeof(Connection) );
for ( i = 0; i < dtblsize; i++ ) {
c[i].c_dn = NULL;
c[i].c_cdn = NULL;
c[i].c_addr = NULL;
c[i].c_domain = NULL;
c[i].c_ops = NULL;
c[i].c_sb.sb_sd = -1;
c[i].c_sb.sb_options = LBER_NO_READ_AHEAD;
c[i].c_sb.sb_naddr = 0;
c[i].c_sb.sb_ber.ber_buf = NULL;
c[i].c_sb.sb_ber.ber_ptr = NULL;
c[i].c_sb.sb_ber.ber_end = NULL;
c[i].c_writewaiter = 0;
c[i].c_connid = 0;
ldap_pvt_thread_mutex_init( &c[i].c_dnmutex );
ldap_pvt_thread_mutex_init( &c[i].c_opsmutex );
ldap_pvt_thread_mutex_init( &c[i].c_pdumutex );
ldap_pvt_thread_cond_init( &c[i].c_wcv );
}
if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "socket() failed errno %d (%s)", err,
err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
exit( 1 );
}
i = 1;
if ( setsockopt( tcps, SOL_SOCKET, SO_REUSEADDR, (char *) &i,
sizeof(i) ) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "setsockopt(reuse) failed errno %d (%s)",
err, err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
}
#ifdef SO_KEEPALIVE
i = 1;
if ( setsockopt( tcps, SOL_SOCKET, SO_KEEPALIVE, (char *) &i,
sizeof(i) ) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "setsockopt(keepalive) failed errno %d (%s)",
err, err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
}
#endif
#ifdef TCP_NODELAY
i = 1;
if ( setsockopt( tcps, IPPROTO_TCP, TCP_NODELAY, (char *) &i,
sizeof(i) ) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "setsockopt(TCP_NODELAY) failed errno %d (%s)",
err, err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
}
#endif
(void) memset( (void *) &addr, '\0', sizeof(addr) );
addr.sin_family = AF_INET;
//replaced; addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_addr.s_addr = inet_addr(inetaddr);
addr.sin_port = htons( (int)port );
if ( bind( tcps, (struct sockaddr *) &addr, sizeof(addr) ) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "bind() failed errno %d (%s)\n",
err, err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
exit( 1 );
}
if ( listen( tcps, 5 ) == -1 ) {
int err = errno;
Debug( LDAP_DEBUG_ANY, "listen() failed errno %d (%s)",
err, err > -1 && err < sys_nerr ? sys_errlist[err] :
"unknown", 0 );
exit( 1 );
}
Debug( LDAP_DEBUG_ANY, "slapd starting\n", 0, 0, 0 );
if (( slapd_pid_file != NULL ) &&
(( fp = fopen( slapd_pid_file, "w" )) != NULL )) {
fprintf( fp, "%d\n", (int) getpid() );
fclose( fp );
}
if (( slapd_args_file != NULL ) &&
(( fp = fopen( slapd_args_file, "w" )) != NULL )) {
for ( i = 0; i < g_argc; i++ ) {
fprintf( fp, "%s ", g_argv[i] );
}
fprintf( fp, "\n" );
fclose( fp );
}
while ( !slapd_shutdown ) {
struct sockaddr_in from;
struct hostent *hp;
struct timeval zero;
struct timeval *tvp;
int len, pid;
char *client_name;
char *client_addr;
FD_ZERO( &writefds );
FD_ZERO( &readfds );
FD_SET( tcps, &readfds );
zero.tv_sec = 0;
zero.tv_usec = 0;
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Debug( LDAP_DEBUG_CONNS,
"listening for connections on %d, activity on:",
tcps, 0, 0 );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
for ( i = 0; i < dtblsize; i++ ) {
if ( c[i].c_sb.sb_sd != -1 ) {
FD_SET( c[i].c_sb.sb_sd, &readfds );
if ( c[i].c_writewaiter ) {
FD_SET( c[i].c_sb.sb_sd, &writefds );
}
Debug( LDAP_DEBUG_CONNS, " %dr%s", i,
c[i].c_writewaiter ? "w" : "", 0 );
}
}
Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
Debug( LDAP_DEBUG_CONNS, "before select active_threads %d\n",
active_threads, 0, 0 );
#if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
tvp = NULL;
#else
tvp = active_threads ? &zero : NULL;
#endif
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
switch ( i = select( dtblsize, &readfds, &writefds, 0, tvp ) ) {
case -1: { /* failure - try again */
int err = errno;
Debug( LDAP_DEBUG_CONNS,
"select failed errno %d (%s)\n",
err, err > -1 && err < sys_nerr ?
sys_errlist[err] : "unknown", 0 );
} continue;
case 0: /* timeout - let threads run */
Debug( LDAP_DEBUG_CONNS, "select timeout - yielding\n",
0, 0, 0 );
ldap_pvt_thread_yield();
continue;
default: /* something happened - deal with it */
Debug( LDAP_DEBUG_CONNS, "select activity on %d descriptors\n", i, 0, 0 );
; /* FALL */
}
ldap_pvt_thread_mutex_lock( ¤ttime_mutex );
time( ¤ttime );
ldap_pvt_thread_mutex_unlock( ¤ttime_mutex );
/* new connection */
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
if ( FD_ISSET( tcps, &readfds ) ) {
len = sizeof(from);
if ( (ns = accept( tcps, (struct sockaddr *) &from,
&len )) == -1 )
{
int err = errno;
Debug( LDAP_DEBUG_ANY,
"accept() failed errno %d (%s)", err,
err > -1 && err < sys_nerr ?
sys_errlist[err] : "unknown", 0 );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
continue;
}
if ( ioctl( ns, FIONBIO, (caddr_t) &on ) == -1 ) {
Debug( LDAP_DEBUG_ANY,
"FIONBIO ioctl on %d failed\n", ns, 0, 0 );
}
Debug( LDAP_DEBUG_CONNS, "new connection on %d\n", ns,
0, 0 );
len = sizeof(from);
if ( getpeername( ns, (struct sockaddr *) &from, &len )
== 0 ) {
char *s;
client_addr = inet_ntoa( from.sin_addr );
#ifdef SLAPD_RLOOKUPS
hp = gethostbyaddr( (char *)
&(from.sin_addr),
sizeof(from.sin_addr), AF_INET );
if(hp) {
client_name = hp->h_name;
/* normalize the domain */
for ( s = client_name; *s; s++ ) {
*s = TOLOWER( (unsigned char) *s );
}
} else {
client_name = NULL;
}
#else
client_name = NULL;
#endif
} else {
client_name = NULL;;
client_addr = NULL;
}
#ifdef HAVE_TCPD
if(!hosts_ctl("slapd",
client_name != NULL ? client_name : STRING_UNKNOWN,
client_addr != NULL ? client_addr : STRING_UNKNOWN,
STRING_UNKNOWN))
{
/* DENY ACCESS */
Statslog( LDAP_DEBUG_ANY,
"fd=%d connection from %s (%s) denied.\n",
ns,
client_name == NULL ? "unknown" : client_name,
client_addr == NULL ? "unknown" : client_addr,
0, 0 );
close(ns);
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
continue;
}
#endif /* HAVE_TCPD */
c[ns].c_sb.sb_sd = ns;
ldap_pvt_thread_mutex_lock( &ops_mutex );
c[ns].c_connid = num_conns++;
ldap_pvt_thread_mutex_unlock( &ops_mutex );
Statslog( LDAP_DEBUG_STATS,
"conn=%d fd=%d connection from %s (%s) accepted.\n",
c[ns].c_connid, ns,
client_name == NULL ? "unknown" : client_name,
client_addr == NULL ? "unknown" : client_addr,
0 );
if ( c[ns].c_addr != NULL ) {
free( c[ns].c_addr );
}
c[ns].c_addr = ch_strdup( client_addr );
if ( c[ns].c_domain != NULL ) {
free( c[ns].c_domain );
}
c[ns].c_domain = ch_strdup( client_name == NULL
? "" : client_name );
ldap_pvt_thread_mutex_lock( &c[ns].c_dnmutex );
if ( c[ns].c_dn != NULL ) {
free( c[ns].c_dn );
c[ns].c_dn = NULL;
}
if ( c[ns].c_cdn != NULL ) {
free( c[ns].c_cdn );
c[ns].c_cdn = NULL;
}
ldap_pvt_thread_mutex_unlock( &c[ns].c_dnmutex );
c[ns].c_starttime = currenttime;
c[ns].c_opsinitiated = 0;
c[ns].c_opscompleted = 0;
}
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
Debug( LDAP_DEBUG_CONNS, "activity on:", 0, 0, 0 );
for ( i = 0; i < dtblsize; i++ ) {
int r, w;
r = FD_ISSET( i, &readfds );
w = FD_ISSET( i, &writefds );
if ( i != tcps && (r || w) ) {
Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
r ? "r" : "", w ? "w" : "" );
}
}
Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
for ( i = 0; i < dtblsize; i++ ) {
if ( i == tcps || (! FD_ISSET( i, &readfds ) &&
! FD_ISSET( i, &writefds )) ) {
continue;
}
if ( FD_ISSET( i, &writefds ) ) {
Debug( LDAP_DEBUG_CONNS,
"signaling write waiter on %d\n", i, 0, 0 );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
active_threads++;
c[i].c_writewaiter = 0;
ldap_pvt_thread_cond_signal( &c[i].c_wcv );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
}
if ( FD_ISSET( i, &readfds ) ) {
Debug( LDAP_DEBUG_CONNS,
"read activity on %d\n", i, 0, 0 );
connection_activity( &c[i] );
}
}
ldap_pvt_thread_yield();
}
close( tcps );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Debug( LDAP_DEBUG_ANY,
"slapd shutting down - waiting for %d threads to terminate\n",
active_threads, 0, 0 );
while ( active_threads > 0 ) {
ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
}
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
/* let backends do whatever cleanup they need to do */
Debug( LDAP_DEBUG_TRACE,
"slapd shutting down - waiting for backends to close down\n", 0, 0,
0 );
be_close();
Debug( LDAP_DEBUG_ANY, "slapd stopping\n", 0, 0, 0 );
return NULL;
}
void
slap_set_shutdown( int sig )
{
slapd_shutdown = 1;
ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
/* reinstall self */
(void) SIGNAL( sig, slap_set_shutdown );
}
void
slap_do_nothing( int sig )
{
/* reinstall self */
(void) SIGNAL( sig, slap_do_nothing );
}
#include "portable.h"
#include <stdio.h>
#include <ac/errno.h>
#include <ac/signal.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>
#include <ac/unistd.h>
#include "ldapconfig.h"
#include "slap.h"
#include "lutil.h" /* Get lutil_detach() */
#ifdef LDAP_SIGCHLD
static void wait4child( int sig );
#endif
/*
* when more than one slapd is running on one machine, each one might have
* it's own LOCAL for syslogging and must have its own pid/args files
*/
#ifdef LOG_LOCAL4
#define DEFAULT_SYSLOG_USER LOG_LOCAL4
typedef struct _str2intDispatch {
char *stringVal;
int abbr;
int intVal;
} STRDISP, *STRDISP_P;
/* table to compute syslog-options to integer */
static STRDISP syslog_types[] = {
{ "LOCAL0", 6, LOG_LOCAL0 },
{ "LOCAL1", 6, LOG_LOCAL1 },
{ "LOCAL2", 6, LOG_LOCAL2 },
{ "LOCAL3", 6, LOG_LOCAL3 },
{ "LOCAL4", 6, LOG_LOCAL4 },
{ "LOCAL5", 6, LOG_LOCAL5 },
{ "LOCAL6", 6, LOG_LOCAL6 },
{ "LOCAL7", 6, LOG_LOCAL7 },
{NULL}
};
static int cnvt_str2int();
#endif /* LOG_LOCAL4 */
static void
usage( char *name )
{
fprintf( stderr, "usage: %s [-d ?|debuglevel] [-f configfile] [-p portnumber] [-a inet bind address] [-s sysloglevel]", name );
#ifdef LOG_LOCAL4
fprintf( stderr, " [-l sysloguser]" );
#endif
fprintf( stderr, "\n" );
}
int
main( int argc, char **argv )
{
int i;
int inetd = 0;
int port;
char *inetaddr = NULL;
portAddr *portaddr;
int udp;
Backend *be = NULL;
FILE *fp = NULL;
char *configfile;
char *serverName;
#ifdef LOG_LOCAL4
char *optstring = "d:f:ip:a:s:ul:";
int syslogUser = DEFAULT_SYSLOG_USER;
#else
char *optstring = "d:f:ip:a:s:u";
#endif
portaddr = malloc(sizeof(portAddr));
configfile = SLAPD_DEFAULT_CONFIGFILE;
port = LDAP_PORT;
g_argc = argc;
g_argv = argv;
while ( (i = getopt( argc, argv, optstring )) != EOF ) {
switch ( i ) {
#ifdef LDAP_DEBUG
case 'd': /* turn on debugging */
if ( optarg[0] == '?' ) {
printf( "Debug levels:\n" );
printf( "\tLDAP_DEBUG_TRACE\t%d\n",
LDAP_DEBUG_TRACE );
printf( "\tLDAP_DEBUG_PACKETS\t%d\n",
LDAP_DEBUG_PACKETS );
printf( "\tLDAP_DEBUG_ARGS\t\t%d\n",
LDAP_DEBUG_ARGS );
printf( "\tLDAP_DEBUG_CONNS\t%d\n",
LDAP_DEBUG_CONNS );
printf( "\tLDAP_DEBUG_BER\t\t%d\n",
LDAP_DEBUG_BER );
printf( "\tLDAP_DEBUG_FILTER\t%d\n",
LDAP_DEBUG_FILTER );
printf( "\tLDAP_DEBUG_CONFIG\t%d\n",
LDAP_DEBUG_CONFIG );
printf( "\tLDAP_DEBUG_ACL\t\t%d\n",
LDAP_DEBUG_ACL );
printf( "\tLDAP_DEBUG_STATS\t%d\n",
LDAP_DEBUG_STATS );
printf( "\tLDAP_DEBUG_STATS2\t%d\n",
LDAP_DEBUG_STATS2 );
printf( "\tLDAP_DEBUG_SHELL\t%d\n",
LDAP_DEBUG_SHELL );
printf( "\tLDAP_DEBUG_PARSE\t%d\n",
LDAP_DEBUG_PARSE );
printf( "\tLDAP_DEBUG_ANY\t\t%d\n",
LDAP_DEBUG_ANY );
exit( 0 );
} else {
ldap_debug |= atoi( optarg );
lber_debug = (ldap_debug & LDAP_DEBUG_BER);
}
break;
#else
case 'd': /* turn on debugging */
fprintf( stderr,
"must compile with LDAP_DEBUG for debugging\n" );
break;
#endif
case 'f': /* read config file */
configfile = ch_strdup( optarg );
break;
case 'i': /* run from inetd */
inetd = 1;
break;
case 'p': /* port on which to listen */
port = atoi( optarg );
break;
case 's': /* set syslog level */
ldap_syslog = atoi( optarg );
break;
#ifdef LOG_LOCAL4
case 'l': /* set syslog local user */
syslogUser = cnvt_str2int( optarg, syslog_types,
DEFAULT_SYSLOG_USER );
break;
#endif
case 'u': /* do udp */
udp = 1;
break;
// ADDED FOR -a SAKE
case 'a': /* bind to specific inet address */
inetaddr = ch_strdup( optarg );
break;
default:
usage( argv[0] );
exit( 1 );
}
}
Debug( LDAP_DEBUG_TRACE, "%s", Versionstr, 0, 0 );
if ( (serverName = strrchr( argv[0], '/' )) == NULL ) {
serverName = ch_strdup( argv[0] );
} else {
serverName = ch_strdup( serverName + 1 );
}
// ADDED FOR -a SAKE
if ( ! inetaddr) {
inetaddr = ch_strdup("0.0.0.0");
}
//disabled; printf(" inet address = %s\n",inetaddr);
portaddr->port = port;
portaddr->inetaddr = inetaddr;
if ( ! inetd ) {
/* pre-open config file before detach in case it is a relative path */
fp = fopen( configfile, "r" );
#ifdef LDAP_DEBUG
lutil_detach( ldap_debug, 0 );
#else
lutil_detach( 0, 0 );
#endif
}
#ifdef LOG_LOCAL4
openlog( serverName, OPENLOG_OPTIONS, syslogUser );
#else
openlog( serverName, OPENLOG_OPTIONS );
#endif
init();
read_config( configfile, &be, fp );
if ( ! inetd ) {
int status;
(void) SIGNAL( SIGPIPE, SIG_IGN );
(void) SIGNAL( LDAP_SIGUSR1, slap_do_nothing );
(void) SIGNAL( LDAP_SIGUSR2, slap_set_shutdown );
(void) SIGNAL( SIGTERM, slap_set_shutdown );
(void) SIGNAL( SIGINT, slap_set_shutdown );
(void) SIGNAL( SIGHUP, slap_set_shutdown );
#ifdef LDAP_SIGCHLD
(void) SIGNAL( LDAP_SIGCHLD, wait4child );
#endif
time( &starttime );
if ( status = ldap_pvt_thread_create( &listener_tid, 0,
slapd_daemon, (void *) portaddr) != 0 )
{
Debug( LDAP_DEBUG_ANY,
"listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
exit( 1 );
}
ldap_pvt_thread_join( listener_tid, (void *) NULL );
return 0;
} else {
Connection c;
Operation *o;
BerElement ber;
unsigned long len, tag;
long msgid;
int flen;
struct sockaddr_in from;
struct hostent *hp;
c.c_dn = NULL;
c.c_cdn = NULL;
c.c_ops = NULL;
c.c_sb.sb_sd = 0;
c.c_sb.sb_options = 0;
c.c_sb.sb_naddr = udp ? 1 : 0;
c.c_sb.sb_ber.ber_buf = NULL;
c.c_sb.sb_ber.ber_ptr = NULL;
c.c_sb.sb_ber.ber_end = NULL;
ldap_pvt_thread_mutex_init( &c.c_dnmutex );
ldap_pvt_thread_mutex_init( &c.c_opsmutex );
ldap_pvt_thread_mutex_init( &c.c_pdumutex );
#ifdef notdefcldap
c.c_sb.sb_addrs = (void **) saddrlist;
c.c_sb.sb_fromaddr = &faddr;
c.c_sb.sb_useaddr = saddrlist[ 0 ] = &saddr;
#endif
flen = sizeof(from);
if ( getpeername( 0, (struct sockaddr *) &from, &flen ) == 0 ) {
#ifdef SLAPD_RLOOKUPS
hp = gethostbyaddr( (char *) &(from.sin_addr),
sizeof(from.sin_addr), AF_INET );
#else
hp = NULL;
#endif
Debug( LDAP_DEBUG_ARGS, "connection from %s (%s)\n",
hp == NULL ? "unknown" : hp->h_name,
inet_ntoa( from.sin_addr ), 0 );
c.c_addr = inet_ntoa( from.sin_addr );
c.c_domain = ch_strdup( hp == NULL ? "" : hp->h_name );
} else {
Debug( LDAP_DEBUG_ARGS, "connection from unknown\n",
0, 0, 0 );
}
ber_init( &ber, 0 );
while ( (tag = ber_get_next( &c.c_sb, &len, &ber ))
== LDAP_TAG_MESSAGE ) {
ldap_pvt_thread_mutex_lock( ¤ttime_mutex );
time( ¤ttime );
ldap_pvt_thread_mutex_unlock( ¤ttime_mutex );
if ( (tag = ber_get_int( &ber, &msgid ))
!= LDAP_TAG_MSGID ) {
/* log and send error */
Debug( LDAP_DEBUG_ANY,
"ber_get_int returns 0x%lx\n", tag, 0, 0 );
ber_free( &ber, 1 );
return 1;
}
if ( (tag = ber_peek_tag( &ber, &len ))
== LBER_ERROR ) {
/* log, close and send error */
Debug( LDAP_DEBUG_ANY,
"ber_peek_tag returns 0x%lx\n", tag, 0, 0 );
ber_free( &ber, 1 );
close( c.c_sb.sb_sd );
c.c_sb.sb_sd = -1;
return 1;
}
connection_activity( &c );
ber_free( &ber, 1 );
}
}
return 1;
}
#ifdef LDAP_SIGCHLD
/*
* Catch and discard terminated child processes, to avoid zombies.
*/
static void
wait4child( int sig )
{
int save_errno = errno;
#ifdef WNOHANG
errno = 0;
#ifdef HAVE_WAITPID
while ( waitpid( (pid_t)-1, NULL, WNOHANG ) >= 0 || errno == EINTR )
; /* NULL */
#else
while ( wait3( NULL, WNOHANG, NULL ) >= 0 || errno == EINTR )
; /* NULL */
#endif
#else
(void) wait( NULL );
#endif
(void) SIGNAL( sig, wait4child );
errno = save_errno;
}
#endif /* SIGCHLD || SIGCLD */
#ifdef LOG_LOCAL4
/*
* Convert a string to an integer by means of a dispatcher table
* if the string is not in the table return the default
*/
static int
cnvt_str2int (stringVal, dispatcher, defaultVal)
char *stringVal;
STRDISP_P dispatcher;
int defaultVal;
{
int retVal = defaultVal;
STRDISP_P disp;
for (disp = dispatcher; disp->stringVal; disp++) {
if (!strncasecmp (stringVal, disp->stringVal, disp->abbr)) {
retVal = disp->intVal;
break;
}
}
return (retVal);
} /* cnvt_str2int */
#endif /* LOG_LOCAL4 */
/* slap.h - stand alone ldap server include file */
#ifndef _SLDAPD_H_
#define _SLDAPD_H_
#include <stdlib.h>
#ifndef LDAP_SYSLOG
#define LDAP_SYSLOG 1
#endif
#include <sys/types.h>
#include <ac/syslog.h>
#include <ac/regex.h>
#include <ac/time.h>
#undef NDEBUG
#include <assert.h>
#include "avl.h"
#include "lber.h"
#include "ldap.h"
#include "ldap_pvt_thread.h"
#include "ldif.h"
#ifdef f_next
#undef f_next /* name conflict between sys/file.h on SCO and struct filter */
#endif
/* LDAPMod.mod_op value ===> Must be kept in sync with ldap.h!
*
* This is a value used internally by the backends. It is needed to allow
* adding values that already exist without getting an error as required by
* modrdn when the new rdn was already an attribute value itself.
* JCG 05/1999 (gomez@engr.sgi.com)
*/
#define LDAP_MOD_SOFTADD 0x04 /* Just make sure value is there */
#define DN_DNS 0
#define DN_X500 1
#define ON 1
#define OFF (-1)
#define UNDEFINED 0
#define MAXREMATCHES 10
#define DNSEPARATOR(c) ((c) == ',' || (c) == ';')
#define SEPARATOR(c) ((c) == ',' || (c) == ';' || (c) == '+')
#define SPACE(c) ((c) == ' ' || (c) == '\n')
#define NEEDSESCAPE(c) ((c) == '\\' || (c) == '"')
LDAP_BEGIN_DECL
struct slap_op;
struct slap_conn;
/*
* represents an attribute value assertion (i.e., attr=value)
*/
typedef struct ava {
char *ava_type;
struct berval ava_value;
} Ava;
/*
* represents a search filter
*/
typedef struct filter {
unsigned long f_choice; /* values taken from ldap.h */
union {
/* present */
char *f_un_type;
/* equality, lessorequal, greaterorequal, approx */
Ava f_un_ava;
/* and, or, not */
struct filter *f_un_complex;
/* substrings */
struct sub {
char *f_un_sub_type;
char *f_un_sub_initial;
char **f_un_sub_any;
char *f_un_sub_final;
} f_un_sub;
} f_un;
#define f_type f_un.f_un_type
#define f_ava f_un.f_un_ava
#define f_avtype f_un.f_un_ava.ava_type
#define f_avvalue f_un.f_un_ava.ava_value
#define f_and f_un.f_un_complex
#define f_or f_un.f_un_complex
#define f_not f_un.f_un_complex
#define f_list f_un.f_un_complex
#define f_sub f_un.f_un_sub
#define f_sub_type f_un.f_un_sub.f_un_sub_type
#define f_sub_initial f_un.f_un_sub.f_un_sub_initial
#define f_sub_any f_un.f_un_sub.f_un_sub_any
#define f_sub_final f_un.f_un_sub.f_un_sub_final
struct filter *f_next;
} Filter;
/*
* represents an attribute (type + values + syntax)
*/
typedef struct attr {
char *a_type;
struct berval **a_vals;
int a_syntax;
struct attr *a_next;
} Attribute;
/*
* the attr_syntax() routine returns one of these values
* telling what kind of syntax an attribute supports.
*/
#define SYNTAX_CIS 0x01 /* case insensitive string */
#define SYNTAX_CES 0x02 /* case sensitive string */
#define SYNTAX_BIN 0x04 /* binary data */
#define SYNTAX_TEL 0x08 /* telephone number string */
#define SYNTAX_DN 0x10 /* dn string */
/*
* the id used in the indexes to refer to an entry
*/
typedef unsigned long ID;
#define NOID ((unsigned long)-1)
/*
* represents an entry in core
*/
typedef struct entry {
char *e_dn; /* DN of this entry */
char *e_ndn; /* normalized DN of this entry */
Attribute *e_attrs; /* list of attributes + values */
ID e_id; /* id of this entry - this should */
/* really be private to back-ldbm */
char e_state; /* for the cache */
ldap_pvt_thread_rdwr_t e_rdwr; /* reader/writer lock */
#define ENTRY_STATE_DELETED 1
#define ENTRY_STATE_CREATING 2
int e_refcnt; /* # threads ref'ing this entry */
struct entry *e_lrunext; /* for cache lru list */
struct entry *e_lruprev;
} Entry;
/*
* represents an access control list
*/
/* the "by" part */
struct access {
char *a_dnpat;
char *a_addrpat;
char *a_domainpat;
char *a_dnattr;
long a_access;
#ifdef SLAPD_ACLGROUPS
char *a_group;
char *a_objectclassvalue;
char *a_groupattrname;
#endif
#define ACL_NONE 0x01
#define ACL_COMPARE 0x02
#define ACL_SEARCH 0x04
#define ACL_READ 0x08
#define ACL_WRITE 0x10
#define ACL_SELF 0x40
struct access *a_next;
};
/* the "to" part */
struct acl {
/* "to" part: the entries this acl applies to */
Filter *acl_filter;
regex_t acl_dnre;
char *acl_dnpat;
char **acl_attrs;
/* "by" part: list of who has what access to the entries */
struct access *acl_access;
struct acl *acl_next;
};
/*
* represents schema information for a database
*/
struct objclass {
char *oc_name;
char **oc_required;
char **oc_allowed;
struct objclass *oc_next;
};
/*
* represents a "database"
*/
typedef struct backend Backend;
struct backend {
char **be_suffix; /* the DN suffixes of data in this backend */
char **be_suffixAlias; /* the DN suffix aliases of data in this backend */
char *be_root_dn; /* the magic "root" dn for this db */
char *be_root_ndn; /* the magic "root" normalized dn for this db */
char *be_root_pw; /* the magic "root" password for this db */
int be_readonly; /* 1 => db is in "read only" mode */
int be_maxDerefDepth; /* limit for depth of an alias deref */
int be_sizelimit; /* size limit for this backend */
int be_timelimit; /* time limit for this backend */
struct acl *be_acl; /* access control list for this backend */
int be_dfltaccess; /* access given if no acl matches */
char **be_replica; /* replicas of this backend (in master) */
char *be_replogfile; /* replication log file (in master) */
char *be_update_ndn; /* allowed to make changes (in replicas) */
int be_lastmod; /* keep track of lastmodified{by,time} */
char *be_type; /* type of database */
void *be_private; /* anything the backend needs */
/* backend routines */
int (*be_bind) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *dn, int method, struct berval *cred, char** edn ));
void (*be_unbind) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o ));
int (*be_search) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *base, int scope, int deref, int slimit, int tlimit,
Filter *f, char *filterstr, char **attrs, int attrsonly));
int (*be_compare)LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *dn, Ava *ava));
int (*be_modify) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *dn, LDAPMod *m));
int (*be_modrdn) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *dn, char *newrdn, int deleteoldrdn ));
int (*be_add) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
Entry *e));
int (*be_delete) LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
char *dn));
/* Bug: be_abandon in unused! */
void (*be_abandon)LDAP_P((Backend *be,
struct slap_conn *c, struct slap_op *o,
int msgid));
void (*be_config) LDAP_P((Backend *be,
char *fname, int lineno, int argc, char **argv ));
void (*be_init) LDAP_P((Backend *be));
void (*be_close) LDAP_P((Backend *be));
#ifdef SLAPD_ACLGROUPS
int (*be_group) LDAP_P((Backend *be, Entry *e,
char *bdn, char *edn,
char *objectclassValue, char *groupattrName ));
#endif
};
/*
* represents an operation pending from an ldap client
*/
typedef struct slap_op {
BerElement *o_ber; /* ber of the request */
long o_msgid; /* msgid of the request */
unsigned long o_tag; /* tag of the request */
time_t o_time; /* time op was initiated */
char *o_dn; /* dn bound when op was initiated */
char *o_ndn; /* normalized dn bound when op was initiated */
int o_authtype; /* auth method used to bind dn */
/* values taken from ldap.h */
/* LDAP_AUTH_* */
int o_opid; /* id of this operation */
int o_connid; /* id of conn initiating this op */
#ifdef LDAP_CONNECTIONLESS
int o_cldap; /* != 0 if this came in via CLDAP */
struct sockaddr o_clientaddr; /* client address if via CLDAP */
char o_searchbase; /* search base if via CLDAP */
#endif
struct slap_op *o_next; /* next operation pending */
ldap_pvt_thread_t o_tid; /* thread handling this op */
int o_abandon; /* signals op has been abandoned */
ldap_pvt_thread_mutex_t o_abandonmutex; /* signals op has been abandoned */
void *o_private; /* anything the backend needs */
} Operation;
/*
* represents a connection from an ldap client
*/
typedef struct slap_conn {
Sockbuf c_sb; /* ber connection stuff */
char *c_cdn; /* DN provided by the client */
char *c_dn; /* DN bound to this conn */
ldap_pvt_thread_mutex_t c_dnmutex; /* mutex for c_dn field */
int c_authtype; /* auth method used to bind c_dn */
#ifdef LDAP_COMPAT
int c_version; /* for compatibility w/2.0, 3.0 */
#endif
char *c_addr; /* address of client on this conn */
char *c_domain; /* domain of client on this conn */
Operation *c_ops; /* list of pending operations */
ldap_pvt_thread_mutex_t c_opsmutex; /* mutex for c_ops list & stats */
ldap_pvt_thread_mutex_t c_pdumutex; /* only one pdu written at a time */
ldap_pvt_thread_cond_t c_wcv; /* used to wait for sd write-ready*/
int c_gettingber; /* in the middle of ber_get_next */
BerElement *c_currentber; /* ber we're getting */
int c_writewaiter; /* signals write-ready sd waiter */
int c_pduwaiters; /* signals threads waiting 4 pdu */
time_t c_starttime; /* when the connection was opened */
int c_connid; /* id of this connection for stats*/
int c_opsinitiated; /* # ops initiated/next op id */
int c_opscompleted; /* # ops completed */
} Connection;
#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)
#define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) \
{ \
if ( ldap_debug & level ) \
fprintf( stderr, fmt, connid, opid, arg1, arg2, arg3 );\
if ( ldap_syslog & level ) \
syslog( ldap_syslog_level, fmt, connid, opid, arg1, \
arg2, arg3 ); \
}
#else
#define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 )
#endif
typedef struct _portAddr {
int port;
const char* inetaddr;
} portAddr;
#include "proto-slap.h"
LDAP_END_DECL
#endif /* _slap_h_ */