.
[kopensolaris-gnu/glibc.git] / 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 #if defined(LIBC_SCCS) && !defined(lint)
35 static const char main_rcsid[] =
36   "$Id$";
37 #endif
38
39 /*
40  * rpc_main.c, Top level of the RPC protocol compiler.
41  */
42
43 #include <errno.h>
44 #include <stdio.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <libintl.h>
48 #include <ctype.h>
49 #include <sys/types.h>
50 #include <sys/param.h>
51 #include <sys/file.h>
52 #include <sys/stat.h>
53 #include <sys/wait.h>
54 #include "rpc_parse.h"
55 #include "rpc_util.h"
56 #include "rpc_scan.h"
57 #include "proto.h"
58
59 #define EXTEND  1               /* alias for TRUE */
60 #define DONT_EXTEND     0       /* alias for FALSE */
61
62 struct commandline
63   {
64     int cflag;                  /* xdr C routines */
65     int hflag;                  /* header file */
66     int lflag;                  /* client side stubs */
67     int mflag;                  /* server side stubs */
68     int nflag;                  /* netid flag */
69     int sflag;                  /* server stubs for the given transport */
70     int tflag;                  /* dispatch Table file */
71     int Ssflag;                 /* produce server sample code */
72     int Scflag;                 /* produce client sample code */
73     int makefileflag;           /* Generate a template Makefile */
74     const char *infile;         /* input module name */
75     const char *outfile;        /* output module name */
76   };
77
78
79 static const char *cmdname;
80
81 #define SVR4_CPP "/usr/ccs/lib/cpp"
82 #define SUNOS_CPP "/lib/cpp"
83
84 static const char *svcclosetime = "120";
85 static int cppDefined;  /* explicit path for C preprocessor */
86 static const char *CPP = SUNOS_CPP;
87 static const char CPPFLAGS[] = "-C";
88 static char *pathbuf;
89 static int cpp_pid;
90 static const char *allv[] =
91 {
92   "rpcgen", "-s", "udp", "-s", "tcp"
93 };
94 static int allc = sizeof (allv) / sizeof (allv[0]);
95 static const char *allnv[] =
96 {
97   "rpcgen", "-s", "netpath",
98 };
99 static int allnc = sizeof (allnv) / sizeof (allnv[0]);
100
101 /*
102  * machinations for handling expanding argument list
103  */
104 static void addarg (const char *);      /* add another argument to the list */
105 static void putarg (int, const char *);         /* put argument at specified location */
106 static void clear_args (void);  /* clear argument list */
107 static void checkfiles (const char *, const char *);
108                                        /* check if out file already exists */
109
110 static void clear_args (void);
111 static char *extendfile (const char *file, const char *ext);
112 static void open_output (const char *infile, const char *outfile);
113 static void add_warning (void);
114 static void clear_args (void);
115 static void find_cpp (void);
116 static void open_input (const char *infile, const char *define);
117 static int check_nettype (const char *name, const char *list_to_check[]);
118 static void c_output (const char *infile, const char *define,
119                       int extend, const char *outfile);
120 static void h_output (const char *infile, const char *define,
121                       int extend, const char *outfile);
122 static void s_output (int argc, const char *argv[], const char *infile,
123                       const char *define, int extend,
124                       const char *outfile, int nomain, int netflag);
125 static void l_output (const char *infile, const char *define,
126                       int extend, const char *outfile);
127 static void t_output (const char *infile, const char *define,
128                       int extend, const char *outfile);
129 static void svc_output (const char *infile, const char *define,
130                         int extend, const char *outfile);
131 static void clnt_output (const char *infile, const char *define,
132                          int extend, const char *outfile);
133 static void mkfile_output (struct commandline *cmd);
134 static int do_registers (int argc, const char *argv[]);
135 static void addarg (const char *cp);
136 static void putarg (int whereto, const char *cp);
137 static void checkfiles (const char *infile, const char *outfile);
138 static int parseargs (int argc, const char *argv[], struct commandline *cmd);
139 static void usage (void) __attribute__ ((noreturn));
140 static void options_usage (void) __attribute__ ((noreturn));
141 static void c_initialize (void);
142 static char *generate_guard (const char *pathname);
143
144
145 #define ARGLISTLEN      20
146 #define FIXEDARGS         2
147
148 static const char *arglist[ARGLISTLEN];
149 static int argcount = FIXEDARGS;
150
151
152 int nonfatalerrors;             /* errors */
153 int inetdflag /* = 1 */ ;       /* Support for inetd *//* is now the default */
154 int pmflag;                     /* Support for port monitors */
155 int logflag;                    /* Use syslog instead of fprintf for errors */
156 int tblflag;                    /* Support for dispatch table file */
157 int mtflag;                     /* Support for MT */
158
159 #define INLINE 3
160 /*length at which to start doing an inline */
161
162 int inlineflag = INLINE;        /* length at which to start doing an inline. 3 = default
163                                    if 0, no xdr_inline code */
164
165 int indefinitewait;             /* If started by port monitors, hang till it wants */
166 int exitnow;                    /* If started by port monitors, exit after the call */
167 int timerflag;                  /* TRUE if !indefinite && !exitnow */
168 int newstyle;                   /* newstyle of passing arguments (by value) */
169 #ifdef __GNU_LIBRARY__
170 int Cflag = 1;                  /* ANSI C syntax */
171 #else
172 int Cflag;                      /* ANSI C/C++ syntax */
173 #endif
174 int CCflag;                     /* C++ files */
175 static int allfiles;            /* generate all files */
176 #ifdef __GNU_LIBRARY__
177 int tirpcflag;                  /* generating code for tirpc, by default */
178 #else
179 int tirpcflag = 1;              /* generating code for tirpc, by default */
180 #endif
181 xdrfunc *xdrfunc_head;          /* xdr function list */
182 xdrfunc *xdrfunc_tail;          /* xdr function list */
183
184 int
185 main (int argc, const char *argv[])
186 {
187   struct commandline cmd;
188
189   (void) memset ((char *) &cmd, 0, sizeof (struct commandline));
190   clear_args ();
191   if (!parseargs (argc, argv, &cmd))
192     usage ();
193
194   if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
195       cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag)
196     {
197       checkfiles (cmd.infile, cmd.outfile);
198     }
199   else
200     checkfiles (cmd.infile, NULL);
201
202   if (cmd.cflag)
203     c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
204   else if (cmd.hflag)
205     h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
206   else if (cmd.lflag)
207     l_output (cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
208   else if (cmd.sflag || cmd.mflag || (cmd.nflag))
209     s_output (argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
210               cmd.outfile, cmd.mflag, cmd.nflag);
211   else if (cmd.tflag)
212     t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
213   else if (cmd.Ssflag)
214     svc_output (cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
215   else if (cmd.Scflag)
216     clnt_output (cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
217   else if (cmd.makefileflag)
218     mkfile_output (&cmd);
219   else
220     {
221       /* the rescans are required, since cpp may effect input */
222       c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
223       reinitialize ();
224       h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");
225       reinitialize ();
226       l_output (cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
227       reinitialize ();
228       if (inetdflag || !tirpcflag)
229         s_output (allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
230                   "_svc.c", cmd.mflag, cmd.nflag);
231       else
232         s_output (allnc, allnv, cmd.infile, "-DRPC_SVC",
233                   EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
234       if (tblflag)
235         {
236           reinitialize ();
237           t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
238         }
239       if (allfiles)
240         {
241           reinitialize ();
242           svc_output (cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
243           reinitialize ();
244           clnt_output (cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
245         }
246       if (allfiles || (cmd.makefileflag == 1))
247         {
248           reinitialize ();
249           mkfile_output (&cmd);
250         }
251     }
252
253   return nonfatalerrors;
254 }
255
256 /*
257  * add extension to filename
258  */
259 static char *
260 extendfile (const char *file, const char *ext)
261 {
262   char *res;
263   const char *p;
264
265   res = alloc (strlen (file) + strlen (ext) + 1);
266   if (res == NULL)
267     abort ();
268   p = strrchr (file, '.');
269   if (p == NULL)
270     p = file + strlen (file);
271   strcpy (res, file);
272   strcpy (res + (p - file), ext);
273   return res;
274 }
275
276 /*
277  * Open output file with given extension
278  */
279 static void
280 open_output (const char *infile, const char *outfile)
281 {
282   if (outfile == NULL)
283     {
284       fout = stdout;
285       return;
286     }
287
288   if (infile != NULL && streq (outfile, infile))
289     {
290       fprintf (stderr, _ ("%s: output would overwrite %s\n"), cmdname,
291                infile);
292       crash ();
293     }
294   fout = fopen (outfile, "w");
295   if (fout == NULL)
296     {
297       fprintf (stderr, _ ("%s: unable to open %s: %m\n"), cmdname, outfile);
298       crash ();
299     }
300   record_open (outfile);
301 }
302
303 /* Close the output file and check for write errors.  */
304 static void
305 close_output (const char *outfile)
306 {
307   if (fclose (fout) == EOF)
308     {
309       fprintf (stderr, _("%s: while writing output %s: %m"), cmdname,
310                outfile ?: "<stdout>");
311       crash ();
312     }
313 }
314
315 static void
316 add_warning (void)
317 {
318   fprintf (fout, "/*\n");
319   fprintf (fout, " * Please do not edit this file.\n");
320   fprintf (fout, " * It was generated using rpcgen.\n");
321   fprintf (fout, " */\n\n");
322 }
323
324 /* clear list of arguments */
325 static void
326 clear_args (void)
327 {
328   int i;
329   for (i = FIXEDARGS; i < ARGLISTLEN; ++i)
330     arglist[i] = NULL;
331   argcount = FIXEDARGS;
332 }
333
334 /* make sure that a CPP exists */
335 static void
336 find_cpp (void)
337 {
338   struct stat buf;
339
340   if (stat (CPP, &buf) < 0)
341     {                           /* /lib/cpp or explicit cpp does not exist */
342       if (cppDefined)
343         {
344           fprintf (stderr, _ ("cannot find C preprocessor: %s \n"), CPP);
345           crash ();
346         }
347       else
348         {                       /* try the other one */
349           CPP = SVR4_CPP;
350           if (stat (CPP, &buf) < 0)
351             {                   /* can't find any cpp */
352               fputs (_ ("cannot find any C preprocessor (cpp)\n"), stdout);
353               crash ();
354             }
355         }
356     }
357 }
358
359 /*
360  * Open input file with given define for C-preprocessor
361  */
362 static void
363 open_input (const char *infile, const char *define)
364 {
365   int pd[2];
366
367   infilename = (infile == NULL) ? "<stdin>" : infile;
368   if (pipe (pd) != 0)
369     {
370       perror ("pipe");
371       exit (1);
372     }
373   cpp_pid = fork ();
374   switch (cpp_pid)
375     {
376     case 0:
377       find_cpp ();
378       putarg (0, CPP);
379       putarg (1, CPPFLAGS);
380       addarg (define);
381       if (infile)
382         addarg (infile);
383       addarg ((char *) NULL);
384       close (1);
385       dup2 (pd[1], 1);
386       close (pd[0]);
387       execv (arglist[0], (char **) arglist);
388       perror ("execv");
389       exit (1);
390     case -1:
391       perror ("fork");
392       exit (1);
393     }
394   close (pd[1]);
395   fin = fdopen (pd[0], "r");
396   if (fin == NULL)
397     {
398       fprintf (stderr, "%s: ", cmdname);
399       perror (infilename);
400       crash ();
401     }
402 }
403
404 /* Close the connection to the C-preprocessor and check for successfull
405    termination.  */
406 static void
407 close_input (void)
408 {
409   int status;
410
411   fclose (fin);
412   /* Check the termination status.  */
413   if (waitpid (cpp_pid, &status, 0) < 0)
414     {
415       perror ("waitpid");
416       crash ();
417     }
418   if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
419     {
420       if (WIFSIGNALED (status))
421         fprintf (stderr, _("%s: C preprocessor failed with signal %d\n"),
422                  cmdname, WTERMSIG (status));
423       else
424         fprintf (stderr, _("%s: C preprocessor failed with exit code %d\n"),
425                  cmdname, WEXITSTATUS (status));
426       crash ();
427     }
428 }
429
430 /* valid tirpc nettypes */
431 static const char *valid_ti_nettypes[] =
432 {
433   "netpath",
434   "visible",
435   "circuit_v",
436   "datagram_v",
437   "circuit_n",
438   "datagram_n",
439   "udp",
440   "tcp",
441   "raw",
442   NULL
443 };
444
445 /* valid inetd nettypes */
446 static const char *valid_i_nettypes[] =
447 {
448   "udp",
449   "tcp",
450   NULL
451 };
452
453 static int
454 check_nettype (const char *name, const char *list_to_check[])
455 {
456   int i;
457   for (i = 0; list_to_check[i] != NULL; i++)
458     {
459       if (strcmp (name, list_to_check[i]) == 0)
460         {
461           return 1;
462         }
463     }
464   fprintf (stderr, _ ("illegal nettype :`%s'\n"), name);
465   return 0;
466 }
467
468 /*
469  * Compile into an XDR routine output file
470  */
471
472 static void
473 c_output (const char *infile, const char *define, int extend,
474           const char *outfile)
475 {
476   definition *def;
477   char *include;
478   const char *outfilename;
479   long tell;
480
481   c_initialize ();
482   open_input (infile, define);
483   outfilename = extend ? extendfile (infile, outfile) : outfile;
484   open_output (infile, outfilename);
485   add_warning ();
486   if (infile && (include = extendfile (infile, ".h")))
487     {
488       fprintf (fout, "#include \"%s\"\n", include);
489       free (include);
490       /* .h file already contains rpc/rpc.h */
491     }
492   else
493     fprintf (fout, "#include <rpc/rpc.h>\n");
494   tell = ftell (fout);
495   while ((def = get_definition ()) != NULL)
496     emit (def);
497
498   if (extend && tell == ftell (fout))
499     unlink (outfilename);
500   close_input ();
501   close_output (outfilename);
502 }
503
504 void
505 c_initialize (void)
506 {
507
508   /* add all the starting basic types */
509
510   add_type (1, "int");
511   add_type (1, "long");
512   add_type (1, "short");
513   add_type (1, "bool");
514
515   add_type (1, "u_int");
516   add_type (1, "u_long");
517   add_type (1, "u_short");
518
519 }
520
521 char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
522         char    *(*proc)();\n\
523         xdrproc_t       xdr_arg;\n\
524         unsigned        len_arg;\n\
525         xdrproc_t       xdr_res;\n\
526         unsigned        len_res;\n\
527 };\n";
528
529
530 static char *
531 generate_guard (const char *pathname)
532 {
533   const char *filename;
534   char *guard, *tmp;
535
536   filename = strrchr (pathname, '/');   /* find last component */
537   filename = ((filename == NULL) ? pathname : filename + 1);
538   guard = strdup (filename);
539   /* convert to upper case */
540   tmp = guard;
541   while (*tmp)
542     {
543       if (islower (*tmp))
544         *tmp = toupper (*tmp);
545       tmp++;
546     }
547
548   guard = extendfile (guard, "_H_RPCGEN");
549   return guard;
550 }
551
552 /*
553  * Compile into an XDR header file
554  */
555
556
557 static void
558 h_output (const char *infile, const char *define, int extend,
559           const char *outfile)
560 {
561   xdrfunc *xdrfuncp;
562   definition *def;
563   const char *ifilename;
564   const char *outfilename;
565   long tell;
566   char *guard;
567   list *l;
568
569   open_input (infile, define);
570   outfilename = extend ? extendfile (infile, outfile) : outfile;
571   open_output (infile, outfilename);
572   add_warning ();
573   ifilename = (infile == NULL) ? "STDIN" : infile;
574   guard = generate_guard (outfilename ? outfilename : ifilename);
575
576   fprintf (fout, "#ifndef _%s\n#define _%s\n\n", guard,
577            guard);
578
579   fprintf (fout, "#include <rpc/rpc.h>\n\n");
580
581   if (mtflag)
582     {
583       fprintf (fout, "#include <pthread.h>\n");
584     }
585
586   /* put the C++ support */
587   if (Cflag && !CCflag)
588     {
589       fprintf (fout, "\n#ifdef __cplusplus\n");
590       fprintf (fout, "extern \"C\" {\n");
591       fprintf (fout, "#endif\n\n");
592     }
593
594   tell = ftell (fout);
595   /* print data definitions */
596   while ((def = get_definition ()) != NULL)
597     {
598       print_datadef (def);
599     }
600
601   /* print function declarations.
602      Do this after data definitions because they might be used as
603      arguments for functions */
604   for (l = defined; l != NULL; l = l->next)
605     {
606       print_funcdef (l->val);
607     }
608   /* Now  print all xdr func declarations */
609   if (xdrfunc_head != NULL)
610     {
611       fprintf (fout, "\n/* the xdr functions */\n");
612       if (CCflag)
613         {
614           fprintf (fout, "\n#ifdef __cplusplus\n");
615           fprintf (fout, "extern \"C\" {\n");
616           fprintf (fout, "#endif\n");
617         }
618       if (!Cflag)
619         {
620           xdrfuncp = xdrfunc_head;
621           while (xdrfuncp != NULL)
622             {
623               print_xdr_func_def (xdrfuncp->name,
624                                   xdrfuncp->pointerp, 2);
625               xdrfuncp = xdrfuncp->next;
626             }
627         }
628       else
629         {
630           int i;
631
632           for (i = 1; i < 3; ++i)
633             {
634               if (i == 1)
635                 fprintf (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n");
636               else
637                 fprintf (fout, "\n#else /* K&R C */\n");
638
639               xdrfuncp = xdrfunc_head;
640               while (xdrfuncp != NULL)
641                 {
642                   print_xdr_func_def (xdrfuncp->name,
643                                       xdrfuncp->pointerp, i);
644                   xdrfuncp = xdrfuncp->next;
645                 }
646             }
647           fprintf (fout, "\n#endif /* K&R C */\n");
648         }
649     }
650
651   if (extend && tell == ftell (fout))
652     {
653       unlink (outfilename);
654     }
655   else if (tblflag)
656     {
657       fprintf (fout, rpcgen_table_dcl);
658     }
659
660   if (Cflag)
661     {
662       fprintf (fout, "\n#ifdef __cplusplus\n");
663       fprintf (fout, "}\n");
664       fprintf (fout, "#endif\n");
665     }
666
667   fprintf (fout, "\n#endif /* !_%s */\n", guard);
668   close_input ();
669   close_output (outfilename);
670 }
671
672 /*
673  * Compile into an RPC service
674  */
675 static void
676 s_output (int argc, const char *argv[], const char *infile, const char *define,
677           int extend, const char *outfile, int nomain, int netflag)
678 {
679   char *include;
680   definition *def;
681   int foundprogram = 0;
682   const char *outfilename;
683
684   open_input (infile, define);
685   outfilename = extend ? extendfile (infile, outfile) : outfile;
686   open_output (infile, outfilename);
687   add_warning ();
688   if (infile && (include = extendfile (infile, ".h")))
689     {
690       fprintf (fout, "#include \"%s\"\n", include);
691       free (include);
692     }
693   else
694     fprintf (fout, "#include <rpc/rpc.h>\n");
695
696   fprintf (fout, "#include <stdio.h>\n");
697   fprintf (fout, "#include <stdlib.h>\n");
698   fprintf (fout, "#include <rpc/pmap_clnt.h>\n");
699   if (Cflag)
700     fprintf (fout, "#include <string.h>\n");
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                    /* TRANS: the file will not be removed; this is an
1148                       TRANS: informative message.  */
1149                    _("file `%s' already exists and may be overwritten\n"),
1150                    outfile);
1151           crash ();
1152         }
1153     }
1154 }
1155
1156 /*
1157  * Parse command line arguments
1158  */
1159 static int
1160 parseargs (int argc, const char *argv[], struct commandline *cmd)
1161 {
1162   int i;
1163   int j;
1164   int c;
1165   char flag[(1 << 8 * sizeof (char))];
1166   int nflags;
1167
1168   cmdname = argv[0];
1169   cmd->infile = cmd->outfile = NULL;
1170   if (argc < 2)
1171     {
1172       return (0);
1173     }
1174   allfiles = 0;
1175   flag['c'] = 0;
1176   flag['h'] = 0;
1177   flag['l'] = 0;
1178   flag['m'] = 0;
1179   flag['o'] = 0;
1180   flag['s'] = 0;
1181   flag['n'] = 0;
1182   flag['t'] = 0;
1183   flag['S'] = 0;
1184   flag['C'] = 0;
1185   flag['M'] = 0;
1186
1187   for (i = 1; i < argc; i++)
1188     {
1189       if (argv[i][0] != '-')
1190         {
1191           if (cmd->infile)
1192             {
1193               fprintf (stderr,
1194                        _("Cannot specify more than one input file!\n"));
1195               return 0;
1196             }
1197           cmd->infile = argv[i];
1198         }
1199       else
1200         {
1201           for (j = 1; argv[i][j] != 0; j++)
1202             {
1203               c = argv[i][j];
1204               switch (c)
1205                 {
1206                 case 'a':
1207                   allfiles = 1;
1208                   break;
1209                 case 'c':
1210                 case 'h':
1211                 case 'l':
1212                 case 'm':
1213                 case 't':
1214                   if (flag[c])
1215                     return 0;
1216                   flag[c] = 1;
1217                   break;
1218                 case 'S':
1219                   /* sample flag: Ss or Sc.
1220                      Ss means set flag['S'];
1221                      Sc means set flag['C'];
1222                      Sm means set flag['M']; */
1223                   c = argv[i][++j];     /* get next char */
1224                   if (c == 's')
1225                     c = 'S';
1226                   else if (c == 'c')
1227                     c = 'C';
1228                   else if (c == 'm')
1229                     c = 'M';
1230                   else
1231                     return 0;
1232
1233                   if (flag[c])
1234                     return 0;
1235                   flag[c] = 1;
1236                   break;
1237                 case 'C':       /* ANSI C syntax */
1238                   Cflag = 1;
1239                   break;
1240
1241 #ifdef __GNU_LIBRARY__
1242                 case 'k':  /* K&R C syntax */
1243                   Cflag = 0;
1244                   break;
1245
1246 #endif
1247                 case 'b':  /* turn TIRPC flag off for
1248                               generating backward compatible
1249                            */
1250                   tirpcflag = 0;
1251                   break;
1252
1253 #ifdef __GNU_LIBRARY__
1254                 case '5':  /* turn TIRPC flag on for
1255                               generating SysVr4 compatible
1256                            */
1257                   tirpcflag = 1;
1258                   break;
1259 #endif
1260                 case 'I':
1261                   inetdflag = 1;
1262                   break;
1263                 case 'N':
1264                   newstyle = 1;
1265                   break;
1266                 case 'L':
1267                   logflag = 1;
1268                   break;
1269                 case 'K':
1270                   if (++i == argc)
1271                     {
1272                       return (0);
1273                     }
1274                   svcclosetime = argv[i];
1275                   goto nextarg;
1276                 case 'T':
1277                   tblflag = 1;
1278                   break;
1279                 case 'M':
1280                   mtflag = 1;
1281                   break;
1282                 case 'i':
1283                   if (++i == argc)
1284                     {
1285                       return (0);
1286                     }
1287                   inlineflag = atoi (argv[i]);
1288                   goto nextarg;
1289                 case 'n':
1290                 case 'o':
1291                 case 's':
1292                   if (argv[i][j - 1] != '-' ||
1293                       argv[i][j + 1] != 0)
1294                     {
1295                       return (0);
1296                     }
1297                   flag[c] = 1;
1298                   if (++i == argc)
1299                     {
1300                       return (0);
1301                     }
1302                   if (c == 's')
1303                     {
1304                       if (!streq (argv[i], "udp") &&
1305                           !streq (argv[i], "tcp"))
1306                         return 0;
1307                     }
1308                   else if (c == 'o')
1309                     {
1310                       if (cmd->outfile)
1311                         return 0;
1312                       cmd->outfile = argv[i];
1313                     }
1314                   goto nextarg;
1315                 case 'D':
1316                   if (argv[i][j - 1] != '-')
1317                     return 0;
1318                   addarg (argv[i]);
1319                   goto nextarg;
1320                 case 'Y':
1321                   if (++i == argc)
1322                     return 0;
1323                   {
1324                     size_t len = strlen (argv[i]);
1325                     pathbuf = malloc (len + 5);
1326                     if (pathbuf == NULL)
1327                       {
1328                         perror (cmdname);
1329                         crash ();
1330                       }
1331                     stpcpy (stpcpy (pathbuf,
1332                                     argv[i]),
1333                             "/cpp");
1334                     CPP = pathbuf;
1335                     cppDefined = 1;
1336                     goto nextarg;
1337                   }
1338
1339                 default:
1340                   return 0;
1341                 }
1342               }
1343         nextarg:
1344           ;
1345         }
1346     }
1347
1348   cmd->cflag = flag['c'];
1349   cmd->hflag = flag['h'];
1350   cmd->lflag = flag['l'];
1351   cmd->mflag = flag['m'];
1352   cmd->nflag = flag['n'];
1353   cmd->sflag = flag['s'];
1354   cmd->tflag = flag['t'];
1355   cmd->Ssflag = flag['S'];
1356   cmd->Scflag = flag['C'];
1357   cmd->makefileflag = flag['M'];
1358
1359 #ifndef _RPC_THREAD_SAFE_
1360   if (mtflag || newstyle)
1361     {
1362       /* glibc doesn't support these flags.  */
1363       f_print (stderr,
1364                _("This implementation doesn't support newstyle or MT-safe code!\n"));
1365       return (0);
1366     }
1367 #endif
1368   if (tirpcflag)
1369     {
1370       pmflag = inetdflag ? 0 : 1;    /* pmflag or inetdflag is always TRUE */
1371       if ((inetdflag && cmd->nflag))
1372         {                       /* netid not allowed with inetdflag */
1373           fprintf (stderr, _("Cannot use netid flag with inetd flag!\n"));
1374           return 0;
1375         }
1376     }
1377   else
1378     {                           /* 4.1 mode */
1379       pmflag = 0;               /* set pmflag only in tirpcmode */
1380 #ifndef __GNU_LIBRARY__
1381       inetdflag = 1;            /* inetdflag is TRUE by default */
1382 #endif
1383       if (cmd->nflag)
1384         {                       /* netid needs TIRPC */
1385           f_print (stderr, _("Cannot use netid flag without TIRPC!\n"));
1386           return (0);
1387         }
1388     }
1389
1390   if (newstyle && (tblflag || cmd->tflag))
1391     {
1392       f_print (stderr, _("Cannot use table flags with newstyle!\n"));
1393       return (0);
1394     }
1395
1396   /* check no conflicts with file generation flags */
1397   nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
1398     cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
1399
1400   if (nflags == 0)
1401     {
1402       if (cmd->outfile != NULL || cmd->infile == NULL)
1403         {
1404           return (0);
1405         }
1406     }
1407   else if (cmd->infile == NULL &&
1408            (cmd->Ssflag || cmd->Scflag || cmd->makefileflag))
1409     {
1410       fprintf (stderr,
1411                _("\"infile\" is required for template generation flags.\n"));
1412       return 0;
1413     }
1414   if (nflags > 1)
1415     {
1416       fprintf (stderr, _("Cannot have more than one file generation flag!\n"));
1417       return 0;
1418     }
1419   return 1;
1420 }
1421
1422 static void
1423 usage (void)
1424 {
1425   fprintf (stderr, _("usage: %s infile\n"), cmdname);
1426   fprintf (stderr, _("\t%s [-abkCLNTM][-Dname[=value]] [-i size] \
1427 [-I [-K seconds]] [-Y path] infile\n"), cmdname);
1428   fprintf (stderr, _("\t%s [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] \
1429 [-o outfile] [infile]\n"), cmdname);
1430   fprintf (stderr, _("\t%s [-s nettype]* [-o outfile] [infile]\n"), cmdname);
1431   fprintf (stderr, _("\t%s [-n netid]* [-o outfile] [infile]\n"), cmdname);
1432   options_usage ();
1433   exit (1);
1434 }
1435
1436 static void
1437 options_usage (void)
1438 {
1439   f_print (stderr, "options:\n");
1440   f_print (stderr, "-a\t\tgenerate all files, including samples\n");
1441   f_print (stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n");
1442   f_print (stderr, "-c\t\tgenerate XDR routines\n");
1443   f_print (stderr, "-C\t\tANSI C mode\n");
1444   f_print (stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n");
1445   f_print (stderr, "-h\t\tgenerate header file\n");
1446   f_print (stderr, "-i size\t\tsize at which to start generating inline code\n");
1447   f_print (stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n");
1448   f_print (stderr, "-K seconds\tserver exits after K seconds of inactivity\n");
1449   f_print (stderr, "-l\t\tgenerate client side stubs\n");
1450   f_print (stderr, "-L\t\tserver errors will be printed to syslog\n");
1451   f_print (stderr, "-m\t\tgenerate server side stubs\n");
1452   f_print (stderr, "-M\t\tgenerate MT-safe code\n");
1453   f_print (stderr, "-n netid\tgenerate server code that supports named netid\n");
1454   f_print (stderr, "-N\t\tsupports multiple arguments and call-by-value\n");
1455   f_print (stderr, "-o outfile\tname of the output file\n");
1456   f_print (stderr, "-s nettype\tgenerate server code that supports named nettype\n");
1457   f_print (stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n");
1458   f_print (stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n");
1459   f_print (stderr, "-Sm \t\tgenerate makefile template \n");
1460   f_print (stderr, "-t\t\tgenerate RPC dispatch table\n");
1461   f_print (stderr, "-T\t\tgenerate code to support RPC dispatch tables\n");
1462   f_print (stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n");
1463
1464   exit (1);
1465 }