mirror of
https://github.com/Fennix-Project/Kernel.git
synced 2025-05-25 22:14:37 +00:00
423 lines
9.2 KiB
C++
423 lines
9.2 KiB
C++
/*
|
|
This file is part of Fennix Kernel.
|
|
|
|
Fennix Kernel is free software: you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation, either version 3 of
|
|
the License, or (at your option) any later version.
|
|
|
|
Fennix Kernel is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <kshell.hpp>
|
|
|
|
#include <filesystem.hpp>
|
|
#include <driver.hpp>
|
|
#include <lock.hpp>
|
|
#include <debug.h>
|
|
|
|
#include "../Modules/PersonalSystem2/keyboard.hpp"
|
|
#include "../kernel.h"
|
|
#include "../Fex.hpp"
|
|
#include "../DAPI.hpp"
|
|
#include "cmds.hpp"
|
|
|
|
using namespace PS2Keyboard;
|
|
|
|
NewLock(ShellLock);
|
|
|
|
const char sc_ascii_low[] = {'?', '?', '1', '2', '3', '4', '5', '6',
|
|
'7', '8', '9', '0', '-', '=', '?', '?', 'q', 'w', 'e', 'r', 't', 'y',
|
|
'u', 'i', 'o', 'p', '[', ']', '?', '?', 'a', 's', 'd', 'f', 'g',
|
|
'h', 'j', 'k', 'l', ';', '\'', '`', '?', '\\', 'z', 'x', 'c', 'v',
|
|
'b', 'n', 'm', ',', '.', '/', '?', '?', '?', ' '};
|
|
|
|
const char sc_ascii_high[] = {'?', '?', '!', '@', '#', '$', '%', '^',
|
|
'&', '*', '(', ')', '_', '+', '?', '?', 'Q', 'W', 'E', 'R', 'T', 'Y',
|
|
'U', 'I', 'O', 'P', '{', '}', '?', '?', 'A', 'S', 'D', 'F', 'G',
|
|
'H', 'J', 'K', 'L', ';', '\"', '~', '?', '|', 'Z', 'X', 'C', 'V',
|
|
'B', 'N', 'M', '<', '>', '?', '?', '?', '?', ' '};
|
|
|
|
static int LowerCase = true;
|
|
|
|
char GetLetterFromScanCode(uint8_t ScanCode)
|
|
{
|
|
if (ScanCode & 0x80)
|
|
{
|
|
switch (ScanCode)
|
|
{
|
|
case KEY_U_LSHIFT:
|
|
LowerCase = true;
|
|
return 0;
|
|
case KEY_U_RSHIFT:
|
|
LowerCase = true;
|
|
return 0;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (ScanCode)
|
|
{
|
|
case KEY_D_RETURN:
|
|
return '\n';
|
|
case KEY_D_LSHIFT:
|
|
LowerCase = false;
|
|
return 0;
|
|
case KEY_D_RSHIFT:
|
|
LowerCase = false;
|
|
return 0;
|
|
case KEY_D_BACKSPACE:
|
|
return ScanCode;
|
|
default:
|
|
{
|
|
if (ScanCode > 0x39)
|
|
break;
|
|
if (LowerCase)
|
|
return sc_ascii_low[ScanCode];
|
|
else
|
|
return sc_ascii_high[ScanCode];
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int GetChar()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
struct Command
|
|
{
|
|
const char *Name;
|
|
void (*Function)(const char *);
|
|
};
|
|
|
|
static Command commands[] = {
|
|
{"lsof", cmd_lsof},
|
|
{"ls", cmd_ls},
|
|
{"cd", cmd_cd},
|
|
{"cat", cmd_cat},
|
|
{"echo", cmd_echo},
|
|
{"mkdir", nullptr},
|
|
{"touch", nullptr},
|
|
{"rm", nullptr},
|
|
{"rmdir", nullptr},
|
|
{"mv", nullptr},
|
|
{"cp", nullptr},
|
|
{"clear", nullptr},
|
|
{"help", nullptr},
|
|
{"exit", cmd_exit},
|
|
{"reboot", cmd_reboot},
|
|
{"shutdown", cmd_shutdown},
|
|
{"ps", cmd_ps},
|
|
{"kill", cmd_kill},
|
|
{"killall", cmd_killall},
|
|
{"top", cmd_top},
|
|
{"mem", cmd_mem},
|
|
{"mount", nullptr},
|
|
{"umount", nullptr},
|
|
{"uname", cmd_uname},
|
|
{"whoami", cmd_whoami},
|
|
{"passwd", nullptr},
|
|
{"su", nullptr},
|
|
{"login", nullptr},
|
|
{"logout", nullptr},
|
|
{"uptime", cmd_uptime},
|
|
{"chown", nullptr},
|
|
{"chgrp", nullptr},
|
|
{"chmod", nullptr},
|
|
{"chroot", nullptr},
|
|
{"lspci", cmd_lspci}};
|
|
|
|
void StartKernelShell()
|
|
{
|
|
SmartLock(ShellLock);
|
|
|
|
debug("Starting kernel shell...");
|
|
printf("Starting kernel shell...\n");
|
|
thisThread->SetPriority(Tasking::TaskPriority::High);
|
|
Display->SetBuffer(0);
|
|
|
|
Driver::DriverFile KeyboardModule;
|
|
if (likely(DriverManager->GetDrivers().size() > 0))
|
|
{
|
|
foreach (auto Driver in DriverManager->GetDrivers())
|
|
{
|
|
if (((FexExtended *)Driver.ExtendedHeaderAddress)->Driver.Type == FexDriverType::FexDriverType_Input &&
|
|
((FexExtended *)Driver.ExtendedHeaderAddress)->Driver.TypeFlags & FexDriverInputTypes::FexDriverInputTypes_Keyboard)
|
|
{
|
|
KeyboardModule = Driver;
|
|
printf("Using driver \eCA21F6%s\eCCCCCC for keyboard input.\n",
|
|
((FexExtended *)Driver.ExtendedHeaderAddress)->Driver.Name);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Display->SetBuffer(0);
|
|
std::string Buffer;
|
|
std::vector<std::string *> History;
|
|
size_t HistoryIndex = 0;
|
|
bool CtrlDown = false;
|
|
bool TabDoublePress = false;
|
|
|
|
while (true)
|
|
{
|
|
size_t BackspaceCount = 0;
|
|
Buffer.clear();
|
|
|
|
VirtualFileSystem::Node *cwd = thisProcess->CurrentWorkingDirectory;
|
|
if (!cwd)
|
|
cwd = vfs->GetNodeFromPath("/");
|
|
|
|
printf("\e34C6EB%s@%s:%s$ \eCCCCCC",
|
|
"kernel",
|
|
"fennix",
|
|
cwd->FileSystem->GetPathFromNode(cwd).c_str());
|
|
Display->SetBuffer(0);
|
|
|
|
while (true)
|
|
{
|
|
KernelCallback callback{};
|
|
callback.Reason = PollWaitReason;
|
|
DriverManager->IOCB(KeyboardModule.DriverUID, &callback);
|
|
char c = GetLetterFromScanCode(callback.InputCallback.Keyboard.Key);
|
|
|
|
switch (callback.InputCallback.Keyboard.Key)
|
|
{
|
|
case KEY_D_LCTRL:
|
|
{
|
|
CtrlDown = true;
|
|
continue;
|
|
}
|
|
case KEY_U_LCTRL:
|
|
{
|
|
CtrlDown = false;
|
|
continue;
|
|
}
|
|
case KEY_D_BACKSPACE:
|
|
{
|
|
if (BackspaceCount == 0)
|
|
continue;
|
|
|
|
Display->Print('\b', 0);
|
|
Buffer.pop_back();
|
|
BackspaceCount--;
|
|
Display->SetBuffer(0);
|
|
continue;
|
|
}
|
|
case KEY_D_UP:
|
|
{
|
|
if (History.size() == 0 ||
|
|
HistoryIndex == 0)
|
|
continue;
|
|
|
|
HistoryIndex--;
|
|
|
|
for (size_t i = 0; i < Buffer.size(); i++)
|
|
Display->Print('\b', 0);
|
|
Display->SetBuffer(0);
|
|
|
|
Buffer = History[HistoryIndex]->c_str();
|
|
|
|
for (size_t i = 0; i < strlen(Buffer.c_str()); i++)
|
|
Display->Print(Buffer[i], 0);
|
|
BackspaceCount = Buffer.size();
|
|
Display->SetBuffer(0);
|
|
continue;
|
|
}
|
|
case KEY_D_DOWN:
|
|
{
|
|
if (History.size() == 0 ||
|
|
HistoryIndex == History.size())
|
|
continue;
|
|
|
|
if (HistoryIndex == History.size() - 1)
|
|
{
|
|
HistoryIndex++;
|
|
for (size_t i = 0; i < Buffer.size(); i++)
|
|
Display->Print('\b', 0);
|
|
BackspaceCount = Buffer.size();
|
|
Display->SetBuffer(0);
|
|
continue;
|
|
}
|
|
|
|
for (size_t i = 0; i < Buffer.size(); i++)
|
|
Display->Print('\b', 0);
|
|
Display->SetBuffer(0);
|
|
|
|
HistoryIndex++;
|
|
Buffer = History[HistoryIndex]->c_str();
|
|
|
|
for (size_t i = 0; i < strlen(Buffer.c_str()); i++)
|
|
Display->Print(Buffer[i], 0);
|
|
|
|
BackspaceCount = Buffer.size();
|
|
Display->SetBuffer(0);
|
|
continue;
|
|
}
|
|
case KEY_D_TAB:
|
|
{
|
|
if (!TabDoublePress)
|
|
{
|
|
TabDoublePress = true;
|
|
continue;
|
|
}
|
|
TabDoublePress = false;
|
|
if (Buffer.size() == 0)
|
|
{
|
|
for (size_t i = 0; i < sizeof(commands) / sizeof(commands[0]); i++)
|
|
{
|
|
printf("%s ", commands[i].Name);
|
|
Display->SetBuffer(0);
|
|
}
|
|
Display->Print('\n', 0);
|
|
Display->SetBuffer(0);
|
|
goto SecLoopEnd;
|
|
}
|
|
|
|
for (size_t i = 0; i < Buffer.size(); i++)
|
|
Display->Print('\b', 0);
|
|
Display->SetBuffer(0);
|
|
|
|
for (size_t i = 0; i < sizeof(commands) / sizeof(commands[0]); i++)
|
|
{
|
|
if (strncmp(Buffer.c_str(), commands[i].Name, Buffer.size()) == 0)
|
|
{
|
|
Buffer = commands[i].Name;
|
|
for (size_t i = 0; i < strlen(Buffer.c_str()); i++)
|
|
Display->Print(Buffer[i], 0);
|
|
BackspaceCount = Buffer.size();
|
|
Display->SetBuffer(0);
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (c == 0)
|
|
continue;
|
|
|
|
if (CtrlDown)
|
|
{
|
|
switch (std::toupper((char)c))
|
|
{
|
|
case 'C':
|
|
{
|
|
Display->Print('^', 0);
|
|
Display->Print('C', 0);
|
|
Display->Print('\n', 0);
|
|
fixme("No SIGINT handler yet.");
|
|
Display->SetBuffer(0);
|
|
goto SecLoopEnd;
|
|
}
|
|
case 'D':
|
|
{
|
|
Display->Print('^', 0);
|
|
Display->Print('D', 0);
|
|
Display->Print('\n', 0);
|
|
fixme("No SIGKILL handler yet.");
|
|
Display->SetBuffer(0);
|
|
goto SecLoopEnd;
|
|
}
|
|
default:
|
|
continue;
|
|
}
|
|
}
|
|
|
|
Display->Print(c, 0);
|
|
if (c == '\n')
|
|
{
|
|
if (Buffer.length() > 0)
|
|
{
|
|
std::string *hBuff = new std::string(Buffer.c_str());
|
|
History.push_back(hBuff);
|
|
HistoryIndex = History.size();
|
|
}
|
|
break;
|
|
}
|
|
|
|
Buffer += c;
|
|
BackspaceCount++;
|
|
Display->SetBuffer(0);
|
|
}
|
|
SecLoopEnd:
|
|
|
|
if (Buffer.length() == 0)
|
|
continue;
|
|
|
|
bool Found = false;
|
|
for (size_t i = 0; i < sizeof(commands) / sizeof(Command); i++)
|
|
{
|
|
std::string cmd_extracted;
|
|
for (size_t i = 0; i < Buffer.length(); i++)
|
|
{
|
|
if (Buffer[i] == ' ')
|
|
break;
|
|
cmd_extracted += Buffer[i];
|
|
}
|
|
|
|
debug("cmd: %s, array[%d]: %s", cmd_extracted.c_str(), i, commands[i].Name);
|
|
if (strncmp(commands[i].Name, cmd_extracted.c_str(), cmd_extracted.size()) == 0)
|
|
{
|
|
if (strlen(commands[i].Name) != cmd_extracted.size())
|
|
continue;
|
|
|
|
Found = true;
|
|
|
|
std::string arg_only;
|
|
const char *cmd_name = commands[i].Name;
|
|
for (size_t i = strlen(cmd_name) + 1; i < Buffer.length(); i++)
|
|
arg_only += Buffer[i];
|
|
|
|
if (commands[i].Function)
|
|
commands[i].Function(arg_only.c_str());
|
|
else
|
|
{
|
|
std::string cmd_only;
|
|
for (size_t i = 0; i < Buffer.length(); i++)
|
|
{
|
|
if (Buffer[i] == ' ')
|
|
break;
|
|
cmd_only += Buffer[i];
|
|
}
|
|
printf("%s: command not implemented\n",
|
|
cmd_only.c_str());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Found)
|
|
{
|
|
std::string cmd_only;
|
|
for (size_t i = 0; i < Buffer.length(); i++)
|
|
{
|
|
if (Buffer[i] == ' ')
|
|
break;
|
|
cmd_only += Buffer[i];
|
|
}
|
|
printf("%s: command not found\n",
|
|
cmd_only.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void KShellThread()
|
|
{
|
|
StartKernelShell();
|
|
inf_loop;
|
|
}
|