/*	$OpenBSD: csh.c,v 1.41 2017/08/30 06:42:21 anton Exp $	*/

/*	$NetBSD: csh.c,v 1.14 1995/04/29 23:21:28 mycroft Exp $	*/

/*-

 * Copyright (c) 1980, 1991, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <errno.h>

#include <pwd.h>

#include <stdlib.h>

#include <string.h>

#include <locale.h>

#include <unistd.h>

#include <limits.h>

#include <vis.h>

#include <stdarg.h>

#include "csh.h"

#include "proc.h"

#include "extern.h"

#include "pathnames.h"

/*

 * C Shell

 *

 * Bill Joy, UC Berkeley, California, USA

 * October 1978, May 1980

 *

 * Jim Kulp, IIASA, Laxenburg, Austria

 * April 1980

 *

 * Christos Zoulas, Cornell University

 * June, 1991

 */

Char   *dumphist[] = {STRhistory, STRmh, 0, 0};

Char   *loadhist[] = {STRsource, STRmh, STRtildothist, 0};

int     nofile = 0;

bool    reenter = 0;

bool    nverbose = 0;

bool    nexececho = 0;

bool    quitit = 0;

bool    fast = 0;

bool    batch = 0;

bool    mflag = 0;

bool    prompt = 1;

bool    enterhist = 0;

bool    tellwhat = 0;

extern char **environ;

static int	readf(void *, char *, int);

static fpos_t	seekf(void *, fpos_t, int);

static int	writef(void *, const char *, int);

static int	closef(void *);

static int	srccat(Char *, Char *);

static int	srcfile(char *, bool, bool);

static void	phup(int);

static void	srcunit(int, bool, bool);

static void	mailchk(void);

static Char   **defaultpath(void);

int

main(int argc, char *argv[])

{

    Char *cp;

    char *tcp;

    int f;

    char **tempv;

    /*

     * Initialize non constant strings

     */

    tempv = argv;

    /*

     * We are a login shell if: 1. we were invoked as -<something> and we had

     * no arguments 2. or we were invoked only with the -l flag

     */

	/*

	 * Mangle the argv space

	 */

	    continue;

    }

    }

    /*

     * Move the descriptors to safe places. The variable didfds is 0 while we

     * have only FSH* to work with. When didfds is true, we have 0,1,2 and

     * prefer to use these.

     */

    /*

     * XXX: This is to keep programs that use stdio happy.

     *	    what we really want is freunopen() ....

     *	    Closing cshin cshout and csherr (which are really stdin stdout

     *	    and stderr at this point and then reopening them in the same order

     *	    gives us again stdin == cshin stdout == cshout and stderr == csherr.

     *	    If that was not the case builtins like printf that use stdio

     *	    would break. But in any case we could fix that with memcpy and

     *	    a bit of pointer manipulation...

     *	    Fortunately this is not needed under the current implementation

     *	    of stdio.

     */

    /*

     * Initialize the shell variables. ARGV and PROMPT are initialized later.

     * STATUS is also munged in several places. CHILD is munged when

     * forking/waiting

     */

    else

	cp = NULL;

    else

				 * shell */

    /*

     * Grab other useful things from the environment. Should we grab

     * everything??

     */

    /*

     * Re-initialize path if set in environment

     */

    else

    /*

     * Record the interrupt states from the parent process. If the parent is

     * non-interruptible our hand must be forced or we (and our children) won't

     * be either. Our children inherit termination from our parent. We catch it

     * only if we are the login shell.

     */

    /* parents interruptibility */

    /* catch these all, login shell or not */

    /*

     * Process the arguments.

     *

     * Note that processing of -v/-x is actually delayed till after script

     * processing.

     *

     * We set the first character of our name to be '-' if we are a shell

     * running interruptible commands.  Many programs which examine ps'es

     * use this to filter such shells out.

     */

	do

	    case 0:		/* -	Interruptible, no prompt */

	    case 'b':		/* -b	Next arg is input file */

	    case 'c':		/* -c	Command input from arg */

	    case 'e':		/* -e	Exit on any error */

	    case 'f':		/* -f	Fast start */

	    case 'i':		/* -i	Interactive, even if !intty */

	    case 'm':		/* -m	read .cshrc (from su) */

	    case 'n':		/* -n	Don't execute */

	    case 'q':		/* -q	(Undoc'd) ... die on quit */

	    case 's':		/* -s	Read from std input */

	    case 't':		/* -t	Read one line from input */

	    case 'v':		/* -v	Echo hist expanded input */

	    case 'x':		/* -x	Echo just before execution */

	    case 'V':		/* -V	Echo hist expanded input */

	    case 'X':		/* -X	Echo just before execution */

    }

    /*

     * Unless prevented by -, -c, -i, -s, or -t, if there are remaining

     * arguments the first of them is the name of a shell file from which to

     * read commands.

     */

	}

	/*

	 * Replace FSHIN. Handle /dev/std{in,out,err} specially

	 * since once they are closed we cannot open them again.

	 * In that case we use our own saved descriptors

	 */

	    case 0:

	    case 1:

	    case 2:

	    default:

	    }

    }

	}

    }

    /*

     * Decide whether we should play with signals or not. If we are explicitly

     * told (via -i, or -) or we are a login shell (arg0 starts with -) or the

     * input and output are both the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")

     * Note that in only the login shell is it likely that parent may have set

     * signals to be ignored

     */

    /*

     * Save the remaining arguments in argv.

     */

    /*

     * Set up the prompt.

     */

	/* that's a meta-questionmark */

    }

    /*

     * If we are an interactive shell, then start fiddling with the signals;

     * this is a tricky game.

     */

	    /*

	     * Wait till in foreground, in case someone stupidly runs csh &

	     * dont want to try to grab away the tty.

	     */

	    else

		f = -1;

    retry:

		    goto retry;

		}

		/*

		 * Setpgid will fail if we are a session leader and

		 * mypid == mypgrp (POSIX 4.3.3)

		 */

			goto notty;

		/*

		 * We do that after we set our process group, to make sure

		 * that the process group belongs to a process in the same

		 * session as the tty (our process and our group) (POSIX 7.2.4)

		 */

		    goto notty;

	    }

notty:

	    }

	}

    }

    /*

     * Set an exit here in case of an interrupt or error reading the shell

     * start-up scripts.

     */

	/* Will have value(STRhome) here because set fast if don't */

	{

	}

	/*

	 * Source history before .login so that it is available in .login

	 */

    }

    /*

     * Now are ready for the -v and -x flags

     */

    /*

     * All the rest of the world is inside this call. The argument to process

     * indicates whether it should catch "error unwinds".  Thus if we are a

     * interactive shell our call here will never return by being blown past on

     * an error.

     */

    /*

     * Mop-up.

     */

	}

	else {

	}

    }

}

void

untty(void)

{

    }

}

void

importpath(Char *cp)

{

    int i = 0;

    Char *dp;

    Char **pv;

    int     c;

    /*

     * i+2 where i is the number of colons in the path. There are i+1

     * directories in the path plus we need room for a zero terminator.

     */

    dp = cp;

    i = 0;

		}

		else

		    break;

	    }

	}

}

/*

 * Source to the file which is the catenation of the argument names.

 */

static int

srccat(Char *cp, Char *dp)

{

}

/*

 * Source to a file putting the file descriptor in a safe place (> 2).

 */

static int

srcfile(char *f, bool onlyown, bool flag)

{

    int unit;

}

/*

 * Source to a unit.  If onlyown it must be our file or our group or

 * we don't chance it.	This occurs on ".cshrc"s and the like.

 */

int     insource;

static void

srcunit(int unit, bool onlyown, bool hflg)

{

    /* We have to push down a lot of state here */

    /* All this could go into a structure */

    /* The (few) real local variables */

    int     my_reenter;

	}

    }

    /*

     * There is a critical section here while we are pushing down the input

     * stream since we have stuff in different structures. If we weren't

     * careful an interrupt could corrupt SHIN's Bin structure and kill the

     * shell.

     *

     * We could avoid the critical region by grouping all the stuff in a single

     * structure and pointing at it to move it all at once.  This is less

     * efficient globally on many variable references however.

     */

    }

    /* Setup the new values of the state stuff saved above */

    /*

     * Now if we are allowing commands to be interrupted, we let ourselves be

     * interrupted.

     */

	int i;

	/* We made it to the new state... free up its storage */

	/* This code could get run twice but free doesn't care */

	/* Reset input arena */

    }

    /*

     * If process reset() (effectively an unwind) then we must also unwind.

     */

}

void

rechist(void)

{

    int     fd, ftmp, oldidfds;

    struct  varent *shist;

	/*

	 * If $savehist is just set, we use the value of $history

	 * else we use the value in $savehist

	 */

	    else

	}

	else

	    hfile = buf;

	}

    }

}

void

goodbye(void)

{

    }

}

void

exitstat(void)

{

    Char *s;

    /*

     * Note that if STATUS is corrupted (i.e. getn bombs) then error will exit

     * directly because we poke child here. Otherwise we might continue

     * unwarrantedly (sic).

     */

}

/*

 * in the event of a HUP we want to save the history

 */

static void

phup(int sig)

{

    /* XXX sigh, everything after this is a signal race */

    /*

     * We kill the last foreground process group. It then becomes

     * responsible to propagate the SIGHUP to its progeny.

     */

    {

	struct process *pp, *np;

	    np = pp;

	    /*

	     * Find if this job is in the foreground. It could be that

	     * the process leader has exited and the foreground flag

	     * is cleared for it.

	     */

		/*

		 * If a process is in the foreground; we try to kill

		 * it's process group. If we succeed, then the

		 * whole job is gone. Otherwise we keep going...

		 * But avoid sending HUP to the shell again.

		 */

		    /* In case the job was suspended... */

		}

	}

    }

}

Char   *jobargv[2] = {STRjobs, 0};

/*

 * Catch an interrupt, e.g. during lexical input.

 * If we are an interactive shell, we reset the interrupt catch

 * immediately.  In any case we drain the shell output,

 * and finally go through the normal error mechanism, which

 * gets a chance to make the shell go away.

 */

/* ARGSUSED */

void

pintr(int notused)

{

}

void

pintr1(bool wantnl)

{

    Char **v;

	}

    }

    /*

     * If we have an active "onintr" then we search for the label. Note that if

     * one does "onintr -" then we shan't be interruptible so we needn't worry

     * about that here.

     */

    }

    }

}

/*

 * Process is the main driving routine for the shell.

 * It runs all command processing, except for those within { ... }

 * in expressions (which is run by a routine evalav in sh.exp.c which

 * is a stripped down process), and `...` evaluation which is run

 * also by a subset of this code in sh.glob.c in the routine backeval.

 *

 * The code here is a little strange because part of it is interruptible

 * and hence freeing of structures appears to occur when none is necessary

 * if this is ignored.

 *

 * Note that if catch is not set then we will unwind on any error.

 * If an end-of-file occurs, we return.

 */

static struct command *savet = NULL;

void

process(bool catch)

{

	/*

	 * Interruptible during interactive reads

	 */

	}

	/*

	 * For the sake of reset()

	 */

		/* unwind */

	    }

	    /*

	     * Every error is eventually caught here or the shell dies.  It is

	     * at this point that we clean up any left-over open files, by

	     * closing all but a fixed number of pre-defined files.  Thus

	     * routines don't have to worry about leaving files open due to

	     * deeper errors... they will get closed here.

	     */