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 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <sys/uio.h> 29 #include <sys/statvfs.h> 30 #include <sys/vnode.h> 31 #include <sys/thread.h> 32 #include <sys/pathname.h> 33 #include <sys/cred.h> 34 #include <sys/extdirent.h> 35 #include <sys/nbmlock.h> 36 #include <sys/share.h> 37 #include <sys/fcntl.h> 38 #include <nfs/lm.h> 39 40 #include <smbsrv/smb_kproto.h> 41 #include <smbsrv/string.h> 42 #include <smbsrv/smb_vops.h> 43 #include <smbsrv/smb_fsops.h> 44 45 /* 46 * CATIA support 47 * 48 * CATIA V4 is a UNIX product and uses characters in filenames that 49 * are considered invalid by Windows. CATIA V5 is available on both 50 * UNIX and Windows. Thus, as CATIA customers migrate from V4 to V5, 51 * some V4 files could become inaccessible to windows clients if the 52 * filename contains the characters that are considered illegal in 53 * Windows. In order to address this issue an optional character 54 * translation is applied to filenames at the smb_vop interface. 55 * 56 * Character Translation Table 57 * ---------------------------------- 58 * Unix-char (v4) | Windows-char (v5) 59 * ---------------------------------- 60 * * | 0x00a4 Currency Sign 61 * | | 0x00a6 Broken Bar 62 * " | 0x00a8 Diaeresis 63 * < | 0x00ab Left-Pointing Double Angle Quotation Mark 64 * > | 0x00bb Right-Pointing Double Angle Quotation Mark 65 * ? | 0x00bf Inverted Question mark 66 * : | 0x00f7 Division Sign 67 * / | 0x00f8 Latin Small Letter o with stroke 68 * \ | 0x00ff Latin Small Letter Y with Diaeresis 69 * 70 * 71 * Two lookup tables are used to perform the character translation: 72 * 73 * smb_catia_v5_lookup - provides the mapping between UNIX ASCII (v4) 74 * characters and equivalent or translated wide characters. 75 * It is indexed by the decimal value of the ASCII character (0-127). 76 * 77 * smb_catia_v4_lookup - provides the mapping between wide characters 78 * in the range from 0x00A4 to 0x00FF and their UNIX (v4) equivalent 79 * (in wide character format). It is indexed by the decimal value of 80 * the wide character (164-255) with an offset of -164. 81 * If this translation produces a filename containing a '/' create, mkdir 82 * or rename (to the '/' name) operations will not be permitted. It is 83 * not valid to create a filename with a '/' in it. However, if such a 84 * file already exists other operations (e.g, lookup, delete, rename) 85 * are permitted on it. 86 */ 87 88 /* number of characters mapped */ 89 #define SMB_CATIA_NUM_MAPS 9 90 91 /* Windows Characters used in special character mapping */ 92 #define SMB_CATIA_WIN_CURRENCY 0x00a4 93 #define SMB_CATIA_WIN_BROKEN_BAR 0x00a6 94 #define SMB_CATIA_WIN_DIAERESIS 0x00a8 95 #define SMB_CATIA_WIN_LEFT_ANGLE 0x00ab 96 #define SMB_CATIA_WIN_RIGHT_ANGLE 0x00bb 97 #define SMB_CATIA_WIN_INVERTED_QUESTION 0x00bf 98 #define SMB_CATIA_WIN_DIVISION 0x00f7 99 #define SMB_CATIA_WIN_LATIN_O 0x00f8 100 #define SMB_CATIA_WIN_LATIN_Y 0x00ff 101 102 #define SMB_CATIA_V4_LOOKUP_LOW SMB_CATIA_WIN_CURRENCY 103 #define SMB_CATIA_V4_LOOKUP_UPPER SMB_CATIA_WIN_LATIN_Y 104 #define SMB_CATIA_V4_LOOKUP_MAX \ 105 (SMB_CATIA_V4_LOOKUP_UPPER - SMB_CATIA_V4_LOOKUP_LOW + 1) 106 #define SMB_CATIA_V5_LOOKUP_MAX 0x0080 107 108 typedef struct smb_catia_map 109 { 110 unsigned char unixchar; /* v4 */ 111 smb_wchar_t winchar; /* v5 */ 112 } smb_catia_map_t; 113 114 smb_catia_map_t const catia_maps[SMB_CATIA_NUM_MAPS] = 115 { 116 {'"', SMB_CATIA_WIN_DIAERESIS}, 117 {'*', SMB_CATIA_WIN_CURRENCY}, 118 {':', SMB_CATIA_WIN_DIVISION}, 119 {'<', SMB_CATIA_WIN_LEFT_ANGLE}, 120 {'>', SMB_CATIA_WIN_RIGHT_ANGLE}, 121 {'?', SMB_CATIA_WIN_INVERTED_QUESTION}, 122 {'\\', SMB_CATIA_WIN_LATIN_Y}, 123 {'/', SMB_CATIA_WIN_LATIN_O}, 124 {'|', SMB_CATIA_WIN_BROKEN_BAR} 125 }; 126 127 static smb_wchar_t smb_catia_v5_lookup[SMB_CATIA_V5_LOOKUP_MAX]; 128 static smb_wchar_t smb_catia_v4_lookup[SMB_CATIA_V4_LOOKUP_MAX]; 129 130 static void smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr); 131 static void smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp); 132 static callb_cpr_t *smb_lock_frlock_callback(flk_cb_when_t, void *); 133 static void smb_vop_catia_init(); 134 135 extern sysid_t lm_alloc_sysidt(); 136 137 #define SMB_AT_MAX 16 138 static const uint_t smb_attrmap[SMB_AT_MAX] = { 139 0, 140 AT_TYPE, 141 AT_MODE, 142 AT_UID, 143 AT_GID, 144 AT_FSID, 145 AT_NODEID, 146 AT_NLINK, 147 AT_SIZE, 148 AT_ATIME, 149 AT_MTIME, 150 AT_CTIME, 151 AT_RDEV, 152 AT_BLKSIZE, 153 AT_NBLOCKS, 154 AT_SEQ 155 }; 156 157 static boolean_t smb_vop_initialized = B_FALSE; 158 caller_context_t smb_ct; 159 160 /* 161 * smb_vop_init 162 * 163 * This function is not multi-thread safe. The caller must make sure only one 164 * thread makes the call. 165 */ 166 int 167 smb_vop_init(void) 168 { 169 if (smb_vop_initialized) 170 return (0); 171 /* 172 * The caller_context will be used primarily for range locking. 173 * Since the CIFS server is mapping its locks to POSIX locks, 174 * only one pid is used for operations originating from the 175 * CIFS server (to represent CIFS in the VOP_FRLOCK routines). 176 * 177 * XXX: Should smb_ct be per-zone? 178 */ 179 smb_ct.cc_sysid = lm_alloc_sysidt(); 180 if (smb_ct.cc_sysid == LM_NOSYSID) 181 return (ENOMEM); 182 183 smb_ct.cc_caller_id = fs_new_caller_id(); 184 smb_ct.cc_pid = IGN_PID; 185 smb_ct.cc_flags = 0; 186 smb_vop_catia_init(); 187 188 smb_vop_initialized = B_TRUE; 189 return (0); 190 } 191 192 /* 193 * smb_vop_fini 194 * 195 * This function is not multi-thread safe. The caller must make sure only one 196 * thread makes the call. 197 */ 198 void 199 smb_vop_fini(void) 200 { 201 if (!smb_vop_initialized) 202 return; 203 204 lm_free_sysidt(smb_ct.cc_sysid); 205 smb_ct.cc_pid = IGN_PID; 206 smb_ct.cc_sysid = LM_NOSYSID; 207 smb_vop_initialized = B_FALSE; 208 } 209 210 /* 211 * The smb_ct will be used primarily for range locking. 212 * Since the CIFS server is mapping its locks to POSIX locks, 213 * only one pid is used for operations originating from the 214 * CIFS server (to represent CIFS in the VOP_FRLOCK routines). 215 */ 216 int 217 smb_vop_open(vnode_t **vpp, int mode, cred_t *cred) 218 { 219 return (VOP_OPEN(vpp, mode, cred, &smb_ct)); 220 } 221 222 void 223 smb_vop_close(vnode_t *vp, int mode, cred_t *cred) 224 { 225 (void) VOP_CLOSE(vp, mode, 1, (offset_t)0, cred, &smb_ct); 226 } 227 228 int 229 smb_vop_other_opens(vnode_t *vp, int mode) 230 { 231 return (((mode & FWRITE) && vn_has_other_opens(vp, V_WRITE)) || 232 (((mode & FWRITE) == 0) && vn_is_opened(vp, V_WRITE)) || 233 ((mode & FREAD) && vn_has_other_opens(vp, V_READ)) || 234 (((mode & FREAD) == 0) && vn_is_opened(vp, V_READ)) || 235 vn_is_mapped(vp, V_RDORWR)); 236 } 237 238 /* 239 * The smb_vop_* functions have minimal knowledge of CIFS semantics and 240 * serve as an interface to the VFS layer. 241 * 242 * Only smb_fsop_* layer functions should call smb_vop_* layer functions. 243 * (Higher-level CIFS service code should never skip the smb_fsop_* layer 244 * to call smb_vop_* layer functions directly.) 245 */ 246 247 /* 248 * XXX - Extended attributes support in the file system assumed. 249 * This is needed for full NT Streams functionality. 250 */ 251 252 int 253 smb_vop_read(vnode_t *vp, uio_t *uiop, cred_t *cr) 254 { 255 int error; 256 257 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 258 error = VOP_READ(vp, uiop, 0, cr, &smb_ct); 259 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 260 return (error); 261 } 262 263 int 264 smb_vop_write(vnode_t *vp, uio_t *uiop, int ioflag, uint32_t *lcount, 265 cred_t *cr) 266 { 267 int error; 268 269 *lcount = uiop->uio_resid; 270 271 uiop->uio_llimit = MAXOFFSET_T; 272 273 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 274 error = VOP_WRITE(vp, uiop, ioflag, cr, &smb_ct); 275 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 276 277 *lcount -= uiop->uio_resid; 278 279 return (error); 280 } 281 282 /* 283 * smb_vop_getattr() 284 * 285 * smb_fsop_getattr()/smb_vop_getattr() should always be called from the CIFS 286 * service (instead of calling VOP_GETATTR directly) to retrieve attributes 287 * due to special processing needed for streams files. 288 * 289 * All attributes are retrieved. 290 * 291 * When vp denotes a named stream, then unnamed_vp should be passed in (denoting 292 * the corresponding unnamed stream). 293 * A named stream's attributes (as far as CIFS is concerned) are those of the 294 * unnamed stream (minus the size attribute, and the type), plus the size of 295 * the named stream, and a type value of VREG. 296 * Although the file system may store other attributes with the named stream, 297 * these should not be used by CIFS for any purpose. 298 * 299 * File systems without VFSFT_XVATTR do not support DOS attributes or create 300 * time (crtime). In this case the mtime is used as the crtime. 301 * Likewise if VOP_GETATTR doesn't return any system attributes the dosattr 302 * is 0 and the mtime is used as the crtime. 303 */ 304 int 305 smb_vop_getattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *ret_attr, 306 int flags, cred_t *cr) 307 { 308 int error; 309 vnode_t *use_vp; 310 smb_attr_t tmp_attr; 311 xvattr_t tmp_xvattr; 312 xoptattr_t *xoap = NULL; 313 314 if (unnamed_vp) 315 use_vp = unnamed_vp; 316 else 317 use_vp = vp; 318 319 if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) { 320 xva_init(&tmp_xvattr); 321 xoap = xva_getxoptattr(&tmp_xvattr); 322 ASSERT(xoap); 323 324 smb_sa_to_va_mask(ret_attr->sa_mask, 325 &tmp_xvattr.xva_vattr.va_mask); 326 327 XVA_SET_REQ(&tmp_xvattr, XAT_READONLY); 328 XVA_SET_REQ(&tmp_xvattr, XAT_HIDDEN); 329 XVA_SET_REQ(&tmp_xvattr, XAT_SYSTEM); 330 XVA_SET_REQ(&tmp_xvattr, XAT_ARCHIVE); 331 XVA_SET_REQ(&tmp_xvattr, XAT_CREATETIME); 332 XVA_SET_REQ(&tmp_xvattr, XAT_REPARSE); 333 XVA_SET_REQ(&tmp_xvattr, XAT_OFFLINE); 334 XVA_SET_REQ(&tmp_xvattr, XAT_SPARSE); 335 336 error = VOP_GETATTR(use_vp, &tmp_xvattr.xva_vattr, flags, 337 cr, &smb_ct); 338 if (error != 0) 339 return (error); 340 341 ret_attr->sa_vattr = tmp_xvattr.xva_vattr; 342 ret_attr->sa_dosattr = 0; 343 344 if (tmp_xvattr.xva_vattr.va_mask & AT_XVATTR) { 345 xoap = xva_getxoptattr(&tmp_xvattr); 346 ASSERT(xoap); 347 348 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_READONLY)) && 349 (xoap->xoa_readonly)) { 350 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_READONLY; 351 } 352 353 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_HIDDEN)) && 354 (xoap->xoa_hidden)) { 355 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_HIDDEN; 356 } 357 358 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_SYSTEM)) && 359 (xoap->xoa_system)) { 360 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_SYSTEM; 361 } 362 363 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_ARCHIVE)) && 364 (xoap->xoa_archive)) { 365 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_ARCHIVE; 366 } 367 368 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_REPARSE)) && 369 (xoap->xoa_reparse)) { 370 ret_attr->sa_dosattr |= 371 FILE_ATTRIBUTE_REPARSE_POINT; 372 } 373 374 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_OFFLINE)) && 375 (xoap->xoa_offline)) { 376 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_OFFLINE; 377 } 378 379 if ((XVA_ISSET_RTN(&tmp_xvattr, XAT_SPARSE)) && 380 (xoap->xoa_sparse)) { 381 ret_attr->sa_dosattr |= 382 FILE_ATTRIBUTE_SPARSE_FILE; 383 } 384 385 ret_attr->sa_crtime = xoap->xoa_createtime; 386 } else { 387 ret_attr->sa_crtime = ret_attr->sa_vattr.va_mtime; 388 } 389 } else { 390 /* 391 * Support for file systems without VFSFT_XVATTR 392 */ 393 smb_sa_to_va_mask(ret_attr->sa_mask, 394 &ret_attr->sa_vattr.va_mask); 395 396 error = VOP_GETATTR(use_vp, &ret_attr->sa_vattr, 397 flags, cr, &smb_ct); 398 if (error != 0) 399 return (error); 400 401 ret_attr->sa_dosattr = 0; 402 ret_attr->sa_crtime = ret_attr->sa_vattr.va_mtime; 403 } 404 405 if (unnamed_vp) { 406 ret_attr->sa_vattr.va_type = VREG; 407 408 if (ret_attr->sa_mask & (SMB_AT_SIZE | SMB_AT_NBLOCKS)) { 409 tmp_attr.sa_vattr.va_mask = AT_SIZE | AT_NBLOCKS; 410 411 error = VOP_GETATTR(vp, &tmp_attr.sa_vattr, 412 flags, cr, &smb_ct); 413 if (error != 0) 414 return (error); 415 416 ret_attr->sa_vattr.va_size = tmp_attr.sa_vattr.va_size; 417 ret_attr->sa_vattr.va_nblocks = 418 tmp_attr.sa_vattr.va_nblocks; 419 } 420 } 421 422 if (ret_attr->sa_vattr.va_type == VDIR) 423 ret_attr->sa_dosattr |= FILE_ATTRIBUTE_DIRECTORY; 424 425 return (error); 426 } 427 428 /* 429 * smb_vop_setattr() 430 * 431 * smb_fsop_setattr()/smb_vop_setattr() should always be used instead of 432 * VOP_SETATTR() when calling from the CIFS service, due to special processing 433 * for streams files. 434 * 435 * Streams have a size but otherwise do not have separate attributes from 436 * the (unnamed stream) file, i.e., the security and ownership of the file 437 * applies to the stream. In contrast, extended attribute files, which are 438 * used to implement streams, are independent objects with their own 439 * attributes. 440 * 441 * For compatibility with streams, we set the size on the extended attribute 442 * file and apply other attributes to the (unnamed stream) file. The one 443 * exception is that the UID and GID can be set on the stream by passing a 444 * NULL unnamed_vp, which allows callers to synchronize stream ownership 445 * with the (unnamed stream) file. 446 */ 447 int 448 smb_vop_setattr(vnode_t *vp, vnode_t *unnamed_vp, smb_attr_t *attr, 449 int flags, cred_t *cr) 450 { 451 int error = 0; 452 int at_size = 0; 453 vnode_t *use_vp; 454 xvattr_t xvattr; 455 vattr_t *vap; 456 457 if (attr->sa_mask & SMB_AT_DOSATTR) { 458 attr->sa_dosattr &= 459 (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_READONLY | 460 FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | 461 FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_SPARSE_FILE); 462 } 463 464 if (unnamed_vp) { 465 use_vp = unnamed_vp; 466 if (attr->sa_mask & SMB_AT_SIZE) { 467 at_size = 1; 468 attr->sa_mask &= ~SMB_AT_SIZE; 469 } 470 } else { 471 use_vp = vp; 472 } 473 474 /* 475 * The caller should not be setting sa_vattr.va_mask, 476 * but rather sa_mask. 477 */ 478 479 attr->sa_vattr.va_mask = 0; 480 481 if (vfs_has_feature(use_vp->v_vfsp, VFSFT_XVATTR)) { 482 smb_vop_setup_xvattr(attr, &xvattr); 483 vap = &xvattr.xva_vattr; 484 } else { 485 smb_sa_to_va_mask(attr->sa_mask, 486 &attr->sa_vattr.va_mask); 487 vap = &attr->sa_vattr; 488 } 489 490 if ((error = VOP_SETATTR(use_vp, vap, flags, cr, &smb_ct)) != 0) 491 return (error); 492 493 if (at_size) { 494 attr->sa_vattr.va_mask = AT_SIZE; 495 error = VOP_SETATTR(vp, &attr->sa_vattr, flags, 496 zone_kcred(), &smb_ct); 497 } 498 499 return (error); 500 } 501 502 int 503 smb_vop_space(vnode_t *vp, int cmd, flock64_t *bfp, int flags, 504 offset_t offset, cred_t *cr) 505 { 506 int error; 507 508 error = VOP_SPACE(vp, cmd, bfp, flags, offset, cr, &smb_ct); 509 510 return (error); 511 } 512 513 /* 514 * smb_vop_access 515 * 516 * This is a wrapper round VOP_ACCESS. VOP_ACCESS checks the given mode 517 * against file's ACL or Unix permissions. CIFS on the other hand needs to 518 * know if the requested operation can succeed for the given object, this 519 * requires more checks in case of DELETE bit since permissions on the parent 520 * directory are important as well. Based on Windows rules if parent's ACL 521 * grant FILE_DELETE_CHILD a file can be delete regardless of the file's 522 * permissions. 523 */ 524 int 525 smb_vop_access(vnode_t *vp, int mode, int flags, vnode_t *dir_vp, cred_t *cr) 526 { 527 int error = 0; 528 529 if (mode == 0) 530 return (0); 531 532 if ((flags == V_ACE_MASK) && (mode & ACE_DELETE)) { 533 if (dir_vp) { 534 error = VOP_ACCESS(dir_vp, ACE_DELETE_CHILD, flags, 535 cr, NULL); 536 537 if (error == 0) 538 mode &= ~ACE_DELETE; 539 } 540 } 541 542 if (mode) { 543 error = VOP_ACCESS(vp, mode, flags, cr, NULL); 544 } 545 546 return (error); 547 } 548 549 /* 550 * smb_vop_lookup 551 * 552 * dvp: directory vnode (in) 553 * name: name of file to be looked up (in) 554 * vpp: looked-up vnode (out) 555 * od_name: on-disk name of file (out). 556 * This parameter is optional. If a pointer is passed in, it 557 * must be allocated with MAXNAMELEN bytes 558 * rootvp: vnode of the tree root (in) 559 * This parameter is always passed in non-NULL except at the time 560 * of share set up. 561 * direntflags: dirent flags returned from VOP_LOOKUP 562 */ 563 int 564 smb_vop_lookup( 565 vnode_t *dvp, 566 char *name, 567 vnode_t **vpp, 568 char *od_name, 569 int flags, 570 int *direntflags, 571 vnode_t *rootvp, 572 smb_attr_t *attr, 573 cred_t *cr) 574 { 575 int error = 0; 576 int option_flags = 0; 577 pathname_t rpn; 578 char *np = name; 579 char namebuf[MAXNAMELEN]; 580 581 if (*name == '\0') 582 return (EINVAL); 583 584 ASSERT(vpp); 585 *vpp = NULL; 586 *direntflags = 0; 587 588 if ((name[0] == '.') && (name[1] == '.') && (name[2] == 0)) { 589 if (rootvp && (dvp == rootvp)) { 590 VN_HOLD(dvp); 591 *vpp = dvp; 592 return (0); 593 } 594 595 if (dvp->v_flag & VROOT) { 596 vfs_t *vfsp; 597 vnode_t *cvp = dvp; 598 599 /* 600 * Set dvp and check for races with forced unmount 601 * (see lookuppnvp()) 602 */ 603 604 vfsp = cvp->v_vfsp; 605 vfs_rlock_wait(vfsp); 606 if (((dvp = cvp->v_vfsp->vfs_vnodecovered) == NULL) || 607 (cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) { 608 vfs_unlock(vfsp); 609 return (EIO); 610 } 611 vfs_unlock(vfsp); 612 } 613 } 614 615 if (flags & SMB_IGNORE_CASE) 616 option_flags = FIGNORECASE; 617 618 if (flags & SMB_CATIA) 619 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf)); 620 621 pn_alloc(&rpn); 622 623 /* 624 * Easier to not have junk in rpn, as not every FS type 625 * will necessarily fill that in for us. 626 */ 627 bzero(rpn.pn_buf, rpn.pn_bufsize); 628 629 error = VOP_LOOKUP(dvp, np, vpp, NULL, option_flags, NULL, cr, 630 &smb_ct, direntflags, &rpn); 631 632 if (error == 0) { 633 if (od_name) { 634 bzero(od_name, MAXNAMELEN); 635 if ((option_flags & FIGNORECASE) != 0 && 636 rpn.pn_buf[0] != '\0') 637 np = rpn.pn_buf; 638 else 639 np = name; 640 if (flags & SMB_CATIA) 641 smb_vop_catia_v4tov5(np, od_name, MAXNAMELEN); 642 else 643 (void) strlcpy(od_name, np, MAXNAMELEN); 644 } 645 646 if (attr != NULL) { 647 attr->sa_mask = SMB_AT_ALL; 648 (void) smb_vop_getattr(*vpp, NULL, attr, 0, 649 zone_kcred()); 650 } 651 } 652 653 pn_free(&rpn); 654 return (error); 655 } 656 657 int 658 smb_vop_create(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp, 659 int flags, cred_t *cr, vsecattr_t *vsap) 660 { 661 int error; 662 int option_flags = 0; 663 xvattr_t xvattr; 664 vattr_t *vap; 665 char *np = name; 666 char namebuf[MAXNAMELEN]; 667 668 if (flags & SMB_IGNORE_CASE) 669 option_flags = FIGNORECASE; 670 671 attr->sa_vattr.va_mask = 0; 672 673 if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) { 674 smb_vop_setup_xvattr(attr, &xvattr); 675 vap = &xvattr.xva_vattr; 676 } else { 677 smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask); 678 vap = &attr->sa_vattr; 679 } 680 681 if (flags & SMB_CATIA) { 682 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf)); 683 if (strchr(np, '/') != NULL) 684 return (EILSEQ); 685 } 686 687 error = VOP_CREATE(dvp, np, vap, EXCL, attr->sa_vattr.va_mode, 688 vpp, cr, option_flags, &smb_ct, vsap); 689 690 /* 691 * One could argue that filesystems should obey the size 692 * if specified in the create attributes. Unfortunately, 693 * they only appear to let you truncate the size to zero. 694 * SMB needs to set a non-zero size, so work-around. 695 */ 696 if (error == 0 && *vpp != NULL && 697 (vap->va_mask & AT_SIZE) != 0 && 698 vap->va_size > 0) { 699 vattr_t ta = *vap; 700 ta.va_mask = AT_SIZE; 701 (void) VOP_SETATTR(*vpp, &ta, 0, cr, &smb_ct); 702 } 703 704 return (error); 705 } 706 707 int 708 smb_vop_remove(vnode_t *dvp, char *name, int flags, cred_t *cr) 709 { 710 int error; 711 int option_flags = 0; 712 char *np = name; 713 char namebuf[MAXNAMELEN]; 714 715 if (flags & SMB_IGNORE_CASE) 716 option_flags = FIGNORECASE; 717 718 if (flags & SMB_CATIA) 719 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf)); 720 721 error = VOP_REMOVE(dvp, np, cr, &smb_ct, option_flags); 722 723 return (error); 724 } 725 726 /* 727 * smb_vop_link(target-dir-vp, source-file-vp, target-name) 728 * 729 * Create a link - same tree (identical TID) only. 730 */ 731 int 732 smb_vop_link(vnode_t *to_dvp, vnode_t *from_vp, char *to_name, 733 int flags, cred_t *cr) 734 { 735 int option_flags = 0; 736 char *np, *buf; 737 int rc; 738 739 if (flags & SMB_IGNORE_CASE) 740 option_flags = FIGNORECASE; 741 742 if (flags & SMB_CATIA) { 743 buf = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 744 np = smb_vop_catia_v5tov4(to_name, buf, MAXNAMELEN); 745 if (strchr(np, '/') != NULL) { 746 kmem_free(buf, MAXNAMELEN); 747 return (EILSEQ); 748 } 749 750 rc = VOP_LINK(to_dvp, from_vp, np, cr, &smb_ct, option_flags); 751 kmem_free(buf, MAXNAMELEN); 752 return (rc); 753 } 754 755 rc = VOP_LINK(to_dvp, from_vp, to_name, cr, &smb_ct, option_flags); 756 return (rc); 757 } 758 759 /* 760 * smb_vop_rename() 761 * 762 * The rename is for files in the same tree (identical TID) only. 763 */ 764 int 765 smb_vop_rename(vnode_t *from_dvp, char *from_name, vnode_t *to_dvp, 766 char *to_name, int flags, cred_t *cr) 767 { 768 int error; 769 int option_flags = 0; 770 char *from, *to, *fbuf, *tbuf; 771 772 if (flags & SMB_IGNORE_CASE) 773 option_flags = FIGNORECASE; 774 775 if (flags & SMB_CATIA) { 776 tbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 777 to = smb_vop_catia_v5tov4(to_name, tbuf, MAXNAMELEN); 778 if (strchr(to, '/') != NULL) { 779 kmem_free(tbuf, MAXNAMELEN); 780 return (EILSEQ); 781 } 782 783 fbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 784 from = smb_vop_catia_v5tov4(from_name, fbuf, MAXNAMELEN); 785 786 error = VOP_RENAME(from_dvp, from, to_dvp, to, cr, 787 &smb_ct, option_flags); 788 789 kmem_free(tbuf, MAXNAMELEN); 790 kmem_free(fbuf, MAXNAMELEN); 791 return (error); 792 } 793 794 error = VOP_RENAME(from_dvp, from_name, to_dvp, to_name, cr, 795 &smb_ct, option_flags); 796 797 return (error); 798 } 799 800 int 801 smb_vop_mkdir(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp, 802 int flags, cred_t *cr, vsecattr_t *vsap) 803 { 804 int error; 805 int option_flags = 0; 806 xvattr_t xvattr; 807 vattr_t *vap; 808 char *np = name; 809 char namebuf[MAXNAMELEN]; 810 811 if (flags & SMB_IGNORE_CASE) 812 option_flags = FIGNORECASE; 813 814 attr->sa_vattr.va_mask = 0; 815 816 if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) { 817 smb_vop_setup_xvattr(attr, &xvattr); 818 vap = &xvattr.xva_vattr; 819 } else { 820 smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask); 821 vap = &attr->sa_vattr; 822 } 823 824 if (flags & SMB_CATIA) { 825 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf)); 826 if (strchr(np, '/') != NULL) 827 return (EILSEQ); 828 } 829 830 error = VOP_MKDIR(dvp, np, vap, vpp, cr, &smb_ct, option_flags, vsap); 831 832 return (error); 833 } 834 835 /* 836 * smb_vop_rmdir() 837 * 838 * Only simple rmdir supported, consistent with NT semantics 839 * (can only remove an empty directory). 840 * 841 * The third argument to VOP_RMDIR is the current directory of 842 * the process. It allows rmdir wants to EINVAL if one tries to 843 * remove ".". Since SMB servers do not know what their clients' 844 * current directories are, we fake it by supplying a vnode known 845 * to exist and illegal to remove (rootdir). 846 */ 847 int 848 smb_vop_rmdir(vnode_t *dvp, char *name, int flags, cred_t *cr) 849 { 850 int error; 851 int option_flags = 0; 852 char *np = name; 853 char namebuf[MAXNAMELEN]; 854 855 if (flags & SMB_IGNORE_CASE) 856 option_flags = FIGNORECASE; 857 858 if (flags & SMB_CATIA) 859 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf)); 860 861 error = VOP_RMDIR(dvp, np, rootdir, cr, &smb_ct, option_flags); 862 return (error); 863 } 864 865 int 866 smb_vop_commit(vnode_t *vp, cred_t *cr) 867 { 868 return (VOP_FSYNC(vp, 1, cr, &smb_ct)); 869 } 870 871 /* 872 * Some code in smb_node.c needs to know which DOS attributes 873 * we can actually store. Let's define a mask here of all the 874 * DOS attribute flags supported by the following function. 875 */ 876 const uint32_t 877 smb_vop_dosattr_settable = 878 FILE_ATTRIBUTE_ARCHIVE | 879 FILE_ATTRIBUTE_SYSTEM | 880 FILE_ATTRIBUTE_HIDDEN | 881 FILE_ATTRIBUTE_READONLY | 882 FILE_ATTRIBUTE_OFFLINE | 883 FILE_ATTRIBUTE_SPARSE_FILE; 884 885 static void 886 smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr) 887 { 888 xoptattr_t *xoap = NULL; 889 uint_t xva_mask; 890 891 /* 892 * Initialize xvattr, including bzero 893 */ 894 xva_init(xvattr); 895 xoap = xva_getxoptattr(xvattr); 896 897 ASSERT(xoap); 898 899 /* 900 * Copy caller-specified classic attributes to xvattr. 901 * First save xvattr's mask (set in xva_init()), which 902 * contains AT_XVATTR. This is |'d in later if needed. 903 */ 904 905 xva_mask = xvattr->xva_vattr.va_mask; 906 xvattr->xva_vattr = smb_attr->sa_vattr; 907 908 smb_sa_to_va_mask(smb_attr->sa_mask, &xvattr->xva_vattr.va_mask); 909 910 /* 911 * Do not set ctime (only the file system can do it) 912 */ 913 914 xvattr->xva_vattr.va_mask &= ~AT_CTIME; 915 916 if (smb_attr->sa_mask & SMB_AT_DOSATTR) { 917 918 /* 919 * "|" in the original xva_mask, which contains 920 * AT_XVATTR 921 */ 922 923 xvattr->xva_vattr.va_mask |= xva_mask; 924 925 XVA_SET_REQ(xvattr, XAT_ARCHIVE); 926 XVA_SET_REQ(xvattr, XAT_SYSTEM); 927 XVA_SET_REQ(xvattr, XAT_READONLY); 928 XVA_SET_REQ(xvattr, XAT_HIDDEN); 929 XVA_SET_REQ(xvattr, XAT_OFFLINE); 930 XVA_SET_REQ(xvattr, XAT_SPARSE); 931 932 /* 933 * smb_attr->sa_dosattr: If a given bit is not set, 934 * that indicates that the corresponding field needs 935 * to be updated with a "0" value. This is done 936 * implicitly as the xoap->xoa_* fields were bzero'd. 937 */ 938 939 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_ARCHIVE) 940 xoap->xoa_archive = 1; 941 942 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SYSTEM) 943 xoap->xoa_system = 1; 944 945 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_READONLY) 946 xoap->xoa_readonly = 1; 947 948 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_HIDDEN) 949 xoap->xoa_hidden = 1; 950 951 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_OFFLINE) 952 xoap->xoa_offline = 1; 953 954 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SPARSE_FILE) 955 xoap->xoa_sparse = 1; 956 } 957 958 if (smb_attr->sa_mask & SMB_AT_CRTIME) { 959 /* 960 * "|" in the original xva_mask, which contains 961 * AT_XVATTR 962 */ 963 964 xvattr->xva_vattr.va_mask |= xva_mask; 965 XVA_SET_REQ(xvattr, XAT_CREATETIME); 966 xoap->xoa_createtime = smb_attr->sa_crtime; 967 } 968 } 969 970 /* 971 * smb_vop_readdir() 972 * 973 * Collects an SMB_MINLEN_RDDIR_BUF "page" of directory entries. 974 * The directory entries are returned in an fs-independent format by the 975 * underlying file system. That is, the "page" of information returned is 976 * not literally stored on-disk in the format returned. 977 * If the file system supports extended directory entries (has features 978 * VFSFT_DIRENTFLAGS), set V_RDDIR_ENTFLAGS to cause the buffer to be 979 * filled with edirent_t structures, instead of dirent64_t structures. 980 * If the file system supports access based enumeration (abe), set 981 * V_RDDIR_ACCFILTER to filter directory entries based on user cred. 982 */ 983 int 984 smb_vop_readdir(vnode_t *vp, uint32_t offset, 985 void *buf, int *count, int *eof, uint32_t rddir_flag, cred_t *cr) 986 { 987 int error = 0; 988 int flags = 0; 989 int rdirent_size; 990 struct uio auio; 991 struct iovec aiov; 992 993 if (vp->v_type != VDIR) 994 return (ENOTDIR); 995 996 if (vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS)) { 997 flags |= V_RDDIR_ENTFLAGS; 998 rdirent_size = sizeof (edirent_t); 999 } else { 1000 rdirent_size = sizeof (dirent64_t); 1001 } 1002 1003 if (*count < rdirent_size) 1004 return (EINVAL); 1005 1006 if (rddir_flag & SMB_ABE) 1007 flags |= V_RDDIR_ACCFILTER; 1008 1009 aiov.iov_base = buf; 1010 aiov.iov_len = *count; 1011 auio.uio_iov = &aiov; 1012 auio.uio_iovcnt = 1; 1013 auio.uio_loffset = (uint64_t)offset; 1014 auio.uio_segflg = UIO_SYSSPACE; 1015 auio.uio_extflg = UIO_COPY_DEFAULT; 1016 auio.uio_resid = *count; 1017 auio.uio_fmode = 0; 1018 1019 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 1020 error = VOP_READDIR(vp, &auio, cr, eof, &smb_ct, flags); 1021 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct); 1022 1023 if (error == 0) 1024 *count = *count - auio.uio_resid; 1025 1026 return (error); 1027 } 1028 1029 /* 1030 * smb_sa_to_va_mask 1031 * 1032 * Set va_mask by running through the SMB_AT_* #define's and 1033 * setting those bits that correspond to the SMB_AT_* bits 1034 * set in sa_mask. 1035 */ 1036 void 1037 smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp) 1038 { 1039 int i; 1040 uint_t smask; 1041 1042 smask = (sa_mask); 1043 for (i = SMB_AT_TYPE; (i < SMB_AT_MAX) && (smask != 0); ++i) { 1044 if (smask & 1) 1045 *(va_maskp) |= smb_attrmap[i]; 1046 1047 smask >>= 1; 1048 } 1049 } 1050 1051 /* 1052 * smb_vop_stream_lookup() 1053 * 1054 * The name returned in od_name is the on-disk name of the stream with the 1055 * SMB_STREAM_PREFIX stripped off. od_name should be allocated to MAXNAMELEN 1056 * by the caller. 1057 */ 1058 int 1059 smb_vop_stream_lookup( 1060 vnode_t *fvp, 1061 char *stream_name, 1062 vnode_t **vpp, 1063 char *od_name, 1064 vnode_t **xattrdirvpp, 1065 int flags, 1066 vnode_t *rootvp, 1067 cred_t *cr) 1068 { 1069 char *solaris_stream_name; 1070 char *name; 1071 int error, tmpflgs; 1072 1073 if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp, 1074 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0) 1075 return (error); 1076 1077 /* 1078 * Prepend SMB_STREAM_PREFIX to stream name 1079 */ 1080 1081 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1082 (void) snprintf(solaris_stream_name, MAXNAMELEN, 1083 "%s%s", SMB_STREAM_PREFIX, stream_name); 1084 1085 /* 1086 * "name" will hold the on-disk name returned from smb_vop_lookup 1087 * for the stream, including the SMB_STREAM_PREFIX. 1088 */ 1089 1090 name = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 1091 1092 if ((error = smb_vop_lookup(*xattrdirvpp, solaris_stream_name, vpp, 1093 name, flags, &tmpflgs, rootvp, NULL, cr)) != 0) { 1094 VN_RELE(*xattrdirvpp); 1095 } else { 1096 (void) strlcpy(od_name, &(name[SMB_STREAM_PREFIX_LEN]), 1097 MAXNAMELEN); 1098 } 1099 1100 kmem_free(solaris_stream_name, MAXNAMELEN); 1101 kmem_free(name, MAXNAMELEN); 1102 1103 return (error); 1104 } 1105 1106 int 1107 smb_vop_stream_create(vnode_t *fvp, char *stream_name, smb_attr_t *attr, 1108 vnode_t **vpp, vnode_t **xattrdirvpp, int flags, cred_t *cr) 1109 { 1110 char *solaris_stream_name; 1111 int error; 1112 1113 if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp, 1114 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0) 1115 return (error); 1116 1117 /* 1118 * Prepend SMB_STREAM_PREFIX to stream name 1119 */ 1120 1121 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1122 (void) snprintf(solaris_stream_name, MAXNAMELEN, 1123 "%s%s", SMB_STREAM_PREFIX, stream_name); 1124 1125 if ((error = smb_vop_create(*xattrdirvpp, solaris_stream_name, attr, 1126 vpp, flags, cr, NULL)) != 0) 1127 VN_RELE(*xattrdirvpp); 1128 1129 kmem_free(solaris_stream_name, MAXNAMELEN); 1130 1131 return (error); 1132 } 1133 1134 int 1135 smb_vop_stream_remove(vnode_t *vp, char *stream_name, int flags, cred_t *cr) 1136 { 1137 char *solaris_stream_name; 1138 vnode_t *xattrdirvp; 1139 int error; 1140 1141 error = smb_vop_lookup_xattrdir(vp, &xattrdirvp, LOOKUP_XATTR, cr); 1142 if (error != 0) 1143 return (error); 1144 1145 /* 1146 * Prepend SMB_STREAM_PREFIX to stream name 1147 */ 1148 1149 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 1150 (void) snprintf(solaris_stream_name, MAXNAMELEN, 1151 "%s%s", SMB_STREAM_PREFIX, stream_name); 1152 1153 /* XXX might have to use kcred */ 1154 error = smb_vop_remove(xattrdirvp, solaris_stream_name, flags, cr); 1155 1156 kmem_free(solaris_stream_name, MAXNAMELEN); 1157 VN_RELE(xattrdirvp); 1158 1159 return (error); 1160 } 1161 1162 int 1163 smb_vop_lookup_xattrdir(vnode_t *fvp, vnode_t **xattrdirvpp, int flags, 1164 cred_t *cr) 1165 { 1166 int error; 1167 1168 error = VOP_LOOKUP(fvp, "", xattrdirvpp, NULL, flags, NULL, cr, 1169 &smb_ct, NULL, NULL); 1170 return (error); 1171 } 1172 1173 /* 1174 * smb_vop_traverse_check() 1175 * 1176 * This function checks to see if the passed-in vnode has a file system 1177 * mounted on it. If it does, the mount point is "traversed" and the 1178 * vnode for the root of the file system is returned. 1179 */ 1180 int 1181 smb_vop_traverse_check(vnode_t **vpp) 1182 { 1183 int error; 1184 1185 if (vn_mountedvfs(*vpp) == 0) 1186 return (0); 1187 1188 /* 1189 * traverse() may return a different held vnode, even in the error case. 1190 * If it returns a different vnode, it will have released the original. 1191 */ 1192 1193 error = traverse(vpp); 1194 1195 return (error); 1196 } 1197 1198 int /*ARGSUSED*/ 1199 smb_vop_statfs(vnode_t *vp, struct statvfs64 *statp, cred_t *cr) 1200 { 1201 int error; 1202 1203 error = VFS_STATVFS(vp->v_vfsp, statp); 1204 1205 return (error); 1206 } 1207 1208 /* 1209 * smb_vop_acl_read 1210 * 1211 * Reads the ACL of the specified file into 'aclp'. 1212 * acl_type is the type of ACL which the filesystem supports. 1213 * 1214 * Caller has to free the allocated memory for aclp by calling 1215 * acl_free(). 1216 */ 1217 int 1218 smb_vop_acl_read(vnode_t *vp, acl_t **aclp, int flags, acl_type_t acl_type, 1219 cred_t *cr) 1220 { 1221 int error; 1222 vsecattr_t vsecattr; 1223 1224 ASSERT(vp); 1225 ASSERT(aclp); 1226 1227 *aclp = NULL; 1228 bzero(&vsecattr, sizeof (vsecattr_t)); 1229 1230 switch (acl_type) { 1231 case ACLENT_T: 1232 vsecattr.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL | 1233 VSA_DFACLCNT; 1234 break; 1235 1236 case ACE_T: 1237 vsecattr.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS; 1238 break; 1239 1240 default: 1241 return (EINVAL); 1242 } 1243 1244 if ((error = VOP_GETSECATTR(vp, &vsecattr, flags, cr, &smb_ct)) != 0) 1245 return (error); 1246 1247 *aclp = smb_fsacl_from_vsa(&vsecattr, acl_type); 1248 if (vp->v_type == VDIR) 1249 (*aclp)->acl_flags |= ACL_IS_DIR; 1250 1251 return (0); 1252 } 1253 1254 /* 1255 * smb_vop_acl_write 1256 * 1257 * Writes the given ACL in aclp for the specified file. 1258 */ 1259 int 1260 smb_vop_acl_write(vnode_t *vp, acl_t *aclp, int flags, cred_t *cr) 1261 { 1262 int error; 1263 vsecattr_t vsecattr; 1264 int aclbsize; 1265 1266 ASSERT(vp); 1267 ASSERT(aclp); 1268 1269 error = smb_fsacl_to_vsa(aclp, &vsecattr, &aclbsize); 1270 1271 if (error == 0) { 1272 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 1273 error = VOP_SETSECATTR(vp, &vsecattr, flags, cr, &smb_ct); 1274 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct); 1275 } 1276 1277 if (aclbsize && vsecattr.vsa_aclentp) 1278 kmem_free(vsecattr.vsa_aclentp, aclbsize); 1279 1280 return (error); 1281 } 1282 1283 /* 1284 * smb_vop_acl_type 1285 * 1286 * Determines the ACL type for the given vnode. 1287 * ACLENT_T is a Posix ACL and ACE_T is a ZFS ACL. 1288 */ 1289 acl_type_t 1290 smb_vop_acl_type(vnode_t *vp) 1291 { 1292 int error; 1293 ulong_t whichacl; 1294 1295 error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl, 1296 zone_kcred(), NULL); 1297 if (error != 0) { 1298 /* 1299 * If we got an error, then the filesystem 1300 * likely does not understand the _PC_ACL_ENABLED 1301 * pathconf. In this case, we fall back to trying 1302 * POSIX-draft (aka UFS-style) ACLs. 1303 */ 1304 whichacl = _ACL_ACLENT_ENABLED; 1305 } 1306 1307 if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) { 1308 /* 1309 * If the file system supports neither ACE nor 1310 * ACLENT ACLs we will fall back to UFS-style ACLs 1311 * like we did above if there was an error upon 1312 * calling VOP_PATHCONF. 1313 * 1314 * ACE and ACLENT type ACLs are the only interfaces 1315 * supported thus far. If any other bits are set on 1316 * 'whichacl' upon return from VOP_PATHCONF, we will 1317 * ignore them. 1318 */ 1319 whichacl = _ACL_ACLENT_ENABLED; 1320 } 1321 1322 if (whichacl == _ACL_ACLENT_ENABLED) 1323 return (ACLENT_T); 1324 1325 return (ACE_T); 1326 } 1327 1328 static const int zfs_perms[] = { 1329 ACE_READ_DATA, ACE_WRITE_DATA, ACE_APPEND_DATA, ACE_READ_NAMED_ATTRS, 1330 ACE_WRITE_NAMED_ATTRS, ACE_EXECUTE, ACE_DELETE_CHILD, 1331 ACE_READ_ATTRIBUTES, ACE_WRITE_ATTRIBUTES, ACE_DELETE, ACE_READ_ACL, 1332 ACE_WRITE_ACL, ACE_WRITE_OWNER, ACE_SYNCHRONIZE 1333 }; 1334 1335 static const int unix_perms[] = { VREAD, VWRITE, VEXEC }; 1336 /* 1337 * smb_vop_eaccess 1338 * 1339 * Returns the effective permission of the given credential for the 1340 * specified object. 1341 * 1342 * This is just a workaround. We need VFS/FS support for this. 1343 */ 1344 void 1345 smb_vop_eaccess(vnode_t *vp, int *mode, int flags, vnode_t *dir_vp, cred_t *cr) 1346 { 1347 int error, i; 1348 int pnum; 1349 1350 *mode = 0; 1351 1352 if (flags == V_ACE_MASK) { 1353 pnum = sizeof (zfs_perms) / sizeof (int); 1354 1355 for (i = 0; i < pnum; i++) { 1356 error = smb_vop_access(vp, zfs_perms[i], flags, 1357 dir_vp, cr); 1358 if (error == 0) 1359 *mode |= zfs_perms[i]; 1360 } 1361 } else { 1362 pnum = sizeof (unix_perms) / sizeof (int); 1363 1364 for (i = 0; i < pnum; i++) { 1365 error = smb_vop_access(vp, unix_perms[i], flags, 1366 dir_vp, cr); 1367 if (error == 0) 1368 *mode |= unix_perms[i]; 1369 } 1370 } 1371 } 1372 1373 /* 1374 * See comments for smb_fsop_shrlock() 1375 */ 1376 int 1377 smb_vop_shrlock(vnode_t *vp, uint32_t uniq_fid, uint32_t desired_access, 1378 uint32_t share_access, cred_t *cr) 1379 { 1380 struct shrlock shr; 1381 struct shr_locowner shr_own; 1382 short new_access = 0; 1383 short deny = 0; 1384 int flag = 0; 1385 int cmd; 1386 1387 /* 1388 * share locking is not supported for non-regular 1389 * objects in NBMAND mode. 1390 */ 1391 if (nbl_need_check(vp)) { 1392 if (vp->v_type != VREG) 1393 return (0); 1394 1395 cmd = F_SHARE_NBMAND; 1396 } else { 1397 cmd = F_SHARE; 1398 } 1399 1400 if ((desired_access & FILE_DATA_ALL) == 0) { 1401 /* metadata access only */ 1402 new_access |= F_MDACC; 1403 } else { 1404 if (desired_access & (ACE_READ_DATA | ACE_EXECUTE)) { 1405 new_access |= F_RDACC; 1406 flag |= FREAD; 1407 } 1408 1409 if (desired_access & (ACE_WRITE_DATA | ACE_APPEND_DATA | 1410 ACE_ADD_FILE)) { 1411 new_access |= F_WRACC; 1412 flag |= FWRITE; 1413 } 1414 1415 if (SMB_DENY_READ(share_access)) { 1416 deny |= F_RDDNY; 1417 } 1418 1419 if (SMB_DENY_WRITE(share_access)) { 1420 deny |= F_WRDNY; 1421 } 1422 1423 if (cmd == F_SHARE_NBMAND) { 1424 if (desired_access & ACE_DELETE) 1425 new_access |= F_RMACC; 1426 1427 if (SMB_DENY_DELETE(share_access)) { 1428 deny |= F_RMDNY; 1429 } 1430 } 1431 } 1432 1433 shr.s_access = new_access; 1434 shr.s_deny = deny; 1435 shr.s_sysid = smb_ct.cc_sysid; 1436 shr.s_pid = uniq_fid; 1437 shr.s_own_len = sizeof (shr_own); 1438 shr.s_owner = (caddr_t)&shr_own; 1439 shr_own.sl_id = shr.s_sysid; 1440 shr_own.sl_pid = shr.s_pid; 1441 1442 return (VOP_SHRLOCK(vp, cmd, &shr, flag, cr, NULL)); 1443 } 1444 1445 int 1446 smb_vop_unshrlock(vnode_t *vp, uint32_t uniq_fid, cred_t *cr) 1447 { 1448 struct shrlock shr; 1449 struct shr_locowner shr_own; 1450 1451 /* 1452 * share locking is not supported for non-regular 1453 * objects in NBMAND mode. 1454 */ 1455 if (nbl_need_check(vp) && (vp->v_type != VREG)) 1456 return (0); 1457 1458 /* 1459 * For s_access and s_deny, we do not need to pass in the original 1460 * values. 1461 */ 1462 shr.s_access = 0; 1463 shr.s_deny = 0; 1464 shr.s_sysid = smb_ct.cc_sysid; 1465 shr.s_pid = uniq_fid; 1466 shr.s_own_len = sizeof (shr_own); 1467 shr.s_owner = (caddr_t)&shr_own; 1468 shr_own.sl_id = shr.s_sysid; 1469 shr_own.sl_pid = shr.s_pid; 1470 1471 return (VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, cr, NULL)); 1472 } 1473 1474 /* 1475 * Note about mandatory vs advisory locks: 1476 * 1477 * The SMB server really should always request mandatory locks, and 1478 * if the file system does not support them, the SMB server should 1479 * just tell the client it could not get the lock. If we were to 1480 * tell the SMB client "you got the lock" when what they really 1481 * got was only an advisory lock, we would be lying to the client 1482 * about their having exclusive access to the locked range, which 1483 * could easily lead to data corruption. If someone really wants 1484 * the (dangerous) behavior they can set: smb_allow_advisory_locks 1485 */ 1486 int 1487 smb_vop_frlock(vnode_t *vp, cred_t *cr, int flag, flock64_t *bf) 1488 { 1489 flk_callback_t flk_cb; 1490 int cmd = F_SETLK_NBMAND; 1491 1492 if (smb_allow_advisory_locks != 0 && !nbl_need_check(vp)) { 1493 /* 1494 * The file system does not support nbmand, and 1495 * smb_allow_advisory_locks is enabled. (danger!) 1496 */ 1497 cmd = F_SETLK; 1498 } 1499 1500 flk_init_callback(&flk_cb, smb_lock_frlock_callback, NULL); 1501 1502 return (VOP_FRLOCK(vp, cmd, bf, flag, 0, &flk_cb, cr, &smb_ct)); 1503 } 1504 1505 static callb_cpr_t * 1506 /* ARGSUSED */ 1507 smb_lock_frlock_callback(flk_cb_when_t when, void *error) 1508 { 1509 return (0); 1510 } 1511 1512 /* 1513 * smb_vop_catia_init_v4_lookup 1514 * Initialize mapping between wide characters in the range from 1515 * 0x00A4 to 0x00FF and their UNIX (v4) equivalent (wide character). 1516 * Indexed by the decimal value of the wide character (164-255) 1517 * with an offset of -164. 1518 */ 1519 static void 1520 smb_vop_catia_init_v4_lookup() 1521 { 1522 int i, idx, offset = SMB_CATIA_V4_LOOKUP_LOW; 1523 1524 for (i = 0; i < SMB_CATIA_V4_LOOKUP_MAX; i++) 1525 smb_catia_v4_lookup[i] = (smb_wchar_t)(i + offset); 1526 1527 for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) { 1528 idx = (int)catia_maps[i].winchar - offset; 1529 smb_catia_v4_lookup[idx] = (smb_wchar_t)catia_maps[i].unixchar; 1530 } 1531 } 1532 1533 /* 1534 * smb_vop_catia_init_v5_lookup 1535 * Initialize mapping between UNIX ASCII (v4) characters and equivalent 1536 * or translated wide characters. 1537 * Indexed by the decimal value of the ASCII character (0-127). 1538 */ 1539 static void 1540 smb_vop_catia_init_v5_lookup() 1541 { 1542 int i, idx; 1543 1544 for (i = 0; i < SMB_CATIA_V5_LOOKUP_MAX; i++) 1545 smb_catia_v5_lookup[i] = (smb_wchar_t)i; 1546 1547 for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) { 1548 idx = (int)catia_maps[i].unixchar; 1549 smb_catia_v5_lookup[idx] = catia_maps[i].winchar; 1550 } 1551 } 1552 1553 static void 1554 smb_vop_catia_init() 1555 { 1556 smb_vop_catia_init_v4_lookup(); 1557 smb_vop_catia_init_v5_lookup(); 1558 } 1559 1560 /* 1561 * smb_vop_catia_v5tov4 1562 * (windows (v5) to unix (v4)) 1563 * 1564 * Traverse each character in the given source filename and convert the 1565 * multibyte that is equivalent to any special Windows character listed 1566 * in the catia_maps table to the Unix ASCII character if any is 1567 * encountered in the filename. The translated name is returned in buf. 1568 * 1569 * If an error occurs the conversion terminates and name is returned, 1570 * otherwise buf is returned. 1571 */ 1572 char * 1573 smb_vop_catia_v5tov4(char *name, char *buf, int buflen) 1574 { 1575 int v4_idx, numbytes, inc; 1576 int space_left = buflen - 1; /* one byte reserved for null */ 1577 smb_wchar_t wc; 1578 char mbstring[MTS_MB_CHAR_MAX]; 1579 char *p, *src = name, *dst = buf; 1580 1581 ASSERT(name); 1582 ASSERT(buf); 1583 1584 if (!buf || !name) 1585 return (name); 1586 1587 bzero(buf, buflen); 1588 1589 while (*src) { 1590 if ((numbytes = smb_mbtowc(&wc, src, MTS_MB_CHAR_MAX)) < 0) 1591 return (name); 1592 1593 if (wc < SMB_CATIA_V4_LOOKUP_LOW || 1594 wc > SMB_CATIA_V4_LOOKUP_UPPER) { 1595 inc = numbytes; 1596 p = src; 1597 } else { 1598 /* Lookup required. */ 1599 v4_idx = (int)wc - SMB_CATIA_V4_LOOKUP_LOW; 1600 inc = smb_wctomb(mbstring, smb_catia_v4_lookup[v4_idx]); 1601 p = mbstring; 1602 } 1603 1604 if (space_left < inc) 1605 return (name); 1606 1607 (void) strncpy(dst, p, inc); 1608 dst += inc; 1609 space_left -= inc; 1610 src += numbytes; 1611 } 1612 1613 return (buf); 1614 } 1615 1616 /* 1617 * smb_vop_catia_v4tov5 1618 * (unix (v4) to windows (v5)) 1619 * 1620 * Traverse each character in the given filename 'srcbuf' and convert 1621 * the special Unix character that is listed in the catia_maps table to 1622 * the UTF-8 encoding of the corresponding Windows character if any is 1623 * encountered in the filename. 1624 * 1625 * The translated name is returned in buf. 1626 * If an error occurs the conversion terminates and the original name 1627 * is returned in buf. 1628 */ 1629 void 1630 smb_vop_catia_v4tov5(char *name, char *buf, int buflen) 1631 { 1632 int v5_idx, numbytes; 1633 int space_left = buflen - 1; /* one byte reserved for null */ 1634 smb_wchar_t wc; 1635 char mbstring[MTS_MB_CHAR_MAX]; 1636 char *src = name, *dst = buf; 1637 1638 ASSERT(name); 1639 ASSERT(buf); 1640 1641 if (!buf || !name) 1642 return; 1643 1644 (void) bzero(buf, buflen); 1645 while (*src) { 1646 if (smb_isascii(*src)) { 1647 /* Lookup required */ 1648 v5_idx = (int)*src++; 1649 numbytes = smb_wctomb(mbstring, 1650 smb_catia_v5_lookup[v5_idx]); 1651 if (space_left < numbytes) 1652 break; 1653 (void) strncpy(dst, mbstring, numbytes); 1654 } else { 1655 if ((numbytes = smb_mbtowc(&wc, src, 1656 MTS_MB_CHAR_MAX)) < 0) 1657 break; 1658 if (space_left < numbytes) 1659 break; 1660 (void) strncpy(dst, src, numbytes); 1661 src += numbytes; 1662 } 1663 1664 dst += numbytes; 1665 space_left -= numbytes; 1666 } 1667 1668 if (*src) 1669 (void) strlcpy(buf, name, buflen); 1670 } 1671