Shell start:
Initialization of shared memory for process data sharing:
shm_fd = shm_open((const char *) STATE_FILE, (O_CREAT | O_EXCL | O_RDWR), (S_IREAD | S_IWRITE));
ftruncate(shm_fd, sizeof(SHARED_VAR));
conf = mmap(0, sizeof(SHARED_VAR), (PROT_READ | PROT_WRITE), MAP_SHARED, shm_fd, 0));
(init of variables, buffers follows)
(init of terminal next):
status = isatty(fileno(stdin));
if terminal (status == 0):
    input = fopen("/dev/tty", "r");
    output = fopen("/dev/tty", "w");
    tcgetattr(fileno(input),&initial_settings);
    new_settings = initial_settings;
    new_settings.c_lflag |= ICANON;
    new_settings.c_lflag |= ECHO;
    new_settings.c_lflag |= ISIG;
    tcsetattr(fileno(input), TCSANOW, &new_settings);
(init. of signals next):
ignore.sa_handler = SIG_IGN;
sigemptyset(&ignore.sa_mask);
ignore.sa_flags = 0;
sigaction(SIGINT, &ignore, NULL);

childsigint.sa_sigaction = &sig_int;
sigemptyset(&childsigint.sa_mask);
childsigint.sa_flags = SA_SIGINFO;
sigaction(SIGINT, &childsigint, NULL);

childsigchld.sa_sigaction = &sig_child;
sigemptyset(&childsigchld.sa_mask); 
childsigchld.sa_flags = SA_SIGINFO;
sigaction(SIGCHLD, &childsigchld, NULL);

next - an infinite loop reading the command line from a Linux console:
while (fgets(buf, MAXLINE_NETBOOK, input) != NULL)
then - parse the command line just read into buf:
    command to check for semi-colon (more than one command in line read in):
    saveBufPtr = strchr((const char *)buf, ';');
    Similar check to see if there is a pipe in command line read in:
    saveBufPtrPipeToCmda = strchr((const char *)buf, '|');
    And to check for an input file (for a command's arguments):
    saveBufPtrIn = strchr((const char *)buf, '<');
    if there is an input file, open it:
        input_filea = fopen(inFileBufa, "r");
        and save the name of the output file in a string:
        input_file_chPtra = &buf[countCmdChrs];
    Check if there is an output file:
    saveBufPtrOuta = strchr((const char *)buf, '>');
    if there is an output file, open it:
        output_filea = fopen(outFileBufa, "w");
        and save name of output file in a string:
        output_file_chPtra = &buf[countCmdChrs];
    if there is a pipe, parse, separate the 2 commands into buffers (saveBufa,saveBufb):
        strncpy(saveBufa, saveBufPtrPipeToCmdb, cmdLena);
        strncpy(saveBufb, saveBufForLater, cmdLenb); 
    if there is a pipe between commands, or if there is an output file command:
        signal(SIGPIPE, sig_pipe);
        pipe(fdpipe1); (pipe from first command to second command)
        pipe(fdpipe2); (outfile case)
    if there is an input file with command arguments, open it and get them:
        fgets(inputbufa, MAXLINE, input_filea); (and add a null char at end)
        strcpy(inFileArgsReada, inputbufa);
    Put commands and their args into shared buffers to be given to exec function later:
    (using strtok(buffer, space-char), parsing command and its args with space char):
    If there is a second command - similarly - place command and its args into shared mem

    Now deal with forking children processes for each command to be run:
    while-loop for each command (only looking at 1-2 commands right now):
    conf->sigChildDone = FALSE;
    if ((pid = fork()) < 0)
        exit(EXIT_FAILURE);
    else if (pid == 0) /* child */
    { 
        i = conf->cmdNumber;
	**redirection of IO happens here:**
        if first command is running, and there is a pipe to send output to next command:
            dup2(fdpipe1[1], fileno(stdout));
            close(fdpipe1[0]);
        if second command is running, and there is a pipe to get output from first command as this command's input:
            dup2(fdpipe1[0], fileno(stdin));
            close (fdpipe1[1]);
        if there is an output file:
            dup2(fdpipe2[1], fileno(stdout));
        Set up signal for parent to send child process so it can exec command:
        sigemptyset(&newmaskexec);
        sigaddset(&newmaskexec, SIG_TELL_CHILD_EXEC);
        sigprocmask(SIG_BLOCK, &newmaskexec, &oldmaskexec);
        actionexec.sa_flags = SA_SIGINFO; 
        actionexec.sa_sigaction = catchit_FromParentToChild;
        sigaction(SIG_TELL_CHILD_EXEC, &actionexec, NULL);
        sigsuspend(&oldmaskexec);

    }
    else /* parent */
    { 
        svalfork.sival_int = 1;
	svalexec.sival_int = 2;

	sleep(1); 
        if (no output file)
            fflush(stdout);
            sigqueue(pid, SIG_TELL_CHILD_EXEC, svalexec); 
            sigwaitinfo(&newmaskexec, NULL); 
        else (there is an output file - read pipe from child that ran, send to file)
        ***** where error occurs when there is piping and an outfile, so tried 2 ways***
        *** tried this way first, which works for one command, but not 2 with piping***
            fflush(stdout);
            sigqueue(pid, SIG_TELL_CHILD_EXEC, svalexec); 
            sigwaitinfo(&newmaskexec, NULL); 
            n = read(fdpipe2[0], line, MAXBUF);
            fputs(line, output_file);
        **** other way I tried for case when 2 commands pipe and there is an outfile***
            fflush(stdout);
            sigqueue(pid, SIG_TELL_CHILD_EXEC, svalexec); 
            sigwaitinfo(&newmaskexec, NULL); 
            close(fdpipe2[1]);
            FD_ZERO (&rfds);
            FD_ZERO (&wfds);
            FD_ZERO (&efds);
            FD_SET (fdpipe2[0], &rfds);

            const int m = fdpipe2[0] + 1;
            BOOL doneMonitoring = FALSE;
            BOOL checkForSigChild = FALSE;

            while (!doneMonitoring) 
            {
                int r = select (m, &rfds, &wfds, &efds, 0);
                if (FD_ISSET (fdpipe2[0], &rfds)) 
                {
                    ioctl (fdpipe2[0], FIONREAD, &size);
                    ssize_t r = splice (src, NULL, dst, NULL, size, 0);
                }
                else
	        {
	            checkForSigChild = TRUE;
	        }
            if ((checkForSigChild == TRUE) && (conf->sigChildDone == TRUE))
            {
	        doneMonitoring = TRUE;
            }
            else if ((checkForSigChild == TRUE) && (conf->sigChildDone == FALSE))
            {
	        checkForSigChild = FALSE;
            }
        }

	do
	{ /* parent */
            pid = waitpid(pid, &status, 0));
            (followed by checking the status of the waitpid())
        }
	while (!WIFEXITED(status) && !WIFSIGNALED(status));

	tcflush(fileno(output), TCOFLUSH);
        fflush(output_filea);
    } //end parent's part
    conf->cmdNumber++;
    (while loop continues - forks next command in command line if there is one)
until done with all commands in command line

signal handler that runs once parent gives this signal to child so it can exec command:
void catchit_FromParentToChild(int signo, siginfo_t *info, void *extra)
{
   char *env[] = { NULL };
   
   if (there are no outfiles)
      (if first command):
      execvp(conf->cmdArga[0],(char* const*) conf->cmdArga );
      (if second command):
      execvp(conf->cmdArgb[0],(char* const*) conf->cmdArgb );
   else (case of piping and an outfile -- ***errors here!!***)
      (***tried execvp - did not work - execve seemed to get me further along ***)
      (if first command):
      execve(conf->cmdArga[0],(char* const*) conf->cmdArga, env ); 
      (if second command):
      execve(conf->cmdArgb[0],(char* const*) conf->cmdArgb, env );

}

sig_child handler for when child finishes after it has execed command:
static void sig_child(int signo, siginfo_t *child_sigaction, void *context)
{
  for all commands that complete running:
  (check child_sigaction->si_code to see if child exitted normally or there was error)
  
  if (command that completed was 2nd command)
    {
      (this shared memory variable is checked in the case when I monitor
      for the second child being done running, so stop splicing output to out file)
      conf->sigChildDone = TRUE;
    }

return;		/* control goes back to parent */
}

handler that stops the shell from running:
static void sig_int(int signo, siginfo_t *child_sigaction, void *context)
{
  tcflush(child_sigaction->si_fd, TCOFLUSH);
  kill(child_sigaction->si_pid, SIGTERM);
}