grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/udp_server.h

@@ -23,6 +23,10 @@
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Forward decl of struct grpc_server */
 /* This is not typedef'ed to avoid a typedef-redefinition error */
 struct grpc_server;
@@ -31,28 +35,28 @@ struct grpc_server;
 typedef struct grpc_udp_server grpc_udp_server;
 
 /* Called when data is available to read from the socket. */
-typedef void (*grpc_udp_server_read_cb)(grpc_exec_ctx *exec_ctx, grpc_fd *emfd,
-                                        void *user_data);
+typedef void (*grpc_udp_server_read_cb)(grpc_exec_ctx* exec_ctx, grpc_fd* emfd,
+                                        void* user_data);
 
 /* Called when the socket is writeable. */
-typedef void (*grpc_udp_server_write_cb)(grpc_exec_ctx *exec_ctx, grpc_fd *emfd,
-                                         void *user_data);
+typedef void (*grpc_udp_server_write_cb)(grpc_exec_ctx* exec_ctx, grpc_fd* emfd,
+                                         void* user_data);
 
 /* Called when the grpc_fd is about to be orphaned (and the FD closed). */
-typedef void (*grpc_udp_server_orphan_cb)(grpc_exec_ctx *exec_ctx,
-                                          grpc_fd *emfd,
-                                          grpc_closure *shutdown_fd_callback,
-                                          void *user_data);
+typedef void (*grpc_udp_server_orphan_cb)(grpc_exec_ctx* exec_ctx,
+                                          grpc_fd* emfd,
+                                          grpc_closure* shutdown_fd_callback,
+                                          void* user_data);
 
 /* Create a server, initially not bound to any ports */
-grpc_udp_server *grpc_udp_server_create(const grpc_channel_args *args);
+grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
 
 /* Start listening to bound ports. user_data is passed to callbacks. */
-void grpc_udp_server_start(grpc_exec_ctx *exec_ctx, grpc_udp_server *udp_server,
-                           grpc_pollset **pollsets, size_t pollset_count,
-                           void *user_data);
+void grpc_udp_server_start(grpc_exec_ctx* exec_ctx, grpc_udp_server* udp_server,
+                           grpc_pollset** pollsets, size_t pollset_count,
+                           void* user_data);
 
-int grpc_udp_server_get_fd(grpc_udp_server *s, unsigned port_index);
+int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
 /* Add a port to the server, returning port number on success, or negative
    on failure.
@@ -64,13 +68,17 @@ int grpc_udp_server_get_fd(grpc_udp_server *s, unsigned port_index);
 
 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server *s,
-                             const grpc_resolved_address *addr,
+int grpc_udp_server_add_port(grpc_udp_server* s,
+                             const grpc_resolved_address* addr,
                              grpc_udp_server_read_cb read_cb,
                              grpc_udp_server_write_cb write_cb,
                              grpc_udp_server_orphan_cb orphan_cb);
 
-void grpc_udp_server_destroy(grpc_exec_ctx *exec_ctx, grpc_udp_server *server,
-                             grpc_closure *on_done);
+void grpc_udp_server_destroy(grpc_exec_ctx* exec_ctx, grpc_udp_server* server,
+                             grpc_closure* on_done);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_UDP_SERVER_H */

data/src/core/lib/iomgr/{unix_sockets_posix.c → unix_sockets_posix.cc}

@@ -36,12 +36,13 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
 }
 
-grpc_error *grpc_resolve_unix_domain_address(const char *name,
-                                             grpc_resolved_addresses **addrs) {
-  struct sockaddr_un *un;
-  if (strlen(name) > GPR_ARRAY_SIZE(((struct sockaddr_un *)0)->sun_path) - 1) {
-    char *err_msg;
-    grpc_error *err;
+grpc_error* grpc_resolve_unix_domain_address(const char* name,
+                                             grpc_resolved_addresses** addrs) {
+  struct sockaddr_un* un;
+  if (strlen(name) >
+      GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
+    char* err_msg;
+    grpc_error* err;
     gpr_asprintf(&err_msg,
                  "Path name should not have more than %" PRIuPTR " characters.",
                  GPR_ARRAY_SIZE(un->sun_path) - 1);
@@ -50,29 +51,29 @@ grpc_error *grpc_resolve_unix_domain_address(const char *name,
     return err;
   }
   *addrs =
-      (grpc_resolved_addresses *)gpr_malloc(sizeof(grpc_resolved_addresses));
+      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
   (*addrs)->naddrs = 1;
   (*addrs)->addrs =
-      (grpc_resolved_address *)gpr_malloc(sizeof(grpc_resolved_address));
-  un = (struct sockaddr_un *)(*addrs)->addrs->addr;
+      (grpc_resolved_address*)gpr_malloc(sizeof(grpc_resolved_address));
+  un = (struct sockaddr_un*)(*addrs)->addrs->addr;
   un->sun_family = AF_UNIX;
-  strcpy(un->sun_path, name);
+  strncpy(un->sun_path, name, sizeof(un->sun_path));
   (*addrs)->addrs->len = strlen(un->sun_path) + sizeof(un->sun_family) + 1;
   return GRPC_ERROR_NONE;
 }
 
-int grpc_is_unix_socket(const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   return addr->sa_family == AF_UNIX;
 }
 
 void grpc_unlink_if_unix_domain_socket(
-    const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+    const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   if (addr->sa_family != AF_UNIX) {
     return;
   }
-  struct sockaddr_un *un = (struct sockaddr_un *)resolved_addr->addr;
+  struct sockaddr_un* un = (struct sockaddr_un*)resolved_addr->addr;
   struct stat st;
 
   if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
@@ -80,15 +81,15 @@ void grpc_unlink_if_unix_domain_socket(
   }
 }
 
-char *grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address *resolved_addr) {
-  const struct sockaddr *addr = (const struct sockaddr *)resolved_addr->addr;
+char* grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* resolved_addr) {
+  const struct sockaddr* addr = (const struct sockaddr*)resolved_addr->addr;
   if (addr->sa_family != AF_UNIX) {
-    return NULL;
+    return nullptr;
   }
 
-  char *result;
-  gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un *)addr)->sun_path);
+  char* result;
+  gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un*)addr)->sun_path);
   return result;
 }
 

data/src/core/lib/iomgr/unix_sockets_posix.h

@@ -25,17 +25,25 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void grpc_create_socketpair_if_unix(int sv[2]);
 
-grpc_error *grpc_resolve_unix_domain_address(
-    const char *name, grpc_resolved_addresses **addresses);
+grpc_error* grpc_resolve_unix_domain_address(
+    const char* name, grpc_resolved_addresses** addresses);
 
-int grpc_is_unix_socket(const grpc_resolved_address *resolved_addr);
+int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 
 void grpc_unlink_if_unix_domain_socket(
-    const grpc_resolved_address *resolved_addr);
+    const grpc_resolved_address* resolved_addr);
+
+char* grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* resolved_addr);
 
-char *grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address *resolved_addr);
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */

data/src/core/lib/iomgr/{unix_sockets_posix_noop.c → unix_sockets_posix_noop.cc}

@@ -29,18 +29,18 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(0);
 }
 
-grpc_error *grpc_resolve_unix_domain_address(
-    const char *name, grpc_resolved_addresses **addresses) {
+grpc_error* grpc_resolve_unix_domain_address(
+    const char* name, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");
 }
 
-int grpc_is_unix_socket(const grpc_resolved_address *addr) { return false; }
+int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
 
-void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address *addr) {}
+void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}
 
-char *grpc_sockaddr_to_uri_unix_if_possible(const grpc_resolved_address *addr) {
+char* grpc_sockaddr_to_uri_unix_if_possible(const grpc_resolved_address* addr) {
   return NULL;
 }
 

data/src/core/lib/iomgr/{wakeup_fd_cv.c → wakeup_fd_cv.cc}

@@ -46,7 +46,7 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
         (fd_node*)gpr_realloc(g_cvfds.cvfds, sizeof(fd_node) * newsize);
     for (i = g_cvfds.size; i < newsize; i++) {
       g_cvfds.cvfds[i].is_set = 0;
-      g_cvfds.cvfds[i].cvs = NULL;
+      g_cvfds.cvfds[i].cvs = nullptr;
       g_cvfds.cvfds[i].next_free = g_cvfds.free_fds;
       g_cvfds.free_fds = &g_cvfds.cvfds[i];
     }
@@ -55,7 +55,7 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
 
   idx = (int)(g_cvfds.free_fds - g_cvfds.cvfds);
   g_cvfds.free_fds = g_cvfds.free_fds->next_free;
-  g_cvfds.cvfds[idx].cvs = NULL;
+  g_cvfds.cvfds[idx].cvs = nullptr;
   g_cvfds.cvfds[idx].is_set = 0;
   fd_info->read_fd = GRPC_IDX_TO_FD(idx);
   fd_info->write_fd = -1;

data/src/core/lib/iomgr/wakeup_fd_cv.h

@@ -40,6 +40,10 @@
 #define GRPC_FD_TO_IDX(fd) (-(fd)-1)
 #define GRPC_IDX_TO_FD(idx) (-(idx)-1)
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct cv_node {
   gpr_cv* cv;
   struct cv_node* next;
@@ -62,4 +66,10 @@ typedef struct cv_fd_table {
   grpc_poll_function_type poll;
 } cv_fd_table;
 
+extern const grpc_wakeup_fd_vtable grpc_cv_wakeup_fd_vtable;
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_CV_H */

data/src/core/lib/iomgr/{wakeup_fd_pipe.c → wakeup_fd_pipe.cc}

@@ -20,6 +20,7 @@
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
+#include "src/core/lib/iomgr/wakeup_fd_pipe.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
 #include <errno.h>

data/src/core/lib/iomgr/wakeup_fd_pipe.h

@@ -21,6 +21,14 @@
 
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-extern grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable;
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable;
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H */

data/src/core/lib/iomgr/{wakeup_fd_posix.c → wakeup_fd_posix.cc}

@@ -25,8 +25,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_pipe.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-extern grpc_wakeup_fd_vtable grpc_cv_wakeup_fd_vtable;
-static const grpc_wakeup_fd_vtable *wakeup_fd_vtable = NULL;
+static const grpc_wakeup_fd_vtable* wakeup_fd_vtable = nullptr;
 
 int grpc_allow_specialized_wakeup_fd = 1;
 int grpc_allow_pipe_wakeup_fd = 1;
@@ -46,7 +45,7 @@ void grpc_wakeup_fd_global_init(void) {
   }
 }
 
-void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = NULL; }
+void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 
@@ -54,28 +53,28 @@ int grpc_cv_wakeup_fds_enabled(void) { return cv_wakeup_fds_enabled; }
 
 void grpc_enable_cv_wakeup_fds(int enable) { cv_wakeup_fds_enabled = enable; }
 
-grpc_error *grpc_wakeup_fd_init(grpc_wakeup_fd *fd_info) {
+grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
   if (cv_wakeup_fds_enabled) {
     return grpc_cv_wakeup_fd_vtable.init(fd_info);
   }
   return wakeup_fd_vtable->init(fd_info);
 }
 
-grpc_error *grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd *fd_info) {
+grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
   if (cv_wakeup_fds_enabled) {
     return grpc_cv_wakeup_fd_vtable.consume(fd_info);
   }
   return wakeup_fd_vtable->consume(fd_info);
 }
 
-grpc_error *grpc_wakeup_fd_wakeup(grpc_wakeup_fd *fd_info) {
+grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
   if (cv_wakeup_fds_enabled) {
     return grpc_cv_wakeup_fd_vtable.wakeup(fd_info);
   }
   return wakeup_fd_vtable->wakeup(fd_info);
 }
 
-void grpc_wakeup_fd_destroy(grpc_wakeup_fd *fd_info) {
+void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info) {
   if (cv_wakeup_fds_enabled) {
     grpc_cv_wakeup_fd_vtable.destroy(fd_info);
   } else {

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -49,6 +49,10 @@
 
 #include "src/core/lib/iomgr/error.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void grpc_wakeup_fd_global_init(void);
 void grpc_wakeup_fd_global_destroy(void);
 
@@ -91,4 +95,8 @@ void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
  * wakeup_fd_nospecial.c if no such implementation exists. */
 extern const grpc_wakeup_fd_vtable grpc_specialized_wakeup_fd_vtable;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H */

data/src/core/lib/json/json.h

@@ -23,6 +23,10 @@
 
 #include "src/core/lib/json/json_common.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A tree-like structure to hold json values. The key and value pointers
  * are not owned by it.
  */
@@ -70,4 +74,8 @@ char* grpc_json_dump_to_string(grpc_json* json, int indent);
 grpc_json* grpc_json_create(grpc_json_type type);
 void grpc_json_destroy(grpc_json* json);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_JSON_JSON_H */

data/src/core/lib/json/{json_reader.c → json_reader.cc}

@@ -24,60 +24,60 @@
 
 #include "src/core/lib/json/json_reader.h"
 
-static void json_reader_string_clear(grpc_json_reader *reader) {
+static void json_reader_string_clear(grpc_json_reader* reader) {
   reader->vtable->string_clear(reader->userdata);
 }
 
-static void json_reader_string_add_char(grpc_json_reader *reader, uint32_t c) {
+static void json_reader_string_add_char(grpc_json_reader* reader, uint32_t c) {
   reader->vtable->string_add_char(reader->userdata, c);
 }
 
-static void json_reader_string_add_utf32(grpc_json_reader *reader,
+static void json_reader_string_add_utf32(grpc_json_reader* reader,
                                          uint32_t utf32) {
   reader->vtable->string_add_utf32(reader->userdata, utf32);
 }
 
-static uint32_t grpc_json_reader_read_char(grpc_json_reader *reader) {
+static uint32_t grpc_json_reader_read_char(grpc_json_reader* reader) {
   return reader->vtable->read_char(reader->userdata);
 }
 
-static void json_reader_container_begins(grpc_json_reader *reader,
+static void json_reader_container_begins(grpc_json_reader* reader,
                                          grpc_json_type type) {
   reader->vtable->container_begins(reader->userdata, type);
 }
 
 static grpc_json_type grpc_json_reader_container_ends(
-    grpc_json_reader *reader) {
+    grpc_json_reader* reader) {
   return reader->vtable->container_ends(reader->userdata);
 }
 
-static void json_reader_set_key(grpc_json_reader *reader) {
+static void json_reader_set_key(grpc_json_reader* reader) {
   reader->vtable->set_key(reader->userdata);
 }
 
-static void json_reader_set_string(grpc_json_reader *reader) {
+static void json_reader_set_string(grpc_json_reader* reader) {
   reader->vtable->set_string(reader->userdata);
 }
 
-static int json_reader_set_number(grpc_json_reader *reader) {
+static int json_reader_set_number(grpc_json_reader* reader) {
   return reader->vtable->set_number(reader->userdata);
 }
 
-static void json_reader_set_true(grpc_json_reader *reader) {
+static void json_reader_set_true(grpc_json_reader* reader) {
   reader->vtable->set_true(reader->userdata);
 }
 
-static void json_reader_set_false(grpc_json_reader *reader) {
+static void json_reader_set_false(grpc_json_reader* reader) {
   reader->vtable->set_false(reader->userdata);
 }
 
-static void json_reader_set_null(grpc_json_reader *reader) {
+static void json_reader_set_null(grpc_json_reader* reader) {
   reader->vtable->set_null(reader->userdata);
 }
 
 /* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader *reader,
-                           grpc_json_reader_vtable *vtable, void *userdata) {
+void grpc_json_reader_init(grpc_json_reader* reader,
+                           grpc_json_reader_vtable* vtable, void* userdata) {
   memset(reader, 0, sizeof(*reader));
   reader->vtable = vtable;
   reader->userdata = userdata;
@@ -85,13 +85,13 @@ void grpc_json_reader_init(grpc_json_reader *reader,
   reader->state = GRPC_JSON_STATE_VALUE_BEGIN;
 }
 
-int grpc_json_reader_is_complete(grpc_json_reader *reader) {
+int grpc_json_reader_is_complete(grpc_json_reader* reader) {
   return ((reader->depth == 0) &&
           ((reader->state == GRPC_JSON_STATE_END) ||
            (reader->state == GRPC_JSON_STATE_VALUE_END)));
 }
 
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader) {
+grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
   uint32_t c, success;
 
   /* This state-machine is a strict implementation of ECMA-404 */
@@ -177,8 +177,8 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader) {
             if (!success) return GRPC_JSON_PARSE_ERROR;
             json_reader_string_clear(reader);
             reader->state = GRPC_JSON_STATE_VALUE_END;
-          /* The missing break here is intentional. */
-          /* fallthrough */
+            /* The missing break here is intentional. */
+            /* fallthrough */
 
           case GRPC_JSON_STATE_VALUE_END:
           case GRPC_JSON_STATE_OBJECT_KEY_BEGIN: