/* * 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 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * Listen thread creates a console thread whenever there is a tcp client * made a conection to its port. In the console thread, if there are * multiple consoles in the group, client will be asked for a console selection. * a write thread for a console is created when first client connects to a * selected console and console thread becomes read thread for the client. */ #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 <synch.h> #include <signal.h> #include <assert.h> #include <ctype.h> #include <syslog.h> #include <libintl.h> #include <netdb.h> #include "vntsd.h" #include "chars.h" /* display domain names in the group */ static boolean_t display_domain_name(vntsd_cons_t *consp, int *fd) { char buf[VNTSD_LINE_LEN]; char *status; if (consp->clientpq != NULL) { status = gettext("connected"); } else if (consp->status & VNTSD_CONS_DELETED) { status = gettext("removing..."); } else { status = gettext("online"); } (void) snprintf(buf, sizeof (buf), "%-20d%-30s%-25s%s", consp->cons_no, consp->domain_name, status, vntsd_eol); return (vntsd_write_fd(*fd, buf, strlen(buf)) != VNTSD_SUCCESS); } /* output connected message to tcp client */ static int write_connect_msg(vntsd_client_t *clientp, char *group_name, char *domain_name) { int rv = VNTSD_SUCCESS; char buf[VNTSD_LINE_LEN]; if ((rv = vntsd_write_client(clientp, vntsd_eol, VNTSD_EOL_LEN)) != VNTSD_SUCCESS) { return (rv); } (void) snprintf(buf, sizeof (buf), gettext("Connecting to console \"%s\" in group \"%s\" ...."), domain_name, group_name); if ((rv = vntsd_write_line(clientp, buf)) != VNTSD_SUCCESS) { return (rv); } if ((rv = vntsd_write_line(clientp, gettext("Press ~? for control options .."))) != VNTSD_SUCCESS) { return (rv); } return (VNTSD_SUCCESS); } static int create_write_thread(vntsd_cons_t *consp) { assert(consp); /* create write thread for the console */ (void) mutex_lock(&consp->lock); if (thr_create(NULL, 0, (thr_func_t)vntsd_write_thread, (void *)consp, NULL, &consp->wr_tid)) { DERR(stderr, "t@%d create_rd_wr_thread@%d: " "create write thread failed\n", thr_self(), consp->cons_no); (void) close(consp->vcc_fd); consp->vcc_fd = -1; (void) mutex_unlock(&consp->lock); return (VNTSD_ERR_CREATE_WR_THR); } (void) mutex_unlock(&consp->lock); return (VNTSD_SUCCESS); } /* Display all domain consoles in a group. */ static int list_all_domains(vntsd_group_t *groupp, vntsd_client_t *clientp) { char vntsd_line[VNTSD_LINE_LEN]; int rv = VNTSD_SUCCESS; if ((rv = vntsd_write_client(clientp, vntsd_eol, VNTSD_EOL_LEN)) != VNTSD_SUCCESS) { return (rv); } /* * TRANSLATION_NOTE * The following three strings of the form "DOMAIN .." are table * headers and should be all uppercase. */ (void) snprintf(vntsd_line, sizeof (vntsd_line), "%-20s%-30s%-25s", gettext("DOMAIN ID"), gettext("DOMAIN NAME"), gettext("DOMAIN STATE")); if ((rv = vntsd_write_line(clientp, vntsd_line)) != VNTSD_SUCCESS) { return (rv); } (void) mutex_lock(&groupp->lock); if (vntsd_que_find(groupp->conspq, (compare_func_t)display_domain_name, &(clientp->sockfd)) != NULL) { rv = VNTSD_ERR_WRITE_CLIENT; } (void) mutex_unlock(&groupp->lock); return (rv); } /* display help */ static int display_help(vntsd_client_t *clientp) { int rv = VNTSD_SUCCESS; char *bufp; if ((rv = vntsd_write_client(clientp, vntsd_eol, VNTSD_EOL_LEN)) != VNTSD_SUCCESS) { return (rv); } /* * TRANSLATION_NOTE * The following three strings of the form ". -- ..." are help * messages for single character commands. Do not translate the * character before the --. */ bufp = gettext("h -- this help"); if ((rv = vntsd_write_line(clientp, bufp)) != VNTSD_SUCCESS) { return (rv); } bufp = gettext("l -- list of consoles"); if ((rv = vntsd_write_line(clientp, bufp)) != VNTSD_SUCCESS) { return (rv); } bufp = gettext("q -- quit"); if ((rv = vntsd_write_line(clientp, bufp)) != VNTSD_SUCCESS) { return (rv); } /* * TRANSLATION_NOTE * In the following string, "id" is a short mnemonic for * "identifier" and both occurrences should be translated. */ bufp = gettext("c{id}, n{name} -- connect to a console of domain {id}" " or domain {name}"); if ((rv = vntsd_write_line(clientp, bufp)) != VNTSD_SUCCESS) { return (rv); } return (VNTSD_SUCCESS); } /* cons_by_name() - find a console structure according to a ldom's name */ static boolean_t cons_by_name(vntsd_cons_t *consp, char *name) { if (consp->status & VNTSD_CONS_DELETED) { return (B_FALSE); } return (strcmp(consp->domain_name, name) == 0); } /* name_to_cons_no - convert a ldom's name to its consno */ static int name_to_cons_no(vntsd_group_t *groupp, char *name) { vntsd_cons_t *consp; consp = (vntsd_cons_t *)vntsd_que_find(groupp->conspq, (compare_func_t)cons_by_name, name); if (consp == NULL) { return (-1); } return (consp->cons_no); } /* select a console to connect */ static int select_cons(vntsd_group_t *groupp, vntsd_cons_t **consp, vntsd_client_t *clientp, char c) { int cons_no = -1; int n; int i; char buf[VNTSD_LINE_LEN]; int rv; (void) mutex_lock(&groupp->lock); if (groupp->num_cons == 0) { (void) mutex_unlock(&groupp->lock); /* no console in this group */ return (VNTSD_STATUS_NO_CONS); } (void) mutex_unlock(&groupp->lock); /* c{id} or n{name} */ n = VNTSD_LINE_LEN; if ((rv = vntsd_read_line(clientp, buf, &n)) != VNTSD_SUCCESS) { return (rv); } /* parse command */ for (i = 0; i < n; i++) { switch (c) { case 'c': /* c{id} or c {id} */ if (isspace(buf[i])) { continue; } if (!isdigit(buf[i])) { return (VNTSD_ERR_INVALID_INPUT); } cons_no = atoi(buf + i); break; case 'n': /* n{name) or n {name} */ if (isspace(buf[i])) { continue; } buf[n-1] = 0; cons_no = name_to_cons_no(groupp, buf+i); break; default: /* should never get here */ return (VNTSD_ERR_INVALID_INPUT); } /* got user selection */ break; } if (cons_no < 0) { return (VNTSD_ERR_INVALID_INPUT); } /* get selected console */ (void) mutex_lock(&groupp->lock); *consp = (vntsd_cons_t *)vntsd_que_find(groupp->conspq, (compare_func_t)vntsd_cons_by_consno, &cons_no); if (*consp == NULL) { /* during console selection, the console has been deleted */ (void) mutex_unlock(&groupp->lock); return (VNTSD_ERR_INVALID_INPUT); } if ((*consp)->status & VNTSD_CONS_DELETED) { return (VNTSD_ERR_INVALID_INPUT); } (void) mutex_unlock(&groupp->lock); return (VNTSD_SUCCESS); } /* compare if there is a match console in the gorup */ static boolean_t find_cons_in_group(vntsd_cons_t *consp_in_group, vntsd_cons_t *consp) { if (consp_in_group == consp) { return (B_TRUE); } else { return (B_FALSE); } } /* connect a client to a console */ static int connect_cons(vntsd_cons_t *consp, vntsd_client_t *clientp) { int rv, rv1; vntsd_group_t *groupp; assert(consp); groupp = consp->group; assert(groupp); assert(clientp); (void) mutex_lock(&groupp->lock); /* check if console is valid */ consp = vntsd_que_find(groupp->conspq, (compare_func_t)find_cons_in_group, consp); if (consp == NULL) { (void) mutex_unlock(&groupp->lock); return (VNTSD_STATUS_NO_CONS); } if (consp->status & VNTSD_CONS_DELETED) { (void) mutex_unlock(&groupp->lock); return (VNTSD_STATUS_NO_CONS); } (void) mutex_lock(&consp->lock); (void) mutex_lock(&clientp->lock); clientp->cons = consp; /* enable daemon cmd */ clientp->status &= ~VNTSD_CLIENT_DISABLE_DAEMON_CMD; if (consp->clientpq == NULL && consp->vcc_fd == -1) { /* * the first connection to a console - a writer * and the console has not opened. */ consp->vcc_fd = vntsd_open_vcc(consp->dev_name, consp->cons_no); if (consp->vcc_fd < 0) { (void) mutex_unlock(&clientp->lock); (void) mutex_unlock(&consp->lock); (void) mutex_unlock(&groupp->lock); assert(consp->group); return (vntsd_vcc_err(consp)); } } (void) mutex_unlock(&clientp->lock); /* * move the client from group's no console selected queue * to cons queue */ rv = vntsd_que_rm(&groupp->no_cons_clientpq, clientp); assert(rv == VNTSD_SUCCESS); rv = vntsd_que_append(&consp->clientpq, clientp); (void) mutex_unlock(&groupp->lock); if (rv != VNTSD_SUCCESS) { if (consp->clientpq->handle == clientp) { /* writer */ (void) close(consp->vcc_fd); consp->vcc_fd = -1; } (void) mutex_unlock(&consp->lock); return (rv); } (void) mutex_unlock(&consp->lock); if (consp->clientpq->handle == clientp) { /* create a write thread */ rv = create_write_thread(consp); if (rv != VNTSD_SUCCESS) { return (rv); } } /* write connecting message */ if ((rv = write_connect_msg(clientp, consp->group->group_name, consp->domain_name)) != VNTSD_SUCCESS) { return (rv); } /* process input from client */ rv = vntsd_read(clientp); /* client disconnected from the console */ (void) mutex_lock(&groupp->lock); /* remove client from console queue */ (void) mutex_lock(&consp->lock); rv1 = vntsd_que_rm(&consp->clientpq, clientp); assert(rv1 == VNTSD_SUCCESS); /* append client to group's no console selected queue */ rv1 = vntsd_que_append(&groupp->no_cons_clientpq, clientp); (void) mutex_unlock(&groupp->lock); if (consp->clientpq == NULL) { /* clean up console since there is no client connected to it */ assert(consp->vcc_fd != -1); /* force write thread to exit */ assert(consp->wr_tid != (thread_t)-1); (void) thr_kill(consp->wr_tid, SIGUSR1); (void) mutex_unlock(&consp->lock); (void) thr_join(consp->wr_tid, NULL, NULL); (void) mutex_lock(&consp->lock); } if (consp->status & VNTSD_CONS_SIG_WAIT) { /* console is waiting for client to disconnect */ (void) cond_signal(&consp->cvp); } (void) mutex_unlock(&consp->lock); return (rv1 == VNTSD_SUCCESS ? rv : rv1); } /* read command line input */ static int read_cmd(vntsd_client_t *clientp, char *prompt, char *cmd) { int rv; /* disable daemon special command */ (void) mutex_lock(&clientp->lock); clientp->status |= VNTSD_CLIENT_DISABLE_DAEMON_CMD; (void) mutex_unlock(&clientp->lock); if ((rv = vntsd_write_client(clientp, vntsd_eol, VNTSD_EOL_LEN)) != VNTSD_SUCCESS) { return (rv); } if ((rv = vntsd_write_client(clientp, prompt, strlen(prompt))) != VNTSD_SUCCESS) { return (rv); } if ((rv = vntsd_read_data(clientp, cmd)) != VNTSD_SUCCESS) { return (rv); } if (*cmd == BS) { return (VNTSD_SUCCESS); } rv = vntsd_write_client(clientp, cmd, 1); *cmd = tolower(*cmd); return (rv); } /* reset client for selecting a console in the group */ static void client_init(vntsd_client_t *clientp) { (void) mutex_lock(&clientp->lock); clientp->cons = NULL; clientp->status = 0; (void) mutex_unlock(&clientp->lock); } /* is there any connection to a given console? */ static boolean_t is_client_que_empty(vntsd_cons_t *consp) { boolean_t has_client = B_FALSE; (void) mutex_lock(&consp->lock); if (consp->clientpq != NULL) has_client = B_TRUE; (void) mutex_unlock(&consp->lock); return (has_client); } /* * close one opened console. * This function is passed to vntsd_que_walk to close one console. * The function returns B_FALSE so that vntsd_que_walk will * continue to apply the function to all consoles in the group. */ static boolean_t close_one_vcc_fd(vntsd_cons_t *consp) { (void) mutex_lock(&consp->lock); if (consp->vcc_fd != -1) { (void) close(consp->vcc_fd); consp->vcc_fd = -1; } (void) mutex_unlock(&consp->lock); return (B_FALSE); } /* clean up client and exit the thread */ static void client_fini(vntsd_group_t *groupp, vntsd_client_t *clientp) { assert(groupp); assert(clientp); /* disconnct client from tcp port */ assert(clientp->sockfd != -1); (void) close(clientp->sockfd); (void) mutex_lock(&groupp->lock); /* * close all consoles in the group if the client is the * last one connected to the group */ if (vntsd_que_walk(groupp->conspq, (el_func_t)is_client_que_empty) == VNTSD_SUCCESS) { (void) vntsd_que_walk(groupp->conspq, (el_func_t)close_one_vcc_fd); } (void) vntsd_que_rm(&groupp->no_cons_clientpq, clientp); if ((groupp->no_cons_clientpq == NULL) && (groupp->status & VNTSD_GROUP_SIG_WAIT)) { /* * group is waiting to be deleted. - signal the group's * listen thread - the VNTSD_GROUP_SIG_WAIT state will * be cleared when the listen thread exits. */ (void) cond_signal(&groupp->cvp); } (void) mutex_unlock(&groupp->lock); (void) mutex_destroy(&clientp->lock); free(clientp); thr_exit(0); } /* check client's status. exit if client quits or fatal errors */ static void console_chk_status(vntsd_group_t *groupp, vntsd_client_t *clientp, int status) { char err_msg[VNTSD_LINE_LEN]; D1(stderr, "t@%d console_chk_status() status=%d " "client status=%x num consoles=%d \n", thr_self(), status, clientp->status, groupp->num_cons); (void) snprintf(err_msg, VNTSD_LINE_LEN, "console_chk_status client%d" " num_cos=%d", clientp->sockfd, groupp->num_cons); /* * obtain group lock to protect groupp->num_cons. * When groupp->num_cons == 0, close client and exit the tread. */ (void) mutex_lock(&groupp->lock); if (groupp->num_cons == 0) { /* no more console in the group */ (void) mutex_unlock(&groupp->lock); client_fini(groupp, clientp); return; } if (status == VNTSD_STATUS_INTR) { /* reason for signal? */ status = vntsd_cons_chk_intr(clientp); } switch (status) { case VNTSD_STATUS_CLIENT_QUIT: (void) mutex_unlock(&groupp->lock); client_fini(groupp, clientp); return; case VNTSD_STATUS_RESELECT_CONS: if (clientp->cons == NULL) { /* * domain was deleted before client connects to it * connect to other console in the same group */ (void) mutex_unlock(&groupp->lock); client_init(clientp); return; } if ((groupp->num_cons == 1) && ((clientp->status & VNTSD_CLIENT_CONS_DELETED) || (groupp->conspq->handle == clientp->cons))) { /* no other selection available */ (void) mutex_unlock(&groupp->lock); client_fini(groupp, clientp); } else { (void) mutex_unlock(&groupp->lock); client_init(clientp); } return; case VNTSD_STATUS_VCC_IO_ERR: if ((clientp->status & VNTSD_CLIENT_CONS_DELETED) == 0) { /* check if console was deleted */ (void) mutex_unlock(&groupp->lock); status = vntsd_vcc_err(clientp->cons); (void) mutex_lock(&groupp->lock); } if (status != VNTSD_STATUS_CONTINUE) { /* console was deleted */ if (groupp->num_cons <= 1) { (void) mutex_unlock(&groupp->lock); client_fini(groupp, clientp); return; } } (void) mutex_unlock(&groupp->lock); /* console is ok */ client_init(clientp); return; case VNTSD_STATUS_MOV_CONS_FORWARD: case VNTSD_STATUS_MOV_CONS_BACKWARD: if (groupp->num_cons == 1) { /* same console */ (void) mutex_unlock(&groupp->lock); return; } /* get selected console */ clientp->cons = vntsd_que_pos(groupp->conspq, clientp->cons, (status == VNTSD_STATUS_MOV_CONS_FORWARD)?(1):(-1)); (void) mutex_unlock(&groupp->lock); return; case VNTSD_SUCCESS: case VNTSD_STATUS_CONTINUE: (void) mutex_unlock(&groupp->lock); client_init(clientp); return; case VNTSD_STATUS_NO_CONS: /* * there are two cases when the status is VNTSD_SATATUS_NO_CONS. * case 1. the console was removed but there is at least one * another console in the group that client can connect to. * case 2. there is no console in the group. Client needs to * be disconnected from vntsd. */ if (groupp->num_cons == 0) { (void) mutex_unlock(&groupp->lock); client_fini(groupp, clientp); } else { (void) mutex_unlock(&groupp->lock); client_init(clientp); } return; case VNTSD_ERR_INVALID_INPUT: (void) mutex_unlock(&groupp->lock); return; default: /* fatal error */ (void) mutex_unlock(&groupp->lock); vntsd_log(status, err_msg); client_fini(groupp, clientp); return; } } /* console thread */ void * vntsd_console_thread(vntsd_thr_arg_t *argp) { vntsd_group_t *groupp; vntsd_cons_t *consp; vntsd_client_t *clientp; char buf[MAXHOSTNAMELEN]; char prompt[72]; char cmd; int rv = VNTSD_SUCCESS; int num_cons; groupp = (vntsd_group_t *)argp->handle; clientp = (vntsd_client_t *)argp->arg; assert(groupp); assert(clientp); /* free argp, which was allocated in listen thread */ free(argp); /* check if group is removed */ D1(stderr, "t@%d get_client_sel@%lld:client@%d\n", thr_self(), groupp->tcp_port, clientp->sockfd); bzero(buf, MAXHOSTNAMELEN); /* host name */ if (gethostname(buf, MAXHOSTNAMELEN)) { vntsd_log(VNTSD_STATUS_NO_HOST_NAME, "vntsd_console_thread()"); (void) snprintf(buf, sizeof (buf), "unkown host"); } if (snprintf(prompt, sizeof (prompt), "%s-vnts-%s: h, l, c{id}, n{name}, q:", buf, groupp->group_name) >= sizeof (prompt)) { /* long prompt doesn't fit, use short one */ (void) snprintf(prompt, sizeof (prompt), "vnts: h, l, c{id}, n{name}, q:"); } for (;;) { cmd = ' '; D1(stderr, "t@%d console_thread()@%lld:client@%d\n", thr_self(), groupp->tcp_port, clientp->sockfd); num_cons = vntsd_chk_group_total_cons(groupp); if ((num_cons > 1) && (clientp->cons == NULL)) { /* console to connect to */ rv = read_cmd(clientp, prompt, &cmd); /* check error and may exit */ console_chk_status(groupp, clientp, rv); /* any console is removed from group? */ num_cons = vntsd_chk_group_total_cons(groupp); if (num_cons <= 1) { cmd = ' '; } } switch (cmd) { case 'l': /* list domain names */ rv = list_all_domains(groupp, clientp); break; case 'q': rv = VNTSD_STATUS_CLIENT_QUIT; break; case ' ': if (num_cons == 0) { /* no console in the group */ rv = VNTSD_STATUS_NO_CONS; break; } if (clientp->cons == NULL) { if (num_cons == 1) { /* by pass selecting console */ consp = (vntsd_cons_t *) (groupp->conspq->handle); } else { continue; } } else { consp = clientp->cons; } /* connect to console */ rv = connect_cons(consp, clientp); break; case 'c': case 'n': /* select console */ if (clientp->cons == NULL) { rv = select_cons(groupp, &consp, clientp, cmd); if (rv == VNTSD_ERR_INVALID_INPUT) { rv = display_help(clientp); break; } /* * all consoles in the group * may be gone before this client * could select one. */ if (rv != VNTSD_SUCCESS) break; } else { consp = clientp->cons; } assert(consp); /* connect to console */ rv = connect_cons(consp, clientp); D1(stderr, "t@%d console_thread()" "connect_cons returns %d\n", thr_self(), rv); break; case 'h': default: rv = display_help(clientp); break; } /* check error and may exit */ console_chk_status(groupp, clientp, rv); } /*NOTREACHED*/ return (NULL); }