foreground signal tcsetpgrp c - c

Question

I'm making my own shell cause why the hell not.
When you run a command and end it with &, the process with be run in the background, so I'd like to make an fg command that you can use to put the background process to the foreground.
I have some troubles making the fg function.
If i understand it correctly, putting signal() in the child process will let the child process receive a signal.
Signal receives two arguments, signum and the handler function.
We're gonna use tcsetpgrp() to set a given background process to foreground. So in lsh_fg I call tcsetpgrp(STDIN_FILENO, pid).
So signum should be sigttou so it can receive the signal from tcsetpgrp().
I don't know what should be put inside the handler, since tcsetpgrp() is supposed to do as the man page describes it:
"
The function tcsetpgrp() makes the process group with process group ID
pgrp the foreground process group on the terminal associated to fd
"
As I understand it, tcsetpgrp() is sending a signal to the process that has signal(sigttou,handler), which is put to the foreground when it receives it. But I clearly misunderstood this since it's not working.
My questions: How should I understand the way tcsetpgrp() and signal(sigttou,handler) work together? And what should my handler include?
I really appreciate your answers cause i really got stuck here :-)
See my code below:
Ps: I'm new to C and system programming and this is my first post ever so any constructive criticism regarding my code is warmly welcome
THANKS A LOT :D
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
pid_t pid;
int toke_c;
//function declaration for the function pointers
int lsh_cd(char **args);
int lsh_pwd(char **args);
int lsh_exit(char **args);
int lsh_fg(char **args);
//An array of functions:
int (*builtin_func[]) (char **) = {
&lsh_cd,
&lsh_pwd,
&lsh_exit,
&lsh_fg
};
//An array of the given strings:
char *builtin_str[] = {
"cd",
"pwd",
"exit",
"fg"
};
///built in functions cd and pwd
int lsh_fg(char **args){
tcsetpgrp(STDIN_FILENO, pid);
return 1;
}
void fg_handler()
{
//What to put here???
}
///built in functions cd and pwd
int lsh_cd(char **args)
{
if (args[1] == NULL) {
fprintf(stderr, "lsh: cd: no arguments given\n");
} else {
if (chdir(args[1]) != 0) {
perror("lsh");
}
}
return 1;
}
int lsh_pwd(char **args)
{
char * cwd;
cwd=getcwd (NULL,0);
printf ("%s\n ", cwd);
return 1;
}
int lsh_exit(char **args)
{
return 0;
}
/* Handlers Here*/
void killer()
{
if (pid == 0)
exit(0);
}
void handler()
{
//I DON'T KNOW WHAT TO PUT HERE
}
int lsh_launch(char **args)
{
int status=0;
pid = fork();
if (pid == 0) {
// child process
signal(SIGINT, killer);
if (execvp(args[0], args) == -1) {
fprintf(stderr,"Command not found in $PATH\n");
}
return 1;
} else if (pid < 0) {
//error
perror("lsh");
} else {
// parent
signal(SIGINT, killer);
waitpid(pid, &status, WUNTRACED);
}
return 1;
}
int lsh_background(char **args)
{
pid_t pid;
int status=0;
pid = fork();
if (pid == 0) {
// child process
setpgid(0, 0);
signal(SIGINT, killer);
signal(SIGTTOU, fg_handler);
if (execvp(args[0], args) == -1) {
fprintf(stderr,"Command not found in $PATH\n");
}
return 1;
} else if (pid < 0) {
//error
perror("lsh");
} else {
// parent
signal(SIGTTOU, fg_handler);
signal(SIGINT, killer);
}
return 1;
}
//if a command was entered that we've been using
int lsh_exec(int argc, char **args)
{
int i;
if (args[0] == NULL) {return 1;}
int tresh=4;
char **args1=malloc(toke_c*sizeof(char *));
int j;
for(j=0;j<toke_c-1;j++){
args1[j]=args[j];
}
if(strcmp(args[toke_c-1],"&")==0){
return lsh_background(args1);
}
for (i = 0; i < tresh; i++) {
if (strcmp(args[0], builtin_str[i]) == 0) {
return (*builtin_func[i])(args);
}
}
return lsh_launch(args);
}
#define MAX_STR 256
//reading the line
char *lsh_lread(void)
{
char *str = malloc (MAX_STR);
fgets (str, MAX_STR, stdin);
}
//tokenizer
char **lsh_tokenizer(char *line)
{
int bufsize = 64;
int pos_t = 0;
char **tokens = malloc(bufsize * sizeof(char*));
char *token;
token = strtok(line, " \t\r\n\a");
while (token != NULL) {
tokens[pos_t] = token;
pos_t++;
token = strtok(NULL, " \t\r\n\a");
}
tokens[pos_t] = NULL;
toke_c=pos_t;
return tokens;
}
void lsh_loop(void)
{
int argc;
char *line;
char **args;
int status;
do {
printf(">> ");
line = lsh_lread();
args = lsh_tokenizer(line);
status = lsh_exec(argc,args);
free(line);
free(args);
} while (status);
}
int main(int argc, char **argv)
{
lsh_loop();
return 0;
}

Answer 1

How should I understand the way tcsetpgrp() and signal(sigttou,handler) work together?
For your purposes, they don't. You do not need to send a process a signal to make its process group the foreground pgroup (but see below). In fact, I don't see why you would ever intentionally send a SIGTTOU to a process group that you're trying to put in the foreground.
Here's the central part of POSIX's documentation for tcsetpgrp() (emphasis added):
If the process has a controlling terminal, tcsetpgrp() shall set the foreground process group ID associated with the terminal to pgid_id. The application shall ensure that the file associated with fildes is the controlling terminal of the calling process and the controlling terminal is currently associated with the session of the calling process. The application shall ensure that the value of pgid_id matches a process group ID of a process in the same session as the calling process.
Attempts to use tcsetpgrp() from a process which is a member of a background process group on a fildes associated with its controlling terminal shall cause the process group to be sent a SIGTTOU signal. [...]
You're talking about implementing an fg command. The primary usefulness of such a command is interactive execution, and if a process (i.e. your shell) is receiving that command interactively then it must be in the foreground process group, because that's the only process group that receives input from the terminal. Supposing, then, that such a process calls the function, and that the arguments satisfy their individual requirements, the effect is "tcsetpgrp() shall set the foreground process group ID associated with the terminal to pgid_id." Or fail, of course. No signaling is documented to go along with that.
SIGTTOU comes into this picture only if tcsetpgrp() is called by a process that is in a background process group. Were I implementing a shell, I'd be inclined to disable job control for shells running in the background (the command would fail with an error). The default handler for this signal stops the process (not the same thing as terminating it); this is appropriate for a background process that attempts to write to its session's controlling terminal. Similarly, SIGTTIN by default stops the process, and is delivered to background processes that attempt to read from its session's controlling terminal.
For an fg command, you do not expect or want to handle SIGTTOU or SIGTTIN, but that doesn't mean you don't need to signal. Rather, the (initially foreground) process that calls tcsetpgrp() should afterward send a SIGCONT to the new forground pgroup in case some or all of those processes are stopped, as might well be the case. The default handler for this signal resumes the process if it is stopped, which is exactly what you want.
In short, then, you probably do not need to write any custom signal handlers at all for this purpose.