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