Context Navigation

uipc_syscalls.c @ 8d5fc9d

55-freebsd-126-freebsd-12

Last change on this file since 8d5fc9d was e0b4edbd, checked in by Sebastian Huber <sebastian.huber@…>, on 11/06/18 at 14:42:44

Update to FreeBSD head 2018-11-15

Git mirror commit a18b0830c4be01b39489a891b63d6023ada6358a.

Update #3472.

Property mode set to 100644

File size: 47.2 KB

Line
1	#include <machine/rtems-bsd-kernel-space.h>
2
3	/*-
4	* SPDX-License-Identifier: BSD-3-Clause
5	*
6	* Copyright (c) 1982, 1986, 1989, 1990, 1993
7	* The Regents of the University of California. All rights reserved.
8	*
9	* Redistribution and use in source and binary forms, with or without
10	* modification, are permitted provided that the following conditions
11	* are met:
12	* 1. Redistributions of source code must retain the above copyright
13	* notice, this list of conditions and the following disclaimer.
14	* 2. Redistributions in binary form must reproduce the above copyright
15	* notice, this list of conditions and the following disclaimer in the
16	* documentation and/or other materials provided with the distribution.
17	* 3. Neither the name of the University nor the names of its contributors
18	* may be used to endorse or promote products derived from this software
19	* without specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31	* SUCH DAMAGE.
32	*
33	* @(#)uipc_syscalls.c 8.4 (Berkeley) 2/21/94
34	*/
35
36	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");
38
39	#include <rtems/bsd/local/opt_capsicum.h>
40	#include <rtems/bsd/local/opt_inet.h>
41	#include <rtems/bsd/local/opt_inet6.h>
42	#include <rtems/bsd/local/opt_ktrace.h>
43
44	#include <sys/param.h>
45	#include <sys/systm.h>
46	#include <sys/capsicum.h>
47	#include <sys/kernel.h>
48	#include <sys/lock.h>
49	#include <sys/mutex.h>
50	#include <sys/sysproto.h>
51	#include <sys/malloc.h>
52	#include <sys/filedesc.h>
53	#include <sys/proc.h>
54	#include <sys/filio.h>
55	#include <sys/jail.h>
56	#include <sys/mbuf.h>
57	#include <sys/protosw.h>
58	#include <sys/rwlock.h>
59	#include <sys/socket.h>
60	#include <sys/socketvar.h>
61	#include <sys/syscallsubr.h>
62	#include <sys/uio.h>
63	#include <sys/un.h>
64	#include <sys/unpcb.h>
65	#ifdef KTRACE
66	#include <sys/ktrace.h>
67	#endif
68	#ifdef COMPAT_FREEBSD32
69	#include <compat/freebsd32/freebsd32_util.h>
70	#endif
71
72	#include <net/vnet.h>
73
74	#include <security/audit/audit.h>
75	#include <security/mac/mac_framework.h>
76
77	static int sendit(struct thread td, int s, struct msghdr mp, int flags);
78	static int recvit(struct thread td, int s, struct msghdr mp, void *namelenp);
79
80	#ifndef __rtems__
81	static int accept1(struct thread td, int s, struct sockaddr uname,
82	socklen_t *anamelen, int flags);
83	static int getsockname1(struct thread td, struct getsockname_args uap,
84	int compat);
85	static int getpeername1(struct thread td, struct getpeername_args uap,
86	int compat);
87	#else /* __rtems__ */
88	struct getsockaddr_sockaddr {
89	struct sockaddr header;
90	char data[SOCK_MAXADDRLEN - sizeof(struct sockaddr)];
91	} __aligned(sizeof(long));
92
93	static int getsockaddr(struct sockaddr *, const struct sockaddr , size_t);
94	static int kern_getsockname(struct thread , int, struct sockaddr *,
95	socklen_t *);
96	static int kern_listen(struct thread *, int, int);
97	static int kern_setsockopt(struct thread , int, int, int, const void ,
98	enum uio_seg, socklen_t);
99	static int kern_shutdown(struct thread *, int, int);
100	static int kern_socket(struct thread *, int, int, int);
101	static int kern_socketpair(struct thread , int, int, int, int );
102	#endif /* __rtems__ */
103	static int sockargs(struct mbuf *, char , socklen_t, int);
104
105	#ifndef __rtems__
106	/*
107	* Convert a user file descriptor to a kernel file entry and check if required
108	* capability rights are present.
109	* If required copy of current set of capability rights is returned.
110	* A reference on the file entry is held upon returning.
111	*/
112	int
113	getsock_cap(struct thread td, int fd, cap_rights_t rightsp,
114	struct file *fpp, u_int fflagp, struct filecaps *havecapsp)
115	{
116	struct file *fp;
117	int error;
118
119	error = fget_cap(td, fd, rightsp, &fp, havecapsp);
120	if (error != 0)
121	return (error);
122	if (fp->f_type != DTYPE_SOCKET) {
123	fdrop(fp, td);
124	if (havecapsp != NULL)
125	filecaps_free(havecapsp);
126	return (ENOTSOCK);
127	}
128	if (fflagp != NULL)
129	*fflagp = fp->f_flag;
130	*fpp = fp;
131	return (0);
132	}
133	#else /* __rtems__ */
134	static int
135	rtems_bsd_getsock(int fd, struct file *fpp, u_int fflagp)
136	{
137	struct file *fp;
138	int error;
139
140	if ((uint32_t) fd < rtems_libio_number_iops) {
141	unsigned int flags;
142
143	fp = rtems_bsd_fd_to_fp(fd);
144	flags = rtems_libio_iop_hold(&fp->f_io);
145	if ((flags & LIBIO_FLAGS_OPEN) == 0) {
146	rtems_libio_iop_drop(&fp->f_io);
147	fp = NULL;
148	error = EBADF;
149	} else if (fp->f_io.pathinfo.handlers != &socketops) {
150	rtems_libio_iop_drop(&fp->f_io);
151	fp = NULL;
152	error = ENOTSOCK;
153	} else {
154	if (fflagp != NULL) {
155	*fflagp = rtems_bsd_libio_flags_to_fflag(
156	fp->f_io.flags);
157	}
158
159	error = 0;
160	}
161	} else {
162	fp = NULL;
163	error = EBADF;
164	}
165
166	*fpp = fp;
167
168	return (error);
169	}
170
171	#define getsock_cap(td, fd, rights, fpp, fflagp, havecapsp) rtems_bsd_getsock(fd, fpp, fflagp)
172	#endif /* __rtems__ */
173
174	/*
175	* System call interface to the socket abstraction.
176	*/
177	#if defined(COMPAT_43)
178	#define COMPAT_OLDSOCK
179	#endif
180
181	#ifdef __rtems__
182	static
183	#endif /* __rtems__ */
184	int
185	sys_socket(struct thread td, struct socket_args uap)
186	{
187
188	return (kern_socket(td, uap->domain, uap->type, uap->protocol));
189	}
190
191	int
192	kern_socket(struct thread *td, int domain, int type, int protocol)
193	{
194	struct socket *so;
195	struct file *fp;
196	int fd, error, oflag, fflag;
197
198	AUDIT_ARG_SOCKET(domain, type, protocol);
199
200	oflag = 0;
201	fflag = 0;
202	if ((type & SOCK_CLOEXEC) != 0) {
203	type &= ~SOCK_CLOEXEC;
204	oflag \|= O_CLOEXEC;
205	}
206	if ((type & SOCK_NONBLOCK) != 0) {
207	type &= ~SOCK_NONBLOCK;
208	fflag \|= FNONBLOCK;
209	}
210
211	#ifdef MAC
212	error = mac_socket_check_create(td->td_ucred, domain, type, protocol);
213	if (error != 0)
214	return (error);
215	#endif
216	error = falloc(td, &fp, &fd, oflag);
217	if (error != 0)
218	return (error);
219	/* An extra reference on `fp' has been held for us by falloc(). */
220	error = socreate(domain, &so, type, protocol, td->td_ucred, td);
221	if (error != 0) {
222	fdclose(td, fp, fd);
223	} else {
224	finit(fp, FREAD \| FWRITE \| fflag, DTYPE_SOCKET, so, &socketops);
225	if ((fflag & FNONBLOCK) != 0)
226	(void) fo_ioctl(fp, FIONBIO, &fflag, td->td_ucred, td);
227	td->td_retval[0] = fd;
228	}
229	#ifndef __rtems__
230	fdrop(fp, td);
231	#endif /* __rtems__ */
232	return (error);
233	}
234	#ifdef __rtems__
235	int
236	socket(int domain, int type, int protocol)
237	{
238	struct thread *td = rtems_bsd_get_curthread_or_null();
239	struct socket_args ua = {
240	.domain = domain,
241	.type = type,
242	.protocol = protocol
243	};
244	int error;
245
246	if (td != NULL) {
247	error = sys_socket(td, &ua);
248	} else {
249	error = ENOMEM;
250	}
251
252	if (error == 0) {
253	return td->td_retval[0];
254	} else {
255	rtems_set_errno_and_return_minus_one(error);
256	}
257	}
258	#endif /* __rtems__ */
259
260	#ifdef __rtems__
261	static int kern_bindat(struct thread *td, int dirfd, int fd,
262	struct sockaddr *sa);
263
264	static
265	#endif /* __rtems__ */
266	int
267	sys_bind(struct thread td, struct bind_args uap)
268	{
269	struct sockaddr *sa;
270	int error;
271	#ifdef __rtems__
272	struct getsockaddr_sockaddr gsa;
273	sa = &gsa.header;
274	#endif /* __rtems__ */
275
276	error = getsockaddr(&sa, uap->name, uap->namelen);
277	if (error == 0) {
278	error = kern_bindat(td, AT_FDCWD, uap->s, sa);
279	#ifndef __rtems__
280	free(sa, M_SONAME);
281	#endif /* __rtems__ */
282	}
283	return (error);
284	}
285	#ifdef __rtems__
286	int
287	bind(int socket, const struct sockaddr *address, socklen_t address_len)
288	{
289	struct thread *td = rtems_bsd_get_curthread_or_null();
290	struct bind_args ua = {
291	.s = socket,
292	.name = address,
293	.namelen = address_len
294	};
295	int error;
296
297	if (td != NULL) {
298	error = sys_bind(td, &ua);
299	} else {
300	error = ENOMEM;
301	}
302
303	return rtems_bsd_error_to_status_and_errno(error);
304	}
305	#endif /* __rtems__ */
306
307	int
308	kern_bindat(struct thread td, int dirfd, int fd, struct sockaddr sa)
309	{
310	struct socket *so;
311	struct file *fp;
312	int error;
313
314	#ifdef CAPABILITY_MODE
315	if (IN_CAPABILITY_MODE(td) && (dirfd == AT_FDCWD))
316	return (ECAPMODE);
317	#endif
318
319	AUDIT_ARG_FD(fd);
320	AUDIT_ARG_SOCKADDR(td, dirfd, sa);
321	error = getsock_cap(td, fd, &cap_bind_rights,
322	&fp, NULL, NULL);
323	if (error != 0)
324	return (error);
325	so = fp->f_data;
326	#ifdef KTRACE
327	if (KTRPOINT(td, KTR_STRUCT))
328	ktrsockaddr(sa);
329	#endif
330	#ifdef MAC
331	error = mac_socket_check_bind(td->td_ucred, so, sa);
332	if (error == 0) {
333	#endif
334	if (dirfd == AT_FDCWD)
335	error = sobind(so, sa, td);
336	else
337	error = sobindat(dirfd, so, sa, td);
338	#ifdef MAC
339	}
340	#endif
341	fdrop(fp, td);
342	return (error);
343	}
344
345	#ifndef __rtems__
346	static
347	int
348	sys_bindat(struct thread td, struct bindat_args uap)
349	{
350	struct sockaddr *sa;
351	int error;
352	#ifdef __rtems__
353	struct getsockaddr_sockaddr gsa;
354	sa = &gsa.header;
355	#endif /* __rtems__ */
356
357	error = getsockaddr(&sa, uap->name, uap->namelen);
358	if (error == 0) {
359	error = kern_bindat(td, uap->fd, uap->s, sa);
360	#ifndef __rtems__
361	free(sa, M_SONAME);
362	#endif /* __rtems__ */
363	}
364	return (error);
365	}
366	#endif /* __rtems__ */
367
368	#ifdef __rtems__
369	static
370	#endif /* __rtems__ */
371	int
372	sys_listen(struct thread td, struct listen_args uap)
373	{
374
375	return (kern_listen(td, uap->s, uap->backlog));
376	}
377
378	int
379	kern_listen(struct thread *td, int s, int backlog)
380	{
381	struct socket *so;
382	struct file *fp;
383	int error;
384
385	AUDIT_ARG_FD(s);
386	error = getsock_cap(td, s, &cap_listen_rights,
387	&fp, NULL, NULL);
388	if (error == 0) {
389	so = fp->f_data;
390	#ifdef MAC
391	error = mac_socket_check_listen(td->td_ucred, so);
392	if (error == 0)
393	#endif
394	error = solisten(so, backlog, td);
395	fdrop(fp, td);
396	}
397	return (error);
398	}
399	#ifdef __rtems__
400	int
401	listen(int socket, int backlog)
402	{
403	struct thread *td = rtems_bsd_get_curthread_or_null();
404	struct listen_args ua = {
405	.s = socket,
406	.backlog = backlog
407	};
408	int error;
409
410	if (td != NULL) {
411	error = sys_listen(td, &ua);
412	} else {
413	error = ENOMEM;
414	}
415
416	return rtems_bsd_error_to_status_and_errno(error);
417	}
418	#endif /* __rtems__ */
419
420	#ifdef __rtems__
421	static int kern_accept4(struct thread td, int s, struct sockaddr *name,
422	socklen_t namelen, int flags, struct file *fp);
423	#endif /* __rtems__ */
424	/*
425	* accept1()
426	*/
427	static int
428	accept1(td, s, uname, anamelen, flags)
429	struct thread *td;
430	int s;
431	struct sockaddr *uname;
432	socklen_t *anamelen;
433	int flags;
434	{
435	struct sockaddr *name;
436	socklen_t namelen;
437	struct file *fp;
438	int error;
439
440	if (uname == NULL)
441	return (kern_accept4(td, s, NULL, NULL, flags, NULL));
442
443	error = copyin(anamelen, &namelen, sizeof (namelen));
444	if (error != 0)
445	return (error);
446
447	error = kern_accept4(td, s, &name, &namelen, flags, &fp);
448
449	if (error != 0)
450	return (error);
451
452	if (error == 0 && uname != NULL) {
453	#ifdef COMPAT_OLDSOCK
454	if (flags & ACCEPT4_COMPAT)
455	((struct osockaddr *)name)->sa_family =
456	name->sa_family;
457	#endif
458	error = copyout(name, uname, namelen);
459	}
460	if (error == 0)
461	error = copyout(&namelen, anamelen,
462	sizeof(namelen));
463	if (error != 0)
464	fdclose(td, fp, td->td_retval[0]);
465	#ifndef __rtems__
466	fdrop(fp, td);
467	#endif /* __rtems__ */
468	free(name, M_SONAME);
469	return (error);
470	}
471	#ifdef __rtems__
472	int
473	accept(int socket, struct sockaddr *__restrict address,
474	socklen_t *__restrict address_len)
475	{
476	struct thread *td = rtems_bsd_get_curthread_or_null();
477	int error;
478
479	if (td != NULL) {
480	error = accept1(td, socket, address, address_len,
481	ACCEPT4_INHERIT);
482	} else {
483	error = ENOMEM;
484	}
485
486	if (error == 0) {
487	return td->td_retval[0];
488	} else {
489	rtems_set_errno_and_return_minus_one(error);
490	}
491	}
492	#endif /* __rtems__ */
493
494	#ifndef __rtems__
495	int
496	kern_accept(struct thread td, int s, struct sockaddr *name,
497	socklen_t namelen, struct file *fp)
498	{
499	return (kern_accept4(td, s, name, namelen, ACCEPT4_INHERIT, fp));
500	}
501	#endif /* __rtems__ */
502
503	int
504	kern_accept4(struct thread td, int s, struct sockaddr *name,
505	socklen_t namelen, int flags, struct file *fp)
506	{
507	struct file headfp, nfp = NULL;
508	struct sockaddr *sa = NULL;
509	struct socket head, so;
510	struct filecaps fcaps;
511	u_int fflag;
512	pid_t pgid;
513	int error, fd, tmp;
514
515	if (name != NULL)
516	*name = NULL;
517
518	AUDIT_ARG_FD(s);
519	error = getsock_cap(td, s, &cap_accept_rights,
520	&headfp, &fflag, &fcaps);
521	if (error != 0)
522	return (error);
523	head = headfp->f_data;
524	if ((head->so_options & SO_ACCEPTCONN) == 0) {
525	error = EINVAL;
526	goto done;
527	}
528	#ifdef MAC
529	error = mac_socket_check_accept(td->td_ucred, head);
530	if (error != 0)
531	goto done;
532	#endif
533	error = falloc_caps(td, &nfp, &fd,
534	(flags & SOCK_CLOEXEC) ? O_CLOEXEC : 0, &fcaps);
535	if (error != 0)
536	goto done;
537	SOCK_LOCK(head);
538	if (!SOLISTENING(head)) {
539	SOCK_UNLOCK(head);
540	error = EINVAL;
541	goto noconnection;
542	}
543
544	error = solisten_dequeue(head, &so, flags);
545	if (error != 0)
546	goto noconnection;
547
548	/* An extra reference on `nfp' has been held for us by falloc(). */
549	td->td_retval[0] = fd;
550
551	/* Connection has been removed from the listen queue. */
552	KNOTE_UNLOCKED(&head->so_rdsel.si_note, 0);
553
554	if (flags & ACCEPT4_INHERIT) {
555	pgid = fgetown(&head->so_sigio);
556	if (pgid != 0)
557	fsetown(pgid, &so->so_sigio);
558	} else {
559	fflag &= ~(FNONBLOCK \| FASYNC);
560	if (flags & SOCK_NONBLOCK)
561	fflag \|= FNONBLOCK;
562	}
563
564	finit(nfp, fflag, DTYPE_SOCKET, so, &socketops);
565	/* Sync socket nonblocking/async state with file flags */
566	tmp = fflag & FNONBLOCK;
567	(void) fo_ioctl(nfp, FIONBIO, &tmp, td->td_ucred, td);
568	tmp = fflag & FASYNC;
569	(void) fo_ioctl(nfp, FIOASYNC, &tmp, td->td_ucred, td);
570	error = soaccept(so, &sa);
571	if (error != 0)
572	goto noconnection;
573	if (sa == NULL) {
574	if (name)
575	*namelen = 0;
576	goto done;
577	}
578	AUDIT_ARG_SOCKADDR(td, AT_FDCWD, sa);
579	if (name) {
580	/* check sa_len before it is destroyed */
581	if (*namelen > sa->sa_len)
582	*namelen = sa->sa_len;
583	#ifdef KTRACE
584	if (KTRPOINT(td, KTR_STRUCT))
585	ktrsockaddr(sa);
586	#endif
587	*name = sa;
588	sa = NULL;
589	}
590	noconnection:
591	free(sa, M_SONAME);
592
593	/*
594	* close the new descriptor, assuming someone hasn't ripped it
595	* out from under us.
596	*/
597	if (error != 0)
598	fdclose(td, nfp, fd);
599
600	/*
601	* Release explicitly held references before returning. We return
602	* a reference on nfp to the caller on success if they request it.
603	*/
604	done:
605	if (nfp == NULL)
606	filecaps_free(&fcaps);
607	if (fp != NULL) {
608	if (error == 0) {
609	*fp = nfp;
610	nfp = NULL;
611	} else
612	*fp = NULL;
613	}
614	#ifndef __rtems__
615	if (nfp != NULL)
616	fdrop(nfp, td);
617	#endif /* __rtems__ */
618	fdrop(headfp, td);
619	return (error);
620	}
621
622	#ifndef __rtems__
623	int
624	sys_accept(td, uap)
625	struct thread *td;
626	struct accept_args *uap;
627	{
628
629	return (accept1(td, uap->s, uap->name, uap->anamelen, ACCEPT4_INHERIT));
630	}
631
632	int
633	sys_accept4(td, uap)
634	struct thread *td;
635	struct accept4_args *uap;
636	{
637
638	if (uap->flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))
639	return (EINVAL);
640
641	return (accept1(td, uap->s, uap->name, uap->anamelen, uap->flags));
642	}
643
644	#ifdef COMPAT_OLDSOCK
645	int
646	oaccept(td, uap)
647	struct thread *td;
648	struct accept_args *uap;
649	{
650
651	return (accept1(td, uap->s, uap->name, uap->anamelen,
652	ACCEPT4_INHERIT \| ACCEPT4_COMPAT));
653	}
654	#endif /* COMPAT_OLDSOCK */
655	#endif /* __rtems__ */
656
657	#ifdef __rtems__
658	static int kern_connectat(struct thread *td, int dirfd, int fd,
659	struct sockaddr *sa);
660
661	static
662	#endif /* __rtems__ */
663	int
664	sys_connect(struct thread td, struct connect_args uap)
665	{
666	struct sockaddr *sa;
667	int error;
668	#ifdef __rtems__
669	struct getsockaddr_sockaddr gsa;
670	sa = &gsa.header;
671	#endif /* __rtems__ */
672
673	error = getsockaddr(&sa, uap->name, uap->namelen);
674	if (error == 0) {
675	error = kern_connectat(td, AT_FDCWD, uap->s, sa);
676	#ifndef __rtems__
677	free(sa, M_SONAME);
678	#endif /* __rtems__ */
679	}
680	return (error);
681	}
682	#ifdef __rtems__
683	int
684	connect(int socket, const struct sockaddr *address, socklen_t address_len)
685	{
686	struct thread *td = rtems_bsd_get_curthread_or_null();
687	struct connect_args ua = {
688	.s = socket,
689	.name = address,
690	.namelen = address_len
691	};
692	int error;
693
694	if (td != NULL) {
695	error = sys_connect(td, &ua);
696	} else {
697	error = ENOMEM;
698	}
699
700	return rtems_bsd_error_to_status_and_errno(error);
701	}
702	#endif /* __rtems__ */
703
704	int
705	kern_connectat(struct thread td, int dirfd, int fd, struct sockaddr sa)
706	{
707	struct socket *so;
708	struct file *fp;
709	int error, interrupted = 0;
710
711	#ifdef CAPABILITY_MODE
712	if (IN_CAPABILITY_MODE(td) && (dirfd == AT_FDCWD))
713	return (ECAPMODE);
714	#endif
715
716	AUDIT_ARG_FD(fd);
717	AUDIT_ARG_SOCKADDR(td, dirfd, sa);
718	error = getsock_cap(td, fd, &cap_connect_rights,
719	&fp, NULL, NULL);
720	if (error != 0)
721	return (error);
722	so = fp->f_data;
723	if (so->so_state & SS_ISCONNECTING) {
724	error = EALREADY;
725	goto done1;
726	}
727	#ifdef KTRACE
728	if (KTRPOINT(td, KTR_STRUCT))
729	ktrsockaddr(sa);
730	#endif
731	#ifdef MAC
732	error = mac_socket_check_connect(td->td_ucred, so, sa);
733	if (error != 0)
734	goto bad;
735	#endif
736	if (dirfd == AT_FDCWD)
737	error = soconnect(so, sa, td);
738	else
739	error = soconnectat(dirfd, so, sa, td);
740	if (error != 0)
741	goto bad;
742	if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
743	error = EINPROGRESS;
744	goto done1;
745	}
746	SOCK_LOCK(so);
747	while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
748	error = msleep(&so->so_timeo, &so->so_lock, PSOCK \| PCATCH,
749	"connec", 0);
750	if (error != 0) {
751	if (error == EINTR \|\| error == ERESTART)
752	interrupted = 1;
753	break;
754	}
755	}
756	if (error == 0) {
757	error = so->so_error;
758	so->so_error = 0;
759	}
760	SOCK_UNLOCK(so);
761	bad:
762	if (!interrupted)
763	so->so_state &= ~SS_ISCONNECTING;
764	if (error == ERESTART)
765	error = EINTR;
766	done1:
767	fdrop(fp, td);
768	return (error);
769	}
770
771	#ifndef __rtems__
772	int
773	sys_connectat(struct thread td, struct connectat_args uap)
774	{
775	struct sockaddr *sa;
776	int error;
777	#ifdef __rtems__
778	struct getsockaddr_sockaddr gsa;
779	sa = &gsa.header;
780	#endif /* __rtems__ */
781
782	error = getsockaddr(&sa, uap->name, uap->namelen);
783	if (error == 0) {
784	error = kern_connectat(td, uap->fd, uap->s, sa);
785	#ifndef __rtems__
786	free(sa, M_SONAME);
787	#endif /* __rtems__ */
788	}
789	return (error);
790	}
791	#endif /* __rtems__ */
792
793	int
794	kern_socketpair(struct thread *td, int domain, int type, int protocol,
795	int *rsv)
796	{
797	struct file fp1, fp2;
798	struct socket so1, so2;
799	int fd, error, oflag, fflag;
800
801	AUDIT_ARG_SOCKET(domain, type, protocol);
802
803	oflag = 0;
804	fflag = 0;
805	if ((type & SOCK_CLOEXEC) != 0) {
806	type &= ~SOCK_CLOEXEC;
807	oflag \|= O_CLOEXEC;
808	}
809	if ((type & SOCK_NONBLOCK) != 0) {
810	type &= ~SOCK_NONBLOCK;
811	fflag \|= FNONBLOCK;
812	}
813	#ifdef MAC
814	/* We might want to have a separate check for socket pairs. */
815	error = mac_socket_check_create(td->td_ucred, domain, type,
816	protocol);
817	if (error != 0)
818	return (error);
819	#endif
820	error = socreate(domain, &so1, type, protocol, td->td_ucred, td);
821	if (error != 0)
822	return (error);
823	error = socreate(domain, &so2, type, protocol, td->td_ucred, td);
824	if (error != 0)
825	goto free1;
826	/* On success extra reference to `fp1' and 'fp2' is set by falloc. */
827	error = falloc(td, &fp1, &fd, oflag);
828	if (error != 0)
829	goto free2;
830	rsv[0] = fd;
831	fp1->f_data = so1; /* so1 already has ref count */
832	error = falloc(td, &fp2, &fd, oflag);
833	if (error != 0)
834	goto free3;
835	fp2->f_data = so2; /* so2 already has ref count */
836	rsv[1] = fd;
837	error = soconnect2(so1, so2);
838	if (error != 0)
839	goto free4;
840	if (type == SOCK_DGRAM) {
841	/*
842	* Datagram socket connection is asymmetric.
843	*/
844	error = soconnect2(so2, so1);
845	if (error != 0)
846	goto free4;
847	} else if (so1->so_proto->pr_flags & PR_CONNREQUIRED) {
848	struct unpcb unp, unp2;
849	unp = sotounpcb(so1);
850	unp2 = sotounpcb(so2);
851	/*
852	* No need to lock the unps, because the sockets are brand-new.
853	* No other threads can be using them yet
854	*/
855	unp_copy_peercred(td, unp, unp2, unp);
856	}
857	finit(fp1, FREAD \| FWRITE \| fflag, DTYPE_SOCKET, fp1->f_data,
858	&socketops);
859	finit(fp2, FREAD \| FWRITE \| fflag, DTYPE_SOCKET, fp2->f_data,
860	&socketops);
861	if ((fflag & FNONBLOCK) != 0) {
862	(void) fo_ioctl(fp1, FIONBIO, &fflag, td->td_ucred, td);
863	(void) fo_ioctl(fp2, FIONBIO, &fflag, td->td_ucred, td);
864	}
865	#ifndef __rtems__
866	fdrop(fp1, td);
867	fdrop(fp2, td);
868	#endif /* __rtems__ */
869	return (0);
870	free4:
871	fdclose(td, fp2, rsv[1]);
872	#ifndef __rtems__
873	fdrop(fp2, td);
874	#endif /* __rtems__ */
875	free3:
876	fdclose(td, fp1, rsv[0]);
877	#ifndef __rtems__
878	fdrop(fp1, td);
879	#endif /* __rtems__ */
880	free2:
881	if (so2 != NULL)
882	(void)soclose(so2);
883	free1:
884	if (so1 != NULL)
885	(void)soclose(so1);
886	return (error);
887	}
888
889	#ifdef __rtems__
890	static
891	#endif /* __rtems__ */
892	int
893	sys_socketpair(struct thread td, struct socketpair_args uap)
894	{
895	#ifndef __rtems__
896	int error, sv[2];
897	#else /* __rtems__ */
898	int error;
899	int *sv = uap->rsv;
900	#endif /* __rtems__ */
901
902	error = kern_socketpair(td, uap->domain, uap->type,
903	uap->protocol, sv);
904	if (error != 0)
905	return (error);
906	#ifndef __rtems__
907	error = copyout(sv, uap->rsv, 2 * sizeof(int));
908	if (error != 0) {
909	(void)kern_close(td, sv[0]);
910	(void)kern_close(td, sv[1]);
911	}
912	#endif /* __rtems__ */
913	return (error);
914	}
915	#ifdef __rtems__
916	int
917	socketpair(int domain, int type, int protocol, int *socket_vector)
918	{
919	struct thread *td = rtems_bsd_get_curthread_or_null();
920	struct socketpair_args ua = {
921	.domain = domain,
922	.type = type,
923	.protocol = protocol,
924	.rsv = socket_vector
925	};
926	int error;
927
928	if (td != NULL) {
929	error = sys_socketpair(td, &ua);
930	} else {
931	error = ENOMEM;
932	}
933
934	return rtems_bsd_error_to_status_and_errno(error);
935	}
936	#endif /* __rtems__ */
937
938	#ifdef __rtems__
939	static int
940	kern_sendit( struct thread td, int s, struct msghdr mp, int flags,
941	struct mbuf *control, enum uio_seg segflg);
942	#endif /* __rtems__ */
943	static int
944	sendit(struct thread td, int s, struct msghdr mp, int flags)
945	{
946	struct mbuf *control;
947	struct sockaddr *to;
948	int error;
949	#ifdef __rtems__
950	struct getsockaddr_sockaddr gto;
951	to = &gto.header;
952	#endif /* __rtems__ */
953
954	#ifdef CAPABILITY_MODE
955	if (IN_CAPABILITY_MODE(td) && (mp->msg_name != NULL))
956	return (ECAPMODE);
957	#endif
958
959	if (mp->msg_name != NULL) {
960	error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
961	if (error != 0) {
962	to = NULL;
963	goto bad;
964	}
965	mp->msg_name = to;
966	} else {
967	to = NULL;
968	}
969
970	if (mp->msg_control) {
971	if (mp->msg_controllen < sizeof(struct cmsghdr)
972	#ifdef COMPAT_OLDSOCK
973	&& mp->msg_flags != MSG_COMPAT
974	#endif
975	) {
976	error = EINVAL;
977	goto bad;
978	}
979	error = sockargs(&control, mp->msg_control,
980	mp->msg_controllen, MT_CONTROL);
981	if (error != 0)
982	goto bad;
983	#ifdef COMPAT_OLDSOCK
984	if (mp->msg_flags == MSG_COMPAT) {
985	struct cmsghdr *cm;
986
987	M_PREPEND(control, sizeof(*cm), M_WAITOK);
988	cm = mtod(control, struct cmsghdr *);
989	cm->cmsg_len = control->m_len;
990	cm->cmsg_level = SOL_SOCKET;
991	cm->cmsg_type = SCM_RIGHTS;
992	}
993	#endif
994	} else {
995	control = NULL;
996	}
997
998	error = kern_sendit(td, s, mp, flags, control, UIO_USERSPACE);
999
1000	bad:
1001	#ifndef __rtems__
1002	free(to, M_SONAME);
1003	#endif /* __rtems__ */
1004	return (error);
1005	}
1006
1007	int
1008	kern_sendit(struct thread td, int s, struct msghdr mp, int flags,
1009	struct mbuf *control, enum uio_seg segflg)
1010	{
1011	struct file *fp;
1012	struct uio auio;
1013	struct iovec *iov;
1014	struct socket *so;
1015	#ifndef __rtems__
1016	cap_rights_t *rights;
1017	#endif /* __rtems__ */
1018	#ifdef KTRACE
1019	struct uio *ktruio = NULL;
1020	#endif
1021	ssize_t len;
1022	int i, error;
1023
1024	AUDIT_ARG_FD(s);
1025	#ifndef __rtems__
1026	rights = &cap_send_rights;
1027	cap_rights_init(&rights, CAP_SEND);
1028	if (mp->msg_name != NULL) {
1029	AUDIT_ARG_SOCKADDR(td, AT_FDCWD, mp->msg_name);
1030	rights = &cap_send_connect_rights;
1031	}
1032	#endif /* __rtems__ */
1033	error = getsock_cap(td, s, rights, &fp, NULL, NULL);
1034	if (error != 0) {
1035	m_freem(control);
1036	return (error);
1037	}
1038	so = (struct socket *)fp->f_data;
1039
1040	#ifdef KTRACE
1041	if (mp->msg_name != NULL && KTRPOINT(td, KTR_STRUCT))
1042	ktrsockaddr(mp->msg_name);
1043	#endif
1044	#ifdef MAC
1045	if (mp->msg_name != NULL) {
1046	error = mac_socket_check_connect(td->td_ucred, so,
1047	mp->msg_name);
1048	if (error != 0) {
1049	m_freem(control);
1050	goto bad;
1051	}
1052	}
1053	error = mac_socket_check_send(td->td_ucred, so);
1054	if (error != 0) {
1055	m_freem(control);
1056	goto bad;
1057	}
1058	#endif
1059
1060	auio.uio_iov = mp->msg_iov;
1061	auio.uio_iovcnt = mp->msg_iovlen;
1062	auio.uio_segflg = segflg;
1063	auio.uio_rw = UIO_WRITE;
1064	auio.uio_td = td;
1065	auio.uio_offset = 0; /* XXX */
1066	auio.uio_resid = 0;
1067	iov = mp->msg_iov;
1068	for (i = 0; i < mp->msg_iovlen; i++, iov++) {
1069	if ((auio.uio_resid += iov->iov_len) < 0) {
1070	error = EINVAL;
1071	m_freem(control);
1072	goto bad;
1073	}
1074	}
1075	#ifdef KTRACE
1076	if (KTRPOINT(td, KTR_GENIO))
1077	ktruio = cloneuio(&auio);
1078	#endif
1079	len = auio.uio_resid;
1080	error = sosend(so, mp->msg_name, &auio, 0, control, flags, td);
1081	if (error != 0) {
1082	if (auio.uio_resid != len && (error == ERESTART \|\|
1083	error == EINTR \|\| error == EWOULDBLOCK))
1084	error = 0;
1085	/* Generation of SIGPIPE can be controlled per socket */
1086	if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
1087	!(flags & MSG_NOSIGNAL)) {
1088	#ifndef __rtems__
1089	PROC_LOCK(td->td_proc);
1090	tdsignal(td, SIGPIPE);
1091	PROC_UNLOCK(td->td_proc);
1092	#else /* __rtems__ */
1093	/* FIXME: Determine if we really want to use signals */
1094	#endif /* __rtems__ */
1095	}
1096	}
1097	if (error == 0)
1098	td->td_retval[0] = len - auio.uio_resid;
1099	#ifdef KTRACE
1100	if (ktruio != NULL) {
1101	ktruio->uio_resid = td->td_retval[0];
1102	ktrgenio(s, UIO_WRITE, ktruio, error);
1103	}
1104	#endif
1105	bad:
1106	fdrop(fp, td);
1107	return (error);
1108	}
1109
1110	#ifdef __rtems__
1111	static
1112	#endif /* __rtems__ */
1113	int
1114	sys_sendto(struct thread td, struct sendto_args uap)
1115	{
1116	struct msghdr msg;
1117	struct iovec aiov;
1118
1119	msg.msg_name = __DECONST(void *, uap->to);
1120	msg.msg_namelen = uap->tolen;
1121	msg.msg_iov = &aiov;
1122	msg.msg_iovlen = 1;
1123	msg.msg_control = 0;
1124	#ifdef COMPAT_OLDSOCK
1125	msg.msg_flags = 0;
1126	#endif
1127	aiov.iov_base = __DECONST(void *, uap->buf);
1128	aiov.iov_len = uap->len;
1129	return (sendit(td, uap->s, &msg, uap->flags));
1130	}
1131	#ifdef __rtems__
1132	ssize_t
1133	sendto(int socket, const void *message, size_t length, int flags,
1134	const struct sockaddr *dest_addr, socklen_t dest_len)
1135	{
1136	struct thread *td = rtems_bsd_get_curthread_or_null();
1137	struct sendto_args ua = {
1138	.s = socket,
1139	.buf = (caddr_t) message,
1140	.len = length,
1141	.flags = flags,
1142	.to = dest_addr,
1143	.tolen = dest_len
1144	};
1145	int error;
1146
1147	if (td != NULL) {
1148	error = sys_sendto(td, &ua);
1149	} else {
1150	error = ENOMEM;
1151	}
1152
1153	if (error == 0) {
1154	return td->td_retval[0];
1155	} else {
1156	rtems_set_errno_and_return_minus_one(error);
1157	}
1158	}
1159
1160	int
1161	rtems_bsd_sendto(int socket, struct mbuf *m, int flags,
1162	const struct sockaddr *dest_addr)
1163	{
1164	struct thread *td = rtems_bsd_get_curthread_or_null();
1165	struct file *fp;
1166	struct socket *so;
1167	int error;
1168
1169	error = getsock_cap(td->td_proc->p_fd, socket, CAP_WRITE, &fp, NULL, NULL);
1170	if (error)
1171	return (error);
1172	so = (struct socket *)fp->f_data;
1173
1174	if (td != NULL) {
1175	error = sosend(so, __DECONST(struct sockaddr *, dest_addr),
1176	NULL, m, NULL, flags, td);
1177	} else {
1178	error = ENOMEM;
1179	}
1180
1181	return (error);
1182	}
1183	#endif /* __rtems__ */
1184
1185	#ifndef __rtems__
1186	#ifdef COMPAT_OLDSOCK
1187	int
1188	osend(struct thread td, struct osend_args uap)
1189	{
1190	struct msghdr msg;
1191	struct iovec aiov;
1192
1193	msg.msg_name = 0;
1194	msg.msg_namelen = 0;
1195	msg.msg_iov = &aiov;
1196	msg.msg_iovlen = 1;
1197	aiov.iov_base = __DECONST(void *, uap->buf);
1198	aiov.iov_len = uap->len;
1199	msg.msg_control = 0;
1200	msg.msg_flags = 0;
1201	return (sendit(td, uap->s, &msg, uap->flags));
1202	}
1203
1204	int
1205	osendmsg(struct thread td, struct osendmsg_args uap)
1206	{
1207	struct msghdr msg;
1208	struct iovec *iov;
1209	int error;
1210
1211	error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
1212	if (error != 0)
1213	return (error);
1214	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1215	if (error != 0)
1216	return (error);
1217	msg.msg_iov = iov;
1218	msg.msg_flags = MSG_COMPAT;
1219	error = sendit(td, uap->s, &msg, uap->flags);
1220	free(iov, M_IOV);
1221	return (error);
1222	}
1223	#endif
1224	#endif /* __rtems__ */
1225
1226	#ifdef __rtems__
1227	static
1228	#endif /* __rtems__ */
1229	int
1230	sys_sendmsg(struct thread td, struct sendmsg_args uap)
1231	{
1232	struct msghdr msg;
1233	struct iovec *iov;
1234	int error;
1235
1236	error = copyin(uap->msg, &msg, sizeof (msg));
1237	if (error != 0)
1238	return (error);
1239	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1240	if (error != 0)
1241	return (error);
1242	msg.msg_iov = iov;
1243	#ifdef COMPAT_OLDSOCK
1244	msg.msg_flags = 0;
1245	#endif
1246	error = sendit(td, uap->s, &msg, uap->flags);
1247	free(iov, M_IOV);
1248	return (error);
1249	}
1250	#ifdef __rtems__
1251	ssize_t
1252	sendmsg(int socket, const struct msghdr *message, int flags)
1253	{
1254	struct thread *td = rtems_bsd_get_curthread_or_null();
1255	struct sendmsg_args ua = {
1256	.s = socket,
1257	.msg = message,
1258	.flags = flags
1259	};
1260	int error;
1261
1262	if (td != NULL) {
1263	error = sys_sendmsg(td, &ua);
1264	} else {
1265	error = ENOMEM;
1266	}
1267
1268	if (error == 0) {
1269	return td->td_retval[0];
1270	} else {
1271	rtems_set_errno_and_return_minus_one(error);
1272	}
1273	}
1274	#endif /* __rtems__ */
1275
1276	#ifdef __rtems__
1277	static
1278	#endif /* __rtems__ */
1279	int
1280	kern_recvit(struct thread td, int s, struct msghdr mp, enum uio_seg fromseg,
1281	struct mbuf **controlp)
1282	{
1283	struct uio auio;
1284	struct iovec *iov;
1285	struct mbuf control, m;
1286	caddr_t ctlbuf;
1287	struct file *fp;
1288	struct socket *so;
1289	struct sockaddr *fromsa = NULL;
1290	#ifdef KTRACE
1291	struct uio *ktruio = NULL;
1292	#endif
1293	ssize_t len;
1294	int error, i;
1295
1296	if (controlp != NULL)
1297	*controlp = NULL;
1298
1299	AUDIT_ARG_FD(s);
1300	error = getsock_cap(td, s, &cap_recv_rights,
1301	&fp, NULL, NULL);
1302	if (error != 0)
1303	return (error);
1304	so = fp->f_data;
1305
1306	#ifdef MAC
1307	error = mac_socket_check_receive(td->td_ucred, so);
1308	if (error != 0) {
1309	fdrop(fp, td);
1310	return (error);
1311	}
1312	#endif
1313
1314	auio.uio_iov = mp->msg_iov;
1315	auio.uio_iovcnt = mp->msg_iovlen;
1316	auio.uio_segflg = UIO_USERSPACE;
1317	auio.uio_rw = UIO_READ;
1318	auio.uio_td = td;
1319	auio.uio_offset = 0; /* XXX */
1320	auio.uio_resid = 0;
1321	iov = mp->msg_iov;
1322	for (i = 0; i < mp->msg_iovlen; i++, iov++) {
1323	if ((auio.uio_resid += iov->iov_len) < 0) {
1324	fdrop(fp, td);
1325	return (EINVAL);
1326	}
1327	}
1328	#ifdef KTRACE
1329	if (KTRPOINT(td, KTR_GENIO))
1330	ktruio = cloneuio(&auio);
1331	#endif
1332	control = NULL;
1333	len = auio.uio_resid;
1334	error = soreceive(so, &fromsa, &auio, NULL,
1335	(mp->msg_control \|\| controlp) ? &control : NULL,
1336	&mp->msg_flags);
1337	if (error != 0) {
1338	if (auio.uio_resid != len && (error == ERESTART \|\|
1339	error == EINTR \|\| error == EWOULDBLOCK))
1340	error = 0;
1341	}
1342	if (fromsa != NULL)
1343	AUDIT_ARG_SOCKADDR(td, AT_FDCWD, fromsa);
1344	#ifdef KTRACE
1345	if (ktruio != NULL) {
1346	ktruio->uio_resid = len - auio.uio_resid;
1347	ktrgenio(s, UIO_READ, ktruio, error);
1348	}
1349	#endif
1350	if (error != 0)
1351	goto out;
1352	td->td_retval[0] = len - auio.uio_resid;
1353	if (mp->msg_name) {
1354	len = mp->msg_namelen;
1355	if (len <= 0 \|\| fromsa == NULL)
1356	len = 0;
1357	else {
1358	/* save sa_len before it is destroyed by MSG_COMPAT */
1359	len = MIN(len, fromsa->sa_len);
1360	#ifdef COMPAT_OLDSOCK
1361	if (mp->msg_flags & MSG_COMPAT)
1362	((struct osockaddr *)fromsa)->sa_family =
1363	fromsa->sa_family;
1364	#endif
1365	if (fromseg == UIO_USERSPACE) {
1366	error = copyout(fromsa, mp->msg_name,
1367	(unsigned)len);
1368	if (error != 0)
1369	goto out;
1370	} else
1371	bcopy(fromsa, mp->msg_name, len);
1372	}
1373	mp->msg_namelen = len;
1374	}
1375	if (mp->msg_control && controlp == NULL) {
1376	#ifdef COMPAT_OLDSOCK
1377	/*
1378	* We assume that old recvmsg calls won't receive access
1379	* rights and other control info, esp. as control info
1380	* is always optional and those options didn't exist in 4.3.
1381	* If we receive rights, trim the cmsghdr; anything else
1382	* is tossed.
1383	*/
1384	if (control && mp->msg_flags & MSG_COMPAT) {
1385	if (mtod(control, struct cmsghdr *)->cmsg_level !=
1386	SOL_SOCKET \|\|
1387	mtod(control, struct cmsghdr *)->cmsg_type !=
1388	SCM_RIGHTS) {
1389	mp->msg_controllen = 0;
1390	goto out;
1391	}
1392	control->m_len -= sizeof (struct cmsghdr);
1393	control->m_data += sizeof (struct cmsghdr);
1394	}
1395	#endif
1396	ctlbuf = mp->msg_control;
1397	len = mp->msg_controllen;
1398	mp->msg_controllen = 0;
1399	for (m = control; m != NULL && len >= m->m_len; m = m->m_next) {
1400	if ((error = copyout(mtod(m, caddr_t), ctlbuf,
1401	m->m_len)) != 0)
1402	goto out;
1403
1404	ctlbuf += m->m_len;
1405	len -= m->m_len;
1406	mp->msg_controllen += m->m_len;
1407	}
1408	if (m != NULL) {
1409	mp->msg_flags \|= MSG_CTRUNC;
1410	m_dispose_extcontrolm(m);
1411	}
1412	}
1413	out:
1414	fdrop(fp, td);
1415	#ifdef KTRACE
1416	if (fromsa && KTRPOINT(td, KTR_STRUCT))
1417	ktrsockaddr(fromsa);
1418	#endif
1419	free(fromsa, M_SONAME);
1420
1421	if (error == 0 && controlp != NULL)
1422	*controlp = control;
1423	else if (control != NULL) {
1424	if (error != 0)
1425	m_dispose_extcontrolm(control);
1426	m_freem(control);
1427	}
1428
1429	return (error);
1430	}
1431
1432	static int
1433	recvit(struct thread td, int s, struct msghdr mp, void *namelenp)
1434	{
1435	int error;
1436
1437	error = kern_recvit(td, s, mp, UIO_USERSPACE, NULL);
1438	if (error != 0)
1439	return (error);
1440	if (namelenp != NULL) {
1441	error = copyout(&mp->msg_namelen, namelenp, sizeof (socklen_t));
1442	#ifdef COMPAT_OLDSOCK
1443	if (mp->msg_flags & MSG_COMPAT)
1444	error = 0; /* old recvfrom didn't check */
1445	#endif
1446	}
1447	return (error);
1448	}
1449
1450	#ifdef __rtems__
1451	static
1452	#endif /* __rtems__ */
1453	int
1454	sys_recvfrom(struct thread td, struct recvfrom_args uap)
1455	{
1456	struct msghdr msg;
1457	struct iovec aiov;
1458	int error;
1459
1460	if (uap->fromlenaddr) {
1461	error = copyin(uap->fromlenaddr,
1462	&msg.msg_namelen, sizeof (msg.msg_namelen));
1463	if (error != 0)
1464	goto done2;
1465	} else {
1466	msg.msg_namelen = 0;
1467	}
1468	msg.msg_name = uap->from;
1469	msg.msg_iov = &aiov;
1470	msg.msg_iovlen = 1;
1471	aiov.iov_base = uap->buf;
1472	aiov.iov_len = uap->len;
1473	msg.msg_control = 0;
1474	msg.msg_flags = uap->flags;
1475	error = recvit(td, uap->s, &msg, uap->fromlenaddr);
1476	done2:
1477	return (error);
1478	}
1479	#ifdef __rtems__
1480	ssize_t
1481	recvfrom(int socket, void *__restrict buffer, size_t length, int flags,
1482	struct sockaddr __restrict address, socklen_t __restrict address_len)
1483	{
1484	struct thread *td = rtems_bsd_get_curthread_or_null();
1485	struct recvfrom_args ua = {
1486	.s = socket,
1487	.buf = buffer,
1488	.len = length,
1489	.flags = flags,
1490	.from = address,
1491	.fromlenaddr = address_len
1492	};
1493	int error;
1494
1495	if (td != NULL) {
1496	error = sys_recvfrom(td, &ua);
1497	} else {
1498	error = ENOMEM;
1499	}
1500
1501	if (error == 0) {
1502	return td->td_retval[0];
1503	} else {
1504	rtems_set_errno_and_return_minus_one(error);
1505	}
1506	}
1507	#endif /* __rtems__ */
1508
1509	#ifndef __rtems__
1510	#ifdef COMPAT_OLDSOCK
1511	int
1512	orecvfrom(struct thread td, struct recvfrom_args uap)
1513	{
1514
1515	uap->flags \|= MSG_COMPAT;
1516	return (sys_recvfrom(td, uap));
1517	}
1518	#endif
1519
1520	#ifdef COMPAT_OLDSOCK
1521	int
1522	orecv(struct thread td, struct orecv_args uap)
1523	{
1524	struct msghdr msg;
1525	struct iovec aiov;
1526
1527	msg.msg_name = 0;
1528	msg.msg_namelen = 0;
1529	msg.msg_iov = &aiov;
1530	msg.msg_iovlen = 1;
1531	aiov.iov_base = uap->buf;
1532	aiov.iov_len = uap->len;
1533	msg.msg_control = 0;
1534	msg.msg_flags = uap->flags;
1535	return (recvit(td, uap->s, &msg, NULL));
1536	}
1537
1538	/*
1539	* Old recvmsg. This code takes advantage of the fact that the old msghdr
1540	* overlays the new one, missing only the flags, and with the (old) access
1541	* rights where the control fields are now.
1542	*/
1543	int
1544	orecvmsg(struct thread td, struct orecvmsg_args uap)
1545	{
1546	struct msghdr msg;
1547	struct iovec *iov;
1548	int error;
1549
1550	error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
1551	if (error != 0)
1552	return (error);
1553	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1554	if (error != 0)
1555	return (error);
1556	msg.msg_flags = uap->flags \| MSG_COMPAT;
1557	msg.msg_iov = iov;
1558	error = recvit(td, uap->s, &msg, &uap->msg->msg_namelen);
1559	if (msg.msg_controllen && error == 0)
1560	error = copyout(&msg.msg_controllen,
1561	&uap->msg->msg_accrightslen, sizeof (int));
1562	free(iov, M_IOV);
1563	return (error);
1564	}
1565	#endif
1566	#endif /* __rtems__ */
1567
1568	#ifdef __rtems__
1569	static
1570	#endif /* __rtems__ */
1571	int
1572	sys_recvmsg(struct thread td, struct recvmsg_args uap)
1573	{
1574	struct msghdr msg;
1575	struct iovec uiov, iov;
1576	int error;
1577
1578	error = copyin(uap->msg, &msg, sizeof (msg));
1579	if (error != 0)
1580	return (error);
1581	error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1582	if (error != 0)
1583	return (error);
1584	msg.msg_flags = uap->flags;
1585	#ifdef COMPAT_OLDSOCK
1586	msg.msg_flags &= ~MSG_COMPAT;
1587	#endif
1588	uiov = msg.msg_iov;
1589	msg.msg_iov = iov;
1590	error = recvit(td, uap->s, &msg, NULL);
1591	if (error == 0) {
1592	msg.msg_iov = uiov;
1593	error = copyout(&msg, uap->msg, sizeof(msg));
1594	}
1595	free(iov, M_IOV);
1596	return (error);
1597	}
1598	#ifdef __rtems__
1599	ssize_t
1600	recvmsg(int socket, struct msghdr *message, int flags)
1601	{
1602	struct thread *td = rtems_bsd_get_curthread_or_null();
1603	struct recvmsg_args ua = {
1604	.s = socket,
1605	.msg = message,
1606	.flags = flags
1607	};
1608	int error;
1609
1610	if (td != NULL) {
1611	error = sys_recvmsg(td, &ua);
1612	} else {
1613	error = ENOMEM;
1614	}
1615
1616	if (error == 0) {
1617	return td->td_retval[0];
1618	} else {
1619	rtems_set_errno_and_return_minus_one(error);
1620	}
1621	}
1622	#endif /* __rtems__ */
1623
1624	#ifdef __rtems__
1625	static
1626	#endif /* __rtems__ */
1627	int
1628	sys_shutdown(struct thread td, struct shutdown_args uap)
1629	{
1630
1631	return (kern_shutdown(td, uap->s, uap->how));
1632	}
1633
1634	int
1635	kern_shutdown(struct thread *td, int s, int how)
1636	{
1637	struct socket *so;
1638	struct file *fp;
1639	int error;
1640
1641	AUDIT_ARG_FD(s);
1642	error = getsock_cap(td, s, &cap_shutdown_rights,
1643	&fp, NULL, NULL);
1644	if (error == 0) {
1645	so = fp->f_data;
1646	error = soshutdown(so, how);
1647	#ifndef __rtems__
1648	/*
1649	* Previous versions did not return ENOTCONN, but 0 in
1650	* case the socket was not connected. Some important
1651	* programs like syslogd up to r279016, 2015-02-19,
1652	* still depend on this behavior.
1653	*/
1654	if (error == ENOTCONN &&
1655	td->td_proc->p_osrel < P_OSREL_SHUTDOWN_ENOTCONN)
1656	error = 0;
1657	#endif /* __rtems__ */
1658	fdrop(fp, td);
1659	}
1660	return (error);
1661	}
1662	#ifdef __rtems__
1663	int
1664	shutdown(int socket, int how)
1665	{
1666	struct shutdown_args ua = {
1667	.s = socket,
1668	.how = how
1669	};
1670	int error = sys_shutdown(NULL, &ua);
1671
1672	return rtems_bsd_error_to_status_and_errno(error);
1673	}
1674	#endif /* __rtems__ */
1675
1676	#ifdef __rtems__
1677	static
1678	#endif /* __rtems__ */
1679	int
1680	sys_setsockopt(struct thread td, struct setsockopt_args uap)
1681	{
1682
1683	return (kern_setsockopt(td, uap->s, uap->level, uap->name,
1684	uap->val, UIO_USERSPACE, uap->valsize));
1685	}
1686	#ifdef __rtems__
1687	int
1688	setsockopt(int socket, int level, int option_name, const void *option_value,
1689	socklen_t option_len)
1690	{
1691	struct thread *td = rtems_bsd_get_curthread_or_null();
1692	struct setsockopt_args ua = {
1693	.s = socket,
1694	.level = level,
1695	.name = option_name,
1696	.val = __DECONST(void *, option_value),
1697	.valsize = option_len
1698	};
1699	int error;
1700
1701	if (td != NULL) {
1702	error = sys_setsockopt(td, &ua);
1703	} else {
1704	error = ENOMEM;
1705	}
1706
1707	return rtems_bsd_error_to_status_and_errno(error);
1708	}
1709	#endif /* __rtems__ */
1710
1711	int
1712	kern_setsockopt(struct thread td, int s, int level, int name, const void val,
1713	enum uio_seg valseg, socklen_t valsize)
1714	{
1715	struct socket *so;
1716	struct file *fp;
1717	struct sockopt sopt;
1718	int error;
1719
1720	if (val == NULL && valsize != 0)
1721	return (EFAULT);
1722	if ((int)valsize < 0)
1723	return (EINVAL);
1724
1725	sopt.sopt_dir = SOPT_SET;
1726	sopt.sopt_level = level;
1727	sopt.sopt_name = name;
1728	sopt.sopt_val = __DECONST(void *, val);
1729	sopt.sopt_valsize = valsize;
1730	switch (valseg) {
1731	case UIO_USERSPACE:
1732	sopt.sopt_td = td;
1733	break;
1734	case UIO_SYSSPACE:
1735	sopt.sopt_td = NULL;
1736	break;
1737	default:
1738	panic("kern_setsockopt called with bad valseg");
1739	}
1740
1741	AUDIT_ARG_FD(s);
1742	error = getsock_cap(td, s, &cap_setsockopt_rights,
1743	&fp, NULL, NULL);
1744	if (error == 0) {
1745	so = fp->f_data;
1746	error = sosetopt(so, &sopt);
1747	fdrop(fp, td);
1748	}
1749	return(error);
1750	}
1751
1752	#ifdef __rtems__
1753	static int kern_getsockopt( struct thread *td, int s, int level, int name,
1754	void val, enum uio_seg valseg, socklen_t valsize);
1755
1756	static
1757	#endif /* __rtems__ */
1758	int
1759	sys_getsockopt(struct thread td, struct getsockopt_args uap)
1760	{
1761	socklen_t valsize;
1762	int error;
1763
1764	if (uap->val) {
1765	error = copyin(uap->avalsize, &valsize, sizeof (valsize));
1766	if (error != 0)
1767	return (error);
1768	}
1769
1770	error = kern_getsockopt(td, uap->s, uap->level, uap->name,
1771	uap->val, UIO_USERSPACE, &valsize);
1772
1773	if (error == 0)
1774	error = copyout(&valsize, uap->avalsize, sizeof (valsize));
1775	return (error);
1776	}
1777	#ifdef __rtems__
1778	int
1779	getsockopt(int socket, int level, int option_name, void *__restrict
1780	option_value, socklen_t *__restrict option_len)
1781	{
1782	struct thread *td = rtems_bsd_get_curthread_or_null();
1783	struct getsockopt_args ua = {
1784	.s = socket,
1785	.level = level,
1786	.name = option_name,
1787	.val = (caddr_t) option_value,
1788	.avalsize = option_len
1789	};
1790	int error;
1791
1792	if (td != NULL) {
1793	error = sys_getsockopt(td, &ua);
1794	} else {
1795	error = ENOMEM;
1796	}
1797
1798	return rtems_bsd_error_to_status_and_errno(error);
1799	}
1800	#endif /* __rtems__ */
1801
1802	/*
1803	* Kernel version of getsockopt.
1804	* optval can be a userland or userspace. optlen is always a kernel pointer.
1805	*/
1806	int
1807	kern_getsockopt(struct thread td, int s, int level, int name, void val,
1808	enum uio_seg valseg, socklen_t *valsize)
1809	{
1810	struct socket *so;
1811	struct file *fp;
1812	struct sockopt sopt;
1813	int error;
1814
1815	if (val == NULL)
1816	*valsize = 0;
1817	if ((int)*valsize < 0)
1818	return (EINVAL);
1819
1820	sopt.sopt_dir = SOPT_GET;
1821	sopt.sopt_level = level;
1822	sopt.sopt_name = name;
1823	sopt.sopt_val = val;
1824	sopt.sopt_valsize = (size_t)valsize; / checked non-negative above */
1825	switch (valseg) {
1826	case UIO_USERSPACE:
1827	sopt.sopt_td = td;
1828	break;
1829	case UIO_SYSSPACE:
1830	sopt.sopt_td = NULL;
1831	break;
1832	default:
1833	panic("kern_getsockopt called with bad valseg");
1834	}
1835
1836	AUDIT_ARG_FD(s);
1837	error = getsock_cap(td, s, &cap_getsockopt_rights,
1838	&fp, NULL, NULL);
1839	if (error == 0) {
1840	so = fp->f_data;
1841	error = sogetopt(so, &sopt);
1842	*valsize = sopt.sopt_valsize;
1843	fdrop(fp, td);
1844	}
1845	return (error);
1846	}
1847
1848	/*
1849	* getsockname1() - Get socket name.
1850	*/
1851	static int
1852	getsockname1(struct thread td, struct getsockname_args uap, int compat)
1853	{
1854	struct sockaddr *sa;
1855	socklen_t len;
1856	int error;
1857
1858	error = copyin(uap->alen, &len, sizeof(len));
1859	if (error != 0)
1860	return (error);
1861
1862	error = kern_getsockname(td, uap->fdes, &sa, &len);
1863	if (error != 0)
1864	return (error);
1865
1866	if (len != 0) {
1867	#ifdef COMPAT_OLDSOCK
1868	if (compat)
1869	((struct osockaddr *)sa)->sa_family = sa->sa_family;
1870	#endif
1871	error = copyout(sa, uap->asa, (u_int)len);
1872	}
1873	free(sa, M_SONAME);
1874	if (error == 0)
1875	error = copyout(&len, uap->alen, sizeof(len));
1876	return (error);
1877	}
1878	#ifdef __rtems__
1879	int
1880	getsockname(int socket, struct sockaddr *__restrict address,
1881	socklen_t *__restrict address_len)
1882	{
1883	struct thread *td = rtems_bsd_get_curthread_or_null();
1884	struct getsockname_args ua = {
1885	.fdes = socket,
1886	.asa = address,
1887	.alen = address_len
1888	};
1889	int error;
1890
1891	if (td != NULL) {
1892	error = getsockname1(td, &ua, 0);
1893	} else {
1894	error = ENOMEM;
1895	}
1896
1897	return rtems_bsd_error_to_status_and_errno(error);
1898	}
1899	#endif /* __rtems__ */
1900
1901	int
1902	kern_getsockname(struct thread td, int fd, struct sockaddr *sa,
1903	socklen_t *alen)
1904	{
1905	struct socket *so;
1906	struct file *fp;
1907	socklen_t len;
1908	int error;
1909
1910	AUDIT_ARG_FD(fd);
1911	error = getsock_cap(td, fd, &cap_getsockname_rights,
1912	&fp, NULL, NULL);
1913	if (error != 0)
1914	return (error);
1915	so = fp->f_data;
1916	*sa = NULL;
1917	CURVNET_SET(so->so_vnet);
1918	error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, sa);
1919	CURVNET_RESTORE();
1920	if (error != 0)
1921	goto bad;
1922	if (*sa == NULL)
1923	len = 0;
1924	else
1925	len = MIN(alen, (sa)->sa_len);
1926	*alen = len;
1927	#ifdef KTRACE
1928	if (KTRPOINT(td, KTR_STRUCT))
1929	ktrsockaddr(*sa);
1930	#endif
1931	bad:
1932	fdrop(fp, td);
1933	if (error != 0 && *sa != NULL) {
1934	free(*sa, M_SONAME);
1935	*sa = NULL;
1936	}
1937	return (error);
1938	}
1939
1940	#ifndef __rtems__
1941	int
1942	sys_getsockname(struct thread td, struct getsockname_args uap)
1943	{
1944
1945	return (getsockname1(td, uap, 0));
1946	}
1947
1948	#ifdef COMPAT_OLDSOCK
1949	int
1950	ogetsockname(struct thread td, struct getsockname_args uap)
1951	{
1952
1953	return (getsockname1(td, uap, 1));
1954	}
1955	#endif /* COMPAT_OLDSOCK */
1956	#endif /* __rtems__ */
1957
1958	#ifdef __rtems__
1959	static int
1960	kern_getpeername(struct thread td, int fd, struct sockaddr *sa,
1961	socklen_t *alen);
1962	#endif /* __rtems__ */
1963	/*
1964	* getpeername1() - Get name of peer for connected socket.
1965	*/
1966	static int
1967	getpeername1(struct thread td, struct getpeername_args uap, int compat)
1968	{
1969	struct sockaddr *sa;
1970	socklen_t len;
1971	int error;
1972
1973	error = copyin(uap->alen, &len, sizeof (len));
1974	if (error != 0)
1975	return (error);
1976
1977	error = kern_getpeername(td, uap->fdes, &sa, &len);
1978	if (error != 0)
1979	return (error);
1980
1981	if (len != 0) {
1982	#ifdef COMPAT_OLDSOCK
1983	if (compat)
1984	((struct osockaddr *)sa)->sa_family = sa->sa_family;
1985	#endif
1986	error = copyout(sa, uap->asa, (u_int)len);
1987	}
1988	free(sa, M_SONAME);
1989	if (error == 0)
1990	error = copyout(&len, uap->alen, sizeof(len));
1991	return (error);
1992	}
1993	#ifdef __rtems__
1994	int
1995	getpeername(int socket, struct sockaddr *__restrict address,
1996	socklen_t *__restrict address_len)
1997	{
1998	struct thread *td = rtems_bsd_get_curthread_or_null();
1999	struct getpeername_args ua = {
2000	.fdes = socket,
2001	.asa = address,
2002	.alen = address_len
2003	};
2004	int error;
2005
2006	if (td != NULL) {
2007	error = getpeername1(td, &ua, 0);
2008	} else {
2009	error = ENOMEM;
2010	}
2011
2012	return rtems_bsd_error_to_status_and_errno(error);
2013	}
2014	#endif /* __rtems__ */
2015
2016	int
2017	kern_getpeername(struct thread td, int fd, struct sockaddr *sa,
2018	socklen_t *alen)
2019	{
2020	struct socket *so;
2021	struct file *fp;
2022	socklen_t len;
2023	int error;
2024
2025	AUDIT_ARG_FD(fd);
2026	error = getsock_cap(td, fd, &cap_getpeername_rights,
2027	&fp, NULL, NULL);
2028	if (error != 0)
2029	return (error);
2030	so = fp->f_data;
2031	if ((so->so_state & (SS_ISCONNECTED\|SS_ISCONFIRMING)) == 0) {
2032	error = ENOTCONN;
2033	goto done;
2034	}
2035	*sa = NULL;
2036	CURVNET_SET(so->so_vnet);
2037	error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, sa);
2038	CURVNET_RESTORE();
2039	if (error != 0)
2040	goto bad;
2041	if (*sa == NULL)
2042	len = 0;
2043	else
2044	len = MIN(alen, (sa)->sa_len);
2045	*alen = len;
2046	#ifdef KTRACE
2047	if (KTRPOINT(td, KTR_STRUCT))
2048	ktrsockaddr(*sa);
2049	#endif
2050	bad:
2051	if (error != 0 && *sa != NULL) {
2052	free(*sa, M_SONAME);
2053	*sa = NULL;
2054	}
2055	done:
2056	fdrop(fp, td);
2057	return (error);
2058	}
2059
2060	#ifndef __rtems__
2061	int
2062	sys_getpeername(struct thread td, struct getpeername_args uap)
2063	{
2064
2065	return (getpeername1(td, uap, 0));
2066	}
2067
2068	#ifdef COMPAT_OLDSOCK
2069	int
2070	ogetpeername(struct thread td, struct ogetpeername_args uap)
2071	{
2072
2073	/* XXX uap should have type `getpeername_args ' to begin with. /
2074	return (getpeername1(td, (struct getpeername_args *)uap, 1));
2075	}
2076	#endif /* COMPAT_OLDSOCK */
2077	#endif /* __rtems__ */
2078
2079	static int
2080	sockargs(struct mbuf *mp, char buf, socklen_t buflen, int type)
2081	{
2082	struct sockaddr *sa;
2083	struct mbuf *m;
2084	int error;
2085
2086	if (buflen > MLEN) {
2087	#ifdef COMPAT_OLDSOCK
2088	if (type == MT_SONAME && buflen <= 112)
2089	buflen = MLEN; /* unix domain compat. hack */
2090	else
2091	#endif
2092	if (buflen > MCLBYTES)
2093	return (EINVAL);
2094	}
2095	m = m_get2(buflen, M_WAITOK, type, 0);
2096	m->m_len = buflen;
2097	error = copyin(buf, mtod(m, void *), buflen);
2098	if (error != 0)
2099	(void) m_free(m);
2100	else {
2101	*mp = m;
2102	if (type == MT_SONAME) {
2103	sa = mtod(m, struct sockaddr *);
2104
2105	#if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
2106	if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
2107	sa->sa_family = sa->sa_len;
2108	#endif
2109	sa->sa_len = buflen;
2110	}
2111	}
2112	return (error);
2113	}
2114
2115	int
2116	getsockaddr(struct sockaddr *namp, const struct sockaddr uaddr, size_t len)
2117	{
2118	struct sockaddr *sa;
2119	#ifndef __rtems__
2120	int error;
2121	#endif /* __rtems__ */
2122
2123	if (len > SOCK_MAXADDRLEN)
2124	return (ENAMETOOLONG);
2125	if (len < offsetof(struct sockaddr, sa_data[0]))
2126	return (EINVAL);
2127	#ifndef __rtems__
2128	sa = malloc(len, M_SONAME, M_WAITOK);
2129	error = copyin(uaddr, sa, len);
2130	if (error != 0) {
2131	free(sa, M_SONAME);
2132	} else {
2133	#if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
2134	if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
2135	sa->sa_family = sa->sa_len;
2136	#endif
2137	sa->sa_len = len;
2138	*namp = sa;
2139	}
2140	return (error);
2141	#else /* __rtems__ */
2142	sa = memcpy(*namp, uaddr, len);
2143	sa->sa_len = len;
2144	return (0);
2145	#endif /* __rtems__ */
2146	}
2147
2148	/*
2149	* Dispose of externalized rights from an SCM_RIGHTS message. This function
2150	* should be used in error or truncation cases to avoid leaking file descriptors
2151	* into the recipient's (the current thread's) table.
2152	*/
2153	void
2154	m_dispose_extcontrolm(struct mbuf *m)
2155	{
2156	struct cmsghdr *cm;
2157	struct file *fp;
2158	struct thread *td;
2159	socklen_t clen, datalen;
2160	int error, fd, *fds, nfd;
2161
2162	td = curthread;
2163	for (; m != NULL; m = m->m_next) {
2164	if (m->m_type != MT_EXTCONTROL)
2165	continue;
2166	cm = mtod(m, struct cmsghdr *);
2167	clen = m->m_len;
2168	while (clen > 0) {
2169	if (clen < sizeof(*cm))
2170	panic("%s: truncated mbuf %p", __func__, m);
2171	datalen = CMSG_SPACE(cm->cmsg_len - CMSG_SPACE(0));
2172	if (clen < datalen)
2173	panic("%s: truncated mbuf %p", __func__, m);
2174
2175	if (cm->cmsg_level == SOL_SOCKET &&
2176	cm->cmsg_type == SCM_RIGHTS) {
2177	fds = (int *)CMSG_DATA(cm);
2178	nfd = (cm->cmsg_len - CMSG_SPACE(0)) /
2179	sizeof(int);
2180
2181	while (nfd-- > 0) {
2182	fd = *fds++;
2183	error = fget(td, fd, &cap_no_rights,
2184	&fp);
2185	if (error == 0)
2186	fdclose(td, fp, fd);
2187	}
2188	}
2189	clen -= datalen;
2190	cm = (struct cmsghdr )((uint8_t )cm + datalen);
2191	}
2192	m_chtype(m, MT_CONTROL);
2193	}
2194	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: rtems-libbsd/freebsd/sys/kern/uipc_syscalls.c @ 8d5fc9d

Download in other formats: