Sockets/HTTPSocket.cpp

   1 /** \file HTTPSocket.cpp
   2  **     \date  2004-04-06
   3  **     \author grymse@alhem.net
   4 **/
   5 /*
   6 Copyright (C) 2004-2007  Anders Hedstrom
   7
   8 This library is made available under the terms of the GNU GPL.
   9
  10 If you would like to use this library in a closed-source application,
  11 a separate license agreement is available. For information about
  12 the closed-source license agreement for the C++ sockets library,
  13 please visit http://www.alhem.net/Sockets/license.html and/or
  14 email license@alhem.net.
  15
  16 This program is free software; you can redistribute it and/or
  17 modify it under the terms of the GNU General Public License
  18 as published by the Free Software Foundation; either version 2
  19 of the License, or (at your option) any later version.
  20
  21 This program is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public License
  27 along with this program; if not, write to the Free Software
  28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29 */
  30 #ifdef _MSC_VER
  31 #pragma warning(disable:4786)
  32 #endif
  33 #include "HTTPSocket.h"
  34 #include "Parse.h"
  35 #include "ISocketHandler.h"
  36 #include "Utility.h"
  37 #include <stdarg.h>
  38
  39 #ifdef SOCKETS_NAMESPACE
  40 namespace SOCKETS_NAMESPACE {
  41 #endif
  42
  43
  44 HTTPSocket::HTTPSocket(ISocketHandler& h)
  45 :TcpSocket(h)
  46 ,m_first(true)
  47 ,m_header(true)
  48 ,m_http_version("HTTP/1.0")
  49 ,m_request(false)
  50 ,m_response(false)
  51 ,m_body_size_left(0)
  52 ,m_b_http_1_1(false)
  53 ,m_b_keepalive(false)
  54 {
  55         SetLineProtocol();
  56         DisableInputBuffer();
  57 }
  58
  59
  60 HTTPSocket::~HTTPSocket()
  61 {
  62 }
  63
  64
  65 void HTTPSocket::OnRawData(const char *buf,size_t len)
  66 {
  67         if (!m_header)
  68         {
  69                 if (!m_b_http_1_1 || !m_b_keepalive)
  70                 {
  71                         OnData(buf, len);
  72                 }
  73                 else
  74                 {
  75                         size_t sz = m_body_size_left < len ? m_body_size_left : len;
  76                         OnData(buf, sz);
  77                         m_body_size_left -= sz;
  78                         if (!m_body_size_left)
  79                         {
  80                                 SetLineProtocol( true );
  81                                 m_first = true;
  82                                 m_header = true;
  83                                 m_body_size_left = 0;
  84                                 if (len - sz > 0)
  85                                 {
  86                                         char tmp[TCP_BUFSIZE_READ];
  87                                         memcpy(tmp, buf + sz, len - sz);
  88                                         tmp[len - sz] = 0;
  89                                         OnRead( tmp, len - sz );
  90                                 }
  91                         }
  92                 }
  93         }
  94 }
  95
  96
  97 void HTTPSocket::OnLine(const std::string& line)
  98 {
  99         if (m_first)
 100         {
 101                 Parse pa(line);
 102                 std::string str = pa.getword();
 103                 if (str.size() > 4 && Utility::ToLower(str.substr(0,5)) == "http/") // response
 104                 {
 105                         m_http_version = str;
 106                         m_status = pa.getword();
 107                         m_status_text = pa.getrest();
 108                         m_response = true;
 109                 }
 110                 else // request
 111                 {
 112                         m_method = str;
 113                         m_url = pa.getword();
 114                         size_t spl = m_url.find("?");
 115                         if (spl != std::string::npos)
 116                         {
 117                                 m_uri = m_url.substr(0,spl);
 118                                 m_query_string = m_url.substr(spl + 1);
 119                         }
 120                         else
 121                         {
 122                                 m_uri = m_url;
 123                                 m_query_string = "";
 124                         }
 125                         m_http_version = pa.getword();
 126                         m_b_http_1_1 = m_http_version.size() > 4 && m_http_version.substr(4) == "/1.1";
 127                         m_b_keepalive = m_b_http_1_1;
 128                         m_request = true;
 129                 }
 130                 m_first = false;
 131                 OnFirst();
 132                 return;
 133         }
 134         if (!line.size())
 135         {
 136                 if (m_body_size_left || !m_b_http_1_1 || !m_b_keepalive)
 137                 {
 138                         SetLineProtocol(false);
 139                         m_header = false;
 140                 }
 141                 OnHeaderComplete();
 142                 return;
 143         }
 144         Parse pa(line,":");
 145         std::string key = pa.getword();
 146         std::string value = pa.getrest();
 147         OnHeader(key,value);
 148         if (Utility::ToLower(key) == "content-length")
 149         {
 150                 m_body_size_left = atol(value.c_str());
 151         }
 152         if (m_b_http_1_1 && Utility::ToLower(key) == "connection")
 153         {
 154                 m_b_keepalive = Utility::ToLower(value) != "close";
 155         }
 156         /* If remote end tells us to keep connection alive, and we're operating
 157         in http/1.1 mode (not http/1.0 mode), then we mark the socket to be
 158         retained. */
 159 #ifdef ENABLE_POOL
 160         if (m_b_http_1_1 && m_b_keepalive)
 161         {
 162                 SetRetain();
 163         }
 164 #endif
 165 }
 166
 167
 168 void HTTPSocket::SendResponse()
 169 {
 170         std::string msg;
 171         msg = m_http_version + " " + m_status + " " + m_status_text + "\r\n";
 172         for (string_m::iterator it = m_response_header.begin(); it != m_response_header.end(); it++)
 173         {
 174                 std::string key = (*it).first;
 175                 std::string val = (*it).second;
 176                 msg += key + ": " + val + "\r\n";
 177         }
 178         for (std::list<std::pair<std::string, std::string> >::iterator it2 = m_response_header_append.begin(); it2 != m_response_header_append.end(); ++it2)
 179         {
 180                 msg += it2 -> first + ": " + it2 -> second + "\r\n";
 181         }
 182         msg += "\r\n";
 183         Send( msg );
 184 }
 185
 186
 187 void HTTPSocket::AddResponseHeader(const std::string& header, const char *format, ...)
 188 {
 189         char slask[5000]; // temporary for vsprintf / vsnprintf
 190         va_list ap;
 191
 192         va_start(ap, format);
 193 #ifdef _WIN32
 194         vsprintf(slask, format, ap);
 195 #else
 196         vsnprintf(slask, 5000, format, ap);
 197 #endif
 198         va_end(ap);
 199
 200         m_response_header[header] = slask;
 201 }
 202
 203
 204 void HTTPSocket::SendRequest()
 205 {
 206         std::string msg;
 207         msg = m_method + " " + m_url + " " + m_http_version + "\r\n";
 208         for (string_m::iterator it = m_response_header.begin(); it != m_response_header.end(); it++)
 209         {
 210                 std::string key = (*it).first;
 211                 std::string val = (*it).second;
 212                 msg += key + ": " + val + "\r\n";
 213         }
 214         msg += "\r\n";
 215         Send( msg );
 216 }
 217
 218
 219 std::string HTTPSocket::MyUseragent()
 220 {
 221         std::string version = "C++Sockets/";
 222 #ifdef _VERSION
 223         version += _VERSION;
 224 #endif
 225         return version;
 226 }
 227
 228
 229 void HTTPSocket::Reset()
 230 {
 231         m_first = true;
 232         m_header = true;
 233         m_request = false;
 234         m_response = false;
 235         SetLineProtocol(true);
 236         while (m_response_header.size())
 237         {
 238                 string_m::iterator it = m_response_header.begin();
 239                 m_response_header.erase(it);
 240         }
 241         while (m_response_header_append.size())
 242         {
 243                 std::list<std::pair<std::string, std::string> >::iterator it = m_response_header_append.begin();
 244                 m_response_header_append.erase(it);
 245         }
 246
 247 }
 248
 249
 250 const std::string& HTTPSocket::GetMethod()
 251 {
 252         return m_method;
 253 }
 254
 255
 256 void HTTPSocket::SetMethod(const std::string& x)
 257 {
 258         m_method = x;
 259 }
 260
 261
 262 const std::string& HTTPSocket::GetUrl()
 263 {
 264         return m_url;
 265 }
 266
 267
 268 void HTTPSocket::SetUrl(const std::string& x)
 269 {
 270         m_url = x;
 271 }
 272
 273
 274 const std::string& HTTPSocket::GetUri()
 275 {
 276         return m_uri;
 277 }
 278
 279
 280 const std::string& HTTPSocket::GetQueryString()
 281 {
 282         return m_query_string;
 283 }
 284
 285
 286 const std::string& HTTPSocket::GetHttpVersion()
 287 {
 288         return m_http_version;
 289 }
 290
 291
 292 const std::string& HTTPSocket::GetStatus()
 293 {
 294         return m_status;
 295 }
 296
 297
 298 const std::string& HTTPSocket::GetStatusText()
 299 {
 300         return m_status_text;
 301 }
 302
 303
 304 bool HTTPSocket::IsRequest()
 305 {
 306         return m_request;
 307 }
 308
 309
 310 bool HTTPSocket::IsResponse()
 311 {
 312         return m_response;
 313 }
 314
 315
 316 void HTTPSocket::SetHttpVersion(const std::string& x)
 317 {
 318         m_http_version = x;
 319 }
 320
 321
 322 void HTTPSocket::SetStatus(const std::string& x)
 323 {
 324         m_status = x;
 325 }
 326
 327
 328 void HTTPSocket::SetStatusText(const std::string& x)
 329 {
 330         m_status_text = x;
 331 }
 332
 333
 334 void HTTPSocket::AddResponseHeader(const std::string& x,const std::string& y)
 335 {
 336         m_response_header[Utility::ToLower(x)] = y;
 337 }
 338
 339
 340 void HTTPSocket::AppendResponseHeader(const std::string& x,const std::string& y)
 341 {
 342         m_response_header_append.push_back(std::pair<std::string, std::string>(Utility::ToLower(x),y));
 343 }
 344
 345
 346 void HTTPSocket::SetUri(const std::string& x)
 347 {
 348         m_uri = x;
 349 }
 350
 351
 352 void HTTPSocket::url_this(const std::string& url_in,std::string& protocol,std::string& host,port_t& port,std::string& url,std::string& file)
 353 {
 354         Parse pa(url_in,"/");
 355         protocol = pa.getword(); // http
 356         if (!strcasecmp(protocol.c_str(), "https:"))
 357         {
 358 #ifdef HAVE_OPENSSL
 359                 EnableSSL();
 360 #else
 361                 Handler().LogError(this, "url_this", -1, "SSL not available", LOG_LEVEL_WARNING);
 362 #endif
 363                 port = 443;
 364         }
 365         else
 366         {
 367                 port = 80;
 368         }
 369         host = pa.getword();
 370         if (strstr(host.c_str(),":"))
 371         {
 372                 Parse pa(host,":");
 373                 pa.getword(host);
 374                 port = static_cast<port_t>(pa.getvalue());
 375         }
 376         url = "/" + pa.getrest();
 377         {
 378                 Parse pa(url,"/");
 379                 std::string tmp = pa.getword();
 380                 while (tmp.size())
 381                 {
 382                         file = tmp;
 383                         tmp = pa.getword();
 384                 }
 385         }
 386 } // url_this
 387
 388
 389 bool HTTPSocket::ResponseHeaderIsSet(const std::string& name)
 390 {
 391         string_m::iterator it = m_response_header.find( Utility::ToLower(name) );
 392         if (it != m_response_header.end())
 393         {
 394                 return true;
 395         }
 396         std::list<std::pair<std::string, std::string> >::iterator it2;
 397         for (it2 = m_response_header_append.begin(); it2 != m_response_header_append.end(); it2++)
 398         {
 399                 std::pair<std::string, std::string>& ref = *it2;
 400                 if (ref.first == Utility::ToLower(name) )
 401                 {
 402                         return true;
 403                 }
 404         }
 405         return false;
 406 }
 407
 408
 409 #ifdef SOCKETS_NAMESPACE
 410 }
 411 #endif
 412
 413