/*

 * From @(#)rpc_main.c 1.30 89/03/30

 *

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

 */

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <libintl.h>

#include <locale.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/param.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include "rpc_parse.h"

#include "rpc_util.h"

#include "rpc_scan.h"

#include "proto.h"

#include "../version.h"

#define PACKAGE _libc_intl_domainname

#define EXTEND	1		/* alias for TRUE */

#define DONT_EXTEND	0	/* alias for FALSE */

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

    int makefileflag;		/* Generate a template Makefile */

    const char *infile;		/* input module name */

    const char *outfile;	/* output module name */

  };

static const char *cmdname;

static const char *svcclosetime = "120";

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

static const char *CPP = "/lib/cpp";

static const char CPPFLAGS[] = "-C";

static char *pathbuf;

static int cpp_pid;

static const char *allv[] =

{

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

};

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

static const char *allnv[] =

{

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

};

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

/*

 * machinations for handling expanding argument list

 */

static void addarg (const char *);	/* add another argument to the list */

static void putarg (int, const char *);		/* put argument at specified location */

static void clear_args (void);	/* clear argument list */

static void checkfiles (const char *, const char *);

				       /* check if out file already exists */

static void clear_args (void);

static char *extendfile (const char *file, const char *ext);

static void open_output (const char *infile, const char *outfile);

static void add_warning (void);

static void clear_args (void);

static void find_cpp (void);

static void open_input (const char *infile, const char *define);

static int check_nettype (const char *name, const char *list_to_check[]);

static void c_output (const char *infile, const char *define,

		      int extend, const char *outfile);

static void h_output (const char *infile, const char *define,

		      int extend, const char *outfile);

static void s_output (int argc, const char *argv[], const char *infile,

		      const char *define, int extend,

		      const char *outfile, int nomain, int netflag);

static void l_output (const char *infile, const char *define,

		      int extend, const char *outfile);

static void t_output (const char *infile, const char *define,

		      int extend, const char *outfile);

static void svc_output (const char *infile, const char *define,

			int extend, const char *outfile);

static void clnt_output (const char *infile, const char *define,

			 int extend, const char *outfile);

static void mkfile_output (struct commandline *cmd);

static int do_registers (int argc, const char *argv[]);

static void addarg (const char *cp);

static void putarg (int whereto, const char *cp);

static void checkfiles (const char *infile, const char *outfile);

static int parseargs (int argc, const char *argv[], struct commandline *cmd);

static void usage (FILE *stream, int status) __attribute__ ((noreturn));

static void options_usage (FILE *stream, int status) __attribute__ ((noreturn));

static void print_version (void);

static void c_initialize (void);

static char *generate_guard (const char *pathname);

#define ARGLISTLEN	20

#define FIXEDARGS         2

static const 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 mtflag;			/* Support for MT */

#define INLINE 3

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

int inlineflag = 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 = 1;			/* ANSI C syntax */

int CCflag;			/* C++ files */

static int allfiles;		/* generate all files */

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

xdrfunc *xdrfunc_head;		/* xdr function list */

xdrfunc *xdrfunc_tail;		/* xdr function list */

int

main (int argc, const char *argv[])

{

  struct commandline cmd;

  setlocale (LC_ALL, "");

  textdomain (_libc_intl_domainname);

  (void) memset ((char *) &cmd, 0, sizeof (struct commandline));

  clear_args ();

  if (!parseargs (argc, argv, &cmd))

    usage (stderr, 1);

  if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||

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

    {

      checkfiles (cmd.infile, cmd.outfile);

    }

  else

    checkfiles (cmd.infile, NULL);

  if (cmd.cflag)

    c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);

  else if (cmd.hflag)

    h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);

  else if (cmd.lflag)

    l_output (cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);

  else if (cmd.sflag || cmd.mflag || (cmd.nflag))

    s_output (argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,

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

  else if (cmd.tflag)

    t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);

  else if (cmd.Ssflag)

    svc_output (cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);

  else if (cmd.Scflag)

    clnt_output (cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);

  else if (cmd.makefileflag)

    mkfile_output (&cmd);

  else

    {

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

      c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");

      reinitialize ();

      h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");

      reinitialize ();

      l_output (cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");

      reinitialize ();

      if (inetdflag || !tirpcflag)

	s_output (allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,

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

      else

	s_output (allnc, allnv, cmd.infile, "-DRPC_SVC",

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

      if (tblflag)

	{

	  reinitialize ();

	  t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");

	}

      if (allfiles)

	{

	  reinitialize ();

	  svc_output (cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");

	  reinitialize ();

	  clnt_output (cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");

	}

      if (allfiles || (cmd.makefileflag == 1))

	{

	  reinitialize ();

	  mkfile_output (&cmd);

	}

    }

  return nonfatalerrors;

}

/*

 * add extension to filename

 */

static char *

extendfile (const char *file, const char *ext)

{

  char *res;

  const char *p;

  res = alloc (strlen (file) + strlen (ext) + 1);

  if (res == NULL)

    abort ();

  p = strrchr (file, '.');

  if (p == NULL)

    p = file + strlen (file);

  strcpy (res, file);

  strcpy (res + (p - file), ext);

  return res;

}

/*

 * Open output file with given extension

 */

static void

open_output (const char *infile, const char *outfile)

{

  if (outfile == NULL)

    {

      fout = stdout;

      return;

    }

  if (infile != NULL && streq (outfile, infile))

    {

      fprintf (stderr, _ ("%s: output would overwrite %s\n"), cmdname,

	       infile);

      crash ();

    }

  fout = fopen (outfile, "w");

  if (fout == NULL)

    {

      fprintf (stderr, _ ("%s: unable to open %s: %m\n"), cmdname, outfile);

      crash ();

    }

  record_open (outfile);

}

/* Close the output file and check for write errors.  */

static void

close_output (const char *outfile)

{

  if (fclose (fout) == EOF)

    {

      fprintf (stderr, _("%s: while writing output %s: %m"), cmdname,

	       outfile ?: "<stdout>");

      crash ();

    }

}

static void

add_warning (void)

{

  fprintf (fout, "/*\n");

  fprintf (fout, " * Please do not edit this file.\n");

  fprintf (fout, " * It was generated using rpcgen.\n");

  fprintf (fout, " */\n\n");

}

/* clear list of arguments */

static void

clear_args (void)

{

  int i;

  for (i = FIXEDARGS; i < ARGLISTLEN; ++i)

    arglist[i] = NULL;

  argcount = FIXEDARGS;

}

/* make sure that a CPP exists */

static void

find_cpp (void)

{

  struct stat64 buf;

  if (stat64 (CPP, &buf) == 0)

    return;

  if (cppDefined) /* user specified cpp but it does not exist */

    {

      fprintf (stderr, _ ("cannot find C preprocessor: %s\n"), CPP);

      crash ();

    }

  /* fall back to system CPP */

  CPP = "cpp";

}

/*

 * Open input file with given define for C-preprocessor

 */

static void

open_input (const char *infile, const char *define)

{

  int pd[2];

  infilename = (infile == NULL) ? "<stdin>" : infile;

  if (pipe (pd) != 0)

    {

      perror ("pipe");

      exit (1);

    }

  cpp_pid = fork ();

  switch (cpp_pid)

    {

    case 0:

      find_cpp ();

      putarg (0, CPP);

      putarg (1, CPPFLAGS);

      addarg (define);

      if (infile)

	addarg (infile);

      addarg ((char *) NULL);

      close (1);

      dup2 (pd[1], 1);

      close (pd[0]);

      execvp (arglist[0], (char **) arglist);

      if (errno == ENOENT)

        {

          fprintf (stderr, _ ("cannot find C preprocessor: %s\n"), CPP);

          exit (1);

        }

      perror ("execvp");

      exit (1);

    case -1:

      perror ("fork");

      exit (1);

    }

  close (pd[1]);

  fin = fdopen (pd[0], "r");

  if (fin == NULL)

    {

      fprintf (stderr, "%s: ", cmdname);

      perror (infilename);

      crash ();

    }

}

/* Close the connection to the C-preprocessor and check for successfull

   termination.  */

static void

close_input (void)

{

  int status;

  fclose (fin);

  /* Check the termination status.  */

  if (waitpid (cpp_pid, &status, 0) < 0)

    {

      perror ("waitpid");

      crash ();

    }

  if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)

    {

      if (WIFSIGNALED (status))

	fprintf (stderr, _("%s: C preprocessor failed with signal %d\n"),

		 cmdname, WTERMSIG (status));

      else

	fprintf (stderr, _("%s: C preprocessor failed with exit code %d\n"),

		 cmdname, WEXITSTATUS (status));

      crash ();

    }

}

/* valid tirpc nettypes */

static const char *valid_ti_nettypes[] =

{

  "netpath",

  "visible",

  "circuit_v",

  "datagram_v",

  "circuit_n",

  "datagram_n",

  "udp",

  "tcp",

  "raw",

  NULL

};

/* valid inetd nettypes */

static const char *valid_i_nettypes[] =

{

  "udp",

  "tcp",

  NULL

};

static int

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

{

  int i;

  for (i = 0; list_to_check[i] != NULL; i++)

    {

      if (strcmp (name, list_to_check[i]) == 0)

	{

	  return 1;

	}

    }

  fprintf (stderr, _ ("illegal nettype: `%s'\n"), name);

  return 0;

}

/*

 * Compile into an XDR routine output file

 */

static void

c_output (const char *infile, const char *define, int extend,

	  const char *outfile)

{

  definition *def;

  char *include;

  const char *outfilename;

  long tell;

  c_initialize ();

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  open_output (infile, outfilename);

  add_warning ();

  if (infile && (include = extendfile (infile, ".h")))

    {

      fprintf (fout, "#include \"%s\"\n", include);

      free (include);

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

    }

  else

    fprintf (fout, "#include <rpc/rpc.h>\n");

  tell = ftell (fout);

  while ((def = get_definition ()) != NULL)

    emit (def);

  if (extend && tell == ftell (fout))

    unlink (outfilename);

  close_input ();

  close_output (outfilename);

}

void

c_initialize (void)

{

  /* add all the starting basic types */

  add_type (1, "int");

  add_type (1, "long");

  add_type (1, "short");

  add_type (1, "bool");

  add_type (1, "u_int");

  add_type (1, "u_long");

  add_type (1, "u_short");

}

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

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

	xdrproc_t	xdr_arg;\n\

	unsigned	len_arg;\n\

	xdrproc_t	xdr_res;\n\

	unsigned	len_res;\n\

};\n";

static char *

generate_guard (const char *pathname)

{

  const char *filename;

  char *guard, *tmp;

  filename = strrchr (pathname, '/');	/* find last component */

  filename = ((filename == NULL) ? pathname : filename + 1);

  guard = extendfile (filename, "_H_RPCGEN");

  /* convert to upper case */

  tmp = guard;

  while (*tmp)

    {

      if (islower (*tmp))

	*tmp = toupper (*tmp);

      tmp++;

    }

  return guard;

}

/*

 * Compile into an XDR header file

 */

static void

h_output (const char *infile, const char *define, int extend,

	  const char *outfile)

{

  xdrfunc *xdrfuncp;

  definition *def;

  const char *ifilename;

  const char *outfilename;

  long tell;

  char *guard;

  list *l;

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  open_output (infile, outfilename);

  add_warning ();

  ifilename = (infile == NULL) ? "STDIN" : infile;

  guard = generate_guard (outfilename ? outfilename : ifilename);

  fprintf (fout, "#ifndef _%s\n#define _%s\n\n", guard,

	   guard);

  fprintf (fout, "#include <rpc/rpc.h>\n\n");

  if (mtflag)

    {

      fprintf (fout, "#include <pthread.h>\n");

    }

  /* put the C++ support */

  if (Cflag && !CCflag)

    {

      fprintf (fout, "\n#ifdef __cplusplus\n");

      fprintf (fout, "extern \"C\" {\n");

      fprintf (fout, "#endif\n\n");

    }

  tell = ftell (fout);

  /* print data definitions */

  while ((def = get_definition ()) != NULL)

    {

      print_datadef (def);

    }

  /* print function declarations.

     Do this after data definitions because they might be used as

     arguments for functions */

  for (l = defined; l != NULL; l = l->next)

    {

      print_funcdef (l->val);

    }

  /* Now  print all xdr func declarations */

  if (xdrfunc_head != NULL)

    {

      fprintf (fout, "\n/* the xdr functions */\n");

      if (CCflag)

	{

	  fprintf (fout, "\n#ifdef __cplusplus\n");

	  fprintf (fout, "extern \"C\" {\n");

	  fprintf (fout, "#endif\n");

	}

      if (!Cflag)

	{

	  xdrfuncp = xdrfunc_head;

	  while (xdrfuncp != NULL)

	    {

	      print_xdr_func_def (xdrfuncp->name,

				  xdrfuncp->pointerp, 2);

	      xdrfuncp = xdrfuncp->next;

	    }

	}

      else

	{

	  int i;

	  for (i = 1; i < 3; ++i)

	    {

	      if (i == 1)

		fprintf (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");

	      else

		fprintf (fout, "\n#else /* K&R C */\n");

	      xdrfuncp = xdrfunc_head;

	      while (xdrfuncp != NULL)

		{

		  print_xdr_func_def (xdrfuncp->name,

				      xdrfuncp->pointerp, i);

		  xdrfuncp = xdrfuncp->next;

		}

	    }

	  fprintf (fout, "\n#endif /* K&R C */\n");

	}

    }

  if (extend && tell == ftell (fout))

    {

      unlink (outfilename);

    }

  else if (tblflag)

    {

      fprintf (fout, "%s", rpcgen_table_dcl);

    }

  if (Cflag)

    {

      fprintf (fout, "\n#ifdef __cplusplus\n");

      fprintf (fout, "}\n");

      fprintf (fout, "#endif\n");

    }

  fprintf (fout, "\n#endif /* !_%s */\n", guard);

  free (guard);

  close_input ();

  close_output (outfilename);

}

/*

 * Compile into an RPC service

 */

static void

s_output (int argc, const char *argv[], const char *infile, const char *define,

	  int extend, const char *outfile, int nomain, int netflag)

{

  char *include;

  definition *def;

  int foundprogram = 0;

  const char *outfilename;

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  open_output (infile, outfilename);

  add_warning ();

  if (infile && (include = extendfile (infile, ".h")))

    {

      fprintf (fout, "#include \"%s\"\n", include);

      free (include);

    }

  else

    fprintf (fout, "#include <rpc/rpc.h>\n");

  fprintf (fout, "#include <stdio.h>\n");

  fprintf (fout, "#include <stdlib.h>\n");

  fprintf (fout, "#include <rpc/pmap_clnt.h>\n");

  if (Cflag)

    fprintf (fout, "#include <string.h>\n");

  if (strcmp (svcclosetime, "-1") == 0)

    indefinitewait = 1;

  else if (strcmp (svcclosetime, "0") == 0)

    exitnow = 1;

  else if (inetdflag || pmflag)

    {

      fprintf (fout, "#include <signal.h>\n");

      timerflag = 1;

    }

  if (!tirpcflag && inetdflag)

    fprintf (fout, "#include <sys/ioctl.h> /* ioctl, TIOCNOTTY */\n");

  if (Cflag && (inetdflag || pmflag))

    {

      fprintf (fout, "#include <sys/types.h> /* open */\n");

      fprintf (fout, "#include <sys/stat.h> /* open */\n");

      fprintf (fout, "#include <fcntl.h> /* open */\n");

      fprintf (fout, "#include <unistd.h> /* getdtablesize */\n");

    }

  if (tirpcflag && !(Cflag && (inetdflag || pmflag)))

    fprintf (fout, "#include <sys/types.h>\n");

  fprintf (fout, "#include <memory.h>\n");

  if (inetdflag || !tirpcflag)

    {

      fprintf (fout, "#include <sys/socket.h>\n");

      fprintf (fout, "#include <netinet/in.h>\n");

    }

  if ((netflag || pmflag) && tirpcflag && !nomain)

    {

      fprintf (fout, "#include <netconfig.h>\n");

    }

  if ( /*timerflag && */ tirpcflag)

    fprintf (fout, "#include <sys/resource.h> /* rlimit */\n");

  if (logflag || inetdflag || pmflag)

    {

      fprintf (fout, "#include <syslog.h>\n");

    }

  /* for ANSI-C */

  if (Cflag)

    fprintf (fout, "\n#ifndef SIG_PF\n#define SIG_PF void(*)(int)\n#endif\n");

  if (timerflag)

    fprintf (fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);

  while ((def = get_definition ()) != NULL)

    {

      foundprogram |= (def->def_kind == DEF_PROGRAM);

    }

  if (extend && !foundprogram)

    {

      unlink (outfilename);

      return;

    }

  write_most (infile, netflag, nomain);

  if (!nomain)

    {

      if (!do_registers (argc, argv))

	{

	  if (outfilename)

	    unlink (outfilename);

	  usage (stderr, 1);

	}

      write_rest ();

    }

  close_input ();

  close_output (outfilename);

}

/*

 * generate client side stubs

 */

static void

l_output (const char *infile, const char *define, int extend,

	  const char *outfile)

{

  char *include;

  definition *def;

  int foundprogram = 0;

  const char *outfilename;

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  open_output (infile, outfilename);

  add_warning ();

  if (Cflag)

    fprintf (fout, "#include <memory.h> /* for memset */\n");

  if (infile && (include = extendfile (infile, ".h")))

    {

      fprintf (fout, "#include \"%s\"\n", include);

      free (include);

    }

  else

    fprintf (fout, "#include <rpc/rpc.h>\n");

  while ((def = get_definition ()) != NULL)

    {

      foundprogram |= (def->def_kind == DEF_PROGRAM);

    }

  if (extend && !foundprogram)

    {

      unlink (outfilename);

      return;

    }

  write_stubs ();

  close_input ();

  close_output (outfilename);

}

/*

 * generate the dispatch table

 */

static void

t_output (const char *infile, const char *define, int extend,

	  const char *outfile)

{

  definition *def;

  int foundprogram = 0;

  const char *outfilename;

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  open_output (infile, outfilename);

  add_warning ();

  while ((def = get_definition ()) != NULL)

    {

      foundprogram |= (def->def_kind == DEF_PROGRAM);

    }

  if (extend && !foundprogram)

    {

      unlink (outfilename);

      return;

    }

  write_tables ();

  close_input ();

  close_output (outfilename);

}

/* sample routine for the server template */

static void

svc_output (const char *infile, const char *define, int extend,

	    const char *outfile)

{

  definition *def;

  char *include;

  const char *outfilename;

  long tell;

  open_input (infile, define);

  outfilename = extend ? extendfile (infile, outfile) : outfile;

  checkfiles (infile, outfilename);

  /*check if outfile already exists.

     if so, print an error message and exit */

  open_output (infile, outfilename);

  add_sample_msg ();

  if (infile && (include = extendfile (infile, ".h")))

    {

      fprintf (fout, "#include \"%s\"\n", include);

      free (include);

    }

  else

    fprintf (fout, "#include <rpc/rpc.h>\n");

  tell = ftell (fout);

  while ((def = get_definition ()) != NULL)

    {

      write_sample_svc (def);

    }

  if (extend && tell == ftell (fout))

    {

      unlink (outfilename);

    }

  close_input ();

  close_output (outfilename);

}

/* sample main routine for client */

static void

clnt_output (const char *infile, const char *define, int extend,

	     const char *outfile)

{

  definition *def;

  char *include;

  const char *outfilename;

  long tell;

  int has_program = 0;

  open_input (infile, define);