Sockets/HttpdForm.cpp

   1 /** \file HttpdForm.cpp - read stdin, parse cgi input
   2  **
   3  **     Written: 1999-Feb-10 grymse@alhem.net
   4  **/
   5
   6 /*
   7 Copyright (C) 1999-2007  Anders Hedstrom
   8
   9 This library is made available under the terms of the GNU GPL.
  10
  11 If you would like to use this library in a closed-source application,
  12 a separate license agreement is available. For information about
  13 the closed-source license agreement for the C++ sockets library,
  14 please visit http://www.alhem.net/Sockets/license.html and/or
  15 email license@alhem.net.
  16
  17 This program is free software; you can redistribute it and/or
  18 modify it under the terms of the GNU General Public License
  19 as published by the Free Software Foundation; either version 2
  20 of the License, or (at your option) any later version.
  21
  22 This program is distributed in the hope that it will be useful,
  23 but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 GNU General Public License for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with this program; if not, write to the Free Software
  29 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  30 */
  31 #ifdef _MSC_VER
  32 #pragma warning(disable:4786)
  33 #endif
  34 #include "socket_include.h"
  35 #include "Parse.h"
  36 #include "IFile.h"
  37 #include "HttpdForm.h"
  38
  39 #ifdef SOCKETS_NAMESPACE
  40 namespace SOCKETS_NAMESPACE {
  41 #endif
  42
  43 #define TMPSIZE 10000
  44
  45
  46 HttpdForm::HttpdForm(IFile *infil, const std::string& content_type, size_t content_length) : raw(false)
  47 {
  48         CGI *cgi = NULL;
  49         size_t extra = 2;
  50         char name[TMPSIZE];
  51
  52         m_current = m_cgi.end();
  53         *name = 0;
  54
  55         if (content_type.size() >= 19 && content_type.substr(0, 19) == "multipart/form-data")
  56         {
  57                 Parse pa(content_type,";=");
  58                 char *tempcmp = NULL;
  59                 size_t tc = 0;
  60                 size_t l = 0;
  61                 std::string str = pa.getword();
  62                 m_strBoundary = "";
  63                 while (str.size())
  64                 {
  65                         if (!strcmp(str.c_str(),"boundary"))
  66                         {
  67                                 m_strBoundary = pa.getword();
  68                                 l = m_strBoundary.size();
  69                                 tempcmp = new char[l + extra];
  70                         }
  71                         //
  72                         str = pa.getword();
  73                 }
  74                 if (m_strBoundary.size())
  75                 {
  76                         std::string content_type;
  77                         std::string current_name;
  78                         std::string current_filename;
  79                         char *slask = new char[TMPSIZE];
  80                         infil -> fgets(slask, TMPSIZE);
  81                         while (!infil -> eof())
  82                         {
  83                                 while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
  84                                 {
  85                                         slask[strlen(slask) - 1] = 0;
  86                                 }
  87                                 content_type = "";
  88                                 current_name = "";
  89                                 current_filename = "";
  90                                 if ((strstr(slask,m_strBoundary.c_str()) || strstr(m_strBoundary.c_str(),slask)) && strcmp(slask, m_strBoundary.c_str()))
  91                                 {
  92                                         m_strBoundary = slask;
  93                                         l = m_strBoundary.size();
  94                                         delete[] tempcmp;
  95                                         tempcmp = new char[l + extra];
  96                                 }
  97                                 if (!strcmp(slask, m_strBoundary.c_str()))
  98                                 {
  99                                         // Get headers until empty line
 100                                         infil -> fgets(slask, TMPSIZE);
 101                                         while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
 102                                         {
 103                                                 slask[strlen(slask) - 1] = 0;
 104                                         }
 105                                         while (!infil -> eof() && *slask)
 106                                         {
 107                                                 Parse pa(slask,";");
 108                                                 std::string h = pa.getword();
 109                                                 if (!strcasecmp(h.c_str(),"Content-type:"))
 110                                                 {
 111                                                         content_type = pa.getword();
 112                                                 }
 113                                                 else
 114                                                 if (!strcasecmp(h.c_str(),"Content-Disposition:"))
 115                                                 {
 116                                                         h = pa.getword();
 117                                                         if (!strcmp(h.c_str(),"form-data"))
 118                                                         {
 119                                                                 pa.EnableQuote(true);
 120                                                                 h = pa.getword();
 121                                                                 while (h.size())
 122                                                                 {
 123                                                                         Parse pa2(slask,"=");
 124                                                                         std::string name = pa2.getword();
 125                                                                         std::string h = pa2.getrest();
 126                                                                         if (!strcmp(name.c_str(),"name"))
 127                                                                         {
 128                                                                                 if (h.size() && h[0] == '"')
 129                                                                                 {
 130                                                                                         current_name = h.substr(1, h.size() - 2);
 131                                                                                 }
 132                                                                                 else
 133                                                                                 {
 134                                                                                         current_name = h;
 135                                                                                 }
 136                                                                         }
 137                                                                         else
 138                                                                         if (!strcmp(name.c_str(),"filename"))
 139                                                                         {
 140                                                                                 if (h.size() && h[0] == '"')
 141                                                                                 {
 142                                                                                         current_filename = h.substr(1, h.size() - 2);
 143                                                                                 }
 144                                                                                 else
 145                                                                                 {
 146                                                                                         current_filename = h;
 147                                                                                 }
 148                                                                                 size_t x = 0;
 149                                                                                 for (size_t i = 0; i < current_filename.size(); i++)
 150                                                                                 {
 151                                                                                         if (current_filename[i] == '/' || current_filename[i] == '\\')
 152                                                                                                 x = i + 1;
 153                                                                                 }
 154                                                                                 if (x)
 155                                                                                 {
 156                                                                                         current_filename = current_filename.substr(x);
 157                                                                                 }
 158                                                                         }
 159                                                                         h = pa.getword();
 160                                                                 }
 161                                                         }
 162                                                 }
 163                                                 // get next header value
 164                                                 infil -> fgets(slask, TMPSIZE);
 165                                                 while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
 166                                                 {
 167                                                         slask[strlen(slask) - 1] = 0;
 168                                                 }
 169                                         }
 170                                         // Read content, save...?
 171                                         if (!current_filename.size()) // not a file
 172                                         {
 173                                                 std::string val;
 174                                                 infil -> fgets(slask, TMPSIZE);
 175                                                 while (!infil -> eof() && strncmp(slask,m_strBoundary.c_str(),m_strBoundary.size() ))
 176                                                 {
 177                                                         val += slask;
 178                                                         infil -> fgets(slask, TMPSIZE);
 179                                                 }
 180                                                 // remove trailing cr/linefeed
 181                                                 while (val.size() && (val[val.size() - 1] == 13 || val[val.size() - 1] == 10))
 182                                                 {
 183                                                         val = val.substr(0,val.size() - 1);
 184                                                 }
 185                                                 cgi = new CGI(current_name, val);
 186                                                 m_cgi.push_back(cgi);
 187                                         }
 188                                         else // current_filename.size() > 0
 189                                         {
 190                                                 // read until m_strBoundary...
 191                                                 FILE *fil;
 192                                                 int out = 0;
 193                                                 char c;
 194                                                 char fn[2000]; // where post'd file will be saved
 195 #ifdef _WIN32
 196                                                 {
 197                                                         char tmp_path[2000];
 198                                                         ::GetTempPathA(2000, tmp_path);
 199                                                         if (tmp_path[strlen(tmp_path) - 1] != '\\')
 200                                                         {
 201                                                                 strcat(tmp_path, "\\");
 202                                                         }
 203                                                         sprintf(fn,"%s%s",tmp_path,current_filename.c_str());
 204                                                 }
 205 #else
 206                                                 sprintf(fn,"/tmp/%s",current_filename.c_str());
 207 #endif
 208                                                 if ((fil = fopen(fn, "wb")) != NULL)
 209                                                 {
 210                                                         infil -> fread(&c,1,1);
 211                                                         while (!infil -> eof())
 212                                                         {
 213                                                                 if (out)
 214                                                                 {
 215                                                                         fwrite(&tempcmp[tc],1,1,fil);
 216                                                                 }
 217                                                                 tempcmp[tc] = c;
 218                                                                 tc++;
 219                                                                 if (tc >= l + extra)
 220                                                                 {
 221                                                                         tc = 0;
 222                                                                         out = 1;
 223                                                                 }
 224                                                                 if (tc)
 225                                                                 {
 226                                                                         if (!strncmp(tempcmp + tc + extra, m_strBoundary.c_str(), l - tc) &&
 227                                                                                         !strncmp(tempcmp, m_strBoundary.c_str() + l - tc, tc))
 228                                                                         {
 229                                                                                 break;
 230                                                                         }
 231                                                                 }
 232                                                                 else
 233                                                                 {
 234                                                                         if (!strncmp(tempcmp + extra, m_strBoundary.c_str(), l))
 235                                                                         {
 236                                                                                 break;
 237                                                                         }
 238                                                                 }
 239                                                                 infil -> fread(&c,1,1);
 240                                                         }
 241                                                         fclose(fil);
 242
 243                                                         cgi = new CGI(current_name,fn,fn);
 244                                                         m_cgi.push_back(cgi);
 245
 246                                                         strcpy(slask, m_strBoundary.c_str());
 247                                                         infil -> fgets(slask + strlen(slask), TMPSIZE); // next line
 248                                                 }
 249                                                 else
 250                                                 {
 251                                                         // couldn't open file
 252                                                         break;
 253                                                 }
 254                                         }
 255                                 }
 256                                 else
 257                                 {
 258                                         // Probably '<m_strBoundary>--'
 259                                         break;
 260                                 }
 261                         } // while (!infil -> eof())
 262                         delete[] slask;
 263                 } // if (m_strBoundary)
 264                 if (tempcmp)
 265                 {
 266                         delete[] tempcmp;
 267                 }
 268         }
 269         else
 270         if (strstr(content_type.c_str(), "x-www-form-urlencoded"))
 271         {
 272                 bool got_name = false; // tnx to FatherNitwit
 273                 int i = 0;
 274                 int cl = (int)content_length;
 275                 char c,chigh,clow;
 276                 char *slask = new char[TMPSIZE];
 277                 m_current = m_cgi.end();
 278
 279                 *name = 0;
 280
 281                 infil -> fread(&c,1,1);
 282                 cl--;
 283                 while (cl >= 0 && !infil -> eof())
 284                 {
 285                         switch (c)
 286                         {
 287                                 case '=': /* end of name */
 288                                         slask[i] = 0;
 289                                         i = 0;
 290                                         strcpy(name,slask);
 291                                         got_name = true;
 292                                         break;
 293                                 case '&': /* end of value */
 294                                         slask[i] = 0;
 295                                         i = 0;
 296                                         if (got_name)
 297                                         {
 298                                                 cgi = new CGI(name,slask);
 299                                                 got_name = false;
 300                                         }
 301                                         else
 302                                         {
 303                                                 cgi = new CGI(slask, "");
 304                                         }
 305                                         m_cgi.push_back(cgi);
 306                                         break;
 307                                 case '+': /* space */
 308                                         slask[i++] = ' ';
 309                                         break;
 310                                 case '%': /* hex value */
 311                                         infil -> fread(&chigh,1,1);
 312                                         cl--;
 313                                         chigh -= 48 + (chigh > '9' ? 7 : 0) + (chigh >= 'a' ? 32 : 0);
 314                                         infil -> fread(&clow,1,1);
 315                                         cl--;
 316                                         clow -= 48 + (clow > '9' ? 7 : 0) + (clow >= 'a' ? 32 : 0);
 317                                         slask[i++] = (char)(chigh * 16 + clow);
 318                                         break;
 319                                 default: /* just another char */
 320                                         slask[i++] = c;
 321                                         break;
 322                         }
 323                         //
 324                         if (cl > 0)
 325                         {
 326                                 infil -> fread(&c,1,1);
 327                         }
 328                         cl--;
 329                 }
 330                 slask[i] = 0;
 331                 i = 0;
 332                 if (got_name)
 333                 {
 334                         cgi = new CGI(name,slask);
 335                 }
 336                 else
 337                 {
 338                         cgi = new CGI(slask, "");
 339                 }
 340                 m_cgi.push_back(cgi);
 341                 delete[] slask;
 342         }
 343 }
 344
 345
 346 // HttpdForm(buffer,l) -- request_method GET
 347
 348 HttpdForm::HttpdForm(const std::string& buffer,size_t l) : raw(false)
 349 {
 350         CGI *cgi = NULL;
 351         char *slask = new char[TMPSIZE];
 352         char *name = new char[TMPSIZE];
 353         int i = 0;
 354         char c,chigh,clow;
 355         size_t ptr = 0;
 356         bool got_name = false;
 357
 358         m_current = m_cgi.end();
 359
 360         *name = 0;
 361
 362         ptr = 0;
 363         while (ptr < l)
 364         {
 365                 c = buffer[ptr++];
 366                 switch (c)
 367                 {
 368                         case '=': /* end of name */
 369                                 slask[i] = 0;
 370                                 i = 0;
 371                                 strcpy(name,slask);
 372                                 got_name = true;
 373                                 break;
 374                         case '&': /* end of value */
 375                                 slask[i] = 0;
 376                                 i = 0;
 377                                 if (got_name)
 378                                 {
 379                                         cgi = new CGI(name,slask);
 380                                         got_name = false;
 381                                 }
 382                                 else
 383                                 {
 384                                         cgi = new CGI(slask, "");
 385                                 }
 386                                 m_cgi.push_back(cgi);
 387                                 break;
 388                         case '+': /* space */
 389                                 slask[i++] = ' ';
 390                                 break;
 391                         case '%': /* hex value */
 392                                 chigh = buffer[ptr++];
 393                                 chigh -= 48 + (chigh > '9' ? 7 : 0) + (chigh >= 'a' ? 32 : 0);
 394                                 clow = buffer[ptr++];
 395                                 clow -= 48 + (clow > '9' ? 7 : 0) + (clow >= 'a' ? 32 : 0);
 396                                 slask[i++] = (char)(chigh * 16 + clow);
 397                                 break;
 398                         default: /* just another char */
 399                                 slask[i++] = c;
 400                                 break;
 401                 }
 402         }
 403         slask[i] = 0;
 404         i = 0;
 405         if (got_name)
 406         {
 407                 cgi = new CGI(name,slask);
 408         }
 409         else
 410         {
 411                 cgi = new CGI(slask, "");
 412         }
 413         m_cgi.push_back(cgi);
 414         delete[] slask;
 415         delete[] name;
 416 }
 417
 418
 419 HttpdForm::~HttpdForm()
 420 {
 421         CGI *cgi = NULL; //,*tmp;
 422
 423         for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
 424         {
 425                 cgi = *it;
 426                 delete cgi;
 427         }
 428 }
 429
 430
 431 void HttpdForm::EnableRaw(bool b)
 432 {
 433         raw = b;
 434 }
 435
 436
 437 void HttpdForm::strcpyval(std::string& v,const char *value) const
 438 {
 439         v = "";
 440         for (size_t i = 0; i < strlen(value); i++)
 441         {
 442                 if (value[i] == '<')
 443                 {
 444                         v += "&lt;";
 445                 }
 446                 else
 447                 if (value[i] == '>')
 448                 {
 449                         v += "&gt;";
 450                 }
 451                 else
 452                 if (value[i] == '&')
 453                 {
 454                         v += "&amp;";
 455                 }
 456                 else
 457                 {
 458                         v += value[i];
 459                 }
 460         }
 461 }
 462
 463
 464 bool HttpdForm::getfirst(std::string& n) const
 465 {
 466         m_current = m_cgi.begin();
 467         return getnext(n);
 468 }
 469
 470
 471 bool HttpdForm::getnext(std::string& n) const
 472 {
 473         if (m_current != m_cgi.end() )
 474         {
 475                 CGI *current = *m_current;
 476                 n = current -> name;
 477                 m_current++;
 478                 return true;
 479         }
 480         else
 481         {
 482                 n = "";
 483         }
 484         return false;
 485 }
 486
 487
 488 bool HttpdForm::getfirst(std::string& n,std::string& v) const
 489 {
 490         m_current = m_cgi.begin();
 491         return getnext(n,v);
 492 }
 493
 494
 495 bool HttpdForm::getnext(std::string& n,std::string& v) const
 496 {
 497         if (m_current != m_cgi.end() )
 498         {
 499                 CGI *current = *m_current;
 500                 n = current -> name;
 501                 if (raw)
 502                 {
 503                         v = current -> value;
 504                 }
 505                 else
 506                 {
 507                         strcpyval(v,current -> value.c_str());
 508                 }
 509                 m_current++;
 510                 return true;
 511         }
 512         else
 513         {
 514                 n = "";
 515         }
 516         return false;
 517 }
 518
 519
 520 int HttpdForm::getvalue(const std::string& n,std::string& v) const
 521 {
 522         CGI *cgi = NULL;
 523         int r = 0;
 524
 525         for (cgi_v::const_iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
 526         {
 527                 cgi = *it;
 528                 if (cgi -> name == n)
 529                         break;
 530                 cgi = NULL;
 531         }
 532         if (cgi)
 533         {
 534                 if (raw)
 535                 {
 536                         v = cgi -> value;
 537                 }
 538                 else
 539                 {
 540                         strcpyval(v,cgi -> value.c_str());
 541                 }
 542                 r++;
 543         }
 544         else
 545         {
 546                 v = "";
 547         }
 548
 549         return r;
 550 }
 551
 552
 553 std::string HttpdForm::getvalue(const std::string& n) const
 554 {
 555         for (cgi_v::const_iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
 556         {
 557                 CGI *cgi = *it;
 558                 if (cgi -> name == n)
 559                 {
 560                         return cgi -> value;
 561                 }
 562         }
 563         return "";
 564 }
 565
 566
 567 size_t HttpdForm::getlength(const std::string& n) const
 568 {
 569         CGI *cgi = NULL;
 570         size_t l;
 571
 572         for (cgi_v::const_iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
 573         {
 574                 cgi = *it;
 575                 if (cgi -> name == n)
 576                         break;
 577                 cgi = NULL;
 578         }
 579         l = cgi ? cgi -> value.size() : 0;
 580         if (cgi && !raw)
 581         {
 582                 for (size_t i = 0; i < cgi -> value.size(); i++)
 583                 {
 584                         switch (cgi -> value[i])
 585                         {
 586                         case '<': // &lt;
 587                         case '>': // &gt;
 588                                 l += 4;
 589                                 break;
 590                         case '&': // &amp;
 591                                 l += 5;
 592                                 break;
 593                         }
 594                 }
 595         }
 596         return l;
 597 }
 598
 599
 600 HttpdForm::cgi_v& HttpdForm::getbase()
 601 {
 602         return m_cgi;
 603 }
 604
 605
 606 const std::string& HttpdForm::GetBoundary() const
 607 {
 608         return m_strBoundary;
 609 }
 610
 611
 612 #ifdef SOCKETS_NAMESPACE
 613 }
 614 #endif
 615
 616