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 * autod_parse.c 23 * 24 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 27 */ 28 29 #include <stdio.h> 30 #include <ctype.h> 31 #include <string.h> 32 #include <syslog.h> 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <sys/param.h> 36 #include <errno.h> 37 #include <pwd.h> 38 #include <netinet/in.h> 39 #include <netdb.h> 40 #include <sys/tiuser.h> 41 #include <locale.h> 42 #include <stdlib.h> 43 #include <unistd.h> 44 #include <thread.h> 45 #include <rpc/rpc.h> 46 #include <rpcsvc/mount.h> 47 #include <fcntl.h> 48 #include <limits.h> 49 #include "automount.h" 50 51 /* 52 * This structure is used to determine the hierarchical 53 * relationship between directories 54 */ 55 typedef struct _hiernode { 56 char dirname[MAXFILENAMELEN+1]; 57 struct _hiernode *subdir; 58 struct _hiernode *leveldir; 59 struct mapent *mapent; 60 } hiernode; 61 62 void free_mapent(struct mapent *); 63 64 static int mapline_to_mapent(struct mapent **, struct mapline *, char *, char *, 65 char *, char *, uint_t); 66 static int hierarchical_sort(struct mapent *, hiernode **, char *, char *); 67 static int push_options(hiernode *, char *, char *, int); 68 static int set_mapent_opts(struct mapent *, char *, char *, char *); 69 static void get_opts(char *, char *, char *, bool_t *); 70 static int fstype_opts(struct mapent *, char *, char *, char *); 71 static int modify_mapents(struct mapent **, char *, char *, char *, hiernode *, 72 char *, uint_t, bool_t); 73 static int set_and_fake_mapent_mntlevel(hiernode *, char *, char *, char *, 74 struct mapent **, uint_t, char *, bool_t); 75 static int mark_level1_root(hiernode *, char *); 76 static int mark_and_fake_level1_noroot(hiernode *, char *, char *, char *, 77 struct mapent **, uint_t i, char *); 78 static int convert_mapent_to_automount(struct mapent *, char *, char *); 79 static int automount_opts(char **, char *); 80 static int parse_fsinfo(char *, struct mapent *); 81 static int parse_nfs(char *, struct mapent *, char *, char *, char **, char **, 82 int); 83 static int parse_special(struct mapent *, char *, char *, char **, char **, 84 int); 85 static int get_dir_from_path(char *, char **, int); 86 static int alloc_hiernode(hiernode **, char *); 87 static void free_hiernode(hiernode *); 88 static void trace_mapents(char *, struct mapent *); 89 static void trace_hierarchy(hiernode *, int); 90 static struct mapent *do_mapent_hosts(char *, char *, uint_t); 91 static void freeex_ent(struct exportnode *); 92 static void freeex(struct exportnode *); 93 static void dump_mapent_err(struct mapent *, char *, char *); 94 95 #define PARSE_OK 0 96 #define PARSE_ERROR -1 97 #define MAX_FSLEN 32 98 99 /* 100 * mapentry error type defininitions 101 */ 102 #define MAPENT_NOERR 0 103 #define MAPENT_UATFS 1 104 105 /* 106 * parse_entry(char *key, char *mapname, char *mapopts, struct mapline *ml, 107 * char *subdir, uint_t isdirect, bool_t mount_access) 108 * Parses the data in ml to build a mapentry list containing the information 109 * for the mounts/lookups to be performed. Builds an intermediate mapentry list 110 * by processing ml, hierarchically sorts (builds a tree of) the list according 111 * to mountpoint. Then pushes options down the hierarchy, and fills in the mount 112 * file system. Finally, modifies the intermediate list depending on how far 113 * in the hierarchy the current request is (uses subdir). Deals with special 114 * case of /net map parsing. 115 * Returns a pointer to the head of the mapentry list. 116 */ 117 struct mapent * 118 parse_entry(char *key, char *mapname, char *mapopts, struct mapline *ml, 119 char *subdir, uint_t isdirect, bool_t mount_access) 120 { 121 char *p; 122 char defaultopts[AUTOFS_MAXOPTSLEN]; 123 124 struct mapent *mapents = NULL; 125 hiernode *rootnode = NULL; 126 char *lp = ml->linebuf; 127 128 if (trace > 1) 129 trace_prt(1, " mapline: %s\n", ml->linebuf); 130 131 /* 132 * Assure the key is only one token long. 133 * This prevents options from sneaking in through the 134 * command line or corruption of /etc/mnttab. 135 */ 136 for (p = key; *p != '\0'; p++) { 137 if (isspace(*p)) { 138 syslog(LOG_ERR, 139 "parse_entry: bad key in map %s: %s", mapname, key); 140 return ((struct mapent *)NULL); 141 } 142 } 143 144 /* 145 * select the appropriate parser, and build the mapentry list 146 */ 147 if (strcmp(lp, "-hosts") == 0) { 148 /* 149 * the /net parser - uses do_mapent_hosts to build mapents. 150 * The mapopts are considered default for every entry, so we 151 * don't push options down hierarchies. 152 */ 153 mapents = do_mapent_hosts(mapopts, key, isdirect); 154 if (mapents == NULL) /* nothing to free */ 155 return (mapents); 156 157 if (trace > 3) 158 trace_mapents("do_mapent_hosts:(return)", mapents); 159 160 if (hierarchical_sort(mapents, &rootnode, key, mapname) 161 != PARSE_OK) 162 goto parse_error; 163 } else { 164 /* 165 * all other parsing 166 */ 167 if (mapline_to_mapent(&mapents, ml, key, mapname, 168 mapopts, defaultopts, isdirect) != PARSE_OK) 169 goto parse_error; 170 171 if (mapents == NULL) 172 return (mapents); 173 174 if (hierarchical_sort(mapents, &rootnode, key, mapname) 175 != PARSE_OK) 176 goto parse_error; 177 178 if (push_options(rootnode, defaultopts, mapopts, 179 MAPENT_NOERR) != PARSE_OK) 180 goto parse_error; 181 182 if (trace > 3) { 183 trace_prt(1, "\n\tpush_options (return)\n"); 184 trace_prt(0, "\tdefault options=%s\n", defaultopts); 185 trace_hierarchy(rootnode, 0); 186 }; 187 188 if (parse_fsinfo(mapname, mapents) != PARSE_OK) 189 goto parse_error; 190 } 191 192 /* 193 * Modify the mapentry list. We *must* do this only after 194 * the mapentry list is completely built (since we need to 195 * have parse_fsinfo called first). 196 */ 197 if (modify_mapents(&mapents, mapname, mapopts, subdir, 198 rootnode, key, isdirect, mount_access) != PARSE_OK) 199 goto parse_error; 200 201 /* 202 * XXX: its dangerous to use rootnode after modify mapents as 203 * it may be pointing to mapents that have been freed 204 */ 205 if (rootnode != NULL) 206 free_hiernode(rootnode); 207 208 return (mapents); 209 210 parse_error: 211 syslog(LOG_ERR, "parse_entry: mapentry parse error: map=%s key=%s", 212 mapname, key); 213 free_mapent(mapents); 214 if (rootnode != NULL) 215 free_hiernode(rootnode); 216 return ((struct mapent *)NULL); 217 } 218 219 220 /* 221 * mapline_to_mapent(struct mapent **mapents, struct mapline *ml, 222 * char *key, char *mapname, char *mapopts, char *defaultopts, 223 * uint_t isdirect) 224 * Parses the mapline information in ml word by word to build an intermediate 225 * mapentry list, which is passed back to the caller. The mapentries may have 226 * holes (example no options), as they are completed only later. The logic is 227 * awkward, but needed to provide the supported flexibility in the map entries. 228 * (especially the first line). Note that the key is the full pathname of the 229 * directory to be mounted in a direct map, and ml is the mapentry beyond key. 230 * Returns PARSE_OK or an appropriate error value. 231 */ 232 static int 233 mapline_to_mapent(struct mapent **mapents, struct mapline *ml, char *key, 234 char *mapname, char *mapopts, char *defaultopts, 235 uint_t isdirect) 236 { 237 struct mapent *me = NULL; 238 struct mapent *mp; 239 char w[MAXPATHLEN]; 240 char wq[MAXPATHLEN]; 241 char w1[MAXPATHLEN]; 242 int implied; 243 244 char *lp = ml->linebuf; 245 char *lq = ml->lineqbuf; 246 247 /* do any macro expansions that are required to complete ml */ 248 if (macro_expand(key, lp, lq, LINESZ)) { 249 syslog(LOG_ERR, 250 "mapline_to_mapent: map %s: line too long (max %d chars)", 251 mapname, LINESZ - 1); 252 return (PARSE_ERROR); 253 } 254 if (trace > 3 && (strcmp(ml->linebuf, lp) != 0)) 255 trace_prt(1, 256 " mapline_to_mapent: (expanded) mapline (%s,%s)\n", 257 ml->linebuf, ml->lineqbuf); 258 259 /* init the head of mapentry list to null */ 260 *mapents = NULL; 261 262 /* 263 * Get the first word - its either a '-' if default options provided, 264 * a '/', if the mountroot is implicitly provided, or a mount filesystem 265 * if the mountroot is implicit. Note that if the first word begins with 266 * a '-' then the second must be read and it must be a mountpoint or a 267 * mount filesystem. Use mapopts if no default opts are provided. 268 */ 269 if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1) 270 return (PARSE_ERROR); 271 if (*w == '-') { 272 strcpy(defaultopts, w); 273 if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1) 274 return (PARSE_ERROR); 275 } else 276 strcpy(defaultopts, mapopts); 277 278 /* 279 * implied is true if there is no '/' 280 * We need the same code path if we have an smbfs mount. 281 */ 282 implied = (*w != '/') || (strstr(defaultopts, "fstype=smbfs") != NULL); 283 while (*w == '/' || implied) { 284 mp = me; 285 if ((me = (struct mapent *)malloc(sizeof (*me))) == NULL) 286 goto alloc_failed; 287 (void) memset((char *)me, 0, sizeof (*me)); 288 if (*mapents == NULL) /* special case of head */ 289 *mapents = me; 290 else 291 mp->map_next = me; 292 293 /* 294 * direct maps get an empty string as root - to be filled 295 * by the entire path later. Indirect maps get /key as the 296 * map root. Note that xfn maps don't care about the root 297 * - they override it in getmapent_fn(). 298 */ 299 if (isdirect) { 300 *w1 = '\0'; 301 } else { 302 strcpy(w1, "/"); 303 strcat(w1, key); 304 } 305 if ((me->map_root = strdup(w1)) == NULL) 306 goto alloc_failed; 307 308 /* mntpnt is empty for the mount root */ 309 if (strcmp(w, "/") == 0 || implied) 310 me->map_mntpnt = strdup(""); 311 else 312 me->map_mntpnt = strdup(w); 313 if (me->map_mntpnt == NULL) 314 goto alloc_failed; 315 316 /* 317 * If implied, the word must be a mount filesystem, 318 * and its already read in; also turn off implied - its 319 * not applicable except for the mount root. Else, 320 * read another (or two) words depending on if there's 321 * an option. 322 */ 323 if (implied) /* must be a mount filesystem */ 324 implied = 0; 325 else { 326 if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1) 327 return (PARSE_ERROR); 328 if (w[0] == '-') { 329 /* mount options */ 330 if ((me->map_mntopts = strdup(w)) == NULL) 331 goto alloc_failed; 332 if (getword(w, wq, &lp, &lq, ' ', 333 sizeof (w)) == -1) 334 return (PARSE_ERROR); 335 } 336 } 337 338 /* 339 * must be a mount filesystem or a set of filesystems at 340 * this point. 341 */ 342 if (w[0] == '\0' || w[0] == '-') { 343 syslog(LOG_ERR, 344 "mapline_to_mapent: bad location=%s map=%s key=%s", 345 w, mapname, key); 346 return (PARSE_ERROR); 347 } 348 349 /* 350 * map_fsw and map_fswq hold information which will be 351 * used to determine filesystem information at a later 352 * point. This is required since we can only find out 353 * about the mount file system after the directories 354 * are hierarchically sorted and options have been pushed 355 * down the hierarchies. 356 */ 357 if (((me->map_fsw = strdup(w)) == NULL) || 358 ((me->map_fswq = strdup(wq)) == NULL)) 359 goto alloc_failed; 360 361 /* 362 * the next word, if any, is either another mount point or a 363 * mount filesystem if more than one server is listed. 364 */ 365 if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1) 366 return (PARSE_ERROR); 367 while (*w && *w != '/') { /* more than 1 server listed */ 368 int len; 369 char *fsw, *fswq; 370 len = strlen(me->map_fsw) + strlen(w) + 4; 371 if ((fsw = (char *)malloc(len)) == NULL) 372 goto alloc_failed; 373 sprintf(fsw, "%s %s", me->map_fsw, w); 374 free(me->map_fsw); 375 me->map_fsw = fsw; 376 len = strlen(me->map_fswq) + strlen(wq) + 4; 377 if ((fswq = (char *)malloc(len)) == NULL) 378 goto alloc_failed; 379 sprintf(fswq, "%s %s", me->map_fswq, wq); 380 free(me->map_fswq); 381 me->map_fswq = fswq; 382 if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1) 383 return (PARSE_ERROR); 384 } 385 386 /* initialize flags */ 387 me->map_mntlevel = -1; 388 me->map_modified = FALSE; 389 me->map_faked = FALSE; 390 me->map_err = MAPENT_NOERR; 391 392 me->map_next = NULL; 393 } 394 395 if (*mapents == NULL || w[0] != '\0') { /* sanity check */ 396 if (verbose) { 397 if (*mapents == NULL) 398 syslog(LOG_ERR, 399 "mapline_to_mapent: parsed with null mapents"); 400 else 401 syslog(LOG_ERR, 402 "mapline_to_mapent: parsed nononempty w=%s", w); 403 } 404 return (PARSE_ERROR); 405 } 406 407 if (trace > 3) 408 trace_mapents("mapline_to_mapent:", *mapents); 409 410 return (PARSE_OK); 411 412 alloc_failed: 413 syslog(LOG_ERR, "mapline_to_mapent: Memory allocation failed"); 414 return (ENOMEM); 415 } 416 417 /* 418 * hierarchical_sort(struct mapent *mapents, hiernode **rootnode, char *key 419 * char *mapname) 420 * sorts the mntpnts in each mapent to build a hierarchy of nodes, with 421 * with the rootnode being the mount root. The hierarchy is setup as 422 * levels, and subdirs below each level. Provides a link from node to 423 * the relevant mapentry. 424 * Returns PARSE_OK or appropriate error value 425 */ 426 static int 427 hierarchical_sort(struct mapent *mapents, hiernode **rootnode, char *key, 428 char *mapname) 429 { 430 hiernode *prevnode, *currnode, *newnode; 431 char *path; 432 char dirname[MAXFILENAMELEN]; 433 434 int rc = PARSE_OK; 435 struct mapent *me = mapents; 436 437 /* allocate the rootnode with a default path of "" */ 438 *rootnode = NULL; 439 if ((rc = alloc_hiernode(rootnode, "")) != PARSE_OK) 440 return (rc); 441 442 /* 443 * walk through mapents - for each mapent, locate the position 444 * within the hierarchy by walking across leveldirs, and 445 * subdirs of matched leveldirs. Starts one level below 446 * the root (assumes an implicit match with rootnode). 447 * XXX - this could probably be done more cleanly using recursion. 448 */ 449 while (me != NULL) { 450 451 path = me->map_mntpnt; 452 453 if ((rc = get_dir_from_path(dirname, &path, 454 sizeof (dirname))) != PARSE_OK) 455 return (rc); 456 457 prevnode = *rootnode; 458 currnode = (*rootnode)->subdir; 459 460 while (dirname[0] != '\0') { 461 if (currnode != NULL) { 462 if (strcmp(currnode->dirname, dirname) == 0) { 463 /* 464 * match found - mntpnt is a child of 465 * this node 466 */ 467 prevnode = currnode; 468 currnode = currnode->subdir; 469 } else { 470 prevnode = currnode; 471 currnode = currnode->leveldir; 472 473 if (currnode == NULL) { 474 /* 475 * No more leveldirs to match. 476 * Add a new one 477 */ 478 if ((rc = alloc_hiernode 479 (&newnode, dirname)) 480 != PARSE_OK) 481 return (rc); 482 prevnode->leveldir = newnode; 483 prevnode = newnode; 484 currnode = newnode->subdir; 485 } else { 486 /* try this leveldir */ 487 continue; 488 } 489 } 490 } else { 491 /* no more subdirs to match. Add a new one */ 492 if ((rc = alloc_hiernode(&newnode, 493 dirname)) != PARSE_OK) 494 return (rc); 495 prevnode->subdir = newnode; 496 prevnode = newnode; 497 currnode = newnode->subdir; 498 } 499 if ((rc = get_dir_from_path(dirname, &path, 500 sizeof (dirname))) != PARSE_OK) 501 return (rc); 502 } 503 504 if (prevnode->mapent != NULL) { 505 /* duplicate mntpoint found */ 506 syslog(LOG_ERR, 507 "hierarchical_sort: duplicate mntpnt map=%s key=%s", 508 mapname, key); 509 return (PARSE_ERROR); 510 } 511 512 /* provide a pointer from node to mapent */ 513 prevnode->mapent = me; 514 me = me->map_next; 515 } 516 517 if (trace > 3) { 518 trace_prt(1, "\n\thierarchical_sort:\n"); 519 trace_hierarchy(*rootnode, 0); /* 0 is rootnode's level */ 520 } 521 522 return (rc); 523 } 524 525 /* 526 * push_options(hiernode *node, char *opts, char *mapopts, int err) 527 * Pushes the options down a hierarchical structure. Works recursively from the 528 * root, which is passed in on the first call. Uses a replacement policy. 529 * If a node points to a mapentry, and it has an option, then thats the option 530 * for that mapentry. Else, the node's mapent inherits the option from the 531 * default (which may be the global option for the entry or mapopts). 532 * err is useful in flagging entries with errors in pushing options. 533 * returns PARSE_OK or appropriate error value. 534 */ 535 static int 536 push_options(hiernode *node, char *defaultopts, char *mapopts, int err) 537 { 538 int rc = PARSE_OK; 539 struct mapent *me = NULL; 540 541 /* ensure that all the dirs at a level are passed the default options */ 542 while (node != NULL) { 543 me = node->mapent; 544 if (me != NULL) { /* not all nodes point to a mapentry */ 545 me->map_err = err; 546 if ((rc = set_mapent_opts(me, me->map_mntopts, 547 defaultopts, mapopts)) != PARSE_OK) 548 return (rc); 549 } 550 551 /* push the options to subdirs */ 552 if (node->subdir != NULL) { 553 if (node->mapent && strcmp(node->mapent->map_fstype, 554 MNTTYPE_AUTOFS) == 0) 555 err = MAPENT_UATFS; 556 if ((rc = push_options(node->subdir, defaultopts, 557 mapopts, err)) != PARSE_OK) 558 return (rc); 559 } 560 node = node->leveldir; 561 } 562 return (rc); 563 } 564 565 #define FSTYPE "fstype" 566 #define FSTYPE_EQ "fstype=" 567 #define NO_OPTS "" 568 569 /* 570 * set_mapent_opts(struct mapent *me, char *opts, char *defaultopts, 571 * char *mapopts) 572 * sets the mapentry's options, fstype and mounter fields by separating 573 * out the fstype part from the opts. Use default options if opts is NULL. 574 * Note taht defaultopts may be the same as mapopts. 575 * Returns PARSE_OK or appropriate error value. 576 */ 577 static int 578 set_mapent_opts(struct mapent *me, char *opts, char *defaultopts, 579 char *mapopts) 580 { 581 char entryopts[AUTOFS_MAXOPTSLEN]; 582 char fstype[MAX_FSLEN], mounter[MAX_FSLEN]; 583 int rc = PARSE_OK; 584 bool_t fstype_opt = FALSE; 585 586 strcpy(fstype, MNTTYPE_NFS); /* default */ 587 588 /* set options to default options, if none exist for this entry */ 589 if (opts == NULL) { 590 opts = defaultopts; 591 if (defaultopts == NULL) { /* NULL opts for entry */ 592 strcpy(mounter, fstype); 593 goto done; 594 } 595 } 596 if (*opts == '-') 597 opts++; 598 599 /* separate opts into fstype and (other) entrypopts */ 600 get_opts(opts, entryopts, fstype, &fstype_opt); 601 602 /* replace any existing opts */ 603 if (me->map_mntopts != NULL) 604 free(me->map_mntopts); 605 if ((me->map_mntopts = strdup(entryopts)) == NULL) 606 return (ENOMEM); 607 strcpy(mounter, fstype); 608 609 /* 610 * child options are exactly fstype = somefs, we need to do some 611 * more option pushing work. 612 */ 613 if (fstype_opt == TRUE && 614 (strcmp(me->map_mntopts, NO_OPTS) == 0)) { 615 free(me->map_mntopts); 616 if ((rc = fstype_opts(me, opts, defaultopts, 617 mapopts)) != PARSE_OK) 618 return (rc); 619 } 620 621 done: 622 if (((me->map_fstype = strdup(fstype)) == NULL) || 623 ((me->map_mounter = strdup(mounter)) == NULL)) { 624 if (me->map_fstype != NULL) 625 free(me->map_fstype); 626 syslog(LOG_ERR, "set_mapent_opts: No memory"); 627 return (ENOMEM); 628 } 629 630 return (rc); 631 } 632 633 /* 634 * Check the option string for an "fstype" 635 * option. If found, return the fstype 636 * and the option string with the fstype 637 * option removed, e.g. 638 * 639 * input: "fstype=nfs,ro,nosuid" 640 * opts: "ro,nosuid" 641 * fstype: "nfs" 642 * 643 * Also indicates if the fstype option was present 644 * by setting a flag, if the pointer to the flag 645 * is not NULL. 646 */ 647 static void 648 get_opts(input, opts, fstype, fstype_opt) 649 char *input; 650 char *opts; /* output */ 651 char *fstype; /* output */ 652 bool_t *fstype_opt; 653 { 654 char *p, *pb; 655 char buf[MAXOPTSLEN]; 656 char *placeholder; 657 658 *opts = '\0'; 659 (void) strcpy(buf, input); 660 pb = buf; 661 while (p = (char *)strtok_r(pb, ",", &placeholder)) { 662 pb = NULL; 663 if (strncmp(p, FSTYPE_EQ, 7) == 0) { 664 if (fstype_opt != NULL) 665 *fstype_opt = TRUE; 666 (void) strcpy(fstype, p + 7); 667 } else { 668 if (*opts) 669 (void) strcat(opts, ","); 670 (void) strcat(opts, p); 671 } 672 } 673 } 674 675 /* 676 * fstype_opts(struct mapent *me, char *opts, char *defaultopts, 677 * char *mapopts) 678 * We need to push global options to the child entry if it is exactly 679 * fstype=somefs. 680 */ 681 static int 682 fstype_opts(struct mapent *me, char *opts, char *defaultopts, 683 char *mapopts) 684 { 685 char pushentryopts[AUTOFS_MAXOPTSLEN]; 686 char pushfstype[MAX_FSLEN]; 687 688 if (defaultopts && *defaultopts == '-') 689 defaultopts++; 690 691 /* 692 * the options to push are the global defaults for the entry, 693 * if they exist, or mapopts, if the global defaults for the 694 * entry does not exist. 695 */ 696 if (strcmp(defaultopts, opts) == 0) { 697 if (*mapopts == '-') 698 mapopts++; 699 get_opts(mapopts, pushentryopts, pushfstype, NULL); 700 } else { 701 get_opts(defaultopts, pushentryopts, pushfstype, NULL); 702 } 703 704 me->map_mntopts = strdup(pushentryopts); 705 706 if (!me->map_mntopts) { 707 syslog(LOG_ERR, "fstype_opts: No memory"); 708 return (ENOMEM); 709 } 710 711 return (PARSE_OK); 712 } 713 714 /* 715 * modify_mapents(struct mapent **mapents, char *mapname, 716 * char *mapopts, char *subdir, hiernode *rootnode, 717 * char *key, uint_t isdirect, bool_t mount_access) 718 * modifies the intermediate mapentry list into the final one, and passes 719 * back a pointer to it. The final list may contain faked mapentries for 720 * hiernodes that do not point to a mapentry, or converted mapentries, if 721 * hiernodes that point to a mapentry need to be converted from nfs to autofs. 722 * mounts. Entries that are not directly 1 level below the subdir are removed. 723 * Returns PARSE_OK or PARSE_ERROR 724 */ 725 static int 726 modify_mapents(struct mapent **mapents, char *mapname, 727 char *mapopts, char *subdir, hiernode *rootnode, 728 char *key, uint_t isdirect, bool_t mount_access) 729 { 730 struct mapent *mp = NULL; 731 char w[MAXPATHLEN]; 732 733 struct mapent *me; 734 int rc = PARSE_OK; 735 struct mapent *faked_mapents = NULL; 736 737 /* 738 * correct the mapentry mntlevel from default -1 to level depending on 739 * position in hierarchy, and build any faked mapentries, if required 740 * at one level below the rootnode given by subdir. 741 */ 742 if ((rc = set_and_fake_mapent_mntlevel(rootnode, subdir, key, mapname, 743 &faked_mapents, isdirect, mapopts, mount_access)) != PARSE_OK) 744 return (rc); 745 746 /* 747 * attaches faked mapents to real mapents list. Assumes mapents 748 * is not NULL. 749 */ 750 me = *mapents; 751 while (me->map_next != NULL) 752 me = me->map_next; 753 me->map_next = faked_mapents; 754 755 /* 756 * get rid of nodes marked at level -1 757 */ 758 me = *mapents; 759 while (me != NULL) { 760 if ((me->map_mntlevel == -1) || (me->map_err) || 761 (mount_access == FALSE && me->map_mntlevel == 0)) { 762 /* 763 * syslog any errors and free entry 764 */ 765 if (me->map_err) 766 dump_mapent_err(me, key, mapname); 767 768 if (me == (*mapents)) { 769 /* special case when head has to be freed */ 770 *mapents = me->map_next; 771 if ((*mapents) == NULL) { 772 /* something wierd happened */ 773 if (verbose) 774 syslog(LOG_ERR, 775 "modify_mapents: level error"); 776 return (PARSE_ERROR); 777 } 778 779 /* separate out the node */ 780 me->map_next = NULL; 781 free_mapent(me); 782 me = *mapents; 783 } else { 784 mp->map_next = me->map_next; 785 me->map_next = NULL; 786 free_mapent(me); 787 me = mp->map_next; 788 } 789 continue; 790 } 791 792 /* 793 * convert level 1 mapents that are not already autonodes 794 * to autonodes 795 */ 796 if (me->map_mntlevel == 1 && 797 (strcmp(me->map_fstype, MNTTYPE_AUTOFS) != 0) && 798 (me->map_faked != TRUE)) { 799 if ((rc = convert_mapent_to_automount(me, mapname, 800 mapopts)) != PARSE_OK) 801 return (rc); 802 } 803 strcpy(w, (me->map_mntpnt+strlen(subdir))); 804 strcpy(me->map_mntpnt, w); 805 mp = me; 806 me = me->map_next; 807 } 808 809 if (trace > 3) 810 trace_mapents("modify_mapents:", *mapents); 811 812 return (PARSE_OK); 813 } 814 815 /* 816 * set_and_fake_mapent_mntlevel(hiernode *rootnode, char *subdir, char *key, 817 * char *mapname, struct mapent **faked_mapents, 818 * uint_t isdirect, char *mapopts, bool_t mount_access) 819 * sets the mapentry mount levels (depths) with respect to the subdir. 820 * Assigns a value of 0 to the new root. Finds the level1 directories by 821 * calling mark_*_level1_*(). Also cleans off extra /'s in level0 and 822 * level1 map_mntpnts. Note that one level below the new root is an existing 823 * mapentry if there's a mapentry (nfs mount) corresponding to the root, 824 * and the direct subdir set for the root, if there's no mapentry corresponding 825 * to the root (we install autodirs). Returns PARSE_OK or error value. 826 */ 827 static int 828 set_and_fake_mapent_mntlevel(hiernode *rootnode, char *subdir, char *key, 829 char *mapname, struct mapent **faked_mapents, 830 uint_t isdirect, char *mapopts, bool_t mount_access) 831 { 832 char dirname[MAXFILENAMELEN]; 833 char traversed_path[MAXPATHLEN]; /* used in building fake mapentries */ 834 835 char *subdir_child = subdir; 836 hiernode *prevnode = rootnode; 837 hiernode *currnode = rootnode->subdir; 838 int rc = PARSE_OK; 839 traversed_path[0] = '\0'; 840 841 /* 842 * find and mark the root by tracing down subdir. Use traversed_path 843 * to keep track of how far we go, while guaranteeing that it 844 * contains no '/' at the end. Took some mucking to get that right. 845 */ 846 if ((rc = get_dir_from_path(dirname, &subdir_child, sizeof (dirname))) 847 != PARSE_OK) 848 return (rc); 849 850 if (dirname[0] != '\0') 851 sprintf(traversed_path, "%s/%s", traversed_path, dirname); 852 853 prevnode = rootnode; 854 currnode = rootnode->subdir; 855 while (dirname[0] != '\0' && currnode != NULL) { 856 if (strcmp(currnode->dirname, dirname) == 0) { 857 858 /* subdir is a child of currnode */ 859 prevnode = currnode; 860 currnode = currnode->subdir; 861 862 if ((rc = get_dir_from_path(dirname, &subdir_child, 863 sizeof (dirname))) != PARSE_OK) 864 return (rc); 865 if (dirname[0] != '\0') 866 sprintf(traversed_path, "%s/%s", 867 traversed_path, dirname); 868 869 } else { 870 /* try next leveldir */ 871 prevnode = currnode; 872 currnode = currnode->leveldir; 873 } 874 } 875 876 if (dirname[0] != '\0') { 877 if (verbose) 878 syslog(LOG_ERR, 879 "set_and_fake_mapent_mntlevel: subdir=%s error: map=%s", 880 subdir, mapname); 881 return (PARSE_ERROR); 882 } 883 884 /* 885 * see if level of root really points to a mapent and if 886 * have access to that filessystem - call appropriate 887 * routine to mark level 1 nodes, and build faked entries 888 */ 889 if (prevnode->mapent != NULL && mount_access == TRUE) { 890 if (trace > 3) 891 trace_prt(1, " node mountpoint %s\t travpath=%s\n", 892 prevnode->mapent->map_mntpnt, traversed_path); 893 894 /* 895 * Copy traversed path map_mntpnt to get rid of any extra 896 * '/' the map entry may contain. 897 */ 898 if (strlen(prevnode->mapent->map_mntpnt) < 899 strlen(traversed_path)) { /* sanity check */ 900 if (verbose) 901 syslog(LOG_ERR, 902 "set_and_fake_mapent_mntlevel: path=%s error", 903 traversed_path); 904 return (PARSE_ERROR); 905 } 906 if (strcmp(prevnode->mapent->map_mntpnt, traversed_path) != 0) 907 strcpy(prevnode->mapent->map_mntpnt, traversed_path); 908 909 prevnode->mapent->map_mntlevel = 0; /* root level is 0 */ 910 if (currnode != NULL) { 911 if ((rc = mark_level1_root(currnode, 912 traversed_path)) != PARSE_OK) 913 return (rc); 914 } 915 } else if (currnode != NULL) { 916 if (trace > 3) 917 trace_prt(1, " No rootnode, travpath=%s\n", 918 traversed_path); 919 if ((rc = mark_and_fake_level1_noroot(currnode, 920 traversed_path, key, mapname, faked_mapents, isdirect, 921 mapopts)) != PARSE_OK) 922 return (rc); 923 } 924 925 if (trace > 3) { 926 trace_prt(1, "\n\tset_and_fake_mapent_mntlevel\n"); 927 trace_hierarchy(rootnode, 0); 928 } 929 930 return (rc); 931 } 932 933 934 /* 935 * mark_level1_root(hiernode *node, char *traversed_path) 936 * marks nodes upto one level below the rootnode given by subdir 937 * recursively. Called if rootnode points to a mapent. 938 * In this routine, a level 1 node is considered to be the 1st existing 939 * mapentry below the root node, so there's no faking involved. 940 * Returns PARSE_OK or error value 941 */ 942 static int 943 mark_level1_root(hiernode *node, char *traversed_path) 944 { 945 /* ensure we touch all leveldirs */ 946 while (node) { 947 /* 948 * mark node level as 1, if one exists - else walk down 949 * subdirs until we find one. 950 */ 951 if (node->mapent == NULL) { 952 char w[MAXPATHLEN]; 953 954 if (node->subdir != NULL) { 955 sprintf(w, "%s/%s", traversed_path, 956 node->dirname); 957 if (mark_level1_root(node->subdir, w) 958 == PARSE_ERROR) 959 return (PARSE_ERROR); 960 } else { 961 if (verbose) { 962 syslog(LOG_ERR, 963 "mark_level1_root: hierarchy error"); 964 } 965 return (PARSE_ERROR); 966 } 967 } else { 968 char w[MAXPATHLEN]; 969 970 sprintf(w, "%s/%s", traversed_path, node->dirname); 971 if (trace > 3) 972 trace_prt(1, " node mntpnt %s\t travpath %s\n", 973 node->mapent->map_mntpnt, w); 974 975 /* replace mntpnt with travpath to clean extra '/' */ 976 if (strlen(node->mapent->map_mntpnt) < strlen(w)) { 977 if (verbose) { 978 syslog(LOG_ERR, 979 "mark_level1_root: path=%s error", 980 traversed_path); 981 } 982 return (PARSE_ERROR); 983 } 984 if (strcmp(node->mapent->map_mntpnt, w) != 0) 985 strcpy(node->mapent->map_mntpnt, w); 986 node->mapent->map_mntlevel = 1; 987 } 988 node = node->leveldir; 989 } 990 return (PARSE_OK); 991 } 992 993 /* 994 * mark_and_fake_level1_noroot(hiernode *node, char *traversed_path, 995 * char *key,char *mapname, struct mapent **faked_mapents, 996 * uint_t isdirect, char *mapopts) 997 * Called if the root of the hierarchy does not point to a mapent. marks nodes 998 * upto one physical level below the rootnode given by subdir. checks if 999 * there's a real mapentry. If not, it builds a faked one (autonode) at that 1000 * point. The faked autonode is direct, with the map being the same as the 1001 * original one from which the call originated. Options are same as that of 1002 * the map and assigned in automount_opts(). Returns PARSE_OK or error value. 1003 */ 1004 static int 1005 mark_and_fake_level1_noroot(hiernode *node, char *traversed_path, 1006 char *key, char *mapname, struct mapent **faked_mapents, 1007 uint_t isdirect, char *mapopts) 1008 { 1009 struct mapent *me; 1010 int rc = 0; 1011 char faked_map_mntpnt[MAXPATHLEN]; 1012 char w1[MAXPATHLEN]; 1013 char w[MAXPATHLEN]; 1014 1015 while (node != NULL) { 1016 if (node->mapent != NULL) { 1017 /* 1018 * existing mapentry at level 1 - copy travpath to 1019 * get rid of extra '/' in mntpnt 1020 */ 1021 sprintf(w, "%s/%s", traversed_path, node->dirname); 1022 if (trace > 3) 1023 trace_prt(1, " node mntpnt=%s\t travpath=%s\n", 1024 node->mapent->map_mntpnt, w); 1025 if (strlen(node->mapent->map_mntpnt) < strlen(w)) { 1026 /* sanity check */ 1027 if (verbose) 1028 syslog(LOG_ERR, 1029 "mark_fake_level1_noroot:path=%s error", 1030 traversed_path); 1031 return (PARSE_ERROR); 1032 } 1033 if (strcmp(node->mapent->map_mntpnt, w) != 0) 1034 strcpy(node->mapent->map_mntpnt, w); 1035 node->mapent->map_mntlevel = 1; 1036 } else { 1037 /* 1038 * build the faked autonode 1039 */ 1040 if ((me = (struct mapent *)malloc(sizeof (*me))) 1041 == NULL) { 1042 syslog(LOG_ERR, 1043 "mark_and_fake_level1_noroot: out of memory"); 1044 return (ENOMEM); 1045 } 1046 (void) memset((char *)me, 0, sizeof (*me)); 1047 1048 if ((me->map_fs = (struct mapfs *) 1049 malloc(sizeof (struct mapfs))) == NULL) 1050 return (ENOMEM); 1051 (void) memset(me->map_fs, 0, sizeof (struct mapfs)); 1052 1053 if (isdirect) { 1054 *w1 = '\0'; 1055 } else { 1056 strcpy(w1, "/"); 1057 strcat(w1, key); 1058 } 1059 me->map_root = strdup(w1); 1060 1061 sprintf(faked_map_mntpnt, "%s/%s", traversed_path, 1062 node->dirname); 1063 me->map_mntpnt = strdup(faked_map_mntpnt); 1064 me->map_fstype = strdup(MNTTYPE_AUTOFS); 1065 me->map_mounter = strdup(MNTTYPE_AUTOFS); 1066 1067 /* set options */ 1068 if ((rc = automount_opts(&me->map_mntopts, mapopts)) 1069 != PARSE_OK) 1070 return (rc); 1071 me->map_fs->mfs_dir = strdup(mapname); 1072 me->map_mntlevel = 1; 1073 me->map_modified = FALSE; 1074 me->map_faked = TRUE; /* mark as faked */ 1075 if (me->map_root == NULL || 1076 me->map_mntpnt == NULL || 1077 me->map_fstype == NULL || 1078 me->map_mounter == NULL || 1079 me->map_mntopts == NULL || 1080 me->map_fs->mfs_dir == NULL) { 1081 syslog(LOG_ERR, 1082 "mark_and_fake_level1_noroot: out of memory"); 1083 free_mapent(*faked_mapents); 1084 return (ENOMEM); 1085 } 1086 1087 if (*faked_mapents == NULL) 1088 *faked_mapents = me; 1089 else { /* attach to the head */ 1090 me->map_next = *faked_mapents; 1091 *faked_mapents = me; 1092 } 1093 node->mapent = me; 1094 } 1095 node = node->leveldir; 1096 } 1097 return (rc); 1098 } 1099 1100 /* 1101 * convert_mapent_to_automount(struct mapent *me, char *mapname, 1102 * char *mapopts) 1103 * change the mapentry me to an automount - free fields first and NULL them 1104 * to avoid freeing again, while freeing the mapentry at a later stage. 1105 * Could have avoided freeing entries here as we don't really look at them. 1106 * Give the converted mapent entry the options that came with the map using 1107 * automount_opts(). Returns PARSE_OK or appropriate error value. 1108 */ 1109 static int 1110 convert_mapent_to_automount(struct mapent *me, char *mapname, 1111 char *mapopts) 1112 { 1113 struct mapfs *mfs = me->map_fs; /* assumes it exists */ 1114 int rc = PARSE_OK; 1115 1116 /* free relevant entries */ 1117 if (mfs->mfs_host) { 1118 free(mfs->mfs_host); 1119 mfs->mfs_host = NULL; 1120 } 1121 while (me->map_fs->mfs_next != NULL) { 1122 mfs = me->map_fs->mfs_next; 1123 if (mfs->mfs_host) 1124 free(mfs->mfs_host); 1125 if (mfs->mfs_dir) 1126 free(mfs->mfs_dir); 1127 me->map_fs->mfs_next = mfs->mfs_next; /* nulls eventually */ 1128 free((void*)mfs); 1129 } 1130 1131 /* replace relevant entries */ 1132 if (me->map_fstype) 1133 free(me->map_fstype); 1134 if ((me->map_fstype = strdup(MNTTYPE_AUTOFS)) == NULL) 1135 goto alloc_failed; 1136 1137 if (me->map_mounter) 1138 free(me->map_mounter); 1139 if ((me->map_mounter = strdup(me->map_fstype)) == NULL) 1140 goto alloc_failed; 1141 1142 if (me->map_fs->mfs_dir) 1143 free(me->map_fs->mfs_dir); 1144 if ((me->map_fs->mfs_dir = strdup(mapname)) == NULL) 1145 goto alloc_failed; 1146 1147 /* set options */ 1148 if (me->map_mntopts) 1149 free(me->map_mntopts); 1150 if ((rc = automount_opts(&me->map_mntopts, mapopts)) != PARSE_OK) 1151 return (rc); 1152 1153 /* mucked with this entry, set the map_modified field to TRUE */ 1154 me->map_modified = TRUE; 1155 1156 return (rc); 1157 1158 alloc_failed: 1159 syslog(LOG_ERR, 1160 "convert_mapent_to_automount: Memory allocation failed"); 1161 return (ENOMEM); 1162 } 1163 1164 /* 1165 * automount_opts(char **map_mntopts, char *mapopts) 1166 * modifies automount opts - gets rid of all "indirect" and "direct" strings 1167 * if they exist, and then adds a direct string to force a direct automount. 1168 * Rest of the mapopts stay intact. Returns PARSE_OK or appropriate error. 1169 */ 1170 static int 1171 automount_opts(char **map_mntopts, char *mapopts) 1172 { 1173 char *opts; 1174 char *opt; 1175 int len; 1176 char *placeholder; 1177 char buf[AUTOFS_MAXOPTSLEN]; 1178 1179 char *addopt = "direct"; 1180 1181 len = strlen(mapopts)+ strlen(addopt)+2; /* +2 for ",", '\0' */ 1182 if (len > AUTOFS_MAXOPTSLEN) { 1183 syslog(LOG_ERR, 1184 "option string %s too long (max=%d)", mapopts, 1185 AUTOFS_MAXOPTSLEN-8); 1186 return (PARSE_ERROR); 1187 } 1188 1189 if (((*map_mntopts) = ((char *)malloc(len))) == NULL) { 1190 syslog(LOG_ERR, "automount_opts: Memory allocation failed"); 1191 return (ENOMEM); 1192 } 1193 memset(*map_mntopts, 0, len); 1194 1195 strcpy(buf, mapopts); 1196 opts = buf; 1197 while ((opt = strtok_r(opts, ",", &placeholder)) != NULL) { 1198 opts = NULL; 1199 1200 /* remove trailing and leading spaces */ 1201 while (isspace(*opt)) 1202 opt++; 1203 len = strlen(opt)-1; 1204 while (isspace(opt[len])) 1205 opt[len--] = '\0'; 1206 1207 /* 1208 * if direct or indirect found, get rid of it, else put it 1209 * back 1210 */ 1211 if ((strcmp(opt, "indirect") == 0) || 1212 (strcmp(opt, "direct") == 0)) 1213 continue; 1214 if (*map_mntopts[0] != '\0') 1215 strcat(*map_mntopts, ","); 1216 strcat(*map_mntopts, opt); 1217 } 1218 1219 /* add the direct string at the end */ 1220 if (*map_mntopts[0] != '\0') 1221 strcat(*map_mntopts, ","); 1222 strcat(*map_mntopts, addopt); 1223 1224 return (PARSE_OK); 1225 } 1226 1227 /* 1228 * parse_fsinfo(char *mapname, struct mapent *mapents) 1229 * parses the filesystem information stored in me->map_fsw and me->map_fswq 1230 * and calls appropriate filesystem parser. 1231 * Returns PARSE_OK or an appropriate error value. 1232 */ 1233 static int 1234 parse_fsinfo(char *mapname, struct mapent *mapents) 1235 { 1236 struct mapent *me = mapents; 1237 char *bufp; 1238 char *bufq; 1239 int wordsz = MAXPATHLEN; 1240 int err = 0; 1241 1242 while (me != NULL) { 1243 bufp = ""; 1244 bufq = ""; 1245 if (strcmp(me->map_fstype, MNTTYPE_NFS) == 0) { 1246 err = parse_nfs(mapname, me, me->map_fsw, 1247 me->map_fswq, &bufp, &bufq, wordsz); 1248 } else { 1249 err = parse_special(me, me->map_fsw, me->map_fswq, 1250 &bufp, &bufq, wordsz); 1251 } 1252 1253 if (err != PARSE_OK || *me->map_fsw != '\0' || 1254 *me->map_fswq != '\0') { 1255 /* sanity check */ 1256 if (verbose) 1257 syslog(LOG_ERR, 1258 "parse_fsinfo: mount location error %s", 1259 me->map_fsw); 1260 return (PARSE_ERROR); 1261 } 1262 1263 me = me->map_next; 1264 } 1265 1266 if (trace > 3) { 1267 trace_mapents("parse_fsinfo:", mapents); 1268 } 1269 1270 return (PARSE_OK); 1271 } 1272 1273 /* 1274 * This function parses the map entry for a nfs type file system 1275 * The input is the string lp (and lq) which can be one of the 1276 * following forms: 1277 * a) host[(penalty)][,host[(penalty)]]... :/directory 1278 * b) host[(penalty)]:/directory[ host[(penalty)]:/directory]... 1279 * This routine constructs a mapfs link-list for each of 1280 * the hosts and the corresponding file system. The list 1281 * is then attatched to the mapent struct passed in. 1282 */ 1283 int 1284 parse_nfs(mapname, me, fsw, fswq, lp, lq, wsize) 1285 struct mapent *me; 1286 char *mapname, *fsw, *fswq, **lp, **lq; 1287 int wsize; 1288 { 1289 struct mapfs *mfs, **mfsp; 1290 char *wlp, *wlq; 1291 char *hl, hostlist[1024], *hlq, hostlistq[1024]; 1292 char hostname_and_penalty[MXHOSTNAMELEN+5]; 1293 char *hn, *hnq, hostname[MXHOSTNAMELEN+1]; 1294 char dirname[MAXPATHLEN+1], subdir[MAXPATHLEN+1]; 1295 char qbuff[MAXPATHLEN+1], qbuff1[MAXPATHLEN+1]; 1296 char pbuff[10], pbuffq[10]; 1297 int penalty; 1298 char w[MAXPATHLEN]; 1299 char wq[MAXPATHLEN]; 1300 int host_cnt; 1301 1302 mfsp = &me->map_fs; 1303 *mfsp = NULL; 1304 1305 /* 1306 * there may be more than one entry in the map list. Get the 1307 * first one. Use temps to handle the word information and 1308 * copy back into fsw and fswq fields when done. 1309 */ 1310 *lp = fsw; 1311 *lq = fswq; 1312 if (getword(w, wq, lp, lq, ' ', wsize) == -1) 1313 return (PARSE_ERROR); 1314 while (*w && *w != '/') { 1315 bool_t maybe_url; 1316 1317 maybe_url = TRUE; 1318 1319 wlp = w; wlq = wq; 1320 if (getword(hostlist, hostlistq, &wlp, &wlq, ':', 1321 sizeof (hostlist)) == -1) 1322 return (PARSE_ERROR); 1323 if (!*hostlist) 1324 goto bad_entry; 1325 1326 if (strcmp(hostlist, "nfs") != 0) 1327 maybe_url = FALSE; 1328 1329 if (getword(dirname, qbuff, &wlp, &wlq, ':', 1330 sizeof (dirname)) == -1) 1331 return (PARSE_ERROR); 1332 if (*dirname == '\0') 1333 goto bad_entry; 1334 1335 if (maybe_url == TRUE && strncmp(dirname, "//", 2) != 0) 1336 maybe_url = FALSE; 1337 1338 /* 1339 * See the next block comment ("Once upon a time ...") to 1340 * understand this. It turns the deprecated concept 1341 * of "subdir mounts" produced some useful code for handling 1342 * the possibility of a ":port#" in the URL. 1343 */ 1344 if (maybe_url == FALSE) 1345 *subdir = '/'; 1346 else 1347 *subdir = ':'; 1348 1349 *qbuff = ' '; 1350 1351 /* 1352 * Once upon time, before autofs, there was support for 1353 * "subdir mounts". The idea was to "economize" the 1354 * number of mounts, so if you had a number of entries 1355 * all referring to a common subdirectory, e.g. 1356 * 1357 * carol seasons:/export/home11/carol 1358 * ted seasons:/export/home11/ted 1359 * alice seasons:/export/home11/alice 1360 * 1361 * then you could tell the automounter to mount a 1362 * common mountpoint which was delimited by the second 1363 * colon: 1364 * 1365 * carol seasons:/export/home11:carol 1366 * ted seasons:/export/home11:ted 1367 * alice seasons:/export/home11:alice 1368 * 1369 * The automounter would mount seasons:/export/home11 1370 * then for any other map entry that referenced the same 1371 * directory it would build a symbolic link that 1372 * appended the remainder of the path after the second 1373 * colon, i.e. once the common subdir was mounted, then 1374 * other directories could be accessed just by link 1375 * building - no further mounts required. 1376 * 1377 * In theory the "mount saving" idea sounded good. In 1378 * practice the saving didn't amount to much and the 1379 * symbolic links confused people because the common 1380 * mountpoint had to have a pseudonym. 1381 * 1382 * To remain backward compatible with the existing 1383 * maps, we interpret a second colon as a slash. 1384 */ 1385 if (getword(subdir+1, qbuff+1, &wlp, &wlq, ':', 1386 sizeof (subdir)) == -1) 1387 return (PARSE_ERROR); 1388 1389 if (*(subdir+1)) 1390 (void) strcat(dirname, subdir); 1391 1392 hl = hostlist; hlq = hostlistq; 1393 1394 host_cnt = 0; 1395 for (;;) { 1396 1397 if (getword(hostname_and_penalty, qbuff, &hl, &hlq, ',', 1398 sizeof (hostname_and_penalty)) == -1) 1399 return (PARSE_ERROR); 1400 if (!*hostname_and_penalty) 1401 break; 1402 1403 host_cnt++; 1404 if (host_cnt > 1) 1405 maybe_url = FALSE; 1406 1407 hn = hostname_and_penalty; 1408 hnq = qbuff; 1409 if (getword(hostname, qbuff1, &hn, &hnq, '(', 1410 sizeof (hostname)) == -1) 1411 return (PARSE_ERROR); 1412 if (hostname[0] == '\0') 1413 goto bad_entry; 1414 1415 if (strcmp(hostname, hostname_and_penalty) == 0) { 1416 penalty = 0; 1417 } else { 1418 maybe_url = FALSE; 1419 hn++; hnq++; 1420 if (getword(pbuff, pbuffq, &hn, &hnq, ')', 1421 sizeof (pbuff)) == -1) 1422 return (PARSE_ERROR); 1423 if (!*pbuff) 1424 penalty = 0; 1425 else 1426 penalty = atoi(pbuff); 1427 } 1428 mfs = (struct mapfs *)malloc(sizeof (*mfs)); 1429 if (mfs == NULL) { 1430 syslog(LOG_ERR, 1431 "parse_nfs: Memory allocation failed"); 1432 return (PARSE_ERROR); 1433 } 1434 (void) memset(mfs, 0, sizeof (*mfs)); 1435 *mfsp = mfs; 1436 mfsp = &mfs->mfs_next; 1437 1438 if (maybe_url == TRUE) { 1439 char *host; 1440 char *path; 1441 char *sport; 1442 1443 host = dirname+2; 1444 path = strchr(host, '/'); 1445 if (path == NULL) { 1446 syslog(LOG_ERR, 1447 "parse_nfs: illegal nfs url syntax: %s", 1448 host); 1449 1450 return (PARSE_ERROR); 1451 } 1452 *path = '\0'; 1453 sport = strchr(host, ':'); 1454 1455 if (sport != NULL && sport < path) { 1456 *sport = '\0'; 1457 mfs->mfs_port = atoi(sport+1); 1458 1459 if (mfs->mfs_port > USHRT_MAX) { 1460 syslog(LOG_ERR, 1461 "parse_nfs: invalid " 1462 "port number (%d) in " 1463 "NFS URL", 1464 mfs->mfs_port); 1465 1466 return (PARSE_ERROR); 1467 } 1468 1469 } 1470 1471 path++; 1472 if (*path == '\0') 1473 path = "."; 1474 1475 mfs->mfs_flags |= MFS_URL; 1476 1477 mfs->mfs_host = strdup(host); 1478 mfs->mfs_dir = strdup(path); 1479 } else { 1480 mfs->mfs_host = strdup(hostname); 1481 mfs->mfs_dir = strdup(dirname); 1482 } 1483 1484 mfs->mfs_penalty = penalty; 1485 if (mfs->mfs_host == NULL || mfs->mfs_dir == NULL) { 1486 syslog(LOG_ERR, 1487 "parse_nfs: Memory allocation failed"); 1488 return (PARSE_ERROR); 1489 } 1490 } 1491 /* 1492 * We check host_cnt to make sure we haven't parsed an entry 1493 * with no host information. 1494 */ 1495 if (host_cnt == 0) { 1496 syslog(LOG_ERR, 1497 "parse_nfs: invalid host specified - bad entry " 1498 "in map %s \"%s\"", 1499 mapname, w); 1500 return (PARSE_ERROR); 1501 } 1502 if (getword(w, wq, lp, lq, ' ', wsize) == -1) 1503 return (PARSE_ERROR); 1504 } 1505 1506 strcpy(fsw, w); 1507 strcpy(fswq, wq); 1508 1509 return (PARSE_OK); 1510 1511 bad_entry: 1512 syslog(LOG_ERR, "parse_nfs: bad entry in map %s \"%s\"", mapname, w); 1513 return (PARSE_ERROR); 1514 } 1515 1516 static int 1517 parse_special(me, w, wq, lp, lq, wsize) 1518 struct mapent *me; 1519 char *w, *wq, **lp, **lq; 1520 int wsize; 1521 { 1522 char devname[MAXPATHLEN + 1], qbuf[MAXPATHLEN + 1]; 1523 char *wlp, *wlq; 1524 struct mapfs *mfs; 1525 1526 wlp = w; 1527 wlq = wq; 1528 if (getword(devname, qbuf, &wlp, &wlq, ' ', sizeof (devname)) == -1) 1529 return (PARSE_ERROR); 1530 if (devname[0] == '\0') 1531 return (PARSE_ERROR); 1532 1533 mfs = (struct mapfs *)malloc(sizeof (struct mapfs)); 1534 if (mfs == NULL) 1535 return (PARSE_ERROR); 1536 (void) memset(mfs, 0, sizeof (*mfs)); 1537 1538 /* 1539 * A device name that begins with a slash could 1540 * be confused with a mountpoint path, hence use 1541 * a colon to escape a device string that begins 1542 * with a slash, e.g. 1543 * 1544 * foo -ro /bar foo:/bar 1545 * and 1546 * foo -ro /dev/sr0 1547 * 1548 * would confuse the parser. The second instance 1549 * must use a colon: 1550 * 1551 * foo -ro :/dev/sr0 1552 */ 1553 mfs->mfs_dir = strdup(&devname[devname[0] == ':']); 1554 if (mfs->mfs_dir == NULL) 1555 return (PARSE_ERROR); 1556 me->map_fs = mfs; 1557 if (getword(w, wq, lp, lq, ' ', wsize) == -1) 1558 return (PARSE_ERROR); 1559 return (0); 1560 } 1561 1562 /* 1563 * get_dir_from_path(char *dir, char **path, int dirsz) 1564 * gets the directory name dir from path for max string of length dirsz. 1565 * A modification of the getword routine. Assumes the delimiter is '/' 1566 * and that excess /'s are redundant. 1567 * Returns PARSE_OK or PARSE_ERROR 1568 */ 1569 static int 1570 get_dir_from_path(char *dir, char **path, int dirsz) 1571 { 1572 char *tmp = dir; 1573 int count = dirsz; 1574 1575 if (dirsz <= 0) { 1576 if (verbose) 1577 syslog(LOG_ERR, 1578 "get_dir_from_path: invalid directory size %d", dirsz); 1579 return (PARSE_ERROR); 1580 } 1581 1582 /* get rid of leading /'s in path */ 1583 while (**path == '/') 1584 (*path)++; 1585 1586 /* now at a word or at the end of path */ 1587 while ((**path) && ((**path) != '/')) { 1588 if (--count <= 0) { 1589 *tmp = '\0'; 1590 syslog(LOG_ERR, 1591 "get_dir_from_path: max pathlength exceeded %d", dirsz); 1592 return (PARSE_ERROR); 1593 } 1594 *dir++ = *(*path)++; 1595 } 1596 1597 *dir = '\0'; 1598 1599 /* get rid of trailing /'s in path */ 1600 while (**path == '/') 1601 (*path)++; 1602 1603 return (PARSE_OK); 1604 } 1605 1606 /* 1607 * alloc_hiernode(hiernode **newnode, char *dirname) 1608 * allocates a new hiernode corresponding to a new directory entry 1609 * in the hierarchical structure, and passes a pointer to it back 1610 * to the calling program. 1611 * Returns PARSE_OK or appropriate error value. 1612 */ 1613 static int 1614 alloc_hiernode(hiernode **newnode, char *dirname) 1615 { 1616 if ((*newnode = (hiernode *)malloc(sizeof (hiernode))) == NULL) { 1617 syslog(LOG_ERR, "alloc_hiernode: Memory allocation failed"); 1618 return (ENOMEM); 1619 } 1620 1621 memset(((char *)*newnode), 0, sizeof (hiernode)); 1622 strcpy(((*newnode)->dirname), dirname); 1623 return (PARSE_OK); 1624 } 1625 1626 /* 1627 * free_hiernode(hiernode *node) 1628 * frees the allocated hiernode given the head of the structure 1629 * recursively calls itself until it frees entire structure. 1630 * Returns nothing. 1631 */ 1632 static void 1633 free_hiernode(hiernode *node) 1634 { 1635 hiernode *currnode = node; 1636 hiernode *prevnode = NULL; 1637 1638 while (currnode != NULL) { 1639 if (currnode->subdir != NULL) 1640 free_hiernode(currnode->subdir); 1641 prevnode = currnode; 1642 currnode = currnode->leveldir; 1643 free((void*)prevnode); 1644 } 1645 } 1646 1647 /* 1648 * free_mapent(struct mapent *) 1649 * free the mapentry and its fields 1650 */ 1651 void 1652 free_mapent(me) 1653 struct mapent *me; 1654 { 1655 struct mapfs *mfs; 1656 struct mapent *m; 1657 1658 while (me) { 1659 while (me->map_fs) { 1660 mfs = me->map_fs; 1661 if (mfs->mfs_host) 1662 free(mfs->mfs_host); 1663 if (mfs->mfs_dir) 1664 free(mfs->mfs_dir); 1665 if (mfs->mfs_args) 1666 free(mfs->mfs_args); 1667 if (mfs->mfs_nconf) 1668 freenetconfigent(mfs->mfs_nconf); 1669 me->map_fs = mfs->mfs_next; 1670 free((char *)mfs); 1671 } 1672 1673 if (me->map_root) 1674 free(me->map_root); 1675 if (me->map_mntpnt) 1676 free(me->map_mntpnt); 1677 if (me->map_mntopts) 1678 free(me->map_mntopts); 1679 if (me->map_fstype) 1680 free(me->map_fstype); 1681 if (me->map_mounter) 1682 free(me->map_mounter); 1683 if (me->map_fsw) 1684 free(me->map_fsw); 1685 if (me->map_fswq) 1686 free(me->map_fswq); 1687 1688 m = me; 1689 me = me->map_next; 1690 free((char *)m); 1691 } 1692 } 1693 1694 /* 1695 * trace_mapents(struct mapent *mapents) 1696 * traces through the mapentry structure and prints it element by element 1697 * returns nothing 1698 */ 1699 static void 1700 trace_mapents(char *s, struct mapent *mapents) 1701 { 1702 struct mapfs *mfs; 1703 struct mapent *me; 1704 1705 trace_prt(1, "\n\t%s\n", s); 1706 for (me = mapents; me; me = me->map_next) { 1707 trace_prt(1, " (%s,%s)\t %s%s -%s\n", 1708 me->map_fstype ? me->map_fstype : "", 1709 me->map_mounter ? me->map_mounter : "", 1710 me->map_root ? me->map_root : "", 1711 me->map_mntpnt ? me->map_mntpnt : "", 1712 me->map_mntopts ? me->map_mntopts : ""); 1713 for (mfs = me->map_fs; mfs; mfs = mfs->mfs_next) 1714 trace_prt(0, "\t\t%s:%s\n", 1715 mfs->mfs_host ? mfs->mfs_host: "", 1716 mfs->mfs_dir ? mfs->mfs_dir : ""); 1717 1718 trace_prt(1, "\tme->map_fsw=%s\n", 1719 me->map_fsw ? me->map_fsw:"", 1720 me->map_fswq ? me->map_fsw:""); 1721 trace_prt(1, "\t mntlevel=%d\t%s\t%s err=%d\n", 1722 me->map_mntlevel, 1723 me->map_modified ? "modify=TRUE":"modify=FALSE", 1724 me->map_faked ? "faked=TRUE":"faked=FALSE", 1725 me->map_err); 1726 } 1727 } 1728 1729 /* 1730 * trace_hierarchy(hiernode *node) 1731 * traces the allocated hiernode given the head of the structure 1732 * recursively calls itself until it traces entire structure. 1733 * the first call made at the root is made with a zero level. 1734 * nodelevel is simply used to print tab and make the tracing clean. 1735 * Returns nothing. 1736 */ 1737 static void 1738 trace_hierarchy(hiernode *node, int nodelevel) 1739 { 1740 hiernode *currnode = node; 1741 int i; 1742 1743 while (currnode != NULL) { 1744 if (currnode->subdir != NULL) { 1745 for (i = 0; i < nodelevel; i++) 1746 trace_prt(0, "\t"); 1747 trace_prt(0, "\t(%s, ", 1748 currnode->dirname ? currnode->dirname :""); 1749 if (currnode->mapent) { 1750 trace_prt(0, "%d, %s)\n", 1751 currnode->mapent->map_mntlevel, 1752 currnode->mapent->map_mntopts ? 1753 currnode->mapent->map_mntopts:""); 1754 } 1755 else 1756 trace_prt(0, " ,)\n"); 1757 nodelevel++; 1758 trace_hierarchy(currnode->subdir, nodelevel); 1759 } else { 1760 for (i = 0; i < nodelevel; i++) 1761 trace_prt(0, "\t"); 1762 trace_prt(0, "\t(%s, ", 1763 currnode->dirname ? currnode->dirname :""); 1764 if (currnode->mapent) { 1765 trace_prt(0, "%d, %s)\n", 1766 currnode->mapent->map_mntlevel, 1767 currnode->mapent->map_mntopts ? 1768 currnode->mapent->map_mntopts:""); 1769 } 1770 else 1771 trace_prt(0, ", )\n"); 1772 } 1773 currnode = currnode->leveldir; 1774 } 1775 } 1776 1777 struct mapent * 1778 do_mapent_hosts(mapopts, host, isdirect) 1779 char *mapopts, *host; 1780 uint_t isdirect; 1781 { 1782 CLIENT *cl; 1783 struct mapent *me, *ms, *mp; 1784 struct mapfs *mfs; 1785 struct exportnode *ex = NULL; 1786 struct exportnode *exlist, *texlist, **texp, *exnext; 1787 struct timeval timeout; 1788 enum clnt_stat clnt_stat; 1789 char name[MAXPATHLEN]; 1790 char entryopts[MAXOPTSLEN]; 1791 char fstype[32], mounter[32]; 1792 int exlen, duplicate; 1793 struct mnttab mb; /* needed for hasmntopt() to get nfs version */ 1794 rpcvers_t nfsvers; /* version in map options, 0 if not there */ 1795 rpcvers_t vers, versmin; /* used to negotiate nfs vers in pingnfs() */ 1796 int retries, delay; 1797 int foundvers; 1798 1799 if (trace > 1) 1800 trace_prt(1, " do_mapent_hosts: host %s\n", host); 1801 1802 /* check for special case: host is me */ 1803 1804 if (self_check(host)) { 1805 ms = (struct mapent *)malloc(sizeof (*ms)); 1806 if (ms == NULL) 1807 goto alloc_failed; 1808 (void) memset((char *)ms, 0, sizeof (*ms)); 1809 (void) strcpy(fstype, MNTTYPE_NFS); 1810 get_opts(mapopts, entryopts, fstype, NULL); 1811 ms->map_mntopts = strdup(entryopts); 1812 if (ms->map_mntopts == NULL) 1813 goto alloc_failed; 1814 ms->map_mounter = strdup(fstype); 1815 if (ms->map_mounter == NULL) 1816 goto alloc_failed; 1817 ms->map_fstype = strdup(MNTTYPE_NFS); 1818 if (ms->map_fstype == NULL) 1819 goto alloc_failed; 1820 1821 if (isdirect) 1822 name[0] = '\0'; 1823 else { 1824 (void) strcpy(name, "/"); 1825 (void) strcat(name, host); 1826 } 1827 ms->map_root = strdup(name); 1828 if (ms->map_root == NULL) 1829 goto alloc_failed; 1830 ms->map_mntpnt = strdup(""); 1831 if (ms->map_mntpnt == NULL) 1832 goto alloc_failed; 1833 mfs = (struct mapfs *)malloc(sizeof (*mfs)); 1834 if (mfs == NULL) 1835 goto alloc_failed; 1836 (void) memset((char *)mfs, 0, sizeof (*mfs)); 1837 ms->map_fs = mfs; 1838 mfs->mfs_host = strdup(host); 1839 if (mfs->mfs_host == NULL) 1840 goto alloc_failed; 1841 mfs->mfs_dir = strdup("/"); 1842 if (mfs->mfs_dir == NULL) 1843 goto alloc_failed; 1844 1845 /* initialize mntlevel and modify */ 1846 ms->map_mntlevel = -1; 1847 ms->map_modified = FALSE; 1848 ms->map_faked = FALSE; 1849 1850 if (trace > 1) 1851 trace_prt(1, 1852 " do_mapent_hosts: self-host %s OK\n", host); 1853 1854 return (ms); 1855 } 1856 1857 /* 1858 * Call pingnfs. Note that we can't have replicated hosts in /net. 1859 * XXX - we would like to avoid duplicating the across the wire calls 1860 * made here in nfsmount(). The pingnfs cache should help avoid it. 1861 */ 1862 mb.mnt_mntopts = mapopts; 1863 foundvers = nopt(&mb, MNTOPT_VERS, (int *)&nfsvers); 1864 if (!foundvers) 1865 nfsvers = 0; 1866 if (set_versrange(nfsvers, &vers, &versmin) != 0) { 1867 syslog(LOG_ERR, "Incorrect NFS version specified for %s", host); 1868 return ((struct mapent *)NULL); 1869 } 1870 if (pingnfs(host, get_retry(mapopts) + 1, &vers, versmin, 0, FALSE, 1871 NULL, NULL) != RPC_SUCCESS) 1872 return ((struct mapent *)NULL); 1873 1874 retries = get_retry(mapopts); 1875 delay = INITDELAY; 1876 retry: 1877 /* get export list of host */ 1878 cl = clnt_create(host, MOUNTPROG, MOUNTVERS, "circuit_v"); 1879 if (cl == NULL) { 1880 cl = clnt_create(host, MOUNTPROG, MOUNTVERS, "datagram_v"); 1881 if (cl == NULL) { 1882 syslog(LOG_ERR, 1883 "do_mapent_hosts: %s %s", host, clnt_spcreateerror("")); 1884 return ((struct mapent *)NULL); 1885 } 1886 1887 } 1888 #ifdef MALLOC_DEBUG 1889 add_alloc("CLNT_HANDLE", cl, 0, __FILE__, __LINE__); 1890 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 1891 __FILE__, __LINE__); 1892 #endif 1893 1894 timeout.tv_usec = 0; 1895 timeout.tv_sec = 25; 1896 if (clnt_stat = clnt_call(cl, MOUNTPROC_EXPORT, xdr_void, 0, 1897 xdr_exports, (caddr_t)&ex, timeout)) { 1898 1899 if (retries-- > 0) { 1900 clnt_destroy(cl); 1901 DELAY(delay); 1902 goto retry; 1903 } 1904 1905 syslog(LOG_ERR, 1906 "do_mapent_hosts: %s: export list: %s", 1907 host, clnt_sperrno(clnt_stat)); 1908 #ifdef MALLOC_DEBUG 1909 drop_alloc("CLNT_HANDLE", cl, __FILE__, __LINE__); 1910 drop_alloc("AUTH_HANDLE", cl->cl_auth, 1911 __FILE__, __LINE__); 1912 #endif 1913 clnt_destroy(cl); 1914 return ((struct mapent *)NULL); 1915 } 1916 1917 #ifdef MALLOC_DEBUG 1918 drop_alloc("CLNT_HANDLE", cl, __FILE__, __LINE__); 1919 drop_alloc("AUTH_HANDLE", cl->cl_auth, 1920 __FILE__, __LINE__); 1921 #endif 1922 clnt_destroy(cl); 1923 1924 if (ex == NULL) { 1925 if (trace > 1) 1926 trace_prt(1, 1927 gettext(" getmapent_hosts: null export list\n")); 1928 return ((struct mapent *)NULL); 1929 } 1930 1931 /* now sort by length of names - to get mount order right */ 1932 exlist = ex; 1933 texlist = NULL; 1934 #ifdef lint 1935 exnext = NULL; 1936 #endif 1937 for (; ex; ex = exnext) { 1938 exnext = ex->ex_next; 1939 exlen = strlen(ex->ex_dir); 1940 duplicate = 0; 1941 for (texp = &texlist; *texp; texp = &((*texp)->ex_next)) { 1942 if (exlen < (int)strlen((*texp)->ex_dir)) 1943 break; 1944 duplicate = (strcmp(ex->ex_dir, (*texp)->ex_dir) == 0); 1945 if (duplicate) { 1946 /* disregard duplicate entry */ 1947 freeex_ent(ex); 1948 break; 1949 } 1950 } 1951 if (!duplicate) { 1952 ex->ex_next = *texp; 1953 *texp = ex; 1954 } 1955 } 1956 exlist = texlist; 1957 1958 (void) strcpy(fstype, MNTTYPE_NFS); 1959 get_opts(mapopts, entryopts, fstype, NULL); 1960 (void) strcpy(mounter, fstype); 1961 1962 /* Now create a mapent from the export list */ 1963 ms = NULL; 1964 me = NULL; 1965 1966 for (ex = exlist; ex; ex = ex->ex_next) { 1967 mp = me; 1968 me = (struct mapent *)malloc(sizeof (*me)); 1969 if (me == NULL) 1970 goto alloc_failed; 1971 (void) memset((char *)me, 0, sizeof (*me)); 1972 1973 if (ms == NULL) 1974 ms = me; 1975 else 1976 mp->map_next = me; 1977 1978 if (isdirect) 1979 name[0] = '\0'; 1980 else { 1981 (void) strcpy(name, "/"); 1982 (void) strcat(name, host); 1983 } 1984 me->map_root = strdup(name); 1985 if (me->map_root == NULL) 1986 goto alloc_failed; 1987 1988 *name = '\0'; 1989 if (strcmp(ex->ex_dir, "/") != 0) { 1990 if (*(ex->ex_dir) != '/') 1991 (void) strcpy(name, "/"); 1992 (void) strcat(name, ex->ex_dir); 1993 } 1994 me->map_mntpnt = strdup(name); 1995 if (me->map_mntpnt == NULL) 1996 goto alloc_failed; 1997 1998 me->map_fstype = strdup(fstype); 1999 if (me->map_fstype == NULL) 2000 goto alloc_failed; 2001 me->map_mounter = strdup(mounter); 2002 if (me->map_mounter == NULL) 2003 goto alloc_failed; 2004 me->map_mntopts = strdup(entryopts); 2005 if (me->map_mntopts == NULL) 2006 goto alloc_failed; 2007 2008 mfs = (struct mapfs *)malloc(sizeof (*mfs)); 2009 if (mfs == NULL) 2010 goto alloc_failed; 2011 (void) memset((char *)mfs, 0, sizeof (*mfs)); 2012 me->map_fs = mfs; 2013 mfs->mfs_host = strdup(host); 2014 if (mfs->mfs_host == NULL) 2015 goto alloc_failed; 2016 mfs->mfs_dir = strdup(ex->ex_dir); 2017 if (mfs->mfs_dir == NULL) 2018 goto alloc_failed; 2019 2020 /* initialize mntlevel and modify values */ 2021 me->map_mntlevel = -1; 2022 me->map_modified = FALSE; 2023 me->map_faked = FALSE; 2024 } 2025 freeex(exlist); 2026 2027 if (trace > 1) 2028 trace_prt(1, " do_mapent_hosts: host %s OK\n", host); 2029 2030 return (ms); 2031 2032 alloc_failed: 2033 syslog(LOG_ERR, "do_mapent_hosts: Memory allocation failed"); 2034 free_mapent(ms); 2035 freeex(exlist); 2036 return ((struct mapent *)NULL); 2037 } 2038 2039 2040 static void 2041 freeex_ent(ex) 2042 struct exportnode *ex; 2043 { 2044 struct groupnode *groups, *tmpgroups; 2045 2046 free(ex->ex_dir); 2047 groups = ex->ex_groups; 2048 while (groups) { 2049 free(groups->gr_name); 2050 tmpgroups = groups->gr_next; 2051 free((char *)groups); 2052 groups = tmpgroups; 2053 } 2054 free((char *)ex); 2055 } 2056 2057 static void 2058 freeex(ex) 2059 struct exportnode *ex; 2060 { 2061 struct exportnode *tmpex; 2062 2063 while (ex) { 2064 tmpex = ex->ex_next; 2065 freeex_ent(ex); 2066 ex = tmpex; 2067 } 2068 } 2069 2070 static const char uatfs_err[] = "submount under fstype=autofs not supported"; 2071 /* 2072 * dump_mapent_err(struct mapent *me, char *key, char *mapname) 2073 * syslog appropriate error in mapentries. 2074 */ 2075 static void dump_mapent_err(struct mapent *me, char *key, char *mapname) 2076 { 2077 switch (me->map_err) { 2078 case MAPENT_NOERR: 2079 if (verbose) 2080 syslog(LOG_ERR, 2081 "map=%s key=%s mntpnt=%s: no error"); 2082 break; 2083 case MAPENT_UATFS: 2084 syslog(LOG_ERR, 2085 "mountpoint %s in map %s key %s not mounted: %s", 2086 me->map_mntpnt, mapname, key, uatfs_err); 2087 break; 2088 default: 2089 if (verbose) 2090 syslog(LOG_ERR, 2091 "map=%s key=%s mntpnt=%s: unknown mapentry error"); 2092 } 2093 } 2094