/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-07-10 06:42

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	148k	int* retval) {
37	148k	struct accept_args uap = {
38	148k	.s = s,
39	148k	.name = name,
40	148k	.anamelen = anamelen,
41	148k	};
42	148k	return accept(kernproc, &uap, retval);
43	148k	}
44
45		__attribute__((visibility("default"))) int accept_nocancel_wrapper(
46	96.6k	int s, caddr_t name, socklen_t* anamelen, int* retval) {
47	96.6k	struct accept_nocancel_args uap = {
48	96.6k	.s = s,
49	96.6k	.name = name,
50	96.6k	.anamelen = anamelen,
51	96.6k	};
52	96.6k	return accept_nocancel(kernproc, &uap, retval);
53	96.6k	}
54
55		__attribute__((visibility("default"))) int bind_wrapper(int s, caddr_t name,
56		socklen_t namelen,
57	90.8k	int* retval) {
58	90.8k	struct bind_args uap = {
59	90.8k	.s = s,
60	90.8k	.name = name,
61	90.8k	.namelen = namelen,
62	90.8k	};
63	90.8k	return bind(kernproc, &uap, retval);
64	90.8k	}
65
66	148k	__attribute__((visibility("default"))) int close_wrapper(int fd, int* retval) {
67	148k	struct close_args uap = {
68	148k	.fd = fd,
69	148k	};
70	148k	return sys_close(kernproc, &uap, retval);
71	148k	}
72
73		__attribute__((visibility("default"))) int connect_wrapper(int s, caddr_t name,
74		socklen_t namelen,
75	92.6k	int* retval) {
76	92.6k	struct connect_args uap = {
77	92.6k	.s = s,
78	92.6k	.name = name,
79	92.6k	.namelen = namelen,
80	92.6k	};
81	92.6k	return connect(kernproc, &uap, retval);
82	92.6k	}
83
84		__attribute__((visibility("default"))) int connect_nocancel_wrapper(
85	115k	int s, caddr_t name, socklen_t namelen, int* retval) {
86	115k	struct connect_nocancel_args uap = {
87	115k	.s = s,
88	115k	.name = name,
89	115k	.namelen = namelen,
90	115k	};
91	115k	return connect_nocancel(kernproc, &uap, retval);
92	115k	}
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	285k	size_t* len, sae_connid_t* connid, int* retval) {
98	285k	struct connectx_args uap = {
99	285k	.socket = socket,
100	285k	.endpoints = endpoints,
101	285k	.associd = associd,
102	285k	.flags = flags,
103	285k	.iov = iov,
104	285k	.iovcnt = iovcnt,
105	285k	.len = len,
106	285k	.connid = connid,
107	285k	};
108	285k	return connectx(kernproc, &uap, retval);
109	285k	}
110
111		__attribute__((visibility("default"))) int disconnectx_wrapper(
112	70.2k	int s, sae_associd_t aid, sae_connid_t cid, int* retval) {
113	70.2k	struct disconnectx_args uap = {
114	70.2k	.s = s,
115	70.2k	.aid = aid,
116	70.2k	.cid = cid,
117	70.2k	};
118	70.2k	return disconnectx(kernproc, &uap, retval);
119	70.2k	}
120
121		__attribute__((visibility("default"))) int getpeername_wrapper(int fdes,
122		caddr_t asa,
123		socklen_t* alen,
124	102k	int* retval) {
125	102k	struct getpeername_args uap = {
126	102k	.fdes = fdes,
127	102k	.asa = asa,
128	102k	.alen = alen,
129	102k	};
130	102k	return getpeername(kernproc, &uap, retval);
131	102k	}
132
133		__attribute__((visibility("default"))) int getsockname_wrapper(int fdes,
134		caddr_t asa,
135		socklen_t* alen,
136	79.6k	int* retval) {
137	79.6k	struct getsockname_args uap = {
138	79.6k	.fdes = fdes,
139	79.6k	.asa = asa,
140	79.6k	.alen = alen,
141	79.6k	};
142	79.6k	return getsockname(kernproc, &uap, retval);
143	79.6k	}
144
145		__attribute__((visibility("default"))) int getsockopt_wrapper(
146	301k	int s, int level, int name, caddr_t val, socklen_t* avalsize, int* retval) {
147	301k	struct getsockopt_args uap = {
148	301k	.s = s,
149	301k	.level = level,
150	301k	.name = name,
151	301k	.val = val,
152	301k	.avalsize = avalsize,
153	301k	};
154	301k	return getsockopt(kernproc, &uap, retval);
155	301k	}
156
157		__attribute__((visibility("default"))) int ioctl_wrapper(int fd, u_long com,
158		caddr_t data,
159	642k	int* retval) {
160	642k	struct ioctl_args uap = {
161	642k	.fd = fd,
162	642k	.com = com,
163	642k	.data = data,
164	642k	};
165	642k	return ioctl(kernproc, &uap, retval);
166	642k	}
167
168		__attribute__((visibility("default"))) int listen_wrapper(int s, int backlog,
169	102k	int* retval) {
170	102k	struct listen_args uap = {
171	102k	.s = s,
172	102k	.backlog = backlog,
173	102k	};
174	102k	return listen(kernproc, &uap, retval);
175	102k	}
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	173k	__attribute__((visibility("default"))) int pipe_wrapper(int* retval) {
243	173k	struct pipe_args uap = {};
244	173k	return pipe(kernproc, &uap, retval);
245	173k	}
246
247		__attribute__((visibility("default"))) int recvfrom_wrapper(
248		int s, void* buf, size_t len, int flags, struct sockaddr* from,
249	72.3k	int* fromlenaddr, int* retval) {
250	72.3k	struct recvfrom_args uap = {
251	72.3k	.s = s,
252	72.3k	.buf = buf,
253	72.3k	.len = len,
254	72.3k	.flags = flags,
255	72.3k	.from = from,
256	72.3k	.fromlenaddr = fromlenaddr,
257	72.3k	};
258	72.3k	return recvfrom(kernproc, &uap, retval);
259	72.3k	}
260
261		__attribute__((visibility("default"))) int recvfrom_nocancel_wrapper(
262		int s, void* buf, size_t len, int flags, struct sockaddr* from,
263	80.5k	int* fromlenaddr, int* retval) {
264	80.5k	struct recvfrom_nocancel_args uap = {
265	80.5k	.s = s,
266	80.5k	.buf = buf,
267	80.5k	.len = len,
268	80.5k	.flags = flags,
269	80.5k	.from = from,
270	80.5k	.fromlenaddr = fromlenaddr,
271	80.5k	};
272	80.5k	return recvfrom_nocancel(kernproc, &uap, retval);
273	80.5k	}
274
275		__attribute__((visibility("default"))) int recvmsg_wrapper(int s,
276		struct msghdr* msg,
277		int flags,
278	92.7k	int* retval) {
279	92.7k	struct recvmsg_args uap = {
280	92.7k	.s = s,
281	92.7k	.msg = msg,
282	92.7k	.flags = flags,
283	92.7k	};
284	92.7k	return recvmsg(kernproc, &uap, retval);
285	92.7k	}
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	156k	int* retval) {
345	156k	struct sendto_args uap = {
346	156k	.s = s,
347	156k	.buf = buf,
348	156k	.len = len,
349	156k	.flags = flags,
350	156k	.to = to,
351	156k	.tolen = tolen,
352	156k	};
353	156k	return sendto(kernproc, &uap, retval);
354	156k	}
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	159k	int s, int level, int name, caddr_t val, socklen_t valsize, int* retval) {
372	159k	struct setsockopt_args uap = {
373	159k	.s = s,
374	159k	.level = level,
375	159k	.name = name,
376	159k	.val = val,
377	159k	.valsize = valsize,
378	159k	};
379	159k	return setsockopt(kernproc, &uap, retval);
380	159k	}
381
382		__attribute__((visibility("default"))) int shutdown_wrapper(int s, int how,
383	122k	int* retval) {
384	122k	struct shutdown_args uap = {
385	122k	.s = s,
386	122k	.how = how,
387	122k	};
388	122k	return shutdown(kernproc, &uap, retval);
389	122k	}
390
391		__attribute__((visibility("default"))) int socket_wrapper(int domain, int type,
392		int protocol,
393	82.9k	int* retval) {
394	82.9k	struct socket_args uap = {
395	82.9k	.domain = domain,
396	82.9k	.type = type,
397	82.9k	.protocol = protocol,
398	82.9k	};
399	82.9k	return socket(kernproc, &uap, retval);
400	82.9k	}
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.72M	int domain, int type, int protocol, int* rsv, int* retval) {
415	1.72M	struct socketpair_args uap = {
416	1.72M	.domain = domain,
417	1.72M	.type = type,
418	1.72M	.protocol = protocol,
419	1.72M	.rsv = rsv,
420	1.72M	};
421	1.72M	return socketpair(kernproc, &uap, retval);
422	1.72M	}
423
424		#pragma clang diagnostic pop