int smtp_do_starttls(connection_t *c) {
char *reply, starttls[] = "STARTTLS\r\n";
int code;
ssize_t ret;
ret = smtp_parse(c, &code, &reply);
if(ret <= 0) {
/* error or need more data */
free(reply);
return ret;
}
fprintf(stderr, "%s SMTP: %s\n", proto_ver(c), reply);
free(reply);
/* Verify EHLO reply */
if(code != 250)
return -1;
/* Send STARTTLS */
if(connection_write(c, starttls, strlen(starttls)) < 0)
return -1;
return 1;
}
status_t send_status_code(connection conn, int status_code, http_version version)
{
size_t i, cb, n;
http_status* pstatus;
assert(conn != NULL);
if (version == VERSION_10) {
pstatus = m_http_status10;
n = sizeof m_http_status10 / sizeof *m_http_status10;
}
else {
pstatus = m_http_status11;
n = sizeof m_http_status11 / sizeof *m_http_status11;
}
for (i = 0; i < n; i++) {
if (pstatus[i].code == status_code) {
cb = strlen(pstatus[i].text);
return connection_write(conn, pstatus[i].text, cb);
}
}
/* Unsupported status code? Pretty internal error, isn't it?
* We just die as we obviously have a major internal error */
fprintf(stderr, "Weird status code: %d (hex %x)\n", status_code, status_code);
return 0;
abort();
}
int smtp_do_ehlo(connection_t *c) {
char *reply, ehlo[] = "EHLO foobar\r\n";
int code;
ssize_t ret;
ret = smtp_parse(c, &code, &reply);
if(ret <= 0) {
/* error or need more data */
free(reply);
return ret;
}
fprintf(stderr, "%s SMTP: %s\n", proto_ver(c), reply);
free(reply);
/* Verify banner */
if(code != 220)
return -1;
/* Send EHLO */
if(connection_write(c, ehlo, strlen(ehlo)) < 0)
return -1;
return 1;
}
tree
connection_eval (string name, string session, string s) {
// cout << "Evaluating " << name << ", " << session << ", " << s << LF;
connection con= connection_get (name, session);
if (is_nil (con)) return "";
connection_write (name, session, s);
return connection_retrieve (name, session);
}
static void
test(struct connection_pool *p, int id) {
int i=0;
while (i<5) {
int handle = id;
const char * line = connection_readline(p, handle, "\n", NULL);
if (line == NULL) {
line = connection_poll(p,1000,&handle,NULL);
}
if (line) {
printf("%d %d: %s\n",i,handle, line);
connection_write(p,handle,"readline\n",9);
++i;
} else {
if (handle) {
printf("Close %d\n",handle);
return;
}
}
}
i=0;
while (i<5) {
int handle = id;
uint8_t * buffer = connection_read(p, handle, 8);
if (buffer == NULL) {
buffer = connection_poll(p,1000,&handle,NULL);
}
if (buffer) {
int j;
printf("%d %d: ",i,handle);
for (j=0;j<8;j++) {
printf("%02x ",buffer[j]);
}
printf("\n");
connection_write(p,handle,"readblock\n",10);
++i;
} else {
if (handle) {
printf("Close %d\n", handle);
return;
}
}
}
}
static inline int send_content_length(entity_header eh, connection conn)
{
char buf[100] = {'\0'}; /* "Content-Length: " + length + '\r\n\0' */
size_t cb, content_length = 0;
content_length = entity_header_get_content_length(eh);
sprintf(buf, "Content-Length: %lu\r\n", (unsigned long)content_length);
cb = strlen(buf);
return connection_write(conn, buf, cb);
}
static void ignore_receive_data_with_qt(urg_t *urg, int timeout)
{
if ((urg->is_sending == URG_FALSE) && (urg->is_laser_on == URG_FALSE)) {
return;
}
connection_write(&urg->connection, "QT\n", 3);
urg->is_laser_on = URG_FALSE;
ignore_receive_data(urg, timeout);
}
/* The only way we can detect that the socket is closed is the first time
* we write to it, we will fail. Subsequent write operations will
* succeed. Shudder!
*/
static int telnet_write(struct connection *connection, const void *data, int len)
{
struct telnet_connection *t_con = connection->priv;
if (t_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
if (connection_write(connection, data, len) == len)
return ERROR_OK;
t_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED;
}
int parse_command(CONNECTION *connection, char *cmd_buf) {
char cmd[32] = {'\0'};
char *p = cmd;
int i;
// skip any preceding whitespace
while(isspace(*cmd_buf) && *cmd_buf != '\0') {
cmd_buf++;
}
// copy until whitespace or EOF
while(!isspace(*cmd_buf) && *cmd_buf != '\0') {
*p++ = *cmd_buf++;
}
*p = '\0';
// check if command exists
for(i = 0; commands[i].name; i++) {
if(!strcmp(commands[i].name, cmd)) {
break;
}
}
if(commands[i].name == 0) {
connection_write(connection, "Unknown command");
return false;
}
if(!IsSet(commands[i].connection_states, connection->state)) {
connection_write(connection, "Invalid connection state for command.");
return false;
}
// check rank here
// if(commands[i].rank ...)
// call function
(*commands[i].function) (connection);
return true;
}
/* write data out to a socket.
*
* this is a blocking write, so the return value must equal the length, if
* that is not the case then flag the connection with an output error.
*/
int tcl_output(struct connection *connection, const void *data, ssize_t len)
{
ssize_t wlen;
struct tcl_connection *tclc;
tclc = connection->priv;
if (tclc->tc_outerror)
return ERROR_SERVER_REMOTE_CLOSED;
wlen = connection_write(connection, data, len);
if (wlen == len)
return ERROR_OK;
LOG_ERROR("error during write: %d != %d", (int)wlen, (int)len);
tclc->tc_outerror = 1;
return ERROR_SERVER_REMOTE_CLOSED;
}
void
connection_write (string name, string session, tree t) {
// cout << "Write " << name << ", " << session << ", " << t << "\n";
string s= as_string (call ("plugin-serialize", name, tree_to_stree (t)));
connection_write (name, session, s);
}
static void *
slapd_daemon_task(
void *ptr
)
{
int l;
time_t last_idle_check = 0;
struct timeval idle;
time( &starttime );
#define SLAPD_IDLE_CHECK_LIMIT 4
if ( global_idletimeout > 0 ) {
last_idle_check = slap_get_time();
/* Set the select timeout.
* Don't just truncate, preserve the fractions of
* seconds to prevent sleeping for zero time.
*/
idle.tv_sec = global_idletimeout/SLAPD_IDLE_CHECK_LIMIT;
idle.tv_usec = global_idletimeout - idle.tv_sec * SLAPD_IDLE_CHECK_LIMIT;
idle.tv_usec *= 1000000 / SLAPD_IDLE_CHECK_LIMIT;
} else {
idle.tv_sec = 0;
idle.tv_usec = 0;
}
for ( l = 0; slap_listeners[l] != NULL; l++ ) {
if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
continue;
#ifdef LDAP_CONNECTIONLESS
/* Since this is connectionless, the data port is the
* listening port. The listen() and accept() calls
* are unnecessary.
*/
if ( slap_listeners[l]->sl_is_udp ) {
slapd_add( slap_listeners[l]->sl_sd );
continue;
}
#endif
if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
int err = sock_errno();
#ifdef LDAP_PF_INET6
/* If error is EADDRINUSE, we are trying to listen to INADDR_ANY and
* we are already listening to in6addr_any, then we want to ignore
* this and continue.
*/
if ( err == EADDRINUSE ) {
int i;
struct sockaddr_in sa = slap_listeners[l]->sl_sa.sa_in_addr;
struct sockaddr_in6 sa6;
if ( sa.sin_family == AF_INET &&
sa.sin_addr.s_addr == htonl(INADDR_ANY) ) {
for ( i = 0 ; i < l; i++ ) {
sa6 = slap_listeners[i]->sl_sa.sa_in6_addr;
if ( sa6.sin6_family == AF_INET6 &&
!memcmp( &sa6.sin6_addr, &in6addr_any, sizeof(struct in6_addr) ) )
break;
}
if ( i < l ) {
/* We are already listening to in6addr_any */
#ifdef NEW_LOGGING
LDAP_LOG(CONNECTION, WARNING,
"slapd_daemon_task: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: Attempt to listen to 0.0.0.0 failed, already listening on ::, assuming IPv4 included\n",
0, 0, 0 );
#endif
slapd_close( slap_listeners[l]->sl_sd );
slap_listeners[l]->sl_sd = AC_SOCKET_INVALID;
continue;
}
}
}
#endif
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, ERR,
"slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
slap_listeners[l]->sl_url.bv_val, err, sock_errstr(err) );
#else
Debug( LDAP_DEBUG_ANY,
"daemon: listen(%s, 5) failed errno=%d (%s)\n",
slap_listeners[l]->sl_url.bv_val, err,
sock_errstr(err) );
#endif
return( (void*)-1 );
}
slapd_add( slap_listeners[l]->sl_sd );
}
#ifdef HAVE_NT_SERVICE_MANAGER
if ( started_event != NULL ) {
ldap_pvt_thread_cond_signal( &started_event );
}
#endif
/* initialization complete. Here comes the loop. */
while ( !slapd_shutdown ) {
ber_socket_t i;
int ns;
int at;
ber_socket_t nfds;
#define SLAPD_EBADF_LIMIT 16
int ebadf = 0;
time_t now;
fd_set readfds;
fd_set writefds;
Sockaddr from;
struct timeval tv;
struct timeval *tvp;
now = slap_get_time();
if( ( global_idletimeout > 0 ) &&
difftime( last_idle_check +
global_idletimeout/SLAPD_IDLE_CHECK_LIMIT, now ) < 0 ) {
connections_timeout_idle( now );
last_idle_check = now;
}
tv = idle;
#ifdef SIGHUP
if( slapd_gentle_shutdown ) {
ber_socket_t active;
if( slapd_gentle_shutdown == 1 ) {
Debug( LDAP_DEBUG_ANY, "slapd gentle shutdown\n", 0, 0, 0 );
close_listeners( 1 );
global_restrictops |= SLAP_RESTRICT_OP_WRITES;
slapd_gentle_shutdown = 2;
}
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
active = slap_daemon.sd_nactives;
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
if( active == 0 ) {
slapd_shutdown = 2;
break;
}
}
#endif
FD_ZERO( &writefds );
FD_ZERO( &readfds );
at = 0;
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
#ifdef FD_SET_MANUAL_COPY
for( s = 0; s < nfds; s++ ) {
if(FD_ISSET( &slap_sd_readers, s )) {
FD_SET( s, &readfds );
}
if(FD_ISSET( &slap_sd_writers, s )) {
FD_SET( s, &writefds );
}
}
#else
AC_MEMCPY( &readfds, &slap_daemon.sd_readers, sizeof(fd_set) );
AC_MEMCPY( &writefds, &slap_daemon.sd_writers, sizeof(fd_set) );
#endif
assert(!FD_ISSET(wake_sds[0], &readfds));
FD_SET( wake_sds[0], &readfds );
for ( l = 0; slap_listeners[l] != NULL; l++ ) {
if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
continue;
if ( slap_listeners[l]->sl_is_mute )
FD_CLR( slap_listeners[l]->sl_sd, &readfds );
else
if (!FD_ISSET(slap_listeners[l]->sl_sd, &readfds))
FD_SET( slap_listeners[l]->sl_sd, &readfds );
}
#ifndef HAVE_WINSOCK
nfds = slap_daemon.sd_nfds;
#else
nfds = dtblsize;
#endif
if ( global_idletimeout && slap_daemon.sd_nactives )
at = 1;
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
if ( !at )
at = ldap_pvt_thread_pool_backload(&connection_pool);
#if defined( HAVE_YIELDING_SELECT ) || defined( NO_THREADS )
tvp = NULL;
#else
tvp = at ? &tv : NULL;
#endif
for ( l = 0; slap_listeners[l] != NULL; l++ ) {
if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID ||
slap_listeners[l]->sl_is_mute )
continue;
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL1,
"slapd_daemon_task: select: listen=%d "
"active_threads=%d tvp=%s\n",
slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "idle" );
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: select: listen=%d active_threads=%d tvp=%s\n",
slap_listeners[l]->sl_sd, at,
tvp == NULL ? "NULL" : "idle" );
#endif
}
switch(ns = select( nfds, &readfds,
#ifdef HAVE_WINSOCK
/* don't pass empty fd_set */
( writefds.fd_count > 0 ? &writefds : NULL ),
#else
&writefds,
#endif
NULL, tvp ))
{
case -1: { /* failure - try again */
int err = sock_errno();
if( err == EBADF
#ifdef WSAENOTSOCK
/* you'd think this would be EBADF */
|| err == WSAENOTSOCK
#endif
) {
if (++ebadf < SLAPD_EBADF_LIMIT)
continue;
}
if( err != EINTR ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, INFO,
"slapd_daemon_task: select failed (%d): %s\n",
err, sock_errstr(err), 0 );
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: select failed (%d): %s\n",
err, sock_errstr(err), 0 );
#endif
slapd_shutdown = 2;
}
}
continue;
case 0: /* timeout - let threads run */
ebadf = 0;
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
"slapd_daemon_task: select timeout - yielding\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
0, 0, 0 );
#endif
ldap_pvt_thread_yield();
continue;
default: /* something happened - deal with it */
if( slapd_shutdown ) continue;
ebadf = 0;
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
"slapd_daemon_task: activity on %d descriptors\n", ns, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
ns, 0, 0 );
#endif
/* FALL THRU */
}
if( FD_ISSET( wake_sds[0], &readfds ) ) {
char c[BUFSIZ];
tcp_read( wake_sds[0], c, sizeof(c) );
#if defined(NO_THREADS) || defined(HAVE_GNU_PTH)
waking = 0;
#endif
continue;
}
for ( l = 0; slap_listeners[l] != NULL; l++ ) {
ber_socket_t s;
socklen_t len = sizeof(from);
long id;
slap_ssf_t ssf = 0;
char *authid = NULL;
#ifdef SLAPD_RLOOKUPS
char hbuf[NI_MAXHOST];
#endif
char *dnsname = NULL;
char *peeraddr = NULL;
#ifdef LDAP_PF_LOCAL
char peername[MAXPATHLEN + sizeof("PATH=")];
#elif defined(LDAP_PF_INET6)
char peername[sizeof("IP=ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 65535")];
#else
char peername[sizeof("IP=255.255.255.255:65336")];
#endif /* LDAP_PF_LOCAL */
peername[0] = '\0';
if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
continue;
if ( !FD_ISSET( slap_listeners[l]->sl_sd, &readfds ) )
continue;
#ifdef LDAP_CONNECTIONLESS
if ( slap_listeners[l]->sl_is_udp ) {
/* The first time we receive a query, we set this
* up as a "connection". It remains open for the life
* of the slapd.
*/
if ( slap_listeners[l]->sl_is_udp < 2 ) {
id = connection_init(
slap_listeners[l]->sl_sd,
slap_listeners[l], "", "",
2, ssf, authid );
slap_listeners[l]->sl_is_udp++;
}
continue;
}
#endif
/* Don't need to look at this in the data loops */
FD_CLR( slap_listeners[l]->sl_sd, &readfds );
FD_CLR( slap_listeners[l]->sl_sd, &writefds );
s = accept( slap_listeners[l]->sl_sd,
(struct sockaddr *) &from, &len );
if ( s == AC_SOCKET_INVALID ) {
int err = sock_errno();
if(
#ifdef EMFILE
err == EMFILE ||
#endif
#ifdef ENFILE
err == ENFILE ||
#endif
0 )
{
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
emfile++;
/* Stop listening until an existing session closes */
slap_listeners[l]->sl_is_mute = 1;
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
}
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, ERR,
"slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
(long)slap_listeners[l]->sl_sd,
err, sock_errstr(err) );
#else
Debug( LDAP_DEBUG_ANY,
"daemon: accept(%ld) failed errno=%d (%s)\n",
(long) slap_listeners[l]->sl_sd, err,
sock_errstr(err) );
#endif
ldap_pvt_thread_yield();
continue;
}
#ifndef HAVE_WINSOCK
/* make sure descriptor number isn't too great */
if ( s >= dtblsize ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, ERR,
"slapd_daemon_task: %ld beyond descriptor table size %ld\n",
(long)s, (long)dtblsize, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"daemon: %ld beyond descriptor table size %ld\n",
(long) s, (long) dtblsize, 0 );
#endif
slapd_close(s);
ldap_pvt_thread_yield();
continue;
}
#endif
#ifdef LDAP_DEBUG
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
/* newly accepted stream should not be in any of the FD SETS */
assert( !FD_ISSET( s, &slap_daemon.sd_actives) );
assert( !FD_ISSET( s, &slap_daemon.sd_readers) );
assert( !FD_ISSET( s, &slap_daemon.sd_writers) );
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
#endif
#if defined( SO_KEEPALIVE ) || defined( TCP_NODELAY )
#ifdef LDAP_PF_LOCAL
/* for IPv4 and IPv6 sockets only */
if ( from.sa_addr.sa_family != AF_LOCAL )
#endif /* LDAP_PF_LOCAL */
{
int rc;
int tmp;
#ifdef SO_KEEPALIVE
/* enable keep alives */
tmp = 1;
rc = setsockopt( s, SOL_SOCKET, SO_KEEPALIVE,
(char *) &tmp, sizeof(tmp) );
if ( rc == AC_SOCKET_ERROR ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, ERR,
"slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE)"
" failed errno=%d (%s)\n",
(long)s, err, sock_errstr(err) );
#else
Debug( LDAP_DEBUG_ANY,
"slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
#endif
}
#endif
#ifdef TCP_NODELAY
/* enable no delay */
tmp = 1;
rc = setsockopt( s, IPPROTO_TCP, TCP_NODELAY,
(char *)&tmp, sizeof(tmp) );
if ( rc == AC_SOCKET_ERROR ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, ERR,
"slapd_daemon_task: setsockopt( %ld, "
"TCP_NODELAY) failed errno=%d (%s)\n",
(long)s, err, sock_errstr(err) );
#else
Debug( LDAP_DEBUG_ANY,
"slapd(%ld): setsockopt(TCP_NODELAY) failed "
"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
#endif
}
#endif
}
#endif
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL1,
"slapd_daemon_task: new connection on %ld\n", (long)s, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
(long) s, 0, 0 );
#endif
switch ( from.sa_addr.sa_family ) {
# ifdef LDAP_PF_LOCAL
case AF_LOCAL:
sprintf( peername, "PATH=%s", from.sa_un_addr.sun_path );
ssf = LDAP_PVT_SASL_LOCAL_SSF;
{
uid_t uid;
gid_t gid;
if( getpeereid( s, &uid, &gid ) == 0 ) {
authid = ch_malloc(
sizeof("uidnumber=4294967295+gidnumber=4294967295,"
"cn=peercred,cn=external,cn=auth"));
sprintf(authid, "uidnumber=%d+gidnumber=%d,"
"cn=peercred,cn=external,cn=auth",
(int) uid, (int) gid);
}
}
dnsname = "local";
break;
#endif /* LDAP_PF_LOCAL */
# ifdef LDAP_PF_INET6
case AF_INET6:
if ( IN6_IS_ADDR_V4MAPPED(&from.sa_in6_addr.sin6_addr) ) {
peeraddr = inet_ntoa( *((struct in_addr *)
&from.sa_in6_addr.sin6_addr.s6_addr[12]) );
sprintf( peername, "IP=%s:%d",
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
(unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
} else {
char addr[INET6_ADDRSTRLEN];
peeraddr = (char *) inet_ntop( AF_INET6,
&from.sa_in6_addr.sin6_addr,
addr, sizeof addr );
sprintf( peername, "IP=%s %d",
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
(unsigned) ntohs( from.sa_in6_addr.sin6_port ) );
}
break;
# endif /* LDAP_PF_INET6 */
case AF_INET:
peeraddr = inet_ntoa( from.sa_in_addr.sin_addr );
sprintf( peername, "IP=%s:%d",
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
(unsigned) ntohs( from.sa_in_addr.sin_port ) );
break;
default:
slapd_close(s);
continue;
}
if ( ( from.sa_addr.sa_family == AF_INET )
#ifdef LDAP_PF_INET6
|| ( from.sa_addr.sa_family == AF_INET6 )
#endif
) {
#ifdef SLAPD_RLOOKUPS
if ( use_reverse_lookup ) {
char *herr;
if (ldap_pvt_get_hname( (const struct sockaddr *)&from, len, hbuf,
sizeof(hbuf), &herr ) == 0) {
ldap_pvt_str2lower( hbuf );
dnsname = hbuf;
}
}
#else
dnsname = NULL;
#endif /* SLAPD_RLOOKUPS */
#ifdef HAVE_TCPD
if ( !hosts_ctl("slapd",
dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
SLAP_STRING_UNKNOWN ))
{
/* DENY ACCESS */
Statslog( LDAP_DEBUG_STATS,
"fd=%ld DENIED from %s (%s)\n",
(long) s,
dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
0, 0 );
slapd_close(s);
continue;
}
#endif /* HAVE_TCPD */
}
id = connection_init(s,
slap_listeners[l],
dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
peername,
#ifdef HAVE_TLS
slap_listeners[l]->sl_is_tls,
#else
0,
#endif
ssf,
authid );
if( authid ) ch_free(authid);
if( id < 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, INFO,
"slapd_daemon_task: "
"connection_init(%ld, %s, %s) "
"failed.\n",
(long)s, peername,
slap_listeners[l]->sl_name.bv_val );
#else
Debug( LDAP_DEBUG_ANY,
"daemon: connection_init(%ld, %s, %s) "
"failed.\n",
(long) s,
peername,
slap_listeners[l]->sl_name.bv_val );
#endif
slapd_close(s);
continue;
}
Statslog( LDAP_DEBUG_STATS,
"conn=%ld fd=%ld ACCEPT from %s (%s)\n",
id, (long) s,
peername,
slap_listeners[l]->sl_name.bv_val,
0 );
slapd_add( s );
continue;
}
#ifdef LDAP_DEBUG
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
"slapd_daemon_task: activity on ", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
#endif
#ifdef HAVE_WINSOCK
for ( i = 0; i < readfds.fd_count; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
" %d%s", readfds.fd_array[i], "r", 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, " %d%s",
readfds.fd_array[i], "r", 0 );
#endif
}
for ( i = 0; i < writefds.fd_count; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
" %d%s", writefds.fd_array[i], "w" , 0 );
#else
Debug( LDAP_DEBUG_CONNS, " %d%s",
writefds.fd_array[i], "w", 0 );
#endif
}
#else
for ( i = 0; i < nfds; i++ ) {
int r, w;
r = FD_ISSET( i, &readfds );
w = FD_ISSET( i, &writefds );
if ( r || w ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
" %d%s%s", i, r ? "r" : "", w ? "w" : "" );
#else
Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
r ? "r" : "", w ? "w" : "" );
#endif
}
}
#endif
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2, "\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
#endif
#endif
/* loop through the writers */
#ifdef HAVE_WINSOCK
for ( i = 0; i < writefds.fd_count; i++ )
#else
for ( i = 0; i < nfds; i++ )
#endif
{
ber_socket_t wd;
#ifdef HAVE_WINSOCK
wd = writefds.fd_array[i];
#else
if( ! FD_ISSET( i, &writefds ) ) {
continue;
}
wd = i;
#endif
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
"slapd_daemon_task: write active on %d\n", wd, 0, 0 );
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: write active on %d\n",
wd, 0, 0 );
#endif
/*
* NOTE: it is possible that the connection was closed
* and that the stream is now inactive.
* connection_write() must valid the stream is still
* active.
*/
if ( connection_write( wd ) < 0 ) {
FD_CLR( (unsigned) wd, &readfds );
slapd_close( wd );
}
}
#ifdef HAVE_WINSOCK
for ( i = 0; i < readfds.fd_count; i++ )
#else
for ( i = 0; i < nfds; i++ )
#endif
{
ber_socket_t rd;
#ifdef HAVE_WINSOCK
rd = readfds.fd_array[i];
#else
if( ! FD_ISSET( i, &readfds ) ) {
continue;
}
rd = i;
#endif
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, DETAIL2,
"slapd_daemon_task: read activity on %d\n", rd, 0, 0 );
#else
Debug ( LDAP_DEBUG_CONNS,
"daemon: read activity on %d\n", rd, 0, 0 );
#endif
/*
* NOTE: it is possible that the connection was closed
* and that the stream is now inactive.
* connection_read() must valid the stream is still
* active.
*/
if ( connection_read( rd ) < 0 ) {
slapd_close( rd );
}
}
ldap_pvt_thread_yield();
}
if( slapd_shutdown == 1 ) {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, CRIT,
"slapd_daemon_task: shutdown requested and initiated.\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: shutdown requested and initiated.\n",
0, 0, 0 );
#endif
} else if ( slapd_shutdown == 2 ) {
#ifdef HAVE_NT_SERVICE_MANAGER
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, CRIT,
"slapd_daemon_task: shutdown initiated by Service Manager.\n",
0, 0, 0);
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: shutdown initiated by Service Manager.\n",
0, 0, 0);
#endif
#else /* !HAVE_NT_SERVICE_MANAGER */
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, CRIT,
"slapd_daemon_task: abnormal condition, "
"shutdown initiated.\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: abnormal condition, shutdown initiated.\n",
0, 0, 0 );
#endif
#endif /* !HAVE_NT_SERVICE_MANAGER */
} else {
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, CRIT,
"slapd_daemon_task: no active streams, shutdown initiated.\n",
0, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: no active streams, shutdown initiated.\n",
0, 0, 0 );
#endif
}
if( slapd_gentle_shutdown != 2 ) {
close_listeners ( 0 );
}
free ( slap_listeners );
slap_listeners = NULL;
if( !slapd_gentle_shutdown ) {
connections_shutdown();
}
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, CRIT,
"slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"slapd shutdown: waiting for %d threads to terminate\n",
ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
#endif
ldap_pvt_thread_pool_destroy(&connection_pool, 1);
return NULL;
}
// 受信した応答の行数を返す
static int scip_response(urg_t *urg, const char* command,
const int expected_ret[], int timeout,
char *receive_buffer, int receive_buffer_max_size)
{
char *p = receive_buffer;
char buffer[BUFFER_SIZE];
int filled_size = 0;
int line_number = 0;
int ret = URG_UNKNOWN_ERROR;
int write_size = (int)strlen(command);
int n = connection_write(&urg->connection, command, write_size);
if (n != write_size) {
return set_errno_and_return(urg, URG_SEND_ERROR);
}
if (p) {
*p = '\0';
}
do {
n = connection_readline(&urg->connection, buffer, BUFFER_SIZE, timeout);
if (n < 0) {
return set_errno_and_return(urg, URG_NO_RESPONSE);
} else if (p && (line_number > 0)
&& (n < (receive_buffer_max_size - filled_size))) {
// エコーバックは完全一致のチェックを行うため、格納しない
memcpy(p, buffer, n);
p += n;
*p++ = '\0';
filled_size += n;
}
if (line_number == 0) {
// エコーバック文字列が、一致するかを確認する
if (strncmp(buffer, command, write_size - 1)) {
return set_errno_and_return(urg, URG_INVALID_RESPONSE);
}
} else if (n > 0 && !(line_number == 1 && n == 1)) {
// エコーバック以外の行のチェックサムを評価する(SCIP 1.1 応答の場合は無視する)
char checksum = buffer[n - 1];
if ((checksum != scip_checksum(buffer, n - 1)) &&
(checksum != scip_checksum(buffer, n - 2))) {
return set_errno_and_return(urg, URG_CHECKSUM_ERROR);
}
}
// ステータス応答を評価して、戻り値を決定する
if (line_number == 1) {
if (n == 1) {
// SCIP 1.1 応答の場合は、正常応答とみなす
ret = 0;
} else if (n != 3) {
return set_errno_and_return(urg, URG_INVALID_RESPONSE);
} else {
int i;
int actual_ret = strtol(buffer, NULL, 10);
for (i = 0; expected_ret[i] != EXPECTED_END; ++i) {
if (expected_ret[i] == actual_ret) {
ret = 0;
break;
}
}
}
}
++line_number;
} while (n > 0);
return (ret < 0) ? ret : (line_number - 1);
}
int send_packet ( struct connection * connection,
struct packet * p )
{
p->checksum = compute_checksum( p );
return connection_write( connection, p );
}
int urg_raw_write(urg_t *urg, const char *data, int data_size)
{
return connection_write(&urg->connection, data, data_size);
}
