source: cheroxy/trunk/src/CRXProxy.cpp@ 34

Last change on this file since 34 was 34, checked in by cheese, 11 years ago

#1 fix crash bug for memcpy on getting request/response message from CRXProxy
File size: 9.0 KB
Line 
1/**
2 * CRXProxy.cpp
3 */
4
5#include "CRXProxy.h"
6
7#include <string.h>
8
9CRXFilter CRXProxy::mFilter;
10
11CRXProxy::CRXProxy (void)
12 : mIsIntercepted (false),
13 mClient (0),
14 mServer (0)
15{
16 /*----------------------------------------------------------------*/
17 /*----------------------------------------------------------------*/
18}
19
20CRXProxy::~CRXProxy (void)
21{
22 /*----------------------------------------------------------------*/
23 Close ();
24 /*----------------------------------------------------------------*/
25}
26
27CRXProxy *
28CRXProxy::GetNewInstance(void)
29{
30 /*----------------------------------------------------------------*/
31 /*----------------------------------------------------------------*/
32
33 return new(std::nothrow) CRXProxy ();
34}
35
36void
37CRXProxy::ReleaseInstance (void)
38{
39 /*----------------------------------------------------------------*/
40 delete this;
41 /*----------------------------------------------------------------*/
42}
43
44void
45CRXProxy::SetClientSocket (const int aSocket)
46{
47 /*----------------------------------------------------------------*/
48 if (aSocket <= 0)
49 return ;
50
51 mClient = aSocket;
52 /*----------------------------------------------------------------*/
53}
54
55void
56CRXProxy::Close (void)
57{
58 /*----------------------------------------------------------------*/
59 mServer.Close ();
60 mClient.Close ();
61 /*----------------------------------------------------------------*/
62}
63
64void
65CRXProxy::SetRequestFilter (const E_CRX_FILTER_REQUEST aType,
66 const bool aIsMatched,
67 const std::string aValue)
68{
69 /*----------------------------------------------------------------*/
70 mFilter.SetRequestFilter (aType, aIsMatched, aValue);
71 /*----------------------------------------------------------------*/
72}
73
74void
75CRXProxy::RemoveRequestFilter (const E_CRX_FILTER_REQUEST aType)
76{
77 /*----------------------------------------------------------------*/
78 mFilter.RemoveRequestFilter (aType);
79 /*----------------------------------------------------------------*/
80}
81
82bool
83CRXProxy::CheckRequestFilter (const E_CRX_FILTER_REQUEST aType)
84{
85 /*----------------------------------------------------------------*/
86 /*----------------------------------------------------------------*/
87
88 return mFilter.CheckRequestFilter (aType, this->mHttpRequest);
89}
90
91int
92CRXProxy::Forward (void)
93{
94 int aResult = 0;
95
96 /*----------------------------------------------------------------*/
97 aResult = ReceiveRequest ();
98 if (aResult < 0)
99 {
100 aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
101 CRX_ERROR (aResult, "Failed to receive from client");
102 }
103
104 aResult = SendRequest ();
105 if (aResult < 0)
106 {
107 aResult = ERROR_PROXY_FAILED_TO_SEND_REQUEST;
108 CRX_ERROR (aResult, "Failed to send to server");
109 return aResult;
110 }
111
112 aResult = ReceiveResponse ();
113 if (aResult < 0)
114 {
115 aResult = ERROR_PROXY_FAILED_TO_RECEIVE_RESPONSE;
116 CRX_ERROR (aResult, "Failed to receive from server");
117 }
118
119 aResult = SendResponse ();
120 if (aResult < 0)
121 {
122 aResult = ERROR_PROXY_FAILED_TO_SEND_RESPONSE;
123 CRX_ERROR (aResult, "Failed to send to client");
124 return aResult;
125 }
126 /*----------------------------------------------------------------*/
127
128 return aResult;
129}
130
131void
132CRXProxy::SetHttpRequest (const char * aHttpRequest)
133{
134 /*----------------------------------------------------------------*/
135 mHttpRequest = aHttpRequest;
136 /*----------------------------------------------------------------*/
137}
138
139char *
140CRXProxy::GetHttpRequest (char * aBuffer,
141 const int aBufferSize) const
142{
143 void * aPtr = static_cast<void *> (aBuffer);
144
145 int aCopyLength = 0;
146 int aRemainLength = aBufferSize;
147 const int aHeaderLength = mHttpRequest.GetHeader ().length ();
148
149 /*----------------------------------------------------------------*/
150 if (aPtr == NULL)
151 return NULL;
152
153 aCopyLength = aRemainLength < aHeaderLength ? aBufferSize : aHeaderLength;
154 if (aCopyLength > 0)
155 memcpy (aPtr, mHttpRequest.GetHeader ().c_str (), aCopyLength);
156 /*----------------------------------------------------------------*/
157
158 return aBuffer;
159}
160
161int
162CRXProxy::GetHttpRequestLength (void) const
163{
164 /*----------------------------------------------------------------*/
165 /*----------------------------------------------------------------*/
166
167 return mHttpRequest.GetHeader().length ();
168}
169
170void
171CRXProxy::SetHttpResponse (const char * aHttpResponse)
172{
173 /*----------------------------------------------------------------*/
174 mHttpResponse = aHttpResponse;
175 /*----------------------------------------------------------------*/
176}
177
178char *
179CRXProxy::GetHttpResponse (char * aBuffer,
180 const int aBufferSize) const
181{
182 void * aPtr = static_cast<void *> (aBuffer);
183
184 int aCopyLength = 0;
185 int aRemainLength = aBufferSize;
186 const int aHeaderLength = mHttpResponse.GetHeader ().length ();
187 const int aContentLength = mHttpResponse.GetContentLength ();
188
189 /*----------------------------------------------------------------*/
190 if (aPtr == NULL)
191 return NULL;
192
193 aCopyLength = aRemainLength < aHeaderLength ? aBufferSize : aHeaderLength;
194 if (aCopyLength > 0)
195 memcpy (aPtr, mHttpResponse.GetHeader ().c_str (), aCopyLength);
196
197 aRemainLength -= aCopyLength;
198
199 aCopyLength = aRemainLength < aContentLength ? aRemainLength : aContentLength;
200 if (aCopyLength > 0)
201 memcpy (aPtr, mHttpResponse.GetContentBody (), aCopyLength);
202 /*----------------------------------------------------------------*/
203
204 return aBuffer;
205}
206
207int
208CRXProxy::GetHttpResponseLength (void) const
209{
210 /*----------------------------------------------------------------*/
211 /*----------------------------------------------------------------*/
212
213 return mHttpResponse.GetHeader ().length ()
214 + mHttpResponse.GetContentLength ();
215}
216
217int
218CRXProxy::ReceiveRequest (void)
219{
220 int aResult = 0;
221
222 const unsigned int aBufferSize = 1024 * 56;
223 char aBuffer[aBufferSize + 1] = {0x00, };
224
225 /*----------------------------------------------------------------*/
226 aResult = mClient.Receive (aBuffer, aBufferSize);
227 if (aResult < 0)
228 {
229 aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
230 CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
231 CRX_ERROR (aResult, "Failed to receive from client");
232 return aResult;
233 }
234
235 /* parse http request */
236 mHttpRequest = aBuffer;
237 /*----------------------------------------------------------------*/
238
239 return aResult < 0 ? aResult : 0;
240}
241
242int
243CRXProxy::SendRequest (void)
244{
245 int aResult = 0;
246 int aSize = mHttpRequest.GetHeader ().length ();
247
248 /*----------------------------------------------------------------*/
249 if (!mServer)
250 {
251 /* connect */
252 aResult = mServer.Connect (mHttpRequest.GetHost (), mHttpRequest.GetPort (), 1);
253 if (aResult < 0)
254 {
255 aResult = ERROR_PROXY_FAILED_TO_CONNECT_TO_SERVER;
256 CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
257 CRX_ERROR (aResult, "Failed to connect to server <%s>", mHttpRequest.GetURL ().c_str ());
258 return aResult;
259 }
260 }
261
262 aResult = mServer.Send (mHttpRequest.GetHeader ().c_str (), aSize);
263 if (aResult != aSize)
264 {
265 CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
266 CRX_ERROR (aResult, "Failed to send to server <%s>", mHttpRequest.GetURL ().c_str ());
267 }
268 /*----------------------------------------------------------------*/
269
270 return aResult < 0 ? aResult : 0;
271}
272
273int
274CRXProxy::ReceiveResponse (void)
275{
276 int aResult = 0;
277
278 const unsigned int aBufferSize = 1024 * 64;
279 char aBuffer[aBufferSize + 1] = {0x00, };
280
281 std::string aHttpResponse;
282
283 /*----------------------------------------------------------------*/
284 for (;;)
285 {
286 memset (aBuffer, 0x00, sizeof (aBuffer));
287
288 aResult = mServer.Receive (aBuffer, aBufferSize);
289 if (aResult < 0)
290 {
291 aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
292 CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
293 CRX_ERROR (aResult, "Failed to receive from server");
294 return aResult;
295 }
296 else if (aResult == 0)
297 {
298 break;
299 }
300
301 aResult = mHttpResponse.SetResponse (aBuffer, aResult);
302 if (aResult)
303 {
304 aResult = ERROR_PROXY_FAILED_TO_SET_RESPONSE;
305 CRX_ERROR (aResult, "Failed to set response");
306 return aResult;
307 }
308 }
309 /*----------------------------------------------------------------*/
310
311 return aResult < 0 ? aResult : 0;
312}
313
314int
315CRXProxy::SendResponse (void)
316{
317 int aResult = 0;
318 int aSize = 0;
319
320 /*----------------------------------------------------------------*/
321 aSize = mHttpResponse.GetHeader ().length ();;
322 aResult = mClient.Send (mHttpResponse.GetHeader ().c_str (), aSize);
323 if (aResult != aSize)
324 {
325 CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
326 CRX_ERROR (aResult, "Failed to send to client");
327 return aResult;
328 }
329
330 aSize = mHttpResponse.GetContentLength ();
331 aResult = mClient.Send (mHttpResponse.GetContentBody (), aSize);
332 if (aResult != aSize)
333 {
334 CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
335 CRX_ERROR (aResult, "Failed to send to client");
336 }
337 /*----------------------------------------------------------------*/
338
339 return aResult < 0 ? aResult : 0;
340}
Note: See TracBrowser for help on using the repository browser.