1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000-2001 Boris Popov 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/namei.h> 33 #include <sys/kernel.h> 34 #include <sys/proc.h> 35 #include <sys/bio.h> 36 #include <sys/buf.h> 37 #include <sys/fcntl.h> 38 #include <sys/mount.h> 39 #include <sys/unistd.h> 40 #include <sys/vnode.h> 41 #include <sys/limits.h> 42 #include <sys/lockf.h> 43 #include <sys/stat.h> 44 45 #include <vm/vm.h> 46 #include <vm/vm_extern.h> 47 48 #include <netsmb/smb.h> 49 #include <netsmb/smb_conn.h> 50 #include <netsmb/smb_subr.h> 51 52 #include <fs/smbfs/smbfs.h> 53 #include <fs/smbfs/smbfs_node.h> 54 #include <fs/smbfs/smbfs_subr.h> 55 56 /* 57 * Prototypes for SMBFS vnode operations 58 */ 59 static vop_create_t smbfs_create; 60 static vop_mknod_t smbfs_mknod; 61 static vop_open_t smbfs_open; 62 static vop_close_t smbfs_close; 63 static vop_access_t smbfs_access; 64 static vop_getattr_t smbfs_getattr; 65 static vop_setattr_t smbfs_setattr; 66 static vop_read_t smbfs_read; 67 static vop_write_t smbfs_write; 68 static vop_fsync_t smbfs_fsync; 69 static vop_remove_t smbfs_remove; 70 static vop_link_t smbfs_link; 71 static vop_lookup_t smbfs_lookup; 72 static vop_rename_t smbfs_rename; 73 static vop_mkdir_t smbfs_mkdir; 74 static vop_rmdir_t smbfs_rmdir; 75 static vop_symlink_t smbfs_symlink; 76 static vop_readdir_t smbfs_readdir; 77 static vop_strategy_t smbfs_strategy; 78 static vop_print_t smbfs_print; 79 static vop_pathconf_t smbfs_pathconf; 80 static vop_advlock_t smbfs_advlock; 81 static vop_getextattr_t smbfs_getextattr; 82 83 struct vop_vector smbfs_vnodeops = { 84 .vop_default = &default_vnodeops, 85 86 .vop_access = smbfs_access, 87 .vop_advlock = smbfs_advlock, 88 .vop_close = smbfs_close, 89 .vop_create = smbfs_create, 90 .vop_fsync = smbfs_fsync, 91 .vop_getattr = smbfs_getattr, 92 .vop_getextattr = smbfs_getextattr, 93 .vop_getpages = smbfs_getpages, 94 .vop_inactive = smbfs_inactive, 95 .vop_ioctl = smbfs_ioctl, 96 .vop_link = smbfs_link, 97 .vop_lookup = smbfs_lookup, 98 .vop_mkdir = smbfs_mkdir, 99 .vop_mknod = smbfs_mknod, 100 .vop_open = smbfs_open, 101 .vop_pathconf = smbfs_pathconf, 102 .vop_print = smbfs_print, 103 .vop_putpages = smbfs_putpages, 104 .vop_read = smbfs_read, 105 .vop_readdir = smbfs_readdir, 106 .vop_reclaim = smbfs_reclaim, 107 .vop_remove = smbfs_remove, 108 .vop_rename = smbfs_rename, 109 .vop_rmdir = smbfs_rmdir, 110 .vop_setattr = smbfs_setattr, 111 /* .vop_setextattr = smbfs_setextattr,*/ 112 .vop_strategy = smbfs_strategy, 113 .vop_symlink = smbfs_symlink, 114 .vop_write = smbfs_write, 115 }; 116 VFS_VOP_VECTOR_REGISTER(smbfs_vnodeops); 117 118 static int 119 smbfs_access(ap) 120 struct vop_access_args /* { 121 struct vnode *a_vp; 122 accmode_t a_accmode; 123 struct ucred *a_cred; 124 struct thread *a_td; 125 } */ *ap; 126 { 127 struct vnode *vp = ap->a_vp; 128 accmode_t accmode = ap->a_accmode; 129 mode_t mpmode; 130 struct smbmount *smp = VTOSMBFS(vp); 131 132 SMBVDEBUG("\n"); 133 if ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) { 134 switch (vp->v_type) { 135 case VREG: case VDIR: case VLNK: 136 return EROFS; 137 default: 138 break; 139 } 140 } 141 mpmode = vp->v_type == VREG ? smp->sm_file_mode : smp->sm_dir_mode; 142 return (vaccess(vp->v_type, mpmode, smp->sm_uid, 143 smp->sm_gid, ap->a_accmode, ap->a_cred)); 144 } 145 146 /* ARGSUSED */ 147 static int 148 smbfs_open(ap) 149 struct vop_open_args /* { 150 struct vnode *a_vp; 151 int a_mode; 152 struct ucred *a_cred; 153 struct thread *a_td; 154 } */ *ap; 155 { 156 struct vnode *vp = ap->a_vp; 157 struct smbnode *np = VTOSMB(vp); 158 struct smb_cred *scred; 159 struct vattr vattr; 160 int mode = ap->a_mode; 161 int error, accmode; 162 163 SMBVDEBUG("%s,%d\n", np->n_name, (np->n_flag & NOPEN) != 0); 164 if (vp->v_type != VREG && vp->v_type != VDIR) { 165 SMBFSERR("open eacces vtype=%d\n", vp->v_type); 166 return EACCES; 167 } 168 if (vp->v_type == VDIR) { 169 np->n_flag |= NOPEN; 170 return 0; 171 } 172 if (np->n_flag & NMODIFIED) { 173 if ((error = smbfs_vinvalbuf(vp, ap->a_td)) == EINTR) 174 return error; 175 smbfs_attr_cacheremove(vp); 176 error = VOP_GETATTR(vp, &vattr, ap->a_cred); 177 if (error) 178 return error; 179 np->n_mtime.tv_sec = vattr.va_mtime.tv_sec; 180 } else { 181 error = VOP_GETATTR(vp, &vattr, ap->a_cred); 182 if (error) 183 return error; 184 if (np->n_mtime.tv_sec != vattr.va_mtime.tv_sec) { 185 error = smbfs_vinvalbuf(vp, ap->a_td); 186 if (error == EINTR) 187 return error; 188 np->n_mtime.tv_sec = vattr.va_mtime.tv_sec; 189 } 190 } 191 if ((np->n_flag & NOPEN) != 0) 192 return 0; 193 /* 194 * Use DENYNONE to give unixy semantics of permitting 195 * everything not forbidden by permissions. Ie denial 196 * is up to server with clients/openers needing to use 197 * advisory locks for further control. 198 */ 199 accmode = SMB_SM_DENYNONE|SMB_AM_OPENREAD; 200 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 201 accmode = SMB_SM_DENYNONE|SMB_AM_OPENRW; 202 scred = smbfs_malloc_scred(); 203 smb_makescred(scred, ap->a_td, ap->a_cred); 204 error = smbfs_smb_open(np, accmode, scred); 205 if (error) { 206 if (mode & FWRITE) 207 return EACCES; 208 else if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 209 accmode = SMB_SM_DENYNONE|SMB_AM_OPENREAD; 210 error = smbfs_smb_open(np, accmode, scred); 211 } 212 } 213 if (error == 0) { 214 np->n_flag |= NOPEN; 215 vnode_create_vobject(ap->a_vp, vattr.va_size, ap->a_td); 216 } 217 smbfs_attr_cacheremove(vp); 218 smbfs_free_scred(scred); 219 return error; 220 } 221 222 static int 223 smbfs_close(ap) 224 struct vop_close_args /* { 225 struct vnodeop_desc *a_desc; 226 struct vnode *a_vp; 227 int a_fflag; 228 struct ucred *a_cred; 229 struct thread *a_td; 230 } */ *ap; 231 { 232 struct vnode *vp = ap->a_vp; 233 struct thread *td = ap->a_td; 234 struct smbnode *np = VTOSMB(vp); 235 struct smb_cred *scred; 236 237 if (vp->v_type == VDIR && (np->n_flag & NOPEN) != 0 && 238 np->n_dirseq != NULL) { 239 scred = smbfs_malloc_scred(); 240 smb_makescred(scred, td, ap->a_cred); 241 smbfs_findclose(np->n_dirseq, scred); 242 smbfs_free_scred(scred); 243 np->n_dirseq = NULL; 244 } 245 return 0; 246 } 247 248 /* 249 * smbfs_getattr call from vfs. 250 */ 251 static int 252 smbfs_getattr(ap) 253 struct vop_getattr_args /* { 254 struct vnode *a_vp; 255 struct vattr *a_vap; 256 struct ucred *a_cred; 257 } */ *ap; 258 { 259 struct vnode *vp = ap->a_vp; 260 struct smbnode *np = VTOSMB(vp); 261 struct vattr *va=ap->a_vap; 262 struct smbfattr fattr; 263 struct smb_cred *scred; 264 u_quad_t oldsize; 265 int error; 266 267 SMBVDEBUG("%lx: '%s' %d\n", (long)vp, np->n_name, (vp->v_vflag & VV_ROOT) != 0); 268 error = smbfs_attr_cachelookup(vp, va); 269 if (!error) 270 return 0; 271 SMBVDEBUG("not in the cache\n"); 272 scred = smbfs_malloc_scred(); 273 smb_makescred(scred, curthread, ap->a_cred); 274 oldsize = np->n_size; 275 error = smbfs_smb_lookup(np, NULL, 0, &fattr, scred); 276 if (error) { 277 SMBVDEBUG("error %d\n", error); 278 smbfs_free_scred(scred); 279 return error; 280 } 281 smbfs_attr_cacheenter(vp, &fattr); 282 smbfs_attr_cachelookup(vp, va); 283 if (np->n_flag & NOPEN) 284 np->n_size = oldsize; 285 smbfs_free_scred(scred); 286 return 0; 287 } 288 289 static int 290 smbfs_setattr(ap) 291 struct vop_setattr_args /* { 292 struct vnode *a_vp; 293 struct vattr *a_vap; 294 struct ucred *a_cred; 295 } */ *ap; 296 { 297 struct vnode *vp = ap->a_vp; 298 struct smbnode *np = VTOSMB(vp); 299 struct vattr *vap = ap->a_vap; 300 struct timespec *mtime, *atime; 301 struct smb_cred *scred; 302 struct smb_share *ssp = np->n_mount->sm_share; 303 struct smb_vc *vcp = SSTOVC(ssp); 304 struct thread *td = curthread; 305 u_quad_t tsize = 0; 306 int isreadonly, doclose, error = 0; 307 int old_n_dosattr; 308 309 SMBVDEBUG("\n"); 310 isreadonly = (vp->v_mount->mnt_flag & MNT_RDONLY); 311 /* 312 * Disallow write attempts if the filesystem is mounted read-only. 313 */ 314 if ((vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL || 315 vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL || 316 vap->va_mode != (mode_t)VNOVAL || vap->va_flags != VNOVAL) && 317 isreadonly) 318 return EROFS; 319 320 /* 321 * We only support setting four flags. Don't allow setting others. 322 * 323 * We map UF_READONLY to SMB_FA_RDONLY, unlike the MacOS X version 324 * of this code, which maps both UF_IMMUTABLE AND SF_IMMUTABLE to 325 * SMB_FA_RDONLY. The immutable flags have different semantics 326 * than readonly, which is the reason for the difference. 327 */ 328 if (vap->va_flags != VNOVAL) { 329 if (vap->va_flags & ~(UF_HIDDEN|UF_SYSTEM|UF_ARCHIVE| 330 UF_READONLY)) 331 return EINVAL; 332 } 333 334 scred = smbfs_malloc_scred(); 335 smb_makescred(scred, td, ap->a_cred); 336 if (vap->va_size != VNOVAL) { 337 switch (vp->v_type) { 338 case VDIR: 339 error = EISDIR; 340 goto out; 341 case VREG: 342 break; 343 default: 344 error = EINVAL; 345 goto out; 346 } 347 if (isreadonly) { 348 error = EROFS; 349 goto out; 350 } 351 doclose = 0; 352 vnode_pager_setsize(vp, (u_long)vap->va_size); 353 tsize = np->n_size; 354 np->n_size = vap->va_size; 355 if ((np->n_flag & NOPEN) == 0) { 356 error = smbfs_smb_open(np, 357 SMB_SM_DENYNONE|SMB_AM_OPENRW, 358 scred); 359 if (error == 0) 360 doclose = 1; 361 } 362 if (error == 0) 363 error = smbfs_smb_setfsize(np, 364 (int64_t)vap->va_size, scred); 365 if (doclose) 366 smbfs_smb_close(ssp, np->n_fid, NULL, scred); 367 if (error) { 368 np->n_size = tsize; 369 vnode_pager_setsize(vp, (u_long)tsize); 370 goto out; 371 } 372 } 373 if ((vap->va_flags != VNOVAL) || (vap->va_mode != (mode_t)VNOVAL)) { 374 old_n_dosattr = np->n_dosattr; 375 376 if (vap->va_mode != (mode_t)VNOVAL) { 377 if (vap->va_mode & S_IWUSR) 378 np->n_dosattr &= ~SMB_FA_RDONLY; 379 else 380 np->n_dosattr |= SMB_FA_RDONLY; 381 } 382 383 if (vap->va_flags != VNOVAL) { 384 if (vap->va_flags & UF_HIDDEN) 385 np->n_dosattr |= SMB_FA_HIDDEN; 386 else 387 np->n_dosattr &= ~SMB_FA_HIDDEN; 388 389 if (vap->va_flags & UF_SYSTEM) 390 np->n_dosattr |= SMB_FA_SYSTEM; 391 else 392 np->n_dosattr &= ~SMB_FA_SYSTEM; 393 394 if (vap->va_flags & UF_ARCHIVE) 395 np->n_dosattr |= SMB_FA_ARCHIVE; 396 else 397 np->n_dosattr &= ~SMB_FA_ARCHIVE; 398 399 /* 400 * We only support setting the immutable / readonly 401 * bit for regular files. According to comments in 402 * the MacOS X version of this code, supporting the 403 * readonly bit on directories doesn't do the same 404 * thing in Windows as in Unix. 405 */ 406 if (vp->v_type == VREG) { 407 if (vap->va_flags & UF_READONLY) 408 np->n_dosattr |= SMB_FA_RDONLY; 409 else 410 np->n_dosattr &= ~SMB_FA_RDONLY; 411 } 412 } 413 414 if (np->n_dosattr != old_n_dosattr) { 415 error = smbfs_smb_setpattr(np, np->n_dosattr, NULL, scred); 416 if (error) 417 goto out; 418 } 419 } 420 mtime = atime = NULL; 421 if (vap->va_mtime.tv_sec != VNOVAL) 422 mtime = &vap->va_mtime; 423 if (vap->va_atime.tv_sec != VNOVAL) 424 atime = &vap->va_atime; 425 if (mtime != atime) { 426 if (vap->va_vaflags & VA_UTIMES_NULL) { 427 error = VOP_ACCESS(vp, VADMIN, ap->a_cred, td); 428 if (error) 429 error = VOP_ACCESS(vp, VWRITE, ap->a_cred, td); 430 } else 431 error = VOP_ACCESS(vp, VADMIN, ap->a_cred, td); 432 #if 0 433 if (mtime == NULL) 434 mtime = &np->n_mtime; 435 if (atime == NULL) 436 atime = &np->n_atime; 437 #endif 438 /* 439 * If file is opened, then we can use handle based calls. 440 * If not, use path based ones. 441 */ 442 if ((np->n_flag & NOPEN) == 0) { 443 if (vcp->vc_flags & SMBV_WIN95) { 444 error = VOP_OPEN(vp, FWRITE, ap->a_cred, td, 445 NULL); 446 if (!error) { 447 /* error = smbfs_smb_setfattrNT(np, 0, 448 mtime, atime, scred); 449 VOP_GETATTR(vp, &vattr, ap->a_cred); */ 450 if (mtime) 451 np->n_mtime = *mtime; 452 VOP_CLOSE(vp, FWRITE, ap->a_cred, td); 453 } 454 } else if ((vcp->vc_sopt.sv_caps & SMB_CAP_NT_SMBS)) { 455 error = smbfs_smb_setptime2(np, mtime, atime, 0, scred); 456 /* error = smbfs_smb_setpattrNT(np, 0, mtime, atime, scred);*/ 457 } else if (SMB_DIALECT(vcp) >= SMB_DIALECT_LANMAN2_0) { 458 error = smbfs_smb_setptime2(np, mtime, atime, 0, scred); 459 } else { 460 error = smbfs_smb_setpattr(np, 0, mtime, scred); 461 } 462 } else { 463 if (vcp->vc_sopt.sv_caps & SMB_CAP_NT_SMBS) { 464 error = smbfs_smb_setfattrNT(np, 0, mtime, atime, scred); 465 } else if (SMB_DIALECT(vcp) >= SMB_DIALECT_LANMAN1_0) { 466 error = smbfs_smb_setftime(np, mtime, atime, scred); 467 } else { 468 /* 469 * I have no idea how to handle this for core 470 * level servers. The possible solution is to 471 * update mtime after file is closed. 472 */ 473 SMBERROR("can't update times on an opened file\n"); 474 } 475 } 476 } 477 /* 478 * Invalidate attribute cache in case if server doesn't set 479 * required attributes. 480 */ 481 smbfs_attr_cacheremove(vp); /* invalidate cache */ 482 VOP_GETATTR(vp, vap, ap->a_cred); 483 np->n_mtime.tv_sec = vap->va_mtime.tv_sec; 484 out: 485 smbfs_free_scred(scred); 486 return error; 487 } 488 /* 489 * smbfs_read call. 490 */ 491 static int 492 smbfs_read(ap) 493 struct vop_read_args /* { 494 struct vnode *a_vp; 495 struct uio *a_uio; 496 int a_ioflag; 497 struct ucred *a_cred; 498 } */ *ap; 499 { 500 struct vnode *vp = ap->a_vp; 501 struct uio *uio = ap->a_uio; 502 503 SMBVDEBUG("\n"); 504 if (vp->v_type != VREG && vp->v_type != VDIR) 505 return EPERM; 506 return smbfs_readvnode(vp, uio, ap->a_cred); 507 } 508 509 static int 510 smbfs_write(ap) 511 struct vop_write_args /* { 512 struct vnode *a_vp; 513 struct uio *a_uio; 514 int a_ioflag; 515 struct ucred *a_cred; 516 } */ *ap; 517 { 518 struct vnode *vp = ap->a_vp; 519 struct uio *uio = ap->a_uio; 520 521 SMBVDEBUG("%d,ofs=%jd,sz=%zd\n",vp->v_type, (intmax_t)uio->uio_offset, 522 uio->uio_resid); 523 if (vp->v_type != VREG) 524 return (EPERM); 525 return smbfs_writevnode(vp, uio, ap->a_cred,ap->a_ioflag); 526 } 527 /* 528 * smbfs_create call 529 * Create a regular file. On entry the directory to contain the file being 530 * created is locked. We must release before we return. We must also free 531 * the pathname buffer pointed at by cnp->cn_pnbuf, always on error, or 532 * only if the SAVESTART bit in cn_flags is clear on success. 533 */ 534 static int 535 smbfs_create(ap) 536 struct vop_create_args /* { 537 struct vnode *a_dvp; 538 struct vnode **a_vpp; 539 struct componentname *a_cnp; 540 struct vattr *a_vap; 541 } */ *ap; 542 { 543 struct vnode *dvp = ap->a_dvp; 544 struct vattr *vap = ap->a_vap; 545 struct vnode **vpp=ap->a_vpp; 546 struct componentname *cnp = ap->a_cnp; 547 struct smbnode *dnp = VTOSMB(dvp); 548 struct vnode *vp; 549 struct vattr vattr; 550 struct smbfattr fattr; 551 struct smb_cred *scred; 552 char *name = cnp->cn_nameptr; 553 int nmlen = cnp->cn_namelen; 554 int error; 555 556 SMBVDEBUG("\n"); 557 *vpp = NULL; 558 if (vap->va_type != VREG) 559 return EOPNOTSUPP; 560 if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred))) 561 return error; 562 scred = smbfs_malloc_scred(); 563 smb_makescred(scred, curthread, cnp->cn_cred); 564 565 error = smbfs_smb_create(dnp, name, nmlen, scred); 566 if (error) 567 goto out; 568 error = smbfs_smb_lookup(dnp, name, nmlen, &fattr, scred); 569 if (error) 570 goto out; 571 error = smbfs_nget(VTOVFS(dvp), dvp, name, nmlen, &fattr, &vp); 572 if (error) 573 goto out; 574 *vpp = vp; 575 if (cnp->cn_flags & MAKEENTRY) 576 cache_enter(dvp, vp, cnp); 577 out: 578 smbfs_free_scred(scred); 579 return error; 580 } 581 582 static int 583 smbfs_remove(ap) 584 struct vop_remove_args /* { 585 struct vnodeop_desc *a_desc; 586 struct vnode * a_dvp; 587 struct vnode * a_vp; 588 struct componentname * a_cnp; 589 } */ *ap; 590 { 591 struct vnode *vp = ap->a_vp; 592 /* struct vnode *dvp = ap->a_dvp;*/ 593 struct componentname *cnp = ap->a_cnp; 594 struct smbnode *np = VTOSMB(vp); 595 struct smb_cred *scred; 596 int error; 597 598 if (vp->v_type == VDIR || (np->n_flag & NOPEN) != 0 || vrefcnt(vp) != 1) 599 return EPERM; 600 scred = smbfs_malloc_scred(); 601 smb_makescred(scred, curthread, cnp->cn_cred); 602 error = smbfs_smb_delete(np, scred); 603 if (error == 0) 604 np->n_flag |= NGONE; 605 cache_purge(vp); 606 smbfs_free_scred(scred); 607 return error; 608 } 609 610 /* 611 * smbfs_file rename call 612 */ 613 static int 614 smbfs_rename(ap) 615 struct vop_rename_args /* { 616 struct vnode *a_fdvp; 617 struct vnode *a_fvp; 618 struct componentname *a_fcnp; 619 struct vnode *a_tdvp; 620 struct vnode *a_tvp; 621 struct componentname *a_tcnp; 622 } */ *ap; 623 { 624 struct vnode *fvp = ap->a_fvp; 625 struct vnode *tvp = ap->a_tvp; 626 struct vnode *fdvp = ap->a_fdvp; 627 struct vnode *tdvp = ap->a_tdvp; 628 struct componentname *tcnp = ap->a_tcnp; 629 /* struct componentname *fcnp = ap->a_fcnp;*/ 630 struct smb_cred *scred; 631 u_int16_t flags = 6; 632 int error=0; 633 634 scred = NULL; 635 /* Check for cross-device rename */ 636 if ((fvp->v_mount != tdvp->v_mount) || 637 (tvp && (fvp->v_mount != tvp->v_mount))) { 638 error = EXDEV; 639 goto out; 640 } 641 642 if (tvp && vrefcnt(tvp) > 1) { 643 error = EBUSY; 644 goto out; 645 } 646 flags = 0x10; /* verify all writes */ 647 if (fvp->v_type == VDIR) { 648 flags |= 2; 649 } else if (fvp->v_type == VREG) { 650 flags |= 1; 651 } else { 652 return EINVAL; 653 } 654 scred = smbfs_malloc_scred(); 655 smb_makescred(scred, curthread, tcnp->cn_cred); 656 /* 657 * It seems that Samba doesn't implement SMB_COM_MOVE call... 658 */ 659 #ifdef notnow 660 if (SMB_DIALECT(SSTOCN(smp->sm_share)) >= SMB_DIALECT_LANMAN1_0) { 661 error = smbfs_smb_move(VTOSMB(fvp), VTOSMB(tdvp), 662 tcnp->cn_nameptr, tcnp->cn_namelen, flags, scred); 663 } else 664 #endif 665 { 666 /* 667 * We have to do the work atomicaly 668 */ 669 if (tvp && tvp != fvp) { 670 error = smbfs_smb_delete(VTOSMB(tvp), scred); 671 if (error) 672 goto out_cacherem; 673 VTOSMB(fvp)->n_flag |= NGONE; 674 } 675 error = smbfs_smb_rename(VTOSMB(fvp), VTOSMB(tdvp), 676 tcnp->cn_nameptr, tcnp->cn_namelen, scred); 677 } 678 679 if (fvp->v_type == VDIR) { 680 if (tvp != NULL && tvp->v_type == VDIR) 681 cache_purge(tdvp); 682 cache_purge(fdvp); 683 } 684 685 out_cacherem: 686 smbfs_attr_cacheremove(fdvp); 687 smbfs_attr_cacheremove(tdvp); 688 out: 689 smbfs_free_scred(scred); 690 if (tdvp == tvp) 691 vrele(tdvp); 692 else 693 vput(tdvp); 694 if (tvp) 695 vput(tvp); 696 vrele(fdvp); 697 vrele(fvp); 698 #ifdef possible_mistake 699 vgone(fvp); 700 if (tvp) 701 vgone(tvp); 702 #endif 703 return error; 704 } 705 706 /* 707 * somtime it will come true... 708 */ 709 static int 710 smbfs_link(ap) 711 struct vop_link_args /* { 712 struct vnode *a_tdvp; 713 struct vnode *a_vp; 714 struct componentname *a_cnp; 715 } */ *ap; 716 { 717 return EOPNOTSUPP; 718 } 719 720 /* 721 * smbfs_symlink link create call. 722 * Sometime it will be functional... 723 */ 724 static int 725 smbfs_symlink(ap) 726 struct vop_symlink_args /* { 727 struct vnode *a_dvp; 728 struct vnode **a_vpp; 729 struct componentname *a_cnp; 730 struct vattr *a_vap; 731 char *a_target; 732 } */ *ap; 733 { 734 return EOPNOTSUPP; 735 } 736 737 static int 738 smbfs_mknod(ap) 739 struct vop_mknod_args /* { 740 } */ *ap; 741 { 742 return EOPNOTSUPP; 743 } 744 745 static int 746 smbfs_mkdir(ap) 747 struct vop_mkdir_args /* { 748 struct vnode *a_dvp; 749 struct vnode **a_vpp; 750 struct componentname *a_cnp; 751 struct vattr *a_vap; 752 } */ *ap; 753 { 754 struct vnode *dvp = ap->a_dvp; 755 /* struct vattr *vap = ap->a_vap;*/ 756 struct vnode *vp; 757 struct componentname *cnp = ap->a_cnp; 758 struct smbnode *dnp = VTOSMB(dvp); 759 struct vattr vattr; 760 struct smb_cred *scred; 761 struct smbfattr fattr; 762 char *name = cnp->cn_nameptr; 763 int len = cnp->cn_namelen; 764 int error; 765 766 if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred))) { 767 return error; 768 } 769 if ((name[0] == '.') && ((len == 1) || ((len == 2) && (name[1] == '.')))) 770 return EEXIST; 771 scred = smbfs_malloc_scred(); 772 smb_makescred(scred, curthread, cnp->cn_cred); 773 error = smbfs_smb_mkdir(dnp, name, len, scred); 774 if (error) 775 goto out; 776 error = smbfs_smb_lookup(dnp, name, len, &fattr, scred); 777 if (error) 778 goto out; 779 error = smbfs_nget(VTOVFS(dvp), dvp, name, len, &fattr, &vp); 780 if (error) 781 goto out; 782 *ap->a_vpp = vp; 783 out: 784 smbfs_free_scred(scred); 785 return error; 786 } 787 788 /* 789 * smbfs_remove directory call 790 */ 791 static int 792 smbfs_rmdir(ap) 793 struct vop_rmdir_args /* { 794 struct vnode *a_dvp; 795 struct vnode *a_vp; 796 struct componentname *a_cnp; 797 } */ *ap; 798 { 799 struct vnode *vp = ap->a_vp; 800 struct vnode *dvp = ap->a_dvp; 801 struct componentname *cnp = ap->a_cnp; 802 /* struct smbmount *smp = VTOSMBFS(vp);*/ 803 struct smbnode *dnp = VTOSMB(dvp); 804 struct smbnode *np = VTOSMB(vp); 805 struct smb_cred *scred; 806 int error; 807 808 if (dvp == vp) 809 return EINVAL; 810 811 scred = smbfs_malloc_scred(); 812 smb_makescred(scred, curthread, cnp->cn_cred); 813 error = smbfs_smb_rmdir(np, scred); 814 if (error == 0) 815 np->n_flag |= NGONE; 816 dnp->n_flag |= NMODIFIED; 817 smbfs_attr_cacheremove(dvp); 818 /* cache_purge(dvp);*/ 819 cache_purge(vp); 820 smbfs_free_scred(scred); 821 return error; 822 } 823 824 /* 825 * smbfs_readdir call 826 */ 827 static int 828 smbfs_readdir(ap) 829 struct vop_readdir_args /* { 830 struct vnode *a_vp; 831 struct uio *a_uio; 832 struct ucred *a_cred; 833 int *a_eofflag; 834 u_long *a_cookies; 835 int a_ncookies; 836 } */ *ap; 837 { 838 struct vnode *vp = ap->a_vp; 839 struct uio *uio = ap->a_uio; 840 int error; 841 842 if (vp->v_type != VDIR) 843 return (EPERM); 844 #ifdef notnow 845 if (ap->a_ncookies) { 846 printf("smbfs_readdir: no support for cookies now..."); 847 return (EOPNOTSUPP); 848 } 849 #endif 850 error = smbfs_readvnode(vp, uio, ap->a_cred); 851 return error; 852 } 853 854 /* ARGSUSED */ 855 static int 856 smbfs_fsync(ap) 857 struct vop_fsync_args /* { 858 struct vnodeop_desc *a_desc; 859 struct vnode * a_vp; 860 struct ucred * a_cred; 861 int a_waitfor; 862 struct thread * a_td; 863 } */ *ap; 864 { 865 /* return (smb_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1));*/ 866 return (0); 867 } 868 869 static 870 int smbfs_print (ap) 871 struct vop_print_args /* { 872 struct vnode *a_vp; 873 } */ *ap; 874 { 875 struct vnode *vp = ap->a_vp; 876 struct smbnode *np = VTOSMB(vp); 877 878 if (np == NULL) { 879 printf("no smbnode data\n"); 880 return (0); 881 } 882 printf("\tname = %s, parent = %p, open = %d\n", np->n_name, 883 np->n_parent ? np->n_parent : NULL, (np->n_flag & NOPEN) != 0); 884 return (0); 885 } 886 887 static int 888 smbfs_pathconf (ap) 889 struct vop_pathconf_args /* { 890 struct vnode *vp; 891 int name; 892 register_t *retval; 893 } */ *ap; 894 { 895 struct smbmount *smp = VFSTOSMBFS(VTOVFS(ap->a_vp)); 896 struct smb_vc *vcp = SSTOVC(smp->sm_share); 897 long *retval = ap->a_retval; 898 int error = 0; 899 900 switch (ap->a_name) { 901 case _PC_FILESIZEBITS: 902 if (vcp->vc_sopt.sv_caps & (SMB_CAP_LARGE_READX | 903 SMB_CAP_LARGE_WRITEX)) 904 *retval = 64; 905 else 906 *retval = 32; 907 break; 908 case _PC_NAME_MAX: 909 *retval = (vcp->vc_hflags2 & SMB_FLAGS2_KNOWS_LONG_NAMES) ? 255 : 12; 910 break; 911 case _PC_PATH_MAX: 912 *retval = 800; /* XXX: a correct one ? */ 913 break; 914 case _PC_NO_TRUNC: 915 *retval = 1; 916 break; 917 default: 918 error = vop_stdpathconf(ap); 919 } 920 return error; 921 } 922 923 static int 924 smbfs_strategy (ap) 925 struct vop_strategy_args /* { 926 struct buf *a_bp 927 } */ *ap; 928 { 929 struct buf *bp=ap->a_bp; 930 struct ucred *cr; 931 struct thread *td; 932 933 SMBVDEBUG("\n"); 934 if (bp->b_flags & B_ASYNC) 935 td = (struct thread *)0; 936 else 937 td = curthread; /* XXX */ 938 if (bp->b_iocmd == BIO_READ) 939 cr = bp->b_rcred; 940 else 941 cr = bp->b_wcred; 942 943 if ((bp->b_flags & B_ASYNC) == 0 ) 944 (void)smbfs_doio(ap->a_vp, bp, cr, td); 945 return (0); 946 } 947 948 int 949 smbfs_ioctl(ap) 950 struct vop_ioctl_args /* { 951 struct vnode *a_vp; 952 u_long a_command; 953 caddr_t a_data; 954 int fflag; 955 struct ucred *cred; 956 struct thread *td; 957 } */ *ap; 958 { 959 return ENOTTY; 960 } 961 962 static char smbfs_atl[] = "rhsvda"; 963 static int 964 smbfs_getextattr(struct vop_getextattr_args *ap) 965 /* { 966 IN struct vnode *a_vp; 967 IN char *a_name; 968 INOUT struct uio *a_uio; 969 IN struct ucred *a_cred; 970 IN struct thread *a_td; 971 }; 972 */ 973 { 974 struct vnode *vp = ap->a_vp; 975 struct thread *td = ap->a_td; 976 struct ucred *cred = ap->a_cred; 977 struct uio *uio = ap->a_uio; 978 const char *name = ap->a_name; 979 struct smbnode *np = VTOSMB(vp); 980 struct vattr vattr; 981 char buf[10]; 982 int i, attr, error; 983 984 error = VOP_ACCESS(vp, VREAD, cred, td); 985 if (error) 986 return error; 987 error = VOP_GETATTR(vp, &vattr, cred); 988 if (error) 989 return error; 990 if (strcmp(name, "dosattr") == 0) { 991 attr = np->n_dosattr; 992 for (i = 0; i < 6; i++, attr >>= 1) 993 buf[i] = (attr & 1) ? smbfs_atl[i] : '-'; 994 buf[i] = 0; 995 error = uiomove(buf, i, uio); 996 997 } else 998 error = EINVAL; 999 return error; 1000 } 1001 1002 /* 1003 * Since we expected to support F_GETLK (and SMB protocol has no such function), 1004 * it is necessary to use lf_advlock(). It would be nice if this function had 1005 * a callback mechanism because it will help to improve a level of consistency. 1006 */ 1007 int 1008 smbfs_advlock(ap) 1009 struct vop_advlock_args /* { 1010 struct vnode *a_vp; 1011 caddr_t a_id; 1012 int a_op; 1013 struct flock *a_fl; 1014 int a_flags; 1015 } */ *ap; 1016 { 1017 struct vnode *vp = ap->a_vp; 1018 struct smbnode *np = VTOSMB(vp); 1019 struct flock *fl = ap->a_fl; 1020 caddr_t id = (caddr_t)1 /* ap->a_id */; 1021 /* int flags = ap->a_flags;*/ 1022 struct thread *td = curthread; 1023 struct smb_cred *scred; 1024 u_quad_t size; 1025 off_t start, end, oadd; 1026 int error, lkop; 1027 1028 if (vp->v_type == VDIR) { 1029 /* 1030 * SMB protocol have no support for directory locking. 1031 * Although locks can be processed on local machine, I don't 1032 * think that this is a good idea, because some programs 1033 * can work wrong assuming directory is locked. So, we just 1034 * return 'operation not supported 1035 */ 1036 return EOPNOTSUPP; 1037 } 1038 size = np->n_size; 1039 switch (fl->l_whence) { 1040 case SEEK_SET: 1041 case SEEK_CUR: 1042 start = fl->l_start; 1043 break; 1044 1045 case SEEK_END: 1046 if (size > OFF_MAX || 1047 (fl->l_start > 0 && size > OFF_MAX - fl->l_start)) 1048 return EOVERFLOW; 1049 start = size + fl->l_start; 1050 break; 1051 1052 default: 1053 return EINVAL; 1054 } 1055 if (start < 0) 1056 return EINVAL; 1057 if (fl->l_len < 0) { 1058 if (start == 0) 1059 return EINVAL; 1060 end = start - 1; 1061 start += fl->l_len; 1062 if (start < 0) 1063 return EINVAL; 1064 } else if (fl->l_len == 0) 1065 end = -1; 1066 else { 1067 oadd = fl->l_len - 1; 1068 if (oadd > OFF_MAX - start) 1069 return EOVERFLOW; 1070 end = start + oadd; 1071 } 1072 scred = smbfs_malloc_scred(); 1073 smb_makescred(scred, td, td->td_ucred); 1074 switch (ap->a_op) { 1075 case F_SETLK: 1076 switch (fl->l_type) { 1077 case F_WRLCK: 1078 lkop = SMB_LOCK_EXCL; 1079 break; 1080 case F_RDLCK: 1081 lkop = SMB_LOCK_SHARED; 1082 break; 1083 case F_UNLCK: 1084 lkop = SMB_LOCK_RELEASE; 1085 break; 1086 default: 1087 smbfs_free_scred(scred); 1088 return EINVAL; 1089 } 1090 error = lf_advlock(ap, &vp->v_lockf, size); 1091 if (error) 1092 break; 1093 lkop = SMB_LOCK_EXCL; 1094 error = smbfs_smb_lock(np, lkop, id, start, end, scred); 1095 if (error) { 1096 int oldtype = fl->l_type; 1097 fl->l_type = F_UNLCK; 1098 ap->a_op = F_UNLCK; 1099 lf_advlock(ap, &vp->v_lockf, size); 1100 fl->l_type = oldtype; 1101 } 1102 break; 1103 case F_UNLCK: 1104 lf_advlock(ap, &vp->v_lockf, size); 1105 error = smbfs_smb_lock(np, SMB_LOCK_RELEASE, id, start, end, scred); 1106 break; 1107 case F_GETLK: 1108 error = lf_advlock(ap, &vp->v_lockf, size); 1109 break; 1110 default: 1111 smbfs_free_scred(scred); 1112 return EINVAL; 1113 } 1114 smbfs_free_scred(scred); 1115 return error; 1116 } 1117 1118 static int 1119 smbfs_pathcheck(struct smbmount *smp, const char *name, int nmlen, int nameiop) 1120 { 1121 static const char *badchars = "*/:<>?"; 1122 static const char *badchars83 = " +|,[]=;"; 1123 const char *cp; 1124 int i, error; 1125 1126 /* 1127 * Backslash characters, being a path delimiter, are prohibited 1128 * within a path component even for LOOKUP operations. 1129 */ 1130 if (strchr(name, '\\') != NULL) 1131 return ENOENT; 1132 1133 if (nameiop == LOOKUP) 1134 return 0; 1135 error = ENOENT; 1136 if (SMB_DIALECT(SSTOVC(smp->sm_share)) < SMB_DIALECT_LANMAN2_0) { 1137 /* 1138 * Name should conform 8.3 format 1139 */ 1140 if (nmlen > 12) 1141 return ENAMETOOLONG; 1142 cp = strchr(name, '.'); 1143 if (cp == NULL) 1144 return error; 1145 if (cp == name || (cp - name) > 8) 1146 return error; 1147 cp = strchr(cp + 1, '.'); 1148 if (cp != NULL) 1149 return error; 1150 for (cp = name, i = 0; i < nmlen; i++, cp++) 1151 if (strchr(badchars83, *cp) != NULL) 1152 return error; 1153 } 1154 for (cp = name, i = 0; i < nmlen; i++, cp++) 1155 if (strchr(badchars, *cp) != NULL) 1156 return error; 1157 return 0; 1158 } 1159 1160 /* 1161 * Things go even weird without fixed inode numbers... 1162 */ 1163 int 1164 smbfs_lookup(ap) 1165 struct vop_lookup_args /* { 1166 struct vnodeop_desc *a_desc; 1167 struct vnode *a_dvp; 1168 struct vnode **a_vpp; 1169 struct componentname *a_cnp; 1170 } */ *ap; 1171 { 1172 struct componentname *cnp = ap->a_cnp; 1173 struct thread *td = curthread; 1174 struct vnode *dvp = ap->a_dvp; 1175 struct vnode **vpp = ap->a_vpp; 1176 struct vnode *vp; 1177 struct smbmount *smp; 1178 struct mount *mp = dvp->v_mount; 1179 struct smbnode *dnp; 1180 struct smbfattr fattr, *fap; 1181 struct smb_cred *scred; 1182 char *name = cnp->cn_nameptr; 1183 int flags = cnp->cn_flags; 1184 int nameiop = cnp->cn_nameiop; 1185 int nmlen = cnp->cn_namelen; 1186 int error, islastcn, isdot; 1187 int killit; 1188 1189 SMBVDEBUG("\n"); 1190 if (dvp->v_type != VDIR) 1191 return ENOTDIR; 1192 if ((flags & ISDOTDOT) && (dvp->v_vflag & VV_ROOT)) { 1193 SMBFSERR("invalid '..'\n"); 1194 return EIO; 1195 } 1196 islastcn = flags & ISLASTCN; 1197 if (islastcn && (mp->mnt_flag & MNT_RDONLY) && (nameiop != LOOKUP)) 1198 return EROFS; 1199 error = vn_dir_check_exec(dvp, cnp); 1200 if (error != 0) 1201 return error; 1202 smp = VFSTOSMBFS(mp); 1203 dnp = VTOSMB(dvp); 1204 isdot = (nmlen == 1 && name[0] == '.'); 1205 1206 error = smbfs_pathcheck(smp, cnp->cn_nameptr, cnp->cn_namelen, nameiop); 1207 1208 if (error) 1209 return ENOENT; 1210 1211 error = cache_lookup(dvp, vpp, cnp, NULL, NULL); 1212 SMBVDEBUG("cache_lookup returned %d\n", error); 1213 if (error > 0) 1214 return error; 1215 if (error) { /* name was found */ 1216 struct vattr vattr; 1217 1218 killit = 0; 1219 vp = *vpp; 1220 error = VOP_GETATTR(vp, &vattr, cnp->cn_cred); 1221 /* 1222 * If the file type on the server is inconsistent 1223 * with what it was when we created the vnode, 1224 * kill the bogus vnode now and fall through to 1225 * the code below to create a new one with the 1226 * right type. 1227 */ 1228 if (error == 0 && 1229 ((vp->v_type == VDIR && 1230 (VTOSMB(vp)->n_dosattr & SMB_FA_DIR) == 0) || 1231 (vp->v_type == VREG && 1232 (VTOSMB(vp)->n_dosattr & SMB_FA_DIR) != 0))) 1233 killit = 1; 1234 else if (error == 0 1235 /* && vattr.va_ctime.tv_sec == VTOSMB(vp)->n_ctime*/) { 1236 if (nameiop != LOOKUP && islastcn) 1237 cnp->cn_flags |= SAVENAME; 1238 SMBVDEBUG("use cached vnode\n"); 1239 return (0); 1240 } 1241 cache_purge(vp); 1242 /* 1243 * XXX This is not quite right, if '.' is 1244 * inconsistent, we really need to start the lookup 1245 * all over again. Hopefully there is some other 1246 * guarantee that prevents this case from happening. 1247 */ 1248 if (killit && vp != dvp) 1249 vgone(vp); 1250 if (vp != dvp) 1251 vput(vp); 1252 else 1253 vrele(vp); 1254 *vpp = NULLVP; 1255 } 1256 /* 1257 * entry is not in the cache or has been expired 1258 */ 1259 error = 0; 1260 *vpp = NULLVP; 1261 scred = smbfs_malloc_scred(); 1262 smb_makescred(scred, td, cnp->cn_cred); 1263 fap = &fattr; 1264 if (flags & ISDOTDOT) { 1265 /* 1266 * In the DOTDOT case, don't go over-the-wire 1267 * in order to request attributes. We already 1268 * know it's a directory and subsequent call to 1269 * smbfs_getattr() will restore consistency. 1270 * 1271 */ 1272 SMBVDEBUG("smbfs_smb_lookup: dotdot\n"); 1273 } else if (isdot) { 1274 error = smbfs_smb_lookup(dnp, NULL, 0, fap, scred); 1275 SMBVDEBUG("result of smbfs_smb_lookup: %d\n", error); 1276 } 1277 else { 1278 error = smbfs_smb_lookup(dnp, name, nmlen, fap, scred); 1279 SMBVDEBUG("result of smbfs_smb_lookup: %d\n", error); 1280 } 1281 if (error && error != ENOENT) 1282 goto out; 1283 if (error) { /* entry not found */ 1284 /* 1285 * Handle RENAME or CREATE case... 1286 */ 1287 if ((nameiop == CREATE || nameiop == RENAME) && islastcn) { 1288 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td); 1289 if (error) 1290 goto out; 1291 cnp->cn_flags |= SAVENAME; 1292 error = EJUSTRETURN; 1293 goto out; 1294 } 1295 error = ENOENT; 1296 goto out; 1297 }/* else { 1298 SMBVDEBUG("Found entry %s with id=%d\n", fap->entryName, fap->dirEntNum); 1299 }*/ 1300 /* 1301 * handle DELETE case ... 1302 */ 1303 if (nameiop == DELETE && islastcn) { /* delete last component */ 1304 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td); 1305 if (error) 1306 goto out; 1307 if (isdot) { 1308 VREF(dvp); 1309 *vpp = dvp; 1310 goto out; 1311 } 1312 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp); 1313 if (error) 1314 goto out; 1315 *vpp = vp; 1316 cnp->cn_flags |= SAVENAME; 1317 goto out; 1318 } 1319 if (nameiop == RENAME && islastcn) { 1320 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td); 1321 if (error) 1322 goto out; 1323 if (isdot) { 1324 error = EISDIR; 1325 goto out; 1326 } 1327 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp); 1328 if (error) 1329 goto out; 1330 *vpp = vp; 1331 cnp->cn_flags |= SAVENAME; 1332 goto out; 1333 } 1334 if (flags & ISDOTDOT) { 1335 mp = dvp->v_mount; 1336 error = vfs_busy(mp, MBF_NOWAIT); 1337 if (error != 0) { 1338 vfs_ref(mp); 1339 VOP_UNLOCK(dvp); 1340 error = vfs_busy(mp, 0); 1341 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 1342 vfs_rel(mp); 1343 if (error) { 1344 error = ENOENT; 1345 goto out; 1346 } 1347 if (VN_IS_DOOMED(dvp)) { 1348 vfs_unbusy(mp); 1349 error = ENOENT; 1350 goto out; 1351 } 1352 } 1353 VOP_UNLOCK(dvp); 1354 error = smbfs_nget(mp, dvp, name, nmlen, NULL, &vp); 1355 vfs_unbusy(mp); 1356 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 1357 if (VN_IS_DOOMED(dvp)) { 1358 if (error == 0) 1359 vput(vp); 1360 error = ENOENT; 1361 } 1362 if (error) 1363 goto out; 1364 *vpp = vp; 1365 } else if (isdot) { 1366 vref(dvp); 1367 *vpp = dvp; 1368 } else { 1369 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp); 1370 if (error) 1371 goto out; 1372 *vpp = vp; 1373 SMBVDEBUG("lookup: getnewvp!\n"); 1374 } 1375 if ((cnp->cn_flags & MAKEENTRY)/* && !islastcn*/) { 1376 /* VTOSMB(*vpp)->n_ctime = VTOSMB(*vpp)->n_vattr.va_ctime.tv_sec;*/ 1377 cache_enter(dvp, *vpp, cnp); 1378 } 1379 out: 1380 smbfs_free_scred(scred); 1381 return (error); 1382 } 1383