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