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