← Back to branch summary

~ps10gel/ubuntu/xenial/trafficserver/6.2.0

« back to all changes in this revision

Viewing changes to iocore/net/NetTest-simple-proxy.c

  • Committer: Bazaar Package Importer
  • Author(s): Arno Toell
  • Date: 2011-01-13 11:49:18 UTC
  • Revision ID: james.westby@ubuntu.com-20110113114918-vu422h8dknrgkj15
Tags: upstream-2.1.5-unstable
Import upstream version 2.1.5-unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
iocore/net/NetTest-simple-proxy.c
 
1
/** @file
 
2
 
 
3
  A brief file description
 
4
 
 
5
  @section license License
 
6
 
 
7
  Licensed to the Apache Software Foundation (ASF) under one
 
8
  or more contributor license agreements.  See the NOTICE file
 
9
  distributed with this work for additional information
 
10
  regarding copyright ownership.  The ASF licenses this file
 
11
  to you under the Apache License, Version 2.0 (the
 
12
  "License"); you may not use this file except in compliance
 
13
  with the License.  You may obtain a copy of the License at
 
14
 
 
15
      http://www.apache.org/licenses/LICENSE-2.0
 
16
 
 
17
  Unless required by applicable law or agreed to in writing, software
 
18
  distributed under the License is distributed on an "AS IS" BASIS,
 
19
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
20
  See the License for the specific language governing permissions and
 
21
  limitations under the License.
 
22
 */
 
23
 
 
24
 
 
25
static unsigned int
 
26
get_addr(char *host)
 
27
{
 
28
  unsigned int addr = inet_addr(host);
 
29
  struct hostent *host_info = NULL;
 
30
 
 
31
  if (!addr || (-1 == (int) addr)) {
 
32
    host_info = gethostbyname(host);
 
33
    if (!host_info) {
 
34
      perror("gethostbyname");
 
35
      return (unsigned int) -1;
 
36
    }
 
37
    addr = *((unsigned int *) host_info->h_addr);
 
38
  }
 
39
  return addr;
 
40
}
 
41
 
 
42
 
 
43
 
 
44
char *origin_server = "npdev.inktomi.com";
 
45
unsigned int origin_server_ip;
 
46
unsigned short origin_server_port = 8080;
 
47
 
 
48
struct NetTesterSM:public Continuation
 
49
{
 
50
  VIO *client_read_vio;
 
51
  VIO *client_resp_write_vio;
 
52
  VIO *server_resp_read_vio;
 
53
  int server_vc_closed, client_vc_closed;
 
54
 
 
55
  IOBufferReader *client_reader, *client_parse_reader;
 
56
 
 
57
  NetVConnection *client_vc, *server_vc;
 
58
  MIOBuffer *request_buf;
 
59
  MIOBuffer *response_buf;
 
60
  char request[2000];
 
61
  int req_len;
 
62
 
 
63
 
 
64
    NetTesterSM(ProxyMutex * _mutex, NetVConnection * _vc):Continuation(_mutex),
 
65
    server_vc_closed(0), client_vc_closed(0)
 
66
  {
 
67
    MUTEX_TRY_LOCK(lock, mutex, _vc->thread);
 
68
    ink_release_assert(lock);
 
69
    client_vc = _vc;
 
70
    server_vc = NULL;
 
71
    SET_HANDLER(&NetTesterSM::handle_request_read_from_client);
 
72
    // jtest headers are really short
 
73
    request_buf = new_MIOBuffer(1);
 
74
    response_buf = new_MIOBuffer(8);
 
75
    client_reader = request_buf->alloc_reader();
 
76
    client_parse_reader = request_buf->alloc_reader();
 
77
    client_read_vio = client_vc->do_io_read(this, INT_MAX, request_buf);
 
78
    //client_vc->set_inactivity_timeout(HRTIME_SECONDS(60));
 
79
    req_len = 0;
 
80
  }
 
81
 
 
82
 
 
83
   ~NetTesterSM()
 
84
  {
 
85
    request_buf->dealloc_all_readers();
 
86
    request_buf->clear();
 
87
    free_MIOBuffer(request_buf);
 
88
    response_buf->dealloc_all_readers();
 
89
    response_buf->clear();
 
90
    free_MIOBuffer(response_buf);
 
91
    //close_server_vc();
 
92
    //close_client_vc();
 
93
  }
 
94
 
 
95
  /* ********************* jtest sample request   **********************
 
96
     GET http://npdev:8080/0.5216393021/6000 HTTP/1.0
 
97
     Proxy-Connection: Keep-Alive
 
98
   */
 
99
 
 
100
  int handle_request_read_from_client(int event, void *data)
 
101
  {
 
102
    int r;
 
103
    char *str;
 
104
    switch (event) {
 
105
    case VC_EVENT_READ_READY:
 
106
      r = client_parse_reader->read_avail();
 
107
      client_parse_reader->read(&request[req_len], r);
 
108
      req_len += r;
 
109
      request[req_len] = 0;
 
110
      Debug("net_test", "%s\n", request);
 
111
      fflush(stdout);
 
112
      //client_vc->set_inactivity_timeout(HRTIME_SECONDS(30));
 
113
      if (strcmp(&request[req_len - 4], "\r\n\r\n") == 0) {
 
114
        Debug("net_test", "The request header is :\n%s\n", request);
 
115
        client_vc->cancel_inactivity_timeout();
 
116
        // connect to the origin server
 
117
        SET_HANDLER(&NetTesterSM::handle_server_connect);
 
118
        sslNetProcessor.connect_re(this, origin_server_ip, origin_server_port);
 
119
      }
 
120
      break;
 
121
    case VC_EVENT_READ_COMPLETE:
 
122
      /* FALLSTHROUGH */
 
123
    case VC_EVENT_EOS:
 
124
      r = client_parse_reader->read_avail();
 
125
      str = NEW(new char[r + 10]);
 
126
      client_parse_reader->read(str, r);
 
127
      /* FALLSTHROUGH */
 
128
    case VC_EVENT_ERROR:
 
129
    case VC_EVENT_INACTIVITY_TIMEOUT:
 
130
      close_client_vc();
 
131
      // fixme
 
132
      // handle timeout events
 
133
      break;
 
134
    default:
 
135
      ink_release_assert(!"unknown event");
 
136
 
 
137
    }
 
138
    return EVENT_CONT;
 
139
  }
 
140
 
 
141
  int handle_server_connect(int event, Event * e)
 
142
  {
 
143
    switch (event) {
 
144
    case NET_EVENT_OPEN:
 
145
      server_vc = (NetVConnection *) e;
 
146
      SET_HANDLER(&NetTesterSM::handle_write_request_to_server);
 
147
      Debug("net_test", "connected to server\n");
 
148
      Debug("net_test", "writing %d to server\n", client_reader->read_avail());
 
149
      server_vc->do_io_write(this, client_reader->read_avail(), client_reader);
 
150
      //vc->set_inactivity_timeout(HRTIME_SECONDS(10));
 
151
      break;
 
152
    case NET_EVENT_OPEN_FAILED:
 
153
    default:
 
154
      close_client_vc();
 
155
      delete this;
 
156
    }
 
157
    return EVENT_CONT;
 
158
  }
 
159
 
 
160
  int handle_write_request_to_server(int event, Event * e)
 
161
  {
 
162
    IOBufferReader *resp_reader;
 
163
    switch (event) {
 
164
    case VC_EVENT_WRITE_READY:
 
165
      Debug("net_test", "wrote some bytes to server\n");
 
166
      break;
 
167
 
 
168
    case VC_EVENT_WRITE_COMPLETE:
 
169
      Debug("net_test", "wrote request to server\n");
 
170
      SET_HANDLER(&NetTesterSM::handle_response_pump);
 
171
      resp_reader = response_buf->alloc_reader();
 
172
 
 
173
      response_buf->autopilot = 1;
 
174
      server_resp_read_vio = server_vc->do_io_read(this, INT64_MAX, response_buf);
 
175
      client_resp_write_vio = client_vc->do_io_write(this, INT64_MAX, resp_reader);
 
176
      response_buf->assign_reader_vio(client_resp_write_vio, resp_reader);
 
177
      response_buf->assign_writer_vio(server_resp_read_vio);
 
178
      break;
 
179
    case VC_EVENT_EOS:
 
180
    case VC_EVENT_ERROR:
 
181
    case VC_EVENT_INACTIVITY_TIMEOUT:
 
182
      close_server_vc();
 
183
      close_client_vc();
 
184
      delete this;
 
185
      return EVENT_DONE;
 
186
      break;
 
187
    default:
 
188
      ink_release_assert(!"unknown event");
 
189
    }
 
190
    return EVENT_CONT;
 
191
  }
 
192
 
 
193
  void close_server_vc()
 
194
  {
 
195
    if (!server_vc_closed)
 
196
      server_vc->do_io_close();
 
197
    server_vc = NULL;
 
198
    server_vc_closed = 1;
 
199
  }
 
200
 
 
201
  void close_client_vc()
 
202
  {
 
203
    if (!client_vc_closed)
 
204
      client_vc->do_io_close();
 
205
    client_vc = NULL;
 
206
    client_vc_closed = 1;
 
207
  }
 
208
 
 
209
  int handle_response_pump(int event, Event * e)
 
210
  {
 
211
    int doc_len;
 
212
    switch (event) {
 
213
    case VC_EVENT_ERROR:
 
214
    case VC_EVENT_INACTIVITY_TIMEOUT:
 
215
      close_server_vc();
 
216
      close_client_vc();
 
217
      delete this;
 
218
      return EVENT_DONE;
 
219
      break;
 
220
 
 
221
 
 
222
    case VC_EVENT_WRITE_READY:
 
223
    case VC_EVENT_READ_READY:
 
224
      ink_release_assert(!"unexpected READY event in handle_response_pump");
 
225
      break;
 
226
 
 
227
    case VC_EVENT_READ_COMPLETE:
 
228
    case VC_EVENT_EOS:
 
229
      doc_len = server_resp_read_vio->ndone;
 
230
      Debug("net_test", "Got response %d bytes from server\n", doc_len);
 
231
      close_server_vc();
 
232
      if (client_resp_write_vio->ndone != doc_len) {
 
233
        client_resp_write_vio->set_nbytes(doc_len);
 
234
        client_vc->reenable(client_resp_write_vio);
 
235
      } else {
 
236
        Debug("net_test", "Wrote response %d bytes to client\n", client_resp_write_vio->ndone);
 
237
        close_client_vc();
 
238
        delete this;
 
239
        return EVENT_DONE;
 
240
      }
 
241
      break;
 
242
    case VC_EVENT_WRITE_COMPLETE:
 
243
      Debug("net_test", "Wrote response %d bytes to client\n", client_resp_write_vio->ndone);
 
244
      close_client_vc();
 
245
      delete this;
 
246
      return EVENT_DONE;
 
247
 
 
248
    default:
 
249
      ink_release_assert(!"unexpected event in handle_response_pump");
 
250
    }
 
251
    return EVENT_CONT;
 
252
 
 
253
  }
 
254
 
 
255
 
 
256
};
 
257
 
 
258
 
 
259
struct NetTesterAccept:public Continuation
 
260
{
 
261
 
 
262
  NetTesterAccept(ProxyMutex * _mutex):Continuation(_mutex)
 
263
  {
 
264
    SET_HANDLER(&NetTesterAccept::handle_accept);
 
265
  }
 
266
 
 
267
  int handle_accept(int event, void *data)
 
268
  {
 
269
    Debug("net_test", "Accepted a connection\n");
 
270
    NetVConnection *vc = (NetVConnection *) data;
 
271
    NEW(new NetTesterSM(new_ProxyMutex(), vc));
 
272
    return EVENT_CONT;
 
273
  }
 
274
 
 
275
 
 
276
};
 
277
 
 
278
//#define TEST_ACCEPT_CANCEL
 
279
 
 
280
struct Stop:public Continuation
 
281
{
 
282
  Action *a;
 
283
    Stop(ProxyMutex * m):Continuation(m)
 
284
  {
 
285
    SET_HANDLER(&Stop::stop);
 
286
  }
 
287
 
 
288
  int stop(int event, Event * e)
 
289
  {
 
290
    printf("Cancelling accept\n");
 
291
    a->cancel();
 
292
    return EVENT_DONE;
 
293
  }
 
294
};
 
295
 
 
296
 
 
297
int
 
298
test_main()
 
299
{
 
300
  Action *a;
 
301
  origin_server_ip = get_addr(origin_server);
 
302
 
 
303
  a = sslNetProcessor.accept(NEW(new NetTesterAccept(new_ProxyMutex())), 45080, true);
 
304
 
 
305
#ifdef TEST_ACCEPT_CANCEL
 
306
  Stop *s = NEW(new Stop(new_ProxyMutex()));
 
307
  eventProcessor.schedule_in(s, HRTIME_SECONDS(10));
 
308
  s->a = a;
 
309
#endif
 
310
 
 
311
  return 0;
 
312
}