sunrpc/rpc_main.c

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user or with the express written consent of
   8  * Sun Microsystems, Inc.
   9  *
  10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  13  *
  14  * Sun RPC is provided with no support and without any obligation on the
  15  * part of Sun Microsystems, Inc. to assist in its use, correction,
  16  * modification or enhancement.
  17  *
  18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  20  * OR ANY PART THEREOF.
  21  *
  22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  23  * or profits or other special, indirect and consequential damages, even if
  24  * Sun has been advised of the possibility of such damages.
  25  *
  26  * Sun Microsystems, Inc.
  27  * 2550 Garcia Avenue
  28  * Mountain View, California  94043
  29  */
  30
  31 /*
  32  * From @(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI;
  33  */
  34 const char main_rcsid[] =
  35   "$Id$";
  36
  37 /*
  38  * rpc_main.c, Top level of the RPC protocol compiler.
  39  */
  40
  41 #include <errno.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <ctype.h>
  46 #include <sys/types.h>
  47 #include <sys/param.h>
  48 #include <sys/file.h>
  49 #include <sys/stat.h>
  50 #include <sys/wait.h>
  51 #include "rpc_parse.h"
  52 #include "rpc_util.h"
  53 #include "rpc_scan.h"
  54 #include "proto.h"
  55
  56 #define EXTEND  1               /* alias for TRUE */
  57 #define DONT_EXTEND     0       /* alias for FALSE */
  58
  59 struct commandline
  60   {
  61     int cflag;                  /* xdr C routines */
  62     int hflag;                  /* header file */
  63     int lflag;                  /* client side stubs */
  64     int mflag;                  /* server side stubs */
  65     int nflag;                  /* netid flag */
  66     int sflag;                  /* server stubs for the given transport */
  67     int tflag;                  /* dispatch Table file */
  68     int Ssflag;                 /* produce server sample code */
  69     int Scflag;                 /* produce client sample code */
  70     int makefileflag;           /* Generate a template Makefile */
  71     const char *infile;         /* input module name */
  72     const char *outfile;        /* output module name */
  73   };
  74
  75
  76 static const char *cmdname;
  77
  78 #define SVR4_CPP "/usr/ccs/lib/cpp"
  79 #define SUNOS_CPP "/lib/cpp"
  80
  81 static const char *svcclosetime = "120";
  82 static int cppDefined = 0;      /* explicit path for C preprocessor */
  83 static const char *CPP = SUNOS_CPP;
  84 static char CPPFLAGS[] = "-C";
  85 static char *pathbuf;
  86 static int cpp_pid;
  87 static const char *allv[] =
  88 {
  89   "rpcgen", "-s", "udp", "-s", "tcp",
  90 };
  91 static int allc = sizeof (allv) / sizeof (allv[0]);
  92 static const char *allnv[] =
  93 {
  94   "rpcgen", "-s", "netpath",
  95 };
  96 static int allnc = sizeof (allnv) / sizeof (allnv[0]);
  97
  98 /*
  99  * machinations for handling expanding argument list
 100  */
 101 static void addarg (const char *);      /* add another argument to the list */
 102 static void putarg (int, const char *);         /* put argument at specified location */
 103 static void clear_args (void);  /* clear argument list */
 104 static void checkfiles (const char *, const char *);
 105                                        /* check if out file already exists */
 106
 107 static void clear_args (void);
 108 static char *extendfile (const char *file, const char *ext);
 109 static void open_output (const char *infile, const char *outfile);
 110 static void add_warning (void);
 111 static void clear_args (void);
 112 static void find_cpp (void);
 113 static void open_input (const char *infile, const char *define);
 114 static int check_nettype (const char *name, const char *list_to_check[]);
 115 static void c_output (const char *infile, const char *define,
 116                       int extend, const char *outfile);
 117 static void h_output (const char *infile, const char *define,
 118                       int extend, const char *outfile);
 119 static void s_output (int argc, const char *argv[], const char *infile,
 120                       const char *define, int extend,
 121                       const char *outfile, int nomain, int netflag);
 122 static void l_output (const char *infile, const char *define,
 123                       int extend, const char *outfile);
 124 static void t_output (const char *infile, const char *define,
 125                       int extend, const char *outfile);
 126 static void svc_output (const char *infile, const char *define,
 127                         int extend, const char *outfile);
 128 static void clnt_output (const char *infile, const char *define,
 129                          int extend, const char *outfile);
 130 static void mkfile_output (struct commandline *cmd);
 131 static int do_registers (int argc, const char *argv[]);
 132 static void addarg (const char *cp);
 133 static void putarg (int whereto, const char *cp);
 134 static void checkfiles (const char *infile, const char *outfile);
 135 static int parseargs (int argc, const char *argv[], struct commandline *cmd);
 136 static void usage (void);
 137 static void options_usage (void);
 138 static void c_initialize (void);
 139 static char *generate_guard (const char *pathname);
 140
 141
 142 #define ARGLISTLEN      20
 143 #define FIXEDARGS         2
 144
 145 static const char *arglist[ARGLISTLEN];
 146 static int argcount = FIXEDARGS;
 147
 148
 149 int nonfatalerrors;             /* errors */
 150 int inetdflag /* = 1 */ ;       /* Support for inetd *//* is now the default */
 151 int pmflag;                     /* Support for port monitors */
 152 int logflag;                    /* Use syslog instead of fprintf for errors */
 153 int tblflag;                    /* Support for dispatch table file */
 154 int mtflag;                     /* Support for MT */
 155
 156 #define INLINE 3
 157 /*length at which to start doing an inline */
 158
 159 int inlineflag = INLINE;        /* length at which to start doing an inline. 3 = default
 160                                    if 0, no xdr_inline code */
 161
 162 int indefinitewait;             /* If started by port monitors, hang till it wants */
 163 int exitnow;                    /* If started by port monitors, exit after the call */
 164 int timerflag;                  /* TRUE if !indefinite && !exitnow */
 165 int newstyle;                   /* newstyle of passing arguments (by value) */
 166 #ifdef __GNU_LIBRARY__
 167 int Cflag = 1;                  /* ANSI C syntax */
 168 #else
 169 int Cflag = 0;                  /* ANSI C/C++ syntax */
 170 #endif
 171 int CCflag = 0;                 /* C++ files */
 172 static int allfiles;            /* generate all files */
 173 #ifdef __GNU_LIBRARY__
 174 int tirpcflag = 0;              /* generating code for tirpc, by default */
 175 #else
 176 int tirpcflag = 1;              /* generating code for tirpc, by default */
 177 #endif
 178 xdrfunc *xdrfunc_head = NULL;   /* xdr function list */
 179 xdrfunc *xdrfunc_tail = NULL;   /* xdr function list */
 180
 181 int
 182 main (int argc, const char *argv[])
 183 {
 184   struct commandline cmd;
 185
 186   (void) memset ((char *) &cmd, 0, sizeof (struct commandline));
 187   clear_args ();
 188   if (!parseargs (argc, argv, &cmd))
 189     usage ();
 190
 191   if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
 192       cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag)
 193     {
 194       checkfiles (cmd.infile, cmd.outfile);
 195     }
 196   else
 197     checkfiles (cmd.infile, NULL);
 198
 199   if (cmd.cflag)
 200     c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
 201   else if (cmd.hflag)
 202     h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
 203   else if (cmd.lflag)
 204     l_output (cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
 205   else if (cmd.sflag || cmd.mflag || (cmd.nflag))
 206     s_output (argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
 207               cmd.outfile, cmd.mflag, cmd.nflag);
 208   else if (cmd.tflag)
 209     t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
 210   else if (cmd.Ssflag)
 211     svc_output (cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
 212   else if (cmd.Scflag)
 213     clnt_output (cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
 214   else if (cmd.makefileflag)
 215     mkfile_output (&cmd);
 216   else
 217     {
 218       /* the rescans are required, since cpp may effect input */
 219       c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
 220       reinitialize ();
 221       h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");
 222       reinitialize ();
 223       l_output (cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
 224       reinitialize ();
 225       if (inetdflag || !tirpcflag)
 226         s_output (allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
 227                   "_svc.c", cmd.mflag, cmd.nflag);
 228       else
 229         s_output (allnc, allnv, cmd.infile, "-DRPC_SVC",
 230                   EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
 231       if (tblflag)
 232         {
 233           reinitialize ();
 234           t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
 235         }
 236       if (allfiles)
 237         {
 238           reinitialize ();
 239           svc_output (cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
 240           reinitialize ();
 241           clnt_output (cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
 242         }
 243       if (allfiles || (cmd.makefileflag == 1))
 244         {
 245           reinitialize ();
 246           mkfile_output (&cmd);
 247         }
 248     }
 249   exit (nonfatalerrors);
 250   /* NOTREACHED */
 251 }
 252
 253 /*
 254  * add extension to filename
 255  */
 256 static char *
 257 extendfile (const char *file, const char *ext)
 258 {
 259   char *res;
 260   const char *p;
 261
 262   res = alloc (strlen (file) + strlen (ext) + 1);
 263   if (res == NULL)
 264     abort ();
 265   p = strrchr (file, '.');
 266   if (p == NULL)
 267     p = file + strlen (file);
 268   strcpy (res, file);
 269   strcpy (res + (p - file), ext);
 270   return res;
 271 }
 272
 273 /*
 274  * Open output file with given extension
 275  */
 276 static void
 277 open_output (const char *infile, const char *outfile)
 278 {
 279   if (outfile == NULL)
 280     {
 281       fout = stdout;
 282       return;
 283     }
 284
 285   if (infile != NULL && streq (outfile, infile))
 286     {
 287       fprintf (stderr, _ ("%s: output would overwrite %s\n"), cmdname,
 288                infile);
 289       crash ();
 290     }
 291   fout = fopen (outfile, "w");
 292   if (fout == NULL)
 293     {
 294       fprintf (stderr, _ ("%s: unable to open "), cmdname);
 295       perror (outfile);
 296       crash ();
 297     }
 298   record_open (outfile);
 299 }
 300
 301 /* Close the output file and check for write errors.  */
 302 static void
 303 close_output (const char *outfile)
 304 {
 305   if (fclose (fout) == EOF)
 306     {
 307       fprintf (stderr, _("%s: while writing output: "), cmdname);
 308       perror (outfile ?: "<stdout>");
 309       crash ();
 310     }
 311 }
 312
 313 static void
 314 add_warning (void)
 315 {
 316   fprintf (fout, "/*\n");
 317   fprintf (fout, " * Please do not edit this file.\n");
 318   fprintf (fout, " * It was generated using rpcgen.\n");
 319   fprintf (fout, " */\n\n");
 320 }
 321
 322 /* clear list of arguments */
 323 static void
 324 clear_args (void)
 325 {
 326   int i;
 327   for (i = FIXEDARGS; i < ARGLISTLEN; ++i)
 328     arglist[i] = NULL;
 329   argcount = FIXEDARGS;
 330 }
 331
 332 /* make sure that a CPP exists */
 333 static void
 334 find_cpp (void)
 335 {
 336   struct stat buf;
 337
 338   if (stat (CPP, &buf) < 0)
 339     {                           /* /lib/cpp or explicit cpp does not exist */
 340       if (cppDefined)
 341         {
 342           fprintf (stderr, _ ("cannot find C preprocessor: %s \n"), CPP);
 343           crash ();
 344         }
 345       else
 346         {                       /* try the other one */
 347           CPP = SVR4_CPP;
 348           if (stat (CPP, &buf) < 0)
 349             {                   /* can't find any cpp */
 350               fputs (_ ("cannot find any C preprocessor (cpp)\n"), stdout);
 351               crash ();
 352             }
 353         }
 354     }
 355 }
 356
 357 /*
 358  * Open input file with given define for C-preprocessor
 359  */
 360 static void
 361 open_input (const char *infile, const char *define)
 362 {
 363   int pd[2];
 364
 365   infilename = (infile == NULL) ? "<stdin>" : infile;
 366   if (pipe (pd) != 0)
 367     {
 368       perror ("pipe");
 369       exit (1);
 370     }
 371   cpp_pid = fork ();
 372   switch (cpp_pid)
 373     {
 374     case 0:
 375       find_cpp ();
 376       putarg (0, CPP);
 377       putarg (1, CPPFLAGS);
 378       addarg (define);
 379       if (infile)
 380         addarg (infile);
 381       addarg ((char *) NULL);
 382       close (1);
 383       dup2 (pd[1], 1);
 384       close (pd[0]);
 385       execv (arglist[0], (char **) arglist);
 386       perror ("execv");
 387       exit (1);
 388     case -1:
 389       perror ("fork");
 390       exit (1);
 391     }
 392   close (pd[1]);
 393   fin = fdopen (pd[0], "r");
 394   if (fin == NULL)
 395     {
 396       fprintf (stderr, "%s: ", cmdname);
 397       perror (infilename);
 398       crash ();
 399     }
 400 }
 401
 402 /* Close the connection to the C-preprocessor and check for successfull
 403    termination.  */
 404 static void
 405 close_input (void)
 406 {
 407   int status;
 408
 409   fclose (fin);
 410   /* Check the termination status.  */
 411   if (waitpid (cpp_pid, &status, 0) < 0)
 412     {
 413       perror ("waitpid");
 414       crash ();
 415     }
 416   if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
 417     {
 418       if (WIFSIGNALED (status))
 419         fprintf (stderr, _("%s: C preprocessor failed with signal %d\n"),
 420                  cmdname, WTERMSIG (status));
 421       else
 422         fprintf (stderr, _("%s: C preprocessor failed with exit code %d\n"),
 423                  cmdname, WEXITSTATUS (status));
 424       crash ();
 425     }
 426 }
 427
 428 /* valid tirpc nettypes */
 429 static const char *valid_ti_nettypes[] =
 430 {
 431   "netpath",
 432   "visible",
 433   "circuit_v",
 434   "datagram_v",
 435   "circuit_n",
 436   "datagram_n",
 437   "udp",
 438   "tcp",
 439   "raw",
 440   NULL
 441 };
 442
 443 /* valid inetd nettypes */
 444 static const char *valid_i_nettypes[] =
 445 {
 446   "udp",
 447   "tcp",
 448   NULL
 449 };
 450
 451 static int
 452 check_nettype (const char *name, const char *list_to_check[])
 453 {
 454   int i;
 455   for (i = 0; list_to_check[i] != NULL; i++)
 456     {
 457       if (strcmp (name, list_to_check[i]) == 0)
 458         {
 459           return 1;
 460         }
 461     }
 462   fprintf (stderr, _ ("illegal nettype :`%s'\n"), name);
 463   return 0;
 464 }
 465
 466 /*
 467  * Compile into an XDR routine output file
 468  */
 469
 470 static void
 471 c_output (const char *infile, const char *define, int extend,
 472           const char *outfile)
 473 {
 474   definition *def;
 475   char *include;
 476   const char *outfilename;
 477   long tell;
 478
 479   c_initialize ();
 480   open_input (infile, define);
 481   outfilename = extend ? extendfile (infile, outfile) : outfile;
 482   open_output (infile, outfilename);
 483   add_warning ();
 484   if (infile && (include = extendfile (infile, ".h")))
 485     {
 486       fprintf (fout, "#include \"%s\"\n", include);
 487       free (include);
 488       /* .h file already contains rpc/rpc.h */
 489     }
 490   else
 491     fprintf (fout, "#include <rpc/rpc.h>\n");
 492   tell = ftell (fout);
 493   while ((def = get_definition ()) != NULL)
 494     emit (def);
 495
 496   if (extend && tell == ftell (fout))
 497     unlink (outfilename);
 498   close_input ();
 499   close_output (outfilename);
 500 }
 501
 502 void
 503 c_initialize (void)
 504 {
 505
 506   /* add all the starting basic types */
 507
 508   add_type (1, "int");
 509   add_type (1, "long");
 510   add_type (1, "short");
 511   add_type (1, "bool");
 512
 513   add_type (1, "u_int");
 514   add_type (1, "u_long");
 515   add_type (1, "u_short");
 516
 517 }
 518
 519 char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
 520         char    *(*proc)();\n\
 521         xdrproc_t       xdr_arg;\n\
 522         unsigned        len_arg;\n\
 523         xdrproc_t       xdr_res;\n\
 524         unsigned        len_res;\n\
 525 };\n";
 526
 527
 528 static char *
 529 generate_guard (const char *pathname)
 530 {
 531   const char *filename;
 532   char *guard, *tmp;
 533
 534   filename = strrchr (pathname, '/');   /* find last component */
 535   filename = ((filename == NULL) ? pathname : filename + 1);
 536   guard = strdup (filename);
 537   /* convert to upper case */
 538   tmp = guard;
 539   while (*tmp)
 540     {
 541       if (islower (*tmp))
 542         *tmp = toupper (*tmp);
 543       tmp++;
 544     }
 545
 546   guard = extendfile (guard, "_H_RPCGEN");
 547   return guard;
 548 }
 549
 550 /*
 551  * Compile into an XDR header file
 552  */
 553
 554
 555 static void
 556 h_output (const char *infile, const char *define, int extend,
 557           const char *outfile)
 558 {
 559   xdrfunc *xdrfuncp;
 560   definition *def;
 561   const char *ifilename;
 562   const char *outfilename;
 563   long tell;
 564   char *guard;
 565   list *l;
 566
 567   open_input (infile, define);
 568   outfilename = extend ? extendfile (infile, outfile) : outfile;
 569   open_output (infile, outfilename);
 570   add_warning ();
 571   ifilename = (infile == NULL) ? "STDIN" : infile;
 572   guard = generate_guard (outfilename ? outfilename : ifilename);
 573
 574   fprintf (fout, "#ifndef _%s\n#define _%s\n\n", guard,
 575            guard);
 576
 577   fprintf (fout, "#include <rpc/rpc.h>\n\n");
 578
 579   if (mtflag)
 580     {
 581       fprintf (fout, "#include <pthread.h>\n");
 582     }
 583
 584   /* put the C++ support */
 585   if (Cflag && !CCflag)
 586     {
 587       fprintf (fout, "\n#ifdef __cplusplus\n");
 588       fprintf (fout, "extern \"C\" {\n");
 589       fprintf (fout, "#endif\n\n");
 590     }
 591
 592   tell = ftell (fout);
 593   /* print data definitions */
 594   while ((def = get_definition ()) != NULL)
 595     {
 596       print_datadef (def);
 597     }
 598
 599   /* print function declarations.
 600      Do this after data definitions because they might be used as
 601      arguments for functions */
 602   for (l = defined; l != NULL; l = l->next)
 603     {
 604       print_funcdef (l->val);
 605     }
 606   /* Now  print all xdr func declarations */
 607   if (xdrfunc_head != NULL)
 608     {
 609       fprintf (fout, "\n/* the xdr functions */\n");
 610       if (CCflag)
 611         {
 612           fprintf (fout, "\n#ifdef __cplusplus\n");
 613           fprintf (fout, "extern \"C\" {\n");
 614           fprintf (fout, "#endif\n");
 615         }
 616       if (!Cflag)
 617         {
 618           xdrfuncp = xdrfunc_head;
 619           while (xdrfuncp != NULL)
 620             {
 621               print_xdr_func_def (xdrfuncp->name,
 622                                   xdrfuncp->pointerp, 2);
 623               xdrfuncp = xdrfuncp->next;
 624             }
 625         }
 626       else
 627         {
 628           int i;
 629
 630           for (i = 1; i < 3; ++i)
 631             {
 632               if (i == 1)
 633                 fprintf (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");
 634               else
 635                 fprintf (fout, "\n#else /* K&R C */\n");
 636
 637               xdrfuncp = xdrfunc_head;
 638               while (xdrfuncp != NULL)
 639                 {
 640                   print_xdr_func_def (xdrfuncp->name,
 641                                       xdrfuncp->pointerp, i);
 642                   xdrfuncp = xdrfuncp->next;
 643                 }
 644             }
 645           fprintf (fout, "\n#endif /* K&R C */\n");
 646         }
 647     }
 648
 649   if (extend && tell == ftell (fout))
 650     {
 651       unlink (outfilename);
 652     }
 653   else if (tblflag)
 654     {
 655       fprintf (fout, rpcgen_table_dcl);
 656     }
 657
 658   if (Cflag)
 659     {
 660       fprintf (fout, "\n#ifdef __cplusplus\n");
 661       fprintf (fout, "}\n");
 662       fprintf (fout, "#endif\n");
 663     }
 664
 665   fprintf (fout, "\n#endif /* !_%s */\n", guard);
 666   close_input ();
 667   close_output (outfilename);
 668 }
 669
 670 /*
 671  * Compile into an RPC service
 672  */
 673 static void
 674 s_output (int argc, const char *argv[], const char *infile, const char *define,
 675           int extend, const char *outfile, int nomain, int netflag)
 676 {
 677   char *include;
 678   definition *def;
 679   int foundprogram = 0;
 680   const char *outfilename;
 681
 682   open_input (infile, define);
 683   outfilename = extend ? extendfile (infile, outfile) : outfile;
 684   open_output (infile, outfilename);
 685   add_warning ();
 686   if (infile && (include = extendfile (infile, ".h")))
 687     {
 688       fprintf (fout, "#include \"%s\"\n", include);
 689       free (include);
 690     }
 691   else
 692     fprintf (fout, "#include <rpc/rpc.h>\n");
 693
 694   fprintf (fout, "#include <stdio.h>\n");
 695   fprintf (fout, "#include <stdlib.h>\n");
 696   if (Cflag)
 697     {
 698       fprintf (fout, "#include <rpc/pmap_clnt.h>\n");
 699       fprintf (fout, "#include <string.h>\n");
 700     }
 701   if (strcmp (svcclosetime, "-1") == 0)
 702     indefinitewait = 1;
 703   else if (strcmp (svcclosetime, "0") == 0)
 704     exitnow = 1;
 705   else if (inetdflag || pmflag)
 706     {
 707       fprintf (fout, "#include <signal.h>\n");
 708       timerflag = 1;
 709     }
 710
 711   if (!tirpcflag && inetdflag)
 712 #ifdef __GNU_LIBRARY__
 713     fprintf (fout, "#include <sys/ioctl.h> /* ioctl, TIOCNOTTY */\n");
 714 #else
 715     fprintf (fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
 716 #endif
 717   if (Cflag && (inetdflag || pmflag))
 718     {
 719 #ifdef __GNU_LIBRARY__
 720       fprintf (fout, "#include <sys/types.h> /* open */\n");
 721       fprintf (fout, "#include <sys/stat.h> /* open */\n");
 722       fprintf (fout, "#include <fcntl.h> /* open */\n");
 723       fprintf (fout, "#include <unistd.h> /* getdtablesize */\n");
 724 #else
 725       fprintf (fout, "#ifdef __cplusplus\n");
 726       fprintf (fout, "#include <sysent.h> /* getdtablesize, open */\n");
 727       fprintf (fout, "#endif /* __cplusplus */\n");
 728       if (tirpcflag)
 729         fprintf (fout, "#include <unistd.h> /* setsid */\n");
 730 #endif
 731     }
 732 #ifdef __GNU_LIBRARY__
 733   if (tirpcflag && !(Cflag && (inetdflag || pmflag)))
 734 #else
 735   if (tirpcflag)
 736 #endif
 737     fprintf (fout, "#include <sys/types.h>\n");
 738
 739   fprintf (fout, "#include <memory.h>\n");
 740 #ifndef __GNU_LIBRARY__
 741   fprintf (fout, "#include <stropts.h>\n");
 742 #endif
 743   if (inetdflag || !tirpcflag)
 744     {
 745       fprintf (fout, "#include <sys/socket.h>\n");
 746       fprintf (fout, "#include <netinet/in.h>\n");
 747     }
 748
 749   if ((netflag || pmflag) && tirpcflag && !nomain)
 750     {
 751       fprintf (fout, "#include <netconfig.h>\n");
 752     }
 753   if ( /*timerflag && */ tirpcflag)
 754     fprintf (fout, "#include <sys/resource.h> /* rlimit */\n");
 755   if (logflag || inetdflag || pmflag)
 756     {
 757 #ifdef __GNU_LIBRARY__
 758       fprintf (fout, "#include <syslog.h>\n");
 759 #else
 760       fprintf (fout, "#ifdef SYSLOG\n");
 761       fprintf (fout, "#include <syslog.h>\n");
 762       fprintf (fout, "#else\n");
 763       fprintf (fout, "#define LOG_ERR 1\n");
 764       fprintf (fout, "#define openlog(a, b, c)\n");
 765       fprintf (fout, "#endif\n");
 766 #endif
 767     }
 768
 769   /* for ANSI-C */
 770   if (Cflag)
 771     fprintf (fout, "\n#ifndef SIG_PF\n#define SIG_PF void(*)(int)\n#endif\n");
 772
 773 #ifndef __GNU_LIBRARY__
 774   fprintf (fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
 775 #endif
 776   if (timerflag)
 777     fprintf (fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
 778   while ((def = get_definition ()) != NULL)
 779     {
 780       foundprogram |= (def->def_kind == DEF_PROGRAM);
 781     }
 782   if (extend && !foundprogram)
 783     {
 784       unlink (outfilename);
 785       return;
 786     }
 787   write_most (infile, netflag, nomain);
 788   if (!nomain)
 789     {
 790       if (!do_registers (argc, argv))
 791         {
 792           if (outfilename)
 793             unlink (outfilename);
 794           usage ();
 795         }
 796       write_rest ();
 797     }
 798   close_input ();
 799   close_output (outfilename);
 800 }
 801
 802 /*
 803  * generate client side stubs
 804  */
 805 static void
 806 l_output (const char *infile, const char *define, int extend,
 807           const char *outfile)
 808 {
 809   char *include;
 810   definition *def;
 811   int foundprogram = 0;
 812   const char *outfilename;
 813
 814   open_input (infile, define);
 815   outfilename = extend ? extendfile (infile, outfile) : outfile;
 816   open_output (infile, outfilename);
 817   add_warning ();
 818   if (Cflag)
 819     fprintf (fout, "#include <memory.h> /* for memset */\n");
 820   if (infile && (include = extendfile (infile, ".h")))
 821     {
 822       fprintf (fout, "#include \"%s\"\n", include);
 823       free (include);
 824     }
 825   else
 826     fprintf (fout, "#include <rpc/rpc.h>\n");
 827   while ((def = get_definition ()) != NULL)
 828     {
 829       foundprogram |= (def->def_kind == DEF_PROGRAM);
 830     }
 831   if (extend && !foundprogram)
 832     {
 833       unlink (outfilename);
 834       return;
 835     }
 836   write_stubs ();
 837   close_input ();
 838   close_output (outfilename);
 839 }
 840
 841 /*
 842  * generate the dispatch table
 843  */
 844 static void
 845 t_output (const char *infile, const char *define, int extend,
 846           const char *outfile)
 847 {
 848   definition *def;
 849   int foundprogram = 0;
 850   const char *outfilename;
 851
 852   open_input (infile, define);
 853   outfilename = extend ? extendfile (infile, outfile) : outfile;
 854   open_output (infile, outfilename);
 855   add_warning ();
 856   while ((def = get_definition ()) != NULL)
 857     {
 858       foundprogram |= (def->def_kind == DEF_PROGRAM);
 859     }
 860   if (extend && !foundprogram)
 861     {
 862       unlink (outfilename);
 863       return;
 864     }
 865   write_tables ();
 866   close_input ();
 867   close_output (outfilename);
 868 }
 869
 870 /* sample routine for the server template */
 871 static void
 872 svc_output (const char *infile, const char *define, int extend,
 873             const char *outfile)
 874 {
 875   definition *def;
 876   char *include;
 877   const char *outfilename;
 878   long tell;
 879
 880   open_input (infile, define);
 881   outfilename = extend ? extendfile (infile, outfile) : outfile;
 882   checkfiles (infile, outfilename);
 883   /*check if outfile already exists.
 884      if so, print an error message and exit */
 885   open_output (infile, outfilename);
 886   add_sample_msg ();
 887
 888   if (infile && (include = extendfile (infile, ".h")))
 889     {
 890       fprintf (fout, "#include \"%s\"\n", include);
 891       free (include);
 892     }
 893   else
 894     fprintf (fout, "#include <rpc/rpc.h>\n");
 895
 896   tell = ftell (fout);
 897   while ((def = get_definition ()) != NULL)
 898     {
 899       write_sample_svc (def);
 900     }
 901   if (extend && tell == ftell (fout))
 902     {
 903       unlink (outfilename);
 904     }
 905   close_input ();
 906   close_output (outfilename);
 907 }
 908
 909
 910 /* sample main routine for client */
 911 static void
 912 clnt_output (const char *infile, const char *define, int extend,
 913              const char *outfile)
 914 {
 915   definition *def;
 916   char *include;
 917   const char *outfilename;
 918   long tell;
 919   int has_program = 0;
 920
 921   open_input (infile, define);
 922   outfilename = extend ? extendfile (infile, outfile) : outfile;
 923   checkfiles (infile, outfilename);
 924   /*check if outfile already exists.
 925      if so, print an error message and exit */
 926
 927   open_output (infile, outfilename);
 928   add_sample_msg ();
 929   if (infile && (include = extendfile (infile, ".h")))
 930     {
 931       fprintf (fout, "#include \"%s\"\n", include);
 932       free (include);
 933     }
 934   else
 935     fprintf (fout, "#include <rpc/rpc.h>\n");
 936   tell = ftell (fout);
 937   while ((def = get_definition ()) != NULL)
 938     {
 939       has_program += write_sample_clnt (def);
 940     }
 941
 942   if (has_program)
 943     write_sample_clnt_main ();
 944
 945   if (extend && tell == ftell (fout))
 946     {
 947       unlink (outfilename);
 948     }
 949   close_input ();
 950   close_output (outfilename);
 951 }
 952
 953 static char *
 954 file_name (const char *file, const char *ext)
 955 {
 956   char *temp;
 957   temp = extendfile (file, ext);
 958
 959   if (access (temp, F_OK) != -1)
 960     return (temp);
 961   else
 962     return ((char *) " ");
 963 }
 964
 965 static void
 966 mkfile_output (struct commandline *cmd)
 967 {
 968   char *mkfilename;
 969   const char *clientname, *clntname, *xdrname, *hdrname;
 970   const char *servername, *svcname, *servprogname, *clntprogname;
 971
 972   svcname = file_name (cmd->infile, "_svc.c");
 973   clntname = file_name (cmd->infile, "_clnt.c");
 974   xdrname = file_name (cmd->infile, "_xdr.c");
 975   hdrname = file_name (cmd->infile, ".h");
 976
 977   if (allfiles)
 978     {
 979       servername = extendfile (cmd->infile, "_server.c");
 980       clientname = extendfile (cmd->infile, "_client.c");
 981     }
 982   else
 983     {
 984       servername = " ";
 985       clientname = " ";
 986     }
 987   servprogname = extendfile (cmd->infile, "_server");
 988   clntprogname = extendfile (cmd->infile, "_client");
 989
 990   if (allfiles)
 991     {
 992       char *cp, *temp;
 993
 994       mkfilename = alloc (strlen ("Makefile.") + strlen (cmd->infile) + 1);
 995       temp = rindex (cmd->infile, '.');
 996       cp = stpcpy (mkfilename, "Makefile.");
 997       strncpy (cp, cmd->infile, (temp - cmd->infile));
 998     }
 999   else
1000     mkfilename = (char *) cmd->outfile;
1001
1002   checkfiles (NULL, mkfilename);
1003   open_output (NULL, mkfilename);
1004
1005   fprintf (fout, "\n# This is a template Makefile generated by rpcgen\n");
1006
1007   f_print (fout, "\n# Parameters\n\n");
1008
1009   f_print (fout, "CLIENT = %s\nSERVER = %s\n\n", clntprogname, servprogname);
1010   f_print (fout, "SOURCES_CLNT.c = \nSOURCES_CLNT.h = \n");
1011   f_print (fout, "SOURCES_SVC.c = \nSOURCES_SVC.h = \n");
1012   f_print (fout, "SOURCES.x = %s\n\n", cmd->infile);
1013   f_print (fout, "TARGETS_SVC.c = %s %s %s \n",
1014            svcname, servername, xdrname);
1015   f_print (fout, "TARGETS_CLNT.c = %s %s %s \n",
1016            clntname, clientname, xdrname);
1017   f_print (fout, "TARGETS = %s %s %s %s %s %s\n\n",
1018            hdrname, xdrname, clntname,
1019            svcname, clientname, servername);
1020
1021   f_print (fout, "OBJECTS_CLNT = $(SOURCES_CLNT.c:%%.c=%%.o) \
1022 $(TARGETS_CLNT.c:%%.c=%%.o)");
1023
1024   f_print (fout, "\nOBJECTS_SVC = $(SOURCES_SVC.c:%%.c=%%.o) \
1025 $(TARGETS_SVC.c:%%.c=%%.o)");
1026
1027   f_print (fout, "\n# Compiler flags \n");
1028   if (mtflag)
1029     fprintf (fout, "\nCPPFLAGS += -D_REENTRANT\nCFLAGS += -g \nLDLIBS \
1030 += -lnsl -lpthread \n ");
1031   else
1032     f_print (fout, "\nCFLAGS += -g \nLDLIBS += -lnsl\n");
1033   f_print (fout, "RPCGENFLAGS = \n");
1034
1035   f_print (fout, "\n# Targets \n\n");
1036
1037   f_print (fout, "all : $(CLIENT) $(SERVER)\n\n");
1038   f_print (fout, "$(TARGETS) : $(SOURCES.x) \n");
1039   f_print (fout, "\trpcgen $(RPCGENFLAGS) $(SOURCES.x)\n\n");
1040   f_print (fout, "$(OBJECTS_CLNT) : $(SOURCES_CLNT.c) $(SOURCES_CLNT.h) \
1041 $(TARGETS_CLNT.c) \n\n");
1042
1043   f_print (fout, "$(OBJECTS_SVC) : $(SOURCES_SVC.c) $(SOURCES_SVC.h) \
1044 $(TARGETS_SVC.c) \n\n");
1045   f_print (fout, "$(CLIENT) : $(OBJECTS_CLNT) \n");
1046   f_print (fout, "\t$(LINK.c) -o $(CLIENT) $(OBJECTS_CLNT) \
1047 $(LDLIBS) \n\n");
1048   f_print (fout, "$(SERVER) : $(OBJECTS_SVC) \n");
1049   f_print (fout, "\t$(LINK.c) -o $(SERVER) $(OBJECTS_SVC) $(LDLIBS)\n\n ");
1050   f_print (fout, "clean:\n\t $(RM) core $(TARGETS) $(OBJECTS_CLNT) \
1051 $(OBJECTS_SVC) $(CLIENT) $(SERVER)\n\n");
1052   close_output (mkfilename);
1053 }
1054
1055 /*
1056  * Perform registrations for service output
1057  * Return 0 if failed; 1 otherwise.
1058  */
1059 static int
1060 do_registers (int argc, const char *argv[])
1061 {
1062   int i;
1063
1064   if (inetdflag || !tirpcflag)
1065     {
1066       for (i = 1; i < argc; i++)
1067         {
1068           if (streq (argv[i], "-s"))
1069             {
1070               if (!check_nettype (argv[i + 1], valid_i_nettypes))
1071                 return 0;
1072               write_inetd_register (argv[i + 1]);
1073               i++;
1074             }
1075         }
1076     }
1077   else
1078     {
1079       for (i = 1; i < argc; i++)
1080         if (streq (argv[i], "-s"))
1081           {
1082             if (!check_nettype (argv[i + 1], valid_ti_nettypes))
1083               return 0;
1084             write_nettype_register (argv[i + 1]);
1085             i++;
1086           }
1087         else if (streq (argv[i], "-n"))
1088           {
1089             write_netid_register (argv[i + 1]);
1090             i++;
1091           }
1092     }
1093   return 1;
1094 }
1095
1096 /*
1097  * Add another argument to the arg list
1098  */
1099 static void
1100 addarg (const char *cp)
1101 {
1102   if (argcount >= ARGLISTLEN)
1103     {
1104       fprintf (stderr, _("rpcgen: too many defines\n"));
1105       crash ();
1106       /*NOTREACHED */
1107     }
1108   arglist[argcount++] = cp;
1109 }
1110
1111 static void
1112 putarg (int whereto, const char *cp)
1113 {
1114   if (whereto >= ARGLISTLEN)
1115     {
1116       fprintf (stderr, _("rpcgen: arglist coding error\n"));
1117       crash ();
1118       /*NOTREACHED */
1119     }
1120   arglist[whereto] = cp;
1121 }
1122
1123 /*
1124  * if input file is stdin and an output file is specified then complain
1125  * if the file already exists. Otherwise the file may get overwritten
1126  * If input file does not exist, exit with an error
1127  */
1128
1129 static void
1130 checkfiles (const char *infile, const char *outfile)
1131 {
1132   struct stat buf;
1133
1134   if (infile)                   /* infile ! = NULL */
1135     if (stat (infile, &buf) < 0)
1136       {
1137         perror (infile);
1138         crash ();
1139       }
1140   if (outfile)
1141     {
1142       if (stat (outfile, &buf) < 0)
1143         return;                 /* file does not exist */
1144       else
1145         {
1146           fprintf (stderr,
1147                    _("file `%s' already exists and may be overwritten\n"),
1148                    outfile);
1149           crash ();
1150         }
1151     }
1152 }
1153
1154 /*
1155  * Parse command line arguments
1156  */
1157 static int
1158 parseargs (int argc, const char *argv[], struct commandline *cmd)
1159 {
1160   int i;
1161   int j;
1162   int c;
1163   char flag[(1 << 8 * sizeof (char))];
1164   int nflags;
1165
1166   cmdname = argv[0];
1167   cmd->infile = cmd->outfile = NULL;
1168   if (argc < 2)
1169     {
1170       return (0);
1171     }
1172   allfiles = 0;
1173   flag['c'] = 0;
1174   flag['h'] = 0;
1175   flag['l'] = 0;
1176   flag['m'] = 0;
1177   flag['o'] = 0;
1178   flag['s'] = 0;
1179   flag['n'] = 0;
1180   flag['t'] = 0;
1181   flag['S'] = 0;
1182   flag['C'] = 0;
1183   flag['M'] = 0;
1184
1185   for (i = 1; i < argc; i++)
1186     {
1187       if (argv[i][0] != '-')
1188         {
1189           if (cmd->infile)
1190             {
1191               fprintf (stderr,
1192                        _("Cannot specify more than one input file!\n"));
1193               return 0;
1194             }
1195           cmd->infile = argv[i];
1196         }
1197       else
1198         {
1199           for (j = 1; argv[i][j] != 0; j++)
1200             {
1201               c = argv[i][j];
1202               switch (c)
1203                 {
1204                 case 'a':
1205                   allfiles = 1;
1206                   break;
1207                 case 'c':
1208                 case 'h':
1209                 case 'l':
1210                 case 'm':
1211                 case 't':
1212                   if (flag[c])
1213                     return 0;
1214                   flag[c] = 1;
1215                   break;
1216                 case 'S':
1217                   /* sample flag: Ss or Sc.
1218                      Ss means set flag['S'];
1219                      Sc means set flag['C'];
1220                      Sm means set flag['M']; */
1221                   c = argv[i][++j];     /* get next char */
1222                   if (c == 's')
1223                     c = 'S';
1224                   else if (c == 'c')
1225                     c = 'C';
1226                   else if (c == 'm')
1227                     c = 'M';
1228                   else
1229                     return 0;
1230
1231                   if (flag[c])
1232                     return 0;
1233                   flag[c] = 1;
1234                   break;
1235                 case 'C':       /* ANSI C syntax */
1236                   Cflag = 1;
1237                   break;
1238
1239 #ifdef __GNU_LIBRARY__
1240                 case 'k':  /* K&R C syntax */
1241                   Cflag = 0;
1242                   break;
1243
1244 #endif
1245                 case 'b':  /* turn TIRPC flag off for
1246                               generating backward compatible
1247                            */
1248                   tirpcflag = 0;
1249                   break;
1250
1251 #ifdef __GNU_LIBRARY__
1252                 case '5':  /* turn TIRPC flag on for
1253                               generating SysVr4 compatible
1254                            */
1255                   tirpcflag = 1;
1256                   break;
1257 #endif
1258                 case 'I':
1259                   inetdflag = 1;
1260                   break;
1261                 case 'N':
1262                   newstyle = 1;
1263                   break;
1264                 case 'L':
1265                   logflag = 1;
1266                   break;
1267                 case 'K':
1268                   if (++i == argc)
1269                     {
1270                       return (0);
1271                     }
1272                   svcclosetime = argv[i];
1273                   goto nextarg;
1274                 case 'T':
1275                   tblflag = 1;
1276                   break;
1277                 case 'M':
1278                   mtflag = 1;
1279                   break;
1280                 case 'i':
1281                   if (++i == argc)
1282                     {
1283                       return (0);
1284                     }
1285                   inlineflag = atoi (argv[i]);
1286                   goto nextarg;
1287                 case 'n':
1288                 case 'o':
1289                 case 's':
1290                   if (argv[i][j - 1] != '-' ||
1291                       argv[i][j + 1] != 0)
1292                     {
1293                       return (0);
1294                     }
1295                   flag[c] = 1;
1296                   if (++i == argc)
1297                     {
1298                       return (0);
1299                     }
1300                   if (c == 's')
1301                     {
1302                       if (!streq (argv[i], "udp") &&
1303                           !streq (argv[i], "tcp"))
1304                         return 0;
1305                     }
1306                   else if (c == 'o')
1307                     {
1308                       if (cmd->outfile)
1309                         return 0;
1310                       cmd->outfile = argv[i];
1311                     }
1312                   goto nextarg;
1313                 case 'D':
1314                   if (argv[i][j - 1] != '-')
1315                     return 0;
1316                   addarg (argv[i]);
1317                   goto nextarg;
1318                 case 'Y':
1319                   if (++i == argc)
1320                     return 0;
1321                   {
1322                     size_t len = strlen (argv[i]);
1323                     pathbuf = malloc (len + 5);
1324                     if (pathbuf == NULL)
1325                       {
1326                         perror (cmdname);
1327                         crash ();
1328                       }
1329                     stpcpy (stpcpy (pathbuf,
1330                                     argv[i]),
1331                             "/cpp");
1332                     CPP = pathbuf;
1333                     cppDefined = 1;
1334                     goto nextarg;
1335                   }
1336
1337                 default:
1338                   return 0;
1339                 }
1340               }
1341         nextarg:
1342           ;
1343         }
1344     }
1345
1346   cmd->cflag = flag['c'];
1347   cmd->hflag = flag['h'];
1348   cmd->lflag = flag['l'];
1349   cmd->mflag = flag['m'];
1350   cmd->nflag = flag['n'];
1351   cmd->sflag = flag['s'];
1352   cmd->tflag = flag['t'];
1353   cmd->Ssflag = flag['S'];
1354   cmd->Scflag = flag['C'];
1355   cmd->makefileflag = flag['M'];
1356
1357   if (tirpcflag)
1358     {
1359       pmflag = inetdflag ? 0 : 1;    /* pmflag or inetdflag is always TRUE */
1360       if ((inetdflag && cmd->nflag))
1361         {                       /* netid not allowed with inetdflag */
1362           fprintf (stderr, _("Cannot use netid flag with inetd flag!\n"));
1363           return 0;
1364         }
1365     }
1366   else
1367     {                           /* 4.1 mode */
1368       pmflag = 0;               /* set pmflag only in tirpcmode */
1369 #ifndef __GNU_LIBRARY__
1370       inetdflag = 1;            /* inetdflag is TRUE by default */
1371 #endif
1372       if (cmd->nflag)
1373         {                       /* netid needs TIRPC */
1374           f_print (stderr, _("Cannot use netid flag without TIRPC!\n"));
1375           return (0);
1376         }
1377     }
1378
1379   if (newstyle && (tblflag || cmd->tflag))
1380     {
1381       f_print (stderr, _("Cannot use table flags with newstyle!\n"));
1382       return (0);
1383     }
1384
1385   /* check no conflicts with file generation flags */
1386   nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
1387     cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
1388
1389   if (nflags == 0)
1390     {
1391       if (cmd->outfile != NULL || cmd->infile == NULL)
1392         {
1393           return (0);
1394         }
1395     }
1396   else if (cmd->infile == NULL &&
1397            (cmd->Ssflag || cmd->Scflag || cmd->makefileflag))
1398     {
1399       fprintf (stderr,
1400                _("\"infile\" is required for template generation flags.\n"));
1401       return 0;
1402     }
1403   if (nflags > 1)
1404     {
1405       fprintf (stderr, _("Cannot have more than one file generation flag!\n"));
1406       return 0;
1407     }
1408   return 1;
1409 }
1410
1411 static void
1412 usage (void)
1413 {
1414   fprintf (stderr, _("usage: %s infile\n"), cmdname);
1415   fprintf (stderr, _("\t%s [-abkCLNTM][-Dname[=value]] [-i size] \
1416 [-I [-K seconds]] [-Y path] infile\n"), cmdname);
1417   fprintf (stderr, _("\t%s [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] \
1418 [-o outfile] [infile]\n"), cmdname);
1419   fprintf (stderr, _("\t%s [-s nettype]* [-o outfile] [infile]\n"), cmdname);
1420   fprintf (stderr, _("\t%s [-n netid]* [-o outfile] [infile]\n"), cmdname);
1421   options_usage ();
1422   exit (1);
1423 }
1424
1425 static void
1426 options_usage (void)
1427 {
1428   f_print (stderr, "options:\n");
1429   f_print (stderr, "-a\t\tgenerate all files, including samples\n");
1430   f_print (stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
1431   f_print (stderr, "-c\t\tgenerate XDR routines\n");
1432   f_print (stderr, "-C\t\tANSI C mode\n");
1433   f_print (stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
1434   f_print (stderr, "-h\t\tgenerate header file\n");
1435   f_print (stderr, "-i size\t\tsize at which to start generating inline code\n");
1436   f_print (stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
1437   f_print (stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
1438   f_print (stderr, "-l\t\tgenerate client side stubs\n");
1439   f_print (stderr, "-L\t\tserver errors will be printed to syslog\n");
1440   f_print (stderr, "-m\t\tgenerate server side stubs\n");
1441   f_print (stderr, "-M\t\tgenerate MT-safe code\n");
1442   f_print (stderr, "-n netid\tgenerate server code that supports named netid\n");
1443   f_print (stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
1444   f_print (stderr, "-o outfile\tname of the output file\n");
1445   f_print (stderr, "-s nettype\tgenerate server code that supports named nettype\n");
1446   f_print (stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
1447   f_print (stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
1448   f_print (stderr, "-Sm \t\tgenerate makefile template \n");
1449   f_print (stderr, "-t\t\tgenerate RPC dispatch table\n");
1450   f_print (stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
1451   f_print (stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
1452
1453   exit (1);
1454 }