1 /* $OpenBSD: server-client.c,v 1.30 2010/02/06 22:55:31 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 21 #include <event.h> 22 #include <fcntl.h> 23 #include <string.h> 24 #include <time.h> 25 #include <paths.h> 26 #include <unistd.h> 27 28 #include "tmux.h" 29 30 void server_client_handle_key(int, struct mouse_event *, void *); 31 void server_client_repeat_timer(int, short, void *); 32 void server_client_check_redraw(struct client *); 33 void server_client_set_title(struct client *); 34 void server_client_reset_state(struct client *); 35 36 int server_client_msg_dispatch(struct client *); 37 void server_client_msg_command(struct client *, struct msg_command_data *); 38 void server_client_msg_identify( 39 struct client *, struct msg_identify_data *, int); 40 void server_client_msg_shell(struct client *); 41 42 void printflike2 server_client_msg_error(struct cmd_ctx *, const char *, ...); 43 void printflike2 server_client_msg_print(struct cmd_ctx *, const char *, ...); 44 void printflike2 server_client_msg_info(struct cmd_ctx *, const char *, ...); 45 46 /* Create a new client. */ 47 void 48 server_client_create(int fd) 49 { 50 struct client *c; 51 int mode; 52 u_int i; 53 54 if ((mode = fcntl(fd, F_GETFL)) == -1) 55 fatal("fcntl failed"); 56 if (fcntl(fd, F_SETFL, mode|O_NONBLOCK) == -1) 57 fatal("fcntl failed"); 58 if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) 59 fatal("fcntl failed"); 60 61 c = xcalloc(1, sizeof *c); 62 c->references = 0; 63 imsg_init(&c->ibuf, fd); 64 server_update_event(c); 65 66 if (gettimeofday(&c->creation_time, NULL) != 0) 67 fatal("gettimeofday failed"); 68 memcpy(&c->activity_time, &c->creation_time, sizeof c->activity_time); 69 70 ARRAY_INIT(&c->prompt_hdata); 71 72 c->tty.fd = -1; 73 c->title = NULL; 74 75 c->session = NULL; 76 c->tty.sx = 80; 77 c->tty.sy = 24; 78 79 screen_init(&c->status, c->tty.sx, 1, 0); 80 job_tree_init(&c->status_jobs); 81 82 c->message_string = NULL; 83 ARRAY_INIT(&c->message_log); 84 85 c->prompt_string = NULL; 86 c->prompt_buffer = NULL; 87 c->prompt_index = 0; 88 89 evtimer_set(&c->repeat_timer, server_client_repeat_timer, c); 90 91 for (i = 0; i < ARRAY_LENGTH(&clients); i++) { 92 if (ARRAY_ITEM(&clients, i) == NULL) { 93 ARRAY_SET(&clients, i, c); 94 return; 95 } 96 } 97 ARRAY_ADD(&clients, c); 98 log_debug("new client %d", fd); 99 } 100 101 /* Lost a client. */ 102 void 103 server_client_lost(struct client *c) 104 { 105 struct message_entry *msg; 106 u_int i; 107 108 for (i = 0; i < ARRAY_LENGTH(&clients); i++) { 109 if (ARRAY_ITEM(&clients, i) == c) 110 ARRAY_SET(&clients, i, NULL); 111 } 112 log_debug("lost client %d", c->ibuf.fd); 113 114 /* 115 * If CLIENT_TERMINAL hasn't been set, then tty_init hasn't been called 116 * and tty_free might close an unrelated fd. 117 */ 118 if (c->flags & CLIENT_TERMINAL) 119 tty_free(&c->tty); 120 121 screen_free(&c->status); 122 job_tree_free(&c->status_jobs); 123 124 if (c->title != NULL) 125 xfree(c->title); 126 127 evtimer_del(&c->repeat_timer); 128 129 evtimer_del(&c->identify_timer); 130 131 if (c->message_string != NULL) 132 xfree(c->message_string); 133 evtimer_del(&c->message_timer); 134 for (i = 0; i < ARRAY_LENGTH(&c->message_log); i++) { 135 msg = &ARRAY_ITEM(&c->message_log, i); 136 xfree(msg->msg); 137 } 138 ARRAY_FREE(&c->message_log); 139 140 if (c->prompt_string != NULL) 141 xfree(c->prompt_string); 142 if (c->prompt_buffer != NULL) 143 xfree(c->prompt_buffer); 144 for (i = 0; i < ARRAY_LENGTH(&c->prompt_hdata); i++) 145 xfree(ARRAY_ITEM(&c->prompt_hdata, i)); 146 ARRAY_FREE(&c->prompt_hdata); 147 148 if (c->cwd != NULL) 149 xfree(c->cwd); 150 151 close(c->ibuf.fd); 152 imsg_clear(&c->ibuf); 153 event_del(&c->event); 154 155 for (i = 0; i < ARRAY_LENGTH(&dead_clients); i++) { 156 if (ARRAY_ITEM(&dead_clients, i) == NULL) { 157 ARRAY_SET(&dead_clients, i, c); 158 break; 159 } 160 } 161 if (i == ARRAY_LENGTH(&dead_clients)) 162 ARRAY_ADD(&dead_clients, c); 163 c->flags |= CLIENT_DEAD; 164 165 recalculate_sizes(); 166 server_update_socket(); 167 } 168 169 /* Process a single client event. */ 170 void 171 server_client_callback(int fd, short events, void *data) 172 { 173 struct client *c = data; 174 175 if (c->flags & CLIENT_DEAD) 176 return; 177 178 if (fd == c->ibuf.fd) { 179 if (events & EV_WRITE && msgbuf_write(&c->ibuf.w) < 0) 180 goto client_lost; 181 182 if (c->flags & CLIENT_BAD) { 183 if (c->ibuf.w.queued == 0) 184 goto client_lost; 185 return; 186 } 187 188 if (events & EV_READ && server_client_msg_dispatch(c) != 0) 189 goto client_lost; 190 } 191 192 server_update_event(c); 193 return; 194 195 client_lost: 196 server_client_lost(c); 197 } 198 199 /* Handle client status timer. */ 200 void 201 server_client_status_timer(void) 202 { 203 struct client *c; 204 struct session *s; 205 struct job *job; 206 struct timeval tv; 207 u_int i; 208 int interval; 209 time_t difference; 210 211 if (gettimeofday(&tv, NULL) != 0) 212 fatal("gettimeofday failed"); 213 214 for (i = 0; i < ARRAY_LENGTH(&clients); i++) { 215 c = ARRAY_ITEM(&clients, i); 216 if (c == NULL || c->session == NULL) 217 continue; 218 if (c->message_string != NULL || c->prompt_string != NULL) { 219 /* 220 * Don't need timed redraw for messages/prompts so bail 221 * now. The status timer isn't reset when they are 222 * redrawn anyway. 223 */ 224 continue; 225 } 226 s = c->session; 227 228 if (!options_get_number(&s->options, "status")) 229 continue; 230 interval = options_get_number(&s->options, "status-interval"); 231 232 difference = tv.tv_sec - c->status_timer.tv_sec; 233 if (difference >= interval) { 234 RB_FOREACH(job, jobs, &c->status_jobs) 235 job_run(job); 236 c->flags |= CLIENT_STATUS; 237 } 238 } 239 } 240 241 /* Handle data key input from client. */ 242 void 243 server_client_handle_key(int key, struct mouse_event *mouse, void *data) 244 { 245 struct client *c = data; 246 struct session *s; 247 struct window *w; 248 struct window_pane *wp; 249 struct options *oo; 250 struct timeval tv; 251 struct key_binding *bd; 252 struct keylist *keylist; 253 int xtimeout, isprefix; 254 u_int i; 255 256 /* Check the client is good to accept input. */ 257 if ((c->flags & (CLIENT_DEAD|CLIENT_SUSPENDED)) != 0) 258 return; 259 if (c->session == NULL) 260 return; 261 s = c->session; 262 263 /* Update the activity timer. */ 264 if (gettimeofday(&c->activity_time, NULL) != 0) 265 fatal("gettimeofday failed"); 266 memcpy(&s->activity_time, &c->activity_time, sizeof s->activity_time); 267 268 w = c->session->curw->window; 269 wp = w->active; 270 oo = &c->session->options; 271 272 /* Special case: number keys jump to pane in identify mode. */ 273 if (c->flags & CLIENT_IDENTIFY && key >= '0' && key <= '9') { 274 if (c->flags & CLIENT_READONLY) 275 return; 276 wp = window_pane_at_index(w, key - '0'); 277 if (wp != NULL && window_pane_visible(wp)) 278 window_set_active_pane(w, wp); 279 server_clear_identify(c); 280 return; 281 } 282 283 /* Handle status line. */ 284 if (!(c->flags & CLIENT_READONLY)) { 285 status_message_clear(c); 286 server_clear_identify(c); 287 } 288 if (c->prompt_string != NULL) { 289 if (!(c->flags & CLIENT_READONLY)) 290 status_prompt_key(c, key); 291 return; 292 } 293 294 /* Check for mouse keys. */ 295 if (key == KEYC_MOUSE) { 296 if (c->flags & CLIENT_READONLY) 297 return; 298 if (options_get_number(oo, "mouse-select-pane")) { 299 window_set_active_at(w, mouse->x, mouse->y); 300 server_redraw_window_borders(w); 301 wp = w->active; 302 } 303 window_pane_mouse(wp, c, mouse); 304 return; 305 } 306 307 /* Is this a prefix key? */ 308 keylist = options_get_data(&c->session->options, "prefix"); 309 isprefix = 0; 310 for (i = 0; i < ARRAY_LENGTH(keylist); i++) { 311 if (key == ARRAY_ITEM(keylist, i)) { 312 isprefix = 1; 313 break; 314 } 315 } 316 317 /* No previous prefix key. */ 318 if (!(c->flags & CLIENT_PREFIX)) { 319 if (isprefix) 320 c->flags |= CLIENT_PREFIX; 321 else { 322 /* Try as a non-prefix key binding. */ 323 if ((bd = key_bindings_lookup(key)) == NULL) { 324 if (!(c->flags & CLIENT_READONLY)) 325 window_pane_key(wp, c, key); 326 } else 327 key_bindings_dispatch(bd, c); 328 } 329 return; 330 } 331 332 /* Prefix key already pressed. Reset prefix and lookup key. */ 333 c->flags &= ~CLIENT_PREFIX; 334 if ((bd = key_bindings_lookup(key | KEYC_PREFIX)) == NULL) { 335 /* If repeating, treat this as a key, else ignore. */ 336 if (c->flags & CLIENT_REPEAT) { 337 c->flags &= ~CLIENT_REPEAT; 338 if (isprefix) 339 c->flags |= CLIENT_PREFIX; 340 else if (!(c->flags & CLIENT_READONLY)) 341 window_pane_key(wp, c, key); 342 } 343 return; 344 } 345 346 /* If already repeating, but this key can't repeat, skip it. */ 347 if (c->flags & CLIENT_REPEAT && !bd->can_repeat) { 348 c->flags &= ~CLIENT_REPEAT; 349 if (isprefix) 350 c->flags |= CLIENT_PREFIX; 351 else if (!(c->flags & CLIENT_READONLY)) 352 window_pane_key(wp, c, key); 353 return; 354 } 355 356 /* If this key can repeat, reset the repeat flags and timer. */ 357 xtimeout = options_get_number(&c->session->options, "repeat-time"); 358 if (xtimeout != 0 && bd->can_repeat) { 359 c->flags |= CLIENT_PREFIX|CLIENT_REPEAT; 360 361 tv.tv_sec = xtimeout / 1000; 362 tv.tv_usec = (xtimeout % 1000) * 1000L; 363 evtimer_del(&c->repeat_timer); 364 evtimer_add(&c->repeat_timer, &tv); 365 } 366 367 /* Dispatch the command. */ 368 key_bindings_dispatch(bd, c); 369 } 370 371 /* Client functions that need to happen every loop. */ 372 void 373 server_client_loop(void) 374 { 375 struct client *c; 376 struct window *w; 377 struct window_pane *wp; 378 u_int i; 379 380 for (i = 0; i < ARRAY_LENGTH(&clients); i++) { 381 c = ARRAY_ITEM(&clients, i); 382 if (c == NULL || c->session == NULL) 383 continue; 384 385 server_client_check_redraw(c); 386 server_client_reset_state(c); 387 } 388 389 /* 390 * Any windows will have been redrawn as part of clients, so clear 391 * their flags now. 392 */ 393 for (i = 0; i < ARRAY_LENGTH(&windows); i++) { 394 w = ARRAY_ITEM(&windows, i); 395 if (w == NULL) 396 continue; 397 398 w->flags &= ~WINDOW_REDRAW; 399 TAILQ_FOREACH(wp, &w->panes, entry) 400 wp->flags &= ~PANE_REDRAW; 401 } 402 } 403 404 /* 405 * Update cursor position and mode settings. The scroll region and attributes 406 * are cleared when idle (waiting for an event) as this is the most likely time 407 * a user may interrupt tmux, for example with ~^Z in ssh(1). This is a 408 * compromise between excessive resets and likelihood of an interrupt. 409 * 410 * tty_region/tty_reset/tty_update_mode already take care of not resetting 411 * things that are already in their default state. 412 */ 413 void 414 server_client_reset_state(struct client *c) 415 { 416 struct window *w = c->session->curw->window; 417 struct window_pane *wp = w->active; 418 struct screen *s = wp->screen; 419 struct options *oo = &c->session->options; 420 int status, mode; 421 422 tty_region(&c->tty, 0, c->tty.sy - 1); 423 424 status = options_get_number(oo, "status"); 425 if (!window_pane_visible(wp) || wp->yoff + s->cy >= c->tty.sy - status) 426 tty_cursor(&c->tty, 0, 0); 427 else 428 tty_cursor(&c->tty, wp->xoff + s->cx, wp->yoff + s->cy); 429 430 mode = s->mode; 431 if (TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry) != NULL && 432 options_get_number(oo, "mouse-select-pane")) 433 mode |= MODE_MOUSE; 434 tty_update_mode(&c->tty, mode); 435 tty_reset(&c->tty); 436 } 437 438 /* Repeat time callback. */ 439 /* ARGSUSED */ 440 void 441 server_client_repeat_timer(unused int fd, unused short events, void *data) 442 { 443 struct client *c = data; 444 445 if (c->flags & CLIENT_REPEAT) 446 c->flags &= ~(CLIENT_PREFIX|CLIENT_REPEAT); 447 } 448 449 /* Check for client redraws. */ 450 void 451 server_client_check_redraw(struct client *c) 452 { 453 struct session *s = c->session; 454 struct window_pane *wp; 455 int flags, redraw; 456 457 flags = c->tty.flags & TTY_FREEZE; 458 c->tty.flags &= ~TTY_FREEZE; 459 460 if (c->flags & (CLIENT_REDRAW|CLIENT_STATUS)) { 461 if (options_get_number(&s->options, "set-titles")) 462 server_client_set_title(c); 463 464 if (c->message_string != NULL) 465 redraw = status_message_redraw(c); 466 else if (c->prompt_string != NULL) 467 redraw = status_prompt_redraw(c); 468 else 469 redraw = status_redraw(c); 470 if (!redraw) 471 c->flags &= ~CLIENT_STATUS; 472 } 473 474 if (c->flags & CLIENT_REDRAW) { 475 screen_redraw_screen(c, 0, 0); 476 c->flags &= ~(CLIENT_STATUS|CLIENT_BORDERS); 477 } else { 478 TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) { 479 if (wp->flags & PANE_REDRAW) 480 screen_redraw_pane(c, wp); 481 } 482 } 483 484 if (c->flags & CLIENT_BORDERS) 485 screen_redraw_screen(c, 0, 1); 486 487 if (c->flags & CLIENT_STATUS) 488 screen_redraw_screen(c, 1, 0); 489 490 c->tty.flags |= flags; 491 492 c->flags &= ~(CLIENT_REDRAW|CLIENT_STATUS|CLIENT_BORDERS); 493 } 494 495 /* Set client title. */ 496 void 497 server_client_set_title(struct client *c) 498 { 499 struct session *s = c->session; 500 const char *template; 501 char *title; 502 503 template = options_get_string(&s->options, "set-titles-string"); 504 505 title = status_replace(c, NULL, template, time(NULL), 1); 506 if (c->title == NULL || strcmp(title, c->title) != 0) { 507 if (c->title != NULL) 508 xfree(c->title); 509 c->title = xstrdup(title); 510 tty_set_title(&c->tty, c->title); 511 } 512 xfree(title); 513 } 514 515 /* Dispatch message from client. */ 516 int 517 server_client_msg_dispatch(struct client *c) 518 { 519 struct imsg imsg; 520 struct msg_command_data commanddata; 521 struct msg_identify_data identifydata; 522 struct msg_environ_data environdata; 523 ssize_t n, datalen; 524 525 if ((n = imsg_read(&c->ibuf)) == -1 || n == 0) 526 return (-1); 527 528 for (;;) { 529 if ((n = imsg_get(&c->ibuf, &imsg)) == -1) 530 return (-1); 531 if (n == 0) 532 return (0); 533 datalen = imsg.hdr.len - IMSG_HEADER_SIZE; 534 535 if (imsg.hdr.peerid != PROTOCOL_VERSION) { 536 server_write_client(c, MSG_VERSION, NULL, 0); 537 c->flags |= CLIENT_BAD; 538 imsg_free(&imsg); 539 continue; 540 } 541 542 log_debug("got %d from client %d", imsg.hdr.type, c->ibuf.fd); 543 switch (imsg.hdr.type) { 544 case MSG_COMMAND: 545 if (datalen != sizeof commanddata) 546 fatalx("bad MSG_COMMAND size"); 547 memcpy(&commanddata, imsg.data, sizeof commanddata); 548 549 server_client_msg_command(c, &commanddata); 550 break; 551 case MSG_IDENTIFY: 552 if (datalen != sizeof identifydata) 553 fatalx("bad MSG_IDENTIFY size"); 554 if (imsg.fd == -1) 555 fatalx("MSG_IDENTIFY missing fd"); 556 memcpy(&identifydata, imsg.data, sizeof identifydata); 557 558 server_client_msg_identify(c, &identifydata, imsg.fd); 559 break; 560 case MSG_RESIZE: 561 if (datalen != 0) 562 fatalx("bad MSG_RESIZE size"); 563 564 tty_resize(&c->tty); 565 recalculate_sizes(); 566 server_redraw_client(c); 567 break; 568 case MSG_EXITING: 569 if (datalen != 0) 570 fatalx("bad MSG_EXITING size"); 571 572 c->session = NULL; 573 tty_close(&c->tty); 574 server_write_client(c, MSG_EXITED, NULL, 0); 575 break; 576 case MSG_WAKEUP: 577 case MSG_UNLOCK: 578 if (datalen != 0) 579 fatalx("bad MSG_WAKEUP size"); 580 581 if (!(c->flags & CLIENT_SUSPENDED)) 582 break; 583 c->flags &= ~CLIENT_SUSPENDED; 584 585 if (gettimeofday(&c->activity_time, NULL) != 0) 586 fatal("gettimeofday"); 587 if (c->session != NULL) { 588 memcpy(&c->session->activity_time, 589 &c->activity_time, 590 sizeof c->session->activity_time); 591 } 592 593 tty_start_tty(&c->tty); 594 server_redraw_client(c); 595 recalculate_sizes(); 596 break; 597 case MSG_ENVIRON: 598 if (datalen != sizeof environdata) 599 fatalx("bad MSG_ENVIRON size"); 600 memcpy(&environdata, imsg.data, sizeof environdata); 601 602 environdata.var[(sizeof environdata.var) - 1] = '\0'; 603 if (strchr(environdata.var, '=') != NULL) 604 environ_put(&c->environ, environdata.var); 605 break; 606 case MSG_SHELL: 607 if (datalen != 0) 608 fatalx("bad MSG_SHELL size"); 609 610 server_client_msg_shell(c); 611 break; 612 default: 613 fatalx("unexpected message"); 614 } 615 616 imsg_free(&imsg); 617 } 618 } 619 620 /* Callback to send error message to client. */ 621 void printflike2 622 server_client_msg_error(struct cmd_ctx *ctx, const char *fmt, ...) 623 { 624 struct msg_print_data data; 625 va_list ap; 626 627 va_start(ap, fmt); 628 xvsnprintf(data.msg, sizeof data.msg, fmt, ap); 629 va_end(ap); 630 631 server_write_client(ctx->cmdclient, MSG_ERROR, &data, sizeof data); 632 } 633 634 /* Callback to send print message to client. */ 635 void printflike2 636 server_client_msg_print(struct cmd_ctx *ctx, const char *fmt, ...) 637 { 638 struct msg_print_data data; 639 va_list ap; 640 641 va_start(ap, fmt); 642 xvsnprintf(data.msg, sizeof data.msg, fmt, ap); 643 va_end(ap); 644 645 server_write_client(ctx->cmdclient, MSG_PRINT, &data, sizeof data); 646 } 647 648 /* Callback to send print message to client, if not quiet. */ 649 void printflike2 650 server_client_msg_info(struct cmd_ctx *ctx, const char *fmt, ...) 651 { 652 struct msg_print_data data; 653 va_list ap; 654 655 if (options_get_number(&global_options, "quiet")) 656 return; 657 658 va_start(ap, fmt); 659 xvsnprintf(data.msg, sizeof data.msg, fmt, ap); 660 va_end(ap); 661 662 server_write_client(ctx->cmdclient, MSG_PRINT, &data, sizeof data); 663 } 664 665 /* Handle command message. */ 666 void 667 server_client_msg_command(struct client *c, struct msg_command_data *data) 668 { 669 struct cmd_ctx ctx; 670 struct cmd_list *cmdlist = NULL; 671 int argc; 672 char **argv, *cause; 673 674 ctx.error = server_client_msg_error; 675 ctx.print = server_client_msg_print; 676 ctx.info = server_client_msg_info; 677 678 ctx.msgdata = data; 679 ctx.curclient = NULL; 680 681 ctx.cmdclient = c; 682 683 argc = data->argc; 684 data->argv[(sizeof data->argv) - 1] = '\0'; 685 if (cmd_unpack_argv(data->argv, sizeof data->argv, argc, &argv) != 0) { 686 server_client_msg_error(&ctx, "command too long"); 687 goto error; 688 } 689 690 if (argc == 0) { 691 argc = 1; 692 argv = xcalloc(1, sizeof *argv); 693 *argv = xstrdup("new-session"); 694 } 695 696 if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) { 697 server_client_msg_error(&ctx, "%s", cause); 698 cmd_free_argv(argc, argv); 699 goto error; 700 } 701 cmd_free_argv(argc, argv); 702 703 if (cmd_list_exec(cmdlist, &ctx) != 1) 704 server_write_client(c, MSG_EXIT, NULL, 0); 705 cmd_list_free(cmdlist); 706 return; 707 708 error: 709 if (cmdlist != NULL) 710 cmd_list_free(cmdlist); 711 server_write_client(c, MSG_EXIT, NULL, 0); 712 } 713 714 /* Handle identify message. */ 715 void 716 server_client_msg_identify( 717 struct client *c, struct msg_identify_data *data, int fd) 718 { 719 c->cwd = NULL; 720 data->cwd[(sizeof data->cwd) - 1] = '\0'; 721 if (*data->cwd != '\0') 722 c->cwd = xstrdup(data->cwd); 723 724 data->term[(sizeof data->term) - 1] = '\0'; 725 tty_init(&c->tty, fd, data->term); 726 if (data->flags & IDENTIFY_UTF8) 727 c->tty.flags |= TTY_UTF8; 728 if (data->flags & IDENTIFY_256COLOURS) 729 c->tty.term_flags |= TERM_256COLOURS; 730 else if (data->flags & IDENTIFY_88COLOURS) 731 c->tty.term_flags |= TERM_88COLOURS; 732 c->tty.key_callback = server_client_handle_key; 733 c->tty.key_data = c; 734 735 tty_resize(&c->tty); 736 737 c->flags |= CLIENT_TERMINAL; 738 } 739 740 /* Handle shell message. */ 741 void 742 server_client_msg_shell(struct client *c) 743 { 744 struct msg_shell_data data; 745 const char *shell; 746 747 shell = options_get_string(&global_s_options, "default-shell"); 748 749 if (*shell == '\0' || areshell(shell)) 750 shell = _PATH_BSHELL; 751 if (strlcpy(data.shell, shell, sizeof data.shell) >= sizeof data.shell) 752 strlcpy(data.shell, _PATH_BSHELL, sizeof data.shell); 753 754 server_write_client(c, MSG_SHELL, &data, sizeof data); 755 c->flags |= CLIENT_BAD; /* it will die after exec */ 756 } 757