[NaCl SDK] Add fake for ppb_host_resolver and ppb_net_address

native_client_sdk/src/libraries/nacl_io/kernel_intercept.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+/* Copyright (c) 2012 The Chromium Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file. */
 
 #ifndef LIBRARIES_NACL_IO_KERNEL_INTERCEPT_H_
 #define LIBRARIES_NACL_IO_KERNEL_INTERCEPT_H_
 
 #include <stdarg.h>
 #include <sys/time.h>
 
 #include <ppapi/c/ppb.h>
 #include <ppapi/c/pp_instance.h>
 
 #include "nacl_io/ossignal.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/ostermios.h"
 #include "nacl_io/ostypes.h"
 #include "nacl_io/osutime.h"
 #include "sdk_util/macros.h"
 
 EXTERN_C_BEGIN
 
 struct fuse_operations;
 
-// The kernel intercept module provides a C->C++ thunk between the libc
-// kernel calls and the KernelProxy singleton.
+/*
+ * The kernel intercept module provides a C->C++ thunk between the libc
+ * kernel calls and the KernelProxy singleton.
+ */
 
-// ki_init must be called with an uninitialized KernelProxy object.  Calling
-// with NULL will instantiate a default kernel proxy object.  ki_init must
-// be called before any other ki_XXX function can be used.
+/*
+ * ki_init must be called with an uninitialized KernelProxy object.  Calling
+ * with NULL will instantiate a default kernel proxy object.  ki_init must
+ * be called before any other ki_XXX function can be used.
+ */
 void ki_init(void* kernel_proxy);
 void ki_init_ppapi(void* kernel_proxy,
                    PP_Instance instance,
                    PPB_GetInterface get_browser_interface);
+
+/*
+ * ki_init_interface() is a variant of ki_init() that can be called with
+ * a PepperInterface object.  The ownership of this object then passes
+ * to nacl_io and it will be deleted on ki_uninit().
+ */
+void ki_init_interface(void* kp, void* pepper_interface);
+
 int ki_register_fs_type(const char* fs_type, struct fuse_operations* fuse_ops);
 int ki_unregister_fs_type(const char* fs_type);
 int ki_is_initialized();
 void ki_uninit();
 
 int ki_chdir(const char* path);
 char* ki_getcwd(char* buf, size_t size);
 char* ki_getwd(char* buf);
 int ki_dup(int oldfd);
 int ki_dup2(int oldfd, int newfd);
@@ skipping 51 matching lines @@
 int ki_killpg(pid_t pid, int sig);
 int ki_sigaction(int signum, const struct sigaction* action,
                  struct sigaction* oaction);
 int ki_sigpause(int sigmask);
 int ki_sigpending(sigset_t* set);
 int ki_sigsuspend(const sigset_t* set);
 sighandler_t ki_signal(int signum, sighandler_t handler);
 sighandler_t ki_sigset(int signum, sighandler_t handler);
 
 #ifdef PROVIDES_SOCKET_API
-// Socket Functions
+/* Socket Functions */
 int ki_accept(int fd, struct sockaddr* addr, socklen_t* len);
 int ki_bind(int fd, const struct sockaddr* addr, socklen_t len);
 int ki_connect(int fd, const struct sockaddr* addr, socklen_t len);
 struct hostent* ki_gethostbyname(const char* name);
 int ki_getpeername(int fd, struct sockaddr* addr, socklen_t* len);
 int ki_getsockname(int fd, struct sockaddr* addr, socklen_t* len);
 int ki_getsockopt(int fd, int lvl, int optname, void* optval, socklen_t* len);
 int ki_listen(int fd, int backlog);
 ssize_t ki_recv(int fd, void* buf, size_t len, int flags);
 ssize_t ki_recvfrom(int fd, void* buf, size_t len, int flags,
                     struct sockaddr* addr, socklen_t* addrlen);
 ssize_t ki_recvmsg(int fd, struct msghdr* msg, int flags);
 ssize_t ki_send(int fd, const void* buf, size_t len, int flags);
 ssize_t ki_sendto(int fd, const void* buf, size_t len, int flags,
                   const struct sockaddr* addr, socklen_t addrlen);
 ssize_t ki_sendmsg(int fd, const struct msghdr* msg, int flags);
 int ki_setsockopt(int fd, int lvl, int optname, const void* optval,
                   socklen_t len);
 int ki_shutdown(int fd, int how);
 int ki_socket(int domain, int type, int protocol);
 int ki_socketpair(int domain, int type, int protocl, int* sv);
-#endif  // PROVIDES_SOCKET_API
+#endif  /* PROVIDES_SOCKET_API */
 
 EXTERN_C_END
 
-#endif  // LIBRARIES_NACL_IO_KERNEL_INTERCEPT_H_
+#endif  /* LIBRARIES_NACL_IO_KERNEL_INTERCEPT_H_ */