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