1/*
2 * Copyright (c) 1997-2013 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/*-
29 * Copyright (c) 1982, 1986, 1991, 1993
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)tty_tty.c 8.2 (Berkeley) 9/23/93
61 */
62
63/*
64 * Indirect driver for controlling tty.
65 */
66#include <sys/param.h>
67#include <sys/systm.h>
68#include <sys/conf.h>
69#include <sys/ioctl.h>
70#include <sys/proc_internal.h>
71#include <sys/tty.h>
72#include <sys/vnode_internal.h>
73#include <sys/file_internal.h>
74#include <sys/kauth.h>
75
76/* Forward declarations for cdevsw[] entry */
77/* XXX we should consider making these static */
78int cttyopen(dev_t dev, int flag, int mode, proc_t p);
79int cttyread(dev_t dev, struct uio *uio, int flag);
80int cttywrite(dev_t dev, struct uio *uio, int flag);
81int cttyioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, proc_t p);
82int cttyselect(dev_t dev, int flag, void* wql, proc_t p);
83static vnode_t cttyvp(proc_t p);
84
85int
86cttyopen(dev_t dev, int flag, __unused int mode, proc_t p)
87{
88 vnode_t ttyvp = cttyvp(p);
89 struct vfs_context context;
90 int error = 0;
91 int cttyflag, doclose = 0;
92 struct session *sessp;
93
94 if (ttyvp == NULL)
95 return (ENXIO);
96
97 context.vc_thread = current_thread();
98 context.vc_ucred = kauth_cred_proc_ref(p);
99
100 sessp = proc_session(p);
101 session_lock(sessp);
102 cttyflag = sessp->s_flags & S_CTTYREF;
103 session_unlock(sessp);
104
105 /*
106 * A little hack--this device, used by many processes,
107 * happens to do an open on another device, which can
108 * cause unhappiness if the second-level open blocks indefinitely
109 * (as could be the case if the master side has hung up). Since
110 * we know that this driver doesn't care about the serializing
111 * opens and closes, we can drop the lock. To avoid opencount leak,
112 * open the vnode only for the first time.
113 */
114 if (cttyflag == 0) {
115 devsw_unlock(dev, S_IFCHR);
116 error = VNOP_OPEN(ttyvp, flag, &context);
117 devsw_lock(dev, S_IFCHR);
118
119 if (error)
120 goto out;
121
122 /*
123 * If S_CTTYREF is set, some other thread did an open
124 * and was able to set the flag, now perform a close, else
125 * set the flag.
126 */
127 session_lock(sessp);
128 if (cttyflag == (sessp->s_flags & S_CTTYREF))
129 sessp->s_flags |= S_CTTYREF;
130 else
131 doclose = 1;
132 session_unlock(sessp);
133
134 /*
135 * We have to take a reference here to make sure a close
136 * gets called during revoke. Note that once a controlling
137 * tty gets opened by this driver, the only way close will
138 * get called is when the session leader , whose controlling
139 * tty is ttyvp, exits and vnode is revoked. We cannot
140 * redirect close from this driver because underlying controlling
141 * terminal might change and close may get redirected to a
142 * wrong vnode causing panic.
143 */
144 if (doclose) {
145 devsw_unlock(dev, S_IFCHR);
146 VNOP_CLOSE(ttyvp, flag, &context);
147 devsw_lock(dev, S_IFCHR);
148 } else {
149 error = vnode_ref(ttyvp);
150 }
151 }
152out:
153 session_rele(sessp);
154
155 vnode_put(ttyvp);
156 kauth_cred_unref(&context.vc_ucred);
157
158 return (error);
159}
160
161int
162cttyread(__unused dev_t dev, struct uio *uio, int flag)
163{
164 vnode_t ttyvp = cttyvp(current_proc());
165 struct vfs_context context;
166 int error;
167
168 if (ttyvp == NULL)
169 return (EIO);
170
171 context.vc_thread = current_thread();
172 context.vc_ucred = NOCRED;
173
174 error = VNOP_READ(ttyvp, uio, flag, &context);
175 vnode_put(ttyvp);
176
177 return (error);
178}
179
180int
181cttywrite(__unused dev_t dev, struct uio *uio, int flag)
182{
183 vnode_t ttyvp = cttyvp(current_proc());
184 struct vfs_context context;
185 int error;
186
187 if (ttyvp == NULL)
188 return (EIO);
189
190 context.vc_thread = current_thread();
191 context.vc_ucred = NOCRED;
192
193 error = VNOP_WRITE(ttyvp, uio, flag, &context);
194 vnode_put(ttyvp);
195
196 return (error);
197}
198
199int
200cttyioctl(__unused dev_t dev, u_long cmd, caddr_t addr, int flag, proc_t p)
201{
202 vnode_t ttyvp = cttyvp(current_proc());
203 struct vfs_context context;
204 struct session *sessp;
205 int error = 0;
206
207 if (ttyvp == NULL)
208 return (EIO);
209 if (cmd == TIOCSCTTY) { /* don't allow controlling tty to be set */
210 error = EINVAL; /* to controlling tty -- infinite recursion */
211 goto out;
212 }
213 if (cmd == TIOCNOTTY) {
214 sessp = proc_session(p);
215 if (!SESS_LEADER(p, sessp)) {
216 OSBitAndAtomic(~((uint32_t)P_CONTROLT), &p->p_flag);
217 if (sessp != SESSION_NULL)
218 session_rele(sessp);
219 error = 0;
220 goto out;
221 } else {
222 if (sessp != SESSION_NULL)
223 session_rele(sessp);
224 error = EINVAL;
225 goto out;
226 }
227 }
228 context.vc_thread = current_thread();
229 context.vc_ucred = NOCRED;
230
231 error = VNOP_IOCTL(ttyvp, cmd, addr, flag, &context);
232out:
233 vnode_put(ttyvp);
234 return (error);
235}
236
237int
238cttyselect(__unused dev_t dev, int flag, void* wql, __unused proc_t p)
239{
240 vnode_t ttyvp = cttyvp(current_proc());
241 struct vfs_context context;
242 int error;
243
244 context.vc_thread = current_thread();
245 context.vc_ucred = NOCRED;
246
247 if (ttyvp == NULL)
248 return (1); /* try operation to get EOF/failure */
249 error = VNOP_SELECT(ttyvp, flag, FREAD|FWRITE, wql, &context);
250 vnode_put(ttyvp);
251 return (error);
252}
253
254/* This returns vnode with ioref */
255static vnode_t
256cttyvp(proc_t p)
257{
258 vnode_t vp;
259 int vid;
260 struct session *sessp;
261
262 sessp = proc_session(p);
263
264 session_lock(sessp);
265 vp = (p->p_flag & P_CONTROLT ? sessp->s_ttyvp : NULLVP);
266 vid = sessp->s_ttyvid;
267 session_unlock(sessp);
268
269 session_rele(sessp);
270
271 if (vp != NULLVP) {
272 /* cannot get an IO reference, return NULLVP */
273 if (vnode_getwithvid(vp, vid) != 0)
274 vp = NULLVP;
275 }
276 return(vp);
277}
278
279