Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First round of fixing up implicit 64->32 bit conversions

Browse Source
pull/3322/head
Craig Tiller 10 years ago
parent 0ebfaa04b0
commit f96dfc3cf8
40 changed files with 261 additions and 145 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      Makefile
  2. 1
      include/grpc/support/port_platform.h
  3. 2
      include/grpc/support/slice_buffer.h
  4. 2
      src/core/channel/channel_args.c
  5. 3
      src/core/channel/compress_filter.c
  6. 10
      src/core/compression/message_compress.c
  7. 4
      src/core/iomgr/alarm.c
  8. 4
      src/core/iomgr/alarm_heap.c
  9. 3
      src/core/iomgr/tcp_client_posix.c
  10. 7
      src/core/iomgr/tcp_server_posix.c
  11. 7
      src/core/iomgr/udp_server.c
  12. 2
      src/core/iomgr/wakeup_fd_pipe.c
  13. 8
      src/core/security/jwt_verifier.c
  14. 2
      src/core/support/slice_buffer.c
  15. 8
      src/core/support/stack_lockfree.c
  16. 14
      src/core/surface/call.c
  17. 13
      src/core/surface/server.c
  18. 6
      src/core/transport/chttp2/frame_goaway.c
  19. 2
      src/core/transport/chttp2/frame_settings.c
  20. 3
      src/core/transport/chttp2/hpack_parser.c
  21. 4
      src/core/transport/chttp2/parsing.c
  22. 39
      src/core/transport/chttp2/stream_encoder.c
  23. 2
      src/core/transport/chttp2/timeout_encoding.c
  24. 12
      src/core/transport/chttp2/writing.c
  25. 19
      src/core/transport/chttp2_transport.c
  26. 2
      src/core/transport/transport.h
  27. 9
      src/core/tsi/fake_transport_security.c
  28. 64
      src/core/tsi/ssl_transport_security.c
  29. 7
      templates/Makefile.template
  30. 34
      test/build/empty.c
  31. 2
      test/core/compression/message_compress_test.c
  32. 2
      test/core/fling/server.c
  33. 2
      test/core/iomgr/fd_posix_test.c
  34. 2
      test/core/iomgr/udp_server_test.c
  35. 4
      test/core/support/murmur_hash_test.c
  36. 7
      test/core/support/stack_lockfree_test.c
  37. 2
      test/core/transport/chttp2/hpack_table_test.c
  38. 4
      test/core/transport/chttp2/stream_encoder_test.c
  39. 40
      test/core/transport/chttp2/stream_map_test.c
  40. 33
      tools/codegen/core/gen_hpack_tables.c

7
Makefile
Unescape View File

@ -231,6 +231,10 @@ endif
CXX11_CHECK_CMD = $(CXX) -std=c++11 -o $(TMPOUT) -c test/build/c++11.cc CXX11_CHECK_CMD = $(CXX) -std=c++11 -o $(TMPOUT) -c test/build/c++11.cc
HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false) HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false)
# Detect if -Wshorten-64-to-32 is a thing
SHORTEN_64_TO_32_CHECK_CMD = $(CC) -Wshorten-64-to-32 test/build/empty.c
HAS_SHORTEN_64_TO_32 = $(shell $(SHORTEN_64_TO_32_CHECK_CMD) 2> /dev/null && echo true || echo false)
# The HOST compiler settings are used to compile the protoc plugins. # The HOST compiler settings are used to compile the protoc plugins.
# In most cases, you won't have to change anything, but if you are # In most cases, you won't have to change anything, but if you are
# cross-compiling, you can override these variables from GNU make's # cross-compiling, you can override these variables from GNU make's
@ -246,6 +250,9 @@ DEFINES += $(EXTRA_DEFINES)
endif endif
CFLAGS += -std=c89 -pedantic -Wsign-conversion CFLAGS += -std=c89 -pedantic -Wsign-conversion
ifeq ($(HAS_SHORTEN_64_TO_32),true)
CFLAGS += -Wshorten-64-to-32
endif
ifeq ($(HAS_CXX11),true) ifeq ($(HAS_CXX11),true)
CXXFLAGS += -std=c++11 CXXFLAGS += -std=c++11
else else

1
include/grpc/support/port_platform.h
Unescape View File

@ -318,6 +318,7 @@ typedef uintptr_t gpr_uintptr;
/* INT64_MAX is unavailable on some platforms. */ /* INT64_MAX is unavailable on some platforms. */
#define GPR_INT64_MAX (gpr_int64)(~(gpr_uint64)0 >> 1) #define GPR_INT64_MAX (gpr_int64)(~(gpr_uint64)0 >> 1)
#define GPR_UINT32_MAX (~(gpr_uint32)0)
/* maximum alignment needed for any type on this platform, rounded up to a /* maximum alignment needed for any type on this platform, rounded up to a
power of two */ power of two */

2
include/grpc/support/slice_buffer.h
Unescape View File

@ -77,7 +77,7 @@ size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice slice);
void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices, size_t n); void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices, size_t n);
/* add a very small (less than 8 bytes) amount of data to the end of a slice /* add a very small (less than 8 bytes) amount of data to the end of a slice
buffer: returns a pointer into which to add the data */ buffer: returns a pointer into which to add the data */
gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned len); gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t len);
/* pop the last buffer, but don't unref it */ /* pop the last buffer, but don't unref it */
void gpr_slice_buffer_pop(gpr_slice_buffer *sb); void gpr_slice_buffer_pop(gpr_slice_buffer *sb);
/* clear a slice buffer, unref all elements */ /* clear a slice buffer, unref all elements */

2
src/core/channel/channel_args.c
Unescape View File

@ -132,7 +132,7 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
for (i = 0; i < a->num_args; ++i) { for (i = 0; i < a->num_args; ++i) {
if (a->args[i].type == GRPC_ARG_INTEGER && if (a->args[i].type == GRPC_ARG_INTEGER &&
!strcmp(GRPC_COMPRESSION_ALGORITHM_ARG, a->args[i].key)) { !strcmp(GRPC_COMPRESSION_ALGORITHM_ARG, a->args[i].key)) {
return a->args[i].value.integer; return (grpc_compression_algorithm)a->args[i].value.integer;
break; break;
} }
} }

3
src/core/channel/compress_filter.c
Unescape View File

@ -142,8 +142,9 @@ static void finish_compressed_sopb(grpc_stream_op_buffer *send_ops,
grpc_stream_op *sop = &send_ops->ops[i]; grpc_stream_op *sop = &send_ops->ops[i];
switch (sop->type) { switch (sop->type) {
case GRPC_OP_BEGIN_MESSAGE: case GRPC_OP_BEGIN_MESSAGE:
GPR_ASSERT(calld->slices.length <= GPR_UINT32_MAX);
grpc_sopb_add_begin_message( grpc_sopb_add_begin_message(
&new_send_ops, calld->slices.length, &new_send_ops, (gpr_uint32)calld->slices.length,
sop->data.begin_message.flags | GRPC_WRITE_INTERNAL_COMPRESS); sop->data.begin_message.flags | GRPC_WRITE_INTERNAL_COMPRESS);
break; break;
case GRPC_OP_SLICE: case GRPC_OP_SLICE:

10
src/core/compression/message_compress.c
Unescape View File

@ -49,19 +49,23 @@ static int zlib_body(z_stream *zs, gpr_slice_buffer *input,
int flush; int flush;
size_t i; size_t i;
gpr_slice outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE); gpr_slice outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
const uInt uint_max = ~(uInt)0;
zs->avail_out = GPR_SLICE_LENGTH(outbuf); GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
zs->next_out = GPR_SLICE_START_PTR(outbuf); zs->next_out = GPR_SLICE_START_PTR(outbuf);
flush = Z_NO_FLUSH; flush = Z_NO_FLUSH;
for (i = 0; i < input->count; i++) { for (i = 0; i < input->count; i++) {
if (i == input->count - 1) flush = Z_FINISH; if (i == input->count - 1) flush = Z_FINISH;
zs->avail_in = GPR_SLICE_LENGTH(input->slices[i]); GPR_ASSERT(GPR_SLICE_LENGTH(input->slices[i]) <= uint_max);
zs->avail_in = (uInt)GPR_SLICE_LENGTH(input->slices[i]);
zs->next_in = GPR_SLICE_START_PTR(input->slices[i]); zs->next_in = GPR_SLICE_START_PTR(input->slices[i]);
do { do {
if (zs->avail_out == 0) { if (zs->avail_out == 0) {
gpr_slice_buffer_add_indexed(output, outbuf); gpr_slice_buffer_add_indexed(output, outbuf);
outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE); outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
zs->avail_out = GPR_SLICE_LENGTH(outbuf); GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
zs->next_out = GPR_SLICE_START_PTR(outbuf); zs->next_out = GPR_SLICE_START_PTR(outbuf);
} }
r = flate(zs, flush); r = flate(zs, flush);

4
src/core/iomgr/alarm.c
Unescape View File

@ -145,7 +145,7 @@ static void list_remove(grpc_alarm *alarm) {
alarm->prev->next = alarm->next; alarm->prev->next = alarm->next;
} }
static void swap_adjacent_shards_in_queue(size_t first_shard_queue_index) { static void swap_adjacent_shards_in_queue(gpr_uint32 first_shard_queue_index) {
shard_type *temp; shard_type *temp;
temp = g_shard_queue[first_shard_queue_index]; temp = g_shard_queue[first_shard_queue_index];
g_shard_queue[first_shard_queue_index] = g_shard_queue[first_shard_queue_index] =
@ -355,7 +355,7 @@ static int run_some_expired_alarms(gpr_mu *drop_mu, gpr_timespec now,
gpr_mu_lock(drop_mu); gpr_mu_lock(drop_mu);
} }
return n; return (int)n;
} }
int grpc_alarm_check(gpr_mu *drop_mu, gpr_timespec now, gpr_timespec *next) { int grpc_alarm_check(gpr_mu *drop_mu, gpr_timespec now, gpr_timespec *next) {

4
src/core/iomgr/alarm_heap.c
Unescape View File

@ -45,7 +45,7 @@
its argument. */ its argument. */
static void adjust_upwards(grpc_alarm **first, gpr_uint32 i, grpc_alarm *t) { static void adjust_upwards(grpc_alarm **first, gpr_uint32 i, grpc_alarm *t) {
while (i > 0) { while (i > 0) {
gpr_uint32 parent = (i - 1u) / 2u; gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
if (gpr_time_cmp(first[parent]->deadline, t->deadline) >= 0) break; if (gpr_time_cmp(first[parent]->deadline, t->deadline) >= 0) break;
first[i] = first[parent]; first[i] = first[parent];
first[i]->heap_index = i; first[i]->heap_index = i;
@ -94,7 +94,7 @@ static void maybe_shrink(grpc_alarm_heap *heap) {
static void note_changed_priority(grpc_alarm_heap *heap, grpc_alarm *alarm) { static void note_changed_priority(grpc_alarm_heap *heap, grpc_alarm *alarm) {
gpr_uint32 i = alarm->heap_index; gpr_uint32 i = alarm->heap_index;
gpr_uint32 parent = (i - 1u) / 2u; gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
if (gpr_time_cmp(heap->alarms[parent]->deadline, alarm->deadline) < 0) { if (gpr_time_cmp(heap->alarms[parent]->deadline, alarm->deadline) < 0) {
adjust_upwards(heap->alarms, i, alarm); adjust_upwards(heap->alarms, i, alarm);
} else { } else {

3
src/core/iomgr/tcp_client_posix.c
Unescape View File

@ -229,7 +229,8 @@ void grpc_tcp_client_connect(void (*cb)(void *arg, grpc_endpoint *ep),
} }
do { do {
err = connect(fd, addr, addr_len); GPR_ASSERT(addr_len < ~(socklen_t)0);
err = connect(fd, addr, (socklen_t)addr_len);
} while (err < 0 && errno == EINTR); } while (err < 0 && errno == EINTR);
addr_str = grpc_sockaddr_to_uri(addr); addr_str = grpc_sockaddr_to_uri(addr);

7
src/core/iomgr/tcp_server_posix.c
Unescape View File

@ -83,7 +83,7 @@ typedef struct {
struct sockaddr sockaddr; struct sockaddr sockaddr;
struct sockaddr_un un; struct sockaddr_un un;
} addr; } addr;
int addr_len; size_t addr_len;
grpc_iomgr_closure read_closure; grpc_iomgr_closure read_closure;
grpc_iomgr_closure destroyed_closure; grpc_iomgr_closure destroyed_closure;
} server_port; } server_port;
@ -236,7 +236,7 @@ static void init_max_accept_queue_size(void) {
char *end; char *end;
long i = strtol(buf, &end, 10); long i = strtol(buf, &end, 10);
if (i > 0 && i <= INT_MAX && end && *end == 0) { if (i > 0 && i <= INT_MAX && end && *end == 0) {
n = i; n = (int)i;
} }
} }
fclose(fp); fclose(fp);
@ -274,7 +274,8 @@ static int prepare_socket(int fd, const struct sockaddr *addr,
goto error; goto error;
} }
if (bind(fd, addr, addr_len) < 0) { GPR_ASSERT(addr_len < ~(socklen_t)0);
if (bind(fd, addr, (socklen_t)addr_len) < 0) {
char *addr_str; char *addr_str;
grpc_sockaddr_to_string(&addr_str, addr, 0); grpc_sockaddr_to_string(&addr_str, addr, 0);
gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno)); gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));

7
src/core/iomgr/udp_server.c
Unescape View File

@ -78,7 +78,7 @@ typedef struct {
struct sockaddr sockaddr; struct sockaddr sockaddr;
struct sockaddr_un un; struct sockaddr_un un;
} addr; } addr;
int addr_len; size_t addr_len;
grpc_iomgr_closure read_closure; grpc_iomgr_closure read_closure;
grpc_iomgr_closure destroyed_closure; grpc_iomgr_closure destroyed_closure;
grpc_udp_server_read_cb read_cb; grpc_udp_server_read_cb read_cb;
@ -242,7 +242,8 @@ static int prepare_socket(int fd, const struct sockaddr *addr,
#endif #endif
} }
if (bind(fd, addr, addr_len) < 0) { GPR_ASSERT(addr_len < ~(socklen_t)0);
if (bind(fd, addr, (socklen_t)addr_len) < 0) {
char *addr_str; char *addr_str;
grpc_sockaddr_to_string(&addr_str, addr, 0); grpc_sockaddr_to_string(&addr_str, addr, 0);
gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno)); gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
@ -431,7 +432,7 @@ void grpc_udp_server_start(grpc_udp_server *s, grpc_pollset **pollsets,
/* TODO(rjshade): Add a test for this method. */ /* TODO(rjshade): Add a test for this method. */
void grpc_udp_server_write(server_port *sp, const char *buffer, size_t buf_len, void grpc_udp_server_write(server_port *sp, const char *buffer, size_t buf_len,
const struct sockaddr *peer_address) { const struct sockaddr *peer_address) {
int rc; ssize_t rc;
rc = sendto(sp->fd, buffer, buf_len, 0, peer_address, sizeof(peer_address)); rc = sendto(sp->fd, buffer, buf_len, 0, peer_address, sizeof(peer_address));
if (rc < 0) { if (rc < 0) {
gpr_log(GPR_ERROR, "Unable to send data: %s", strerror(errno)); gpr_log(GPR_ERROR, "Unable to send data: %s", strerror(errno));

2
src/core/iomgr/wakeup_fd_pipe.c
Unescape View File

@ -56,7 +56,7 @@ static void pipe_init(grpc_wakeup_fd *fd_info) {
static void pipe_consume(grpc_wakeup_fd *fd_info) { static void pipe_consume(grpc_wakeup_fd *fd_info) {
char buf[128]; char buf[128];
int r; ssize_t r;
for (;;) { for (;;) {
r = read(fd_info->read_fd, buf, sizeof(buf)); r = read(fd_info->read_fd, buf, sizeof(buf));

8
src/core/security/jwt_verifier.c
Unescape View File

@ -33,6 +33,7 @@
#include "src/core/security/jwt_verifier.h" #include "src/core/security/jwt_verifier.h"
#include <limits.h>
#include <string.h> #include <string.h>
#include "src/core/httpcli/httpcli.h" #include "src/core/httpcli/httpcli.h"
@ -412,7 +413,9 @@ static EVP_PKEY *extract_pkey_from_x509(const char *x509_str) {
X509 *x509 = NULL; X509 *x509 = NULL;
EVP_PKEY *result = NULL; EVP_PKEY *result = NULL;
BIO *bio = BIO_new(BIO_s_mem()); BIO *bio = BIO_new(BIO_s_mem());
BIO_write(bio, x509_str, strlen(x509_str)); size_t len = strlen(x509_str);
GPR_ASSERT(len < INT_MAX);
BIO_write(bio, x509_str, (int)len);
x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL); x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
if (x509 == NULL) { if (x509 == NULL) {
gpr_log(GPR_ERROR, "Unable to parse x509 cert."); gpr_log(GPR_ERROR, "Unable to parse x509 cert.");
@ -439,7 +442,8 @@ static BIGNUM *bignum_from_base64(const char *b64) {
gpr_log(GPR_ERROR, "Invalid base64 for big num."); gpr_log(GPR_ERROR, "Invalid base64 for big num.");
return NULL; return NULL;
} }
result = BN_bin2bn(GPR_SLICE_START_PTR(bin), GPR_SLICE_LENGTH(bin), NULL); result =
BN_bin2bn(GPR_SLICE_START_PTR(bin), (int)GPR_SLICE_LENGTH(bin), NULL);
gpr_slice_unref(bin); gpr_slice_unref(bin);
return result; return result;
} }

2
src/core/support/slice_buffer.c
Unescape View File

@ -69,7 +69,7 @@ void gpr_slice_buffer_destroy(gpr_slice_buffer *sb) {
} }
} }
gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned n) { gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t n) {
gpr_slice *back; gpr_slice *back;
gpr_uint8 *out; gpr_uint8 *out;

8
src/core/support/stack_lockfree.c
Unescape View File

@ -123,13 +123,13 @@ int gpr_stack_lockfree_push(gpr_stack_lockfree *stack, int entry) {
#ifndef NDEBUG #ifndef NDEBUG
/* Check for double push */ /* Check for double push */
{ {
int pushed_index = entry / (8 * sizeof(gpr_atm)); int pushed_index = entry / (int)(8 * sizeof(gpr_atm));
int pushed_bit = entry % (8 * sizeof(gpr_atm)); int pushed_bit = entry % (int)(8 * sizeof(gpr_atm));
gpr_atm old_val; gpr_atm old_val;
old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index], old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index],
(gpr_atm)(1UL << pushed_bit)); (gpr_atm)(1UL << pushed_bit));
GPR_ASSERT((old_val & (1UL << pushed_bit)) == 0); GPR_ASSERT((old_val & (gpr_atm)(1UL << pushed_bit)) == 0);
} }
#endif #endif
@ -167,7 +167,7 @@ int gpr_stack_lockfree_pop(gpr_stack_lockfree *stack) {
old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index], old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index],
-(gpr_atm)(1UL << pushed_bit)); -(gpr_atm)(1UL << pushed_bit));
GPR_ASSERT((old_val & (1UL << pushed_bit)) != 0); GPR_ASSERT((old_val & (gpr_atm)(1UL << pushed_bit)) != 0);
} }
#endif #endif

14
src/core/surface/call.c
Unescape View File

@ -508,7 +508,7 @@ static void set_status_code(grpc_call *call, status_source source,
if (call->status[source].is_set) return; if (call->status[source].is_set) return;
call->status[source].is_set = 1; call->status[source].is_set = 1;
call->status[source].code = status; call->status[source].code = (grpc_status_code)status;
call->error_status_set = status != GRPC_STATUS_OK; call->error_status_set = status != GRPC_STATUS_OK;
if (status != GRPC_STATUS_OK && !grpc_bbq_empty(&call->incoming_queue)) { if (status != GRPC_STATUS_OK && !grpc_bbq_empty(&call->incoming_queue)) {
@ -604,7 +604,7 @@ static void unlock(grpc_call *call) {
int completing_requests = 0; int completing_requests = 0;
int start_op = 0; int start_op = 0;
int i; int i;
const gpr_uint32 MAX_RECV_PEEK_AHEAD = 65536; const size_t MAX_RECV_PEEK_AHEAD = 65536;
size_t buffered_bytes; size_t buffered_bytes;
int cancel_alarm = 0; int cancel_alarm = 0;
@ -1107,10 +1107,12 @@ static int fill_send_ops(grpc_call *call, grpc_transport_stream_op *op) {
/* fall through intended */ /* fall through intended */
case WRITE_STATE_STARTED: case WRITE_STATE_STARTED:
if (is_op_live(call, GRPC_IOREQ_SEND_MESSAGE)) { if (is_op_live(call, GRPC_IOREQ_SEND_MESSAGE)) {
size_t length;
data = call->request_data[GRPC_IOREQ_SEND_MESSAGE]; data = call->request_data[GRPC_IOREQ_SEND_MESSAGE];
flags = call->request_flags[GRPC_IOREQ_SEND_MESSAGE]; flags = call->request_flags[GRPC_IOREQ_SEND_MESSAGE];
grpc_sopb_add_begin_message( length = grpc_byte_buffer_length(data.send_message);
&call->send_ops, grpc_byte_buffer_length(data.send_message), flags); GPR_ASSERT(length <= GPR_UINT32_MAX);
grpc_sopb_add_begin_message(&call->send_ops, (gpr_uint32)length, flags);
copy_byte_buffer_to_stream_ops(data.send_message, &call->send_ops); copy_byte_buffer_to_stream_ops(data.send_message, &call->send_ops);
op->send_ops = &call->send_ops; op->send_ops = &call->send_ops;
call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE; call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE;
@ -1243,7 +1245,7 @@ static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
} }
if (op == GRPC_IOREQ_SEND_STATUS) { if (op == GRPC_IOREQ_SEND_STATUS) {
set_status_code(call, STATUS_FROM_SERVER_STATUS, set_status_code(call, STATUS_FROM_SERVER_STATUS,
reqs[i].data.send_status.code); (gpr_uint32)reqs[i].data.send_status.code);
if (reqs[i].data.send_status.details) { if (reqs[i].data.send_status.details) {
set_status_details(call, STATUS_FROM_SERVER_STATUS, set_status_details(call, STATUS_FROM_SERVER_STATUS,
GRPC_MDSTR_REF(reqs[i].data.send_status.details)); GRPC_MDSTR_REF(reqs[i].data.send_status.details));
@ -1333,7 +1335,7 @@ static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,
GPR_ASSERT(status != GRPC_STATUS_OK); GPR_ASSERT(status != GRPC_STATUS_OK);
set_status_code(c, STATUS_FROM_API_OVERRIDE, status); set_status_code(c, STATUS_FROM_API_OVERRIDE, (gpr_uint32)status);
set_status_details(c, STATUS_FROM_API_OVERRIDE, details); set_status_details(c, STATUS_FROM_API_OVERRIDE, details);
c->cancel_with_status = status; c->cancel_with_status = status;

13
src/core/surface/server.c
Unescape View File

@ -33,6 +33,7 @@
#include "src/core/surface/server.h" #include "src/core/surface/server.h"
#include <limits.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -804,7 +805,7 @@ grpc_server *grpc_server_create_from_filters(
server->request_freelist = server->request_freelist =
gpr_stack_lockfree_create(server->max_requested_calls); gpr_stack_lockfree_create(server->max_requested_calls);
for (i = 0; i < (size_t)server->max_requested_calls; i++) { for (i = 0; i < (size_t)server->max_requested_calls; i++) {
gpr_stack_lockfree_push(server->request_freelist, i); gpr_stack_lockfree_push(server->request_freelist, (int)i);
} }
request_matcher_init(&server->unregistered_request_matcher, request_matcher_init(&server->unregistered_request_matcher,
server->max_requested_calls); server->max_requested_calls);
@ -896,7 +897,7 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
grpc_mdstr *host; grpc_mdstr *host;
grpc_mdstr *method; grpc_mdstr *method;
gpr_uint32 hash; gpr_uint32 hash;
gpr_uint32 slots; size_t slots;
gpr_uint32 probes; gpr_uint32 probes;
gpr_uint32 max_probes = 0; gpr_uint32 max_probes = 0;
grpc_transport_op op; grpc_transport_op op;
@ -949,7 +950,8 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
crm->host = host; crm->host = host;
crm->method = method; crm->method = method;
} }
chand->registered_method_slots = slots; GPR_ASSERT(slots <= GPR_UINT32_MAX);
chand->registered_method_slots = (gpr_uint32)slots;
chand->registered_method_max_probes = max_probes; chand->registered_method_max_probes = max_probes;
} }
@ -970,7 +972,7 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
op.set_accept_stream_user_data = chand; op.set_accept_stream_user_data = chand;
op.on_connectivity_state_change = &chand->channel_connectivity_changed; op.on_connectivity_state_change = &chand->channel_connectivity_changed;
op.connectivity_state = &chand->connectivity_state; op.connectivity_state = &chand->connectivity_state;
op.disconnect = gpr_atm_acq_load(&s->shutdown_flag); op.disconnect = gpr_atm_acq_load(&s->shutdown_flag) != 0;
grpc_transport_perform_op(transport, &op); grpc_transport_perform_op(transport, &op);
} }
@ -1256,8 +1258,9 @@ static void done_request_event(void *req, grpc_cq_completion *c) {
if (rc >= server->requested_calls && if (rc >= server->requested_calls &&
rc < server->requested_calls + server->max_requested_calls) { rc < server->requested_calls + server->max_requested_calls) {
GPR_ASSERT(rc - server->requested_calls <= INT_MAX);
gpr_stack_lockfree_push(server->request_freelist, gpr_stack_lockfree_push(server->request_freelist,
rc - server->requested_calls); (int)(rc - server->requested_calls));
} else { } else {
gpr_free(req); gpr_free(req);
} }

6
src/core/transport/chttp2/frame_goaway.c
Unescape View File

@ -143,7 +143,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
transport_parsing->goaway_received = 1; transport_parsing->goaway_received = 1;
transport_parsing->goaway_last_stream_index = p->last_stream_id; transport_parsing->goaway_last_stream_index = p->last_stream_id;
gpr_slice_unref(transport_parsing->goaway_text); gpr_slice_unref(transport_parsing->goaway_text);
transport_parsing->goaway_error = p->error_code; transport_parsing->goaway_error = (grpc_status_code)p->error_code;
transport_parsing->goaway_text = transport_parsing->goaway_text =
gpr_slice_new(p->debug_data, p->debug_length, gpr_free); gpr_slice_new(p->debug_data, p->debug_length, gpr_free);
p->debug_data = NULL; p->debug_data = NULL;
@ -160,7 +160,9 @@ void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
gpr_slice_buffer *slice_buffer) { gpr_slice_buffer *slice_buffer) {
gpr_slice header = gpr_slice_malloc(9 + 4 + 4); gpr_slice header = gpr_slice_malloc(9 + 4 + 4);
gpr_uint8 *p = GPR_SLICE_START_PTR(header); gpr_uint8 *p = GPR_SLICE_START_PTR(header);
gpr_uint32 frame_length = 4 + 4 + GPR_SLICE_LENGTH(debug_data); gpr_uint32 frame_length;
GPR_ASSERT(GPR_SLICE_LENGTH(debug_data) < GPR_UINT32_MAX - 4 - 4);
frame_length = 4 + 4 + (gpr_uint32)GPR_SLICE_LENGTH(debug_data);
/* frame header: length */ /* frame header: length */
*p++ = frame_length >> 16; *p++ = frame_length >> 16;

2
src/core/transport/chttp2/frame_settings.c
Unescape View File

@ -76,7 +76,7 @@ static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new, gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new,
gpr_uint32 force_mask, size_t count) { gpr_uint32 force_mask, size_t count) {
size_t i; size_t i;
size_t n = 0; gpr_uint32 n = 0;
gpr_slice output; gpr_slice output;
gpr_uint8 *p; gpr_uint8 *p;

3
src/core/transport/chttp2/hpack_parser.c
Unescape View File

@ -1085,7 +1085,8 @@ static int parse_string_prefix(grpc_chttp2_hpack_parser *p,
static void append_bytes(grpc_chttp2_hpack_parser_string *str, static void append_bytes(grpc_chttp2_hpack_parser_string *str,
const gpr_uint8 *data, size_t length) { const gpr_uint8 *data, size_t length) {
if (length + str->length > str->capacity) { if (length + str->length > str->capacity) {
str->capacity = str->length + length; GPR_ASSERT(str->length + length <= GPR_UINT32_MAX);
str->capacity = (gpr_uint32)(str->length + length);
str->str = gpr_realloc(str->str, str->capacity); str->str = gpr_realloc(str->str, str->capacity);
} }
memcpy(str->str + str->length, data, length); memcpy(str->str + str->length, data, length);

4
src/core/transport/chttp2/parsing.c
Unescape View File

@ -131,7 +131,7 @@ void grpc_chttp2_publish_reads(
published later */ published later */
if (transport_parsing->goaway_received) { if (transport_parsing->goaway_received) {
grpc_chttp2_add_incoming_goaway(transport_global, grpc_chttp2_add_incoming_goaway(transport_global,
transport_parsing->goaway_error, (gpr_uint32)transport_parsing->goaway_error,
transport_parsing->goaway_text); transport_parsing->goaway_text);
transport_parsing->goaway_text = gpr_empty_slice(); transport_parsing->goaway_text = gpr_empty_slice();
transport_parsing->goaway_received = 0; transport_parsing->goaway_received = 0;
@ -212,7 +212,7 @@ void grpc_chttp2_publish_reads(
if (stream_parsing->saw_rst_stream) { if (stream_parsing->saw_rst_stream) {
stream_global->cancelled = 1; stream_global->cancelled = 1;
stream_global->cancelled_status = grpc_chttp2_http2_error_to_grpc_status( stream_global->cancelled_status = grpc_chttp2_http2_error_to_grpc_status(
stream_parsing->rst_stream_reason); (grpc_chttp2_error_code)stream_parsing->rst_stream_reason);
if (stream_parsing->rst_stream_reason == GRPC_CHTTP2_NO_ERROR) { if (stream_parsing->rst_stream_reason == GRPC_CHTTP2_NO_ERROR) {
stream_global->published_cancelled = 1; stream_global->published_cancelled = 1;
} }

39
src/core/transport/chttp2/stream_encoder.c
Unescape View File

@ -74,8 +74,9 @@ typedef struct {
} framer_state; } framer_state;
/* fills p (which is expected to be 9 bytes long) with a data frame header */ /* fills p (which is expected to be 9 bytes long) with a data frame header */
static void fill_header(gpr_uint8 *p, gpr_uint8 type, gpr_uint32 id, static void fill_header(gpr_uint8 *p, gpr_uint8 type, gpr_uint32 id, size_t len,
gpr_uint32 len, gpr_uint8 flags) { gpr_uint8 flags) {
GPR_ASSERT(len < 16777316);
*p++ = len >> 16; *p++ = len >> 16;
*p++ = len >> 8; *p++ = len >> 8;
*p++ = len; *p++ = len;
@ -185,7 +186,7 @@ static grpc_mdelem *add_elem(grpc_chttp2_hpack_compressor *c,
gpr_uint32 key_hash = elem->key->hash; gpr_uint32 key_hash = elem->key->hash;
gpr_uint32 elem_hash = GRPC_MDSTR_KV_HASH(key_hash, elem->value->hash); gpr_uint32 elem_hash = GRPC_MDSTR_KV_HASH(key_hash, elem->value->hash);
gpr_uint32 new_index = c->tail_remote_index + c->table_elems + 1; gpr_uint32 new_index = c->tail_remote_index + c->table_elems + 1;
gpr_uint32 elem_size = 32 + GPR_SLICE_LENGTH(elem->key->slice) + size_t elem_size = 32 + GPR_SLICE_LENGTH(elem->key->slice) +
GPR_SLICE_LENGTH(elem->value->slice); GPR_SLICE_LENGTH(elem->value->slice);
grpc_mdelem *elem_to_unref; grpc_mdelem *elem_to_unref;
@ -270,7 +271,7 @@ static grpc_mdelem *add_elem(grpc_chttp2_hpack_compressor *c,
static void emit_indexed(grpc_chttp2_hpack_compressor *c, gpr_uint32 index, static void emit_indexed(grpc_chttp2_hpack_compressor *c, gpr_uint32 index,
framer_state *st) { framer_state *st) {
size_t len = GRPC_CHTTP2_VARINT_LENGTH(index, 1); gpr_uint32 len = GRPC_CHTTP2_VARINT_LENGTH(index, 1);
GRPC_CHTTP2_WRITE_VARINT(index, 1, 0x80, add_tiny_header_data(st, len), len); GRPC_CHTTP2_WRITE_VARINT(index, 1, 0x80, add_tiny_header_data(st, len), len);
} }
@ -291,11 +292,13 @@ static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2); gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2);
gpr_uint8 huffman_prefix; gpr_uint8 huffman_prefix;
gpr_slice value_slice = get_wire_value(elem, &huffman_prefix); gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
gpr_uint32 len_val = GPR_SLICE_LENGTH(value_slice); size_t len_val = GPR_SLICE_LENGTH(value_slice);
gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1); gpr_uint32 len_val_len;
GPR_ASSERT(len_val <= GPR_UINT32_MAX);
len_val_len = GRPC_CHTTP2_VARINT_LENGTH((gpr_uint32)len_val, 1);
GRPC_CHTTP2_WRITE_VARINT(key_index, 2, 0x40, GRPC_CHTTP2_WRITE_VARINT(key_index, 2, 0x40,
add_tiny_header_data(st, len_pfx), len_pfx); add_tiny_header_data(st, len_pfx), len_pfx);
GRPC_CHTTP2_WRITE_VARINT(len_val, 1, 0x00, GRPC_CHTTP2_WRITE_VARINT((gpr_uint32)len_val, 1, 0x00,
add_tiny_header_data(st, len_val_len), len_val_len); add_tiny_header_data(st, len_val_len), len_val_len);
add_header_data(st, gpr_slice_ref(value_slice)); add_header_data(st, gpr_slice_ref(value_slice));
} }
@ -306,23 +309,27 @@ static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4); gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);
gpr_uint8 huffman_prefix; gpr_uint8 huffman_prefix;
gpr_slice value_slice = get_wire_value(elem, &huffman_prefix); gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
gpr_uint32 len_val = GPR_SLICE_LENGTH(value_slice); size_t len_val = GPR_SLICE_LENGTH(value_slice);
gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1); gpr_uint32 len_val_len;
GPR_ASSERT(len_val <= GPR_UINT32_MAX);
len_val_len = GRPC_CHTTP2_VARINT_LENGTH((gpr_uint32)len_val, 1);
GRPC_CHTTP2_WRITE_VARINT(key_index, 4, 0x00, GRPC_CHTTP2_WRITE_VARINT(key_index, 4, 0x00,
add_tiny_header_data(st, len_pfx), len_pfx); add_tiny_header_data(st, len_pfx), len_pfx);
GRPC_CHTTP2_WRITE_VARINT(len_val, 1, 0x00, GRPC_CHTTP2_WRITE_VARINT((gpr_uint32)len_val, 1, 0x00,
add_tiny_header_data(st, len_val_len), len_val_len); add_tiny_header_data(st, len_val_len), len_val_len);
add_header_data(st, gpr_slice_ref(value_slice)); add_header_data(st, gpr_slice_ref(value_slice));
} }
static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c, static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
grpc_mdelem *elem, framer_state *st) { grpc_mdelem *elem, framer_state *st) {
gpr_uint32 len_key = GPR_SLICE_LENGTH(elem->key->slice); gpr_uint32 len_key = (gpr_uint32)GPR_SLICE_LENGTH(elem->key->slice);
gpr_uint8 huffman_prefix; gpr_uint8 huffman_prefix;
gpr_slice value_slice = get_wire_value(elem, &huffman_prefix); gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
gpr_uint32 len_val = GPR_SLICE_LENGTH(value_slice); gpr_uint32 len_val = (gpr_uint32)GPR_SLICE_LENGTH(value_slice);
gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1); gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1); gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
GPR_ASSERT(len_key <= GPR_UINT32_MAX);
GPR_ASSERT(GPR_SLICE_LENGTH(value_slice) <= GPR_UINT32_MAX);
*add_tiny_header_data(st, 1) = 0x40; *add_tiny_header_data(st, 1) = 0x40;
GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00, GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00,
add_tiny_header_data(st, len_key_len), len_key_len); add_tiny_header_data(st, len_key_len), len_key_len);
@ -334,12 +341,14 @@ static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
static void emit_lithdr_noidx_v(grpc_chttp2_hpack_compressor *c, static void emit_lithdr_noidx_v(grpc_chttp2_hpack_compressor *c,
grpc_mdelem *elem, framer_state *st) { grpc_mdelem *elem, framer_state *st) {
gpr_uint32 len_key = GPR_SLICE_LENGTH(elem->key->slice); gpr_uint32 len_key = (gpr_uint32)GPR_SLICE_LENGTH(elem->key->slice);
gpr_uint8 huffman_prefix; gpr_uint8 huffman_prefix;
gpr_slice value_slice = get_wire_value(elem, &huffman_prefix); gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
gpr_uint32 len_val = GPR_SLICE_LENGTH(value_slice); gpr_uint32 len_val = (gpr_uint32)GPR_SLICE_LENGTH(value_slice);
gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1); gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1); gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
GPR_ASSERT(len_key <= GPR_UINT32_MAX);
GPR_ASSERT(GPR_SLICE_LENGTH(value_slice) <= GPR_UINT32_MAX);
*add_tiny_header_data(st, 1) = 0x00; *add_tiny_header_data(st, 1) = 0x00;
GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00, GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00,
add_tiny_header_data(st, len_key_len), len_key_len); add_tiny_header_data(st, len_key_len), len_key_len);
@ -565,7 +574,7 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
framer_state st; framer_state st;
gpr_slice slice; gpr_slice slice;
grpc_stream_op *op; grpc_stream_op *op;
gpr_uint32 max_take_size; size_t max_take_size;
gpr_uint32 curop = 0; gpr_uint32 curop = 0;
gpr_uint32 unref_op; gpr_uint32 unref_op;
grpc_mdctx *mdctx = compressor->mdctx; grpc_mdctx *mdctx = compressor->mdctx;

2
src/core/transport/chttp2/timeout_encoding.c
Unescape View File

@ -123,7 +123,7 @@ void grpc_chttp2_encode_timeout(gpr_timespec timeout, char *buffer) {
enc_nanos(buffer, timeout.tv_nsec); enc_nanos(buffer, timeout.tv_nsec);
} else if (timeout.tv_sec < 1000 && timeout.tv_nsec != 0) { } else if (timeout.tv_sec < 1000 && timeout.tv_nsec != 0) {
enc_micros(buffer, enc_micros(buffer,
timeout.tv_sec * 1000000 + (int)(timeout.tv_sec * 1000000) +
(timeout.tv_nsec / 1000 + (timeout.tv_nsec % 1000 != 0))); (timeout.tv_nsec / 1000 + (timeout.tv_nsec % 1000 != 0)));
} else { } else {
enc_seconds(buffer, timeout.tv_sec + (timeout.tv_nsec != 0)); enc_seconds(buffer, timeout.tv_sec + (timeout.tv_nsec != 0));

12
src/core/transport/chttp2/writing.c
Unescape View File

@ -32,10 +32,13 @@
*/ */
#include "src/core/transport/chttp2/internal.h" #include "src/core/transport/chttp2/internal.h"
#include "src/core/transport/chttp2/http2_errors.h"
#include <limits.h>
#include <grpc/support/log.h> #include <grpc/support/log.h>
#include "src/core/transport/chttp2/http2_errors.h"
static void finalize_outbuf(grpc_chttp2_transport_writing *transport_writing); static void finalize_outbuf(grpc_chttp2_transport_writing *transport_writing);
int grpc_chttp2_unlocking_check_writes( int grpc_chttp2_unlocking_check_writes(
@ -78,11 +81,12 @@ int grpc_chttp2_unlocking_check_writes(
stream_writing->send_closed = GRPC_DONT_SEND_CLOSED; stream_writing->send_closed = GRPC_DONT_SEND_CLOSED;
if (stream_global->outgoing_sopb) { if (stream_global->outgoing_sopb) {
window_delta = window_delta = grpc_chttp2_preencode(
grpc_chttp2_preencode(stream_global->outgoing_sopb->ops, stream_global->outgoing_sopb->ops,
&stream_global->outgoing_sopb->nops, &stream_global->outgoing_sopb->nops,
GPR_MIN(transport_global->outgoing_window, (gpr_uint32)GPR_MIN(GPR_MIN(transport_global->outgoing_window,
stream_global->outgoing_window), stream_global->outgoing_window),
GPR_UINT32_MAX),
&stream_writing->sopb); &stream_writing->sopb);
GRPC_CHTTP2_FLOWCTL_TRACE_TRANSPORT( GRPC_CHTTP2_FLOWCTL_TRACE_TRANSPORT(
"write", transport_global, outgoing_window, -(gpr_int64)window_delta); "write", transport_global, outgoing_window, -(gpr_int64)window_delta);

19
src/core/transport/chttp2_transport.c
Unescape View File

@ -692,7 +692,8 @@ static void perform_stream_op_locked(
op->max_recv_bytes - stream_global->max_recv_bytes); op->max_recv_bytes - stream_global->max_recv_bytes);
stream_global->unannounced_incoming_window += stream_global->unannounced_incoming_window +=
op->max_recv_bytes - stream_global->max_recv_bytes; op->max_recv_bytes - stream_global->max_recv_bytes;
stream_global->max_recv_bytes = op->max_recv_bytes; stream_global->max_recv_bytes =
(gpr_uint32)(GPR_MIN(op->max_recv_bytes, GPR_UINT32_MAX));
} }
grpc_chttp2_incoming_metadata_live_op_buffer_end( grpc_chttp2_incoming_metadata_live_op_buffer_end(
&stream_global->outstanding_metadata); &stream_global->outstanding_metadata);
@ -761,7 +762,7 @@ static void perform_transport_op(grpc_transport *gt, grpc_transport_op *op) {
t->global.sent_goaway = 1; t->global.sent_goaway = 1;
grpc_chttp2_goaway_append( grpc_chttp2_goaway_append(
t->global.last_incoming_stream_id, t->global.last_incoming_stream_id,
grpc_chttp2_grpc_status_to_http2_error(op->goaway_status), (gpr_uint32)grpc_chttp2_grpc_status_to_http2_error(op->goaway_status),
gpr_slice_ref(*op->goaway_message), &t->global.qbuf); gpr_slice_ref(*op->goaway_message), &t->global.qbuf);
close_transport = !grpc_chttp2_has_streams(t); close_transport = !grpc_chttp2_has_streams(t);
} }
@ -829,8 +830,9 @@ static void remove_stream(grpc_chttp2_transport *t, gpr_uint32 id) {
new_stream_count = grpc_chttp2_stream_map_size(&t->parsing_stream_map) + new_stream_count = grpc_chttp2_stream_map_size(&t->parsing_stream_map) +
grpc_chttp2_stream_map_size(&t->new_stream_map); grpc_chttp2_stream_map_size(&t->new_stream_map);
GPR_ASSERT(new_stream_count <= GPR_UINT32_MAX);
if (new_stream_count != t->global.concurrent_stream_count) { if (new_stream_count != t->global.concurrent_stream_count) {
t->global.concurrent_stream_count = new_stream_count; t->global.concurrent_stream_count = (gpr_uint32)new_stream_count;
maybe_start_some_streams(&t->global); maybe_start_some_streams(&t->global);
} }
} }
@ -943,7 +945,8 @@ static void cancel_from_api(grpc_chttp2_transport_global *transport_global,
gpr_slice_buffer_add( gpr_slice_buffer_add(
&transport_global->qbuf, &transport_global->qbuf,
grpc_chttp2_rst_stream_create( grpc_chttp2_rst_stream_create(
stream_global->id, grpc_chttp2_grpc_status_to_http2_error(status))); stream_global->id,
(gpr_uint32)grpc_chttp2_grpc_status_to_http2_error(status)));
} }
grpc_chttp2_list_add_read_write_state_changed(transport_global, grpc_chttp2_list_add_read_write_state_changed(transport_global,
stream_global); stream_global);
@ -989,11 +992,11 @@ static void close_from_api(grpc_chttp2_transport_global *transport_global,
*p++ = 's'; *p++ = 's';
if (status < 10) { if (status < 10) {
*p++ = 1; *p++ = 1;
*p++ = '0' + status; *p++ = (gpr_uint8)('0' + status);
} else { } else {
*p++ = 2; *p++ = 2;
*p++ = '0' + (status / 10); *p++ = (gpr_uint8)('0' + (status / 10));
*p++ = '0' + (status % 10); *p++ = (gpr_uint8)('0' + (status % 10));
} }
GPR_ASSERT(p == GPR_SLICE_END_PTR(status_hdr)); GPR_ASSERT(p == GPR_SLICE_END_PTR(status_hdr));
len += GPR_SLICE_LENGTH(status_hdr); len += GPR_SLICE_LENGTH(status_hdr);
@ -1121,7 +1124,7 @@ static int recv_data_loop(grpc_chttp2_transport *t, int *success) {
grpc_chttp2_stream_map_move_into(&t->new_stream_map, grpc_chttp2_stream_map_move_into(&t->new_stream_map,
&t->parsing_stream_map); &t->parsing_stream_map);
t->global.concurrent_stream_count = t->global.concurrent_stream_count =
grpc_chttp2_stream_map_size(&t->parsing_stream_map); (gpr_uint32)grpc_chttp2_stream_map_size(&t->parsing_stream_map);
if (t->parsing.initial_window_update != 0) { if (t->parsing.initial_window_update != 0) {
grpc_chttp2_stream_map_for_each(&t->parsing_stream_map, grpc_chttp2_stream_map_for_each(&t->parsing_stream_map,
update_global_window, t); update_global_window, t);

2
src/core/transport/transport.h
Unescape View File

@ -75,7 +75,7 @@ typedef struct grpc_transport_stream_op {
/** The number of bytes this peer is currently prepared to receive. /** The number of bytes this peer is currently prepared to receive.
These bytes will be eventually used to replenish per-stream flow control These bytes will be eventually used to replenish per-stream flow control
windows. */ windows. */
gpr_uint32 max_recv_bytes; size_t max_recv_bytes;
grpc_iomgr_closure *on_done_recv; grpc_iomgr_closure *on_done_recv;
grpc_pollset *bind_pollset; grpc_pollset *bind_pollset;

9
src/core/tsi/fake_transport_security.c
Unescape View File

@ -100,7 +100,7 @@ static const char* tsi_fake_handshake_message_to_string(int msg) {
static tsi_result tsi_fake_handshake_message_from_string( static tsi_result tsi_fake_handshake_message_from_string(
const char* msg_string, tsi_fake_handshake_message* msg) { const char* msg_string, tsi_fake_handshake_message* msg) {
int i; tsi_fake_handshake_message i;
for (i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) { for (i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) {
if (strncmp(msg_string, tsi_fake_handshake_message_strings[i], if (strncmp(msg_string, tsi_fake_handshake_message_strings[i],
strlen(tsi_fake_handshake_message_strings[i])) == 0) { strlen(tsi_fake_handshake_message_strings[i])) == 0) {
@ -219,7 +219,7 @@ static tsi_result bytes_to_frame(unsigned char* bytes, size_t bytes_size,
frame->offset = 0; frame->offset = 0;
frame->size = bytes_size + TSI_FAKE_FRAME_HEADER_SIZE; frame->size = bytes_size + TSI_FAKE_FRAME_HEADER_SIZE;
if (!tsi_fake_frame_ensure_size(frame)) return TSI_OUT_OF_RESOURCES; if (!tsi_fake_frame_ensure_size(frame)) return TSI_OUT_OF_RESOURCES;
store32_little_endian(frame->size, frame->data); store32_little_endian((gpr_uint32)frame->size, frame->data);
memcpy(frame->data + TSI_FAKE_FRAME_HEADER_SIZE, bytes, bytes_size); memcpy(frame->data + TSI_FAKE_FRAME_HEADER_SIZE, bytes, bytes_size);
tsi_fake_frame_reset(frame, 1 /* needs draining */); tsi_fake_frame_reset(frame, 1 /* needs draining */);
return TSI_OK; return TSI_OK;
@ -266,7 +266,7 @@ static tsi_result fake_protector_protect(tsi_frame_protector* self,
if (frame->size == 0) { if (frame->size == 0) {
/* New frame, create a header. */ /* New frame, create a header. */
size_t written_in_frame_size = 0; size_t written_in_frame_size = 0;
store32_little_endian(impl->max_frame_size, frame_header); store32_little_endian((gpr_uint32)impl->max_frame_size, frame_header);
written_in_frame_size = TSI_FAKE_FRAME_HEADER_SIZE; written_in_frame_size = TSI_FAKE_FRAME_HEADER_SIZE;
result = fill_frame_from_bytes(frame_header, &written_in_frame_size, frame); result = fill_frame_from_bytes(frame_header, &written_in_frame_size, frame);
if (result != TSI_INCOMPLETE_DATA) { if (result != TSI_INCOMPLETE_DATA) {
@ -303,7 +303,8 @@ static tsi_result fake_protector_protect_flush(
frame->size = frame->offset; frame->size = frame->offset;
frame->offset = 0; frame->offset = 0;
frame->needs_draining = 1; frame->needs_draining = 1;
store32_little_endian(frame->size, frame->data); /* Overwrite header. */ store32_little_endian((gpr_uint32)frame->size,
frame->data); /* Overwrite header. */
} }
result = drain_frame_to_bytes(protected_output_frames, result = drain_frame_to_bytes(protected_output_frames,
protected_output_frames_size, frame); protected_output_frames_size, frame);

64
src/core/tsi/ssl_transport_security.c
Unescape View File

@ -291,7 +291,7 @@ static tsi_result add_subject_alt_names_properties_to_peer(
for (i = 0; i < subject_alt_name_count; i++) { for (i = 0; i < subject_alt_name_count; i++) {
GENERAL_NAME* subject_alt_name = GENERAL_NAME* subject_alt_name =
sk_GENERAL_NAME_value(subject_alt_names, i); sk_GENERAL_NAME_value(subject_alt_names, (int)i);
/* Filter out the non-dns entries names. */ /* Filter out the non-dns entries names. */
if (subject_alt_name->type == GEN_DNS) { if (subject_alt_name->type == GEN_DNS) {
unsigned char* dns_name = NULL; unsigned char* dns_name = NULL;
@ -366,7 +366,10 @@ static void log_ssl_error_stack(void) {
/* Performs an SSL_read and handle errors. */ /* Performs an SSL_read and handle errors. */
static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes, static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
size_t* unprotected_bytes_size) { size_t* unprotected_bytes_size) {
int read_from_ssl = SSL_read(ssl, unprotected_bytes, *unprotected_bytes_size); int read_from_ssl;
GPR_ASSERT(*unprotected_bytes_size <= INT_MAX);
read_from_ssl =
SSL_read(ssl, unprotected_bytes, (int)*unprotected_bytes_size);
if (read_from_ssl == 0) { if (read_from_ssl == 0) {
gpr_log(GPR_ERROR, "SSL_read returned 0 unexpectedly."); gpr_log(GPR_ERROR, "SSL_read returned 0 unexpectedly.");
return TSI_INTERNAL_ERROR; return TSI_INTERNAL_ERROR;
@ -400,8 +403,10 @@ static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
/* Performs an SSL_write and handle errors. */ /* Performs an SSL_write and handle errors. */
static tsi_result do_ssl_write(SSL* ssl, unsigned char* unprotected_bytes, static tsi_result do_ssl_write(SSL* ssl, unsigned char* unprotected_bytes,
size_t unprotected_bytes_size) { size_t unprotected_bytes_size) {
int ssl_write_result = int ssl_write_result;
SSL_write(ssl, unprotected_bytes, unprotected_bytes_size); GPR_ASSERT(unprotected_bytes_size <= INT_MAX);
ssl_write_result =
SSL_write(ssl, unprotected_bytes, (int)unprotected_bytes_size);
if (ssl_write_result < 0) { if (ssl_write_result < 0) {
ssl_write_result = SSL_get_error(ssl, ssl_write_result); ssl_write_result = SSL_get_error(ssl, ssl_write_result);
if (ssl_write_result == SSL_ERROR_WANT_READ) { if (ssl_write_result == SSL_ERROR_WANT_READ) {
@ -423,7 +428,9 @@ static tsi_result ssl_ctx_use_certificate_chain(
size_t pem_cert_chain_size) { size_t pem_cert_chain_size) {
tsi_result result = TSI_OK; tsi_result result = TSI_OK;
X509* certificate = NULL; X509* certificate = NULL;
BIO* pem = BIO_new_mem_buf((void*)pem_cert_chain, pem_cert_chain_size); BIO* pem;
GPR_ASSERT(pem_cert_chain_size <= INT_MAX);
pem = BIO_new_mem_buf((void*)pem_cert_chain, (int)pem_cert_chain_size);
if (pem == NULL) return TSI_OUT_OF_RESOURCES; if (pem == NULL) return TSI_OUT_OF_RESOURCES;
do { do {
@ -464,7 +471,9 @@ static tsi_result ssl_ctx_use_private_key(SSL_CTX* context,
size_t pem_key_size) { size_t pem_key_size) {
tsi_result result = TSI_OK; tsi_result result = TSI_OK;
EVP_PKEY* private_key = NULL; EVP_PKEY* private_key = NULL;
BIO* pem = BIO_new_mem_buf((void*)pem_key, pem_key_size); BIO* pem;
GPR_ASSERT(pem_key_size <= INT_MAX);
pem = BIO_new_mem_buf((void*)pem_key, (int)pem_key_size);
if (pem == NULL) return TSI_OUT_OF_RESOURCES; if (pem == NULL) return TSI_OUT_OF_RESOURCES;
do { do {
private_key = PEM_read_bio_PrivateKey(pem, NULL, NULL, ""); private_key = PEM_read_bio_PrivateKey(pem, NULL, NULL, "");
@ -491,8 +500,11 @@ static tsi_result ssl_ctx_load_verification_certs(
size_t num_roots = 0; size_t num_roots = 0;
X509* root = NULL; X509* root = NULL;
X509_NAME* root_name = NULL; X509_NAME* root_name = NULL;
BIO* pem = BIO_new_mem_buf((void*)pem_roots, pem_roots_size); BIO* pem;
X509_STORE* root_store = SSL_CTX_get_cert_store(context); X509_STORE* root_store;
GPR_ASSERT(pem_roots_size <= INT_MAX);
pem = BIO_new_mem_buf((void*)pem_roots, (int)pem_roots_size);
root_store = SSL_CTX_get_cert_store(context);
if (root_store == NULL) return TSI_INVALID_ARGUMENT; if (root_store == NULL) return TSI_INVALID_ARGUMENT;
if (pem == NULL) return TSI_OUT_OF_RESOURCES; if (pem == NULL) return TSI_OUT_OF_RESOURCES;
if (root_names != NULL) { if (root_names != NULL) {
@ -592,7 +604,9 @@ static tsi_result extract_x509_subject_names_from_pem_cert(
const unsigned char* pem_cert, size_t pem_cert_size, tsi_peer* peer) { const unsigned char* pem_cert, size_t pem_cert_size, tsi_peer* peer) {
tsi_result result = TSI_OK; tsi_result result = TSI_OK;
X509* cert = NULL; X509* cert = NULL;
BIO* pem = BIO_new_mem_buf((void*)pem_cert, pem_cert_size); BIO* pem;
GPR_ASSERT(pem_cert_size <= INT_MAX);
pem = BIO_new_mem_buf((void*)pem_cert, (int)pem_cert_size);
if (pem == NULL) return TSI_OUT_OF_RESOURCES; if (pem == NULL) return TSI_OUT_OF_RESOURCES;
cert = PEM_read_bio_X509(pem, NULL, NULL, ""); cert = PEM_read_bio_X509(pem, NULL, NULL, "");
@ -657,8 +671,9 @@ static tsi_result ssl_protector_protect(tsi_frame_protector* self,
int pending_in_ssl = BIO_pending(impl->from_ssl); int pending_in_ssl = BIO_pending(impl->from_ssl);
if (pending_in_ssl > 0) { if (pending_in_ssl > 0) {
*unprotected_bytes_size = 0; *unprotected_bytes_size = 0;
GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames, read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
*protected_output_frames_size); (int)*protected_output_frames_size);
if (read_from_ssl < 0) { if (read_from_ssl < 0) {
gpr_log(GPR_ERROR, gpr_log(GPR_ERROR,
"Could not read from BIO even though some data is pending"); "Could not read from BIO even though some data is pending");
@ -684,8 +699,9 @@ static tsi_result ssl_protector_protect(tsi_frame_protector* self,
result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_size); result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_size);
if (result != TSI_OK) return result; if (result != TSI_OK) return result;
GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames, read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
*protected_output_frames_size); (int)*protected_output_frames_size);
if (read_from_ssl < 0) { if (read_from_ssl < 0) {
gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write."); gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
return TSI_INTERNAL_ERROR; return TSI_INTERNAL_ERROR;
@ -715,8 +731,9 @@ static tsi_result ssl_protector_protect_flush(
*still_pending_size = (size_t)pending; *still_pending_size = (size_t)pending;
if (*still_pending_size == 0) return TSI_OK; if (*still_pending_size == 0) return TSI_OK;
GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames, read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
*protected_output_frames_size); (int)*protected_output_frames_size);
if (read_from_ssl <= 0) { if (read_from_ssl <= 0) {
gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write."); gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
return TSI_INTERNAL_ERROR; return TSI_INTERNAL_ERROR;
@ -751,8 +768,9 @@ static tsi_result ssl_protector_unprotect(
*unprotected_bytes_size = output_bytes_size - output_bytes_offset; *unprotected_bytes_size = output_bytes_size - output_bytes_offset;
/* Then, try to write some data to ssl. */ /* Then, try to write some data to ssl. */
GPR_ASSERT(*protected_frames_bytes_size <= INT_MAX);
written_into_ssl = BIO_write(impl->into_ssl, protected_frames_bytes, written_into_ssl = BIO_write(impl->into_ssl, protected_frames_bytes,
*protected_frames_bytes_size); (int)*protected_frames_bytes_size);
if (written_into_ssl < 0) { if (written_into_ssl < 0) {
gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d", gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d",
written_into_ssl); written_into_ssl);
@ -792,7 +810,8 @@ static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
*bytes_size > INT_MAX) { *bytes_size > INT_MAX) {
return TSI_INVALID_ARGUMENT; return TSI_INVALID_ARGUMENT;
} }
bytes_read_from_ssl = BIO_read(impl->from_ssl, bytes, *bytes_size); GPR_ASSERT(*bytes_size <= INT_MAX);
bytes_read_from_ssl = BIO_read(impl->from_ssl, bytes, (int)*bytes_size);
if (bytes_read_from_ssl < 0) { if (bytes_read_from_ssl < 0) {
*bytes_size = 0; *bytes_size = 0;
if (!BIO_should_retry(impl->from_ssl)) { if (!BIO_should_retry(impl->from_ssl)) {
@ -822,7 +841,9 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
if (bytes == NULL || bytes_size == 0 || *bytes_size > INT_MAX) { if (bytes == NULL || bytes_size == 0 || *bytes_size > INT_MAX) {
return TSI_INVALID_ARGUMENT; return TSI_INVALID_ARGUMENT;
} }
bytes_written_into_ssl_size = BIO_write(impl->into_ssl, bytes, *bytes_size); GPR_ASSERT(*bytes_size <= INT_MAX);
bytes_written_into_ssl_size =
BIO_write(impl->into_ssl, bytes, (int)*bytes_size);
if (bytes_written_into_ssl_size < 0) { if (bytes_written_into_ssl_size < 0) {
gpr_log(GPR_ERROR, "Could not write to memory BIO."); gpr_log(GPR_ERROR, "Could not write to memory BIO.");
impl->result = TSI_INTERNAL_ERROR; impl->result = TSI_INTERNAL_ERROR;
@ -1044,9 +1065,9 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
static int select_protocol_list(const unsigned char** out, static int select_protocol_list(const unsigned char** out,
unsigned char* outlen, unsigned char* outlen,
const unsigned char* client_list, const unsigned char* client_list,
unsigned int client_list_len, size_t client_list_len,
const unsigned char* server_list, const unsigned char* server_list,
unsigned int server_list_len) { size_t server_list_len) {
const unsigned char* client_current = client_list; const unsigned char* client_current = client_list;
while ((unsigned int)(client_current - client_list) < client_list_len) { while ((unsigned int)(client_current - client_list) < client_list_len) {
unsigned char client_current_len = *(client_current++); unsigned char client_current_len = *(client_current++);
@ -1219,7 +1240,8 @@ static int server_handshaker_factory_npn_advertised_callback(
tsi_ssl_server_handshaker_factory* factory = tsi_ssl_server_handshaker_factory* factory =
(tsi_ssl_server_handshaker_factory*)arg; (tsi_ssl_server_handshaker_factory*)arg;
*out = factory->alpn_protocol_list; *out = factory->alpn_protocol_list;
*outlen = factory->alpn_protocol_list_length; GPR_ASSERT(factory->alpn_protocol_list_length <= UINT_MAX);
*outlen = (unsigned int)factory->alpn_protocol_list_length;
return SSL_TLSEXT_ERR_OK; return SSL_TLSEXT_ERR_OK;
} }
@ -1277,8 +1299,10 @@ tsi_result tsi_create_ssl_client_handshaker_factory(
break; break;
} }
#if TSI_OPENSSL_ALPN_SUPPORT #if TSI_OPENSSL_ALPN_SUPPORT
if (SSL_CTX_set_alpn_protos(ssl_context, impl->alpn_protocol_list, GPR_ASSERT(impl->alpn_protocol_list_length < UINT_MAX);
impl->alpn_protocol_list_length)) { if (SSL_CTX_set_alpn_protos(
ssl_context, impl->alpn_protocol_list,
(unsigned int)impl->alpn_protocol_list_length)) {
gpr_log(GPR_ERROR, "Could not set alpn protocol list to context."); gpr_log(GPR_ERROR, "Could not set alpn protocol list to context.");
result = TSI_INVALID_ARGUMENT; result = TSI_INVALID_ARGUMENT;
break; break;

7
templates/Makefile.template
Unescape View File

@ -247,6 +247,10 @@
CXX11_CHECK_CMD = $(CXX) -std=c++11 -o $(TMPOUT) -c test/build/c++11.cc CXX11_CHECK_CMD = $(CXX) -std=c++11 -o $(TMPOUT) -c test/build/c++11.cc
HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false) HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false)
# Detect if -Wshorten-64-to-32 is a thing
SHORTEN_64_TO_32_CHECK_CMD = $(CC) -Wshorten-64-to-32 test/build/empty.c
HAS_SHORTEN_64_TO_32 = $(shell $(SHORTEN_64_TO_32_CHECK_CMD) 2> /dev/null && echo true || echo false)
# The HOST compiler settings are used to compile the protoc plugins. # The HOST compiler settings are used to compile the protoc plugins.
# In most cases, you won't have to change anything, but if you are # In most cases, you won't have to change anything, but if you are
# cross-compiling, you can override these variables from GNU make's # cross-compiling, you can override these variables from GNU make's
@ -262,6 +266,9 @@
endif endif
CFLAGS += -std=c89 -pedantic -Wsign-conversion CFLAGS += -std=c89 -pedantic -Wsign-conversion
ifeq ($(HAS_SHORTEN_64_TO_32),true)
CFLAGS += -Wshorten-64-to-32
endif
ifeq ($(HAS_CXX11),true) ifeq ($(HAS_CXX11),true)
CXXFLAGS += -std=c++11 CXXFLAGS += -std=c++11
else else

34
test/build/empty.c
Unescape View File

@ -0,0 +1,34 @@
/*
*
* Copyright 2015, 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.
*
*/
int main(void) {}

2
test/core/compression/message_compress_test.c
Unescape View File

@ -149,7 +149,7 @@ static gpr_slice create_test_value(test_value id) {
static void test_bad_data(void) { static void test_bad_data(void) {
gpr_slice_buffer input; gpr_slice_buffer input;
gpr_slice_buffer output; gpr_slice_buffer output;
int i; grpc_compression_algorithm i;
gpr_slice_buffer_init(&input); gpr_slice_buffer_init(&input);
gpr_slice_buffer_init(&output); gpr_slice_buffer_init(&output);

2
test/core/fling/server.c
Unescape View File

@ -197,7 +197,7 @@ int main(int argc, char **argv) {
grpc_test_init(1, fake_argv); grpc_test_init(1, fake_argv);
grpc_init(); grpc_init();
srand(clock()); srand((unsigned)clock());
cl = gpr_cmdline_create("fling server"); cl = gpr_cmdline_create("fling server");
gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr); gpr_cmdline_add_string(cl, "bind", "Bind host:port", &addr);

2
test/core/iomgr/fd_posix_test.c
Unescape View File

@ -419,7 +419,7 @@ static void test_grpc_fd_change(void) {
int flags; int flags;
int sv[2]; int sv[2];
char data; char data;
int result; ssize_t result;
grpc_iomgr_closure first_closure; grpc_iomgr_closure first_closure;
grpc_iomgr_closure second_closure; grpc_iomgr_closure second_closure;

2
test/core/iomgr/udp_server_test.c
Unescape View File

@ -53,7 +53,7 @@ static void on_connect(void *arg, grpc_endpoint *udp) {}
static void on_read(int fd, grpc_udp_server_cb new_transport_cb, void *cb_arg) { static void on_read(int fd, grpc_udp_server_cb new_transport_cb, void *cb_arg) {
char read_buffer[512]; char read_buffer[512];
int byte_count; ssize_t byte_count;
gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset)); gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
byte_count = recv(fd, read_buffer, sizeof(read_buffer), 0); byte_count = recv(fd, read_buffer, sizeof(read_buffer), 0);

4
test/core/support/murmur_hash_test.c
Unescape View File

@ -57,8 +57,8 @@ static void verification_test(hash_func hash, gpr_uint32 expected) {
the seed */ the seed */
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
key[i] = (uint8_t)i; key[i] = (gpr_uint8)i;
hashes[i] = hash(key, i, 256u - i); hashes[i] = hash(key, i, (gpr_uint32)(256u - i));
} }
/* Then hash the result array */ /* Then hash the result array */

7
test/core/support/stack_lockfree_test.c
Unescape View File

@ -62,7 +62,7 @@ static void test_serial_sized(size_t size) {
/* Now add repeatedly more items and check them */ /* Now add repeatedly more items and check them */
for (i = 1; i < size; i *= 2) { for (i = 1; i < size; i *= 2) {
for (j = 0; j <= i; j++) { for (j = 0; j <= i; j++) {
GPR_ASSERT(gpr_stack_lockfree_push(stack, j) == (j == 0)); GPR_ASSERT(gpr_stack_lockfree_push(stack, (int)j) == (j == 0));
} }
for (j = 0; j <= i; j++) { for (j = 0; j <= i; j++) {
GPR_ASSERT(gpr_stack_lockfree_pop(stack) == (int)(i - j)); GPR_ASSERT(gpr_stack_lockfree_pop(stack) == (int)(i - j));
@ -118,7 +118,7 @@ static void test_mt_sized(size_t size, int nth) {
stack = gpr_stack_lockfree_create(size); stack = gpr_stack_lockfree_create(size);
for (i = 0; i < nth; i++) { for (i = 0; i < nth; i++) {
args[i].stack = stack; args[i].stack = stack;
args[i].stack_size = size; args[i].stack_size = (int)size;
args[i].nthreads = nth; args[i].nthreads = nth;
args[i].rank = i; args[i].rank = i;
args[i].sum = 0; args[i].sum = 0;
@ -137,7 +137,8 @@ static void test_mt_sized(size_t size, int nth) {
} }
static void test_mt() { static void test_mt() {
size_t size, nth; size_t size;
int nth;
for (nth = 1; nth < MAX_THREADS; nth++) { for (nth = 1; nth < MAX_THREADS; nth++) {
for (size = 128; size < MAX_STACK_SIZE; size *= 2) { for (size = 128; size < MAX_STACK_SIZE; size *= 2) {
test_mt_sized(size, nth); test_mt_sized(size, nth);

2
test/core/transport/chttp2/hpack_table_test.c
Unescape View File

@ -49,7 +49,7 @@ static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_mdstr *mdstr,
GPR_ASSERT(gpr_slice_str_cmp(mdstr->slice, str) == 0); GPR_ASSERT(gpr_slice_str_cmp(mdstr->slice, str) == 0);
} }
static void assert_index(const grpc_chttp2_hptbl *tbl, size_t idx, static void assert_index(const grpc_chttp2_hptbl *tbl, gpr_uint32 idx,
const char *key, const char *value) { const char *key, const char *value) {
grpc_mdelem *md = grpc_chttp2_hptbl_lookup(tbl, idx); grpc_mdelem *md = grpc_chttp2_hptbl_lookup(tbl, idx);
assert_str(tbl, md->key, key); assert_str(tbl, md->key, key);

4
test/core/transport/chttp2/stream_encoder_test.c
Unescape View File

@ -75,8 +75,8 @@ static void verify_sopb(size_t window_available, int eof,
gpr_slice_buffer_init(&output); gpr_slice_buffer_init(&output);
grpc_sopb_init(&encops); grpc_sopb_init(&encops);
GPR_ASSERT(expect_window_used == GPR_ASSERT(expect_window_used ==
grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, window_available, grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops,
&encops)); (gpr_uint32)window_available, &encops));
grpc_chttp2_encode(encops.ops, encops.nops, eof, 0xdeadbeef, &g_compressor, grpc_chttp2_encode(encops.ops, encops.nops, eof, 0xdeadbeef, &g_compressor,
&output); &output);
encops.nops = 0; encops.nops = 0;

40
test/core/transport/chttp2/stream_map_test.c
Unescape View File

@ -82,9 +82,9 @@ static void test_double_deletion(void) {
} }
/* test add & lookup */ /* test add & lookup */
static void test_basic_add_find(size_t n) { static void test_basic_add_find(gpr_uint32 n) {
grpc_chttp2_stream_map map; grpc_chttp2_stream_map map;
size_t i; gpr_uint32 i;
size_t got; size_t got;
LOG_TEST("test_basic_add_find"); LOG_TEST("test_basic_add_find");
@ -107,15 +107,15 @@ static void test_basic_add_find(size_t n) {
/* verify that for_each gets the right values during test_delete_evens_XXX */ /* verify that for_each gets the right values during test_delete_evens_XXX */
static void verify_for_each(void *user_data, gpr_uint32 stream_id, void *ptr) { static void verify_for_each(void *user_data, gpr_uint32 stream_id, void *ptr) {
size_t *for_each_check = user_data; gpr_uint32 *for_each_check = user_data;
GPR_ASSERT(ptr); GPR_ASSERT(ptr);
GPR_ASSERT(*for_each_check == stream_id); GPR_ASSERT(*for_each_check == stream_id);
*for_each_check += 2; *for_each_check += 2;
} }
static void check_delete_evens(grpc_chttp2_stream_map *map, size_t n) { static void check_delete_evens(grpc_chttp2_stream_map *map, gpr_uint32 n) {
size_t for_each_check = 1; gpr_uint32 for_each_check = 1;
size_t i; gpr_uint32 i;
size_t got; size_t got;
GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, 0)); GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(map, 0));
@ -139,9 +139,9 @@ static void check_delete_evens(grpc_chttp2_stream_map *map, size_t n) {
/* add a bunch of keys, delete the even ones, and make sure the map is /* add a bunch of keys, delete the even ones, and make sure the map is
consistent */ consistent */
static void test_delete_evens_sweep(size_t n) { static void test_delete_evens_sweep(gpr_uint32 n) {
grpc_chttp2_stream_map map; grpc_chttp2_stream_map map;
size_t i; gpr_uint32 i;
LOG_TEST("test_delete_evens_sweep"); LOG_TEST("test_delete_evens_sweep");
gpr_log(GPR_INFO, "n = %d", n); gpr_log(GPR_INFO, "n = %d", n);
@ -152,7 +152,8 @@ static void test_delete_evens_sweep(size_t n) {
} }
for (i = 1; i <= n; i++) { for (i = 1; i <= n; i++) {
if ((i & 1) == 0) { if ((i & 1) == 0) {
GPR_ASSERT((void *)i == grpc_chttp2_stream_map_delete(&map, i)); GPR_ASSERT((void *)(gpr_uintptr)i ==
grpc_chttp2_stream_map_delete(&map, i));
} }
} }
check_delete_evens(&map, n); check_delete_evens(&map, n);
@ -161,9 +162,9 @@ static void test_delete_evens_sweep(size_t n) {
/* add a bunch of keys, delete the even ones immediately, and make sure the map /* add a bunch of keys, delete the even ones immediately, and make sure the map
is consistent */ is consistent */
static void test_delete_evens_incremental(size_t n) { static void test_delete_evens_incremental(gpr_uint32 n) {
grpc_chttp2_stream_map map; grpc_chttp2_stream_map map;
size_t i; gpr_uint32 i;
LOG_TEST("test_delete_evens_incremental"); LOG_TEST("test_delete_evens_incremental");
gpr_log(GPR_INFO, "n = %d", n); gpr_log(GPR_INFO, "n = %d", n);
@ -181,10 +182,10 @@ static void test_delete_evens_incremental(size_t n) {
/* add a bunch of keys, delete old ones after some time, ensure the /* add a bunch of keys, delete old ones after some time, ensure the
backing array does not grow */ backing array does not grow */
static void test_periodic_compaction(size_t n) { static void test_periodic_compaction(gpr_uint32 n) {
grpc_chttp2_stream_map map; grpc_chttp2_stream_map map;
size_t i; gpr_uint32 i;
size_t del; gpr_uint32 del;
LOG_TEST("test_periodic_compaction"); LOG_TEST("test_periodic_compaction");
gpr_log(GPR_INFO, "n = %d", n); gpr_log(GPR_INFO, "n = %d", n);
@ -192,10 +193,11 @@ static void test_periodic_compaction(size_t n) {
grpc_chttp2_stream_map_init(&map, 16); grpc_chttp2_stream_map_init(&map, 16);
GPR_ASSERT(map.capacity == 16); GPR_ASSERT(map.capacity == 16);
for (i = 1; i <= n; i++) { for (i = 1; i <= n; i++) {
grpc_chttp2_stream_map_add(&map, i, (void *)i); grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
if (i > 8) { if (i > 8) {
del = i - 8; del = i - 8;
GPR_ASSERT((void *)del == grpc_chttp2_stream_map_delete(&map, del)); GPR_ASSERT((void *)(gpr_uintptr)del ==
grpc_chttp2_stream_map_delete(&map, del));
} }
} }
GPR_ASSERT(map.capacity == 16); GPR_ASSERT(map.capacity == 16);
@ -203,9 +205,9 @@ static void test_periodic_compaction(size_t n) {
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t n = 1; gpr_uint32 n = 1;
size_t prev = 1; gpr_uint32 prev = 1;
size_t tmp; gpr_uint32 tmp;
grpc_test_init(argc, argv); grpc_test_init(argc, argv);

33
tools/codegen/core/gen_hpack_tables.c
Unescape View File

@ -127,7 +127,9 @@ static void generate_first_byte_lut(void) {
/* represents a set of symbols as an array of booleans indicating inclusion */ /* represents a set of symbols as an array of booleans indicating inclusion */
typedef struct { char included[GRPC_CHTTP2_NUM_HUFFSYMS]; } symset; typedef struct { char included[GRPC_CHTTP2_NUM_HUFFSYMS]; } symset;
/* represents a lookup table indexed by a nibble */ /* represents a lookup table indexed by a nibble */
typedef struct { int values[16]; } nibblelut; typedef struct { unsigned values[16]; } nibblelut;
#define NOT_SET (~(unsigned)0)
/* returns a symset that includes all possible symbols */ /* returns a symset that includes all possible symbols */
static symset symset_all(void) { static symset symset_all(void) {
@ -148,7 +150,7 @@ static nibblelut nibblelut_empty(void) {
nibblelut x; nibblelut x;
int i; int i;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
x.values[i] = -1; x.values[i] = NOT_SET;
} }
return x; return x;
} }
@ -168,7 +170,7 @@ static int nsyms(symset s) {
/* global table of discovered huffman decoding states */ /* global table of discovered huffman decoding states */
static struct { static struct {
/* the bit offset that this state starts at */ /* the bit offset that this state starts at */
int bitofs; unsigned bitofs;
/* the set of symbols that this state started with */ /* the set of symbols that this state started with */
symset syms; symset syms;
@ -177,13 +179,13 @@ static struct {
/* lookup table for what to emit */ /* lookup table for what to emit */
nibblelut emit; nibblelut emit;
} huffstates[MAXHUFFSTATES]; } huffstates[MAXHUFFSTATES];
static int nhuffstates = 0; static unsigned nhuffstates = 0;
/* given a number of decoded bits and a set of symbols that are live, /* given a number of decoded bits and a set of symbols that are live,
return the index into the decoder table for this state. return the index into the decoder table for this state.
set isnew to 1 if this state was previously undiscovered */ set isnew to 1 if this state was previously undiscovered */
static int state_index(int bitofs, symset syms, int *isnew) { static unsigned state_index(unsigned bitofs, symset syms, unsigned *isnew) {
int i; unsigned i;
for (i = 0; i < nhuffstates; i++) { for (i = 0; i < nhuffstates; i++) {
if (huffstates[i].bitofs != bitofs) continue; if (huffstates[i].bitofs != bitofs) continue;
if (0 != memcmp(huffstates[i].syms.included, syms.included, if (0 != memcmp(huffstates[i].syms.included, syms.included,
@ -211,24 +213,24 @@ static int state_index(int bitofs, symset syms, int *isnew) {
emit - the symbol to emit on this nibble (or -1 if no symbol has been emit - the symbol to emit on this nibble (or -1 if no symbol has been
found) found)
syms - the set of symbols that could be matched */ syms - the set of symbols that could be matched */
static void build_dec_tbl(int state, int nibble, int nibbits, unsigned bitofs, static void build_dec_tbl(unsigned state, unsigned nibble, int nibbits,
int emit, symset syms) { unsigned bitofs, unsigned emit, symset syms) {
int i; unsigned i;
unsigned bit; unsigned bit;
/* If we have four bits in the nibble we're looking at, then we can fill in /* If we have four bits in the nibble we're looking at, then we can fill in
a slot in the lookup tables. */ a slot in the lookup tables. */
if (nibbits == 4) { if (nibbits == 4) {
int isnew; unsigned isnew;
/* Find the state that we are in: this may be a new state, in which case /* Find the state that we are in: this may be a new state, in which case
we recurse to fill it in, or we may have already seen this state, in we recurse to fill it in, or we may have already seen this state, in
which case the recursion terminates */ which case the recursion terminates */
int st = state_index(bitofs, syms, &isnew); unsigned st = state_index(bitofs, syms, &isnew);
GPR_ASSERT(huffstates[state].next.values[nibble] == -1); GPR_ASSERT(huffstates[state].next.values[nibble] == NOT_SET);
huffstates[state].next.values[nibble] = st; huffstates[state].next.values[nibble] = st;
huffstates[state].emit.values[nibble] = emit; huffstates[state].emit.values[nibble] = emit;
if (isnew) { if (isnew) {
build_dec_tbl(st, 0, 0, bitofs, -1, syms); build_dec_tbl(st, 0, 0, bitofs, NOT_SET, syms);
} }
return; return;
} }
@ -290,8 +292,9 @@ static void dump_ctbl(const char *name) {
} }
static void generate_huff_tables(void) { static void generate_huff_tables(void) {
int i; unsigned i;
build_dec_tbl(state_index(0, symset_all(), &i), 0, 0, 0, -1, symset_all()); build_dec_tbl(state_index(0, symset_all(), &i), 0, 0, 0, NOT_SET,
symset_all());
nctbl = 0; nctbl = 0;
printf("static const gpr_uint8 next_tbl[%d] = {", nhuffstates); printf("static const gpr_uint8 next_tbl[%d] = {", nhuffstates);

Write Preview
Loading…
Cancel
Save