1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * Portions of this source code were derived from Berkeley 4.3 BSD
31 * under license from the Regents of the University of California.
32 */
33
34 #include <sys/param.h>
35 #include <sys/isa_defs.h>
36 #include <sys/types.h>
37 #include <sys/sysmacros.h>
38 #include <sys/user.h>
39 #include <sys/systm.h>
40 #include <sys/errno.h>
41 #include <sys/fcntl.h>
42 #include <sys/stat.h>
43 #include <sys/vnode.h>
44 #include <sys/vfs.h>
45 #include <sys/file.h>
46 #include <sys/mode.h>
47 #include <sys/uio.h>
48 #include <sys/debug.h>
49 #include <c2/audit.h>
50
51 /*
52 * Common code for openat(). Check permissions, allocate an open
53 * file structure, and call the device open routine (if any).
54 */
55
56 static int
57 copen(int startfd, char *fname, int filemode, int createmode)
58 {
59 struct pathname pn;
60 vnode_t *vp, *sdvp;
61 file_t *fp, *startfp;
62 enum vtype type;
63 int error;
64 int fd, dupfd;
65 vnode_t *startvp;
66 proc_t *p = curproc;
67 uio_seg_t seg = UIO_USERSPACE;
68 char *open_filename = fname;
69 uint32_t auditing = AU_AUDITING();
70 char startchar;
71
72 if (filemode & (FSEARCH|FEXEC)) {
73 /*
74 * Must be one or the other and neither FREAD nor FWRITE
75 * Must not be any of FAPPEND FCREAT FTRUNC FXATTR FXATTRDIROPEN
76 * XXX: Should these just be silently ignored?
77 */
78 if ((filemode & (FREAD|FWRITE)) ||
79 (filemode & (FSEARCH|FEXEC)) == (FSEARCH|FEXEC) ||
80 (filemode & (FAPPEND|FCREAT|FTRUNC|FXATTR|FXATTRDIROPEN)))
81 return (set_errno(EINVAL));
82 }
83
84 if (startfd == AT_FDCWD) {
85 /*
86 * Regular open()
87 */
88 startvp = NULL;
89 } else {
90 /*
91 * We're here via openat()
92 */
93 if (copyin(fname, &startchar, sizeof (char)))
94 return (set_errno(EFAULT));
95
96 /*
97 * if startchar is / then startfd is ignored
98 */
99 if (startchar == '/')
100 startvp = NULL;
101 else {
102 if ((startfp = getf(startfd)) == NULL)
103 return (set_errno(EBADF));
104 startvp = startfp->f_vnode;
105 VN_HOLD(startvp);
106 releasef(startfd);
107 }
108 }
109
110 /*
111 * Handle __openattrdirat() requests
112 */
113 if (filemode & FXATTRDIROPEN) {
114 if (auditing && startvp != NULL)
115 audit_setfsat_path(1);
116 if (error = lookupnameat(fname, seg, FOLLOW,
117 NULLVPP, &vp, startvp))
118 return (set_errno(error));
119 if (startvp != NULL)
120 VN_RELE(startvp);
121
122 startvp = vp;
123 }
124
125 /*
126 * Do we need to go into extended attribute space?
127 */
128 if (filemode & FXATTR) {
129 if (startfd == AT_FDCWD) {
130 if (copyin(fname, &startchar, sizeof (char)))
131 return (set_errno(EFAULT));
132
133 /*
134 * If startchar == '/' then no extended attributes
135 * are looked up.
136 */
137 if (startchar == '/') {
138 startvp = NULL;
139 } else {
140 mutex_enter(&p->p_lock);
141 startvp = PTOU(p)->u_cdir;
142 VN_HOLD(startvp);
143 mutex_exit(&p->p_lock);
144 }
145 }
146
147 /*
148 * Make sure we have a valid extended attribute request.
149 * We must either have a real fd or AT_FDCWD and a relative
150 * pathname.
151 */
152 if (startvp == NULL) {
153 goto noxattr;
154 }
155 }
156
157 if (filemode & (FXATTR|FXATTRDIROPEN)) {
158 vattr_t vattr;
159
160 if (error = pn_get(fname, UIO_USERSPACE, &pn)) {
161 goto out;
162 }
163
164 /*
165 * In order to access hidden attribute directory the
166 * user must be able to stat() the file
167 */
168 vattr.va_mask = AT_ALL;
169 if (error = VOP_GETATTR(startvp, &vattr, 0, CRED(), NULL)) {
170 pn_free(&pn);
171 goto out;
172 }
173
174 if ((startvp->v_vfsp->vfs_flag & VFS_XATTR) != 0 ||
175 vfs_has_feature(startvp->v_vfsp, VFSFT_SYSATTR_VIEWS)) {
176 error = VOP_LOOKUP(startvp, "", &sdvp, &pn,
177 (filemode & FXATTRDIROPEN) ? LOOKUP_XATTR :
178 LOOKUP_XATTR|CREATE_XATTR_DIR, rootvp, CRED(),
179 NULL, NULL, NULL);
180 } else {
181 error = EINVAL;
182 }
183
184 /*
185 * For __openattrdirat() use "." as filename to open
186 * as part of vn_openat()
187 */
188 if (error == 0 && (filemode & FXATTRDIROPEN)) {
189 open_filename = ".";
190 seg = UIO_SYSSPACE;
191 }
192
193 pn_free(&pn);
194 if (error != 0)
195 goto out;
196
197 VN_RELE(startvp);
198 startvp = sdvp;
199 }
200
201 noxattr:
202 if ((filemode & (FREAD|FWRITE|FSEARCH|FEXEC|FXATTRDIROPEN)) != 0) {
203 if ((filemode & (FNONBLOCK|FNDELAY)) == (FNONBLOCK|FNDELAY))
204 filemode &= ~FNDELAY;
205 error = falloc((vnode_t *)NULL, filemode, &fp, &fd);
206 if (error == 0) {
207 if (auditing && startvp != NULL)
208 audit_setfsat_path(1);
209 /*
210 * Last arg is a don't-care term if
211 * !(filemode & FCREAT).
212 */
213 error = vn_openat(open_filename, seg, filemode,
214 (int)(createmode & MODEMASK),
215 &vp, CRCREAT, PTOU(curproc)->u_cmask,
216 startvp, fd);
217
218 if (startvp != NULL)
219 VN_RELE(startvp);
220 if (error == 0) {
221 if ((vp->v_flag & VDUP) == 0) {
222 fp->f_vnode = vp;
223 mutex_exit(&fp->f_tlock);
224 /*
225 * We must now fill in the slot
226 * falloc reserved.
227 */
228 setf(fd, fp);
229 return (fd);
230 } else {
231 /*
232 * Special handling for /dev/fd.
233 * Give up the file pointer
234 * and dup the indicated file descriptor
235 * (in v_rdev). This is ugly, but I've
236 * seen worse.
237 */
238 unfalloc(fp);
239 dupfd = getminor(vp->v_rdev);
240 type = vp->v_type;
241 mutex_enter(&vp->v_lock);
242 vp->v_flag &= ~VDUP;
243 mutex_exit(&vp->v_lock);
244 VN_RELE(vp);
245 if (type != VCHR)
246 return (set_errno(EINVAL));
247 if ((fp = getf(dupfd)) == NULL) {
248 setf(fd, NULL);
249 return (set_errno(EBADF));
250 }
251 mutex_enter(&fp->f_tlock);
252 fp->f_count++;
253 mutex_exit(&fp->f_tlock);
254 setf(fd, fp);
255 releasef(dupfd);
256 }
257 return (fd);
258 } else {
259 setf(fd, NULL);
260 unfalloc(fp);
261 return (set_errno(error));
262 }
263 }
264 } else {
265 error = EINVAL;
266 }
267 out:
268 if (startvp != NULL)
269 VN_RELE(startvp);
270 return (set_errno(error));
271 }
272
273 #define OPENMODE32(fmode) (((fmode) & (FSEARCH | FEXEC))? \
274 (fmode) : (fmode) - FOPEN)
275 #define OPENMODE64(fmode) (OPENMODE32(fmode) | FOFFMAX)
276 #ifdef _LP64
277 #define OPENMODE(fmode) OPENMODE64(fmode)
278 #else
279 #define OPENMODE(fmode) OPENMODE32(fmode)
280 #endif
281
282 /*
283 * Open a file.
284 */
285 int
286 openat(int fd, char *path, int fmode, int cmode)
287 {
288 return (copen(fd, path, OPENMODE(fmode), cmode));
289 }
290
291 int
292 open(char *path, int fmode, int cmode)
293 {
294 return (openat(AT_FDCWD, path, fmode, cmode));
295 }
296
297 #if defined(_ILP32) || defined(_SYSCALL32_IMPL)
298 /*
299 * Open for large files in 32-bit environment. Sets the FOFFMAX flag.
300 */
301 int
302 openat64(int fd, char *path, int fmode, int cmode)
303 {
304 return (copen(fd, path, OPENMODE64(fmode), cmode));
305 }
306
307 int
308 open64(char *path, int fmode, int cmode)
309 {
310 return (openat64(AT_FDCWD, path, fmode, cmode));
311 }
312
313 #endif /* _ILP32 || _SYSCALL32_IMPL */
314
315 #ifdef _SYSCALL32_IMPL
316 /*
317 * Open for 32-bit compatibility on 64-bit kernel
318 */
319 int
320 openat32(int fd, char *path, int fmode, int cmode)
321 {
322 return (copen(fd, path, OPENMODE32(fmode), cmode));
323 }
324
325 int
326 open32(char *path, int fmode, int cmode)
327 {
328 return (openat32(AT_FDCWD, path, fmode, cmode));
329 }
330
331 #endif /* _SYSCALL32_IMPL */