589 lines
9.9 KiB
C++
Executable File
589 lines
9.9 KiB
C++
Executable File
/*
|
|
* This file is a part of Winix
|
|
* and is not publicly distributed
|
|
*
|
|
* Copyright (c) 2008-2013, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include "postmultiparser.h"
|
|
#include "log.h"
|
|
#include "utf8/utf8.h"
|
|
|
|
|
|
|
|
PostMultiParser::PostMultiParser()
|
|
{
|
|
in_buffer = new unsigned char[WINIX_POSTMULTI_INPUT_BUFFER];
|
|
}
|
|
|
|
|
|
PostMultiParser::PostMultiParser(const PostMultiParser & p)
|
|
{
|
|
in_buffer = new unsigned char[WINIX_POSTMULTI_INPUT_BUFFER];
|
|
config = p.config;
|
|
}
|
|
|
|
|
|
PostMultiParser & PostMultiParser::operator=(const PostMultiParser & p)
|
|
{
|
|
in_buffer = new unsigned char[WINIX_POSTMULTI_INPUT_BUFFER];
|
|
config = p.config;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
PostMultiParser::~PostMultiParser()
|
|
{
|
|
delete [] in_buffer;
|
|
}
|
|
|
|
|
|
void PostMultiParser::SetConfig(Config * pconfig)
|
|
{
|
|
config = pconfig;
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadBoundary()
|
|
{
|
|
boundary.clear();
|
|
|
|
while( last != -1 && last != 10 && last != 13 )
|
|
{
|
|
boundary += last;
|
|
ReadChar();
|
|
}
|
|
|
|
if( last == 13 )
|
|
{
|
|
ReadChar();
|
|
line_end_dos = true;
|
|
}
|
|
|
|
if( last == 10 )
|
|
ReadChar();
|
|
}
|
|
|
|
|
|
bool PostMultiParser::IsWhite(int c)
|
|
{
|
|
if( c==' ' || c=='\t' || c==13 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void PostMultiParser::SkipWhite()
|
|
{
|
|
while( IsWhite(last) )
|
|
ReadChar();
|
|
}
|
|
|
|
|
|
bool PostMultiParser::IsHeader()
|
|
{
|
|
SkipWhite();
|
|
|
|
if( last == 10 )
|
|
{
|
|
ReadChar();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
void PostMultiParser::ReadHeaderName()
|
|
{
|
|
SkipWhite();
|
|
|
|
while( last!=-1 && last!=':' && last!='=' && !IsWhite(last) && last!=10 )
|
|
{
|
|
header_name += last;
|
|
ReadChar();
|
|
}
|
|
|
|
SkipWhite();
|
|
|
|
if( last != ':' && last != '=' )
|
|
{
|
|
err = WINIX_ERR_BROKEN_INPUT;
|
|
return;
|
|
}
|
|
|
|
ReadChar();
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadHeaderValue()
|
|
{
|
|
bool was_apost = false;
|
|
|
|
SkipWhite();
|
|
|
|
if( last == '"' )
|
|
{
|
|
was_apost = true;
|
|
ReadChar();
|
|
}
|
|
|
|
while( last!=-1 && last!=10 &&
|
|
((!was_apost && last!=';' && !IsWhite(last)) || (was_apost && last!='"')))
|
|
{
|
|
header_value += last;
|
|
ReadChar();
|
|
}
|
|
|
|
if( was_apost )
|
|
{
|
|
if( last != '"' )
|
|
{
|
|
err = WINIX_ERR_BROKEN_INPUT;
|
|
return;
|
|
}
|
|
|
|
ReadChar();
|
|
}
|
|
|
|
SkipWhite();
|
|
|
|
if( last != ';' && last != 10 )
|
|
{
|
|
err = WINIX_ERR_BROKEN_INPUT;
|
|
return;
|
|
}
|
|
|
|
ReadChar();
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadPartHeader()
|
|
{
|
|
header_name.clear();
|
|
header_value.clear();
|
|
|
|
ReadHeaderName();
|
|
|
|
if( err != WINIX_ERR_OK )
|
|
return;
|
|
|
|
ReadHeaderValue();
|
|
|
|
if( err != WINIX_ERR_OK )
|
|
return;
|
|
|
|
log << "PMP: " << header_name << ": " << header_value << logend;
|
|
|
|
if( header_name == "name" )
|
|
name = header_value;
|
|
|
|
if( header_name == "filename" )
|
|
filename = header_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool PostMultiParser::HasBoundary()
|
|
{
|
|
if( content.size() < boundary.size() )
|
|
return false;
|
|
|
|
size_t c = content.size() - boundary.size();
|
|
size_t b = 0;
|
|
|
|
for( ; c<content.size() ; ++c, ++b)
|
|
{
|
|
if( content[c] != boundary[b] )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
void PostMultiParser::LogFirst(const std::string & to_log, size_t len)
|
|
{
|
|
if( len > to_log.size() )
|
|
len = to_log.size();
|
|
|
|
log << log3 << "PMP: Content (";
|
|
|
|
if( len > 0 )
|
|
log << "len: " << to_log.size() << ", first " << len << " bytes";
|
|
else
|
|
log << "empty";
|
|
|
|
log << "): \"";
|
|
log.LogString(to_log, len);
|
|
log << "\"" << logend;
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadContentSkipBoundary(bool has_boundary)
|
|
{
|
|
if( has_boundary && content.size() >= boundary.size() )
|
|
{
|
|
content.erase(content.size()-boundary.size());
|
|
content_len -= boundary.size();
|
|
}
|
|
|
|
// the last new line character doesn't belong to the content
|
|
// this is a new line character before the boundary
|
|
if( !content.empty() && content[content.size()-1] == 10 )
|
|
{
|
|
content.erase(content.size()-1);
|
|
content_len -= 1;
|
|
|
|
if( line_end_dos && !content.empty() && content[content.size()-1] == 13 )
|
|
{
|
|
content.erase(content.size()-1);
|
|
content_len -= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadContentToFileLoop()
|
|
{
|
|
bool has_boundary = false;
|
|
|
|
|
|
while( last!=-1 )
|
|
{
|
|
content += last;
|
|
content_len += 1;
|
|
ReadChar();
|
|
|
|
if( HasBoundary() )
|
|
{
|
|
has_boundary = true;
|
|
break;
|
|
}
|
|
|
|
if( content.size() >= WINIX_POSTMULTI_OUTPUT_BUFFER )
|
|
{
|
|
tmp_file.write(content.c_str(), content.size());
|
|
content.clear();
|
|
}
|
|
|
|
if( config->post_file_max != 0 && content_len > config->post_file_max )
|
|
{
|
|
err = WINIX_ERR_INPUT_TOO_LARGE;
|
|
log << log1 << "PMP: content greater than " << config->post_file_max << " (skipping)" << logend;
|
|
return;
|
|
}
|
|
}
|
|
|
|
ReadContentSkipBoundary(has_boundary);
|
|
|
|
// saving the rest
|
|
if( !content.empty() )
|
|
{
|
|
tmp_file.write(content.c_str(), content.size());
|
|
content.clear();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void PostMultiParser::ReadContentToFile()
|
|
{
|
|
time_t t1, t2;
|
|
|
|
content.clear();
|
|
content.reserve(WINIX_POSTMULTI_OUTPUT_BUFFER);
|
|
content_len = 0;
|
|
t1 = time(0);
|
|
|
|
ReadContentToFileLoop();
|
|
|
|
tmp_file.close();
|
|
log << log2 << "PMP: content size: " << content_len << " bytes" << logend;
|
|
|
|
t2 = time(0);
|
|
|
|
if( t2 - t1 > 1 )
|
|
log << log2 << "PMP: content read in " << (t2-t1) << " sec" << logend;
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadContentLoop()
|
|
{
|
|
bool has_boundary = false;
|
|
|
|
|
|
while( last!=-1 && !(has_boundary=HasBoundary()) )
|
|
{
|
|
content += last;
|
|
content_len += 1;
|
|
ReadChar();
|
|
|
|
if( config->post_file_max != 0 && content_len > (size_t)config->post_file_max )
|
|
{
|
|
err = WINIX_ERR_INPUT_TOO_LARGE;
|
|
log << log1 << "PMP: content greater than " << config->post_file_max << " (skipping)" << logend;
|
|
return;
|
|
}
|
|
}
|
|
|
|
ReadContentSkipBoundary(has_boundary);
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadContent()
|
|
{
|
|
content.clear();
|
|
content_len = 0;
|
|
|
|
ReadContentLoop();
|
|
|
|
log << log2 << "PMP: content size: " << content_len << " bytes" << logend;
|
|
|
|
if( !IsSubStringNoCase("pass", name.c_str()) )
|
|
LogFirst(content, config->log_post_value_size);
|
|
}
|
|
|
|
|
|
void PostMultiParser::ConvStr(const std::string & src, std::wstring & dst)
|
|
{
|
|
if( config->utf8 )
|
|
PT::UTF8ToWide(src, dst);
|
|
else
|
|
AssignString(src, dst);
|
|
}
|
|
|
|
|
|
void PostMultiParser::AddNormalPostVar()
|
|
{
|
|
if( post_tab->size() >= WINIX_POSTTABLE_MAXSIZE )
|
|
{
|
|
err = WINIX_ERR_INPUT_TOO_LARGE;
|
|
log << log1 << "PMP: more than " << WINIX_POSTTABLE_MAXSIZE << " post variables (skipping)" << logend;
|
|
return;
|
|
}
|
|
|
|
ConvStr(name, namew);
|
|
ConvStr(content, contentw);
|
|
|
|
bool added = InsertPostVar(*post_tab, namew, contentw);
|
|
|
|
log << log2 << "PMP: POST var, name: \"" << namew << "\"";
|
|
|
|
if( !added )
|
|
log << log2 << " (skipped)";
|
|
|
|
log << logend;
|
|
}
|
|
|
|
|
|
void PostMultiParser::AddFilePostVar()
|
|
{
|
|
if( post_file_tab->size() >= WINIX_POSTTABLE_MAXSIZE )
|
|
{
|
|
err = WINIX_ERR_INPUT_TOO_LARGE;
|
|
log << log1 << "PMP: more than " << WINIX_POSTTABLE_MAXSIZE << " post file variables (skipping)" << logend;
|
|
return;
|
|
}
|
|
|
|
ConvStr(name, namew);
|
|
ConvStr(filename, post_file_temp.filename);
|
|
post_file_temp.tmp_filename = tmp_filename;
|
|
post_file_temp.file_size = content_len;
|
|
|
|
bool added = InsertPostVar(*post_file_tab, namew, post_file_temp);
|
|
|
|
log << log2 << "PMP: POST FILE var, name: \"" << namew << "\"";
|
|
|
|
if( !added )
|
|
log << log2 << " (skipped)";
|
|
|
|
log << logend;
|
|
}
|
|
|
|
|
|
void PostMultiParser::AddPostVar()
|
|
{
|
|
if( name.empty() )
|
|
return;
|
|
|
|
if( filename.empty() )
|
|
AddNormalPostVar();
|
|
else
|
|
AddFilePostVar();
|
|
}
|
|
|
|
|
|
|
|
void PostMultiParser::CheckBoundaryEnd()
|
|
{
|
|
if( last == '-' )
|
|
{
|
|
ReadChar();
|
|
|
|
if( last != '-' )
|
|
{
|
|
err = WINIX_ERR_BROKEN_INPUT;
|
|
return;
|
|
}
|
|
|
|
// end of parsing
|
|
// the rest input (if exists) is ignored
|
|
last = -1;
|
|
}
|
|
|
|
// skipping a new line after the boundary
|
|
if( last == 13 )
|
|
ReadChar();
|
|
|
|
if( last == 10 )
|
|
ReadChar();
|
|
}
|
|
|
|
|
|
void PostMultiParser::CreateTmpFile()
|
|
{
|
|
wchar_t buf[1024];
|
|
size_t buf_len = sizeof(buf)/sizeof(wchar_t);
|
|
|
|
if( config->upload_dir.empty() )
|
|
{
|
|
log << log1 << "PMP: upload_dir is not set in the config" << logend;
|
|
err = WINIX_ERR_CANT_CREATE_FILE;
|
|
return;
|
|
}
|
|
|
|
swprintf(buf, buf_len, L"%ls/tmp/pmp_%u_%d_%u", config->upload_dir.c_str(), (unsigned)getpid(), tmp_filename_postfix, rand());
|
|
tmp_filename_postfix += 1;
|
|
|
|
tmp_filename = buf;
|
|
PT::WideToUTF8(tmp_filename, atmp_filename);
|
|
|
|
tmp_file.open(atmp_filename.c_str(), std::ios_base::binary | std::ios_base::out);
|
|
// !! dodac ustawienie chmod config.upload_files_chmod dla tymczasowego pliku
|
|
|
|
if( !tmp_file )
|
|
{
|
|
log << log1 << "PMP: can't create a temporary file: " << atmp_filename << logend;
|
|
err = WINIX_ERR_CANT_CREATE_FILE;
|
|
return;
|
|
}
|
|
|
|
log << log3 << "PMP: using temporary file for the content: " << atmp_filename << logend;
|
|
}
|
|
|
|
|
|
|
|
|
|
void PostMultiParser::ReadPart()
|
|
{
|
|
name.clear();
|
|
filename.clear();
|
|
|
|
while( IsHeader() )
|
|
ReadPartHeader();
|
|
|
|
if( err != WINIX_ERR_OK )
|
|
return;
|
|
|
|
if( !filename.empty() )
|
|
CreateTmpFile();
|
|
|
|
if( err != WINIX_ERR_OK )
|
|
return;
|
|
|
|
if( !filename.empty() )
|
|
ReadContentToFile();
|
|
else
|
|
ReadContent();
|
|
|
|
if( err == WINIX_ERR_OK )
|
|
{
|
|
AddPostVar();
|
|
CheckBoundaryEnd();
|
|
}
|
|
|
|
if( err != WINIX_ERR_OK && !filename.empty() )
|
|
{
|
|
log << log1 << "PMP: deleting the tmp file: " << tmp_filename << logend;
|
|
RemoveFile(tmp_filename);
|
|
}
|
|
}
|
|
|
|
|
|
void PostMultiParser::ReadChar()
|
|
{
|
|
if( last == -1 )
|
|
return;
|
|
|
|
if( in_buffer_ind >= in_buffer_len )
|
|
{
|
|
if( in_buffer_len < WINIX_POSTMULTI_INPUT_BUFFER )
|
|
{
|
|
last = -1;
|
|
return;
|
|
}
|
|
|
|
in_buffer_len = FCGX_GetStr((char*)in_buffer, WINIX_POSTMULTI_INPUT_BUFFER, in);
|
|
in_buffer_ind = 0;
|
|
}
|
|
|
|
if( in_buffer_len == 0 )
|
|
{
|
|
last = -1;
|
|
}
|
|
else
|
|
{
|
|
last = in_buffer[in_buffer_ind];
|
|
in_buffer_ind += 1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
Error PostMultiParser::Parse(FCGX_Stream * in_, PostTab & post_tab_, PostFileTab & post_file_tab_)
|
|
{
|
|
in = in_;
|
|
last = 0;
|
|
err = WINIX_ERR_OK;
|
|
var_index = 1;
|
|
line_end_dos = false;
|
|
in_buffer_ind = WINIX_POSTMULTI_INPUT_BUFFER;
|
|
in_buffer_len = WINIX_POSTMULTI_INPUT_BUFFER;
|
|
post_tab = &post_tab_;
|
|
post_file_tab = &post_file_tab_;
|
|
tmp_filename_postfix = 1;
|
|
|
|
ReadChar();
|
|
ReadBoundary();
|
|
|
|
if( boundary.empty() )
|
|
return WINIX_ERR_NO_BOUNDARY;
|
|
|
|
while( last!=-1 && err == WINIX_ERR_OK )
|
|
ReadPart();
|
|
|
|
if( err != WINIX_ERR_OK )
|
|
{
|
|
RemovePostFileTmp(*post_file_tab);
|
|
post_tab->clear();
|
|
post_file_tab->clear();
|
|
|
|
if( err != WINIX_ERR_INPUT_TOO_LARGE && err != WINIX_ERR_CANT_CREATE_FILE )
|
|
log << log1 << "PMP: syntax error" << logend;
|
|
}
|
|
|
|
return err;
|
|
}
|