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