public:

typedef booster::shared_ptr<http::file> file_ptr;

typedef std::vector<file_ptr> files_type;

files_type get_files()

{

files_type result;

result.swap(files_);

return result;

}

bool set_content_type(std::string const &ct)

{

http::content_type t(ct);

return set_content_type(t);

}

bool set_content_type(http::content_type const &content_type)

{

std::string bkey = content_type.parameter_by_key("boundary");

if(bkey.empty())

return false;

boundary_ = "\r\n--" + bkey;

crlfcrlf_ = "\r\n\r\n";

position_ = 2; // First CRLF does not appear if first state

state_ = expecting_first_boundary;

file_.reset(new http::file());

file_->set_temporary_directory(temp_dir_);

if(memory_limit_ != -1) {

file_->set_memory_limit(memory_limit_);

}

return true;

}

multipart_parser(std::string const &temp_dir = std::string(),size_t memory_limit = -1) :

state_ ( expecting_first_boundary ),

position_(0),

temp_dir_(temp_dir),

memory_limit_(memory_limit),

file_is_ready_(false)

{

}

~multipart_parser()

{

}

typedef enum {

parsing_error,

meta_ready,

content_partial,

content_ready,

continue_input,

eof,

no_room_left

} parsing_result_type;

static bool is_ok(parsing_result_type r) {

switch(r) {

case meta_ready:

case content_partial:

case content_ready:

case continue_input:

return true;

default:

return false;

}

}

bool has_file() { return file_is_ready_; }

http::file &get_file()

{

if(!file_is_ready_)

throw booster::logic_error("Invalid state for get_file");

return *file_;

}

http::file &last_file()

{

if(files_.empty())

throw booster::logic_error("No file was uploaded");

return *files_.back();

}

parsing_result_type consume(char const *&buffer,char const *buffer_end)

{

for(;buffer!=buffer_end;buffer++) {

#ifdef DEBUG_MULTIPART_PARSER

std::cerr << "[";

if(*buffer < 32)

std::cerr << int(*buffer);

else

std::cerr << *buffer ;

std::cerr <<"]" << state_str_[state_] << ", pos="<<position_ << std::endl;

#endif

switch(state_) {

case expecting_first_boundary:

if(*buffer != boundary_[position_])

return parsing_error;

position_++;

if(position_ == boundary_.size()) {

state_ = expecting_one_crlf_or_eof;

position_ = 0;

}

break;

case expecting_one_crlf_or_eof:

if(*buffer=='\r')

state_=expecting_lf;

else if(*buffer=='-')

state_=expecting_minus;

else

return parsing_error;

break;

case expecting_minus:

if(*buffer!='-')

return parsing_error;

state_=expecting_eof_cr;

break;

case expecting_eof_cr:

if(*buffer!='\r')

return parsing_error;

state_=expecting_eof_lf;

break;

case expecting_eof_lf:

if(*buffer!='\n')

return parsing_error;

if(buffer + 1 == buffer_end) {

buffer++;

return eof;

}

else

return parsing_error;

case expecting_lf:

if(*buffer!='\n')

return parsing_error;

state_=expecting_crlfcrlf;

break;

case expecting_crlfcrlf:

header_+=*buffer;

if(*buffer == crlfcrlf_[position_])

position_++;

else

position_=0;

if(position_ == crlfcrlf_.size()) {

if(!process_header(header_))

return parsing_error;

header_.clear();

position_ = 0;

state_ = expecting_separator_boundary;

buffer++;

file_is_ready_=true;

return meta_ready;

}

break;

case expecting_separator_boundary:

{

std::streambuf *out=file_->write_data().rdbuf();

char const *this_boundary = boundary_.c_str();

size_t boundary_size = boundary_.size();

while(buffer != buffer_end) {

char c=*buffer;

if(c == this_boundary[position_])

position_++;

else if(position_ > 0) {

std::streamsize expected = position_;

std::streamsize s=out->sputn(this_boundary,position_);

position_ = 0;

if(c == boundary_[0])

position_=1;

if(s!=expected)

return no_room_left;

}

if(position_ == 0) {

if(out->sputc(c)==EOF)

return no_room_left;

}

else if(position_ == boundary_size) {

state_ = expecting_one_crlf_or_eof;

position_ = 0;

file_->data().seekg(0);

files_.push_back(file_);

file_.reset(new http::file());

file_->set_temporary_directory(temp_dir_);

if(memory_limit_ != -1) {

file_->set_memory_limit(memory_limit_);

}

buffer++;

file_is_ready_=false;

return content_ready;

}

buffer++;

} // end while

return content_partial;

}

break;

}

}

if(file_is_ready_)

return content_partial;

else

return continue_input;

}

private:

bool process_header(std::string const &hdr)

{

size_t pos = 0;

while(pos < hdr.size()) {

size_t next = hdr.find("\r\n",pos);

if(next==std::string::npos) {

return false;

}

if(next == pos) {

return true;

}

std::string one_header=hdr.substr(pos,next-pos);

pos=next+2;

std::string::iterator p=one_header.begin(),e=one_header.end();

p=http::protocol::skip_ws(p,e);

std::string::iterator start=p;

std::string::iterator end=http::protocol::tocken(p,e);

std::string header_name(start,end);

p=http::protocol::skip_ws(end,e);

if(p==e || *p!=':')

return false;

p=http::protocol::skip_ws(p+1,e);

if(http::protocol::compare(header_name,"Content-Disposition")==0) {

start = p;

end=http::protocol::tocken(p,e);

if(http::protocol::compare(std::string(start,end),"form-data")!=0)

return false;

p=end;

if(!parse_content_disposition(p,e))

return false;

}

else if(http::protocol::compare(header_name,"Content-Type")==0) {

http::content_type ct(std::string(p,e));

file_->mime(ct.media_type());

}

}

return false;

}

bool parse_content_disposition(std::string::iterator p,std::string::iterator e)

{

p=http::protocol::skip_ws(p,e);

while(p!=e) {

std::string name,value;

if(!parse_pair(p,e,name,value))

return false;

for(unsigned i=0;i<name.size();i++)

name[i]=http::protocol::ascii_to_lower(name[i]);

if(name=="filename")

file_->filename(value);

else if(name=="name")

file_->name(value);

p=http::protocol::skip_ws(p,e);

}

return true;

}

bool parse_pair(std::string::iterator &p,std::string::iterator e,std::string &name,std::string &value)

{

if(p==e)

return false;

if(*p!=';')

return false;

p=http::protocol::skip_ws(p+1,e);

if(p==e)

return false;

std::string::iterator start = p;

std::string::iterator end = http::protocol::tocken(p,e);

if(start==end)

return false;

if(end==e)

return false;

if(*end!='=')

return false;

name.assign(start,end);

p=http::protocol::skip_ws(end+1,e);

if(p==e)

return false;

if(*p=='"') {

std::string::iterator tmp=p;

value=http::protocol::unquote(tmp,e);

if(p==tmp)

return false;

p=tmp;

return true;

}

else {

std::string::iterator tmp=http::protocol::tocken(p,e);

if(tmp==p)

return false;

value.assign(p,tmp);

p=tmp;

return true;

}

}

typedef enum {

expecting_first_boundary,

expecting_one_crlf_or_eof,

expecting_minus,

expecting_eof_cr,

expecting_eof_lf,

expecting_lf,

expecting_crlfcrlf,

expecting_separator_boundary

} states_type;

#ifdef DEBUG_MULTIPART_PARSER

static char const * const state_str_[8];

#endif

states_type state_;

file_ptr file_;

files_type files_;

size_t position_;

std::string header_;

std::string boundary_;

std::string crlfcrlf_;

std::string temp_dir_;

int memory_limit_;

bool file_is_ready_;