usr.bin/rpcgen/rpc_svcout.c

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user.
   8  *
   9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12  *
  13  * Sun RPC is provided with no support and without any obligation on the
  14  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15  * modification or enhancement.
  16  *
  17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19  * OR ANY PART THEREOF.
  20  *
  21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22  * or profits or other special, indirect and consequential damages, even if
  23  * Sun has been advised of the possibility of such damages.
  24  *
  25  * Sun Microsystems, Inc.
  26  * 2550 Garcia Avenue
  27  * Mountain View, California  94043
  28  */
  29
  30 #if 0
  31 #ifndef lint
  32 #ident  "@(#)rpc_svcout.c       1.4     90/04/13 SMI"
  33 static char sccsid[] = "@(#)rpc_svcout.c 1.29 89/03/30 (C) 1987 SMI";
  34 #endif
  35 #endif
  36
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 /*
  41  * rpc_svcout.c, Server-skeleton outputter for the RPC protocol compiler
  42  * Copyright (C) 1987, Sun Microsystems, Inc.
  43  */
  44 #include <stdio.h>
  45 #include <string.h>
  46 #include "rpc_parse.h"
  47 #include "rpc_scan.h"
  48 #include "rpc_util.h"
  49
  50 static char RQSTP[] = "rqstp";
  51 static char TRANSP[] = "transp";
  52 static char ARG[] = "argument";
  53 static char RESULT[] = "result";
  54 static char ROUTINE[] = "local";
  55 static char RETVAL[] = "retval";
  56
  57 char _errbuf[256];      /* For all messages */
  58
  59 void internal_proctype( proc_list * );
  60 static void write_real_program( definition * );
  61 static void write_program(definition *, const char *);
  62 static void printerr(const char *, const char *);
  63 static void printif(const char *, const char *, const char *, const char *);
  64 static void write_inetmost(const char *);
  65 static void print_return(const char *);
  66 static void print_pmapunset(const char *);
  67 static void print_err_message(const char *);
  68 static void write_timeout_func( void );
  69 static void write_pm_most(const char *, int);
  70 static void write_rpc_svc_fg(const char *, const char *);
  71 static void open_log_file(const char *, const char *);
  72 static void write_msg_out( void );
  73
  74
  75 static void
  76 p_xdrfunc(const char *rname, const char *typename)
  77 {
  78         f_print(fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n",
  79             rname, stringfix(typename));
  80 }
  81
  82 void
  83 internal_proctype(proc_list *plist)
  84 {
  85         f_print(fout, "static ");
  86         ptype(plist->res_prefix, plist->res_type, 1);
  87         f_print(fout, "*");
  88 }
  89
  90
  91 /*
  92  * write most of the service, that is, everything but the registrations.
  93  */
  94 void
  95 write_most(const char *infile, int netflag, int nomain)
  96 {
  97         if (inetdflag || pmflag) {
  98                 const char *var_type;
  99                 var_type = (nomain? "extern" : "static");
 100                 f_print(fout, "%s int _rpcpmstart;", var_type);
 101                 f_print(fout, "\t\t/* Started by a port monitor ? */\n");
 102                 if (!tirpcflag || tirpc_socket) {
 103                         f_print(fout, "%s int _rpcfdtype;", var_type);
 104                         f_print(fout, "\n\t\t /* Whether Stream or \
 105 Datagram ? */\n");
 106                 }
 107
 108                 if (timerflag) {
 109                         f_print(fout, " /* States a server can be in \
 110 wrt request */\n\n");
 111                         f_print(fout, "#define\t_IDLE 0\n");
 112                         f_print(fout, "#define\t_SERVED 1\n");
 113                         f_print(fout, "#define\t_SERVING 2\n\n");
 114                         f_print(fout, "static int _rpcsvcstate = _IDLE;");
 115                         f_print(fout, "\t /* Set when a request is \
 116 serviced */\n");
 117
 118                         if (mtflag) {
 119                                 f_print(fout, "pthread_mutex_t _svcstate_lock;");
 120                                 f_print(fout, "\t\t\t/* Mutex lock for variable _rpcsvcstate */\n");
 121
 122                         }
 123
 124                 }
 125
 126                 write_svc_aux(nomain);
 127         }
 128         /* write out dispatcher and stubs */
 129         write_programs((char *)NULL);
 130
 131         if (nomain)
 132                 return;
 133
 134         f_print(fout, "\nint\n");
 135         f_print(fout, "main()\n");
 136         f_print(fout, "{\n");
 137         if (inetdflag) {
 138                 write_inetmost(infile);
 139                 /* Includes call to write_rpc_svc_fg() */
 140         } else {
 141                 if (tirpcflag) {
 142                         if (netflag) {
 143                                 f_print(fout,
 144                                         "\tregister SVCXPRT *%s;\n", TRANSP);
 145                                 f_print(fout,
 146                                         "\tstruct netconfig *nconf = NULL;\n");
 147                         }
 148                         f_print(fout, "\tpid_t pid;\n");
 149                         f_print(fout, "\tint i;\n");
 150                         if (pmflag) {
 151                                 if (tirpc_socket) {
 152                                         f_print(fout, "\tstruct sockaddr_storage saddr;\n");
 153                                         f_print(fout, "\tsocklen_t asize = sizeof (saddr);\n\n");
 154                                 } else
 155                                         f_print(fout, "\tchar mname[FMNAMESZ + 1];\n\n");
 156                         }
 157
 158                         if (mtflag & timerflag)
 159                                 f_print(fout, "\tmutex_init(&_svcstate_lock, USYNC_THREAD, NULL);\n");
 160                         if (pmflag) {
 161                                 write_pm_most(infile, netflag);
 162                                 f_print(fout, "\telse {\n");
 163                                 write_rpc_svc_fg(infile, "\t\t");
 164                                 f_print(fout, "\t}\n");
 165                         } else
 166                                 write_rpc_svc_fg(infile, "\t\t");
 167
 168                 } else {
 169                         f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
 170                         f_print(fout, "\n");
 171                         print_pmapunset("\t");
 172                 }
 173         }
 174
 175         if (logflag && !inetdflag) {
 176                 open_log_file(infile, "\t");
 177         }
 178 }
 179
 180 /*
 181  * write a registration for the given transport
 182  */
 183 void
 184 write_netid_register(const char *transp)
 185 {
 186         list *l;
 187         definition *def;
 188         version_list *vp;
 189         const char *sp;
 190         char tmpbuf[32];
 191
 192         sp = "";
 193         f_print(fout, "\n");
 194         f_print(fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp);
 195         f_print(fout, "%s\tif (nconf == NULL) {\n", sp);
 196         (void) sprintf(_errbuf, "cannot find %s netid.", transp);
 197         sprintf(tmpbuf, "%s\t\t", sp);
 198         print_err_message(tmpbuf);
 199         f_print(fout, "%s\t\texit(1);\n", sp);
 200         f_print(fout, "%s\t}\n", sp);
 201         if (tirpcflag) {
 202                 f_print(fout, "%s\t%s = svc_tli_create(RPC_ANYFD, ",
 203                     sp, TRANSP);
 204                 f_print(fout,"nconf, 0, RPC_MAXDATASIZE, RPC_MAXDATASIZE);\n");
 205         } else {
 206                 f_print(fout,
 207                     "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n",
 208                     sp, TRANSP);
 209         }
 210         f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
 211         (void) sprintf(_errbuf, "cannot create %s service.", transp);
 212         print_err_message(tmpbuf);
 213         f_print(fout, "%s\t\texit(1);\n", sp);
 214         f_print(fout, "%s\t}\n", sp);
 215
 216         for (l = defined; l != NULL; l = l->next) {
 217                 def = (definition *) l->val;
 218                 if (def->def_kind != DEF_PROGRAM) {
 219                         continue;
 220                 }
 221                 for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 222                         f_print(fout,
 223                                 "%s\t(void) rpcb_unset(%s, %s, nconf);\n",
 224                                 sp, def->def_name, vp->vers_name);
 225                         f_print(fout,
 226                                 "%s\tif (!svc_reg(%s, %s, %s, ",
 227                                 sp, TRANSP, def->def_name, vp->vers_name);
 228                         pvname(def->def_name, vp->vers_num);
 229                         f_print(fout, ", nconf)) {\n");
 230                         (void) sprintf(_errbuf,
 231                                 "unable to register (%s, %s, %s).",
 232                                 def->def_name, vp->vers_name, transp);
 233                         print_err_message(tmpbuf);
 234                         f_print(fout, "%s\t\texit(1);\n", sp);
 235                         f_print(fout, "%s\t}\n", sp);
 236                 }
 237         }
 238         f_print(fout, "%s\tfreenetconfigent(nconf);\n", sp);
 239 }
 240
 241 /*
 242  * write a registration for the given transport for TLI
 243  */
 244 void
 245 write_nettype_register(const char *transp)
 246 {
 247         list *l;
 248         definition *def;
 249         version_list *vp;
 250
 251         for (l = defined; l != NULL; l = l->next) {
 252                 def = (definition *) l->val;
 253                 if (def->def_kind != DEF_PROGRAM) {
 254                         continue;
 255                 }
 256                 for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 257                         f_print(fout, "\tif (!svc_create(");
 258                         pvname(def->def_name, vp->vers_num);
 259                         f_print(fout, ", %s, %s, \"%s\")) {\n",
 260                                 def->def_name, vp->vers_name, transp);
 261                         (void) sprintf(_errbuf,
 262                                 "unable to create (%s, %s) for %s.",
 263                                         def->def_name, vp->vers_name, transp);
 264                         print_err_message("\t\t");
 265                         f_print(fout, "\t\texit(1);\n");
 266                         f_print(fout, "\t}\n");
 267                 }
 268         }
 269 }
 270
 271 /*
 272  * write the rest of the service
 273  */
 274 void
 275 write_rest(void)
 276 {
 277         f_print(fout, "\n");
 278         if (inetdflag) {
 279                 f_print(fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP);
 280                 (void) sprintf(_errbuf, "could not create a handle");
 281                 print_err_message("\t\t");
 282                 f_print(fout, "\t\texit(1);\n");
 283                 f_print(fout, "\t}\n");
 284                 if (timerflag) {
 285                         f_print(fout, "\tif (_rpcpmstart) {\n");
 286                         f_print(fout,
 287                                 "\t\t(void) signal(SIGALRM, closedown);\n");
 288                         f_print(fout, "\t\t(void) \
 289 alarm(_RPCSVC_CLOSEDOWN/2);\n");
 290                         f_print(fout, "\t}\n");
 291                 }
 292         }
 293         f_print(fout, "\tsvc_run();\n");
 294         (void) sprintf(_errbuf, "svc_run returned");
 295         print_err_message("\t");
 296         f_print(fout, "\texit(1);\n");
 297         f_print(fout, "\t/* NOTREACHED */\n");
 298         f_print(fout, "}\n");
 299 }
 300
 301 void
 302 write_programs(const char *storage)
 303 {
 304         list *l;
 305         definition *def;
 306
 307         /* write out stubs for procedure  definitions */
 308         for (l = defined; l != NULL; l = l->next) {
 309                 def = (definition *) l->val;
 310                 if (def->def_kind == DEF_PROGRAM) {
 311                         write_real_program(def);
 312                 }
 313         }
 314
 315         /* write out dispatcher for each program */
 316         for (l = defined; l != NULL; l = l->next) {
 317                 def = (definition *) l->val;
 318                 if (def->def_kind == DEF_PROGRAM) {
 319                         write_program(def, storage);
 320                 }
 321         }
 322
 323
 324 }
 325
 326 /*
 327  * write out definition of internal function (e.g. _printmsg_1(...))
 328  *  which calls server's defintion of actual function (e.g. printmsg_1(...)).
 329  *  Unpacks single user argument of printmsg_1 to call-by-value format
 330  *  expected by printmsg_1.
 331  */
 332 static void
 333 write_real_program(definition *def)
 334 {
 335         version_list *vp;
 336         proc_list *proc;
 337         decl_list *l;
 338
 339         if (!newstyle) return;  /* not needed for old style */
 340         for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 341                 for (proc = vp->procs; proc != NULL; proc = proc->next) {
 342                         f_print(fout, "\n");
 343                         if (!mtflag)
 344                                 internal_proctype(proc);
 345                         else
 346                                 f_print(fout, "int");
 347                         f_print(fout, "\n_");
 348                         pvname(proc->proc_name, vp->vers_num);
 349                         f_print(fout, "(");
 350                         /* arg name */
 351                         if (proc->arg_num > 1)
 352                                 f_print(fout, proc->args.argname);
 353                         else
 354                                 ptype(proc->args.decls->decl.prefix,
 355                                       proc->args.decls->decl.type, 0);
 356                         if (mtflag) {
 357                                 f_print(fout, " *argp, void *%s, struct svc_req *%s)\n",
 358                                         RESULT, RQSTP);
 359
 360
 361                         }
 362                         else
 363                                 f_print(fout, " *argp, struct svc_req *%s)\n",
 364                                         RQSTP);
 365
 366                         f_print(fout, "{\n");
 367                         f_print(fout, "\treturn (");
 368                         pvname_svc(proc->proc_name, vp->vers_num);
 369                         f_print(fout, "(");
 370                         if (proc->arg_num < 2) { /* single argument */
 371                                 if (!streq(proc->args.decls->decl.type, "void"))
 372                                         f_print(fout, "*argp, "); /* non-void */
 373                         } else {
 374                                 for (l = proc->args.decls;  l != NULL;
 375                                      l = l->next)
 376                                         f_print(fout, "argp->%s, ",
 377                                                 l->decl.name);
 378                         }
 379                         if (mtflag)
 380                                 f_print(fout, "%s, ",RESULT);
 381                         f_print(fout, "%s));\n}\n", RQSTP);
 382                 }
 383         }
 384 }
 385
 386 static void
 387 write_program(definition *def, const char *storage)
 388 {
 389         version_list *vp;
 390         proc_list *proc;
 391         int filled;
 392
 393         for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 394                 f_print(fout, "\n");
 395                 if (storage != NULL) {
 396                         f_print(fout, "%s ", storage);
 397                 }
 398                 f_print(fout, "void\n");
 399                 pvname(def->def_name, vp->vers_num);
 400
 401                 f_print(fout, "(struct svc_req *%s, ", RQSTP);
 402                 f_print(fout, "SVCXPRT *%s)\n", TRANSP);
 403                 f_print(fout, "{\n");
 404
 405                 filled = 0;
 406                 f_print(fout, "\tunion {\n");
 407                 for (proc = vp->procs; proc != NULL; proc = proc->next) {
 408                         if (proc->arg_num < 2) { /* single argument */
 409                                 if (streq(proc->args.decls->decl.type,
 410                                           "void")) {
 411                                         continue;
 412                                 }
 413                                 filled = 1;
 414                                 f_print(fout, "\t\t");
 415                                 ptype(proc->args.decls->decl.prefix,
 416                                       proc->args.decls->decl.type, 0);
 417                                 pvname(proc->proc_name, vp->vers_num);
 418                                 f_print(fout, "_arg;\n");
 419
 420                         } else {
 421                                 filled = 1;
 422                                 f_print(fout, "\t\t%s", proc->args.argname);
 423                                 f_print(fout, " ");
 424                                 pvname(proc->proc_name, vp->vers_num);
 425                                 f_print(fout, "_arg;\n");
 426                         }
 427                 }
 428                 if (!filled) {
 429                         f_print(fout, "\t\tint fill;\n");
 430                 }
 431                 f_print(fout, "\t} %s;\n", ARG);
 432
 433                 if (mtflag) {
 434                         f_print(fout, "\tunion {\n");
 435                         for (proc = vp->procs; proc != NULL; proc = proc->next) {
 436                                 f_print(fout, "\t\t");
 437                                 ptype(proc->res_prefix, proc->res_type, 0);
 438                                 pvname(proc->proc_name, vp->vers_num);
 439                                 f_print(fout, "_res;\n");
 440                         }
 441                         f_print(fout, "\t} %s;\n", RESULT);
 442                         f_print(fout, "\tbool_t %s;\n", RETVAL);
 443
 444                 } else
 445                         f_print(fout, "\tchar *%s;\n", RESULT);
 446
 447                 f_print(fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT);
 448                 if (mtflag)
 449                         f_print(fout,
 450                                 "\tbool_t (*%s)(char *, void *, struct svc_req *);\n",
 451                                 ROUTINE);
 452                 else
 453                         f_print(fout,
 454                                 "\tchar *(*%s)(char *, struct svc_req *);\n",
 455                                 ROUTINE);
 456                 f_print(fout, "\n");
 457
 458                 if (timerflag) {
 459                         if (mtflag)
 460                                 f_print(fout, "\tpthread_mutex_lock(&_svcstate_lock);\n");
 461
 462                         f_print(fout, "\t_rpcsvcstate = _SERVING;\n");
 463                         if (mtflag)
 464                                 f_print(fout, "\tpthread_mutex_unlock(&_svcstate_lock);\n");
 465                 }
 466
 467                 f_print(fout, "\tswitch (%s->rq_proc) {\n", RQSTP);
 468                 if (!nullproc(vp->procs)) {
 469                         f_print(fout, "\tcase NULLPROC:\n");
 470                         f_print(fout,
 471                                 "\t\t(void) svc_sendreply(%s,\n\t\t\t"
 472                                 "(xdrproc_t) xdr_void, (char *)NULL);\n",
 473                                 TRANSP);
 474                         print_return("\t\t");
 475                         f_print(fout, "\n");
 476                 }
 477                 for (proc = vp->procs; proc != NULL; proc = proc->next) {
 478                         f_print(fout, "\tcase %s:\n", proc->proc_name);
 479                         if (proc->arg_num < 2) { /* single argument */
 480                                 p_xdrfunc(ARG, proc->args.decls->decl.type);
 481                         } else {
 482                                 p_xdrfunc(ARG, proc->args.argname);
 483                         }
 484                         p_xdrfunc(RESULT, proc->res_type);
 485
 486                         if (mtflag)
 487                                 f_print(fout,
 488                                         "\t\t%s = (bool_t (*) (char *,  void *,  struct svc_req *))",
 489                                         ROUTINE);
 490                         else
 491                                 f_print(fout,
 492                                         "\t\t%s = (char *(*)(char *, struct svc_req *)) ",
 493                                         ROUTINE);
 494                         if (newstyle) { /* new style: calls internal routine */
 495                                 f_print(fout, "_");
 496                         }
 497                         if (!newstyle)
 498                                 pvname_svc(proc->proc_name, vp->vers_num);
 499                         else
 500                                 pvname(proc->proc_name, vp->vers_num);
 501                         f_print(fout, ";\n");
 502                         f_print(fout, "\t\tbreak;\n\n");
 503                 }
 504                 f_print(fout, "\tdefault:\n");
 505                 printerr("noproc", TRANSP);
 506                 print_return("\t\t");
 507                 f_print(fout, "\t}\n");
 508
 509                 f_print(fout,
 510                         "\t(void) memset((char *)&%s, 0, sizeof (%s));\n",
 511                         ARG, ARG);
 512                 printif("getargs", TRANSP, "(caddr_t) &", ARG);
 513                 printerr("decode", TRANSP);
 514                 print_return("\t\t");
 515                 f_print(fout, "\t}\n");
 516
 517                 if (!mtflag)
 518                         f_print(fout, "\t%s = (*%s)((char *)&%s, %s);\n",
 519                                 RESULT, ROUTINE, ARG, RQSTP);
 520                 else
 521                         f_print(fout, "\t%s = (bool_t) (*%s)((char *)&%s, (void *)&%s, %s);\n",
 522                                 RETVAL, ROUTINE, ARG, RESULT, RQSTP);
 523
 524
 525                 if (mtflag)
 526                         f_print(fout,
 527                                 "\tif (%s > 0 && !svc_sendreply(%s, xdr_%s, (char *)&%s)) {\n",
 528                                 RETVAL, TRANSP, RESULT, RESULT);
 529                 else
 530                         f_print(fout,
 531                                 "\tif (%s != NULL && !svc_sendreply(%s, xdr_%s, %s)) {\n",
 532                                 RESULT, TRANSP, RESULT, RESULT);
 533
 534                 printerr("systemerr", TRANSP);
 535                 f_print(fout, "\t}\n");
 536
 537                 printif("freeargs", TRANSP, "(caddr_t) &", ARG);
 538                 (void) sprintf(_errbuf, "unable to free arguments");
 539                 print_err_message("\t\t");
 540                 f_print(fout, "\t\texit(1);\n");
 541                 f_print(fout, "\t}\n");
 542                 /* print out free routine */
 543                 if (mtflag) {
 544                         f_print(fout,"\tif (!");
 545                         pvname(def->def_name, vp->vers_num);
 546                         f_print(fout,"_freeresult(%s, xdr_%s, (caddr_t) &%s))\n",
 547                                 TRANSP, RESULT, RESULT);
 548                         (void) sprintf(_errbuf, "unable to free results");
 549                         print_err_message("\t\t");
 550                         f_print(fout, "\n");
 551                 };
 552                 print_return("\t");
 553                 f_print(fout, "}\n");
 554         }
 555 }
 556
 557 static void
 558 printerr(const char *err, const char *transp)
 559 {
 560         f_print(fout, "\t\tsvcerr_%s(%s);\n", err, transp);
 561 }
 562
 563 static void
 564 printif(const char *proc, const char *transp, const char *prefix,
 565     const char *arg)
 566 {
 567         f_print(fout, "\tif (!svc_%s(%s, xdr_%s, (char *)%s%s)) {\n",
 568                 proc, transp, arg, prefix, arg);
 569 }
 570
 571 int
 572 nullproc(proc_list *proc)
 573 {
 574         for (; proc != NULL; proc = proc->next) {
 575                 if (streq(proc->proc_num, "0")) {
 576                         return (1);
 577                 }
 578         }
 579         return (0);
 580 }
 581
 582 static void
 583 write_inetmost(const char *infile)
 584 {
 585         f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP);
 586         f_print(fout, "\tint sock;\n");
 587         f_print(fout, "\tint proto;\n");
 588         f_print(fout, "\tstruct sockaddr_in saddr;\n");
 589         f_print(fout, "\tsocklen_t asize = sizeof (saddr);\n");
 590         f_print(fout, "\n");
 591         f_print(fout,
 592         "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n");
 593         f_print(fout, "\t\tsocklen_t ssize = sizeof (int);\n\n");
 594         f_print(fout, "\t\tif (saddr.sin_family != AF_INET)\n");
 595         f_print(fout, "\t\t\texit(1);\n");
 596         f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n");
 597         f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n");
 598         f_print(fout, "\t\t\texit(1);\n");
 599         f_print(fout, "\t\tsock = 0;\n");
 600         f_print(fout, "\t\t_rpcpmstart = 1;\n");
 601         f_print(fout, "\t\tproto = 0;\n");
 602         open_log_file(infile, "\t\t");
 603         f_print(fout, "\t} else {\n");
 604         write_rpc_svc_fg(infile, "\t\t");
 605         f_print(fout, "\t\tsock = RPC_ANYSOCK;\n");
 606         print_pmapunset("\t\t");
 607         f_print(fout, "\t}\n");
 608 }
 609
 610 static void
 611 print_return(const char *space)
 612 {
 613         if (exitnow)
 614                 f_print(fout, "%sexit(0);\n", space);
 615         else {
 616                 if (timerflag) {
 617                         if (mtflag)
 618                                 f_print(fout, "%spthread_mutex_lock(&_svcstate_lock);\n", space);
 619                                 f_print(fout, "%s_rpcsvcstate = _SERVED;\n", space);
 620                         if (mtflag)
 621                                 f_print(fout, "%spthread_mutex_unlock(&_svcstate_lock);\n", space);
 622                 }
 623                 f_print(fout, "%sreturn;\n", space);
 624         }
 625 }
 626
 627 static void
 628 print_pmapunset(const char *space)
 629 {
 630         list *l;
 631         definition *def;
 632         version_list *vp;
 633
 634         for (l = defined; l != NULL; l = l->next) {
 635                 def = (definition *) l->val;
 636                 if (def->def_kind == DEF_PROGRAM) {
 637                         for (vp = def->def.pr.versions; vp != NULL;
 638                                         vp = vp->next) {
 639                                 f_print(fout, "%s(void) pmap_unset(%s, %s);\n",
 640                                         space, def->def_name, vp->vers_name);
 641                         }
 642                 }
 643         }
 644 }
 645
 646 static void
 647 print_err_message(const char *space)
 648 {
 649         if (logflag)
 650                 f_print(fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf);
 651         else if (inetdflag || pmflag)
 652                 f_print(fout, "%s_msgout(\"%s\");\n", space, _errbuf);
 653         else
 654                 f_print(fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf);
 655 }
 656
 657 /*
 658  * Write the server auxiliary function (_msgout, timeout)
 659  */
 660 void
 661 write_svc_aux(int nomain)
 662 {
 663         if (!logflag)
 664                 write_msg_out();
 665         if (!nomain)
 666                 write_timeout_func();
 667 }
 668
 669 /*
 670  * Write the _msgout function
 671  */
 672
 673 static void
 674 write_msg_out(void)
 675 {
 676         f_print(fout, "\n");
 677 /*
 678  * Avoid making _msgout() static -- it's useful to have it visible
 679  * in the toplevel RPC server code.
 680  */
 681         f_print(fout, "static\n");
 682         f_print(fout, "void _msgout(const char* msg)\n");
 683         f_print(fout, "{\n");
 684         f_print(fout, "#ifdef RPC_SVC_FG\n");
 685         if (inetdflag || pmflag)
 686                 f_print(fout, "\tif (_rpcpmstart)\n");
 687         f_print(fout, "\t\tsyslog(LOG_ERR, \"%%s\", msg);\n");
 688         f_print(fout, "\telse\n");
 689         f_print(fout,
 690                 "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n");
 691         f_print(fout, "#else\n");
 692         f_print(fout, "\tsyslog(LOG_ERR, \"%%s\", msg);\n");
 693         f_print(fout, "#endif\n");
 694         f_print(fout, "}\n");
 695 }
 696
 697 /*
 698  * Write the timeout function
 699  */
 700 static void
 701 write_timeout_func(void)
 702 {
 703         if (!timerflag)
 704                 return;
 705
 706         f_print(fout, "\n");
 707         f_print(fout, "static void\n");
 708         f_print(fout, "closedown(int sig)\n");
 709         f_print(fout, "{\n");
 710         if (mtflag)
 711                 f_print(fout, "\tpthread_mutex_lock(&_svcstate_lock);\n");
 712         f_print(fout, "\tif (_rpcsvcstate == _IDLE) {\n");
 713         f_print(fout, "\t\textern fd_set svc_fdset;\n");
 714         f_print(fout, "\t\tstatic int size;\n");
 715         f_print(fout, "\t\tint i, openfd;\n");
 716         if (tirpcflag && pmflag) {
 717                 f_print(fout, "\t\tstruct t_info tinfo;\n\n");
 718                 f_print(fout,
 719                         "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n");
 720         } else {
 721                 f_print(fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n");
 722         }
 723         f_print(fout, "\t\t\texit(0);\n");
 724         f_print(fout, "\t\tif (size == 0) {\n");
 725         if (tirpcflag) {
 726                 f_print(fout, "\t\t\tstruct rlimit rl;\n\n");
 727                 f_print(fout, "\t\t\trl.rlim_max = 0;\n");
 728                 f_print(fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n");
 729                 f_print(fout, "\t\t\tif ((size = rl.rlim_max) == 0) {\n");
 730
 731                 if (mtflag)
 732                         f_print(fout, "\t\t\t\tpthread_mutex_unlock(&_svcstate_lock);\n");
 733
 734                 f_print(fout, "\t\t\t\treturn;\n\t\t\t}\n");
 735         } else {
 736                 f_print(fout, "\t\t\tsize = getdtablesize();\n");
 737         }
 738         f_print(fout, "\t\t}\n");
 739         f_print(fout,
 740                 "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n");
 741         f_print(fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n");
 742         f_print(fout, "\t\t\t\topenfd++;\n");
 743         f_print(fout, "\t\tif (openfd <= 1)\n");
 744         f_print(fout, "\t\t\texit(0);\n");
 745         f_print(fout, "\t}\n");
 746         f_print(fout, "\tif (_rpcsvcstate == _SERVED)\n");
 747         f_print(fout, "\t\t_rpcsvcstate = _IDLE;\n\n");
 748         if (mtflag)
 749                 f_print(fout, "\tpthread_mutex_unlock(&_svcstate_lock);\n");
 750
 751         f_print(fout, "\t(void) signal(SIGALRM, closedown);\n");
 752         f_print(fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN/2);\n");
 753         f_print(fout, "}\n");
 754
 755 }
 756
 757 /*
 758  * Write the most of port monitor support
 759  */
 760 static void
 761 write_pm_most(const char *infile, int netflag)
 762 {
 763         list *l;
 764         definition *def;
 765         version_list *vp;
 766
 767         if (tirpc_socket) {
 768                 f_print(fout,
 769                 "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n");
 770                 f_print(fout, "\t\tsocklen_t ssize = sizeof (int);\n");
 771         } else {
 772                 f_print(fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n");
 773                 f_print(fout, "\t\t(!strcmp(mname, \"sockmod\") ||");
 774                 f_print(fout, " !strcmp(mname, \"timod\"))) {\n");
 775         }
 776         f_print(fout, "\t\tchar *netid;\n");
 777         if (!netflag) { /* Not included by -n option */
 778                 f_print(fout, "\t\tstruct netconfig *nconf = NULL;\n");
 779                 f_print(fout, "\t\tSVCXPRT *%s;\n", TRANSP);
 780         }
 781         if (timerflag)
 782                 f_print(fout, "\t\tint pmclose;\n");
 783 /*
 784  *  Not necessary, defined in /usr/include/stdlib
 785  *  f_print(fout, "\t\textern char *getenv();\n");
 786  */
 787         f_print(fout, "\n");
 788         if (tirpc_socket) {
 789                 f_print(fout, "\t\tif (saddr.ss_family != AF_INET &&\n");
 790                 f_print(fout, "\t\t    saddr.ss_family != AF_INET6)\n");
 791                 f_print(fout, "\t\t\texit(1);\n");
 792                 f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n");
 793                 f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n");
 794                 f_print(fout, "\t\t\texit(1);\n");
 795         }
 796         f_print(fout, "\t\t_rpcpmstart = 1;\n");
 797         open_log_file(infile, "\t\t");
 798         f_print(fout, "\n\t\tif ((netid = \
 799 getenv(\"NLSPROVIDER\")) == NULL) {\n");
 800
 801         if (timerflag) {
 802                 f_print(fout, "\t\t/* started from inetd */\n");
 803                 f_print(fout, "\t\t\tpmclose = 1;\n");
 804         }
 805         f_print(fout,
 806                 "\t\t} else {\n");
 807         f_print(fout, "\t\t\tif ((nconf = getnetconfigent(netid)) == NULL)\n");
 808         sprintf(_errbuf, "cannot get transport info");
 809         print_err_message("\t\t\t\t");
 810        if (timerflag) {
 811                 if (tirpc_socket)
 812                         f_print(fout, "\n\t\t\tpmclose = 1;\t/* XXX */\n");
 813                 else
 814                         f_print(fout,
 815                             "\n\t\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n");
 816         }
 817         f_print(fout, "\t\t}\n");
 818         /*
 819          * A kludgy support for inetd services. Inetd only works with
 820          * sockmod, and RPC works only with timod, hence all this jugglery
 821          */
 822         if (!tirpc_socket) {
 823                 f_print(fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n");
 824                 f_print(fout, "\t\t\tif (ioctl(0, I_POP, 0) || ");
 825                 f_print(fout, "ioctl(0, I_PUSH, \"timod\")) {\n");
 826                 sprintf(_errbuf, "could not get the right module");
 827                 print_err_message("\t\t\t\t");
 828                 f_print(fout, "\t\t\t\texit(1);\n");
 829                 f_print(fout, "\t\t\t}\n");
 830                 f_print(fout, "\t\t}\n");
 831         }
 832         if (tirpcflag) {
 833                 f_print(fout,
 834                 "\t\tif ((%s = svc_tli_create(0, nconf, NULL, \
 835                 RPC_MAXDATASIZE, RPC_MAXDATASIZE)) \
 836                 == NULL) {\n",
 837                 TRANSP);
 838         } else {
 839                 f_print(fout,
 840                     "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) \
 841                     == NULL) {\n",
 842                     TRANSP);
 843         }
 844         sprintf(_errbuf, "cannot create server handle");
 845         print_err_message("\t\t\t");
 846         f_print(fout, "\t\t\texit(1);\n");
 847         f_print(fout, "\t\t}\n");
 848         f_print(fout, "\t\tif (nconf)\n");
 849         f_print(fout, "\t\t\tfreenetconfigent(nconf);\n");
 850         for (l = defined; l != NULL; l = l->next) {
 851                 def = (definition *) l->val;
 852                 if (def->def_kind != DEF_PROGRAM) {
 853                         continue;
 854                 }
 855                 for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 856                         f_print(fout,
 857                                 "\t\tif (!svc_reg(%s, %s, %s, ",
 858                                 TRANSP, def->def_name, vp->vers_name);
 859                         pvname(def->def_name, vp->vers_num);
 860                         f_print(fout, ", 0)) {\n");
 861                         (void) sprintf(_errbuf, "unable to register (%s, %s).",
 862                                         def->def_name, vp->vers_name);
 863                         print_err_message("\t\t\t");
 864                         f_print(fout, "\t\t\texit(1);\n");
 865                         f_print(fout, "\t\t}\n");
 866                 }
 867         }
 868         if (timerflag) {
 869                 f_print(fout, "\t\tif (pmclose) {\n");
 870                 f_print(fout, "\t\t\t(void) signal(SIGALRM, closedown);\n");
 871                 f_print(fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN/2);\n");
 872                 f_print(fout, "\t\t}\n");
 873         }
 874         f_print(fout, "\t\tsvc_run();\n");
 875         f_print(fout, "\t\texit(1);\n");
 876         f_print(fout, "\t\t/* NOTREACHED */\n");
 877         f_print(fout, "\t}");
 878 }
 879
 880 /*
 881  * Support for backgrounding the server if self started.
 882  */
 883 static void
 884 write_rpc_svc_fg(const char *infile, const char *sp)
 885 {
 886         f_print(fout, "#ifndef RPC_SVC_FG\n");
 887         f_print(fout, "%sint size;\n", sp);
 888         if (tirpcflag)
 889                 f_print(fout, "%sstruct rlimit rl;\n", sp);
 890         if (inetdflag)
 891                 f_print(fout, "%sint pid, i;\n\n", sp);
 892         f_print(fout, "%spid = fork();\n", sp);
 893         f_print(fout, "%sif (pid < 0) {\n", sp);
 894         f_print(fout, "%s\tperror(\"cannot fork\");\n", sp);
 895         f_print(fout, "%s\texit(1);\n", sp);
 896         f_print(fout, "%s}\n", sp);
 897         f_print(fout, "%sif (pid)\n", sp);
 898         f_print(fout, "%s\texit(0);\n", sp);
 899         /* get number of file descriptors */
 900         if (tirpcflag) {
 901                 f_print(fout, "%srl.rlim_max = 0;\n", sp);
 902                 f_print(fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp);
 903                 f_print(fout, "%sif ((size = rl.rlim_max) == 0)\n", sp);
 904                 f_print(fout, "%s\texit(1);\n", sp);
 905         } else {
 906                 f_print(fout, "%ssize = getdtablesize();\n", sp);
 907         }
 908
 909         f_print(fout, "%sfor (i = 0; i < size; i++)\n", sp);
 910         f_print(fout, "%s\t(void) close(i);\n", sp);
 911         /* Redirect stderr and stdout to console */
 912         f_print(fout, "%si = open(\"/dev/console\", 2);\n", sp);
 913         f_print(fout, "%s(void) dup2(i, 1);\n", sp);
 914         f_print(fout, "%s(void) dup2(i, 2);\n", sp);
 915         /* This removes control of the controlling terminal */
 916         if (tirpcflag)
 917                 f_print(fout, "%ssetsid();\n", sp);
 918         else {
 919                 f_print(fout, "%si = open(\"/dev/tty\", 2);\n", sp);
 920                 f_print(fout, "%sif (i >= 0) {\n", sp);
 921                 f_print(fout,
 922                         "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);
 923                 f_print(fout, "%s\t(void) close(i);\n", sp);
 924                 f_print(fout, "%s}\n", sp);
 925         }
 926         if (!logflag)
 927                 open_log_file(infile, sp);
 928         f_print(fout, "#endif\n");
 929         if (logflag)
 930                 open_log_file(infile, sp);
 931 }
 932
 933 static void
 934 open_log_file(const char *infile, const char *sp)
 935 {
 936         char *s;
 937
 938         s = strrchr(infile, '.');
 939         if (s)
 940                 *s = '\0';
 941         f_print(fout, "%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile);
 942         if (s)
 943                 *s = '.';
 944 }
 945
 946
 947
 948
 949 /*
 950  * write a registration for the given transport for Inetd
 951  */
 952 void
 953 write_inetd_register(const char *transp)
 954 {
 955         list *l;
 956         definition *def;
 957         version_list *vp;
 958         const char *sp;
 959         int isudp;
 960         char tmpbuf[32];
 961
 962         if (inetdflag)
 963                 sp = "\t";
 964         else
 965                 sp = "";
 966         if (streq(transp, "udp"))
 967                 isudp = 1;
 968         else
 969                 isudp = 0;
 970         f_print(fout, "\n");
 971         if (inetdflag) {
 972                 f_print(fout,
 973                         "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n",
 974                         isudp ? "SOCK_DGRAM" : "SOCK_STREAM");
 975         }
 976         f_print(fout, "%s\t%s = svc%s_create(%s",
 977                 sp, TRANSP, transp, inetdflag? "sock": "RPC_ANYSOCK");
 978         if (!isudp)
 979                 f_print(fout, ", 0, 0");
 980         f_print(fout, ");\n");
 981         f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP);
 982         (void) sprintf(_errbuf, "cannot create %s service.", transp);
 983         (void) sprintf(tmpbuf, "%s\t\t", sp);
 984         print_err_message(tmpbuf);
 985         f_print(fout, "%s\t\texit(1);\n", sp);
 986         f_print(fout, "%s\t}\n", sp);
 987
 988         if (inetdflag) {
 989                 f_print(fout, "%s\tif (!_rpcpmstart)\n\t", sp);
 990                 f_print(fout, "%s\tproto = IPPROTO_%s;\n",
 991                                 sp, isudp ? "UDP": "TCP");
 992         }
 993         for (l = defined; l != NULL; l = l->next) {
 994                 def = (definition *) l->val;
 995                 if (def->def_kind != DEF_PROGRAM) {
 996                         continue;
 997                 }
 998                 for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) {
 999                         f_print(fout, "%s\tif (!svc_register(%s, %s, %s, ",
1000                                 sp, TRANSP, def->def_name, vp->vers_name);
1001                         pvname(def->def_name, vp->vers_num);
1002                         if (inetdflag)
1003                                 f_print(fout, ", proto)) {\n");
1004                         else
1005                                 f_print(fout, ", IPPROTO_%s)) {\n",
1006                                         isudp ? "UDP": "TCP");
1007                         (void) sprintf(_errbuf,
1008                                 "unable to register (%s, %s, %s).",
1009                                 def->def_name, vp->vers_name, transp);
1010                         print_err_message(tmpbuf);
1011                         f_print(fout, "%s\t\texit(1);\n", sp);
1012                         f_print(fout, "%s\t}\n", sp);
1013                 }
1014         }
1015         if (inetdflag)
1016                 f_print(fout, "\t}\n");
1017 }