cde/programs/dtcm/server/svcmain.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: svcmain.c /main/10 1998/04/06 13:13:49 mgreess $ */
  24 /*
  25  *  (c) Copyright 1993, 1994 Hewlett-Packard Company
  26  *  (c) Copyright 1993, 1994 International Business Machines Corp.
  27  *  (c) Copyright 1993, 1994 Novell, Inc.
  28  *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
  29  */
  30
  31 #if defined(linux)
  32 #define _POSIX_C_SOURCE 2
  33 #endif
  34
  35 #include <EUSCompat.h>
  36 #include <stdio.h>
  37 #include <errno.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41 #include <sys/time.h>
  42 #include <sys/resource.h>
  43 #ifdef SVR4
  44 #ifndef _NETINET_IN_H
  45 #include <netinet/in.h>
  46 #endif /* _NETINET_IN_H */
  47 #endif
  48
  49 #if defined(SunOS) || defined(USL) || defined(__uxp__)
  50 #include <netconfig.h>
  51 #include <netdir.h>
  52 #include <sys/stropts.h>
  53 #include <tiuser.h>
  54 #endif /* SunOS || USL || __uxp__ */
  55 #include <sys/param.h>
  56 #include <sys/stat.h>
  57 #include <fcntl.h>
  58 #include <rpc/rpc.h>
  59 #include <sys/file.h>
  60 #include <sys/signal.h>
  61 #include <pwd.h>
  62 #include <grp.h>
  63 #include "rpcextras.h"
  64 #include "log.h"
  65 #include "cmscalendar.h"
  66 #include "repeat.h"
  67 #include "lutil.h"
  68 #include "cmsdata.h"
  69
  70 #ifndef S_IRWXU
  71 #define S_IRWXU         (S_IRUSR|S_IWUSR|S_IXUSR)
  72 #endif
  73 #ifndef S_IRWXG
  74 #define S_IRWXG         (S_IRGRP|S_IWGRP|S_IXGRP)
  75 #endif
  76 #ifndef S_IRWXO
  77 #define S_IRWXO         (S_IROTH|S_IWOTH|S_IXOTH)
  78 #endif
  79
  80 #define S_MASK  (S_INPUT|S_HIPRI|S_ERROR|S_HANGUP)
  81
  82 int debug;
  83 static int standalone;                  /* default is 0 */
  84 static int received_sighup = 0;         /* 1 means we get SIGHUP */
  85 static int rpc_in_process = 0;          /* 1 means processing client request */
  86 static int garbage_collection_time = 240; /* in min; default time is 4:00am */
  87
  88 char    *pgname;
  89
  90 uid_t daemon_uid;
  91 gid_t daemon_gid;
  92
  93 /*
  94  * get garbage collection time
  95  * the given string should be in the format hhmm
  96  * where hh is 0 - 23 and mm is 00 - 59
  97  */
  98 static int
  99 _GetGtime(char *timestr)
 100 {
 101         int     hour, minute, len, i;
 102
 103         if (timestr == NULL)
 104                 goto error;
 105
 106         if ((len = strlen(timestr)) > 4)
 107                 goto error;
 108
 109         for (i = 0; i < len; i++) {
 110                 if (timestr[i] < '0' || timestr[i] > '9')
 111                         goto error;
 112         }
 113
 114         minute = atoi(&timestr[len - 2]);
 115         timestr[len - 2] = NULL;
 116         hour = atoi(timestr);
 117
 118         if (hour > 23 || minute > 59)
 119                 goto error;
 120
 121         garbage_collection_time = hour * 60 + minute;
 122
 123         return (0);
 124
 125 error:
 126         fprintf(stderr, "The time specified is invalid.\n");
 127         return (-1);
 128 }
 129
 130 static void
 131 parse_args(int argc, char **argv)
 132 {
 133         int     opt;
 134
 135         if (pgname = strrchr (argv[0], '/'))
 136                 pgname++;
 137         else
 138                 pgname = argv[0];
 139
 140         while ((opt = getopt (argc, argv, "dsg:")) != -1)
 141         {
 142                 switch (opt)
 143                 {
 144                 case 'd':
 145                         debug = 1;
 146                         break;
 147                 case 's':
 148                         standalone = 1;
 149                         break;
 150                 case 'g':
 151                         if (_GetGtime(optarg))
 152                                 goto error;
 153                         break;
 154                 case '?':
 155                         goto error;
 156                 }
 157         }
 158
 159         if (optind == argc)
 160                 return;
 161
 162 #if defined(_aix)
 163         /*
 164          * rpc.cmsd gets started by the inetd.
 165          * On AIX inetd requires that two arguments be supplied to the RPC
 166          * programs as follows (from the inetd.conf man page):
 167          *
 168          * ServerArgs      Specifies the command line arguments that the
 169          * inetd daemon should use to execute the server. The maximum number
 170          * of arguments is five. The first argument specifies the name of the
 171          * server used.  If the SocketType parameter is sunrpc_tcp or
 172          * sunrpc_udp, * the second argument specifies the program name and
 173          * the third argument specifies the version of the program. For
 174          * services that the inetd daemon provides internally, this field
 175          * should be empty.
 176          */
 177
 178         else if (optind == 1 && argc >= 3)
 179         {
 180                 int i,j;
 181                 char **argv_r;
 182
 183                 if (argc == 3)
 184                   return;
 185
 186                 argv_r = (char **) malloc(argc * sizeof(char *));
 187
 188                 argv_r[0] = argv[0];
 189                 for (i=optind+2, j=1; i<argc; i++,j++)
 190                   argv_r[j] = argv[i];
 191                 parse_args(argc-2, argv_r);
 192
 193                 free((void *) argv_r);
 194                 return;
 195         }
 196 #endif
 197
 198 error:
 199         fprintf (stderr, "Usage: %s [-d] [-s] [-g hhmm]\n", pgname);
 200         exit (-1);
 201 }
 202
 203 static void
 204 init_dir()
 205 {
 206         char *dir = _DtCMS_DEFAULT_DIR;
 207         char msgbuf[BUFSIZ];
 208         int create_dir;
 209         struct stat info;
 210         mode_t mode;
 211
 212         if (geteuid() != 0)
 213         {
 214                 fprintf (stderr,
 215                         "%s: must be run in super-user mode!  Exited.\n",
 216                         pgname);
 217                 exit (-1);
 218         }
 219
 220         create_dir = 0;
 221         if (stat(dir, &info))
 222         {
 223                 /* if directory does not exist, create the directory */
 224                 if ((errno != ENOENT) || mkdir(dir, S_IRWXU|S_IRWXG|S_IRWXO))
 225                 {
 226                         if (errno == ENOENT)
 227                                 sprintf(msgbuf, "%s: cannot create %s.\n%s: %s",
 228                                         pgname, dir, pgname, "System error");
 229                         else
 230                                 sprintf(msgbuf, "%s: cannot access %s.\n%s: %s",
 231                                         pgname, dir, pgname, "System error");
 232                         perror (msgbuf);
 233                         exit (-1);
 234                 }
 235                 create_dir = 1;
 236         }
 237
 238         /* if dir is just created, we need to do chmod and chown.
 239          * Otherwise, only do chmod and/or chown if permssion and/or
 240          * ownership is wrong.
 241          */
 242         mode = S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO;
 243
 244         if (create_dir || info.st_mode != (mode | S_IFDIR)) {
 245
 246                 /* set directory permission to be "rwxrwsrwt" */
 247                 if (chmod(dir, mode)) {
 248                         sprintf(msgbuf, "%s: Permission on %s%s\n%s%s\n%s%s",
 249                                 pgname, dir,
 250                                 " is wrong but cannot be corrected.", pgname,
 251                                 ": This might happen if you are mounting the directory.",
 252                                 pgname, ": System error");
 253                         perror(msgbuf);
 254                         if (create_dir)
 255                                 rmdir(dir);
 256                         exit(-1);
 257                 }
 258         }
 259
 260         if (create_dir || info.st_uid!=daemon_uid || info.st_gid!=daemon_gid) {
 261                 /* set directory ownership to: owner = 1, group = 1 */
 262                 if (chown(dir, daemon_uid, daemon_gid)) {
 263                         sprintf(msgbuf, "%s: Ownership on %s%s\n%s%s\n%s%s",
 264                                 pgname, dir,
 265                                 " is wrong but cannot be corrected.", pgname,
 266                                 ": This might happen if you are mounting the directory.",
 267                                 pgname, ": System error");
 268                         perror(msgbuf);
 269                         if (create_dir)
 270                                 rmdir(dir);
 271                         exit(-1);
 272                 }
 273         }
 274
 275         /* Change current directory, so core file can be dumped. */
 276         chdir (dir);
 277 }
 278
 279 /*
 280  * send a SIGHUP signal to the rpc.cmsd that is already running
 281  */
 282 static void
 283 send_hup()
 284 {
 285         FILE    *fp = NULL;
 286         char    buf[BUFSIZ];
 287         pid_t   pid, mypid = getpid();
 288         extern FILE *popen(const char *, const char *);
 289         extern int pclose(FILE *);
 290
 291         sprintf(buf, "ps -e|grep rpc.cmsd|grep -v grep");
 292
 293         if ((fp = popen(buf, "r")) == NULL) {
 294                 if (debug)
 295                         fprintf(stderr, "rpc.cmsd: popen failed\n");
 296         } else {
 297                 while (fgets(buf, sizeof(buf), fp) != NULL) {
 298                         if ((pid = atol(buf)) != mypid) {
 299                                 if (kill(pid, SIGHUP))
 300                                     perror("rpc.cmsd: failed to send SIGHUP");
 301                                 if (debug)
 302                                     fprintf(stderr, "rpc.cmsd: %s %ld\n",
 303                                                 "sent SIGHUP to", (long)pid);
 304                         }
 305                 }
 306                 pclose(fp);
 307         }
 308 }
 309
 310 /*
 311  * We only allow one rpc.cmsd to run on each machine.
 312  */
 313 static int
 314 lock_it()
 315 {
 316         char *dir = _DtCMS_DEFAULT_DIR;
 317         char    buff [MAXPATHLEN];
 318         int     error;
 319         int     fd;
 320 #ifdef SVR4
 321         struct flock locker;
 322         locker.l_type = F_WRLCK;
 323         locker.l_whence = 0;
 324         locker.l_start = 0;
 325         locker.l_len = 0;
 326 #endif /* SVR4 */
 327
 328         strcpy (buff, dir);
 329         strcat (buff, "/.lock.");
 330
 331         /*
 332          * /var/spool might be mounted.  Use .lock.hostname to
 333          * prevent more than one cms running in each host.
 334          */
 335         strcat(buff, _DtCmGetLocalHost());
 336
 337         fd = open(buff, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
 338         if (fd < 0)
 339         {
 340                 perror (buff);
 341                 exit (-1);
 342         }
 343
 344         /*
 345          * Note, we have to use flock() instead of lockf() because cms process
 346          * is run in each host.
 347          */
 348 #ifdef SVR4
 349         if (fcntl (fd, F_SETLK, &locker) != 0)
 350 #else
 351         if (flock (fd, LOCK_EX|LOCK_NB) != 0)
 352 #endif /* SVR4 */
 353         {
 354                 error = errno;
 355
 356                 close(fd);
 357
 358                 if (error != EWOULDBLOCK && error != EACCES) {
 359
 360                         perror ("rpc.cmsd: failed to lock lockfile");
 361                         fprintf(stderr, "error = %d\n", error);
 362                         exit (-1);
 363
 364                 } else {
 365                         if (debug)
 366                                 fprintf(stderr, "rpc.cmsd: %s\n",
 367                                     "lock_it failed due to another process");
 368
 369                         /* cms has been running.... */
 370                         return(error);
 371                 }
 372         }
 373
 374         return (0);
 375 }
 376
 377 static void
 378 program(struct svc_req *rqstp, register SVCXPRT *transp)
 379 {
 380         char *result;
 381         char *argument = NULL;
 382         program_handle ph = getph();
 383         struct rpcgen_table *proc;
 384
 385         /* set rpc_in_process so that sighup handler won't exit right away */
 386         rpc_in_process = 1;
 387
 388         /* first do some bounds checking: */
 389         if (rqstp->rq_vers >= ph->nvers) {
 390                 svcerr_noproc(transp);
 391                 goto done;
 392         }
 393         if (ph->prog[rqstp->rq_vers].nproc == 0) {
 394                 svcerr_noproc(transp);
 395                 goto done;
 396         }
 397         if (rqstp->rq_proc >= ph->prog[rqstp->rq_vers].nproc) {
 398                 svcerr_noproc(transp);
 399                 goto done;
 400         }
 401
 402         if (rqstp->rq_proc == NULLPROC) {
 403                 if (debug) fprintf(stderr, "rpc.cmsd: ping\n");
 404                 (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (caddr_t)NULL);
 405                 goto done;
 406         }
 407
 408         /* assert - the program number, version and proc numbers are valid */
 409         proc = &(ph->prog[rqstp->rq_vers].vers[rqstp->rq_proc]);
 410         argument = (char*)calloc(proc->len_arg, sizeof(char));
 411         if (!svc_getargs(transp, proc->xdr_arg, argument)) {
 412                 svcerr_decode(transp);
 413                 goto done;
 414         }
 415
 416         result = (*proc->proc)(argument, rqstp);
 417         if (result != NULL && !svc_sendreply(transp, proc->xdr_res, result)) {
 418                 svcerr_systemerr(transp);
 419         }
 420
 421         if (!svc_freeargs(transp, proc->xdr_arg, argument)) {
 422                 (void)fprintf(stderr, "unable to free arguments");
 423                 exit(1);
 424         }
 425         free(argument);
 426
 427 done:
 428         rpc_in_process = 0;
 429
 430         /* exit if we have received the SIGHUP signal */
 431         if (received_sighup == 1) {
 432                 if (debug)
 433                         fprintf(stderr, "rpc.cmsd: received SIGHUP, %s",
 434                                 "exiting after finished processing\n");
 435                 exit(0);
 436         }
 437 }
 438
 439 /*
 440  * Signal handler for SIGHUP.
 441  * If we are in the middle of processing a client request,
 442  * finish processing before we exit.
 443  */
 444 static void
 445 sighup_handler(int sig_num)
 446 {
 447         if (debug)
 448                 fprintf(stderr, "rpc.cmsd: sighup received\n");
 449
 450         if (rpc_in_process == 0) {
 451                 if (debug)
 452                         fprintf(stderr, "rpc.cmsd: exit from sighup_handler\n");
 453                 exit(0);
 454         } else {
 455                 if (debug)
 456                         fprintf(stderr, "rpc.cmsd: set received_sighup to 1\n");
 457                 received_sighup = 1;
 458         }
 459 }
 460
 461 /*
 462  * garbage_collection_time (in min) is the time to do garbage collection
 463  * each day
 464  * This routine returns the difference between the first garbage collection
 465  * time and now so that the calling routine can set the alarm.
 466  */
 467 static int
 468 _GetFirstGarbageCollectionTime()
 469 {
 470         int n=0, midnight=0, gtime=0;
 471
 472         n = time(0);
 473
 474         /* try today first */
 475         midnight = next_ndays(n, 0);
 476         gtime = next_nmins(midnight, garbage_collection_time);
 477
 478         if (gtime < n) {
 479                 /* the first garbage collection will be done tomorrow */
 480                 midnight = next_ndays(n, 1);
 481                 gtime = next_nmins(midnight, garbage_collection_time);
 482         }
 483
 484         return (gtime - n);
 485 }
 486
 487 static void
 488 init_alarm()
 489 {
 490         int next;
 491         extern void garbage_collect();
 492         extern void debug_switch();
 493
 494 #if defined(SVR4) && !defined(linux)
 495         extern void (*sigset(int, void (*)(int)))(int);
 496         sigset(SIGUSR1, garbage_collect);
 497         sigset(SIGALRM, garbage_collect);
 498         sigset(SIGUSR2, debug_switch);
 499 #else
 500         signal(SIGUSR1, garbage_collect);
 501         signal(SIGALRM, garbage_collect);
 502         signal(SIGUSR2, debug_switch);
 503 #endif /* SVR4 */
 504
 505         next = _GetFirstGarbageCollectionTime();
 506         alarm((unsigned) next);
 507 }
 508
 509 main(int argc, char **argv)
 510 {
 511         u_long version;
 512         program_handle ph = newph();
 513         struct passwd *pw;
 514         struct group *gr;
 515         struct rlimit rl;
 516         struct sockaddr_in saddr;
 517         int asize = sizeof (saddr);
 518         SVCXPRT *tcp_transp = (SVCXPRT *)-1;
 519         SVCXPRT *udp_transp = (SVCXPRT *)-1;
 520         int     fd, error;
 521
 522 #if defined(SunOS) || defined(USL) || defined(__uxp__)
 523         struct netconfig *nconf_udp;
 524         struct netconfig *nconf_tcp;
 525         struct t_info info;
 526 #if !defined(USL) || (defined(USL) && (OSMAJORVERSION > 1))
 527         char mname[FMNAMESZ+1];
 528 #endif
 529 #endif /* SunOS || USL */
 530
 531         pw = (struct passwd *)getpwnam("daemon");
 532         gr = (struct group *)getgrnam("daemon");
 533         if (pw != NULL)
 534                 daemon_uid = pw->pw_uid;
 535         else
 536                 daemon_uid = 1;
 537         if (gr != NULL)
 538                 daemon_gid = gr->gr_gid;
 539         else
 540                 daemon_gid = 1;
 541
 542         parse_args(argc, argv);
 543
 544         /* check to see if we are started by inetd */
 545         if (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {
 546
 547                 standalone = 0;
 548
 549 #if defined(SunOS) || defined(USL) || defined(__uxp__)
 550 #if !defined(USL) || (defined(USL) && (OSMAJORVERSION > 1))
 551                 /* we need a TLI endpoint rather than a socket */
 552                 if (ioctl(0, I_LOOK, mname) != 0) {
 553                         perror("rpc.cmsd: ioctl failed to get module name");
 554                         exit(1);
 555                 }
 556                 if (strcmp(mname, "sockmod") == 0) {
 557                         /* Change socket fd to TLI fd */
 558                         if (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, "timod")) {
 559                                 perror("rpc.cmsd: ioctl I_POP/I_PUSH failed");
 560                                 exit(1);
 561                         }
 562                 } else if (strcmp(mname, "timod") != 0) {
 563                         fprintf(stderr, "rpc.cmsd: fd 0 is not timod\n");
 564                         exit(1);
 565                 }
 566 #else  /* !USL || (USL && OSMAJORVERSION > 1) */
 567                 if (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, "timod")) {
 568                         perror("rpc.cmsd: ioctl I_POP/I_PUSH failed");
 569                         exit(1);
 570                 }
 571 #endif /* !USL || (USL && OSMAJORVERSION > 1) */
 572
 573         } else if (t_getinfo(0, &info) == 0) {
 574                 standalone = 0;
 575
 576 #endif /* SunOS || USL */
 577
 578         } else
 579                 standalone = 1;
 580
 581         /*
 582          * if it is started by inetd, make stderr to be
 583          * output to console.
 584          */
 585         if (!standalone) {
 586                 if ((fd = open ("/dev/console", O_WRONLY)) >= 0) {
 587                         if (fd != 2) {
 588                                 dup2(fd, 2);
 589                                 close (fd);
 590                         }
 591                 }
 592         }
 593
 594         /* Set up private directory and switch euid/egid to daemon. */
 595         umask (S_IWOTH);
 596         init_dir();
 597
 598         /* Don't allow multiple cms processes running in the same host. */
 599         if ((error = lock_it()) != 0 && !standalone) {
 600                 /* we are invoked by inetd but another rpc.cmsd
 601                  * is alreay running, so send SIGHUP to it
 602                  */
 603
 604                 send_hup();
 605
 606                 /* try to lock it again */
 607                 if (lock_it() != 0) {
 608                         if (debug)
 609                                 fprintf(stderr, "cm: rpc.cmsd is still running\n");
 610                         exit(0);
 611                 }
 612
 613         } else if (error != 0) {
 614                 fprintf(stderr, "rpc.cmsd: rpc.cmsd is already running.\n");
 615                 exit(0);
 616         }
 617
 618         /* use signal because we only need it once */
 619         signal(SIGHUP, sighup_handler);
 620
 621
 622 #if defined(SunOS) || defined(USL) || defined(__uxp__)
 623         /* raise the soft limit of number of file descriptor */
 624         /* this is to prevent the backend from running out of open file des */
 625         getrlimit(RLIMIT_NOFILE, &rl);
 626         rl.rlim_cur = (rl.rlim_max <= 256) ? rl.rlim_max : 256;
 627         setrlimit(RLIMIT_NOFILE, &rl);
 628 #endif
 629
 630 #if defined(SunOS) || defined(USL) || defined(__uxp__)
 631         nconf_udp = getnetconfigent("udp");
 632         nconf_tcp = getnetconfigent("tcp");
 633
 634         for (version = 0; version < ph->nvers; version++) {
 635                 /* don't register unsupported versions: */
 636                 if (ph->prog[version].nproc == 0) continue;
 637
 638                 if (standalone) {
 639                         rpcb_unset(ph->program_num, version, NULL);
 640                         if (debug)
 641                                 fprintf(stderr,
 642                                         "rpc.cmsd: rpcb_unset for version %ld\n",
 643                                         version);
 644                 }
 645
 646                 /* brought up by inetd, use fd 0 which must be a TLI fd */
 647                 if (udp_transp == (SVCXPRT *)-1) {
 648                         udp_transp = svc_tli_create(standalone ? RPC_ANYFD : 0,
 649                                 nconf_udp, (struct t_bind*) NULL, 0, 0);
 650
 651                         if (udp_transp == NULL) {
 652                                 t_error("rtable_main.c: svc_tli_create(udp)");
 653                                 exit(2);
 654                         }
 655                 }
 656
 657                 if (svc_reg(udp_transp, ph->program_num, version, program,
 658                                 standalone ? nconf_udp : NULL) == 0) {
 659                         t_error("rtable_main.c: svc_reg");
 660                         exit(3);
 661                 }
 662
 663                 /* Set up tcp for calls that potentially return */
 664                 /* large amount of data.  This transport is not */
 665                 /* registered with inetd so need to register it */
 666                 /* with rpcbind ourselves.                      */
 667
 668                 rpcb_unset(ph->program_num, version, nconf_tcp);
 669
 670                 if (tcp_transp == (SVCXPRT *)-1) {
 671                         tcp_transp = svc_tli_create(RPC_ANYFD, nconf_tcp,
 672                                         (struct t_bind *)NULL, 0, 0);
 673
 674                         if (tcp_transp == NULL) {
 675                                 t_error("rtable_main.c: svc_til_create(tcp)");
 676                                 exit(2);
 677                         }
 678                 }
 679
 680                 if (svc_reg(tcp_transp, ph->program_num, version, program,
 681                                 nconf_tcp) == 0) {
 682                         t_error("rtable_main.c: svc_reg(tcp)");
 683                         exit(3);
 684                 }
 685         }/*for*/
 686
 687         if (nconf_udp)
 688                 freenetconfigent(nconf_udp);
 689         if (nconf_tcp)
 690                 freenetconfigent(nconf_tcp);
 691
 692 #else
 693
 694         for (version = 0; version < ph->nvers; version++) {
 695                 /* don't register unsupported versions: */
 696                 if (ph->prog[version].nproc == 0) continue;
 697
 698 #ifndef HPUX
 699                 if (standalone)
 700 #endif
 701                         (void) pmap_unset(ph->program_num, version);
 702
 703                 if (udp_transp == (SVCXPRT *)-1) {
 704                         udp_transp = svcudp_create(standalone ? RPC_ANYSOCK : 0
 705 #if defined(_AIX) || defined(hpV4) || defined(__osf__) || defined(linux) || \
 706         defined(CSRG_BASED)
 707                                         );
 708 #else
 709                                         ,0,0);
 710 #endif
 711                         if (udp_transp == NULL) {
 712                                 (void)fprintf(stderr,
 713                                 "rtable_main.c: cannot create udp service.\n");
 714                                 exit(1);
 715                         }
 716                 }
 717
 718 #ifndef HPUX
 719                 if (!svc_register(udp_transp, ph->program_num, version, program,
 720                                 standalone ? IPPROTO_UDP : 0)) {
 721 #else
 722                 if (!svc_register(udp_transp, ph->program_num, version, program,
 723                                 IPPROTO_UDP)) {
 724 #endif
 725                         (void)fprintf(stderr, "rtable_main.c: unable to register");
 726                         exit(1);
 727                 }
 728
 729                 /* Set up tcp for calls that potentially return */
 730                 /* large amount of data.  This transport is not */
 731                 /* registered with inetd so need to register it */
 732                 /* with rpcbind ourselves.                      */
 733
 734                 if (tcp_transp == (SVCXPRT *)-1) {
 735                         tcp_transp = svctcp_create(RPC_ANYSOCK, 0, 0);
 736                         if (tcp_transp == NULL) {
 737                                 (void)fprintf(stderr,
 738                                 "rtable_main.c: cannot create tcp service.\n");
 739                                 exit(1);
 740                         }
 741                 }
 742
 743                 if (!svc_register(tcp_transp, ph->program_num, version, program,
 744                                 IPPROTO_TCP)) {
 745                         (void)fprintf(stderr, "rtable_main.c: unable to register(tcp)");
 746                         exit(1);
 747                 }
 748         }
 749
 750 #endif /* SunOS || USL */
 751
 752 #ifndef AIX
 753 #ifdef HPUX
 754         setgid (daemon_gid);
 755         setuid (daemon_uid);
 756 #else
 757         setegid (daemon_gid);
 758         seteuid (daemon_uid);
 759 #endif /* HPUX */
 760 #endif /* AIX */
 761
 762         init_time();
 763         init_alarm();
 764         _DtCm_init_hash();
 765
 766         svc_run();
 767
 768         (void)fprintf(stderr, "rpc.cmsd: svc_run returned\n");
 769         return(1);
 770 }
 771