src/Sockets/HttpdCookies.cpp

   1 /** \file HttpdCookies.cpp
   2 */
   3 /*
   4 Copyright (C) 2003-2007  Anders Hedstrom
   5
   6 This library is made available under the terms of the GNU GPL.
   7
   8 If you would like to use this library in a closed-source application,
   9 a separate license agreement is available. For information about
  10 the closed-source license agreement for the C++ sockets library,
  11 please visit http://www.alhem.net/Sockets/license.html and/or
  12 email license@alhem.net.
  13
  14 This program is free software; you can redistribute it and/or
  15 modify it under the terms of the GNU General Public License
  16 as published by the Free Software Foundation; either version 2
  17 of the License, or (at your option) any later version.
  18
  19 This program is distributed in the hope that it will be useful,
  20 but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with this program; if not, write to the Free Software
  26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27 */
  28
  29 #ifdef _MSC_VER
  30 #pragma warning(disable:4786)
  31 #endif
  32 #include "Parse.h"
  33 #include "Utility.h"
  34 #include "HTTPSocket.h"
  35 #include "HttpdCookies.h"
  36
  37 #ifdef SOCKETS_NAMESPACE
  38 namespace SOCKETS_NAMESPACE {
  39 #endif
  40
  41 #ifdef _DEBUG
  42 #define DEB(x) x; fflush(stderr);
  43 #else
  44 #define DEB(x)
  45 #endif
  46
  47
  48 HttpdCookies::HttpdCookies()
  49 {
  50 }
  51
  52 HttpdCookies::HttpdCookies(const std::string& s)
  53 {
  54         Parse *pa = new Parse(s,";");
  55
  56         std::string slask = pa -> getword();
  57         while (slask.size())
  58         {
  59                 Parse *pa2 = new Parse(slask,"=");
  60                 std::string name = pa2 -> getword();
  61                 std::string value = pa2 -> getword();
  62                 delete pa2;
  63                 m_cookies.push_back(std::pair<std::string, std::string>(name, value));
  64                 //
  65                 slask = pa -> getword();
  66         }
  67         delete pa;
  68 }
  69
  70 void HttpdCookies::add(const std::string& s)
  71 {
  72         Parse *pa = new Parse(s,";");
  73 DEB(fprintf(stderr, "Parse cookie: %s\n", s.c_str());)
  74         std::string slask = pa -> getword();
  75         while (slask.size())
  76         {
  77                 Parse *pa2 = new Parse(slask,"=");
  78                 std::string name = pa2 -> getword();
  79                 std::string value = pa2 -> getword();
  80                 delete pa2;
  81                 m_cookies.push_back(std::pair<std::string, std::string>(name, value));
  82                 //
  83                 slask = pa -> getword();
  84         }
  85         delete pa;
  86 }
  87
  88 HttpdCookies::~HttpdCookies()
  89 {
  90 }
  91
  92 bool HttpdCookies::getvalue(const std::string& name,std::string& buffer) const
  93 {
  94         for (cookie_v::const_iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
  95         {
  96                 const std::pair<std::string, std::string>& ref = *it;
  97                 if (!strcasecmp(ref.first.c_str(),name.c_str()))
  98                 {
  99                         buffer = ref.second;
 100                         return true;
 101                 }
 102         }
 103         buffer = "";
 104         return false;
 105 }
 106
 107 void HttpdCookies::replacevalue(const std::string& name,const std::string& value)
 108 {
 109         for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
 110         {
 111                 std::pair<std::string, std::string>& ref = *it;
 112                 if (!strcasecmp(ref.first.c_str(),name.c_str()))
 113                 {
 114                         ref.second = value;
 115                         return;
 116                 }
 117         }
 118         m_cookies.push_back(std::pair<std::string, std::string>(name, value));
 119
 120 }
 121
 122 void HttpdCookies::replacevalue(const std::string& name,long l)
 123 {
 124         replacevalue(name, Utility::l2string(l));
 125 }
 126
 127 void HttpdCookies::replacevalue(const std::string& name,int i)
 128 {
 129         replacevalue(name, Utility::l2string(i));
 130 }
 131
 132 size_t HttpdCookies::getlength(const std::string& name) const
 133 {
 134         for (cookie_v::const_iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
 135         {
 136                 const std::pair<std::string, std::string>& ref = *it;
 137                 if (!strcasecmp(ref.first.c_str(),name.c_str()))
 138                 {
 139                         return ref.second.size();
 140                 }
 141         }
 142         return 0;
 143 }
 144
 145 void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, const std::string& value)
 146 {
 147         char *str = new char[name.size() + value.size() + domain.size() + path.size() + 100];
 148
 149         // set-cookie response
 150         if (domain.size())
 151         {
 152                 sprintf(str, "%s=%s; domain=%s; path=%s; expires=%s",
 153                  name.c_str(), value.c_str(),
 154                  domain.c_str(),
 155                  path.c_str(),
 156                  expiredatetime().c_str());
 157         }
 158         else
 159         {
 160                 sprintf(str, "%s=%s; path=%s; expires=%s",
 161                  name.c_str(), value.c_str(),
 162                  path.c_str(),
 163                  expiredatetime().c_str());
 164         }
 165         sock -> AddResponseHeader("Set-cookie", str);
 166         delete[] str;
 167
 168         replacevalue(name, value);
 169 }
 170
 171 void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, long value)
 172 {
 173         char *str = new char[name.size() + domain.size() + path.size() + 100];
 174         char dt[80];
 175
 176         // set-cookie response
 177         if (domain.size())
 178         {
 179                 sprintf(str, "%s=%ld; domain=%s; path=%s; expires=%s",
 180                  name.c_str(), value,
 181                  domain.c_str(),
 182                  path.c_str(),
 183                  expiredatetime().c_str());
 184         }
 185         else
 186         {
 187                 sprintf(str, "%s=%ld; path=%s; expires=%s",
 188                  name.c_str(), value,
 189                  path.c_str(),
 190                  expiredatetime().c_str());
 191         }
 192         sock -> AddResponseHeader("Set-cookie", str);
 193         delete[] str;
 194
 195         sprintf(dt, "%ld", value);
 196         replacevalue(name, dt);
 197 }
 198
 199 void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const std::string& path, const std::string& name, int value)
 200 {
 201         char *str = new char[name.size() + domain.size() + path.size() + 100];
 202         char dt[80];
 203
 204         // set-cookie response
 205         if (domain.size())
 206         {
 207                 sprintf(str, "%s=%d; domain=%s; path=%s; expires=%s",
 208                  name.c_str(), value,
 209                  domain.c_str(),
 210                  path.c_str(),
 211                  expiredatetime().c_str());
 212         }
 213         else
 214         {
 215                 sprintf(str, "%s=%d; path=%s; expires=%s",
 216                  name.c_str(), value,
 217                  path.c_str(),
 218                  expiredatetime().c_str());
 219         }
 220         sock -> AddResponseHeader("Set-cookie", str);
 221         delete[] str;
 222
 223         sprintf(dt, "%d", value);
 224         replacevalue(name, dt);
 225 }
 226
 227
 228 const std::string& HttpdCookies::expiredatetime() const
 229 {
 230         time_t t = time(NULL);
 231         struct tm tp;
 232 #ifdef _WIN32
 233         memcpy(&tp, gmtime(&t), sizeof(tp));
 234 #else
 235         gmtime_r(&t, &tp);
 236 #endif
 237         const char *days[7] = {"Sunday", "Monday",
 238          "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
 239         const char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May",
 240          "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 241         char dt[100];
 242
 243         sprintf(dt, "%s, %02d-%s-%04d %02d:%02d:%02d GMT",
 244          days[tp.tm_wday],
 245          tp.tm_mday,
 246          months[tp.tm_mon],
 247          tp.tm_year + 1910,
 248          tp.tm_hour,
 249          tp.tm_min,
 250          tp.tm_sec);
 251         m_date = dt;
 252         return m_date;
 253 }
 254
 255
 256 void HttpdCookies::Reset()
 257 {
 258         while (!m_cookies.empty())
 259         {
 260                 m_cookies.erase(m_cookies.begin());
 261         }
 262         m_date = "";
 263 }
 264
 265
 266 #ifdef SOCKETS_NAMESPACE
 267 }
 268 #endif
 269
 270