1 /* 2 * Copyright 2004-2010, Haiku. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 * 5 * Copyright 2002, Travis Geiselbrecht. All rights reserved. 6 * Distributed under the terms of the NewOS License. 7 */ 8 9 10 #include <ctype.h> 11 #include <dirent.h> 12 #include <errno.h> 13 #include <stdio.h> 14 #include <stdlib.h> 15 #include <string.h> 16 #include <termios.h> 17 #include <unistd.h> 18 19 #include <FindDirectory.h> 20 #include <image.h> 21 #include <InterfaceDefs.h> 22 #include <OS.h> 23 24 #include <keyboard_mouse_driver.h> 25 #include <Keymap.h> 26 27 28 struct console; 29 30 struct keyboard { 31 struct keyboard* next; 32 int device; 33 int target; 34 thread_id thread; 35 }; 36 37 struct console { 38 int console_fd; 39 thread_id console_writer; 40 41 struct keyboard* keyboards; 42 43 int tty_master_fd; 44 int tty_slave_fd; 45 int tty_num; 46 }; 47 48 49 struct console gConsole; 50 51 52 void 53 error(const char* message, ...) 54 { 55 char buffer[2048]; 56 57 va_list args; 58 va_start(args, message); 59 60 vsnprintf(buffer, sizeof(buffer), message, args); 61 62 va_end(args); 63 64 // put it out on stderr as well as to serial/syslog 65 fputs(buffer, stderr); 66 debug_printf("%s", buffer); 67 } 68 69 70 void 71 update_leds(int fd, uint32 modifiers) 72 { 73 char lockIO[3] = {0, 0, 0}; 74 75 if ((modifiers & B_NUM_LOCK) != 0) 76 lockIO[0] = 1; 77 if ((modifiers & B_CAPS_LOCK) != 0) 78 lockIO[1] = 1; 79 if ((modifiers & B_SCROLL_LOCK) != 0) 80 lockIO[2] = 1; 81 82 ioctl(fd, KB_SET_LEDS, &lockIO); 83 } 84 85 86 static int32 87 keyboard_reader(void* arg) 88 { 89 struct keyboard* keyboard = (struct keyboard*)arg; 90 uint8 activeDeadKey = 0; 91 uint32 modifiers = 0; 92 93 BKeymap keymap; 94 // Load current keymap from disk (we can't talk to the input server) 95 // TODO: find a better way (we shouldn't have to care about the on-disk 96 // location) 97 char path[PATH_MAX]; 98 status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, 99 path, sizeof(path)); 100 if (status == B_OK) { 101 strlcat(path, "/Key_map", sizeof(path)); 102 status = keymap.SetTo(path); 103 } 104 if (status != B_OK) 105 keymap.SetToDefault(); 106 107 for (;;) { 108 raw_key_info rawKeyInfo; 109 if (ioctl(keyboard->device, KB_READ, &rawKeyInfo) != 0) 110 break; 111 112 uint32 keycode = rawKeyInfo.keycode; 113 bool isKeyDown = rawKeyInfo.is_keydown; 114 115 if (keycode == 0) 116 continue; 117 118 uint32 changedModifiers = keymap.Modifier(keycode); 119 bool isLock = (changedModifiers 120 & (B_CAPS_LOCK | B_NUM_LOCK | B_SCROLL_LOCK)) != 0; 121 if (changedModifiers != 0 && (!isLock || isKeyDown)) { 122 uint32 oldModifiers = modifiers; 123 124 if ((isKeyDown && !isLock) 125 || (isKeyDown && !(modifiers & changedModifiers))) 126 modifiers |= changedModifiers; 127 else { 128 modifiers &= ~changedModifiers; 129 130 // ensure that we don't clear a combined B_*_KEY when still 131 // one of the individual B_{LEFT|RIGHT}_*_KEY is pressed 132 if (modifiers & (B_LEFT_SHIFT_KEY | B_RIGHT_SHIFT_KEY)) 133 modifiers |= B_SHIFT_KEY; 134 if (modifiers & (B_LEFT_COMMAND_KEY | B_RIGHT_COMMAND_KEY)) 135 modifiers |= B_COMMAND_KEY; 136 if (modifiers & (B_LEFT_CONTROL_KEY | B_RIGHT_CONTROL_KEY)) 137 modifiers |= B_CONTROL_KEY; 138 if (modifiers & (B_LEFT_OPTION_KEY | B_RIGHT_OPTION_KEY)) 139 modifiers |= B_OPTION_KEY; 140 } 141 142 if (modifiers != oldModifiers) { 143 if (isLock) 144 update_leds(keyboard->device, modifiers); 145 } 146 } 147 148 uint8 newDeadKey = 0; 149 if (activeDeadKey == 0 || !isKeyDown) 150 newDeadKey = keymap.ActiveDeadKey(keycode, modifiers); 151 152 char* string = NULL; 153 int32 numBytes = 0; 154 if (newDeadKey == 0 && isKeyDown) { 155 keymap.GetChars(keycode, modifiers, activeDeadKey, &string, 156 &numBytes); 157 if (numBytes > 0) 158 write(keyboard->target, string, numBytes); 159 160 delete[] string; 161 } 162 163 if (newDeadKey == 0) { 164 if (isKeyDown && !modifiers && activeDeadKey != 0) { 165 // a dead key was completed 166 activeDeadKey = 0; 167 } 168 } else if (isKeyDown) { 169 // start of a dead key 170 activeDeadKey = newDeadKey; 171 } 172 } 173 174 return 0; 175 } 176 177 178 static int32 179 console_writer(void* arg) 180 { 181 struct console* con = (struct console*)arg; 182 183 for (;;) { 184 char buffer[1024]; 185 ssize_t length = read(con->tty_master_fd, buffer, sizeof(buffer)); 186 if (length < 0) 187 break; 188 189 write(con->console_fd, buffer, length); 190 } 191 192 return 0; 193 } 194 195 196 static void 197 stop_keyboards(struct console* con) 198 { 199 // close devices 200 201 for (struct keyboard* keyboard = con->keyboards; keyboard != NULL; 202 keyboard = keyboard->next) { 203 close(keyboard->device); 204 } 205 206 // wait for the threads 207 208 for (struct keyboard* keyboard = con->keyboards; keyboard != NULL;) { 209 struct keyboard* next = keyboard->next; 210 wait_for_thread(keyboard->thread, NULL); 211 212 delete keyboard; 213 keyboard = next; 214 } 215 216 con->keyboards = NULL; 217 } 218 219 220 /*! Opens the all keyboard drivers it finds starting from the given 221 location \a start that support the debugger extension. 222 */ 223 static struct keyboard* 224 open_keyboards(int target, const char* start, struct keyboard* previous) 225 { 226 // Wait for the directory to appear, if we're loaded early in boot 227 // it may take a while for it to appear while the drivers load. 228 DIR* dir; 229 int32 tries = 0; 230 while (true) { 231 dir = opendir(start); 232 if (dir != NULL) 233 break; 234 if(++tries == 10) 235 return NULL; 236 sleep(1); 237 } 238 239 struct keyboard* keyboard = previous; 240 241 while (true) { 242 dirent* entry = readdir(dir); 243 if (entry == NULL) 244 break; 245 if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) 246 continue; 247 248 char path[PATH_MAX]; 249 strlcpy(path, start, sizeof(path)); 250 strlcat(path, "/", sizeof(path)); 251 strlcat(path, entry->d_name, sizeof(path)); 252 253 struct stat stat; 254 if (::stat(path, &stat) != 0) 255 continue; 256 257 if (S_ISDIR(stat.st_mode)) { 258 keyboard = open_keyboards(target, path, keyboard); 259 continue; 260 } 261 262 // Try to open it as a device 263 int fd = open(path, O_RDONLY); 264 if (fd >= 0) { 265 // Turn on debugger mode 266 if (ioctl(fd, KB_SET_DEBUG_READER, NULL, 0) == 0) { 267 keyboard = new ::keyboard(); 268 keyboard->device = fd; 269 keyboard->target = target; 270 keyboard->thread = spawn_thread(&keyboard_reader, path, 271 B_URGENT_DISPLAY_PRIORITY, keyboard); 272 if (keyboard->thread < 0) { 273 close(fd); 274 closedir(dir); 275 delete keyboard; 276 return NULL; 277 } 278 279 if (previous != NULL) 280 previous->next = keyboard; 281 282 resume_thread(keyboard->thread); 283 } else 284 close(fd); 285 } 286 } 287 288 closedir(dir); 289 return keyboard; 290 } 291 292 293 static int 294 start_console(struct console* con) 295 { 296 memset(con, 0, sizeof(struct console)); 297 con->console_fd = -1; 298 con->tty_master_fd = -1; 299 con->tty_slave_fd = -1; 300 con->console_writer = -1; 301 302 con->console_fd = open("/dev/console", O_WRONLY); 303 if (con->console_fd < 0) 304 return -2; 305 306 DIR* dir = opendir("/dev/pt"); 307 if (dir != NULL) { 308 struct dirent* entry; 309 char name[64]; 310 311 while ((entry = readdir(dir)) != NULL) { 312 if (entry->d_name[0] == '.') 313 continue; 314 315 snprintf(name, sizeof(name), "/dev/pt/%s", entry->d_name); 316 317 con->tty_master_fd = open(name, O_RDWR); 318 if (con->tty_master_fd >= 0) { 319 snprintf(name, sizeof(name), "/dev/tt/%s", entry->d_name); 320 321 con->tty_slave_fd = open(name, O_RDWR); 322 if (con->tty_slave_fd < 0) { 323 error("Could not open tty %s: %s!\n", name, 324 strerror(errno)); 325 close(con->tty_master_fd); 326 } else { 327 // set default mode 328 struct termios termios; 329 struct winsize size; 330 331 if (tcgetattr(con->tty_slave_fd, &termios) == 0) { 332 termios.c_iflag = ICRNL; 333 termios.c_oflag = OPOST | ONLCR; 334 termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHONL; 335 336 tcsetattr(con->tty_slave_fd, TCSANOW, &termios); 337 } 338 339 if (ioctl(con->console_fd, TIOCGWINSZ, &size, 340 sizeof(struct winsize)) == 0) { 341 // we got the window size from the console 342 ioctl(con->tty_slave_fd, TIOCSWINSZ, &size, 343 sizeof(struct winsize)); 344 } 345 } 346 break; 347 } 348 } 349 350 setenv("TTY", name, true); 351 } 352 353 if (con->tty_master_fd < 0 || con->tty_slave_fd < 0) 354 return -3; 355 356 con->keyboards 357 = open_keyboards(con->tty_master_fd, "/dev/input/keyboard", NULL); 358 if (con->keyboards == NULL) 359 return -4; 360 361 con->console_writer = spawn_thread(&console_writer, "console writer", 362 B_URGENT_DISPLAY_PRIORITY, con); 363 if (con->console_writer < 0) 364 return -5; 365 366 resume_thread(con->console_writer); 367 setenv("TERM", "xterm", true); 368 369 return 0; 370 } 371 372 373 static void 374 stop_console(struct console* con) 375 { 376 // close TTY FDs; this will also unblock the threads 377 close(con->tty_master_fd); 378 close(con->tty_slave_fd); 379 380 // close console and keyboards 381 close(con->console_fd); 382 wait_for_thread(con->console_writer, NULL); 383 384 stop_keyboards(con); 385 } 386 387 388 static pid_t 389 start_process(int argc, const char** argv, struct console* con) 390 { 391 int savedInput = dup(0); 392 int savedOutput = dup(1); 393 int savedError = dup(2); 394 395 dup2(con->tty_slave_fd, 0); 396 dup2(con->tty_slave_fd, 1); 397 dup2(con->tty_slave_fd, 2); 398 399 pid_t pid = load_image(argc, argv, (const char**)environ); 400 resume_thread(pid); 401 setpgid(pid, 0); 402 tcsetpgrp(con->tty_slave_fd, pid); 403 404 dup2(savedInput, 0); 405 dup2(savedOutput, 1); 406 dup2(savedError, 2); 407 close(savedInput); 408 close(savedOutput); 409 close(savedError); 410 411 return pid; 412 } 413 414 415 int 416 main(int argc, char** argv) 417 { 418 // we're a session leader 419 setsid(); 420 421 int err = start_console(&gConsole); 422 if (err < 0) { 423 error("consoled: error %d starting console.\n", err); 424 return err; 425 } 426 427 // move our stdin and stdout to the console 428 dup2(gConsole.tty_slave_fd, 0); 429 dup2(gConsole.tty_slave_fd, 1); 430 dup2(gConsole.tty_slave_fd, 2); 431 432 if (argc > 1) { 433 // a command was given: we run it only once 434 435 // get the command argument vector 436 int commandArgc = argc - 1; 437 const char** commandArgv = new const char*[commandArgc + 1]; 438 for (int i = 0; i < commandArgc; i++) 439 commandArgv[i] = argv[i + 1]; 440 441 commandArgv[commandArgc] = NULL; 442 443 // start the process 444 pid_t process = start_process(commandArgc, commandArgv, &gConsole); 445 446 status_t returnCode; 447 wait_for_thread(process, &returnCode); 448 } else { 449 // no command given: start a shell in an endless loop 450 for (;;) { 451 pid_t shellProcess; 452 status_t returnCode; 453 const char* shellArgv[] = { "/bin/sh", "--login", NULL }; 454 455 shellProcess = start_process(2, shellArgv, &gConsole); 456 457 wait_for_thread(shellProcess, &returnCode); 458 459 puts("Restart shell"); 460 } 461 } 462 463 stop_console(&gConsole); 464 465 return 0; 466 } 467 468