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); }