kernel/core/commands.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  *  Copyright (C) 2010  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   7  *
   8  *  This program is free software: you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation, either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 #include <build.h>
  24 #include <system.h>
  25 #include <arch/io.h>
  26 #include <string.h>
  27 #include <partition.h>
  28 #include <env.h>
  29 #include <dev.h>
  30 #include <vfs.h>
  31 #include <fs.h>
  32 #include <tty.h>
  33 #include <proc.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <net/socket.h>
  37 #include <net/dhcp.h>
  38 #include <module.h>
  39 #include <commands.h>
  40 #include <signal.h>
  41 #include <smp.h>
  42 #include <build.h>
  43 #include <config.h>
  44 #include <net/if.h>
  45 #include <net/net.h>
  46 #include <net/ip.h>
  47 #include <net/ndp.h>
  48 #include <net/tun.h>
  49 #include <net/icmp.h>
  50 #include <net/hostname.h>
  51 #include <mouse.h>
  52 #include <pipe.h>
  53 #include <cache.h>
  54 #include <sound/audio.h>
  55
  56 command_t command_list;
  57 extern partition_t partition_list;
  58
  59 unsigned char cmd_buf[256];
  60
  61 typedef void (*void_fn_void_t)(void);
  62
  63 extern task_t task_list;
  64 extern vfs_t vfs_list;
  65 extern unsigned long file_cache_id;
  66 extern task_t *_curr_task;
  67 extern module_t *module_load (char *modname);
  68 extern unsigned long timer_ticks;
  69
  70
  71 char *argparse (char *cmd)
  72 {
  73         unsigned cmd_len = strlen (cmd);
  74         unsigned p = 1;
  75
  76         while (p < cmd_len) {
  77                 if (cmd[p] == ' ')
  78                         return cmd + p + 1;
  79
  80                 p ++;
  81         }
  82
  83         return "";
  84 }
  85
  86 /*************************************************************\
  87 |                          OMMANDs                            |
  88 \*************************************************************/
  89
  90
  91 unsigned command_help (char *command, unsigned len)
  92 {
  93         command_t *ctx;
  94
  95         tty_t *tty = currtty;
  96
  97         tty_cls (tty);
  98
  99         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
 100                 printf ("%s : %s\n", ctx->name, ctx->desc);
 101
 102                 if (tty->screen_y >= (tty_char.y-1)) {
 103                         if (!vgagui)
 104                                 video_color (0, 15);
 105
 106                         printf ("Press enter to continue");
 107
 108                         video_color (15, 0);
 109                         printf (" ");
 110
 111                         /* wait, until enter key is pressed */
 112                         for (;;)
 113                                 if (tty == currtty) {
 114                                         if (getkey () != '\n')
 115                                                 schedule ();
 116                                         else
 117                                                 break;
 118                                 } else
 119                                         schedule ();
 120
 121                         tty_cls (tty);
 122                 }
 123         }
 124
 125         return 1;
 126 }
 127
 128 unsigned command_hdd (char *command, unsigned len)
 129 {
 130 #ifdef ARCH_i386
 131         int t;
 132         int m;
 133         int c;
 134         int c2;
 135         int h;
 136         int s;
 137
 138         outb (0x70, 0x12);
 139         t = inb (0x71);
 140
 141         if (t >> 4 == 0)
 142                 printf ("/dev/hda not installed\n");
 143         else {
 144                 outb (0x70, 0x1b);
 145                 c = inb (0x71);
 146                 outb (0x70, 0x1c);
 147                 c2 = inb (0x71);
 148                 outb (0x70, 0x1d);
 149                 h = inb (0x71);
 150                 outb (0x70, 0x23);
 151                 s = inb (0x71);
 152
 153                 printf ("/dev/hda installed - CHS=%d-%d:%d:%d\n", c, c2, h, s);
 154         }
 155
 156         if (t & 0xF == 0)
 157                 printf ("/dev/hdb not installed\n");
 158         else {
 159                 outb (0x70, 0x24);
 160                 c = inb (0x71);
 161                 outb (0x70, 0x25);
 162                 c2 = inb (0x71);
 163                 outb (0x70, 0x26);
 164                 h = inb (0x71);
 165                 outb (0x70, 0x2c);
 166                 s = inb (0x71);
 167
 168                 printf ("/dev/hdb installed - CHS=%d-%d:%d:%d\n", c, c2, h, s);
 169         }
 170 #endif
 171
 172         return 1;
 173 }
 174
 175 unsigned command_reboot (char *command, unsigned len)
 176 {
 177         arch_cpu_reset ();
 178
 179         while (1);
 180
 181         return 1;
 182 }
 183
 184 unsigned command_halt (char *command, unsigned len)
 185 {
 186         arch_cpu_shutdown ();
 187
 188         kprintf ("\nSystem halted\nPlease press power button ..");
 189
 190         int_disable ();
 191
 192         while (1);
 193
 194         return 1;
 195 }
 196
 197 unsigned command_tasks (char *command, unsigned len)
 198 {
 199         printf ("id\tname\tpriority\n");
 200
 201         task_t *task;
 202         for (task = task_list.next; task != &task_list; task = task->next)
 203                 printf ("%d\t%s\t%u\n", task->id, task->name, task->priority);
 204
 205         return 1;
 206 }
 207
 208 unsigned command_ps (char *command, unsigned len)
 209 {
 210         proc_display ();
 211
 212         return 1;
 213 }
 214
 215 unsigned command_uptime (char *command, unsigned len)
 216 {
 217         uptime ();
 218
 219         return 1;
 220 }
 221
 222 unsigned command_version (char *command, unsigned len)
 223 {
 224         osinfo ();
 225
 226         return 1;
 227 }
 228
 229 unsigned command_debug (char *command, unsigned len)
 230 {
 231         strcpy (cmd_buf, argparse (command));
 232
 233         unsigned l = strlen (cmd_buf);
 234
 235         if (l) {
 236                 debug = atoi (cmd_buf);
 237
 238                 printf ("Developer mode was enabled with mask 0x%x.\n", debug);
 239
 240                 return 1;
 241         }
 242
 243         printf ("Developer mode was disabled.\n");
 244         debug = 0;
 245
 246         return 1;
 247 }
 248
 249 unsigned command_mount (char *command, unsigned len)
 250 {
 251         strcpy (cmd_buf, argparse (command));
 252         char devname[20];
 253         char mountpoint[32];
 254
 255         unsigned l = strlen (cmd_buf);
 256         unsigned x = 0;
 257         while (x < l) {
 258                 if (cmd_buf[x] == ' ')
 259                         break;
 260                 x ++;
 261         }
 262
 263         memcpy (devname, cmd_buf, x);
 264         devname[x] = '\0';
 265         strcpy (mountpoint, argparse (cmd_buf));
 266         unsigned y = strlen (mountpoint);
 267
 268         if (mountpoint[y-1] != '/') {
 269                 mountpoint[y] = '/';
 270                 mountpoint[y+1] = '\0';
 271         }
 272
 273         if (x && y) {
 274                 partition_t *p = partition_find (devname);
 275
 276                 if (p)
 277                         mount (p, "", mountpoint);
 278                 else
 279                         printf ("ERROR -> partition %s does not exists\n", devname);
 280         } else
 281                 mount_display ();
 282
 283         return 1;
 284 }
 285
 286 unsigned command_umount (char *command, unsigned len)
 287 {
 288         char mountpoint[32];
 289         strcpy (mountpoint, argparse (command));
 290
 291         unsigned y = strlen (mountpoint);
 292         unsigned x = 0;
 293
 294         if (mountpoint[y-1] != '/') {
 295                 mountpoint[y] = '/';
 296                 mountpoint[y+1] = '\0';
 297         }
 298
 299         if (y) {
 300                 partition_t *partition;
 301                 for (partition = partition_list.next; partition != &partition_list; partition = partition->next) {
 302                         if (umount (partition, mountpoint))
 303                                 x ++;
 304                 }
 305
 306                 if (!x)
 307                         printf ("ERROR -> directory %s is not mounted\n", mountpoint);
 308
 309                 if (x > 1)
 310                         printf ("WARNING -> multiple (%d) umount of %s\n", x, mountpoint);
 311         } else
 312                 return 0;
 313
 314         return 1;
 315 }
 316
 317 unsigned command_env (char *command, unsigned len)
 318 {
 319         env_display ();
 320
 321         return 1;
 322 }
 323
 324 unsigned command_cd (char *command, unsigned len)
 325 {
 326         strcpy (cmd_buf, argparse (command));
 327
 328         cd (cmd_buf);
 329
 330         return 1;
 331 }
 332
 333 unsigned command_ls (char *command, unsigned len)
 334 {
 335         strcpy (cmd_buf, argparse (command));
 336
 337         ls (cmd_buf);
 338
 339         return 1;
 340 }
 341
 342 unsigned command_cat (char *command, unsigned len)
 343 {
 344         strcpy (cmd_buf, argparse (command));
 345
 346         cat (cmd_buf);
 347
 348         return 1;
 349 }
 350
 351 unsigned command_cp (char *command, unsigned len)
 352 {
 353         strcpy (cmd_buf, argparse (command));
 354
 355         unsigned l = strlen (cmd_buf);
 356         unsigned p = 0;
 357
 358         while (l) {
 359                 if (cmd_buf[l] == ' ') {
 360                         cmd_buf[l] = '\0';
 361                         p = l;
 362                 }
 363
 364                 l --;
 365         }
 366
 367         if (!p) {
 368                 printf ("Syntax:\ncp <source> <destination>\n");
 369                 return 0;
 370         }
 371
 372         cp (cmd_buf, cmd_buf+p+1);
 373
 374         return 1;
 375 }
 376
 377
 378 unsigned command_rm (char *command, unsigned len)
 379 {
 380         strcpy (cmd_buf, argparse (command));
 381
 382         rm (cmd_buf);
 383
 384         return 1;
 385 }
 386
 387 unsigned command_mkdir (char *command, unsigned len)
 388 {
 389         strcpy (cmd_buf, argparse (command));
 390
 391         mkdir (cmd_buf);
 392
 393         return 1;
 394 }
 395
 396 unsigned command_touch (char *command, unsigned len)
 397 {
 398         strcpy (cmd_buf, argparse (command));
 399
 400         touch (cmd_buf);
 401
 402         return 1;
 403 }
 404
 405 unsigned command_exec (char *command, unsigned len)
 406 {
 407         if (!strncmp ("./", command, 2))
 408                 strcpy (cmd_buf, command+2);
 409         else
 410                 strcpy (cmd_buf, argparse (command));
 411
 412         unsigned arg_len = strlen (argparse (cmd_buf));
 413         char arg[arg_len+1];
 414         strcpy (arg, argparse (cmd_buf));
 415         arg[arg_len] = '\0';
 416
 417         unsigned cmd_buf_len = strlen (cmd_buf);
 418
 419         tty_t *tty = currtty;
 420
 421         if (!tty)
 422                 return 0;
 423
 424         /* lock current tty keyboard */
 425         tty_lock (tty);
 426
 427         /* if there is argument after name, rewrite space character to zero */
 428         if (cmd_buf [cmd_buf_len-(arg_len+1)] == ' ')
 429                 cmd_buf [cmd_buf_len-(arg_len+1)] = '\0';
 430         else
 431                 cmd_buf [cmd_buf_len-arg_len] = '\0';
 432
 433         vfs_content_t content;
 434         /* read file data from filesystem */
 435         int ret = vfs_read (cmd_buf, strlen (cmd_buf), &content);
 436
 437         if (ret < 0) {
 438                 printf ("%s: command not found\n", cmd_buf);
 439                 DPRINT (DBG_CMDS, "ERROR -> vfs_read () - '%s'\n", cmd_buf);
 440                 tty_unlock (tty);
 441                 return 0;
 442         }
 443
 444         unsigned bin_len = content.len;
 445
 446         unsigned char *bin = (unsigned char *) swmalloc (bin_len);
 447
 448         if (!bin) {
 449                 printf ("ERROR -> out of memory\n");
 450                 return 0;
 451         }
 452
 453         //paging_disable ();
 454
 455         /* copy image to page aligned memory */
 456         memcpy (bin, content.ptr, bin_len);
 457
 458         //paging_enable ();
 459
 460         cache_closebyptr (content.ptr);
 461
 462         unsigned entry, code, data, data_off, bss;
 463         int err = exec_elf (bin, &entry, &data, &data_off, &bss);
 464
 465         if (err) {
 466                 printf ("ERROR -> invalid ELF exec\n");
 467
 468                 /* free program image */
 469                 swfree (bin, bin_len);
 470
 471                 tty_unlock (tty);
 472                 return 0;
 473         }
 474
 475         /* create process */
 476         proc_t *proc = proc_create (tty, cmd_buf, entry);
 477
 478         /* check for & character as app parameter */
 479         unsigned d = 0;
 480         while (d < arg_len) {
 481                 if (arg[d] == '&') {
 482                         if (proc_flag_set (proc, PROC_FLAG_DAEMON))
 483                                 printf ("%s: started as daemon\n", cmd_buf);
 484
 485                         arg[d] = '\0';
 486
 487                         if (arg_len > 2 && arg[d-1] == ' ') {
 488                                 arg[d-1] = '\0';
 489                                 arg_len --;
 490                         }
 491
 492                         arg_len --;
 493
 494                         break;
 495                 }
 496                 d ++;
 497         }
 498
 499         if (!proc) {
 500                 printf ("ERROR -> Invalid process: %s\n", cmd_buf);
 501
 502                 /* free program image */
 503                 swfree (bin, bin_len);
 504
 505                 tty_unlock (tty);
 506                 return 0;
 507         }
 508
 509         /* save process information to structure for later use */
 510         proc->start = (unsigned) bin;
 511         proc->code = entry;
 512         proc->data = data;
 513         proc->data_off = data_off;
 514         proc->bss = bss;
 515         proc->end = (unsigned) (bin + bin_len);
 516
 517         /* well, set argument for out app */
 518         proc_arg_set (proc, arg, arg_len);
 519
 520         proc_vmem_map (proc);
 521
 522         /* Is this process started as daemon ? */
 523         /* wait here, until pid != 0*/
 524         if (!(proc->flags & PROC_FLAG_DAEMON))
 525                 while (proc->pid)
 526                         schedule ();
 527
 528         /* enable interrupts */
 529         int_enable ();
 530
 531         /* unlock tty console - user can write in */
 532         tty_unlock (tty);
 533
 534         _curr_task = proc->tty->task;   // this is pretty needed for correct return to our tty task
 535
 536         if (!(proc->flags & PROC_FLAG_DAEMON)) {
 537                 if (!proc_done (proc))
 538                         for (;;)        // NOTE: heh, this is good stuff :P
 539                                 schedule ();
 540
 541                 /* free program image */
 542                 swfree (bin, bin_len);
 543         }
 544
 545         /* switch to next task */
 546         schedule ();
 547
 548         return 1;
 549 }
 550
 551 unsigned command_lsdev (char *command, unsigned len)
 552 {
 553         dev_display ();
 554
 555         return 1;
 556 }
 557
 558 unsigned command_login (char *command, unsigned len)
 559 {
 560         currtty->user = NULL;
 561         currtty->logged = false;
 562
 563         video_color (7, 0);
 564         printf ("login: ");
 565
 566         return 1;
 567 }
 568
 569 unsigned command_serialw (char *command, unsigned len)
 570 {
 571         dev_t *dev = dev_find ("/dev/com0");
 572
 573         if (dev) {
 574                 unsigned len = strlen (argparse (command));
 575                 char data[len+1];
 576                 memcpy (data, argparse (command), len);
 577                 data[len] = '\0';
 578
 579                 dev->handler (DEV_ACT_WRITE, data, len);
 580
 581                 printf ("serialw: %s\n", data);
 582         }
 583
 584         return 1;
 585 }
 586
 587 unsigned command_serialr (char *command, unsigned len)
 588 {
 589         dev_t *dev = dev_find ("/dev/com0");
 590
 591         if (dev) {
 592                 char data[11];
 593
 594                 dev->handler (DEV_ACT_READ, data, 1);
 595
 596                 printf ("serialr: %s\n", data);
 597         }
 598
 599         return 1;
 600 }
 601
 602 unsigned command_fdisk (char *command, unsigned len)
 603 {
 604         char *parm = argparse (command);
 605
 606         fdisk (parm, strlen (parm));
 607
 608         return 1;
 609 }
 610
 611 unsigned command_hdcat (char *command, unsigned len)
 612 {
 613         tty_lock (currtty);
 614
 615         dev_t *dev = (dev_t *) dev_find (argparse (command));
 616
 617         if (dev) {
 618                 partition_t p;
 619                 p.base_io = 0;
 620
 621                 switch (dev->devname[7]) {
 622                         case 'a':
 623                                 p.id = 0;
 624                                 p.base_io = 0x1F0;
 625                                 break;
 626                         case 'b':
 627                                 p.id = 1;
 628                                 p.base_io = 0x1F0;
 629                                 break;
 630                         case 'c':
 631                                 p.id = 0;
 632                                 p.base_io = 0x170;
 633                                 break;
 634                         case 'd':
 635                                 p.id = 1;
 636                                 p.base_io = 0x170;
 637                                 break;
 638                 }
 639
 640                 int c, d = 0;
 641                 unsigned char block[512];
 642
 643                 printf ("dev: %s\n", dev->devname);
 644
 645                 while (!key_pressed (1)) {
 646                         if (key_pressed (72) == 1) {
 647                                 printf ("##block: %d\n", d);
 648                                 dev->handler (DEV_ACT_READ, &p, block, "", d);
 649
 650                                 for (c = 0; c < 512; c ++)
 651                                         printf ("%c", (unsigned) block[c]);
 652                                 d ++;
 653                         }
 654
 655                         usleep (5);
 656                 }
 657         } else
 658                 printf ("Please specify block device, example: hdcat /dev/hda\n");
 659
 660         tty_unlock (currtty);
 661
 662         return 1;
 663 }
 664
 665 unsigned command_free (char *command, unsigned len)
 666 {
 667         util_cmdfree ();
 668
 669         return 1;
 670 }
 671
 672 unsigned command_top (char *command, unsigned len)
 673 {
 674         tty_lock (currtty);
 675
 676         proc_top ();
 677
 678         tty_unlock (currtty);
 679
 680         return 1;
 681 }
 682
 683 unsigned command_date (char *command, unsigned len)
 684 {
 685         tm *t = rtc_getcurrtime ();
 686
 687         printf ("%02u:%02u:%02u, %u.%u.%u\n",
 688                 t->tm_hour, t->tm_min, t->tm_sec, t->tm_mday, t->tm_mon, t->tm_year);
 689
 690         return 1;
 691 }
 692
 693 /*
 694      Tone             Frequency (Hz)
 695         C               130.8
 696         D               146.8
 697         E               164.8
 698         F               174.6
 699         G               196.0
 700         A               220.0
 701         H               246.9
 702
 703         C               261.6
 704         D               293.7
 705         E               329.6
 706         F               349.2
 707         G               392.0
 708         A               440.0
 709         H               493.9
 710
 711         C               523.3
 712         D               587.3
 713         E               659.3
 714         F               698.5
 715         G               784.0
 716         A               880.0
 717         H               987.8
 718
 719         C               1046.5
 720         D               1174.7
 721         E               1318.5
 722         F               1396.9
 723         G               1568.0
 724         A               1760.0
 725         H               1975.5
 726 */
 727
 728 void play_tone (dev_t *dev, char tone, char type, char time)
 729 {
 730         unsigned t = 2;
 731
 732         switch (type) {
 733                 case '1':
 734                         t = 1;
 735                         break;
 736                 case '2':
 737                         t = 2;
 738                         break;
 739                 case '3':
 740                         t = 3;
 741                         break;
 742                 case '4':
 743                         t = 4;
 744                         break;
 745         }
 746
 747
 748         unsigned tt = 1;
 749
 750         printf ("play_tone (.., %c, %d, %d);\n", tone, t, tt);
 751
 752         switch (tone) {
 753                 case 'c':
 754                         dev->handler (DEV_ACT_PLAY, 131*t);
 755                         break;
 756                 case 'd':
 757                         dev->handler (DEV_ACT_PLAY, 147*t);
 758                         break;
 759                 case 'e':
 760                         dev->handler (DEV_ACT_PLAY, 165*t);
 761                         break;
 762                 case 'f':
 763                         dev->handler (DEV_ACT_PLAY, 175*t);
 764                         break;
 765                 case 'g':
 766                         dev->handler (DEV_ACT_PLAY, 196*t);
 767                         break;
 768                 case 'a':
 769                         dev->handler (DEV_ACT_PLAY, 220*t);
 770                         break;
 771                 case 'h':
 772                         dev->handler (DEV_ACT_PLAY, 247*t);
 773                         break;
 774                 case 'C':
 775                         dev->handler (DEV_ACT_PLAY, 136*t);
 776                         break;
 777                 case 'F':
 778                         dev->handler (DEV_ACT_PLAY, 188*t);
 779                         break;
 780         }
 781
 782         switch (time) {
 783                 case '0':
 784                         timer_wait (2500);
 785                         break;
 786                 case '1':
 787                         timer_wait (1250);
 788                         break;
 789                 case '2':
 790                         timer_wait (625);
 791                         break;
 792         }
 793
 794
 795
 796         printf ("end: play_tone ();\n");
 797
 798         dev->handler (DEV_ACT_PLAY, 0);
 799 }
 800
 801 void play_song (dev_t *dev, char *data)
 802 {
 803         printf ("play_song ();\n");
 804         unsigned i = 0, l = strlen (data);
 805         unsigned time = 1;
 806         while (i != l) {
 807                 switch (data[i]) {
 808                         printf ("switch ()\n");
 809                         case 'p':
 810
 811                                 switch (data[i+1]) {
 812                                         case '0':
 813                                                 timer_wait (2500);
 814                                                 break;
 815                                         case '1':
 816                                                 timer_wait (1250);
 817                                                 break;
 818                                         case '2':
 819                                                 timer_wait (625);
 820                                                 break;
 821                                 }
 822
 823
 824                                 i ++;
 825                                 break;
 826                         case ' ':
 827                                 break;
 828                         default:
 829                                 play_tone (dev, data[i], data[i+1], data[i+2]);
 830                                 i += 2;
 831                                 break;
 832                 }
 833
 834                 i ++;
 835         }
 836
 837 }
 838
 839 unsigned command_spk (char *command, unsigned len)
 840 {
 841         unsigned int freq = 20;
 842
 843         dev_t *dev = dev_find ("/dev/pcspk");
 844
 845         if (dev) {
 846 /*
 847 We wish you a merry christmas v1.0
 848
 849 D2(1/8) G2(1/8) G2(1/16) A2(1/16) G2(1/16) Fis2(1/16) E2(1/8) C2(1/8) E2(1/8) A2(1/8) A2(1/16) H2(1/16) A2(1/16)  G2(1/16) Fis2(1/8) D2(1/4) H2(1/8) H2(1/16) C3(1/16) H2(1/16) A2(1/16) G2(1/8) E2(1/8) D2(1/16) D2(1/16) E2(1/8)  A2(1/8) Fis2(1/8) G2(1/8)
 850 */
 851
 852                 play_song (dev, "d21 g21 g22 a22 g22 F22 e21 c21 e21 a21 a22 h22 a22 g22 F21 d20 h21 h22 c32 h22 a22 g21 e21 d22 d22 e21 a21 F21 g21");
 853
 854                 timer_wait (2000);
 855
 856 /*
 857 We wish you a merry christmas v3.0
 858
 859 G2(1/8) C3(1/8) C3(1/16) D3(1/16) C3(1/16) H2(1/16) A2(1/4) D3(1/8) D3(1/16) E3(1/16) D3(1/16) C3(1/16) H2(1/4)  G2(1/8) E3(1/8) E3(1/16) F3(1/16) E3(1/16) D3(1/16) C3(1/8) A2(1/8) G2(1/8) A2(1/8) D3(1/8) H2(1/8) C3(1/8)
 860 */
 861
 862                 play_song (dev, "g21 c31 c32 d32 c32 h22 a20 d31 d32 e32 d32 c32 h20 g21 e31 e32 f32 e32 d32 c31 a21 g21 a21 d31 h21 c31");
 863
 864                 timer_wait (2000);
 865
 866 /*
 867  Dallas v2.0
 868 G2(1/8) C3(1/8) P(1/16) G2(1/16) G3(1/8) C3(1/16) E3(1/8) D3(1/16) E3(1/16) C3(1/8) G2(1/8) C3(1/8) A3(1/8) G3(1/8) E3(1/16) F3(1/16) G3(1/8) G3(1/16) P(1/16) G2(1/8) C3(1/8) A3(1/8) G3(1/8) E3(1/16) F3(1/16) G3(1/8) D3(1/16) E3(1/16) C3(1/8) G2(1/8) C3(1/8) E3(1/16) F3(1/16) D3(1/8) G3(1/8) G3(1/8)
 869 */
 870         /*      play_song (dev, "g21 c31 p2 g22 g31 c32 e31 d32 e32 c31 g21 c31 a31 g31 e32 f32 g31 g32 p2 g21 c31 a31 g31 e32 f32 g31 d32 e32 c31 g21 c31 e32 f32 d31 g31 g31");*/
 871
 872                 //timer_wait (2000);
 873         }
 874
 875         return 1;
 876 }
 877
 878 extern bool bus_pci_acthandler (unsigned act, char *block, unsigned block_len);
 879 extern netif_t netif_list;
 880 extern void ext2_dump ();
 881 void thread_test ()
 882 {
 883         while (1) {
 884
 885                 kprintf ("hu\n");
 886
 887                 unsigned long timer_start = timer_ticks + ((unsigned) 1 * 1000);
 888
 889                 while (timer_start > timer_ticks)
 890                         schedule ();
 891         }
 892 }
 893
 894 unsigned command_test (char *command, unsigned len)
 895 {
 896         partition_t *p = partition_find ("/dev/hda0");
 897
 898         if (p)
 899                 mount (p, "", "/mnt/hdd/");
 900         else
 901                 return 0;
 902
 903         cd ("/mnt/hdd");
 904
 905         return 1;
 906 }
 907
 908 unsigned command_test2 (char *command, unsigned len)
 909 {
 910         partition_t *p = partition_find ("/dev/cdc0");
 911
 912         if (p)
 913                 mount (p, "", "/mnt/cdrom/");
 914         else
 915                 return 0;
 916
 917         cd ("/mnt/cdrom");
 918
 919 /*      tty_t *tty = tty_find ("tty0");
 920
 921         if (!tty)
 922                 return 0;
 923         char str[513];
 924         int r = tty_read (tty, str, 512);
 925
 926         if (r > 0) {
 927                 printf ("str: r: %d\n", r);
 928                 int i;
 929                 for (i = 0; i < r; i ++)
 930                         tty_putch (str[i]);
 931         }
 932   */
 933
 934 /*      int ret = vfs_read ("wav", 3);
 935
 936         if (ret < 0) {
 937                 printf ("chyba\n");
 938                 return 0;
 939         }
 940
 941         cache_t *cache = cache_read ();
 942
 943         unsigned char *p = (unsigned char *) &cache->data;
 944
 945         unsigned bin_len = cache->limit;
 946
 947         unsigned char *bin = (unsigned char *) 0x400000 - 44;
 948
 949         memcpy (bin, p, bin_len);
 950
 951         typedef struct {
 952                 unsigned chunkid;
 953                 unsigned chunksize;
 954                 unsigned format;
 955         } riff_head_t;
 956
 957         typedef struct {
 958                 unsigned subchunk1id;
 959                 unsigned subchunk1size;
 960                 unsigned short audioformat;
 961                 unsigned short numchannels;
 962                 unsigned samplerate;
 963                 unsigned byterate;
 964                 unsigned short blockalign;
 965                 unsigned short bitspersample;
 966         } fmt_head_t;
 967
 968         typedef struct {
 969                 unsigned subchunk2id;
 970                 unsigned subchunk2size;
 971         } data_head_t;
 972
 973         riff_head_t *r = (riff_head_t *) bin;
 974         fmt_head_t *fmt = (fmt_head_t *) ((char *) bin + sizeof (riff_head_t));
 975         data_head_t *data = (data_head_t *) ((char *) bin + sizeof (riff_head_t) + sizeof (fmt_head_t));
 976
 977         printf ("riff_head_t 0x%x : %d : 0x%x\n", r->chunkid, r->chunksize, r->format);
 978         printf ("fmt_head_t %d : %d : %d : %d : %d : %d\n", fmt->audioformat, fmt->subchunk1size, fmt->numchannels, fmt->samplerate, fmt->byterate, fmt->bitspersample);
 979         printf ("data_head_t 0x%x : %d\n", data->subchunk2id, data->subchunk2size);
 980         //memset (bin+44, 0, bin_len-44);
 981         //dev->handler (DEV_ACT_WRITE, bin+44, bin_len-44);
 982
 983         snd_cfg_t cfg;
 984         cfg.dev = "/dev/ac97";
 985         cfg.rate = fmt->samplerate;
 986         cfg.format = SOUND_FORMAT_S16;
 987         cfg.channels = fmt->numchannels;
 988
 989         snd_audio_t *aud = audio_open (&cfg);
 990
 991         if (!aud)
 992                 return 0;
 993
 994         audio_write (aud, bin+44, (bin_len-44));
 995
 996         //swfree (bin, bin_len);*/
 997
 998
 999
1000         return 1;
1001 }
1002
1003 unsigned command_test3 (char *command, unsigned len)
1004 {
1005         netif_t *netif = netif_findbyname ("eth0");
1006         dhcp_config_if(netif);
1007
1008         return 1;
1009 }
1010
1011 unsigned command_test4 (char *command, unsigned len)
1012 {
1013
1014
1015         return 1;
1016 }
1017
1018 unsigned command_mouse (char *command, unsigned len)
1019 {
1020         printf ("PS/2 Mouse test\n");
1021
1022         dev_t *dev = dev_find ("/dev/mouseps2");
1023
1024         if (!dev)
1025                 return 0;
1026
1027         dev_mouse_t mouse;
1028
1029         int ps2_fd = open ("/dev/mouseps2", O_RDONLY);
1030
1031         if (!ps2_fd)
1032                 return 0;
1033
1034 printf ("dddd\n");
1035
1036         while (!key_pressed (1)) {
1037                 int r = read (ps2_fd, &mouse, sizeof (dev_mouse_t));
1038
1039                 if (!r) {
1040                         kprintf ("oj oj\n");
1041                         return 0;
1042                 }
1043
1044                 kprintf ("ps2mouse: x,y: %d, %d | 0x%x \n", mouse.pos_x, mouse.pos_y, mouse.flags);
1045
1046                 lseek (ps2_fd, 0, SEEK_SET);
1047
1048                 schedule ();
1049         }
1050
1051         return 1;
1052 }
1053
1054 unsigned command_vesa (char *command, unsigned len)
1055 {
1056         if (!init_video_vesa ())
1057                 printf ("vesa -> failed\n");
1058
1059         return 1;
1060 }
1061
1062 unsigned command_kill (char *command, unsigned len)
1063 {
1064         strcpy (cmd_buf, argparse (currtty->shell));
1065
1066         pid_t pid = (pid_t) atoi (cmd_buf);
1067
1068         proc_t *proc = proc_findbypid (pid);
1069
1070         if (!proc) {
1071                 printf ("kill: (%s) - No such process\n", cmd_buf);
1072                 return 0;
1073         }
1074
1075         /* send SIGTERM to selected process */
1076         if (!proc_signal (proc, SIGTERM))
1077                 return 0;
1078
1079         /* check for daemon */
1080         if (proc->flags & PROC_FLAG_DAEMON)
1081                 if (!proc_done (proc))
1082                         return 0;
1083
1084         return 1;
1085 }
1086
1087 unsigned command_modprobe (char *command, unsigned len)
1088 {
1089         unsigned arg_len = strlen (argparse (currtty->shell));
1090         char arg[arg_len+1];
1091         strcpy (arg, argparse (currtty->shell));
1092         arg[arg_len] = '\0';
1093
1094         module_load (arg);
1095
1096         return 1;
1097 }
1098
1099 unsigned command_lsmod (char *command, unsigned len)
1100 {
1101         module_display ();
1102
1103         return 1;
1104 }
1105
1106 #ifdef CONFIG_DRV_PCI
1107 unsigned command_lspci (char *command, unsigned len)
1108 {
1109 #ifdef ARCH_i386
1110         pcidev_display ();
1111 #endif
1112         return 1;
1113 }
1114 #endif
1115
1116 unsigned command_iflist (char *command, unsigned len)
1117 {
1118         iflist_display ();
1119
1120         return 1;
1121 }
1122
1123 unsigned command_ifconfig (char *command, unsigned len)
1124 {
1125         strcpy (cmd_buf, argparse (command));
1126         char ifid[20];
1127         char ip[32];
1128
1129         unsigned l = strlen (cmd_buf);
1130         unsigned x = 0;
1131         while (x < l) {
1132                 if (cmd_buf[x] == ' ')
1133                         break;
1134                 x ++;
1135         }
1136
1137         memcpy (ifid, cmd_buf, x);
1138         ifid[x] = '\0';
1139
1140         strcpy (ip, argparse (cmd_buf));
1141         unsigned y = strlen (ip);
1142
1143         netif_t *netif = netif_findbyname (ifid);
1144
1145         if (!netif) {
1146                 printf ("ifconfig -> bad network interface name, example: eth0\n");
1147                 return 0;
1148         }
1149
1150         net_ipv4 ipv4;
1151         net_ipv6 ipv6;
1152         if (ipv4 = net_proto_ip_convert (ip)) {
1153                 netif_ip_addr (netif, ipv4, IF_CFG_TYPE_STATIC);
1154
1155                 printf ("%s: IPv4 ", ifid);
1156                 net_proto_ip_print (ipv4);
1157                 printf (" - OK\n");
1158         } else if (net_proto_ipv6_convert (ipv6, ip)) {
1159                 netif_ipv6_addr (netif, ipv6, IF_CFG_TYPE_STATIC);
1160
1161                 printf ("%s: IPv6 ", ifid);
1162                 net_proto_ipv6_print (ipv6);
1163                 printf (" - OK\n");
1164         } else {
1165                 printf ("ifconfig -> bad ip address format, example:\n\t\t192.168.1.1 for IPv4\n\t\tfc00:0:0:0:0:0:0:10 for IPv6\n");
1166                 return 0;
1167         }
1168
1169         return 1;
1170 }
1171
1172 unsigned command_ifroute (char *command, unsigned len)
1173 {
1174         strcpy (cmd_buf, argparse (command));
1175         char ifid[20];
1176         char ip[32];
1177
1178         unsigned l = strlen (cmd_buf);
1179         unsigned x = 0;
1180         while (x < l) {
1181                 if (cmd_buf[x] == ' ')
1182                         break;
1183                 x ++;
1184         }
1185
1186         memcpy (ifid, cmd_buf, x);
1187         ifid[x] = '\0';
1188
1189         strcpy (ip, argparse (cmd_buf));
1190         unsigned y = strlen (ip);
1191
1192         netif_t *netif = netif_findbyname (ifid);
1193
1194         if (!netif) {
1195                 printf ("ifroute -> bad network interface name, example: eth0\n");
1196                 return 0;
1197         }
1198
1199         unsigned char a;
1200         unsigned char b;
1201         unsigned char c;
1202         unsigned char d;
1203
1204         unsigned g = 0;
1205         unsigned i = 0;
1206
1207         unsigned h[4];
1208
1209         while (i < y) {
1210                 if (ip[i] == '.') {
1211                         ip[i] = '\0';
1212                         h[g] = i+1;
1213                         g ++;
1214                 }
1215
1216                 i ++;
1217         }
1218
1219         if (g != 3) {
1220                 printf ("ifroute -> bad ip address format, example: 192.168.1.254\n");
1221                 return 0;
1222         }
1223
1224         a = atoi (ip);
1225         b = atoi (ip+h[0]);
1226         c = atoi (ip+h[1]);
1227         d = atoi (ip+h[2]);
1228
1229         printf ("%s->gw: %d.%d.%d.%d - OK\n", ifid, a, b, c, d);
1230
1231         return netif_gw_addr (netif, NET_IPV4_TO_ADDR (a, b, c, d));
1232 }
1233
1234 unsigned command_dnsconfig (char *command, unsigned len)
1235 {
1236         strcpy (cmd_buf, argparse (currtty->shell));
1237
1238         if (!cmd_buf)
1239                 return 0;
1240
1241         unsigned l = strlen (cmd_buf);
1242
1243         if (!l) {
1244                 printf ("dnsconfig -> your domain name server is: ");
1245                 net_proto_ip_print (dns_addr_get ());
1246                 printf ("\n");
1247
1248                 return 0;
1249         }
1250
1251         printf ("dnsconfig: %s - OK\n", cmd_buf);
1252
1253         net_ipv4 dns = net_proto_ip_convert (cmd_buf);
1254
1255         if (!dns)
1256                 return 0;
1257
1258         dns_addr (dns);
1259
1260         return 1;
1261 }
1262
1263 unsigned command_dhcpcl (char *command, unsigned len)
1264 {
1265         strcpy (cmd_buf, argparse (currtty->shell));
1266
1267         if (!cmd_buf)
1268                 return 0;
1269
1270         unsigned l = strlen (cmd_buf);
1271
1272         if (!l) {
1273                 printf ("dhcpcl -> please specify interface\n");
1274                 return 0;
1275         }
1276
1277         netif_t *netif = netif_findbyname (cmd_buf);
1278
1279         if (!netif) {
1280                 printf ("dhcpcl -> bad network interface name, example: eth0\n");
1281                 return 0;
1282         }
1283
1284         unsigned ret = dhcp_config_if (netif);
1285
1286         if (ret < 0) {
1287                 switch (ret) {
1288                         case DHCP_OUT_OF_MEMORY:
1289                                 printf ("dhcpcl -> out of memory\n");
1290                                 break;
1291                         case DHCP_SOCKET_FAILED:
1292                         case DHCP_CONNECT_FAILED:
1293                         case DHCP_CANT_SEND_REQUEST:
1294                                 printf ("dhcpcl -> problem with network layer\n");
1295                                 break;
1296                         case DHCP_CANT_RECV_RESPONSE:
1297                                 printf ("dhcpcl -> can't receive response\n");
1298                                 break;
1299                         case DHCP_BAD_PACKET:
1300                                 printf ("dhcpcl -> bad packet received\n");
1301                                 break;
1302                         case DHCP_SRV_DIDNT_UNDERSTAND:
1303                                 printf ("dhcpcl -> server didn't understand\n");
1304                                 break;
1305                 }
1306         } else
1307                 printf ("dhcpcl -> interface %s successfully configured\n", cmd_buf);
1308
1309         return 0;
1310 }
1311
1312 unsigned command_tunconfig (char *command, unsigned len)
1313 {
1314         strcpy (cmd_buf, argparse (currtty->shell));
1315
1316         if (!cmd_buf)
1317                 return 0;
1318
1319         unsigned l = strlen (cmd_buf);
1320
1321         if (!l) {
1322                 printf ("tunconfig -> wrong syntax !\ntunconfig <ipv4tunnel> for enable or tunconfig 0 for disable\n");
1323
1324                 return 0;
1325         }
1326
1327         /* you can disable this service over character '0' as parameter */
1328         if (l == 1 && cmd_buf[0] == '0') {
1329                 tun6_addr (0);
1330
1331                 printf ("tunconfig: disabled - OK\n");
1332
1333                 return 1;
1334         }
1335
1336         /* classical ipv4 address from tunnel server */
1337         net_ipv4 tunnel = net_proto_ip_convert (cmd_buf);
1338
1339         if (!tunnel) {
1340                 printf ("tunconfig -> wrong syntax !\nExample: tunconfig 216.66.80.30\n");
1341
1342                 return 0;
1343         }
1344
1345         tun6_addr (tunnel);
1346
1347         printf ("tunconfig: ::%s - OK\n", cmd_buf);
1348
1349         return 1;
1350 }
1351
1352
1353 unsigned command_hostname (char *command, unsigned len)
1354 {
1355         strcpy (cmd_buf, argparse (currtty->shell));
1356
1357         if (!cmd_buf)
1358                 return 0;
1359
1360         unsigned l = strlen (cmd_buf);
1361
1362         if (!l) {
1363                 printf ("%s\n", hostname_get ());
1364
1365                 return 0;
1366         }
1367
1368         printf ("hostname: %s - OK\n", cmd_buf);
1369
1370         hostname_set (cmd_buf);
1371
1372         return 1;
1373 }
1374
1375 unsigned command_kbdmap (char *command, unsigned len)
1376 {
1377         strcpy (cmd_buf, argparse (currtty->shell));
1378
1379         if (!cmd_buf)
1380                 return 0;
1381
1382         unsigned ret = keyboard_setlayout (cmd_buf);
1383
1384         if (ret)
1385                 printf ("Keyboard layout was changed to '%s'\n", cmd_buf);
1386
1387         return ret;
1388 }
1389
1390 unsigned command_mkzexfs (char *command, unsigned len)
1391 {
1392 #ifdef ARCH_i386
1393         strcpy (cmd_buf, argparse (currtty->shell));
1394
1395         partition_t *p = partition_find (cmd_buf);
1396
1397         if (!p)
1398                 return 0;
1399
1400         mkzexfs (p);
1401 #endif
1402         return 1;
1403 }
1404
1405 unsigned command_mkext2 (char *command, unsigned len)
1406 {
1407 #ifdef ARCH_i386
1408         strcpy (cmd_buf, argparse (currtty->shell));
1409
1410         if (!cmd_buf)
1411                 return 0;
1412
1413         partition_t *p = partition_find ("/dev/hda0");
1414
1415         mkext2 (p);
1416 #endif
1417         return 1;
1418 }
1419
1420 unsigned command_ping (char *command, unsigned len)
1421 {
1422
1423         strcpy (cmd_buf, argparse (currtty->shell));
1424
1425         if (!cmd_buf)
1426                 return 0;
1427
1428         netif_t *netif = netif_findbyname ("eth0");
1429
1430         if (!netif) {
1431                 printf ("ping -> network interface does not exists\n");
1432                 return 0;
1433         }
1434
1435         unsigned char a;
1436         unsigned char b;
1437         unsigned char c;
1438         unsigned char d;
1439
1440         unsigned g = 0;
1441         unsigned i = 0;
1442         unsigned y = strlen (cmd_buf);
1443
1444         if (!y) {
1445                 printf ("ping -> wrong syntax, please specify address\n");
1446                 return 0;
1447         }
1448
1449         unsigned h[4];
1450
1451         while (i < y) {
1452                 if (cmd_buf[i] == '.') {
1453                         cmd_buf[i] = '\0';
1454                         h[g] = i+1;
1455                         g ++;
1456                 }
1457
1458                 i ++;
1459         }
1460
1461         net_ipv4 target = 0;
1462
1463         if (g != 3) {
1464                 strcpy (cmd_buf, argparse (currtty->shell));
1465
1466                 if (dns_cache_get (cmd_buf, &target, 4) != 1)
1467                         if (dns_send_request (cmd_buf, &target, 4) != 1) {
1468                                 printf ("ping -> bad hostname or ip address format, example: 192.168.1.1\n");
1469                                 return 0;
1470                         }
1471         } else {
1472                 a = atoi (cmd_buf);
1473                 b = atoi (cmd_buf+h[0]);
1474                 c = atoi (cmd_buf+h[1]);
1475                 d = atoi (cmd_buf+h[2]);
1476
1477                 target = NET_IPV4_TO_ADDR (a, b, c, d);
1478
1479                 strcpy (cmd_buf, argparse (currtty->shell));
1480         }
1481
1482         char address[20];
1483         net_proto_ip_convert2 (target, address);
1484
1485         i = 0;
1486
1487         while (i < 8) {
1488                 unsigned long time_a = timer_ticks;
1489                 unsigned ret = net_proto_icmp_ping (netif, target);
1490                 if (ret) {
1491                         printf ("ping -> %s (%s) - %ums\n", cmd_buf, address, (timer_ticks - time_a));
1492                 } else {
1493                         printf ("ping -> Host %s is unreachable\n", cmd_buf);
1494                         break;
1495                 }
1496
1497                 i ++;
1498         }
1499
1500         return 1;
1501 }
1502
1503 unsigned command_ping6 (char *command, unsigned len)
1504 {
1505         strcpy (cmd_buf, argparse (currtty->shell));
1506
1507         if (!cmd_buf)
1508                 return 0;
1509
1510         netif_t *netif = netif_findbyname ("eth0");
1511
1512         if (!netif) {
1513                 printf ("ping6 -> network interface does not exists\n");
1514                 return 0;
1515         }
1516
1517         unsigned short a;
1518         unsigned short b;
1519         unsigned short c;
1520         unsigned short d;
1521         unsigned short e;
1522         unsigned short f;
1523         unsigned short g;
1524         unsigned short h;
1525
1526         unsigned j = 0;
1527         unsigned i = 0;
1528         unsigned y = strlen (cmd_buf);
1529
1530         if (!y) {
1531                 printf ("ping6 -> wrong syntax, please specify ipv6 address\n");
1532                 return 0;
1533         }
1534
1535         unsigned k[8];
1536
1537         while (i < y) {
1538                 if (cmd_buf[i] == ':') {
1539                         cmd_buf[i] = '\0';
1540                         k[j] = i+1;
1541                         j ++;
1542                 }
1543
1544                 i ++;
1545         }
1546
1547         net_ipv6 target;
1548
1549         if (j != 7) {
1550                 strcpy (cmd_buf, argparse (currtty->shell));
1551
1552                 if (dns_cache_get (cmd_buf, &target, 16) != 1)
1553                         if (dns_send_request (cmd_buf, &target, 16) != 1) {
1554                                 printf ("ping6 -> bad hostname or ip address format, example: 2001:4d3:8fe:2:0:0:0:1\n");
1555                                 return 0;
1556                         }
1557         } else {
1558                 char *endptr;
1559
1560                 a = strtol (cmd_buf, &endptr, 16);
1561                 b = strtol (cmd_buf+k[0], &endptr, 16);
1562                 c = strtol (cmd_buf+k[1], &endptr, 16);
1563                 d = strtol (cmd_buf+k[2], &endptr, 16);
1564                 e = strtol (cmd_buf+k[3], &endptr, 16);
1565                 f = strtol (cmd_buf+k[4], &endptr, 16);
1566                 g = strtol (cmd_buf+k[5], &endptr, 16);
1567                 h = strtol (cmd_buf+k[6], &endptr, 16);
1568
1569                 NET_IPV6_TO_ADDR (target, a, b, c, d, e, f, g, h);
1570
1571                 //printf ("ipv6: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", a, b, c, d, e, f, g, h);
1572
1573                 strcpy (cmd_buf, argparse (currtty->shell));
1574         }
1575
1576         char address[40];
1577         //net_proto_ipv6_convert2 (target, address);
1578
1579         i = 0;
1580
1581         while (i < 8) {
1582                 unsigned long time_a = timer_ticks;
1583                 unsigned ret = net_proto_icmp6_ping (netif, target);
1584                 if (ret) {
1585                         printf ("ping6 -> %s (%s) - %ums\n", cmd_buf, cmd_buf, (timer_ticks - time_a));
1586                 } else {
1587                         printf ("ping6 -> Host %s is unreachable\n", cmd_buf);
1588                         break;
1589                 }
1590
1591                 i ++;
1592         }
1593
1594         return 1;
1595 }
1596
1597 unsigned command_netexec (char *command, unsigned len)
1598 {
1599         strcpy (cmd_buf, argparse (command));
1600
1601         if (!cmd_buf)
1602                 return 0;
1603
1604         if (!strlen (cmd_buf)) {
1605                 printf ("Syntax:\nnetexec <ip_of_tftp> <filename> [parameters]\n");
1606                 return 0;
1607         }
1608
1609         unsigned arg_len = strlen (argparse (cmd_buf));
1610         char arg[arg_len+1];
1611         strcpy (arg, argparse (cmd_buf));
1612         arg[arg_len] = '\0';
1613
1614         unsigned cmd_buf_len = strlen (cmd_buf);
1615         cmd_buf [cmd_buf_len-arg_len] = '\0';
1616
1617         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1618                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1619                 cmd_buf_len --;
1620         }
1621
1622         char file[arg_len+1];
1623         unsigned file_len = 0;
1624         memcpy (file, arg, arg_len);
1625         while (file_len < arg_len) {
1626                 if (file[file_len] == ' ') {
1627                         file[file_len] = '\0';
1628                         break;
1629                 }
1630                 file_len ++;
1631         }
1632
1633         if (file[arg_len] != '\0')
1634                 file[arg_len] = '\0';
1635
1636         unsigned l = file_len;
1637
1638         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1639
1640         if (!ret) {
1641                 printf ("tftp -> something go wrong !\n");
1642                 return 0;
1643         }
1644
1645         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1646
1647         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1648
1649         if (!bin)
1650                 return 0;
1651
1652         int ret2 = tftp_client_read (ret, bin, l);
1653
1654         if (!ret2) {
1655                 printf ("tftp -> tftp_client_read () error\n");
1656                 swfree (bin, l);
1657                 return 0;
1658         }
1659
1660         unsigned entry, code, data, data_off, bss;
1661         int err = exec_elf (bin, &entry, &data, &data_off, &bss);
1662
1663         if (err != NULL) {
1664                 printf ("ERROR -> invalid ELF exec\n");
1665                 return 0;
1666         }
1667
1668         tty_lock (currtty);
1669         timer_wait (1);
1670         /* create process */
1671         proc_t *proc = proc_create (currtty, "netexec", entry);
1672         timer_wait (1);
1673
1674
1675         /* check for & character as app parameter */
1676 /*      unsigned d = 0;
1677         while (d < arg_len) {
1678                 if (arg[d] == '&') {
1679                         if (proc_flag_set (proc, PROC_FLAG_DAEMON))
1680                                 printf ("%s: started as daemon\n", cmd_buf);
1681
1682                         arg[d] = '\0';
1683
1684                         if (arg_len > 2 && arg[d-1] == ' ') {
1685                                 arg[d-1] = '\0';
1686                                 arg_len --;
1687                         }
1688
1689                         arg_len --;
1690
1691                         break;
1692                 }
1693                 d ++;
1694         }*/
1695
1696         if (!proc) {
1697                 printf ("ERROR -> Invalid process: %s\n", cmd_buf);
1698                 return 0;
1699         }
1700
1701         timer_wait (1);
1702
1703         /* save process information to structure for later use */
1704         proc->start = (unsigned) bin;
1705         proc->code = entry;
1706         proc->data = data;
1707         proc->data_off = data_off;
1708         proc->bss = bss;
1709         proc->end = (unsigned) (bin + l);
1710
1711         timer_wait (1);
1712
1713         /* well, set argument for out app */
1714         proc_arg_set (proc, arg+file_len+1, arg_len-file_len-1);
1715
1716         proc_vmem_map (proc);
1717
1718         timer_wait (1);
1719
1720         /* Is this process started as daemon ? */
1721         /* wait here, until pid != 0*/
1722         if (!(proc->flags & PROC_FLAG_DAEMON))
1723                 while (proc->pid)
1724                         schedule ();
1725
1726         timer_wait (1);
1727
1728         /* enable interrupts */
1729         int_enable ();
1730
1731         /* unlock tty console - user can write in */
1732         tty_unlock (proc->tty);
1733
1734         _curr_task = proc->tty->task;   // this is pretty needed for correct return to our tty task
1735
1736         if (!(proc->flags & PROC_FLAG_DAEMON)) {
1737                 if (!proc_done (proc))
1738                         while (1)       // NOTE: heh, this is good stuff :P
1739                                 schedule ();
1740
1741                 /* free image of app */
1742                 swfree (bin, l);
1743         }
1744
1745         /* switch to next task */
1746         schedule ();
1747
1748         sclose (ret);
1749
1750         return 1;
1751 }
1752
1753 unsigned command_netcp (char *command, unsigned len)
1754 {
1755         strcpy (cmd_buf, argparse (command));
1756
1757         if (!cmd_buf)
1758                 return 0;
1759
1760         if (!strlen (cmd_buf)) {
1761                 printf ("Syntax:\nnetcp <ip_of_tftp> <tftp_file> <output_file>\n");
1762                 return 0;
1763         }
1764
1765         unsigned arg_len = strlen (argparse (cmd_buf));
1766         char arg[arg_len+1];
1767         strcpy (arg, argparse (cmd_buf));
1768         arg[arg_len] = '\0';
1769
1770         unsigned cmd_buf_len = strlen (cmd_buf);
1771         cmd_buf [cmd_buf_len-arg_len] = '\0';
1772
1773         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1774                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1775                 cmd_buf_len --;
1776         }
1777
1778         char file[arg_len+1];
1779         unsigned file_len = 0;
1780         memcpy (file, arg, arg_len);
1781         while (file_len < arg_len) {
1782                 if (file[file_len] == ' ') {
1783                         file[file_len] = '\0';
1784                         break;
1785                 }
1786                 file_len ++;
1787         }
1788
1789         if (file[arg_len] != '\0')
1790                 file[arg_len] = '\0';
1791
1792         unsigned l = file_len;
1793
1794         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1795
1796         if (!ret) {
1797                 printf ("tftp -> something go wrong !\n");
1798                 return 0;
1799         }
1800
1801         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1802
1803         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1804
1805         if (!bin)
1806                 return 0;
1807
1808         int ret2 = tftp_client_read (ret, bin, l);
1809
1810         if (!ret2) {
1811                 printf ("tftp -> tftp_client_read () error\n");
1812                 swfree (bin, l);
1813                 return 0;
1814         }
1815
1816         sclose (ret);
1817
1818         char *output = argparse (arg);
1819
1820         if (!output) {
1821                 swfree (bin, l);
1822                 printf ("ERROR -> output file name is empty\n");
1823                 return 0;
1824         }
1825
1826         int fd = open (output, O_WRONLY | O_CREAT);
1827
1828         if (!fd) {
1829                 swfree (bin, l);
1830                 printf ("ERROR -> something go wrong with %s\n", output);
1831                 return 0;
1832         }
1833
1834         ret = write (fd, bin, l);
1835
1836         if (!ret) {
1837                 swfree (bin, l);
1838                 printf ("ERROR -> File '%s' could'nt be writed\n", output);
1839         }
1840
1841         return 1;
1842 }
1843
1844 extern bool ide_acthandler (unsigned act, partition_t *p, char *block, char *more, int n);
1845 unsigned command_znfscl (char *command, unsigned len)
1846 {
1847 #ifdef ARCH_i386
1848         strcpy (cmd_buf, argparse (command));
1849
1850         if (!strlen (cmd_buf)) {
1851                 printf ("Syntax:\nznfscl <ip_of_znfs>\n");
1852                 return 0;
1853         }
1854
1855         dev_t *dev = dev_find ("/dev/vbd");
1856
1857         if (dev) {
1858                 printf ("znfscl: You are already connected to znfs server\n");
1859                 return 0;
1860         }
1861
1862         dev = (dev_t *) dev_register ("vbd", "Virtual Block Device", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
1863
1864         if (!dev)
1865                 return 0;
1866
1867         partition_t *p = partition_add (dev, fs_supported ("znfs"), 0);
1868
1869         if (!p)
1870                 return 0;
1871
1872         /* connect to specified address */
1873         if (znfs_init (p, cmd_buf) != 1) {
1874                 printf ("znfs: Wrong znfs server\n");
1875                 return 0;
1876         }
1877
1878         char str[16];
1879
1880         sprintf (str, "/mnt/%s", p->name+5);
1881
1882         mkdir (str);
1883
1884         mount (p, "", str);
1885
1886         printf ("znfs: You are succefully connected to ZNFS server '%s'\nZNFS was mounted into '%s'\n", cmd_buf, str);
1887 #else
1888         printf ("ERROR -> this architecture is not supported yet\n");
1889 #endif
1890         return 1;
1891 }
1892
1893 void task_savemode ()
1894 {
1895         /* disable cpu for cycle */
1896         for (;; schedule ())
1897                 arch_cpu_hlt ();
1898 }
1899
1900 unsigned command_savemode (char *command, unsigned len)
1901 {
1902         task_t *task = (task_t *) task_create ("savemode", (unsigned) &task_savemode, 16);
1903
1904         if (!task) {
1905                 printf ("ERROR -> Save mode thread was'nt created\n");
1906                 return 0;
1907         }
1908
1909         printf ("Save mode was succefully started\n");
1910
1911         return 1;
1912 }
1913
1914 unsigned command_cpuinfo (char *command, unsigned len)
1915 {
1916         printf ("Processor info:\n");
1917
1918         cat ("/proc/cpuinfo");
1919
1920         return 1;
1921 }
1922
1923 unsigned command_adm (char *command, unsigned len)
1924 {
1925         printf ("Automatic Device Mounter - init ()\n");
1926
1927         init_adm ();
1928
1929         return 1;
1930 }
1931
1932 unsigned command_ttyctrl (char *command, unsigned len)
1933 {
1934         char *parm = argparse (command);
1935
1936         if (!strlen (parm)) {
1937                 printf ("ttyctrl <operation> [parameter]\n\toperations: add; list; change <ttyid>\n");
1938                 return 0;
1939         }
1940
1941         if (!strncmp (parm, "add", 3)) {
1942                 tty_t *tty = tty_create ();
1943
1944                 if (!tty)
1945                         return 0;
1946
1947                 video_color (7, 0);
1948
1949                 tty_write (tty, "\nlogin: ", 8);
1950
1951                 printf ("New tty '%s' was created\n", tty->name);
1952         } else
1953         if (!strncmp (parm, "list", 4)) {
1954                 tty_listview ();
1955         } else
1956         if (!strncmp (parm, "change", 6)) {
1957                 tty_t *tty = tty_find ((char *) argparse (parm));
1958
1959                 if (!tty)
1960                         return 0;
1961
1962                 tty_change (tty);
1963
1964                 printf ("\n");
1965         }
1966
1967         return 1;
1968 }
1969
1970 unsigned command_cmd (char *command, unsigned len)
1971 {
1972         unsigned s = 0;
1973         unsigned e = 0;
1974
1975         if (!strlen (argparse (command))) {
1976                 printf ("cmd <command1>;<command2>;...;\n");
1977                 return 0;
1978         }
1979
1980         char *cmds = kmalloc (len - 3);
1981
1982         if (!cmds)
1983                 return 0;
1984
1985         memcpy (cmds, command + 4, len - 4);
1986         cmds[len - 4] = '\0';
1987
1988         unsigned i;
1989         for (i = 1; i < len - 4; i ++) {
1990                 if (cmds[i] == ';') {
1991                         cmds[i] = '\0';
1992                         e = i-1;
1993
1994                         command_parser (cmds+s, e-s+1);
1995
1996                         s = i+1;
1997                 }
1998         }
1999
2000         kfree (cmds);
2001
2002         return 1;
2003 }
2004
2005 /*************************************************************\
2006 |                       COMMAND's UTILS                       |
2007 \*************************************************************/
2008
2009 unsigned command_parser (char *command, unsigned len)
2010 {
2011         /* find first non-space in command */
2012         int i = 0;
2013         for (i = 0; i < len; i ++) {
2014                 if (command[i] != ' ')
2015                         break;
2016         }
2017         command_t *ctx;
2018
2019         /* try to find the command */
2020         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
2021                 if (!cstrcmp (ctx->name, command+i)) {
2022                         ctx->handler (command+i, len-i);        /* execute context function */
2023                         return 1;
2024                 }
2025         }
2026
2027         printf ("%s: command not found\n", command);
2028
2029         return 0;
2030 }
2031
2032 void commands (int i)
2033 {
2034         // currtty->shell_len has been set to zero already
2035         command_parser (currtty->shell, strlen(currtty->shell));
2036 }
2037
2038 unsigned command_register (char *name, char *desc, command_handler_t *handler, unsigned flags)
2039 {
2040         command_t *c;
2041         /* we dont want commands with same name */
2042         for (c = command_list.next; c != &command_list; c = c->next)
2043                 if (!strcmp(c->name, name))
2044                         return 0;
2045
2046         command_t *ctx;
2047
2048         // alloc and init context
2049         ctx = (command_t *) kmalloc (sizeof (command_t));
2050
2051         if (!ctx)
2052                 return 0;
2053
2054         unsigned name_len = strlen (name);
2055         ctx->name = (char *) kmalloc (sizeof (char) * name_len +1);
2056
2057         if (!ctx->name)
2058                 return 0;
2059
2060         memcpy (ctx->name, name, name_len);
2061         ctx->name[name_len] = '\0';
2062
2063         unsigned desc_len = strlen (desc);
2064         ctx->desc = (char *) kmalloc (sizeof (char) * desc_len +1);
2065
2066         if (!ctx->desc)
2067                 return 0;
2068
2069         memcpy (ctx->desc, desc, desc_len);
2070         ctx->desc[desc_len] = '\0';
2071
2072         ctx->handler = handler;
2073         ctx->flags = flags;
2074
2075         ctx->next = &command_list;
2076         ctx->prev = command_list.prev;
2077         ctx->prev->next = ctx;
2078         ctx->next->prev = ctx;
2079
2080         return 1;
2081 }
2082
2083 unsigned command_unregister (char *name)
2084 {
2085         command_t *ctx;
2086
2087         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
2088                 if (!strcmp(ctx->name, name)) {
2089                         ctx->next->prev = ctx->prev;
2090                         ctx->prev->next = ctx->next;
2091
2092                         return 1;
2093                 }
2094         }
2095
2096         return 0;
2097 }
2098
2099 /*************************************************************\
2100 |                 INITIALIZATION OF COMMANDS                  |
2101 \*************************************************************/
2102
2103 unsigned int init_commands ()
2104 {
2105         command_list.next = &command_list;
2106         command_list.prev = &command_list;
2107
2108         // reg commands
2109         command_register ("help", "Displays list of available commands", &command_help, 0);
2110         command_register ("hdd", "Detect HDD", &command_hdd, 0);
2111         command_register ("reboot", "Reboot computer", &command_reboot, 0);
2112         command_register ("halt", "Shutdown computer", &command_halt, 0);
2113         command_register ("tasks", "Print all tasks", &command_tasks, 0);
2114         command_register ("ps", "Print all process", &command_ps, 0);
2115         command_register ("uptime", "Print uptime in seconds", &command_uptime, 0);
2116         command_register ("version", "Displays a version of system", &command_version, 0);
2117         command_register ("debug", "Change to developer mode", &command_debug, 0);
2118         command_register ("mount", "Mount device to selected directory", &command_mount, 0);
2119         command_register ("umount", "Unmount mounted directory", &command_umount, 0);
2120         command_register ("env", "Displays all env variables", &command_env, 0);
2121         command_register ("cd", "Change directory", &command_cd, 0);
2122         command_register ("ls", " Displays files in current directory", &command_ls, 0);
2123         command_register ("cat", "Displays text in selected file", &command_cat, 0);
2124         command_register ("cp", "Copy a file", &command_cp, 0);
2125         command_register ("rm", "Remove a file", &command_rm, 0);
2126         command_register ("mkdir", "Create a directory", &command_mkdir, 0);
2127         command_register ("touch", "Create a file", &command_touch, 0);
2128         command_register ("exec", "Execute a selected program", &command_exec, 0);
2129         command_register ("lsdev", "Displays found devices", &command_lsdev, 0);
2130         command_register ("login", "Login as another user", &command_login, 0);
2131         command_register ("fdisk", "Partition table manipulator", &command_fdisk, 0);
2132         command_register ("hdcat", "Read selected block of data from drive", &command_hdcat, 0);
2133         command_register ("free", "Display amount of free and used memory", &command_free, 0);
2134         command_register ("top", "Stats of cpu usage", &command_top, 0);
2135         command_register ("date", "Show current date and time", &command_date, 0);
2136         //command_register ("xmastime", "play noels on pc-speaker", &command_spk, 0);
2137         command_register ("test", "Some test", &command_test, 0);
2138         //command_register ("test2", "Some test", &command_test2, 0);
2139         //command_register ("test3", "Some test", &command_test3, 0);
2140         //command_register ("testd", "Some test", &command_test4, 0);
2141         //command_register ("vesa", "Some test", &command_vesa, 0);
2142         command_register ("kill", "Send a signal to process", &command_kill, 0);
2143         command_register ("modprobe", "program to add modules from the kernel", &command_modprobe, 0);
2144         command_register ("lsmod", "program to show the status of modules", &command_lsmod, 0);
2145 #ifdef CONFIG_DRV_PCI
2146         command_register ("lspci", "list all pci devices", &command_lspci, 0);
2147 #endif
2148         command_register ("mouse", "ps2 mouse test", &command_mouse, 0);
2149         command_register ("iflist", "Show network interface", &command_iflist, 0);
2150         command_register ("ifconfig", "Configure network interface", &command_ifconfig, 0);
2151         command_register ("ifroute", "Configure gateway address", &command_ifroute, 0);
2152         command_register ("dnsconfig", "Configure domain name server address", &command_dnsconfig, 0);
2153         command_register ("dhcpcl", "Configure interface using DHCP", &command_dhcpcl, 0);
2154 #ifdef CONFIG_PROTO_TUN6
2155         command_register ("tunconfig", "Configure IPv6 tunnel server address", &command_tunconfig, 0);
2156 #endif
2157         command_register ("hostname", "Configure network hostname", &command_hostname, 0);
2158         command_register ("kbdmap", "Change keyboard layout", &command_kbdmap, 0);
2159 #ifdef CONFIG_DRV_ZEXFS
2160         command_register ("mkzexfs", "Create zexfs filesystem on hdd", &command_mkzexfs, 0);
2161 #endif
2162 #ifdef CONFIG_DRV_EXT2
2163         command_register ("mkext2", "Create ext2 filesystem on hdd", &command_mkext2, 0);
2164 #endif
2165 #ifdef CONFIG_PROTO_IPV4
2166         command_register ("ping", "Send ICMP echo request", &command_ping, 0);
2167 #endif
2168 #ifdef CONFIG_PROTO_IPV6
2169         command_register ("ping6", "Send ICMPv6 echo request", &command_ping6, 0);
2170 #endif
2171         command_register ("netexec", "Execute file from network", &command_netexec, 0);
2172         command_register ("netcp", "Copy file from network to filesystem", &command_netcp, 0);
2173 #ifdef CONFIG_DRV_ZNFS
2174         command_register ("znfscl", "Connect to znfs server - network filesystem", &command_znfscl, 0);
2175 #endif
2176         command_register ("savemode", "Make less cpu load", &command_savemode, 0);
2177         command_register ("cpuinfo", "Show CPU info", &command_cpuinfo, 0);
2178
2179         command_register ("adm", "Automatic Device Mounter", &command_adm, 0);
2180         command_register ("ttyctrl", "TTY Console control", &command_ttyctrl, 0);
2181         command_register ("cmd", "Execute command sequence", &command_cmd, 0);
2182
2183         return 1;
2184 }