mirror of https://github.com/grpc/grpc.git
Nicolas Noble
9 years ago
commit
60a1f24fbf
25 changed files with 1 additions and 1721 deletions
@ -1,51 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2016, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#ifndef GRPC_GRPC_CRONET_H |
|
||||||
#define GRPC_GRPC_CRONET_H |
|
||||||
|
|
||||||
#include <grpc/grpc.h> |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
extern "C" { |
|
||||||
#endif |
|
||||||
|
|
||||||
GRPCAPI grpc_channel *grpc_cronet_secure_channel_create( |
|
||||||
void *engine, const char *target, const grpc_channel_args *args, |
|
||||||
void *reserved); |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
#endif /* GRPC_GRPC_CRONET_H */ |
|
||||||
@ -1,69 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2016, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#include <grpc/impl/codegen/port_platform.h> |
|
||||||
|
|
||||||
#include <stdio.h> |
|
||||||
#include <string.h> |
|
||||||
|
|
||||||
#include <grpc/support/alloc.h> |
|
||||||
#include <grpc/support/log.h> |
|
||||||
|
|
||||||
#include "src/core/lib/surface/channel.h" |
|
||||||
#include "src/core/lib/transport/transport_impl.h" |
|
||||||
|
|
||||||
// Cronet transport object
|
|
||||||
typedef struct cronet_transport { |
|
||||||
grpc_transport base; // must be first element in this structure
|
|
||||||
void *engine; |
|
||||||
char *host; |
|
||||||
} cronet_transport; |
|
||||||
|
|
||||||
extern grpc_transport_vtable grpc_cronet_vtable; |
|
||||||
|
|
||||||
GRPCAPI grpc_channel *grpc_cronet_secure_channel_create( |
|
||||||
void *engine, const char *target, const grpc_channel_args *args, |
|
||||||
void *reserved) { |
|
||||||
cronet_transport *ct = gpr_malloc(sizeof(cronet_transport)); |
|
||||||
ct->base.vtable = &grpc_cronet_vtable; |
|
||||||
ct->engine = engine; |
|
||||||
ct->host = gpr_malloc(strlen(target) + 1); |
|
||||||
strcpy(ct->host, target); |
|
||||||
gpr_log(GPR_DEBUG, |
|
||||||
"grpc_create_cronet_transport: cronet_engine = %p, target=%s", engine, |
|
||||||
ct->host); |
|
||||||
|
|
||||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
|
||||||
return grpc_channel_create(&exec_ctx, target, args, |
|
||||||
GRPC_CLIENT_DIRECT_CHANNEL, (grpc_transport *)ct); |
|
||||||
} |
|
||||||
@ -1,85 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2016, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
/* This file has empty implementation of all the functions exposed by the cronet
|
|
||||||
library, so we can build it in all environments */ |
|
||||||
|
|
||||||
#include <stdbool.h> |
|
||||||
|
|
||||||
#include <grpc/support/log.h> |
|
||||||
|
|
||||||
#include "third_party/objective_c/Cronet/cronet_c_for_grpc.h" |
|
||||||
|
|
||||||
#ifdef GRPC_COMPILE_WITH_CRONET |
|
||||||
/* link with the real CRONET library in the build system */ |
|
||||||
#else |
|
||||||
/* Dummy implementation of cronet API just to test for build-ability */ |
|
||||||
cronet_bidirectional_stream* cronet_bidirectional_stream_create( |
|
||||||
cronet_engine* engine, void* annotation, |
|
||||||
cronet_bidirectional_stream_callback* callback) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
int cronet_bidirectional_stream_start( |
|
||||||
cronet_bidirectional_stream* stream, const char* url, int priority, |
|
||||||
const char* method, const cronet_bidirectional_stream_header_array* headers, |
|
||||||
bool end_of_stream) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream, |
|
||||||
char* buffer, int capacity) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream, |
|
||||||
const char* buffer, int count, |
|
||||||
bool end_of_stream) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
int cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream) { |
|
||||||
GPR_ASSERT(0); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
#endif /* GRPC_COMPILE_WITH_CRONET */ |
|
||||||
@ -1,640 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2016, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#include <string.h> |
|
||||||
|
|
||||||
#include <grpc/impl/codegen/port_platform.h> |
|
||||||
#include <grpc/support/alloc.h> |
|
||||||
#include <grpc/support/host_port.h> |
|
||||||
#include <grpc/support/log.h> |
|
||||||
#include <grpc/support/slice_buffer.h> |
|
||||||
#include <grpc/support/string_util.h> |
|
||||||
#include <grpc/support/useful.h> |
|
||||||
|
|
||||||
#include "src/core/ext/transport/chttp2/transport/incoming_metadata.h" |
|
||||||
#include "src/core/lib/iomgr/exec_ctx.h" |
|
||||||
#include "src/core/lib/support/string.h" |
|
||||||
#include "src/core/lib/surface/channel.h" |
|
||||||
#include "src/core/lib/transport/metadata_batch.h" |
|
||||||
#include "src/core/lib/transport/transport_impl.h" |
|
||||||
#include "third_party/objective_c/Cronet/cronet_c_for_grpc.h" |
|
||||||
|
|
||||||
#define GRPC_HEADER_SIZE_IN_BYTES 5 |
|
||||||
|
|
||||||
// Global flag that gets set with GRPC_TRACE env variable
|
|
||||||
int grpc_cronet_trace = 1; |
|
||||||
|
|
||||||
// Cronet transport object
|
|
||||||
struct grpc_cronet_transport { |
|
||||||
grpc_transport base; /* must be first element in this structure */ |
|
||||||
cronet_engine *engine; |
|
||||||
char *host; |
|
||||||
}; |
|
||||||
|
|
||||||
typedef struct grpc_cronet_transport grpc_cronet_transport; |
|
||||||
|
|
||||||
enum send_state { |
|
||||||
CRONET_SEND_IDLE = 0, |
|
||||||
CRONET_REQ_STARTED, |
|
||||||
CRONET_SEND_HEADER, |
|
||||||
CRONET_WRITE, |
|
||||||
CRONET_WRITE_COMPLETED, |
|
||||||
}; |
|
||||||
|
|
||||||
enum recv_state { |
|
||||||
CRONET_RECV_IDLE = 0, |
|
||||||
CRONET_RECV_READ_LENGTH, |
|
||||||
CRONET_RECV_READ_DATA, |
|
||||||
CRONET_RECV_CLOSED, |
|
||||||
}; |
|
||||||
|
|
||||||
static const char *recv_state_name[] = { |
|
||||||
"CRONET_RECV_IDLE", "CRONET_RECV_READ_LENGTH", "CRONET_RECV_READ_DATA,", |
|
||||||
"CRONET_RECV_CLOSED"}; |
|
||||||
|
|
||||||
// Enum that identifies calling function.
|
|
||||||
enum e_caller { |
|
||||||
PERFORM_STREAM_OP, |
|
||||||
ON_READ_COMPLETE, |
|
||||||
ON_RESPONSE_HEADERS_RECEIVED, |
|
||||||
ON_RESPONSE_TRAILERS_RECEIVED |
|
||||||
}; |
|
||||||
|
|
||||||
enum callback_id { |
|
||||||
CB_SEND_INITIAL_METADATA = 0, |
|
||||||
CB_SEND_MESSAGE, |
|
||||||
CB_SEND_TRAILING_METADATA, |
|
||||||
CB_RECV_MESSAGE, |
|
||||||
CB_RECV_INITIAL_METADATA, |
|
||||||
CB_RECV_TRAILING_METADATA, |
|
||||||
CB_NUM_CALLBACKS |
|
||||||
}; |
|
||||||
|
|
||||||
struct stream_obj { |
|
||||||
// we store received bytes here as they trickle in.
|
|
||||||
gpr_slice_buffer write_slice_buffer; |
|
||||||
cronet_bidirectional_stream *cbs; |
|
||||||
gpr_slice slice; |
|
||||||
gpr_slice_buffer read_slice_buffer; |
|
||||||
struct grpc_slice_buffer_stream sbs; |
|
||||||
char *read_buffer; |
|
||||||
int remaining_read_bytes; |
|
||||||
int total_read_bytes; |
|
||||||
|
|
||||||
char *write_buffer; |
|
||||||
size_t write_buffer_size; |
|
||||||
|
|
||||||
// Hold the URL
|
|
||||||
char *url; |
|
||||||
|
|
||||||
bool response_headers_received; |
|
||||||
bool read_requested; |
|
||||||
bool response_trailers_received; |
|
||||||
bool read_closed; |
|
||||||
|
|
||||||
// Recv message stuff
|
|
||||||
grpc_byte_buffer **recv_message; |
|
||||||
// Initial metadata stuff
|
|
||||||
grpc_metadata_batch *recv_initial_metadata; |
|
||||||
// Trailing metadata stuff
|
|
||||||
grpc_metadata_batch *recv_trailing_metadata; |
|
||||||
grpc_chttp2_incoming_metadata_buffer imb; |
|
||||||
|
|
||||||
// This mutex protects receive state machine execution
|
|
||||||
gpr_mu recv_mu; |
|
||||||
// we can queue up up to 2 callbacks for each OP
|
|
||||||
grpc_closure *callback_list[CB_NUM_CALLBACKS][2]; |
|
||||||
|
|
||||||
// storage for header
|
|
||||||
cronet_bidirectional_stream_header *headers; |
|
||||||
uint32_t num_headers; |
|
||||||
cronet_bidirectional_stream_header_array header_array; |
|
||||||
// state tracking
|
|
||||||
enum recv_state cronet_recv_state; |
|
||||||
enum send_state cronet_send_state; |
|
||||||
}; |
|
||||||
|
|
||||||
typedef struct stream_obj stream_obj; |
|
||||||
|
|
||||||
static void next_send_step(stream_obj *s); |
|
||||||
static void next_recv_step(stream_obj *s, enum e_caller caller); |
|
||||||
|
|
||||||
static void set_pollset_do_nothing(grpc_exec_ctx *exec_ctx, grpc_transport *gt, |
|
||||||
grpc_stream *gs, grpc_pollset *pollset) {} |
|
||||||
|
|
||||||
static void enqueue_callbacks(grpc_closure *callback_list[]) { |
|
||||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
|
||||||
if (callback_list[0]) { |
|
||||||
grpc_exec_ctx_enqueue(&exec_ctx, callback_list[0], true, NULL); |
|
||||||
callback_list[0] = NULL; |
|
||||||
} |
|
||||||
if (callback_list[1]) { |
|
||||||
grpc_exec_ctx_enqueue(&exec_ctx, callback_list[1], true, NULL); |
|
||||||
callback_list[1] = NULL; |
|
||||||
} |
|
||||||
grpc_exec_ctx_finish(&exec_ctx); |
|
||||||
} |
|
||||||
|
|
||||||
static void on_canceled(cronet_bidirectional_stream *stream) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "on_canceled %p", stream); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void on_failed(cronet_bidirectional_stream *stream, int net_error) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "on_failed %p, error = %d", stream, net_error); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void on_succeeded(cronet_bidirectional_stream *stream) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "on_succeeded %p", stream); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void on_response_trailers_received( |
|
||||||
cronet_bidirectional_stream *stream, |
|
||||||
const cronet_bidirectional_stream_header_array *trailers) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: on_response_trailers_received"); |
|
||||||
} |
|
||||||
stream_obj *s = (stream_obj *)stream->annotation; |
|
||||||
|
|
||||||
memset(&s->imb, 0, sizeof(s->imb)); |
|
||||||
grpc_chttp2_incoming_metadata_buffer_init(&s->imb); |
|
||||||
unsigned int i = 0; |
|
||||||
for (i = 0; i < trailers->count; i++) { |
|
||||||
grpc_chttp2_incoming_metadata_buffer_add( |
|
||||||
&s->imb, grpc_mdelem_from_metadata_strings( |
|
||||||
grpc_mdstr_from_string(trailers->headers[i].key), |
|
||||||
grpc_mdstr_from_string(trailers->headers[i].value))); |
|
||||||
} |
|
||||||
s->response_trailers_received = true; |
|
||||||
next_recv_step(s, ON_RESPONSE_TRAILERS_RECEIVED); |
|
||||||
} |
|
||||||
|
|
||||||
static void on_write_completed(cronet_bidirectional_stream *stream, |
|
||||||
const char *data) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "W: on_write_completed"); |
|
||||||
} |
|
||||||
stream_obj *s = (stream_obj *)stream->annotation; |
|
||||||
enqueue_callbacks(s->callback_list[CB_SEND_MESSAGE]); |
|
||||||
s->cronet_send_state = CRONET_WRITE_COMPLETED; |
|
||||||
next_send_step(s); |
|
||||||
} |
|
||||||
|
|
||||||
static void process_recv_message(stream_obj *s, const uint8_t *recv_data) { |
|
||||||
gpr_slice read_data_slice = gpr_slice_malloc((uint32_t)s->total_read_bytes); |
|
||||||
uint8_t *dst_p = GPR_SLICE_START_PTR(read_data_slice); |
|
||||||
memcpy(dst_p, recv_data, (size_t)s->total_read_bytes); |
|
||||||
gpr_slice_buffer_add(&s->read_slice_buffer, read_data_slice); |
|
||||||
grpc_slice_buffer_stream_init(&s->sbs, &s->read_slice_buffer, 0); |
|
||||||
*s->recv_message = (grpc_byte_buffer *)&s->sbs; |
|
||||||
} |
|
||||||
|
|
||||||
static int parse_grpc_header(const uint8_t *data) { |
|
||||||
const uint8_t *p = data + 1; |
|
||||||
int length = 0; |
|
||||||
length |= ((uint8_t)*p++) << 24; |
|
||||||
length |= ((uint8_t)*p++) << 16; |
|
||||||
length |= ((uint8_t)*p++) << 8; |
|
||||||
length |= ((uint8_t)*p++); |
|
||||||
return length; |
|
||||||
} |
|
||||||
|
|
||||||
static void on_read_completed(cronet_bidirectional_stream *stream, char *data, |
|
||||||
int count) { |
|
||||||
stream_obj *s = (stream_obj *)stream->annotation; |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: on_read_completed count=%d, total=%d, remaining=%d", |
|
||||||
count, s->total_read_bytes, s->remaining_read_bytes); |
|
||||||
} |
|
||||||
if (count > 0) { |
|
||||||
GPR_ASSERT(s->recv_message); |
|
||||||
s->remaining_read_bytes -= count; |
|
||||||
next_recv_step(s, ON_READ_COMPLETE); |
|
||||||
} else { |
|
||||||
s->read_closed = true; |
|
||||||
next_recv_step(s, ON_READ_COMPLETE); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void on_response_headers_received( |
|
||||||
cronet_bidirectional_stream *stream, |
|
||||||
const cronet_bidirectional_stream_header_array *headers, |
|
||||||
const char *negotiated_protocol) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: on_response_headers_received"); |
|
||||||
} |
|
||||||
stream_obj *s = (stream_obj *)stream->annotation; |
|
||||||
enqueue_callbacks(s->callback_list[CB_RECV_INITIAL_METADATA]); |
|
||||||
s->response_headers_received = true; |
|
||||||
next_recv_step(s, ON_RESPONSE_HEADERS_RECEIVED); |
|
||||||
} |
|
||||||
|
|
||||||
static void on_request_headers_sent(cronet_bidirectional_stream *stream) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "W: on_request_headers_sent"); |
|
||||||
} |
|
||||||
stream_obj *s = (stream_obj *)stream->annotation; |
|
||||||
enqueue_callbacks(s->callback_list[CB_SEND_INITIAL_METADATA]); |
|
||||||
s->cronet_send_state = CRONET_SEND_HEADER; |
|
||||||
next_send_step(s); |
|
||||||
} |
|
||||||
|
|
||||||
// Callback function pointers (invoked by cronet in response to events)
|
|
||||||
static cronet_bidirectional_stream_callback callbacks = { |
|
||||||
on_request_headers_sent, |
|
||||||
on_response_headers_received, |
|
||||||
on_read_completed, |
|
||||||
on_write_completed, |
|
||||||
on_response_trailers_received, |
|
||||||
on_succeeded, |
|
||||||
on_failed, |
|
||||||
on_canceled}; |
|
||||||
|
|
||||||
static void invoke_closing_callback(stream_obj *s) { |
|
||||||
grpc_chttp2_incoming_metadata_buffer_publish(&s->imb, |
|
||||||
s->recv_trailing_metadata); |
|
||||||
if (s->callback_list[CB_RECV_TRAILING_METADATA]) { |
|
||||||
enqueue_callbacks(s->callback_list[CB_RECV_TRAILING_METADATA]); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void set_recv_state(stream_obj *s, enum recv_state state) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "next_state = %s", recv_state_name[state]); |
|
||||||
} |
|
||||||
s->cronet_recv_state = state; |
|
||||||
} |
|
||||||
|
|
||||||
// This is invoked from perform_stream_op, and all on_xxxx callbacks.
|
|
||||||
static void next_recv_step(stream_obj *s, enum e_caller caller) { |
|
||||||
gpr_mu_lock(&s->recv_mu); |
|
||||||
switch (s->cronet_recv_state) { |
|
||||||
case CRONET_RECV_IDLE: |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_recv_state = CRONET_RECV_IDLE"); |
|
||||||
} |
|
||||||
if (caller == PERFORM_STREAM_OP || |
|
||||||
caller == ON_RESPONSE_HEADERS_RECEIVED) { |
|
||||||
if (s->read_closed && s->response_trailers_received) { |
|
||||||
invoke_closing_callback(s); |
|
||||||
set_recv_state(s, CRONET_RECV_CLOSED); |
|
||||||
} else if (s->response_headers_received == true && |
|
||||||
s->read_requested == true) { |
|
||||||
set_recv_state(s, CRONET_RECV_READ_LENGTH); |
|
||||||
s->total_read_bytes = s->remaining_read_bytes = |
|
||||||
GRPC_HEADER_SIZE_IN_BYTES; |
|
||||||
GPR_ASSERT(s->read_buffer); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: cronet_bidirectional_stream_read()"); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_read(s->cbs, s->read_buffer, |
|
||||||
s->remaining_read_bytes); |
|
||||||
} |
|
||||||
} |
|
||||||
break; |
|
||||||
case CRONET_RECV_READ_LENGTH: |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_recv_state = CRONET_RECV_READ_LENGTH"); |
|
||||||
} |
|
||||||
if (caller == ON_READ_COMPLETE) { |
|
||||||
if (s->read_closed) { |
|
||||||
invoke_closing_callback(s); |
|
||||||
enqueue_callbacks(s->callback_list[CB_RECV_MESSAGE]); |
|
||||||
set_recv_state(s, CRONET_RECV_CLOSED); |
|
||||||
} else { |
|
||||||
GPR_ASSERT(s->remaining_read_bytes == 0); |
|
||||||
set_recv_state(s, CRONET_RECV_READ_DATA); |
|
||||||
s->total_read_bytes = s->remaining_read_bytes = |
|
||||||
parse_grpc_header((const uint8_t *)s->read_buffer); |
|
||||||
s->read_buffer = |
|
||||||
gpr_realloc(s->read_buffer, (uint32_t)s->remaining_read_bytes); |
|
||||||
GPR_ASSERT(s->read_buffer); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: cronet_bidirectional_stream_read()"); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_read(s->cbs, (char *)s->read_buffer, |
|
||||||
s->remaining_read_bytes); |
|
||||||
} |
|
||||||
} |
|
||||||
break; |
|
||||||
case CRONET_RECV_READ_DATA: |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_recv_state = CRONET_RECV_READ_DATA"); |
|
||||||
} |
|
||||||
if (caller == ON_READ_COMPLETE) { |
|
||||||
if (s->remaining_read_bytes > 0) { |
|
||||||
int offset = s->total_read_bytes - s->remaining_read_bytes; |
|
||||||
GPR_ASSERT(s->read_buffer); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "R: cronet_bidirectional_stream_read()"); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_read( |
|
||||||
s->cbs, (char *)s->read_buffer + offset, s->remaining_read_bytes); |
|
||||||
} else { |
|
||||||
gpr_slice_buffer_init(&s->read_slice_buffer); |
|
||||||
uint8_t *p = (uint8_t *)s->read_buffer; |
|
||||||
process_recv_message(s, p); |
|
||||||
set_recv_state(s, CRONET_RECV_IDLE); |
|
||||||
enqueue_callbacks(s->callback_list[CB_RECV_MESSAGE]); |
|
||||||
} |
|
||||||
} |
|
||||||
break; |
|
||||||
case CRONET_RECV_CLOSED: |
|
||||||
break; |
|
||||||
default: |
|
||||||
GPR_ASSERT(0); // Should not reach here
|
|
||||||
break; |
|
||||||
} |
|
||||||
gpr_mu_unlock(&s->recv_mu); |
|
||||||
} |
|
||||||
|
|
||||||
// This function takes the data from s->write_slice_buffer and assembles into
|
|
||||||
// a contiguous byte stream with 5 byte gRPC header prepended.
|
|
||||||
static void create_grpc_frame(stream_obj *s) { |
|
||||||
gpr_slice slice = gpr_slice_buffer_take_first(&s->write_slice_buffer); |
|
||||||
uint8_t *raw_data = GPR_SLICE_START_PTR(slice); |
|
||||||
size_t length = GPR_SLICE_LENGTH(slice); |
|
||||||
s->write_buffer_size = length + GRPC_HEADER_SIZE_IN_BYTES; |
|
||||||
s->write_buffer = gpr_realloc(s->write_buffer, s->write_buffer_size); |
|
||||||
uint8_t *p = (uint8_t *)s->write_buffer; |
|
||||||
// Append 5 byte header
|
|
||||||
*p++ = 0; |
|
||||||
*p++ = (uint8_t)(length >> 24); |
|
||||||
*p++ = (uint8_t)(length >> 16); |
|
||||||
*p++ = (uint8_t)(length >> 8); |
|
||||||
*p++ = (uint8_t)(length); |
|
||||||
// append actual data
|
|
||||||
memcpy(p, raw_data, length); |
|
||||||
} |
|
||||||
|
|
||||||
static void do_write(stream_obj *s) { |
|
||||||
gpr_slice_buffer *sb = &s->write_slice_buffer; |
|
||||||
GPR_ASSERT(sb->count <= 1); |
|
||||||
if (sb->count > 0) { |
|
||||||
create_grpc_frame(s); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "W: cronet_bidirectional_stream_write"); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_write(s->cbs, s->write_buffer, |
|
||||||
(int)s->write_buffer_size, false); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
//
|
|
||||||
static void next_send_step(stream_obj *s) { |
|
||||||
switch (s->cronet_send_state) { |
|
||||||
case CRONET_SEND_IDLE: |
|
||||||
GPR_ASSERT( |
|
||||||
s->cbs); // cronet_bidirectional_stream is not initialized yet.
|
|
||||||
s->cronet_send_state = CRONET_REQ_STARTED; |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_bidirectional_stream_start to %s", s->url); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_start(s->cbs, s->url, 0, "POST", |
|
||||||
&s->header_array, false); |
|
||||||
// we no longer need the memory that was allocated earlier.
|
|
||||||
gpr_free(s->header_array.headers); |
|
||||||
break; |
|
||||||
case CRONET_SEND_HEADER: |
|
||||||
do_write(s); |
|
||||||
s->cronet_send_state = CRONET_WRITE; |
|
||||||
break; |
|
||||||
case CRONET_WRITE_COMPLETED: |
|
||||||
do_write(s); |
|
||||||
break; |
|
||||||
default: |
|
||||||
GPR_ASSERT(0); |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void convert_metadata_to_cronet_headers(grpc_linked_mdelem *head, |
|
||||||
const char *host, |
|
||||||
stream_obj *s) { |
|
||||||
grpc_linked_mdelem *curr = head; |
|
||||||
// Walk the linked list and get number of header fields
|
|
||||||
uint32_t num_headers_available = 0; |
|
||||||
while (curr != NULL) { |
|
||||||
curr = curr->next; |
|
||||||
num_headers_available++; |
|
||||||
} |
|
||||||
// Allocate enough memory
|
|
||||||
s->headers = (cronet_bidirectional_stream_header *)gpr_malloc( |
|
||||||
sizeof(cronet_bidirectional_stream_header) * num_headers_available); |
|
||||||
|
|
||||||
// Walk the linked list again, this time copying the header fields.
|
|
||||||
// s->num_headers
|
|
||||||
// can be less than num_headers_available, as some headers are not used for
|
|
||||||
// cronet
|
|
||||||
curr = head; |
|
||||||
s->num_headers = 0; |
|
||||||
while (s->num_headers < num_headers_available) { |
|
||||||
grpc_mdelem *mdelem = curr->md; |
|
||||||
curr = curr->next; |
|
||||||
const char *key = grpc_mdstr_as_c_string(mdelem->key); |
|
||||||
const char *value = grpc_mdstr_as_c_string(mdelem->value); |
|
||||||
if (strcmp(key, ":scheme") == 0 || strcmp(key, ":method") == 0 || |
|
||||||
strcmp(key, ":authority") == 0) { |
|
||||||
// Cronet populates these fields on its own.
|
|
||||||
continue; |
|
||||||
} |
|
||||||
if (strcmp(key, ":path") == 0) { |
|
||||||
// Create URL by appending :path value to the hostname
|
|
||||||
gpr_asprintf(&s->url, "https://%s%s", host, value); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "extracted URL = %s", s->url); |
|
||||||
} |
|
||||||
continue; |
|
||||||
} |
|
||||||
s->headers[s->num_headers].key = key; |
|
||||||
s->headers[s->num_headers].value = value; |
|
||||||
s->num_headers++; |
|
||||||
if (curr == NULL) { |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void perform_stream_op(grpc_exec_ctx *exec_ctx, grpc_transport *gt, |
|
||||||
grpc_stream *gs, grpc_transport_stream_op *op) { |
|
||||||
grpc_cronet_transport *ct = (grpc_cronet_transport *)gt; |
|
||||||
GPR_ASSERT(ct->engine); |
|
||||||
stream_obj *s = (stream_obj *)gs; |
|
||||||
if (op->recv_trailing_metadata) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, |
|
||||||
"perform_stream_op - recv_trailing_metadata: on_complete=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
s->recv_trailing_metadata = op->recv_trailing_metadata; |
|
||||||
GPR_ASSERT(!s->callback_list[CB_RECV_TRAILING_METADATA][0]); |
|
||||||
s->callback_list[CB_RECV_TRAILING_METADATA][0] = op->on_complete; |
|
||||||
} |
|
||||||
if (op->recv_message) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "perform_stream_op - recv_message: on_complete=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
s->recv_message = (grpc_byte_buffer **)op->recv_message; |
|
||||||
GPR_ASSERT(!s->callback_list[CB_RECV_MESSAGE][0]); |
|
||||||
GPR_ASSERT(!s->callback_list[CB_RECV_MESSAGE][1]); |
|
||||||
s->callback_list[CB_RECV_MESSAGE][0] = op->recv_message_ready; |
|
||||||
s->callback_list[CB_RECV_MESSAGE][1] = op->on_complete; |
|
||||||
s->read_requested = true; |
|
||||||
next_recv_step(s, PERFORM_STREAM_OP); |
|
||||||
} |
|
||||||
if (op->recv_initial_metadata) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "perform_stream_op - recv_initial_metadata:=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
s->recv_initial_metadata = op->recv_initial_metadata; |
|
||||||
GPR_ASSERT(!s->callback_list[CB_RECV_INITIAL_METADATA][0]); |
|
||||||
GPR_ASSERT(!s->callback_list[CB_RECV_INITIAL_METADATA][1]); |
|
||||||
s->callback_list[CB_RECV_INITIAL_METADATA][0] = |
|
||||||
op->recv_initial_metadata_ready; |
|
||||||
s->callback_list[CB_RECV_INITIAL_METADATA][1] = op->on_complete; |
|
||||||
} |
|
||||||
if (op->send_initial_metadata) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, |
|
||||||
"perform_stream_op - send_initial_metadata: on_complete=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
s->num_headers = 0; |
|
||||||
convert_metadata_to_cronet_headers(op->send_initial_metadata->list.head, |
|
||||||
ct->host, s); |
|
||||||
s->header_array.count = s->num_headers; |
|
||||||
s->header_array.capacity = s->num_headers; |
|
||||||
s->header_array.headers = s->headers; |
|
||||||
GPR_ASSERT(!s->callback_list[CB_SEND_INITIAL_METADATA][0]); |
|
||||||
s->callback_list[CB_SEND_INITIAL_METADATA][0] = op->on_complete; |
|
||||||
} |
|
||||||
if (op->send_message) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "perform_stream_op - send_message: on_complete=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
grpc_byte_stream_next(exec_ctx, op->send_message, &s->slice, |
|
||||||
op->send_message->length, NULL); |
|
||||||
// Check that compression flag is not ON. We don't support compression yet.
|
|
||||||
// TODO (makdharma): add compression support
|
|
||||||
GPR_ASSERT(op->send_message->flags == 0); |
|
||||||
gpr_slice_buffer_add(&s->write_slice_buffer, s->slice); |
|
||||||
if (s->cbs == NULL) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_bidirectional_stream_create"); |
|
||||||
} |
|
||||||
s->cbs = cronet_bidirectional_stream_create(ct->engine, s, &callbacks); |
|
||||||
GPR_ASSERT(s->cbs); |
|
||||||
s->read_closed = false; |
|
||||||
s->response_trailers_received = false; |
|
||||||
s->response_headers_received = false; |
|
||||||
s->cronet_send_state = CRONET_SEND_IDLE; |
|
||||||
s->cronet_recv_state = CRONET_RECV_IDLE; |
|
||||||
} |
|
||||||
GPR_ASSERT(!s->callback_list[CB_SEND_MESSAGE][0]); |
|
||||||
s->callback_list[CB_SEND_MESSAGE][0] = op->on_complete; |
|
||||||
next_send_step(s); |
|
||||||
} |
|
||||||
if (op->send_trailing_metadata) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, |
|
||||||
"perform_stream_op - send_trailing_metadata: on_complete=%p", |
|
||||||
op->on_complete); |
|
||||||
} |
|
||||||
GPR_ASSERT(!s->callback_list[CB_SEND_TRAILING_METADATA][0]); |
|
||||||
s->callback_list[CB_SEND_TRAILING_METADATA][0] = op->on_complete; |
|
||||||
if (s->cbs) { |
|
||||||
// Send an "empty" write to the far end to signal that we're done.
|
|
||||||
// This will induce the server to send down trailers.
|
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "W: cronet_bidirectional_stream_write"); |
|
||||||
} |
|
||||||
cronet_bidirectional_stream_write(s->cbs, "abc", 0, true); |
|
||||||
} else { |
|
||||||
// We never created a stream. This was probably an empty request.
|
|
||||||
invoke_closing_callback(s); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static int init_stream(grpc_exec_ctx *exec_ctx, grpc_transport *gt, |
|
||||||
grpc_stream *gs, grpc_stream_refcount *refcount, |
|
||||||
const void *server_data) { |
|
||||||
stream_obj *s = (stream_obj *)gs; |
|
||||||
memset(s->callback_list, 0, sizeof(s->callback_list)); |
|
||||||
s->cbs = NULL; |
|
||||||
gpr_mu_init(&s->recv_mu); |
|
||||||
s->read_buffer = gpr_malloc(GRPC_HEADER_SIZE_IN_BYTES); |
|
||||||
s->write_buffer = gpr_malloc(GRPC_HEADER_SIZE_IN_BYTES); |
|
||||||
gpr_slice_buffer_init(&s->write_slice_buffer); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "cronet_transport - init_stream"); |
|
||||||
} |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
static void destroy_stream(grpc_exec_ctx *exec_ctx, grpc_transport *gt, |
|
||||||
grpc_stream *gs, void *and_free_memory) { |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "Destroy stream"); |
|
||||||
} |
|
||||||
stream_obj *s = (stream_obj *)gs; |
|
||||||
s->cbs = NULL; |
|
||||||
gpr_free(s->read_buffer); |
|
||||||
gpr_free(s->write_buffer); |
|
||||||
gpr_free(s->url); |
|
||||||
gpr_mu_destroy(&s->recv_mu); |
|
||||||
if (and_free_memory) { |
|
||||||
gpr_free(and_free_memory); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void destroy_transport(grpc_exec_ctx *exec_ctx, grpc_transport *gt) { |
|
||||||
grpc_cronet_transport *ct = (grpc_cronet_transport *)gt; |
|
||||||
gpr_free(ct->host); |
|
||||||
if (grpc_cronet_trace) { |
|
||||||
gpr_log(GPR_DEBUG, "Destroy transport"); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
const grpc_transport_vtable grpc_cronet_vtable = { |
|
||||||
sizeof(stream_obj), "cronet_http", init_stream, |
|
||||||
set_pollset_do_nothing, perform_stream_op, NULL, |
|
||||||
destroy_stream, destroy_transport, NULL}; |
|
||||||
@ -1,202 +0,0 @@ |
|||||||
// Copyright 2016 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 COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_ |
|
||||||
#define COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_ |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
extern "C" { |
|
||||||
#endif |
|
||||||
|
|
||||||
#include <stddef.h> |
|
||||||
|
|
||||||
/* Cronet Engine API. */ |
|
||||||
|
|
||||||
/* Opaque object representing Cronet Engine. Created and configured outside
|
|
||||||
* of this API to facilitate sharing with other components */ |
|
||||||
typedef struct cronet_engine { void* obj; } cronet_engine; |
|
||||||
|
|
||||||
void cronet_engine_add_quic_hint(cronet_engine* engine, |
|
||||||
const char* host, |
|
||||||
int port, |
|
||||||
int alternate_port); |
|
||||||
|
|
||||||
/* Cronet Bidirectional Stream API */ |
|
||||||
|
|
||||||
/* Opaque object representing Cronet Bidirectional Stream. */ |
|
||||||
typedef struct cronet_bidirectional_stream { |
|
||||||
void* obj; |
|
||||||
void* annotation; |
|
||||||
} cronet_bidirectional_stream; |
|
||||||
|
|
||||||
/* A single request or response header element. */ |
|
||||||
typedef struct cronet_bidirectional_stream_header { |
|
||||||
const char* key; |
|
||||||
const char* value; |
|
||||||
} cronet_bidirectional_stream_header; |
|
||||||
|
|
||||||
/* Array of request or response headers or trailers. */ |
|
||||||
typedef struct cronet_bidirectional_stream_header_array { |
|
||||||
size_t count; |
|
||||||
size_t capacity; |
|
||||||
cronet_bidirectional_stream_header* headers; |
|
||||||
} cronet_bidirectional_stream_header_array; |
|
||||||
|
|
||||||
/* Set of callbacks used to receive callbacks from bidirectional stream. */ |
|
||||||
typedef struct cronet_bidirectional_stream_callback { |
|
||||||
/* Invoked when request headers are sent. Indicates that stream has initiated
|
|
||||||
* the request. Consumer may call cronet_bidirectional_stream_write() to start |
|
||||||
* writing data. |
|
||||||
*/ |
|
||||||
void (*on_request_headers_sent)(cronet_bidirectional_stream* stream); |
|
||||||
|
|
||||||
/* Invoked when initial response headers are received.
|
|
||||||
* Consumer must call cronet_bidirectional_stream_read() to start reading. |
|
||||||
* Consumer may call cronet_bidirectional_stream_write() to start writing or |
|
||||||
* close the stream. Contents of |headers| is valid for duration of the call. |
|
||||||
*/ |
|
||||||
void (*on_response_headers_received)( |
|
||||||
cronet_bidirectional_stream* stream, |
|
||||||
const cronet_bidirectional_stream_header_array* headers, |
|
||||||
const char* negotiated_protocol); |
|
||||||
|
|
||||||
/* Invoked when data is read into the buffer passed to
|
|
||||||
* cronet_bidirectional_stream_read(). Only part of the buffer may be |
|
||||||
* populated. To continue reading, call cronet_bidirectional_stream_read(). |
|
||||||
* It may be invoked after on_response_trailers_received()}, if there was |
|
||||||
* pending read data before trailers were received. |
|
||||||
* |
|
||||||
* If count is 0, it means the remote side has signaled that it will send no |
|
||||||
* more data; future calls to cronet_bidirectional_stream_read() will result |
|
||||||
* in the on_data_read() callback or on_succeded() callback if |
|
||||||
* cronet_bidirectional_stream_write() was invoked with end_of_stream set to |
|
||||||
* true. |
|
||||||
*/ |
|
||||||
void (*on_read_completed)(cronet_bidirectional_stream* stream, |
|
||||||
char* data, |
|
||||||
int count); |
|
||||||
|
|
||||||
/**
|
|
||||||
* Invoked when all data passed to cronet_bidirectional_stream_write() is |
|
||||||
* sent. |
|
||||||
* To continue writing, call cronet_bidirectional_stream_write(). |
|
||||||
*/ |
|
||||||
void (*on_write_completed)(cronet_bidirectional_stream* stream, |
|
||||||
const char* data); |
|
||||||
|
|
||||||
/* Invoked when trailers are received before closing the stream. Only invoked
|
|
||||||
* when server sends trailers, which it may not. May be invoked while there is |
|
||||||
* read data remaining in local buffer. Contents of |trailers| is valid for |
|
||||||
* duration of the call. |
|
||||||
*/ |
|
||||||
void (*on_response_trailers_received)( |
|
||||||
cronet_bidirectional_stream* stream, |
|
||||||
const cronet_bidirectional_stream_header_array* trailers); |
|
||||||
|
|
||||||
/**
|
|
||||||
* Invoked when there is no data to be read or written and the stream is |
|
||||||
* closed successfully remotely and locally. Once invoked, no further callback |
|
||||||
* methods will be invoked. |
|
||||||
*/ |
|
||||||
void (*on_succeded)(cronet_bidirectional_stream* stream); |
|
||||||
|
|
||||||
/**
|
|
||||||
* Invoked if the stream failed for any reason after |
|
||||||
* cronet_bidirectional_stream_start(). HTTP/2 error codes are |
|
||||||
* mapped to chrome net error codes. Once invoked, no further callback methods |
|
||||||
* will be invoked. |
|
||||||
*/ |
|
||||||
void (*on_failed)(cronet_bidirectional_stream* stream, int net_error); |
|
||||||
|
|
||||||
/**
|
|
||||||
* Invoked if the stream was canceled via |
|
||||||
* cronet_bidirectional_stream_cancel(). Once invoked, no further callback |
|
||||||
* methods will be invoked. |
|
||||||
*/ |
|
||||||
void (*on_canceled)(cronet_bidirectional_stream* stream); |
|
||||||
} cronet_bidirectional_stream_callback; |
|
||||||
|
|
||||||
/* Create a new stream object that uses |engine| and |callback|. All stream
|
|
||||||
* tasks are performed asynchronously on the |engine| network thread. |callback| |
|
||||||
* methods are invoked synchronously on the |engine| network thread, but must |
|
||||||
* not run tasks on the current thread to prevent blocking networking operations |
|
||||||
* and causing exceptions during shutdown. The |annotation| is stored in |
|
||||||
* bidirectional stream for arbitrary use by application. |
|
||||||
* |
|
||||||
* Returned |cronet_bidirectional_stream*| is owned by the caller, and must be |
|
||||||
* destroyed using |cronet_bidirectional_stream_destroy|. |
|
||||||
* |
|
||||||
* Both |calback| and |engine| must remain valid until stream is destroyed. |
|
||||||
*/ |
|
||||||
cronet_bidirectional_stream* cronet_bidirectional_stream_create( |
|
||||||
cronet_engine* engine, |
|
||||||
void* annotation, |
|
||||||
cronet_bidirectional_stream_callback* callback); |
|
||||||
|
|
||||||
/* TBD: The following methods return int. Should it be a custom type? */ |
|
||||||
|
|
||||||
/* Destroy stream object. Destroy could be called from any thread, including
|
|
||||||
* network thread, but is posted, so |stream| is valid until calling task is |
|
||||||
* complete. |
|
||||||
*/ |
|
||||||
int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream); |
|
||||||
|
|
||||||
/* Start the stream by sending request to |url| using |method| and |headers|. If
|
|
||||||
* |end_of_stream| is true, then no data is expected to be written. |
|
||||||
*/ |
|
||||||
int cronet_bidirectional_stream_start( |
|
||||||
cronet_bidirectional_stream* stream, |
|
||||||
const char* url, |
|
||||||
int priority, |
|
||||||
const char* method, |
|
||||||
const cronet_bidirectional_stream_header_array* headers, |
|
||||||
bool end_of_stream); |
|
||||||
|
|
||||||
/* Read response data into |buffer| of |capacity| length. Must only be called at
|
|
||||||
* most once in response to each invocation of the |
|
||||||
* on_response_headers_received() and on_read_completed() methods of the |
|
||||||
* cronet_bidirectional_stream_callback. |
|
||||||
* Each call will result in an invocation of one of the callback's |
|
||||||
* on_read_completed method if data is read, its on_succeeded() method if |
|
||||||
* the stream is closed, or its on_failed() method if there's an error. |
|
||||||
*/ |
|
||||||
int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream, |
|
||||||
char* buffer, |
|
||||||
int capacity); |
|
||||||
|
|
||||||
/* Read response data into |buffer| of |capacity| length. Must only be called at
|
|
||||||
* most once in response to each invocation of the |
|
||||||
* on_response_headers_received() and on_read_completed() methods of the |
|
||||||
* cronet_bidirectional_stream_callback. |
|
||||||
* Each call will result in an invocation of one of the callback's |
|
||||||
* on_read_completed method if data is read, its on_succeeded() method if |
|
||||||
* the stream is closed, or its on_failed() method if there's an error. |
|
||||||
*/ |
|
||||||
int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream, |
|
||||||
const char* buffer, |
|
||||||
int count, |
|
||||||
bool end_of_stream); |
|
||||||
|
|
||||||
/* Cancels the stream. Can be called at any time after
|
|
||||||
* cronet_bidirectional_stream_start(). The on_canceled() method of |
|
||||||
* cronet_bidirectional_stream_callback will be invoked when cancelation |
|
||||||
* is complete and no further callback methods will be invoked. If the |
|
||||||
* stream has completed or has not started, calling |
|
||||||
* cronet_bidirectional_stream_cancel() has no effect and on_canceled() will not |
|
||||||
* be invoked. At most one callback method may be invoked after |
|
||||||
* cronet_bidirectional_stream_cancel() has completed. |
|
||||||
*/ |
|
||||||
int cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream); |
|
||||||
|
|
||||||
/* Returns true if the |stream| was successfully started and is now done
|
|
||||||
* (succeeded, canceled, or failed). |
|
||||||
* Returns false if the |stream| stream is not yet started or is in progress. |
|
||||||
*/ |
|
||||||
bool cronet_bidirectional_stream_is_done(cronet_bidirectional_stream* stream); |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
#endif // COMPONENTS_CRONET_IOS_CRONET_C_FOR_GRPC_H_
|
|
||||||
Loading…
Reference in new issue