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 /* 23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 24 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 25 */ 26 27 #include <stdio.h> 28 #include <unistd.h> 29 #include <stdlib.h> 30 #include <ctype.h> 31 #include <syslog.h> 32 #include <string.h> 33 #include <deflt.h> 34 #include <kstat.h> 35 #include <sys/param.h> 36 #include <sys/types.h> 37 #include <sys/time.h> 38 #include <sys/stat.h> 39 #include <sys/wait.h> 40 #include <sys/socket.h> 41 #include <netinet/in.h> 42 #include <signal.h> 43 #include <sys/signal.h> 44 #include <rpc/rpc.h> 45 #include <rpc/pmap_clnt.h> 46 #include <sys/mount.h> 47 #include <sys/mntent.h> 48 #include <sys/mnttab.h> 49 #include <sys/fstyp.h> 50 #include <sys/fsid.h> 51 #include <arpa/inet.h> 52 #include <netdb.h> 53 #include <netconfig.h> 54 #include <netdir.h> 55 #include <errno.h> 56 #define NFSCLIENT 57 #include <nfs/nfs.h> 58 #include <nfs/mount.h> 59 #include <rpcsvc/mount.h> 60 #include <rpc/nettype.h> 61 #include <locale.h> 62 #include <setjmp.h> 63 #include <sys/socket.h> 64 #include <thread.h> 65 #include <limits.h> 66 #include <nss_dbdefs.h> /* for NSS_BUFLEN_HOSTS */ 67 #include <nfs/nfs_sec.h> 68 #include <sys/sockio.h> 69 #include <net/if.h> 70 #include <assert.h> 71 #include <nfs/nfs_clnt.h> 72 #include <rpcsvc/nfs4_prot.h> 73 #include <nfs/nfs4.h> 74 #define NO_RDDIR_CACHE 75 #include "automount.h" 76 #include "replica.h" 77 #include "nfs_subr.h" 78 #include "webnfs.h" 79 #include "nfs_resolve.h" 80 #include <sys/sockio.h> 81 #include <net/if.h> 82 #include <rpcsvc/daemon_utils.h> 83 #include <pwd.h> 84 #include <strings.h> 85 #include <tsol/label.h> 86 #include <zone.h> 87 #include <limits.h> 88 #include <libscf.h> 89 #include <libshare.h> 90 #include "smfcfg.h" 91 92 extern void set_nfsv4_ephemeral_mount_to(void); 93 94 extern char *nfs_get_qop_name(); 95 extern AUTH *nfs_create_ah(); 96 extern enum snego_stat nfs_sec_nego(); 97 98 #define MAXHOSTS 512 99 100 /* 101 * host cache states 102 */ 103 #define NOHOST 0 104 #define GOODHOST 1 105 #define DEADHOST 2 106 107 #define NFS_ARGS_EXTB_secdata(args, secdata) \ 108 { (args).nfs_args_ext = NFS_ARGS_EXTB, \ 109 (args).nfs_ext_u.nfs_extB.secdata = secdata; } 110 111 struct cache_entry { 112 struct cache_entry *cache_next; 113 char *cache_host; 114 time_t cache_time; 115 int cache_state; 116 rpcvers_t cache_reqvers; 117 rpcvers_t cache_outvers; 118 char *cache_proto; 119 }; 120 121 struct mfs_snego_t { 122 int sec_opt; 123 bool_t snego_done; 124 char *nfs_flavor; 125 seconfig_t nfs_sec; 126 }; 127 typedef struct mfs_snego_t mfs_snego_t; 128 129 static struct cache_entry *cache_head = NULL; 130 rwlock_t cache_lock; /* protect the cache chain */ 131 132 static enum nfsstat nfsmount(struct mapfs *, char *, char *, int, uid_t, 133 action_list *); 134 static int is_nfs_port(char *); 135 136 static void netbuf_free(struct netbuf *); 137 static int get_pathconf(CLIENT *, char *, char *, struct pathcnf **, int); 138 static struct mapfs *enum_servers(struct mapent *, char *); 139 static struct mapfs *get_mysubnet_servers(struct mapfs *); 140 static int subnet_test(int af, struct sioc_addrreq *); 141 static struct netbuf *get_addr(char *, rpcprog_t, rpcvers_t, 142 struct netconfig **, char *, ushort_t, struct t_info *); 143 144 static struct netbuf *get_pubfh(char *, rpcvers_t, mfs_snego_t *, 145 struct netconfig **, char *, ushort_t, struct t_info *, caddr_t *, 146 bool_t, char *); 147 148 static int create_homedir(const char *, const char *); 149 150 enum type_of_stuff { 151 SERVER_ADDR = 0, 152 SERVER_PING = 1, 153 SERVER_FH = 2 154 }; 155 156 static void *get_server_netinfo(enum type_of_stuff, char *, rpcprog_t, 157 rpcvers_t, mfs_snego_t *, struct netconfig **, char *, ushort_t, 158 struct t_info *, caddr_t *, bool_t, char *, enum clnt_stat *); 159 static void *get_netconfig_info(enum type_of_stuff, char *, rpcprog_t, 160 rpcvers_t, struct netconfig *, ushort_t, struct t_info *, 161 struct t_bind *, caddr_t *, bool_t, char *, enum clnt_stat *, 162 mfs_snego_t *); 163 static void *get_server_addrorping(char *, rpcprog_t, rpcvers_t, 164 struct netconfig *, ushort_t, struct t_info *, struct t_bind *, 165 caddr_t *, bool_t, char *, enum clnt_stat *, int); 166 static void *get_server_fh(char *, rpcprog_t, rpcvers_t, mfs_snego_t *, 167 struct netconfig *, ushort_t, struct t_info *, struct t_bind *, 168 caddr_t *, bool_t, char *, enum clnt_stat *); 169 170 struct mapfs *add_mfs(struct mapfs *, int, struct mapfs **, struct mapfs **); 171 void free_mfs(struct mapfs *); 172 static void dump_mfs(struct mapfs *, char *, int); 173 static char *dump_distance(struct mapfs *); 174 static void cache_free(struct cache_entry *); 175 static int cache_check(char *, rpcvers_t *, char *); 176 static void cache_enter(char *, rpcvers_t, rpcvers_t, char *, int); 177 void destroy_auth_client_handle(CLIENT *cl); 178 179 #ifdef CACHE_DEBUG 180 static void trace_host_cache(); 181 static void trace_portmap_cache(); 182 #endif /* CACHE_DEBUG */ 183 184 static int rpc_timeout = 20; 185 186 #ifdef CACHE_DEBUG 187 /* 188 * host cache counters. These variables do not need to be protected 189 * by mutex's. They have been added to measure the utility of the 190 * goodhost/deadhost cache in the lazy hierarchical mounting scheme. 191 */ 192 static int host_cache_accesses = 0; 193 static int host_cache_lookups = 0; 194 static int deadhost_cache_hits = 0; 195 static int goodhost_cache_hits = 0; 196 197 /* 198 * portmap cache counters. These variables do not need to be protected 199 * by mutex's. They have been added to measure the utility of the portmap 200 * cache in the lazy hierarchical mounting scheme. 201 */ 202 static int portmap_cache_accesses = 0; 203 static int portmap_cache_lookups = 0; 204 static int portmap_cache_hits = 0; 205 #endif /* CACHE_DEBUG */ 206 207 /* 208 * There are the defaults (range) for the client when determining 209 * which NFS version to use when probing the server (see above). 210 * These will only be used when the vers mount option is not used and 211 * these may be reset if /etc/default/nfs is configured to do so. 212 */ 213 static rpcvers_t vers_max_default = NFS_VERSMAX_DEFAULT; 214 static rpcvers_t vers_min_default = NFS_VERSMIN_DEFAULT; 215 216 /* 217 * list of support services needed 218 */ 219 static char *service_list[] = { STATD, LOCKD, NULL }; 220 static char *service_list_v4[] = { STATD, LOCKD, NFS4CBD, NFSMAPID, NULL }; 221 222 static void read_default_nfs(void); 223 static int is_v4_mount(char *); 224 static void start_nfs4cbd(void); 225 226 int 227 mount_nfs( 228 struct mapent *me, 229 char *mntpnt, 230 char *prevhost, 231 int overlay, 232 uid_t uid, 233 action_list **alpp) 234 { 235 struct mapfs *mfs, *mp; 236 int err = -1; 237 action_list *alp; 238 char *dir; 239 240 241 alp = *alpp; 242 243 read_default_nfs(); 244 245 mfs = enum_servers(me, prevhost); 246 if (mfs == NULL) 247 return (ENOENT); 248 249 /* 250 * Try loopback if we have something on localhost; if nothing 251 * works, we will fall back to NFS 252 */ 253 if (is_nfs_port(me->map_mntopts)) { 254 for (mp = mfs; mp; mp = mp->mfs_next) { 255 if (self_check(mp->mfs_host)) { 256 err = loopbackmount(mp->mfs_dir, 257 mntpnt, me->map_mntopts, overlay); 258 if (err) { 259 mp->mfs_ignore = 1; 260 } else { 261 /* 262 * Free action_list if there 263 * is one as it is not needed. 264 * Make sure to set alpp to null 265 * so caller doesn't try to free it 266 * again. 267 */ 268 if (*alpp) { 269 free(*alpp); 270 *alpp = NULL; 271 } 272 break; 273 } 274 } 275 } 276 } 277 if (err) { 278 dir = strdup(mfs->mfs_dir); 279 err = nfsmount(mfs, mntpnt, me->map_mntopts, 280 overlay, uid, alp); 281 if (err && trace > 1) { 282 trace_prt(1, " Couldn't mount %s:%s, err=%d\n", 283 mfs->mfs_host ? mfs->mfs_host : "", 284 mfs->mfs_dir ? mfs->mfs_dir : dir, err); 285 } 286 free(dir); 287 } 288 free_mfs(mfs); 289 return (err); 290 } 291 292 293 /* 294 * Using the new ioctl SIOCTONLINK to determine if a host is on the same 295 * subnet. Remove the old network, subnet check. 296 */ 297 298 static struct mapfs * 299 get_mysubnet_servers(struct mapfs *mfs_in) 300 { 301 int s; 302 struct mapfs *mfs, *p, *mfs_head = NULL, *mfs_tail = NULL; 303 304 struct netconfig *nconf; 305 NCONF_HANDLE *nc = NULL; 306 struct nd_hostserv hs; 307 struct nd_addrlist *retaddrs; 308 struct netbuf *nb; 309 struct sioc_addrreq areq; 310 int res; 311 int af; 312 int i; 313 int sa_size; 314 315 hs.h_serv = "rpcbind"; 316 317 for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) { 318 nc = setnetconfig(); 319 320 while (nconf = getnetconfig(nc)) { 321 322 /* 323 * Care about INET family only. proto_done flag 324 * indicates if we have already covered this 325 * protocol family. If so skip it 326 */ 327 if (((strcmp(nconf->nc_protofmly, NC_INET6) == 0) || 328 (strcmp(nconf->nc_protofmly, NC_INET) == 0)) && 329 (nconf->nc_semantics == NC_TPI_CLTS)) { 330 } else 331 continue; 332 333 hs.h_host = mfs->mfs_host; 334 335 if (netdir_getbyname(nconf, &hs, &retaddrs) != ND_OK) 336 continue; 337 338 /* 339 * For each host address see if it's on our 340 * local subnet. 341 */ 342 343 if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) 344 af = AF_INET6; 345 else 346 af = AF_INET; 347 nb = retaddrs->n_addrs; 348 for (i = 0; i < retaddrs->n_cnt; i++, nb++) { 349 memset(&areq.sa_addr, 0, sizeof (areq.sa_addr)); 350 memcpy(&areq.sa_addr, nb->buf, MIN(nb->len, 351 sizeof (areq.sa_addr))); 352 if (res = subnet_test(af, &areq)) { 353 p = add_mfs(mfs, DIST_MYNET, 354 &mfs_head, &mfs_tail); 355 if (!p) { 356 netdir_free(retaddrs, 357 ND_ADDRLIST); 358 endnetconfig(nc); 359 return (NULL); 360 } 361 break; 362 } 363 } /* end of every host */ 364 if (trace > 2) { 365 trace_prt(1, "get_mysubnet_servers: host=%s " 366 "netid=%s res=%s\n", mfs->mfs_host, 367 nconf->nc_netid, res == 1?"SUC":"FAIL"); 368 } 369 370 netdir_free(retaddrs, ND_ADDRLIST); 371 } /* end of while */ 372 373 endnetconfig(nc); 374 375 } /* end of every map */ 376 377 return (mfs_head); 378 379 } 380 381 int 382 subnet_test(int af, struct sioc_addrreq *areq) 383 { 384 int s; 385 386 if ((s = socket(af, SOCK_DGRAM, 0)) < 0) { 387 return (0); 388 } 389 390 areq->sa_res = -1; 391 392 if (ioctl(s, SIOCTONLINK, (caddr_t)areq) < 0) { 393 syslog(LOG_ERR, "subnet_test:SIOCTONLINK failed"); 394 return (0); 395 } 396 close(s); 397 if (areq->sa_res == 1) 398 return (1); 399 else 400 return (0); 401 402 403 } 404 405 /* 406 * ping a bunch of hosts at once and sort by who responds first 407 */ 408 static struct mapfs * 409 sort_servers(struct mapfs *mfs_in, int timeout) 410 { 411 struct mapfs *m1 = NULL; 412 enum clnt_stat clnt_stat; 413 414 if (!mfs_in) 415 return (NULL); 416 417 clnt_stat = nfs_cast(mfs_in, &m1, timeout); 418 419 if (!m1) { 420 char buff[2048] = {'\0'}; 421 422 for (m1 = mfs_in; m1; m1 = m1->mfs_next) { 423 (void) strcat(buff, m1->mfs_host); 424 if (m1->mfs_next) 425 (void) strcat(buff, ","); 426 } 427 428 syslog(LOG_ERR, "servers %s not responding: %s", 429 buff, clnt_sperrno(clnt_stat)); 430 } 431 432 return (m1); 433 } 434 435 /* 436 * Add a mapfs entry to the list described by *mfs_head and *mfs_tail, 437 * provided it is not marked "ignored" and isn't a dupe of ones we've 438 * already seen. 439 */ 440 struct mapfs * 441 add_mfs(struct mapfs *mfs, int distance, struct mapfs **mfs_head, 442 struct mapfs **mfs_tail) 443 { 444 struct mapfs *tmp, *new; 445 446 for (tmp = *mfs_head; tmp; tmp = tmp->mfs_next) 447 if ((strcmp(tmp->mfs_host, mfs->mfs_host) == 0 && 448 strcmp(tmp->mfs_dir, mfs->mfs_dir) == 0) || 449 mfs->mfs_ignore) 450 return (*mfs_head); 451 new = (struct mapfs *)malloc(sizeof (struct mapfs)); 452 if (!new) { 453 syslog(LOG_ERR, "Memory allocation failed: %m"); 454 return (NULL); 455 } 456 bcopy(mfs, new, sizeof (struct mapfs)); 457 new->mfs_next = NULL; 458 if (distance) 459 new->mfs_distance = distance; 460 if (!*mfs_head) 461 *mfs_tail = *mfs_head = new; 462 else { 463 (*mfs_tail)->mfs_next = new; 464 *mfs_tail = new; 465 } 466 return (*mfs_head); 467 } 468 469 static void 470 dump_mfs(struct mapfs *mfs, char *message, int level) 471 { 472 struct mapfs *m1; 473 474 if (trace <= level) 475 return; 476 477 trace_prt(1, "%s", message); 478 if (!mfs) { 479 trace_prt(0, "mfs is null\n"); 480 return; 481 } 482 for (m1 = mfs; m1; m1 = m1->mfs_next) 483 trace_prt(0, "%s[%s] ", m1->mfs_host, dump_distance(m1)); 484 trace_prt(0, "\n"); 485 } 486 487 static char * 488 dump_distance(struct mapfs *mfs) 489 { 490 switch (mfs->mfs_distance) { 491 case 0: return ("zero"); 492 case DIST_SELF: return ("self"); 493 case DIST_MYSUB: return ("mysub"); 494 case DIST_MYNET: return ("mynet"); 495 case DIST_OTHER: return ("other"); 496 default: return ("other"); 497 } 498 } 499 500 /* 501 * Walk linked list "raw", building a new list consisting of members 502 * NOT found in list "filter", returning the result. 503 */ 504 static struct mapfs * 505 filter_mfs(struct mapfs *raw, struct mapfs *filter) 506 { 507 struct mapfs *mfs, *p, *mfs_head = NULL, *mfs_tail = NULL; 508 int skip; 509 510 if (!raw) 511 return (NULL); 512 for (mfs = raw; mfs; mfs = mfs->mfs_next) { 513 for (skip = 0, p = filter; p; p = p->mfs_next) { 514 if (strcmp(p->mfs_host, mfs->mfs_host) == 0 && 515 strcmp(p->mfs_dir, mfs->mfs_dir) == 0) { 516 skip = 1; 517 break; 518 } 519 } 520 if (skip) 521 continue; 522 p = add_mfs(mfs, 0, &mfs_head, &mfs_tail); 523 if (!p) 524 return (NULL); 525 } 526 return (mfs_head); 527 } 528 529 /* 530 * Walk a linked list of mapfs structs, freeing each member. 531 */ 532 void 533 free_mfs(struct mapfs *mfs) 534 { 535 struct mapfs *tmp; 536 537 while (mfs) { 538 tmp = mfs->mfs_next; 539 free(mfs); 540 mfs = tmp; 541 } 542 } 543 544 /* 545 * New code for NFS client failover: we need to carry and sort 546 * lists of server possibilities rather than return a single 547 * entry. It preserves previous behaviour of sorting first by 548 * locality (loopback-or-preferred/subnet/net/other) and then 549 * by ping times. We'll short-circuit this process when we 550 * have ENOUGH or more entries. 551 */ 552 static struct mapfs * 553 enum_servers(struct mapent *me, char *preferred) 554 { 555 struct mapfs *p, *m1, *m2, *mfs_head = NULL, *mfs_tail = NULL; 556 557 /* 558 * Short-circuit for simple cases. 559 */ 560 if (!me->map_fs->mfs_next) { 561 p = add_mfs(me->map_fs, DIST_OTHER, &mfs_head, &mfs_tail); 562 if (!p) 563 return (NULL); 564 return (mfs_head); 565 } 566 567 dump_mfs(me->map_fs, " enum_servers: mapent: ", 2); 568 569 /* 570 * get addresses & see if any are myself 571 * or were mounted from previously in a 572 * hierarchical mount. 573 */ 574 if (trace > 2) 575 trace_prt(1, " enum_servers: looking for pref/self\n"); 576 for (m1 = me->map_fs; m1; m1 = m1->mfs_next) { 577 if (m1->mfs_ignore) 578 continue; 579 if (self_check(m1->mfs_host) || 580 strcmp(m1->mfs_host, preferred) == 0) { 581 p = add_mfs(m1, DIST_SELF, &mfs_head, &mfs_tail); 582 if (!p) 583 return (NULL); 584 } 585 } 586 if (trace > 2 && m1) 587 trace_prt(1, " enum_servers: pref/self found, %s\n", 588 m1->mfs_host); 589 590 /* 591 * look for entries on this subnet 592 */ 593 dump_mfs(m1, " enum_servers: input of get_mysubnet_servers: ", 2); 594 m1 = get_mysubnet_servers(me->map_fs); 595 dump_mfs(m1, " enum_servers: output of get_mysubnet_servers: ", 3); 596 if (m1 && m1->mfs_next) { 597 m2 = sort_servers(m1, rpc_timeout / 2); 598 dump_mfs(m2, " enum_servers: output of sort_servers: ", 3); 599 free_mfs(m1); 600 m1 = m2; 601 } 602 603 for (m2 = m1; m2; m2 = m2->mfs_next) { 604 p = add_mfs(m2, 0, &mfs_head, &mfs_tail); 605 if (!p) 606 return (NULL); 607 } 608 if (m1) 609 free_mfs(m1); 610 611 /* 612 * add the rest of the entries at the end 613 */ 614 m1 = filter_mfs(me->map_fs, mfs_head); 615 dump_mfs(m1, " enum_servers: etc: output of filter_mfs: ", 3); 616 m2 = sort_servers(m1, rpc_timeout / 2); 617 dump_mfs(m2, " enum_servers: etc: output of sort_servers: ", 3); 618 if (m1) 619 free_mfs(m1); 620 m1 = m2; 621 for (m2 = m1; m2; m2 = m2->mfs_next) { 622 p = add_mfs(m2, DIST_OTHER, &mfs_head, &mfs_tail); 623 if (!p) 624 return (NULL); 625 } 626 if (m1) 627 free_mfs(m1); 628 629 done: 630 dump_mfs(mfs_head, " enum_servers: output: ", 1); 631 return (mfs_head); 632 } 633 634 static enum nfsstat 635 nfsmount( 636 struct mapfs *mfs_in, 637 char *mntpnt, char *opts, 638 int overlay, 639 uid_t uid, 640 action_list *alp) 641 { 642 CLIENT *cl; 643 char remname[MAXPATHLEN], *mnttabtext = NULL; 644 char mopts[MAX_MNTOPT_STR]; 645 char netname[MAXNETNAMELEN+1]; 646 char *mntopts = NULL; 647 int mnttabcnt = 0; 648 int loglevel; 649 struct mnttab m; 650 struct nfs_args *argp = NULL, *head = NULL, *tail = NULL, 651 *prevhead, *prevtail; 652 int flags; 653 struct fhstatus fhs; 654 struct timeval timeout; 655 enum clnt_stat rpc_stat; 656 enum nfsstat status; 657 struct stat stbuf; 658 struct netconfig *nconf; 659 rpcvers_t vers, versmin; /* used to negotiate nfs version in pingnfs */ 660 /* and mount version with mountd */ 661 rpcvers_t outvers; /* final version to be used during mount() */ 662 rpcvers_t nfsvers; /* version in map options, 0 if not there */ 663 rpcvers_t mountversmax; /* tracks the max mountvers during retries */ 664 665 /* used to negotiate nfs version using webnfs */ 666 rpcvers_t pubvers, pubversmin, pubversmax; 667 int posix; 668 struct nd_addrlist *retaddrs; 669 struct mountres3 res3; 670 nfs_fh3 fh3; 671 char *fstype; 672 int count, i; 673 char scerror_msg[MAXMSGLEN]; 674 int *auths; 675 int delay; 676 int retries; 677 char *nfs_proto = NULL; 678 uint_t nfs_port = 0; 679 char *p, *host, *rhost, *dir; 680 struct mapfs *mfs = NULL; 681 int error, last_error = 0; 682 int replicated; 683 int entries = 0; 684 int v2cnt = 0, v3cnt = 0, v4cnt = 0; 685 int v2near = 0, v3near = 0, v4near = 0; 686 int skipentry = 0; 687 char *nfs_flavor; 688 seconfig_t nfs_sec; 689 int sec_opt, scerror; 690 struct sec_data *secdata; 691 int secflags; 692 struct netbuf *syncaddr; 693 bool_t use_pubfh; 694 ushort_t thisport; 695 int got_val; 696 mfs_snego_t mfssnego_init, mfssnego; 697 698 dump_mfs(mfs_in, " nfsmount: input: ", 2); 699 replicated = (mfs_in->mfs_next != NULL); 700 m.mnt_mntopts = opts; 701 if (replicated && hasmntopt(&m, MNTOPT_SOFT)) { 702 if (verbose) 703 syslog(LOG_WARNING, 704 "mount on %s is soft and will not be replicated.", mntpnt); 705 replicated = 0; 706 } 707 if (replicated && !hasmntopt(&m, MNTOPT_RO)) { 708 if (verbose) 709 syslog(LOG_WARNING, 710 "mount on %s is not read-only and will not be replicated.", 711 mntpnt); 712 replicated = 0; 713 } 714 if (replicated) 715 loglevel = LOG_WARNING; 716 else 717 loglevel = LOG_ERR; 718 719 if (trace > 1) { 720 if (replicated) 721 trace_prt(1, " nfsmount: replicated mount on %s %s:\n", 722 mntpnt, opts); 723 else 724 trace_prt(1, " nfsmount: standard mount on %s %s:\n", 725 mntpnt, opts); 726 for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) 727 trace_prt(1, " %s:%s\n", 728 mfs->mfs_host, mfs->mfs_dir); 729 } 730 731 /* 732 * Make sure mountpoint is safe to mount on 733 */ 734 if (lstat(mntpnt, &stbuf) < 0) { 735 syslog(LOG_ERR, "Couldn't stat %s: %m", mntpnt); 736 return (NFSERR_NOENT); 737 } 738 739 /* 740 * Get protocol specified in options list, if any. 741 */ 742 if ((str_opt(&m, "proto", &nfs_proto)) == -1) { 743 return (NFSERR_NOENT); 744 } 745 746 /* 747 * Get port specified in options list, if any. 748 */ 749 got_val = nopt(&m, MNTOPT_PORT, (int *)&nfs_port); 750 if (!got_val) 751 nfs_port = 0; /* "unspecified" */ 752 if (nfs_port > USHRT_MAX) { 753 syslog(LOG_ERR, "%s: invalid port number %d", mntpnt, nfs_port); 754 return (NFSERR_NOENT); 755 } 756 757 /* 758 * Set mount(2) flags here, outside of the loop. 759 */ 760 flags = MS_OPTIONSTR; 761 flags |= (hasmntopt(&m, MNTOPT_RO) == NULL) ? 0 : MS_RDONLY; 762 flags |= (hasmntopt(&m, MNTOPT_NOSUID) == NULL) ? 0 : MS_NOSUID; 763 flags |= overlay ? MS_OVERLAY : 0; 764 if (mntpnt[strlen(mntpnt) - 1] != ' ') 765 /* direct mount point without offsets */ 766 flags |= MS_OVERLAY; 767 768 use_pubfh = (hasmntopt(&m, MNTOPT_PUBLIC) == NULL) ? FALSE : TRUE; 769 770 (void) memset(&mfssnego_init, 0, sizeof (mfs_snego_t)); 771 if (hasmntopt(&m, MNTOPT_SECURE) != NULL) { 772 if (++mfssnego_init.sec_opt > 1) { 773 syslog(loglevel, 774 "conflicting security options"); 775 return (NFSERR_IO); 776 } 777 if (nfs_getseconfig_byname("dh", &mfssnego_init.nfs_sec)) { 778 syslog(loglevel, 779 "error getting dh information from %s", 780 NFSSEC_CONF); 781 return (NFSERR_IO); 782 } 783 } 784 785 if (hasmntopt(&m, MNTOPT_SEC) != NULL) { 786 if ((str_opt(&m, MNTOPT_SEC, 787 &mfssnego_init.nfs_flavor)) == -1) { 788 syslog(LOG_ERR, "nfsmount: no memory"); 789 return (NFSERR_IO); 790 } 791 } 792 793 if (mfssnego_init.nfs_flavor) { 794 if (++mfssnego_init.sec_opt > 1) { 795 syslog(loglevel, 796 "conflicting security options"); 797 free(mfssnego_init.nfs_flavor); 798 return (NFSERR_IO); 799 } 800 if (nfs_getseconfig_byname(mfssnego_init.nfs_flavor, 801 &mfssnego_init.nfs_sec)) { 802 syslog(loglevel, 803 "error getting %s information from %s", 804 mfssnego_init.nfs_flavor, NFSSEC_CONF); 805 free(mfssnego_init.nfs_flavor); 806 return (NFSERR_IO); 807 } 808 free(mfssnego_init.nfs_flavor); 809 } 810 811 nextentry: 812 skipentry = 0; 813 814 got_val = nopt(&m, MNTOPT_VERS, (int *)&nfsvers); 815 if (!got_val) 816 nfsvers = 0; /* "unspecified" */ 817 if (set_versrange(nfsvers, &vers, &versmin) != 0) { 818 syslog(LOG_ERR, "Incorrect NFS version specified for %s", 819 mntpnt); 820 last_error = NFSERR_NOENT; 821 goto ret; 822 } 823 824 if (nfsvers != 0) { 825 pubversmax = pubversmin = nfsvers; 826 } else { 827 pubversmax = vers; 828 pubversmin = versmin; 829 } 830 831 /* 832 * Walk the whole list, pinging and collecting version 833 * info so that we can make sure the mount will be 834 * homogeneous with respect to version. 835 * 836 * If we have a version preference, this is easy; we'll 837 * just reject anything that doesn't match. 838 * 839 * If not, we want to try to provide the best compromise 840 * that considers proximity, preference for a higher version, 841 * sorted order, and number of replicas. We will count 842 * the number of V2 and V3 replicas and also the number 843 * which are "near", i.e. the localhost or on the same 844 * subnet. 845 */ 846 for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) { 847 848 849 if (mfs->mfs_ignore) 850 continue; 851 852 /* 853 * If the host is '[a:d:d:r:e:s:s'], 854 * only use 'a:d:d:r:e:s:s' for communication 855 */ 856 host = strdup(mfs->mfs_host); 857 if (host == NULL) { 858 syslog(LOG_ERR, "nfsmount: no memory"); 859 last_error = NFSERR_IO; 860 goto out; 861 } 862 unbracket(&host); 863 864 (void) memcpy(&mfssnego, &mfssnego_init, sizeof (mfs_snego_t)); 865 866 if (use_pubfh == TRUE || mfs->mfs_flags & MFS_URL) { 867 char *path; 868 869 if (nfs_port != 0 && mfs->mfs_port != 0 && 870 nfs_port != mfs->mfs_port) { 871 872 syslog(LOG_ERR, "nfsmount: port (%u) in nfs URL" 873 " not the same as port (%d) in port " 874 "option\n", mfs->mfs_port, nfs_port); 875 last_error = NFSERR_IO; 876 goto out; 877 878 } else if (nfs_port != 0) 879 thisport = nfs_port; 880 else 881 thisport = mfs->mfs_port; 882 883 dir = mfs->mfs_dir; 884 885 if ((mfs->mfs_flags & MFS_URL) == 0) { 886 path = malloc(strlen(dir) + 2); 887 if (path == NULL) { 888 syslog(LOG_ERR, "nfsmount: no memory"); 889 last_error = NFSERR_IO; 890 goto out; 891 } 892 path[0] = (char)WNL_NATIVEPATH; 893 (void) strcpy(&path[1], dir); 894 } else { 895 path = dir; 896 } 897 898 argp = (struct nfs_args *) 899 malloc(sizeof (struct nfs_args)); 900 901 if (!argp) { 902 if (path != dir) 903 free(path); 904 syslog(LOG_ERR, "nfsmount: no memory"); 905 last_error = NFSERR_IO; 906 goto out; 907 } 908 (void) memset(argp, 0, sizeof (*argp)); 909 910 /* 911 * RDMA support 912 * By now Mount argument struct has been allocated, 913 * either a pub_fh path will be taken or the regular 914 * one. So here if a protocol was specified and it 915 * was not rdma we let it be, else we set DO_RDMA. 916 * If no proto was there we advise on trying RDMA. 917 */ 918 if (nfs_proto) { 919 if (strcmp(nfs_proto, "rdma") == 0) { 920 free(nfs_proto); 921 nfs_proto = NULL; 922 argp->flags |= NFSMNT_DORDMA; 923 } 924 } else 925 argp->flags |= NFSMNT_TRYRDMA; 926 927 for (pubvers = pubversmax; pubvers >= pubversmin; 928 pubvers--) { 929 930 nconf = NULL; 931 argp->addr = get_pubfh(host, pubvers, &mfssnego, 932 &nconf, nfs_proto, thisport, NULL, 933 &argp->fh, TRUE, path); 934 935 if (argp->addr != NULL) 936 break; 937 938 if (nconf != NULL) 939 freenetconfigent(nconf); 940 } 941 942 if (path != dir) 943 free(path); 944 945 if (argp->addr != NULL) { 946 947 /* 948 * The use of llock option for NFSv4 949 * mounts is not required since file 950 * locking is included within the protocol 951 */ 952 if (pubvers != NFS_V4) 953 argp->flags |= NFSMNT_LLOCK; 954 955 argp->flags |= NFSMNT_PUBLIC; 956 957 vers = pubvers; 958 mfs->mfs_args = argp; 959 mfs->mfs_version = pubvers; 960 mfs->mfs_nconf = nconf; 961 mfs->mfs_flags |= MFS_FH_VIA_WEBNFS; 962 963 } else { 964 free(argp); 965 966 /* 967 * If -public was specified, give up 968 * on this entry now. 969 */ 970 if (use_pubfh == TRUE) { 971 syslog(loglevel, 972 "%s: no public file handle support", 973 host); 974 last_error = NFSERR_NOENT; 975 mfs->mfs_ignore = 1; 976 continue; 977 } 978 979 /* 980 * Back off to a conventional mount. 981 * 982 * URL's can contain escape characters. Get 983 * rid of them. 984 */ 985 path = malloc(strlen(dir) + 2); 986 987 if (path == NULL) { 988 syslog(LOG_ERR, "nfsmount: no memory"); 989 last_error = NFSERR_IO; 990 goto out; 991 } 992 993 strcpy(path, dir); 994 URLparse(path); 995 mfs->mfs_dir = path; 996 mfs->mfs_flags |= MFS_ALLOC_DIR; 997 mfs->mfs_flags &= ~MFS_URL; 998 } 999 } 1000 1001 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0) { 1002 i = pingnfs(host, get_retry(opts) + 1, &vers, versmin, 1003 0, FALSE, NULL, nfs_proto); 1004 if (i != RPC_SUCCESS) { 1005 if (i == RPC_PROGVERSMISMATCH) { 1006 syslog(loglevel, "server %s: NFS " 1007 "protocol version mismatch", 1008 host); 1009 } else { 1010 syslog(loglevel, "server %s not " 1011 "responding", host); 1012 } 1013 mfs->mfs_ignore = 1; 1014 last_error = NFSERR_NOENT; 1015 continue; 1016 } 1017 if (nfsvers != 0 && nfsvers != vers) { 1018 if (nfs_proto == NULL) 1019 syslog(loglevel, 1020 "NFS version %d " 1021 "not supported by %s", 1022 nfsvers, host); 1023 else 1024 syslog(loglevel, 1025 "NFS version %d " 1026 "with proto %s " 1027 "not supported by %s", 1028 nfsvers, nfs_proto, host); 1029 mfs->mfs_ignore = 1; 1030 last_error = NFSERR_NOENT; 1031 continue; 1032 } 1033 } 1034 1035 free(host); 1036 1037 switch (vers) { 1038 case NFS_V4: v4cnt++; break; 1039 case NFS_V3: v3cnt++; break; 1040 case NFS_VERSION: v2cnt++; break; 1041 default: break; 1042 } 1043 1044 /* 1045 * It's not clear how useful this stuff is if 1046 * we are using webnfs across the internet, but it 1047 * can't hurt. 1048 */ 1049 if (mfs->mfs_distance && 1050 mfs->mfs_distance <= DIST_MYSUB) { 1051 switch (vers) { 1052 case NFS_V4: v4near++; break; 1053 case NFS_V3: v3near++; break; 1054 case NFS_VERSION: v2near++; break; 1055 default: break; 1056 } 1057 } 1058 1059 /* 1060 * If the mount is not replicated, we don't want to 1061 * ping every entry, so we'll stop here. This means 1062 * that we may have to go back to "nextentry" above 1063 * to consider another entry if we can't get 1064 * all the way to mount(2) with this one. 1065 */ 1066 if (!replicated) 1067 break; 1068 1069 } 1070 1071 if (nfsvers == 0) { 1072 /* 1073 * Choose the NFS version. 1074 * We prefer higher versions, but will choose a one- 1075 * version downgrade in service if we can use a local 1076 * network interface and avoid a router. 1077 */ 1078 if (v4cnt && v4cnt >= v3cnt && (v4near || !v3near)) 1079 nfsvers = NFS_V4; 1080 else if (v3cnt && v3cnt >= v2cnt && (v3near || !v2near)) 1081 nfsvers = NFS_V3; 1082 else 1083 nfsvers = NFS_VERSION; 1084 if (trace > 2) 1085 trace_prt(1, 1086 " nfsmount: v4=%d[%d]v3=%d[%d],v2=%d[%d] => v%d.\n", 1087 v4cnt, v4near, v3cnt, v3near, 1088 v2cnt, v2near, nfsvers); 1089 } 1090 1091 /* 1092 * Since we don't support different NFS versions in replicated 1093 * mounts, set fstype now. 1094 * Also take the opportunity to set 1095 * the mount protocol version as appropriate. 1096 */ 1097 switch (nfsvers) { 1098 case NFS_V4: 1099 fstype = MNTTYPE_NFS4; 1100 break; 1101 case NFS_V3: 1102 fstype = MNTTYPE_NFS3; 1103 if (use_pubfh == FALSE) { 1104 mountversmax = MOUNTVERS3; 1105 versmin = MOUNTVERS3; 1106 } 1107 break; 1108 case NFS_VERSION: 1109 fstype = MNTTYPE_NFS; 1110 if (use_pubfh == FALSE) { 1111 mountversmax = MOUNTVERS_POSIX; 1112 versmin = MOUNTVERS; 1113 } 1114 break; 1115 } 1116 1117 /* 1118 * Our goal here is to evaluate each of several possible 1119 * replicas and try to come up with a list we can hand 1120 * to mount(2). If we don't have a valid "head" at the 1121 * end of this process, it means we have rejected all 1122 * potential server:/path tuples. We will fail quietly 1123 * in front of mount(2), and will have printed errors 1124 * where we found them. 1125 * XXX - do option work outside loop w careful design 1126 * XXX - use macro for error condition free handling 1127 */ 1128 for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) { 1129 1130 /* 1131 * Initialize retry and delay values on a per-server basis. 1132 */ 1133 retries = get_retry(opts); 1134 delay = INITDELAY; 1135 retry: 1136 if (mfs->mfs_ignore) 1137 continue; 1138 1139 /* 1140 * If we don't have a fh yet, and if this is not a replicated 1141 * mount, we haven't done a pingnfs() on the next entry, 1142 * so we don't know if the next entry is up or if it 1143 * supports an NFS version we like. So if we had a problem 1144 * with an entry, we need to go back and run through some new 1145 * code. 1146 */ 1147 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0 && 1148 !replicated && skipentry) 1149 goto nextentry; 1150 1151 vers = mountversmax; 1152 host = mfs->mfs_host; 1153 dir = mfs->mfs_dir; 1154 1155 /* 1156 * Remember the possible '[a:d:d:r:e:s:s]' as the address to be 1157 * later passed to mount(2) and used in the mnttab line, but 1158 * only use 'a:d:d:r:e:s:s' for communication 1159 */ 1160 rhost = strdup(host); 1161 if (rhost == NULL) { 1162 syslog(LOG_ERR, "nfsmount: no memory"); 1163 last_error = NFSERR_IO; 1164 goto out; 1165 } 1166 unbracket(&host); 1167 1168 (void) sprintf(remname, "%s:%s", rhost, dir); 1169 if (trace > 4 && replicated) 1170 trace_prt(1, " nfsmount: examining %s\n", remname); 1171 1172 if (mfs->mfs_args == NULL) { 1173 1174 /* 1175 * Allocate nfs_args structure 1176 */ 1177 argp = (struct nfs_args *) 1178 malloc(sizeof (struct nfs_args)); 1179 1180 if (!argp) { 1181 syslog(LOG_ERR, "nfsmount: no memory"); 1182 last_error = NFSERR_IO; 1183 goto out; 1184 } 1185 1186 (void) memset(argp, 0, sizeof (*argp)); 1187 1188 /* 1189 * RDMA support 1190 * By now Mount argument struct has been allocated, 1191 * either a pub_fh path will be taken or the regular 1192 * one. So here if a protocol was specified and it 1193 * was not rdma we let it be, else we set DO_RDMA. 1194 * If no proto was there we advise on trying RDMA. 1195 */ 1196 if (nfs_proto) { 1197 if (strcmp(nfs_proto, "rdma") == 0) { 1198 free(nfs_proto); 1199 nfs_proto = NULL; 1200 argp->flags |= NFSMNT_DORDMA; 1201 } 1202 } else 1203 argp->flags |= NFSMNT_TRYRDMA; 1204 } else { 1205 argp = mfs->mfs_args; 1206 mfs->mfs_args = NULL; 1207 1208 /* 1209 * Skip entry if we already have file handle but the 1210 * NFS version is wrong. 1211 */ 1212 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) && 1213 mfs->mfs_version != nfsvers) { 1214 1215 free(argp); 1216 skipentry = 1; 1217 mfs->mfs_ignore = 1; 1218 continue; 1219 } 1220 } 1221 1222 prevhead = head; 1223 prevtail = tail; 1224 if (!head) 1225 head = tail = argp; 1226 else 1227 tail = tail->nfs_ext_u.nfs_extB.next = argp; 1228 1229 /* 1230 * WebNFS and NFSv4 behave similarly in that they 1231 * don't use the mount protocol. Therefore, avoid 1232 * mount protocol like things when version 4 is being 1233 * used. 1234 */ 1235 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0 && 1236 nfsvers != NFS_V4) { 1237 timeout.tv_usec = 0; 1238 timeout.tv_sec = rpc_timeout; 1239 rpc_stat = RPC_TIMEDOUT; 1240 1241 /* Create the client handle. */ 1242 1243 if (trace > 1) { 1244 trace_prt(1, 1245 " nfsmount: Get mount version: request " 1246 "vers=%d min=%d\n", vers, versmin); 1247 } 1248 1249 while ((cl = clnt_create_vers(host, MOUNTPROG, &outvers, 1250 versmin, vers, "udp")) == NULL) { 1251 if (trace > 4) { 1252 trace_prt(1, 1253 " nfsmount: Can't get mount " 1254 "version: rpcerr=%d\n", 1255 rpc_createerr.cf_stat); 1256 } 1257 if (rpc_createerr.cf_stat == RPC_UNKNOWNHOST || 1258 rpc_createerr.cf_stat == RPC_TIMEDOUT) 1259 break; 1260 1261 /* 1262 * backoff and return lower version to retry the ping. 1263 * XXX we should be more careful and handle 1264 * RPC_PROGVERSMISMATCH here, because that error 1265 * is handled in clnt_create_vers(). It's not done to 1266 * stay in sync with the nfs mount command. 1267 */ 1268 vers--; 1269 if (vers < versmin) 1270 break; 1271 if (trace > 4) { 1272 trace_prt(1, 1273 " nfsmount: Try version=%d\n", 1274 vers); 1275 } 1276 } 1277 1278 if (cl == NULL) { 1279 free(argp); 1280 head = prevhead; 1281 tail = prevtail; 1282 if (tail) 1283 tail->nfs_ext_u.nfs_extB.next = NULL; 1284 last_error = NFSERR_NOENT; 1285 1286 if (rpc_createerr.cf_stat != RPC_UNKNOWNHOST && 1287 rpc_createerr.cf_stat != 1288 RPC_PROGVERSMISMATCH && 1289 retries-- > 0) { 1290 DELAY(delay); 1291 goto retry; 1292 } 1293 1294 syslog(loglevel, "%s %s", host, 1295 clnt_spcreateerror( 1296 "server not responding")); 1297 skipentry = 1; 1298 mfs->mfs_ignore = 1; 1299 continue; 1300 } 1301 if (trace > 1) { 1302 trace_prt(1, 1303 " nfsmount: mount version=%d\n", outvers); 1304 } 1305 #ifdef MALLOC_DEBUG 1306 add_alloc("CLNT_HANDLE", cl, 0, __FILE__, __LINE__); 1307 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 1308 __FILE__, __LINE__); 1309 #endif 1310 1311 if (__clnt_bindresvport(cl) < 0) { 1312 free(argp); 1313 head = prevhead; 1314 tail = prevtail; 1315 if (tail) 1316 tail->nfs_ext_u.nfs_extB.next = NULL; 1317 last_error = NFSERR_NOENT; 1318 1319 if (retries-- > 0) { 1320 destroy_auth_client_handle(cl); 1321 DELAY(delay); 1322 goto retry; 1323 } 1324 1325 syslog(loglevel, "mount %s: %s", host, 1326 "Couldn't bind to reserved port"); 1327 destroy_auth_client_handle(cl); 1328 skipentry = 1; 1329 mfs->mfs_ignore = 1; 1330 continue; 1331 } 1332 1333 #ifdef MALLOC_DEBUG 1334 drop_alloc("AUTH_HANDLE", cl->cl_auth, 1335 __FILE__, __LINE__); 1336 #endif 1337 AUTH_DESTROY(cl->cl_auth); 1338 if ((cl->cl_auth = authsys_create_default()) == NULL) { 1339 free(argp); 1340 head = prevhead; 1341 tail = prevtail; 1342 if (tail) 1343 tail->nfs_ext_u.nfs_extB.next = NULL; 1344 last_error = NFSERR_NOENT; 1345 1346 if (retries-- > 0) { 1347 destroy_auth_client_handle(cl); 1348 DELAY(delay); 1349 goto retry; 1350 } 1351 1352 syslog(loglevel, "mount %s: %s", host, 1353 "Failed creating default auth handle"); 1354 destroy_auth_client_handle(cl); 1355 skipentry = 1; 1356 mfs->mfs_ignore = 1; 1357 continue; 1358 } 1359 #ifdef MALLOC_DEBUG 1360 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 1361 __FILE__, __LINE__); 1362 #endif 1363 } else 1364 cl = NULL; 1365 1366 /* 1367 * set security options 1368 */ 1369 sec_opt = 0; 1370 (void) memset(&nfs_sec, 0, sizeof (nfs_sec)); 1371 if (hasmntopt(&m, MNTOPT_SECURE) != NULL) { 1372 if (++sec_opt > 1) { 1373 syslog(loglevel, 1374 "conflicting security options for %s", 1375 remname); 1376 free(argp); 1377 head = prevhead; 1378 tail = prevtail; 1379 if (tail) 1380 tail->nfs_ext_u.nfs_extB.next = NULL; 1381 last_error = NFSERR_IO; 1382 destroy_auth_client_handle(cl); 1383 skipentry = 1; 1384 mfs->mfs_ignore = 1; 1385 continue; 1386 } 1387 if (nfs_getseconfig_byname("dh", &nfs_sec)) { 1388 syslog(loglevel, 1389 "error getting dh information from %s", 1390 NFSSEC_CONF); 1391 free(argp); 1392 head = prevhead; 1393 tail = prevtail; 1394 if (tail) 1395 tail->nfs_ext_u.nfs_extB.next = NULL; 1396 last_error = NFSERR_IO; 1397 destroy_auth_client_handle(cl); 1398 skipentry = 1; 1399 mfs->mfs_ignore = 1; 1400 continue; 1401 } 1402 } 1403 1404 nfs_flavor = NULL; 1405 if (hasmntopt(&m, MNTOPT_SEC) != NULL) { 1406 if ((str_opt(&m, MNTOPT_SEC, &nfs_flavor)) == -1) { 1407 syslog(LOG_ERR, "nfsmount: no memory"); 1408 last_error = NFSERR_IO; 1409 destroy_auth_client_handle(cl); 1410 goto out; 1411 } 1412 } 1413 1414 if (nfs_flavor) { 1415 if (++sec_opt > 1) { 1416 syslog(loglevel, 1417 "conflicting security options for %s", 1418 remname); 1419 free(nfs_flavor); 1420 free(argp); 1421 head = prevhead; 1422 tail = prevtail; 1423 if (tail) 1424 tail->nfs_ext_u.nfs_extB.next = NULL; 1425 last_error = NFSERR_IO; 1426 destroy_auth_client_handle(cl); 1427 skipentry = 1; 1428 mfs->mfs_ignore = 1; 1429 continue; 1430 } 1431 if (nfs_getseconfig_byname(nfs_flavor, &nfs_sec)) { 1432 syslog(loglevel, 1433 "error getting %s information from %s", 1434 nfs_flavor, NFSSEC_CONF); 1435 free(nfs_flavor); 1436 free(argp); 1437 head = prevhead; 1438 tail = prevtail; 1439 if (tail) 1440 tail->nfs_ext_u.nfs_extB.next = NULL; 1441 last_error = NFSERR_IO; 1442 destroy_auth_client_handle(cl); 1443 skipentry = 1; 1444 mfs->mfs_ignore = 1; 1445 continue; 1446 } 1447 free(nfs_flavor); 1448 } 1449 1450 posix = (nfsvers != NFS_V4 && 1451 hasmntopt(&m, MNTOPT_POSIX) != NULL) ? 1 : 0; 1452 1453 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0 && 1454 nfsvers != NFS_V4) { 1455 bool_t give_up_on_mnt; 1456 bool_t got_mnt_error; 1457 /* 1458 * If we started with a URL, if first byte of path is not "/", 1459 * then the mount will likely fail, so we should try again 1460 * with a prepended "/". 1461 */ 1462 if (mfs->mfs_flags & MFS_ALLOC_DIR && *dir != '/') 1463 give_up_on_mnt = FALSE; 1464 else 1465 give_up_on_mnt = TRUE; 1466 1467 got_mnt_error = FALSE; 1468 1469 try_mnt_slash: 1470 if (got_mnt_error == TRUE) { 1471 int i, l; 1472 1473 give_up_on_mnt = TRUE; 1474 l = strlen(dir); 1475 1476 /* 1477 * Insert a "/" to front of mfs_dir. 1478 */ 1479 for (i = l; i > 0; i--) 1480 dir[i] = dir[i-1]; 1481 1482 dir[0] = '/'; 1483 } 1484 1485 /* Get fhandle of remote path from server's mountd */ 1486 1487 switch (outvers) { 1488 case MOUNTVERS: 1489 if (posix) { 1490 free(argp); 1491 head = prevhead; 1492 tail = prevtail; 1493 if (tail) 1494 tail->nfs_ext_u.nfs_extB.next = 1495 NULL; 1496 last_error = NFSERR_NOENT; 1497 syslog(loglevel, 1498 "can't get posix info for %s", 1499 host); 1500 destroy_auth_client_handle(cl); 1501 skipentry = 1; 1502 mfs->mfs_ignore = 1; 1503 continue; 1504 } 1505 /* FALLTHRU */ 1506 case MOUNTVERS_POSIX: 1507 if (nfsvers == NFS_V3) { 1508 free(argp); 1509 head = prevhead; 1510 tail = prevtail; 1511 if (tail) 1512 tail->nfs_ext_u.nfs_extB.next = 1513 NULL; 1514 last_error = NFSERR_NOENT; 1515 syslog(loglevel, 1516 "%s doesn't support NFS Version 3", 1517 host); 1518 destroy_auth_client_handle(cl); 1519 skipentry = 1; 1520 mfs->mfs_ignore = 1; 1521 continue; 1522 } 1523 rpc_stat = clnt_call(cl, MOUNTPROC_MNT, 1524 xdr_dirpath, (caddr_t)&dir, 1525 xdr_fhstatus, (caddr_t)&fhs, timeout); 1526 if (rpc_stat != RPC_SUCCESS) { 1527 1528 if (give_up_on_mnt == FALSE) { 1529 got_mnt_error = TRUE; 1530 goto try_mnt_slash; 1531 } 1532 1533 /* 1534 * Given the way "clnt_sperror" works, the "%s" 1535 * immediately following the "not responding" 1536 * is correct. 1537 */ 1538 free(argp); 1539 head = prevhead; 1540 tail = prevtail; 1541 if (tail) 1542 tail->nfs_ext_u.nfs_extB.next = 1543 NULL; 1544 last_error = NFSERR_NOENT; 1545 1546 if (retries-- > 0) { 1547 destroy_auth_client_handle(cl); 1548 DELAY(delay); 1549 goto retry; 1550 } 1551 1552 if (trace > 3) { 1553 trace_prt(1, 1554 " nfsmount: mount RPC " 1555 "failed for %s\n", 1556 host); 1557 } 1558 syslog(loglevel, 1559 "%s server not responding%s", 1560 host, clnt_sperror(cl, "")); 1561 destroy_auth_client_handle(cl); 1562 skipentry = 1; 1563 mfs->mfs_ignore = 1; 1564 continue; 1565 } 1566 if ((errno = fhs.fhs_status) != MNT_OK) { 1567 1568 if (give_up_on_mnt == FALSE) { 1569 got_mnt_error = TRUE; 1570 goto try_mnt_slash; 1571 } 1572 1573 free(argp); 1574 head = prevhead; 1575 tail = prevtail; 1576 if (tail) 1577 tail->nfs_ext_u.nfs_extB.next = 1578 NULL; 1579 if (errno == EACCES) { 1580 status = NFSERR_ACCES; 1581 } else { 1582 syslog(loglevel, "%s: %m", 1583 host); 1584 status = NFSERR_IO; 1585 } 1586 if (trace > 3) { 1587 trace_prt(1, 1588 " nfsmount: mount RPC gave" 1589 " %d for %s:%s\n", 1590 errno, host, dir); 1591 } 1592 last_error = status; 1593 destroy_auth_client_handle(cl); 1594 skipentry = 1; 1595 mfs->mfs_ignore = 1; 1596 continue; 1597 } 1598 argp->fh = malloc((sizeof (fhandle))); 1599 if (!argp->fh) { 1600 syslog(LOG_ERR, "nfsmount: no memory"); 1601 last_error = NFSERR_IO; 1602 destroy_auth_client_handle(cl); 1603 goto out; 1604 } 1605 (void) memcpy(argp->fh, 1606 &fhs.fhstatus_u.fhs_fhandle, 1607 sizeof (fhandle)); 1608 break; 1609 case MOUNTVERS3: 1610 posix = 0; 1611 (void) memset((char *)&res3, '\0', 1612 sizeof (res3)); 1613 rpc_stat = clnt_call(cl, MOUNTPROC_MNT, 1614 xdr_dirpath, (caddr_t)&dir, 1615 xdr_mountres3, (caddr_t)&res3, timeout); 1616 if (rpc_stat != RPC_SUCCESS) { 1617 1618 if (give_up_on_mnt == FALSE) { 1619 got_mnt_error = TRUE; 1620 goto try_mnt_slash; 1621 } 1622 1623 /* 1624 * Given the way "clnt_sperror" works, the "%s" 1625 * immediately following the "not responding" 1626 * is correct. 1627 */ 1628 free(argp); 1629 head = prevhead; 1630 tail = prevtail; 1631 if (tail) 1632 tail->nfs_ext_u.nfs_extB.next = 1633 NULL; 1634 last_error = NFSERR_NOENT; 1635 1636 if (retries-- > 0) { 1637 destroy_auth_client_handle(cl); 1638 DELAY(delay); 1639 goto retry; 1640 } 1641 1642 if (trace > 3) { 1643 trace_prt(1, 1644 " nfsmount: mount RPC " 1645 "failed for %s\n", 1646 host); 1647 } 1648 syslog(loglevel, 1649 "%s server not responding%s", 1650 remname, clnt_sperror(cl, "")); 1651 destroy_auth_client_handle(cl); 1652 skipentry = 1; 1653 mfs->mfs_ignore = 1; 1654 continue; 1655 } 1656 if ((errno = res3.fhs_status) != MNT_OK) { 1657 1658 if (give_up_on_mnt == FALSE) { 1659 got_mnt_error = TRUE; 1660 goto try_mnt_slash; 1661 } 1662 1663 free(argp); 1664 head = prevhead; 1665 tail = prevtail; 1666 if (tail) 1667 tail->nfs_ext_u.nfs_extB.next = 1668 NULL; 1669 if (errno == EACCES) { 1670 status = NFSERR_ACCES; 1671 } else { 1672 syslog(loglevel, "%s: %m", 1673 remname); 1674 status = NFSERR_IO; 1675 } 1676 if (trace > 3) { 1677 trace_prt(1, 1678 " nfsmount: mount RPC gave" 1679 " %d for %s:%s\n", 1680 errno, host, dir); 1681 } 1682 last_error = status; 1683 destroy_auth_client_handle(cl); 1684 skipentry = 1; 1685 mfs->mfs_ignore = 1; 1686 continue; 1687 } 1688 1689 /* 1690 * Negotiate the security flavor for nfs_mount 1691 */ 1692 auths = res3.mountres3_u.mountinfo. 1693 auth_flavors.auth_flavors_val; 1694 count = res3.mountres3_u.mountinfo. 1695 auth_flavors.auth_flavors_len; 1696 1697 if (sec_opt) { 1698 for (i = 0; i < count; i++) 1699 if (auths[i] == 1700 nfs_sec.sc_nfsnum) { 1701 break; 1702 } 1703 if (i >= count) { 1704 syslog(LOG_ERR, 1705 "%s: does not support " 1706 "security \"%s\"\n", 1707 remname, nfs_sec.sc_name); 1708 clnt_freeres(cl, xdr_mountres3, 1709 (caddr_t)&res3); 1710 free(argp); 1711 head = prevhead; 1712 tail = prevtail; 1713 if (tail) 1714 tail->nfs_ext_u. 1715 nfs_extB.next = 1716 NULL; 1717 last_error = NFSERR_IO; 1718 destroy_auth_client_handle(cl); 1719 skipentry = 1; 1720 mfs->mfs_ignore = 1; 1721 continue; 1722 } 1723 } else if (count > 0) { 1724 for (i = 0; i < count; i++) { 1725 if (!(scerror = 1726 nfs_getseconfig_bynumber( 1727 auths[i], &nfs_sec))) { 1728 sec_opt++; 1729 break; 1730 } 1731 } 1732 if (i >= count) { 1733 if (nfs_syslog_scerr(scerror, 1734 scerror_msg) 1735 != -1) { 1736 syslog(LOG_ERR, 1737 "%s cannot be " 1738 "mounted because it" 1739 " is shared with " 1740 "security flavor %d" 1741 " which %s", 1742 remname, 1743 auths[i-1], 1744 scerror_msg); 1745 } 1746 clnt_freeres(cl, xdr_mountres3, 1747 (caddr_t)&res3); 1748 free(argp); 1749 head = prevhead; 1750 tail = prevtail; 1751 if (tail) 1752 tail->nfs_ext_u. 1753 nfs_extB.next = 1754 NULL; 1755 last_error = NFSERR_IO; 1756 destroy_auth_client_handle(cl); 1757 skipentry = 1; 1758 mfs->mfs_ignore = 1; 1759 continue; 1760 } 1761 } 1762 1763 fh3.fh3_length = 1764 res3.mountres3_u.mountinfo.fhandle. 1765 fhandle3_len; 1766 (void) memcpy(fh3.fh3_u.data, 1767 res3.mountres3_u.mountinfo.fhandle. 1768 fhandle3_val, 1769 fh3.fh3_length); 1770 clnt_freeres(cl, xdr_mountres3, 1771 (caddr_t)&res3); 1772 argp->fh = malloc(sizeof (nfs_fh3)); 1773 if (!argp->fh) { 1774 syslog(LOG_ERR, "nfsmount: no memory"); 1775 last_error = NFSERR_IO; 1776 destroy_auth_client_handle(cl); 1777 goto out; 1778 } 1779 (void) memcpy(argp->fh, &fh3, sizeof (nfs_fh3)); 1780 break; 1781 default: 1782 free(argp); 1783 head = prevhead; 1784 tail = prevtail; 1785 if (tail) 1786 tail->nfs_ext_u.nfs_extB.next = NULL; 1787 last_error = NFSERR_NOENT; 1788 syslog(loglevel, 1789 "unknown MOUNT version %ld on %s", 1790 vers, remname); 1791 destroy_auth_client_handle(cl); 1792 skipentry = 1; 1793 mfs->mfs_ignore = 1; 1794 continue; 1795 } /* switch */ 1796 } 1797 if (nfsvers == NFS_V4) { 1798 argp->fh = strdup(dir); 1799 if (argp->fh == NULL) { 1800 syslog(LOG_ERR, "nfsmount: no memory"); 1801 last_error = NFSERR_IO; 1802 goto out; 1803 } 1804 } 1805 1806 if (trace > 4) 1807 trace_prt(1, " nfsmount: have %s filehandle for %s\n", 1808 fstype, remname); 1809 1810 argp->flags |= NFSMNT_NEWARGS; 1811 argp->flags |= NFSMNT_INT; /* default is "intr" */ 1812 argp->flags |= NFSMNT_HOSTNAME; 1813 argp->hostname = strdup(host); 1814 if (argp->hostname == NULL) { 1815 syslog(LOG_ERR, "nfsmount: no memory"); 1816 last_error = NFSERR_IO; 1817 goto out; 1818 } 1819 1820 /* 1821 * In this case, we want NFSv4 to behave like 1822 * non-WebNFS so that we get the server address. 1823 */ 1824 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0) { 1825 nconf = NULL; 1826 1827 if (nfs_port != 0) 1828 thisport = nfs_port; 1829 else 1830 thisport = mfs->mfs_port; 1831 1832 /* 1833 * For NFSv4, we want to avoid rpcbind, so call 1834 * get_server_netinfo() directly to tell it that 1835 * we want to go "direct_to_server". Otherwise, 1836 * do what has always been done. 1837 */ 1838 if (nfsvers == NFS_V4) { 1839 enum clnt_stat cstat; 1840 1841 argp->addr = get_server_netinfo(SERVER_ADDR, 1842 host, NFS_PROGRAM, nfsvers, NULL, 1843 &nconf, nfs_proto, thisport, NULL, 1844 NULL, TRUE, NULL, &cstat); 1845 } else { 1846 argp->addr = get_addr(host, NFS_PROGRAM, 1847 nfsvers, &nconf, nfs_proto, 1848 thisport, NULL); 1849 } 1850 1851 if (argp->addr == NULL) { 1852 if (argp->hostname) 1853 free(argp->hostname); 1854 free(argp->fh); 1855 free(argp); 1856 head = prevhead; 1857 tail = prevtail; 1858 if (tail) 1859 tail->nfs_ext_u.nfs_extB.next = NULL; 1860 last_error = NFSERR_NOENT; 1861 1862 if (retries-- > 0) { 1863 destroy_auth_client_handle(cl); 1864 DELAY(delay); 1865 goto retry; 1866 } 1867 1868 syslog(loglevel, "%s: no NFS service", host); 1869 destroy_auth_client_handle(cl); 1870 skipentry = 1; 1871 mfs->mfs_ignore = 1; 1872 continue; 1873 } 1874 if (trace > 4) 1875 trace_prt(1, 1876 "\tnfsmount: have net address for %s\n", 1877 remname); 1878 1879 } else { 1880 nconf = mfs->mfs_nconf; 1881 mfs->mfs_nconf = NULL; 1882 } 1883 1884 argp->flags |= NFSMNT_KNCONF; 1885 argp->knconf = get_knconf(nconf); 1886 if (argp->knconf == NULL) { 1887 netbuf_free(argp->addr); 1888 freenetconfigent(nconf); 1889 if (argp->hostname) 1890 free(argp->hostname); 1891 free(argp->fh); 1892 free(argp); 1893 head = prevhead; 1894 tail = prevtail; 1895 if (tail) 1896 tail->nfs_ext_u.nfs_extB.next = NULL; 1897 last_error = NFSERR_NOSPC; 1898 destroy_auth_client_handle(cl); 1899 skipentry = 1; 1900 mfs->mfs_ignore = 1; 1901 continue; 1902 } 1903 if (trace > 4) 1904 trace_prt(1, 1905 "\tnfsmount: have net config for %s\n", 1906 remname); 1907 1908 if (hasmntopt(&m, MNTOPT_SOFT) != NULL) { 1909 argp->flags |= NFSMNT_SOFT; 1910 } 1911 if (hasmntopt(&m, MNTOPT_NOINTR) != NULL) { 1912 argp->flags &= ~(NFSMNT_INT); 1913 } 1914 if (hasmntopt(&m, MNTOPT_NOAC) != NULL) { 1915 argp->flags |= NFSMNT_NOAC; 1916 } 1917 if (hasmntopt(&m, MNTOPT_NOCTO) != NULL) { 1918 argp->flags |= NFSMNT_NOCTO; 1919 } 1920 if (hasmntopt(&m, MNTOPT_FORCEDIRECTIO) != NULL) { 1921 argp->flags |= NFSMNT_DIRECTIO; 1922 } 1923 if (hasmntopt(&m, MNTOPT_NOFORCEDIRECTIO) != NULL) { 1924 argp->flags &= ~(NFSMNT_DIRECTIO); 1925 } 1926 1927 /* 1928 * Set up security data for argp->nfs_ext_u.nfs_extB.secdata. 1929 */ 1930 if (mfssnego.snego_done) { 1931 memcpy(&nfs_sec, &mfssnego.nfs_sec, 1932 sizeof (seconfig_t)); 1933 } else if (!sec_opt) { 1934 /* 1935 * Get default security mode. 1936 */ 1937 if (nfs_getseconfig_default(&nfs_sec)) { 1938 syslog(loglevel, 1939 "error getting default security entry\n"); 1940 free_knconf(argp->knconf); 1941 netbuf_free(argp->addr); 1942 freenetconfigent(nconf); 1943 if (argp->hostname) 1944 free(argp->hostname); 1945 free(argp->fh); 1946 free(argp); 1947 head = prevhead; 1948 tail = prevtail; 1949 if (tail) 1950 tail->nfs_ext_u.nfs_extB.next = NULL; 1951 last_error = NFSERR_NOSPC; 1952 destroy_auth_client_handle(cl); 1953 skipentry = 1; 1954 mfs->mfs_ignore = 1; 1955 continue; 1956 } 1957 argp->flags |= NFSMNT_SECDEFAULT; 1958 } 1959 1960 /* 1961 * For AUTH_DH 1962 * get the network address for the time service on 1963 * the server. If an RPC based time service is 1964 * not available then try the IP time service. 1965 * 1966 * Eventurally, we want to move this code to nfs_clnt_secdata() 1967 * when autod_nfs.c and mount.c can share the same 1968 * get_the_addr/get_netconfig_info routine. 1969 */ 1970 secflags = 0; 1971 syncaddr = NULL; 1972 retaddrs = NULL; 1973 1974 if (nfs_sec.sc_rpcnum == AUTH_DH || nfsvers == NFS_V4) { 1975 /* 1976 * If not using the public fh and not NFS_V4, we can try 1977 * talking RPCBIND. Otherwise, assume that firewalls 1978 * prevent us from doing that. 1979 */ 1980 if ((mfs->mfs_flags & MFS_FH_VIA_WEBNFS) == 0 && 1981 nfsvers != NFS_V4) { 1982 enum clnt_stat cstat; 1983 syncaddr = get_server_netinfo(SERVER_ADDR, 1984 host, RPCBPROG, RPCBVERS, NULL, &nconf, 1985 NULL, 0, NULL, NULL, FALSE, NULL, &cstat); 1986 } 1987 1988 if (syncaddr != NULL) { 1989 /* for flags in sec_data */ 1990 secflags |= AUTH_F_RPCTIMESYNC; 1991 } else { 1992 struct nd_hostserv hs; 1993 int error; 1994 1995 hs.h_host = host; 1996 hs.h_serv = "timserver"; 1997 error = netdir_getbyname(nconf, &hs, &retaddrs); 1998 1999 if (error != ND_OK && 2000 nfs_sec.sc_rpcnum == AUTH_DH) { 2001 syslog(loglevel, 2002 "%s: secure: no time service\n", 2003 host); 2004 free_knconf(argp->knconf); 2005 netbuf_free(argp->addr); 2006 freenetconfigent(nconf); 2007 if (argp->hostname) 2008 free(argp->hostname); 2009 free(argp->fh); 2010 free(argp); 2011 head = prevhead; 2012 tail = prevtail; 2013 if (tail) 2014 tail->nfs_ext_u.nfs_extB.next = 2015 NULL; 2016 last_error = NFSERR_IO; 2017 destroy_auth_client_handle(cl); 2018 skipentry = 1; 2019 mfs->mfs_ignore = 1; 2020 continue; 2021 } 2022 2023 if (error == ND_OK) 2024 syncaddr = retaddrs->n_addrs; 2025 2026 /* 2027 * For potential usage by NFS V4 when AUTH_DH 2028 * is negotiated via SECINFO in the kernel. 2029 */ 2030 if (nfsvers == NFS_V4 && syncaddr && 2031 host2netname(netname, host, NULL)) { 2032 argp->syncaddr = 2033 malloc(sizeof (struct netbuf)); 2034 argp->syncaddr->buf = 2035 malloc(syncaddr->len); 2036 (void) memcpy(argp->syncaddr->buf, 2037 syncaddr->buf, syncaddr->len); 2038 argp->syncaddr->len = syncaddr->len; 2039 argp->syncaddr->maxlen = 2040 syncaddr->maxlen; 2041 argp->netname = strdup(netname); 2042 argp->flags |= NFSMNT_SECURE; 2043 } 2044 } /* syncaddr */ 2045 } /* AUTH_DH */ 2046 2047 /* 2048 * TSOL notes: automountd in tsol extension 2049 * has "read down" capability, i.e. we allow 2050 * a user to trigger an nfs mount into a lower 2051 * labeled zone. We achieve this by always having 2052 * root issue the mount request so that the 2053 * lookup ops can go past /zone/<zone_name> 2054 * on the server side. 2055 */ 2056 if (is_system_labeled()) 2057 nfs_sec.sc_uid = (uid_t)0; 2058 else 2059 nfs_sec.sc_uid = uid; 2060 /* 2061 * If AUTH_DH is a chosen flavor now, its data will be stored 2062 * in the sec_data structure via nfs_clnt_secdata(). 2063 */ 2064 if (!(secdata = nfs_clnt_secdata(&nfs_sec, host, argp->knconf, 2065 syncaddr, secflags))) { 2066 syslog(LOG_ERR, 2067 "errors constructing security related data\n"); 2068 if (secflags & AUTH_F_RPCTIMESYNC) 2069 netbuf_free(syncaddr); 2070 else if (retaddrs) 2071 netdir_free(retaddrs, ND_ADDRLIST); 2072 if (argp->syncaddr) 2073 netbuf_free(argp->syncaddr); 2074 if (argp->netname) 2075 free(argp->netname); 2076 if (argp->hostname) 2077 free(argp->hostname); 2078 free_knconf(argp->knconf); 2079 netbuf_free(argp->addr); 2080 freenetconfigent(nconf); 2081 free(argp->fh); 2082 free(argp); 2083 head = prevhead; 2084 tail = prevtail; 2085 if (tail) 2086 tail->nfs_ext_u.nfs_extB.next = NULL; 2087 last_error = NFSERR_IO; 2088 destroy_auth_client_handle(cl); 2089 skipentry = 1; 2090 mfs->mfs_ignore = 1; 2091 continue; 2092 } 2093 NFS_ARGS_EXTB_secdata(*argp, secdata); 2094 /* end of security stuff */ 2095 2096 if (trace > 4) 2097 trace_prt(1, 2098 " nfsmount: have secure info for %s\n", remname); 2099 2100 if (hasmntopt(&m, MNTOPT_GRPID) != NULL) { 2101 argp->flags |= NFSMNT_GRPID; 2102 } 2103 if (nopt(&m, MNTOPT_RSIZE, &argp->rsize)) { 2104 argp->flags |= NFSMNT_RSIZE; 2105 } 2106 if (nopt(&m, MNTOPT_WSIZE, &argp->wsize)) { 2107 argp->flags |= NFSMNT_WSIZE; 2108 } 2109 if (nopt(&m, MNTOPT_TIMEO, &argp->timeo)) { 2110 argp->flags |= NFSMNT_TIMEO; 2111 } 2112 if (nopt(&m, MNTOPT_RETRANS, &argp->retrans)) { 2113 argp->flags |= NFSMNT_RETRANS; 2114 } 2115 if (nopt(&m, MNTOPT_ACTIMEO, &argp->acregmax)) { 2116 argp->flags |= NFSMNT_ACREGMAX; 2117 argp->flags |= NFSMNT_ACDIRMAX; 2118 argp->flags |= NFSMNT_ACDIRMIN; 2119 argp->flags |= NFSMNT_ACREGMIN; 2120 argp->acdirmin = argp->acregmin = argp->acdirmax 2121 = argp->acregmax; 2122 } else { 2123 if (nopt(&m, MNTOPT_ACREGMIN, &argp->acregmin)) { 2124 argp->flags |= NFSMNT_ACREGMIN; 2125 } 2126 if (nopt(&m, MNTOPT_ACREGMAX, &argp->acregmax)) { 2127 argp->flags |= NFSMNT_ACREGMAX; 2128 } 2129 if (nopt(&m, MNTOPT_ACDIRMIN, &argp->acdirmin)) { 2130 argp->flags |= NFSMNT_ACDIRMIN; 2131 } 2132 if (nopt(&m, MNTOPT_ACDIRMAX, &argp->acdirmax)) { 2133 argp->flags |= NFSMNT_ACDIRMAX; 2134 } 2135 } 2136 2137 if (posix) { 2138 argp->pathconf = NULL; 2139 if (error = get_pathconf(cl, dir, remname, 2140 &argp->pathconf, retries)) { 2141 if (secflags & AUTH_F_RPCTIMESYNC) 2142 netbuf_free(syncaddr); 2143 else if (retaddrs) 2144 netdir_free(retaddrs, ND_ADDRLIST); 2145 free_knconf(argp->knconf); 2146 netbuf_free(argp->addr); 2147 freenetconfigent(nconf); 2148 nfs_free_secdata( 2149 argp->nfs_ext_u.nfs_extB.secdata); 2150 if (argp->syncaddr) 2151 netbuf_free(argp->syncaddr); 2152 if (argp->netname) 2153 free(argp->netname); 2154 if (argp->hostname) 2155 free(argp->hostname); 2156 free(argp->fh); 2157 free(argp); 2158 head = prevhead; 2159 tail = prevtail; 2160 if (tail) 2161 tail->nfs_ext_u.nfs_extB.next = NULL; 2162 last_error = NFSERR_IO; 2163 2164 if (error == RET_RETRY && retries-- > 0) { 2165 destroy_auth_client_handle(cl); 2166 DELAY(delay); 2167 goto retry; 2168 } 2169 2170 destroy_auth_client_handle(cl); 2171 skipentry = 1; 2172 mfs->mfs_ignore = 1; 2173 continue; 2174 } 2175 argp->flags |= NFSMNT_POSIX; 2176 if (trace > 4) 2177 trace_prt(1, 2178 " nfsmount: have pathconf for %s\n", 2179 remname); 2180 } 2181 2182 /* 2183 * free loop-specific data structures 2184 */ 2185 destroy_auth_client_handle(cl); 2186 freenetconfigent(nconf); 2187 if (secflags & AUTH_F_RPCTIMESYNC) 2188 netbuf_free(syncaddr); 2189 else if (retaddrs) 2190 netdir_free(retaddrs, ND_ADDRLIST); 2191 2192 /* 2193 * Decide whether to use remote host's lockd or local locking. 2194 * If we are using the public fh, we've already turned 2195 * LLOCK on. 2196 */ 2197 if (hasmntopt(&m, MNTOPT_LLOCK)) 2198 argp->flags |= NFSMNT_LLOCK; 2199 if (!(argp->flags & NFSMNT_LLOCK) && nfsvers == NFS_VERSION && 2200 remote_lock(host, argp->fh)) { 2201 syslog(loglevel, "No network locking on %s : " 2202 "contact admin to install server change", host); 2203 argp->flags |= NFSMNT_LLOCK; 2204 } 2205 2206 /* 2207 * Build a string for /etc/mnttab. 2208 * If possible, coalesce strings with same 'dir' info. 2209 */ 2210 if ((mfs->mfs_flags & MFS_URL) == 0) { 2211 char *tmp; 2212 2213 if (mnttabcnt) { 2214 p = strrchr(mnttabtext, (int)':'); 2215 if (!p || strcmp(p+1, dir) != 0) { 2216 mnttabcnt += strlen(remname) + 2; 2217 } else { 2218 *p = '\0'; 2219 mnttabcnt += strlen(rhost) + 2; 2220 } 2221 if ((tmp = realloc(mnttabtext, 2222 mnttabcnt)) != NULL) { 2223 mnttabtext = tmp; 2224 strcat(mnttabtext, ","); 2225 } else { 2226 free(mnttabtext); 2227 mnttabtext = NULL; 2228 } 2229 } else { 2230 mnttabcnt = strlen(remname) + 1; 2231 if ((mnttabtext = malloc(mnttabcnt)) != NULL) 2232 mnttabtext[0] = '\0'; 2233 } 2234 2235 if (mnttabtext != NULL) 2236 strcat(mnttabtext, remname); 2237 2238 } else { 2239 char *tmp; 2240 int more_cnt = 0; 2241 char sport[16]; 2242 2243 more_cnt += strlen("nfs://"); 2244 more_cnt += strlen(mfs->mfs_host); 2245 2246 if (mfs->mfs_port != 0) { 2247 (void) sprintf(sport, ":%u", mfs->mfs_port); 2248 } else 2249 sport[0] = '\0'; 2250 2251 more_cnt += strlen(sport); 2252 more_cnt += 1; /* "/" */ 2253 more_cnt += strlen(mfs->mfs_dir); 2254 2255 if (mnttabcnt) { 2256 more_cnt += 1; /* "," */ 2257 mnttabcnt += more_cnt; 2258 2259 if ((tmp = realloc(mnttabtext, 2260 mnttabcnt)) != NULL) { 2261 mnttabtext = tmp; 2262 strcat(mnttabtext, ","); 2263 } else { 2264 free(mnttabtext); 2265 mnttabtext = NULL; 2266 } 2267 } else { 2268 mnttabcnt = more_cnt + 1; 2269 if ((mnttabtext = malloc(mnttabcnt)) != NULL) 2270 mnttabtext[0] = '\0'; 2271 } 2272 2273 if (mnttabtext != NULL) { 2274 strcat(mnttabtext, "nfs://"); 2275 strcat(mnttabtext, mfs->mfs_host); 2276 strcat(mnttabtext, sport); 2277 strcat(mnttabtext, "/"); 2278 strcat(mnttabtext, mfs->mfs_dir); 2279 } 2280 } 2281 2282 if (!mnttabtext) { 2283 syslog(LOG_ERR, "nfsmount: no memory"); 2284 last_error = NFSERR_IO; 2285 goto out; 2286 } 2287 2288 /* 2289 * At least one entry, can call mount(2). 2290 */ 2291 entries++; 2292 2293 /* 2294 * If replication was defeated, don't do more work 2295 */ 2296 if (!replicated) 2297 break; 2298 } 2299 2300 2301 /* 2302 * Did we get through all possibilities without success? 2303 */ 2304 if (!entries) 2305 goto out; 2306 2307 /* Make "xattr" the default if "noxattr" is not specified. */ 2308 strcpy(mopts, opts); 2309 if (!hasmntopt(&m, MNTOPT_NOXATTR) && !hasmntopt(&m, MNTOPT_XATTR)) { 2310 if (strlen(mopts) > 0) 2311 strcat(mopts, ","); 2312 strcat(mopts, "xattr"); 2313 } 2314 2315 /* 2316 * enable services as needed. 2317 */ 2318 { 2319 char **sl; 2320 2321 if (strcmp(fstype, MNTTYPE_NFS4) == 0) 2322 sl = service_list_v4; 2323 else 2324 sl = service_list; 2325 2326 (void) _check_services(sl); 2327 } 2328 2329 /* 2330 * Whew; do the mount, at last. 2331 */ 2332 if (trace > 1) { 2333 trace_prt(1, " mount %s %s (%s)\n", mnttabtext, mntpnt, mopts); 2334 } 2335 2336 /* 2337 * About to do a nfs mount, make sure the mount_to is set for 2338 * potential ephemeral mounts with NFSv4. 2339 */ 2340 set_nfsv4_ephemeral_mount_to(); 2341 2342 /* 2343 * If no action list pointer then do the mount, otherwise 2344 * build the actions list pointer with the mount information. 2345 * so the mount can be done in the kernel. 2346 */ 2347 if (alp == NULL) { 2348 if (mount(mnttabtext, mntpnt, flags | MS_DATA, fstype, 2349 head, sizeof (*head), mopts, MAX_MNTOPT_STR) < 0) { 2350 if (trace > 1) 2351 trace_prt(1, " Mount of %s on %s: %d\n", 2352 mnttabtext, mntpnt, errno); 2353 if (errno != EBUSY || verbose) 2354 syslog(LOG_ERR, 2355 "Mount of %s on %s: %m", mnttabtext, mntpnt); 2356 last_error = NFSERR_IO; 2357 goto out; 2358 } 2359 2360 last_error = NFS_OK; 2361 if (stat(mntpnt, &stbuf) == 0) { 2362 if (trace > 1) { 2363 trace_prt(1, " mount %s dev=%x rdev=%x OK\n", 2364 mnttabtext, stbuf.st_dev, stbuf.st_rdev); 2365 } 2366 } else { 2367 if (trace > 1) { 2368 trace_prt(1, " mount %s OK\n", mnttabtext); 2369 trace_prt(1, " stat of %s failed\n", mntpnt); 2370 } 2371 2372 } 2373 } else { 2374 alp->action.action = AUTOFS_MOUNT_RQ; 2375 alp->action.action_list_entry_u.mounta.spec = 2376 strdup(mnttabtext); 2377 alp->action.action_list_entry_u.mounta.dir = strdup(mntpnt); 2378 alp->action.action_list_entry_u.mounta.flags = 2379 flags | MS_DATA; 2380 alp->action.action_list_entry_u.mounta.fstype = 2381 strdup(fstype); 2382 alp->action.action_list_entry_u.mounta.dataptr = (char *)head; 2383 alp->action.action_list_entry_u.mounta.datalen = 2384 sizeof (*head); 2385 mntopts = malloc(strlen(mopts) + 1); 2386 strcpy(mntopts, mopts); 2387 mntopts[strlen(mopts)] = '\0'; 2388 alp->action.action_list_entry_u.mounta.optptr = mntopts; 2389 alp->action.action_list_entry_u.mounta.optlen = 2390 strlen(mntopts) + 1; 2391 last_error = NFS_OK; 2392 goto ret; 2393 } 2394 2395 out: 2396 argp = head; 2397 while (argp) { 2398 if (argp->pathconf) 2399 free(argp->pathconf); 2400 free_knconf(argp->knconf); 2401 netbuf_free(argp->addr); 2402 if (argp->syncaddr) 2403 netbuf_free(argp->syncaddr); 2404 if (argp->netname) { 2405 free(argp->netname); 2406 } 2407 if (argp->hostname) 2408 free(argp->hostname); 2409 nfs_free_secdata(argp->nfs_ext_u.nfs_extB.secdata); 2410 free(argp->fh); 2411 head = argp; 2412 argp = argp->nfs_ext_u.nfs_extB.next; 2413 free(head); 2414 } 2415 ret: 2416 if (nfs_proto) 2417 free(nfs_proto); 2418 if (mnttabtext) 2419 free(mnttabtext); 2420 2421 for (mfs = mfs_in; mfs; mfs = mfs->mfs_next) { 2422 2423 if (mfs->mfs_flags & MFS_ALLOC_DIR) { 2424 free(mfs->mfs_dir); 2425 mfs->mfs_dir = NULL; 2426 mfs->mfs_flags &= ~MFS_ALLOC_DIR; 2427 } 2428 2429 if (mfs->mfs_args != NULL && alp == NULL) { 2430 free(mfs->mfs_args); 2431 mfs->mfs_args = NULL; 2432 } 2433 2434 if (mfs->mfs_nconf != NULL) { 2435 freenetconfigent(mfs->mfs_nconf); 2436 mfs->mfs_nconf = NULL; 2437 } 2438 } 2439 2440 return (last_error); 2441 } 2442 2443 /* 2444 * get_pathconf(cl, path, fsname, pcnf, cretries) 2445 * ugliness that requires that ppathcnf and pathcnf stay consistent 2446 * cretries is a copy of retries used to determine when to syslog 2447 * on retry situations. 2448 */ 2449 static int 2450 get_pathconf(CLIENT *cl, char *path, char *fsname, struct pathcnf **pcnf, 2451 int cretries) 2452 { 2453 struct ppathcnf *p = NULL; 2454 enum clnt_stat rpc_stat; 2455 struct timeval timeout; 2456 2457 p = (struct ppathcnf *)malloc(sizeof (struct ppathcnf)); 2458 if (p == NULL) { 2459 syslog(LOG_ERR, "get_pathconf: Out of memory"); 2460 return (RET_ERR); 2461 } 2462 memset((caddr_t)p, 0, sizeof (struct ppathcnf)); 2463 2464 timeout.tv_sec = 10; 2465 timeout.tv_usec = 0; 2466 rpc_stat = clnt_call(cl, MOUNTPROC_PATHCONF, 2467 xdr_dirpath, (caddr_t)&path, xdr_ppathcnf, (caddr_t)p, timeout); 2468 if (rpc_stat != RPC_SUCCESS) { 2469 if (cretries-- <= 0) { 2470 syslog(LOG_ERR, 2471 "get_pathconf: %s: server not responding: %s", 2472 fsname, clnt_sperror(cl, "")); 2473 } 2474 free(p); 2475 return (RET_RETRY); 2476 } 2477 if (_PC_ISSET(_PC_ERROR, p->pc_mask)) { 2478 syslog(LOG_ERR, "get_pathconf: no info for %s", fsname); 2479 free(p); 2480 return (RET_ERR); 2481 } 2482 *pcnf = (struct pathcnf *)p; 2483 return (RET_OK); 2484 } 2485 2486 void 2487 netbuf_free(nb) 2488 struct netbuf *nb; 2489 { 2490 if (nb == NULL) 2491 return; 2492 if (nb->buf) 2493 free(nb->buf); 2494 free(nb); 2495 } 2496 2497 #define SMALL_HOSTNAME 20 2498 #define SMALL_PROTONAME 10 2499 #define SMALL_PROTOFMLYNAME 10 2500 2501 struct portmap_cache { 2502 int cache_prog; 2503 int cache_vers; 2504 time_t cache_time; 2505 char cache_small_hosts[SMALL_HOSTNAME + 1]; 2506 char *cache_hostname; 2507 char *cache_proto; 2508 char *cache_protofmly; 2509 char cache_small_protofmly[SMALL_PROTOFMLYNAME + 1]; 2510 char cache_small_proto[SMALL_PROTONAME + 1]; 2511 struct netbuf cache_srv_addr; 2512 struct portmap_cache *cache_prev, *cache_next; 2513 }; 2514 2515 rwlock_t portmap_cache_lock; 2516 static int portmap_cache_valid_time = 30; 2517 struct portmap_cache *portmap_cache_head, *portmap_cache_tail; 2518 2519 #ifdef MALLOC_DEBUG 2520 void 2521 portmap_cache_flush() 2522 { 2523 struct portmap_cache *next = NULL, *cp; 2524 2525 (void) rw_wrlock(&portmap_cache_lock); 2526 for (cp = portmap_cache_head; cp; cp = cp->cache_next) { 2527 if (cp->cache_hostname != NULL && 2528 cp->cache_hostname != 2529 cp->cache_small_hosts) 2530 free(cp->cache_hostname); 2531 if (cp->cache_proto != NULL && 2532 cp->cache_proto != 2533 cp->cache_small_proto) 2534 free(cp->cache_proto); 2535 if (cp->cache_srv_addr.buf != NULL) 2536 free(cp->cache_srv_addr.buf); 2537 next = cp->cache_next; 2538 free(cp); 2539 } 2540 portmap_cache_head = NULL; 2541 portmap_cache_tail = NULL; 2542 (void) rw_unlock(&portmap_cache_lock); 2543 } 2544 #endif 2545 2546 /* 2547 * Returns 1 if the entry is found in the cache, 0 otherwise. 2548 */ 2549 static int 2550 portmap_cache_lookup(hostname, prog, vers, nconf, addrp) 2551 char *hostname; 2552 rpcprog_t prog; 2553 rpcvers_t vers; 2554 struct netconfig *nconf; 2555 struct netbuf *addrp; 2556 { 2557 struct portmap_cache *cachep, *prev, *next = NULL, *cp; 2558 int retval = 0; 2559 2560 timenow = time(NULL); 2561 2562 (void) rw_rdlock(&portmap_cache_lock); 2563 2564 /* 2565 * Increment the portmap cache counters for # accesses and lookups 2566 * Use a smaller factor (100 vs 1000 for the host cache) since 2567 * initial analysis shows this cache is looked up 10% that of the 2568 * host cache. 2569 */ 2570 #ifdef CACHE_DEBUG 2571 portmap_cache_accesses++; 2572 portmap_cache_lookups++; 2573 if ((portmap_cache_lookups%100) == 0) 2574 trace_portmap_cache(); 2575 #endif /* CACHE_DEBUG */ 2576 2577 for (cachep = portmap_cache_head; cachep; 2578 cachep = cachep->cache_next) { 2579 if (timenow > cachep->cache_time) { 2580 /* 2581 * We stumbled across an entry in the cache which 2582 * has timed out. Free up all the entries that 2583 * were added before it, which will positionally 2584 * be after this entry. And adjust neighboring 2585 * pointers. 2586 * When we drop the lock and re-acquire it, we 2587 * need to start from the beginning. 2588 */ 2589 (void) rw_unlock(&portmap_cache_lock); 2590 (void) rw_wrlock(&portmap_cache_lock); 2591 for (cp = portmap_cache_head; 2592 cp && (cp->cache_time >= timenow); 2593 cp = cp->cache_next) 2594 ; 2595 if (cp == NULL) 2596 goto done; 2597 /* 2598 * Adjust the link of the predecessor. 2599 * Make the tail point to the new last entry. 2600 */ 2601 prev = cp->cache_prev; 2602 if (prev == NULL) { 2603 portmap_cache_head = NULL; 2604 portmap_cache_tail = NULL; 2605 } else { 2606 prev->cache_next = NULL; 2607 portmap_cache_tail = prev; 2608 } 2609 for (; cp; cp = next) { 2610 if (cp->cache_hostname != NULL && 2611 cp->cache_hostname != 2612 cp->cache_small_hosts) 2613 free(cp->cache_hostname); 2614 if (cp->cache_proto != NULL && 2615 cp->cache_proto != 2616 cp->cache_small_proto) 2617 free(cp->cache_proto); 2618 if (cp->cache_srv_addr.buf != NULL) 2619 free(cp->cache_srv_addr.buf); 2620 next = cp->cache_next; 2621 free(cp); 2622 } 2623 goto done; 2624 } 2625 if (cachep->cache_hostname == NULL || 2626 prog != cachep->cache_prog || vers != cachep->cache_vers || 2627 strcmp(nconf->nc_proto, cachep->cache_proto) != 0 || 2628 strcmp(nconf->nc_protofmly, cachep->cache_protofmly) != 0 || 2629 strcmp(hostname, cachep->cache_hostname) != 0) 2630 continue; 2631 /* 2632 * Cache Hit. 2633 */ 2634 #ifdef CACHE_DEBUG 2635 portmap_cache_hits++; /* up portmap cache hit counter */ 2636 #endif /* CACHE_DEBUG */ 2637 addrp->len = cachep->cache_srv_addr.len; 2638 memcpy(addrp->buf, cachep->cache_srv_addr.buf, addrp->len); 2639 retval = 1; 2640 break; 2641 } 2642 done: 2643 (void) rw_unlock(&portmap_cache_lock); 2644 return (retval); 2645 } 2646 2647 static void 2648 portmap_cache_enter(hostname, prog, vers, nconf, addrp) 2649 char *hostname; 2650 rpcprog_t prog; 2651 rpcvers_t vers; 2652 struct netconfig *nconf; 2653 struct netbuf *addrp; 2654 { 2655 struct portmap_cache *cachep; 2656 int protofmlylen; 2657 int protolen, hostnamelen; 2658 2659 timenow = time(NULL); 2660 2661 cachep = malloc(sizeof (struct portmap_cache)); 2662 if (cachep == NULL) 2663 return; 2664 memset((char *)cachep, 0, sizeof (*cachep)); 2665 2666 hostnamelen = strlen(hostname); 2667 if (hostnamelen <= SMALL_HOSTNAME) 2668 cachep->cache_hostname = cachep->cache_small_hosts; 2669 else { 2670 cachep->cache_hostname = malloc(hostnamelen + 1); 2671 if (cachep->cache_hostname == NULL) 2672 goto nomem; 2673 } 2674 strcpy(cachep->cache_hostname, hostname); 2675 protolen = strlen(nconf->nc_proto); 2676 if (protolen <= SMALL_PROTONAME) 2677 cachep->cache_proto = cachep->cache_small_proto; 2678 else { 2679 cachep->cache_proto = malloc(protolen + 1); 2680 if (cachep->cache_proto == NULL) 2681 goto nomem; 2682 } 2683 protofmlylen = strlen(nconf->nc_protofmly); 2684 if (protofmlylen <= SMALL_PROTOFMLYNAME) 2685 cachep->cache_protofmly = cachep->cache_small_protofmly; 2686 else { 2687 cachep->cache_protofmly = malloc(protofmlylen + 1); 2688 if (cachep->cache_protofmly == NULL) 2689 goto nomem; 2690 } 2691 2692 strcpy(cachep->cache_proto, nconf->nc_proto); 2693 cachep->cache_prog = prog; 2694 cachep->cache_vers = vers; 2695 cachep->cache_time = timenow + portmap_cache_valid_time; 2696 cachep->cache_srv_addr.len = addrp->len; 2697 cachep->cache_srv_addr.buf = malloc(addrp->len); 2698 if (cachep->cache_srv_addr.buf == NULL) 2699 goto nomem; 2700 memcpy(cachep->cache_srv_addr.buf, addrp->buf, addrp->maxlen); 2701 cachep->cache_prev = NULL; 2702 (void) rw_wrlock(&portmap_cache_lock); 2703 /* 2704 * There's a window in which we could have multiple threads making 2705 * the same cache entry. This can be avoided by walking the cache 2706 * once again here to check and see if there are duplicate entries 2707 * (after grabbing the write lock). This isn't fatal and I'm not 2708 * going to bother with this. 2709 */ 2710 #ifdef CACHE_DEBUG 2711 portmap_cache_accesses++; /* up portmap cache access counter */ 2712 #endif /* CACHE_DEBUG */ 2713 cachep->cache_next = portmap_cache_head; 2714 if (portmap_cache_head != NULL) 2715 portmap_cache_head->cache_prev = cachep; 2716 portmap_cache_head = cachep; 2717 (void) rw_unlock(&portmap_cache_lock); 2718 return; 2719 2720 nomem: 2721 syslog(LOG_ERR, "portmap_cache_enter: Memory allocation failed"); 2722 if (cachep->cache_srv_addr.buf) 2723 free(cachep->cache_srv_addr.buf); 2724 if (cachep->cache_proto && protolen > SMALL_PROTONAME) 2725 free(cachep->cache_proto); 2726 if (cachep->cache_hostname && hostnamelen > SMALL_HOSTNAME) 2727 free(cachep->cache_hostname); 2728 if (cachep->cache_protofmly && protofmlylen > SMALL_PROTOFMLYNAME) 2729 free(cachep->cache_protofmly); 2730 if (cachep) 2731 free(cachep); 2732 cachep = NULL; 2733 } 2734 2735 static int 2736 get_cached_srv_addr(char *hostname, rpcprog_t prog, rpcvers_t vers, 2737 struct netconfig *nconf, struct netbuf *addrp) 2738 { 2739 if (portmap_cache_lookup(hostname, prog, vers, nconf, addrp)) 2740 return (1); 2741 if (rpcb_getaddr(prog, vers, nconf, addrp, hostname) == 0) 2742 return (0); 2743 portmap_cache_enter(hostname, prog, vers, nconf, addrp); 2744 return (1); 2745 } 2746 2747 /* 2748 * Get a network address on "hostname" for program "prog" 2749 * with version "vers". If the port number is specified (non zero) 2750 * then try for a TCP/UDP transport and set the port number of the 2751 * resulting IP address. 2752 * 2753 * If the address of a netconfig pointer was passed and 2754 * if it's not null, use it as the netconfig otherwise 2755 * assign the address of the netconfig that was used to 2756 * establish contact with the service. 2757 * 2758 * tinfo argument is for matching the get_addr() defined in 2759 * ../nfs/mount/mount.c 2760 */ 2761 2762 static struct netbuf * 2763 get_addr(char *hostname, rpcprog_t prog, rpcvers_t vers, 2764 struct netconfig **nconfp, char *proto, ushort_t port, 2765 struct t_info *tinfo) 2766 2767 { 2768 enum clnt_stat cstat; 2769 2770 return (get_server_netinfo(SERVER_ADDR, hostname, prog, vers, NULL, 2771 nconfp, proto, port, tinfo, NULL, FALSE, NULL, &cstat)); 2772 } 2773 2774 static struct netbuf * 2775 get_pubfh(char *hostname, rpcvers_t vers, mfs_snego_t *mfssnego, 2776 struct netconfig **nconfp, char *proto, ushort_t port, 2777 struct t_info *tinfo, caddr_t *fhp, bool_t get_pubfh, char *fspath) 2778 { 2779 enum clnt_stat cstat; 2780 2781 return (get_server_netinfo(SERVER_FH, hostname, NFS_PROGRAM, vers, 2782 mfssnego, nconfp, proto, port, tinfo, fhp, get_pubfh, fspath, 2783 &cstat)); 2784 } 2785 2786 static enum clnt_stat 2787 get_ping(char *hostname, rpcprog_t prog, rpcvers_t vers, 2788 struct netconfig **nconfp, ushort_t port, bool_t direct_to_server) 2789 { 2790 enum clnt_stat cstat; 2791 2792 (void) get_server_netinfo(SERVER_PING, hostname, prog, 2793 vers, NULL, nconfp, NULL, port, NULL, NULL, 2794 direct_to_server, NULL, &cstat); 2795 2796 return (cstat); 2797 } 2798 2799 void * 2800 get_server_netinfo( 2801 enum type_of_stuff type_of_stuff, 2802 char *hostname, 2803 rpcprog_t prog, 2804 rpcvers_t vers, 2805 mfs_snego_t *mfssnego, 2806 struct netconfig **nconfp, 2807 char *proto, 2808 ushort_t port, /* may be zero */ 2809 struct t_info *tinfo, 2810 caddr_t *fhp, 2811 bool_t direct_to_server, 2812 char *fspath, 2813 enum clnt_stat *cstatp) 2814 { 2815 struct netbuf *nb = NULL; 2816 struct netconfig *nconf = NULL; 2817 NCONF_HANDLE *nc = NULL; 2818 int error = 0; 2819 int fd = 0; 2820 struct t_bind *tbind = NULL; 2821 int nthtry = FIRST_TRY; 2822 2823 if (nconfp && *nconfp) { 2824 return (get_netconfig_info(type_of_stuff, hostname, 2825 prog, vers, nconf, port, tinfo, tbind, fhp, 2826 direct_to_server, fspath, cstatp, mfssnego)); 2827 } 2828 2829 /* 2830 * No nconf passed in. 2831 * 2832 * Try to get a nconf from /etc/netconfig. 2833 * First choice is COTS, second is CLTS unless proto 2834 * is specified. When we retry, we reset the 2835 * netconfig list, so that we search the whole list 2836 * for the next choice. 2837 */ 2838 if ((nc = setnetpath()) == NULL) 2839 goto done; 2840 2841 /* 2842 * If proto is specified, then only search for the match, 2843 * otherwise try COTS first, if failed, then try CLTS. 2844 */ 2845 if (proto) { 2846 while ((nconf = getnetpath(nc)) != NULL) { 2847 if (strcmp(nconf->nc_proto, proto)) 2848 continue; 2849 /* 2850 * If the port number is specified then TCP/UDP 2851 * is needed. Otherwise any cots/clts will do. 2852 */ 2853 if (port) { 2854 if ((strcmp(nconf->nc_protofmly, NC_INET) && 2855 strcmp(nconf->nc_protofmly, NC_INET6)) || 2856 (strcmp(nconf->nc_proto, NC_TCP) && 2857 strcmp(nconf->nc_proto, NC_UDP))) 2858 continue; 2859 } 2860 nb = get_netconfig_info(type_of_stuff, hostname, 2861 prog, vers, nconf, port, tinfo, tbind, fhp, 2862 direct_to_server, fspath, cstatp, mfssnego); 2863 if (*cstatp == RPC_SUCCESS) 2864 break; 2865 2866 assert(nb == NULL); 2867 2868 } 2869 if (nconf == NULL) 2870 goto done; 2871 } else { 2872 retry: 2873 while ((nconf = getnetpath(nc)) != NULL) { 2874 if (nconf->nc_flag & NC_VISIBLE) { 2875 if (nthtry == FIRST_TRY) { 2876 if ((nconf->nc_semantics == 2877 NC_TPI_COTS_ORD) || 2878 (nconf->nc_semantics == 2879 NC_TPI_COTS)) { 2880 if (port == 0) 2881 break; 2882 if ((strcmp(nconf->nc_protofmly, 2883 NC_INET) == 0 || 2884 strcmp(nconf->nc_protofmly, 2885 NC_INET6) == 0) && 2886 (strcmp(nconf->nc_proto, 2887 NC_TCP) == 0)) 2888 break; 2889 } 2890 } 2891 if (nthtry == SECOND_TRY) { 2892 if (nconf->nc_semantics == 2893 NC_TPI_CLTS) { 2894 if (port == 0) 2895 break; 2896 if ((strcmp(nconf->nc_protofmly, 2897 NC_INET) == 0 || 2898 strcmp(nconf->nc_protofmly, 2899 NC_INET6) == 0) && 2900 (strcmp(nconf->nc_proto, 2901 NC_UDP) == 0)) 2902 break; 2903 } 2904 } 2905 } 2906 } 2907 2908 if (nconf == NULL) { 2909 if (++nthtry <= MNT_PREF_LISTLEN) { 2910 endnetpath(nc); 2911 if ((nc = setnetpath()) == NULL) 2912 goto done; 2913 goto retry; 2914 } else 2915 goto done; 2916 } else { 2917 nb = get_netconfig_info(type_of_stuff, hostname, 2918 prog, vers, nconf, port, tinfo, tbind, fhp, 2919 direct_to_server, fspath, cstatp, mfssnego); 2920 if (*cstatp != RPC_SUCCESS) 2921 /* 2922 * Continue the same search path in the 2923 * netconfig db until no more matched nconf 2924 * (nconf == NULL). 2925 */ 2926 goto retry; 2927 } 2928 } 2929 2930 /* 2931 * Got nconf and nb. Now dup the netconfig structure (nconf) 2932 * and return it thru nconfp. 2933 */ 2934 if (nconf != NULL) { 2935 if ((*nconfp = getnetconfigent(nconf->nc_netid)) == NULL) { 2936 syslog(LOG_ERR, "no memory\n"); 2937 free(nb); 2938 nb = NULL; 2939 } 2940 } else { 2941 *nconfp = NULL; 2942 } 2943 done: 2944 if (nc) 2945 endnetpath(nc); 2946 return (nb); 2947 } 2948 2949 void * 2950 get_server_fh(char *hostname, rpcprog_t prog, rpcvers_t vers, 2951 mfs_snego_t *mfssnego, struct netconfig *nconf, ushort_t port, 2952 struct t_info *tinfo, struct t_bind *tbind, caddr_t *fhp, 2953 bool_t direct_to_server, char *fspath, enum clnt_stat *cstat) 2954 { 2955 AUTH *ah = NULL; 2956 AUTH *new_ah = NULL; 2957 struct snego_t snego; 2958 enum clnt_stat cs = RPC_TIMEDOUT; 2959 struct timeval tv; 2960 bool_t file_handle = 1; 2961 enum snego_stat sec; 2962 CLIENT *cl = NULL; 2963 int fd = -1; 2964 struct netbuf *nb = NULL; 2965 2966 if (direct_to_server != TRUE) 2967 return (NULL); 2968 2969 if (prog == NFS_PROGRAM && vers == NFS_V4) 2970 if (strncasecmp(nconf->nc_proto, NC_UDP, strlen(NC_UDP)) == 0) 2971 goto done; 2972 2973 if ((fd = t_open(nconf->nc_device, O_RDWR, tinfo)) < 0) 2974 goto done; 2975 2976 /* LINTED pointer alignment */ 2977 if ((tbind = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR)) == NULL) 2978 goto done; 2979 2980 if (setup_nb_parms(nconf, tbind, tinfo, hostname, fd, 2981 direct_to_server, port, prog, vers, file_handle) < 0) { 2982 goto done; 2983 } 2984 2985 cl = clnt_tli_create(fd, nconf, &tbind->addr, prog, vers, 0, 0); 2986 if (cl == NULL) 2987 goto done; 2988 2989 ah = authsys_create_default(); 2990 if (ah != NULL) { 2991 #ifdef MALLOC_DEBUG 2992 drop_alloc("AUTH_HANDLE", cl->cl_auth, 2993 __FILE__, __LINE__); 2994 #endif 2995 AUTH_DESTROY(cl->cl_auth); 2996 cl->cl_auth = ah; 2997 #ifdef MALLOC_DEBUG 2998 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 2999 __FILE__, __LINE__); 3000 #endif 3001 } 3002 3003 if (!mfssnego->snego_done && vers != NFS_V4) { 3004 /* 3005 * negotiate sec flavor. 3006 */ 3007 snego.cnt = 0; 3008 if ((sec = nfs_sec_nego(vers, cl, fspath, &snego)) == 3009 SNEGO_SUCCESS) { 3010 int jj; 3011 3012 /* 3013 * check if server supports the one 3014 * specified in the sec= option. 3015 */ 3016 if (mfssnego->sec_opt) { 3017 for (jj = 0; jj < snego.cnt; jj++) { 3018 if (snego.array[jj] == 3019 mfssnego->nfs_sec.sc_nfsnum) { 3020 mfssnego->snego_done = TRUE; 3021 break; 3022 } 3023 } 3024 } 3025 3026 /* 3027 * find a common sec flavor 3028 */ 3029 if (!mfssnego->snego_done) { 3030 for (jj = 0; jj < snego.cnt; jj++) { 3031 if (!nfs_getseconfig_bynumber( 3032 snego.array[jj], 3033 &mfssnego->nfs_sec)) { 3034 mfssnego->snego_done = TRUE; 3035 break; 3036 } 3037 } 3038 } 3039 if (!mfssnego->snego_done) 3040 goto done; 3041 /* 3042 * Now that the flavor has been 3043 * negotiated, get the fh. 3044 * 3045 * First, create an auth handle using the negotiated 3046 * sec flavor in the next lookup to 3047 * fetch the filehandle. 3048 */ 3049 new_ah = nfs_create_ah(cl, hostname, 3050 &mfssnego->nfs_sec); 3051 if (new_ah == NULL) 3052 goto done; 3053 #ifdef MALLOC_DEBUG 3054 drop_alloc("AUTH_HANDLE", cl->cl_auth, 3055 __FILE__, __LINE__); 3056 #endif 3057 AUTH_DESTROY(cl->cl_auth); 3058 cl->cl_auth = new_ah; 3059 #ifdef MALLOC_DEBUG 3060 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 3061 __FILE__, __LINE__); 3062 #endif 3063 } else if (sec == SNEGO_ARRAY_TOO_SMALL || 3064 sec == SNEGO_FAILURE) { 3065 goto done; 3066 } 3067 } 3068 3069 switch (vers) { 3070 case NFS_VERSION: 3071 { 3072 wnl_diropargs arg; 3073 wnl_diropres res; 3074 3075 memset((char *)&arg.dir, 0, sizeof (wnl_fh)); 3076 memset((char *)&res, 0, sizeof (wnl_diropres)); 3077 arg.name = fspath; 3078 if (wnlproc_lookup_2(&arg, &res, cl) != 3079 RPC_SUCCESS || res.status != WNL_OK) 3080 goto done; 3081 *fhp = malloc(sizeof (wnl_fh)); 3082 3083 if (*fhp == NULL) { 3084 syslog(LOG_ERR, "no memory\n"); 3085 goto done; 3086 } 3087 3088 memcpy((char *)*fhp, 3089 (char *)&res.wnl_diropres_u.wnl_diropres.file, 3090 sizeof (wnl_fh)); 3091 cs = RPC_SUCCESS; 3092 } 3093 break; 3094 case NFS_V3: 3095 { 3096 WNL_LOOKUP3args arg; 3097 WNL_LOOKUP3res res; 3098 nfs_fh3 *fh3p; 3099 3100 memset((char *)&arg.what.dir, 0, sizeof (wnl_fh3)); 3101 memset((char *)&res, 0, sizeof (WNL_LOOKUP3res)); 3102 arg.what.name = fspath; 3103 if (wnlproc3_lookup_3(&arg, &res, cl) != 3104 RPC_SUCCESS || res.status != WNL3_OK) 3105 goto done; 3106 3107 fh3p = (nfs_fh3 *)malloc(sizeof (*fh3p)); 3108 3109 if (fh3p == NULL) { 3110 syslog(LOG_ERR, "no memory\n"); 3111 goto done; 3112 } 3113 3114 fh3p->fh3_length = 3115 res.WNL_LOOKUP3res_u.res_ok.object.data.data_len; 3116 memcpy(fh3p->fh3_u.data, 3117 res.WNL_LOOKUP3res_u.res_ok.object.data.data_val, 3118 fh3p->fh3_length); 3119 3120 *fhp = (caddr_t)fh3p; 3121 3122 cs = RPC_SUCCESS; 3123 } 3124 break; 3125 case NFS_V4: 3126 tv.tv_sec = 10; 3127 tv.tv_usec = 0; 3128 cs = clnt_call(cl, NULLPROC, xdr_void, 0, 3129 xdr_void, 0, tv); 3130 if (cs != RPC_SUCCESS) 3131 goto done; 3132 3133 *fhp = strdup(fspath); 3134 if (fhp == NULL) { 3135 cs = RPC_SYSTEMERROR; 3136 goto done; 3137 } 3138 break; 3139 } 3140 nb = (struct netbuf *)malloc(sizeof (struct netbuf)); 3141 if (nb == NULL) { 3142 syslog(LOG_ERR, "no memory\n"); 3143 cs = RPC_SYSTEMERROR; 3144 goto done; 3145 } 3146 nb->buf = (char *)malloc(tbind->addr.maxlen); 3147 if (nb->buf == NULL) { 3148 syslog(LOG_ERR, "no memory\n"); 3149 free(nb); 3150 nb = NULL; 3151 cs = RPC_SYSTEMERROR; 3152 goto done; 3153 } 3154 (void) memcpy(nb->buf, tbind->addr.buf, tbind->addr.len); 3155 nb->len = tbind->addr.len; 3156 nb->maxlen = tbind->addr.maxlen; 3157 done: 3158 if (cstat != NULL) 3159 *cstat = cs; 3160 destroy_auth_client_handle(cl); 3161 cleanup_tli_parms(tbind, fd); 3162 return (nb); 3163 } 3164 3165 /* 3166 * Sends a null call to the remote host's (NFS program, versp). versp 3167 * may be "NULL" in which case the default maximum version is used. 3168 * Upon return, versp contains the maximum version supported iff versp!= NULL. 3169 */ 3170 enum clnt_stat 3171 pingnfs( 3172 char *hostpart, 3173 int attempts, 3174 rpcvers_t *versp, 3175 rpcvers_t versmin, 3176 ushort_t port, /* may be zero */ 3177 bool_t usepub, 3178 char *path, 3179 char *proto) 3180 { 3181 CLIENT *cl = NULL; 3182 struct timeval rpc_to_new = {15, 0}; 3183 static struct timeval rpc_rtrans_new = {-1, -1}; 3184 enum clnt_stat clnt_stat; 3185 int i, j; 3186 rpcvers_t versmax; /* maximum version to try against server */ 3187 rpcvers_t outvers; /* version supported by host on last call */ 3188 rpcvers_t vers_to_try; /* to try different versions against host */ 3189 char *hostname; 3190 struct netconfig *nconf; 3191 3192 hostname = strdup(hostpart); 3193 if (hostname == NULL) { 3194 return (RPC_SYSTEMERROR); 3195 } 3196 unbracket(&hostname); 3197 3198 if (path != NULL && strcmp(hostname, "nfs") == 0 && 3199 strncmp(path, "//", 2) == 0) { 3200 char *sport; 3201 3202 hostname = strdup(path+2); 3203 3204 if (hostname == NULL) 3205 return (RPC_SYSTEMERROR); 3206 3207 path = strchr(hostname, '/'); 3208 3209 /* 3210 * This cannot happen. If it does, give up 3211 * on the ping as this is obviously a corrupt 3212 * entry. 3213 */ 3214 if (path == NULL) { 3215 free(hostname); 3216 return (RPC_SUCCESS); 3217 } 3218 3219 /* 3220 * Probable end point of host string. 3221 */ 3222 *path = '\0'; 3223 3224 sport = strchr(hostname, ':'); 3225 3226 if (sport != NULL && sport < path) { 3227 3228 /* 3229 * Actual end point of host string. 3230 */ 3231 *sport = '\0'; 3232 port = htons((ushort_t)atoi(sport+1)); 3233 } 3234 3235 usepub = TRUE; 3236 } 3237 3238 /* Pick up the default versions and then set them appropriately */ 3239 if (versp) { 3240 versmax = *versp; 3241 /* use versmin passed in */ 3242 } else { 3243 read_default_nfs(); 3244 set_versrange(0, &versmax, &versmin); 3245 } 3246 3247 if (proto && 3248 strncasecmp(proto, NC_UDP, strlen(NC_UDP)) == 0 && 3249 versmax == NFS_V4) { 3250 if (versmin == NFS_V4) { 3251 if (versp) { 3252 *versp = versmax - 1; 3253 return (RPC_SUCCESS); 3254 } 3255 return (RPC_PROGUNAVAIL); 3256 } else { 3257 versmax--; 3258 } 3259 } 3260 3261 if (versp) 3262 *versp = versmax; 3263 3264 switch (cache_check(hostname, versp, proto)) { 3265 case GOODHOST: 3266 if (hostname != hostpart) 3267 free(hostname); 3268 return (RPC_SUCCESS); 3269 case DEADHOST: 3270 if (hostname != hostpart) 3271 free(hostname); 3272 return (RPC_TIMEDOUT); 3273 case NOHOST: 3274 default: 3275 break; 3276 } 3277 3278 /* 3279 * XXX The retransmission time rpcbrmttime is a global defined 3280 * in the rpc library (rpcb_clnt.c). We use (and like) the default 3281 * value of 15 sec in the rpc library. The code below is to protect 3282 * us in case it changes. This need not be done under a lock since 3283 * any # of threads entering this function will get the same 3284 * retransmission value. 3285 */ 3286 if (rpc_rtrans_new.tv_sec == -1 && rpc_rtrans_new.tv_usec == -1) { 3287 __rpc_control(CLCR_GET_RPCB_RMTTIME, (char *)&rpc_rtrans_new); 3288 if (rpc_rtrans_new.tv_sec != 15 && rpc_rtrans_new.tv_sec != 0) 3289 if (trace > 1) 3290 trace_prt(1, "RPC library rttimer changed\n"); 3291 } 3292 3293 /* 3294 * XXX Manipulate the total timeout to get the number of 3295 * desired retransmissions. This code is heavily dependant on 3296 * the RPC backoff mechanism in clnt_dg_call (clnt_dg.c). 3297 */ 3298 for (i = 0, j = rpc_rtrans_new.tv_sec; i < attempts-1; i++) { 3299 if (j < RPC_MAX_BACKOFF) 3300 j *= 2; 3301 else 3302 j = RPC_MAX_BACKOFF; 3303 rpc_to_new.tv_sec += j; 3304 } 3305 3306 vers_to_try = versmax; 3307 3308 /* 3309 * check the host's version within the timeout 3310 */ 3311 if (trace > 1) 3312 trace_prt(1, " ping: %s timeout=%ld request vers=%d min=%d\n", 3313 hostname, rpc_to_new.tv_sec, versmax, versmin); 3314 3315 if (usepub == FALSE) { 3316 do { 3317 /* 3318 * If NFSv4, then we do the same thing as is used 3319 * for public filehandles so that we avoid rpcbind 3320 */ 3321 if (vers_to_try == NFS_V4) { 3322 if (trace > 4) { 3323 trace_prt(1, " pingnfs: Trying ping via " 3324 "\"circuit_v\"\n"); 3325 } 3326 3327 cl = clnt_create_service_timed(hostname, "nfs", 3328 NFS_PROGRAM, vers_to_try, 3329 port, "circuit_v", &rpc_to_new); 3330 if (cl != NULL) { 3331 outvers = vers_to_try; 3332 break; 3333 } 3334 if (trace > 4) { 3335 trace_prt(1, 3336 " pingnfs: Can't ping via " 3337 "\"circuit_v\" %s: RPC error=%d\n", 3338 hostname, rpc_createerr.cf_stat); 3339 } 3340 3341 } else { 3342 cl = clnt_create_vers_timed(hostname, 3343 NFS_PROGRAM, &outvers, versmin, vers_to_try, 3344 "datagram_v", &rpc_to_new); 3345 if (cl != NULL) 3346 break; 3347 if (trace > 4) { 3348 trace_prt(1, 3349 " pingnfs: Can't ping via " 3350 "\"datagram_v\"%s: RPC error=%d\n", 3351 hostname, rpc_createerr.cf_stat); 3352 } 3353 if (rpc_createerr.cf_stat == RPC_UNKNOWNHOST || 3354 rpc_createerr.cf_stat == RPC_TIMEDOUT) 3355 break; 3356 if (rpc_createerr.cf_stat == 3357 RPC_PROGNOTREGISTERED) { 3358 if (trace > 4) { 3359 trace_prt(1, 3360 " pingnfs: Trying ping " 3361 "via \"circuit_v\"\n"); 3362 } 3363 cl = clnt_create_vers_timed(hostname, 3364 NFS_PROGRAM, &outvers, 3365 versmin, vers_to_try, 3366 "circuit_v", &rpc_to_new); 3367 if (cl != NULL) 3368 break; 3369 if (trace > 4) { 3370 trace_prt(1, 3371 " pingnfs: Can't ping " 3372 "via \"circuit_v\" %s: " 3373 "RPC error=%d\n", 3374 hostname, 3375 rpc_createerr.cf_stat); 3376 } 3377 } 3378 } 3379 3380 /* 3381 * backoff and return lower version to retry the ping. 3382 * XXX we should be more careful and handle 3383 * RPC_PROGVERSMISMATCH here, because that error is handled 3384 * in clnt_create_vers(). It's not done to stay in sync 3385 * with the nfs mount command. 3386 */ 3387 vers_to_try--; 3388 if (vers_to_try < versmin) 3389 break; 3390 if (versp != NULL) { /* recheck the cache */ 3391 *versp = vers_to_try; 3392 if (trace > 4) { 3393 trace_prt(1, 3394 " pingnfs: check cache: vers=%d\n", 3395 *versp); 3396 } 3397 switch (cache_check(hostname, versp, proto)) { 3398 case GOODHOST: 3399 if (hostname != hostpart) 3400 free(hostname); 3401 return (RPC_SUCCESS); 3402 case DEADHOST: 3403 if (hostname != hostpart) 3404 free(hostname); 3405 return (RPC_TIMEDOUT); 3406 case NOHOST: 3407 default: 3408 break; 3409 } 3410 } 3411 if (trace > 4) { 3412 trace_prt(1, " pingnfs: Try version=%d\n", 3413 vers_to_try); 3414 } 3415 } while (cl == NULL); 3416 3417 3418 if (cl == NULL) { 3419 if (verbose) 3420 syslog(LOG_ERR, "pingnfs: %s%s", 3421 hostname, clnt_spcreateerror("")); 3422 clnt_stat = rpc_createerr.cf_stat; 3423 } else { 3424 clnt_destroy(cl); 3425 clnt_stat = RPC_SUCCESS; 3426 } 3427 3428 } else { 3429 for (vers_to_try = versmax; vers_to_try >= versmin; 3430 vers_to_try--) { 3431 3432 nconf = NULL; 3433 3434 if (trace > 4) { 3435 trace_prt(1, " pingnfs: Try version=%d " 3436 "using get_ping()\n", vers_to_try); 3437 } 3438 3439 clnt_stat = get_ping(hostname, NFS_PROGRAM, 3440 vers_to_try, &nconf, port, TRUE); 3441 3442 if (nconf != NULL) 3443 freenetconfigent(nconf); 3444 3445 if (clnt_stat == RPC_SUCCESS) { 3446 outvers = vers_to_try; 3447 break; 3448 } 3449 } 3450 } 3451 3452 if (trace > 1) 3453 clnt_stat == RPC_SUCCESS ? 3454 trace_prt(1, " pingnfs OK: nfs version=%d\n", outvers): 3455 trace_prt(1, " pingnfs FAIL: can't get nfs version\n"); 3456 3457 if (clnt_stat == RPC_SUCCESS) { 3458 cache_enter(hostname, versmax, outvers, proto, GOODHOST); 3459 if (versp != NULL) 3460 *versp = outvers; 3461 } else 3462 cache_enter(hostname, versmax, versmax, proto, DEADHOST); 3463 3464 if (hostpart != hostname) 3465 free(hostname); 3466 3467 return (clnt_stat); 3468 } 3469 3470 #define MNTTYPE_LOFS "lofs" 3471 3472 int 3473 loopbackmount(fsname, dir, mntopts, overlay) 3474 char *fsname; /* Directory being mounted */ 3475 char *dir; /* Directory being mounted on */ 3476 char *mntopts; 3477 int overlay; 3478 { 3479 struct mnttab mnt; 3480 int flags = 0; 3481 char fstype[] = MNTTYPE_LOFS; 3482 int dirlen; 3483 struct stat st; 3484 char optbuf[MAX_MNTOPT_STR]; 3485 3486 dirlen = strlen(dir); 3487 if (dir[dirlen-1] == ' ') 3488 dirlen--; 3489 3490 if (dirlen == strlen(fsname) && 3491 strncmp(fsname, dir, dirlen) == 0) { 3492 syslog(LOG_ERR, 3493 "Mount of %s on %s would result in deadlock, aborted\n", 3494 fsname, dir); 3495 return (RET_ERR); 3496 } 3497 mnt.mnt_mntopts = mntopts; 3498 if (hasmntopt(&mnt, MNTOPT_RO) != NULL) 3499 flags |= MS_RDONLY; 3500 3501 (void) strlcpy(optbuf, mntopts, sizeof (optbuf)); 3502 3503 if (overlay) 3504 flags |= MS_OVERLAY; 3505 3506 if (trace > 1) 3507 trace_prt(1, 3508 " loopbackmount: fsname=%s, dir=%s, flags=%d\n", 3509 fsname, dir, flags); 3510 3511 if (is_system_labeled()) { 3512 if (create_homedir((const char *)fsname, 3513 (const char *)dir) == 0) { 3514 return (NFSERR_NOENT); 3515 } 3516 } 3517 3518 if (mount(fsname, dir, flags | MS_DATA | MS_OPTIONSTR, fstype, 3519 NULL, 0, optbuf, sizeof (optbuf)) < 0) { 3520 syslog(LOG_ERR, "Mount of %s on %s: %m", fsname, dir); 3521 return (RET_ERR); 3522 } 3523 3524 if (stat(dir, &st) == 0) { 3525 if (trace > 1) { 3526 trace_prt(1, 3527 " loopbackmount of %s on %s dev=%x rdev=%x OK\n", 3528 fsname, dir, st.st_dev, st.st_rdev); 3529 } 3530 } else { 3531 if (trace > 1) { 3532 trace_prt(1, 3533 " loopbackmount of %s on %s OK\n", fsname, dir); 3534 trace_prt(1, " stat of %s failed\n", dir); 3535 } 3536 } 3537 3538 return (0); 3539 } 3540 3541 /* 3542 * Look for the value of a numeric option of the form foo=x. If found, set 3543 * *valp to the value and return non-zero. If not found or the option is 3544 * malformed, return zero. 3545 */ 3546 3547 int 3548 nopt(mnt, opt, valp) 3549 struct mnttab *mnt; 3550 char *opt; 3551 int *valp; /* OUT */ 3552 { 3553 char *equal; 3554 char *str; 3555 3556 /* 3557 * We should never get a null pointer, but if we do, it's better to 3558 * ignore the option than to dump core. 3559 */ 3560 3561 if (valp == NULL) { 3562 syslog(LOG_DEBUG, "null pointer for %s option", opt); 3563 return (0); 3564 } 3565 3566 if (str = hasmntopt(mnt, opt)) { 3567 if (equal = strchr(str, '=')) { 3568 *valp = atoi(&equal[1]); 3569 return (1); 3570 } else { 3571 syslog(LOG_ERR, "Bad numeric option '%s'", str); 3572 } 3573 } 3574 return (0); 3575 } 3576 3577 int 3578 nfsunmount(mnt) 3579 struct mnttab *mnt; 3580 { 3581 struct timeval timeout; 3582 CLIENT *cl; 3583 enum clnt_stat rpc_stat; 3584 char *host, *path; 3585 struct replica *list; 3586 int i, count = 0; 3587 int isv4mount = is_v4_mount(mnt->mnt_mountp); 3588 3589 if (trace > 1) 3590 trace_prt(1, " nfsunmount: umount %s\n", mnt->mnt_mountp); 3591 3592 if (umount(mnt->mnt_mountp) < 0) { 3593 if (trace > 1) 3594 trace_prt(1, " nfsunmount: umount %s FAILED\n", 3595 mnt->mnt_mountp); 3596 if (errno) 3597 return (errno); 3598 } 3599 3600 /* 3601 * If this is a NFSv4 mount, the mount protocol was not used 3602 * so we just return. 3603 */ 3604 if (isv4mount) { 3605 if (trace > 1) 3606 trace_prt(1, " nfsunmount: umount %s OK\n", 3607 mnt->mnt_mountp); 3608 return (0); 3609 } 3610 3611 /* 3612 * If mounted with -o public, then no need to contact server 3613 * because mount protocol was not used. 3614 */ 3615 if (hasmntopt(mnt, MNTOPT_PUBLIC) != NULL) { 3616 return (0); 3617 } 3618 3619 /* 3620 * The rest of this code is advisory to the server. 3621 * If it fails return success anyway. 3622 */ 3623 3624 list = parse_replica(mnt->mnt_special, &count); 3625 if (!list) { 3626 if (count >= 0) 3627 syslog(LOG_ERR, 3628 "Memory allocation failed: %m"); 3629 return (ENOMEM); 3630 } 3631 3632 for (i = 0; i < count; i++) { 3633 3634 host = list[i].host; 3635 path = list[i].path; 3636 3637 /* 3638 * Skip file systems mounted using WebNFS, because mount 3639 * protocol was not used. 3640 */ 3641 if (strcmp(host, "nfs") == 0 && strncmp(path, "//", 2) == 0) 3642 continue; 3643 3644 cl = clnt_create(host, MOUNTPROG, MOUNTVERS, "datagram_v"); 3645 if (cl == NULL) 3646 break; 3647 #ifdef MALLOC_DEBUG 3648 add_alloc("CLNT_HANDLE", cl, 0, __FILE__, __LINE__); 3649 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, 3650 __FILE__, __LINE__); 3651 #endif 3652 if (__clnt_bindresvport(cl) < 0) { 3653 if (verbose) 3654 syslog(LOG_ERR, "umount %s:%s: %s", 3655 host, path, 3656 "Couldn't bind to reserved port"); 3657 destroy_auth_client_handle(cl); 3658 continue; 3659 } 3660 #ifdef MALLOC_DEBUG 3661 drop_alloc("AUTH_HANDLE", cl->cl_auth, __FILE__, __LINE__); 3662 #endif 3663 AUTH_DESTROY(cl->cl_auth); 3664 if ((cl->cl_auth = authsys_create_default()) == NULL) { 3665 if (verbose) 3666 syslog(LOG_ERR, "umount %s:%s: %s", 3667 host, path, 3668 "Failed creating default auth handle"); 3669 destroy_auth_client_handle(cl); 3670 continue; 3671 } 3672 #ifdef MALLOC_DEBUG 3673 add_alloc("AUTH_HANDLE", cl->cl_auth, 0, __FILE__, __LINE__); 3674 #endif 3675 timeout.tv_usec = 0; 3676 timeout.tv_sec = 5; 3677 rpc_stat = clnt_call(cl, MOUNTPROC_UMNT, xdr_dirpath, 3678 (caddr_t)&path, xdr_void, (char *)NULL, timeout); 3679 if (verbose && rpc_stat != RPC_SUCCESS) 3680 syslog(LOG_ERR, "%s: %s", 3681 host, clnt_sperror(cl, "unmount")); 3682 destroy_auth_client_handle(cl); 3683 } 3684 3685 free_replica(list, count); 3686 3687 if (trace > 1) 3688 trace_prt(1, " nfsunmount: umount %s OK\n", mnt->mnt_mountp); 3689 3690 done: 3691 return (0); 3692 } 3693 3694 /* 3695 * Put a new entry in the cache chain by prepending it to the front. 3696 * If there isn't enough memory then just give up. 3697 */ 3698 static void 3699 cache_enter(host, reqvers, outvers, proto, state) 3700 char *host; 3701 rpcvers_t reqvers; 3702 rpcvers_t outvers; 3703 char *proto; 3704 int state; 3705 { 3706 struct cache_entry *entry; 3707 int cache_time = 30; /* sec */ 3708 3709 timenow = time(NULL); 3710 3711 entry = (struct cache_entry *)malloc(sizeof (struct cache_entry)); 3712 if (entry == NULL) 3713 return; 3714 (void) memset((caddr_t)entry, 0, sizeof (struct cache_entry)); 3715 entry->cache_host = strdup(host); 3716 if (entry->cache_host == NULL) { 3717 cache_free(entry); 3718 return; 3719 } 3720 entry->cache_reqvers = reqvers; 3721 entry->cache_outvers = outvers; 3722 entry->cache_proto = (proto == NULL ? NULL : strdup(proto)); 3723 entry->cache_state = state; 3724 entry->cache_time = timenow + cache_time; 3725 (void) rw_wrlock(&cache_lock); 3726 #ifdef CACHE_DEBUG 3727 host_cache_accesses++; /* up host cache access counter */ 3728 #endif /* CACHE DEBUG */ 3729 entry->cache_next = cache_head; 3730 cache_head = entry; 3731 (void) rw_unlock(&cache_lock); 3732 } 3733 3734 static int 3735 cache_check(host, versp, proto) 3736 char *host; 3737 rpcvers_t *versp; 3738 char *proto; 3739 { 3740 int state = NOHOST; 3741 struct cache_entry *ce, *prev; 3742 3743 timenow = time(NULL); 3744 3745 (void) rw_rdlock(&cache_lock); 3746 3747 #ifdef CACHE_DEBUG 3748 /* Increment the lookup and access counters for the host cache */ 3749 host_cache_accesses++; 3750 host_cache_lookups++; 3751 if ((host_cache_lookups%1000) == 0) 3752 trace_host_cache(); 3753 #endif /* CACHE DEBUG */ 3754 3755 for (ce = cache_head; ce; ce = ce->cache_next) { 3756 if (timenow > ce->cache_time) { 3757 (void) rw_unlock(&cache_lock); 3758 (void) rw_wrlock(&cache_lock); 3759 for (prev = NULL, ce = cache_head; ce; 3760 prev = ce, ce = ce->cache_next) { 3761 if (timenow > ce->cache_time) { 3762 cache_free(ce); 3763 if (prev) 3764 prev->cache_next = NULL; 3765 else 3766 cache_head = NULL; 3767 break; 3768 } 3769 } 3770 (void) rw_unlock(&cache_lock); 3771 return (state); 3772 } 3773 if (strcmp(host, ce->cache_host) != 0) 3774 continue; 3775 if ((proto == NULL && ce->cache_proto != NULL) || 3776 (proto != NULL && ce->cache_proto == NULL)) 3777 continue; 3778 if (proto != NULL && 3779 strcmp(proto, ce->cache_proto) != 0) 3780 continue; 3781 3782 if (versp == NULL || 3783 (versp != NULL && *versp == ce->cache_reqvers) || 3784 (versp != NULL && *versp == ce->cache_outvers)) { 3785 if (versp != NULL) 3786 *versp = ce->cache_outvers; 3787 state = ce->cache_state; 3788 3789 /* increment the host cache hit counters */ 3790 #ifdef CACHE_DEBUG 3791 if (state == GOODHOST) 3792 goodhost_cache_hits++; 3793 if (state == DEADHOST) 3794 deadhost_cache_hits++; 3795 #endif /* CACHE_DEBUG */ 3796 (void) rw_unlock(&cache_lock); 3797 return (state); 3798 } 3799 } 3800 (void) rw_unlock(&cache_lock); 3801 return (state); 3802 } 3803 3804 /* 3805 * Free a cache entry and all entries 3806 * further down the chain since they 3807 * will also be expired. 3808 */ 3809 static void 3810 cache_free(entry) 3811 struct cache_entry *entry; 3812 { 3813 struct cache_entry *ce, *next = NULL; 3814 3815 for (ce = entry; ce; ce = next) { 3816 if (ce->cache_host) 3817 free(ce->cache_host); 3818 if (ce->cache_proto) 3819 free(ce->cache_proto); 3820 next = ce->cache_next; 3821 free(ce); 3822 } 3823 } 3824 3825 #ifdef MALLOC_DEBUG 3826 void 3827 cache_flush() 3828 { 3829 (void) rw_wrlock(&cache_lock); 3830 cache_free(cache_head); 3831 cache_head = NULL; 3832 (void) rw_unlock(&cache_lock); 3833 } 3834 3835 void 3836 flush_caches() 3837 { 3838 mutex_lock(&cleanup_lock); 3839 cond_signal(&cleanup_start_cv); 3840 (void) cond_wait(&cleanup_done_cv, &cleanup_lock); 3841 mutex_unlock(&cleanup_lock); 3842 cache_flush(); 3843 portmap_cache_flush(); 3844 } 3845 #endif 3846 3847 /* 3848 * Returns 1, if port option is NFS_PORT or 3849 * nfsd is running on the port given 3850 * Returns 0, if both port is not NFS_PORT and nfsd is not 3851 * running on the port. 3852 */ 3853 3854 static int 3855 is_nfs_port(char *opts) 3856 { 3857 struct mnttab m; 3858 uint_t nfs_port = 0; 3859 struct servent sv; 3860 char buf[256]; 3861 int got_port; 3862 3863 m.mnt_mntopts = opts; 3864 3865 /* 3866 * Get port specified in options list, if any. 3867 */ 3868 got_port = nopt(&m, MNTOPT_PORT, (int *)&nfs_port); 3869 3870 /* 3871 * if no port specified or it is same as NFS_PORT return nfs 3872 * To use any other daemon the port number should be different 3873 */ 3874 if (!got_port || nfs_port == NFS_PORT) 3875 return (1); 3876 /* 3877 * If daemon is nfsd, return nfs 3878 */ 3879 if (getservbyport_r(nfs_port, NULL, &sv, buf, 256) == &sv && 3880 strcmp(sv.s_name, "nfsd") == 0) 3881 return (1); 3882 3883 /* 3884 * daemon is not nfs 3885 */ 3886 return (0); 3887 } 3888 3889 3890 /* 3891 * destroy_auth_client_handle(cl) 3892 * destroys the created client handle 3893 */ 3894 void 3895 destroy_auth_client_handle(CLIENT *cl) 3896 { 3897 if (cl) { 3898 if (cl->cl_auth) { 3899 #ifdef MALLOC_DEBUG 3900 drop_alloc("AUTH_HANDLE", cl->cl_auth, 3901 __FILE__, __LINE__); 3902 #endif 3903 AUTH_DESTROY(cl->cl_auth); 3904 cl->cl_auth = NULL; 3905 } 3906 #ifdef MALLOC_DEBUG 3907 drop_alloc("CLNT_HANDLE", cl, 3908 __FILE__, __LINE__); 3909 #endif 3910 clnt_destroy(cl); 3911 } 3912 } 3913 3914 3915 /* 3916 * Attempt to figure out which version of NFS to use in pingnfs(). If 3917 * the version number was specified (i.e., non-zero), then use it. 3918 * Otherwise, default to the compiled-in default or the default as set 3919 * by the /etc/default/nfs configuration (as read by read_default(). 3920 */ 3921 int 3922 set_versrange(rpcvers_t nfsvers, rpcvers_t *vers, rpcvers_t *versmin) 3923 { 3924 switch (nfsvers) { 3925 case 0: 3926 *vers = vers_max_default; 3927 *versmin = vers_min_default; 3928 break; 3929 case NFS_V4: 3930 *vers = NFS_V4; 3931 *versmin = NFS_V4; 3932 break; 3933 case NFS_V3: 3934 *vers = NFS_V3; 3935 *versmin = NFS_V3; 3936 break; 3937 case NFS_VERSION: 3938 *vers = NFS_VERSION; /* version 2 */ 3939 *versmin = NFS_VERSMIN; /* version 2 */ 3940 break; 3941 default: 3942 return (-1); 3943 } 3944 return (0); 3945 } 3946 3947 #ifdef CACHE_DEBUG 3948 /* 3949 * trace_portmap_cache() 3950 * traces the portmap cache values at desired points 3951 */ 3952 static void 3953 trace_portmap_cache() 3954 { 3955 syslog(LOG_ERR, "portmap_cache: accesses=%d lookups=%d hits=%d\n", 3956 portmap_cache_accesses, portmap_cache_lookups, 3957 portmap_cache_hits); 3958 } 3959 3960 /* 3961 * trace_host_cache() 3962 * traces the host cache values at desired points 3963 */ 3964 static void 3965 trace_host_cache() 3966 { 3967 syslog(LOG_ERR, 3968 "host_cache: accesses=%d lookups=%d deadhits=%d goodhits=%d\n", 3969 host_cache_accesses, host_cache_lookups, deadhost_cache_hits, 3970 goodhost_cache_hits); 3971 } 3972 #endif /* CACHE_DEBUG */ 3973 3974 /* 3975 * Read the NFS SMF properties to determine if the 3976 * client has been configured for a new min/max for the NFS version to 3977 * use. 3978 */ 3979 3980 #define SVC_NFS_CLIENT "svc:/network/nfs/client" 3981 3982 static void 3983 read_default_nfs(void) 3984 { 3985 struct stat buf; 3986 char defval[4]; 3987 int errno, bufsz; 3988 int tmp, ret = 0; 3989 3990 bufsz = 4; 3991 ret = nfs_smf_get_prop("client_versmin", defval, DEFAULT_INSTANCE, 3992 SCF_TYPE_INTEGER, SVC_NFS_CLIENT, &bufsz); 3993 if (ret == SA_OK) { 3994 errno = 0; 3995 tmp = strtol(defval, (char **)NULL, 10); 3996 if (errno == 0) { 3997 vers_min_default = tmp; 3998 } 3999 } 4000 4001 bufsz = 4; 4002 ret = nfs_smf_get_prop("client_versmax", defval, DEFAULT_INSTANCE, 4003 SCF_TYPE_INTEGER, SVC_NFS_CLIENT, &bufsz); 4004 if (ret == SA_OK) { 4005 errno = 0; 4006 tmp = strtol(defval, (char **)NULL, 10); 4007 if (errno == 0) { 4008 vers_max_default = tmp; 4009 } 4010 } 4011 4012 /* 4013 * Quick sanity check on the values picked up from the 4014 * defaults file. Make sure that a mistake wasn't 4015 * made that will confuse things later on. 4016 * If so, reset to compiled-in defaults 4017 */ 4018 if (vers_min_default > vers_max_default || 4019 vers_min_default < NFS_VERSMIN || 4020 vers_max_default > NFS_VERSMAX) { 4021 if (trace > 1) { 4022 trace_prt(1, 4023 " read_default: version minimum/maximum incorrectly configured\n"); 4024 trace_prt(1, 4025 " read_default: config is min=%d, max%d. Resetting to min=%d, max%d\n", 4026 vers_min_default, vers_max_default, 4027 NFS_VERSMIN_DEFAULT, 4028 NFS_VERSMAX_DEFAULT); 4029 } 4030 vers_min_default = NFS_VERSMIN_DEFAULT; 4031 vers_max_default = NFS_VERSMAX_DEFAULT; 4032 } 4033 } 4034 4035 /* 4036 * Find the mnttab entry that corresponds to "name". 4037 * We're not sure what the name represents: either 4038 * a mountpoint name, or a special name (server:/path). 4039 * Return the last entry in the file that matches. 4040 */ 4041 static struct extmnttab * 4042 mnttab_find(dirname) 4043 char *dirname; 4044 { 4045 FILE *fp; 4046 struct extmnttab mnt; 4047 struct extmnttab *res = NULL; 4048 4049 fp = fopen(MNTTAB, "r"); 4050 if (fp == NULL) { 4051 if (trace > 1) 4052 trace_prt(1, " mnttab_find: unable to open mnttab\n"); 4053 return (NULL); 4054 } 4055 while (getextmntent(fp, &mnt, sizeof (struct extmnttab)) == 0) { 4056 if (strcmp(mnt.mnt_mountp, dirname) == 0 || 4057 strcmp(mnt.mnt_special, dirname) == 0) { 4058 if (res) 4059 fsfreemnttab(res); 4060 res = fsdupmnttab(&mnt); 4061 } 4062 } 4063 4064 resetmnttab(fp); 4065 fclose(fp); 4066 if (res == NULL) { 4067 if (trace > 1) 4068 trace_prt(1, " mnttab_find: unable to find %s\n", 4069 dirname); 4070 } 4071 return (res); 4072 } 4073 4074 /* 4075 * This function's behavior is taken from nfsstat. 4076 * Trying to determine what NFS version was used for the mount. 4077 */ 4078 static int 4079 is_v4_mount(char *mntpath) 4080 { 4081 kstat_ctl_t *kc = NULL; /* libkstat cookie */ 4082 kstat_t *ksp; 4083 ulong_t fsid; 4084 struct mntinfo_kstat mik; 4085 struct extmnttab *mntp; 4086 uint_t mnt_minor; 4087 4088 if ((mntp = mnttab_find(mntpath)) == NULL) 4089 return (FALSE); 4090 4091 /* save the minor number and free the struct so we don't forget */ 4092 mnt_minor = mntp->mnt_minor; 4093 fsfreemnttab(mntp); 4094 4095 if ((kc = kstat_open()) == NULL) 4096 return (FALSE); 4097 4098 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { 4099 if (ksp->ks_type != KSTAT_TYPE_RAW) 4100 continue; 4101 if (strcmp(ksp->ks_module, "nfs") != 0) 4102 continue; 4103 if (strcmp(ksp->ks_name, "mntinfo") != 0) 4104 continue; 4105 if (mnt_minor != ksp->ks_instance) 4106 continue; 4107 4108 if (kstat_read(kc, ksp, &mik) == -1) 4109 continue; 4110 4111 (void) kstat_close(kc); 4112 if (mik.mik_vers == 4) 4113 return (TRUE); 4114 else 4115 return (FALSE); 4116 } 4117 (void) kstat_close(kc); 4118 4119 return (FALSE); 4120 } 4121 4122 static int 4123 create_homedir(const char *src, const char *dst) { 4124 4125 struct stat stbuf; 4126 char *dst_username; 4127 struct passwd *pwd, pwds; 4128 char buf_pwd[NSS_BUFLEN_PASSWD]; 4129 int homedir_len; 4130 int dst_dir_len; 4131 int src_dir_len; 4132 4133 if (trace > 1) 4134 trace_prt(1, "entered create_homedir\n"); 4135 4136 if (stat(src, &stbuf) == 0) { 4137 if (trace > 1) 4138 trace_prt(1, "src exists\n"); 4139 return (1); 4140 } 4141 4142 dst_username = strrchr(dst, '/'); 4143 if (dst_username) { 4144 dst_username++; /* Skip over slash */ 4145 pwd = getpwnam_r(dst_username, &pwds, buf_pwd, 4146 sizeof (buf_pwd)); 4147 if (pwd == NULL) { 4148 return (0); 4149 } 4150 } else { 4151 return (0); 4152 } 4153 4154 homedir_len = strlen(pwd->pw_dir); 4155 dst_dir_len = strlen(dst) - homedir_len; 4156 src_dir_len = strlen(src) - homedir_len; 4157 4158 /* Check that the paths are in the same zone */ 4159 if (src_dir_len < dst_dir_len || 4160 (strncmp(dst, src, dst_dir_len) != 0)) { 4161 if (trace > 1) 4162 trace_prt(1, " paths don't match\n"); 4163 return (0); 4164 } 4165 /* Check that mountpoint is an auto_home entry */ 4166 if (dst_dir_len < 0 || 4167 (strcmp(pwd->pw_dir, dst + dst_dir_len) != 0)) { 4168 return (0); 4169 } 4170 4171 /* Check that source is an home directory entry */ 4172 if (src_dir_len < 0 || 4173 (strcmp(pwd->pw_dir, src + src_dir_len) != 0)) { 4174 if (trace > 1) 4175 trace_prt(1, " homedir (2) doesn't match %s\n", 4176 src+src_dir_len); 4177 return (0); 4178 } 4179 4180 if (mkdir(src, 4181 S_IRUSR | S_IWUSR | S_IXUSR | S_IXGRP | S_IXOTH) == -1) { 4182 if (trace > 1) { 4183 trace_prt(1, " Couldn't mkdir %s\n", src); 4184 } 4185 return (0); 4186 } 4187 4188 if (chown(src, pwd->pw_uid, pwd->pw_gid) == -1) { 4189 unlink(src); 4190 return (0); 4191 } 4192 4193 /* Created new home directory for the user */ 4194 return (1); 4195 } 4196 4197 void 4198 free_nfs_args(struct nfs_args *argp) 4199 { 4200 struct nfs_args *oldp; 4201 while (argp) { 4202 if (argp->pathconf) 4203 free(argp->pathconf); 4204 if (argp->knconf) 4205 free_knconf(argp->knconf); 4206 if (argp->addr) 4207 netbuf_free(argp->addr); 4208 if (argp->syncaddr) 4209 netbuf_free(argp->syncaddr); 4210 if (argp->netname) 4211 free(argp->netname); 4212 if (argp->hostname) 4213 free(argp->hostname); 4214 if (argp->nfs_ext_u.nfs_extB.secdata) 4215 nfs_free_secdata(argp->nfs_ext_u.nfs_extB.secdata); 4216 if (argp->fh) 4217 free(argp->fh); 4218 if (argp->nfs_ext_u.nfs_extA.secdata) { 4219 sec_data_t *sd; 4220 sd = argp->nfs_ext_u.nfs_extA.secdata; 4221 if (sd == NULL) 4222 break; 4223 switch (sd->rpcflavor) { 4224 case AUTH_NONE: 4225 case AUTH_UNIX: 4226 case AUTH_LOOPBACK: 4227 break; 4228 case AUTH_DES: 4229 { 4230 dh_k4_clntdata_t *dhk4; 4231 dhk4 = (dh_k4_clntdata_t *)sd->data; 4232 if (dhk4 == NULL) 4233 break; 4234 if (dhk4->syncaddr.buf) 4235 free(dhk4->syncaddr.buf); 4236 if (dhk4->knconf->knc_protofmly) 4237 free(dhk4->knconf->knc_protofmly); 4238 if (dhk4->knconf->knc_proto) 4239 free(dhk4->knconf->knc_proto); 4240 if (dhk4->knconf) 4241 free(dhk4->knconf); 4242 if (dhk4->netname) 4243 free(dhk4->netname); 4244 free(dhk4); 4245 break; 4246 } 4247 case RPCSEC_GSS: 4248 { 4249 gss_clntdata_t *gss; 4250 gss = (gss_clntdata_t *)sd->data; 4251 if (gss == NULL) 4252 break; 4253 if (gss->mechanism.elements) 4254 free(gss->mechanism.elements); 4255 free(gss); 4256 break; 4257 } 4258 } 4259 } 4260 oldp = argp; 4261 if (argp->nfs_args_ext == NFS_ARGS_EXTB) 4262 argp = argp->nfs_ext_u.nfs_extB.next; 4263 else 4264 argp = NULL; 4265 free(oldp); 4266 } 4267 } 4268 4269 void * 4270 get_netconfig_info(enum type_of_stuff type_of_stuff, char *hostname, 4271 rpcprog_t prog, rpcvers_t vers, struct netconfig *nconf, 4272 ushort_t port, struct t_info *tinfo, struct t_bind *tbind, 4273 caddr_t *fhp, bool_t direct_to_server, char *fspath, 4274 enum clnt_stat *cstat, mfs_snego_t *mfssnego) 4275 { 4276 struct netconfig *nb = NULL; 4277 int ping_server = 0; 4278 4279 4280 if (nconf == NULL) 4281 return (NULL); 4282 4283 switch (type_of_stuff) { 4284 case SERVER_FH: 4285 nb = get_server_fh(hostname, prog, vers, mfssnego, 4286 nconf, port, tinfo, tbind, fhp, direct_to_server, 4287 fspath, cstat); 4288 break; 4289 case SERVER_PING: 4290 ping_server = 1; 4291 case SERVER_ADDR: 4292 nb = get_server_addrorping(hostname, prog, vers, 4293 nconf, port, tinfo, tbind, fhp, direct_to_server, 4294 fspath, cstat, ping_server); 4295 break; 4296 default: 4297 assert(nb != NULL); 4298 } 4299 return (nb); 4300 } 4301 4302 /* 4303 * Get the server address or can we ping it or not. 4304 * Check the portmap cache first for server address. 4305 * If no entries there, ping the server with a NULLPROC rpc. 4306 */ 4307 void * 4308 get_server_addrorping(char *hostname, rpcprog_t prog, rpcvers_t vers, 4309 struct netconfig *nconf, ushort_t port, struct t_info *tinfo, 4310 struct t_bind *tbind, caddr_t *fhp, bool_t direct_to_server, 4311 char *fspath, enum clnt_stat *cstat, int ping_server) 4312 { 4313 struct timeval tv; 4314 enum clnt_stat cs = RPC_TIMEDOUT; 4315 struct netbuf *nb = NULL; 4316 CLIENT *cl = NULL; 4317 int fd = -1; 4318 4319 if (prog == NFS_PROGRAM && vers == NFS_V4) 4320 if (strncasecmp(nconf->nc_proto, NC_UDP, strlen(NC_UDP)) == 0) 4321 goto done; 4322 4323 if ((fd = t_open(nconf->nc_device, O_RDWR, tinfo)) < 0) { 4324 goto done; 4325 } 4326 4327 /* LINTED pointer alignment */ 4328 if ((tbind = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR)) 4329 == NULL) { 4330 goto done; 4331 } 4332 4333 if (direct_to_server != TRUE) { 4334 if (!ping_server) { 4335 if (get_cached_srv_addr(hostname, prog, vers, 4336 nconf, &tbind->addr) == 0) 4337 goto done; 4338 } else { 4339 if (port == 0) 4340 goto done; 4341 } 4342 } 4343 if (setup_nb_parms(nconf, tbind, tinfo, hostname, 4344 fd, direct_to_server, port, prog, vers, 0) < 0) 4345 goto done; 4346 4347 if (port || (direct_to_server == TRUE)) { 4348 tv.tv_sec = 10; 4349 tv.tv_usec = 0; 4350 cl = clnt_tli_create(fd, nconf, &tbind->addr, 4351 prog, vers, 0, 0); 4352 if (cl == NULL) 4353 goto done; 4354 4355 cs = clnt_call(cl, NULLPROC, xdr_void, 0, 4356 xdr_void, 0, tv); 4357 if (cs != RPC_SUCCESS) { 4358 syslog(LOG_ERR, "error is %d", cs); 4359 goto done; 4360 } 4361 } 4362 if (!ping_server) { 4363 nb = (struct netbuf *)malloc(sizeof (struct netbuf)); 4364 if (nb == NULL) { 4365 syslog(LOG_ERR, "no memory\n"); 4366 goto done; 4367 } 4368 nb->buf = (char *)malloc(tbind->addr.maxlen); 4369 if (nb->buf == NULL) { 4370 syslog(LOG_ERR, "no memory\n"); 4371 free(nb); 4372 nb = NULL; 4373 goto done; 4374 } 4375 (void) memcpy(nb->buf, tbind->addr.buf, tbind->addr.len); 4376 nb->len = tbind->addr.len; 4377 nb->maxlen = tbind->addr.maxlen; 4378 cs = RPC_SUCCESS; 4379 } 4380 done: 4381 destroy_auth_client_handle(cl); 4382 cleanup_tli_parms(tbind, fd); 4383 *cstat = cs; 4384 return (nb); 4385 } 4386