xref: /illumos-gate/usr/src/cmd/vscan/vscand/vs_eng.c (revision 29a5d005)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

/*
 * vs_eng.c manages the vs_engines array of scan engine.
 * Access to the array and other private data is protected by vs_eng_mutex.
 * A caller can wait for an available engine connection on vs_eng_cv
 *
 */

#include <sys/types.h>
#include <sys/synch.h>
#include <sys/socket.h>
#include <sys/filio.h>
#include <sys/ioctl.h>
#include <sys/debug.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <errno.h>
#include <poll.h>
#include <pthread.h>
#include <time.h>

#include <signal.h>
#include <thread.h>

#include "vs_incl.h"

/* max connections per scan engine */
#define	VS_CXN_MAX	VS_VAL_SE_MAXCONN_MAX

/*
 * vs_eng_state_t - connection state
 *
 * Each configured scan engine supports up to vse_cfg.vep_maxconn
 * connections. These connections are represented by a vs_connection_t
 * which defines the connection state, associated socket descriptor
 * and how long the connection has been available. A connection
 * that has been available but unused for vs_inactivity_timeout
 * seconds will be closed by the housekeeper thread.
 *
 * When a scan engine is reconfigured to have less connections
 * (or is disabled) any of the superflous connections which are in
 * AVAILABLE state are closed (DISCONNECTED). Others are set to
 * CLOSE_PENDING to be closed (DISCONNECTED) when the engine is
 * released (when the current request completes).
 *
 *              +---------------------+
 *  |---------->| VS_ENG_DISCONNECTED |<-----------------|
 *  |           +---------------------+                  |
 *  |              |                                     |
 *  |              | eng_get                             |
 *  |              v                                     | release/
 *  | shutdown  +---------------------+   reconfig       | shutdown
 *  |<----------| VS_ENG_RESERVED     | -----------|     |
 *  |           +---------------------+            |     |
 *  |              |                               v     |
 *  |              |                       +----------------------+
 *  |              | connect               | VS_ENG_CLOSE_PENDING |
 *  |              |                       +----------------------+
 *  |              v                               ^
 *  | shutdown  +---------------------+            |
 *  |<----------| VS_ENG_INUSE        |------------|
 *  |           +---------------------+  reconfig/error
 *  |              |           ^
 *  |              | release   | eng_get
 *  | reconfig/    |           |
 *  | timeout/     v           |
 *  | shutdown  +---------------------+
 *  |<----------| VS_ENG_AVAILABLE    |
 *              +---------------------+
 *
 */

typedef enum {
	VS_ENG_DISCONNECTED = 0,
	VS_ENG_RESERVED,
	VS_ENG_INUSE,
	VS_ENG_AVAILABLE,
	VS_ENG_CLOSE_PENDING
} vs_eng_state_t;

typedef struct vs_connection {
	vs_eng_state_t vsc_state;
	int vsc_sockfd;
	struct timeval vsc_avail_time;
} vs_connection_t;

typedef struct vs_engine {
	vs_props_se_t vse_cfg;	/* host, port, maxconn */
	int vse_inuse;		/* # connections in use */
	boolean_t vse_error;
	vs_connection_t vse_cxns[VS_CXN_MAX];
} vs_engine_t;

static vs_engine_t vs_engines[VS_SE_MAX];

static int vs_eng_next;		/* round-robin "finger" */
static int vs_eng_count;	/* how many configured engines */
static int vs_eng_total_maxcon;	/* total configured connections */
static int vs_eng_total_inuse;	/* total connections in use */
static int vs_eng_wait_count;	/* # threads waiting for connection */

static pthread_mutex_t vs_eng_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t vs_eng_cv;
int vs_inactivity_timeout = 60; /* seconds */
int vs_reuse_connection = 1;

time_t vs_eng_wait = VS_ENG_WAIT_DFLT;

/* local functions */
static int vs_eng_connect(char *, int);
static boolean_t vs_eng_check_errors(void);
static int vs_eng_find_connection(int *, int *, boolean_t);
static int vs_eng_find_next(boolean_t);
static int vs_eng_compare(int, char *, int);
static void vs_eng_config_close(vs_engine_t *, int);
static void *vs_eng_housekeeper(void *);


#ifdef FIONBIO
/* non-blocking connect */
static int nbio_connect(int, const struct sockaddr *, int);
int vs_connect_timeout = 5000; /* milliseconds */
#endif /* FIONBIO */


/*
 * vs_eng_init
 */
void
vs_eng_init()
{
	pthread_t tid;

	(void) pthread_cond_init(&vs_eng_cv, NULL);
	(void) pthread_mutex_lock(&vs_eng_mutex);

	(void) memset(vs_engines, 0, sizeof (vs_engine_t) * VS_SE_MAX);

	vs_eng_total_maxcon = 0;
	vs_eng_total_inuse = 0;
	vs_eng_count = 0;
	vs_eng_next = 0;

	(void) pthread_mutex_unlock(&vs_eng_mutex);

	(void) pthread_create(&tid, NULL, vs_eng_housekeeper, NULL);
}


/*
 * vs_eng_config
 *
 * Configure scan engine connections.
 *
 * If a scan engine has been reconfigured (different host or port)
 * the scan engine's error count is reset.
 *
 * If the host/port has changed, the engine has been disabled
 * or less connections are configured now, connections need
 * to be closed or placed in CLOSE_PENDING state (vs_eng_config_close)
 *
 * vs_icap_config is invoked to reset engine-specific data stored
 * in vs_icap.
 *
 */
void
vs_eng_config(vs_props_all_t *config)
{
	int i;
	vs_props_se_t *cfg;
	vs_engine_t *eng;

	(void) pthread_mutex_lock(&vs_eng_mutex);

	vs_eng_count = 0;
	vs_eng_total_maxcon = 0;

	for (i = 0; i < VS_SE_MAX; i++) {
		cfg = &config->va_se[i];
		eng = &vs_engines[i];

		if (vs_eng_compare(i, cfg->vep_host, cfg->vep_port) != 0) {
			vs_eng_config_close(eng, 0);
			eng->vse_error = B_FALSE;
		}

		if (cfg->vep_enable) {
			if (cfg->vep_maxconn < eng->vse_cfg.vep_maxconn)
				vs_eng_config_close(eng, cfg->vep_maxconn);

			eng->vse_cfg = *cfg;
			vs_eng_total_maxcon += cfg->vep_maxconn;
			vs_eng_count++;
		} else {
			vs_eng_config_close(eng, 0);
			(void) memset(&eng->vse_cfg, 0, sizeof (vs_props_se_t));
		}

		vs_icap_config(i, eng->vse_cfg.vep_host, eng->vse_cfg.vep_port);
	}

	if ((vs_eng_total_maxcon <= 0) || (vs_eng_count == 0))
		syslog(LOG_NOTICE, "Scan Engine - no engines configured");

	(void) pthread_mutex_unlock(&vs_eng_mutex);
}


/*
 * vs_eng_config_close
 *
 *	If the host/port has changed, the engine has been disabled
 *	or less connections are configured now, connections need
 *	to be closed or placed in CLOSE_PENDING state
 */
static void
vs_eng_config_close(vs_engine_t *eng, int start_idx)
{
	int i;
	vs_connection_t *cxn;

	for (i = start_idx; i < eng->vse_cfg.vep_maxconn; i++) {
		cxn = &(eng->vse_cxns[i]);

		switch (cxn->vsc_state) {
		case VS_ENG_RESERVED:
		case VS_ENG_INUSE:
			cxn->vsc_state = VS_ENG_CLOSE_PENDING;
			break;
		case VS_ENG_AVAILABLE:
			(void) close(cxn->vsc_sockfd);
			cxn->vsc_sockfd = -1;
			cxn->vsc_state = VS_ENG_DISCONNECTED;
			break;
		case VS_ENG_CLOSE_PENDING:
		case VS_ENG_DISCONNECTED:
			break;
		}
	}
}


/*
 * vs_eng_fini
 */
void
vs_eng_fini()
{
	(void) pthread_cond_destroy(&vs_eng_cv);
}


/*
 * vs_eng_housekeeper
 *
 * Wakeup every (vs_inactivity_timeout / 2) seconds and close
 * any connections that are in AVAILABLE state but have not
 * been used for vs_inactivity_timeout seconds.
 */
/* ARGSUSED */
static void *
vs_eng_housekeeper(void *arg)
{
	struct timeval now;
	long expire;
	int i, j;
	vs_engine_t *eng;
	vs_connection_t *cxn;

	for (;;) {
		(void) sleep(vs_inactivity_timeout / 2);

		if (vscand_get_state() == VS_STATE_SHUTDOWN)
			break;

		(void) gettimeofday(&now, NULL);
		expire = now.tv_sec - vs_inactivity_timeout;

		(void) pthread_mutex_lock(&vs_eng_mutex);
		for (i = 0; i < VS_SE_MAX; i++) {
			eng = &(vs_engines[i]);
			for (j = 0; j < eng->vse_cfg.vep_maxconn; j++) {
				cxn = &(eng->vse_cxns[j]);

				if ((cxn->vsc_state == VS_ENG_AVAILABLE) &&
				    (cxn->vsc_avail_time.tv_sec < expire)) {
					(void) close(cxn->vsc_sockfd);
					cxn->vsc_sockfd = -1;
					cxn->vsc_state = VS_ENG_DISCONNECTED;
				}
			}
		}
		(void) pthread_mutex_unlock(&vs_eng_mutex);
	}

	return (NULL);
}


/*
 * vs_eng_set_error
 *
 * If the engine identified in conn (host, port) matches the
 * engine in vs_engines set or clear the error state of the
 * engine and update the error statistics.
 *
 * If error == 0, clear the error state(B_FALSE), else set
 * the error state (B_TRUE) and increment engine error stats
 */
void
vs_eng_set_error(vs_eng_ctx_t *eng_ctx, int error)
{
	int eidx = eng_ctx->vse_eidx;
	int cidx =  eng_ctx->vse_cidx;
	vs_engine_t *eng;

	(void) pthread_mutex_lock(&vs_eng_mutex);

	eng = &(vs_engines[eidx]);

	if (vs_eng_compare(eidx, eng_ctx->vse_host, eng_ctx->vse_port) == 0)
		eng->vse_error = (error == 0) ? B_FALSE : B_TRUE;

	if (error != 0) {
		eng->vse_cxns[cidx].vsc_state = VS_ENG_CLOSE_PENDING;
		vs_stats_eng_err(eng_ctx->vse_engid);
	}

	(void) pthread_mutex_unlock(&vs_eng_mutex);
}


/*
 * vs_eng_get
 * Get next available scan engine connection.
 * If retry == B_TRUE look for a scan engine with no errors.
 *
 * Returns: 0 - success
 *         -1 - error
 */
int
vs_eng_get(vs_eng_ctx_t *eng_ctx, boolean_t retry)
{
	struct timespec tswait;
	int eidx, cidx, sockfd;
	vs_engine_t *eng;
	vs_connection_t *cxn;

	(void) pthread_mutex_lock(&vs_eng_mutex);

	/*
	 * If no engines connections configured OR
	 * retry and only one engine configured, give up
	 */
	if ((vs_eng_total_maxcon <= 0) ||
	    ((retry == B_TRUE) && (vs_eng_count <= 1))) {
		(void) pthread_mutex_unlock(&vs_eng_mutex);
		return (-1);
	}

	tswait.tv_sec = vs_eng_wait;
	tswait.tv_nsec = 0;

	while ((vscand_get_state() != VS_STATE_SHUTDOWN) &&
	    (vs_eng_find_connection(&eidx, &cidx, retry) == -1)) {
		/* If retry and all configured engines have errors, give up */
		if (retry && vs_eng_check_errors() == B_TRUE) {
			(void) pthread_mutex_unlock(&vs_eng_mutex);
			return (-1);
		}

		/* wait for a connection to become available */
		vs_eng_wait_count++;
		if (pthread_cond_reltimedwait_np(&vs_eng_cv, &vs_eng_mutex,
		    &tswait) < 0) {
			syslog(LOG_NOTICE, "Scan Engine "
			    "- timeout waiting for available engine");
			vs_eng_wait_count--;
			(void) pthread_mutex_unlock(&vs_eng_mutex);
			return (-1);
		}
		vs_eng_wait_count--;
	}

	if (vscand_get_state() == VS_STATE_SHUTDOWN) {
		(void) pthread_mutex_unlock(&vs_eng_mutex);
		return (-1);
	}

	eng = &(vs_engines[eidx]);
	cxn = &(eng->vse_cxns[cidx]);

	/* update in use counts */
	eng->vse_inuse++;
	vs_eng_total_inuse++;

	/* update round-robin index */
	if (!retry)
		vs_eng_next = (eidx == VS_SE_MAX) ? 0 : eidx + 1;

	/* populate vs_eng_ctx_t */
	eng_ctx->vse_eidx = eidx;
	eng_ctx->vse_cidx = cidx;
	(void) strlcpy(eng_ctx->vse_engid, eng->vse_cfg.vep_engid,
	    sizeof (eng_ctx->vse_engid));
	(void) strlcpy(eng_ctx->vse_host, eng->vse_cfg.vep_host,
	    sizeof (eng_ctx->vse_host));
	eng_ctx->vse_port = eng->vse_cfg.vep_port;
	eng_ctx->vse_sockfd = cxn->vsc_sockfd;

	if (cxn->vsc_state == VS_ENG_INUSE) {
		(void) pthread_mutex_unlock(&vs_eng_mutex);
		return (0);
	}

	/* state == VS_ENG_RESERVED, need to connect */

	(void) pthread_mutex_unlock(&vs_eng_mutex);

	sockfd = vs_eng_connect(eng_ctx->vse_host, eng_ctx->vse_port);

	/* retry a failed connection once */
	if (sockfd == -1) {
		(void) sleep(1);
		sockfd = vs_eng_connect(eng_ctx->vse_host, eng_ctx->vse_port);
	}

	if (sockfd == -1) {
		syslog(LOG_NOTICE, "Scan Engine - connection error (%s:%d) %s",
		    eng_ctx->vse_host, eng_ctx->vse_port,
		    errno ? strerror(errno) : "");
		vs_eng_set_error(eng_ctx, 1);
		vs_eng_release(eng_ctx);
		return (-1);
	}

	(void) pthread_mutex_lock(&vs_eng_mutex);
	switch (cxn->vsc_state) {
	case VS_ENG_DISCONNECTED:
		/* SHUTDOWN occured */
		(void) pthread_mutex_unlock(&vs_eng_mutex);
		vs_eng_release(eng_ctx);
		return (-1);
	case VS_ENG_RESERVED:
		cxn->vsc_state = VS_ENG_INUSE;
		break;
	case VS_ENG_CLOSE_PENDING:
		/* reconfigure occured. Connection will be closed after use */
		break;
	case VS_ENG_INUSE:
	case VS_ENG_AVAILABLE:
	default:
		ASSERT(0);
		break;
	}

	cxn->vsc_sockfd = sockfd;
	eng_ctx->vse_sockfd = sockfd;

	(void) pthread_mutex_unlock(&vs_eng_mutex);
	return (0);
}


/*
 * vs_eng_check_errors
 *
 * Check if all engines with maxconn > 0 are in error state
 *
 * Returns: B_TRUE  - all (valid) engines are in error state
 *          B_FALSE - otherwise
 */
static boolean_t
vs_eng_check_errors()
{
	int i;

	for (i = 0; i < VS_SE_MAX; i++) {
		if (vs_engines[i].vse_cfg.vep_maxconn > 0 &&
		    (vs_engines[i].vse_error == B_FALSE))
			return (B_FALSE);
	}

	return (B_TRUE);
}


/*
 * vs_eng_find_connection
 *
 * Identify the next engine to be used (vs_eng_find_next()).
 * Select the engine's first connection in AVAILABLE state.
 * If no connection is in AVAILABLE state, select the first
 * that is in DISCONNECTED state.
 *
 * Returns: 0 success
 *         -1 no engine connections available (eng_idx & cxn_idx undefined)
 */
static int
vs_eng_find_connection(int *eng_idx, int *cxn_idx, boolean_t retry)
{
	int i, idx;
	vs_engine_t *eng;
	vs_connection_t *cxn;

	/* identify engine */
	if ((idx = vs_eng_find_next(retry)) == -1)
		return (-1);

	eng = &(vs_engines[idx]);
	*eng_idx = idx;

	/* identify connection */
	idx = -1;
	for (i = 0; i < eng->vse_cfg.vep_maxconn; i++) {
		cxn = &(eng->vse_cxns[i]);
		if (cxn->vsc_state == VS_ENG_AVAILABLE) {
			*cxn_idx = i;
			cxn->vsc_state = VS_ENG_INUSE;
			return (0);
		}

		if ((idx == -1) &&
		    (cxn->vsc_state == VS_ENG_DISCONNECTED)) {
			idx = i;
		}
	}

	if (idx == -1)
		return (-1);

	eng->vse_cxns[idx].vsc_state = VS_ENG_RESERVED;
	*cxn_idx = idx;
	return (0);
}


/*
 * vs_eng_find_next
 *
 * Returns: -1 no engine connections available
 *          idx of engine to use
 */
static int
vs_eng_find_next(boolean_t retry)
{
	int i;

	for (i = vs_eng_next; i < VS_SE_MAX; i++) {
		if (vs_engines[i].vse_inuse <
		    vs_engines[i].vse_cfg.vep_maxconn) {
			if (!retry || (vs_engines[i].vse_error == B_FALSE))
				return (i);
		}
	}

	for (i = 0; i < vs_eng_next; i++) {
		if (vs_engines[i].vse_inuse <
		    vs_engines[i].vse_cfg.vep_maxconn) {
			if (!retry || (vs_engines[i].vse_error == B_FALSE))
				return (i);
		}
	}

	return (-1);
}


/*
 * vs_eng_release
 */
void
vs_eng_release(const vs_eng_ctx_t *eng_ctx)
{
	int eidx = eng_ctx->vse_eidx;
	int cidx = eng_ctx->vse_cidx;
	vs_connection_t *cxn;

	(void) pthread_mutex_lock(&vs_eng_mutex);
	cxn = &(vs_engines[eidx].vse_cxns[cidx]);

	switch (cxn->vsc_state) {
	case VS_ENG_DISCONNECTED:
		break;
	case VS_ENG_RESERVED:
		cxn->vsc_state = VS_ENG_DISCONNECTED;
		break;
	case VS_ENG_INUSE:
		if (vs_reuse_connection) {
			cxn->vsc_state = VS_ENG_AVAILABLE;
			(void) gettimeofday(&cxn->vsc_avail_time, NULL);
			break;
		}
		/* FALLTHROUGH */
	case VS_ENG_CLOSE_PENDING:
		(void) close(cxn->vsc_sockfd);
		cxn->vsc_sockfd = -1;
		cxn->vsc_state = VS_ENG_DISCONNECTED;
		break;
	case VS_ENG_AVAILABLE:
	default:
		ASSERT(0);
		break;
	}

	/* decrement in use counts */
	vs_engines[eidx].vse_inuse--;
	vs_eng_total_inuse--;

	/* wake up next thread waiting for a connection */
	(void) pthread_cond_signal(&vs_eng_cv);

	(void) pthread_mutex_unlock(&vs_eng_mutex);
}


/*
 * vs_eng_close_connections
 *
 * Set vs_eng_total_maxcon to 0 to ensure no new engine sessions
 * can be initiated.
 * Close all open connections to abort in-progress scans.
 * Set connection state to DISCONNECTED.
 */
void
vs_eng_close_connections(void)
{
	int i, j;
	vs_connection_t *cxn;

	(void) pthread_mutex_lock(&vs_eng_mutex);
	vs_eng_total_maxcon = 0;

	for (i = 0; i < VS_SE_MAX; i++) {
		for (j = 0; j < VS_CXN_MAX; j++) {
			cxn = &(vs_engines[i].vse_cxns[j]);

			switch (cxn->vsc_state) {
			case VS_ENG_INUSE:
			case VS_ENG_AVAILABLE:
			case VS_ENG_CLOSE_PENDING:
				(void) close(cxn->vsc_sockfd);
				cxn->vsc_sockfd = -1;
				break;
			case VS_ENG_DISCONNECTED:
			case VS_ENG_RESERVED:
			default:
				break;

			}

			cxn->vsc_state = VS_ENG_DISCONNECTED;
		}
	}
	(void) pthread_mutex_unlock(&vs_eng_mutex);
}


/*
 * vs_eng_connect
 * open socket connection to remote scan engine
 *
 * Returns: sockfd or -1 (error)
 */
static int
vs_eng_connect(char *host, int port)
{
	int rc, sockfd, opt_nodelay, opt_keepalive, opt_reuseaddr, err_num;
	struct sockaddr_in addr;
	struct hostent *hp;

	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
		return (-1);

	hp = getipnodebyname(host, AF_INET, 0, &err_num);
	if (hp == NULL) {
		(void) close(sockfd);
		return (-1);
	}

	(void) memset(&addr, 0, sizeof (addr));
	(void) memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);
	addr.sin_port = htons(port);
	addr.sin_family = hp->h_addrtype;
	freehostent(hp);

#ifdef FIONBIO /* Use non-blocking mode for connect. */
	rc = nbio_connect(sockfd, (struct sockaddr *)&addr,
	    sizeof (struct sockaddr));
#else
	rc = connect(sockfd, (struct sockaddr *)&addr,
	    sizeof (struct sockaddr));
#endif

	opt_nodelay = 1;
	opt_keepalive = 1;
	opt_reuseaddr = 1;

	if ((rc < 0) ||
	    (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY,
	    &opt_nodelay, sizeof (opt_nodelay)) < 0) ||
	    (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
	    &opt_keepalive, sizeof (opt_keepalive)) < 0) ||
	    (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
	    &opt_reuseaddr, sizeof (opt_reuseaddr)) < 0)) {
		(void) close(sockfd);
		return (-1);
	}

	return (sockfd);
}


/*
 * nbio_connect
 *
 * Attempt to do a non-blocking connect call.
 * Wait for a maximum of "vs_connect_timeout" millisec, then check for
 * socket error to determine if connect successful or not.
 */
#ifdef FIONBIO
static int
nbio_connect(int sockfd, const struct sockaddr *sa, int sa_len)
{
	struct pollfd pfd;
	int nbio, rc;
	int error, len = sizeof (error);

	nbio = 1;
	if ((ioctl(sockfd, FIONBIO, &nbio)) < 0)
		return (connect(sockfd, sa, sa_len));

	if ((rc = connect(sockfd, sa, sa_len)) != 0) {
		if (errno == EINPROGRESS || errno == EINTR) {
			errno = 0;
			pfd.fd = sockfd;
			pfd.events = POLLOUT;
			pfd.revents = 0;

			if ((rc = poll(&pfd, 1, vs_connect_timeout)) <= 0) {
				if (rc == 0)
					errno = ETIMEDOUT;
				rc = -1;
			} else {
				if ((pfd.revents &
				    (POLLHUP | POLLERR | POLLNVAL)) ||
				    (!(pfd.revents & POLLOUT))) {
					rc = -1;
				} else {
					rc = getsockopt(sockfd, SOL_SOCKET,
					    SO_ERROR, &error, &len);
					if (rc != 0 || error != 0)
						rc = -1;
					if (error != 0)
						errno = error;
				}
			}
		}
	}

	nbio = 0;
	(void) ioctl(sockfd, FIONBIO, &nbio);

	return (rc);
}
#endif


/*
 * vs_eng_scanstamp_current
 *
 * Check if scanstamp matches that of ANY engine with no errors.
 * We cannot include engines with errors as they may have been
 * inaccessible for a long time and thus we may have an old
 * scanstamp value for them.
 * If a match is found the scanstamp is considered to be current
 *
 * returns: 1 if current, 0 otherwise
 */
int
vs_eng_scanstamp_current(vs_scanstamp_t scanstamp)
{
	int i;

	/* if scan stamp is null, not current */
	if (scanstamp[0] == '\0')
		return (0);

	/* if scanstamp matches that of any enabled engine with no errors */
	(void) pthread_mutex_lock(&vs_eng_mutex);
	for (i = 0; i < VS_SE_MAX; i++) {
		if ((vs_engines[i].vse_cfg.vep_enable) &&
		    (vs_engines[i].vse_error == B_FALSE) &&
		    (vs_icap_compare_scanstamp(i, scanstamp) == 0))
			break;
	}
	(void) pthread_mutex_unlock(&vs_eng_mutex);

	return ((i < VS_SE_MAX) ? 1 : 0);
}


/*
 * vs_eng_compare
 * compare host and port with that stored for engine idx
 *
 * Returns: 0 - if equal
 */
static int
vs_eng_compare(int idx, char *host, int port)
{
	if (vs_engines[idx].vse_cfg.vep_port != port)
		return (-1);

	if (strcmp(vs_engines[idx].vse_cfg.vep_host, host) != 0)
		return (-1);

	return (0);
}