usr/src/cmd/ypcmd/ypserv.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2017 Gary Mills
  24  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  29 /*        All Rights Reserved   */
  30
  31 /*
  32  * Portions of this source code were derived from Berkeley 4.3 BSD
  33  * under license from the Regents of the University of California.
  34  */
  35
  36 /*
  37  * This contains the mainline code for the YP server.  Data
  38  * structures which are process-global are also in this module.
  39  */
  40
  41 /* this is so that ypserv will compile under 5.5 */
  42 #define _SVID_GETTOD
  43 #include <sys/time.h>
  44 extern int gettimeofday(struct timeval *);
  45
  46 #include "ypsym.h"
  47 #include <sys/types.h>
  48 #include <sys/wait.h>
  49 #include <fcntl.h>
  50 #include <rpc/rpc.h>
  51 #include <netconfig.h>
  52 #include <netdir.h>
  53 #include <sys/select.h>
  54 #include <stdlib.h>
  55 #include <unistd.h>
  56 #include <stdio.h>
  57 #include <stdarg.h>
  58 #include <signal.h>
  59 #include "shim.h"
  60 #include "yptol.h"
  61 #include <syslog.h>
  62
  63 static char register_failed[] = "ypserv:  Unable to register service for ";
  64 bool silent = TRUE;
  65
  66 /*
  67  * client_setup_failure will be TRUE, if setup of the
  68  * connection to rpc.nisd_resolv failed
  69  */
  70 bool client_setup_failure = FALSE;
  71
  72 /* N2L options */
  73 bool init_dit = FALSE;
  74 bool init_containers = FALSE;
  75 bool init_maps = FALSE;
  76 char **ldapCLA = NULL;
  77
  78 /* For DNS forwarding command line option (-d) */
  79 bool dnsforward = FALSE;
  80 int resolv_pid = 0;
  81 CLIENT *resolv_client = NULL;
  82 char *resolv_tp = "ticots";
  83
  84 #ifdef MINUS_C_OPTION
  85 /* For cluster support (-c) */
  86 bool multiflag = FALSE;
  87 #endif
  88
  89 static char logfile[] = "/var/yp/ypserv.log";
  90 void logprintf(char *format, ...);
  91
  92 static void ypexit(void);
  93 static void ypinit(int argc, char **argv);
  94 static void ypdispatch(struct svc_req *rqstp, SVCXPRT *transp);
  95 static void ypolddispatch(struct svc_req *rqstp, SVCXPRT *transp);
  96 static void ypget_command_line_args(int argc, char **argv);
  97 extern void setup_resolv(bool *fwding, int *child,
  98                         CLIENT **client, char *tp_type, long prognum);
  99 static void cleanup_resolv(int);
 100
 101 /*
 102  * This is the main line code for the yp server.
 103  */
 104 int
 105 main(int argc, char **argv)
 106 {
 107         if (geteuid() != 0) {
 108                 fprintf(stderr, "must be root to run %s\n", argv[0]);
 109                 exit(1);
 110         }
 111
 112         /* Set up shop */
 113         ypinit(argc, argv);
 114
 115         /* If requested set up the N2L maps. May take a while */
 116         if (init_dit)
 117                 if (FAILURE == dump_maps_to_dit(init_containers)) {
 118                         fprintf(stderr, "Fatal error dumping maps to DIT."
 119                         " See syslog and LDAP server logs for details.\n");
 120                         exit(1);
 121                 }
 122
 123         if (init_maps)
 124                 if (FAILURE == dump_dit_to_maps()) {
 125                         fprintf(stderr, "Fatal error dumping DIT to maps."
 126                         " See syslog and LDAP server logs for details.\n");
 127                         exit(1);
 128                 }
 129
 130         /*
 131          * If we were asked to init the maps now exit. User will then use
 132          * ypstart to restart ypserv and all the other NIS daemons.
 133          */
 134         if (init_dit || init_maps) {
 135                 printf("Map setup complete. Please now restart NIS daemons "
 136                         "with ypstart.\n");
 137                 exit(0);
 138         }
 139
 140         svc_run();
 141
 142         /*
 143          * This is stupid, but the compiler likes to warn us about the
 144          * absence of returns from main()
 145          */
 146         return (0);
 147 }
 148
 149 typedef struct {
 150         char            *netid;
 151         int             fd;
 152         int             olddispatch;    /* Register on protocol version 1 ? */
 153         int             class;          /* Other services that must succeed */
 154         SVCXPRT         *xprt;
 155         int             ok;             /* Registered successfully ? */
 156 } ypservice_t;
 157
 158 ypservice_t     service[] = {
 159         { "udp", -1, 1, 4, 0, 0 },
 160         { "tcp", -1, 1, 4, 0, 0 },
 161         { "udp6", -1, 0, 6, 0, 0 },
 162         { "tcp6", -1, 0, 6, 0, 0 }
 163 };
 164
 165 #define MAXSERVICES     (sizeof (service)/sizeof (service[0]))
 166
 167 int             service_classes[MAXSERVICES];
 168
 169 /*
 170  * Does startup processing for the yp server.
 171  */
 172 static void
 173 ypinit(int argc, char **argv)
 174 {
 175         int pid;
 176         int stat;
 177         struct sigaction act;
 178         int ufd, tfd;
 179         SVCXPRT *utransp, *ttransp;
 180         struct netconfig *nconf;
 181         int connmaxrec = RPC_MAXDATASIZE;
 182         int i, j, services = 0;
 183
 184
 185         /*
 186          * Init yptol flags. Will get redone by init_lock_system() but we need
 187          * to know if we should parse yptol cmd line options.
 188          */
 189         init_yptol_flag();
 190
 191         ypget_command_line_args(argc, argv);
 192
 193         if (silent) {
 194                 pid = (int)fork();
 195
 196                 if (pid == -1) {
 197                     logprintf("ypserv:  ypinit fork failure.\n");
 198                     ypexit();
 199                 }
 200
 201                 if (pid != 0) {
 202                     exit(0);
 203                 }
 204         }
 205
 206         if (!init_lock_system(FALSE)) {
 207                 ypexit();
 208         }
 209
 210         get_secure_nets(argv[0]);
 211
 212         if (silent) {
 213                 closelog();
 214                 closefrom(3);
 215         }
 216
 217         if (yptol_mode) {
 218                 stat = parseConfig(ldapCLA, NTOL_MAP_FILE);
 219                 if (stat == 1) {
 220                         logprintf("NIS to LDAP mapping inactive.\n");
 221                 } else if (stat != 0) {
 222                         logprintf("Aborting after NIS to LDAP mapping "
 223                                                         "error.\n");
 224                         fflush(stderr);
 225                         exit(-1);
 226                 }
 227         }
 228
 229         if (silent) {
 230                 freopen("/dev/null", "r", stdin);
 231                 if (access(logfile, _IOWRT)) {
 232                     freopen("/dev/null", "w", stdout);
 233                     freopen("/dev/null", "w", stderr);
 234                 } else {
 235                     freopen(logfile, "a", stdout);
 236                     freopen(logfile, "a", stderr);
 237                 }
 238
 239                 (void) open("/dev/tty", O_RDWR);
 240
 241                 setpgrp();
 242         }
 243
 244 #ifdef  SYSVCONFIG
 245         sigset(SIGHUP, (void (*)())sysvconfig);
 246 #else
 247         sigset(SIGHUP, SIG_IGN);
 248 #endif
 249
 250         /*
 251          * Setting disposition to SIG_IGN will not create zombies when child
 252          * processes terminate.
 253          */
 254         sigset(SIGCHLD, SIG_IGN);
 255
 256         act.sa_handler = cleanup_resolv;
 257         sigemptyset(&act.sa_mask);
 258         act.sa_flags = SA_RESETHAND;
 259         sigaction(SIGTERM, &act, NULL);
 260         sigaction(SIGQUIT, &act, NULL);
 261         sigaction(SIGABRT, &act, NULL);
 262         sigaction(SIGBUS, &act, NULL);
 263         sigaction(SIGSEGV, &act, NULL);
 264
 265         /*
 266          * Set non-blocking mode and maximum record size for
 267          * connection oriented RPC transports.
 268          */
 269         if (!rpc_control(RPC_SVC_CONNMAXREC_SET, &connmaxrec)) {
 270                 logprintf("unable to set maximum RPC record size");
 271         }
 272
 273         svc_unreg(YPPROG, YPVERS);
 274         svc_unreg(YPPROG, YPVERS_ORIG);
 275
 276         for (i = 0; i < sizeof (service)/sizeof (ypservice_t); i++) {
 277
 278                 service_classes[i] = -1;
 279
 280                 if ((nconf = getnetconfigent(service[i].netid)) == NULL) {
 281                         logprintf("getnetconfigent(\"%s\") failed\n",
 282                                         service[i].netid);
 283                         continue;
 284                 }
 285
 286                 if ((service[i].fd = t_open(nconf->nc_device, O_RDWR, NULL)) <
 287                         0) {
 288                         logprintf("t_open failed for %s\n", service[i].netid);
 289                         freenetconfigent(nconf);
 290                         continue;
 291                 }
 292
 293                 if (netdir_options(nconf, ND_SET_RESERVEDPORT, service[i].fd,
 294                         NULL) < 0) {
 295                         logprintf("could not set reserved port for %s\n",
 296                                 service[i].netid);
 297                         (void) close(service[i].fd);
 298                         service[i].fd = -1;
 299                         freenetconfigent(nconf);
 300                         continue;
 301                 }
 302
 303                 if ((service[i].xprt = svc_tli_create(service[i].fd, nconf,
 304                         NULL, 0, 0)) == NULL) {
 305                         logprintf("svc_tli_create failed for %s\n",
 306                                 service[i].netid);
 307                         (void) close(service[i].fd);
 308                         service[i].fd = -1;
 309                         freenetconfigent(nconf);
 310                         continue;
 311                 }
 312
 313                 if (!svc_reg(service[i].xprt, YPPROG, YPVERS, ypdispatch,
 314                         nconf)) {
 315                         logprintf("%s %s\n", service[i].netid, register_failed);
 316                         svc_destroy(service[i].xprt);
 317                         service[i].xprt = 0;
 318                         (void) close(service[i].fd);
 319                         service[i].fd = -1;
 320                         freenetconfigent(nconf);
 321                         continue;
 322                 }
 323
 324                 if (service[i].olddispatch && !svc_reg(service[i].xprt, YPPROG,
 325                                         YPVERS_ORIG, ypolddispatch, nconf)) {
 326                         logprintf("old %s %s\n",
 327                                 service[i].netid, register_failed);
 328                         /* Can only unregister prognum/versnum */
 329                         svc_destroy(service[i].xprt);
 330                         service[i].xprt = 0;
 331                         (void) close(service[i].fd);
 332                         service[i].fd = -1;
 333                         freenetconfigent(nconf);
 334                         continue;
 335                 }
 336
 337                 services++;
 338                 service[i].ok = 1;
 339                 service_classes[i] = service[i].class;
 340
 341                 freenetconfigent(nconf);
 342
 343         }
 344
 345         /*
 346          * Check if we managed to register enough services to continue.
 347          * It's OK if we managed to register all IPv4 services but no
 348          * IPv6, or the other way around, but not if we (say) registered
 349          * IPv4 UDP but not TCP.
 350          */
 351         if (services > 0) {
 352                 for (j = 0; j < MAXSERVICES; j++) {
 353                         if (service_classes[j] >= 0) {
 354                                 /*
 355                                  * Must have all services of this class
 356                                  * registered.
 357                                  */
 358                                 for (i = 0; i < MAXSERVICES; i++) {
 359                                         if (service[i].ok == 0 &&
 360                                                 service[i].class ==
 361                                                 service_classes[j]) {
 362                                                 logprintf(
 363                         "unable to register all services for class %d\n",
 364                                                         service[i].class);
 365                                                 ypexit();
 366                                         }
 367                                 }
 368                         }
 369                 }
 370         } else {
 371                 logprintf("unable to register any services\n");
 372                 ypexit();
 373         }
 374
 375         /* Now we setup circuit_n or yp_all() and yp_update() will not work */
 376         if (!svc_create(ypdispatch, YPPROG, YPVERS, "circuit_n")) {
 377                 logprintf("circuit_n %s\n", register_failed);
 378                 ypexit();
 379         }
 380
 381         if (dnsforward) {
 382                 setup_resolv(&dnsforward, &resolv_pid,
 383                                 &resolv_client, resolv_tp, 0);
 384                 if (resolv_client == NULL)
 385                         client_setup_failure = TRUE;
 386         }
 387 }
 388
 389 void
 390 cleanup_resolv(int sig)
 391 {
 392         if (resolv_pid)
 393                 kill(resolv_pid, sig);
 394
 395         kill(getpid(), sig);
 396 }
 397
 398 /*
 399  * This picks up any command line args passed from the process invocation.
 400  */
 401 static void
 402 ypget_command_line_args(int argc, char **argv)
 403 {
 404         for (argv++; --argc; argv++) {
 405
 406                 if ((*argv)[0] == '-') {
 407
 408                         switch ((*argv)[1]) {
 409 #ifdef  MINUS_C_OPTION
 410                         case 'c':
 411                                 multiflag = TRUE;
 412                                 break;
 413 #endif
 414                         case 'd':
 415                                 if (access("/etc/resolv.conf", F_OK) == -1) {
 416                                         fprintf(stderr,
 417                         "No /etc/resolv.conf file, -d option ignored\n");
 418                                 } else {
 419                                         dnsforward = TRUE;
 420                                 }
 421                                 break;
 422                         case 'I':
 423                                 init_containers = TRUE;
 424                                 /* ... and also do -i stuff */
 425                         case 'i':
 426                                 if (yptol_mode) {
 427                                         init_dit = TRUE;
 428                                 } else {
 429                                         fprintf(stderr, "-%c option is illegal "
 430                                         "if not in NIS to LDAP mode. Exiting\n",
 431                                                 (*argv)[1]);
 432                                         fflush(stderr);
 433                                         exit(-1);
 434                                 }
 435
 436                                 /* Handle -ir */
 437                                 if ('r' != (*argv)[2])
 438                                         break;
 439
 440                         case 'r':
 441                                 if (yptol_mode) {
 442                                         init_maps = TRUE;
 443                                 } else {
 444                                         fprintf(stderr, "-r option is illegal "
 445                                                 "if not in NIS to LDAP mode. "
 446                                                 "Exiting\n");
 447                                         fflush(stderr);
 448                                         exit(-1);
 449                                 }
 450                                 break;
 451                         case 'v':
 452                                 silent = FALSE;
 453                                 break;
 454                         }
 455                 }
 456         }
 457
 458         /* If setting up don't run silent or demonize */
 459         if (init_dit || init_maps)
 460                 silent = FALSE;
 461
 462 }
 463
 464 /*
 465  * This dispatches to server action routines based on the input procedure
 466  * number.  ypdispatch is called from the RPC function svc_run.
 467  */
 468 static void
 469 ypdispatch(struct svc_req *rqstp, SVCXPRT *transp)
 470 {
 471         sigset_t set, oset;
 472
 473
 474 #ifdef  SYSVCONFIG
 475         /* prepare to answer questions about system v filesystem aliases */
 476         sysvconfig();
 477 #endif
 478
 479         sigemptyset(&set);
 480         sigaddset(&set, SIGCHLD);
 481         sigprocmask(SIG_BLOCK, &set, &oset);
 482
 483         switch (rqstp->rq_proc) {
 484
 485         case YPPROC_NULL:
 486
 487                 if (!svc_sendreply(transp, xdr_void, 0))
 488                         logprintf("ypserv:  Can't reply to rpc call.\n");
 489                 break;
 490
 491         case YPPROC_DOMAIN:
 492                 ypdomain(transp, TRUE);
 493                 break;
 494
 495         case YPPROC_DOMAIN_NONACK:
 496                 ypdomain(transp, FALSE);
 497                 break;
 498
 499         case YPPROC_MATCH:
 500                 ypmatch(transp, rqstp);
 501                 break;
 502
 503         case YPPROC_FIRST:
 504                 ypfirst(transp);
 505                 break;
 506
 507         case YPPROC_NEXT:
 508                 ypnext(transp);
 509                 break;
 510
 511         case YPPROC_XFR:
 512                 ypxfr(transp, YPPROC_XFR);
 513                 break;
 514
 515         case YPPROC_NEWXFR:
 516                 ypxfr(transp, YPPROC_NEWXFR);
 517                 break;
 518
 519         case YPPROC_CLEAR:
 520                 ypclr_current_map();
 521
 522                 if (!svc_sendreply(transp, xdr_void, 0))
 523                         logprintf("ypserv:  Can't reply to rpc call.\n");
 524                 break;
 525
 526         case YPPROC_ALL:
 527                 ypall(transp);
 528                 break;
 529
 530         case YPPROC_MASTER:
 531                 ypmaster(transp);
 532                 break;
 533
 534         case YPPROC_ORDER:
 535                 yporder(transp);
 536                 break;
 537
 538         case YPPROC_MAPLIST:
 539                 ypmaplist(transp);
 540                 break;
 541
 542         default:
 543                 svcerr_noproc(transp);
 544                 break;
 545
 546         }
 547
 548         sigprocmask(SIG_SETMASK, &oset, (sigset_t *)NULL);
 549
 550 }
 551
 552 static void
 553 ypolddispatch(struct svc_req *rqstp, SVCXPRT *transp)
 554 {
 555         sigset_t set, oset;
 556
 557         sigemptyset(&set);
 558         sigaddset(&set, SIGCHLD);
 559         sigprocmask(SIG_BLOCK, &set, &oset);
 560
 561         switch (rqstp->rq_proc) {
 562
 563         case YPOLDPROC_NULL:
 564                 if (!svc_sendreply(transp, xdr_void, 0))
 565                         logprintf("ypserv:  Can't replay to rpc call.\n");
 566                 break;
 567
 568         case YPOLDPROC_DOMAIN:
 569                 ypdomain(transp, TRUE);
 570                 break;
 571
 572         case YPOLDPROC_DOMAIN_NONACK:
 573                 ypdomain(transp, FALSE);
 574                 break;
 575
 576         case YPOLDPROC_MATCH:
 577                 ypoldmatch(transp, rqstp);
 578                 break;
 579
 580         case YPOLDPROC_FIRST:
 581                 ypoldfirst(transp);
 582                 break;
 583
 584         case YPOLDPROC_NEXT:
 585                 ypoldnext(transp);
 586                 break;
 587
 588         case YPOLDPROC_POLL:
 589                 ypoldpoll(transp);
 590                 break;
 591
 592         case YPOLDPROC_PUSH:
 593                 ypoldpush(transp);
 594                 break;
 595
 596         case YPOLDPROC_PULL:
 597                 ypoldpull(transp);
 598                 break;
 599
 600         case YPOLDPROC_GET:
 601                 ypoldget(transp);
 602
 603         default:
 604                 svcerr_noproc(transp);
 605                 break;
 606         }
 607
 608         sigprocmask(SIG_SETMASK, &oset, (sigset_t *)NULL);
 609 }
 610
 611 /*
 612  * This flushes output to stderr, then aborts the server process to leave a
 613  * core dump.
 614  */
 615 static void
 616 ypexit(void)
 617 {
 618         fflush(stderr);
 619         abort();
 620 }
 621
 622 /*
 623  * This constructs a logging record.
 624  */
 625 void
 626 logprintf(char *format, ...)
 627 {
 628         va_list ap;
 629         struct timeval t;
 630
 631         va_start(ap, format);
 632
 633         if (silent) {
 634                 gettimeofday(&t);
 635                 fseek(stderr, 0, 2);
 636                 fprintf(stderr, "%19.19s: ", ctime(&t.tv_sec));
 637         }
 638
 639         vfprintf(stderr, format, ap);
 640         va_end(ap);
 641         fflush(stderr);
 642 }