/src/SockFuzzer/fuzz/api/syscall_wrappers.c

Source
/*
 * Copyright 2021 Google LLC
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#include "fuzz/api/syscall_wrappers.h"

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wint-conversion"

__attribute__((visibility("default"))) int accept_wrapper(int s, caddr_t name,
                                                          socklen_t* anamelen,
                                                          int* retval) {
  struct accept_args uap = {
      .s = s,
      .name = name,
      .anamelen = anamelen,
  };
  return accept(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int accept_nocancel_wrapper(
    int s, caddr_t name, socklen_t* anamelen, int* retval) {
  struct accept_nocancel_args uap = {
      .s = s,
      .name = name,
      .anamelen = anamelen,
  };
  return accept_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int bind_wrapper(int s, caddr_t name,
                                                        socklen_t namelen,
                                                        int* retval) {
  struct bind_args uap = {
      .s = s,
      .name = name,
      .namelen = namelen,
  };
  return bind(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int close_wrapper(int fd, int* retval) {
  struct close_args uap = {
      .fd = fd,
  };
  return sys_close(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int connect_wrapper(int s, caddr_t name,
                                                           socklen_t namelen,
                                                           int* retval) {
  struct connect_args uap = {
      .s = s,
      .name = name,
      .namelen = namelen,
  };
  return connect(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int connect_nocancel_wrapper(
    int s, caddr_t name, socklen_t namelen, int* retval) {
  struct connect_nocancel_args uap = {
      .s = s,
      .name = name,
      .namelen = namelen,
  };
  return connect_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int connectx_wrapper(
    int socket, const sa_endpoints_t* endpoints, sae_associd_t associd,
    unsigned int flags, const struct iovec* iov, unsigned int iovcnt,
    size_t* len, sae_connid_t* connid, int* retval) {
  struct connectx_args uap = {
      .socket = socket,
      .endpoints = endpoints,
      .associd = associd,
      .flags = flags,
      .iov = iov,
      .iovcnt = iovcnt,
      .len = len,
      .connid = connid,
  };
  return connectx(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int disconnectx_wrapper(
    int s, sae_associd_t aid, sae_connid_t cid, int* retval) {
  struct disconnectx_args uap = {
      .s = s,
      .aid = aid,
      .cid = cid,
  };
  return disconnectx(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int getpeername_wrapper(int fdes,
                                                               caddr_t asa,
                                                               socklen_t* alen,
                                                               int* retval) {
  struct getpeername_args uap = {
      .fdes = fdes,
      .asa = asa,
      .alen = alen,
  };
  return getpeername(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int getsockname_wrapper(int fdes,
                                                               caddr_t asa,
                                                               socklen_t* alen,
                                                               int* retval) {
  struct getsockname_args uap = {
      .fdes = fdes,
      .asa = asa,
      .alen = alen,
  };
  return getsockname(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int getsockopt_wrapper(
    int s, int level, int name, caddr_t val, socklen_t* avalsize, int* retval) {
  struct getsockopt_args uap = {
      .s = s,
      .level = level,
      .name = name,
      .val = val,
      .avalsize = avalsize,
  };
  return getsockopt(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int ioctl_wrapper(int fd, u_long com,
                                                         caddr_t data,
                                                         int* retval) {
  struct ioctl_args uap = {
      .fd = fd,
      .com = com,
      .data = data,
  };
  return ioctl(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int listen_wrapper(int s, int backlog,
                                                          int* retval) {
  struct listen_args uap = {
      .s = s,
      .backlog = backlog,
  };
  return listen(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int necp_client_action_wrapper(
    int necp_fd, uint32_t action, uuid_t client_id, size_t client_id_len,
    uint8_t* buffer, size_t buffer_size, int* retval) {
  struct necp_client_action_args uap = {
      .necp_fd = necp_fd,
      .action = action,
      .client_id = client_id,
      .client_id_len = client_id_len,
      .buffer = buffer,
      .buffer_size = buffer_size,
  };
  return necp_client_action(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int necp_match_policy_wrapper(
    uint8_t* parameters, size_t parameters_size,
    struct necp_aggregate_result* returned_result, int* retval) {
  struct necp_match_policy_args uap = {
      .parameters = parameters,
      .parameters_size = parameters_size,
      .returned_result = returned_result,
  };
  return necp_match_policy(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int necp_open_wrapper(int flags,
                                                             int* retval) {
  struct necp_open_args uap = {
      .flags = flags,
  };
  return necp_open(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int necp_session_action_wrapper(
    int necp_fd, uint32_t action, uint8_t* in_buffer, size_t in_buffer_length,
    uint8_t* out_buffer, size_t out_buffer_length, int* retval) {
  struct necp_session_action_args uap = {
      .necp_fd = necp_fd,
      .action = action,
      .in_buffer = in_buffer,
      .in_buffer_length = in_buffer_length,
      .out_buffer = out_buffer,
      .out_buffer_length = out_buffer_length,
  };
  return necp_session_action(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int necp_session_open_wrapper(
    int flags, int* retval) {
  struct necp_session_open_args uap = {
      .flags = flags,
  };
  return necp_session_open(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int peeloff_wrapper(int s,
                                                           sae_associd_t aid,
                                                           int* retval) {
  struct peeloff_args uap = {
      .s = s,
      .aid = aid,
  };
  return peeloff(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int pipe_wrapper(int* retval) {
  struct pipe_args uap = {};
  return pipe(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int recvfrom_wrapper(
    int s, void* buf, size_t len, int flags, struct sockaddr* from,
    int* fromlenaddr, int* retval) {
  struct recvfrom_args uap = {
      .s = s,
      .buf = buf,
      .len = len,
      .flags = flags,
      .from = from,
      .fromlenaddr = fromlenaddr,
  };
  return recvfrom(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int recvfrom_nocancel_wrapper(
    int s, void* buf, size_t len, int flags, struct sockaddr* from,
    int* fromlenaddr, int* retval) {
  struct recvfrom_nocancel_args uap = {
      .s = s,
      .buf = buf,
      .len = len,
      .flags = flags,
      .from = from,
      .fromlenaddr = fromlenaddr,
  };
  return recvfrom_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int recvmsg_wrapper(int s,
                                                           struct msghdr* msg,
                                                           int flags,
                                                           int* retval) {
  struct recvmsg_args uap = {
      .s = s,
      .msg = msg,
      .flags = flags,
  };
  return recvmsg(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int recvmsg_nocancel_wrapper(
    int s, struct msghdr* msg, int flags, int* retval) {
  struct recvmsg_nocancel_args uap = {
      .s = s,
      .msg = msg,
      .flags = flags,
  };
  return recvmsg_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int recvmsg_x_wrapper(
    int s, struct msghdr_x* msgp, u_int cnt, int flags, user_ssize_t* retval) {
  struct recvmsg_x_args uap = {
      .s = s,
      .msgp = msgp,
      .cnt = cnt,
      .flags = flags,
  };
  return recvmsg_x(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int sendmsg_wrapper(int s, caddr_t msg,
                                                           int flags,
                                                           int* retval) {
  struct sendmsg_args uap = {
      .s = s,
      .msg = msg,
      .flags = flags,
  };
  return sendmsg(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int sendmsg_nocancel_wrapper(
    int s, caddr_t msg, int flags, int* retval) {
  struct sendmsg_nocancel_args uap = {
      .s = s,
      .msg = msg,
      .flags = flags,
  };
  return sendmsg_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int sendmsg_x_wrapper(
    int s, struct msghdr_x* msgp, u_int cnt, int flags, user_ssize_t* retval) {
  struct sendmsg_x_args uap = {
      .s = s,
      .msgp = msgp,
      .cnt = cnt,
      .flags = flags,
  };
  return sendmsg_x(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int sendto_wrapper(int s, caddr_t buf,
                                                          size_t len, int flags,
                                                          caddr_t to,
                                                          socklen_t tolen,
                                                          int* retval) {
  struct sendto_args uap = {
      .s = s,
      .buf = buf,
      .len = len,
      .flags = flags,
      .to = to,
      .tolen = tolen,
  };
  return sendto(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int sendto_nocancel_wrapper(
    int s, caddr_t buf, size_t len, int flags, caddr_t to, socklen_t tolen,
    int* retval) {
  struct sendto_nocancel_args uap = {
      .s = s,
      .buf = buf,
      .len = len,
      .flags = flags,
      .to = to,
      .tolen = tolen,
  };
  return sendto_nocancel(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int setsockopt_wrapper(
    int s, int level, int name, caddr_t val, socklen_t valsize, int* retval) {
  struct setsockopt_args uap = {
      .s = s,
      .level = level,
      .name = name,
      .val = val,
      .valsize = valsize,
  };
  return setsockopt(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int shutdown_wrapper(int s, int how,
                                                            int* retval) {
  struct shutdown_args uap = {
      .s = s,
      .how = how,
  };
  return shutdown(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int socket_wrapper(int domain, int type,
                                                          int protocol,
                                                          int* retval) {
  struct socket_args uap = {
      .domain = domain,
      .type = type,
      .protocol = protocol,
  };
  return socket(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int socket_delegate_wrapper(
    int domain, int type, int protocol, pid_t epid, int* retval) {
  struct socket_delegate_args uap = {
      .domain = domain,
      .type = type,
      .protocol = protocol,
      .epid = epid,
  };
  return socket_delegate(kernproc, &uap, retval);
}

__attribute__((visibility("default"))) int socketpair_wrapper(
    int domain, int type, int protocol, int* rsv, int* retval) {
  struct socketpair_args uap = {
      .domain = domain,
      .type = type,
      .protocol = protocol,
      .rsv = rsv,
  };
  return socketpair(kernproc, &uap, retval);
}

#pragma clang diagnostic pop

Coverage Report

Created: 2026-04-09 06:21

Line	Count	Source
1		/*
2		* Copyright 2021 Google LLC
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		#include "fuzz/api/syscall_wrappers.h"
30
31		#pragma clang diagnostic push
32		#pragma clang diagnostic ignored "-Wint-conversion"
33
34		__attribute__((visibility("default"))) int accept_wrapper(int s, caddr_t name,
35		socklen_t* anamelen,
36	149k	int* retval) {
37	149k	struct accept_args uap = {
38	149k	.s = s,
39	149k	.name = name,
40	149k	.anamelen = anamelen,
41	149k	};
42	149k	return accept(kernproc, &uap, retval);
43	149k	}
44
45		__attribute__((visibility("default"))) int accept_nocancel_wrapper(
46	88.8k	int s, caddr_t name, socklen_t* anamelen, int* retval) {
47	88.8k	struct accept_nocancel_args uap = {
48	88.8k	.s = s,
49	88.8k	.name = name,
50	88.8k	.anamelen = anamelen,
51	88.8k	};
52	88.8k	return accept_nocancel(kernproc, &uap, retval);
53	88.8k	}
54
55		__attribute__((visibility("default"))) int bind_wrapper(int s, caddr_t name,
56		socklen_t namelen,
57	82.1k	int* retval) {
58	82.1k	struct bind_args uap = {
59	82.1k	.s = s,
60	82.1k	.name = name,
61	82.1k	.namelen = namelen,
62	82.1k	};
63	82.1k	return bind(kernproc, &uap, retval);
64	82.1k	}
65
66	143k	__attribute__((visibility("default"))) int close_wrapper(int fd, int* retval) {
67	143k	struct close_args uap = {
68	143k	.fd = fd,
69	143k	};
70	143k	return sys_close(kernproc, &uap, retval);
71	143k	}
72
73		__attribute__((visibility("default"))) int connect_wrapper(int s, caddr_t name,
74		socklen_t namelen,
75	84.7k	int* retval) {
76	84.7k	struct connect_args uap = {
77	84.7k	.s = s,
78	84.7k	.name = name,
79	84.7k	.namelen = namelen,
80	84.7k	};
81	84.7k	return connect(kernproc, &uap, retval);
82	84.7k	}
83
84		__attribute__((visibility("default"))) int connect_nocancel_wrapper(
85	110k	int s, caddr_t name, socklen_t namelen, int* retval) {
86	110k	struct connect_nocancel_args uap = {
87	110k	.s = s,
88	110k	.name = name,
89	110k	.namelen = namelen,
90	110k	};
91	110k	return connect_nocancel(kernproc, &uap, retval);
92	110k	}
93
94		__attribute__((visibility("default"))) int connectx_wrapper(
95		int socket, const sa_endpoints_t* endpoints, sae_associd_t associd,
96		unsigned int flags, const struct iovec* iov, unsigned int iovcnt,
97	290k	size_t* len, sae_connid_t* connid, int* retval) {
98	290k	struct connectx_args uap = {
99	290k	.socket = socket,
100	290k	.endpoints = endpoints,
101	290k	.associd = associd,
102	290k	.flags = flags,
103	290k	.iov = iov,
104	290k	.iovcnt = iovcnt,
105	290k	.len = len,
106	290k	.connid = connid,
107	290k	};
108	290k	return connectx(kernproc, &uap, retval);
109	290k	}
110
111		__attribute__((visibility("default"))) int disconnectx_wrapper(
112	62.8k	int s, sae_associd_t aid, sae_connid_t cid, int* retval) {
113	62.8k	struct disconnectx_args uap = {
114	62.8k	.s = s,
115	62.8k	.aid = aid,
116	62.8k	.cid = cid,
117	62.8k	};
118	62.8k	return disconnectx(kernproc, &uap, retval);
119	62.8k	}
120
121		__attribute__((visibility("default"))) int getpeername_wrapper(int fdes,
122		caddr_t asa,
123		socklen_t* alen,
124	100k	int* retval) {
125	100k	struct getpeername_args uap = {
126	100k	.fdes = fdes,
127	100k	.asa = asa,
128	100k	.alen = alen,
129	100k	};
130	100k	return getpeername(kernproc, &uap, retval);
131	100k	}
132
133		__attribute__((visibility("default"))) int getsockname_wrapper(int fdes,
134		caddr_t asa,
135		socklen_t* alen,
136	77.1k	int* retval) {
137	77.1k	struct getsockname_args uap = {
138	77.1k	.fdes = fdes,
139	77.1k	.asa = asa,
140	77.1k	.alen = alen,
141	77.1k	};
142	77.1k	return getsockname(kernproc, &uap, retval);
143	77.1k	}
144
145		__attribute__((visibility("default"))) int getsockopt_wrapper(
146	318k	int s, int level, int name, caddr_t val, socklen_t* avalsize, int* retval) {
147	318k	struct getsockopt_args uap = {
148	318k	.s = s,
149	318k	.level = level,
150	318k	.name = name,
151	318k	.val = val,
152	318k	.avalsize = avalsize,
153	318k	};
154	318k	return getsockopt(kernproc, &uap, retval);
155	318k	}
156
157		__attribute__((visibility("default"))) int ioctl_wrapper(int fd, u_long com,
158		caddr_t data,
159	655k	int* retval) {
160	655k	struct ioctl_args uap = {
161	655k	.fd = fd,
162	655k	.com = com,
163	655k	.data = data,
164	655k	};
165	655k	return ioctl(kernproc, &uap, retval);
166	655k	}
167
168		__attribute__((visibility("default"))) int listen_wrapper(int s, int backlog,
169	99.5k	int* retval) {
170	99.5k	struct listen_args uap = {
171	99.5k	.s = s,
172	99.5k	.backlog = backlog,
173	99.5k	};
174	99.5k	return listen(kernproc, &uap, retval);
175	99.5k	}
176
177		__attribute__((visibility("default"))) int necp_client_action_wrapper(
178		int necp_fd, uint32_t action, uuid_t client_id, size_t client_id_len,
179	0	uint8_t* buffer, size_t buffer_size, int* retval) {
180	0	struct necp_client_action_args uap = {
181	0	.necp_fd = necp_fd,
182	0	.action = action,
183	0	.client_id = client_id,
184	0	.client_id_len = client_id_len,
185	0	.buffer = buffer,
186	0	.buffer_size = buffer_size,
187	0	};
188	0	return necp_client_action(kernproc, &uap, retval);
189	0	}
190
191		__attribute__((visibility("default"))) int necp_match_policy_wrapper(
192		uint8_t* parameters, size_t parameters_size,
193	0	struct necp_aggregate_result* returned_result, int* retval) {
194	0	struct necp_match_policy_args uap = {
195	0	.parameters = parameters,
196	0	.parameters_size = parameters_size,
197	0	.returned_result = returned_result,
198	0	};
199	0	return necp_match_policy(kernproc, &uap, retval);
200	0	}
201
202		__attribute__((visibility("default"))) int necp_open_wrapper(int flags,
203	0	int* retval) {
204	0	struct necp_open_args uap = {
205	0	.flags = flags,
206	0	};
207	0	return necp_open(kernproc, &uap, retval);
208	0	}
209
210		__attribute__((visibility("default"))) int necp_session_action_wrapper(
211		int necp_fd, uint32_t action, uint8_t* in_buffer, size_t in_buffer_length,
212	0	uint8_t* out_buffer, size_t out_buffer_length, int* retval) {
213	0	struct necp_session_action_args uap = {
214	0	.necp_fd = necp_fd,
215	0	.action = action,
216	0	.in_buffer = in_buffer,
217	0	.in_buffer_length = in_buffer_length,
218	0	.out_buffer = out_buffer,
219	0	.out_buffer_length = out_buffer_length,
220	0	};
221	0	return necp_session_action(kernproc, &uap, retval);
222	0	}
223
224		__attribute__((visibility("default"))) int necp_session_open_wrapper(
225	0	int flags, int* retval) {
226	0	struct necp_session_open_args uap = {
227	0	.flags = flags,
228	0	};
229	0	return necp_session_open(kernproc, &uap, retval);
230	0	}
231
232		__attribute__((visibility("default"))) int peeloff_wrapper(int s,
233		sae_associd_t aid,
234	92.8k	int* retval) {
235	92.8k	struct peeloff_args uap = {
236	92.8k	.s = s,
237	92.8k	.aid = aid,
238	92.8k	};
239	92.8k	return peeloff(kernproc, &uap, retval);
240	92.8k	}
241
242	167k	__attribute__((visibility("default"))) int pipe_wrapper(int* retval) {
243	167k	struct pipe_args uap = {};
244	167k	return pipe(kernproc, &uap, retval);
245	167k	}
246
247		__attribute__((visibility("default"))) int recvfrom_wrapper(
248		int s, void* buf, size_t len, int flags, struct sockaddr* from,
249	66.9k	int* fromlenaddr, int* retval) {
250	66.9k	struct recvfrom_args uap = {
251	66.9k	.s = s,
252	66.9k	.buf = buf,
253	66.9k	.len = len,
254	66.9k	.flags = flags,
255	66.9k	.from = from,
256	66.9k	.fromlenaddr = fromlenaddr,
257	66.9k	};
258	66.9k	return recvfrom(kernproc, &uap, retval);
259	66.9k	}
260
261		__attribute__((visibility("default"))) int recvfrom_nocancel_wrapper(
262		int s, void* buf, size_t len, int flags, struct sockaddr* from,
263	66.9k	int* fromlenaddr, int* retval) {
264	66.9k	struct recvfrom_nocancel_args uap = {
265	66.9k	.s = s,
266	66.9k	.buf = buf,
267	66.9k	.len = len,
268	66.9k	.flags = flags,
269	66.9k	.from = from,
270	66.9k	.fromlenaddr = fromlenaddr,
271	66.9k	};
272	66.9k	return recvfrom_nocancel(kernproc, &uap, retval);
273	66.9k	}
274
275		__attribute__((visibility("default"))) int recvmsg_wrapper(int s,
276		struct msghdr* msg,
277		int flags,
278	86.9k	int* retval) {
279	86.9k	struct recvmsg_args uap = {
280	86.9k	.s = s,
281	86.9k	.msg = msg,
282	86.9k	.flags = flags,
283	86.9k	};
284	86.9k	return recvmsg(kernproc, &uap, retval);
285	86.9k	}
286
287		__attribute__((visibility("default"))) int recvmsg_nocancel_wrapper(
288	0	int s, struct msghdr* msg, int flags, int* retval) {
289	0	struct recvmsg_nocancel_args uap = {
290	0	.s = s,
291	0	.msg = msg,
292	0	.flags = flags,
293	0	};
294	0	return recvmsg_nocancel(kernproc, &uap, retval);
295	0	}
296
297		__attribute__((visibility("default"))) int recvmsg_x_wrapper(
298	0	int s, struct msghdr_x* msgp, u_int cnt, int flags, user_ssize_t* retval) {
299	0	struct recvmsg_x_args uap = {
300	0	.s = s,
301	0	.msgp = msgp,
302	0	.cnt = cnt,
303	0	.flags = flags,
304	0	};
305	0	return recvmsg_x(kernproc, &uap, retval);
306	0	}
307
308		__attribute__((visibility("default"))) int sendmsg_wrapper(int s, caddr_t msg,
309		int flags,
310	0	int* retval) {
311	0	struct sendmsg_args uap = {
312	0	.s = s,
313	0	.msg = msg,
314	0	.flags = flags,
315	0	};
316	0	return sendmsg(kernproc, &uap, retval);
317	0	}
318
319		__attribute__((visibility("default"))) int sendmsg_nocancel_wrapper(
320	0	int s, caddr_t msg, int flags, int* retval) {
321	0	struct sendmsg_nocancel_args uap = {
322	0	.s = s,
323	0	.msg = msg,
324	0	.flags = flags,
325	0	};
326	0	return sendmsg_nocancel(kernproc, &uap, retval);
327	0	}
328
329		__attribute__((visibility("default"))) int sendmsg_x_wrapper(
330	0	int s, struct msghdr_x* msgp, u_int cnt, int flags, user_ssize_t* retval) {
331	0	struct sendmsg_x_args uap = {
332	0	.s = s,
333	0	.msgp = msgp,
334	0	.cnt = cnt,
335	0	.flags = flags,
336	0	};
337	0	return sendmsg_x(kernproc, &uap, retval);
338	0	}
339
340		__attribute__((visibility("default"))) int sendto_wrapper(int s, caddr_t buf,
341		size_t len, int flags,
342		caddr_t to,
343		socklen_t tolen,
344	154k	int* retval) {
345	154k	struct sendto_args uap = {
346	154k	.s = s,
347	154k	.buf = buf,
348	154k	.len = len,
349	154k	.flags = flags,
350	154k	.to = to,
351	154k	.tolen = tolen,
352	154k	};
353	154k	return sendto(kernproc, &uap, retval);
354	154k	}
355
356		__attribute__((visibility("default"))) int sendto_nocancel_wrapper(
357		int s, caddr_t buf, size_t len, int flags, caddr_t to, socklen_t tolen,
358	0	int* retval) {
359	0	struct sendto_nocancel_args uap = {
360	0	.s = s,
361	0	.buf = buf,
362	0	.len = len,
363	0	.flags = flags,
364	0	.to = to,
365	0	.tolen = tolen,
366	0	};
367	0	return sendto_nocancel(kernproc, &uap, retval);
368	0	}
369
370		__attribute__((visibility("default"))) int setsockopt_wrapper(
371	150k	int s, int level, int name, caddr_t val, socklen_t valsize, int* retval) {
372	150k	struct setsockopt_args uap = {
373	150k	.s = s,
374	150k	.level = level,
375	150k	.name = name,
376	150k	.val = val,
377	150k	.valsize = valsize,
378	150k	};
379	150k	return setsockopt(kernproc, &uap, retval);
380	150k	}
381
382		__attribute__((visibility("default"))) int shutdown_wrapper(int s, int how,
383	113k	int* retval) {
384	113k	struct shutdown_args uap = {
385	113k	.s = s,
386	113k	.how = how,
387	113k	};
388	113k	return shutdown(kernproc, &uap, retval);
389	113k	}
390
391		__attribute__((visibility("default"))) int socket_wrapper(int domain, int type,
392		int protocol,
393	69.1k	int* retval) {
394	69.1k	struct socket_args uap = {
395	69.1k	.domain = domain,
396	69.1k	.type = type,
397	69.1k	.protocol = protocol,
398	69.1k	};
399	69.1k	return socket(kernproc, &uap, retval);
400	69.1k	}
401
402		__attribute__((visibility("default"))) int socket_delegate_wrapper(
403	0	int domain, int type, int protocol, pid_t epid, int* retval) {
404	0	struct socket_delegate_args uap = {
405	0	.domain = domain,
406	0	.type = type,
407	0	.protocol = protocol,
408	0	.epid = epid,
409	0	};
410	0	return socket_delegate(kernproc, &uap, retval);
411	0	}
412
413		__attribute__((visibility("default"))) int socketpair_wrapper(
414	1.68M	int domain, int type, int protocol, int* rsv, int* retval) {
415	1.68M	struct socketpair_args uap = {
416	1.68M	.domain = domain,
417	1.68M	.type = type,
418	1.68M	.protocol = protocol,
419	1.68M	.rsv = rsv,
420	1.68M	};
421	1.68M	return socketpair(kernproc, &uap, retval);
422	1.68M	}
423
424		#pragma clang diagnostic pop