source/client.cpp

   1 #include <boost/bind.hpp>
   2 #include <iostream>
   3 #include <cstdlib>
   4 #include <theodwalha/client.hpp>
   5 #include <theodwalha/configuration.hpp>
   6 #include <theodwalha/temporary.hpp>
   7 #include <theodwalha/reply.hpp>
   8
   9 http_server_client::http_server_client(boost::asio::io_service & io_service, temporary_file_manager & file_manager, module_manager & modules):
  10         socket(io_service),
  11         file_manager(file_manager),
  12         modules(modules),
  13         keep_alive_counter(keep_alive_max)
  14 {
  15         read_buffer = new char[read_buffer_size];
  16 }
  17
  18 http_server_client::~http_server_client()
  19 {
  20         delete read_buffer;
  21 }
  22
  23 void http_server_client::start()
  24 {
  25         initialise();
  26         read();
  27 }
  28
  29 void http_server_client::initialise()
  30 {
  31         bytes_read = 0;
  32         got_header = false;
  33 }
  34
  35 void http_server_client::read()
  36 {
  37         if(debugging)
  38                 std::cout << "Reading" << std::endl;
  39
  40         socket.async_read_some(boost::asio::buffer(read_buffer, read_buffer_size), boost::bind(&http_server_client::read_event, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
  41 }
  42
  43 void http_server_client::write(std::string const & data)
  44 {
  45         if(debugging)
  46                 std::cout << "Writing:" << std::endl << data << std::endl;
  47
  48         char * write_buffer = new char[data.size()];
  49         std::memcpy(write_buffer, data.c_str(), data.size());
  50         boost::asio::async_write(socket, boost::asio::buffer(write_buffer, data.size()), boost::bind(&http_server_client::write_event, this, boost::asio::placeholders::error, write_buffer));
  51 }
  52
  53 void http_server_client::terminate()
  54 {
  55         if(debugging)
  56                 std::cout << "Terminating" << std::endl;
  57         if(!temporary_file_name.empty())
  58         {
  59                 temporary_file.close();
  60                 file_manager.release(temporary_file_name);
  61         }
  62         delete this;
  63 }
  64
  65 void http_server_client::read_event(boost::system::error_code const & error, std::size_t bytes_in_buffer)
  66 {
  67         if(debugging)
  68                 std::cout << "Read event" << std::endl;
  69
  70         if(!error)
  71         {
  72                 if(debugging)
  73                         std::cout << "Read " << bytes_in_buffer << " bytes" << std::endl;
  74                 bytes_read += bytes_in_buffer;
  75
  76                 if(bytes_read > maximal_request_size)
  77                 {
  78                         std::cout << "Request too large" << std::endl;
  79                         terminate();
  80                         return;
  81                 }
  82
  83                 std::string new_data(read_buffer, bytes_in_buffer);
  84
  85                 if(temporary_file_name.empty())
  86                 {
  87                         extended_buffer += new_data;
  88
  89                         if(debugging)
  90                                 std::cout << extended_buffer << std::endl;
  91
  92                         if(!got_header)
  93                         {
  94                                 std::string error_message;
  95                                 current_request = http_request();
  96                                 process_header_result::type result = process_header(extended_buffer, current_request, error_message);
  97                                 switch(result)
  98                                 {
  99                                         case process_header_result::no_delimiter:
 100                                                 std::cout << "No delimiter yet" << std::endl;
 101                                                 break;
 102
 103                                         case process_header_result::error:
 104                                                 std::cout << error_message << std::endl;
 105                                                 terminate();
 106                                                 return;
 107
 108                                         case process_header_result::success:
 109                                                 got_header = true;
 110                                                 if(debugging)
 111                                                         std::cout << "Retrieved the full HTTP header" << std::endl;
 112                                                 break;
 113                                 }
 114                         }
 115
 116                         if(extended_buffer.size() > maximal_extended_buffer_size)
 117                         {
 118                                 if(!got_header)
 119                                 {
 120                                         std::cout << "A client exceeded the maximal extended buffer size without delivering the HTTP header" << std::endl;
 121                                         terminate();
 122                                         return;
 123                                 }
 124
 125                                 temporary_file_name = file_manager.generate_name();
 126                                 if(!temporary_file.open_create(temporary_file_name))
 127                                 {
 128                                         std::cout << "Failed to open temporary file " << temporary_file_name << std::endl;
 129                                         exit(1);
 130                                 }
 131
 132                                 temporary_file.write(extended_buffer);
 133                                 extended_buffer.clear();
 134
 135                                 std::cout << "Using temporary file name " << temporary_file_name << std::endl;
 136                         }
 137                 }
 138                 else
 139                         temporary_file.write(new_data);
 140
 141                 if(got_header)
 142                 {
 143                         std::size_t expected_byte_count = current_request.header_size + current_request.content_length;
 144                         if(debugging)
 145                                 std::cout << "Expected byte count: " << current_request.header_size << " + " << current_request.content_length << " = " << expected_byte_count << std::endl;
 146                         if(bytes_read > expected_byte_count)
 147                         {
 148                                 std::cout << "Received too many bytes from a client: " << bytes_read << " > " << expected_byte_count << std::endl;
 149                                 terminate();
 150                                 return;
 151                         }
 152                         else if(bytes_read == expected_byte_count)
 153                         {
 154                                 if(debugging)
 155                                         std::cout << "Ready to serve data for " << current_request.path << std::endl;
 156                                 module_result result;
 157                                 if(modules.process_request(current_request, result))
 158                                 {
 159                                         if(debugging)
 160                                                 std::cout << "The module manager successfully processed the request" << std::endl;
 161                                         std::string data;
 162                                         if(generate_content(current_request, result, data))
 163                                         {
 164                                                 if(debugging)
 165                                                         std::cout << "Successfully generated the HTTP content, serving it to the client" << std::endl;
 166                                                 write(data);
 167                                                 return;
 168                                         }
 169                                         else
 170                                         {
 171                                                 std::cout << "Failed to generate HTTP content" << std::endl;
 172                                                 terminate();
 173                                                 return;
 174                                         }
 175                                 }
 176                                 else
 177                                 {
 178                                         std::cout << "The module manager failed to process this request" << std::endl;
 179                                         terminate();
 180                                         return;
 181                                 }
 182                         }
 183                 }
 184
 185                 read();
 186         }
 187         else
 188         {
 189                 if(debugging)
 190                         std::cout << "Read error" << std::endl;
 191                 terminate();
 192         }
 193 }
 194
 195 void http_server_client::write_event(boost::system::error_code const & error, char * write_buffer)
 196 {
 197         delete write_buffer;
 198
 199         if(debugging)
 200                 std::cout << "Got a write event" << std::endl;
 201
 202         if(!error)
 203         {
 204                 if(current_request.keep_alive)
 205                 {
 206                         keep_alive_counter--;
 207                         if(keep_alive_counter <= 0)
 208                         {
 209                                 if(debugging)
 210                                         std::cout << "Client keep alive counter is zero" << std::endl;
 211                                 terminate();
 212                         }
 213                         else
 214                         {
 215                                 if(debugging)
 216                                         std::cout << "Reinitialising the state" << std::endl;
 217                                 initialise();
 218                                 read();
 219                         }
 220                 }
 221                 else
 222                 {
 223                         if(debugging)
 224                                 std::cout << "No keep-alive" << std::endl;
 225                         terminate();
 226                 }
 227         }
 228         else
 229         {
 230                 std::cout << "Write error" << std::endl;
 231                 terminate();
 232         }
 233 }
 234
 235 bool http_server_client::generate_content(http_request & request, module_result & result, std::string & content)
 236 {
 237         http_reply reply;
 238         reply.protocol = request.protocol_version;
 239         switch(result.return_code)
 240         {
 241                 case request_handler_return_code::ok:
 242                         reply.ok();
 243                         break;
 244
 245                 case request_handler_return_code::forbidden:
 246                         reply.forbidden();
 247                         break;
 248
 249                 case request_handler_return_code::not_found:
 250                         reply.not_found();
 251                         break;
 252
 253                 default:
 254                         std::cout << "Unknown request handler return code specified" << std::endl;
 255                         return false;
 256         }
 257
 258         reply.gzip = request.gzip;
 259         reply.keep_alive = request.keep_alive;
 260         reply.content_type = result.content_type;
 261         reply.keep_alive_timeout = keep_alive_timeout;
 262         reply.keep_alive_max = keep_alive_counter;
 263         reply.content = result.content;
 264
 265         if(!reply.get_packet(content))
 266         {
 267                 std::cout << "Failed to build reply packet" << std::endl;
 268                 return false;
 269         }
 270
 271         return true;
 272 }