usr/src/cmd/vntsd/cmd.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Vntsd handles two types of special commands, one is telnet
  28  * commands and another is vntsd special commands.
  29  * telnet commands supported are:
  30  * WILL
  31  * WONT
  32  * DO
  33  * DONT
  34  *  TEL_ECHO
  35  *  SUPRESS
  36  *  LINEMODE
  37  * BRK
  38  * AYT
  39  * HT
  40  * NOP
  41  *
  42  * Vntsd special commands are:
  43  *  Send break                  (~#)
  44  *  Send alternate break        (~^B)
  45  *  Exit                        (~.)
  46  *  Force write access          (~w)
  47  *  Console next                (~n)
  48  *  Console previous            (~p)
  49  *  Help                        (~?)
  50  */
  51
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #include <unistd.h>
  56 #include <sys/types.h>
  57 #include <sys/socket.h>
  58 #include <netinet/in.h>
  59 #include <thread.h>
  60 #include <ctype.h>
  61 #include <sys/termio.h>
  62 #include <libintl.h>
  63 #include <syslog.h>
  64 #include "vntsd.h"
  65 #include "chars.h"
  66
  67 char vntsd_eol[] = { CR, LF, 0};
  68
  69 typedef int         (*e_func_t)(vntsd_client_t *clientp);
  70 /* structure for daemon special cmd */
  71 typedef struct {
  72         char e_char;                            /* char to match on */
  73         char *e_help;                           /* help string */
  74         e_func_t e_func;                        /* command */
  75 } esctable_t;
  76
  77 /* genbrk() -  send a break to vcc driver */
  78 static int
  79 genbrk(vntsd_client_t *clientp)
  80 {
  81
  82         vntsd_cons_t *consp;
  83
  84         assert(clientp);
  85         assert(clientp->cons);
  86
  87         consp = clientp->cons;
  88         D1(stderr, "t@%d genbrk fd=%d sockfd %d\n", thr_self(),
  89             consp->vcc_fd, clientp->sockfd);
  90
  91         assert(consp->clientpq != NULL);
  92         if (consp->clientpq->handle != clientp) {
  93                 /* reader */
  94                 return (vntsd_write_line(clientp,
  95                     gettext(VNTSD_NO_WRITE_ACCESS_MSG)));
  96         }
  97
  98         /* writer */
  99         if (ioctl(consp->vcc_fd, TCSBRK, NULL)) {
 100                 return (VNTSD_ERR_VCC_IOCTL);
 101         }
 102
 103         return (VNTSD_STATUS_CONTINUE);
 104 }
 105
 106
 107 /* genaltbrk() - handle the alternate break sequence */
 108 static int
 109 genaltbrk(vntsd_client_t *clientp)
 110 {
 111         vntsd_cons_t *consp;
 112         char brkseq[2] = { '~', CNTRL('B')};
 113
 114         assert(clientp);
 115         assert(clientp->cons);
 116
 117         consp = clientp->cons;
 118         D1(stderr, "t@%d genaltbrk fd=%d sockfd %d\n", thr_self(),
 119             consp->vcc_fd, clientp->sockfd);
 120
 121         assert(consp->clientpq != NULL);
 122         if (consp->clientpq->handle != clientp) {
 123                 /* reader */
 124                 return (vntsd_write_line(clientp,
 125                     gettext(VNTSD_NO_WRITE_ACCESS_MSG)));
 126         }
 127
 128         /*
 129          * Unlike the genbrk() function we will just forward the break sequence
 130          * on to vcc and subsequently the underlying console driver. This will
 131          * involve sending the characters '~' and CNTRL('B').
 132          */
 133         if ((vntsd_write_fd(clientp->cons->vcc_fd, brkseq, sizeof (brkseq))) ==
 134             VNTSD_SUCCESS)
 135                 return (VNTSD_STATUS_CONTINUE);
 136         else
 137                 return (VNTSD_STATUS_VCC_IO_ERR);
 138 }
 139
 140 /*
 141  * console_forward()  - cycle client to the next console
 142  * in the group queue.
 143  */
 144 static int
 145 console_forward(vntsd_client_t *clientp)
 146 {
 147         /* forward when there are mutiple consoles in the group */
 148         if (clientp->cons->group->num_cons > 1)
 149                 return (VNTSD_STATUS_MOV_CONS_FORWARD);
 150
 151         return (VNTSD_STATUS_CONTINUE);
 152
 153 }
 154
 155 /*
 156  * console_backward()  - cycle client to the previous
 157  * console in the group queue.
 158  */
 159 static int
 160 console_backward(vntsd_client_t *clientp)
 161 {
 162         /* backward when there are mutiple consoles in the group */
 163         if (clientp->cons->group->num_cons > 1)
 164                 return (VNTSD_STATUS_MOV_CONS_BACKWARD);
 165
 166         return (VNTSD_STATUS_CONTINUE);
 167
 168 }
 169
 170 /* acquire_write() - acquire write access to a console. */
 171 static int
 172 acquire_write(vntsd_client_t *clientp)
 173 {
 174         int     rv;
 175         int     yes_no = 1;
 176         vntsd_cons_t *consp;
 177
 178         assert(clientp);
 179         consp = clientp->cons;
 180         assert(consp);
 181
 182         if (consp->clientpq->handle == clientp) {
 183                 /* client is a  writer */
 184                 if ((rv = vntsd_write_line(clientp,
 185                     gettext("You have write permission"))) !=
 186                     VNTSD_SUCCESS) {
 187                         return (rv);
 188
 189                 }
 190                 return (VNTSD_STATUS_CONTINUE);
 191         }
 192
 193         /* message to client */
 194         if ((rv = vntsd_write_client(clientp, vntsd_eol, VNTSD_EOL_LEN))
 195             != VNTSD_SUCCESS) {
 196                 return (rv);
 197         }
 198
 199         /*
 200          * TRANSLATION_NOTE
 201          * The following string should be formatted to fit on multiple lines
 202          * assuming a line width of at most 78 characters. There must be no
 203          * trailing newline.
 204          */
 205         if ((rv = vntsd_write_lines(clientp,
 206             gettext("Warning: another user currently "
 207             "has write permission\nto this console and forcibly removing "
 208             "him/her will terminate\nany current write action and all work "
 209             "will be lost."))) != VNTSD_SUCCESS) {
 210                 return (rv);
 211         }
 212
 213         /* get client yes no */
 214         if ((rv = vntsd_write_client(clientp, vntsd_eol,
 215             VNTSD_EOL_LEN)) != VNTSD_SUCCESS) {
 216                 return (rv);
 217         }
 218
 219         if ((rv = vntsd_get_yes_no(clientp,
 220             gettext("Would you like to continue?"),
 221             &yes_no)) != VNTSD_SUCCESS) {
 222                 return (rv);
 223         }
 224
 225         if (yes_no == B_FALSE) {
 226                 /* client change mind no need to acquire  write access */
 227                 return (VNTSD_STATUS_CONTINUE);
 228         }
 229
 230         return (VNTSD_STATUS_ACQUIRE_WRITER);
 231 }
 232
 233 /* client_exit()  - disconnect client from the console. */
 234 static int
 235 client_exit(void)
 236 {
 237         return (VNTSD_STATUS_RESELECT_CONS);
 238 }
 239
 240 static int daemon_cmd_help(vntsd_client_t *clientp);
 241
 242 /* table for daemon commands */
 243
 244 static esctable_t  etable[] = {
 245
 246         /* send a break to vcc */
 247         {'#', "Send break",  genbrk},
 248
 249         /* alternate break sequence */
 250         {CNTRL('B'), "Send alternate break", genaltbrk},
 251
 252         /* exit */
 253         {'.', "Exit from this console",  (e_func_t)client_exit},
 254
 255         /* acquire write access */
 256         {'w', "Force write access", acquire_write},
 257
 258         /* connect to next console in queue */
 259         {'n', "Console next", (e_func_t)console_forward},
 260
 261         /* connect to previous console in queue */
 262         {'p', "Console previous", (e_func_t)console_backward},
 263
 264         /* help must be next to last */
 265         {'?', "Help", daemon_cmd_help},
 266
 267         /* table terminator */
 268         {0, 0, 0}
 269 };
 270
 271 void
 272 vntsd_init_esctable_msgs(void)
 273 {
 274         esctable_t  *p;
 275
 276         for (p = etable; p->e_char != '\0'; p++) {
 277                 p->e_help = gettext(p->e_help);
 278         }
 279 }
 280
 281 /* daemon_cmd_help() - print help. */
 282 static int
 283 daemon_cmd_help(vntsd_client_t *clientp)
 284 {
 285         esctable_t  *p;
 286         int         rv;
 287         char        buf[VNTSD_LINE_LEN];
 288
 289         if ((rv = vntsd_write_client(clientp, vntsd_eol,
 290             VNTSD_EOL_LEN)) != VNTSD_SUCCESS) {
 291                 return (rv);
 292         }
 293
 294         /*
 295          * TRANSLATION_NOTE
 296          * VNTSD is the name of the VNTS daemon and should not be translated.
 297          */
 298         if ((rv = vntsd_write_line(clientp, gettext("VNTSD commands"))) !=
 299             VNTSD_SUCCESS) {
 300                 return (rv);
 301         }
 302
 303         for (p = etable; p->e_char; p++) {
 304
 305                 if (p->e_char == CNTRL('B')) {
 306                         (void) snprintf(buf, sizeof (buf), "~^B --%s",
 307                             p->e_help);
 308                 } else {
 309                         (void) snprintf(buf, sizeof (buf),
 310                             "~%c --%s", p->e_char, p->e_help);
 311                 }
 312
 313                 if ((rv = vntsd_write_line(clientp, buf)) != VNTSD_SUCCESS) {
 314                         return (rv);
 315                 }
 316         }
 317
 318         return (VNTSD_STATUS_CONTINUE);
 319 }
 320
 321 /* exit from daemon command */
 322 static int
 323 exit_daemon_cmd(vntsd_client_t *clientp, int rv)
 324 {
 325         (void) mutex_lock(&clientp->lock);
 326         clientp->status &= ~VNTSD_CLIENT_DISABLE_DAEMON_CMD;
 327         (void) mutex_unlock(&clientp->lock);
 328         return (rv);
 329 }
 330
 331 /*
 332  * vntsd_process_daemon_cmd() - special commands
 333  * "<RET>~"  vntsd daemon commands
 334  * "<RET>~~" enter '~' character
 335  */
 336 int
 337 vntsd_process_daemon_cmd(vntsd_client_t *clientp, char c)
 338 {
 339         esctable_t *p;
 340         int         rv;
 341         char        prev_char;
 342
 343         prev_char = clientp->prev_char;
 344
 345         if (c != VNTSD_DAEMON_CMD || (prev_char != 0 && prev_char != CR)) {
 346                 /* not a daemon command */
 347                 return (VNTSD_SUCCESS);
 348         }
 349
 350         if (clientp->status & VNTSD_CLIENT_DISABLE_DAEMON_CMD) {
 351                 return (VNTSD_STATUS_CONTINUE);
 352         }
 353
 354         /* no reentry to process_daemon_cmd */
 355         (void) mutex_lock(&clientp->lock);
 356         clientp->status |= VNTSD_CLIENT_DISABLE_DAEMON_CMD;
 357         (void) mutex_unlock(&clientp->lock);
 358
 359         D3(stderr, "t@%d process_daemon_cmd %d %d \n", thr_self(),
 360             clientp->cons->vcc_fd, clientp->sockfd);
 361
 362         /* read in command */
 363         if ((rv = vntsd_read_char(clientp, &c)) != VNTSD_SUCCESS) {
 364                 return (exit_daemon_cmd(clientp, rv));
 365         }
 366
 367         if (c == VNTSD_DAEMON_CMD) {
 368                 /*
 369                  * received another '~'
 370                  * a user types '~~' to get '~'
 371                  */
 372                 (void) mutex_lock(&clientp->lock);
 373                 clientp->status &= ~VNTSD_CLIENT_DISABLE_DAEMON_CMD;
 374                 (void) mutex_unlock(&clientp->lock);
 375                 return (VNTSD_SUCCESS);
 376         }
 377
 378         for (p = etable; p->e_char; p++) {
 379                 if (p->e_char == c) {
 380                         /* found match */
 381                         assert(p->e_func);
 382                         rv = (*p->e_func)(clientp);
 383                         return (exit_daemon_cmd(clientp, rv));
 384                 }
 385         }
 386
 387         /* no match, print out the help */
 388         p--;
 389         assert(p->e_char == '?');
 390         rv = (*p->e_func)(clientp);
 391
 392         return (exit_daemon_cmd(clientp, rv));
 393
 394 }
 395
 396 /* vntsd_set_telnet_options() - change  telnet client to  character mode. */
 397 int
 398 vntsd_set_telnet_options(int fd)
 399 {
 400         /* set client telnet options */
 401         uint8_t buf[] = {IAC, DONT, LINEMODE, IAC, WILL, SUPRESS, IAC, WILL,
 402                 TEL_ECHO, IAC, DONT, TERM_TYPE, IAC, DONT, TERM_SP,
 403                 IAC, DONT, STATUS, IAC, DONT, FC, IAC, DONT, TM, IAC, DONT, ENV,
 404                 IAC, DONT, WIN_SIZE};
 405
 406         return (vntsd_write_fd(fd, (char *)buf, 30));
 407 }
 408
 409 /*  vntsd_telnet_cmd() process telnet commands */
 410 int
 411 vntsd_telnet_cmd(vntsd_client_t *clientp, char c)
 412 {
 413         uint8_t buf[4];
 414         char    cmd;
 415         int     rv = VNTSD_STATUS_CONTINUE;
 416
 417         bzero(buf, 4);
 418
 419         if ((uint8_t)c != IAC) {
 420                 /* not telnet cmd */
 421                 return (VNTSD_SUCCESS);
 422         }
 423
 424         if ((rv = vntsd_read_char(clientp, &cmd)) != VNTSD_SUCCESS) {
 425                 return (rv);
 426         }
 427
 428         if ((uint8_t)cmd == WILL || (uint8_t)cmd == WONT ||
 429             (uint8_t)cmd == DO || (uint8_t)cmd == DONT) {
 430                 if ((rv = vntsd_read_char(clientp, &c)) != VNTSD_SUCCESS) {
 431                         return (rv);
 432                 }
 433         }
 434
 435
 436         switch ((uint8_t)cmd) {
 437
 438         case WILL:
 439
 440                 switch ((uint8_t)c) {
 441                 case TEL_ECHO:
 442                 case SUPRESS:
 443                 case LINEMODE:
 444                         break;
 445                 default:
 446                         syslog(LOG_ERR, "not support telnet WILL %x\n", c);
 447                         break;
 448                 }
 449                 break;
 450
 451         case  WONT:
 452
 453                 switch ((uint8_t)c) {
 454                 case TEL_ECHO:
 455                 case SUPRESS:
 456                 case LINEMODE:
 457                 default:
 458                         syslog(LOG_ERR, "not support telnet WONT %x\n", c);
 459                         break;
 460                 }
 461                 break;
 462
 463         case DO:
 464         case DONT:
 465
 466                 buf[0] = IAC;
 467                 buf[1] = WILL;
 468                 buf[2] = c;
 469                 rv = vntsd_write_client(clientp, (char *)buf, 3);
 470
 471                 break;
 472
 473         case BRK:
 474
 475                 /* send break to vcc */
 476                 rv = genbrk(clientp);
 477                 break;
 478
 479         case IP:
 480
 481                 break;
 482
 483         case AYT: {
 484                         static char aytresp[] = "vntsd here";
 485
 486                         rv = vntsd_write_client(clientp, aytresp,
 487                             sizeof (aytresp) - 1);
 488                         break;
 489                 }
 490
 491         case HT:
 492         case NOP:
 493                 return (VNTSD_STATUS_CONTINUE);
 494
 495         default:
 496                 syslog(LOG_ERR, "not support telnet ctrl %2.2x\n", 0xff & cmd);
 497                 break;
 498         }
 499
 500         if (rv == VNTSD_SUCCESS) {
 501                 return (VNTSD_STATUS_CONTINUE);
 502         } else {
 503                 return (rv);
 504         }
 505 }
 506
 507
 508 /*
 509  * vntsd_ctrl_cmd()   - control keys
 510  * read and write suspend are supported.
 511  */
 512 int
 513 vntsd_ctrl_cmd(vntsd_client_t *clientp, char c)
 514 {
 515         int     cmd;
 516
 517         D3(stderr, "t@%d vntsd_ctrl_cmd%d %d\n", thr_self(),
 518             clientp->cons->vcc_fd, clientp->sockfd);
 519
 520         if ((c != START) && (c != STOP)) {
 521                 /* not a supported control command */
 522                 return (VNTSD_SUCCESS);
 523         }
 524
 525         if (c == START) {
 526                 D3(stderr, "t@%d client restart\n", thr_self());
 527
 528                 /* send resume read */
 529                 cmd = 1;
 530
 531                 if (ioctl(clientp->cons->vcc_fd, TCXONC, &cmd)) {
 532                         return (VNTSD_STATUS_VCC_IO_ERR);
 533                 }
 534
 535         }
 536
 537         if (c == STOP) {
 538                 D3(stderr, "t@%d client suspend\n", thr_self());
 539
 540                 /* send suspend read */
 541                 cmd = 0;
 542
 543                 if (ioctl(clientp->cons->vcc_fd, TCXONC, &cmd)) {
 544                         return (VNTSD_STATUS_VCC_IO_ERR);
 545                 }
 546
 547         }
 548
 549         return (VNTSD_STATUS_CONTINUE);
 550 }