]>
Commit | Line | Data |
---|---|---|
1c79356b | 1 | /* |
39236c6e | 2 | * Copyright (c) 1997-2013 Apple Computer, Inc. All rights reserved. |
5d5c5d0d | 3 | * |
2d21ac55 | 4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
1c79356b | 5 | * |
2d21ac55 A |
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. | |
8f6c56a5 | 14 | * |
2d21ac55 A |
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 | |
8f6c56a5 A |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, | |
2d21ac55 A |
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. | |
8f6c56a5 | 25 | * |
2d21ac55 | 26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
1c79356b | 27 | */ |
1c79356b A |
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> | |
91447636 | 70 | #include <sys/proc_internal.h> |
1c79356b | 71 | #include <sys/tty.h> |
91447636 A |
72 | #include <sys/vnode_internal.h> |
73 | #include <sys/file_internal.h> | |
2d21ac55 | 74 | #include <sys/kauth.h> |
91447636 A |
75 | |
76 | /* Forward declarations for cdevsw[] entry */ | |
77 | /* XXX we should consider making these static */ | |
2d21ac55 | 78 | int cttyopen(dev_t dev, int flag, int mode, proc_t p); |
91447636 A |
79 | int cttyread(dev_t dev, struct uio *uio, int flag); |
80 | int cttywrite(dev_t dev, struct uio *uio, int flag); | |
2d21ac55 A |
81 | int cttyioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, proc_t p); |
82 | int cttyselect(dev_t dev, int flag, void* wql, proc_t p); | |
83 | static vnode_t cttyvp(proc_t p); | |
1c79356b | 84 | |
1c79356b | 85 | int |
6d2010ae | 86 | cttyopen(dev_t dev, int flag, __unused int mode, proc_t p) |
1c79356b | 87 | { |
39236c6e A |
88 | vnode_t ttyvp = cttyvp(p); |
89 | struct vfs_context context; | |
90 | int error = 0; | |
91 | int cttyflag, doclose = 0; | |
92 | struct session *sessp; | |
1c79356b | 93 | |
39236c6e A |
94 | if (ttyvp == NULL) |
95 | return (ENXIO); | |
316670eb | 96 | |
39236c6e A |
97 | context.vc_thread = current_thread(); |
98 | context.vc_ucred = kauth_cred_proc_ref(p); | |
316670eb | 99 | |
39236c6e A |
100 | sessp = proc_session(p); |
101 | session_lock(sessp); | |
102 | cttyflag = sessp->s_flags & S_CTTYREF; | |
103 | session_unlock(sessp); | |
316670eb | 104 | |
39236c6e A |
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); | |
316670eb | 116 | error = VNOP_OPEN(ttyvp, flag, &context); |
39236c6e A |
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 | } | |
316670eb | 151 | } |
39236c6e A |
152 | out: |
153 | session_rele(sessp); | |
316670eb | 154 | |
39236c6e A |
155 | vnode_put(ttyvp); |
156 | kauth_cred_unref(&context.vc_ucred); | |
316670eb | 157 | |
1c79356b A |
158 | return (error); |
159 | } | |
160 | ||
1c79356b | 161 | int |
91447636 | 162 | cttyread(__unused dev_t dev, struct uio *uio, int flag) |
1c79356b | 163 | { |
2d21ac55 | 164 | vnode_t ttyvp = cttyvp(current_proc()); |
91447636 | 165 | struct vfs_context context; |
1c79356b A |
166 | int error; |
167 | ||
168 | if (ttyvp == NULL) | |
169 | return (EIO); | |
91447636 | 170 | |
2d21ac55 | 171 | context.vc_thread = current_thread(); |
91447636 A |
172 | context.vc_ucred = NOCRED; |
173 | ||
174 | error = VNOP_READ(ttyvp, uio, flag, &context); | |
2d21ac55 | 175 | vnode_put(ttyvp); |
91447636 | 176 | |
1c79356b A |
177 | return (error); |
178 | } | |
179 | ||
1c79356b | 180 | int |
91447636 | 181 | cttywrite(__unused dev_t dev, struct uio *uio, int flag) |
1c79356b | 182 | { |
2d21ac55 | 183 | vnode_t ttyvp = cttyvp(current_proc()); |
91447636 | 184 | struct vfs_context context; |
1c79356b A |
185 | int error; |
186 | ||
187 | if (ttyvp == NULL) | |
188 | return (EIO); | |
91447636 | 189 | |
2d21ac55 | 190 | context.vc_thread = current_thread(); |
91447636 A |
191 | context.vc_ucred = NOCRED; |
192 | ||
193 | error = VNOP_WRITE(ttyvp, uio, flag, &context); | |
2d21ac55 | 194 | vnode_put(ttyvp); |
91447636 | 195 | |
1c79356b A |
196 | return (error); |
197 | } | |
198 | ||
1c79356b | 199 | int |
2d21ac55 | 200 | cttyioctl(__unused dev_t dev, u_long cmd, caddr_t addr, int flag, proc_t p) |
1c79356b | 201 | { |
2d21ac55 | 202 | vnode_t ttyvp = cttyvp(current_proc()); |
91447636 | 203 | struct vfs_context context; |
2d21ac55 A |
204 | struct session *sessp; |
205 | int error = 0; | |
1c79356b A |
206 | |
207 | if (ttyvp == NULL) | |
208 | return (EIO); | |
2d21ac55 A |
209 | if (cmd == TIOCSCTTY) { /* don't allow controlling tty to be set */ |
210 | error = EINVAL; /* to controlling tty -- infinite recursion */ | |
211 | goto out; | |
212 | } | |
1c79356b | 213 | if (cmd == TIOCNOTTY) { |
2d21ac55 A |
214 | sessp = proc_session(p); |
215 | if (!SESS_LEADER(p, sessp)) { | |
b0d623f7 | 216 | OSBitAndAtomic(~((uint32_t)P_CONTROLT), &p->p_flag); |
2d21ac55 A |
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 | } | |
1c79356b | 227 | } |
2d21ac55 | 228 | context.vc_thread = current_thread(); |
91447636 A |
229 | context.vc_ucred = NOCRED; |
230 | ||
2d21ac55 A |
231 | error = VNOP_IOCTL(ttyvp, cmd, addr, flag, &context); |
232 | out: | |
233 | vnode_put(ttyvp); | |
234 | return (error); | |
1c79356b A |
235 | } |
236 | ||
1c79356b | 237 | int |
2d21ac55 | 238 | cttyselect(__unused dev_t dev, int flag, void* wql, __unused proc_t p) |
1c79356b | 239 | { |
2d21ac55 | 240 | vnode_t ttyvp = cttyvp(current_proc()); |
91447636 | 241 | struct vfs_context context; |
2d21ac55 | 242 | int error; |
91447636 | 243 | |
2d21ac55 | 244 | context.vc_thread = current_thread(); |
91447636 | 245 | context.vc_ucred = NOCRED; |
1c79356b A |
246 | |
247 | if (ttyvp == NULL) | |
248 | return (1); /* try operation to get EOF/failure */ | |
2d21ac55 A |
249 | error = VNOP_SELECT(ttyvp, flag, FREAD|FWRITE, wql, &context); |
250 | vnode_put(ttyvp); | |
251 | return (error); | |
1c79356b A |
252 | } |
253 | ||
2d21ac55 A |
254 | /* This returns vnode with ioref */ |
255 | static vnode_t | |
256 | cttyvp(proc_t p) | |
1c79356b | 257 | { |
2d21ac55 A |
258 | vnode_t vp; |
259 | int vid; | |
260 | struct session *sessp; | |
1c79356b | 261 | |
2d21ac55 | 262 | sessp = proc_session(p); |
1c79356b | 263 | |
2d21ac55 A |
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 | } | |
1c79356b | 278 |