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_dhcpcl (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 ("dhcpcl -> please specify interface\n");
1278                 return 0;
1279         }
1280
1281         netif_t *netif = netif_findbyname (cmd_buf);
1282
1283         if (!netif) {
1284                 printf ("dhcpcl -> bad network interface name, example: eth0\n");
1285                 return 0;
1286         }
1287
1288         unsigned ret = dhcp_config_if (netif);
1289
1290         if (ret < 0) {
1291                 switch (ret) {
1292                         case DHCP_OUT_OF_MEMORY:
1293                                 printf ("dhcpcl -> out of memory\n");
1294                                 break;
1295                         case DHCP_SOCKET_FAILED:
1296                         case DHCP_CONNECT_FAILED:
1297                         case DHCP_CANT_SEND_REQUEST:
1298                                 printf ("dhcpcl -> problem with network layer\n");
1299                                 break;
1300                         case DHCP_CANT_RECV_RESPONSE:
1301                                 printf ("dhcpcl -> can't receive response\n");
1302                                 break;
1303                         case DHCP_BAD_PACKET:
1304                                 printf ("dhcpcl -> bad packet received\n");
1305                                 break;
1306                         case DHCP_SRV_DIDNT_UNDERSTAND:
1307                                 printf ("dhcpcl -> server didn't understand\n");
1308                                 break;
1309                 }
1310         } else {
1311                 printf ("dhcpcl -> interface %s successfully configured\n", cmd_buf);
1312         }
1313 }
1314
1315 unsigned command_tunconfig (char *command, unsigned len)
1316 {
1317         strcpy (cmd_buf, argparse (currtty->shell));
1318
1319         if (!cmd_buf)
1320                 return 0;
1321
1322         unsigned l = strlen (cmd_buf);
1323
1324         if (!l) {
1325                 printf ("tunconfig -> wrong syntax !\ntunconfig <ipv4tunnel> for enable or tunconfig 0 for disable\n");
1326
1327                 return 0;
1328         }
1329
1330         /* you can disable this service over character '0' as parameter */
1331         if (l == 1 && cmd_buf[0] == '0') {
1332                 tun6_addr (0);
1333
1334                 printf ("tunconfig: disabled - OK\n");
1335
1336                 return 1;
1337         }
1338
1339         /* classical ipv4 address from tunnel server */
1340         net_ipv4 tunnel = net_proto_ip_convert (cmd_buf);
1341
1342         if (!tunnel) {
1343                 printf ("tunconfig -> wrong syntax !\nExample: tunconfig 216.66.80.30\n");
1344
1345                 return 0;
1346         }
1347
1348         tun6_addr (tunnel);
1349
1350         printf ("tunconfig: ::%s - OK\n", cmd_buf);
1351
1352         return 1;
1353 }
1354
1355
1356 unsigned command_hostname (char *command, unsigned len)
1357 {
1358         strcpy (cmd_buf, argparse (currtty->shell));
1359
1360         if (!cmd_buf)
1361                 return 0;
1362
1363         unsigned l = strlen (cmd_buf);
1364
1365         if (!l) {
1366                 printf ("%s\n", hostname_get ());
1367
1368                 return 0;
1369         }
1370
1371         printf ("hostname: %s - OK\n", cmd_buf);
1372
1373         hostname_set (cmd_buf);
1374
1375         return 1;
1376 }
1377
1378 unsigned command_kbdmap (char *command, unsigned len)
1379 {
1380         strcpy (cmd_buf, argparse (currtty->shell));
1381
1382         if (!cmd_buf)
1383                 return 0;
1384
1385         unsigned ret = keyboard_setlayout (cmd_buf);
1386
1387         if (ret)
1388                 printf ("Keyboard layout was changed to '%s'\n", cmd_buf);
1389
1390         return ret;
1391 }
1392
1393 unsigned command_mkzexfs (char *command, unsigned len)
1394 {
1395 #ifdef ARCH_i386
1396         strcpy (cmd_buf, argparse (currtty->shell));
1397
1398         partition_t *p = partition_find (cmd_buf);
1399
1400         if (!p)
1401                 return 0;
1402
1403         mkzexfs (p);
1404 #endif
1405         return 1;
1406 }
1407
1408 unsigned command_mkext2 (char *command, unsigned len)
1409 {
1410 #ifdef ARCH_i386
1411         strcpy (cmd_buf, argparse (currtty->shell));
1412
1413         if (!cmd_buf)
1414                 return 0;
1415
1416         partition_t *p = partition_find ("/dev/hda0");
1417
1418         mkext2 (p);
1419 #endif
1420         return 1;
1421 }
1422
1423 unsigned command_ping (char *command, unsigned len)
1424 {
1425
1426         strcpy (cmd_buf, argparse (currtty->shell));
1427
1428         if (!cmd_buf)
1429                 return 0;
1430
1431         netif_t *netif = netif_findbyname ("eth0");
1432
1433         if (!netif) {
1434                 printf ("ping -> network interface does not exists\n");
1435                 return 0;
1436         }
1437
1438         unsigned char a;
1439         unsigned char b;
1440         unsigned char c;
1441         unsigned char d;
1442
1443         unsigned g = 0;
1444         unsigned i = 0;
1445         unsigned y = strlen (cmd_buf);
1446
1447         if (!y) {
1448                 printf ("ping -> wrong syntax, please specify address\n");
1449                 return 0;
1450         }
1451
1452         unsigned h[4];
1453
1454         while (i < y) {
1455                 if (cmd_buf[i] == '.') {
1456                         cmd_buf[i] = '\0';
1457                         h[g] = i+1;
1458                         g ++;
1459                 }
1460
1461                 i ++;
1462         }
1463
1464         net_ipv4 target = 0;
1465
1466         if (g != 3) {
1467                 strcpy (cmd_buf, argparse (currtty->shell));
1468
1469                 if (dns_cache_get (cmd_buf, &target, 4) != 1)
1470                         if (dns_send_request (cmd_buf, &target, 4) != 1) {
1471                                 printf ("ping -> bad hostname or ip address format, example: 192.168.1.1\n");
1472                                 return 0;
1473                         }
1474         } else {
1475                 a = atoi (cmd_buf);
1476                 b = atoi (cmd_buf+h[0]);
1477                 c = atoi (cmd_buf+h[1]);
1478                 d = atoi (cmd_buf+h[2]);
1479
1480                 target = NET_IPV4_TO_ADDR (a, b, c, d);
1481
1482                 strcpy (cmd_buf, argparse (currtty->shell));
1483         }
1484
1485         char address[20];
1486         net_proto_ip_convert2 (target, address);
1487
1488         i = 0;
1489
1490         while (i < 8) {
1491                 unsigned long time_a = timer_ticks;
1492                 unsigned ret = net_proto_icmp_ping (netif, target);
1493                 if (ret) {
1494                         printf ("ping -> %s (%s) - %ums\n", cmd_buf, address, (timer_ticks - time_a));
1495                 } else {
1496                         printf ("ping -> Host %s is unreachable\n", cmd_buf);
1497                         break;
1498                 }
1499
1500                 i ++;
1501         }
1502
1503         return 1;
1504 }
1505
1506 unsigned command_ping6 (char *command, unsigned len)
1507 {
1508         strcpy (cmd_buf, argparse (currtty->shell));
1509
1510         if (!cmd_buf)
1511                 return 0;
1512
1513         netif_t *netif = netif_findbyname ("eth0");
1514
1515         if (!netif) {
1516                 printf ("ping6 -> network interface does not exists\n");
1517                 return 0;
1518         }
1519
1520         unsigned short a;
1521         unsigned short b;
1522         unsigned short c;
1523         unsigned short d;
1524         unsigned short e;
1525         unsigned short f;
1526         unsigned short g;
1527         unsigned short h;
1528
1529         unsigned j = 0;
1530         unsigned i = 0;
1531         unsigned y = strlen (cmd_buf);
1532
1533         if (!y) {
1534                 printf ("ping6 -> wrong syntax, please specify ipv6 address\n");
1535                 return 0;
1536         }
1537
1538         unsigned k[8];
1539
1540         while (i < y) {
1541                 if (cmd_buf[i] == ':') {
1542                         cmd_buf[i] = '\0';
1543                         k[j] = i+1;
1544                         j ++;
1545                 }
1546
1547                 i ++;
1548         }
1549
1550         net_ipv6 target;
1551
1552         if (j != 7) {
1553                 strcpy (cmd_buf, argparse (currtty->shell));
1554
1555                 if (dns_cache_get (cmd_buf, &target, 16) != 1)
1556                         if (dns_send_request (cmd_buf, &target, 16) != 1) {
1557                                 printf ("ping6 -> bad hostname or ip address format, example: 2001:4d3:8fe:2:0:0:0:1\n");
1558                                 return 0;
1559                         }
1560         } else {
1561                 char *endptr;
1562
1563                 a = strtol (cmd_buf, &endptr, 16);
1564                 b = strtol (cmd_buf+k[0], &endptr, 16);
1565                 c = strtol (cmd_buf+k[1], &endptr, 16);
1566                 d = strtol (cmd_buf+k[2], &endptr, 16);
1567                 e = strtol (cmd_buf+k[3], &endptr, 16);
1568                 f = strtol (cmd_buf+k[4], &endptr, 16);
1569                 g = strtol (cmd_buf+k[5], &endptr, 16);
1570                 h = strtol (cmd_buf+k[6], &endptr, 16);
1571
1572                 NET_IPV6_TO_ADDR (target, a, b, c, d, e, f, g, h);
1573
1574                 //printf ("ipv6: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", a, b, c, d, e, f, g, h);
1575
1576                 strcpy (cmd_buf, argparse (currtty->shell));
1577         }
1578
1579         char address[40];
1580         //net_proto_ipv6_convert2 (target, address);
1581
1582         i = 0;
1583
1584         while (i < 8) {
1585                 unsigned long time_a = timer_ticks;
1586                 unsigned ret = net_proto_icmp6_ping (netif, target);
1587                 if (ret) {
1588                         printf ("ping6 -> %s (%s) - %ums\n", cmd_buf, cmd_buf, (timer_ticks - time_a));
1589                 } else {
1590                         printf ("ping6 -> Host %s is unreachable\n", cmd_buf);
1591                         break;
1592                 }
1593
1594                 i ++;
1595         }
1596
1597         return 1;
1598 }
1599
1600 unsigned command_netexec (char *command, unsigned len)
1601 {
1602         strcpy (cmd_buf, argparse (command));
1603
1604         if (!cmd_buf)
1605                 return 0;
1606
1607         if (!strlen (cmd_buf)) {
1608                 printf ("Syntax:\nnetexec <ip_of_tftp> <filename> [parameters]\n");
1609                 return 0;
1610         }
1611
1612         unsigned arg_len = strlen (argparse (cmd_buf));
1613         char arg[arg_len+1];
1614         strcpy (arg, argparse (cmd_buf));
1615         arg[arg_len] = '\0';
1616
1617         unsigned cmd_buf_len = strlen (cmd_buf);
1618         cmd_buf [cmd_buf_len-arg_len] = '\0';
1619
1620         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1621                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1622                 cmd_buf_len --;
1623         }
1624
1625         char file[arg_len+1];
1626         unsigned file_len = 0;
1627         memcpy (file, arg, arg_len);
1628         while (file_len < arg_len) {
1629                 if (file[file_len] == ' ') {
1630                         file[file_len] = '\0';
1631                         break;
1632                 }
1633                 file_len ++;
1634         }
1635
1636         if (file[arg_len] != '\0')
1637                 file[arg_len] = '\0';
1638
1639         unsigned l = file_len;
1640
1641         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1642
1643         if (!ret) {
1644                 printf ("tftp -> something go wrong !\n");
1645                 return 0;
1646         }
1647
1648         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1649
1650         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1651
1652         if (!bin)
1653                 return 0;
1654
1655         int ret2 = tftp_client_read (ret, bin, l);
1656
1657         if (!ret2) {
1658                 printf ("tftp -> tftp_client_read () error\n");
1659                 swfree (bin, l);
1660                 return 0;
1661         }
1662
1663         unsigned entry, code, data, data_off, bss;
1664         int err = exec_elf (bin, &entry, &data, &data_off, &bss);
1665
1666         if (err != NULL) {
1667                 printf ("ERROR -> invalid ELF exec\n");
1668                 return 0;
1669         }
1670
1671         tty_lock (currtty);
1672         timer_wait (1);
1673         /* create process */
1674         proc_t *proc = proc_create (currtty, "netexec", entry);
1675         timer_wait (1);
1676
1677
1678         /* check for & character as app parameter */
1679 /*      unsigned d = 0;
1680         while (d < arg_len) {
1681                 if (arg[d] == '&') {
1682                         if (proc_flag_set (proc, PROC_FLAG_DAEMON))
1683                                 printf ("%s: started as daemon\n", cmd_buf);
1684
1685                         arg[d] = '\0';
1686
1687                         if (arg_len > 2 && arg[d-1] == ' ') {
1688                                 arg[d-1] = '\0';
1689                                 arg_len --;
1690                         }
1691
1692                         arg_len --;
1693
1694                         break;
1695                 }
1696                 d ++;
1697         }*/
1698
1699         if (!proc) {
1700                 printf ("ERROR -> Invalid process: %s\n", cmd_buf);
1701                 return 0;
1702         }
1703
1704         timer_wait (1);
1705
1706         /* save process information to structure for later use */
1707         proc->start = (unsigned) bin;
1708         proc->code = entry;
1709         proc->data = data;
1710         proc->data_off = data_off;
1711         proc->bss = bss;
1712         proc->end = (unsigned) (bin + l);
1713
1714         timer_wait (1);
1715
1716         /* well, set argument for out app */
1717         proc_arg_set (proc, arg+file_len+1, arg_len-file_len-1);
1718
1719         proc_vmem_map (proc);
1720
1721         timer_wait (1);
1722
1723         /* Is this process started as daemon ? */
1724         /* wait here, until pid != 0*/
1725         if (!(proc->flags & PROC_FLAG_DAEMON))
1726                 while (proc->pid)
1727                         schedule ();
1728
1729         timer_wait (1);
1730
1731         /* enable interrupts */
1732         int_enable ();
1733
1734         /* unlock tty console - user can write in */
1735         tty_unlock (proc->tty);
1736
1737         _curr_task = proc->tty->task;   // this is pretty needed for correct return to our tty task
1738
1739         if (!(proc->flags & PROC_FLAG_DAEMON)) {
1740                 if (!proc_done (proc))
1741                         while (1)       // NOTE: heh, this is good stuff :P
1742                                 schedule ();
1743
1744                 /* free image of app */
1745                 swfree (bin, l);
1746         }
1747
1748         /* switch to next task */
1749         schedule ();
1750
1751         sclose (ret);
1752
1753         return 1;
1754 }
1755
1756 unsigned command_netcp (char *command, unsigned len)
1757 {
1758         strcpy (cmd_buf, argparse (command));
1759
1760         if (!cmd_buf)
1761                 return 0;
1762
1763         if (!strlen (cmd_buf)) {
1764                 printf ("Syntax:\nnetcp <ip_of_tftp> <tftp_file> <output_file>\n");
1765                 return 0;
1766         }
1767
1768         unsigned arg_len = strlen (argparse (cmd_buf));
1769         char arg[arg_len+1];
1770         strcpy (arg, argparse (cmd_buf));
1771         arg[arg_len] = '\0';
1772
1773         unsigned cmd_buf_len = strlen (cmd_buf);
1774         cmd_buf [cmd_buf_len-arg_len] = '\0';
1775
1776         if (cmd_buf[cmd_buf_len-arg_len-1] == ' ') {
1777                 cmd_buf[cmd_buf_len-arg_len-1] = '\0';
1778                 cmd_buf_len --;
1779         }
1780
1781         char file[arg_len+1];
1782         unsigned file_len = 0;
1783         memcpy (file, arg, arg_len);
1784         while (file_len < arg_len) {
1785                 if (file[file_len] == ' ') {
1786                         file[file_len] = '\0';
1787                         break;
1788                 }
1789                 file_len ++;
1790         }
1791
1792         if (file[arg_len] != '\0')
1793                 file[arg_len] = '\0';
1794
1795         unsigned l = file_len;
1796
1797         unsigned ret = tftp_client_connect (cmd_buf, 69, file, &l);
1798
1799         if (!ret) {
1800                 printf ("tftp -> something go wrong !\n");
1801                 return 0;
1802         }
1803
1804         printf ("tftp -> file length: %ubytes\t\t[OK]\n", l);
1805
1806         char *bin = (unsigned char *) swmalloc (sizeof (char) * (l+1));
1807
1808         if (!bin)
1809                 return 0;
1810
1811         int ret2 = tftp_client_read (ret, bin, l);
1812
1813         if (!ret2) {
1814                 printf ("tftp -> tftp_client_read () error\n");
1815                 swfree (bin, l);
1816                 return 0;
1817         }
1818
1819         sclose (ret);
1820
1821         char *output = argparse (arg);
1822
1823         if (!output) {
1824                 swfree (bin, l);
1825                 printf ("ERROR -> output file name is empty\n");
1826                 return 0;
1827         }
1828
1829         int fd = open (output, O_WRONLY | O_CREAT);
1830
1831         if (!fd) {
1832                 swfree (bin, l);
1833                 printf ("ERROR -> something go wrong with %s\n", output);
1834                 return 0;
1835         }
1836
1837         ret = write (fd, bin, l);
1838
1839         if (!ret) {
1840                 swfree (bin, l);
1841                 printf ("ERROR -> File '%s' could'nt be writed\n", output);
1842         }
1843
1844         return 1;
1845 }
1846
1847
1848 unsigned command_znfscl (char *command, unsigned len)
1849 {
1850 #ifdef ARCH_i386
1851         strcpy (cmd_buf, argparse (command));
1852
1853         if (!strlen (cmd_buf)) {
1854                 printf ("Syntax:\nznfscl <ip_of_znfs>\n");
1855                 return 0;
1856         }
1857
1858         dev_t *dev = dev_find ("/dev/vbd");
1859
1860         if (dev) {
1861                 printf ("znfscl: You are already connected to znfs server\n");
1862                 return 0;
1863         }
1864
1865         dev = (dev_t *) dev_register ("vbd", "Virtual Block Device", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
1866
1867         if (!dev)
1868                 return 0;
1869
1870         partition_t *p = partition_add (dev, fs_supported ("znfs"), 0);
1871
1872         if (!p)
1873                 return 0;
1874
1875         /* connect to specified address */
1876         if (znfs_init (p, cmd_buf) != 1) {
1877                 printf ("znfs: Wrong znfs server\n");
1878                 return 0;
1879         }
1880
1881         char str[16];
1882
1883         sprintf (str, "/mnt/%s", p->name+5);
1884
1885         mkdir (str);
1886
1887         mount (p, "", str);
1888
1889         printf ("znfs: You are succefully connected to ZNFS server '%s'\nZNFS was mounted into '%s'\n", cmd_buf, str);
1890 #else
1891         printf ("ERROR -> this architecture is not supported yet\n");
1892 #endif
1893         return 1;
1894 }
1895
1896 void task_savemode ()
1897 {
1898         /* disable cpu for cycle */
1899         for (;; schedule ())
1900                 arch_cpu_hlt ();
1901 }
1902
1903 unsigned command_savemode (char *command, unsigned len)
1904 {
1905         task_t *task = (task_t *) task_create ("savemode", (unsigned) &task_savemode, 16);
1906
1907         if (!task) {
1908                 printf ("ERROR -> Save mode thread was'nt created\n");
1909                 return 0;
1910         }
1911
1912         printf ("Save mode was succefully started\n");
1913
1914         return 1;
1915 }
1916
1917 unsigned command_cpuinfo (char *command, unsigned len)
1918 {
1919         printf ("Processor info:\n");
1920
1921         cat ("/proc/cpuinfo");
1922
1923         return 1;
1924 }
1925
1926 unsigned command_adm (char *command, unsigned len)
1927 {
1928         printf ("Automatic Device Mounter - init ()\n");
1929
1930         init_adm ();
1931
1932         return 1;
1933 }
1934
1935 unsigned command_ttyctrl (char *command, unsigned len)
1936 {
1937         char *parm = argparse (command);
1938
1939         if (!strlen (parm)) {
1940                 printf ("ttyctrl <operation> [parameter]\n\toperations: add; list; change <ttyid>\n");
1941                 return 0;
1942         }
1943
1944         if (!strncmp (parm, "add", 3)) {
1945                 tty_t *tty = tty_create ();
1946
1947                 if (!tty)
1948                         return 0;
1949
1950                 video_color (7, 0);
1951
1952                 tty_write (tty, "\nlogin: ", 8);
1953
1954                 printf ("New tty '%s' was created\n", tty->name);
1955         } else
1956         if (!strncmp (parm, "list", 4)) {
1957                 tty_listview ();
1958         } else
1959         if (!strncmp (parm, "change", 6)) {
1960                 tty_t *tty = tty_find ((char *) argparse (parm));
1961
1962                 if (!tty)
1963                         return 0;
1964
1965                 tty_change (tty);
1966
1967                 printf ("\n");
1968         }
1969
1970         return 1;
1971 }
1972
1973 unsigned command_cmd (char *command, unsigned len)
1974 {
1975         unsigned s = 0;
1976         unsigned e = 0;
1977
1978         if (!strlen (argparse (command))) {
1979                 printf ("cmd <command1>;<command2>;...;\n");
1980                 return 0;
1981         }
1982
1983         char *cmds = kmalloc (len - 3);
1984
1985         if (!cmds)
1986                 return 0;
1987
1988         memcpy (cmds, command + 4, len - 4);
1989         cmds[len - 4] = '\0';
1990
1991         unsigned i;
1992         for (i = 1; i < len - 4; i ++) {
1993                 if (cmds[i] == ';') {
1994                         cmds[i] = '\0';
1995                         e = i-1;
1996
1997                         command_parser (cmds+s, e-s+1);
1998
1999                         s = i+1;
2000                 }
2001         }
2002
2003         kfree (cmds);
2004
2005         return 1;
2006 }
2007
2008 /*************************************************************\
2009 |                       COMMAND's UTILS                       |
2010 \*************************************************************/
2011
2012 unsigned command_parser (char *command, unsigned len)
2013 {
2014         /* find first non-space in command */
2015         int i = 0;
2016         for (i = 0; i < len; i ++) {
2017                 if (command[i] != ' ')
2018                         break;
2019         }
2020         command_t *ctx;
2021
2022         /* try to find the command */
2023         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
2024                 if (!cstrcmp (ctx->name, command+i)) {
2025                         ctx->handler (command+i, len-i);        /* execute context function */
2026                         return 1;
2027                 }
2028         }
2029
2030         printf ("%s: command not found\n", command);
2031
2032         return 0;
2033 }
2034
2035 void commands (int i)
2036 {
2037         // currtty->shell_len has been set to zero already
2038         command_parser (currtty->shell, strlen(currtty->shell));
2039 }
2040
2041 unsigned command_register (char *name, char *desc, command_handler_t *handler, unsigned flags)
2042 {
2043         command_t *c;
2044         /* we dont want commands with same name */
2045         for (c = command_list.next; c != &command_list; c = c->next)
2046                 if (!strcmp(c->name, name))
2047                         return 0;
2048
2049         command_t *ctx;
2050
2051         // alloc and init context
2052         ctx = (command_t *) kmalloc (sizeof (command_t));
2053
2054         if (!ctx)
2055                 return 0;
2056
2057         unsigned name_len = strlen (name);
2058         ctx->name = (char *) kmalloc (sizeof (char) * name_len +1);
2059
2060         if (!ctx->name)
2061                 return 0;
2062
2063         memcpy (ctx->name, name, name_len);
2064         ctx->name[name_len] = '\0';
2065
2066         unsigned desc_len = strlen (desc);
2067         ctx->desc = (char *) kmalloc (sizeof (char) * desc_len +1);
2068
2069         if (!ctx->desc)
2070                 return 0;
2071
2072         memcpy (ctx->desc, desc, desc_len);
2073         ctx->desc[desc_len] = '\0';
2074
2075         ctx->handler = handler;
2076         ctx->flags = flags;
2077
2078         ctx->next = &command_list;
2079         ctx->prev = command_list.prev;
2080         ctx->prev->next = ctx;
2081         ctx->next->prev = ctx;
2082
2083         return 1;
2084 }
2085
2086 unsigned command_unregister (char *name)
2087 {
2088         command_t *ctx;
2089
2090         for (ctx = command_list.next; ctx != &command_list; ctx = ctx->next) {
2091                 if (!strcmp(ctx->name, name)) {
2092                         ctx->next->prev = ctx->prev;
2093                         ctx->prev->next = ctx->next;
2094
2095                         return 1;
2096                 }
2097         }
2098
2099         return 0;
2100 }
2101
2102 /*************************************************************\
2103 |                 INITIALIZATION OF COMMANDS                  |
2104 \*************************************************************/
2105
2106 unsigned int init_commands ()
2107 {
2108         command_list.next = &command_list;
2109         command_list.prev = &command_list;
2110
2111         // reg commands
2112         command_register ("help", "Displays list of available commands", &command_help, 0);
2113         command_register ("hdd", "Detect HDD", &command_hdd, 0);
2114         command_register ("reboot", "Reboot computer", &command_reboot, 0);
2115         command_register ("halt", "Shutdown computer", &command_halt, 0);
2116         command_register ("tasks", "Print all tasks", &command_tasks, 0);
2117         command_register ("ps", "Print all process", &command_ps, 0);
2118         command_register ("uptime", "Print uptime in seconds", &command_uptime, 0);
2119         command_register ("version", "Displays a version of system", &command_version, 0);
2120         command_register ("debug", "Change to developer mode", &command_debug, 0);
2121         command_register ("mount", "Mount device to selected directory", &command_mount, 0);
2122         command_register ("umount", "Unmount mounted directory", &command_umount, 0);
2123         command_register ("env", "Displays all env variables", &command_env, 0);
2124         command_register ("cd", "Change directory", &command_cd, 0);
2125         command_register ("ls", " Displays files in current directory", &command_ls, 0);
2126         command_register ("cat", "Displays text in selected file", &command_cat, 0);
2127         command_register ("cp", "Copy a file", &command_cp, 0);
2128         command_register ("rm", "Remove a file", &command_rm, 0);
2129         command_register ("mkdir", "Create a directory", &command_mkdir, 0);
2130         command_register ("touch", "Create a file", &command_touch, 0);
2131         command_register ("exec", "Execute a selected program", &command_exec, 0);
2132         command_register ("lsdev", "Displays found devices", &command_lsdev, 0);
2133         command_register ("login", "Login as another user", &command_login, 0);
2134         command_register ("fdisk", "Partition table manipulator", &command_fdisk, 0);
2135         command_register ("hdcat", "Read selected block of data from drive", &command_hdcat, 0);
2136         command_register ("free", "Display amount of free and used memory", &command_free, 0);
2137         command_register ("top", "Stats of cpu usage", &command_top, 0);
2138         command_register ("date", "Show current date and time", &command_date, 0);
2139         command_register ("xmastime", "play noels on pc-speaker", &command_spk, 0);
2140         command_register ("test", "Some test", &command_test, 0);
2141         command_register ("test2", "Some test", &command_test2, 0);
2142         //command_register ("test3", "Some test", &command_test3, 0);
2143         //command_register ("testd", "Some test", &command_test4, 0);
2144         //command_register ("vesa", "Some test", &command_vesa, 0);
2145         command_register ("kill", "Send a signal to process", &command_kill, 0);
2146         command_register ("modprobe", "program to add modules from the kernel", &command_modprobe, 0);
2147         command_register ("lsmod", "program to show the status of modules", &command_lsmod, 0);
2148 #ifdef CONFIG_DRV_PCI
2149         command_register ("lspci", "list all pci devices", &command_lspci, 0);
2150 #endif
2151         command_register ("mouse", "ps2 mouse test", &command_mouse, 0);
2152         command_register ("iflist", "Show network interface", &command_iflist, 0);
2153         command_register ("ifconfig", "Configure network interface", &command_ifconfig, 0);
2154         command_register ("ifroute", "Configure gateway address", &command_ifroute, 0);
2155         command_register ("dnsconfig", "Configure domain name server address", &command_dnsconfig, 0);
2156         command_register ("dhcpcl", "Configure interface using DHCP", &command_dhcpcl, 0);
2157 #ifdef CONFIG_PROTO_TUN6
2158         command_register ("tunconfig", "Configure IPv6 tunnel server address", &command_tunconfig, 0);
2159 #endif
2160         command_register ("hostname", "Configure network hostname", &command_hostname, 0);
2161         command_register ("kbdmap", "Change keyboard layout", &command_kbdmap, 0);
2162 #ifdef CONFIG_DRV_ZEXFS
2163         command_register ("mkzexfs", "Create zexfs filesystem on hdd", &command_mkzexfs, 0);
2164 #endif
2165 #ifdef CONFIG_DRV_EXT2
2166         command_register ("mkext2", "Create ext2 filesystem on hdd", &command_mkext2, 0);
2167 #endif
2168 #ifdef CONFIG_PROTO_IPV4
2169         command_register ("ping", "Send ICMP echo request", &command_ping, 0);
2170 #endif
2171 #ifdef CONFIG_PROTO_IPV6
2172         command_register ("ping6", "Send ICMPv6 echo request", &command_ping6, 0);
2173 #endif
2174         command_register ("netexec", "Execute file from network", &command_netexec, 0);
2175         command_register ("netcp", "Copy file from network to filesystem", &command_netcp, 0);
2176 #ifdef CONFIG_DRV_ZNFS
2177         command_register ("znfscl", "Connect to znfs server - network filesystem", &command_znfscl, 0);
2178 #endif
2179         command_register ("savemode", "Make less cpu load", &command_savemode, 0);
2180         command_register ("cpuinfo", "Show CPU info", &command_cpuinfo, 0);
2181
2182         command_register ("adm", "Automatic Device Mounter", &command_adm, 0);
2183         command_register ("ttyctrl", "TTY Console control", &command_ttyctrl, 0);
2184         command_register ("cmd", "Execute command sequence", &command_cmd, 0);
2185
2186         return 1;
2187 }