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 } 644