kernel/core/tty.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@gmail.com)
   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         tty->read_len = 0;
  84
  85         if (tty != currtty)
  86                 return 1;
  87
  88 #ifdef ARCH_i386
  89         if (vgagui) {
  90                 if (vgagui == 2)
  91                         video_gfx_cls (0);
  92
  93                 return 1;
  94         }
  95
  96         csr_x = 0;
  97         csr_y = 0;
  98
  99         video_scroll ();
 100         video_move_csr ();
 101 #endif
 102         video_cls ();
 103
 104         return 1;
 105 }
 106
 107 /* lock manipulation with selected tty */
 108 bool tty_lock (tty_t *tty)
 109 {
 110         if (!tty)
 111                 return 0;
 112
 113         tty->active = false;
 114
 115         return 1;
 116 }
 117
 118 /* unlock manipulation with selected tty */
 119 bool tty_unlock (tty_t *tty)
 120 {
 121         if (!tty)
 122                 return 0;
 123
 124         tty->active = true;
 125
 126         return 1;
 127 }
 128
 129 /* startup function for tty init */
 130 bool tty_startup ()
 131 {
 132         tty_t *tty = tty0;
 133
 134         if (tty == NULL)
 135                 return 0;
 136
 137         currtty = tty;
 138
 139         strcpy (currtty->pwd, (char *) env_get ("PWD"));
 140
 141         currtty = tty;
 142
 143         env_set ("PWD", tty->pwd);
 144
 145         /* always default colors */
 146         attrib = 0x07;
 147
 148         /* clear screen*/
 149         video_cls ();
 150
 151         return 1;
 152 }
 153
 154 /* change current tty to selected one */
 155 bool tty_change (tty_t *tty)
 156 {
 157 #ifndef ARCH_i386
 158         return 0;
 159 #endif
 160         if (tty == NULL)
 161                 return 0;
 162
 163 #ifdef ARCH_i386
 164         /* redraw screen with selected tty */
 165         memcpy (textmemptr, tty->screen, tty_char.x * tty_char.y * 2);
 166
 167         csr_x = tty->screen_x;
 168         csr_y = tty->screen_y;
 169
 170         video_move_csr ();
 171 #endif
 172         strcpy (currtty->pwd, (char *) env_get ("PWD"));
 173
 174         if (currtty->user && currtty->user->name)
 175                 strcpy (currtty->user->name, (char *) env_get ("USER"));
 176
 177         currtty = tty;
 178
 179         env_set ("PWD", tty->pwd);
 180
 181         if (tty->user)
 182                 env_set ("USER", tty->user->name);
 183
 184         return 1;
 185 }
 186
 187 /* move cursor position to selected place */
 188 bool tty_gotoxy (tty_t *tty, unsigned char x, unsigned char y)
 189 {
 190         if (tty == NULL)
 191                 return 0;
 192
 193         if (x >= tty_char.x || y >= tty_char.y)
 194                 return 0;
 195
 196         video_gotoxy (x, y);
 197
 198         tty->screen_x = x;
 199         tty->screen_y = y;
 200
 201         return 1;
 202 }
 203
 204 /* find wanted tty by name */
 205 tty_t *tty_find (char *name)
 206 {
 207         tty_t *tty;
 208
 209         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 210                 if (!strcmp (tty->name, name))
 211                         return tty;
 212         }
 213
 214         return NULL;
 215 }
 216
 217 /* find tty by task */
 218 tty_t *tty_findbytask (task_t *task)
 219 {
 220         tty_t *tty;
 221
 222         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 223                 if (tty->task == task)
 224                         return tty;
 225         }
 226
 227         return NULL;
 228 }
 229
 230 /* display list of created tty consoles */
 231 void tty_listview ()
 232 {
 233         unsigned short id = 1;
 234
 235         tty_t *tty;
 236
 237         for (tty = tty_list.next; tty != &tty_list; tty = tty->next) {
 238                 printf ("%d.\t%s\t%s\n", id, tty->name, currtty == tty ? "<- current" : "");
 239
 240                 id ++;
 241         }
 242 }
 243
 244 /* main function for print strings into selected tty */
 245 bool tty_write (tty_t *tty, char *str, unsigned len)
 246 {
 247         if (!tty)
 248                 return 0;
 249
 250         unsigned l = 0;
 251         while (l != len) {
 252                 if (!tty_putnch (tty, str[l]))
 253                         break;
 254
 255                 l ++;
 256         }
 257
 258         return 1;
 259 }
 260
 261 /* read strings from selected tty */
 262 int tty_read (tty_t *tty, char *str, unsigned len)
 263 {
 264         if (!tty || !str)
 265                 return 0;
 266
 267         char *p = (char *) tty->screen;
 268
 269         unsigned l = 0;
 270         unsigned n = 2000;
 271
 272         unsigned x = 0;
 273         unsigned y = 0;
 274
 275         if (len+tty->read_len > n)
 276                 len = n-tty->read_len;
 277
 278         for (l = 0; l < len; l ++) {
 279                 if (p[((l+tty->read_len)*2)+1])
 280                         str[l] = p[((l+tty->read_len)*2)+1];
 281
 282                 x ++;
 283
 284                 if (x >= tty_char.x) {
 285                         x = 0;
 286                         y ++;
 287                         str[l] = '\n';
 288                 }
 289         }
 290
 291         str[l] = '\0';
 292
 293         tty->read_len += l;
 294
 295         return l;
 296 }
 297
 298 /* print character to current tty */
 299 bool tty_putch (char c)
 300 {
 301         tty_putnch (currtty, c);
 302
 303         return 1;
 304 }
 305
 306 /* print character to selected tty */
 307 bool tty_putnch (tty_t *tty, char c)
 308 {
 309         /* we wont null character */
 310         if (!c)
 311                 return 0;
 312
 313         switch (c) {
 314                 case '\n':
 315                         tty->screen_y ++;
 316                         tty->screen_x = 0;
 317                         break;
 318                 case '\b':
 319                         if (tty->screen_x)
 320                                 tty->screen_x --;
 321
 322                         /* save font attributes (colors) */
 323                         tty->screen[(tty->screen_x+(tty->screen_y*tty_char.x))*2] = ' ';
 324                         /* save character into buffer */
 325                         tty->screen[((tty->screen_x+(tty->screen_y*tty_char.x))*2)+1] = attrib;
 326                         break;
 327                 case '\t':
 328                         tty->screen_x = (tty->screen_x + 8) & ~(8 - 1);
 329                         break;
 330                 default:
 331                         /* save font attributes (colors) */
 332                         tty->screen[(tty->screen_x+(tty->screen_y*tty_char.x))*2] = c;
 333                         /* save character into buffer */
 334                         tty->screen[((tty->screen_x+(tty->screen_y*tty_char.x))*2)+1] = attrib;
 335                         tty->screen_x ++;
 336                         break;
 337         }
 338
 339         if (tty->screen_x >= tty_char.x) {
 340                 tty->screen_x -= tty_char.x;
 341                 tty->screen_y ++;
 342         }
 343
 344         if (tty->screen_y >= tty_char.y) {
 345                 unsigned i;
 346                 /* save old screen, but with one line offset */
 347                 for (i = 0; i < (tty_char.x * tty_char.y * 2) - (tty_char.x * 2); i ++)
 348                         con_screen[i] = tty->screen[i+(tty_char.x * 2)];
 349                 /* copy new image into tty screen */
 350                 for (i = 0; i < (tty_char.x * tty_char.y * 2); i ++)
 351                         tty->screen[i] = con_screen[i];
 352
 353                 tty->read_len += tty_char.x;
 354
 355                 tty->screen_y = tty_char.y - 1;
 356         }
 357
 358         if (!vgagui)
 359         if (tty == currtty)
 360                 video_putch (c);
 361
 362         return 1;
 363 }
 364
 365 /* create Message Of The Day in /etc/motd */
 366 bool tty_motd ()
 367 {
 368         vfs_list_add ("motd", VFS_FILEATTR_FILE | VFS_FILEATTR_READ | VFS_FILEATTR_SYSTEM, "/etc/");
 369
 370         char *motd =    "\t\t\t\tWelcome !\n"
 371                         "This is ZeX/OS - operating system created by Tomas 'ZeXx86' Jedrzejek\n"
 372                         "Please visit web page www.zexos.org for more information ..\n"
 373                         "Latest source code is available on git repository: git://repo.or.cz/ZeXOS.git\n"
 374                         "You can display list of the built-in commands by \"help\".\n"
 375                         "Default login name is \"root\" secured by password \"root\".\n";
 376
 377         vfs_mmap ("/etc/motd", 9, motd, strlen (motd));
 378
 379         video_color (15, 0);
 380
 381         vfs_cat ("/etc/motd", 9);
 382
 383         video_color (7, 0);
 384
 385         return 1;
 386 }
 387
 388 /* create new tty console */
 389 tty_t *tty_create ()
 390 {
 391         /* Software limit - max. 1K of ttys */
 392         if (tty_count > TTY_COUNT_MAX)
 393                 return 0;
 394
 395         char name[8];
 396         sprintf (name, "tty%d", tty_count);
 397
 398         unsigned name_len = strlen (name);
 399
 400         /* alloc and init context */
 401         tty_t *tty = (tty_t *) kmalloc (sizeof (tty_t));
 402
 403         if (!tty)
 404                 return 0;
 405
 406         memset (tty, 0, sizeof (tty_t));
 407
 408         tty->screen = (char *) kmalloc (tty_char.x * tty_char.y * 2);
 409
 410         if (!tty->screen) {
 411                 kfree (tty);
 412                 return 0;
 413         }
 414
 415         tty->name = (char *) kmalloc (sizeof (char) * name_len + 1);
 416
 417         if (!tty->name) {
 418                 kfree (tty->screen);
 419                 kfree (tty);
 420                 return 0;
 421         }
 422
 423         memcpy (tty->name, name, name_len);
 424         tty->name[name_len] = '\0';
 425
 426         memset (tty->screen, 0, tty_char.x * tty_char.y * 2);
 427
 428         tty->screen_x = 0;
 429         tty->screen_y = 0;
 430
 431         tty->logged = false;
 432
 433         tty->active = true;
 434
 435         tty->read_len = 0;
 436
 437         strcpy (tty->pwd, (char *) env_get ("PWD"));
 438
 439         tty->task = (task_t *) task_create (name, (unsigned) task_tty, 32);
 440
 441         /* add into list */
 442         tty->next = &tty_list;
 443         tty->prev = tty_list.prev;
 444         tty->prev->next = tty;
 445         tty->next->prev = tty;
 446
 447         tty_count ++;
 448
 449         return tty;
 450 }
 451
 452 /* thread for running tty consoles - handle selected console */
 453 void task_thread (tty_t *tty)
 454 {
 455         schedule ();
 456
 457         if (!tty)
 458                 return;
 459
 460         if (tty != currtty)
 461                 return;
 462
 463         if (tty->active) {
 464                 /* handle console on kernel level */
 465                 int id = gets ();
 466
 467                 if (id == 1)
 468                         if (tty->user) {
 469                                 console (id);
 470                         } else
 471                                 getlogin (id);
 472
 473                 /* VESA mode - graphical font */
 474                 if (vgagui == 2) {
 475                         unsigned i = 0;
 476                         unsigned j = 0;
 477                         unsigned k = 0;
 478                         unsigned m = tty_char.x * tty_char.y;
 479
 480                         while (i < m) {
 481                                 gputch (1+(j*tty_font.x), 11+(k*(tty_font.y+1)), vesa_16cto16b (tty->screen[i*2+1] & 0x0F), tty->screen[i*2]);
 482
 483                                 j ++;
 484
 485                                 if (j >= tty_char.x) {
 486                                         j = 0;
 487                                         k ++;
 488                                 }
 489
 490                                 i ++;
 491                         }
 492
 493                         video_gfx_fbswap ();
 494                 }
 495         }
 496 }
 497
 498 /* startup function for created tty console */
 499 static unsigned task_tty ()
 500 {
 501         tty_t *tty = tty_findbytask (_curr_task);
 502
 503         if (!tty)
 504                 return 0;
 505
 506         while (1)
 507                 task_thread (tty);
 508 }
 509
 510 /* change tty console to next (+) or previous (-) in list */
 511 void tty_switch (char act)
 512 {
 513         switch (act) {
 514                 case '+':
 515                 {
 516                         tty_t *tty = currtty->next;
 517
 518                         if (tty == &tty_list)
 519                                 tty = tty_list.next;
 520
 521                         if (tty)
 522                                 tty_change (tty);
 523
 524                         break;
 525                 }
 526                 case '-':
 527                 {
 528                         tty_t *tty = currtty->prev;
 529
 530                         if (tty == &tty_list)
 531                                 tty = tty_list.prev;
 532
 533                         if (tty)
 534                                 tty_change (tty);
 535
 536                         break;
 537                 }
 538         }
 539 }
 540
 541 /* special function for initialization of graphical tty */
 542 tty_t *gtty_init ()
 543 {
 544         tty_t *tty = tty_create ();
 545
 546         tty_change (tty);
 547
 548         return tty;
 549 }
 550
 551 /* initialization of tty */
 552 unsigned int init_tty ()
 553 {
 554         /* pre-set tty list */
 555         tty_list.next = &tty_list;
 556         tty_list.prev = &tty_list;
 557
 558         /* default values */
 559         tty_count = 0;
 560
 561         tty_font_set ((char *) font5x8, 5, 8);
 562
 563         switch (vgagui) {
 564                 case 0: /* VGA-Textual console */
 565                         tty_char_set (80, 25);
 566                         break;
 567                 case 1: /* VGA console */
 568                         tty_char_set (53, 18);
 569                         break;
 570                 case 2: /* VESA concole */
 571                         tty_char_set (80, 65);
 572                         break;
 573         }
 574
 575         video_color (7, 0);
 576
 577         /* create consoles */
 578         tty0 = tty_create ();
 579
 580         if (!tty0)
 581                 return 0;
 582
 583 #ifdef ARCH_i386
 584         tty1 = tty_create ();
 585
 586         if (!tty1)
 587                 return 0;
 588 #endif
 589         tty_startup ();
 590
 591         /* printf MOTD into TTY0 console */
 592         tty_motd ();
 593
 594         /* then print login messages */
 595         tty_write (tty0, "\nlogin: ", 8);
 596         tty_write (tty1, "\nlogin: ", 8);
 597
 598         return 1;
 599 }
 600