Skip to content

Commit b070017

Browse files
azkrishpyazkrishpy
committed
lint
1 parent e5e3b4e commit b070017

5 files changed

Lines changed: 93 additions & 67 deletions

File tree

‎source/h1_connection.c‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1077,7 +1077,8 @@ static void s_write_outgoing_stream(struct aws_h1_connection *connection, bool f
10771077
if (!first_try) {
10781078
AWS_LOGF_TRACE(
10791079
AWS_LS_HTTP_CONNECTION,
1080-
"id=%p: Outgoing stream task stopped. outgoing_stream=%p waiting_for_chunks:%d waiting_for_data_writes:%d",
1080+
"id=%p: Outgoing stream task stopped. outgoing_stream=%p waiting_for_chunks:%d "
1081+
"waiting_for_data_writes:%d",
10811082
(void *)&connection->base,
10821083
outgoing_stream ? (void *)&outgoing_stream->base : NULL,
10831084
waiting_for_chunks,

‎source/h1_encoder.c‎

Lines changed: 19 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -150,31 +150,23 @@ static int s_scan_outgoing_headers(
150150
return AWS_OP_SUCCESS;
151151
}
152152

153-
static int s_validate_manual_data_writes(
154-
const struct aws_h1_encoder_message *encoder_message,
155-
bool has_body_stream) {
153+
static int s_validate_manual_data_writes(const struct aws_h1_encoder_message *encoder_message, bool has_body_stream) {
156154

157155
/* Manual data writes require Content-Length header */
158156
if (encoder_message->content_length == 0) {
159-
AWS_LOGF_ERROR(
160-
AWS_LS_HTTP_STREAM,
161-
"id=static: Manual data writes require Content-Length header");
157+
AWS_LOGF_ERROR(AWS_LS_HTTP_STREAM, "id=static: Manual data writes require Content-Length header");
162158
return aws_raise_error(AWS_ERROR_HTTP_INVALID_HEADER_FIELD);
163159
}
164160

165161
/* Manual data writes cannot use chunked encoding */
166162
if (encoder_message->has_chunked_encoding_header) {
167-
AWS_LOGF_ERROR(
168-
AWS_LS_HTTP_STREAM,
169-
"id=static: Manual data writes cannot use Transfer-Encoding: chunked");
163+
AWS_LOGF_ERROR(AWS_LS_HTTP_STREAM, "id=static: Manual data writes cannot use Transfer-Encoding: chunked");
170164
return aws_raise_error(AWS_ERROR_HTTP_INVALID_HEADER_FIELD);
171165
}
172166

173167
/* Manual data writes cannot have body stream */
174168
if (has_body_stream) {
175-
AWS_LOGF_ERROR(
176-
AWS_LS_HTTP_STREAM,
177-
"id=static: Manual data writes cannot have body stream");
169+
AWS_LOGF_ERROR(AWS_LS_HTTP_STREAM, "id=static: Manual data writes cannot have body stream");
178170
return aws_raise_error(AWS_ERROR_HTTP_INVALID_HEADER_FIELD);
179171
}
180172

@@ -424,7 +416,12 @@ int aws_h1_encoder_message_init_from_response(
424416
body_headers_ignored |= status_int == AWS_HTTP_STATUS_CODE_304_NOT_MODIFIED;
425417
bool body_headers_forbidden = status_int == AWS_HTTP_STATUS_CODE_204_NO_CONTENT || status_int / 100 == 1;
426418
err = s_scan_outgoing_headers(
427-
message, response, &header_lines_len, body_headers_ignored, body_headers_forbidden, false /*use_manual_data_writes*/);
419+
message,
420+
response,
421+
&header_lines_len,
422+
body_headers_ignored,
423+
body_headers_forbidden,
424+
false /*use_manual_data_writes*/);
428425
if (err) {
429426
goto error;
430427
}
@@ -740,11 +737,11 @@ typedef int encoder_state_fn(struct aws_h1_encoder *encoder, struct aws_byte_buf
740737
static int s_switch_state(struct aws_h1_encoder *encoder, enum aws_h1_encoder_state state) {
741738
/* Don't reset progress_bytes when transitioning between DATA_WRITE states,
742739
* as we need to track cumulative progress across multiple writes */
743-
bool preserve_progress = (encoder->state == AWS_H1_ENCODER_STATE_DATA_WRITE_NEXT ||
744-
encoder->state == AWS_H1_ENCODER_STATE_DATA_WRITE_BODY) &&
745-
(state == AWS_H1_ENCODER_STATE_DATA_WRITE_NEXT ||
746-
state == AWS_H1_ENCODER_STATE_DATA_WRITE_BODY);
747-
740+
bool preserve_progress =
741+
(encoder->state == AWS_H1_ENCODER_STATE_DATA_WRITE_NEXT ||
742+
encoder->state == AWS_H1_ENCODER_STATE_DATA_WRITE_BODY) &&
743+
(state == AWS_H1_ENCODER_STATE_DATA_WRITE_NEXT || state == AWS_H1_ENCODER_STATE_DATA_WRITE_BODY);
744+
748745
encoder->state = state;
749746
if (!preserve_progress) {
750747
encoder->progress_bytes = 0;
@@ -1060,7 +1057,7 @@ static int s_encoder_state_data_write_next(struct aws_h1_encoder *encoder, struc
10601057
/* Write out data from current manual data write */
10611058
static int s_encoder_state_data_write_body(struct aws_h1_encoder *encoder, struct aws_byte_buf *dst) {
10621059
struct aws_h1_data_write *data_write = encoder->message->current_data_write;
1063-
1060+
10641061
if (dst->capacity == dst->len) {
10651062
return AWS_OP_SUCCESS;
10661063
}
@@ -1088,11 +1085,9 @@ static int s_encoder_state_data_write_body(struct aws_h1_encoder *encoder, struc
10881085
if (aws_add_u64_checked(encoder->progress_bytes, amount_read, &encoder->progress_bytes) ||
10891086
encoder->progress_bytes > encoder->message->content_length) {
10901087
ENCODER_LOGF(
1091-
ERROR,
1092-
encoder,
1093-
"Manual data writes exceeded Content-Length: %" PRIu64,
1094-
encoder->message->content_length);
1095-
aws_h1_data_write_complete_and_destroy(data_write, encoder->current_stream, AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT);
1088+
ERROR, encoder, "Manual data writes exceeded Content-Length: %" PRIu64, encoder->message->content_length);
1089+
aws_h1_data_write_complete_and_destroy(
1090+
data_write, encoder->current_stream, AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT);
10961091
encoder->message->current_data_write = NULL;
10971092
return aws_raise_error(AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT);
10981093
}

‎source/h1_stream.c‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,8 @@ static void s_stream_cross_thread_work_task(struct aws_channel_task *task, void
101101
bool new_outgoing_data = !aws_linked_list_empty(&stream->synced_data.pending_chunk_list) ||
102102
!aws_linked_list_empty(&stream->synced_data.pending_data_write_list);
103103
aws_linked_list_move_all_back(&stream->thread_data.pending_chunk_list, &stream->synced_data.pending_chunk_list);
104-
aws_linked_list_move_all_back(&stream->thread_data.pending_data_write_list, &stream->synced_data.pending_data_write_list);
104+
aws_linked_list_move_all_back(
105+
&stream->thread_data.pending_data_write_list, &stream->synced_data.pending_data_write_list);
105106

106107
/* If we JUST learned about having an outgoing response, that's a reason to try sending data */
107108
if (stream->synced_data.has_outgoing_response && !stream->thread_data.has_outgoing_response) {
@@ -417,7 +418,9 @@ static int s_stream_write_data(
417418

418419
if (stream->synced_data.has_final_data_write) {
419420
AWS_LOGF_ERROR(
420-
AWS_LS_HTTP_STREAM, "id=%p: Cannot write data after final write (end_stream=true).", (void *)stream_base);
421+
AWS_LS_HTTP_STREAM,
422+
"id=%p: Cannot write data after final write (end_stream=true).",
423+
(void *)stream_base);
421424
error_code = AWS_ERROR_HTTP_MANUAL_WRITE_HAS_COMPLETED;
422425
goto unlock;
423426
}

‎tests/test_h1_client.c‎

Lines changed: 55 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -5159,11 +5159,14 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_single_chunk) {
51595159
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
51605160

51615161
struct client_stream_tester stream_tester;
5162-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5163-
.request = request,
5164-
.connection = tester.connection,
5165-
.use_manual_data_writes = true,
5166-
}));
5162+
ASSERT_SUCCESS(client_stream_tester_init(
5163+
&stream_tester,
5164+
allocator,
5165+
&(struct client_stream_tester_options){
5166+
.request = request,
5167+
.connection = tester.connection,
5168+
.use_manual_data_writes = true,
5169+
}));
51675170

51685171
testing_channel_drain_queued_tasks(&tester.testing_channel);
51695172
aws_http_message_destroy(request);
@@ -5223,11 +5226,14 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_multiple_chunks) {
52235226
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
52245227

52255228
struct client_stream_tester stream_tester;
5226-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5227-
.request = request,
5228-
.connection = tester.connection,
5229-
.use_manual_data_writes = true,
5230-
}));
5229+
ASSERT_SUCCESS(client_stream_tester_init(
5230+
&stream_tester,
5231+
allocator,
5232+
&(struct client_stream_tester_options){
5233+
.request = request,
5234+
.connection = tester.connection,
5235+
.use_manual_data_writes = true,
5236+
}));
52315237

52325238
testing_channel_drain_queued_tasks(&tester.testing_channel);
52335239
aws_http_message_destroy(request);
@@ -5306,10 +5312,13 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_not_enabled) {
53065312
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
53075313

53085314
struct client_stream_tester stream_tester;
5309-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5310-
.request = request,
5311-
.connection = tester.connection,
5312-
}));
5315+
ASSERT_SUCCESS(client_stream_tester_init(
5316+
&stream_tester,
5317+
allocator,
5318+
&(struct client_stream_tester_options){
5319+
.request = request,
5320+
.connection = tester.connection,
5321+
}));
53135322

53145323
testing_channel_drain_queued_tasks(&tester.testing_channel);
53155324
aws_http_message_destroy(request);
@@ -5351,11 +5360,14 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_after_final) {
53515360
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
53525361

53535362
struct client_stream_tester stream_tester;
5354-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5355-
.request = request,
5356-
.connection = tester.connection,
5357-
.use_manual_data_writes = true,
5358-
}));
5363+
ASSERT_SUCCESS(client_stream_tester_init(
5364+
&stream_tester,
5365+
allocator,
5366+
&(struct client_stream_tester_options){
5367+
.request = request,
5368+
.connection = tester.connection,
5369+
.use_manual_data_writes = true,
5370+
}));
53595371

53605372
testing_channel_drain_queued_tasks(&tester.testing_channel);
53615373
aws_http_message_destroy(request);
@@ -5410,11 +5422,14 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_exceeds_content_length) {
54105422
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
54115423

54125424
struct client_stream_tester stream_tester;
5413-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5414-
.request = request,
5415-
.connection = tester.connection,
5416-
.use_manual_data_writes = true,
5417-
}));
5425+
ASSERT_SUCCESS(client_stream_tester_init(
5426+
&stream_tester,
5427+
allocator,
5428+
&(struct client_stream_tester_options){
5429+
.request = request,
5430+
.connection = tester.connection,
5431+
.use_manual_data_writes = true,
5432+
}));
54185433

54195434
testing_channel_drain_queued_tasks(&tester.testing_channel);
54205435
aws_http_message_destroy(request);
@@ -5463,11 +5478,14 @@ H1_CLIENT_TEST_CASE(h1_client_write_data_less_than_content_length) {
54635478
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
54645479

54655480
struct client_stream_tester stream_tester;
5466-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5467-
.request = request,
5468-
.connection = tester.connection,
5469-
.use_manual_data_writes = true,
5470-
}));
5481+
ASSERT_SUCCESS(client_stream_tester_init(
5482+
&stream_tester,
5483+
allocator,
5484+
&(struct client_stream_tester_options){
5485+
.request = request,
5486+
.connection = tester.connection,
5487+
.use_manual_data_writes = true,
5488+
}));
54715489

54725490
testing_channel_drain_queued_tasks(&tester.testing_channel);
54735491
aws_http_message_destroy(request);
@@ -5513,11 +5531,14 @@ H1_CLIENT_TEST_CASE(h1_client_unified_write_data_api) {
55135531
ASSERT_SUCCESS(aws_http_message_add_header_array(request, headers, AWS_ARRAY_SIZE(headers)));
55145532

55155533
struct client_stream_tester stream_tester;
5516-
ASSERT_SUCCESS(client_stream_tester_init(&stream_tester, allocator, &(struct client_stream_tester_options){
5517-
.request = request,
5518-
.connection = tester.connection,
5519-
.use_manual_data_writes = true,
5520-
}));
5534+
ASSERT_SUCCESS(client_stream_tester_init(
5535+
&stream_tester,
5536+
allocator,
5537+
&(struct client_stream_tester_options){
5538+
.request = request,
5539+
.connection = tester.connection,
5540+
.use_manual_data_writes = true,
5541+
}));
55215542

55225543
testing_channel_drain_queued_tasks(&tester.testing_channel);
55235544
aws_http_message_destroy(request);

‎tests/test_h1_encoder.c‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -82,7 +82,8 @@ H1_ENCODER_TEST_CASE(h1_encoder_content_length_header) {
8282
aws_linked_list_init(&chunk_list);
8383

8484
struct aws_h1_encoder_message encoder_message;
85-
ASSERT_SUCCESS(aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
85+
ASSERT_SUCCESS(
86+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
8687

8788
ASSERT_FALSE(encoder_message.has_chunked_encoding_header);
8889
ASSERT_FALSE(encoder_message.has_connection_close_header);
@@ -124,7 +125,8 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_chunked_header) {
124125
aws_linked_list_init(&chunk_list);
125126

126127
struct aws_h1_encoder_message encoder_message;
127-
ASSERT_SUCCESS(aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
128+
ASSERT_SUCCESS(
129+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
128130

129131
ASSERT_TRUE(encoder_message.has_chunked_encoding_header);
130132
ASSERT_FALSE(encoder_message.has_connection_close_header);
@@ -171,7 +173,8 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_chunked_header_with_multiple_e
171173
aws_linked_list_init(&chunk_list);
172174

173175
struct aws_h1_encoder_message encoder_message;
174-
ASSERT_SUCCESS(aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
176+
ASSERT_SUCCESS(
177+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
175178

176179
ASSERT_TRUE(encoder_message.has_chunked_encoding_header);
177180
ASSERT_FALSE(encoder_message.has_connection_close_header);
@@ -212,7 +215,8 @@ H1_ENCODER_TEST_CASE(h1_encoder_case_insensitive_header_names) {
212215
aws_linked_list_init(&chunk_list);
213216

214217
struct aws_h1_encoder_message encoder_message;
215-
ASSERT_SUCCESS(aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
218+
ASSERT_SUCCESS(
219+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
216220

217221
ASSERT_TRUE(encoder_message.has_chunked_encoding_header);
218222
ASSERT_FALSE(encoder_message.has_connection_close_header);
@@ -299,7 +303,8 @@ H1_ENCODER_TEST_CASE(h1_encoder_transfer_encoding_chunked_across_multiple_header
299303
aws_linked_list_init(&chunk_list);
300304

301305
struct aws_h1_encoder_message encoder_message;
302-
ASSERT_SUCCESS(aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
306+
ASSERT_SUCCESS(
307+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
303308

304309
ASSERT_TRUE(encoder_message.has_chunked_encoding_header);
305310
ASSERT_FALSE(encoder_message.has_connection_close_header);
@@ -386,7 +391,8 @@ static int s_test_bad_request(
386391
struct aws_h1_encoder_message encoder_message;
387392

388393
ASSERT_ERROR(
389-
expected_error, aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
394+
expected_error,
395+
aws_h1_encoder_message_init_from_request(&encoder_message, allocator, request, &chunk_list, NULL, false));
390396

391397
aws_http_message_destroy(request);
392398
aws_h1_encoder_message_clean_up(&encoder_message);

0 commit comments

Comments
 (0)