1/*
2 * Copyright (c) 1982, 1986, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)sys_socket.c 8.1 (Berkeley) 6/10/93
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD: head/sys/kern/sys_socket.c 130480 2004-06-14 18:16:22Z rwatson $");
34
35#include "opt_mac.h"
36
37#include <sys/param.h>
38#include <sys/systm.h>
39#include <sys/file.h>
40#include <sys/filedesc.h>
41#include <sys/mac.h>
42#include <sys/protosw.h>
43#include <sys/sigio.h>
44#include <sys/socket.h>
45#include <sys/socketvar.h>
46#include <sys/filio.h> /* XXX */
47#include <sys/sockio.h>
48#include <sys/stat.h>
49#include <sys/uio.h>
50#include <sys/ucred.h>
51
52#include <net/if.h>
53#include <net/route.h>
54
55struct fileops socketops = {
56 .fo_read = soo_read,
57 .fo_write = soo_write,
58 .fo_ioctl = soo_ioctl,
59 .fo_poll = soo_poll,
60 .fo_kqfilter = soo_kqfilter,
61 .fo_stat = soo_stat,
62 .fo_close = soo_close,
63 .fo_flags = DFLAG_PASSABLE
64};
65
66/* ARGSUSED */
67int
68soo_read(fp, uio, active_cred, flags, td)
69 struct file *fp;
70 struct uio *uio;
71 struct ucred *active_cred;
72 struct thread *td;
73 int flags;
74{
75 struct socket *so = fp->f_data;
76 int error;
77
78 NET_LOCK_GIANT();
79#ifdef MAC
80 SOCK_LOCK(so);
81 error = mac_check_socket_receive(active_cred, so);
82 SOCK_UNLOCK(so);
83 if (error) {
84 NET_UNLOCK_GIANT();
85 return (error);
86 }
87#endif
88 error = so->so_proto->pr_usrreqs->pru_soreceive(so, 0, uio, 0, 0, 0);
89 NET_UNLOCK_GIANT();
90 return (error);
91}
92
93/* ARGSUSED */
94int
95soo_write(fp, uio, active_cred, flags, td)
96 struct file *fp;
97 struct uio *uio;
98 struct ucred *active_cred;
99 struct thread *td;
100 int flags;
101{
102 struct socket *so = fp->f_data;
103 int error;
104
105 NET_LOCK_GIANT();
106#ifdef MAC
107 SOCK_LOCK(so);
108 error = mac_check_socket_send(active_cred, so);
109 SOCK_UNLOCK(so);
110 if (error) {
111 NET_UNLOCK_GIANT();
112 return (error);
113 }
114#endif
115 error = so->so_proto->pr_usrreqs->pru_sosend(so, 0, uio, 0, 0, 0,
116 uio->uio_td);
117 NET_UNLOCK_GIANT();
118 return (error);
119}
120
121int
122soo_ioctl(fp, cmd, data, active_cred, td)
123 struct file *fp;
124 u_long cmd;
125 void *data;
126 struct ucred *active_cred;
127 struct thread *td;
128{
129 register struct socket *so = fp->f_data;
130
131 switch (cmd) {
132
133 case FIONBIO:
134 if (*(int *)data)
135 so->so_state |= SS_NBIO;
136 else
137 so->so_state &= ~SS_NBIO;
138 return (0);
139
140 case FIOASYNC:
141 if (*(int *)data) {
142 so->so_state |= SS_ASYNC;
143 so->so_rcv.sb_flags |= SB_ASYNC;
144 so->so_snd.sb_flags |= SB_ASYNC;
145 } else {
146 so->so_state &= ~SS_ASYNC;
147 so->so_rcv.sb_flags &= ~SB_ASYNC;
148 so->so_snd.sb_flags &= ~SB_ASYNC;
149 }
150 return (0);
151
152 case FIONREAD:
153 *(int *)data = so->so_rcv.sb_cc;
154 return (0);
155
156 case FIOSETOWN:
157 return (fsetown(*(int *)data, &so->so_sigio));
158
159 case FIOGETOWN:
160 *(int *)data = fgetown(&so->so_sigio);
161 return (0);
162
163 case SIOCSPGRP:
164 return (fsetown(-(*(int *)data), &so->so_sigio));
165
166 case SIOCGPGRP:
167 *(int *)data = -fgetown(&so->so_sigio);
168 return (0);
169
170 case SIOCATMARK:
171 *(int *)data = (so->so_rcv.sb_state & SBS_RCVATMARK) != 0;
172 return (0);
173 }
174 /*
175 * Interface/routing/protocol specific ioctls:
176 * interface and routing ioctls should have a
177 * different entry since a socket's unnecessary
178 */
179 if (IOCGROUP(cmd) == 'i')
180 return (ifioctl(so, cmd, data, td));
181 if (IOCGROUP(cmd) == 'r')
182 return (rtioctl(cmd, data));
183 return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, 0, td));
184}
185
186int
187soo_poll(fp, events, active_cred, td)
188 struct file *fp;
189 int events;
190 struct ucred *active_cred;
191 struct thread *td;
192{
193 struct socket *so = fp->f_data;
194 return so->so_proto->pr_usrreqs->pru_sopoll(so, events,
195 fp->f_cred, td);
196}
197
198int
199soo_stat(fp, ub, active_cred, td)
200 struct file *fp;
201 struct stat *ub;
202 struct ucred *active_cred;
203 struct thread *td;
204{
205 struct socket *so = fp->f_data;
206
207 bzero((caddr_t)ub, sizeof (*ub));
208 ub->st_mode = S_IFSOCK;
209 /*
210 * If SBS_CANTRCVMORE is set, but there's still data left in the
211 * receive buffer, the socket is still readable.
212 */
213 if ((so->so_rcv.sb_state & SBS_CANTRCVMORE) == 0 ||
214 so->so_rcv.sb_cc != 0)
215 ub->st_mode |= S_IRUSR | S_IRGRP | S_IROTH;
216 if ((so->so_snd.sb_state & SBS_CANTSENDMORE) == 0)
217 ub->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
218 ub->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl;
219 ub->st_uid = so->so_cred->cr_uid;
220 ub->st_gid = so->so_cred->cr_gid;
221 return ((*so->so_proto->pr_usrreqs->pru_sense)(so, ub));
222}
223
224/*
225 * API socket close on file pointer. We call soclose() to close the
226 * socket (including initiating closing protocols). soclose() will
227 * sorele() the file reference but the actual socket will not go away
228 * until the socket's ref count hits 0.
229 */
230/* ARGSUSED */
231int
232soo_close(fp, td)
233 struct file *fp;
234 struct thread *td;
235{
236 int error = 0;
237 struct socket *so;
238
239 so = fp->f_data;
240 fp->f_ops = &badfileops;
241 fp->f_data = NULL;
242
243 if (so)
244 error = soclose(so);
245 return (error);
246}