vscan/vscand/vs_eng.c

/*
 * 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.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * 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 he 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;
        }
        /* LINTED E_CASE_FALL_THROUGH - close connection */
    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);
}