1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "nacl_io/kernel_intercept.h"
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <string.h>
10
11 #include "nacl_io/kernel_proxy.h"
12 #include "nacl_io/kernel_wrap.h"
13 #include "nacl_io/kernel_wrap_real.h"
14 #include "nacl_io/log.h"
15 #include "nacl_io/osmman.h"
16 #include "nacl_io/ossocket.h"
17 #include "nacl_io/ostime.h"
18 #include "nacl_io/pepper_interface.h"
19 #include "nacl_io/real_pepper_interface.h"
20
21 using namespace nacl_io;
22
23 #define ON_NOSYS_RETURN(x) \
24 if (!ki_is_initialized()) { \
25 errno = ENOSYS; \
26 return x; \
27 }
28
29 #define TRACE_KP_CALLS 0
30
31 #if TRACE_KP_CALLS
32 #define KP_TRACE nacl_io_log
33 #else
34 #define KP_TRACE(...)
35 #endif
36
37 #define KP_CALL(METHOD, ARGS) \
38 ON_NOSYS_RETURN(-1); \
39 int rtn = s_state.kp-> METHOD ARGS; \
40 KP_TRACE("ki_" #METHOD " -> %d\n", rtn); \
41 return rtn;
42
43 struct KernelInterceptState {
44 KernelProxy* kp;
45 PepperInterface* ppapi;
46 bool kp_owned;
47 };
48
49 static KernelInterceptState s_state;
50
51 // The the test code we want to be able to save the previous kernel
52 // proxy when intialising and restore it on uninit.
53 static KernelInterceptState s_saved_state;
54
ki_push_state_for_testing()55 int ki_push_state_for_testing() {
56 assert(s_saved_state.kp == NULL);
57 if (s_saved_state.kp != NULL)
58 return 1;
59 s_saved_state = s_state;
60 s_state.kp = NULL;
61 s_state.ppapi = NULL;
62 s_state.kp_owned = false;
63 return 0;
64 }
65
ki_pop_state()66 static void ki_pop_state() {
67 // Swap out the KernelProxy. This will normally reset the
68 // proxy to NULL, aside from in test code that has called
69 // ki_push_state_for_testing().
70 s_state = s_saved_state;
71 s_saved_state.kp = NULL;
72 s_saved_state.ppapi = NULL;
73 s_saved_state.kp_owned = false;
74 }
75
ki_pop_state_for_testing()76 int ki_pop_state_for_testing() {
77 ki_pop_state();
78 return 0;
79 }
80
ki_init(void * kp)81 int ki_init(void* kp) {
82 LOG_TRACE("ki_init: %p", kp);
83 return ki_init_ppapi(kp, 0, NULL);
84 }
85
ki_init_ppapi(void * kp,PP_Instance instance,PPB_GetInterface get_browser_interface)86 int ki_init_ppapi(void* kp,
87 PP_Instance instance,
88 PPB_GetInterface get_browser_interface) {
89 assert(!s_state.kp);
90 if (s_state.kp != NULL)
91 return 1;
92 PepperInterface* ppapi = NULL;
93 if (instance && get_browser_interface) {
94 ppapi = new RealPepperInterface(instance, get_browser_interface);
95 s_state.ppapi = ppapi;
96 }
97 int rtn = ki_init_interface(kp, ppapi);
98 return rtn;
99 }
100
ki_init_interface(void * kp,void * pepper_interface)101 int ki_init_interface(void* kp, void* pepper_interface) {
102 LOG_TRACE("ki_init_interface: %p %p", kp, pepper_interface);
103 assert(!s_state.kp);
104 if (s_state.kp != NULL)
105 return 1;
106 PepperInterface* ppapi = static_cast<PepperInterface*>(pepper_interface);
107 kernel_wrap_init();
108
109 if (kp == NULL) {
110 s_state.kp = new KernelProxy();
111 s_state.kp_owned = true;
112 } else {
113 s_state.kp = static_cast<KernelProxy*>(kp);
114 s_state.kp_owned = false;
115 }
116
117 if (s_state.kp->Init(ppapi) != 0)
118 return 1;
119
120 return 0;
121 }
122
ki_is_initialized()123 int ki_is_initialized() {
124 return s_state.kp != NULL;
125 }
126
ki_uninit()127 int ki_uninit() {
128 LOG_TRACE("ki_uninit");
129 assert(s_state.kp);
130 if (s_state.kp == NULL)
131 return 1;
132
133 if (s_saved_state.kp == NULL)
134 kernel_wrap_uninit();
135
136 // If we are going to delete the KernelProxy don't do it
137 // until we've swapped it out.
138 KernelInterceptState state_to_delete = s_state;
139
140 ki_pop_state();
141
142 if (state_to_delete.kp_owned)
143 delete state_to_delete.kp;
144
145 delete state_to_delete.ppapi;
146 return 0;
147 }
148
ki_get_proxy()149 nacl_io::KernelProxy* ki_get_proxy() {
150 return s_state.kp;
151 }
152
ki_exit(int status)153 void ki_exit(int status) {
154 KP_TRACE("ki_exit\n");
155 if (ki_is_initialized())
156 s_state.kp->exit(status);
157
158 _real_exit(status);
159 }
160
ki_getcwd(char * buf,size_t size)161 char* ki_getcwd(char* buf, size_t size) {
162 ON_NOSYS_RETURN(NULL);
163 KP_TRACE("ki_getcwd\n");
164 return s_state.kp->getcwd(buf, size);
165 }
166
ki_getwd(char * buf)167 char* ki_getwd(char* buf) {
168 ON_NOSYS_RETURN(NULL);
169 KP_TRACE("ki_getwd\n");
170 return s_state.kp->getwd(buf);
171 }
172
ki_chdir(const char * path)173 int ki_chdir(const char* path) {
174 KP_CALL(chdir, (path));
175 }
176
ki_dup(int oldfd)177 int ki_dup(int oldfd) {
178 KP_CALL(dup, (oldfd));
179 }
180
ki_dup2(int oldfd,int newfd)181 int ki_dup2(int oldfd, int newfd) {
182 KP_CALL(dup2, (oldfd, newfd));
183 }
184
ki_chmod(const char * path,mode_t mode)185 int ki_chmod(const char* path, mode_t mode) {
186 KP_CALL(chmod, (path, mode));
187 }
188
ki_fchdir(int fd)189 int ki_fchdir(int fd) {
190 KP_CALL(fchdir, (fd));
191 }
192
ki_fchmod(int fd,mode_t mode)193 int ki_fchmod(int fd, mode_t mode) {
194 KP_CALL(fchmod, (fd, mode));
195 }
196
ki_stat(const char * path,struct stat * buf)197 int ki_stat(const char* path, struct stat* buf) {
198 KP_CALL(stat, (path, buf));
199 }
200
ki_mkdir(const char * path,mode_t mode)201 int ki_mkdir(const char* path, mode_t mode) {
202 KP_CALL(mkdir, (path, mode));
203 }
204
ki_rmdir(const char * path)205 int ki_rmdir(const char* path) {
206 KP_CALL(rmdir, (path));
207 }
208
ki_mount(const char * source,const char * target,const char * filesystemtype,unsigned long mountflags,const void * data)209 int ki_mount(const char* source,
210 const char* target,
211 const char* filesystemtype,
212 unsigned long mountflags,
213 const void* data) {
214 KP_CALL(mount, (source, target, filesystemtype, mountflags, data));
215 }
216
ki_umount(const char * path)217 int ki_umount(const char* path) {
218 KP_CALL(umount, (path));
219 }
220
ki_open(const char * path,int oflag,mode_t mode)221 int ki_open(const char* path, int oflag, mode_t mode) {
222 KP_CALL(open, (path, oflag, mode));
223 }
224
ki_pipe(int pipefds[2])225 int ki_pipe(int pipefds[2]) {
226 KP_CALL(pipe, (pipefds));
227 }
228
ki_read(int fd,void * buf,size_t nbyte)229 ssize_t ki_read(int fd, void* buf, size_t nbyte) {
230 ON_NOSYS_RETURN(-1);
231 KP_TRACE("ki_read\n");
232 return s_state.kp->read(fd, buf, nbyte);
233 }
234
ki_write(int fd,const void * buf,size_t nbyte)235 ssize_t ki_write(int fd, const void* buf, size_t nbyte) {
236 ON_NOSYS_RETURN(-1);
237 KP_TRACE("ki_write\n");
238 return s_state.kp->write(fd, buf, nbyte);
239 }
240
ki_fstat(int fd,struct stat * buf)241 int ki_fstat(int fd, struct stat* buf) {
242 KP_CALL(fstat, (fd, buf));
243 }
244
ki_getdents(int fd,struct dirent * buf,unsigned int count)245 int ki_getdents(int fd, struct dirent* buf, unsigned int count) {
246 KP_CALL(getdents, (fd, buf, count));
247 }
248
ki_ftruncate(int fd,off_t length)249 int ki_ftruncate(int fd, off_t length) {
250 KP_CALL(ftruncate, (fd, length));
251 }
252
ki_fsync(int fd)253 int ki_fsync(int fd) {
254 KP_CALL(fsync, (fd));
255 }
256
ki_fdatasync(int fd)257 int ki_fdatasync(int fd) {
258 KP_CALL(fdatasync, (fd));
259 }
260
ki_isatty(int fd)261 int ki_isatty(int fd) {
262 ON_NOSYS_RETURN(0);
263 KP_TRACE("ki_isatty\n");
264 return s_state.kp->isatty(fd);
265 }
266
ki_close(int fd)267 int ki_close(int fd) {
268 KP_CALL(close, (fd));
269 }
270
ki_lseek(int fd,off_t offset,int whence)271 off_t ki_lseek(int fd, off_t offset, int whence) {
272 ON_NOSYS_RETURN(-1);
273 KP_TRACE("ki_lseek\n");
274 return s_state.kp->lseek(fd, offset, whence);
275 }
276
ki_remove(const char * path)277 int ki_remove(const char* path) {
278 KP_CALL(remove, (path));
279 }
280
ki_unlink(const char * path)281 int ki_unlink(const char* path) {
282 KP_CALL(unlink, (path));
283 }
284
ki_truncate(const char * path,off_t length)285 int ki_truncate(const char* path, off_t length) {
286 KP_CALL(truncate, (path, length));
287 }
288
ki_lstat(const char * path,struct stat * buf)289 int ki_lstat(const char* path, struct stat* buf) {
290 KP_CALL(lstat, (path, buf));
291 }
292
ki_link(const char * oldpath,const char * newpath)293 int ki_link(const char* oldpath, const char* newpath) {
294 KP_CALL(link, (oldpath, newpath));
295 }
296
ki_rename(const char * path,const char * newpath)297 int ki_rename(const char* path, const char* newpath) {
298 KP_CALL(rename, (path, newpath));
299 }
300
ki_symlink(const char * oldpath,const char * newpath)301 int ki_symlink(const char* oldpath, const char* newpath) {
302 KP_CALL(symlink, (oldpath, newpath));
303 }
304
ki_access(const char * path,int amode)305 int ki_access(const char* path, int amode) {
306 KP_CALL(access, (path, amode));
307 }
308
ki_readlink(const char * path,char * buf,size_t count)309 int ki_readlink(const char* path, char* buf, size_t count) {
310 KP_CALL(readlink, (path, buf, count));
311 }
312
ki_utimes(const char * path,const struct timeval times[2])313 int ki_utimes(const char* path, const struct timeval times[2]) {
314 ON_NOSYS_RETURN(-1);
315 KP_TRACE("ki_utimes");
316 // Implement in terms of utimens.
317 if (!times) {
318 return s_state.kp->utimens(path, NULL);
319 }
320
321 struct timespec ts[2];
322 ts[0].tv_sec = times[0].tv_sec;
323 ts[0].tv_nsec = times[0].tv_usec * 1000;
324 ts[1].tv_sec = times[1].tv_sec;
325 ts[1].tv_nsec = times[1].tv_usec * 1000;
326 return s_state.kp->utimens(path, ts);
327 }
328
ki_futimes(int fd,const struct timeval times[2])329 int ki_futimes(int fd, const struct timeval times[2]) {
330 ON_NOSYS_RETURN(-1);
331 KP_TRACE("ki_futimes");
332 // Implement in terms of futimens.
333 if (!times) {
334 return s_state.kp->futimens(fd, NULL);
335 }
336
337 struct timespec ts[2];
338 ts[0].tv_sec = times[0].tv_sec;
339 ts[0].tv_nsec = times[0].tv_usec * 1000;
340 ts[1].tv_sec = times[1].tv_sec;
341 ts[1].tv_nsec = times[1].tv_usec * 1000;
342 return s_state.kp->futimens(fd, ts);
343 }
344
ki_mmap(void * addr,size_t length,int prot,int flags,int fd,off_t offset)345 void* ki_mmap(void* addr,
346 size_t length,
347 int prot,
348 int flags,
349 int fd,
350 off_t offset) {
351 ON_NOSYS_RETURN(MAP_FAILED);
352 KP_TRACE("ki_mmap\n");
353 return s_state.kp->mmap(addr, length, prot, flags, fd, offset);
354 }
355
ki_munmap(void * addr,size_t length)356 int ki_munmap(void* addr, size_t length) {
357 ON_NOSYS_RETURN(-1);
358 KP_TRACE("ki_munmap\n");
359 return s_state.kp->munmap(addr, length);
360 }
361
ki_open_resource(const char * file)362 int ki_open_resource(const char* file) {
363 ON_NOSYS_RETURN(-1);
364 KP_TRACE("ki_open_resource\n");
365 return s_state.kp->open_resource(file);
366 }
367
ki_fcntl(int d,int request,va_list args)368 int ki_fcntl(int d, int request, va_list args) {
369 KP_CALL(fcntl, (d, request, args));
370 }
371
ki_ioctl(int d,int request,va_list args)372 int ki_ioctl(int d, int request, va_list args) {
373 KP_CALL(ioctl, (d, request, args));
374 }
375
ki_chown(const char * path,uid_t owner,gid_t group)376 int ki_chown(const char* path, uid_t owner, gid_t group) {
377 KP_CALL(chown, (path, owner, group));
378 }
379
ki_fchown(int fd,uid_t owner,gid_t group)380 int ki_fchown(int fd, uid_t owner, gid_t group) {
381 KP_CALL(fchown, (fd, owner, group));
382 }
383
ki_lchown(const char * path,uid_t owner,gid_t group)384 int ki_lchown(const char* path, uid_t owner, gid_t group) {
385 KP_CALL(lchown, (path, owner, group));
386 }
387
ki_utime(const char * filename,const struct utimbuf * times)388 int ki_utime(const char* filename, const struct utimbuf* times) {
389 ON_NOSYS_RETURN(-1);
390 KP_TRACE("ki_utime\n");
391 // Implement in terms of utimens.
392 if (!times) {
393 return s_state.kp->utimens(filename, NULL);
394 }
395
396 struct timespec ts[2];
397 ts[0].tv_sec = times->actime;
398 ts[0].tv_nsec = 0;
399 ts[1].tv_sec = times->modtime;
400 ts[1].tv_nsec = 0;
401 return s_state.kp->utimens(filename, ts);
402 }
403
ki_futimens(int fd,const struct timespec times[2])404 int ki_futimens(int fd, const struct timespec times[2]) {
405 KP_CALL(futimens, (fd, times));
406 }
407
ki_umask(mode_t mask)408 mode_t ki_umask(mode_t mask) {
409 ON_NOSYS_RETURN(0);
410 KP_TRACE("ki_umask\n");
411 return s_state.kp->umask(mask);
412 }
413
ki_poll(struct pollfd * fds,nfds_t nfds,int timeout)414 int ki_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
415 KP_CALL(poll, (fds, nfds, timeout));
416 }
417
ki_select(int nfds,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout)418 int ki_select(int nfds,
419 fd_set* readfds,
420 fd_set* writefds,
421 fd_set* exceptfds,
422 struct timeval* timeout) {
423 KP_CALL(select, (nfds, readfds, writefds, exceptfds, timeout));
424 }
425
ki_tcflush(int fd,int queue_selector)426 int ki_tcflush(int fd, int queue_selector) {
427 KP_CALL(tcflush, (fd, queue_selector));
428 }
429
ki_tcgetattr(int fd,struct termios * termios_p)430 int ki_tcgetattr(int fd, struct termios* termios_p) {
431 KP_CALL(tcgetattr, (fd, termios_p));
432 }
433
ki_tcsetattr(int fd,int optional_actions,const struct termios * termios_p)434 int ki_tcsetattr(int fd,
435 int optional_actions,
436 const struct termios* termios_p) {
437 KP_CALL(tcsetattr, (fd, optional_actions, termios_p));
438 }
439
ki_kill(pid_t pid,int sig)440 int ki_kill(pid_t pid, int sig) {
441 KP_CALL(kill, (pid, sig));
442 }
443
ki_killpg(pid_t pid,int sig)444 int ki_killpg(pid_t pid, int sig) {
445 errno = ENOSYS;
446 return -1;
447 }
448
ki_sigaction(int signum,const struct sigaction * action,struct sigaction * oaction)449 int ki_sigaction(int signum,
450 const struct sigaction* action,
451 struct sigaction* oaction) {
452 KP_CALL(sigaction, (signum, action, oaction));
453 }
454
ki_sigpause(int sigmask)455 int ki_sigpause(int sigmask) {
456 errno = ENOSYS;
457 return -1;
458 }
459
ki_sigpending(sigset_t * set)460 int ki_sigpending(sigset_t* set) {
461 errno = ENOSYS;
462 return -1;
463 }
464
ki_sigsuspend(const sigset_t * set)465 int ki_sigsuspend(const sigset_t* set) {
466 errno = ENOSYS;
467 return -1;
468 }
469
ki_signal(int signum,sighandler_t handler)470 sighandler_t ki_signal(int signum, sighandler_t handler) {
471 return ki_sigset(signum, handler);
472 }
473
ki_sigset(int signum,sighandler_t handler)474 sighandler_t ki_sigset(int signum, sighandler_t handler) {
475 ON_NOSYS_RETURN(SIG_ERR);
476 KP_TRACE("ki_sigset\n");
477 // Implement sigset(2) in terms of sigaction(2).
478 struct sigaction action;
479 struct sigaction oaction;
480 memset(&action, 0, sizeof(action));
481 memset(&oaction, 0, sizeof(oaction));
482 action.sa_handler = handler;
483 int rtn = s_state.kp->sigaction(signum, &action, &oaction);
484 if (rtn)
485 return SIG_ERR;
486 return oaction.sa_handler;
487 }
488
489 #ifdef PROVIDES_SOCKET_API
490 // Socket Functions
ki_accept(int fd,struct sockaddr * addr,socklen_t * len)491 int ki_accept(int fd, struct sockaddr* addr, socklen_t* len) {
492 KP_CALL(accept, (fd, addr, len));
493 }
494
ki_bind(int fd,const struct sockaddr * addr,socklen_t len)495 int ki_bind(int fd, const struct sockaddr* addr, socklen_t len) {
496 KP_CALL(bind, (fd, addr, len));
497 }
498
ki_connect(int fd,const struct sockaddr * addr,socklen_t len)499 int ki_connect(int fd, const struct sockaddr* addr, socklen_t len) {
500 KP_CALL(connect, (fd, addr, len));
501 }
502
ki_gethostbyname(const char * name)503 struct hostent* ki_gethostbyname(const char* name) {
504 ON_NOSYS_RETURN(NULL);
505 return s_state.kp->gethostbyname(name);
506 }
507
ki_getnameinfo(const struct sockaddr * sa,socklen_t salen,char * host,size_t hostlen,char * serv,size_t servlen,unsigned int flags)508 int ki_getnameinfo(const struct sockaddr *sa,
509 socklen_t salen,
510 char *host,
511 size_t hostlen,
512 char *serv,
513 size_t servlen,
514 unsigned int flags) {
515 ON_NOSYS_RETURN(EAI_SYSTEM);
516 KP_TRACE("ki_getnameinfo\n");
517 return s_state.kp->getnameinfo(sa, salen, host, hostlen, serv, servlen,
518 flags);
519 }
520
ki_getaddrinfo(const char * node,const char * service,const struct addrinfo * hints,struct addrinfo ** res)521 int ki_getaddrinfo(const char* node,
522 const char* service,
523 const struct addrinfo* hints,
524 struct addrinfo** res) {
525 ON_NOSYS_RETURN(EAI_SYSTEM);
526 KP_TRACE("ki_getaddrinfo\n");
527 return s_state.kp->getaddrinfo(node, service, hints, res);
528 }
529
ki_freeaddrinfo(struct addrinfo * res)530 void ki_freeaddrinfo(struct addrinfo* res) {
531 KP_TRACE("ki_freeaddrinfo\n");
532 s_state.kp->freeaddrinfo(res);
533 }
534
ki_getpeername(int fd,struct sockaddr * addr,socklen_t * len)535 int ki_getpeername(int fd, struct sockaddr* addr, socklen_t* len) {
536 KP_CALL(getpeername, (fd, addr, len));
537 }
538
ki_getsockname(int fd,struct sockaddr * addr,socklen_t * len)539 int ki_getsockname(int fd, struct sockaddr* addr, socklen_t* len) {
540 KP_CALL(getsockname, (fd, addr, len));
541 }
542
ki_getsockopt(int fd,int lvl,int optname,void * optval,socklen_t * len)543 int ki_getsockopt(int fd, int lvl, int optname, void* optval, socklen_t* len) {
544 KP_CALL(getsockopt, (fd, lvl, optname, optval, len));
545 }
546
ki_listen(int fd,int backlog)547 int ki_listen(int fd, int backlog) {
548 KP_CALL(listen, (fd, backlog));
549 }
550
ki_recv(int fd,void * buf,size_t len,int flags)551 ssize_t ki_recv(int fd, void* buf, size_t len, int flags) {
552 ON_NOSYS_RETURN(-1);
553 KP_TRACE("ki_recv\n");
554 return s_state.kp->recv(fd, buf, len, flags);
555 }
556
ki_recvfrom(int fd,void * buf,size_t len,int flags,struct sockaddr * addr,socklen_t * addrlen)557 ssize_t ki_recvfrom(int fd,
558 void* buf,
559 size_t len,
560 int flags,
561 struct sockaddr* addr,
562 socklen_t* addrlen) {
563 ON_NOSYS_RETURN(-1);
564 KP_TRACE("ki_recvfrom\n");
565 return s_state.kp->recvfrom(fd, buf, len, flags, addr, addrlen);
566 }
567
ki_recvmsg(int fd,struct msghdr * msg,int flags)568 ssize_t ki_recvmsg(int fd, struct msghdr* msg, int flags) {
569 ON_NOSYS_RETURN(-1);
570 KP_TRACE("ki_recvmsg\n");
571 return s_state.kp->recvmsg(fd, msg, flags);
572 }
573
ki_send(int fd,const void * buf,size_t len,int flags)574 ssize_t ki_send(int fd, const void* buf, size_t len, int flags) {
575 ON_NOSYS_RETURN(-1);
576 KP_TRACE("ki_send\n");
577 return s_state.kp->send(fd, buf, len, flags);
578 }
579
ki_sendto(int fd,const void * buf,size_t len,int flags,const struct sockaddr * addr,socklen_t addrlen)580 ssize_t ki_sendto(int fd,
581 const void* buf,
582 size_t len,
583 int flags,
584 const struct sockaddr* addr,
585 socklen_t addrlen) {
586 ON_NOSYS_RETURN(-1);
587 KP_TRACE("ki_sendto\n");
588 return s_state.kp->sendto(fd, buf, len, flags, addr, addrlen);
589 }
590
ki_sendmsg(int fd,const struct msghdr * msg,int flags)591 ssize_t ki_sendmsg(int fd, const struct msghdr* msg, int flags) {
592 ON_NOSYS_RETURN(-1);
593 KP_TRACE("ki_sendmsg\n");
594 return s_state.kp->sendmsg(fd, msg, flags);
595 }
596
ki_setsockopt(int fd,int lvl,int optname,const void * optval,socklen_t len)597 int ki_setsockopt(int fd,
598 int lvl,
599 int optname,
600 const void* optval,
601 socklen_t len) {
602 KP_CALL(setsockopt, (fd, lvl, optname, optval, len));
603 }
604
ki_shutdown(int fd,int how)605 int ki_shutdown(int fd, int how) {
606 KP_CALL(shutdown, (fd, how));
607 }
608
ki_socket(int domain,int type,int protocol)609 int ki_socket(int domain, int type, int protocol) {
610 KP_CALL(socket, (domain, type, protocol));
611 }
612
ki_socketpair(int domain,int type,int protocol,int * sv)613 int ki_socketpair(int domain, int type, int protocol, int* sv) {
614 KP_CALL(socketpair, (domain, type, protocol, sv));
615 }
616 #endif // PROVIDES_SOCKET_API
617