src/Sockets/HttpRequest.cpp

   1 /**
   2  **     \file HttpRequest.cpp
   3  **     \date  2007-10-05
   4  **     \author grymse@alhem.net
   5 **/
   6 /*
   7 Copyright (C) 2007  Anders Hedstrom
   8
   9 This program is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU General Public License
  11 as published by the Free Software Foundation; either version 2
  12 of the License, or (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22 */
  23 #ifdef _MSC_VER
  24 #pragma warning(disable:4786)
  25 #endif
  26 #include "HttpRequest.h"
  27 #include "Utility.h"
  28 #include "MemFile.h"
  29 #include "HttpdForm.h"
  30 #include "HttpdCookies.h"
  31 #include "Parse.h"
  32
  33 #ifdef SOCKETS_NAMESPACE
  34 namespace SOCKETS_NAMESPACE {
  35 #endif
  36
  37 #ifdef _DEBUG
  38 #define DEB(x) x; fflush(stderr);
  39 #else
  40 #define DEB(x)
  41 #endif
  42
  43
  44 // --------------------------------------------------------------------------------------
  45 HttpRequest::HttpRequest() : HttpTransaction()
  46 , m_server_port(0)
  47 , m_is_ssl(false)
  48 , m_body_file(NULL)
  49 , m_form(NULL)
  50 {
  51 }
  52
  53
  54 // --------------------------------------------------------------------------------------
  55 HttpRequest::HttpRequest(const HttpRequest& src) : HttpTransaction(src)
  56 , m_method(src.m_method)
  57 , m_protocol(src.m_protocol)
  58 , m_req_uri(src.m_req_uri)
  59 , m_remote_addr(src.m_remote_addr)
  60 , m_remote_host(src.m_remote_host)
  61 , m_server_name(src.m_server_name)
  62 , m_server_port(src.m_server_port)
  63 , m_is_ssl(src.m_is_ssl)
  64 , m_attribute(src.m_attribute)
  65 , m_null(src.m_null)
  66 , m_body_file(src.m_body_file)
  67 , m_form(src.m_form)
  68 , m_cookies(src.m_cookies)
  69 , m_cookie(src.m_cookie)
  70 {
  71 }
  72
  73
  74 // --------------------------------------------------------------------------------------
  75 HttpRequest::~HttpRequest()
  76 {
  77         m_body_file = std::auto_ptr<IFile>(NULL);
  78         m_form = std::auto_ptr<HttpdForm>(NULL);
  79 /*
  80         if (m_body_file)
  81         {
  82                 delete m_body_file;
  83         }
  84         if (m_form)
  85         {
  86                 delete m_form;
  87         }
  88 */
  89 }
  90
  91
  92 // --------------------------------------------------------------------------------------
  93 void HttpRequest::SetHttpMethod(const std::string& value)
  94 {
  95         m_method = value;
  96 }
  97
  98
  99 const std::string& HttpRequest::HttpMethod() const
 100 {
 101         return m_method;
 102 }
 103
 104
 105
 106 // --------------------------------------------------------------------------------------
 107 void HttpRequest::SetHttpVersion(const std::string& value)
 108 {
 109         m_protocol = value;
 110 }
 111
 112
 113 const std::string& HttpRequest::HttpVersion() const
 114 {
 115         return m_protocol;
 116 }
 117
 118
 119
 120 // --------------------------------------------------------------------------------------
 121 void HttpRequest::SetUri(const std::string& value)
 122 {
 123         m_req_uri = Utility::rfc1738_decode(value);
 124 }
 125
 126
 127 const std::string& HttpRequest::Uri() const
 128 {
 129         return m_req_uri;
 130 }
 131
 132
 133
 134 // --------------------------------------------------------------------------------------
 135 void HttpRequest::SetRemoteAddr(const std::string& value)
 136 {
 137         m_remote_addr = value;
 138 }
 139
 140
 141 const std::string& HttpRequest::RemoteAddr() const
 142 {
 143         return m_remote_addr;
 144 }
 145
 146
 147
 148 // --------------------------------------------------------------------------------------
 149 void HttpRequest::SetRemoteHost(const std::string& value)
 150 {
 151         m_remote_host = value;
 152 }
 153
 154
 155 const std::string& HttpRequest::RemoteHost() const
 156 {
 157         return m_remote_host;
 158 }
 159
 160
 161
 162 // --------------------------------------------------------------------------------------
 163 void HttpRequest::SetServerName(const std::string& value)
 164 {
 165         m_server_name = value;
 166 }
 167
 168
 169 const std::string& HttpRequest::ServerName() const
 170 {
 171         return m_server_name;
 172 }
 173
 174
 175
 176 // --------------------------------------------------------------------------------------
 177 void HttpRequest::SetServerPort(int value)
 178 {
 179         m_server_port = value;
 180 }
 181
 182
 183 int HttpRequest::ServerPort() const
 184 {
 185         return m_server_port;
 186 }
 187
 188
 189
 190 // --------------------------------------------------------------------------------------
 191 void HttpRequest::SetIsSsl(bool value)
 192 {
 193         m_is_ssl = value;
 194 }
 195
 196
 197 bool HttpRequest::IsSsl() const
 198 {
 199         return m_is_ssl;
 200 }
 201
 202
 203
 204 // --------------------------------------------------------------------------------------
 205 void HttpRequest::SetAttribute(const std::string& key, const std::string& value)
 206 {
 207         m_attribute[Utility::ToLower(key)] = value;
 208 }
 209
 210
 211 void HttpRequest::SetAttribute(const std::string& key, long value)
 212 {
 213         m_attribute[Utility::ToLower(key)] = Utility::l2string(value);
 214 }
 215
 216
 217 const std::string& HttpRequest::Attribute(const std::string& key) const
 218 {
 219         std::map<std::string, std::string>::const_iterator it;
 220         if ( (it = m_attribute.find(Utility::ToLower(key))) != m_attribute.end())
 221                 return it -> second;
 222         return m_null;
 223 }
 224
 225
 226 // --------------------------------------------------------------------------------------
 227 const std::map<std::string, std::string>& HttpRequest::Attributes() const
 228 {
 229         return m_attribute;
 230 }
 231
 232
 233 // --------------------------------------------------------------------------------------
 234 void HttpRequest::AddCookie(const std::string& str)
 235 {
 236         m_cookies.add( str );
 237         Parse pa(str, ";");
 238         std::string lstr = pa.getword();
 239         while (!lstr.empty())
 240         {
 241                 Parse pa2(lstr, "=");
 242                 std::string name = pa2.getword();
 243                 m_cookie[name] = lstr;
 244 DEB(fprintf(stderr, " *** AddCookie '%s' = '%s'\n", name.c_str(), lstr.c_str());)
 245                 lstr = pa.getword();
 246         }
 247 }
 248
 249
 250 // --------------------------------------------------------------------------------------
 251 void HttpRequest::InitBody( size_t sz )
 252 {
 253         if (!m_body_file.get())
 254                 m_body_file = std::auto_ptr<IFile>(new MemFile);
 255 DEB(    else
 256                 fprintf(stderr, "Body data file already opened\n");)
 257 }
 258
 259
 260 // --------------------------------------------------------------------------------------
 261 void HttpRequest::Write( const char *buf, size_t sz )
 262 {
 263         if (m_body_file.get())
 264                 m_body_file -> fwrite(buf, 1, sz);
 265 DEB(    else
 266                 fprintf(stderr, "Write: Body data file not open\n");)
 267 }
 268
 269
 270 // --------------------------------------------------------------------------------------
 271 void HttpRequest::CloseBody()
 272 {
 273         if (m_body_file.get())
 274                 m_body_file -> fclose();
 275 DEB(    else
 276                 fprintf(stderr, "CloseBody: File not open\n");)
 277 }
 278
 279
 280 // --------------------------------------------------------------------------------------
 281 void HttpRequest::ParseBody()
 282 {
 283         std::map<std::string, std::string>::const_iterator it;
 284         if ( (it = m_attribute.find("query_string")) != m_attribute.end())
 285         {
 286                 std::string qs = it -> second;
 287                 m_form = std::auto_ptr<HttpdForm>(new HttpdForm( qs, qs.size() ));
 288         }
 289         else
 290         if (m_body_file.get())
 291         {
 292                 m_form = std::auto_ptr<HttpdForm>(new HttpdForm( m_body_file.get(), ContentType(), ContentLength() ));
 293         }
 294         else
 295         {
 296                 // dummy
 297                 m_form = std::auto_ptr<HttpdForm>(new HttpdForm( "", 0 ));
 298         }
 299 }
 300
 301
 302 // --------------------------------------------------------------------------------------
 303 const HttpdForm& HttpRequest::Form() const
 304 {
 305         return *m_form;
 306 }
 307
 308
 309 // --------------------------------------------------------------------------------------
 310 const HttpdCookies& HttpRequest::Cookies() const
 311 {
 312         return m_cookies;
 313 }
 314
 315
 316 // --------------------------------------------------------------------------------------
 317 void HttpRequest::Reset()
 318 {
 319         HttpTransaction::Reset();
 320         m_method = "";
 321         m_protocol = "";
 322         m_req_uri = "";
 323         m_remote_addr = "";
 324         m_remote_host = "";
 325         m_server_name = "";
 326         m_server_port = 0;
 327         m_is_ssl = false;
 328         while (!m_attribute.empty())
 329         {
 330                 m_attribute.erase(m_attribute.begin());
 331         }
 332         m_body_file = std::auto_ptr<IFile>(NULL);
 333         m_form = std::auto_ptr<HttpdForm>(NULL);
 334 /*
 335         if (m_body_file)
 336         {
 337                 delete m_body_file;
 338                 m_body_file = NULL;
 339         }
 340         if (m_form)
 341         {
 342                 delete m_form;
 343                 m_form = NULL;
 344         }
 345 */
 346         m_cookies.Reset();
 347         while (!m_cookie.empty())
 348         {
 349                 m_cookie.erase(m_cookie.begin());
 350         }
 351 }
 352
 353
 354 #ifdef SOCKETS_NAMESPACE
 355 } // namespace SOCKETS_NAMESPACE {
 356 #endif
 357
 358