GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/rpcgen/rpc_main.c Lines: 213 462 46.1 %
Date: 2016-12-06 Branches: 98 331 29.6 %

Line Branch Exec Source
1
/* $OpenBSD: rpc_main.c,v 1.32 2015/11/11 02:52:46 deraadt Exp $	 */
2
/* $NetBSD: rpc_main.c,v 1.9 1996/02/19 11:12:43 pk Exp $	 */
3
4
/*
5
 * Copyright (c) 2010, Oracle America, Inc.
6
 *
7
 * Redistribution and use in source and binary forms, with or without
8
 * modification, are permitted provided that the following conditions are
9
 * met:
10
 *
11
 *     * Redistributions of source code must retain the above copyright
12
 *       notice, this list of conditions and the following disclaimer.
13
 *     * Redistributions in binary form must reproduce the above
14
 *       copyright notice, this list of conditions and the following
15
 *       disclaimer in the documentation and/or other materials
16
 *       provided with the distribution.
17
 *     * Neither the name of the "Oracle America, Inc." nor the names of its
18
 *       contributors may be used to endorse or promote products derived
19
 *       from this software without specific prior written permission.
20
 *
21
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25
 *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
26
 *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27
 *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
28
 *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29
 *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30
 *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
 */
34
35
/*
36
 * rpc_main.c, Top level of the RPC protocol compiler.
37
 */
38
39
#define RPCGEN_VERSION	"199506"/* This program's version (year & month) */
40
41
#include <sys/types.h>
42
#include <sys/file.h>
43
#include <stdio.h>
44
#include <stdlib.h>
45
#include <string.h>
46
#include <unistd.h>
47
#include <limits.h>
48
#include <ctype.h>
49
#include <sys/stat.h>
50
#include "rpc_parse.h"
51
#include "rpc_util.h"
52
#include "rpc_scan.h"
53
54
#define EXTEND	1		/* alias for TRUE */
55
#define DONT_EXTEND	0	/* alias for FALSE */
56
57
#define SVR4_CPP "/usr/ccs/lib/cpp"
58
#define SUNOS_CPP "/lib/cpp"
59
static int      cppDefined = 0;	/* explicit path for C preprocessor */
60
61
struct commandline {
62
	int cflag;	/* xdr C routines */
63
	int hflag;	/* header file */
64
	int lflag;	/* client side stubs */
65
	int mflag;	/* server side stubs */
66
	int nflag;	/* netid flag */
67
	int sflag;	/* server stubs for the given transport */
68
	int tflag;	/* dispatch Table file */
69
	int Ssflag;	/* produce server sample code */
70
	int Scflag;	/* produce client sample code */
71
	char *infile;	/* input module name */
72
	char *outfile;/* output module name */
73
};
74
75
static char    *cmdname;
76
77
static char    *svcclosetime = "120";
78
static char    *CPP = "/usr/bin/cpp";
79
static char     CPPFLAGS[] = "-C";
80
static char     pathbuf[PATH_MAX];
81
static char    *allv[] = {
82
	"rpcgen", "-s", "udp", "-s", "tcp",
83
};
84
static int      allc = sizeof(allv) / sizeof(allv[0]);
85
static char    *allnv[] = {
86
	"rpcgen", "-s", "netpath",
87
};
88
static int      allnc = sizeof(allnv) / sizeof(allnv[0]);
89
90
#define ARGLISTLEN	20
91
#define FIXEDARGS         2
92
93
static char    *arglist[ARGLISTLEN];
94
static int      argcount = FIXEDARGS;
95
96
97
int             nonfatalerrors;	/* errors */
98
int             inetdflag /* = 1 */ ;	/* Support for inetd *//* is now the
99
					 * default */
100
int             pmflag;		/* Support for port monitors */
101
int             logflag;	/* Use syslog instead of fprintf for errors */
102
int             tblflag;	/* Support for dispatch table file */
103
int             callerflag;	/* Generate svc_caller() function */
104
105
#define INLINE 3
106
/* length at which to start doing an inline */
107
108
int doinline = INLINE;	/* length at which to start doing an
109
			 * inline. 3 = default if 0, no
110
			 * xdr_inline code */
111
112
int indefinitewait;	/* If started by port monitors, hang till it
113
			 * wants */
114
int exitnow;	/* If started by port monitors, exit after
115
		 * the call */
116
int timerflag;	/* TRUE if !indefinite && !exitnow */
117
int newstyle;	/* newstyle of passing arguments (by value) */
118
int Cflag = 0;	/* ANSI C syntax */
119
static int allfiles;	/* generate all files */
120
int tirpcflag = 0;	/* generating code for tirpc, by default */
121
122
static void c_output(char *, char *, int, char *);
123
static void h_output(char *, char *, int, char *);
124
static void s_output(int, char **, char *, char *, int, char *, int, int);
125
static void l_output(char *, char *, int, char *);
126
static void t_output(char *, char *, int, char *);
127
static void svc_output(char *, char *, int, char *);
128
static void clnt_output(char *, char *, int, char *);
129
static int do_registers(int, char **);
130
static void addarg(char *);
131
static void putarg(int, char *);
132
static void clear_args(void);
133
static void checkfiles(char *, char *);
134
static int parseargs(int, char **, struct commandline *);
135
static void usage(void);
136
void c_initialize(void);
137
138
int
139
main(int argc, char *argv[])
140
3
{
141
	struct commandline cmd;
142
143
3
	if (pledge("stdio rpath wpath cpath proc exec", NULL) == -1) {
144
		perror("pledge");
145
		exit(1);
146
	}
147
148
3
	(void) memset((char *) &cmd, 0, sizeof(struct commandline));
149
3
	clear_args();
150
3
	if (!parseargs(argc, argv, &cmd))
151
		usage();
152
153




6
	if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
154
	    cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {
155
3
		checkfiles(cmd.infile, cmd.outfile);
156
	} else
157
		checkfiles(cmd.infile, NULL);
158
159
3
	if (cmd.cflag) {
160
		c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
161
3
	} else if (cmd.hflag) {
162
1
		h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
163
2
	} else if (cmd.lflag) {
164
		l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
165

4
	} else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
166
2
		s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
167
			 cmd.outfile, cmd.mflag, cmd.nflag);
168
	} else if (cmd.tflag) {
169
		t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
170
	} else if (cmd.Ssflag) {
171
		svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
172
	} else if (cmd.Scflag) {
173
		clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
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");
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
		if (allfiles) {
193
			reinitialize();
194
			svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
195
		}
196
		if (allfiles) {
197
			reinitialize();
198
			clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
199
		}
200
	}
201
3
	exit(nonfatalerrors);
202
	/* NOTREACHED */
203
}
204
205
/*
206
 * add extension to filename
207
 */
208
static char *
209
extendfile(char *path, char *ext)
210
3
{
211
	char *file;
212
	char *res;
213
	char *p;
214
	size_t len;
215
216
3
	if ((file = strrchr(path, '/')) == NULL)
217
1
		file = path;
218
	else
219
2
		file++;
220
221
3
	len = strlen(file) + strlen(ext) + 1;
222
3
	res = malloc(len);
223
3
	if (res == NULL) {
224
		fprintf(stderr, "could not allocate memory\n");
225
		exit(1);
226
	}
227
3
	p = strrchr(file, '.');
228
3
	if (p == NULL)
229
		p = file + strlen(file);
230
3
	(void) strlcpy(res, file, len);
231
3
	(void) strlcpy(res + (p - file), ext, len - (p - file));
232
3
	return (res);
233
}
234
235
/*
236
 * Open output file with given extension
237
 */
238
static void
239
open_output(char *infile, char *outfile)
240
3
{
241
242
3
	if (outfile == NULL) {
243
		fout = stdout;
244
		return;
245
	}
246

3
	if (infile != NULL && streq(outfile, infile)) {
247
		fprintf(stderr, "%s: output would overwrite %s\n", cmdname,
248
		    infile);
249
		crash();
250
	}
251
3
	fout = fopen(outfile, "w");
252
3
	if (fout == NULL) {
253
		fprintf(stderr, "%s: unable to open ", cmdname);
254
		perror(outfile);
255
		crash();
256
	}
257
3
	record_open(outfile);
258
259
}
260
261
static void
262
add_warning(void)
263
3
{
264
3
	fprintf(fout, "/*\n");
265
3
	fprintf(fout, " * Please do not edit this file.\n");
266
3
	fprintf(fout, " * It was generated using rpcgen.\n");
267
3
	fprintf(fout, " */\n\n");
268
3
}
269
270
/* clear list of arguments */
271
static void
272
clear_args(void)
273
3
{
274
	int             i;
275
57
	for (i = FIXEDARGS; i < ARGLISTLEN; i++)
276
54
		arglist[i] = NULL;
277
3
	argcount = FIXEDARGS;
278
3
}
279
280
/* make sure that a CPP exists */
281
static void
282
find_cpp(void)
283
3
{
284
	struct stat     buf;
285
286
	/* SVR4 or explicit cpp does not exist */
287
3
	if (stat(CPP, &buf) < 0) {
288
		if (cppDefined) {
289
			fprintf(stderr, "cannot find C preprocessor: %s \n", CPP);
290
			crash();
291
		} else {
292
			/* try the other one */
293
			CPP = SUNOS_CPP;
294
			if (stat(CPP, &buf) < 0) {	/* can't find any cpp */
295
				fprintf(stderr,
296
				    "cannot find any C preprocessor: %s\n", CPP);
297
				crash();
298
			}
299
		}
300
	}
301
3
}
302
303
/*
304
 * Open input file with given define for C-preprocessor
305
 */
306
static void
307
open_input(char *infile, char *define)
308
3
{
309
	int             pd[2];
310
311
3
	infilename = (infile == NULL) ? "<stdin>" : infile;
312
3
	(void) pipe(pd);
313
3
	switch (fork()) {
314
	case 0:
315
3
		find_cpp();
316
3
		putarg(0, CPP);
317
3
		putarg(1, CPPFLAGS);
318
3
		addarg(define);
319
3
		addarg(infile);
320
3
		addarg((char *) NULL);
321
3
		(void) close(1);
322
3
		(void) dup2(pd[1], 1);
323
3
		(void) close(pd[0]);
324
3
		execv(arglist[0], arglist);
325
		perror("execv");
326
		exit(1);
327
	case -1:
328
		perror("fork");
329
		exit(1);
330
	}
331
3
	(void) close(pd[1]);
332
3
	fin = fdopen(pd[0], "r");
333
3
	if (fin == NULL) {
334
		fprintf(stderr, "%s: ", cmdname);
335
		perror(infilename);
336
		crash();
337
	}
338
3
}
339
340
/* valid tirpc nettypes */
341
static char    *valid_ti_nettypes[] = {
342
	"netpath",
343
	"visible",
344
	"circuit_v",
345
	"datagram_v",
346
	"circuit_n",
347
	"datagram_n",
348
	"udp",
349
	"tcp",
350
	"raw",
351
	NULL
352
};
353
354
/* valid inetd nettypes */
355
static char    *valid_i_nettypes[] = {
356
	"udp",
357
	"tcp",
358
	NULL
359
};
360
361
static int
362
check_nettype(char *name, char *list_to_check[])
363
{
364
	int             i;
365
	for (i = 0; list_to_check[i] != NULL; i++) {
366
		if (strcmp(name, list_to_check[i]) == 0)
367
			return 1;
368
	}
369
	fprintf(stderr, "illegal nettype :\'%s\'\n", name);
370
	return 0;
371
}
372
373
/*
374
 * Compile into an XDR routine output file
375
 */
376
377
static void
378
c_output(infile, define, extend, outfile)
379
	char           *infile;
380
	char           *define;
381
	int             extend;
382
	char           *outfile;
383
{
384
	definition     *def;
385
	char           *include;
386
	char           *outfilename;
387
	long            tell;
388
389
	c_initialize();
390
	open_input(infile, define);
391
	outfilename = extend ? extendfile(infile, outfile) : outfile;
392
	open_output(infile, outfilename);
393
	add_warning();
394
	if (infile && (include = extendfile(infile, ".h"))) {
395
		fprintf(fout, "#include \"%s\"\n", include);
396
		free(include);
397
		/* .h file already contains rpc/rpc.h */
398
	} else
399
		fprintf(fout, "#include <rpc/rpc.h>\n");
400
	tell = ftell(fout);
401
	while ((def = get_definition())) {
402
		emit(def);
403
	}
404
	if (extend && tell == ftell(fout)) {
405
		(void) unlink(outfilename);
406
	}
407
}
408
409
410
void
411
c_initialize(void)
412
{
413
414
	/* add all the starting basic types */
415
416
	add_type(1, "int");
417
	add_type(1, "long");
418
	add_type(1, "short");
419
	add_type(1, "bool");
420
421
	add_type(1, "u_int");
422
	add_type(1, "u_long");
423
	add_type(1, "u_short");
424
425
}
426
427
static const char rpcgen_table_dcl[] = "struct rpcgen_table {\n\
428
	char	*(*proc)();\n\
429
	xdrproc_t	xdr_arg;\n\
430
	unsigned int	len_arg;\n\
431
	xdrproc_t	xdr_res;\n\
432
	unsigned int	len_res;\n\
433
};\n";
434
435
436
static char *
437
generate_guard(char *pathname)
438
1
{
439
	char           *filename, *guard, *tmp, *tmp2;
440
441
1
	filename = strrchr(pathname, '/');	/* find last component */
442
1
	filename = ((filename == 0) ? pathname : filename + 1);
443
1
	guard = strdup(filename);
444
1
	if (guard == NULL) {
445
		fprintf(stderr, "out of memory while processing %s\n", filename);
446
		crash();
447
	}
448
449
	/* convert to upper case */
450
1
	tmp = guard;
451
12
	while (*tmp) {
452
20
		if (islower((unsigned char)*tmp))
453
16
			*tmp = toupper((unsigned char)*tmp);
454
10
		tmp++;
455
	}
456
457
1
	tmp2 = extendfile(guard, "_H_RPCGEN");
458
1
	free(guard);
459
1
	guard = tmp2;
460
461
1
	return (guard);
462
}
463
464
/*
465
 * Compile into an XDR header file
466
 */
467
468
static void
469
h_output(infile, define, extend, outfile)
470
	char           *infile;
471
	char           *define;
472
	int             extend;
473
	char           *outfile;
474
1
{
475
	definition     *def;
476
	char           *outfilename;
477
	long            tell;
478
	char           *guard;
479
	list           *l;
480
481
1
	open_input(infile, define);
482
1
	outfilename = extend ? extendfile(infile, outfile) : outfile;
483
1
	open_output(infile, outfilename);
484
1
	add_warning();
485
1
	guard = generate_guard(outfilename ? outfilename : infile);
486
487
1
	fprintf(fout, "#ifndef _%s\n#define _%s\n\n", guard,
488
		guard);
489
490
1
	fprintf(fout, "#define RPCGEN_VERSION\t%s\n\n", RPCGEN_VERSION);
491
1
	fprintf(fout, "#include <rpc/rpc.h>\n\n");
492
493
1
	tell = ftell(fout);
494
	/* print data definitions */
495
35
	while ((def = get_definition())) {
496
33
		print_datadef(def);
497
	}
498
499
	/*
500
	 * print function declarations. Do this after data definitions
501
	 * because they might be used as arguments for functions
502
	 */
503
34
	for (l = defined; l != NULL; l = l->next) {
504
33
		print_funcdef(l->val);
505
	}
506

1
	if (extend && tell == ftell(fout)) {
507
		(void) unlink(outfilename);
508
1
	} else if (tblflag) {
509
		fprintf(fout, rpcgen_table_dcl);
510
	}
511
1
	fprintf(fout, "\n#endif /* !_%s */\n", guard);
512
513
1
	free(guard);
514
1
}
515
516
/*
517
 * Compile into an RPC service
518
 */
519
static void
520
s_output(argc, argv, infile, define, extend, outfile, nomain, netflag)
521
	int             argc;
522
	char           *argv[];
523
	char           *infile;
524
	char           *define;
525
	int             extend;
526
	char           *outfile;
527
	int             nomain;
528
	int             netflag;
529
2
{
530
	char           *include;
531
	definition     *def;
532
2
	int             foundprogram = 0;
533
	char           *outfilename;
534
535
2
	open_input(infile, define);
536
2
	outfilename = extend ? extendfile(infile, outfile) : outfile;
537
2
	open_output(infile, outfilename);
538
2
	add_warning();
539

4
	if (infile && (include = extendfile(infile, ".h"))) {
540
2
		fprintf(fout, "#include \"%s\"\n", include);
541
2
		free(include);
542
	} else
543
		fprintf(fout, "#include <rpc/rpc.h>\n");
544
545
2
	fprintf(fout, "#include <unistd.h>\n");
546
2
	fprintf(fout, "#include <stdio.h>\n");
547
2
	fprintf(fout, "#include <stdlib.h>/* getenv, exit */\n");
548
2
	if (Cflag) {
549
2
		fprintf(fout,
550
			"#include <rpc/pmap_clnt.h> /* for pmap_unset */\n");
551
2
		fprintf(fout, "#include <string.h> /* strcmp */ \n");
552
	}
553
2
	fprintf(fout, "#include <netdb.h>\n");	/* evas */
554
2
	if (strcmp(svcclosetime, "-1") == 0)
555
		indefinitewait = 1;
556
2
	else if (strcmp(svcclosetime, "0") == 0)
557
		exitnow = 1;
558

2
	else if (inetdflag || pmflag) {
559
2
		fprintf(fout, "#include <signal.h>\n");
560
2
		timerflag = 1;
561
	}
562

2
	if (!tirpcflag && inetdflag)
563
2
		fprintf(fout, "#include <sys/ttycom.h>/* TIOCNOTTY */\n");
564

2
	if (Cflag && (inetdflag || pmflag)) {
565
2
		fprintf(fout, "#ifdef __cplusplus\n");
566
2
		fprintf(fout, "#include <sysent.h> /* getdtablesize, open */\n");
567
2
		fprintf(fout, "#endif /* __cplusplus */\n");
568
569
2
		if (tirpcflag)
570
			fprintf(fout, "#include <unistd.h> /* setsid */\n");
571
	}
572
2
	if (tirpcflag)
573
		fprintf(fout, "#include <sys/types.h>\n");
574
575
2
	fprintf(fout, "#include <memory.h>\n");
576
2
	if (tirpcflag)
577
		fprintf(fout, "#include <stropts.h>\n");
578
579

2
	if (inetdflag || !tirpcflag) {
580
2
		fprintf(fout, "#include <sys/socket.h>\n");
581
2
		fprintf(fout, "#include <netinet/in.h>\n");
582
	}
583

2
	if ((netflag || pmflag) && tirpcflag) {
584
		fprintf(fout, "#include <netconfig.h>\n");
585
	}
586
2
	if (/* timerflag && */ tirpcflag)
587
		fprintf(fout, "#include <sys/resource.h> /* rlimit */\n");
588

2
	if (logflag || inetdflag || pmflag) {
589
2
		fprintf(fout, "#include <syslog.h>\n");
590
2
		fprintf(fout, "#include <errno.h>\n");
591
	}
592
	/* for ANSI-C */
593
2
	fprintf(fout, "\n#ifdef __STDC__\n#define SIG_PF void(*)(int)\n#endif\n");
594
595
2
	fprintf(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n");
596
2
	if (timerflag)
597
2
		fprintf(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime);
598
49
	while ((def = get_definition())) {
599
47
		foundprogram |= (def->def_kind == DEF_PROGRAM);
600
	}
601
2
	if (extend && !foundprogram) {
602
		(void) unlink(outfilename);
603
		return;
604
	}
605
2
	if (callerflag)		/* EVAS */
606
		fprintf(fout, "\nstatic SVCXPRT *caller;\n");	/* EVAS */
607
2
	write_most(infile, netflag, nomain);
608
2
	if (!nomain) {
609
		if (!do_registers(argc, argv)) {
610
			if (outfilename)
611
				(void) unlink(outfilename);
612
			usage();
613
		}
614
		write_rest();
615
	}
616
}
617
618
/*
619
 * generate client side stubs
620
 */
621
static void
622
l_output(infile, define, extend, outfile)
623
	char           *infile;
624
	char           *define;
625
	int             extend;
626
	char           *outfile;
627
{
628
	char           *include;
629
	definition     *def;
630
	int             foundprogram = 0;
631
	char           *outfilename;
632
633
	open_input(infile, define);
634
	outfilename = extend ? extendfile(infile, outfile) : outfile;
635
	open_output(infile, outfilename);
636
	add_warning();
637
	if (Cflag)
638
		fprintf(fout, "#include <memory.h> /* for memset */\n");
639
	if (infile && (include = extendfile(infile, ".h"))) {
640
		fprintf(fout, "#include \"%s\"\n", include);
641
		free(include);
642
	} else
643
		fprintf(fout, "#include <rpc/rpc.h>\n");
644
	while ((def = get_definition()))
645
		foundprogram |= (def->def_kind == DEF_PROGRAM);
646
647
	if (extend && !foundprogram) {
648
		(void) unlink(outfilename);
649
		return;
650
	}
651
	write_stubs();
652
}
653
654
/*
655
 * generate the dispatch table
656
 */
657
static void
658
t_output(infile, define, extend, outfile)
659
	char           *infile;
660
	char           *define;
661
	int             extend;
662
	char           *outfile;
663
{
664
	definition     *def;
665
	int             foundprogram = 0;
666
	char           *outfilename;
667
668
	open_input(infile, define);
669
	outfilename = extend ? extendfile(infile, outfile) : outfile;
670
	open_output(infile, outfilename);
671
	add_warning();
672
	while ((def = get_definition()))
673
		foundprogram |= (def->def_kind == DEF_PROGRAM);
674
675
	if (extend && !foundprogram) {
676
		(void) unlink(outfilename);
677
		return;
678
	}
679
	write_tables();
680
}
681
682
/* sample routine for the server template */
683
static void
684
svc_output(infile, define, extend, outfile)
685
	char           *infile;
686
	char           *define;
687
	int             extend;
688
	char           *outfile;
689
{
690
	definition     *def;
691
	char           *include;
692
	char           *outfilename;
693
	long            tell;
694
695
	open_input(infile, define);
696
	outfilename = extend ? extendfile(infile, outfile) : outfile;
697
	checkfiles(infile, outfilename);	/* check if outfile already
698
						 * exists. if so, print an
699
						 * error message and exit */
700
	open_output(infile, outfilename);
701
	add_sample_msg();
702
703
	if (infile && (include = extendfile(infile, ".h"))) {
704
		fprintf(fout, "#include \"%s\"\n", include);
705
		free(include);
706
	} else
707
		fprintf(fout, "#include <rpc/rpc.h>\n");
708
709
	tell = ftell(fout);
710
	while ((def = get_definition()))
711
		write_sample_svc(def);
712
713
	if (extend && tell == ftell(fout))
714
		(void) unlink(outfilename);
715
}
716
717
718
/* sample main routine for client */
719
static void
720
clnt_output(infile, define, extend, outfile)
721
	char           *infile;
722
	char           *define;
723
	int             extend;
724
	char           *outfile;
725
{
726
	definition *def;
727
	char *include, *outfilename;
728
	long tell;
729
	int has_program = 0;
730
731
	open_input(infile, define);
732
	outfilename = extend ? extendfile(infile, outfile) : outfile;
733
734
	/*
735
	 * check if outfile already exists. if so,
736
	 * print an error message and exit
737
	 */
738
	checkfiles(infile, outfilename);
739
740
	open_output(infile, outfilename);
741
	add_sample_msg();
742
	if (infile && (include = extendfile(infile, ".h"))) {
743
		fprintf(fout, "#include \"%s\"\n", include);
744
		free(include);
745
	} else
746
		fprintf(fout, "#include <rpc/rpc.h>\n");
747
	tell = ftell(fout);
748
	while ((def = get_definition()))
749
		has_program += write_sample_clnt(def);
750
751
	if (has_program)
752
		write_sample_clnt_main();
753
754
	if (extend && tell == ftell(fout))
755
		(void) unlink(outfilename);
756
}
757
758
/*
759
 * Perform registrations for service output
760
 * Return 0 if failed; 1 otherwise.
761
 */
762
static int
763
do_registers(argc, argv)
764
	int             argc;
765
	char           *argv[];
766
{
767
	int             i;
768
769
	if (inetdflag || !tirpcflag) {
770
		for (i = 1; i < argc; i++) {
771
			if (streq(argv[i], "-s")) {
772
				if (!check_nettype(argv[i + 1], valid_i_nettypes))
773
					return 0;
774
				write_inetd_register(argv[i + 1]);
775
				i++;
776
			}
777
		}
778
	} else {
779
		for (i = 1; i < argc; i++)
780
			if (streq(argv[i], "-s")) {
781
				if (!check_nettype(argv[i + 1], valid_ti_nettypes))
782
					return 0;
783
				write_nettype_register(argv[i + 1]);
784
				i++;
785
			} else if (streq(argv[i], "-n")) {
786
				write_netid_register(argv[i + 1]);
787
				i++;
788
			}
789
	}
790
	return 1;
791
}
792
793
/*
794
 * Add another argument to the arg list
795
 */
796
static void
797
addarg(cp)
798
	char           *cp;
799
9
{
800
9
	if (argcount >= ARGLISTLEN) {
801
		fprintf(stderr, "rpcgen: too many defines\n");
802
		crash();
803
		/* NOTREACHED */
804
	}
805
9
	arglist[argcount++] = cp;
806
807
9
}
808
809
static void
810
putarg(where, cp)
811
	char           *cp;
812
	int             where;
813
6
{
814
6
	if (where >= ARGLISTLEN) {
815
		fprintf(stderr, "rpcgen: arglist coding error\n");
816
		crash();
817
		/* NOTREACHED */
818
	}
819
6
	arglist[where] = cp;
820
6
}
821
822
/*
823
 * if input file is stdin and an output file is specified then complain
824
 * if the file already exists. Otherwise the file may get overwritten
825
 * If input file does not exist, exit with an error
826
 */
827
static void
828
checkfiles(infile, outfile)
829
	char           *infile;
830
	char           *outfile;
831
3
{
832
	struct stat     buf;
833
834
3
	if (infile)		/* infile ! = NULL */
835
3
		if (stat(infile, &buf) < 0) {
836
			perror(infile);
837
			crash();
838
		}
839
#if 0
840
	if (outfile) {
841
		if (stat(outfile, &buf) < 0)
842
			return;	/* file does not exist */
843
		else {
844
			fprintf(stderr,
845
			    "file '%s' already exists and may be overwritten\n",
846
			    outfile);
847
			crash();
848
		}
849
	}
850
#endif
851
3
}
852
853
/*
854
 * Parse command line arguments
855
 */
856
static int
857
parseargs(argc, argv, cmd)
858
	int argc;
859
	char *argv[];
860
	struct commandline *cmd;
861
3
{
862
	int i, j, nflags;
863
	char c, flag[(1 << 8 * sizeof(char))];
864
865
3
	cmdname = argv[0];
866
3
	cmd->infile = cmd->outfile = NULL;
867
3
	if (argc < 2)
868
		return (0);
869
870
3
	allfiles = 0;
871
3
	flag['c'] = 0;
872
3
	flag['h'] = 0;
873
3
	flag['l'] = 0;
874
3
	flag['m'] = 0;
875
3
	flag['o'] = 0;
876
3
	flag['s'] = 0;
877
3
	flag['n'] = 0;
878
3
	flag['t'] = 0;
879
3
	flag['S'] = 0;
880
3
	flag['C'] = 0;
881
17
	for (i = 1; i < argc; i++) {
882
14
		if (argv[i][0] != '-') {
883
3
			if (cmd->infile) {
884
				fprintf(stderr,
885
				    "Cannot specify more than one input file!\n");
886
				return (0);
887
			}
888
3
			cmd->infile = argv[i];
889
		} else {
890
19
			for (j = 1; argv[i][j] != 0; j++) {
891
11
				c = argv[i][j];
892




11
				switch (c) {
893
				case 'A':
894
					callerflag = 1;
895
					break;
896
				case 'a':
897
					allfiles = 1;
898
					break;
899
				case 'c':
900
				case 'h':
901
				case 'l':
902
				case 'm':
903
				case 't':
904
3
					if (flag[(unsigned char)c])
905
						return (0);
906
3
					flag[(unsigned char)c] = 1;
907
3
					break;
908
				case 'S':
909
					/*
910
					 * sample flag: Ss or Sc. Ss means
911
					 * set flag['S']; Sc means set
912
					 * flag['C'];
913
					 */
914
					c = argv[i][++j];	/* get next char */
915
					if (c == 's')
916
						c = 'S';
917
					else if (c == 'c')
918
						c = 'C';
919
					else
920
						return (0);
921
922
					if (flag[(unsigned char)c])
923
						return (0);
924
					flag[(unsigned char)c] = 1;
925
					break;
926
				case 'C':	/* ANSI C syntax */
927
3
					Cflag = 1;
928
3
					break;
929
930
				case 'b':
931
					/*
932
					 * turn TIRPC flag off for
933
					 * generating backward compatible
934
					 */
935
					tirpcflag = 0;
936
					break;
937
938
				case 'I':
939
					inetdflag = 1;
940
					break;
941
				case 'N':
942
					newstyle = 1;
943
					break;
944
				case 'L':
945
2
					logflag = 1;
946
2
					break;
947
				case 'K':
948
					if (++i == argc)
949
						return (0);
950
					svcclosetime = argv[i];
951
					goto nextarg;
952
				case 'T':
953
					tblflag = 1;
954
					break;
955
				case 'i':
956
					if (++i == argc)
957
						return (0);
958
					doinline = atoi(argv[i]);
959
					goto nextarg;
960
				case 'n':
961
				case 'o':
962
				case 's':
963

3
					if (argv[i][j - 1] != '-' ||
964
					    argv[i][j + 1] != 0)
965
						return (0);
966
3
					flag[(unsigned char)c] = 1;
967
3
					if (++i == argc)
968
						return (0);
969
3
					if (c == 's') {
970
						if (!streq(argv[i], "udp") &&
971
						    !streq(argv[i], "tcp"))
972
							return (0);
973
3
					} else if (c == 'o') {
974
3
						if (cmd->outfile)
975
							return (0);
976
3
						cmd->outfile = argv[i];
977
					}
978
					goto nextarg;
979
				case 'D':
980
					if (argv[i][j - 1] != '-')
981
						return (0);
982
					(void) addarg(argv[i]);
983
					goto nextarg;
984
				case 'Y':
985
					if (++i == argc)
986
						return (0);
987
					if (snprintf(pathbuf, sizeof pathbuf,
988
					    "%s/cpp", argv[i]) >= sizeof pathbuf)
989
						usage();
990
					CPP = pathbuf;
991
					cppDefined = 1;
992
					goto nextarg;
993
				default:
994
					return (0);
995
				}
996
			}
997
14
	nextarg:
998
			;
999
		}
1000
	}
1001
1002
3
	cmd->cflag = flag['c'];
1003
3
	cmd->hflag = flag['h'];
1004
3
	cmd->lflag = flag['l'];
1005
3
	cmd->mflag = flag['m'];
1006
3
	cmd->nflag = flag['n'];
1007
3
	cmd->sflag = flag['s'];
1008
3
	cmd->tflag = flag['t'];
1009
3
	cmd->Ssflag = flag['S'];
1010
3
	cmd->Scflag = flag['C'];
1011
1012
3
	if (tirpcflag) {
1013
		pmflag = inetdflag ? 0 : 1;	/* pmflag or inetdflag is
1014
						 * always TRUE */
1015
		if (inetdflag && cmd->nflag) {
1016
			/* netid not allowed with inetdflag */
1017
			fprintf(stderr, "Cannot use netid flag with inetd flag!\n");
1018
			return (0);
1019
		}
1020
	} else {
1021
		/* 4.1 mode */
1022
3
		pmflag = 0;	/* set pmflag only in tirpcmode */
1023
3
		inetdflag = 1;	/* inetdflag is TRUE by default */
1024
3
		if (cmd->nflag) {
1025
			/* netid needs TIRPC */
1026
			fprintf(stderr, "Cannot use netid flag without TIRPC!\n");
1027
			return (0);
1028
		}
1029
	}
1030
1031

3
	if (newstyle && (tblflag || cmd->tflag)) {
1032
		fprintf(stderr, "Cannot use table flags with newstyle!\n");
1033
		return (0);
1034
	}
1035
	/* check no conflicts with file generation flags */
1036
3
	nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag +
1037
	    cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag;
1038
1039
3
	if (nflags == 0) {
1040
		if (cmd->outfile != NULL || cmd->infile == NULL)
1041
			return (0);
1042
3
	} else if (nflags > 1) {
1043
		fprintf(stderr, "Cannot have more than one file generation flag!\n");
1044
		return (0);
1045
	}
1046
3
	return (1);
1047
}
1048
1049
static void
1050
usage(void)
1051
{
1052
	fprintf(stderr, "usage: %s [-abACILNT] [-Dname[=value]] [-i lines] "
1053
	    "[-K seconds] infile\n", cmdname);
1054
	fprintf(stderr, "       %s [-c | -h | -l | -m | -t | -Sc | -Ss] "
1055
	    "[-o outfile] [infile]\n", cmdname);
1056
	fprintf(stderr, "       %s [-s nettype]* [-o outfile] [infile]\n", cmdname);
1057
	exit(1);
1058
}