/*	$OpenBSD: xargs.c,v 1.31 2015/12/09 19:29:49 mmcc Exp $	*/

/*	$FreeBSD: xargs.c,v 1.51 2003/05/03 19:09:11 obrien Exp $	*/

/*-

 * Copyright (c) 1990, 1993

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

 *

 * This code is derived from software contributed to Berkeley by

 * John B. Roll Jr.

 *

 * 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.

 *

 * $xMach: xargs.c,v 1.6 2002/02/23 05:27:47 tim Exp $

 */

#include <sys/wait.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <langinfo.h>

#include <locale.h>

#include <paths.h>

#include <regex.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include "pathnames.h"

static void	parse_input(int, char *[]);

static void	prerun(int, char *[]);

static int	prompt(void);

static void	run(char **);

static void	usage(void);

void		strnsubst(char **, const char *, const char *, size_t);

static void	waitchildren(const char *, int);

static char **av, **bxp, **ep, **endxp, **xp;

static char *argp, *bbp, *ebp, *inpline, *p, *replstr;

static const char *eofstr;

static int count, insingle, indouble, oflag, pflag, tflag, Rflag, rval, zflag;

static int cnt, Iflag, jfound, Lflag, wasquoted, xflag, runeof = 1;

static int curprocs, maxprocs;

static size_t inpsize;

extern char **environ;

int

main(int argc, char *argv[])

	long arg_max;

	int ch, Jflag, nargs, nflag, nline;

	size_t linelen;

	char *endptr;

	const char *errstr;

	/*

	 * POSIX.2 limits the exec line length to ARG_MAX - 2K.  Running that

	 * caused some E2BIG errors, so it was changed to ARG_MAX - 4K.  Given

	 * that the smallest argument is 2 bytes in length, this means that

	 * the number of arguments is limited to:

	 *

	 *	 (ARG_MAX - 4K - LENGTH(utility + arguments)) / 2.

	 *

	 * We arbitrarily limit the number of arguments to 5000.  This is

	 * allowed by POSIX.2 as long as the resulting minimum exec line is

	 * at least LINE_MAX.  Realloc'ing as necessary is possible, but

	 * probably not worthwhile.

	 */

		/* 1 byte for each '\0' */

	}

		case 'E':

		case 'I':

		case 'J':

		case 'L':

			break;

		case 'n':

			break;

		case 'o':

		case 'P':

			break;

		case 'p':

		case 'r':

		case 'R':

			break;

		case 's':

			break;

		case 't':

		case 'x':

		case '0':

		case '?':

		default:

	}

	/*

	 * Allocate pointers for the utility name, the utility arguments,

	 * the maximum arguments to be read from stdin and the trailing

	 * NULL.

	 */

	/*

	 * Use the user's name for the utility as argv[0], just like the

	 * shell.  Echo is the default.  Set up pointers for the user's

	 * arguments.

	 */

	else {

		do {

				char **avj;

				break;

			}

	}

	/*

	 * Set up begin/end/traversing pointers into the array.  The -n

	 * count doesn't include the trailing NULL pointer, so the malloc

	 * added in an extra slot.

	 */

	/*

	 * Allocate buffer space for the arguments read from stdin and the

	 * trailing NULL.  Buffer space is defined as the default or specified

	 * space, minus the length of the utility name and arguments.  Set up

	 * begin/end/traversing pointers into the array.  The -s count does

	 * include the trailing NULL, so the malloc didn't add in an extra

	 * slot.

	 */

	for (;;)

}

static void

parse_input(int argc, char *argv[])

	static int hadblank = 0;

	char **avj;

		/* Quotes escape tabs and spaces. */

			goto addch;

		goto arg2;

	}

	case EOF:

		/* No arguments since last exec. */

		}

		goto arg1;

	case '\0':

		goto addch;

	case '\n':

		/* Quotes do not escape newlines. */

		    strcmp(argp, eofstr) == 0;

		/* Do not make empty args unless they are quoted */

				size_t curlen;

				else {

					/*

					 * If this string is not zero

					 * length, append a space for

					 * separation before the next

					 * argument.

					 */

				}

				/*

				 * Allocate enough to hold what we will

				 * be holding in a second, and to append

				 * a space next time through, if we have

				 * to.

				 */

				else

			}

		}

		/*

		 * If max'd out on args or buffer, or reached EOF,

		 * run the command.  If xflag and max'd out on buffer

		 * but not on args, object.  Having reached the limit

		 * of input lines, as specified by -L is the same as

		 * maxing out on arguments.

		 */

		    (Lflag <= count && xflag) || foundeof) {

			}

			}

		}

	case '\'':

			goto addch;

	case '"':

			goto addch;

	case '\\':

		/* Backslash escapes anything, is escaped by quotes. */

		/* FALLTHROUGH */

	default:

		}

		/* If only one argument, not enough buffer space. */

		/* Didn't hit argument limit, so if xflag object. */

		}

		break;

	}

/*

 * Do things necessary before run()'ing, such as -I substitution,

 * and then call run().

 */

static void

prerun(int argc, char *argv[])

	char **tmp, **tmp2, **avj;

	int repls;

	}

	/*

	 * Allocate memory to hold the argument list, and

	 * a NULL at the tail.

	 */

	/*

	 * Save the first argument and iterate over it, we

	 * cannot do strnsubst() to it.

	 */

	/*

	 * For each argument to utility, if we have not used up

	 * the number of replacements we are allowed to do, and

	 * if the argument contains at least one occurrence of

	 * replstr, call strnsubst(), else just save the string.

	 * Iterations over elements of avj and tmp are done

	 * where appropriate.

	 */

		} else {

		}

	}

	/*

	 * Run it.

	 */

	/*

	 * Walk from the tail to the head, free along the way.

	 */

	/*

	 * Now free the list itself.

	 */

	/*

	 * Free the input line buffer, if we have one.

	 */

}

static void

run(char **argv)

	pid_t pid;

	int fd;

	char **avec;

	/*

	 * If the user wants to be notified of each command before it is

	 * executed, notify them.  If they want the notification to be

	 * followed by a prompt, then prompt them.

	 */

		/*

		 * If the user has asked to be prompted, do so.

		 */

			/*

			 * If they asked not to exec, return without execution

			 * but if they asked to, go to the execution.  If we

			 * could not open their tty, break the switch and drop

			 * back to -t behaviour.

			 */

			case 0:

				return;

			case 1:

				goto exec;

			case 2:

				break;

			}

	}

	case -1:

	case 0:

			}

		} else {

		}

			}

		}

	}

}

static void

waitchildren(const char *name, int waitall)

	pid_t pid;

	int status;

	    WNOHANG : 0)) > 0) {

		/*

		 * According to POSIX, we have to exit if the utility exits

		 * with a 255 status, or is interrupted by a signal.

		 * We are allowed to return any exit status between 1 and

		 * 125 in these cases, but we'll use 124 and 125, the same

		 * values used by GNU xargs.

		 */

			    WEXITSTATUS(status) == 126) {

			}

					    sys_signame[WTERMSIG(status)]);

				else

					    name, WTERMSIG(status));

			}

		}

	}

/*

 * Prompt the user about running a command.

 */

static int

prompt(void)

{

	regex_t cre;

	size_t rsize;

	int match;

	char *response;

	FILE *ttyfp;

	    regcomp(&cre, nl_langinfo(YESEXPR), REG_BASIC) != 0) {

	}

}

static void

usage(void)

{

"usage: xargs [-0oprt] [-E eofstr] [-I replstr [-R replacements]] [-J replstr]\n"

"             [-L number] [-n number [-x]] [-P maxprocs] [-s size]\n"

"             [utility [argument ...]]\n");

}