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