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