ACE/apps/JAWS/server/HTTP_Request.cpp

   1 #include "ace/Message_Block.h"
   2 #include "HTTP_Request.h"
   3 #include "HTTP_Helpers.h"
   4 #include "HTTP_Config.h"
   5 #include "ace/OS_NS_string.h"
   6 #include "ace/OS_NS_pwd.h"
   7 #include "ace/Log_Msg.h"
   8
   9 const char *const
  10 HTTP_Request::static_header_strings_[HTTP_Request::NUM_HEADER_STRINGS] =
  11 {
  12   "Date",
  13   "Pragma",
  14   "Authorization",
  15   "From",
  16   "If-Modified-Since",
  17   "Referrer",
  18   "User-Agent",
  19   "Allow",
  20   "Content-Encoding",
  21   "Content-Length",
  22   "Content-Type",
  23   "Expires",
  24   "Last-Modified"
  25 };
  26
  27 const char *const
  28 HTTP_Request::static_method_strings_[HTTP_Request::NUM_METHOD_STRINGS] =
  29 {
  30   "GET",
  31   "HEAD",
  32   "POST",
  33   "PUT"
  34 };
  35
  36 // For reasons of efficiency, this class expects buffer to be
  37 // null-terminated, and buflen does NOT include the \0.
  38
  39 HTTP_Request::HTTP_Request ()
  40   : got_request_line_ (0),
  41     method_ (0),
  42     uri_ (0),
  43     version_ (0),
  44     path_ (0),
  45     cgi_ (0),
  46     cgi_env_ (0),
  47     cgi_args_ (0),
  48     query_string_ (0),
  49     path_info_ (0),
  50     header_strings_ (HTTP_Request::static_header_strings_),
  51     method_strings_ (HTTP_Request::static_method_strings_)
  52 {
  53   for (size_t i = 0;
  54        i < HTTP_Request::NUM_HEADER_STRINGS;
  55        i++)
  56     this->headers_.recognize (this->header_strings_[i]);
  57 }
  58
  59 HTTP_Request::~HTTP_Request ()
  60 {
  61   ACE_OS::free (this->method_);
  62   ACE_OS::free (this->uri_);
  63   ACE_OS::free (this->version_);
  64   ACE_OS::free (this->path_);
  65   ACE_OS::free (this->query_string_);
  66   ACE_OS::free (this->path_info_);
  67
  68   delete [] this->cgi_env_;
  69 }
  70
  71 int
  72 HTTP_Request::parse_request (ACE_Message_Block &mb)
  73 {
  74   mb.wr_ptr ()[0] = '\0';
  75
  76   // Note that RFC 822 does not mention the maximum length of a header
  77   // line.  So in theory, there is no maximum length.
  78
  79   // In Apache, they assume that each header line should not exceed
  80   // 8K.
  81
  82   int result = this->headers_.complete_header_line (mb.rd_ptr ());
  83
  84   if (result != 0)
  85     {
  86       if (!this->got_request_line ())
  87         {
  88           this->parse_request_line (mb.rd_ptr ());
  89           while (this->headers_.complete_header_line (mb.rd_ptr ()) > 0)
  90             this->headers_.parse_header_line (mb.rd_ptr ());
  91         }
  92       else if (result > 0)
  93         do
  94           this->headers_.parse_header_line (mb.rd_ptr ());
  95         while (this->headers_.complete_header_line (mb.rd_ptr ()) > 0);
  96     }
  97
  98   mb.wr_ptr (ACE_OS::strlen(mb.rd_ptr ()) - mb.length ());
  99
 100   if (this->headers_.end_of_headers ()
 101       || (this->got_request_line () && this->version () == 0))
 102     return this->init (mb.rd_ptr (), mb.length ());
 103   else
 104     return 0;
 105 }
 106
 107 void
 108 HTTP_Request::parse_request_line (char *const request_line)
 109 {
 110   char *ptr = request_line;
 111   char *buf = request_line;
 112   int offset = 1;
 113
 114   this->status_ = HTTP_Status_Code::STATUS_OK;
 115
 116   ptr = ACE_OS::strchr (request_line, '\n');
 117
 118   if (ptr > request_line && ptr[-1] == '\r')
 119     ptr--, offset++;
 120
 121   if (ptr == request_line)
 122     {
 123       this->status_ = HTTP_Status_Code::STATUS_BAD_REQUEST;
 124       return;
 125     }
 126
 127   *ptr = '\0';
 128   ptr += offset;
 129
 130   char *lasts = 0; // for strtok_r
 131
 132   // Get the request type.
 133   this->got_request_line_ = 1;
 134
 135   if (this->method (ACE_OS::strtok_r (buf, " \t", &lasts))
 136       && this->uri (ACE_OS::strtok_r (0, " \t", &lasts)))
 137     {
 138       this->type (this->method ());
 139
 140       if (this->version (ACE_OS::strtok_r (0, " \t", &lasts)) == 0
 141           && this->type () != HTTP_Request::GET)
 142         this->status_ = HTTP_Status_Code::STATUS_NOT_IMPLEMENTED;
 143
 144       if (this->path (this->uri ()) == 0)
 145         this->status_ = HTTP_Status_Code::STATUS_NOT_FOUND;
 146     }
 147
 148   ACE_DEBUG ((LM_DEBUG, " (%t) request %s %s %s parsed\n",
 149               (this->method () ? this->method () : "-"),
 150               (this->uri () ? this->uri () : "="),
 151               (this->version () ? this->version () : "HTTP/0.9")));
 152
 153   ACE_OS::memmove (buf, ptr, ACE_OS::strlen (ptr)+1);
 154 }
 155
 156 int
 157 HTTP_Request::init (char *const buffer,
 158                     int buflen)
 159 {
 160   // Initialize these every time.
 161   content_length_ = -1;
 162
 163   // Extract the data pointer.
 164   data_ = buffer;
 165   datalen_ = 0;
 166
 167   // Set the datalen
 168   if (data_ != 0)
 169     datalen_ = buflen;
 170   else
 171     datalen_ = 0;
 172
 173   ACE_DEBUG ((LM_DEBUG, " (%t) init has initialized\n"));
 174
 175   return 1;
 176 }
 177
 178 const char *
 179 HTTP_Request::method () const
 180 {
 181   return this->method_;
 182 }
 183
 184 const char *
 185 HTTP_Request::uri () const
 186 {
 187   return this->uri_;
 188 }
 189
 190 const char *
 191 HTTP_Request::version () const
 192 {
 193   return this->version_;
 194 }
 195
 196 const char *
 197 HTTP_Request::path () const
 198 {
 199   return this->path_;
 200 }
 201
 202 int
 203 HTTP_Request::cgi () const
 204 {
 205   return this->cgi_;
 206 }
 207
 208 const char **
 209 HTTP_Request::cgi_env () const
 210 {
 211   return (const char **)this->cgi_env_;
 212 }
 213
 214 const char *
 215 HTTP_Request::cgi_args () const
 216 {
 217   return this->cgi_args_;
 218 }
 219
 220 const char *
 221 HTTP_Request::query_string () const
 222 {
 223   return this->query_string_;
 224 }
 225
 226 const char *
 227 HTTP_Request::path_info () const
 228 {
 229   return this->path_info_;
 230 }
 231
 232 int
 233 HTTP_Request::got_request_line () const
 234 {
 235   return this->got_request_line_;
 236 }
 237
 238 int
 239 HTTP_Request::type () const
 240 {
 241   return type_;
 242 }
 243
 244 const Headers &
 245 HTTP_Request::headers () const
 246 {
 247   return this->headers_;
 248 }
 249
 250 const char *
 251 HTTP_Request::header_strings (int index) const
 252 {
 253   const char *hs = 0;
 254
 255   if (0 <= index && index < NUM_HEADER_STRINGS)
 256     hs = this->header_strings_[index];
 257
 258   return hs;
 259 }
 260
 261 const char *
 262 HTTP_Request::header_values (int index) const
 263 {
 264   const char *hs = 0;
 265   const char *hv = 0;
 266
 267   if (0 <= index && index < NUM_HEADER_STRINGS)
 268     {
 269       hs = this->header_strings_[index];
 270       hv = this->headers_[hs].value ();
 271     }
 272
 273   return hv;
 274 }
 275
 276 char *
 277 HTTP_Request::data ()
 278 {
 279   return data_;
 280 }
 281
 282 int
 283 HTTP_Request::data_length ()
 284 {
 285   return datalen_;
 286 }
 287
 288 int
 289 HTTP_Request::content_length ()
 290 {
 291   if (this->content_length_ == -1)
 292     {
 293       const char * clv = this->headers_["Content-length"].value ();
 294       this->content_length_ = (clv ? ACE_OS::atoi (clv) : 0);
 295     }
 296
 297   return this->content_length_;
 298 }
 299
 300 int
 301 HTTP_Request::status ()
 302 {
 303   return this->status_;
 304 }
 305
 306 const char *
 307 HTTP_Request::status_string ()
 308 {
 309   return HTTP_Status_Code::instance ()[this->status_];
 310 }
 311
 312 void
 313 HTTP_Request::dump ()
 314 {
 315   ACE_DEBUG ((LM_DEBUG, "%s command.\n"
 316               "filename is %s,"
 317               " length of the file is %d,"
 318               " data string is %s,"
 319               " datalen is %d,"
 320               " status is %d, which is %s\n\n",
 321               this->method () ? this->method () : "EMPTY",
 322               this->uri () ? this->uri () : "EMPTY",
 323               this->content_length (),
 324               this->data () ? this->data () : "EMPTY",
 325               this->data_length (),
 326               this->status (),
 327               this->status_string ()));
 328 }
 329
 330 const char *
 331 HTTP_Request::method (const char *method_string)
 332 {
 333   if (this->method_)
 334     ACE_OS::free (this->method_);
 335
 336   if (method_string == 0)
 337     {
 338       this->status_ = HTTP_Status_Code::STATUS_BAD_REQUEST;
 339       this->method_ = 0;
 340     }
 341   else
 342     this->method_ = ACE_OS::strdup (method_string);
 343
 344   return this->method_;
 345 }
 346
 347 const char *
 348 HTTP_Request::uri (char *uri_string)
 349 {
 350   if (this->uri_)
 351     ACE_OS::free (this->uri_);
 352
 353   if (uri_string == 0)
 354     {
 355       this->status_ = HTTP_Status_Code::STATUS_BAD_REQUEST;
 356       this->uri_ = 0;
 357     }
 358   else
 359     {
 360       this->uri_ =  ACE_OS::strdup (uri_string);
 361       this->cgi (this->uri_);
 362       HTTP_Helper::HTTP_decode_string (this->uri_);
 363     }
 364
 365   return this->uri_;
 366 }
 367
 368 const char *
 369 HTTP_Request::version (const char *version_string)
 370 {
 371   if (this->version_)
 372     ACE_OS::free (this->version_);
 373
 374   if (version_string)
 375     this->version_ = ACE_OS::strdup (version_string);
 376   else
 377     this->version_ = 0;
 378
 379   return this->version_;
 380 }
 381
 382 int
 383 HTTP_Request::type (const char *type_string)
 384 {
 385   this->type_ = HTTP_Request::NO_TYPE;
 386
 387   if (type_string == 0)
 388     return this->type_;
 389
 390   for (size_t i = 0;
 391        i < HTTP_Request::NUM_METHOD_STRINGS;
 392        i++)
 393
 394     if (ACE_OS::strcmp (type_string, this->method_strings_[i]) == 0)
 395       {
 396         this->type_ = i;
 397         break;
 398       }
 399
 400   if (this->type_ == HTTP_Request::NO_TYPE)
 401     this->status_ = HTTP_Status_Code::STATUS_NOT_IMPLEMENTED;
 402
 403   return this->type_;
 404 }
 405
 406 int
 407 HTTP_Request::cgi (char *uri_string)
 408 {
 409   this->cgi_ = 0;
 410   this->cgi_env_ = 0;
 411   this->cgi_args_ = 0;
 412
 413   ACE_DEBUG ((LM_DEBUG, " (%t) HTTP_Request::cgi (%s)\n", uri_string));
 414
 415   if (uri_string == 0 || ACE_OS::strlen (uri_string) == 0)
 416     return 0;
 417
 418   // There are 2 cases where a file could be a CGI script
 419   //
 420   // (1) the file has a CGI extension.
 421   // (2) the file resides in a CGI bin directory.
 422
 423   char *extra_path_info = 0;
 424   if (this->cgi_in_path (uri_string, extra_path_info)
 425       || this->cgi_in_extension (uri_string, extra_path_info))
 426     {
 427       cgi_args_and_env (extra_path_info);
 428
 429       if (extra_path_info)
 430         {
 431           this->path_info_ = ACE_OS::strdup (extra_path_info);
 432           HTTP_Helper::HTTP_decode_string (this->path_info_);
 433           *extra_path_info = '\0';
 434         }
 435     }
 436
 437   return this->cgi_;
 438 }
 439
 440 int
 441 HTTP_Request::cgi_in_path (char *uri_string, char *&extra_path_info)
 442 {
 443   char *cgi_path;
 444
 445   ACE_DEBUG ((LM_DEBUG, " (%t) HTTP_Request::cgi_in_path (%s)\n",
 446               uri_string));
 447
 448   if (HTTP_Config::instance ()->cgi_path ())
 449     cgi_path = ACE_OS::strdup (HTTP_Config::instance ()->cgi_path ());
 450   else
 451     cgi_path = ACE_OS::strdup ("");
 452
 453   // error checking considered helpful!
 454   if (cgi_path == 0)
 455     return 0;
 456
 457   char *lasts = 0;
 458   char *cgi_path_next = ACE_OS::strtok_r (cgi_path, ":", &lasts);
 459
 460   if (cgi_path_next)
 461     do
 462       {
 463         int len = ACE_OS::strlen (cgi_path_next);
 464
 465         // match path to cgi path
 466         int in_cgi_path = 0;
 467
 468         if (*cgi_path_next == '/')
 469           {
 470             // cgi path next points to an ``absolute'' path
 471             extra_path_info = uri_string;
 472             in_cgi_path =
 473               (ACE_OS::strncmp (extra_path_info, cgi_path_next, len) == 0);
 474           }
 475         else
 476           {
 477             // cgi path next points to a ``relative'' path
 478             extra_path_info = ACE_OS::strstr (uri_string, cgi_path_next);
 479             in_cgi_path = (extra_path_info != 0);
 480           }
 481
 482         if (in_cgi_path)
 483           {
 484             if (extra_path_info[len] == '/')
 485               {
 486                 this->cgi_ = 1;
 487                 extra_path_info += len;
 488
 489                 // move past the executable name
 490                 do
 491                   extra_path_info++;
 492                 while (*extra_path_info != '/'
 493                        && *extra_path_info != '?'
 494                        && *extra_path_info != '\0');
 495
 496                 if (*extra_path_info == '\0')
 497                   extra_path_info = 0;
 498
 499                 break;
 500               }
 501           }
 502         extra_path_info = 0;
 503
 504         cgi_path_next = ACE_OS::strtok_r (0, ":", &lasts);
 505       }
 506     while (cgi_path_next);
 507
 508   ACE_OS::free (cgi_path);
 509
 510   return this->cgi_;
 511 }
 512
 513 int
 514 HTTP_Request::cgi_in_extension (char *uri_string, char *&extra_path_info)
 515 {
 516   extra_path_info = ACE_OS::strstr (uri_string, ".cgi");
 517
 518   ACE_DEBUG ((LM_DEBUG, " (%t) HTTP_Request::cgi_in_extension (%s)\n",
 519               uri_string));
 520
 521   while (extra_path_info != 0)
 522     {
 523       extra_path_info += 4;
 524       // skip past ``.cgi''
 525
 526       switch (*extra_path_info)
 527         {
 528         case '\0':
 529           extra_path_info = 0;
 530           break;
 531         case '/':
 532         case '?':
 533           break;
 534         default:
 535           extra_path_info = ACE_OS::strstr (extra_path_info, ".cgi");
 536           continue;
 537         }
 538       this->cgi_ = 1;
 539       break;
 540     }
 541
 542   return this->cgi_;
 543 }
 544
 545 void
 546 HTTP_Request::cgi_args_and_env (char *&extra_path_info)
 547 {
 548   char *cgi_question = 0;
 549
 550   if (extra_path_info)
 551     cgi_question = ACE_OS::strchr (extra_path_info, '?');
 552
 553   if (extra_path_info == cgi_question)
 554     extra_path_info = 0;
 555
 556   if (cgi_question)
 557     {
 558       *cgi_question++ = '\0';
 559
 560       if (*cgi_question != '\0')
 561         {
 562           // We need the ``original'' QUERY_STRING for the
 563           // environment.  We will substitute '+'s for spaces in the
 564           // other copy.
 565
 566           this->query_string_ = ACE_OS::strdup (cgi_question);
 567
 568           char *ptr = cgi_question;
 569           int count = 0;
 570           do
 571             if (*ptr == '+')
 572               *ptr = ' ';
 573             else if (*ptr == '&' || *ptr == '=')
 574               count++;
 575           while (*++ptr);
 576
 577           count++;
 578
 579           if (ACE_OS::strchr (cgi_question, '='))
 580             {
 581               ACE_NEW (this->cgi_env_, char *[count+1]);
 582
 583               int i = 0;
 584               ptr = cgi_question;
 585               do
 586                 {
 587                   this->cgi_env_ [i++] = ptr;
 588
 589                   while (*ptr++)
 590                       if (*ptr == '&' || *ptr == '=')
 591                         *ptr = '\0';
 592
 593                   HTTP_Helper::HTTP_decode_string (this->cgi_env_[i-1]);
 594                 }
 595               while (i < count);
 596
 597               this->cgi_env_[count] = 0;
 598             }
 599           else
 600             {
 601               this->cgi_args_ = cgi_question;
 602               HTTP_Helper::HTTP_decode_string (cgi_question);
 603             }
 604         }
 605     }
 606 }
 607
 608 const char *
 609 HTTP_Request::path (const char *uri_string)
 610 {
 611   char const *file_name = uri_string;
 612   char buf[MAXPATHLEN + 1];
 613   buf[0] = '\0';
 614
 615   if (file_name == 0) return 0;
 616
 617   if (*file_name == '/')
 618     {
 619       file_name++;
 620       if (*file_name == '~')
 621         {
 622           char *ptr = buf;
 623
 624           while (*++file_name && *file_name != '/')
 625             *ptr++ = *file_name;
 626
 627           *ptr = '\0';
 628
 629           if (ptr == buf)
 630             ACE_OS::strcpy (buf, ACE_OS::getenv ("HOME"));
 631           else
 632             {
 633 #if !defined (ACE_WIN32) && !defined (VXWORKS)
 634               char pw_buf[BUFSIZ];
 635               struct passwd pw_struct;
 636               struct passwd *pw_struct_ptr;
 637               if (ACE_OS::getpwnam_r (buf, &pw_struct, pw_buf,
 638                                       sizeof (pw_buf), &pw_struct_ptr) == 0)
 639                 return 0;
 640               ACE_OS::strcpy (buf, pw_struct.pw_dir);
 641 #endif /* NOT ACE_WIN32 AND NOT VXWORKS */
 642             }
 643
 644           ACE_OS::strcat (buf, "/");
 645           ACE_OS::strcat (buf, HTTP_Config::instance ()->user_dir ());
 646           ACE_OS::strcat (buf, file_name);
 647         }
 648       else
 649         {
 650           // With a starting '/' but no '~'
 651           ACE_OS::strcat (buf, HTTP_Config::instance ()->document_root ());
 652           ACE_OS::strcat (buf, file_name - 1);
 653         }
 654     }
 655
 656   if (*buf != '\0')
 657     this->path_ = ACE_OS::strdup (buf);
 658
 659   return this->path_;
 660 }