I have a group assignment to create a shell. My portion of the assignment is to handle signals and the path variable.
My current issue is figuring out how to handle the signal in a way that it only kills the process started by our shell. I know it would be easier to use kill() and send it straight to a specific process or process group. But the main file was written without using fork(), no pid has been assigned anywhere, either. I'm not sure if I can easily make the necessary change to handle my signals using kill().
How can I use a custom signal handler to affect just the current process running when the signal was sent?
For the sake of testing my own code, I copied this code for a working shell from GeeksForGeeks
The only function I've written or made changes to here is the signal_handler() function. In main(), anything that has to do with calling signal() is code I've written.
// C Program to design a shell in Linux
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include <signal.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<readline/readline.h>
#include<readline/history.h>
#define MAXCOM 1000 // max number of letters to be supported
#define MAXLIST 100 // max number of commands to be supported
#define SIGHUP 1 /* Hangup the process */
#define SIGINT 2 /* Interrupt the process */
#define SIGQUIT 3 /* Quit the process */
#define SIGILL 4 /* Illegal instruction. */
#define SIGTRAP 5 /* Trace trap. */
#define SIGABRT 6 /* Abort. */
// Clearing the shell using escape sequences
#define clear() printf("\033[H\033[J")
// Greeting shell during startup
void init_shell()
{
clear();
printf("\n\n\n\n******************"
"************************");
printf("\n\n\n\t****MY SHELL****");
printf("\n\n\t-USE AT YOUR OWN RISK-");
printf("\n\n\n\n*******************"
"***********************");
char* username = getenv("USER");
printf("\n\n\nUSER is: @%s", username);
printf("\n");
sleep(1);
clear();
}
// Function to take input
int takeInput(char* str)
{
char* buf;
buf = readline("\n>>> ");
if (strlen(buf) != 0) {
add_history(buf);
strcpy(str, buf);
return 0;
}
else {
return 1;
}
}
// Function to print Current Directory.
void printDir()
{
char cwd[1024];
getcwd(cwd, sizeof(cwd));
printf("\nDir: %s", cwd);
}
// Function where the system command is executed
void execArgs(char** parsed)
{
// Forking a child
pid_t pid = fork();
if (pid == -1) {
printf("\nFailed forking child..");
return;
}
else if (pid == 0) {
if (execvp(parsed[0], parsed) < 0) {
printf("\nCould not execute command..");
}
exit(0);
}
else {
// waiting for child to terminate
wait(NULL);
return;
}
}
// Function where the piped system commands is executed
void execArgsPiped(char** parsed, char** parsedpipe)
{
// 0 is read end, 1 is write end
int pipefd[2];
pid_t p1, p2;
if (pipe(pipefd) < 0) {
printf("\nPipe could not be initialized");
return;
}
p1 = fork();
if (p1 < 0) {
printf("\nCould not fork");
return;
}
if (p1 == 0) {
// Child 1 executing..
// It only needs to write at the write end
close(pipefd[0]);
dup2(pipefd[1], STDOUT_FILENO);
close(pipefd[1]);
if (execvp(parsed[0], parsed) < 0) {
printf("\nCould not execute command 1..");
exit(0);
}
}
else {
// Parent executing
p2 = fork();
if (p2 < 0) {
printf("\nCould not fork");
return;
}
// Child 2 executing..
// It only needs to read at the read end
if (p2 == 0) {
close(pipefd[1]);
dup2(pipefd[0], STDIN_FILENO);
close(pipefd[0]);
if (execvp(parsedpipe[0], parsedpipe) < 0) {
printf("\nCould not execute command 2..");
exit(0);
}
}
else {
// parent executing, waiting for two children
wait(NULL);
wait(NULL);
}
}
}
// Help command builtin
void openHelp()
{
puts("\n***WELCOME TO MY SHELL HELP***"
"\nCopyright @ Suprotik Dey"
"\n-Use the shell at your own risk..."
"\nList of Commands supported:"
"\n>cd"
"\n>ls"
"\n>exit"
"\n>all other general commands available in UNIX shell"
"\n>pipe handling"
"\n>improper space handling");
return;
}
// Function to execute builtin commands
int ownCmdHandler(char** parsed)
{
int NoOfOwnCmds = 4, i, switchOwnArg = 0;
char* ListOfOwnCmds[NoOfOwnCmds];
char* username;
ListOfOwnCmds[0] = "exit";
ListOfOwnCmds[1] = "cd";
ListOfOwnCmds[2] = "help";
ListOfOwnCmds[3] = "hello";
for (i = 0; i < NoOfOwnCmds; i++) {
if (strcmp(parsed[0], ListOfOwnCmds[i]) == 0) {
switchOwnArg = i + 1;
break;
}
}
switch (switchOwnArg) {
case 1:
printf("\nGoodbye\n");
exit(0);
case 2:
chdir(parsed[1]);
return 1;
case 3:
openHelp();
return 1;
case 4:
username = getenv("USER");
printf("\nHello %s.\nMind that this is "
"not a place to play around."
"\nUse help to know more..\n",
username);
return 1;
default:
break;
}
return 0;
}
// function for finding pipe
int parsePipe(char* str, char** strpiped)
{
int i;
for (i = 0; i < 2; i++) {
strpiped[i] = strsep(&str, "|");
if (strpiped[i] == NULL)
break;
}
if (strpiped[1] == NULL)
return 0; // returns zero if no pipe is found.
else {
return 1;
}
}
// function for parsing command words
void parseSpace(char* str, char** parsed)
{
int i;
for (i = 0; i < MAXLIST; i++) {
parsed[i] = strsep(&str, " ");
if (parsed[i] == NULL)
break;
if (strlen(parsed[i]) == 0)
i--;
}
}
int processString(char* str, char** parsed, char** parsedpipe)
{
char* strpiped[2];
int piped = 0;
piped = parsePipe(str, strpiped);
if (piped) {
parseSpace(strpiped[0], parsed);
parseSpace(strpiped[1], parsedpipe);
}
else {
parseSpace(str, parsed);
}
if (ownCmdHandler(parsed))
return 0;
else
return 1 + piped;
}
void signal_handler(int sig)
{
// The job of this is to receive signals and handle them without closing this shell.
//pid_t pgid = getpgid(); // The process group id should be equivalent to the process id to all its subprocesses, meaning that sending a signal to the group would have effect on all subprocess.
// i could use killpg()- what it does is it sends signals to all processes in the specified process group
// syntax: int killpg(int pgrp, int sig);
// https://man7.org/linux/man-pages/man2/killpg.2.html
// pgrp- is the process group id
// sig- is the signal to be sent
// example:
//
// int main() {
// pid_t pgrp = getpgrp();
// int sig = SIGTERM;
// killpg(pgrp, sig);
// return 0;
//
// I'm thinking i can use switch statements or if statements to handle various signals like this
// setpgid() can be used in the child process to cause all subprocess to share the same pgid
// You can call setpgid () in the forked child process that will execute the shell script. That will give any spawned processes from that shell script the same group ID as the child process. You can then use killpg () to send a signal to the entire group that all processes in that group will receive.
// setpgid(pid1, pid2);
// What the above syntax does is it sets the pgid of pid1 to the same as the pgid of pid2, causing them to both have the same pid. Therefore receiving signals equally.
//THIS IS A WAY TO HANDLE SIGNALS FOR FOREGROUND PROCESSES
/*void handler(int signum) {
// Handle signal
}
int main() {
struct sigaction sa;
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGINT, &sa, NULL) == -1) {
perror("sigaction");
exit(1);
}
// Run foreground process
while (1) {
// Wait for foreground process to finish
wait(NULL);
}
return 0;
}*/
if (sig == 1)
{
signal(SIGHUP, NULL);
}
else if (sig == 2)
{
signal(SIGINT, NULL);
}
else if (sig == 3)
{
signal(SIGQUIT, NULL);
}
else if (sig == 4)
{
signal(SIGILL, NULL);
}
else if (sig == 5)
{
signal(SIGTRAP, NULL);
}
else if (sig == 6)
{
signal(SIGABRT, NULL);
}
}
int main()
{
char inputString[MAXCOM], * parsedArgs[MAXLIST];
char* parsedArgsPiped[MAXLIST];
int execFlag = 0;
init_shell();
signal(SIGHUP, signal_handler); // Hangup the process
signal(SIGINT, signal_handler); // this calls on the signal_handler function when SIGINT is called CTRL C
signal(SIGQUIT, signal_handler); // Quit the process
signal(SIGILL, signal_handler); // Illegal Instruction
signal(SIGTRAP, signal_handler); // Trace trap
signal(SIGABRT, signal_handler); // Abort
while (1) {
// print shell line
printDir();
// take input
if (takeInput(inputString))
continue;
// process
execFlag = processString(inputString,
parsedArgs, parsedArgsPiped);
// execflag returns zero if there is no command
// or it is a builtin command,
// 1 if it is a simple command
// 2 if it is including a pipe.
// execute
if (execFlag == 1)
execArgs(parsedArgs);
if (execFlag == 2)
execArgsPiped(parsedArgs, parsedArgsPiped);
}
return 0;
}