OpenSolaris_b135/cmd/vntsd/listen.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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* 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_ACCEPT_ERR:
return;
case VNTSD_STATUS_INTR:
assert(groupp->status & VNTSD_GROUP_SIG_WAIT);
/*FALLTHRU*/
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 being deleted, notify main
* thread and exit.
*/
groupp->status &= ~VNTSD_GROUP_SIG_WAIT;
(void) cond_signal(&groupp->cvp);
(void) mutex_unlock(&groupp->lock);
thr_exit(0);
}
/*
* 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);
thr_exit(0);
}
}
/* 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);
/* woke up by signal? */
if (errno == EINTR) {
return (VNTSD_STATUS_INTR);
}
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 *thr_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);
/* check if the group is [being] removed */
if (groupp->status & VNTSD_GROUP_IN_CLEANUP) {
(void) mutex_unlock(&groupp->lock);
vntsd_free_client(clientp);
return (VNTSD_STATUS_NO_CONS);
}
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);
/*
* allocate thr_arg from heap for console thread so
* that thr_arg is still valid after this function exits.
* console thread will free thr_arg.
*/
thr_arg = (vntsd_thr_arg_t *)malloc(sizeof (vntsd_thr_arg_t));
if (thr_arg == NULL) {
vntsd_free_client(clientp);
return (VNTSD_ERR_NO_MEM);
}
thr_arg->handle = groupp;
thr_arg->arg = clientp;
(void) mutex_lock(&clientp->lock);
/* create console selection thread */
if (thr_create(NULL, 0, (thr_func_t)vntsd_console_thread,
thr_arg, THR_DETACHED, &clientp->cons_tid)) {
free(thr_arg);
(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;
vntsd_t *vntsdp;
assert(groupp);
D1(stderr, "t@%d listen@%lld\n", thr_self(), groupp->tcp_port);
vntsdp = groupp->vntsd;
/* 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;
}
/* Check authorization if enabled */
if ((vntsdp->options & VNTSD_OPT_AUTH_CHECK) != 0) {
rv = auth_check_fd(newsockfd, groupp->group_name);
if (rv != B_TRUE) {
D3(stderr, "t@%d listen@%lld group@%s: "
"authorization failure\n", thr_self(),
groupp->tcp_port, groupp->group_name);
(void) close(newsockfd);
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);
}