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