Changeset 44573


Ignore:
Timestamp:
Apr 19, 2008, 1:23:03 PM (10 years ago)
Author:
Darren Garvey
Message:
  • Added case-insensitive name type (typedef for std::basic_string<> using a custom traits class).
  • Modified cgi::map to use cgi::name as key.
  • Also modified files to include common/map.hpp instead of map.hpp.
  • Changed code because a std::string isn't automatically convertible to cgi::name
  • Fixed it so multiple cookies are parsed correctly.
  • Plus, other smallish fixes (cleanup / updating Boost.Thread compatibility).
Location:
sandbox/SOC/2007/cgi/trunk/boost/cgi
Files:
3 added
16 edited

Legend:

Unmodified
Added
Removed
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/acgi/request_service.hpp

    r43773 r44573  
    1313#include "boost/cgi/tags.hpp"
    1414#include "boost/cgi/io_service.hpp"
    15 #include "boost/cgi/map.hpp"
     15#include "boost/cgi/common/map.hpp"
    1616#include "boost/cgi/detail/cgi_service_impl_base.hpp"
    1717#include "boost/cgi/detail/service_base.hpp"
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/basic_client.hpp

    r43979 r44573  
    1212#include <boost/shared_ptr.hpp>
    1313
    14 #include "boost/cgi/map.hpp"
     14#include "boost/cgi/common/map.hpp"
    1515#include "boost/cgi/role_type.hpp"
    1616#include "boost/cgi/status_type.hpp"
     
    144144    //io_service&                           io_service_;
    145145    connection_ptr                        connection_;
     146
     147  public: // **FIXME**
    146148    // we should never read more than content-length bytes.
    147149    std::size_t                           bytes_left_;
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/basic_request.hpp

    r43979 r44573  
    3939#include "boost/cgi/basic_sync_io_object.hpp"
    4040#include "boost/cgi/basic_io_object.hpp"
    41 #include "boost/cgi/map.hpp"
     41#include "boost/cgi/common/map.hpp"
    4242
    4343namespace cgi {
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/cgi/request_impl.hpp

    r43773 r44573  
    2020#include "boost/cgi/role_type.hpp"
    2121#include "boost/cgi/status_type.hpp"
    22 #include "boost/cgi/map.hpp"
     22#include "boost/cgi/common/map.hpp"
    2323#include "boost/cgi/detail/cgi_request_impl_base.hpp"
    2424
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/common/form_part.hpp

    r43773 r44573  
    3838
    3939     std::string content_type; // must exist
    40      std::string name; // Has to exist?
     40     std::string name; // must exist (?) **FIXME**
    4141
    4242     // Using a simple map while everything is changing. This will not copy the
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/connections/shareable_tcp_socket.hpp

    r43780 r44573  
    6464
    6565    // A wrapper to provide condition_type::pointer
    66     struct condition_type : public boost::condition
    67     { typedef boost::shared_ptr<boost::condition> pointer; };
     66    struct condition_type : public boost::condition_variable
     67    { typedef boost::shared_ptr<boost::condition_variable> pointer; };
    6868
    6969    basic_connection(io_service& ios)
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/connections/stdio.hpp

    r43979 r44573  
    6060    std::size_t read_some(MutableBufferSequence buf
    6161                         , boost::system::error_code& ec)
    62     {
    63       //if (std::cin.eof())
    64       //{
    65         //ec = boost::asio::error::eof;
    66       //  return boost::asio::error::eof;
    67       //}
    68       //if( buf.data() != in_.rdbuf() )
    69       //  return in_.read(buf.begin(), buf.size());
    70       //return buf.size();
    71      
    72       //std::cerr<< "In stdio::read_some()" << std::endl
    73       //         << "before = {" << std::endl
    74       //         << std::string(boost::asio::buffer_cast<char *>(buf), boost::asio::buffer_size(buf)) << std::endl
    75       //         << "}" << std::endl;
    76       /*
    77       std::cin.read(boost::asio::buffer_cast<char *>(buf)
    78                    , boost::asio::buffer_size(buf));
    79       if (std::cin.fail() && !std::cin.eof())
    80       {
    81         ec = boost::system::error_code(654, boost::system::system_category);
    82         return 0;
    83       }
    84       */
    85       //std::cerr<< "before = {" << std::endl
    86       //         << std::string(boost::asio::buffer_cast<char *>(buf), boost::asio::buffer_size(buf)) << std::endl
    87       //         << "}" << std::endl;
    88      
     62    { 
    8963      if (std::fread(boost::asio::buffer_cast<void *>(buf)
    9064                    , boost::asio::buffer_size(buf)
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/cgi_request_impl_base.hpp

    r43975 r44573  
    1919#include "boost/cgi/role_type.hpp"
    2020#include "boost/cgi/status_type.hpp"
    21 #include "boost/cgi/map.hpp"
     21#include "boost/cgi/common/map.hpp"
    2222//#include
    2323
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/cgi_service_impl_base.hpp

    r43979 r44573  
     1//        -- detail/cgi_service_impl_base.hpp --
     2//
     3//           Copyright (c) Darren Garvey 2007-2008.
     4// Distributed under the Boost Software License, Version 1.0.
     5//    (See accompanying file LICENSE_1_0.txt or copy at
     6//          http://www.boost.org/LICENSE_1_0.txt)
     7//
     8////////////////////////////////////////////////////////////////
    19#ifndef CGI_CGI_SERVICE_IMPL_BASE_HPP_INCLUDED__
    210#define CGI_CGI_SERVICE_IMPL_BASE_HPP_INCLUDED__
     
    1321#include <boost/algorithm/string/find.hpp>
    1422
    15 #include "boost/cgi/map.hpp"
     23#include "boost/cgi/common/map.hpp"
    1624#include "boost/cgi/basic_client.hpp"
    1725#include "boost/cgi/role_type.hpp"
     
    134142         , boost::system::error_code& ec)
    135143    {
    136       return meta_data[name];
     144      return meta_data[name.c_str()];
    137145    }
    138146
     
    206214                          return POST(impl, name, ec);
    207215                        else
     216        // **FIXME** What about HEAD, PUT ???
    208217                          return "***BOOST_CGI_ERROR_INVALID_REQUEST_METHOD***";
    209218                }
     
    304313      detail::extract_params(vars, impl.cookie_vars()
    305314                            , boost::char_separator<char>
    306                                 ("", "=&", boost::keep_empty_tokens)
     315                                ("", "=;", boost::keep_empty_tokens)
    307316                            , ec);
    308317
     
    318327      //BOOST_ASSERT (!impl.stdin_parsed());
    319328
    320       std::string content_type (var(impl.env_vars(), "CONTENT_TYPE", ec));
    321 
    322       BOOST_ASSERT(!content_type.empty());
    323 
    324       if (boost::algorithm::ifind_first(content_type,
    325             "application/x-www-form-urlencoded"))
    326       {
    327         detail::throw_error(
    328           parse_url_encoded_form(impl, ec)
    329         );
    330       }
    331       else
    332       {
    333         detail::throw_error(
    334           parse_multipart_form(impl, ec)
    335         );
    336       }
    337 
    338       return ec;
    339     }
    340 
    341     boost::system::error_code
    342       parse_url_encoded_form(implementation_type& impl
    343                             , boost::system::error_code& ec)
    344     {     
    345       std::string name;
    346       std::string str;
    347       map_type& post_map(impl.post_vars());
    348      
    349       char ch;
    350       char ch1;
    351       while( impl.characters_left_ )
    352       {
    353         ch = getchar();
    354         --impl.characters_left_;
    355 
    356         switch(ch)
    357         {
    358         case '%': // unencode a hex character sequence
    359           if (impl.characters_left_ >= 2)
    360           {
    361             ch = getchar();
    362             ch1 = getchar();
    363             if (std::isxdigit(ch) && std::isxdigit(ch1))
    364             {
    365               str.append(1, detail::hex_to_char(ch, ch1));
    366             }
    367             else // we don't have a hex sequence
    368             {
    369               str.append(1, '%').append(1, ch).append(1, ch1);
    370             }
    371             impl.characters_left_ -= 2;
    372           }
    373           else // There aren't enough characters to make a hex sequence
    374           {
    375             str.append(1, '%');
    376             --impl.characters_left_;
    377           }
    378           break;
    379         case '+':
    380             str.append(1, ' ');
    381             break;
    382         case ' ':
    383             continue;
    384         case '=': // the name is complete, now get the corresponding value
    385             name = str;
    386             str.clear();
    387             break;
    388         case '&': // we now have the name/value pair, so save it
    389             post_map[name] = str;
    390             str.clear();
    391             name.clear();
    392            break;
    393         default:
    394             str.append(1, ch);
    395         }
    396       }
    397       // save the last param (it won't have a trailing &)
    398       if( !name.empty() )
    399           post_map[name] = str;//.empty() ? "" : str;
    400      
    401 
    402       return ec;
    403     }
    404 
    405     /// Parse a multipart form.
    406     boost::system::error_code
    407       parse_multipart_form(implementation_type& impl, boost::system::error_code& ec)
    408     {
    409329      impl.fp_.reset
    410330      (
     
    415335      return ec;
    416336    }
    417       /*
    418       parse_boundary_marker(impl, ec);
    419       //parse_one_form_part(impl, ec);
    420       move_to_start_of_first_part(impl, ec);
    421       if (ec == boost::asio::error::eof) {
    422         //cerr<< " -- Parsing done -- " << endl;
    423         //return ec.clear();
    424         return boost::system::error_code();
    425       }
    426 
    427       do {
    428         parse_form_part(impl, ec);
    429       }while( !impl.stdin_parsed_  && impl.client_.bytes_left() != 0 );
    430 
    431       // Do this just for now, for debugging
    432       parse_url_encoded_form(impl, ec);
    433       return ec;
    434     }
    435 
    436     boost::system::error_code
    437       parse_form_part(implementation_type& impl, boost::system::error_code& ec)
    438     {
    439       if (!parse_form_part_meta_data(impl, ec)
    440       &&  !parse_form_part_data(impl, ec))
    441         return ec;
    442 
    443       return ec;
    444     }
    445 
    446     boost::system::error_code
    447       parse_form_part_data(implementation_type& impl, boost::system::error_code& ec)
    448     {
    449       std::string regex("^(.*?)" // the data
    450                         "\\x0D\\x0A" // CR LF
    451                         "--" "(");
    452       if (impl.boundary_markers.size() > 1)
    453       {
    454         std::list<std::string>::iterator i(impl.boundary_markers.begin());
    455         regex = regex + "(?:" + *i + ")";
    456         ++i;
    457         for(; i != impl.boundary_markers.end(); ++i)
    458         {
    459           regex = regex + "|(?:" + *i + ")";
    460         }
    461       }
    462       else
    463       {
    464         regex += *impl.boundary_markers.begin();
    465       }
    466      
    467       regex += ")(--)?[ ]*\\x0D\\x0A";
    468       //cerr<< "Regex: " << regex << endl;
    469       boost::regex re(regex);
    470      
    471       typedef typename
    472         implementation_type::buffer_type::iterator
    473       buffer_iter;
    474 
    475       boost::match_results<buffer_iter> matches;
    476 
    477       std::size_t offset = impl.offset_;
    478       //cerr<< "offset = " << offset << endl;
    479 
    480       //int runs = 0;
    481       buffer_iter begin(impl.buf_.begin() + offset);
    482       buffer_iter end(impl.buf_.end());
    483 
    484       for(;;)
    485       {
    486         //cerr<< "Starting regex_search" << endl;
    487         if (!boost::regex_search(begin, end, matches, re
    488                                 , boost::match_default
    489                                 | boost::match_partial))
    490         {
    491          // cerr<< "Can't match any of this. {" << endl
    492           //    << std::string(begin, end) << endl
    493           //    << "}" << endl;
    494           return boost::system::error_code(345, boost::system::system_category);
    495         }
    496         else
    497         {
    498           for (unsigned int i = 0; i < matches.size(); ++i)
    499           {
    500             if (matches[i].length())
    501             {
    502             //  cerr<< "[" << i << "] == {" << endl
    503             //      << matches[i] << endl
    504             //      << "}" << endl;
    505             }
    506           }
    507           //  cerr<< "matches[0] = {" << endl
    508           //      << matches[0].str() << endl
    509           //      << "}" << endl;
    510           if (matches[1].matched)
    511           {
    512             impl.form_parts_.back().buffer_
    513              // = boost::range_iterator<;
    514              = std::make_pair(matches[1].first, matches[1].second);
    515            // cerr<< "Saved buffer (size: "
    516            //     << std::distance(matches[1].first, matches[1].second)
    517            //     << ") := { " << impl.form_parts_.back().name << ", " << matches[1] << " }" << endl;
    518             impl.post_vars()[impl.form_parts_.back().name] = matches[1];
    519             impl.offset_ = offset + matches[0].length();
    520             //offset += matches[0].length();
    521             impl.pos_ = matches[0].second;
    522             //cerr<< "offset := " << offset << endl
    523               //  << "impl.offset_ := " << impl.offset_ << endl;
    524 
    525             if (matches[3].matched)
    526               impl.stdin_parsed_ = true;
    527             //if (impl.client_.bytes_left() == 0)
    528             //{
    529             //  cerr<< "Read all the bytes up." << endl;
    530               //impl.stdin_parsed_ = true;
    531               return ec;
    532             //}
    533           }
    534           else
    535           {
    536             //cerr<< "Reading more data." << endl;
    537             std::size_t bytes_read = impl.client_.read_some(impl.prepare(64), ec);
    538             //impl.stdin_bytes_read_ += bytes_read;
    539            
    540             if (bytes_read == 0)
    541             {
    542               impl.stdin_data_read_ = true;
    543               return ec;
    544             }
    545 
    546             begin = impl.buf_.begin() + offset;
    547             end = impl.buf_.end();
    548             //cerr<< "Buffer (+" << bytes_read << ") == {" << endl
    549             //    << std::string(begin, end) << endl
    550             //    << "}" << endl;
    551 
    552             if (ec)
    553             {
    554               //cerr<< "Error in parse_form_part_data()." << endl;
    555               return ec;
    556             }
    557 
    558           }
    559         }
    560          
    561       }
    562          
    563 
    564       return ec;
    565     }
    566 
    567     boost::system::error_code
    568       parse_form_part_meta_data(implementation_type& impl, boost::system::error_code& ec)
    569     {
    570       // Oh dear this is ugly. The move to Boost.Spirit will have to be sooner than planned.
    571       // (it's a nested, recursive pattern, which regexes don't suit, apparently)
    572       boost::regex re(  "(?:"         // [IGNORE] the line may be empty, as meta-data is optional
    573                           "^"
    574                           "([-\\w]+)" // name
    575                           ":[ ^]*"       // separator
    576                           "([-/\\w]+)" // optional(?) value
    577                           ""
    578                           "(?:"
    579                             ";"
    580                             "[ ]*"    // additional name/value pairs (don't capture)
    581                             "([-\\w]+)" // name
    582                             "[ \\x0D\\x0A]*=[ \\x0D\\x0A]*"       // separator
    583                             "(?:\"?([-.\\w]*)\"?)" // value may be empty
    584                           ")?"
    585                           "(?:"
    586                             ";"
    587                             "[ ]*"    // additional name/value pairs (don't capture)
    588                             "([-\\w]+)" // name
    589                             "[ \\x0D\\x0A]*=[ \\x0D\\x0A]*"       // separator
    590                             "(?:\"?([-.\\w]*)\"?)" // value may be empty
    591                           ")?"        // mark the extra n/v pairs optional
    592                           "\\x0D\\x0A"
    593                         ")"
    594                         "(?:"
    595                           "([-\\w]+)" // name
    596                           ":[ ^]*"       // separator
    597                           "([-/\\w]+)" // optional(?) value
    598                           ""
    599                           "(?:"
    600                             ";"
    601                             "[ ]*"    // additional name/value pairs (don't capture)
    602                             "([-\\w]+)" // name
    603                             "[ \\x0D\\x0A]*=[ \\x0D\\x0A]*"       // separator
    604                             "(?:\"?([-.\\w]*)\"?)" // value may be empty
    605                           ")?"
    606                           "(?:"
    607                             ";"
    608                             "[ ]*"    // additional name/value pairs (don't capture)
    609                             "([-\\w]+)" // name
    610                             "[ \\x0D\\x0A]*=[ \\x0D\\x0A]*"       // separator
    611                             "(?:\"?([-.\\w]*)\"?)" // value may be empty
    612                           ")?"        // mark the extra n/v pairs optional
    613                           "\\x0D\\x0A"    // followed by the end of the line
    614                         ")?"
    615                       "(\\x0D\\x0A)");     // followed by the 'header termination' line
    616 
    617       typedef typename
    618         implementation_type::buffer_type::iterator
    619       buffer_iter;
    620 
    621       boost::match_results<
    622         typename
    623           implementation_type::buffer_type::iterator
    624       > matches;
    625      
    626       std::size_t offset = impl.offset_;
    627       //cerr.flush();
    628       impl.pos_ = impl.buf_.begin();
    629       int runs = 0;
    630       //cerr<< "Entering for() loop." << endl;
    631       std::size_t bytes_read = 0;
    632       for(;;)
    633       {
    634         buffer_iter begin(impl.buf_.begin() + offset);
    635         buffer_iter end(impl.buf_.end());
    636        
    637         if (!boost::regex_search(begin, end, matches, re
    638                                 , boost::match_default | boost::match_partial))
    639         {
    640           //cerr<< "No chance of a match, quitting." << endl;
    641           impl.stdin_parsed_ = true;
    642           return ec;
    643         }
    644         //cerr<< "matches.str() == {" << endl
    645          //   << matches.str() << endl
    646          //   << "}" << endl
    647          //   << matches.size() << " submatches" << endl;
    648        // for (unsigned i = matches.size(); i != 0; --i)
    649        // {
    650           //cerr<< "match[" << i << "] := { " << matches[i] << " }" << endl;
    651         //}
    652         if (matches[0].matched)
    653         {
    654           common::form_part part;
    655           for ( unsigned int i = 1
    656               ; i < matches.size()
    657                && matches[i].matched
    658                && !matches[i].str().empty()
    659               ; i+=2)
    660           {
    661            if (matches[i].str() == "name")
    662             {
    663               part.name = matches[i+1];
    664           //    cerr<< "Saved name" << endl;
    665             }
    666             else
    667             {
    668               part.meta_data_[matches[i]]
    669                 = std::make_pair(matches[i+1].first, matches[i+1].second);
    670            //   cerr<< "Part := { " << matches[i] << ", " << matches[i+1] << " }" << endl;
    671               //= boost::iterator_range<buffer_iter>(matches[3].first, matches[3].second);
    672             }
    673             impl.form_parts_.push_back(part);
    674          
    675          
    676          }
    677          
    678          if (matches[13].str() == "\r\n")
    679          {
    680            impl.offset_ = offset + matches[0].length();
    681            offset += matches[0].length();
    682            impl.pos_ = matches[0].second;
    683          
    684            //cerr<< "Current buffer == {" << endl
    685            //    << impl.buffer_string() << endl
    686            //    << "}" << endl;
    687            //cerr<< "Leaving parse_form_part_meta_data()" << endl;
    688            return ec;
    689          }
    690          else
    691          {
    692            throw std::runtime_error("Invalid POST data (header wasn't terminated as expected)");
    693          }
    694          
    695         }else{
    696          // cerr<< "Not read enough data yet, reading more." << endl;
    697           bytes_read = impl.client_.read_some(impl.prepare(64), ec);
    698           if (ec)
    699           {
    700           //  cerr<< "Error reading data: " << ec.message() << endl;
    701            // cerr<< "Leaving parse_form_part_meta_data()" << endl;
    702             return ec;
    703           }
    704          // cerr<< "Read " << bytes_read << " bytes." << endl;
    705           //cerr<< "buffer = {" << endl
    706            //   << impl.buffer_string() << endl
    707              // << "} or {" << endl;
    708               //<< std::string(impl.pos_, ;
    709           / *
    710           for (unsigned int i = 0; i < matches.size(); ++i)
    711           {
    712             if (matches[i].length())
    713             {
    714               cerr<< "[" << i << "] == {" << endl
    715                   << matches[i] << endl
    716                   << "}" << endl;
    717             }
    718           }
    719           cerr<< "-------buf------" << endl
    720               << std::string(begin, end) << endl
    721               << "----------------" << endl;
    722           * /
    723           //offset = impl.buf_.end();
    724             if (++runs > 40)
    725             {
    726              // cerr<< "Run 40 times; bailing out." << endl;
    727               break;
    728             }
    729          // cerr<< "Waiting buffer (unparsed) == {" << endl << std::flush
    730           //    << impl.buffer_string() << endl
    731            //   << "}" << endl
    732             //  << "offset     = " << offset     << endl;
    733         //if (bytes_read == 0)
    734         //  break;
    735        }
    736       }
    737 
    738       //cerr<< "impl.part
    739 
    740  //     cerr<< "Leaving parse_form_part_meta_data()" << endl;
    741       return ec;
    742     }
    743 
    744     boost::system::error_code
    745       move_to_start_of_first_part(implementation_type& impl, boost::system::error_code& ec)
    746     {
    747       //cerr<< "Marker = " << impl.boundary_markers.front() << endl
    748       //    << "blah" << "--" + impl.boundary_markers.front() + ")" << endl;
    749       boost::regex re("((?:.*)?"   // optional leading characters
    750                       //"(?:\\x0D\\x0A)|^" // start of line
    751                       "[\\x0D\\x0A^]*?"
    752                       "("
    753                         "--" + impl.boundary_markers.front() + // two dashes and our marker
    754                       ")"
    755                       "(--)?" // optional two dashes (not sure if this is allowed)
    756                       " *\\x0D\\x0A)");
    757                                         // on the first marker.
    758 
    759       typedef typename
    760           implementation_type::buffer_type::iterator
    761       buffer_iter;
    762 
    763       boost::match_results<
    764         typename
    765           implementation_type::buffer_type::iterator
    766       > matches;
    767       //cerr<< "Boundary marker == {" << endl
    768       //    << impl.boundary_marker << endl
    769       //    << "}" << endl;
    770 
    771       // get data into our buffer until we reach the first boundary marker.
    772       int runs = 0;
    773       std::size_t offset = 0;
    774 //      std::size_t bytes_read = impl.client_.read_some(impl.prepare(32), ec);
    775 //      if (ec || (bytes_read == 0))
    776 //        return ec;
    777       std::size_t bytes_read = 0;
    778       for(;;)
    779       {
    780         bytes_read = impl.client_.read_some(impl.prepare(32), ec);
    781         if (ec || (bytes_read == 0))
    782           return ec;
    783         buffer_iter begin(impl.buf_.begin());// + offset);
    784         buffer_iter end(impl.buf_.end());
    785         if (!boost::regex_search(begin, end //impl.buf_.begin(), impl.buf_.end()
    786                                 , matches, re, boost::match_default | boost::match_partial))
    787         {
    788           // No chance of matching input with expected, so erase it and start again.
    789           //std::cerr<< " == buffer = " << std::string(impl.buf_.begin(), impl.buf_.end())
    790           //         << " == capacity = " << impl.buf_.capacity() << " ======= ";
    791           //impl.buf_.clear();
    792    //       cerr<< "No chance of matching." << endl;
    793           offset = impl.buf_.size();
    794           //std::cerr<< "Buffer cleared." << endl;
    795           continue;
    796         }
    797         else
    798         {
    799           //std::cerr<< "regex_search == true" << std::endl
    800           //         << "matches[0] =={{ " << matches[0] << " }}=== " << std::endl
    801           //         << "matches[1] =={{ " << matches[1] << " }}=== " << std::endl
    802           //         << "matches[2] =={{ " << matches[2] << " }}=== " << std::endl;
    803           if (matches[2].matched){
    804     //        cerr<< "Found boundary marker... OK!!" << endl;
    805             //cerr<< "[0] = " << matches[0].str() << endl;
    806             //cerr<< "[1] = " << matches[1].str() << endl;
    807             //impl.offset_ = matches[1].length();
    808             //impl.pos_ = matches[0].second;
    809             //cerr<< "setting pos_ to < " << std::string(impl.pos_, impl.pos_ + 5) << "... >" << endl
    810             //    << "setting offset_ = " << impl.offset_ << endl;
    811            //     << std::string(matches[1].first, matches[1].second) << endl;
    812             //impl.pos_ = matches[1].second;
    813             //cerr<< "deleting {" << endl
    814             //    << std::string(impl.buf_.begin(), matches[0].second) << endl
    815             //    << "} leaving {" << endl
    816             //    << std::string(matches[0].second, impl.buf_.end()) << endl
    817             //    << "}" << endl;
    818             //cerr<< "bufsize = " << impl.buf_.size() << endl;
    819             //cerr<< "bufsize = " << impl.buf_.size() << endl;
    820       //      cerr<< "buffer now (before erase) == {" << endl
    821         //        << std::string(impl.buf_.begin(), impl.buf_.end()) << endl
    822           //      << "}" << endl;
    823             impl.buf_.erase(impl.buf_.begin(), matches[0].second);
    824             impl.offset_ = 0;
    825             impl.pos_ = impl.buf_.begin();
    826             return ec;
    827           } else {
    828           //  cerr<< "not read enough data" << std::endl;
    829       //std::cerr<< "; bytes_read = " << bytes_read
    830         //      << "; bufsize = " << impl.buf_.size()
    831           //     << "; capacity = " << impl.buf_.capacity() << std::flush
    832             //   << "; data = {{" << std::string(impl.buf_.begin(), impl.buf_.end()) << "}}";
    833            
    834             if (++runs > 10)
    835               return ec;
    836             continue;
    837           }
    838         }
    839       }
    840 
    841      
    842       // skip that line and then erase the buffer
    843       return ec;
    844     }
    845 
    846     boost::system::error_code
    847       parse_one_form_part(implementation_type& impl, boost::system::error_code& ec)
    848     {
    849       // continuously read data while parsing it until one complete form part has
    850       // been read.
    851       // Note, this may mean recursing into embedded sub-parts if necessary, but
    852       // still only the first *complete* part/sub-part would be read.
    853       //boost::regex re("\r\n--" + impl.boundary_marker + " +
    854 
    855       for(;;)
    856       {
    857         //if (impl.client_.read_some(impl.prepare(1024), ec))
    858         //  return ec;
    859         //boost::asio::read_until(impl.client_, impl.buffer_, impl.boundary_marker, ec);
    860         break;
    861 
    862 
    863       }
    864 
    865       return ec;
    866     }
    867 
    868     /// Get the boundary marker from the CONTENT_TYPE header.
    869     boost::system::error_code
    870       parse_boundary_marker(implementation_type& impl, boost::system::error_code& ec)
    871     {
    872       // get the meta-data appended to the content_type
    873       std::string content_type(var(impl.env_vars(), "CONTENT_TYPE", ec));
    874       //BOOST_ASSERT(!content_type.empty());
    875 
    876       //boost::algorithm::ifind(var(impl, "CONTENT_TYPE"), "bounday="
    877      
    878       boost::regex re("; ?boundary=\"?([^\"\n\r]+)\"?");
    879       boost::smatch match_results;
    880       if (!boost::regex_search(content_type, match_results, re))
    881         return boost::system::error_code(666, boost::system::system_category);
    882 
    883       impl.boundary_marker = match_results[1].str();
    884       // New boundary markers are added to the front of the list.
    885       impl.boundary_markers.push_front(match_results[1].str());
    886 
    887       / *
    888       cerr<< "full = " << content_type << endl
    889           << "full search string = " << match_results[0] << endl
    890           << "marker length = " << match_results[1].length() << endl
    891           << "marker = " << impl.boundary_marker << endl
    892           << "_[2] = " << match_results[2] << endl;
    893           * /
    894      
    895       return ec;
    896     }
    897 */
    898     /// Read and parse a single cgi POST meta variable (greedily)
    899     template<typename RequestImpl>
    900     boost::system::error_code
    901     parse_one_post_var(RequestImpl& impl, boost::system::error_code& ec)
    902     {
    903       //#     error "Not implemented"
    904       return ec;
    905     }
    906337  };
    907338
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/common_headers.hpp

    r43773 r44573  
    1414
    1515#include "boost/cgi/buffer.hpp"
    16 #include "boost/cgi/map.hpp"
     16#include "boost/cgi/common/map.hpp"
    1717#include "boost/cgi/io_service.hpp"
    1818#include "boost/cgi/streambuf.hpp"
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/extract_params.hpp

    r38810 r44573  
    1414#include <boost/system/error_code.hpp>
    1515
    16 #include "url_decode.hpp"
     16#include "boost/cgi/detail/url_decode.hpp"
    1717
    1818namespace cgi {
     
    4848         current_token.clear();
    4949       }else
    50        if( *iter == "&" )
     50       if( *iter == "&" || *iter == ";" )
    5151       {
    52          destination[name] = current_token;
     52         destination[name.c_str()] = current_token;
    5353         current_token.clear();
    5454         name.clear();
     
    5959     }
    6060     if( !name.empty() )
    61        destination[name] = current_token;
     61       destination[name.c_str()] = current_token;
    6262
    6363     return ec;
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/save_environment.hpp

    r43773 r44573  
    1313#include <string>
    1414#include <cstdlib>
    15 #include "boost/cgi/map.hpp"
     15#include "boost/cgi/common/map.hpp"
    1616
    1717// The process' environment
     
    4949         std::string sa(*env, i);
    5050         std::string sb((*env+i+1), j-i-1);
    51          env_map[sa] = sb;
     51         env_map[sa.c_str()] = sb;
    5252       }
    5353     }
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/detail/url_decode.hpp

    r43791 r44573  
    5555   }
    5656
    57    /// Workaround for istreams, since the above can't be used directly
    58    char url_decode(std::istream& is)
    59    {
    60      const char c1 = is.get();
    61      return url_decode(c1, is.get());
    62    }
    63 
    6457   /// URL-decode a string
    6558   std::string url_decode( const std::string& str )
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/fcgi/client.hpp

    r43773 r44573  
    1515#include <boost/asio/buffer.hpp>
    1616#include "boost/cgi/tags.hpp"
    17 #include "boost/cgi/map.hpp"
     17#include "boost/cgi/common/map.hpp"
    1818#include "boost/cgi/io_service.hpp"
    1919#include "boost/cgi/basic_client.hpp"
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/fcgi/request_service.hpp

    r43979 r44573  
    1313
    1414//#include "boost/cgi/scgi/request_impl.hpp"
    15 #include "boost/cgi/map.hpp"
     15#include "boost/cgi/common/map.hpp"
    1616#include "boost/cgi/tags.hpp"
    1717#include "boost/cgi/read.hpp"
     
    427427      **/
    428428
    429       if( _data.find(_name) != _data.end() )
    430         return _data[_name];
     429      if( _data.find(_name.c_str()) != _data.end() )
     430        // **FIXME**
     431        return _data[_name.c_str()];
    431432      return "";
    432433    }
     
    651652        //std::cerr<< "[hw] data := " << data << std::endl;
    652653
    653         impl.env_vars_[name] = data;
     654        // **FIXME**
     655        impl.env_vars_[name.c_str()] = data;
    654656      }
    655657
  • sandbox/SOC/2007/cgi/trunk/boost/cgi/map.hpp

    r43773 r44573  
    1010#define CGI_MAP_HPP_INCLUDED__
    1111
    12 #include <map>
    13 #include <string>
     12#warning This file is deprecated, use common/map.hpp instead.
    1413
    15 namespace cgi {
    16  namespace common {
    17 
    18   typedef std::map<std::string,std::string>    map;
    19 
    20  } // namespace common
    21 } // namespace cgi
     14#include "boost/cgi/common/map.hpp"
    2215
    2316#endif // CGI_MAP_HPP_INCLUDED__
Note: See TracChangeset for help on using the changeset viewer.