• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #include "test/core/end2end/end2end_tests.h"
20 
21 #include <stdio.h>
22 #include <string.h>
23 
24 #include <grpc/byte_buffer.h>
25 #include <grpc/grpc.h>
26 #include <grpc/support/alloc.h>
27 #include <grpc/support/log.h>
28 #include <grpc/support/time.h>
29 #include "src/core/lib/gpr/string.h"
30 #include "test/core/end2end/cq_verifier.h"
31 
tag(intptr_t t)32 static void* tag(intptr_t t) { return (void*)t; }
33 
begin_test(grpc_end2end_test_config config,const char * test_name,grpc_channel_args * client_args,grpc_channel_args * server_args)34 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
35                                             const char* test_name,
36                                             grpc_channel_args* client_args,
37                                             grpc_channel_args* server_args) {
38   grpc_end2end_test_fixture f;
39   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
40   f = config.create_fixture(client_args, server_args);
41   config.init_client(&f, client_args);
42   config.init_server(&f, server_args);
43   return f;
44 }
45 
n_seconds_from_now(int n)46 static gpr_timespec n_seconds_from_now(int n) {
47   return grpc_timeout_seconds_to_deadline(n);
48 }
49 
five_seconds_from_now(void)50 static gpr_timespec five_seconds_from_now(void) {
51   return n_seconds_from_now(5);
52 }
53 
drain_cq(grpc_completion_queue * cq)54 static void drain_cq(grpc_completion_queue* cq) {
55   grpc_event ev;
56   do {
57     ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
58   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
59 }
60 
shutdown_server(grpc_end2end_test_fixture * f)61 static void shutdown_server(grpc_end2end_test_fixture* f) {
62   if (!f->server) return;
63   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
64   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
65                                          grpc_timeout_seconds_to_deadline(5),
66                                          nullptr)
67                  .type == GRPC_OP_COMPLETE);
68   grpc_server_destroy(f->server);
69   f->server = nullptr;
70 }
71 
shutdown_client(grpc_end2end_test_fixture * f)72 static void shutdown_client(grpc_end2end_test_fixture* f) {
73   if (!f->client) return;
74   grpc_channel_destroy(f->client);
75   f->client = nullptr;
76 }
77 
end_test(grpc_end2end_test_fixture * f)78 static void end_test(grpc_end2end_test_fixture* f) {
79   shutdown_server(f);
80   shutdown_client(f);
81 
82   grpc_completion_queue_shutdown(f->cq);
83   drain_cq(f->cq);
84   grpc_completion_queue_destroy(f->cq);
85   grpc_completion_queue_destroy(f->shutdown_cq);
86 }
87 
simple_request_body(grpc_end2end_test_fixture f)88 static void simple_request_body(grpc_end2end_test_fixture f) {
89   grpc_call* c;
90   cq_verifier* cqv = cq_verifier_create(f.cq);
91   grpc_op ops[6];
92   grpc_op* op;
93   grpc_metadata_array initial_metadata_recv;
94   grpc_metadata_array trailing_metadata_recv;
95   grpc_metadata_array request_metadata_recv;
96   grpc_call_details call_details;
97   grpc_status_code status;
98   grpc_call_error error;
99   grpc_slice details;
100 
101   grpc_slice host = grpc_slice_from_static_string("slartibartfast.local");
102   gpr_timespec deadline = five_seconds_from_now();
103   c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
104                                grpc_slice_from_static_string("/foo"), &host,
105                                deadline, nullptr);
106   GPR_ASSERT(c);
107 
108   grpc_metadata_array_init(&initial_metadata_recv);
109   grpc_metadata_array_init(&trailing_metadata_recv);
110   grpc_metadata_array_init(&request_metadata_recv);
111   grpc_call_details_init(&call_details);
112 
113   memset(ops, 0, sizeof(ops));
114   op = ops;
115   op->op = GRPC_OP_SEND_INITIAL_METADATA;
116   op->data.send_initial_metadata.count = 0;
117   op->flags = 0;
118   op->reserved = nullptr;
119   op++;
120   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
121   op->flags = 0;
122   op->reserved = nullptr;
123   op++;
124   op->op = GRPC_OP_RECV_INITIAL_METADATA;
125   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
126   op->flags = 0;
127   op->reserved = nullptr;
128   op++;
129   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
130   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
131   op->data.recv_status_on_client.status = &status;
132   op->data.recv_status_on_client.status_details = &details;
133   op->flags = 0;
134   op->reserved = nullptr;
135   op++;
136   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
137                                 nullptr);
138   GPR_ASSERT(GRPC_CALL_OK == error);
139 
140   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
141   cq_verify(cqv);
142 
143   GPR_ASSERT(status == GRPC_STATUS_INTERNAL);
144 
145   grpc_slice_unref(details);
146   grpc_metadata_array_destroy(&initial_metadata_recv);
147   grpc_metadata_array_destroy(&trailing_metadata_recv);
148   grpc_metadata_array_destroy(&request_metadata_recv);
149   grpc_call_details_destroy(&call_details);
150 
151   grpc_call_unref(c);
152 
153   cq_verifier_destroy(cqv);
154 }
155 
test_invoke_simple_request(grpc_end2end_test_config config)156 static void test_invoke_simple_request(grpc_end2end_test_config config) {
157   grpc_end2end_test_fixture f;
158 
159   f = begin_test(config, "test_invoke_simple_request", nullptr, nullptr);
160   simple_request_body(f);
161   end_test(&f);
162   config.tear_down_data(&f);
163 }
164 
bad_hostname(grpc_end2end_test_config config)165 void bad_hostname(grpc_end2end_test_config config) {
166   if (config.feature_mask & FEATURE_MASK_SUPPORTS_HOSTNAME_VERIFICATION) {
167     test_invoke_simple_request(config);
168   }
169 }
170 
bad_hostname_pre_init(void)171 void bad_hostname_pre_init(void) {}
172