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", 2); 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, (struct sigaction *)NULL); 260 sigaction(SIGQUIT, &act, (struct sigaction *)NULL); 261 sigaction(SIGABRT, &act, (struct sigaction *)NULL); 262 sigaction(SIGBUS, &act, (struct sigaction *)NULL); 263 sigaction(SIGSEGV, &act, (struct sigaction *)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 } 643