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