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