kernel/core/tty.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <build.h>
  23 #include <system.h>
  24 #include <string.h>
  25 #include <vfs.h>
  26
  27 #ifdef ARCH_i386                        /* i386 specific things */
  28 extern int gets (void);
  29 extern unsigned short *textmemptr;
  30 #endif
  31 extern int attrib;
  32 extern int csr_x, csr_y;
  33 extern unsigned char vgagui;
  34
  35 static char con_screen[TTY_CON_BUF];    /* console buffer for image of screen */
  36 static unsigned short tty_count;        /* number of created ttys */
  37 tty_font_t tty_font;                    /* global font settings */
  38 tty_char_t tty_char;                    /* global character array settings */
  39
  40 tty_t tty_list;                         /* list for all created ttys */
  41 tty_t *tty0, *tty1;                     /* structures for default ttys (0, 1) */
  42
  43 static unsigned task_tty ();
  44
  45 /* setup of font */
  46 bool tty_font_set (char *c, unsigned char x, unsigned char y)
  47 {
  48         if (!c || !x || !y)
  49                 return 0;
  50
  51         tty_font.c = c;
  52         tty_font.x = x;
  53         tty_font.y = y;
  54
  55         return 1;
  56 }
  57
  58 /* setup of character array */
  59 bool tty_char_set (unsigned short x, unsigned short y)
  60 {
  61         if ((x * y * 2) > TTY_CON_BUF)
  62                 return 0;
  63
  64         tty_char.x = x;
  65         tty_char.y = y;
  66
  67         return 1;
  68 }
  69
  70 /* clear selected screen */
  71 bool tty_cls (tty_t *tty)
  72 {
  73         if (!tty)
  74                 return 0;
  75
  76         if (!tty->screen)
  77                 return 0;
  78
  79         memset (tty->screen, 0, tty_char.x * tty_char.y * 2);
  80
  81         tty->screen_x = 0;
  82         tty->screen_y = 0;
  83
  84         if (tty != currtty)
  85                 return 1;
  86
  87 #ifdef ARCH_i386
  88         if (vgagui) {
  89                 if (vgagui == 2)
  90                         video_gfx_cls (0);
  91
  92                 return 1;
  93         }
  94
  95         csr_x = 0;
  96         csr_y = 0;
  97
  98         video_scroll ();
  99         video_move_csr ();
 100 #endif
 101         video_cls ();
 102
 103         return 1;
 104 }
 105
 106 /* lock manipulation with selected tty */
 107 bool tty_lock (tty_t *tty)
 108 {
 109         if (!tty)
 110                 return 0;
 111
 112         tty->active = false;
 113
 114         return 1;
 115 }
 116
 117 /* unlock manipulation with selected tty */
 118 bool tty_unlock (tty_t *tty)
 119 {
 120         if (!tty)
 121                 return 0;
 122
 123         tty->active = true;
 124
 125         return 1;
 126 }
 127
 128 /* startup function for tty init */
 129 bool tty_startup ()
 130 {
 131         tty_t *tty = tty0;
 132
 133         if (tty == NULL)
 134                 return 0;
 135
 136         currtty = tty;
 137
 138         strcpy (currtty->pwd, (char *) env_get ("PWD"));
 139
 140         currtty = tty;
 141
 142         env_set ("PWD", tty->pwd);
 143
 144         /* always default colors */
 145         attrib = 0x07;
 146
 147         /* clear screen*/
 148         video_cls ();
 149
 150         return 1;
 151 }
 152
 153 /* change current tty to selected one */
 154 bool tty_change (tty_t *tty)
 155 {
 156 #ifndef ARCH_i386
 157         return 0;
 158 #endif
 159         if (tty == NULL)
 160                 return 0;
 161
 162 #ifdef ARCH_i386
 163         /* redraw screen with selected tty */
 164         memcpy (textmemptr, tty->screen, tty_char.x * tty_char.y * 2);
 165
 166         csr_x = tty->screen_x;
 167         csr_y = tty->screen_y;
 168
 169         video_move_csr ();
 170 #endif
 171         strcpy (currtty->pwd, (char *) env_get ("PWD"));
 172
 173         if (currtty->user && currtty->user->name)
 174                 strcpy (currtty->user->name, (char *) env_get ("USER"));
 175
 176         currtty = tty;
 177
 178         env_set ("PWD", tty->pwd);
 179
 180         if (tty->user)
 181                 env_set ("USER", tty->user->name);
 182
 183         return 1;
 184 }
 185
 186 /* move cursor position to selected place */
 187 bool tty_gotoxy (tty_t *tty, unsigned char x, unsigned char y)
 188 {
 189         if (tty == NULL)
 190                 return 0;
 191
 192         if (x >= tty_char.x || y >= tty_char.y)
 193                 return 0;
 194
 195         video_gotoxy (x, y);
 196
 197         tty->screen_x = x;
 198         tty->screen_y = y;
 199
 200         return 1;
 201 }
 202
 203 /* find wanted tty by name */
 204 tty_t *tty_find (char *name)
 205 {
 206         tty_t *tty;
 207
 208         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 209                 if (!strcmp (tty->name, name))
 210                         return tty;
 211         }
 212
 213         return NULL;
 214 }
 215
 216 /* find tty by task */
 217 tty_t *tty_findbytask (task_t *task)
 218 {
 219         tty_t *tty;
 220
 221         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 222                 if (tty->task == task)
 223                         return tty;
 224         }
 225
 226         return NULL;
 227 }
 228
 229 /* display list of created tty consoles */
 230 void tty_listview ()
 231 {
 232         unsigned short id = 1;
 233
 234         tty_t *tty;
 235
 236         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 237                 printf ("%d.\t%s\t%s\n", id, tty->name, currtty == tty ? "<- current" : "");
 238
 239                 id ++;
 240         }
 241 }
 242
 243 /* enable logging for TTY */
 244 int tty_log_create (tty_t *tty, unsigned short len)
 245 {
 246         if (!tty || !len)
 247                 return 0;
 248
 249         tty->log = (tty_log_t *) kmalloc (sizeof (tty_log_t));
 250
 251         if (!tty->log)
 252                 return 0;
 253
 254         tty->log->buf = (char *) kmalloc (sizeof (char) * len);
 255
 256         if (!tty->log->buf) {
 257                 kfree (tty->log);
 258                 return 0;
 259         }
 260
 261         tty->log->len = len;
 262         tty->log->pos = 0;
 263
 264         return 1;
 265 }
 266
 267 /* main function for print strings into selected tty */
 268 bool tty_write (tty_t *tty, char *str, unsigned len)
 269 {
 270         if (!tty)
 271                 return 0;
 272
 273         unsigned l = 0;
 274         while (l != len) {
 275                 if (!tty_putnch (tty, str[l]))
 276                         break;
 277
 278                 l ++;
 279         }
 280
 281         return 1;
 282 }
 283
 284 /* read strings from selected tty */
 285 int tty_read (tty_t *tty, char *str, unsigned len)
 286 {
 287         if (!tty || !str)
 288                 return 0;
 289
 290         /* create log buffer for current tty when not exist */
 291         if (!tty->log)
 292                 if (!tty_log_create (tty, 512))
 293                         return 0;
 294
 295         unsigned l = len;
 296
 297         if (l > tty->log->pos)
 298                 l = tty->log->pos;
 299
 300         memcpy (str, tty->log->buf, l);
 301
 302         tty->log->pos -= l;
 303
 304         return l;
 305 }
 306
 307 /* print character to current tty */
 308 bool tty_putch (char c)
 309 {
 310         tty_putnch (currtty, c);
 311
 312         return 1;
 313 }
 314
 315 /* print character to selected tty */
 316 bool tty_putnch (tty_t *tty, char c)
 317 {
 318         /* we wont null character */
 319         if (!c)
 320                 return 0;
 321
 322         switch (c) {
 323                 case '\n':
 324                         tty->screen_y ++;
 325                         tty->screen_x = 0;
 326                         break;
 327                 case '\b':
 328                         if (tty->screen_x)
 329                                 tty->screen_x --;
 330
 331                         /* save font attributes (colors) */
 332                         tty->screen[(tty->screen_x+(tty->screen_y*tty_char.x))*2] = ' ';
 333                         /* save character into buffer */
 334                         tty->screen[((tty->screen_x+(tty->screen_y*tty_char.x))*2)+1] = attrib;
 335
 336                         break;
 337                 case '\t':
 338                         tty->screen_x = (tty->screen_x + 8) & ~7;
 339                         break;
 340                 default:
 341                         /* save font attributes (colors) */
 342                         tty->screen[(tty->screen_x+(tty->screen_y*tty_char.x))*2] = c;
 343                         /* save character into buffer */
 344                         tty->screen[((tty->screen_x+(tty->screen_y*tty_char.x))*2)+1] = attrib;
 345                         tty->screen_x ++;
 346                         break;
 347         }
 348
 349         if (tty->screen_x >= tty_char.x) {
 350                 tty->screen_x -= tty_char.x;
 351                 tty->screen_y ++;
 352         }
 353
 354         if (tty->screen_y >= tty_char.y) {
 355                 unsigned i;
 356                 /* save old screen, but with one line offset */
 357                 for (i = 0; i < (tty_char.x * tty_char.y * 2) - (tty_char.x * 2); i ++)
 358                         con_screen[i] = tty->screen[i+(tty_char.x * 2)];
 359                 /* copy new image into tty screen */
 360                 for (i = 0; i < (tty_char.x * tty_char.y * 2); i ++)
 361                         tty->screen[i] = con_screen[i];
 362
 363                 tty->screen_y = tty_char.y - 1;
 364         }
 365
 366         if (tty == currtty) {
 367                 if (!vgagui)
 368                         video_putch (c);
 369         }
 370
 371         if (tty->log) {
 372                 if (tty->log->pos+1 == tty->log->len) {
 373                         memcpy (tty->log->buf, tty->log->buf+1, tty->log->len-1);
 374                         tty->log->buf[tty->log->pos] = c;
 375                 } else
 376                         tty->log->buf[tty->log->pos ++] = c;
 377         }
 378
 379         return 1;
 380 }
 381
 382 /* create Message Of The Day in /etc/motd */
 383 bool tty_motd ()
 384 {
 385         vfs_list_add ("motd", VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_SYSTEM, "/etc/");
 386
 387         char *motd =    "\t\t\t\tWelcome !\n"
 388                         "This is ZeX/OS - operating system created by Tomas 'ZeXx86' Jedrzejek\n"
 389                         "Please visit web page www.zexos.org for more information ..\n"
 390                         "Latest source code is available on git repository: git://repo.or.cz/ZeXOS.git\n"
 391                         "You can display list of the built-in commands by \"help\".\n"
 392                         "Default login name is \"root\" secured by password \"root\".\n";
 393
 394         vfs_content_t content;
 395         content.ptr = motd;
 396         content.len = strlen (motd);
 397
 398         vfs_mmap ("/etc/motd", 9, &content);
 399
 400         video_color (15, 0);
 401
 402         vfs_cat ("/etc/motd", 9);
 403
 404         video_color (7, 0);
 405
 406         return 1;
 407 }
 408
 409 /* virtual terminal (device handler) */
 410 bool vterm_acthandler (unsigned act, char *block, unsigned block_len)
 411 {
 412         switch (act) {
 413                 case DEV_ACT_INIT:
 414                 {
 415                         dev_flags_t *flags = (dev_flags_t *) block;
 416
 417                         if (!flags)
 418                                 return 0;
 419
 420                         if (block_len != sizeof (dev_flags_t))
 421                                 return 0;
 422
 423                         tty_t *tty = tty_find ((char *) flags->iomem);
 424
 425                         if (!tty)
 426                                 return 0;
 427
 428                         flags->iomem = (void *) tty->screen;
 429                         flags->iolen = tty_char.x * tty_char.y * 2;
 430
 431                         return 1;
 432                 }
 433                 break;
 434         }
 435
 436         return 0;
 437 }
 438
 439 /* create new tty console */
 440 tty_t *tty_create ()
 441 {
 442         /* Software limit - max. 1K of ttys */
 443         if (tty_count > TTY_COUNT_MAX)
 444                 return 0;
 445
 446         char name[8];
 447         sprintf (name, "tty%d", tty_count);
 448
 449         unsigned name_len = strlen (name);
 450
 451         /* alloc and init context */
 452         tty_t *tty = (tty_t *) kmalloc (sizeof (tty_t));
 453
 454         if (!tty)
 455                 return 0;
 456
 457         memset (tty, 0, sizeof (tty_t));
 458
 459         tty->screen = (char *) kmalloc (tty_char.x * tty_char.y * 2);
 460
 461         if (!tty->screen) {
 462                 kfree (tty);
 463                 return 0;
 464         }
 465
 466         tty->name = (char *) kmalloc (sizeof (char) * name_len + 1);
 467
 468         if (!tty->name) {
 469                 kfree (tty->screen);
 470                 kfree (tty);
 471                 return 0;
 472         }
 473
 474         memcpy (tty->name, name, name_len);
 475         tty->name[name_len] = '\0';
 476
 477         memset (tty->screen, 0, tty_char.x * tty_char.y * 2);
 478
 479         tty->screen_x = 0;
 480         tty->screen_y = 0;
 481
 482         tty->logged = false;
 483
 484         tty->active = true;
 485
 486         tty->log = 0;
 487
 488         strcpy (tty->pwd, (char *) env_get ("PWD"));
 489
 490         tty->task = (task_t *) task_create (name, (unsigned) task_tty, 32);
 491
 492         /* add into list */
 493         tty->next = &tty_list;
 494         tty->prev = tty_list.prev;
 495         tty->prev->next = tty;
 496         tty->next->prev = tty;
 497
 498         /* create device which correspnd with current TTY */
 499         dev_register (name, "Virtual terminal", DEV_ATTR_CHAR, (dev_handler_t *) &vterm_acthandler);
 500
 501         tty_count ++;
 502
 503         return tty;
 504 }
 505
 506 /* thread for running tty consoles - handle selected console */
 507 void task_thread (tty_t *tty)
 508 {
 509         schedule ();
 510
 511         if (!tty)
 512                 return;
 513
 514         if (tty != currtty)
 515                 return;
 516
 517         if (tty->active) {
 518                 /* handle console on kernel level */
 519                 int id = gets ();
 520
 521                 if (id == 1)
 522                         if (tty->user) {
 523                                 console (id);
 524                         } else
 525                                 getlogin (id);
 526
 527                 /* VESA mode - graphical font */
 528                 if (vgagui == 2) {
 529                         unsigned i = 0;
 530                         unsigned j = 0;
 531                         unsigned k = 0;
 532                         unsigned m = tty_char.x * tty_char.y;
 533
 534                         while (i < m) {
 535                                 gputch (1+(j*tty_font.x), 11+(k*(tty_font.y+1)), vesa_16cto16b (tty->screen[i*2+1] & 0x0F), tty->screen[i*2]);
 536
 537                                 j ++;
 538
 539                                 if (j >= tty_char.x) {
 540                                         j = 0;
 541                                         k ++;
 542                                 }
 543
 544                                 i ++;
 545                         }
 546
 547                         video_gfx_fbswap ();
 548                 }
 549         }
 550 }
 551
 552 /* startup function for created tty console */
 553 static unsigned task_tty ()
 554 {
 555         tty_t *tty = tty_findbytask (_curr_task);
 556
 557         if (!tty)
 558                 return 0;
 559
 560         for (;;)
 561                 task_thread (tty);
 562 }
 563
 564 /* change tty console to next (+) or previous (-) in list */
 565 void tty_switch (char act)
 566 {
 567         switch (act) {
 568                 case '+':
 569                 {
 570                         tty_t *tty = currtty->next;
 571
 572                         if (tty == &tty_list)
 573                                 tty = tty_list.next;
 574
 575                         if (tty)
 576                                 tty_change (tty);
 577
 578                         break;
 579                 }
 580                 case '-':
 581                 {
 582                         tty_t *tty = currtty->prev;
 583
 584                         if (tty == &tty_list)
 585                                 tty = tty_list.prev;
 586
 587                         if (tty)
 588                                 tty_change (tty);
 589
 590                         break;
 591                 }
 592         }
 593 }
 594
 595 /* special function for initialization of graphical tty */
 596 tty_t *gtty_init ()
 597 {
 598         tty_t *tty = tty_create ();
 599
 600         tty_change (tty);
 601
 602         return tty;
 603 }
 604
 605 /* initialization of tty */
 606 unsigned int init_tty ()
 607 {
 608         /* pre-set tty list */
 609         tty_list.next = &tty_list;
 610         tty_list.prev = &tty_list;
 611
 612         /* default values */
 613         tty_count = 0;
 614
 615         tty_font_set ((char *) font5x8, 5, 8);
 616
 617         switch (vgagui) {
 618                 case 0: /* VGA-Textual console */
 619                         tty_char_set (80, 25);
 620                         break;
 621                 case 1: /* VGA console */
 622                         tty_char_set (53, 18);
 623                         break;
 624                 case 2: /* VESA concole */
 625                         tty_char_set (80, 65);
 626                         break;
 627         }
 628
 629         video_color (7, 0);
 630
 631         /* create consoles */
 632         tty0 = tty_create ();
 633
 634         if (!tty0)
 635                 return 0;
 636
 637 #ifdef ARCH_i386
 638         tty1 = tty_create ();
 639
 640         if (!tty1)
 641                 return 0;
 642 #endif
 643         tty_startup ();
 644
 645         /* printf MOTD into TTY0 console */
 646         tty_motd ();
 647
 648         /* then print login messages */
 649         tty_write (tty0, "\nlogin: ", 8);
 650 #ifdef ARCH_i386
 651         tty_write (tty1, "\nlogin: ", 8);
 652 #endif
 653         return 1;
 654 }
 655