xref: /illumos-gate/usr/src/cmd/vntsd/listen.c (revision 4d39be2b)

/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Each group has a listen thread. It is created at the time
 * of a group creation and destroyed when a group does not have
 * any console associated with it.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <thread.h>
#include <assert.h>
#include <signal.h>
#include <ctype.h>
#include <syslog.h>
#include "vntsd.h"

#define	    MAX_BIND_RETRIES		6
/*
 * check the state of listen thread. exit if there is an fatal error
 * or the group is removed. Main thread will call free_group
 * to close group socket and free group structure.
 */
static void
listen_chk_status(vntsd_group_t *groupp, int status)
{
	char	    err_msg[VNTSD_LINE_LEN];


	D1(stderr, "t@%d listen_chk_status() status=%d group=%s "
	    "tcp=%lld group status = %x\n", thr_self(), status,
	    groupp->group_name, groupp->tcp_port, groupp->status);

	(void) snprintf(err_msg, sizeof (err_msg),
	    "Group:%s TCP port %lld status %x",
	    groupp->group_name, groupp->tcp_port, groupp->status);


	switch (status) {

	case VNTSD_SUCCESS:
		return;

	case VNTSD_STATUS_INTR:
		/* signal for deleting group */
		assert(groupp->status & VNTSD_GROUP_SIG_WAIT);

		/* let main thread know  */
		(void) mutex_lock(&groupp->lock);
		groupp->status &= ~VNTSD_GROUP_SIG_WAIT;
		(void) cond_signal(&groupp->cvp);
		(void) mutex_unlock(&groupp->lock);

		thr_exit(0);
		break;

	case VNTSD_STATUS_ACCEPT_ERR:
		return;

	case VNTSD_STATUS_NO_CONS:
	default:
		/* fatal error or no console in the group, remove the group. */

		(void) mutex_lock(&groupp->lock);

		if (groupp->status & VNTSD_GROUP_SIG_WAIT) {
			/* group is already in deletion */
			(void) mutex_unlock(&groupp->lock);
			return;
		}

		/*
		 * if there still is console(s) in the group,
		 * the console(s) could not be connected any more because of
		 * a fatal error. Therefore, mark the console and notify
		 * main thread to delete console and group.
		 */
		(void) vntsd_que_walk(groupp->conspq,
		    (el_func_t)vntsd_mark_deleted_cons);
		groupp->status |= VNTSD_GROUP_CLEAN_CONS;

		/* signal main thread to delete the group */
		(void) thr_kill(groupp->vntsd->tid, SIGUSR1);
		(void) mutex_unlock(&groupp->lock);

		/* log error */
		if (status != VNTSD_STATUS_NO_CONS)
			vntsd_log(status, err_msg);
		break;
	}
}

/* allocate and initialize listening socket. */
static int
open_socket(int port_no, int *sockfd)
{

	struct	    sockaddr_in addr;
	int	    on;
	int	    retries = 0;


	/* allocate a socket */
	*sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (*sockfd < 0) {
		if (errno == EINTR) {
			return (VNTSD_STATUS_INTR);
		}
		return (VNTSD_ERR_LISTEN_SOCKET);
	}

#ifdef DEBUG
	/* set reuse local socket address */
	on = 1;
	if (setsockopt(*sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on))) {
		return (VNTSD_ERR_LISTEN_OPTS);
	}
#endif

	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = (vntsd_ip_addr()).s_addr;
	addr.sin_port = htons(port_no);

	/* bind socket */

	for (; ; ) {

		/*
		 * After a socket is closed, the port
		 * is transitioned to TIME_WAIT state.
		 * It may take a few retries to bind
		 * a just released port.
		 */
		if (bind(*sockfd, (struct sockaddr *)&addr,
			    sizeof (addr)) < 0) {

			if (errno == EINTR) {
				return (VNTSD_STATUS_INTR);
			}

			if (errno == EADDRINUSE && retries < MAX_BIND_RETRIES) {
				/* port may be in TIME_WAIT state, retry */
				(void) sleep(5);
				retries++;
				continue;
			}

			return (VNTSD_ERR_LISTEN_BIND);

		}

		break;

	}

	if (listen(*sockfd, VNTSD_MAX_SOCKETS) == -1) {
		if (errno == EINTR) {
			return (VNTSD_STATUS_INTR);
		}
		return (VNTSD_ERR_LISTEN_BIND);
	}

	D1(stderr, "t@%d open_socket() sockfd=%d\n", thr_self(), *sockfd);
	return (VNTSD_SUCCESS);
}

/* ceate console selection thread */
static int
create_console_thread(vntsd_group_t *groupp, int sockfd)
{
	vntsd_client_t	    *clientp;
	vntsd_thr_arg_t	    arg;
	int		    rv;


	assert(groupp);
	D1(stderr, "t@%d create_console_thread@%lld:client@%d\n", thr_self(),
	    groupp->tcp_port, sockfd);

	/* allocate a new client */
	clientp = (vntsd_client_t *)malloc(sizeof (vntsd_client_t));
	if (clientp  == NULL) {
		return (VNTSD_ERR_NO_MEM);
	}

	/* initialize the client */
	bzero(clientp, sizeof (vntsd_client_t));

	clientp->sockfd = sockfd;
	clientp->cons_tid = (thread_t)-1;

	(void) mutex_init(&clientp->lock, USYNC_THREAD|LOCK_ERRORCHECK, NULL);

	/* append client to group */
	(void) mutex_lock(&groupp->lock);

	if ((rv = vntsd_que_append(&groupp->no_cons_clientpq, clientp))
	    != VNTSD_SUCCESS) {
		(void) mutex_unlock(&groupp->lock);
		vntsd_free_client(clientp);
		return (rv);
	}

	(void) mutex_unlock(&groupp->lock);

	(void) mutex_lock(&clientp->lock);

	/* parameters for console thread */
	bzero(&arg, sizeof (arg));

	arg.handle = groupp;
	arg.arg = clientp;

	/* create console selection thread */
	if (thr_create(NULL, 0, (thr_func_t)vntsd_console_thread,
		    &arg, THR_DETACHED, &clientp->cons_tid)) {

		(void) mutex_unlock(&clientp->lock);
		(void) mutex_lock(&groupp->lock);
		(void) vntsd_que_rm(&groupp->no_cons_clientpq, clientp);
		(void) mutex_unlock(&groupp->lock);
		vntsd_free_client(clientp);

		return (VNTSD_ERR_CREATE_CONS_THR);
	}

	(void) mutex_unlock(&clientp->lock);

	return (VNTSD_SUCCESS);
}

/* listen thread */
void *
vntsd_listen_thread(vntsd_group_t *groupp)
{

	int		newsockfd;
	size_t		clilen;
	struct		sockaddr_in cli_addr;
	int		rv;
	int		num_cons;

	assert(groupp);

	D1(stderr, "t@%d listen@%lld\n", thr_self(), groupp->tcp_port);


	/* initialize listen socket */
	(void) mutex_lock(&groupp->lock);
	rv = open_socket(groupp->tcp_port, &groupp->sockfd);
	(void) mutex_unlock(&groupp->lock);
	listen_chk_status(groupp, rv);

	for (; ; ) {

		clilen = sizeof (cli_addr);

		/* listen to the socket */
		newsockfd = accept(groupp->sockfd, (struct sockaddr *)&cli_addr,
			    &clilen);

		D1(stderr, "t@%d listen_thread() connected sockfd=%d\n",
		    thr_self(), newsockfd);

		if (newsockfd <=  0) {

			if (errno == EINTR) {
				listen_chk_status(groupp, VNTSD_STATUS_INTR);
			} else {
				listen_chk_status(groupp,
				    VNTSD_STATUS_ACCEPT_ERR);
			}
			continue;
		}
		num_cons = vntsd_chk_group_total_cons(groupp);
		if (num_cons == 0) {
			(void) close(newsockfd);
			listen_chk_status(groupp, VNTSD_STATUS_NO_CONS);
			continue;
		}

		/* a connection is established */
		rv = vntsd_set_telnet_options(newsockfd);
		if (rv != VNTSD_SUCCESS) {
			(void) close(newsockfd);
			listen_chk_status(groupp, rv);
		}
		rv = create_console_thread(groupp, newsockfd);
		if (rv != VNTSD_SUCCESS) {
			(void) close(newsockfd);
			listen_chk_status(groupp, rv);
		}
	}

	/*NOTREACHED*/
	return (NULL);
}