void close()
{
boost::system::error_code ignored_ec;
m_socket.shutdown(
boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
m_socket.close(ignored_ec);
}
void run_server::process(socket_type ssock,
pfi::lang::shared_ptr<cgi> cc)
{
for (;;){
pfi::lang::shared_ptr<stream_socket> sock(ssock->accept());
if (!sock) continue;
if (ssock->timeout()>0 && !sock->set_timeout(ssock->timeout()))
continue;
try{
http::request req(sock);
stringstream sout;
map<string, string> env;
for (http::header::iterator p=req.head().begin();
p!=req.head().end(); p++)
env["HTTP_"+str_to_upper(p->first)]=p->second;
env["REQUEST_METHOD"]=req.method();
env["REQUEST_URI"]=req.path().path();
if (req.path().query()!="")
env["REQUEST_URI"]+="?"+req.path().query();
env["SCRIPT_NAME"]=req.path().path();
env["QUERY_STRING"]=req.path().query();
env["REMOTE_ADDR"]=sock->remote_addr().to_string();
env["REMOTE_PORT"]=lexical_cast<string>(sock->remote_port());
env["SERVER_PORT"]=lexical_cast<string>(ssock->port());
env["SERVER_NAME"]="localhost";
env["SERVER_PROTOCOL"]="HTTP/1.1";
env["SERVER_SIGNATURE"]="pficommon/" PFICOMMON_VERSION " standalone web server";
env["SERVER_SOFTWARE"]="pficommon/" PFICOMMON_VERSION;
env["CONTENT_LENGTH"]=req.head()["Content-Length"];
env["CONTENT_TYPE"]=req.head()["Content-Type"];
cc->exec(req.body(), sout, cerr, env);
pfi::lang::shared_ptr<http::response> resp=gen_resp(sout);
resp->send(sock);
}
catch(exception&){
}
}
}
lambda(int id_, http_sync_server& self_,
socket_type&& sock_)
: id(id_)
, self(self_)
, sock(std::move(sock_))
, work(sock.get_io_service())
{
}
void write()
{
m_socket.async_write_some(
m_write_buf.data(),
bind(&this_type::handle_write, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)
);
}
void read()
{
m_socket.async_read_some(
m_read_buf.prepare(),
bind(&this_type::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)
);
}
Request (CheckerImp& owner, boost::asio::io_service& io_service,
IP::Endpoint const& address, asio::shared_handler <
void (Result)> const& handler)
: m_owner (owner)
, m_io_service (io_service)
, m_address (address)
, m_handler (handler)
, m_socket (m_io_service)
, m_canAccept (false)
{
m_owner.add (*this);
m_socket.async_connect (IPAddressConversion::to_asio_endpoint (
m_address), asio::wrap_handler (std::bind (
&Request::handle_connect, Ptr(this),
asio::placeholders::error), m_handler));
}
/// Try receive one packet from the socket into the incoming_queue
bool receive_one_from_socket_into_queue()
{
bool r=false;
// Is there space to receive a packet?
if( incoming_not_full() )
{
// Yes, try receive a packet into the queue
if( m_sock->recv(incoming_queue().incoming()) >= 0 )
{
// Got one! push it into the incoming queue
incoming_queue().push();
// and show success
r = true;
}
}
return r;
}
/// Send one packet from the outgoing_queue out the socket
bool send_one_from_queue_to_socket()
{
bool r=false;
// Is there a packet to send?
if( outgoing_not_empty() )
{
// Yes, try send it
if( m_sock->send(outgoing_queue().outgoing()) >= 0 )
{
// Success sending it, so pop the packet off the outgoing queue
outgoing_queue().pop();
// and show success
r=true;
}
}
return r;
}
size_t do_write_some(const const_buffer &buffers, error_code &ec)
{
return socket.write_some(buffers, ec);
}
size_t do_write_some(const const_buffer &buffers)
{
return socket.write_some(buffers);
}
size_t do_read_some(const mutable_buffer &buffers, error_code &ec)
{
return socket.read_some(buffers, ec);
}
lowest_layer_type& do_lowest_layer()
{
return socket.lowest_layer();
}
io_service& do_get_io_service()
{
return socket.get_io_service();
}
void do_async_write_some(const const_buffer &buffers, WriteHandler handler)
{
socket.async_write_some(buffers, handler);
}
void do_async_read_some(const mutable_buffer &buffers, ReadHandler handler)
{
socket.async_read_some(buffers, handler);
}
ios_type& io_service()
{ return m_socket.get_io_service();}
void cancel ()
{
m_socket.cancel();
}
const lowest_layer_type& do_lowest_layer() const
{
return socket.lowest_layer();
}
static void resize_buffs(socket_type sock, const size_t rx_size, const size_t tx_size){
if (rx_size != 0) sock->set_option(asio::socket_base::receive_buffer_size(rx_size));
if (tx_size != 0) sock->set_option(asio::socket_base::send_buffer_size(tx_size));
}
size_t do_read_some(const mutable_buffer &buffers)
{
return socket.read_some(buffers);
}
