isns/isnsd/server.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.
 */

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <poll.h>
#ifdef DEBUG
#include <time.h>
#endif

#include "isns_server.h"
#include "isns_cache.h"
#include "isns_pdu.h"
#include "isns_msgq.h"
#include "isns_func.h"
#include "isns_log.h"
#include "isns_provider.h"

/* external functions */
#ifdef DEBUG
extern void dump_pdu1(isns_pdu_t *);
extern int verbose_tc;
#endif

extern boolean_t time_to_exit;

void *
isns_connection(
    void *arg
)
{
    int status = 0;

    conn_arg_t *conn;

    isns_pdu_t *pdu, *combined_pdu, *new_combined_pdu;
    uint8_t *payload_ptr;
    size_t pdu_sz;

    conn = (conn_arg_t *)arg;

    conn->out_packet.pdu = NULL;
    conn->out_packet.sz = 0;
    combined_pdu = NULL;
    pdu = NULL;

    while (status == 0 &&
        time_to_exit == B_FALSE &&
        isns_rcv_pdu(conn->so, &pdu, &pdu_sz, ISNS_RCV_TIMEOUT) > 0) {
        uint16_t flags = pdu->flags;
        if (ISNS_MSG_RECEIVED_ENABLED()) {
            char buf[INET6_ADDRSTRLEN];
            struct sockaddr_storage *ssp = &conn->ss;
            struct sockaddr_in *sinp = (struct sockaddr_in *)ssp;
            if (ssp->ss_family == AF_INET) {
                (void) inet_ntop(AF_INET,
                    (void *)&(sinp->sin_addr),
                    buf, sizeof (buf));
            } else {
                (void) inet_ntop(AF_INET6,
                    (void *)&(sinp->sin_addr),
                    buf, sizeof (buf));
            }
            ISNS_MSG_RECEIVED((uintptr_t)buf);
        }

        if ((flags & ISNS_FLAG_FIRST_PDU) == ISNS_FLAG_FIRST_PDU) {
            if (combined_pdu != NULL || pdu->seq != 0) {
                goto conn_done;
            }
            combined_pdu = pdu;
            pdu = NULL;
        } else {
            if (combined_pdu == NULL ||
                combined_pdu->func_id != pdu->func_id ||
                combined_pdu->xid != pdu->xid ||
                (combined_pdu->seq + 1) != pdu->seq) {
                /* expect the first pdu, the same tranx id */
                /* and the next sequence id */
                goto conn_done;
            }
            new_combined_pdu = (isns_pdu_t *)malloc(
                ISNSP_HEADER_SIZE +
                combined_pdu->payload_len +
                pdu->payload_len);
            if (new_combined_pdu == NULL) {
                goto conn_done;
            }
            (void) memcpy((void *)new_combined_pdu,
                (void *)combined_pdu,
                ISNSP_HEADER_SIZE + combined_pdu->payload_len);
            payload_ptr = new_combined_pdu->payload +
                combined_pdu->payload_len;
            (void) memcpy((void *)payload_ptr,
                (void *)pdu->payload,
                pdu->payload_len);
            new_combined_pdu->seq = pdu->seq;
            free(combined_pdu);
            combined_pdu = new_combined_pdu;
            free(pdu);
            pdu = NULL;
        }
        if ((flags & ISNS_FLAG_LAST_PDU) == ISNS_FLAG_LAST_PDU) {
#ifdef DEBUG
            time_t t;
            clock_t c;

            dump_pdu1(combined_pdu);

            if (verbose_tc != 0) {
                t = time(NULL);
                c = clock();
            }
#endif

            conn->in_packet.pdu = combined_pdu;
            conn->out_packet.pl = 0;
            conn->ec = 0;

            if (packet_split_verify(conn) == 0) {
                (void) cache_lock(conn->lock);
                status = conn->handler(conn);
                conn->ec = cache_unlock(conn->lock, conn->ec);
            }

            switch (status) {
            case -1:
                /* error */
                break;
            case 0:
                status = isns_response(conn);

                isnslog(LOG_DEBUG, "isns_connection",
                    "Response status: %d.", status);
                if (ISNS_MSG_RESPONDED_ENABLED()) {
                    char buf[INET6_ADDRSTRLEN];
                    struct sockaddr_storage *ssp =
                        &conn->ss;
                    struct sockaddr_in *sinp =
                        (struct sockaddr_in *)ssp;
                    if (ssp->ss_family == AF_INET) {
                        (void) inet_ntop(AF_INET,
                            (void *)&(sinp->sin_addr),
                            buf, sizeof (buf));
                    } else {
                        (void) inet_ntop(AF_INET6,
                            (void *)&(sinp->sin_addr),
                            buf, sizeof (buf));
                    }
                    ISNS_MSG_RESPONDED((uintptr_t)buf);
                }
                break;
            default:
                /* no need to send response message */
                status = 0;
                break;
            }

#ifdef DEBUG
            if (verbose_tc != 0) {
                t = time(NULL) - t;
                c = clock() - c;
                printf("time %d clock %.4lf -msg response\n",
                    t, c / (double)CLOCKS_PER_SEC);
            }
#endif
            free(combined_pdu);
            combined_pdu = NULL;
        }
    }

conn_done:
    if (pdu != NULL) {
        free(pdu);
    }
    if (combined_pdu != NULL) {
        free(combined_pdu);
    }
    (void) close(conn->so);
    (void) free(conn->out_packet.pdu);
    (void) free(conn);

    /* decrease the thread ref count */
    dec_thr_count();

    return (NULL);
}

/* the iSNS server port watcher */

void *
isns_port_watcher(
    /* LINTED E_FUNC_ARG_UNUSED */
    void *arg
)
{
    int s, f;
    int opt = 1;
    struct sockaddr_in sin;
    struct sockaddr_in *sinp;
    struct sockaddr_storage *ssp;
    socklen_t sslen;
    char buf[INET6_ADDRSTRLEN];
    pthread_t tid;
    struct pollfd fds;
    int poll_ret;

    conn_arg_t *conn;

    if ((s = socket(AF_INET, SOCK_STREAM, 0)) != -1) {
        /* IPv4 */
        isnslog(LOG_DEBUG, "isns_port_watcher", "IPv4 socket created.");
        (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *)&opt,
            sizeof (opt));

        sin.sin_family      = AF_INET;
        sin.sin_port        = htons(ISNS_DEFAULT_SERVER_PORT);
        sin.sin_addr.s_addr = htonl(INADDR_ANY);

        if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
            isnslog(LOG_DEBUG, "isns_port_watcher",
                "binding on server port failed: %%m");
            goto watch_failed;
        }
        isnslog(LOG_DEBUG, "isns_port_watcher",
            "successful binding on server port.");
    } else {
        isnslog(LOG_DEBUG, "isns_port_watcher",
            "cannot create socket: %%m.");
        goto watch_failed;
    }

    if (listen(s, 5) < 0) {
        isnslog(LOG_DEBUG, "isns_port_watcher",
            "listening on server port failed: %%m.");
        goto watch_failed;
    }
    isnslog(LOG_DEBUG, "isns_port_watcher", "listening on server port ok.");

    fds.fd = s;
    fds.events = (POLLIN | POLLRDNORM);
    fds.revents = 0;

    /* waiting for connections */
    for (;;) {
        if (time_to_exit) {
            return (NULL);
        }

        poll_ret = poll(&fds, 1, 1000);
        if (poll_ret <= 0) {
            continue;
        }

        /* allocate a connection argument */
        conn = (conn_arg_t *)malloc(sizeof (conn_arg_t));
        if (conn == NULL) {
            isnslog(LOG_DEBUG, "isns_port_watcher",
                "malloc() failed.");
            goto watch_failed;
        }
        ssp = &conn->ss;
        sslen = sizeof (conn->ss);
        f = accept(s, (struct sockaddr *)ssp, &sslen);
        if (f < 0) {
            isnslog(LOG_DEBUG, "isns_port_watcher",
                "accepting connection failed: %%m.");
            goto watch_failed;
        }
        sinp = (struct sockaddr_in *)ssp;
        if (ssp->ss_family == AF_INET) {
            (void) inet_ntop(AF_INET, (void *)&(sinp->sin_addr),
                buf, sizeof (buf));
        } else {
            (void) inet_ntop(AF_INET6, (void *)&(sinp->sin_addr),
                buf, sizeof (buf));
        }
        isnslog(LOG_DEBUG, "isns_port_watcher",
            "connection from %s:%d.", buf,
            sinp->sin_port);

        if (ISNS_CONNECTION_ACCEPTED_ENABLED()) {
            ISNS_CONNECTION_ACCEPTED((uintptr_t)buf);
        }

        conn->so = f;
        /* create an isns connection */
        if (pthread_create(&tid, NULL,
            isns_connection, (void *)conn) != 0) {
            (void) close(f);
            (void) free(conn);
            isnslog(LOG_DEBUG, "isns_port_watcher",
                "pthread_create() failed.");
        } else {
            /* increase the thread ref count */
            inc_thr_count();
        }
    }

watch_failed:
    shutdown_server();
    return (NULL);
}

static uint16_t xid = 0;
static pthread_mutex_t xid_mtx = PTHREAD_MUTEX_INITIALIZER;
uint16_t
get_server_xid(
)
{
    uint16_t tmp;

    (void) pthread_mutex_lock(&xid_mtx);
    tmp = ++ xid;
    (void) pthread_mutex_unlock(&xid_mtx);

    return (tmp);
}