grpc 1.7.3 → 1.8.0

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

@@ -21,8 +21,15 @@
 
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_WINSOCK_SOCKET
 #include "src/core/lib/iomgr/socket_windows.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* There isn't really any such thing as a pollset under Windows, due to the
    nature of the IO completion ports. A Windows "pollset" is merely a mutex
    used to synchronize with the IOCP, and workers are condition variables
@@ -35,8 +42,8 @@ typedef enum {
 } grpc_pollset_worker_link_type;
 
 typedef struct grpc_pollset_worker_link {
-  struct grpc_pollset_worker *next;
-  struct grpc_pollset_worker *prev;
+  struct grpc_pollset_worker* next;
+  struct grpc_pollset_worker* prev;
 } grpc_pollset_worker_link;
 
 struct grpc_pollset;
@@ -45,7 +52,7 @@ typedef struct grpc_pollset grpc_pollset;
 typedef struct grpc_pollset_worker {
   gpr_cv cv;
   int kicked;
-  struct grpc_pollset *pollset;
+  struct grpc_pollset* pollset;
   grpc_pollset_worker_link links[GRPC_POLLSET_WORKER_LINK_TYPES];
 } grpc_pollset_worker;
 
@@ -54,10 +61,16 @@ struct grpc_pollset {
   int kicked_without_pollers;
   int is_iocp_worker;
   grpc_pollset_worker root_worker;
-  grpc_closure *on_shutdown;
+  grpc_closure* on_shutdown;
 };
 
 void grpc_pollset_global_init(void);
 void grpc_pollset_global_shutdown(void);
 
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_WINDOWS_H */

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

@@ -113,6 +113,16 @@
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
 #define GRPC_TIMER_USE_GENERIC 1
+#elif defined(GPR_OPENBSD)
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETADDR 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
+#define GRPC_TIMER_USE_GENERIC 1
 #elif defined(GPR_NACL)
 #define GRPC_HAVE_ARPA_NAMESER 1
 #define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1

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

@@ -25,6 +25,10 @@
 
 #define GRPC_MAX_SOCKADDR_SIZE 128
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
   char addr[GRPC_MAX_SOCKADDR_SIZE];
   size_t len;
@@ -32,24 +36,28 @@ typedef struct {
 
 typedef struct {
   size_t naddrs;
-  grpc_resolved_address *addrs;
+  grpc_resolved_address* addrs;
 } grpc_resolved_addresses;
 
 /* Asynchronously resolve addr. Use default_port if a port isn't designated
    in addr, otherwise use the port in addr. */
 /* TODO(ctiller): add a timeout here */
-extern void (*grpc_resolve_address)(grpc_exec_ctx *exec_ctx, const char *addr,
-                                    const char *default_port,
-                                    grpc_pollset_set *interested_parties,
-                                    grpc_closure *on_done,
-                                    grpc_resolved_addresses **addresses);
+extern void (*grpc_resolve_address)(grpc_exec_ctx* exec_ctx, const char* addr,
+                                    const char* default_port,
+                                    grpc_pollset_set* interested_parties,
+                                    grpc_closure* on_done,
+                                    grpc_resolved_addresses** addresses);
 /* Destroy resolved addresses */
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addresses);
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses);
 
 /* Resolve addr in a blocking fashion. Returns NULL on failure. On success,
    result must be freed with grpc_resolved_addresses_destroy. */
-extern grpc_error *(*grpc_blocking_resolve_address)(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses);
+extern grpc_error* (*grpc_blocking_resolve_address)(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H */

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

@@ -33,22 +33,22 @@
 #include <grpc/support/thd.h>
 #include <grpc/support/time.h>
 #include <grpc/support/useful.h>
+#include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
-#include "src/core/lib/support/block_annotate.h"
 #include "src/core/lib/support/string.h"
 
-static grpc_error *blocking_resolve_address_impl(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) {
+static grpc_error* blocking_resolve_address_impl(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
   struct addrinfo hints;
-  struct addrinfo *result = NULL, *resp;
-  char *host;
-  char *port;
+  struct addrinfo *result = nullptr, *resp;
+  char* host;
+  char* port;
   int s;
   size_t i;
-  grpc_error *err;
+  grpc_error* err;
 
   if (name[0] == 'u' && name[1] == 'n' && name[2] == 'i' && name[3] == 'x' &&
       name[4] == ':' && name[5] != 0) {
@@ -57,14 +57,14 @@ static grpc_error *blocking_resolve_address_impl(
 
   /* parse name, splitting it into host and port parts */
   gpr_split_host_port(name, &host, &port);
-  if (host == NULL) {
+  if (host == nullptr) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto done;
   }
-  if (port == NULL) {
-    if (default_port == NULL) {
+  if (port == nullptr) {
+    if (default_port == nullptr) {
       err = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
@@ -81,16 +81,16 @@ static grpc_error *blocking_resolve_address_impl(
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   s = getaddrinfo(host, port, &hints, &result);
-  GRPC_SCHEDULING_END_BLOCKING_REGION;
+  GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX;
 
   if (s != 0) {
     /* Retry if well-known service name is recognized */
-    const char *svc[][2] = {{"http", "80"}, {"https", "443"}};
+    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
       if (strcmp(port, svc[i][0]) == 0) {
         GRPC_SCHEDULING_START_BLOCKING_REGION;
         s = getaddrinfo(host, svc[i][1], &hints, &result);
-        GRPC_SCHEDULING_END_BLOCKING_REGION;
+        GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX;
         break;
       }
     }
@@ -113,15 +113,15 @@ static grpc_error *blocking_resolve_address_impl(
 
   /* Success path: set addrs non-NULL, fill it in */
   *addresses =
-      (grpc_resolved_addresses *)gpr_malloc(sizeof(grpc_resolved_addresses));
+      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
   (*addresses)->naddrs = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
+  for (resp = result; resp != nullptr; resp = resp->ai_next) {
     (*addresses)->naddrs++;
   }
-  (*addresses)->addrs = (grpc_resolved_address *)gpr_malloc(
+  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
       sizeof(grpc_resolved_address) * (*addresses)->naddrs);
   i = 0;
-  for (resp = result; resp != NULL; resp = resp->ai_next) {
+  for (resp = result; resp != nullptr; resp = resp->ai_next) {
     memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
     (*addresses)->addrs[i].len = resp->ai_addrlen;
     i++;
@@ -137,24 +137,24 @@ done:
   return err;
 }
 
-grpc_error *(*grpc_blocking_resolve_address)(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) = blocking_resolve_address_impl;
+grpc_error* (*grpc_blocking_resolve_address)(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) = blocking_resolve_address_impl;
 
 typedef struct {
-  char *name;
-  char *default_port;
-  grpc_closure *on_done;
-  grpc_resolved_addresses **addrs_out;
+  char* name;
+  char* default_port;
+  grpc_closure* on_done;
+  grpc_resolved_addresses** addrs_out;
   grpc_closure request_closure;
-  void *arg;
+  void* arg;
 } request;
 
 /* Callback to be passed to grpc_executor to asynch-ify
  * grpc_blocking_resolve_address */
-static void do_request_thread(grpc_exec_ctx *exec_ctx, void *rp,
-                              grpc_error *error) {
-  request *r = (request *)rp;
+static void do_request_thread(grpc_exec_ctx* exec_ctx, void* rp,
+                              grpc_error* error) {
+  request* r = (request*)rp;
   GRPC_CLOSURE_SCHED(
       exec_ctx, r->on_done,
       grpc_blocking_resolve_address(r->name, r->default_port, r->addrs_out));
@@ -163,19 +163,19 @@ static void do_request_thread(grpc_exec_ctx *exec_ctx, void *rp,
   gpr_free(r);
 }
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addrs) {
-  if (addrs != NULL) {
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addrs) {
+  if (addrs != nullptr) {
     gpr_free(addrs->addrs);
   }
   gpr_free(addrs);
 }
 
-static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
-                                 const char *default_port,
-                                 grpc_pollset_set *interested_parties,
-                                 grpc_closure *on_done,
-                                 grpc_resolved_addresses **addrs) {
-  request *r = (request *)gpr_malloc(sizeof(request));
+static void resolve_address_impl(grpc_exec_ctx* exec_ctx, const char* name,
+                                 const char* default_port,
+                                 grpc_pollset_set* interested_parties,
+                                 grpc_closure* on_done,
+                                 grpc_resolved_addresses** addrs) {
+  request* r = (request*)gpr_malloc(sizeof(request));
   GRPC_CLOSURE_INIT(&r->request_closure, do_request_thread, r,
                     grpc_executor_scheduler(GRPC_EXECUTOR_SHORT));
   r->name = gpr_strdup(name);
@@ -186,8 +186,8 @@ static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
 }
 
 void (*grpc_resolve_address)(
-    grpc_exec_ctx *exec_ctx, const char *name, const char *default_port,
-    grpc_pollset_set *interested_parties, grpc_closure *on_done,
-    grpc_resolved_addresses **addrs) = resolve_address_impl;
+    grpc_exec_ctx* exec_ctx, const char* name, const char* default_port,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    grpc_resolved_addresses** addrs) = resolve_address_impl;
 
 #endif

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

@@ -38,22 +38,23 @@
 #include <string.h>
 
 typedef struct request {
-  grpc_closure *on_done;
-  grpc_resolved_addresses **addresses;
-  struct addrinfo *hints;
-  char *host;
-  char *port;
+  grpc_closure* on_done;
+  grpc_resolved_addresses** addresses;
+  struct addrinfo* hints;
+  char* host;
+  char* port;
 } request;
 
-static int retry_named_port_failure(int status, request *r,
+static int retry_named_port_failure(int status, request* r,
                                     uv_getaddrinfo_cb getaddrinfo_cb) {
   if (status != 0) {
     // This loop is copied from resolve_address_posix.c
-    char *svc[][2] = {{"http", "80"}, {"https", "443"}};
+    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
       if (strcmp(r->port, svc[i][0]) == 0) {
         int retry_status;
-        uv_getaddrinfo_t *req = gpr_malloc(sizeof(uv_getaddrinfo_t));
+        uv_getaddrinfo_t* req =
+            (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
         req->data = r;
         r->port = gpr_strdup(svc[i][1]);
         retry_status = uv_getaddrinfo(uv_default_loop(), req, getaddrinfo_cb,
@@ -72,12 +73,12 @@ static int retry_named_port_failure(int status, request *r,
   return 1;
 }
 
-static grpc_error *handle_addrinfo_result(int status, struct addrinfo *result,
-                                          grpc_resolved_addresses **addresses) {
-  struct addrinfo *resp;
+static grpc_error* handle_addrinfo_result(int status, struct addrinfo* result,
+                                          grpc_resolved_addresses** addresses) {
+  struct addrinfo* resp;
   size_t i;
   if (status != 0) {
-    grpc_error *error;
+    grpc_error* error;
     *addresses = NULL;
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("getaddrinfo failed");
     error =
@@ -85,13 +86,14 @@ static grpc_error *handle_addrinfo_result(int status, struct addrinfo *result,
                            grpc_slice_from_static_string(uv_strerror(status)));
     return error;
   }
-  (*addresses) = gpr_malloc(sizeof(grpc_resolved_addresses));
+  (*addresses) =
+      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
   (*addresses)->naddrs = 0;
   for (resp = result; resp != NULL; resp = resp->ai_next) {
     (*addresses)->naddrs++;
   }
-  (*addresses)->addrs =
-      gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs);
+  (*addresses)->addrs = (grpc_resolved_address*)gpr_malloc(
+      sizeof(grpc_resolved_address) * (*addresses)->naddrs);
   i = 0;
   for (resp = result; resp != NULL; resp = resp->ai_next) {
     memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
@@ -101,7 +103,7 @@ static grpc_error *handle_addrinfo_result(int status, struct addrinfo *result,
 
   {
     for (i = 0; i < (*addresses)->naddrs; i++) {
-      char *buf;
+      char* buf;
       grpc_sockaddr_to_string(&buf, &(*addresses)->addrs[i], 0);
       gpr_free(buf);
     }
@@ -109,13 +111,13 @@ static grpc_error *handle_addrinfo_result(int status, struct addrinfo *result,
   return GRPC_ERROR_NONE;
 }
 
-static void getaddrinfo_callback(uv_getaddrinfo_t *req, int status,
-                                 struct addrinfo *res) {
-  request *r = (request *)req->data;
+static void getaddrinfo_callback(uv_getaddrinfo_t* req, int status,
+                                 struct addrinfo* res) {
+  request* r = (request*)req->data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_error *error;
+  grpc_error* error;
   int retry_status;
-  char *port = r->port;
+  char* port = r->port;
 
   gpr_free(req);
   retry_status = retry_named_port_failure(status, r, getaddrinfo_callback);
@@ -137,14 +139,14 @@ static void getaddrinfo_callback(uv_getaddrinfo_t *req, int status,
   uv_freeaddrinfo(res);
 }
 
-static grpc_error *try_split_host_port(const char *name,
-                                       const char *default_port, char **host,
-                                       char **port) {
+static grpc_error* try_split_host_port(const char* name,
+                                       const char* default_port, char** host,
+                                       char** port) {
   /* parse name, splitting it into host and port parts */
-  grpc_error *error;
+  grpc_error* error;
   gpr_split_host_port(name, host, port);
   if (*host == NULL) {
-    char *msg;
+    char* msg;
     gpr_asprintf(&msg, "unparseable host:port: '%s'", name);
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
     gpr_free(msg);
@@ -153,7 +155,7 @@ static grpc_error *try_split_host_port(const char *name,
   if (*port == NULL) {
     // TODO(murgatroid99): add tests for this case
     if (default_port == NULL) {
-      char *msg;
+      char* msg;
       gpr_asprintf(&msg, "no port in name '%s'", name);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
       gpr_free(msg);
@@ -164,16 +166,17 @@ static grpc_error *try_split_host_port(const char *name,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *blocking_resolve_address_impl(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) {
-  char *host;
-  char *port;
+static grpc_error* blocking_resolve_address_impl(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
+  char* host;
+  char* port;
   struct addrinfo hints;
   uv_getaddrinfo_t req;
   int s;
-  grpc_error *err;
+  grpc_error* err;
   int retry_status;
+  request r;
 
   GRPC_UV_ASSERT_SAME_THREAD();
 
@@ -191,8 +194,10 @@ static grpc_error *blocking_resolve_address_impl(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   s = uv_getaddrinfo(uv_default_loop(), &req, NULL, host, port, &hints);
-  request r = {
-      .addresses = addresses, .hints = &hints, .host = host, .port = port};
+  r.addresses = addresses;
+  r.hints = &hints;
+  r.host = host;
+  r.port = port;
   retry_status = retry_named_port_failure(s, &r, NULL);
   if (retry_status <= 0) {
     s = retry_status;
@@ -208,28 +213,28 @@ done:
   return err;
 }
 
-grpc_error *(*grpc_blocking_resolve_address)(
-    const char *name, const char *default_port,
-    grpc_resolved_addresses **addresses) = blocking_resolve_address_impl;
+grpc_error* (*grpc_blocking_resolve_address)(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) = blocking_resolve_address_impl;
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses *addrs) {
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addrs) {
   if (addrs != NULL) {
     gpr_free(addrs->addrs);
   }
   gpr_free(addrs);
 }
 
-static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
-                                 const char *default_port,
-                                 grpc_pollset_set *interested_parties,
-                                 grpc_closure *on_done,
-                                 grpc_resolved_addresses **addrs) {
-  uv_getaddrinfo_t *req = NULL;
-  request *r = NULL;
-  struct addrinfo *hints = NULL;
-  char *host = NULL;
-  char *port = NULL;
-  grpc_error *err;
+static void resolve_address_impl(grpc_exec_ctx* exec_ctx, const char* name,
+                                 const char* default_port,
+                                 grpc_pollset_set* interested_parties,
+                                 grpc_closure* on_done,
+                                 grpc_resolved_addresses** addrs) {
+  uv_getaddrinfo_t* req = NULL;
+  request* r = NULL;
+  struct addrinfo* hints = NULL;
+  char* host = NULL;
+  char* port = NULL;
+  grpc_error* err;
   int s;
   GRPC_UV_ASSERT_SAME_THREAD();
   err = try_split_host_port(name, default_port, &host, &port);
@@ -239,16 +244,16 @@ static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
     gpr_free(port);
     return;
   }
-  r = gpr_malloc(sizeof(request));
+  r = (request*)gpr_malloc(sizeof(request));
   r->on_done = on_done;
   r->addresses = addrs;
   r->host = host;
   r->port = port;
-  req = gpr_malloc(sizeof(uv_getaddrinfo_t));
+  req = (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
   req->data = r;
 
   /* Call getaddrinfo */
-  hints = gpr_malloc(sizeof(struct addrinfo));
+  hints = (addrinfo*)gpr_malloc(sizeof(struct addrinfo));
   memset(hints, 0, sizeof(struct addrinfo));
   hints->ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
   hints->ai_socktype = SOCK_STREAM; /* stream socket */
@@ -273,8 +278,8 @@ static void resolve_address_impl(grpc_exec_ctx *exec_ctx, const char *name,
 }
 
 void (*grpc_resolve_address)(
-    grpc_exec_ctx *exec_ctx, const char *name, const char *default_port,
-    grpc_pollset_set *interested_parties, grpc_closure *on_done,
-    grpc_resolved_addresses **addrs) = resolve_address_impl;
+    grpc_exec_ctx* exec_ctx, const char* name, const char* default_port,
+    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    grpc_resolved_addresses** addrs) = resolve_address_impl;
 
 #endif /* GRPC_UV */