rpc_main.c revision 307697
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" 34static 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: stable/11/usr.bin/rpcgen/rpc_main.c 307697 2016-10-21 03:10:05Z araujo $"); 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 59static void c_output(const char *, const char *, int, const char *); 60static void h_output(const char *, const char *, int, const char *, int); 61static void l_output(const char *, const char *, int, const char *); 62static void t_output(const char *, const char *, int, const char *); 63static void clnt_output(const char *, const char *, int, const char * ); 64static char *generate_guard(const char *); 65static void c_initialize(void); 66 67static void usage(void); 68static void options_usage(void); 69static int do_registers(int, const char **); 70static int parseargs(int, const char **, struct commandline *); 71static void svc_output(const char *, const char *, int, const char *); 72static void mkfile_output(struct commandline *); 73static 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 78static const char *svcclosetime = "120"; 79static const char *CPP = NULL; 80static const char CPPFLAGS[] = "-C"; 81static char pathbuf[MAXPATHLEN + 1]; 82static const char *allv[] = { 83 "rpcgen", "-s", "udp", "-s", "tcp", 84}; 85static int allc = nitems(allv); 86static const char *allnv[] = { 87 "rpcgen", "-s", "netpath", 88}; 89static int allnc = nitems(allnv); 90 91/* 92 * machinations for handling expanding argument list 93 */ 94static void addarg(const char *); /* add another argument to the list */ 95static void insarg(int, const char *); /* insert arg at specified location */ 96static void clear_args(void); /* clear argument list */ 97static 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 105static char *arglist[ARGLISTLEN]; 106static int argcount = FIXEDARGS; 107 108 109int nonfatalerrors; /* errors */ 110int inetdflag = 0; /* Support for inetd is disabled by default, use -I */ 111int pmflag = 0; /* Support for port monitors is disabled by default */ 112int tirpc_socket = 1; /* TI-RPC on socket, no TLI library */ 113int logflag; /* Use syslog instead of fprintf for errors */ 114int tblflag; /* Support for dispatch table file */ 115int mtflag = 0; /* Support for MT */ 116 117#define INLINE 0 118/* length at which to start doing an inline */ 119 120int inline_size = INLINE; 121/* 122 * Length at which to start doing an inline. INLINE = default 123 * if 0, no xdr_inline code 124 */ 125 126int indefinitewait; /* If started by port monitors, hang till it wants */ 127int exitnow; /* If started by port monitors, exit after the call */ 128int timerflag; /* TRUE if !indefinite && !exitnow */ 129int newstyle; /* newstyle of passing arguments (by value) */ 130int CCflag = 0; /* C++ files */ 131static int allfiles; /* generate all files */ 132int tirpcflag = 1; /* generating code for tirpc, by default */ 133xdrfunc *xdrfunc_head = NULL; /* xdr function list */ 134xdrfunc *xdrfunc_tail = NULL; /* xdr function list */ 135pid_t childpid; 136 137 138int 139main(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 */ 220static char * 221extendfile(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 */ 244static void 245open_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 267static void 268add_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 */ 277static void 278clear_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 */ 287static void 288prepend_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 */ 314static void 315open_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 */ 345static 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 */ 360static const char *valid_i_nettypes[] = 361{ 362 "udp", 363 "tcp", 364 NULL 365 }; 366 367static int 368check_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 380static const char * 381file_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 394static void 395c_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 423void 424c_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 438static 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 447char * 448generate_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 guard = extendfile(guard, "_H_RPCGEN"); 488 return (guard); 489} 490 491/* 492 * Compile into an XDR header file 493 */ 494 495 496static void 497h_output(const char *infile, const char *define, int extend, const char *outfile, int headeronly) 498{ 499 definition *def; 500 const char *outfilename; 501 long tell; 502 const char *guard; 503 list *l; 504 xdrfunc *xdrfuncp; 505 506 open_input(infile, define); 507 outfilename = extend ? extendfile(infile, outfile) : outfile; 508 open_output(infile, outfilename); 509 add_warning(); 510 if (outfilename || infile){ 511 guard = generate_guard(outfilename ? outfilename: infile); 512 } else 513 guard = "STDIN_"; 514 515 f_print(fout, "#ifndef _%s\n#define _%s\n\n", guard, 516 guard); 517 518 f_print(fout, "#include <rpc/rpc.h>\n"); 519 520 if (mtflag) 521 f_print(fout, "#include <pthread.h>\n"); 522 523 /* put the C++ support */ 524 if (!CCflag) { 525 f_print(fout, "\n#ifdef __cplusplus\n"); 526 f_print(fout, "extern \"C\" {\n"); 527 f_print(fout, "#endif\n\n"); 528 } 529 530 /* put in a typedef for quadprecision. Only with Cflag */ 531 532 tell = ftell(fout); 533 534 /* print data definitions */ 535 while ( (def = get_definition()) ) { 536 print_datadef(def, headeronly); 537 } 538 539 /* 540 * print function declarations. 541 * Do this after data definitions because they might be used as 542 * arguments for functions 543 */ 544 for (l = defined; l != NULL; l = l->next) { 545 print_funcdef(l->val, headeronly); 546 } 547 /* Now print all xdr func declarations */ 548 if (xdrfunc_head != NULL){ 549 550 f_print(fout, 551 "\n/* the xdr functions */\n"); 552 553 if (CCflag){ 554 f_print(fout, "\n#ifdef __cplusplus\n"); 555 f_print(fout, "extern \"C\" {\n"); 556 f_print(fout, "#endif\n"); 557 } 558 559 xdrfuncp = xdrfunc_head; 560 while (xdrfuncp != NULL){ 561 print_xdr_func_def(xdrfuncp->name, xdrfuncp->pointerp); 562 xdrfuncp = xdrfuncp->next; 563 } 564 } 565 566 if (extend && tell == ftell(fout)) { 567 (void) unlink(outfilename); 568 } else if (tblflag) { 569 f_print(fout, rpcgen_table_dcl); 570 } 571 572 f_print(fout, "\n#ifdef __cplusplus\n"); 573 f_print(fout, "}\n"); 574 f_print(fout, "#endif\n"); 575 576 f_print(fout, "\n#endif /* !_%s */\n", guard); 577} 578 579/* 580 * Compile into an RPC service 581 */ 582static void 583s_output(int argc, const char *argv[], const char *infile, const char *define, 584 int extend, const char *outfile, int nomain, int netflag) 585{ 586 char *include; 587 definition *def; 588 int foundprogram = 0; 589 const char *outfilename; 590 591 open_input(infile, define); 592 outfilename = extend ? extendfile(infile, outfile) : outfile; 593 open_output(infile, outfilename); 594 add_warning(); 595 if (infile && (include = extendfile(infile, ".h"))) { 596 f_print(fout, "#include \"%s\"\n", include); 597 free(include); 598 } else 599 f_print(fout, "#include <rpc/rpc.h>\n"); 600 601 f_print(fout, "#include <stdio.h>\n"); 602 f_print(fout, "#include <stdlib.h> /* getenv, exit */\n"); 603 f_print (fout, "#include <rpc/pmap_clnt.h> /* for pmap_unset */\n"); 604 f_print (fout, "#include <string.h> /* strcmp */\n"); 605 if (tirpcflag) 606 f_print(fout, "#include <rpc/rpc_com.h>\n"); 607 if (strcmp(svcclosetime, "-1") == 0) 608 indefinitewait = 1; 609 else if (strcmp(svcclosetime, "0") == 0) 610 exitnow = 1; 611 else if (inetdflag || pmflag) { 612 f_print(fout, "#include <signal.h>\n"); 613 timerflag = 1; 614 } 615 616 if (!tirpcflag && inetdflag) 617 f_print(fout, "#include <sys/ttycom.h> /* TIOCNOTTY */\n"); 618 if (inetdflag || pmflag) { 619 f_print(fout, "#ifdef __cplusplus\n"); 620 f_print(fout, 621 "#include <sys/sysent.h> /* getdtablesize, open */\n"); 622 f_print(fout, "#endif /* __cplusplus */\n"); 623 } 624 if (tirpcflag) { 625 f_print(fout, "#include <fcntl.h> /* open */\n"); 626 f_print(fout, "#include <unistd.h> /* fork / setsid */\n"); 627 f_print(fout, "#include <sys/types.h>\n"); 628 } 629 630 f_print(fout, "#include <string.h>\n"); 631 if (inetdflag || !tirpcflag) { 632 f_print(fout, "#include <sys/socket.h>\n"); 633 f_print(fout, "#include <netinet/in.h>\n"); 634 } 635 636 if ((netflag || pmflag) && tirpcflag && !nomain) { 637 f_print(fout, "#include <netconfig.h>\n"); 638 } 639 if (tirpcflag) 640 f_print(fout, "#include <sys/resource.h> /* rlimit */\n"); 641 if (logflag || inetdflag || pmflag || tirpcflag) 642 f_print(fout, "#include <syslog.h>\n"); 643 644 f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n"); 645 if (timerflag) 646 f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", 647 svcclosetime); 648 while ( (def = get_definition()) ) { 649 foundprogram |= (def->def_kind == DEF_PROGRAM); 650 } 651 if (extend && !foundprogram) { 652 (void) unlink(outfilename); 653 return; 654 } 655 write_most(infile, netflag, nomain); 656 if (!nomain) { 657 if (!do_registers(argc, argv)) { 658 if (outfilename) 659 (void) unlink(outfilename); 660 usage(); 661 } 662 write_rest(); 663 } 664} 665 666/* 667 * generate client side stubs 668 */ 669static void 670l_output(const char *infile, const char *define, int extend, const char *outfile) 671{ 672 char *include; 673 definition *def; 674 int foundprogram = 0; 675 const char *outfilename; 676 677 open_input(infile, define); 678 outfilename = extend ? extendfile(infile, outfile) : outfile; 679 open_output(infile, outfilename); 680 add_warning(); 681 f_print (fout, "#include <string.h> /* for memset */\n"); 682 if (infile && (include = extendfile(infile, ".h"))) { 683 f_print(fout, "#include \"%s\"\n", include); 684 free(include); 685 } else 686 f_print(fout, "#include <rpc/rpc.h>\n"); 687 while ( (def = get_definition()) ) { 688 foundprogram |= (def->def_kind == DEF_PROGRAM); 689 } 690 if (extend && !foundprogram) { 691 (void) unlink(outfilename); 692 return; 693 } 694 write_stubs(); 695} 696 697/* 698 * generate the dispatch table 699 */ 700static void 701t_output(const char *infile, const char *define, int extend, const char *outfile) 702{ 703 definition *def; 704 int foundprogram = 0; 705 const char *outfilename; 706 707 open_input(infile, define); 708 outfilename = extend ? extendfile(infile, outfile) : outfile; 709 open_output(infile, outfilename); 710 add_warning(); 711 while ( (def = get_definition()) ) { 712 foundprogram |= (def->def_kind == DEF_PROGRAM); 713 } 714 if (extend && !foundprogram) { 715 (void) unlink(outfilename); 716 return; 717 } 718 write_tables(); 719} 720 721/* sample routine for the server template */ 722static void 723svc_output(const char *infile, const char *define, int extend, const char *outfile) 724{ 725 definition *def; 726 char *include; 727 const char *outfilename; 728 long tell; 729 open_input(infile, define); 730 outfilename = extend ? extendfile(infile, outfile) : outfile; 731 checkfiles(infile, outfilename); 732 /* 733 * Check if outfile already exists. 734 * if so, print an error message and exit 735 */ 736 open_output(infile, outfilename); 737 add_sample_msg(); 738 739 if (infile && (include = extendfile(infile, ".h"))) { 740 f_print(fout, "#include \"%s\"\n", include); 741 free(include); 742 } else 743 f_print(fout, "#include <rpc/rpc.h>\n"); 744 745 tell = ftell(fout); 746 while ( (def = get_definition()) ) { 747 write_sample_svc(def); 748 } 749 if (extend && tell == ftell(fout)) { 750 (void) unlink(outfilename); 751 } 752} 753 754/* sample main routine for client */ 755static void 756clnt_output(const char *infile, const char *define, int extend, const char *outfile) 757{ 758 definition *def; 759 char *include; 760 const char *outfilename; 761 long tell; 762 int has_program = 0; 763 764 open_input(infile, define); 765 outfilename = extend ? extendfile(infile, outfile) : outfile; 766 checkfiles(infile, outfilename); 767 /* 768 * Check if outfile already exists. 769 * if so, print an error message and exit 770 */ 771 772 open_output(infile, outfilename); 773 add_sample_msg(); 774 if (infile && (include = extendfile(infile, ".h"))) { 775 f_print(fout, "#include \"%s\"\n", include); 776 free(include); 777 } else 778 f_print(fout, "#include <rpc/rpc.h>\n"); 779 f_print(fout, "#include <stdio.h>\n"); 780 f_print(fout, "#include <stdlib.h>\n"); 781 tell = ftell(fout); 782 while ( (def = get_definition()) ) { 783 has_program += write_sample_clnt(def); 784 } 785 786 if (has_program) 787 write_sample_clnt_main(); 788 789 if (extend && tell == ftell(fout)) { 790 (void) unlink(outfilename); 791 } 792} 793 794 795static void mkfile_output(struct commandline *cmd) 796{ 797 const char *mkfilename, *clientname, *clntname, *xdrname, *hdrname; 798 const char *servername, *svcname, *servprogname, *clntprogname; 799 char *temp, *mkftemp; 800 801 svcname = file_name(cmd->infile, "_svc.c"); 802 clntname = file_name(cmd->infile, "_clnt.c"); 803 xdrname = file_name(cmd->infile, "_xdr.c"); 804 hdrname = file_name(cmd->infile, ".h"); 805 806 807 if (allfiles){ 808 servername = extendfile(cmd->infile, "_server.c"); 809 clientname = extendfile(cmd->infile, "_client.c"); 810 }else{ 811 servername = " "; 812 clientname = " "; 813 } 814 servprogname = extendfile(cmd->infile, "_server"); 815 clntprogname = extendfile(cmd->infile, "_client"); 816 817 if (allfiles){ 818 mkftemp = xmalloc(strlen("makefile.") + 819 strlen(cmd->infile) + 1); 820 temp = strrchr(cmd->infile, '.'); 821 strcpy(mkftemp, "makefile."); 822 (void) strncat(mkftemp, cmd->infile, 823 (temp - cmd->infile)); 824 mkfilename = mkftemp; 825 } else 826 mkfilename = cmd->outfile; 827 828 829 checkfiles(NULL, mkfilename); 830 open_output(NULL, mkfilename); 831 832 f_print(fout, "\n# This is a template makefile generated\ 833 by rpcgen \n"); 834 835 f_print(fout, "\n# Parameters \n\n"); 836 837 f_print(fout, "CLIENT = %s\nSERVER = %s\n\n", 838 clntprogname, servprogname); 839 f_print(fout, "SOURCES_CLNT.c = \nSOURCES_CLNT.h = \n"); 840 f_print(fout, "SOURCES_SVC.c = \nSOURCES_SVC.h = \n"); 841 f_print(fout, "SOURCES.x = %s\n\n", cmd->infile); 842 f_print(fout, "TARGETS_SVC.c = %s %s %s \n", 843 svcname, servername, xdrname); 844 f_print(fout, "TARGETS_CLNT.c = %s %s %s \n", 845 clntname, clientname, xdrname); 846 f_print(fout, "TARGETS = %s %s %s %s %s %s\n\n", 847 hdrname, xdrname, clntname, 848 svcname, clientname, servername); 849 850 f_print(fout, "OBJECTS_CLNT = $(SOURCES_CLNT.c:%%.c=%%.o) \ 851$(TARGETS_CLNT.c:%%.c=%%.o) "); 852 853 f_print(fout, "\nOBJECTS_SVC = $(SOURCES_SVC.c:%%.c=%%.o) \ 854$(TARGETS_SVC.c:%%.c=%%.o) "); 855 856 857 f_print(fout, "\n# Compiler flags \n"); 858 if (mtflag) 859 f_print(fout, "\nCFLAGS += -D_REENTRANT -D_THEAD_SAFE \nLDLIBS += -pthread\n"); 860 861 f_print(fout, "RPCGENFLAGS = \n"); 862 863 f_print(fout, "\n# Targets \n\n"); 864 865 f_print(fout, "all : $(CLIENT) $(SERVER)\n\n"); 866 f_print(fout, "$(TARGETS) : $(SOURCES.x) \n"); 867 f_print(fout, "\trpcgen $(RPCGENFLAGS) $(SOURCES.x)\n\n"); 868 if (allfiles) { 869 f_print(fout, "\trpcgen -Sc $(RPCGENFLAGS) $(SOURCES.x) -o %s\n\n", clientname); 870 f_print(fout, "\trpcgen -Ss $(RPCGENFLAGS) $(SOURCES.x) -o %s\n\n", servername); 871 } 872 f_print(fout, "$(OBJECTS_CLNT) : $(SOURCES_CLNT.c) $(SOURCES_CLNT.h) \ 873$(TARGETS_CLNT.c) \n\n"); 874 875 f_print(fout, "$(OBJECTS_SVC) : $(SOURCES_SVC.c) $(SOURCES_SVC.h) \ 876$(TARGETS_SVC.c) \n\n"); 877 f_print(fout, "$(CLIENT) : $(OBJECTS_CLNT) \n"); 878 f_print(fout, "\t$(CC) -o $(CLIENT) $(OBJECTS_CLNT) \ 879$(LDLIBS) \n\n"); 880 f_print(fout, "$(SERVER) : $(OBJECTS_SVC) \n"); 881 f_print(fout, "\t$(CC) -o $(SERVER) $(OBJECTS_SVC) $(LDLIBS)\n\n"); 882 f_print(fout, "clean:\n\t rm -f core $(TARGETS) $(OBJECTS_CLNT) \ 883$(OBJECTS_SVC) $(CLIENT) $(SERVER)\n\n"); 884} 885 886 887 888/* 889 * Perform registrations for service output 890 * Return 0 if failed; 1 otherwise. 891 */ 892static int 893do_registers(int argc, const char *argv[]) 894{ 895 int i; 896 897 if (inetdflag || !tirpcflag) { 898 for (i = 1; i < argc; i++) { 899 if (streq(argv[i], "-s")) { 900 if (!check_nettype(argv[i + 1], 901 valid_i_nettypes)) 902 return (0); 903 write_inetd_register(argv[i + 1]); 904 i++; 905 } 906 } 907 } else { 908 for (i = 1; i < argc; i++) 909 if (streq(argv[i], "-s")) { 910 if (!check_nettype(argv[i + 1], 911 valid_ti_nettypes)) 912 return (0); 913 write_nettype_register(argv[i + 1]); 914 i++; 915 } else if (streq(argv[i], "-n")) { 916 write_netid_register(argv[i + 1]); 917 i++; 918 } 919 } 920 return (1); 921} 922 923/* 924 * Add another argument to the arg list 925 */ 926static void 927addarg(const char *cp) 928{ 929 if (argcount >= ARGLISTLEN) { 930 warnx("too many defines"); 931 crash(); 932 /*NOTREACHED*/ 933 } 934 if (cp != NULL) 935 arglist[argcount++] = xstrdup(cp); 936 else 937 arglist[argcount++] = NULL; 938 939} 940 941/* 942 * Insert an argument at the specified location 943 */ 944static void 945insarg(int place, const char *cp) 946{ 947 int i; 948 949 if (argcount >= ARGLISTLEN) { 950 warnx("too many defines"); 951 crash(); 952 /*NOTREACHED*/ 953 } 954 955 /* Move up existing arguments */ 956 for (i = argcount - 1; i >= place; i--) 957 arglist[i + 1] = arglist[i]; 958 959 arglist[place] = xstrdup(cp); 960 argcount++; 961} 962 963/* 964 * if input file is stdin and an output file is specified then complain 965 * if the file already exists. Otherwise the file may get overwritten 966 * If input file does not exist, exit with an error 967 */ 968 969static void 970checkfiles(const char *infile, const char *outfile) 971{ 972 973 struct stat buf; 974 975 if (infile) /* infile ! = NULL */ 976 if (stat(infile, &buf) < 0) 977 { 978 warn("%s", infile); 979 crash(); 980 } 981 if (outfile) { 982 if (stat(outfile, &buf) < 0) 983 return; /* file does not exist */ 984 else { 985 warnx("file '%s' already exists and may be overwritten", outfile); 986 crash(); 987 } 988 } 989} 990 991/* 992 * Parse command line arguments 993 */ 994static int 995parseargs(int argc, const char *argv[], struct commandline *cmd) 996{ 997 int i; 998 int j; 999 char c, ch; 1000 char flag[(1 << 8 * sizeof (char))]; 1001 int nflags; 1002 1003 cmd->infile = cmd->outfile = NULL; 1004 if (argc < 2) { 1005 return (0); 1006 } 1007 allfiles = 0; 1008 flag['c'] = 0; 1009 flag['h'] = 0; 1010 flag['l'] = 0; 1011 flag['m'] = 0; 1012 flag['o'] = 0; 1013 flag['s'] = 0; 1014 flag['n'] = 0; 1015 flag['t'] = 0; 1016 flag['S'] = 0; 1017 flag['C'] = 0; 1018 flag['M'] = 0; 1019 1020 for (i = 1; i < argc; i++) { 1021 if (argv[i][0] != '-') { 1022 if (cmd->infile) { 1023 warnx("cannot specify more than one input file"); 1024 return (0); 1025 } 1026 cmd->infile = argv[i]; 1027 } else { 1028 for (j = 1; argv[i][j] != 0; j++) { 1029 c = argv[i][j]; 1030 switch (c) { 1031 case 'a': 1032 allfiles = 1; 1033 break; 1034 case 'c': 1035 case 'h': 1036 case 'l': 1037 case 'm': 1038 case 't': 1039 if (flag[(int)c]) { 1040 return (0); 1041 } 1042 flag[(int)c] = 1; 1043 break; 1044 case 'S': 1045 /* 1046 * sample flag: Ss or Sc. 1047 * Ss means set flag['S']; 1048 * Sc means set flag['C']; 1049 * Sm means set flag['M']; 1050 */ 1051 ch = argv[i][++j]; /* get next char */ 1052 if (ch == 's') 1053 ch = 'S'; 1054 else if (ch == 'c') 1055 ch = 'C'; 1056 else if (ch == 'm') 1057 ch = 'M'; 1058 else 1059 return (0); 1060 1061 if (flag[(int)ch]) { 1062 return (0); 1063 } 1064 flag[(int)ch] = 1; 1065 break; 1066 case 'C': /* ANSI C syntax */ 1067 ch = argv[i][j+1]; /* get next char */ 1068 1069 if (ch != 'C') 1070 break; 1071 CCflag = 1; 1072 break; 1073 case 'b': 1074 /* 1075 * Turn TIRPC flag off for 1076 * generating backward compatible 1077 * code 1078 */ 1079 tirpcflag = 0; 1080 break; 1081 1082 case 'I': 1083 inetdflag = 1; 1084 break; 1085 case 'N': 1086 newstyle = 1; 1087 break; 1088 case 'L': 1089 logflag = 1; 1090 break; 1091 case 'P': 1092 pmflag = 1; 1093 break; 1094 case 'K': 1095 if (++i == argc) { 1096 return (0); 1097 } 1098 svcclosetime = argv[i]; 1099 goto nextarg; 1100 case 'T': 1101 tblflag = 1; 1102 break; 1103 case 'M': 1104 mtflag = 1; 1105 break; 1106 case 'i' : 1107 if (++i == argc) { 1108 return (0); 1109 } 1110 inline_size = atoi(argv[i]); 1111 goto nextarg; 1112 case 'n': 1113 case 'o': 1114 case 's': 1115 if (argv[i][j - 1] != '-' || 1116 argv[i][j + 1] != 0) { 1117 return (0); 1118 } 1119 flag[(int)c] = 1; 1120 if (++i == argc) { 1121 return (0); 1122 } 1123 if (c == 'o') { 1124 if (cmd->outfile) { 1125 return (0); 1126 } 1127 cmd->outfile = argv[i]; 1128 } 1129 goto nextarg; 1130 case 'D': 1131 if (argv[i][j - 1] != '-') { 1132 return (0); 1133 } 1134 (void) addarg(argv[i]); 1135 goto nextarg; 1136 case 'Y': 1137 if (++i == argc) { 1138 return (0); 1139 } 1140 if (strlcpy(pathbuf, argv[i], 1141 sizeof(pathbuf)) >= sizeof(pathbuf) 1142 || strlcat(pathbuf, "/cpp", 1143 sizeof(pathbuf)) >= 1144 sizeof(pathbuf)) { 1145 warnx("argument too long"); 1146 return (0); 1147 } 1148 CPP = pathbuf; 1149 goto nextarg; 1150 1151 1152 1153 default: 1154 return (0); 1155 } 1156 } 1157 nextarg: 1158 ; 1159 } 1160 } 1161 1162 cmd->cflag = flag['c']; 1163 cmd->hflag = flag['h']; 1164 cmd->lflag = flag['l']; 1165 cmd->mflag = flag['m']; 1166 cmd->nflag = flag['n']; 1167 cmd->sflag = flag['s']; 1168 cmd->tflag = flag['t']; 1169 cmd->Ssflag = flag['S']; 1170 cmd->Scflag = flag['C']; 1171 cmd->makefileflag = flag['M']; 1172 1173 if (tirpcflag) { 1174 if (inetdflag) 1175 pmflag = 0; 1176 if ((inetdflag && cmd->nflag)) { 1177 /* netid not allowed with inetdflag */ 1178 warnx("cannot use netid flag with inetd flag"); 1179 return (0); 1180 } 1181 } else { /* 4.1 mode */ 1182 pmflag = 0; /* set pmflag only in tirpcmode */ 1183 if (cmd->nflag) { /* netid needs TIRPC */ 1184 warnx("cannot use netid flag without TIRPC"); 1185 return (0); 1186 } 1187 } 1188 1189 if (newstyle && (tblflag || cmd->tflag)) { 1190 warnx("cannot use table flags with newstyle"); 1191 return (0); 1192 } 1193 1194 /* check no conflicts with file generation flags */ 1195 nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag + 1196 cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + 1197 cmd->Scflag + cmd->makefileflag; 1198 1199 if (nflags == 0) { 1200 if (cmd->outfile != NULL || cmd->infile == NULL) { 1201 return (0); 1202 } 1203 } else if (cmd->infile == NULL && 1204 (cmd->Ssflag || cmd->Scflag || cmd->makefileflag)) { 1205 warnx("\"infile\" is required for template generation flags"); 1206 return (0); 1207 } if (nflags > 1) { 1208 warnx("cannot have more than one file generation flag"); 1209 return (0); 1210 } 1211 return (1); 1212} 1213 1214static void 1215usage(void) 1216{ 1217 f_print(stderr, "%s\n%s\n%s\n%s\n%s\n", 1218 "usage: rpcgen infile", 1219 " rpcgen [-abCLNTM] [-Dname[=value]] [-i size]\ 1220[-I -P [-K seconds]] [-Y path] infile", 1221 " rpcgen [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm]\ 1222[-o outfile] [infile]", 1223 " rpcgen [-s nettype]* [-o outfile] [infile]", 1224 " rpcgen [-n netid]* [-o outfile] [infile]"); 1225 options_usage(); 1226 exit(1); 1227} 1228 1229static void 1230options_usage(void) 1231{ 1232 f_print(stderr, "options:\n"); 1233 f_print(stderr, "-a\t\tgenerate all files, including samples\n"); 1234 f_print(stderr, "-b\t\tbackward compatibility mode (generates code \ 1235for FreeBSD 4.X)\n"); 1236 f_print(stderr, "-c\t\tgenerate XDR routines\n"); 1237 f_print(stderr, "-C\t\tANSI C mode\n"); 1238 f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n"); 1239 f_print(stderr, "-h\t\tgenerate header file\n"); 1240 f_print(stderr, "-i size\t\tsize at which to start generating\ 1241inline code\n"); 1242 f_print(stderr, "-I\t\tgenerate code for inetd support in server\n"); 1243 f_print(stderr, "-K seconds\tserver exits after K seconds of\ 1244inactivity\n"); 1245 f_print(stderr, "-l\t\tgenerate client side stubs\n"); 1246 f_print(stderr, "-L\t\tserver errors will be printed to syslog\n"); 1247 f_print(stderr, "-m\t\tgenerate server side stubs\n"); 1248 f_print(stderr, "-M\t\tgenerate MT-safe code\n"); 1249 f_print(stderr, "-n netid\tgenerate server code that supports\ 1250named netid\n"); 1251 f_print(stderr, "-N\t\tsupports multiple arguments and\ 1252call-by-value\n"); 1253 f_print(stderr, "-o outfile\tname of the output file\n"); 1254 f_print(stderr, "-P\t\tgenerate code for port monitoring support in server\n"); 1255 f_print(stderr, "-s nettype\tgenerate server code that supports named\ 1256nettype\n"); 1257 f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote\ 1258procedures\n"); 1259 f_print(stderr, "-Ss\t\tgenerate sample server code that defines\ 1260remote procedures\n"); 1261 f_print(stderr, "-Sm \t\tgenerate makefile template \n"); 1262 1263 f_print(stderr, "-t\t\tgenerate RPC dispatch table\n"); 1264 f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n"); 1265 f_print(stderr, "-Y path\t\tpath where cpp is found\n"); 1266 exit(1); 1267} 1268