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 error = VOP_LOOKUP(dvp, np, vpp, NULL, option_flags, NULL, cr,
624 &smb_ct, direntflags, &rpn);
625
626 if (error == 0) {
627 if (od_name) {
628 bzero(od_name, MAXNAMELEN);
629 np = (option_flags == FIGNORECASE) ? rpn.pn_buf : name;
630
631 if (flags & SMB_CATIA)
632 smb_vop_catia_v4tov5(np, od_name, MAXNAMELEN);
633 else
634 (void) strlcpy(od_name, np, MAXNAMELEN);
635 }
636
637 if (attr != NULL) {
638 attr->sa_mask = SMB_AT_ALL;
639 (void) smb_vop_getattr(*vpp, NULL, attr, 0,
640 zone_kcred());
641 }
642 }
643
644 pn_free(&rpn);
645 return (error);
646 }
647
648 int
649 smb_vop_create(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp,
650 int flags, cred_t *cr, vsecattr_t *vsap)
651 {
652 int error;
653 int option_flags = 0;
654 xvattr_t xvattr;
655 vattr_t *vap;
656 char *np = name;
657 char namebuf[MAXNAMELEN];
658
659 if (flags & SMB_IGNORE_CASE)
660 option_flags = FIGNORECASE;
661
662 attr->sa_vattr.va_mask = 0;
663
664 if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) {
665 smb_vop_setup_xvattr(attr, &xvattr);
666 vap = &xvattr.xva_vattr;
667 } else {
668 smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);
669 vap = &attr->sa_vattr;
670 }
671
672 if (flags & SMB_CATIA) {
673 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
674 if (strchr(np, '/') != NULL)
675 return (EILSEQ);
676 }
677
678 error = VOP_CREATE(dvp, np, vap, EXCL, attr->sa_vattr.va_mode,
679 vpp, cr, option_flags, &smb_ct, vsap);
680
681 return (error);
682 }
683
684 int
685 smb_vop_remove(vnode_t *dvp, char *name, int flags, cred_t *cr)
686 {
687 int error;
688 int option_flags = 0;
689 char *np = name;
690 char namebuf[MAXNAMELEN];
691
692 if (flags & SMB_IGNORE_CASE)
693 option_flags = FIGNORECASE;
694
695 if (flags & SMB_CATIA)
696 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
697
698 error = VOP_REMOVE(dvp, np, cr, &smb_ct, option_flags);
699
700 return (error);
701 }
702
703 /*
704 * smb_vop_link(target-dir-vp, source-file-vp, target-name)
705 *
706 * Create a link - same tree (identical TID) only.
707 */
708 int
709 smb_vop_link(vnode_t *to_dvp, vnode_t *from_vp, char *to_name,
710 int flags, cred_t *cr)
711 {
712 int option_flags = 0;
713 char *np, *buf;
714 int rc;
715
716 if (flags & SMB_IGNORE_CASE)
717 option_flags = FIGNORECASE;
718
719 if (flags & SMB_CATIA) {
720 buf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
721 np = smb_vop_catia_v5tov4(to_name, buf, MAXNAMELEN);
722 if (strchr(np, '/') != NULL) {
723 kmem_free(buf, MAXNAMELEN);
724 return (EILSEQ);
725 }
726
727 rc = VOP_LINK(to_dvp, from_vp, np, cr, &smb_ct, option_flags);
728 kmem_free(buf, MAXNAMELEN);
729 return (rc);
730 }
731
732 rc = VOP_LINK(to_dvp, from_vp, to_name, cr, &smb_ct, option_flags);
733 return (rc);
734 }
735
736 /*
737 * smb_vop_rename()
738 *
739 * The rename is for files in the same tree (identical TID) only.
740 */
741 int
742 smb_vop_rename(vnode_t *from_dvp, char *from_name, vnode_t *to_dvp,
743 char *to_name, int flags, cred_t *cr)
744 {
745 int error;
746 int option_flags = 0;
747 char *from, *to, *fbuf, *tbuf;
748
749 if (flags & SMB_IGNORE_CASE)
750 option_flags = FIGNORECASE;
751
752 if (flags & SMB_CATIA) {
753 tbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
754 to = smb_vop_catia_v5tov4(to_name, tbuf, MAXNAMELEN);
755 if (strchr(to, '/') != NULL) {
756 kmem_free(tbuf, MAXNAMELEN);
757 return (EILSEQ);
758 }
759
760 fbuf = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
761 from = smb_vop_catia_v5tov4(from_name, fbuf, MAXNAMELEN);
762
763 error = VOP_RENAME(from_dvp, from, to_dvp, to, cr,
764 &smb_ct, option_flags);
765
766 kmem_free(tbuf, MAXNAMELEN);
767 kmem_free(fbuf, MAXNAMELEN);
768 return (error);
769 }
770
771 error = VOP_RENAME(from_dvp, from_name, to_dvp, to_name, cr,
772 &smb_ct, option_flags);
773
774 return (error);
775 }
776
777 int
778 smb_vop_mkdir(vnode_t *dvp, char *name, smb_attr_t *attr, vnode_t **vpp,
779 int flags, cred_t *cr, vsecattr_t *vsap)
780 {
781 int error;
782 int option_flags = 0;
783 xvattr_t xvattr;
784 vattr_t *vap;
785 char *np = name;
786 char namebuf[MAXNAMELEN];
787
788 if (flags & SMB_IGNORE_CASE)
789 option_flags = FIGNORECASE;
790
791 attr->sa_vattr.va_mask = 0;
792
793 if (vfs_has_feature(dvp->v_vfsp, VFSFT_XVATTR)) {
794 smb_vop_setup_xvattr(attr, &xvattr);
795 vap = &xvattr.xva_vattr;
796 } else {
797 smb_sa_to_va_mask(attr->sa_mask, &attr->sa_vattr.va_mask);
798 vap = &attr->sa_vattr;
799 }
800
801 if (flags & SMB_CATIA) {
802 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
803 if (strchr(np, '/') != NULL)
804 return (EILSEQ);
805 }
806
807 error = VOP_MKDIR(dvp, np, vap, vpp, cr, &smb_ct, option_flags, vsap);
808
809 return (error);
810 }
811
812 /*
813 * smb_vop_rmdir()
814 *
815 * Only simple rmdir supported, consistent with NT semantics
816 * (can only remove an empty directory).
817 *
818 * The third argument to VOP_RMDIR is the current directory of
819 * the process. It allows rmdir wants to EINVAL if one tries to
820 * remove ".". Since SMB servers do not know what their clients'
821 * current directories are, we fake it by supplying a vnode known
822 * to exist and illegal to remove (rootdir).
823 */
824 int
825 smb_vop_rmdir(vnode_t *dvp, char *name, int flags, cred_t *cr)
826 {
827 int error;
828 int option_flags = 0;
829 char *np = name;
830 char namebuf[MAXNAMELEN];
831
832 if (flags & SMB_IGNORE_CASE)
833 option_flags = FIGNORECASE;
834
835 if (flags & SMB_CATIA)
836 np = smb_vop_catia_v5tov4(name, namebuf, sizeof (namebuf));
837
838 error = VOP_RMDIR(dvp, np, rootdir, cr, &smb_ct, option_flags);
839 return (error);
840 }
841
842 int
843 smb_vop_commit(vnode_t *vp, cred_t *cr)
844 {
845 return (VOP_FSYNC(vp, 1, cr, &smb_ct));
846 }
847
848 /*
849 * Some code in smb_node.c needs to know which DOS attributes
850 * we can actually store. Let's define a mask here of all the
851 * DOS attribute flags supported by the following function.
852 */
853 const uint32_t
854 smb_vop_dosattr_settable =
855 FILE_ATTRIBUTE_ARCHIVE |
856 FILE_ATTRIBUTE_SYSTEM |
857 FILE_ATTRIBUTE_HIDDEN |
858 FILE_ATTRIBUTE_READONLY |
859 FILE_ATTRIBUTE_OFFLINE |
860 FILE_ATTRIBUTE_SPARSE_FILE;
861
862 static void
863 smb_vop_setup_xvattr(smb_attr_t *smb_attr, xvattr_t *xvattr)
864 {
865 xoptattr_t *xoap = NULL;
866 uint_t xva_mask;
867
868 /*
869 * Initialize xvattr, including bzero
870 */
871 xva_init(xvattr);
872 xoap = xva_getxoptattr(xvattr);
873
874 ASSERT(xoap);
875
876 /*
877 * Copy caller-specified classic attributes to xvattr.
878 * First save xvattr's mask (set in xva_init()), which
879 * contains AT_XVATTR. This is |'d in later if needed.
880 */
881
882 xva_mask = xvattr->xva_vattr.va_mask;
883 xvattr->xva_vattr = smb_attr->sa_vattr;
884
885 smb_sa_to_va_mask(smb_attr->sa_mask, &xvattr->xva_vattr.va_mask);
886
887 /*
888 * Do not set ctime (only the file system can do it)
889 */
890
891 xvattr->xva_vattr.va_mask &= ~AT_CTIME;
892
893 if (smb_attr->sa_mask & SMB_AT_DOSATTR) {
894
895 /*
896 * "|" in the original xva_mask, which contains
897 * AT_XVATTR
898 */
899
900 xvattr->xva_vattr.va_mask |= xva_mask;
901
902 XVA_SET_REQ(xvattr, XAT_ARCHIVE);
903 XVA_SET_REQ(xvattr, XAT_SYSTEM);
904 XVA_SET_REQ(xvattr, XAT_READONLY);
905 XVA_SET_REQ(xvattr, XAT_HIDDEN);
906 XVA_SET_REQ(xvattr, XAT_OFFLINE);
907 XVA_SET_REQ(xvattr, XAT_SPARSE);
908
909 /*
910 * smb_attr->sa_dosattr: If a given bit is not set,
911 * that indicates that the corresponding field needs
912 * to be updated with a "0" value. This is done
913 * implicitly as the xoap->xoa_* fields were bzero'd.
914 */
915
916 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_ARCHIVE)
917 xoap->xoa_archive = 1;
918
919 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SYSTEM)
920 xoap->xoa_system = 1;
921
922 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_READONLY)
923 xoap->xoa_readonly = 1;
924
925 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_HIDDEN)
926 xoap->xoa_hidden = 1;
927
928 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_OFFLINE)
929 xoap->xoa_offline = 1;
930
931 if (smb_attr->sa_dosattr & FILE_ATTRIBUTE_SPARSE_FILE)
932 xoap->xoa_sparse = 1;
933 }
934
935 if (smb_attr->sa_mask & SMB_AT_CRTIME) {
936 /*
937 * "|" in the original xva_mask, which contains
938 * AT_XVATTR
939 */
940
941 xvattr->xva_vattr.va_mask |= xva_mask;
942 XVA_SET_REQ(xvattr, XAT_CREATETIME);
943 xoap->xoa_createtime = smb_attr->sa_crtime;
944 }
945 }
946
947 /*
948 * smb_vop_readdir()
949 *
950 * Collects an SMB_MINLEN_RDDIR_BUF "page" of directory entries.
951 * The directory entries are returned in an fs-independent format by the
952 * underlying file system. That is, the "page" of information returned is
953 * not literally stored on-disk in the format returned.
954 * If the file system supports extended directory entries (has features
955 * VFSFT_DIRENTFLAGS), set V_RDDIR_ENTFLAGS to cause the buffer to be
956 * filled with edirent_t structures, instead of dirent64_t structures.
957 * If the file system supports access based enumeration (abe), set
958 * V_RDDIR_ACCFILTER to filter directory entries based on user cred.
959 */
960 int
961 smb_vop_readdir(vnode_t *vp, uint32_t offset,
962 void *buf, int *count, int *eof, uint32_t rddir_flag, cred_t *cr)
963 {
964 int error = 0;
965 int flags = 0;
966 int rdirent_size;
967 struct uio auio;
968 struct iovec aiov;
969
970 if (vp->v_type != VDIR)
971 return (ENOTDIR);
972
973 if (vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS)) {
974 flags |= V_RDDIR_ENTFLAGS;
975 rdirent_size = sizeof (edirent_t);
976 } else {
977 rdirent_size = sizeof (dirent64_t);
978 }
979
980 if (*count < rdirent_size)
981 return (EINVAL);
982
983 if (rddir_flag & SMB_ABE)
984 flags |= V_RDDIR_ACCFILTER;
985
986 aiov.iov_base = buf;
987 aiov.iov_len = *count;
988 auio.uio_iov = &aiov;
989 auio.uio_iovcnt = 1;
990 auio.uio_loffset = (uint64_t)offset;
991 auio.uio_segflg = UIO_SYSSPACE;
992 auio.uio_extflg = UIO_COPY_DEFAULT;
993 auio.uio_resid = *count;
994 auio.uio_fmode = 0;
995
996 (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);
997 error = VOP_READDIR(vp, &auio, cr, eof, &smb_ct, flags);
998 VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, &smb_ct);
999
1000 if (error == 0)
1001 *count = *count - auio.uio_resid;
1002
1003 return (error);
1004 }
1005
1006 /*
1007 * smb_sa_to_va_mask
1008 *
1009 * Set va_mask by running through the SMB_AT_* #define's and
1010 * setting those bits that correspond to the SMB_AT_* bits
1011 * set in sa_mask.
1012 */
1013 void
1014 smb_sa_to_va_mask(uint_t sa_mask, uint_t *va_maskp)
1015 {
1016 int i;
1017 uint_t smask;
1018
1019 smask = (sa_mask);
1020 for (i = SMB_AT_TYPE; (i < SMB_AT_MAX) && (smask != 0); ++i) {
1021 if (smask & 1)
1022 *(va_maskp) |= smb_attrmap[i];
1023
1024 smask >>= 1;
1025 }
1026 }
1027
1028 /*
1029 * smb_vop_stream_lookup()
1030 *
1031 * The name returned in od_name is the on-disk name of the stream with the
1032 * SMB_STREAM_PREFIX stripped off. od_name should be allocated to MAXNAMELEN
1033 * by the caller.
1034 */
1035 int
1036 smb_vop_stream_lookup(
1037 vnode_t *fvp,
1038 char *stream_name,
1039 vnode_t **vpp,
1040 char *od_name,
1041 vnode_t **xattrdirvpp,
1042 int flags,
1043 vnode_t *rootvp,
1044 cred_t *cr)
1045 {
1046 char *solaris_stream_name;
1047 char *name;
1048 int error, tmpflgs;
1049
1050 if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp,
1051 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0)
1052 return (error);
1053
1054 /*
1055 * Prepend SMB_STREAM_PREFIX to stream name
1056 */
1057
1058 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1059 (void) snprintf(solaris_stream_name, MAXNAMELEN,
1060 "%s%s", SMB_STREAM_PREFIX, stream_name);
1061
1062 /*
1063 * "name" will hold the on-disk name returned from smb_vop_lookup
1064 * for the stream, including the SMB_STREAM_PREFIX.
1065 */
1066
1067 name = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
1068
1069 if ((error = smb_vop_lookup(*xattrdirvpp, solaris_stream_name, vpp,
1070 name, flags, &tmpflgs, rootvp, NULL, cr)) != 0) {
1071 VN_RELE(*xattrdirvpp);
1072 } else {
1073 (void) strlcpy(od_name, &(name[SMB_STREAM_PREFIX_LEN]),
1074 MAXNAMELEN);
1075 }
1076
1077 kmem_free(solaris_stream_name, MAXNAMELEN);
1078 kmem_free(name, MAXNAMELEN);
1079
1080 return (error);
1081 }
1082
1083 int
1084 smb_vop_stream_create(vnode_t *fvp, char *stream_name, smb_attr_t *attr,
1085 vnode_t **vpp, vnode_t **xattrdirvpp, int flags, cred_t *cr)
1086 {
1087 char *solaris_stream_name;
1088 int error;
1089
1090 if ((error = smb_vop_lookup_xattrdir(fvp, xattrdirvpp,
1091 LOOKUP_XATTR | CREATE_XATTR_DIR, cr)) != 0)
1092 return (error);
1093
1094 /*
1095 * Prepend SMB_STREAM_PREFIX to stream name
1096 */
1097
1098 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1099 (void) snprintf(solaris_stream_name, MAXNAMELEN,
1100 "%s%s", SMB_STREAM_PREFIX, stream_name);
1101
1102 if ((error = smb_vop_create(*xattrdirvpp, solaris_stream_name, attr,
1103 vpp, flags, cr, NULL)) != 0)
1104 VN_RELE(*xattrdirvpp);
1105
1106 kmem_free(solaris_stream_name, MAXNAMELEN);
1107
1108 return (error);
1109 }
1110
1111 int
1112 smb_vop_stream_remove(vnode_t *vp, char *stream_name, int flags, cred_t *cr)
1113 {
1114 char *solaris_stream_name;
1115 vnode_t *xattrdirvp;
1116 int error;
1117
1118 error = smb_vop_lookup_xattrdir(vp, &xattrdirvp, LOOKUP_XATTR, cr);
1119 if (error != 0)
1120 return (error);
1121
1122 /*
1123 * Prepend SMB_STREAM_PREFIX to stream name
1124 */
1125
1126 solaris_stream_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
1127 (void) snprintf(solaris_stream_name, MAXNAMELEN,
1128 "%s%s", SMB_STREAM_PREFIX, stream_name);
1129
1130 /* XXX might have to use kcred */
1131 error = smb_vop_remove(xattrdirvp, solaris_stream_name, flags, cr);
1132
1133 kmem_free(solaris_stream_name, MAXNAMELEN);
1134 VN_RELE(xattrdirvp);
1135
1136 return (error);
1137 }
1138
1139 int
1140 smb_vop_lookup_xattrdir(vnode_t *fvp, vnode_t **xattrdirvpp, int flags,
1141 cred_t *cr)
1142 {
1143 int error;
1144
1145 error = VOP_LOOKUP(fvp, "", xattrdirvpp, NULL, flags, NULL, cr,
1146 &smb_ct, NULL, NULL);
1147 return (error);
1148 }
1149
1150 /*
1151 * smb_vop_traverse_check()
1152 *
1153 * This function checks to see if the passed-in vnode has a file system
1154 * mounted on it. If it does, the mount point is "traversed" and the
1155 * vnode for the root of the file system is returned.
1156 */
1157 int
1158 smb_vop_traverse_check(vnode_t **vpp)
1159 {
1160 int error;
1161
1162 if (vn_mountedvfs(*vpp) == 0)
1163 return (0);
1164
1165 /*
1166 * traverse() may return a different held vnode, even in the error case.
1167 * If it returns a different vnode, it will have released the original.
1168 */
1169
1170 error = traverse(vpp);
1171
1172 return (error);
1173 }
1174
1175 int /*ARGSUSED*/
1176 smb_vop_statfs(vnode_t *vp, struct statvfs64 *statp, cred_t *cr)
1177 {
1178 int error;
1179
1180 error = VFS_STATVFS(vp->v_vfsp, statp);
1181
1182 return (error);
1183 }
1184
1185 /*
1186 * smb_vop_acl_read
1187 *
1188 * Reads the ACL of the specified file into 'aclp'.
1189 * acl_type is the type of ACL which the filesystem supports.
1190 *
1191 * Caller has to free the allocated memory for aclp by calling
1192 * acl_free().
1193 */
1194 int
1195 smb_vop_acl_read(vnode_t *vp, acl_t **aclp, int flags, acl_type_t acl_type,
1196 cred_t *cr)
1197 {
1198 int error;
1199 vsecattr_t vsecattr;
1200
1201 ASSERT(vp);
1202 ASSERT(aclp);
1203
1204 *aclp = NULL;
1205 bzero(&vsecattr, sizeof (vsecattr_t));
1206
1207 switch (acl_type) {
1208 case ACLENT_T:
1209 vsecattr.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL |
1210 VSA_DFACLCNT;
1211 break;
1212
1213 case ACE_T:
1214 vsecattr.vsa_mask = VSA_ACE | VSA_ACECNT | VSA_ACE_ACLFLAGS;
1215 break;
1216
1217 default:
1218 return (EINVAL);
1219 }
1220
1221 if (error = VOP_GETSECATTR(vp, &vsecattr, flags, cr, &smb_ct))
1222 return (error);
1223
1224 *aclp = smb_fsacl_from_vsa(&vsecattr, acl_type);
1225 if (vp->v_type == VDIR)
1226 (*aclp)->acl_flags |= ACL_IS_DIR;
1227
1228 return (0);
1229 }
1230
1231 /*
1232 * smb_vop_acl_write
1233 *
1234 * Writes the given ACL in aclp for the specified file.
1235 */
1236 int
1237 smb_vop_acl_write(vnode_t *vp, acl_t *aclp, int flags, cred_t *cr)
1238 {
1239 int error;
1240 vsecattr_t vsecattr;
1241 int aclbsize;
1242
1243 ASSERT(vp);
1244 ASSERT(aclp);
1245
1246 error = smb_fsacl_to_vsa(aclp, &vsecattr, &aclbsize);
1247
1248 if (error == 0) {
1249 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);
1250 error = VOP_SETSECATTR(vp, &vsecattr, flags, cr, &smb_ct);
1251 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, &smb_ct);
1252 }
1253
1254 if (aclbsize && vsecattr.vsa_aclentp)
1255 kmem_free(vsecattr.vsa_aclentp, aclbsize);
1256
1257 return (error);
1258 }
1259
1260 /*
1261 * smb_vop_acl_type
1262 *
1263 * Determines the ACL type for the given vnode.
1264 * ACLENT_T is a Posix ACL and ACE_T is a ZFS ACL.
1265 */
1266 acl_type_t
1267 smb_vop_acl_type(vnode_t *vp)
1268 {
1269 int error;
1270 ulong_t whichacl;
1271
1272 error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl,
1273 zone_kcred(), NULL);
1274 if (error != 0) {
1275 /*
1276 * If we got an error, then the filesystem
1277 * likely does not understand the _PC_ACL_ENABLED
1278 * pathconf. In this case, we fall back to trying
1279 * POSIX-draft (aka UFS-style) ACLs.
1280 */
1281 whichacl = _ACL_ACLENT_ENABLED;
1282 }
1283
1284 if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) {
1285 /*
1286 * If the file system supports neither ACE nor
1287 * ACLENT ACLs we will fall back to UFS-style ACLs
1288 * like we did above if there was an error upon
1289 * calling VOP_PATHCONF.
1290 *
1291 * ACE and ACLENT type ACLs are the only interfaces
1292 * supported thus far. If any other bits are set on
1293 * 'whichacl' upon return from VOP_PATHCONF, we will
1294 * ignore them.
1295 */
1296 whichacl = _ACL_ACLENT_ENABLED;
1297 }
1298
1299 if (whichacl == _ACL_ACLENT_ENABLED)
1300 return (ACLENT_T);
1301
1302 return (ACE_T);
1303 }
1304
1305 static const int zfs_perms[] = {
1306 ACE_READ_DATA, ACE_WRITE_DATA, ACE_APPEND_DATA, ACE_READ_NAMED_ATTRS,
1307 ACE_WRITE_NAMED_ATTRS, ACE_EXECUTE, ACE_DELETE_CHILD,
1308 ACE_READ_ATTRIBUTES, ACE_WRITE_ATTRIBUTES, ACE_DELETE, ACE_READ_ACL,
1309 ACE_WRITE_ACL, ACE_WRITE_OWNER, ACE_SYNCHRONIZE
1310 };
1311
1312 static const int unix_perms[] = { VREAD, VWRITE, VEXEC };
1313 /*
1314 * smb_vop_eaccess
1315 *
1316 * Returns the effective permission of the given credential for the
1317 * specified object.
1318 *
1319 * This is just a workaround. We need VFS/FS support for this.
1320 */
1321 void
1322 smb_vop_eaccess(vnode_t *vp, int *mode, int flags, vnode_t *dir_vp, cred_t *cr)
1323 {
1324 int error, i;
1325 int pnum;
1326
1327 *mode = 0;
1328
1329 if (flags == V_ACE_MASK) {
1330 pnum = sizeof (zfs_perms) / sizeof (int);
1331
1332 for (i = 0; i < pnum; i++) {
1333 error = smb_vop_access(vp, zfs_perms[i], flags,
1334 dir_vp, cr);
1335 if (error == 0)
1336 *mode |= zfs_perms[i];
1337 }
1338 } else {
1339 pnum = sizeof (unix_perms) / sizeof (int);
1340
1341 for (i = 0; i < pnum; i++) {
1342 error = smb_vop_access(vp, unix_perms[i], flags,
1343 dir_vp, cr);
1344 if (error == 0)
1345 *mode |= unix_perms[i];
1346 }
1347 }
1348 }
1349
1350 /*
1351 * See comments for smb_fsop_shrlock()
1352 */
1353 int
1354 smb_vop_shrlock(vnode_t *vp, uint32_t uniq_fid, uint32_t desired_access,
1355 uint32_t share_access, cred_t *cr)
1356 {
1357 struct shrlock shr;
1358 struct shr_locowner shr_own;
1359 short new_access = 0;
1360 short deny = 0;
1361 int flag = 0;
1362 int cmd;
1363
1364 /*
1365 * share locking is not supported for non-regular
1366 * objects in NBMAND mode.
1367 */
1368 if (nbl_need_check(vp)) {
1369 if (vp->v_type != VREG)
1370 return (0);
1371
1372 cmd = F_SHARE_NBMAND;
1373 } else {
1374 cmd = F_SHARE;
1375 }
1376
1377 if ((desired_access & FILE_DATA_ALL) == 0) {
1378 /* metadata access only */
1379 new_access |= F_MDACC;
1380 } else {
1381 if (desired_access & (ACE_READ_DATA | ACE_EXECUTE)) {
1382 new_access |= F_RDACC;
1383 flag |= FREAD;
1384 }
1385
1386 if (desired_access & (ACE_WRITE_DATA | ACE_APPEND_DATA |
1387 ACE_ADD_FILE)) {
1388 new_access |= F_WRACC;
1389 flag |= FWRITE;
1390 }
1391
1392 if (SMB_DENY_READ(share_access)) {
1393 deny |= F_RDDNY;
1394 }
1395
1396 if (SMB_DENY_WRITE(share_access)) {
1397 deny |= F_WRDNY;
1398 }
1399
1400 if (cmd == F_SHARE_NBMAND) {
1401 if (desired_access & ACE_DELETE)
1402 new_access |= F_RMACC;
1403
1404 if (SMB_DENY_DELETE(share_access)) {
1405 deny |= F_RMDNY;
1406 }
1407 }
1408 }
1409
1410 shr.s_access = new_access;
1411 shr.s_deny = deny;
1412 shr.s_sysid = smb_ct.cc_sysid;
1413 shr.s_pid = uniq_fid;
1414 shr.s_own_len = sizeof (shr_own);
1415 shr.s_owner = (caddr_t)&shr_own;
1416 shr_own.sl_id = shr.s_sysid;
1417 shr_own.sl_pid = shr.s_pid;
1418
1419 return (VOP_SHRLOCK(vp, cmd, &shr, flag, cr, NULL));
1420 }
1421
1422 int
1423 smb_vop_unshrlock(vnode_t *vp, uint32_t uniq_fid, cred_t *cr)
1424 {
1425 struct shrlock shr;
1426 struct shr_locowner shr_own;
1427
1428 /*
1429 * share locking is not supported for non-regular
1430 * objects in NBMAND mode.
1431 */
1432 if (nbl_need_check(vp) && (vp->v_type != VREG))
1433 return (0);
1434
1435 /*
1436 * For s_access and s_deny, we do not need to pass in the original
1437 * values.
1438 */
1439 shr.s_access = 0;
1440 shr.s_deny = 0;
1441 shr.s_sysid = smb_ct.cc_sysid;
1442 shr.s_pid = uniq_fid;
1443 shr.s_own_len = sizeof (shr_own);
1444 shr.s_owner = (caddr_t)&shr_own;
1445 shr_own.sl_id = shr.s_sysid;
1446 shr_own.sl_pid = shr.s_pid;
1447
1448 return (VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, cr, NULL));
1449 }
1450
1451 int
1452 smb_vop_frlock(vnode_t *vp, cred_t *cr, int flag, flock64_t *bf)
1453 {
1454 int cmd = nbl_need_check(vp) ? F_SETLK_NBMAND : F_SETLK;
1455 flk_callback_t flk_cb;
1456
1457 flk_init_callback(&flk_cb, smb_lock_frlock_callback, NULL);
1458
1459 return (VOP_FRLOCK(vp, cmd, bf, flag, 0, &flk_cb, cr, &smb_ct));
1460 }
1461
1462 static callb_cpr_t *
1463 /* ARGSUSED */
1464 smb_lock_frlock_callback(flk_cb_when_t when, void *error)
1465 {
1466 return (0);
1467 }
1468
1469 /*
1470 * smb_vop_catia_init_v4_lookup
1471 * Initialize mapping between wide characters in the range from
1472 * 0x00A4 to 0x00FF and their UNIX (v4) equivalent (wide character).
1473 * Indexed by the decimal value of the wide character (164-255)
1474 * with an offset of -164.
1475 */
1476 static void
1477 smb_vop_catia_init_v4_lookup()
1478 {
1479 int i, idx, offset = SMB_CATIA_V4_LOOKUP_LOW;
1480
1481 for (i = 0; i < SMB_CATIA_V4_LOOKUP_MAX; i++)
1482 smb_catia_v4_lookup[i] = (smb_wchar_t)(i + offset);
1483
1484 for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) {
1485 idx = (int)catia_maps[i].winchar - offset;
1486 smb_catia_v4_lookup[idx] = (smb_wchar_t)catia_maps[i].unixchar;
1487 }
1488 }
1489
1490 /*
1491 * smb_vop_catia_init_v5_lookup
1492 * Initialize mapping between UNIX ASCII (v4) characters and equivalent
1493 * or translated wide characters.
1494 * Indexed by the decimal value of the ASCII character (0-127).
1495 */
1496 static void
1497 smb_vop_catia_init_v5_lookup()
1498 {
1499 int i, idx;
1500
1501 for (i = 0; i < SMB_CATIA_V5_LOOKUP_MAX; i++)
1502 smb_catia_v5_lookup[i] = (smb_wchar_t)i;
1503
1504 for (i = 0; i < SMB_CATIA_NUM_MAPS; i++) {
1505 idx = (int)catia_maps[i].unixchar;
1506 smb_catia_v5_lookup[idx] = catia_maps[i].winchar;
1507 }
1508 }
1509
1510 static void
1511 smb_vop_catia_init()
1512 {
1513 smb_vop_catia_init_v4_lookup();
1514 smb_vop_catia_init_v5_lookup();
1515 }
1516
1517 /*
1518 * smb_vop_catia_v5tov4
1519 * (windows (v5) to unix (v4))
1520 *
1521 * Traverse each character in the given source filename and convert the
1522 * multibyte that is equivalent to any special Windows character listed
1523 * in the catia_maps table to the Unix ASCII character if any is
1524 * encountered in the filename. The translated name is returned in buf.
1525 *
1526 * If an error occurs the conversion terminates and name is returned,
1527 * otherwise buf is returned.
1528 */
1529 char *
1530 smb_vop_catia_v5tov4(char *name, char *buf, int buflen)
1531 {
1532 int v4_idx, numbytes, inc;
1533 int space_left = buflen - 1; /* one byte reserved for null */
1534 smb_wchar_t wc;
1535 char mbstring[MTS_MB_CHAR_MAX];
1536 char *p, *src = name, *dst = buf;
1537
1538 ASSERT(name);
1539 ASSERT(buf);
1540
1541 if (!buf || !name)
1542 return (name);
1543
1544 bzero(buf, buflen);
1545
1546 while (*src) {
1547 if ((numbytes = smb_mbtowc(&wc, src, MTS_MB_CHAR_MAX)) < 0)
1548 return (name);
1549
1550 if (wc < SMB_CATIA_V4_LOOKUP_LOW ||
1551 wc > SMB_CATIA_V4_LOOKUP_UPPER) {
1552 inc = numbytes;
1553 p = src;
1554 } else {
1555 /* Lookup required. */
1556 v4_idx = (int)wc - SMB_CATIA_V4_LOOKUP_LOW;
1557 inc = smb_wctomb(mbstring, smb_catia_v4_lookup[v4_idx]);
1558 p = mbstring;
1559 }
1560
1561 if (space_left < inc)
1562 return (name);
1563
1564 (void) strncpy(dst, p, inc);
1565 dst += inc;
1566 space_left -= inc;
1567 src += numbytes;
1568 }
1569
1570 return (buf);
1571 }
1572
1573 /*
1574 * smb_vop_catia_v4tov5
1575 * (unix (v4) to windows (v5))
1576 *
1577 * Traverse each character in the given filename 'srcbuf' and convert
1578 * the special Unix character that is listed in the catia_maps table to
1579 * the UTF-8 encoding of the corresponding Windows character if any is
1580 * encountered in the filename.
1581 *
1582 * The translated name is returned in buf.
1583 * If an error occurs the conversion terminates and the original name
1584 * is returned in buf.
1585 */
1586 void
1587 smb_vop_catia_v4tov5(char *name, char *buf, int buflen)
1588 {
1589 int v5_idx, numbytes;
1590 int space_left = buflen - 1; /* one byte reserved for null */
1591 smb_wchar_t wc;
1592 char mbstring[MTS_MB_CHAR_MAX];
1593 char *src = name, *dst = buf;
1594
1595 ASSERT(name);
1596 ASSERT(buf);
1597
1598 if (!buf || !name)
1599 return;
1600
1601 (void) bzero(buf, buflen);
1602 while (*src) {
1603 if (smb_isascii(*src)) {
1604 /* Lookup required */
1605 v5_idx = (int)*src++;
1606 numbytes = smb_wctomb(mbstring,
1607 smb_catia_v5_lookup[v5_idx]);
1608 if (space_left < numbytes)
1609 break;
1610 (void) strncpy(dst, mbstring, numbytes);
1611 } else {
1612 if ((numbytes = smb_mbtowc(&wc, src,
1613 MTS_MB_CHAR_MAX)) < 0)
1614 break;
1615 if (space_left < numbytes)
1616 break;
1617 (void) strncpy(dst, src, numbytes);
1618 src += numbytes;
1619 }
1620
1621 dst += numbytes;
1622 space_left -= numbytes;
1623 }
1624
1625 if (*src)
1626 (void) strlcpy(buf, name, buflen);
1627 }