00001
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifdef _MSC_VER
00034 #pragma warning(disable:4786)
00035 #endif
00036 #include "Ajp13Socket.h"
00037 #include "ajp13.h"
00038
00039 #ifdef SOCKETS_NAMESPACE
00040 namespace SOCKETS_NAMESPACE {
00041 #endif
00042
00043 #ifdef _DEBUG
00044 #define DEB(x) x
00045 #else
00046 #define DEB(x)
00047 #endif
00048
00049
00050
00051 Ajp13Socket::Ajp13Socket(ISocketHandler& h) : AjpBaseSocket(h)
00052 , m_body_size_left(0)
00053 , m_b_reused(false)
00054 {
00055 }
00056
00057
00058
00059 void Ajp13Socket::OnHeader( short id, short len )
00060 {
00061 if (id != 0x1234)
00062 {
00063 DEB( fprintf(stderr, "ABORT: bad packet id: %x\n", id);)
00064 SetCloseAndDelete();
00065 }
00066 else
00067 {
00068 DEB(fprintf(stderr, "Packet size: %d bytes\n", len);)
00069 }
00070 }
00071
00072
00073
00074 void Ajp13Socket::ReceiveBody(const char *buf, size_t sz)
00075 {
00076 if (sz - 2 > m_body_size_left)
00077 {
00078 DEB( fprintf(stderr, "More body data received than expected\n");)
00079 SetCloseAndDelete();
00080 return;
00081 }
00082
00083 m_req.Write( buf + 2, sz - 2 );
00084 m_body_size_left -= sz - 2;
00085
00086
00087 if (m_body_size_left)
00088 {
00089 int ptr = 4;
00090 char msg[100];
00091 msg[0] = 'A';
00092 msg[1] = 'B';
00093
00094
00095
00096
00097
00098
00099
00100
00101 put_byte(msg, ptr, 0x06);
00102 put_integer(msg, ptr, 1000);
00103
00104 short len = htons( ptr - 4 );
00105 memcpy( msg + 2, &len, 2 );
00106
00107 SendBuf( msg, ptr );
00108 return;
00109 }
00110
00111
00112 m_req.CloseBody();
00113
00114
00115 Execute();
00116
00117 }
00118
00119
00120
00121 void Ajp13Socket::ReceiveForwardRequest( const char *buf, size_t sz )
00122 {
00123
00124 int ptr = 0;
00125
00126 get_byte(buf, ptr);
00127 unsigned char method = get_byte(buf, ptr);
00128 std::string protocol = get_string(buf, ptr);
00129 std::string req_uri = get_string(buf, ptr);
00130 std::string remote_addr = get_string(buf, ptr);
00131 std::string remote_host = get_string(buf, ptr);
00132 std::string server_name = get_string(buf, ptr);
00133 short server_port = get_integer(buf, ptr);
00134 bool is_ssl = get_boolean(buf, ptr);
00135
00136 std::string method_str = Utility::l2string( method );
00137 std::map<int, std::string>::const_iterator it = Init.Method.find( method );
00138 if (it != Init.Method.end())
00139 {
00140 method_str = it -> second;
00141 }
00142 m_req.SetHttpMethod( method_str );
00143 m_req.SetHttpVersion( protocol );
00144 m_req.SetUri( req_uri );
00145 m_req.SetRemoteAddr( remote_addr );
00146 m_req.SetRemoteHost( remote_host );
00147 m_req.SetServerName( server_name );
00148 m_req.SetServerPort( server_port );
00149 m_req.SetIsSsl( is_ssl );
00150
00151
00152 short num_headers = get_integer(buf, ptr);
00153 for (int i = 0; i < num_headers; i++)
00154 {
00155 std::string key;
00156 if ( (unsigned char)buf[ptr] == 0xa0)
00157 {
00158 unsigned short x = (unsigned short)get_integer(buf, ptr);
00159 std::map<int, std::string>::const_iterator it;
00160 if ( (it = Init.Header.find(x)) != Init.Header.end())
00161 {
00162 key = it -> second;
00163 }
00164 else
00165 {
00166 DEB( fprintf(stderr, "Unknown header key value: %x\n", x);)
00167 SetCloseAndDelete();
00168 break;
00169 }
00170 }
00171 else
00172 {
00173 key = get_string(buf, ptr);
00174 }
00175 if (Utility::ToLower(key) == "cookie" || Utility::ToLower(key) == "cookie2")
00176 m_req.AddCookie(get_string(buf, ptr));
00177 else
00178 m_req.SetHeader(key, get_string(buf, ptr));
00179 }
00180
00181
00182 m_body_size_left = m_req.ContentLength();
00183
00184
00185 bool ok = true;
00186 while ( (unsigned char)buf[ptr] != 0xff)
00187 {
00188 std::string key;
00189 unsigned char code = buf[ptr++];
00190 switch ( code)
00191 {
00192 case 10:
00193 key = get_string(buf, ptr);
00194 break;
00195 default:
00196 {
00197 std::map<int, std::string>::const_iterator it = Init.Attribute.find( code );
00198 if (it != Init.Attribute.end())
00199 {
00200 key = it -> second;
00201 }
00202 else
00203 {
00204 DEB( fprintf(stderr, "Unknown attribute key: 0x%02x\n", buf[ptr]);)
00205 SetCloseAndDelete();
00206 ok = false;
00207 }
00208 }
00209 }
00210 if (!ok)
00211 break;
00212 if (code == 11)
00213 m_req.SetAttribute(key, get_integer(buf, ptr));
00214 else
00215 m_req.SetAttribute(key, get_string(buf, ptr));
00216 }
00217
00218
00219 if (!m_body_size_left)
00220 {
00221 Execute();
00222 }
00223 else
00224 {
00225
00226 m_req.InitBody( m_body_size_left );
00227 }
00228 }
00229
00230
00231
00232 void Ajp13Socket::ReceiveShutdown( const char *buf, size_t sz )
00233 {
00234 }
00235
00236
00237
00238 void Ajp13Socket::ReceivePing( const char *buf, size_t sz )
00239 {
00240 }
00241
00242
00243
00244 void Ajp13Socket::ReceiveCPing( const char *buf, size_t sz )
00245 {
00246 char msg[5];
00247 msg[0] = 'A';
00248 msg[1] = 'B';
00249
00250 int ptr = 4;
00251 put_byte(msg, ptr, 0x09);
00252
00253 short len = htons( ptr - 4 );
00254 memcpy( msg + 2, &len, 2 );
00255
00256 SendBuf( msg, ptr );
00257
00258 if (m_b_reused)
00259 reset();
00260 }
00261
00262
00263
00264 void Ajp13Socket::Execute()
00265 {
00266
00267 m_req.ParseBody();
00268
00269
00270 IHttpServer_OnExec( m_req );
00271
00272 }
00273
00274
00275
00276 void Ajp13Socket::IHttpServer_Respond(const HttpResponse& res)
00277 {
00278 char msg[8192];
00279 msg[0] = 'A';
00280 msg[1] = 'B';
00281
00282 m_res = res;
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292 if (!m_res.ContentLength() && m_res.GetFile().size())
00293 {
00294
00295 }
00296
00297
00298 {
00299 int ptr = 4;
00300 put_byte(msg, ptr, 0x04);
00301 put_integer(msg, ptr, m_res.HttpStatusCode() );
00302 put_string(msg, ptr, m_res.HttpStatusMsg() );
00303 put_integer(msg, ptr, (short)m_res.Headers().size() );
00304 for (Utility::ncmap<std::string>::const_iterator it = m_res.Headers().begin(); it != m_res.Headers().end(); ++it)
00305 {
00306 Utility::ncmap<int>::const_iterator it2 = Init.ResponseHeader.find( it -> first );
00307 if (it2 != Init.ResponseHeader.end())
00308 {
00309 put_integer(msg, ptr, it2 -> second);
00310 }
00311 else
00312 {
00313 put_string(msg, ptr, it -> first);
00314 }
00315 put_string(msg, ptr, it -> second);
00316 }
00317 std::list<std::string> vec = m_res.CookieNames();
00318 {
00319 for (std::list<std::string>::iterator it = vec.begin(); it != vec.end(); ++it)
00320 {
00321 Utility::ncmap<int>::const_iterator it2 = Init.ResponseHeader.find( "set-cookie" );
00322 if (it2 != Init.ResponseHeader.end())
00323 {
00324 put_integer(msg, ptr, it2 -> second);
00325 }
00326 else
00327 {
00328 put_string(msg, ptr, "set-cookie");
00329 }
00330 put_string(msg, ptr, m_res.Cookie(*it) );
00331 }
00332 }
00333
00334 short len = htons( ptr - 4 );
00335 memcpy( msg + 2, &len, 2 );
00336
00337 SendBuf( msg, ptr );
00338 }
00339
00340 OnTransferLimit();
00341 }
00342
00343
00344
00345 void Ajp13Socket::OnTransferLimit()
00346 {
00347 char msg[8192];
00348 msg[0] = 'A';
00349 msg[1] = 'B';
00350
00351
00352 size_t n = m_res.GetFile().fread(msg + 7, 1, 8100);
00353 while (n > 0)
00354 {
00355 int ptr = 4;
00356 put_byte(msg, ptr, 0x03);
00357 put_integer(msg, ptr, (short)n);
00358 ptr += (int)n;
00359 put_byte(msg, ptr, 0);
00360
00361 short len = htons( ptr - 4 );
00362 memcpy( msg + 2, &len, 2 );
00363
00364 SendBuf( msg, ptr );
00365 if (GetOutputLength() > 1)
00366 {
00367 SetTransferLimit( 1 );
00368 break;
00369 }
00370
00371
00372 n = m_res.GetFile().fread(msg + 7, 1, 8100);
00373 }
00374 if (!GetOutputLength())
00375 {
00376
00377 int ptr = 4;
00378 put_byte(msg, ptr, 0x05);
00379 put_boolean(msg, ptr, m_b_reused);
00380
00381
00382
00383
00384
00385
00386 short len = htons( ptr - 4 );
00387 memcpy( msg + 2, &len, 2 );
00388
00389 SendBuf( msg, ptr );
00390
00391 SetTransferLimit(0);
00392 m_res.GetFile().fclose();
00393 IHttpServer_OnResponseComplete();
00394 if (m_b_reused)
00395 {
00396 Reset();
00397 }
00398 }
00399 }
00400
00401
00402
00403 void Ajp13Socket::Reset()
00404 {
00405 reset();
00406 m_body_size_left = 0;
00407 m_req.Reset();
00408 m_res.Reset();
00409 }
00410
00411
00412
00413 void Ajp13Socket::OnPacket( const char *buf, size_t sz )
00414 {
00415 DEB(fprintf(stderr, "OnPacket: %d bytes, code 0x%02x %02x %02x %02x\n", sz, *buf, buf[1], buf[2], buf[3]);)
00416
00417
00418 if (m_body_size_left)
00419 {
00420 ReceiveBody(buf, sz);
00421 return;
00422 }
00423 switch (*buf)
00424 {
00425 case 0x2:
00426 ReceiveForwardRequest(buf, sz);
00427 break;
00428 case 0x7:
00429 ReceiveShutdown(buf, sz);
00430 break;
00431 case 0x8:
00432 ReceivePing(buf, sz);
00433 break;
00434 case 0xa:
00435 ReceiveCPing(buf, sz);
00436 break;
00437 default:
00438 DEB( fprintf(stderr, "Unknown packet type: 0x%02x\n", *buf);)
00439 SetCloseAndDelete();
00440 }
00441
00442 }
00443
00444
00445
00446 void Ajp13Socket::SetReused(bool x)
00447 {
00448 m_b_reused = x;
00449 }
00450
00451
00452
00453 bool Ajp13Socket::IsReused()
00454 {
00455 return m_b_reused;
00456 }
00457
00458
00459 #ifdef SOCKETS_NAMESPACE
00460 }
00461 #endif
00462
00463