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