1 /* $NetBSD: rpc_main.c,v 1.45 2022/03/04 21:12:04 andvar Exp $ */ 2 3 /* 4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 5 * unrestricted use provided that this legend is included on all tape 6 * media and as a part of the software program in whole or part. Users 7 * may copy or modify Sun RPC without charge, but are not authorized 8 * to license or distribute it to anyone else except as part of a product or 9 * program developed by the user or with the express written consent of 10 * Sun Microsystems, Inc. 11 * 12 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 13 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 14 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 15 * 16 * Sun RPC is provided with no support and without any obligation on the 17 * part of Sun Microsystems, Inc. to assist in its use, correction, 18 * modification or enhancement. 19 * 20 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 21 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 22 * OR ANY PART THEREOF. 23 * 24 * In no event will Sun Microsystems, Inc. be liable for any lost revenue 25 * or profits or other special, indirect and consequential damages, even if 26 * Sun has been advised of the possibility of such damages. 27 * 28 * Sun Microsystems, Inc. 29 * 2550 Garcia Avenue 30 * Mountain View, California 94043 31 */ 32 33 #if HAVE_NBTOOL_CONFIG_H 34 #include "nbtool_config.h" 35 #endif 36 37 #include <sys/cdefs.h> 38 #if defined(__RCSID) && !defined(lint) 39 #if 0 40 static char sccsid[] = "@(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI"; 41 #else 42 __RCSID("$NetBSD: rpc_main.c,v 1.45 2022/03/04 21:12:04 andvar Exp $"); 43 #endif 44 #endif 45 46 /* 47 * rpc_main.c, Top level of the RPC protocol compiler. 48 */ 49 50 #define RPCGEN_VERSION "199506"/* This program's version (year & month) */ 51 52 #include <sys/types.h> 53 #include <sys/param.h> 54 #include <sys/file.h> 55 #include <sys/stat.h> 56 #include <ctype.h> 57 #include <err.h> 58 #include <stdio.h> 59 #include <stdlib.h> 60 #include <string.h> 61 #include <unistd.h> 62 #include "rpc_scan.h" 63 #include "rpc_parse.h" 64 #include "rpc_util.h" 65 66 #define EXTEND 1 /* alias for TRUE */ 67 #define DONT_EXTEND 0 /* alias for FALSE */ 68 69 struct commandline { 70 int cflag; /* xdr C routines */ 71 int hflag; /* header file */ 72 int lflag; /* client side stubs */ 73 int mflag; /* server side stubs */ 74 int nflag; /* netid flag */ 75 int sflag; /* server stubs for the given transport */ 76 int tflag; /* dispatch Table file */ 77 int Ssflag; /* produce server sample code */ 78 int Scflag; /* produce client sample code */ 79 char *infile; /* input module name */ 80 char *outfile; /* output module name */ 81 }; 82 83 84 static char *cmdname; 85 86 static const char *svcclosetime = "120"; 87 static const char *CPP; 88 static char CPPFLAGS[] = "-C"; 89 static char pathbuf[MAXPATHLEN + 1]; 90 91 /* these cannot be const */ 92 static char allv0[] = "rpcgen"; 93 static char allv1[] = "-s"; 94 static char allv2[] = "udp"; 95 static char allv3[] = "-s"; 96 static char allv4[] = "tcp"; 97 static char *allv[] = { 98 allv0, 99 allv1, 100 allv2, 101 allv3, 102 allv4, 103 }; 104 static int allc = sizeof(allv) / sizeof(allv[0]); 105 106 /* these cannot be const */ 107 static char allnv0[] = "rpcgen"; 108 static char allnv1[] = "-s"; 109 static char allnv2[] = "netpath"; 110 static char *allnv[] = { 111 allnv0, 112 allnv1, 113 allnv2, 114 }; 115 static int allnc = sizeof(allnv) / sizeof(allnv[0]); 116 117 #define ARGLISTLEN 20 118 #define FIXEDARGS 2 119 120 static const char *arglist[ARGLISTLEN]; 121 static int argcount = FIXEDARGS; 122 123 124 int nonfatalerrors; /* errors */ 125 int inetdflag /* = 1 */ ; /* Support for inetd *//* is now the default */ 126 int pmflag; /* Support for port monitors */ 127 int logflag; /* Use syslog instead of fprintf for errors */ 128 int tblflag; /* Support for dispatch table file */ 129 int BSDflag; /* use BSD cplusplus macros */ 130 int callerflag; /* Generate svc_caller() function */ 131 int docleanup = 1; /* cause atexit to remove files */ 132 133 #define INLINE 3 134 /*length at which to start doing an inline */ 135 136 int doinline = INLINE; /* length at which to start doing an inline. 3 137 * = default if 0, no xdr_inline code */ 138 139 int indefinitewait; /* If started by port monitors, hang till it 140 * wants */ 141 int exitnow; /* If started by port monitors, exit after the 142 * call */ 143 int timerflag; /* TRUE if !indefinite && !exitnow */ 144 int newstyle; /* newstyle of passing arguments (by value) */ 145 int Mflag = 0; /* multithread safe */ 146 static int allfiles; /* generate all files */ 147 int tirpcflag = 1; /* generating code for tirpc, by default */ 148 149 #ifdef __MSDOS__ 150 static char *dos_cppfile = NULL; 151 #endif 152 153 static char *extendfile(const char *, const char *); 154 static void open_output(const char *, const char *); 155 static void add_warning(void); 156 static void clear_args(void); 157 static void open_input(const char *, const char *); 158 static int check_nettype(const char *, const char *[]); 159 static void c_output(const char *, const char *, int, const char *); 160 static void c_initialize(void); 161 static char *generate_guard(const char *); 162 static void h_output(const char *, const char *, int, const char *); 163 static void s_output(int, char *[], char *, const char *, int, const char *, 164 int, int); 165 static void l_output(const char *, const char *, int, const char *); 166 static void t_output(const char *, const char *, int, const char *); 167 static void svc_output(const char *, const char *, int, const char *); 168 static void clnt_output(const char *, const char *, int, const char *); 169 static int do_registers(int, char *[]); 170 static void addarg(const char *); 171 static void putarg(int, const char *); 172 static void checkfiles(const char *, const char *); 173 static int parseargs(int, char *[], struct commandline *); 174 static void usage(void) __dead; 175 static void options_usage(void) __dead; 176 177 int 178 main(int argc, char *argv[]) 179 { 180 struct commandline cmd; 181 182 setprogname(argv[0]); 183 if ((CPP = getenv("RPCGEN_CPP")) == NULL) { 184 CPP = "/usr/bin/cpp"; 185 if (access(CPP, X_OK)) 186 CPP = "/usr/bin/clang-cpp"; 187 } 188 189 (void) memset((char *) &cmd, 0, sizeof(struct commandline)); 190 clear_args(); 191 atexit(crash); 192 if (!parseargs(argc, argv, &cmd)) 193 usage(); 194 195 if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag || 196 cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) { 197 checkfiles(cmd.infile, cmd.outfile); 198 } else 199 checkfiles(cmd.infile, NULL); 200 201 if (cmd.cflag) { 202 c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile); 203 } else 204 if (cmd.hflag) { 205 h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile); 206 } else 207 if (cmd.lflag) { 208 l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile); 209 } else 210 if (cmd.sflag || cmd.mflag || (cmd.nflag)) { 211 s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND, 212 cmd.outfile, cmd.mflag, cmd.nflag); 213 } else 214 if (cmd.tflag) { 215 t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile); 216 } else 217 if (cmd.Ssflag) { 218 svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile); 219 } else 220 if (cmd.Scflag) { 221 clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile); 222 } else { 223 /* the rescans 224 * are 225 * required, 226 * since cpp 227 * may effect 228 * input */ 229 c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c"); 230 reinitialize(); 231 h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h"); 232 reinitialize(); 233 l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c"); 234 reinitialize(); 235 if (inetdflag || !tirpcflag) 236 s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND, 237 "_svc.c", cmd.mflag, cmd.nflag); 238 else 239 s_output(allnc, allnv, cmd.infile, "-DRPC_SVC", 240 EXTEND, "_svc.c", cmd.mflag, cmd.nflag); 241 if (tblflag) { 242 reinitialize(); 243 t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i"); 244 } 245 if (allfiles) { 246 reinitialize(); 247 svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c"); 248 } 249 if (allfiles) { 250 reinitialize(); 251 clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c"); 252 } 253 } 254 #ifdef __MSDOS__ 255 if (dos_cppfile != NULL) { 256 (void) fclose(fin); 257 (void) unlink(dos_cppfile); 258 } 259 #endif 260 docleanup = 0; 261 exit(nonfatalerrors); 262 /* NOTREACHED */ 263 } 264 /* 265 * add extension to filename 266 */ 267 static char * 268 extendfile(const char *path, const char *ext) 269 { 270 const char *file; 271 char *res; 272 const char *p; 273 274 if ((file = strrchr(path, '/')) == NULL) 275 file = path; 276 else 277 file++; 278 279 res = alloc(strlen(file) + strlen(ext) + 1); 280 if (res == NULL) { 281 err(EXIT_FAILURE, "Out of memory"); 282 } 283 p = strrchr(file, '.'); 284 if (p == NULL) { 285 p = file + strlen(file); 286 } 287 (void) strcpy(res, file); 288 (void) strcpy(res + (p - file), ext); 289 return (res); 290 } 291 /* 292 * Open output file with given extension 293 */ 294 static void 295 open_output(const char *infile, const char *outfile) 296 { 297 298 if (outfile == NULL) { 299 fout = stdout; 300 return; 301 } 302 if (infile != NULL && streq(outfile, infile)) { 303 errx(EXIT_FAILURE, "Output would overwrite `%s'", infile); 304 } 305 fout = fopen(outfile, "w"); 306 if (fout == NULL) { 307 err(EXIT_FAILURE, "Can't open `%s'", outfile); 308 } 309 record_open(outfile); 310 311 } 312 313 static void 314 add_warning(void) 315 { 316 f_print(fout, "/*\n"); 317 f_print(fout, " * Please do not edit this file.\n"); 318 f_print(fout, " * It was generated using rpcgen.\n"); 319 f_print(fout, " */\n\n"); 320 } 321 322 /* clear list of arguments */ 323 static void 324 clear_args(void) 325 { 326 int i; 327 for (i = FIXEDARGS; i < ARGLISTLEN; i++) 328 arglist[i] = NULL; 329 argcount = FIXEDARGS; 330 } 331 332 /* 333 * Open input file with given define for C-preprocessor 334 */ 335 static void 336 open_input(const char *infile, const char *define) 337 { 338 int pd[2]; 339 340 infilename = (infile == NULL) ? "<stdin>" : infile; 341 #ifdef __MSDOS__ 342 #define DOSCPP "\\prog\\bc31\\bin\\cpp.exe" 343 { 344 int retval; 345 char drive[MAXDRIVE], dir[MAXDIR], name[MAXFILE], ext[MAXEXT]; 346 char cppfile[MAXPATH]; 347 char *cpp; 348 349 if ((cpp = getenv("RPCGEN_CPP")) == NULL && 350 (cpp = searchpath("cpp.exe")) == NULL) 351 cpp = DOSCPP; 352 353 putarg(0, cpp); 354 putarg(1, "-P-"); 355 putarg(2, CPPFLAGS); 356 addarg(define); 357 addarg(infile); 358 addarg(NULL); 359 360 retval = spawnvp(P_WAIT, arglist[0], arglist); 361 if (retval != 0) { 362 err(EXIT_FAILURE, "C preprocessor failed"); 363 } 364 fnsplit(infile, drive, dir, name, ext); 365 fnmerge(cppfile, drive, dir, name, ".i"); 366 367 fin = fopen(cppfile, "r"); 368 if (fin == NULL) { 369 err(EXIT_FAILURE, "Can't open `%s'", cppfile); 370 } 371 dos_cppfile = strdup(cppfile); 372 if (dos_cppfile == NULL) { 373 err(EXIT_FAILURE, "Can't copy `%s'", cppfile); 374 } 375 } 376 #else 377 (void) pipe(pd); 378 switch (fork()) { 379 case 0: 380 putarg(0, CPP); 381 putarg(1, CPPFLAGS); 382 addarg(define); 383 addarg(infile); 384 addarg(NULL); 385 (void) close(1); 386 (void) dup2(pd[1], 1); 387 (void) close(pd[0]); 388 execvp(arglist[0], __UNCONST(arglist)); 389 err(EXIT_FAILURE, "$RPCGEN_CPP: %s", CPP); 390 case -1: 391 err(EXIT_FAILURE, "fork"); 392 } 393 (void) close(pd[1]); 394 fin = fdopen(pd[0], "r"); 395 #endif 396 if (fin == NULL) { 397 err(EXIT_FAILURE, "Can't open `%s'", infilename); 398 } 399 } 400 /* valid tirpc nettypes */ 401 static const char *valid_ti_nettypes[] = 402 { 403 "netpath", 404 "visible", 405 "circuit_v", 406 "datagram_v", 407 "circuit_n", 408 "datagram_n", 409 "udp", 410 "tcp", 411 "raw", 412 NULL 413 }; 414 /* valid inetd nettypes */ 415 static const char *valid_i_nettypes[] = 416 { 417 "udp", 418 "tcp", 419 NULL 420 }; 421 422 static int 423 check_nettype(const char *name, const char *list_to_check[]) 424 { 425 int i; 426 for (i = 0; list_to_check[i] != NULL; i++) { 427 if (strcmp(name, list_to_check[i]) == 0) { 428 return 1; 429 } 430 } 431 f_print(stderr, "illegal nettype :\'%s\'\n", name); 432 return 0; 433 } 434 /* 435 * Compile into an XDR routine output file 436 */ 437 438 static void 439 c_output(const char *infile, const char *define, int extend, 440 const char *outfile) 441 { 442 definition *def; 443 char *include; 444 const char *outfilename; 445 long tell; 446 447 c_initialize(); 448 open_input(infile, define); 449 outfilename = extend ? extendfile(infile, outfile) : outfile; 450 open_output(infile, outfilename); 451 add_warning(); 452 if (infile && (include = extendfile(infile, ".h"))) { 453 f_print(fout, "#include \"%s\"\n", include); 454 free(include); 455 /* .h file already contains rpc/rpc.h */ 456 } else 457 f_print(fout, "#include <rpc/rpc.h>\n"); 458 tell = ftell(fout); 459 while ((def = get_definition()) != NULL) { 460 emit(def); 461 } 462 if (extend && tell == ftell(fout)) { 463 (void) unlink(outfilename); 464 } 465 } 466 467 468 static void 469 c_initialize(void) 470 { 471 472 /* add all the starting basic types */ 473 474 add_type(1, "int"); 475 add_type(1, "long"); 476 add_type(1, "short"); 477 add_type(1, "bool"); 478 479 add_type(1, "u_int"); 480 add_type(1, "u_long"); 481 add_type(1, "u_short"); 482 483 } 484 485 const char rpcgen_table_dcl[] = "struct rpcgen_table {\n\ 486 char *(*proc)();\n\ 487 xdrproc_t xdr_arg;\n\ 488 unsigned len_arg;\n\ 489 xdrproc_t xdr_res;\n\ 490 unsigned len_res;\n\ 491 };\n"; 492 493 494 static char * 495 generate_guard(const char *pathname) 496 { 497 const char *filename; 498 char *guard, *tmp, *tmp2, *extdot; 499 500 filename = strrchr(pathname, '/'); /* find last component */ 501 filename = ((filename == 0) ? pathname : filename + 1); 502 guard = strdup(filename); 503 if (guard == NULL) { 504 err(EXIT_FAILURE, "strdup"); 505 } 506 extdot = strrchr(guard, '.'); 507 508 /* 509 * Convert to valid C symbol name and make it upper case. 510 * Map non alphanumerical characters to '_'. 511 * 512 * Leave extension as it is. It will be handled in extendfile(). 513 */ 514 for (tmp = guard; *tmp; tmp++) { 515 if (islower((unsigned char)*tmp)) 516 *tmp = toupper((unsigned char)*tmp); 517 else if (isupper((unsigned char)*tmp)) 518 continue; 519 else if (isdigit((unsigned char)*tmp)) 520 continue; 521 else if (*tmp == '_') 522 continue; 523 else if (tmp == extdot) 524 break; 525 else 526 *tmp = '_'; 527 } 528 529 /* 530 * Can't have a '_' or '.' at the front of a symbol name, because it 531 * will end up as "__". 532 * 533 * Prefix it with "RPCGEN_". 534 */ 535 if (guard[0] == '_' || guard[0] == '.') { 536 if (asprintf(&tmp2, "RPCGEN_%s", guard) == -1) { 537 err(EXIT_FAILURE, "asprintf"); 538 } 539 free(guard); 540 guard = tmp2; 541 } 542 543 /* Replace the file extension */ 544 tmp2 = extendfile(guard, "_H_RPCGEN"); 545 free(guard); 546 guard = tmp2; 547 548 return (guard); 549 } 550 551 /* 552 * Compile into an XDR header file 553 */ 554 static void 555 h_output(const char *infile, const char *define, int extend, 556 const char *outfile) 557 { 558 definition *def; 559 const char *outfilename; 560 long tell; 561 char *guard; 562 list *l; 563 int did; 564 565 open_input(infile, define); 566 outfilename = extend ? extendfile(infile, outfile) : outfile; 567 open_output(infile, outfilename); 568 add_warning(); 569 if (outfilename || infile) 570 guard = generate_guard(outfilename ? outfilename : infile); 571 else { 572 guard = strdup("STDIN_"); 573 if (guard == NULL) { 574 err(EXIT_FAILURE, "strdup"); 575 } 576 } 577 578 f_print(fout, "#ifndef _%s\n#define _%s\n\n", guard, 579 guard); 580 581 f_print(fout, "#define RPCGEN_VERSION\t%s\n\n", RPCGEN_VERSION); 582 f_print(fout, "#include <rpc/rpc.h>\n\n"); 583 584 tell = ftell(fout); 585 /* print data definitions */ 586 while ((def = get_definition()) != NULL) { 587 print_datadef(def); 588 } 589 590 /* print function declarations. Do this after data definitions 591 * because they might be used as arguments for functions */ 592 did = 0; 593 for (l = defined; l != NULL; l = l->next) { 594 print_funcdef(l->val, &did); 595 } 596 print_funcend(did); 597 598 for (l = defined; l != NULL; l = l->next) { 599 print_progdef(l->val); 600 } 601 602 if (extend && tell == ftell(fout)) { 603 (void) unlink(outfilename); 604 } else 605 if (tblflag) { 606 f_print(fout, rpcgen_table_dcl); 607 } 608 f_print(fout, "\n#endif /* !_%s */\n", guard); 609 610 free(guard); 611 } 612 613 /* 614 * Compile into an RPC service 615 */ 616 static void 617 s_output(int argc, char *argv[], char *infile, 618 const char *define, int extend, const char *outfile, int nomain, 619 int netflag) 620 { 621 char *include; 622 definition *def; 623 int foundprogram = 0; 624 const char *outfilename; 625 626 open_input(infile, define); 627 outfilename = extend ? extendfile(infile, outfile) : outfile; 628 open_output(infile, outfilename); 629 add_warning(); 630 if (infile && (include = extendfile(infile, ".h"))) { 631 f_print(fout, "#include \"%s\"\n", include); 632 free(include); 633 } else 634 f_print(fout, "#include <rpc/rpc.h>\n"); 635 636 f_print(fout, "#include <sys/ioctl.h>\n"); 637 f_print(fout, "#include <fcntl.h>\n"); 638 f_print(fout, "#include <stdio.h>\n"); 639 f_print(fout, "#include <err.h>\n"); 640 f_print(fout, "#include <stdlib.h>\n"); 641 f_print(fout, "#include <unistd.h>\n"); 642 f_print(fout, "#include <rpc/pmap_clnt.h>\n"); 643 f_print(fout, "#include <string.h>\n"); 644 f_print(fout, "#include <netdb.h>\n"); 645 if (strcmp(svcclosetime, "-1") == 0) 646 indefinitewait = 1; 647 else 648 if (strcmp(svcclosetime, "0") == 0) 649 exitnow = 1; 650 else 651 if (inetdflag || pmflag) { 652 f_print(fout, "#include <signal.h>\n"); 653 timerflag = 1; 654 } 655 if (!tirpcflag && inetdflag) 656 f_print(fout, "#include <sys/ttycom.h>\n"); 657 if (inetdflag || pmflag) { 658 f_print(fout, "#ifdef __cplusplus\n"); 659 f_print(fout, "#include <sysent.h>\n"); 660 f_print(fout, "#endif /* __cplusplus */\n"); 661 } 662 if (tirpcflag) 663 f_print(fout, "#include <sys/types.h>\n"); 664 665 f_print(fout, "#include <memory.h>\n"); 666 667 if (inetdflag || !tirpcflag) { 668 f_print(fout, "#include <sys/socket.h>\n"); 669 f_print(fout, "#include <netinet/in.h>\n"); 670 } 671 if ((netflag || pmflag) && tirpcflag) { 672 f_print(fout, "#include <netconfig.h>\n"); 673 } 674 if ( /* timerflag && */ tirpcflag) 675 f_print(fout, "#include <sys/resource.h>\n"); 676 if (logflag || inetdflag || pmflag) 677 f_print(fout, "#include <syslog.h>\n"); 678 679 f_print(fout, "\n#define SIG_PF void(*)(int)\n"); 680 681 f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n"); 682 if (timerflag) 683 f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime); 684 while ((def = get_definition()) != NULL) { 685 foundprogram |= (def->def_kind == DEF_PROGRAM); 686 } 687 if (extend && !foundprogram) { 688 (void) unlink(outfilename); 689 return; 690 } 691 if (callerflag) /* EVAS */ 692 f_print(fout, "\nstatic SVCXPRT *caller;\n"); /* EVAS */ 693 write_most(infile, netflag, nomain); 694 if (!nomain) { 695 if (!do_registers(argc, argv)) { 696 if (outfilename) 697 (void) unlink(outfilename); 698 usage(); 699 } 700 write_rest(); 701 } 702 } 703 /* 704 * generate client side stubs 705 */ 706 static void 707 l_output(const char *infile, const char *define, int extend, 708 const char *outfile) 709 { 710 char *include; 711 definition *def; 712 int foundprogram = 0; 713 const char *outfilename; 714 715 open_input(infile, define); 716 outfilename = extend ? extendfile(infile, outfile) : outfile; 717 open_output(infile, outfilename); 718 add_warning(); 719 f_print(fout, "#include <memory.h>\n"); 720 if (infile && (include = extendfile(infile, ".h"))) { 721 f_print(fout, "#include \"%s\"\n", include); 722 free(include); 723 } else 724 f_print(fout, "#include <rpc/rpc.h>\n"); 725 while ((def = get_definition()) != NULL) { 726 foundprogram |= (def->def_kind == DEF_PROGRAM); 727 } 728 if (extend && !foundprogram) { 729 (void) unlink(outfilename); 730 return; 731 } 732 write_stubs(); 733 } 734 /* 735 * generate the dispatch table 736 */ 737 static void 738 t_output(const char *infile, const char *define, int extend, 739 const char *outfile) 740 { 741 definition *def; 742 int foundprogram = 0; 743 const char *outfilename; 744 745 open_input(infile, define); 746 outfilename = extend ? extendfile(infile, outfile) : outfile; 747 open_output(infile, outfilename); 748 add_warning(); 749 while ((def = get_definition()) != NULL) { 750 foundprogram |= (def->def_kind == DEF_PROGRAM); 751 } 752 if (extend && !foundprogram) { 753 (void) unlink(outfilename); 754 return; 755 } 756 write_tables(); 757 } 758 /* sample routine for the server template */ 759 static void 760 svc_output(const char *infile, const char *define, int extend, 761 const char *outfile) 762 { 763 definition *def; 764 char *include; 765 const char *outfilename; 766 long tell; 767 768 open_input(infile, define); 769 outfilename = extend ? extendfile(infile, outfile) : outfile; 770 checkfiles(infile, outfilename); /* check if outfile already 771 * exists. if so, print an 772 * error message and exit */ 773 open_output(infile, outfilename); 774 add_sample_msg(); 775 776 if (infile && (include = extendfile(infile, ".h"))) { 777 f_print(fout, "#include \"%s\"\n", include); 778 free(include); 779 } else 780 f_print(fout, "#include <rpc/rpc.h>\n"); 781 782 tell = ftell(fout); 783 while ((def = get_definition()) != NULL) { 784 write_sample_svc(def); 785 } 786 if (extend && tell == ftell(fout)) { 787 (void) unlink(outfilename); 788 } 789 } 790 791 792 /* sample main routine for client */ 793 static void 794 clnt_output(const char *infile, const char *define, int extend, 795 const char *outfile) 796 { 797 definition *def; 798 char *include; 799 const char *outfilename; 800 long tell; 801 int has_program = 0; 802 803 open_input(infile, define); 804 outfilename = extend ? extendfile(infile, outfile) : outfile; 805 checkfiles(infile, outfilename); /* check if outfile already 806 * exists. if so, print an 807 * error message and exit */ 808 809 open_output(infile, outfilename); 810 add_sample_msg(); 811 f_print(fout, "#include <stdio.h>\n"); 812 f_print(fout, "#include <err.h>\n"); 813 if (infile && (include = extendfile(infile, ".h"))) { 814 f_print(fout, "#include \"%s\"\n", include); 815 free(include); 816 } else 817 f_print(fout, "#include <rpc/rpc.h>\n"); 818 tell = ftell(fout); 819 while ((def = get_definition()) != NULL) { 820 has_program += write_sample_clnt(def); 821 } 822 823 if (has_program) 824 write_sample_clnt_main(); 825 826 if (extend && tell == ftell(fout)) { 827 (void) unlink(outfilename); 828 } 829 } 830 /* 831 * Perform registrations for service output 832 * Return 0 if failed; 1 otherwise. 833 */ 834 static int 835 do_registers(int argc, char *argv[]) 836 { 837 int i; 838 839 if (inetdflag || !tirpcflag) { 840 for (i = 1; i < argc; i++) { 841 if (streq(argv[i], "-s")) { 842 if (!check_nettype(argv[i + 1], valid_i_nettypes)) 843 return 0; 844 write_inetd_register(argv[i + 1]); 845 i++; 846 } 847 } 848 } else { 849 for (i = 1; i < argc; i++) 850 if (streq(argv[i], "-s")) { 851 if (!check_nettype(argv[i + 1], valid_ti_nettypes)) 852 return 0; 853 write_nettype_register(argv[i + 1]); 854 i++; 855 } else 856 if (streq(argv[i], "-n")) { 857 write_netid_register(argv[i + 1]); 858 i++; 859 } 860 } 861 return 1; 862 } 863 /* 864 * Add another argument to the arg list 865 */ 866 static void 867 addarg(const char *cp) 868 { 869 if (argcount >= ARGLISTLEN) { 870 errx(EXIT_FAILURE, "Internal error: too many defines"); 871 /* NOTREACHED */ 872 } 873 arglist[argcount++] = cp; 874 875 } 876 877 static void 878 putarg(int pwhere, const char *cp) 879 { 880 if (pwhere >= ARGLISTLEN) { 881 errx(EXIT_FAILURE, "Internal error: arglist coding error"); 882 /* NOTREACHED */ 883 } 884 arglist[pwhere] = cp; 885 886 } 887 /* 888 * if input file is stdin and an output file is specified then complain 889 * if the file already exists. Otherwise the file may get overwritten 890 * If input file does not exist, exit with an error 891 */ 892 893 static void 894 checkfiles(const char *infile, const char *outfile) 895 { 896 897 struct stat buf; 898 899 if (infile) /* infile ! = NULL */ 900 if (stat(infile, &buf) < 0) { 901 err(EXIT_FAILURE, "Can't stat `%s'", infile); 902 }; 903 #if 0 904 if (outfile) { 905 if (stat(outfile, &buf) < 0) 906 return; /* file does not exist */ 907 else { 908 errx(EXIT_FAILURE, 909 "`%s' already exists and would be overwritten", 910 outfile); 911 } 912 } 913 #endif 914 } 915 /* 916 * Parse command line arguments 917 */ 918 static int 919 parseargs(int argc, char *argv[], struct commandline *cmd) 920 { 921 int i; 922 int j; 923 int c; 924 char flag[1 << CHAR_BIT]; 925 int nflags; 926 927 cmdname = argv[0]; 928 cmd->infile = cmd->outfile = NULL; 929 if (argc < 2) { 930 return (0); 931 } 932 allfiles = 0; 933 flag['c'] = 0; 934 flag['h'] = 0; 935 flag['l'] = 0; 936 flag['m'] = 0; 937 flag['o'] = 0; 938 flag['s'] = 0; 939 flag['n'] = 0; 940 flag['t'] = 0; 941 flag['S'] = 0; 942 flag['C'] = 0; 943 for (i = 1; i < argc; i++) { 944 if (argv[i][0] != '-') { 945 if (cmd->infile) { 946 f_print(stderr, "Cannot specify more than one input file!\n"); 947 948 return (0); 949 } 950 cmd->infile = argv[i]; 951 } else { 952 for (j = 1; argv[i][j] != 0; j++) { 953 c = argv[i][j]; 954 switch (c) { 955 case 'A': 956 callerflag = 1; 957 break; 958 case 'a': 959 allfiles = 1; 960 break; 961 case 'B': 962 BSDflag = 1; 963 break; 964 case 'c': 965 case 'h': 966 case 'l': 967 case 'm': 968 case 't': 969 if (flag[c]) { 970 return (0); 971 } 972 flag[c] = 1; 973 break; 974 case 'S': 975 /* sample flag: Ss or Sc. Ss means set 976 * flag['S']; Sc means set flag['C']; */ 977 c = argv[i][++j]; /* get next char */ 978 if (c == 's') 979 c = 'S'; 980 else 981 if (c == 'c') 982 c = 'C'; 983 else 984 return (0); 985 986 if (flag[c]) { 987 return (0); 988 } 989 flag[c] = 1; 990 break; 991 case 'C': /* deprecated ANSI C syntax */ 992 break; 993 994 case 'b': /* turn TIRPC flag off for 995 * generating backward 996 * compatible */ 997 tirpcflag = 0; 998 break; 999 1000 case 'I': 1001 inetdflag = 1; 1002 break; 1003 case 'M': 1004 Mflag = 1; 1005 break; 1006 case 'N': 1007 newstyle = 1; 1008 break; 1009 case 'L': 1010 logflag = 1; 1011 break; 1012 case 'K': 1013 if (++i == argc) { 1014 return (0); 1015 } 1016 svcclosetime = argv[i]; 1017 goto nextarg; 1018 case 'T': 1019 tblflag = 1; 1020 break; 1021 case 'i': 1022 if (++i == argc) { 1023 return (0); 1024 } 1025 doinline = atoi(argv[i]); 1026 goto nextarg; 1027 case 'n': 1028 case 'o': 1029 case 's': 1030 if (argv[i][j - 1] != '-' || 1031 argv[i][j + 1] != 0) { 1032 return (0); 1033 } 1034 flag[c] = 1; 1035 if (++i == argc) { 1036 return (0); 1037 } 1038 if (c == 's') { 1039 if (!streq(argv[i], "udp") && 1040 !streq(argv[i], "tcp")) { 1041 return (0); 1042 } 1043 } else 1044 if (c == 'o') { 1045 if (cmd->outfile) { 1046 return (0); 1047 } 1048 cmd->outfile = argv[i]; 1049 } 1050 goto nextarg; 1051 case 'D': 1052 if (argv[i][j - 1] != '-') { 1053 return (0); 1054 } 1055 (void) addarg(argv[i]); 1056 goto nextarg; 1057 case 'Y': 1058 if (++i == argc) { 1059 return (0); 1060 } 1061 (void) strlcpy(pathbuf, argv[i], 1062 sizeof(pathbuf)); 1063 (void) strlcat(pathbuf, "/cpp", 1064 sizeof(pathbuf)); 1065 CPP = pathbuf; 1066 goto nextarg; 1067 1068 case 'v': 1069 printf("version 1.0\n"); 1070 exit(0); 1071 1072 default: 1073 return (0); 1074 } 1075 } 1076 nextarg: 1077 ; 1078 } 1079 } 1080 1081 cmd->cflag = flag['c']; 1082 cmd->hflag = flag['h']; 1083 cmd->lflag = flag['l']; 1084 cmd->mflag = flag['m']; 1085 cmd->nflag = flag['n']; 1086 cmd->sflag = flag['s']; 1087 cmd->tflag = flag['t']; 1088 cmd->Ssflag = flag['S']; 1089 cmd->Scflag = flag['C']; 1090 1091 if (tirpcflag) { 1092 pmflag = inetdflag ? 0 : 1; /* pmflag or inetdflag is 1093 * always TRUE */ 1094 if ((inetdflag && cmd->nflag)) { /* netid not allowed 1095 * with inetdflag */ 1096 f_print(stderr, "Cannot use netid flag with inetd flag!\n"); 1097 return (0); 1098 } 1099 } else { /* 4.1 mode */ 1100 pmflag = 0; /* set pmflag only in tirpcmode */ 1101 inetdflag = 1; /* inetdflag is TRUE by default */ 1102 if (cmd->nflag) { /* netid needs TIRPC */ 1103 f_print(stderr, "Cannot use netid flag without TIRPC!\n"); 1104 return (0); 1105 } 1106 } 1107 1108 if (newstyle && (tblflag || cmd->tflag)) { 1109 f_print(stderr, "Cannot use table flags with newstyle!\n"); 1110 return (0); 1111 } 1112 /* check no conflicts with file generation flags */ 1113 nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag + 1114 cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag; 1115 1116 if (nflags == 0) { 1117 if (cmd->outfile != NULL || cmd->infile == NULL) { 1118 return (0); 1119 } 1120 } else 1121 if (nflags > 1) { 1122 f_print(stderr, "Cannot have more than one file generation flag!\n"); 1123 return (0); 1124 } 1125 return (1); 1126 } 1127 1128 static void 1129 usage(void) 1130 { 1131 f_print(stderr, "usage: %s infile\n", cmdname); 1132 f_print(stderr, "\t%s [-AaBbILMNTv] [-Dname[=value]] [-i size] [-K seconds] [-Y pathname] infile\n", 1133 cmdname); 1134 f_print(stderr, "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss] [-o outfile] [infile]\n", 1135 cmdname); 1136 f_print(stderr, "\t%s [-s nettype] [-o outfile] [infile]\n", cmdname); 1137 f_print(stderr, "\t%s [-n netid] [-o outfile] [infile]\n", cmdname); 1138 options_usage(); 1139 exit(1); 1140 } 1141 1142 static void 1143 options_usage(void) 1144 { 1145 f_print(stderr, "options:\n"); 1146 f_print(stderr, "-A\t\tgenerate svc_caller() function\n"); 1147 f_print(stderr, "-a\t\tgenerate all files, including samples\n"); 1148 f_print(stderr, "-B\t\tgenerate BSD c++ macros\n"); 1149 f_print(stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n"); 1150 f_print(stderr, "-c\t\tgenerate XDR routines\n"); 1151 f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n"); 1152 f_print(stderr, "-h\t\tgenerate header file\n"); 1153 f_print(stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n"); 1154 f_print(stderr, "-i size\t\tsize at which to start generating inline code\n"); 1155 f_print(stderr, "-K seconds\tserver exits after K seconds of inactivity\n"); 1156 f_print(stderr, "-L\t\tserver errors will be printed to syslog\n"); 1157 f_print(stderr, "-l\t\tgenerate client side stubs\n"); 1158 f_print(stderr, "-M\t\tgenerate thread-safe stubs\n"); 1159 f_print(stderr, "-m\t\tgenerate server side stubs\n"); 1160 f_print(stderr, "-N\t\tsupports multiple arguments and call-by-value\n"); 1161 f_print(stderr, "-n netid\tgenerate server code that supports named netid\n"); 1162 f_print(stderr, "-o outfile\tname of the output file\n"); 1163 f_print(stderr, "-s nettype\tgenerate server code that supports named nettype\n"); 1164 f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n"); 1165 f_print(stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n"); 1166 f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n"); 1167 f_print(stderr, "-t\t\tgenerate RPC dispatch table\n"); 1168 f_print(stderr, "-v\t\tdisplay version number\n"); 1169 f_print(stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n"); 1170 1171 exit(1); 1172 } 1173
Indexes created Tue Sep 23 02:09:52 GMT 2025