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 extern unsigned start;
 895 extern unsigned end;
 896 extern bool ide_acthandler (unsigned act, partition_t *p, char *block, char *more, int n);
 897 unsigned command_test (char *command, unsigned len)
 898 {
 899         partition_t *p = partition_find ("/dev/hda0");
 900
 901         if (p)
 902                 mount (p, "", "/mnt/hdd/");
 903         else
 904                 return 0;
 905
 906         cd ("/mnt/hdd");
 907
 908         return 1;
 909 }
 910 extern char *vgafb;
 911 extern char *vgadb;
 912 unsigned command_test2 (char *command, unsigned len)
 913 {
 914         partition_t *p = partition_find ("/dev/cdc0");
 915
 916         if (p)
 917                 mount (p, "", "/mnt/cdrom/");
 918         else
 919                 return 0;
 920
 921         cd ("/mnt/cdrom");
 922
 923 /*      tty_t *tty = tty_find ("tty0");
 924
 925         if (!tty)
 926                 return 0;
 927         char str[513];
 928         int r = tty_read (tty, str, 512);
 929
 930         if (r > 0) {
 931                 printf ("str: r: %d\n", r);
 932                 int i;
 933                 for (i = 0; i < r; i ++)
 934                         tty_putch (str[i]);
 935         }
 936   */
 937
 938 /*      int ret = vfs_read ("wav", 3);
 939
 940         if (ret < 0) {
 941                 printf ("chyba\n");
 942                 return 0;
 943         }
 944
 945         cache_t *cache = cache_read ();
 946
 947         unsigned char *p = (unsigned char *) &cache->data;
 948
 949         unsigned bin_len = cache->limit;
 950
 951         unsigned char *bin = (unsigned char *) 0x400000 - 44;
 952
 953         memcpy (bin, p, bin_len);
 954
 955         typedef struct {
 956                 unsigned chunkid;
 957                 unsigned chunksize;
 958                 unsigned format;
 959         } riff_head_t;
 960
 961         typedef struct {
 962                 unsigned subchunk1id;
 963                 unsigned subchunk1size;
 964                 unsigned short audioformat;
 965                 unsigned short numchannels;
 966                 unsigned samplerate;
 967                 unsigned byterate;
 968                 unsigned short blockalign;
 969                 unsigned short bitspersample;
 970         } fmt_head_t;
 971
 972         typedef struct {
 973                 unsigned subchunk2id;
 974                 unsigned subchunk2size;
 975         } data_head_t;
 976
 977         riff_head_t *r = (riff_head_t *) bin;
 978         fmt_head_t *fmt = (fmt_head_t *) ((char *) bin + sizeof (riff_head_t));
 979         data_head_t *data = (data_head_t *) ((char *) bin + sizeof (riff_head_t) + sizeof (fmt_head_t));
 980
 981         printf ("riff_head_t 0x%x : %d : 0x%x\n", r->chunkid, r->chunksize, r->format);
 982         printf ("fmt_head_t %d : %d : %d : %d : %d : %d\n", fmt->audioformat, fmt->subchunk1size, fmt->numchannels, fmt->samplerate, fmt->byterate, fmt->bitspersample);
 983         printf ("data_head_t 0x%x : %d\n", data->subchunk2id, data->subchunk2size);
 984         //memset (bin+44, 0, bin_len-44);
 985         //dev->handler (DEV_ACT_WRITE, bin+44, bin_len-44);
 986
 987         snd_cfg_t cfg;
 988         cfg.dev = "/dev/ac97";
 989         cfg.rate = fmt->samplerate;
 990         cfg.format = SOUND_FORMAT_S16;
 991         cfg.channels = fmt->numchannels;
 992
 993         snd_audio_t *aud = audio_open (&cfg);
 994
 995         if (!aud)
 996                 return 0;
 997
 998         audio_write (aud, bin+44, (bin_len-44));
 999
1000         //swfree (bin, bin_len);*/
1001
1002
1003
1004         return 1;
1005 }
1006
1007 unsigned command_test3 (char *command, unsigned len)
1008 {
1009         netif_t *netif = netif_findbyname ("eth0");
1010         dhcp_config_if(netif);
1011
1012         return 1;
1013 }
1014
1015 unsigned command_test4 (char *command, unsigned len)
1016 {
1017
1018
1019         return 1;
1020 }
1021
1022 unsigned command_mouse (char *command, unsigned len)
1023 {
1024         printf ("PS/2 Mouse test\n");
1025
1026         dev_t *dev = dev_find ("/dev/mouseps2");
1027
1028         if (!dev)
1029                 return 0;
1030
1031         dev_mouse_t mouse;
1032
1033         int ps2_fd = open ("/dev/mouseps2", O_RDONLY);
1034
1035         if (!ps2_fd)
1036                 return 0;
1037
1038 printf ("dddd\n");
1039
1040         while (!key_pressed (1)) {
1041                 int r = read (ps2_fd, &mouse, sizeof (dev_mouse_t));
1042
1043                 if (!r) {
1044                         kprintf ("oj oj\n");
1045                         return 0;
1046                 }
1047
1048                 kprintf ("ps2mouse: x,y: %d, %d | 0x%x \n", mouse.pos_x, mouse.pos_y, mouse.flags);
1049
1050                 lseek (ps2_fd, 0, SEEK_SET);
1051
1052                 schedule ();
1053         }
1054
1055         return 1;
1056 }
1057
1058 unsigned command_vesa (char *command, unsigned len)
1059 {
1060         if (!init_video_vesa ())
1061                 printf ("vesa -> failed\n");
1062
1063         return 1;
1064 }
1065
1066 unsigned command_kill (char *command, unsigned len)
1067 {
1068         strcpy (cmd_buf, argparse (currtty->shell));
1069
1070         pid_t pid = (pid_t) atoi (cmd_buf);
1071
1072         proc_t *proc = proc_findbypid (pid);
1073
1074         if (!proc) {
1075                 printf ("kill: (%s) - No such process\n", cmd_buf);
1076                 return 0;
1077         }
1078
1079         /* send SIGTERM to selected process */
1080         if (!proc_signal (proc, SIGTERM))
1081                 return 0;
1082
1083         /* check for daemon */
1084         if (proc->flags & PROC_FLAG_DAEMON)
1085                 if (!proc_done (proc))
1086                         return 0;
1087
1088         return 1;
1089 }
1090
1091 unsigned command_modprobe (char *command, unsigned len)
1092 {
1093         unsigned arg_len = strlen (argparse (currtty->shell));
1094         char arg[arg_len+1];
1095         strcpy (arg, argparse (currtty->shell));
1096         arg[arg_len] = '\0';
1097
1098         module_load (arg);
1099
1100         return 1;
1101 }
1102
1103 unsigned command_lsmod (char *command, unsigned len)
1104 {
1105         module_display ();
1106
1107         return 1;
1108 }
1109
1110 #ifdef CONFIG_DRV_PCI
1111 unsigned command_lspci (char *command, unsigned len)
1112 {
1113 #ifdef ARCH_i386
1114         pcidev_display ();
1115 #endif
1116         return 1;
1117 }
1118 #endif
1119
1120 unsigned command_iflist (char *command, unsigned len)
1121 {
1122         iflist_display ();
1123
1124         return 1;
1125 }
1126
1127 unsigned command_ifconfig (char *command, unsigned len)
1128 {
1129         strcpy (cmd_buf, argparse (command));
1130         char ifid[20];
1131         char ip[32];
1132
1133         unsigned l = strlen (cmd_buf);
1134         unsigned x = 0;
1135         while (x < l) {
1136                 if (cmd_buf[x] == ' ')
1137                         break;
1138                 x ++;
1139         }
1140
1141         memcpy (ifid, cmd_buf, x);
1142         ifid[x] = '\0';
1143
1144         strcpy (ip, argparse (cmd_buf));
1145         unsigned y = strlen (ip);
1146
1147         netif_t *netif = netif_findbyname (ifid);
1148
1149         if (!netif) {
1150                 printf ("ifconfig -> bad network interface name, example: eth0\n");
1151                 return 0;
1152         }
1153
1154         net_ipv4 ipv4;
1155         net_ipv6 ipv6;
1156         if (ipv4 = net_proto_ip_convert (ip)) {
1157                 netif_ip_addr (netif, ipv4, IF_CFG_TYPE_STATIC);
1158
1159                 printf ("%s: IPv4 ", ifid);
1160                 net_proto_ip_print (ipv4);
1161                 printf (" - OK\n");
1162         } else if (net_proto_ipv6_convert (ipv6, ip)) {
1163                 netif_ipv6_addr (netif, ipv6, IF_CFG_TYPE_STATIC);
1164
1165                 printf ("%s: IPv6 ", ifid);
1166                 net_proto_ipv6_print (ipv6);
1167                 printf (" - OK\n");
1168         } else {
1169                 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");
1170                 return 0;
1171         }
1172
1173         return 1;
1174 }
1175
1176 unsigned command_ifroute (char *command, unsigned len)
1177 {
1178         strcpy (cmd_buf, argparse (command));
1179         char ifid[20];
1180         char ip[32];
1181
1182         unsigned l = strlen (cmd_buf);
1183         unsigned x = 0;
1184         while (x < l) {
1185                 if (cmd_buf[x] == ' ')
1186                         break;
1187                 x ++;
1188         }
1189
1190         memcpy (ifid, cmd_buf, x);
1191         ifid[x] = '\0';
1192
1193         strcpy (ip, argparse (cmd_buf));
1194         unsigned y = strlen (ip);
1195
1196         netif_t *netif = netif_findbyname (ifid);
1197
1198         if (!netif) {
1199                 printf ("ifroute -> bad network interface name, example: eth0\n");
1200                 return 0;
1201         }
1202
1203         unsigned char a;
1204         unsigned char b;
1205         unsigned char c;
1206         unsigned char d;
1207
1208         unsigned g = 0;
1209         unsigned i = 0;
1210
1211         unsigned h[4];
1212
1213         while (i < y) {
1214                 if (ip[i] == '.') {
1215                         ip[i] = '\0';
1216                         h[g] = i+1;
1217                         g ++;
1218                 }
1219
1220                 i ++;
1221         }
1222
1223         if (g != 3) {
1224                 printf ("ifroute -> bad ip address format, example: 192.168.1.254\n");
1225                 return 0;
1226         }
1227
1228         a = atoi (ip);
1229         b = atoi (ip+h[0]);
1230         c = atoi (ip+h[1]);
1231         d = atoi (ip+h[2]);
1232
1233         printf ("%s->gw: %d.%d.%d.%d - OK\n", ifid, a, b, c, d);
1234
1235         return netif_gw_addr (netif, NET_IPV4_TO_ADDR (a, b, c, d));
1236 }
1237
1238 unsigned command_dnsconfig (char *command, unsigned len)
1239 {
1240         strcpy (cmd_buf, argparse (currtty->shell));
1241
1242         if (!cmd_buf)
1243                 return 0;
1244
1245         unsigned l = strlen (cmd_buf);
1246
1247         if (!l) {
1248                 printf ("dnsconfig -> your domain name server is: ");
1249                 net_proto_ip_print (dns_addr_get ());
1250                 printf ("\n");
1251
1252                 return 0;
1253         }
1254
1255         printf ("dnsconfig: %s - OK\n", cmd_buf);
1256
1257         net_ipv4 dns = net_proto_ip_convert (cmd_buf);
1258
1259         if (!dns)
1260                 return 0;
1261
1262         dns_addr (dns);
1263
1264         return 1;
1265 }
1266
1267 unsigned command_tunconfig (char *command, unsigned len)
1268 {
1269         strcpy (cmd_buf, argparse (currtty->shell));
1270
1271         if (!cmd_buf)
1272                 return 0;
1273
1274         unsigned l = strlen (cmd_buf);
1275
1276         if (!l) {
1277                 printf ("tunconfig -> wrong syntax !\ntunconfig <ipv4tunnel> for enable or tunconfig 0 for disable\n");
1278
1279                 return 0;
1280         }
1281
1282         /* you can disable this service over character '0' as parameter */
1283         if (l == 1 && cmd_buf[0] == '0') {
1284                 tun6_addr (0);
1285
1286                 printf ("tunconfig: disabled - OK\n");
1287
1288                 return 1;
1289         }
1290
1291         /* classical ipv4 address from tunnel server */
1292         net_ipv4 tunnel = net_proto_ip_convert (cmd_buf);
1293
1294         if (!tunnel) {
1295                 printf ("tunconfig -> wrong syntax !\nExample: tunconfig 216.66.80.30\n");
1296
1297                 return 0;
1298         }
1299
1300         tun6_addr (tunnel);
1301
1302         printf ("tunconfig: ::%s - OK\n", cmd_buf);
1303
1304         return 1;
1305 }
1306
1307
1308 unsigned command_hostname (char *command, unsigned len)
1309 {
1310         strcpy (cmd_buf, argparse (currtty->shell));
1311
1312         if (!cmd_buf)
1313                 return 0;
1314
1315         unsigned l = strlen (cmd_buf);
1316
1317         if (!l) {
1318                 printf ("%s\n", hostname_get ());
1319
1320                 return 0;
1321         }
1322
1323         printf ("hostname: %s - OK\n", cmd_buf);
1324
1325         hostname_set (cmd_buf);
1326
1327         return 1;
1328 }
1329
1330 unsigned command_kbdmap (char *command, unsigned len)
1331 {
1332         strcpy (cmd_buf, argparse (currtty->shell));
1333
1334         if (!cmd_buf)
1335                 return 0;
1336
1337         unsigned ret = keyboard_setlayout (cmd_buf);
1338
1339         if (ret)
1340                 printf ("Keyboard layout was changed to '%s'\n", cmd_buf);
1341
1342         return ret;
1343 }
1344
1345 unsigned command_mkzexfs (char *command, unsigned len)
1346 {
1347 #ifdef ARCH_i386
1348         strcpy (cmd_buf, argparse (currtty->shell));
1349
1350         partition_t *p = partition_find (cmd_buf);
1351
1352         if (!p)
1353                 return 0;
1354
1355         mkzexfs (p);
1356 #endif
1357         return 1;
1358 }
1359
1360 unsigned command_mkext2 (char *command, unsigned len)
1361 {
1362 #ifdef ARCH_i386
1363         strcpy (cmd_buf, argparse (currtty->shell));
1364
1365         if (!cmd_buf)
1366                 return 0;
1367
1368         partition_t *p = partition_find ("/dev/hda0");
1369
1370         mkext2 (p);
1371 #endif
1372         return 1;
1373 }
1374
1375 unsigned command_ping (char *command, unsigned len)
1376 {
1377
1378         strcpy (cmd_buf, argparse (currtty->shell));
1379
1380         if (!cmd_buf)
1381                 return 0;
1382
1383         netif_t *netif = netif_findbyname ("eth0");
1384
1385         if (!netif) {
1386                 printf ("ping -> network interface does not exists\n");
1387                 return 0;
1388         }
1389
1390         unsigned char a;
1391         unsigned char b;
1392         unsigned char c;
1393         unsigned char d;
1394
1395         unsigned g = 0;
1396         unsigned i = 0;
1397         unsigned y = strlen (cmd_buf);
1398
1399         if (!y) {
1400                 printf ("ping -> wrong syntax, please specify address\n");
1401                 return 0;
1402         }
1403
1404         unsigned h[4];
1405
1406         while (i < y) {
1407                 if (cmd_buf[i] == '.') {
1408                         cmd_buf[i] = '\0';
1409                         h[g] = i+1;
1410                         g ++;
1411                 }
1412
1413                 i ++;
1414         }
1415
1416         net_ipv4 target = 0;
1417
1418         if (g != 3) {
1419                 strcpy (cmd_buf, argparse (currtty->shell));
1420
1421                 if (dns_cache_get (cmd_buf, &target, 4) != 1)
1422                         if (dns_send_request (cmd_buf, &target, 4) != 1) {
1423                                 printf ("ping -> bad hostname or ip address format, example: 192.168.1.1\n");
1424                                 return 0;
1425                         }
1426         } else {
1427                 a = atoi (cmd_buf);
1428                 b = atoi (cmd_buf+h[0]);
1429                 c = atoi (cmd_buf+h[1]);
1430                 d = atoi (cmd_buf+h[2]);
1431
1432                 target = NET_IPV4_TO_ADDR (a, b, c, d);
1433
1434                 strcpy (cmd_buf, argparse (currtty->shell));
1435         }
1436
1437         char address[20];
1438         net_proto_ip_convert2 (target, address);
1439
1440         i = 0;
1441
1442         while (i < 8) {
1443                 unsigned long time_a = timer_ticks;
1444                 unsigned ret = net_proto_icmp_ping (netif, target);
1445                 if (ret) {
1446                         printf ("ping -> %s (%s) - %ums\n", cmd_buf, address, (timer_ticks - time_a));
1447                 } else {
1448                         printf ("ping -> Host %s is unreachable\n", cmd_buf);
1449                         break;
1450                 }
1451
1452                 i ++;
1453         }
1454
1455         return 1;
1456 }
1457
1458 unsigned command_ping6 (char *command, unsigned len)
1459 {
1460         strcpy (cmd_buf, argparse (currtty->shell));
1461
1462         if (!cmd_buf)
1463                 return 0;
1464
1465         netif_t *netif = netif_findbyname ("eth0");
1466
1467         if (!netif) {
1468                 printf ("ping6 -> network interface does not exists\n");
1469                 return 0;
1470         }
1471
1472         unsigned short a;
1473         unsigned short b;
1474         unsigned short c;
1475         unsigned short d;
1476         unsigned short e;
1477         unsigned short f;
1478         unsigned short g;
1479         unsigned short h;
1480
1481         unsigned j = 0;
1482         unsigned i = 0;
1483         unsigned y = strlen (cmd_buf);
1484
1485         if (!y) {
1486                 printf ("ping6 -> wrong syntax, please specify ipv6 address\n");
1487                 return 0;
1488         }
1489
1490         unsigned k[8];
1491
1492         while (i < y) {
1493                 if (cmd_buf[i] == ':') {
1494                         cmd_buf[i] = '\0';
1495                         k[j] = i+1;
1496                         j ++;
1497                 }
1498
1499                 i ++;
1500         }
1501
1502         net_ipv6 target;
1503
1504         if (j != 7) {
1505                 strcpy (cmd_buf, argparse (currtty->shell));
1506
1507                 if (dns_cache_get (cmd_buf, &target, 16) != 1)
1508                         if (dns_send_request (cmd_buf, &target, 16) != 1) {
1509                                 printf ("ping6 -> bad hostname or ip address format, example: 2001:4d3:8fe:2:0:0:0:1\n");
1510                                 return 0;
1511                         }
1512         } else {
1513                 char *endptr;
1514
1515                 a = strtol (cmd_buf, &endptr, 16);
1516                 b = strtol (cmd_buf+k[0], &endptr, 16);
1517                 c = strtol (cmd_buf+k[1], &endptr, 16);
1518                 d = strtol (cmd_buf+k[2], &endptr, 16);
1519                 e = strtol (cmd_buf+k[3], &endptr, 16);
1520                 f = strtol (cmd_buf+k[4], &endptr, 16);
1521                 g = strtol (cmd_buf+k[5], &endptr, 16);
1522                 h = strtol (cmd_buf+k[6], &endptr, 16);
1523
1524                 NET_IPV6_TO_ADDR (target, a, b, c, d, e, f, g, h);
1525
1526                 //printf ("ipv6: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", a, b, c, d, e, f, g, h);
1527
1528                 strcpy (cmd_buf, argparse (currtty->shell));
1529         }
1530
1531         char address[40];
1532         //net_proto_ipv6_convert2 (target, address);
1533
1534         i = 0;
1535
1536         while (i < 8) {
1537                 unsigned long time_a = timer_ticks;
1538                 unsigned ret = net_proto_icmp6_ping (netif, target);
1539                 if (ret) {
1540                         printf ("ping6 -> %s (%s) - %ums\n", cmd_buf, cmd_buf, (timer_ticks - time_a));
1541                 } else {
1542                         printf ("ping6 -> Host %s is unreachable\n", cmd_buf);
1543                         break;
1544                 }
1545
1546                 i ++;
1547         }
1548
1549         return 1;
1550 }
1551
1552 unsigned command_netexec (char *command, unsigned len)
1553 {
1554         strcpy (cmd_buf, argparse (command));
1555
1556         if (!cmd_buf)
1557                 return 0;
1558
1559         if (!strlen (cmd_buf)) {
1560                 printf ("Syntax:\nnetexec <ip_of_tftp> <filename> [parameters]\n");
1561                 return 0;
1562         }
1563
1564         unsigned arg_len = strlen (argparse (cmd_buf));
1565         char arg[arg_len+1];
1566         strcpy (arg, argparse (cmd_buf));
1567         arg[arg_len] = '\0';
1568
1569         unsigned cmd_buf_len = strlen (cmd_buf);
1570         cmd_buf [cmd_buf_len-arg_len] = '\0';
1571
1572         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1573                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1574                 cmd_buf_len --;
1575         }
1576
1577         char file[arg_len+1];
1578         unsigned file_len = 0;
1579         memcpy (file, arg, arg_len);
1580         while (file_len < arg_len) {
1581                 if (file[file_len] == ' ') {
1582                         file[file_len] = '\0';
1583                         break;
1584                 }
1585                 file_len ++;
1586         }
1587
1588         if (file[arg_len] != '\0')
1589                 file[arg_len] = '\0';
1590
1591         unsigned l = file_len;
1592
1593         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1594
1595         if (!ret) {
1596                 printf ("tftp -> something go wrong !\n");
1597                 return 0;
1598         }
1599
1600         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1601
1602         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1603
1604         if (!bin)
1605                 return 0;
1606
1607         int ret2 = tftp_client_read (ret, bin, l);
1608
1609         if (!ret2) {
1610                 printf ("tftp -> tftp_client_read () error\n");
1611                 swfree (bin, l);
1612                 return 0;
1613         }
1614
1615         unsigned entry, code, data, data_off, bss;
1616         int err = exec_elf (bin, &entry, &data, &data_off, &bss);
1617
1618         if (err != NULL) {
1619                 printf ("ERROR -> invalid ELF exec\n");
1620                 return 0;
1621         }
1622
1623         tty_lock (currtty);
1624         timer_wait (1);
1625         /* create process */
1626         proc_t *proc = proc_create (currtty, "netexec", entry);
1627         timer_wait (1);
1628
1629
1630         /* check for & character as app parameter */
1631 /*      unsigned d = 0;
1632         while (d < arg_len) {
1633                 if (arg[d] == '&') {
1634                         if (proc_flag_set (proc, PROC_FLAG_DAEMON))
1635                                 printf ("%s: started as daemon\n", cmd_buf);
1636
1637                         arg[d] = '\0';
1638
1639                         if (arg_len > 2 && arg[d-1] == ' ') {
1640                                 arg[d-1] = '\0';
1641                                 arg_len --;
1642                         }
1643
1644                         arg_len --;
1645
1646                         break;
1647                 }
1648                 d ++;
1649         }*/
1650
1651         if (!proc) {
1652                 printf ("ERROR -> Invalid process: %s\n", cmd_buf);
1653                 return 0;
1654         }
1655
1656         timer_wait (1);
1657
1658         /* save process information to structure for later use */
1659         proc->start = (unsigned) bin;
1660         proc->code = entry;
1661         proc->data = data;
1662         proc->data_off = data_off;
1663         proc->bss = bss;
1664         proc->end = (unsigned) (bin + l);
1665
1666         timer_wait (1);
1667
1668         /* well, set argument for out app */
1669         proc_arg_set (proc, arg+file_len+1, arg_len-file_len-1);
1670
1671         proc_vmem_map (proc);
1672
1673         timer_wait (1);
1674
1675         /* Is this process started as daemon ? */
1676         /* wait here, until pid != 0*/
1677         if (!(proc->flags & PROC_FLAG_DAEMON))
1678                 while (proc->pid)
1679                         schedule ();
1680
1681         timer_wait (1);
1682
1683         /* enable interrupts */
1684         int_enable ();
1685
1686         /* unlock tty console - user can write in */
1687         tty_unlock (proc->tty);
1688
1689         _curr_task = proc->tty->task;   // this is pretty needed for correct return to our tty task
1690
1691         if (!(proc->flags & PROC_FLAG_DAEMON)) {
1692                 if (!proc_done (proc))
1693                         while (1)       // NOTE: heh, this is good stuff :P
1694                                 schedule ();
1695
1696                 /* free image of app */
1697                 swfree (bin, l);
1698         }
1699
1700         /* switch to next task */
1701         schedule ();
1702
1703         sclose (ret);
1704
1705         return 1;
1706 }
1707
1708 unsigned command_netcp (char *command, unsigned len)
1709 {
1710         strcpy (cmd_buf, argparse (command));
1711
1712         if (!cmd_buf)
1713                 return 0;
1714
1715         if (!strlen (cmd_buf)) {
1716                 printf ("Syntax:\nnetcp <ip_of_tftp> <tftp_file> <output_file>\n");
1717                 return 0;
1718         }
1719
1720         unsigned arg_len = strlen (argparse (cmd_buf));
1721         char arg[arg_len+1];
1722         strcpy (arg, argparse (cmd_buf));
1723         arg[arg_len] = '\0';
1724
1725         unsigned cmd_buf_len = strlen (cmd_buf);
1726         cmd_buf [cmd_buf_len-arg_len] = '\0';
1727
1728         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1729                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1730                 cmd_buf_len --;
1731         }
1732
1733         char file[arg_len+1];
1734         unsigned file_len = 0;
1735         memcpy (file, arg, arg_len);
1736         while (file_len < arg_len) {
1737                 if (file[file_len] == ' ') {
1738                         file[file_len] = '\0';
1739                         break;
1740                 }
1741                 file_len ++;
1742         }
1743
1744         if (file[arg_len] != '\0')
1745                 file[arg_len] = '\0';
1746
1747         unsigned l = file_len;
1748
1749         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1750
1751         if (!ret) {
1752                 printf ("tftp -> something go wrong !\n");
1753                 return 0;
1754         }
1755
1756         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1757
1758         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1759
1760         if (!bin)
1761                 return 0;
1762
1763         int ret2 = tftp_client_read (ret, bin, l);
1764
1765         if (!ret2) {
1766                 printf ("tftp -> tftp_client_read () error\n");
1767                 swfree (bin, l);
1768                 return 0;
1769         }
1770
1771         sclose (ret);
1772
1773         char *output = argparse (arg);
1774
1775         if (!output) {
1776                 swfree (bin, l);
1777                 printf ("ERROR -> output file name is empty\n");
1778                 return 0;
1779         }
1780
1781         int fd = open (output, O_WRONLY | O_CREAT);
1782
1783         if (!fd) {
1784                 swfree (bin, l);
1785                 printf ("ERROR -> something go wrong with %s\n", output);
1786                 return 0;
1787         }
1788
1789         ret = write (fd, bin, l);
1790
1791         if (!ret) {
1792                 swfree (bin, l);
1793                 printf ("ERROR -> File '%s' could'nt be writed\n", output);
1794         }
1795
1796         return 1;
1797 }
1798
1799
1800 unsigned command_znfscl (char *command, unsigned len)
1801 {
1802 #ifdef ARCH_i386
1803         strcpy (cmd_buf, argparse (command));
1804
1805         if (!strlen (cmd_buf)) {
1806                 printf ("Syntax:\nznfscl <ip_of_znfs>\n");
1807                 return 0;
1808         }
1809
1810         dev_t *dev = dev_find ("/dev/vbd");
1811
1812         if (dev) {
1813                 printf ("znfscl: You are already connected to znfs server\n");
1814                 return 0;
1815         }
1816
1817         dev = (dev_t *) dev_register ("vbd", "Virtual Block Device", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
1818
1819         if (!dev)
1820                 return 0;
1821
1822         partition_t *p = partition_add (dev, fs_supported ("znfs"), 0);
1823
1824         if (!p)
1825                 return 0;
1826
1827         /* connect to specified address */
1828         if (znfs_init (p, cmd_buf) != 1) {
1829                 printf ("znfs: Wrong znfs server\n");
1830                 return 0;
1831         }
1832
1833         char str[16];
1834
1835         sprintf (str, "/mnt/%s", p->name+5);
1836
1837         mkdir (str);
1838
1839         mount (p, "", str);
1840
1841         printf ("znfs: You are succefully connected to ZNFS server '%s'\nZNFS was mounted into '%s'\n", cmd_buf, str);
1842 #else
1843         printf ("ERROR -> this architecture is not supported yet\n");
1844 #endif
1845         return 1;
1846 }
1847
1848 void task_savemode ()
1849 {
1850         /* disable cpu for cycle */
1851         for (;; schedule ())
1852                 arch_cpu_hlt ();
1853 }
1854
1855 unsigned command_savemode (char *command, unsigned len)
1856 {
1857         task_t *task = (task_t *) task_create ("savemode", (unsigned) &task_savemode, 16);
1858
1859         if (!task) {
1860                 printf ("ERROR -> Save mode thread was'nt created\n");
1861                 return 0;
1862         }
1863
1864         printf ("Save mode was succefully started\n");
1865
1866         return 1;
1867 }
1868
1869 unsigned command_cpuinfo (char *command, unsigned len)
1870 {
1871         printf ("Processor info:\n");
1872
1873         cat ("/proc/cpuinfo");
1874
1875         return 1;
1876 }
1877
1878 unsigned command_adm (char *command, unsigned len)
1879 {
1880         printf ("Automatic Device Mounter - init ()\n");
1881
1882         init_adm ();
1883
1884         return 1;
1885 }
1886
1887 unsigned command_ttyctrl (char *command, unsigned len)
1888 {
1889         char *parm = argparse (command);
1890
1891         if (!strlen (parm)) {
1892                 printf ("ttyctrl <operation> [parameter]\n\toperations: add; list; change <ttyid>\n");
1893                 return 0;
1894         }
1895
1896         if (!strncmp (parm, "add", 3)) {
1897                 tty_t *tty = tty_create ();
1898
1899                 if (!tty)
1900                         return 0;
1901
1902                 video_color (7, 0);
1903
1904                 tty_write (tty, "\nlogin: ", 8);
1905
1906                 printf ("New tty '%s' was created\n", tty->name);
1907         } else
1908         if (!strncmp (parm, "list", 4)) {
1909                 tty_listview ();
1910         } else
1911         if (!strncmp (parm, "change", 6)) {
1912                 tty_t *tty = tty_find ((char *) argparse (parm));
1913
1914                 if (!tty)
1915                         return 0;
1916
1917                 tty_change (tty);
1918
1919                 printf ("\n");
1920         }
1921
1922         return 1;
1923 }
1924
1925 unsigned command_cmd (char *command, unsigned len)
1926 {
1927         unsigned s = 0;
1928         unsigned e = 0;
1929
1930         if (!strlen (argparse (command))) {
1931                 printf ("cmd <command1>;<command2>;...;\n");
1932                 return 0;
1933         }
1934
1935         char *cmds = kmalloc (len - 3);
1936
1937         if (!cmds)
1938                 return 0;
1939
1940         memcpy (cmds, command + 4, len - 4);
1941         cmds[len - 4] = '\0';
1942
1943         unsigned i;
1944         for (i = 1; i < len - 4; i ++) {
1945                 if (cmds[i] == ';') {
1946                         cmds[i] = '\0';
1947                         e = i-1;
1948
1949                         command_parser (cmds+s, e-s+1);
1950
1951                         s = i+1;
1952                 }
1953         }
1954
1955         kfree (cmds);
1956
1957         return 1;
1958 }
1959
1960 /*************************************************************\
1961 |                       COMMAND's UTILS                       |
1962 \*************************************************************/
1963
1964 unsigned command_parser (char *command, unsigned len)
1965 {
1966         /* find first non-space in command */
1967         int i = 0;
1968         for (i = 0; i < len; i ++) {
1969                 if (command[i] != ' ')
1970                         break;
1971         }
1972         command_t *ctx;
1973
1974         /* try to find the command */
1975         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
1976                 if (!cstrcmp (ctx->name, command+i)) {
1977                         ctx->handler (command+i, len-i);        /* execute context function */
1978                         return 1;
1979                 }
1980         }
1981
1982         printf ("%s: command not found\n", command);
1983
1984         return 0;
1985 }
1986
1987 void commands (int i)
1988 {
1989         // currtty->shell_len has been set to zero already
1990         command_parser (currtty->shell, strlen(currtty->shell));
1991 }
1992
1993 unsigned command_register (char *name, char *desc, command_handler_t *handler, unsigned flags)
1994 {
1995         command_t *c;
1996         /* we dont want commands with same name */
1997         for (c = command_list.next; c != &command_list; c = c->next)
1998                 if (!strcmp(c->name, name))
1999                         return 0;
2000
2001         command_t *ctx;
2002
2003         // alloc and init context
2004         ctx = (command_t *) kmalloc (sizeof (command_t));
2005
2006         if (!ctx)
2007                 return 0;
2008
2009         unsigned name_len = strlen (name);
2010         ctx->name = (char *) kmalloc (sizeof (char) * name_len +1);
2011
2012         if (!ctx->name)
2013                 return 0;
2014
2015         memcpy (ctx->name, name, name_len);
2016         ctx->name[name_len] = '\0';
2017
2018         unsigned desc_len = strlen (desc);
2019         ctx->desc = (char *) kmalloc (sizeof (char) * desc_len +1);
2020
2021         if (!ctx->desc)
2022                 return 0;
2023
2024         memcpy (ctx->desc, desc, desc_len);
2025         ctx->desc[desc_len] = '\0';
2026
2027         ctx->handler = handler;
2028         ctx->flags = flags;
2029
2030         ctx->next = &command_list;
2031         ctx->prev = command_list.prev;
2032         ctx->prev->next = ctx;
2033         ctx->next->prev = ctx;
2034
2035         return 1;
2036 }
2037
2038 unsigned command_unregister (char *name)
2039 {
2040         command_t *ctx;
2041
2042         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
2043                 if (!strcmp(ctx->name, name)) {
2044                         ctx->next->prev = ctx->prev;
2045                         ctx->prev->next = ctx->next;
2046
2047                         return 1;
2048                 }
2049         }
2050
2051         return 0;
2052 }
2053
2054 /*************************************************************\
2055 |                 INITIALIZATION OF COMMANDS                  |
2056 \*************************************************************/
2057
2058 unsigned int init_commands ()
2059 {
2060         command_list.next = &command_list;
2061         command_list.prev = &command_list;
2062
2063         // reg commands
2064         command_register ("help", "Displays list of available commands", &command_help, 0);
2065         command_register ("hdd", "Detect HDD", &command_hdd, 0);
2066         command_register ("reboot", "Reboot computer", &command_reboot, 0);
2067         command_register ("halt", "Shutdown computer", &command_halt, 0);
2068         command_register ("tasks", "Print all tasks", &command_tasks, 0);
2069         command_register ("ps", "Print all process", &command_ps, 0);
2070         command_register ("uptime", "Print uptime in seconds", &command_uptime, 0);
2071         command_register ("version", "Displays a version of system", &command_version, 0);
2072         command_register ("debug", "Change to developer mode", &command_debug, 0);
2073         command_register ("mount", "Mount device to selected directory", &command_mount, 0);
2074         command_register ("umount", "Unmount mounted directory", &command_umount, 0);
2075         command_register ("env", "Displays all env variables", &command_env, 0);
2076         command_register ("cd", "Change directory", &command_cd, 0);
2077         command_register ("ls", " Displays files in current directory", &command_ls, 0);
2078         command_register ("cat", "Displays text in selected file", &command_cat, 0);
2079         command_register ("cp", "Copy a file", &command_cp, 0);
2080         command_register ("rm", "Remove a file", &command_rm, 0);
2081         command_register ("mkdir", "Create a directory", &command_mkdir, 0);
2082         command_register ("touch", "Create a file", &command_touch, 0);
2083         command_register ("exec", "Execute a selected program", &command_exec, 0);
2084         command_register ("lsdev", "Displays found devices", &command_lsdev, 0);
2085         command_register ("login", "Login as another user", &command_login, 0);
2086         command_register ("fdisk", "Partition table manipulator", &command_fdisk, 0);
2087         command_register ("hdcat", "Read selected block of data from drive", &command_hdcat, 0);
2088         command_register ("free", "Display amount of free and used memory", &command_free, 0);
2089         command_register ("top", "Stats of cpu usage", &command_top, 0);
2090         command_register ("date", "Show current date and time", &command_date, 0);
2091         command_register ("xmastime", "play noels on pc-speaker", &command_spk, 0);
2092         command_register ("test", "Some test", &command_test, 0);
2093         command_register ("test2", "Some test", &command_test2, 0);
2094         command_register ("test3", "Some test", &command_test3, 0);
2095         //command_register ("testd", "Some test", &command_test4, 0);
2096         //command_register ("vesa", "Some test", &command_vesa, 0);
2097         command_register ("kill", "Send a signal to process", &command_kill, 0);
2098         command_register ("modprobe", "program to add modules from the kernel", &command_modprobe, 0);
2099         command_register ("lsmod", "program to show the status of modules", &command_lsmod, 0);
2100 #ifdef CONFIG_DRV_PCI
2101         command_register ("lspci", "list all pci devices", &command_lspci, 0);
2102 #endif
2103         command_register ("mouse", "ps2 mouse test", &command_mouse, 0);
2104         command_register ("iflist", "Show network interface", &command_iflist, 0);
2105         command_register ("ifconfig", "Configure network interface", &command_ifconfig, 0);
2106         command_register ("ifroute", "Configure gateway address", &command_ifroute, 0);
2107         command_register ("dnsconfig", "Configure domain name server address", &command_dnsconfig, 0);
2108 #ifdef CONFIG_PROTO_TUN6
2109         command_register ("tunconfig", "Configure IPv6 tunnel server address", &command_tunconfig, 0);
2110 #endif
2111         command_register ("hostname", "Configure network hostname", &command_hostname, 0);
2112         command_register ("kbdmap", "Change keyboard layout", &command_kbdmap, 0);
2113 #ifdef CONFIG_DRV_ZEXFS
2114         command_register ("mkzexfs", "Create zexfs filesystem on hdd", &command_mkzexfs, 0);
2115 #endif
2116 #ifdef CONFIG_DRV_EXT2
2117         command_register ("mkext2", "Create ext2 filesystem on hdd", &command_mkext2, 0);
2118 #endif
2119 #ifdef CONFIG_PROTO_IPV4
2120         command_register ("ping", "Send ICMP echo request", &command_ping, 0);
2121 #endif
2122 #ifdef CONFIG_PROTO_IPV6
2123         command_register ("ping6", "Send ICMPv6 echo request", &command_ping6, 0);
2124 #endif
2125         command_register ("netexec", "Execute file from network", &command_netexec, 0);
2126         command_register ("netcp", "Copy file from network to filesystem", &command_netcp, 0);
2127 #ifdef CONFIG_DRV_ZNFS
2128         command_register ("znfscl", "Connect to znfs server - network filesystem", &command_znfscl, 0);
2129 #endif
2130         command_register ("savemode", "Make less cpu load", &command_savemode, 0);
2131         command_register ("cpuinfo", "Show CPU info", &command_cpuinfo, 0);
2132
2133         command_register ("adm", "Automatic Device Mounter", &command_adm, 0);
2134         command_register ("ttyctrl", "TTY Console control", &command_ttyctrl, 0);
2135         command_register ("cmd", "Execute command sequence", &command_cmd, 0);
2136
2137         return 1;
2138 }