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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * automount.c 23 * 24 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 25 */ 26 27 28 #include <ctype.h> 29 #include <stdio.h> 30 #include <unistd.h> 31 #include <stdlib.h> 32 #include <locale.h> 33 #include <stdarg.h> 34 #include <errno.h> 35 #include <string.h> 36 #include <dirent.h> 37 #include <signal.h> 38 #include <syslog.h> 39 #include <libshare.h> 40 #include <libscf.h> 41 #include <sys/param.h> 42 #include <sys/time.h> 43 #include <sys/vfs.h> 44 #include <sys/types.h> 45 #include <sys/stat.h> 46 #include <sys/mnttab.h> 47 #include <sys/mntent.h> 48 #include <sys/mount.h> 49 #include <sys/utsname.h> 50 #include <sys/tiuser.h> 51 #include <rpc/rpc.h> 52 #include <rpcsvc/nfs_prot.h> 53 #include <nsswitch.h> 54 #include <deflt.h> 55 #include <rpcsvc/daemon_utils.h> 56 #include "automount.h" 57 #include "smfcfg.h" 58 59 static int mkdir_r(char *); 60 struct autodir *dir_head; 61 struct autodir *dir_tail; 62 static struct extmnttab *find_mount(); 63 int verbose = 0; 64 int trace = 0; 65 66 static void usage(); 67 static int compare_opts(char *, char *); 68 static void do_unmounts(); 69 70 static int mount_timeout = AUTOFS_MOUNT_TIMEOUT; 71 72 static char *service_list[] = { AUTOMOUNTD, NULL }; 73 74 /* 75 * XXX 76 * The following are needed because they're used in auto_subr.c and 77 * we link with it. Should avoid this. 78 */ 79 mutex_t cleanup_lock; 80 cond_t cleanup_start_cv; 81 cond_t cleanup_done_cv; 82 83 int 84 main(int argc, char *argv[]) 85 { 86 int c; 87 struct autofs_args ai; 88 struct utsname utsname; 89 char autofs_addr[MAXADDRLEN]; 90 struct autodir *dir, *d; 91 struct stat stbuf; 92 char *master_map = "auto_master"; 93 int null; 94 struct extmnttab mnt, *mntp; 95 struct mnttab *omntp; 96 char mntopts[MAX_MNTOPT_STR]; 97 int mntflgs; 98 int count = 0; 99 char *stack[STACKSIZ]; 100 char **stkptr; 101 char *defval; 102 struct sigaction sigintact; 103 int ret = 0, bufsz = 0; 104 char valbuf[6]; 105 106 /* 107 * protect this command from session termination when run in background 108 * we test background by whether SIGINT is ignored 109 */ 110 (void) sigaction(SIGINT, NULL, &sigintact); 111 if (sigintact.sa_sigaction == SIG_IGN) { 112 (void) signal(SIGHUP, SIG_IGN); 113 (void) setsid(); 114 } 115 116 /* 117 * Read in the values from SMF first before we check 118 * commandline options so the options override the SMF values. 119 */ 120 bufsz = 6; 121 ret = autofs_smf_get_prop("timeout", valbuf, DEFAULT_INSTANCE, 122 SCF_TYPE_INTEGER, AUTOMOUNTD, &bufsz); 123 if (ret == SA_OK) 124 /* 125 * Ignore errno. In event of failure, mount_timeout is 126 * already initialized to the correct value. 127 */ 128 mount_timeout = strtol(valbuf, (char **)NULL, 10); 129 130 bufsz = 6; 131 ret = autofs_smf_get_prop("automount_verbose", valbuf, DEFAULT_INSTANCE, 132 SCF_TYPE_BOOLEAN, AUTOMOUNTD, &bufsz); 133 if (ret == SA_OK) { 134 if (strncasecmp("true", valbuf, 4) == 0) 135 verbose = TRUE; 136 } 137 138 put_automountd_env(); 139 140 while ((c = getopt(argc, argv, "mM:D:f:t:v?")) != EOF) { 141 switch (c) { 142 case 'm': 143 pr_msg("Warning: -m option not supported"); 144 break; 145 case 'M': 146 pr_msg("Warning: -M option not supported"); 147 break; 148 case 'D': 149 pr_msg("Warning: -D option not supported"); 150 break; 151 case 'f': 152 pr_msg("Error: -f option no longer supported"); 153 usage(); 154 break; 155 case 't': 156 if (strchr(optarg, '=')) { 157 pr_msg("Error: invalid value for -t"); 158 usage(); 159 } 160 mount_timeout = atoi(optarg); 161 break; 162 case 'v': 163 verbose++; 164 break; 165 default: 166 usage(); 167 break; 168 } 169 } 170 171 if (optind < argc) { 172 pr_msg("%s: command line mountpoints/maps " 173 "no longer supported", argv[optind]); 174 usage(); 175 } 176 177 current_mounts = getmntlist(); 178 if (current_mounts == NULL) { 179 pr_msg("Couldn't establish current mounts"); 180 exit(1); 181 } 182 183 (void) umask(0); 184 ns_setup(stack, &stkptr); 185 186 openlog("automount", LOG_PID, LOG_DAEMON); 187 (void) loadmaster_map(master_map, "", stack, &stkptr); 188 if (dir_head != NULL) { 189 /* 190 * automount maps found. enable services as needed. 191 */ 192 _check_services(service_list); 193 } 194 195 closelog(); 196 197 if (uname(&utsname) < 0) { 198 pr_msg("uname: %m"); 199 exit(1); 200 } 201 (void) strcpy(autofs_addr, utsname.nodename); 202 (void) strcat(autofs_addr, ".autofs"); 203 ai.addr.buf = autofs_addr; 204 ai.addr.len = strlen(ai.addr.buf); 205 ai.addr.maxlen = ai.addr.len; 206 207 ai.mount_to = mount_timeout; 208 ai.rpc_to = AUTOFS_RPC_TIMEOUT; 209 210 /* 211 * Mount the daemon at its mount points. 212 */ 213 for (dir = dir_head; dir; dir = dir->dir_next) { 214 215 /* 216 * Skip null entries 217 */ 218 if (strcmp(dir->dir_map, "-null") == 0) 219 continue; 220 221 /* 222 * Skip null'ed entries 223 */ 224 null = 0; 225 for (d = dir->dir_prev; d; d = d->dir_prev) { 226 if (strcmp(dir->dir_name, d->dir_name) == 0) 227 null = 1; 228 } 229 if (null) 230 continue; 231 232 /* 233 * Check whether there's already an entry 234 * in the mnttab for this mountpoint. 235 */ 236 if (mntp = find_mount(dir->dir_name, 1)) { 237 /* 238 * If it's not an autofs mount - don't 239 * mount over it. 240 */ 241 if (strcmp(mntp->mnt_fstype, MNTTYPE_AUTOFS) != 0) { 242 pr_msg("%s: already mounted", 243 mntp->mnt_mountp); 244 continue; 245 } 246 247 /* 248 * Compare the mnttab entry with the master map 249 * entry. If the map or mount options are 250 * different, then update this information 251 * with a remount. 252 */ 253 if (strcmp(mntp->mnt_special, dir->dir_map) == 0 && 254 compare_opts(dir->dir_opts, 255 mntp->mnt_mntopts) == 0) { 256 continue; /* no change */ 257 } 258 259 /* 260 * Check for an overlaid direct autofs mount. 261 * Cannot remount since it's inaccessible. 262 */ 263 omntp = (struct mnttab *)mntp; 264 if (hasmntopt(omntp, "direct") != NULL) { 265 mntp = find_mount(dir->dir_name, 0); 266 omntp = (struct mnttab *)mntp; 267 if (hasmntopt(omntp, "direct") == NULL) { 268 if (verbose) 269 pr_msg("%s: cannot remount", 270 dir->dir_name); 271 continue; 272 } 273 } 274 275 dir->dir_remount = 1; 276 } 277 278 /* 279 * Create a mount point if necessary 280 * If the path refers to an existing symbolic 281 * link, refuse to mount on it. This avoids 282 * future problems. 283 */ 284 if (lstat(dir->dir_name, &stbuf) == 0) { 285 if ((stbuf.st_mode & S_IFMT) != S_IFDIR) { 286 pr_msg("%s: Not a directory", dir->dir_name); 287 continue; 288 } 289 } else { 290 if (mkdir_r(dir->dir_name)) { 291 pr_msg("%s: %m", dir->dir_name); 292 continue; 293 } 294 } 295 296 ai.path = dir->dir_name; 297 ai.opts = dir->dir_opts; 298 ai.map = dir->dir_map; 299 ai.subdir = ""; 300 ai.direct = dir->dir_direct; 301 if (dir->dir_direct) 302 ai.key = dir->dir_name; 303 else 304 ai.key = ""; 305 306 (void) sprintf(mntopts, "ignore,%s", 307 dir->dir_direct ? "direct" : "indirect"); 308 if (dir->dir_opts && *dir->dir_opts) { 309 (void) strcat(mntopts, ","); 310 (void) strcat(mntopts, dir->dir_opts); 311 } 312 mntflgs = MS_OPTIONSTR | (dir->dir_remount ? MS_REMOUNT : 0); 313 if (mount(dir->dir_map, dir->dir_name, MS_DATA | mntflgs, 314 MNTTYPE_AUTOFS, &ai, sizeof (ai), mntopts, 315 MAX_MNTOPT_STR) < 0) { 316 pr_msg("mount %s: %m", dir->dir_name); 317 continue; 318 } 319 320 count++; 321 322 if (verbose) { 323 if (dir->dir_remount) 324 pr_msg("%s remounted", dir->dir_name); 325 else 326 pr_msg("%s mounted", dir->dir_name); 327 } 328 } 329 330 if (verbose && count == 0) 331 pr_msg("no mounts"); 332 333 /* 334 * Now compare the /etc/mnttab with the master 335 * map. Any autofs mounts in the /etc/mnttab 336 * that are not in the master map must be 337 * unmounted 338 */ 339 do_unmounts(); 340 341 return (0); 342 } 343 344 /* 345 * Find a mount entry given 346 * the mountpoint path. 347 * Optionally return the first 348 * or last entry. 349 */ 350 static struct extmnttab * 351 find_mount(mntpnt, first) 352 char *mntpnt; 353 int first; 354 { 355 struct mntlist *mntl; 356 struct extmnttab *found = NULL; 357 358 for (mntl = current_mounts; mntl; mntl = mntl->mntl_next) { 359 360 if (strcmp(mntpnt, mntl->mntl_mnt->mnt_mountp) == 0) { 361 found = mntl->mntl_mnt; 362 if (first) 363 break; 364 } 365 } 366 367 return (found); 368 } 369 370 static char *ignore_opts[] = {"ignore", "direct", "indirect", "dev", NULL}; 371 372 /* 373 * Compare mount options 374 * ignoring "ignore", "direct", "indirect" 375 * and "dev=". 376 */ 377 static int 378 compare_opts(opts, mntopts) 379 char *opts, *mntopts; 380 { 381 char optbuf1[MAX_MNTOPT_STR], *s = optbuf1; 382 char optbuf2[MAX_MNTOPT_STR]; 383 char **opttbl1, **opttbl2; 384 int nopts1, nopts2; 385 char *ostart, *optr, *valp; 386 int j, i, notsame; 387 388 opttbl1 = opttbl2 = NULL; 389 /* 390 * Parse the two option strings to split them both into 391 * lists of individual options. 392 */ 393 if (mntopts != NULL) 394 (void) strcpy(s, mntopts); 395 else 396 *s = '\0'; 397 if (*s != '\0') 398 nopts1 = 1; 399 else 400 nopts1 = 0; 401 for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) { 402 nopts1++; 403 s++; 404 } 405 if (nopts1) 406 if ((opttbl1 = memalign(sizeof (char *), 407 nopts1 * sizeof (char *))) == NULL) 408 return (1); 409 nopts1 = 0; 410 s = optbuf1; 411 for (ostart = optr = s; *optr != '\0'; ostart = optr) { 412 if (getsubopt(&optr, ignore_opts, &valp) == -1) { 413 opttbl1[nopts1++] = ostart; 414 } 415 } 416 s = optbuf2; 417 if (opts != NULL) 418 (void) strcpy(s, opts); 419 else 420 *s = '\0'; 421 if (*s != '\0') 422 nopts2 = 1; 423 else 424 nopts2 = 0; 425 for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) { 426 nopts2++; 427 s++; 428 } 429 if (nopts2) 430 if ((opttbl2 = memalign(sizeof (char *), 431 nopts2 * sizeof (char *))) == NULL) { 432 notsame = 1; 433 goto done; 434 } 435 nopts2 = 0; 436 s = optbuf2; 437 for (ostart = optr = s; *optr != '\0'; ostart = optr) { 438 if (getsubopt(&optr, ignore_opts, &valp) == -1) { 439 opttbl2[nopts2++] = ostart; 440 } 441 } 442 if (nopts2 != nopts1) { 443 notsame = 1; 444 goto done; 445 } 446 notsame = 0; 447 for (i = 0; i < nopts1; i++) { 448 notsame = 1; 449 for (j = 0; j < nopts2; j++) { 450 if (strcmp(opttbl1[i], opttbl2[j]) == 0) { 451 notsame = 0; 452 break; 453 } 454 } 455 if (notsame) 456 break; 457 } 458 459 done: 460 if (opttbl1 != NULL) 461 free(opttbl1); 462 if (opttbl2 != NULL) 463 free(opttbl2); 464 return (notsame); 465 } 466 467 static void 468 usage() 469 { 470 pr_msg("Usage: automount [ -v ] [ -t duration ]"); 471 exit(1); 472 /* NOTREACHED */ 473 } 474 475 /* 476 * Unmount any autofs mounts that 477 * aren't in the master map 478 */ 479 static void 480 do_unmounts() 481 { 482 struct mntlist *mntl; 483 struct extmnttab *mnt; 484 struct mnttab *omnt; 485 struct autodir *dir; 486 int current; 487 int count = 0; 488 struct zone_summary *zsp; 489 490 zsp = fs_get_zone_summaries(); 491 if (zsp == NULL) { 492 pr_msg("Couldn't establish active zones"); 493 exit(1); 494 } 495 for (mntl = current_mounts; mntl; mntl = mntl->mntl_next) { 496 mnt = mntl->mntl_mnt; 497 omnt = (struct mnttab *)mnt; 498 if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS) != 0) 499 continue; 500 if (fs_mount_in_other_zone(zsp, mnt->mnt_mountp)) 501 continue; 502 /* 503 * Don't unmount autofs mounts done 504 * from the autofs mount command. 505 * How do we tell them apart ? 506 * Autofs mounts not eligible for auto-unmount 507 * have the "nest" pseudo-option. 508 */ 509 if (hasmntopt(omnt, "nest") != NULL) 510 continue; 511 512 current = 0; 513 for (dir = dir_head; dir; dir = dir->dir_next) { 514 if (strcmp(dir->dir_name, mnt->mnt_mountp) == 0) { 515 current = strcmp(dir->dir_map, "-null"); 516 break; 517 } 518 } 519 if (current) 520 continue; 521 522 523 if (umount(mnt->mnt_mountp) == 0) { 524 if (verbose) { 525 pr_msg("%s unmounted", 526 mnt->mnt_mountp); 527 } 528 count++; 529 } 530 } 531 if (verbose && count == 0) 532 pr_msg("no unmounts"); 533 } 534 535 static int 536 mkdir_r(dir) 537 char *dir; 538 { 539 int err; 540 char *slash; 541 542 if (mkdir(dir, 0555) == 0 || errno == EEXIST) 543 return (0); 544 if (errno != ENOENT) 545 return (-1); 546 slash = strrchr(dir, '/'); 547 if (slash == NULL) 548 return (-1); 549 *slash = '\0'; 550 err = mkdir_r(dir); 551 *slash++ = '/'; 552 if (err || !*slash) 553 return (err); 554 return (mkdir(dir, 0555)); 555 } 556 557 /* 558 * Print an error. 559 * Works like printf (fmt string and variable args) 560 * except that it will subsititute an error message 561 * for a "%m" string (like syslog). 562 */ 563 /* VARARGS1 */ 564 void 565 pr_msg(const char *fmt, ...) 566 { 567 va_list ap; 568 char buf[BUFSIZ], *p2; 569 char *p1; 570 char *nfmt; 571 572 (void) strcpy(buf, "automount: "); 573 p2 = buf + strlen(buf); 574 575 nfmt = gettext(fmt); 576 577 for (p1 = nfmt; *p1; p1++) { 578 if (*p1 == '%' && *(p1+1) == 'm') { 579 (void) strcpy(p2, strerror(errno)); 580 p2 += strlen(p2); 581 p1++; 582 } else { 583 *p2++ = *p1; 584 } 585 } 586 if (p2 > buf && *(p2-1) != '\n') 587 *p2++ = '\n'; 588 *p2 = '\0'; 589 590 va_start(ap, fmt); 591 (void) vfprintf(stderr, buf, ap); 592 va_end(ap); 593 } 594