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