/* $OpenBSD: rpc_main.c,v 1.32 2015/11/11 02:52:46 deraadt Exp $	 */

/* $NetBSD: rpc_main.c,v 1.9 1996/02/19 11:12:43 pk Exp $	 */

/*

 * Copyright (c) 2010, Oracle America, Inc.

 *

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

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

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

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

 *     * Neither the name of the "Oracle America, Inc." 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 COPYRIGHT HOLDERS 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

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

 */

/*

 * rpc_main.c, Top level of the RPC protocol compiler.

 */

#define RPCGEN_VERSION	"199506"/* This program's version (year & month) */

#include <sys/types.h>

#include <sys/file.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <ctype.h>

#include <sys/stat.h>

#include "rpc_parse.h"

#include "rpc_util.h"

#include "rpc_scan.h"

#define EXTEND	1		/* alias for TRUE */

#define DONT_EXTEND	0	/* alias for FALSE */

#define SVR4_CPP "/usr/ccs/lib/cpp"

#define SUNOS_CPP "/lib/cpp"

static int      cppDefined = 0;	/* explicit path for C preprocessor */

struct commandline {

	int cflag;	/* xdr C routines */

	int hflag;	/* header file */

	int lflag;	/* client side stubs */

	int mflag;	/* server side stubs */

	int nflag;	/* netid flag */

	int sflag;	/* server stubs for the given transport */

	int tflag;	/* dispatch Table file */

	int Ssflag;	/* produce server sample code */

	int Scflag;	/* produce client sample code */

	char *infile;	/* input module name */

	char *outfile;/* output module name */

};

static char    *cmdname;

static char    *svcclosetime = "120";

static char    *CPP = "/usr/bin/cpp";

static char     CPPFLAGS[] = "-C";

static char     pathbuf[PATH_MAX];

static char    *allv[] = {

	"rpcgen", "-s", "udp", "-s", "tcp",

};

static int      allc = sizeof(allv) / sizeof(allv[0]);

static char    *allnv[] = {

	"rpcgen", "-s", "netpath",

};

static int      allnc = sizeof(allnv) / sizeof(allnv[0]);

#define ARGLISTLEN	20

#define FIXEDARGS         2

static char    *arglist[ARGLISTLEN];

static int      argcount = FIXEDARGS;

int             nonfatalerrors;	/* errors */

int             inetdflag /* = 1 */ ;	/* Support for inetd *//* is now the

					 * default */

int             pmflag;		/* Support for port monitors */

int             logflag;	/* Use syslog instead of fprintf for errors */

int             tblflag;	/* Support for dispatch table file */

int             callerflag;	/* Generate svc_caller() function */

#define INLINE 3

/* length at which to start doing an inline */

int doinline = INLINE;	/* length at which to start doing an

			 * inline. 3 = default if 0, no

			 * xdr_inline code */

int indefinitewait;	/* If started by port monitors, hang till it

			 * wants */

int exitnow;	/* If started by port monitors, exit after

		 * the call */

int timerflag;	/* TRUE if !indefinite && !exitnow */

int newstyle;	/* newstyle of passing arguments (by value) */

int Cflag = 0;	/* ANSI C syntax */

static int allfiles;	/* generate all files */

int tirpcflag = 0;	/* generating code for tirpc, by default */

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

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

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

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

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

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

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

static int do_registers(int, char **);

static void addarg(char *);

static void putarg(int, char *);

static void clear_args(void);

static void checkfiles(char *, char *);

static int parseargs(int, char **, struct commandline *);

static void usage(void);

void c_initialize(void);

int

main(int argc, char *argv[])

	struct commandline cmd;

	}

	    cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {

	} else

			 cmd.outfile, cmd.mflag, cmd.nflag);

	} else {

		/* the rescans are required, since cpp may effect input */

			    "_svc.c", cmd.mflag, cmd.nflag);

		else

			    EXTEND, "_svc.c", cmd.mflag, cmd.nflag);

		}

		}

		}

	}

	/* NOTREACHED */

}

/*

 * add extension to filename

 */

static char *

extendfile(char *path, char *ext)

	char *file;

	char *res;

	char *p;

	size_t len;

	else

	}

}

/*

 * Open output file with given extension

 */

static void

open_output(char *infile, char *outfile)

	}

		    infile);

	}

	}

}

static void

add_warning(void)

/* clear list of arguments */

static void

clear_args(void)

	int             i;

/* make sure that a CPP exists */

static void

find_cpp(void)

	struct stat     buf;

	/* SVR4 or explicit cpp does not exist */

		} else {

			/* try the other one */

				    "cannot find any C preprocessor: %s\n", CPP);

			}

		}

	}

/*

 * Open input file with given define for C-preprocessor

 */

static void

open_input(char *infile, char *define)

	int             pd[2];

	case 0:

	case -1:

	}

	}

/* valid tirpc nettypes */

static char    *valid_ti_nettypes[] = {

	"netpath",

	"visible",

	"circuit_v",

	"datagram_v",

	"circuit_n",

	"datagram_n",

	"udp",

	"tcp",

	"raw",

	NULL

};

/* valid inetd nettypes */

static char    *valid_i_nettypes[] = {

	"udp",

	"tcp",

	NULL

};

static int

check_nettype(char *name, char *list_to_check[])

{

	int             i;

	}

}

/*

 * Compile into an XDR routine output file

 */

static void

c_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

{

	definition     *def;

	char           *include;

	char           *outfilename;

	long            tell;

		/* .h file already contains rpc/rpc.h */

	} else

	}

	}

}

void

c_initialize(void)

{

	/* add all the starting basic types */

}

static const char rpcgen_table_dcl[] = "struct rpcgen_table {\n\

	char	*(*proc)();\n\

	xdrproc_t	xdr_arg;\n\

	unsigned int	len_arg;\n\

	xdrproc_t	xdr_res;\n\

	unsigned int	len_res;\n\

};\n";

static char *

generate_guard(char *pathname)

	char           *filename, *guard, *tmp, *tmp2;

	}

	/* convert to upper case */

	}

}

/*

 * Compile into an XDR header file

 */

static void

h_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

	definition     *def;

	char           *outfilename;

	long            tell;

	char           *guard;

	list           *l;

		guard);

	/* print data definitions */

	}

	/*

	 * print function declarations. Do this after data definitions

	 * because they might be used as arguments for functions

	 */

	}

	}

/*

 * Compile into an RPC service

 */

static void

s_output(argc, argv, infile, define, extend, outfile, nomain, netflag)

	int             argc;

	char           *argv[];

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

	int             nomain;

	int             netflag;

	char           *include;

	definition     *def;

	char           *outfilename;

	} else

			"#include <rpc/pmap_clnt.h> /* for pmap_unset */\n");

	}

	}

	}

	}

	}

	}

	/* for ANSI-C */

	}

	}

		}

	}

}

/*

 * generate client side stubs

 */

static void

l_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

{

	char           *include;

	definition     *def;

	char           *outfilename;

	} else

	}

}

/*

 * generate the dispatch table

 */

static void

t_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

{

	definition     *def;

	char           *outfilename;

	}

}

/* sample routine for the server template */

static void

svc_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

{

	definition     *def;

	char           *include;

	char           *outfilename;

	long            tell;

						 * exists. if so, print an

						 * error message and exit */

	} else

}

/* sample main routine for client */

static void

clnt_output(infile, define, extend, outfile)

	char           *infile;

	char           *define;

	int             extend;

	char           *outfile;

{

	definition *def;

	char *include, *outfilename;

	long tell;

	/*

	 * check if outfile already exists. if so,

	 * print an error message and exit

	 */

	} else

}

/*

 * Perform registrations for service output

 * Return 0 if failed; 1 otherwise.

 */

static int

do_registers(argc, argv)

	int             argc;

	char           *argv[];

{

	int             i;

			}

		}

	} else {

			}

	}

}

/*

 * Add another argument to the arg list

 */

static void

addarg(cp)

	char           *cp;

		/* NOTREACHED */

	}

static void

putarg(where, cp)

	char           *cp;

	int             where;

		/* NOTREACHED */

	}

/*

 * if input file is stdin and an output file is specified then complain

 * if the file already exists. Otherwise the file may get overwritten

 * If input file does not exist, exit with an error

 */

static void

checkfiles(infile, outfile)

	char           *infile;

	char           *outfile;

	struct stat     buf;

		}

#if 0

	if (outfile) {

		if (stat(outfile, &buf) < 0)

			return;	/* file does not exist */

		else {

			fprintf(stderr,

			    "file '%s' already exists and may be overwritten\n",

			    outfile);

			crash();

		}

	}

#endif

/*

 * Parse command line arguments

 */

static int

parseargs(argc, argv, cmd)

	int argc;

	char *argv[];

	struct commandline *cmd;

	int i, j, nflags;

	char c, flag[(1 << 8 * sizeof(char))];

				    "Cannot specify more than one input file!\n");

			}

		} else {

				case 'A':

				case 'a':

				case 'c':

				case 'h':

				case 'l':

				case 'm':

				case 't':

				case 'S':

					/*

					 * sample flag: Ss or Sc. Ss means

					 * set flag['S']; Sc means set

					 * flag['C'];

					 */

					else

				case 'C':	/* ANSI C syntax */

				case 'b':

					/*

					 * turn TIRPC flag off for

					 * generating backward compatible

					 */

				case 'I':

				case 'N':

				case 'L':

				case 'K':

				case 'T':

				case 'i':

				case 'n':

				case 'o':

				case 's':

					    argv[i][j + 1] != 0)