(value);
} else if (name == "writable") {
if (value == "true") {
m_writable = true;
} else if (value == "false") {
m_writable = false;
} else {
BOOST_THROW_EXCEPTION( error::bad_arg() << error::errinfo_arg_name(name) );
}
} else {
BOOST_THROW_EXCEPTION( error::bad_arg() << error::errinfo_arg_name(name) );
}
}
void FileService::operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn)
{
// get the relative resource path for the request
const std::string relative_path(get_relative_resource(http_request_ptr->get_resource()));
// determine the path of the file being requested
boost::filesystem::path file_path;
if (relative_path.empty()) {
// request matches resource exactly
if (m_file.empty()) {
// no file is specified, either in the request or in the options
PION_LOG_WARN(m_logger, "No file option defined ("
<< get_resource() << ")");
sendNotFoundResponse(http_request_ptr, tcp_conn);
return;
} else {
file_path = m_file;
}
} else {
// request does not match resource
if (m_directory.empty()) {
// no directory is specified for the relative file
PION_LOG_WARN(m_logger, "No directory option defined ("
<< get_resource() << "): " << relative_path);
sendNotFoundResponse(http_request_ptr, tcp_conn);
return;
} else {
file_path = m_directory / relative_path;
}
}
// make sure that the requested file is within the configured directory
file_path.normalize();
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
std::string file_string = file_path.string();
if (file_string.find(m_directory.string()) != 0) {
#else
std::string file_string = file_path.file_string();
if (file_string.find(m_directory.directory_string()) != 0) {
#endif
PION_LOG_WARN(m_logger, "Request for file outside of directory ("
<< get_resource() << "): " << relative_path);
static const std::string FORBIDDEN_HTML_START =
"\n"
"403 Forbidden \n"
"\n"
"Forbidden \n"
"The requested URL ";
static const std::string FORBIDDEN_HTML_FINISH =
" is not in the configured directory.
\n"
"\n";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_FORBIDDEN);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_FORBIDDEN);
if (http_request_ptr->get_method() != http::types::REQUEST_METHOD_HEAD) {
writer->write_no_copy(FORBIDDEN_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(FORBIDDEN_HTML_FINISH);
}
writer->send();
return;
}
// requests specifying directories are not allowed
if (boost::filesystem::is_directory(file_path)) {
PION_LOG_WARN(m_logger, "Request for directory ("
<< get_resource() << "): " << relative_path);
static const std::string FORBIDDEN_HTML_START =
"\n"
"403 Forbidden \n"
"\n"
"Forbidden \n"
"The requested URL ";
static const std::string FORBIDDEN_HTML_FINISH =
" is a directory.
\n"
"\n";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_FORBIDDEN);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_FORBIDDEN);
if (http_request_ptr->get_method() != http::types::REQUEST_METHOD_HEAD) {
writer->write_no_copy(FORBIDDEN_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(FORBIDDEN_HTML_FINISH);
}
writer->send();
return;
}
if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_GET
|| http_request_ptr->get_method() == http::types::REQUEST_METHOD_HEAD)
{
// the type of response we will send
enum ResponseType {
RESPONSE_UNDEFINED, // initial state until we know how to respond
RESPONSE_OK, // normal response that includes the file's content
RESPONSE_HEAD_OK, // response to HEAD request (would send file's content)
RESPONSE_NOT_FOUND, // Not Found (404)
RESPONSE_NOT_MODIFIED // Not Modified (304) response to If-Modified-Since
} response_type = RESPONSE_UNDEFINED;
// used to hold our response information
DiskFile response_file;
// get the If-Modified-Since request header
const std::string if_modified_since(http_request_ptr->get_header(http::types::HEADER_IF_MODIFIED_SINCE));
// check the cache for a corresponding entry (if enabled)
// note that m_cache_setting may equal 0 if m_scan_setting == 1
if (m_cache_setting > 0 || m_scan_setting > 0) {
// search for a matching cache entry
boost::mutex::scoped_lock cache_lock(m_cache_mutex);
CacheMap::iterator cache_itr = m_cache_map.find(relative_path);
if (cache_itr == m_cache_map.end()) {
// no existing cache entries found
if (m_scan_setting == 1 || m_scan_setting == 3) {
// do not allow files to be added;
// all requests must correspond with existing cache entries
// since no match was found, just return file not found
PION_LOG_WARN(m_logger, "Request for unknown file ("
<< get_resource() << "): " << relative_path);
response_type = RESPONSE_NOT_FOUND;
} else {
PION_LOG_DEBUG(m_logger, "No cache entry for request ("
<< get_resource() << "): " << relative_path);
}
} else {
// found an existing cache entry
PION_LOG_DEBUG(m_logger, "Found cache entry for request ("
<< get_resource() << "): " << relative_path);
if (m_cache_setting == 0) {
// cache is disabled
// copy & re-use file_path and mime_type
response_file.setFilePath(cache_itr->second.getFilePath());
response_file.setMimeType(cache_itr->second.getMimeType());
// get the file_size and last_modified timestamp
response_file.update();
// just compare strings for simplicity (parsing this date format sucks!)
if (response_file.getLastModifiedString() == if_modified_since) {
// no need to read the file; the modified times match!
response_type = RESPONSE_NOT_MODIFIED;
} else {
if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_HEAD) {
response_type = RESPONSE_HEAD_OK;
} else {
response_type = RESPONSE_OK;
PION_LOG_DEBUG(m_logger, "Cache disabled, reading file ("
<< get_resource() << "): " << relative_path);
}
}
} else {
// cache is enabled
// true if the entry was updated (used for log message)
bool cache_was_updated = false;
if (cache_itr->second.getLastModified() == 0) {
// cache file for the first time
cache_was_updated = true;
cache_itr->second.update();
if (m_max_cache_size==0 || cache_itr->second.getFileSize() <= m_max_cache_size) {
// read the file (may throw exception)
cache_itr->second.read();
} else {
cache_itr->second.resetFileContent();
}
} else if (m_cache_setting == 1) {
// check if file has been updated (may throw exception)
cache_was_updated = cache_itr->second.checkUpdated();
} // else cache_setting == 2 (use existing values)
// get the response type
if (cache_itr->second.getLastModifiedString() == if_modified_since) {
response_type = RESPONSE_NOT_MODIFIED;
} else if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_HEAD) {
response_type = RESPONSE_HEAD_OK;
} else {
response_type = RESPONSE_OK;
}
// copy cache contents so that we can release the mutex
response_file = cache_itr->second;
// check if max size has been exceeded
if (cache_was_updated && m_max_cache_size > 0 && cache_itr->second.getFileSize() > m_max_cache_size) {
cache_itr->second.resetFileContent();
}
PION_LOG_DEBUG(m_logger, (cache_was_updated ? "Updated" : "Using")
<< " cache entry for request ("
<< get_resource() << "): " << relative_path);
}
}
}
if (response_type == RESPONSE_UNDEFINED) {
// make sure that the file exists
if (! boost::filesystem::exists(file_path)) {
PION_LOG_WARN(m_logger, "File not found ("
<< get_resource() << "): " << relative_path);
sendNotFoundResponse(http_request_ptr, tcp_conn);
return;
}
response_file.setFilePath(file_path);
PION_LOG_DEBUG(m_logger, "Found file for request ("
<< get_resource() << "): " << relative_path);
// determine the MIME type
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
response_file.setMimeType(findMIMEType( response_file.getFilePath().filename().string()));
#else
response_file.setMimeType(findMIMEType( response_file.getFilePath().leaf() ));
#endif
// get the file_size and last_modified timestamp
response_file.update();
// just compare strings for simplicity (parsing this date format sucks!)
if (response_file.getLastModifiedString() == if_modified_since) {
// no need to read the file; the modified times match!
response_type = RESPONSE_NOT_MODIFIED;
} else if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_HEAD) {
response_type = RESPONSE_HEAD_OK;
} else {
response_type = RESPONSE_OK;
if (m_cache_setting != 0) {
if (m_max_cache_size==0 || response_file.getFileSize() <= m_max_cache_size) {
// read the file (may throw exception)
response_file.read();
}
// add new entry to the cache
PION_LOG_DEBUG(m_logger, "Adding cache entry for request ("
<< get_resource() << "): " << relative_path);
boost::mutex::scoped_lock cache_lock(m_cache_mutex);
m_cache_map.insert( std::make_pair(relative_path, response_file) );
}
}
}
if (response_type == RESPONSE_OK) {
// use DiskFileSender to send a file
DiskFileSenderPtr sender_ptr(DiskFileSender::create(response_file,
http_request_ptr, tcp_conn,
m_max_chunk_size));
sender_ptr->send();
} else if (response_type == RESPONSE_NOT_FOUND) {
sendNotFoundResponse(http_request_ptr, tcp_conn);
} else {
// sending headers only -> use our own response object
// prepare a response and set the Content-Type
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_content_type(response_file.getMimeType());
// set Last-Modified header to enable client-side caching
writer->get_response().add_header(http::types::HEADER_LAST_MODIFIED,
response_file.getLastModifiedString());
switch(response_type) {
case RESPONSE_UNDEFINED:
case RESPONSE_NOT_FOUND:
case RESPONSE_OK:
// this should never happen
BOOST_ASSERT(false);
break;
case RESPONSE_NOT_MODIFIED:
// set "Not Modified" response
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NOT_MODIFIED);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NOT_MODIFIED);
break;
case RESPONSE_HEAD_OK:
// set "OK" response (not really necessary since this is the default)
writer->get_response().set_status_code(http::types::RESPONSE_CODE_OK);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_OK);
break;
}
// send the response
writer->send();
}
} else if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_POST
|| http_request_ptr->get_method() == http::types::REQUEST_METHOD_PUT
|| http_request_ptr->get_method() == http::types::REQUEST_METHOD_DELETE)
{
// If not writable, then send 405 (Method Not Allowed) response for POST, PUT or DELETE requests.
if (!m_writable) {
static const std::string NOT_ALLOWED_HTML_START =
"\n"
"405 Method Not Allowed \n"
"\n"
"Not Allowed \n"
"The requested method ";
static const std::string NOT_ALLOWED_HTML_FINISH =
" is not allowed on this server.
\n"
"\n";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_METHOD_NOT_ALLOWED);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_METHOD_NOT_ALLOWED);
writer->write_no_copy(NOT_ALLOWED_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_method());
writer->write_no_copy(NOT_ALLOWED_HTML_FINISH);
writer->get_response().add_header("Allow", "GET, HEAD");
writer->send();
} else {
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_POST
|| http_request_ptr->get_method() == http::types::REQUEST_METHOD_PUT)
{
if (boost::filesystem::exists(file_path)) {
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NO_CONTENT);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NO_CONTENT);
} else {
// The file doesn't exist yet, so it will be created below, unless the
// directory of the requested file also doesn't exist.
if (!boost::filesystem::exists(file_path.branch_path())) {
static const std::string NOT_FOUND_HTML_START =
"\n"
"404 Not Found \n"
"\n"
"Not Found \n"
"The directory of the requested URL ";
static const std::string NOT_FOUND_HTML_FINISH =
" was not found on this server.
\n"
"\n";
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NOT_FOUND);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NOT_FOUND);
writer->write_no_copy(NOT_FOUND_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(NOT_FOUND_HTML_FINISH);
writer->send();
return;
}
static const std::string CREATED_HTML_START =
"\n"
"201 Created \n"
"\n"
"Created \n"
"";
static const std::string CREATED_HTML_FINISH =
"
\n"
"\n";
writer->get_response().set_status_code(http::types::RESPONSE_CODE_CREATED);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_CREATED);
writer->get_response().add_header(http::types::HEADER_LOCATION, http_request_ptr->get_resource());
writer->write_no_copy(CREATED_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(CREATED_HTML_FINISH);
}
std::ios_base::openmode mode = http_request_ptr->get_method() == http::types::REQUEST_METHOD_POST?
std::ios::app : std::ios::out;
boost::filesystem::ofstream file_stream(file_path, mode);
file_stream.write(http_request_ptr->get_content(), http_request_ptr->get_content_length());
file_stream.close();
if (!boost::filesystem::exists(file_path)) {
static const std::string PUT_FAILED_HTML_START =
"\n"
"500 Server Error \n"
"\n"
"Server Error \n"
"Error writing to ";
static const std::string PUT_FAILED_HTML_FINISH =
".
\n"
"\n";
writer->get_response().set_status_code(http::types::RESPONSE_CODE_SERVER_ERROR);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_SERVER_ERROR);
writer->write_no_copy(PUT_FAILED_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(PUT_FAILED_HTML_FINISH);
}
writer->send();
} else if (http_request_ptr->get_method() == http::types::REQUEST_METHOD_DELETE) {
if (!boost::filesystem::exists(file_path)) {
sendNotFoundResponse(http_request_ptr, tcp_conn);
} else {
try {
boost::filesystem::remove(file_path);
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NO_CONTENT);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NO_CONTENT);
writer->send();
} catch (std::exception& e) {
static const std::string DELETE_FAILED_HTML_START =
"\n"
"500 Server Error \n"
"\n"
"Server Error \n"
"Could not delete ";
static const std::string DELETE_FAILED_HTML_FINISH =
".
\n"
"\n";
writer->get_response().set_status_code(http::types::RESPONSE_CODE_SERVER_ERROR);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_SERVER_ERROR);
writer->write_no_copy(DELETE_FAILED_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource())
<< "."
<< boost::diagnostic_information(e);
writer->write_no_copy(DELETE_FAILED_HTML_FINISH);
writer->send();
}
}
} else {
// This should never be reached.
writer->get_response().set_status_code(http::types::RESPONSE_CODE_SERVER_ERROR);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_SERVER_ERROR);
writer->send();
}
}
}
// Any method not handled above is unimplemented.
else {
static const std::string NOT_IMPLEMENTED_HTML_START =
"
\n"
"501 Not Implemented \n"
"\n"
"Not Implemented \n"
"The requested method ";
static const std::string NOT_IMPLEMENTED_HTML_FINISH =
" is not implemented on this server.
\n"
"\n";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NOT_IMPLEMENTED);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NOT_IMPLEMENTED);
writer->write_no_copy(NOT_IMPLEMENTED_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_method());
writer->write_no_copy(NOT_IMPLEMENTED_HTML_FINISH);
writer->send();
}
}
void FileService::sendNotFoundResponse(http::request_ptr& http_request_ptr,
tcp::connection_ptr& tcp_conn)
{
static const std::string NOT_FOUND_HTML_START =
"\n"
"404 Not Found \n"
"\n"
"Not Found \n"
"The requested URL ";
static const std::string NOT_FOUND_HTML_FINISH =
" was not found on this server.
\n"
"\n";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_NOT_FOUND);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_NOT_FOUND);
if (http_request_ptr->get_method() != http::types::REQUEST_METHOD_HEAD) {
writer->write_no_copy(NOT_FOUND_HTML_START);
writer << algorithm::xml_encode(http_request_ptr->get_resource());
writer->write_no_copy(NOT_FOUND_HTML_FINISH);
}
writer->send();
}
void FileService::start(void)
{
PION_LOG_DEBUG(m_logger, "Starting up resource (" << get_resource() << ')');
// scan directory/file if scan setting != 0
if (m_scan_setting != 0) {
// force caching if scan == (2 | 3)
if (m_cache_setting == 0 && m_scan_setting > 1)
m_cache_setting = 1;
boost::mutex::scoped_lock cache_lock(m_cache_mutex);
// add entry for file if one is defined
if (! m_file.empty()) {
// use empty relative_path for file option
// use placeholder entry (do not pre-populate) if scan == 1
addCacheEntry("", m_file, m_scan_setting == 1);
}
// scan directory if one is defined
if (! m_directory.empty())
scanDirectory(m_directory);
}
}
void FileService::stop(void)
{
PION_LOG_DEBUG(m_logger, "Shutting down resource (" << get_resource() << ')');
// clear cached files (if started again, it will re-scan)
boost::mutex::scoped_lock cache_lock(m_cache_mutex);
m_cache_map.clear();
}
void FileService::scanDirectory(const boost::filesystem::path& dir_path)
{
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_DEBUG(m_logger, "Scanning directory (" << get_resource() << "): "
<< dir_path.string());
#else
PION_LOG_DEBUG(m_logger, "Scanning directory (" << get_resource() << "): "
<< dir_path.directory_string());
#endif
// iterate through items in the directory
boost::filesystem::directory_iterator end_itr;
for ( boost::filesystem::directory_iterator itr( dir_path );
itr != end_itr; ++itr )
{
if ( boost::filesystem::is_directory(*itr) ) {
// item is a sub-directory
// recursively call scanDirectory()
scanDirectory(*itr);
} else {
// item is a regular file
// figure out relative path to the file
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
std::string file_path_string( itr->path().string() );
std::string relative_path( file_path_string.substr(m_directory.string().size() + 1) );
#else
std::string file_path_string( itr->path().file_string() );
std::string relative_path( file_path_string.substr(m_directory.directory_string().size() + 1) );
#endif
// add item to cache (use placeholder if scan == 1)
addCacheEntry(relative_path, *itr, m_scan_setting == 1);
}
}
}
std::pair
FileService::addCacheEntry(const std::string& relative_path,
const boost::filesystem::path& file_path,
const bool placeholder)
{
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
DiskFile cache_entry(file_path, NULL, 0, 0, findMIMEType(file_path.filename().string()));
#else
DiskFile cache_entry(file_path, NULL, 0, 0, findMIMEType(file_path.leaf()));
#endif
if (! placeholder) {
cache_entry.update();
// only read the file if its size is <= max_cache_size
if (m_max_cache_size==0 || cache_entry.getFileSize() <= m_max_cache_size) {
try { cache_entry.read(); }
catch (std::exception&) {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_ERROR(m_logger, "Unable to add file to cache: "
<< file_path.string());
#else
PION_LOG_ERROR(m_logger, "Unable to add file to cache: "
<< file_path.file_string());
#endif
return std::make_pair(m_cache_map.end(), false);
}
}
}
std::pair add_entry_result
= m_cache_map.insert( std::make_pair(relative_path, cache_entry) );
if (add_entry_result.second) {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_DEBUG(m_logger, "Added file to cache: "
<< file_path.string());
#else
PION_LOG_DEBUG(m_logger, "Added file to cache: "
<< file_path.file_string());
#endif
} else {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_ERROR(m_logger, "Unable to insert cache entry for file: "
<< file_path.string());
#else
PION_LOG_ERROR(m_logger, "Unable to insert cache entry for file: "
<< file_path.file_string());
#endif
}
return add_entry_result;
}
std::string FileService::findMIMEType(const std::string& file_name) {
// initialize m_mime_types if it hasn't been done already
boost::call_once(FileService::createMIMETypes, m_mime_types_init_flag);
// determine the file's extension
std::string extension(file_name.substr(file_name.find_last_of('.') + 1));
boost::algorithm::to_lower(extension);
// search for the matching mime type and return the result
MIMETypeMap::iterator i = m_mime_types_ptr->find(extension);
return (i == m_mime_types_ptr->end() ? DEFAULT_MIME_TYPE : i->second);
}
void FileService::createMIMETypes(void) {
// create the map
static MIMETypeMap mime_types;
// populate mime types
mime_types["js"] = "text/javascript";
mime_types["txt"] = "text/plain";
mime_types["xml"] = "text/xml";
mime_types["css"] = "text/css";
mime_types["htm"] = "text/html";
mime_types["html"] = "text/html";
mime_types["xhtml"] = "text/html";
mime_types["gif"] = "image/gif";
mime_types["png"] = "image/png";
mime_types["jpg"] = "image/jpeg";
mime_types["jpeg"] = "image/jpeg";
mime_types["svg"] = "image/svg+xml";
mime_types["eof"] = "application/vnd.ms-fontobject";
mime_types["otf"] = "application/x-font-opentype";
mime_types["ttf"] = "application/x-font-ttf";
mime_types["woff"] = "application/font-woff";
// ...
// set the static pointer
m_mime_types_ptr = &mime_types;
}
// DiskFile member functions
void DiskFile::update(void)
{
// set file_size and last_modified
m_file_size = boost::numeric_cast(boost::filesystem::file_size( m_file_path ));
m_last_modified = boost::filesystem::last_write_time( m_file_path );
m_last_modified_string = http::types::get_date_string( m_last_modified );
}
void DiskFile::read(void)
{
// re-allocate storage buffer for the file's content
m_file_content.reset(new char[m_file_size]);
// open the file for reading
boost::filesystem::ifstream file_stream;
file_stream.open(m_file_path, std::ios::in | std::ios::binary);
// read the file into memory
if (!file_stream.is_open() || !file_stream.read(m_file_content.get(), m_file_size)) {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
const std::string file_name = m_file_path.string();
#else
const std::string file_name = m_file_path.file_string();
#endif
BOOST_THROW_EXCEPTION( error::read_file() << error::errinfo_file_name(file_name) );
}
}
bool DiskFile::checkUpdated(void)
{
// get current values
std::streamsize cur_size = boost::numeric_cast(boost::filesystem::file_size( m_file_path ));
time_t cur_modified = boost::filesystem::last_write_time( m_file_path );
// check if file has not been updated
if (cur_modified == m_last_modified && cur_size == m_file_size)
return false;
// file has been updated
// update file_size and last_modified timestamp
m_file_size = cur_size;
m_last_modified = cur_modified;
m_last_modified_string = http::types::get_date_string( m_last_modified );
// read new contents
read();
return true;
}
// DiskFileSender member functions
DiskFileSender::DiskFileSender(DiskFile& file, pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn,
unsigned long max_chunk_size)
: m_logger(PION_GET_LOGGER("pion.FileService.DiskFileSender")), m_disk_file(file),
m_writer(pion::http::response_writer::create(tcp_conn, *http_request_ptr, boost::bind(&tcp::connection::finish, tcp_conn))),
m_max_chunk_size(max_chunk_size), m_file_bytes_to_send(0), m_bytes_sent(0)
{
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_DEBUG(m_logger, "Preparing to send file"
<< (m_disk_file.hasFileContent() ? " (cached): " : ": ")
<< m_disk_file.getFilePath().string());
#else
PION_LOG_DEBUG(m_logger, "Preparing to send file"
<< (m_disk_file.hasFileContent() ? " (cached): " : ": ")
<< m_disk_file.getFilePath().file_string());
#endif
// set the Content-Type HTTP header using the file's MIME type
m_writer->get_response().set_content_type(m_disk_file.getMimeType());
// set Last-Modified header to enable client-side caching
m_writer->get_response().add_header(http::types::HEADER_LAST_MODIFIED,
m_disk_file.getLastModifiedString());
// use "200 OK" HTTP response
m_writer->get_response().set_status_code(http::types::RESPONSE_CODE_OK);
m_writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_OK);
}
void DiskFileSender::send(void)
{
// check if we have nothing to send (send 0 byte response content)
if (m_disk_file.getFileSize() <= m_bytes_sent) {
m_writer->send();
return;
}
// calculate the number of bytes to send (m_file_bytes_to_send)
m_file_bytes_to_send = m_disk_file.getFileSize() - m_bytes_sent;
if (m_max_chunk_size > 0 && m_file_bytes_to_send > m_max_chunk_size)
m_file_bytes_to_send = m_max_chunk_size;
// get the content to send (file_content_ptr)
char *file_content_ptr;
if (m_disk_file.hasFileContent()) {
// the entire file IS cached in memory (m_disk_file.file_content)
file_content_ptr = m_disk_file.getFileContent() + m_bytes_sent;
} else {
// the file is not cached in memory
// check if the file has been opened yet
if (! m_file_stream.is_open()) {
// open the file for reading
m_file_stream.open(m_disk_file.getFilePath(), std::ios::in | std::ios::binary);
if (! m_file_stream.is_open()) {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_ERROR(m_logger, "Unable to open file: "
<< m_disk_file.getFilePath().string());
#else
PION_LOG_ERROR(m_logger, "Unable to open file: "
<< m_disk_file.getFilePath().file_string());
#endif
return;
}
}
// check if the content buffer was initialized yet
if (! m_content_buf) {
// allocate memory for the new content buffer
m_content_buf.reset(new char[m_file_bytes_to_send]);
}
file_content_ptr = m_content_buf.get();
// read a block of data from the file into the content buffer
if (! m_file_stream.read(m_content_buf.get(), m_file_bytes_to_send)) {
if (m_file_stream.gcount() > 0) {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_ERROR(m_logger, "File size inconsistency: "
<< m_disk_file.getFilePath().string());
#else
PION_LOG_ERROR(m_logger, "File size inconsistency: "
<< m_disk_file.getFilePath().file_string());
#endif
} else {
# if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3
PION_LOG_ERROR(m_logger, "Unable to read file: "
<< m_disk_file.getFilePath().string());
#else
PION_LOG_ERROR(m_logger, "Unable to read file: "
<< m_disk_file.getFilePath().file_string());
#endif
}
return;
}
}
// send the content
m_writer->write_no_copy(file_content_ptr, m_file_bytes_to_send);
if (m_bytes_sent + m_file_bytes_to_send >= m_disk_file.getFileSize()) {
// this is the last piece of data to send
if (m_bytes_sent > 0) {
// send last chunk in a series
m_writer->send_final_chunk(boost::bind(&DiskFileSender::handle_write,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
} else {
// sending entire file at once
m_writer->send(boost::bind(&DiskFileSender::handle_write,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
} else {
// there will be more data -> send a chunk
m_writer->send_chunk(boost::bind(&DiskFileSender::handle_write,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
}
void DiskFileSender::handle_write(const boost::system::error_code& write_error,
std::size_t bytes_written)
{
bool finished_sending = true;
if (write_error) {
// encountered error sending response data
m_writer->get_connection()->set_lifecycle(tcp::connection::LIFECYCLE_CLOSE); // make sure it will get closed
PION_LOG_WARN(m_logger, "Error sending file (" << write_error.message() << ')');
} else {
// response data sent OK
// use m_file_bytes_to_send instead of bytes_written; bytes_written
// includes bytes for HTTP headers and chunking headers
m_bytes_sent += m_file_bytes_to_send;
if (m_bytes_sent >= m_disk_file.getFileSize()) {
// finished sending
PION_LOG_DEBUG(m_logger, "Sent "
<< (m_file_bytes_to_send < m_disk_file.getFileSize() ? "file chunk" : "complete file")
<< " of " << m_file_bytes_to_send << " bytes (finished"
<< (m_writer->get_connection()->get_keep_alive() ? ", keeping alive)" : ", closing)") );
} else {
// NOT finished sending
PION_LOG_DEBUG(m_logger, "Sent file chunk of " << m_file_bytes_to_send << " bytes");
finished_sending = false;
m_writer->clear();
}
}
if (finished_sending) {
// connection::finish() calls tcp::server::finish_connection, which will either:
// a) call http::server::handle_connection again if keep-alive is true; or,
// b) close the socket and remove it from the server's connection pool
m_writer->get_connection()->finish();
} else {
send();
}
}
} // end namespace plugins
} // end namespace pion
/// creates new FileService objects
extern "C" PION_PLUGIN pion::plugins::FileService *pion_create_FileService(void)
{
return new pion::plugins::FileService();
}
/// destroys FileService objects
extern "C" PION_PLUGIN void pion_destroy_FileService(pion::plugins::FileService *service_ptr)
{
delete service_ptr;
}
pion-5.0.7+dfsg.orig/services/LogService.cpp 0000644 0003720 0000144 00000013175 12420270445 020340 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#include "LogService.hpp"
#if defined(PION_USE_LOG4CXX)
#include
#include
#elif defined(PION_USE_LOG4CPLUS)
#include
#include
#elif defined(PION_USE_LOG4CPP)
#include
#endif
#include
using namespace pion;
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
// static members of LogServiceAppender
const unsigned int LogServiceAppender::DEFAULT_MAX_EVENTS = 25;
// LogServiceAppender member functions
#if defined(PION_USE_LOG4CPP)
LogServiceAppender::LogServiceAppender(void)
: log4cpp::AppenderSkeleton("LogServiceAppender"),
m_max_events(DEFAULT_MAX_EVENTS), m_num_events(0),
m_layout_ptr(new log4cpp::BasicLayout())
{}
#else
LogServiceAppender::LogServiceAppender(void)
: m_max_events(DEFAULT_MAX_EVENTS), m_num_events(0)
{}
#endif
LogServiceAppender::~LogServiceAppender()
{
#if defined(PION_USE_LOG4CPLUS)
destructorImpl();
#endif
}
#if defined(PION_USE_LOG4CXX)
void LogServiceAppender::append(const log4cxx::spi::LoggingEventPtr& event)
{
// custom layouts is not supported for log4cxx library
std::string formatted_string(boost::lexical_cast(event->getTimeStamp()));
formatted_string += ' ';
formatted_string += event->getLevel()->toString();
formatted_string += ' ';
formatted_string += event->getLoggerName();
formatted_string += " - ";
formatted_string += event->getRenderedMessage();
formatted_string += '\n';
addLogString(formatted_string);
}
#elif defined(PION_USE_LOG4CPLUS)
void LogServiceAppender::append(const log4cplus::spi::InternalLoggingEvent& event)
{
// custom layouts is not supported for log4cplus library
std::string formatted_string(boost::lexical_cast(event.getTimestamp().sec()));
formatted_string += ' ';
formatted_string += m_log_level_manager.toString(event.getLogLevel());
formatted_string += ' ';
formatted_string += event.getLoggerName();
formatted_string += " - ";
formatted_string += event.getMessage();
formatted_string += '\n';
addLogString(formatted_string);
}
#elif defined(PION_USE_LOG4CPP)
void LogServiceAppender::_append(const log4cpp::LoggingEvent& event)
{
std::string formatted_string(m_layout_ptr->format(event));
addLogString(formatted_string);
}
#endif
void LogServiceAppender::addLogString(const std::string& log_string)
{
boost::mutex::scoped_lock log_lock(m_log_mutex);
m_log_events.push_back(log_string);
++m_num_events;
while (m_num_events > m_max_events) {
m_log_events.erase(m_log_events.begin());
--m_num_events;
}
}
void LogServiceAppender::writeLogEvents(pion::http::response_writer_ptr& writer)
{
#if defined(PION_USE_LOG4CXX) || defined(PION_USE_LOG4CPLUS) || defined(PION_USE_LOG4CPP)
boost::mutex::scoped_lock log_lock(m_log_mutex);
for (std::list::const_iterator i = m_log_events.begin();
i != m_log_events.end(); ++i)
{
writer << *i;
}
#elif defined(PION_DISABLE_LOGGING)
writer << "Logging is disabled." << http::types::STRING_CRLF;
#else
writer << "Using ostream logging." << http::types::STRING_CRLF;
#endif
}
// LogService member functions
LogService::LogService(void)
: m_log_appender_ptr(new LogServiceAppender())
{
#if defined(PION_USE_LOG4CXX)
m_log_appender_ptr->setName("LogServiceAppender");
log4cxx::Logger::getRootLogger()->addAppender(m_log_appender_ptr);
#elif defined(PION_USE_LOG4CPLUS)
m_log_appender_ptr->setName("LogServiceAppender");
log4cplus::Logger::getRoot().addAppender(m_log_appender_ptr);
#elif defined(PION_USE_LOG4CPP)
log4cpp::Category::getRoot().addAppender(m_log_appender_ptr);
#endif
}
LogService::~LogService()
{
#if defined(PION_USE_LOG4CXX)
// removeAppender() also deletes the object
log4cxx::Logger::getRootLogger()->removeAppender(m_log_appender_ptr);
#elif defined(PION_USE_LOG4CPLUS)
// removeAppender() also deletes the object
log4cplus::Logger::getRoot().removeAppender("LogServiceAppender");
#elif defined(PION_USE_LOG4CPP)
// removeAppender() also deletes the object
log4cpp::Category::getRoot().removeAppender(m_log_appender_ptr);
#else
delete m_log_appender_ptr;
#endif
}
/// handles requests for LogService
void LogService::operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn)
{
// Set Content-type to "text/plain" (plain ascii text)
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_content_type(http::types::CONTENT_TYPE_TEXT);
getLogAppender().writeLogEvents(writer);
writer->send();
}
} // end namespace plugins
} // end namespace pion
/// creates new LogService objects
extern "C" PION_PLUGIN pion::plugins::LogService *pion_create_LogService(void)
{
return new pion::plugins::LogService();
}
/// destroys LogService objects
extern "C" PION_PLUGIN void pion_destroy_LogService(pion::plugins::LogService *service_ptr)
{
delete service_ptr;
}
pion-5.0.7+dfsg.orig/services/EchoService.cpp 0000644 0003720 0000144 00000012712 12420270445 020471 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#include "EchoService.hpp"
#include
#include
#include
#include
using namespace pion;
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
/// used by handle_request to write dictionary terms
void writeDictionaryTerm(http::response_writer_ptr& writer,
const ihash_multimap::value_type& val)
{
// text is copied into writer text cache
writer << val.first << http::types::HEADER_NAME_VALUE_DELIMITER
<< val.second
<< http::types::STRING_CRLF;
}
// EchoService member functions
/// handles requests for EchoService
void EchoService::operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn)
{
// this web service uses static text to test the mixture of "copied" with
// "static" (no-copy) text
static const std::string REQUEST_ECHO_TEXT("[Request Echo]");
static const std::string REQUEST_HEADERS_TEXT("[Request Headers]");
static const std::string QUERY_PARAMS_TEXT("[Query Parameters]");
static const std::string COOKIE_PARAMS_TEXT("[Cookie Parameters]");
static const std::string POST_CONTENT_TEXT("[POST Content]");
static const std::string USER_INFO_TEXT("[USER Info]");
// Set Content-type to "text/plain" (plain ascii text)
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_content_type(http::types::CONTENT_TYPE_TEXT);
// write request information
writer->write_no_copy(REQUEST_ECHO_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
writer
<< "Request method: "
<< http_request_ptr->get_method()
<< http::types::STRING_CRLF
<< "Resource originally requested: "
<< http_request_ptr->get_original_resource()
<< http::types::STRING_CRLF
<< "Resource delivered: "
<< http_request_ptr->get_resource()
<< http::types::STRING_CRLF
<< "Query string: "
<< http_request_ptr->get_query_string()
<< http::types::STRING_CRLF
<< "HTTP version: "
<< http_request_ptr->get_version_major() << '.' << http_request_ptr->get_version_minor()
<< http::types::STRING_CRLF
<< "Content length: "
<< (unsigned long)http_request_ptr->get_content_length()
<< http::types::STRING_CRLF
<< http::types::STRING_CRLF;
// write request headers
writer->write_no_copy(REQUEST_HEADERS_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
std::for_each(http_request_ptr->get_headers().begin(), http_request_ptr->get_headers().end(),
boost::bind(&writeDictionaryTerm, writer, _1));
writer->write_no_copy(http::types::STRING_CRLF);
// write query parameters
writer->write_no_copy(QUERY_PARAMS_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
std::for_each(http_request_ptr->get_queries().begin(), http_request_ptr->get_queries().end(),
boost::bind(&writeDictionaryTerm, writer, _1));
writer->write_no_copy(http::types::STRING_CRLF);
// write cookie parameters
writer->write_no_copy(COOKIE_PARAMS_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
std::for_each(http_request_ptr->get_cookies().begin(), http_request_ptr->get_cookies().end(),
boost::bind(&writeDictionaryTerm, writer, _1));
writer->write_no_copy(http::types::STRING_CRLF);
// write POST content
writer->write_no_copy(POST_CONTENT_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
if (http_request_ptr->get_content_length() != 0) {
writer->write(http_request_ptr->get_content(), http_request_ptr->get_content_length());
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
}
// if authenticated, write user info
user_ptr user = http_request_ptr->get_user();
if (user) {
writer->write_no_copy(USER_INFO_TEXT);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
writer << "User authenticated, username: " << user->get_username();
writer->write_no_copy(http::types::STRING_CRLF);
}
// send the writer
writer->send();
}
} // end namespace plugins
} // end namespace pion
/// creates new EchoService objects
extern "C" PION_PLUGIN pion::plugins::EchoService *pion_create_EchoService(void)
{
return new pion::plugins::EchoService();
}
/// destroys EchoService objects
extern "C" PION_PLUGIN void pion_destroy_EchoService(pion::plugins::EchoService *service_ptr)
{
delete service_ptr;
}
pion-5.0.7+dfsg.orig/services/HelloService.cpp 0000644 0003720 0000144 00000003125 12420270445 020654 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#include "HelloService.hpp"
#include
using namespace pion;
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
// HelloService member functions
/// handles requests for HelloService
void HelloService::operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn)
{
static const std::string HELLO_HTML = "Hello World!";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->write_no_copy(HELLO_HTML);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
writer->send();
}
} // end namespace plugins
} // end namespace pion
/// creates new HelloService objects
extern "C" PION_PLUGIN pion::plugins::HelloService *pion_create_HelloService(void)
{
return new pion::plugins::HelloService();
}
/// destroys HelloService objects
extern "C" PION_PLUGIN void pion_destroy_HelloService(pion::plugins::HelloService *service_ptr)
{
delete service_ptr;
}
pion-5.0.7+dfsg.orig/services/FileService.vcxproj.filters 0000644 0003720 0000144 00000002032 12420270445 023044 0 ustar roberto users
{4FC737F1-C7A5-4376-A066-2A32D752A2FF}
cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
{93995380-89BD-4b04-88EB-625FBE52EBFB}
h;hpp;hxx;hm;inl;inc;xsd
{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav
Source Files
Header Files
pion-5.0.7+dfsg.orig/services/CookieService.vcxproj.filters 0000644 0003720 0000144 00000002036 12420270445 023402 0 ustar roberto users
{4FC737F1-C7A5-4376-A066-2A32D752A2FF}
cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
{93995380-89BD-4b04-88EB-625FBE52EBFB}
h;hpp;hxx;hm;inl;inc;xsd
{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav
Source Files
Header Files
pion-5.0.7+dfsg.orig/services/HelloService.vcxproj.filters 0000644 0003720 0000144 00000002034 12420270445 023232 0 ustar roberto users
{4FC737F1-C7A5-4376-A066-2A32D752A2FF}
cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
{93995380-89BD-4b04-88EB-625FBE52EBFB}
h;hpp;hxx;hm;inl;inc;xsd
{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav
Source Files
Header Files
pion-5.0.7+dfsg.orig/services/AllowNothingService.vcxproj 0000644 0003720 0000144 00000033014 12420270445 023127 0 ustar roberto users
Debug_DLL_full
Win32
Debug_DLL_full
x64
Debug_static
Win32
Debug_static
x64
Release_DLL_full
Win32
Release_DLL_full
x64
Release_static
Win32
Release_static
x64
{8C8A8E46-4588-4CE1-B624-89C36EA5209E}
AllowNothingService
Win32Proj
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
<_ProjectFileVersion>10.0.40219.1
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
X64
ProgramDatabase
X64
MultiThreadedDLL
ALLOWNOTHINGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
ALLOWNOTHINGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
ProgramDatabase
false
MachineX64
ALLOWNOTHINGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
ALLOWNOTHINGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
MachineX64
MultiThreadedDLL
{61f4b4d5-3608-4264-9f4b-b0da3e3fdf62}
false
pion-5.0.7+dfsg.orig/services/CookieService.vcxproj 0000644 0003720 0000144 00000032742 12420270445 021742 0 ustar roberto users
Debug_DLL_full
Win32
Debug_DLL_full
x64
Debug_static
Win32
Debug_static
x64
Release_DLL_full
Win32
Release_DLL_full
x64
Release_static
Win32
Release_static
x64
{1CF012D8-A47C-4D2B-952D-D90D19795A07}
CookieService
Win32Proj
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
<_ProjectFileVersion>10.0.40219.1
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
X64
ProgramDatabase
X64
MultiThreadedDLL
COOKIESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
COOKIESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
ProgramDatabase
false
MachineX64
COOKIESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
COOKIESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
MachineX64
MultiThreadedDLL
{61f4b4d5-3608-4264-9f4b-b0da3e3fdf62}
false
pion-5.0.7+dfsg.orig/services/FileService.hpp 0000644 0003720 0000144 00000032143 12420270445 020477 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_FILESERVICE_HEADER__
#define __PION_FILESERVICE_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
///
/// DiskFile: class used to represent files stored on disk
///
class DiskFile {
public:
/// default constructor
DiskFile(void)
: m_file_size(0), m_last_modified(0) {}
/// used to construct new disk file objects
DiskFile(const boost::filesystem::path& path,
char *content, unsigned long size,
std::time_t modified, const std::string& mime)
: m_file_path(path), m_file_content(content), m_file_size(size),
m_last_modified(modified), m_mime_type(mime)
{}
/// copy constructor
DiskFile(const DiskFile& f)
: m_file_path(f.m_file_path), m_file_content(f.m_file_content),
m_file_size(f.m_file_size), m_last_modified(f.m_last_modified),
m_last_modified_string(f.m_last_modified_string), m_mime_type(f.m_mime_type)
{}
/// updates the file_size and last_modified timestamp to disk
void update(void);
/// reads content from disk into file_content buffer (may throw)
void read(void);
/**
* checks if the file has been updated and updates vars if it has (may throw)
*
* @return true if the file was updated
*/
bool checkUpdated(void);
/// return path to the cached file
inline const boost::filesystem::path& getFilePath(void) const { return m_file_path; }
/// returns content of the cached file
inline char *getFileContent(void) { return m_file_content.get(); }
/// returns true if there is cached file content
inline bool hasFileContent(void) const { return static_cast(m_file_content); }
/// returns size of the file's content
inline unsigned long getFileSize(void) const { return m_file_size; }
/// returns timestamp that the cached file was last modified (0 = cache disabled)
inline std::time_t getLastModified(void) const { return m_last_modified; }
/// returns timestamp that the cached file was last modified (string format)
inline const std::string& getLastModifiedString(void) const { return m_last_modified_string; }
/// returns mime type for the cached file
inline const std::string& getMimeType(void) const { return m_mime_type; }
/// sets the path to the cached file
inline void setFilePath(const boost::filesystem::path& p) { m_file_path = p; }
/// appends to the path of the cached file
inline void appendFilePath(const std::string& p) { m_file_path /= p; }
/// sets the mime type for the cached file
inline void setMimeType(const std::string& t) { m_mime_type = t; }
/// resets the size of the file content buffer
inline void resetFileContent(unsigned long n = 0) {
if (n == 0) m_file_content.reset();
else m_file_content.reset(new char[n]);
}
protected:
/// path to the cached file
boost::filesystem::path m_file_path;
/// content of the cached file
boost::shared_array m_file_content;
/// size of the file's content
std::streamsize m_file_size;
/// timestamp that the cached file was last modified (0 = cache disabled)
std::time_t m_last_modified;
/// timestamp that the cached file was last modified (string format)
std::string m_last_modified_string;
/// mime type for the cached file
std::string m_mime_type;
};
///
/// DiskFileSender: class used to send files to clients using HTTP responses
///
class DiskFileSender :
public boost::enable_shared_from_this,
private boost::noncopyable
{
public:
/**
* creates new DiskFileSender objects
*
* @param file disk file object that should be sent
* @param http_request_ptr HTTP request that we are responding to
* @param tcp_conn TCP connection used to send the file
* @param max_chunk_size sets the maximum chunk size (default=0, unlimited)
*/
static inline boost::shared_ptr
create(DiskFile& file,
pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn,
unsigned long max_chunk_size = 0)
{
return boost::shared_ptr(new DiskFileSender(file, http_request_ptr,
tcp_conn, max_chunk_size));
}
/// default virtual destructor
virtual ~DiskFileSender() {}
/// Begins sending the file to the client. Following a call to this
/// function, it is not thread safe to use your reference to the
/// DiskFileSender object.
void send(void);
/// sets the logger to be used
inline void set_logger(logger log_ptr) { m_logger = log_ptr; }
/// returns the logger currently in use
inline logger get_logger(void) { return m_logger; }
protected:
/**
* protected constructor restricts creation of objects (use create())
*
* @param file disk file object that should be sent
* @param http_request_ptr HTTP request that we are responding to
* @param tcp_conn TCP connection used to send the file
* @param max_chunk_size sets the maximum chunk size
*/
DiskFileSender(DiskFile& file,
pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn,
unsigned long max_chunk_size);
/**
* handler called after a send operation has completed
*
* @param write_error error status from the last write operation
* @param bytes_written number of bytes sent by the last write operation
*/
void handle_write(const boost::system::error_code& write_error,
std::size_t bytes_written);
/// primary logging interface used by this class
logger m_logger;
private:
/// the disk file we are sending
DiskFile m_disk_file;
/// the HTTP response we are sending
pion::http::response_writer_ptr m_writer;
/// used to read the file from disk if it is not already cached in memory
boost::filesystem::ifstream m_file_stream;
/// buffer used to send file content
boost::shared_array m_content_buf;
/**
* maximum chunk size (in bytes): files larger than this size will be
* delivered to clients using HTTP chunked responses. A value of
* zero means that the size is unlimited (chunking is disabled).
*/
unsigned long m_max_chunk_size;
/// the number of file bytes send in the last operation
unsigned long m_file_bytes_to_send;
/// the number of bytes we have sent so far
unsigned long m_bytes_sent;
};
/// data type for a DiskFileSender pointer
typedef boost::shared_ptr DiskFileSenderPtr;
///
/// FileService: web service that serves regular files
///
class FileService :
public pion::http::plugin_service
{
public:
// default constructor and destructor
FileService(void);
virtual ~FileService() {}
/**
* configuration options supported by FileService:
*
* directory: all files within the directory will be made available
* file:
* cache:
* scan:
* max_chunk_size:
* writable:
*/
virtual void set_option(const std::string& name, const std::string& value);
/// handles requests for FileService
virtual void operator()(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
/// called when the web service's server is starting
virtual void start(void);
/// called when the web service's server is stopping
virtual void stop(void);
/// sets the logger to be used
inline void set_logger(logger log_ptr) { m_logger = log_ptr; }
/// returns the logger currently in use
inline logger get_logger(void) { return m_logger; }
protected:
/// data type for map of file names to cache entries
typedef PION_HASH_MAP CacheMap;
/// data type for map of file extensions to MIME types
typedef PION_HASH_MAP MIMETypeMap;
/**
* adds all files within a directory to the cache
*
* @param dir_path the directory to scan (sub-directories are included)
*/
void scanDirectory(const boost::filesystem::path& dir_path);
/**
* adds a single file to the cache
*
* @param relative_path path for the file relative to the root directory
* @param file_path actual path to the file on disk
* @param placeholder if true, the file's contents are not cached
*
* @return std::pair if an entry is added to the
* cache, second will be true and first will point to the new entry
*/
std::pair
addCacheEntry(const std::string& relative_path,
const boost::filesystem::path& file_path,
const bool placeholder);
/**
* searches for a MIME type that matches a file
*
* @param file_name name of the file to search for
* @return MIME type corresponding with the file, or DEFAULT_MIME_TYPE if none found
*/
static std::string findMIMEType(const std::string& file_name);
void sendNotFoundResponse(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
/// primary logging interface used by this class
logger m_logger;
private:
/// function called once to initialize the map of MIME types
static void createMIMETypes(void);
/// mime type used if no others are found for the file's extension
static const std::string DEFAULT_MIME_TYPE;
/// default setting for cache configuration option
static const unsigned int DEFAULT_CACHE_SETTING;
/// default setting for scan configuration option
static const unsigned int DEFAULT_SCAN_SETTING;
/// default setting for the maximum cache size option
static const unsigned long DEFAULT_MAX_CACHE_SIZE;
/// default setting for the maximum chunk size option
static const unsigned long DEFAULT_MAX_CHUNK_SIZE;
/// flag used to make sure that createMIMETypes() is called only once
static boost::once_flag m_mime_types_init_flag;
/// map of file extensions to MIME types
static MIMETypeMap * m_mime_types_ptr;
/// directory containing files that will be made available
boost::filesystem::path m_directory;
/// single file served by the web service
boost::filesystem::path m_file;
/// used to cache file contents and metadata in memory
CacheMap m_cache_map;
/// mutex used to make the file cache thread-safe
boost::mutex m_cache_mutex;
/**
* cache configuration setting:
* 0 = do not cache files in memory
* 1 = cache files in memory when requested, check for any updates
* 2 = cache files in memory when requested, ignore any updates
*/
unsigned int m_cache_setting;
/**
* scan configuration setting (only applies to directories):
* 0 = do not scan the directory; allow files to be added at any time
* 1 = scan directory when started, and do not allow files to be added
* 2 = scan directory and pre-populate cache; allow new files
* 3 = scan directory and pre-populate cache; ignore new files
*/
unsigned int m_scan_setting;
/**
* maximum cache size (in bytes): files larger than this size will never be
* cached in memory. A value of zero means that the size is unlimited.
*/
unsigned long m_max_cache_size;
/**
* maximum chunk size (in bytes): files larger than this size will be
* delivered to clients using HTTP chunked responses. A value of
* zero means that the size is unlimited (chunking is disabled).
*/
unsigned long m_max_chunk_size;
/**
* Whether the file and/or directory served are writable.
*/
bool m_writable;
};
} // end namespace plugins
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/services/AllowNothingService.vcxproj.filters 0000644 0003720 0000144 00000002052 12420270445 024574 0 ustar roberto users
{4FC737F1-C7A5-4376-A066-2A32D752A2FF}
cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
{93995380-89BD-4b04-88EB-625FBE52EBFB}
h;hpp;hxx;hm;inl;inc;xsd
{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav
Source Files
Header Files
pion-5.0.7+dfsg.orig/services/CMakeLists.txt 0000644 0003720 0000144 00000002321 12420270445 020321 0 ustar roberto users # ---------------------------------------------------------------------
# pion: a Boost C++ framework for building lightweight HTTP interfaces
# ---------------------------------------------------------------------
# Copyright (C) 2013 Splunk Inc. (https://github.com/splunk/pion)
#
# Distributed under the Boost Software License, Version 1.0.
# See http://www.boost.org/LICENSE_1_0.txt
# ---------------------------------------------------------------------
cmake_minimum_required(VERSION 2.8.10 FATAL_ERROR)
set(PROJECT_NAME services)
project(${PROJECT_NAME} CXX)
# get all *.cpp files from src to build target
file(GLOB SRC_FILES ${PROJECT_SOURCE_DIR}/*.cpp)
# build targets from each file
foreach(_file ${SRC_FILES})
get_filename_component(_prj_name ${_file} NAME_WE)
string(TOUPPER ${_prj_name} _prj_name_upper)
message("BUILD_${_prj_name_upper} = ${BUILD_${_prj_name_upper}}")
if (BUILD_${_prj_name_upper})
add_library(${_prj_name} MODULE ${_file})
target_link_libraries(${_prj_name} pion)
install(TARGETS ${_prj_name}
RUNTIME DESTINATION services
LIBRARY DESTINATION services
ARCHIVE DESTINATION services
)
endif()
endforeach()
pion-5.0.7+dfsg.orig/services/FileService.vcxproj 0000644 0003720 0000144 00000032724 12420270445 021410 0 ustar roberto users
Debug_DLL_full
Win32
Debug_DLL_full
x64
Debug_static
Win32
Debug_static
x64
Release_DLL_full
Win32
Release_DLL_full
x64
Release_static
Win32
Release_static
x64
{70CA1FA9-BA9A-4EA4-9B7B-C747238991C1}
FileService
Win32Proj
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
<_ProjectFileVersion>10.0.40219.1
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
X64
ProgramDatabase
X64
MultiThreadedDLL
FILESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
FILESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
ProgramDatabase
false
MachineX64
FILESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
FILESERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
MachineX64
MultiThreadedDLL
{61f4b4d5-3608-4264-9f4b-b0da3e3fdf62}
false
pion-5.0.7+dfsg.orig/services/EchoService.hpp 0000644 0003720 0000144 00000002014 12420270445 020470 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_ECHOSERVICE_HEADER__
#define __PION_ECHOSERVICE_HEADER__
#include
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
///
/// EchoService: web service that echos back requests (to test request parsing)
///
class EchoService :
public pion::http::plugin_service
{
public:
EchoService(void) {}
virtual ~EchoService() {}
virtual void operator()(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
};
} // end namespace plugins
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/services/AllowNothingService.cpp 0000644 0003720 0000144 00000004073 12420270445 022221 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#include "AllowNothingService.hpp"
#include
#include
using namespace pion;
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
void AllowNothingService::operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn)
{
static const std::string DENY_HTML = "No, you can't.";
http::response_writer_ptr writer(http::response_writer::create(tcp_conn, *http_request_ptr,
boost::bind(&tcp::connection::finish, tcp_conn)));
writer->get_response().set_status_code(http::types::RESPONSE_CODE_METHOD_NOT_ALLOWED);
writer->get_response().set_status_message(http::types::RESPONSE_MESSAGE_METHOD_NOT_ALLOWED);
// This is a legitimate header, but it crashes when it's sent.
//writer->get_response().add_header("Allow", "");
// Use this line to demonstrate that it's the empty header value that's causing the problem.
writer->get_response().add_header("Allow", "GET");
writer->write_no_copy(DENY_HTML);
writer->write_no_copy(http::types::STRING_CRLF);
writer->write_no_copy(http::types::STRING_CRLF);
writer->send();
}
} // end namespace plugins
} // end namespace pion
/// creates new AllowNothingService objects
extern "C" PION_PLUGIN pion::plugins::AllowNothingService *pion_create_AllowNothingService(void)
{
return new pion::plugins::AllowNothingService();
}
/// destroys AllowNothingService objects
extern "C" PION_PLUGIN void pion_destroy_AllowNothingService(pion::plugins::AllowNothingService *service_ptr)
{
delete service_ptr;
}
pion-5.0.7+dfsg.orig/services/HelloService.vcxproj 0000644 0003720 0000144 00000032733 12420270445 021574 0 ustar roberto users
Debug_DLL_full
Win32
Debug_DLL_full
x64
Debug_static
Win32
Debug_static
x64
Release_DLL_full
Win32
Release_DLL_full
x64
Release_static
Win32
Release_static
x64
{9EE2433A-B460-45E0-8968-EC5CE8EF9875}
HelloService
Win32Proj
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
<_ProjectFileVersion>10.0.40219.1
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
X64
ProgramDatabase
X64
MultiThreadedDLL
HELLOSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
HELLOSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
ProgramDatabase
false
MachineX64
HELLOSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
HELLOSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
MachineX64
MultiThreadedDLL
{61f4b4d5-3608-4264-9f4b-b0da3e3fdf62}
false
pion-5.0.7+dfsg.orig/services/Makefile.am 0000644 0003720 0000144 00000004154 12420270445 017623 0 ustar roberto users # --------------------------------
# pion automake configuration file
# --------------------------------
AM_CPPFLAGS = -I../include
pion_pluginsdir = @PION_PLUGINS_DIRECTORY@
pion_plugins_LTLIBRARIES = HelloService.la EchoService.la \
CookieService.la LogService.la FileService.la AllowNothingService.la
HelloService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
HelloService_la_SOURCES = HelloService.hpp HelloService.cpp
HelloService_la_LDFLAGS = -no-undefined -module -avoid-version
HelloService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
HelloService_la_DEPENDENCIES = ../src/libpion.la
EchoService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
EchoService_la_SOURCES = EchoService.hpp EchoService.cpp
EchoService_la_LDFLAGS = -no-undefined -module -avoid-version
EchoService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
EchoService_la_DEPENDENCIES = ../src/libpion.la
CookieService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
CookieService_la_SOURCES = CookieService.hpp CookieService.cpp
CookieService_la_LDFLAGS = -no-undefined -module -avoid-version
CookieService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
CookieService_la_DEPENDENCIES = ../src/libpion.la
LogService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
LogService_la_SOURCES = LogService.hpp LogService.cpp
LogService_la_LDFLAGS = -no-undefined -module -avoid-version
LogService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
LogService_la_DEPENDENCIES = ../src/libpion.la
# Build both dynamic and static library for FileService
#FileService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
FileService_la_SOURCES = FileService.hpp FileService.cpp
FileService_la_LDFLAGS = -no-undefined -module -avoid-version
FileService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
FileService_la_DEPENDENCIES = ../src/libpion.la
AllowNothingService_la_CXXFLAGS = -shared $(AM_CXXFLAGS)
AllowNothingService_la_SOURCES = AllowNothingService.hpp AllowNothingService.cpp
AllowNothingService_la_LDFLAGS = -no-undefined -module -avoid-version
AllowNothingService_la_LIBADD = ../src/libpion.la @PION_EXTERNAL_LIBS@
AllowNothingService_la_DEPENDENCIES = ../src/libpion.la
EXTRA_DIST = *.vcxproj *.vcxproj.filters
pion-5.0.7+dfsg.orig/services/LogService.vcxproj 0000644 0003720 0000144 00000032715 12420270445 021252 0 ustar roberto users
Debug_DLL_full
Win32
Debug_DLL_full
x64
Debug_static
Win32
Debug_static
x64
Release_DLL_full
Win32
Release_DLL_full
x64
Release_static
Win32
Release_static
x64
{12F95FE7-ACE1-4281-86BF-4117AE2D633E}
LogService
Win32Proj
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
DynamicLibrary
v120
DynamicLibrary
v120
StaticLibrary
v120
StaticLibrary
v120
<_ProjectFileVersion>10.0.40219.1
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
AllRules.ruleset
X64
ProgramDatabase
X64
MultiThreadedDLL
LOGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
LOGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
ProgramDatabase
false
MachineX64
LOGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
X64
LOGSERVICE_EXPORTS;PION_FULL;%(PreprocessorDefinitions)
false
MachineX64
MultiThreadedDLL
{61f4b4d5-3608-4264-9f4b-b0da3e3fdf62}
false
pion-5.0.7+dfsg.orig/services/AllowNothingService.hpp 0000644 0003720 0000144 00000002231 12420270445 022220 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_ALLOW_NOTHING_SERVICE_HEADER__
#define __PION_ALLOW_NOTHING_SERVICE_HEADER__
#include
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
///
/// This class has a corresponding create function (pion_create_AllowNothingService) and
/// destroy function (pion_destroy_AllowNothingService), as required for use by plugin.
///
class AllowNothingService : public pion::http::plugin_service
{
public:
AllowNothingService(void) {}
~AllowNothingService() {}
virtual void operator()(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
};
} // end namespace plugins
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/services/CookieService.hpp 0000644 0003720 0000144 00000002013 12420270445 021022 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_COOKIESERVICE_HEADER__
#define __PION_COOKIESERVICE_HEADER__
#include
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
///
/// CookieService: web service that displays and updates cookies
///
class CookieService :
public pion::http::plugin_service
{
public:
CookieService(void) {}
virtual ~CookieService() {}
virtual void operator()(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
};
} // end namespace plugins
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/services/EchoService.vcxproj.filters 0000644 0003720 0000144 00000002032 12420270445 023043 0 ustar roberto users
{4FC737F1-C7A5-4376-A066-2A32D752A2FF}
cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
{93995380-89BD-4b04-88EB-625FBE52EBFB}
h;hpp;hxx;hm;inl;inc;xsd
{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav
Source Files
Header Files
pion-5.0.7+dfsg.orig/services/LogService.hpp 0000644 0003720 0000144 00000011522 12420270445 020337 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_LOGSERVICE_HEADER__
#define __PION_LOGSERVICE_HEADER__
#include
#include
#include
#include
#include
#include
#include
#if defined(PION_USE_LOG4CXX)
#include
// version 0.10.x introduces a new data type that is declared in a
// pool.h header file. If we're using 0.9.x, just declare the type
// as an int since it is not being used at all
#ifndef _LOG4CXX_HELPERS_POOL_H
namespace log4cxx {
namespace helpers {
typedef int Pool;
}
}
#endif
#endif
namespace pion { // begin namespace pion
namespace plugins { // begin namespace plugins
///
/// LogServiceAppender: caches log events in memory for use by LogService
///
class LogServiceAppender
#ifdef PION_HAS_LOG_APPENDER
: public log_appender
#endif
{
public:
// default constructor and destructor
LogServiceAppender(void);
virtual ~LogServiceAppender();
/// sets the maximum number of log events cached in memory
inline void setMaxEvents(unsigned int n) { m_max_events = n; }
/// adds a formatted log message to the memory cache
void addLogString(const std::string& log_string);
/// writes the events cached in memory to a response stream
void writeLogEvents(pion::http::response_writer_ptr& writer);
private:
/// default maximum number of events cached in memory
static const unsigned int DEFAULT_MAX_EVENTS;
/// maxiumum number of events cached in memory
unsigned int m_max_events;
/// number of events currently cached in memory
unsigned int m_num_events;
/// memory cache of pre-formatted log events
std::list m_log_events;
/// mutex to make class thread-safe
boost::mutex m_log_mutex;
#if defined(PION_USE_LOG4CXX)
public:
// member functions inherited from the Appender interface class
virtual void close() {}
virtual bool requiresLayout() const { return false; }
protected:
/// adds log event to the memory cache
virtual void append(const log4cxx::spi::LoggingEventPtr& event);
// version 0.10.x adds a second "pool" argument -> just ignore it
virtual void append(const log4cxx::spi::LoggingEventPtr& event,
log4cxx::helpers::Pool& pool)
{
append(event);
}
#elif defined(PION_USE_LOG4CPLUS)
public:
// member functions inherited from the Appender interface class
virtual void close() {}
protected:
virtual void append(const log4cplus::spi::InternalLoggingEvent& event);
private:
/// this is used to convert numeric log levels into strings
log4cplus::LogLevelManager m_log_level_manager;
#elif defined(PION_USE_LOG4CPP)
public:
// member functions inherited from the AppenderSkeleton class
virtual void close() {}
virtual bool requiresLayout() const { return true; }
virtual void setLayout(log4cpp::Layout* layout) { m_layout_ptr.reset(layout); }
protected:
/// adds log event to the memory cache
virtual void _append(const log4cpp::LoggingEvent& event);
private:
/// the logging layout used to format events
boost::scoped_ptr m_layout_ptr;
#endif
};
///
/// LogService: web service that displays log messages
///
class LogService :
public pion::http::plugin_service
{
public:
// default constructor and destructor
LogService(void);
virtual ~LogService();
/// handles a new HTTP request
virtual void operator()(pion::http::request_ptr& http_request_ptr,
pion::tcp::connection_ptr& tcp_conn);
/// returns the log appender used by LogService
inline LogServiceAppender& getLogAppender(void) {
#ifdef PION_HAS_LOG_APPENDER
return dynamic_cast(*m_log_appender_ptr);
#else
return *m_log_appender_ptr;
#endif
}
private:
/// this is used to keep track of log messages
#ifdef PION_HAS_LOG_APPENDER
log_appender_ptr m_log_appender_ptr;
#else
LogServiceAppender * m_log_appender_ptr;
#endif
};
} // end namespace plugins
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/ 0000755 0003720 0000144 00000000000 12420270445 015363 5 ustar roberto users pion-5.0.7+dfsg.orig/include/pion/ 0000755 0003720 0000144 00000000000 12420270445 016330 5 ustar roberto users pion-5.0.7+dfsg.orig/include/pion/admin_rights.hpp 0000644 0003720 0000144 00000005174 12420270445 021520 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_ADMIN_RIGHTS_HEADER__
#define __PION_ADMIN_RIGHTS_HEADER__
#include
#include
#include
#include
namespace pion { // begin namespace pion
///
/// admin_rights: obtains administrative rights for the process
///
class PION_API admin_rights {
public:
/**
* constructs object, obtaining administrative rights; will block
* if another thread has already obtained rights
*
* @param use_log if false, then no logging will be performed
*/
admin_rights(bool use_log = true);
/// destructor releases administrative rights
virtual ~admin_rights() { release(); }
/// releases administrative rights
void release(void);
/// calculates the user id based upon the user configuration parameter
static long run_as_user(const std::string& user_name);
/// calculates the group id based upon the group configuration parameter
static long run_as_group(const std::string& group_name);
private:
/**
* finds an identifier within a system credentials file (users or groups)
*
* @param name descriptive name to lookup (user or group name, may be id)
* @param file system credentials file to look within
*
* @return boost::int32_t identifier found, or -1 if none found
*/
static long find_system_id(const std::string& name, const std::string& file);
/// adminisitrator or root user identifier
static const boost::int16_t ADMIN_USER_ID;
/// mutex used to prevent multiple threads from corrupting user id
static boost::mutex m_mutex;
/// primary logging interface used by this class
logger m_logger;
/// lock used to prevent multiple threads from corrupting user id
boost::unique_lock m_lock;
/// saved user identifier before upgrading to administrator
boost::int16_t m_user_id;
/// true if the class currently holds administrative rights
bool m_has_rights;
/// if false, then no logging will be performed
bool m_use_log;
};
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/config.hpp.xcode 0000644 0003720 0000144 00000005056 12420270445 021415 0 ustar roberto users /* common/include/pion/PionConfig.hpp. Generated from PionConfig.hpp.in by configure. */
// ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_PIONCONFIG_HEADER__
#define __PION_PIONCONFIG_HEADER__
// DO NOT USE autoheader ; this file is not automanaged!!!
/* Define to the version number of pion. */
#define PION_VERSION "5.0.7"
/* Define to the directory where Pion plug-ins are installed. */
#define PION_PLUGINS_DIRECTORY "/usr/local/lib/pion/plugins"
/* Define to the directory where cygwin is installed. */
#define PION_CYGWIN_DIRECTORY ""
/* Define to 1 if C library supports malloc_trim() */
#undef PION_HAVE_MALLOC_TRIM
// -----------------------------------------------------------------------
// hash_map support
//
// At least one of the following options should be defined.
/* Define to 1 if you have the header file. */
/* #undef PION_HAVE_EXT_HASH_MAP 1 */
/* Define to 1 if you have the header file. */
/* #undef PION_HAVE_HASH_MAP */
/* Define to 1 if you have the header file. */
#define PION_HAVE_TR1_UNORDERED_MAP
/* Define to 1 if you have the header file. */
/* #undef PION_HAVE_UNORDERED_MAP */
// -----------------------------------------------------------------------
// Logging Options
//
// At most one of the logging options below should be defined. If none of
// them are defined, std::cout and std::cerr will be used for logging.
/* Define to 1 to use the `log4cplus' library (-llog4cplus) for logging. */
#define PION_USE_LOG4CPLUS 1
/* Define to 1 to use the `log4cxx' library (-llog4cxx) for logging. */
/* #undef PION_USE_LOG4CXX */
/* Define to 1 to use the `log4cpp' library (-llog4cpp) for logging. */
/* #undef PION_USE_LOG4CPP */
/* Define to 1 to disable logging. */
/* #undef PION_DISABLE_LOGGING */
// -----------------------------------------------------------------------
/* Define to 1 if you have the `zlib' library. */
#define PION_HAVE_ZLIB 1
/* Define to 1 if you have the `bzlib' library. */
#define PION_HAVE_BZLIB 1
/* Define to 1 if you have the `OpenSSL' library. */
#define PION_HAVE_SSL 1
/* This is used by Windows projects to flag exported symbols */
#define PION_API
#define PION_PLUGIN
#endif
pion-5.0.7+dfsg.orig/include/pion/logger.hpp 0000644 0003720 0000144 00000027567 12420270445 020341 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_LOGGER_HEADER__
#define __PION_LOGGER_HEADER__
#include
#if defined(PION_USE_LOG4CXX)
// unfortunately, the current version of log4cxx has many problems that
// produce very annoying warnings
// log4cxx headers
#include
#include
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4231) // nonstandard extension used : 'extern' before template explicit instantiation
#endif
#include
#include
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#if defined _MSC_VER
#if defined _DEBUG
#pragma comment(lib, "log4cxxd")
#else
#pragma comment(lib, "log4cxx")
#endif
#pragma comment(lib, "odbc32")
#endif
namespace pion {
typedef log4cxx::LoggerPtr logger;
typedef log4cxx::AppenderSkeleton log_appender;
typedef log_appender * log_appender_ptr;
}
#define PION_HAS_LOG_APPENDER 1
#define PION_LOG_CONFIG_BASIC log4cxx::BasicConfigurator::configure();
#define PION_LOG_CONFIG(FILE) log4cxx::PropertyConfigurator::configure(FILE);
#define PION_GET_LOGGER(NAME) log4cxx::Logger::get_logger(NAME)
#define PION_SHUTDOWN_LOGGER log4cxx::LogManager::shutdown();
#define PION_LOG_SETLEVEL_DEBUG(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::DEBUG_INT));
#define PION_LOG_SETLEVEL_INFO(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::INFO_INT));
#define PION_LOG_SETLEVEL_WARN(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::WARN_INT));
#define PION_LOG_SETLEVEL_ERROR(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::ERROR_INT));
#define PION_LOG_SETLEVEL_FATAL(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::FATAL_INT));
#define PION_LOG_SETLEVEL_UP(LOG) LOG->setLevel(LOG->getLevel()->toInt()+1);
#define PION_LOG_SETLEVEL_DOWN(LOG) LOG->setLevel(LOG->getLevel()->toInt()-1);
#define PION_LOG_DEBUG LOG4CXX_DEBUG
#define PION_LOG_INFO LOG4CXX_INFO
#define PION_LOG_WARN LOG4CXX_WARN
#define PION_LOG_ERROR LOG4CXX_ERROR
#define PION_LOG_FATAL LOG4CXX_FATAL
#elif defined(PION_USE_LOG4CPLUS)
// log4cplus headers
#include
#include
#include
#include
#include
#include
#include
#include
#if defined(_MSC_VER) && !defined(PION_CMAKE_BUILD)
#if defined _DEBUG
#if defined PION_STATIC_LINKING
#pragma comment(lib, "log4cplusSD")
#else
#pragma comment(lib, "log4cplusD")
#endif
#else
#if defined PION_STATIC_LINKING
#pragma comment(lib, "log4cplusS")
#else
#pragma comment(lib, "log4cplus")
#endif
#endif
#endif
namespace pion {
typedef log4cplus::Logger logger;
typedef log4cplus::Appender log_appender;
typedef log4cplus::SharedAppenderPtr log_appender_ptr;
///
/// circular_buffer_appender: caches log events in a circular buffer
///
class circular_buffer_appender : public log4cplus::Appender
{
public:
typedef boost::circular_buffer LogEventBuffer;
// default constructor and destructor
circular_buffer_appender(void) : m_log_events(1000) {};
virtual ~circular_buffer_appender() { destructorImpl(); }
/// returns an iterator to the log events in the buffer
const LogEventBuffer& getLogIterator() const {
return m_log_events;
}
public:
// member functions inherited from the Appender interface class
virtual void close() {}
protected:
virtual void append(const log4cplus::spi::InternalLoggingEvent& event) {
boost::mutex::scoped_lock log_lock(m_log_mutex);
m_log_events.push_back(*event.clone());
}
private:
/// circular buffer for log events
LogEventBuffer m_log_events;
/// mutex to make class thread-safe
boost::mutex m_log_mutex;
};
}
#define PION_HAS_LOG_APPENDER 1
#define PION_LOG_CONFIG_BASIC log4cplus::BasicConfigurator::doConfigure();
#define PION_LOG_CONFIG(FILE) log4cplus::PropertyConfigurator::doConfigure(FILE);
#define PION_GET_LOGGER(NAME) log4cplus::Logger::getInstance(NAME)
#define PION_SHUTDOWN_LOGGER log4cplus::Logger::shutdown();
#define PION_LOG_SETLEVEL_DEBUG(LOG) LOG.setLogLevel(log4cplus::DEBUG_LOG_LEVEL);
#define PION_LOG_SETLEVEL_INFO(LOG) LOG.setLogLevel(log4cplus::INFO_LOG_LEVEL);
#define PION_LOG_SETLEVEL_WARN(LOG) LOG.setLogLevel(log4cplus::WARN_LOG_LEVEL);
#define PION_LOG_SETLEVEL_ERROR(LOG) LOG.setLogLevel(log4cplus::ERROR_LOG_LEVEL);
#define PION_LOG_SETLEVEL_FATAL(LOG) LOG.setLogLevel(log4cplus::FATAL_LOG_LEVEL);
#define PION_LOG_SETLEVEL_UP(LOG) LOG.setLogLevel(LOG.getLogLevel()+1);
#define PION_LOG_SETLEVEL_DOWN(LOG) LOG.setLogLevel(LOG.getLogLevel()-1);
#define PION_LOG_DEBUG LOG4CPLUS_DEBUG
#define PION_LOG_INFO LOG4CPLUS_INFO
#define PION_LOG_WARN LOG4CPLUS_WARN
#define PION_LOG_ERROR LOG4CPLUS_ERROR
#define PION_LOG_FATAL LOG4CPLUS_FATAL
#elif defined(PION_USE_LOG4CPP)
// log4cpp headers
#include
#include
#include
#include
namespace pion {
typedef log4cpp::Category* logger;
typedef log4cpp::AppenderSkeleton log_appender;
typedef log_appender * log_appender_ptr;
}
#define PION_HAS_LOG_APPENDER 1
#define PION_LOG_CONFIG_BASIC { log4cpp::OstreamAppender *app = new log4cpp::OstreamAppender("cout", &std::cout); app->setLayout(new log4cpp::BasicLayout()); log4cpp::Category::getRoot().setAppender(app); }
#define PION_LOG_CONFIG(FILE) { log4cpp::PropertyConfigurator::configure(FILE); }
#define PION_GET_LOGGER(NAME) (&log4cpp::Category::getInstance(NAME))
#define PION_SHUTDOWN_LOGGER log4cpp::Category::shutdown();
#define PION_LOG_SETLEVEL_DEBUG(LOG) { LOG->setPriority(log4cpp::Priority::DEBUG); }
#define PION_LOG_SETLEVEL_INFO(LOG) { LOG->setPriority(log4cpp::Priority::INFO); }
#define PION_LOG_SETLEVEL_WARN(LOG) { LOG->setPriority(log4cpp::Priority::WARN); }
#define PION_LOG_SETLEVEL_ERROR(LOG) { LOG->setPriority(log4cpp::Priority::ERROR); }
#define PION_LOG_SETLEVEL_FATAL(LOG) { LOG->setPriority(log4cpp::Priority::FATAL); }
#define PION_LOG_SETLEVEL_UP(LOG) { LOG->setPriority(LOG.getPriority()+1); }
#define PION_LOG_SETLEVEL_DOWN(LOG) { LOG->setPriority(LOG.getPriority()-1); }
#define PION_LOG_DEBUG(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::DEBUG) { LOG->debugStream() << MSG; }
#define PION_LOG_INFO(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::INFO) { LOG->infoStream() << MSG; }
#define PION_LOG_WARN(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::WARN) { LOG->warnStream() << MSG; }
#define PION_LOG_ERROR(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::ERROR) { LOG->errorStream() << MSG; }
#define PION_LOG_FATAL(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::FATAL) { LOG->fatalStream() << MSG; }
#elif defined(PION_DISABLE_LOGGING)
// Logging is disabled -> add do-nothing stubs for logging
namespace pion {
struct PION_API logger {
logger(int /* glog */) {}
operator bool() const { return false; }
static void shutdown() {}
};
typedef int log_appender;
typedef log_appender * log_appender_ptr;
}
#undef PION_HAS_LOG_APPENDER
#define PION_LOG_CONFIG_BASIC {}
#define PION_LOG_CONFIG(FILE) {}
#define PION_GET_LOGGER(NAME) 0
#define PION_SHUTDOWN_LOGGER 0
// use LOG to avoid warnings about LOG not being used
#define PION_LOG_SETLEVEL_DEBUG(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_INFO(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_WARN(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_ERROR(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_FATAL(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_UP(LOG) { if (LOG) {} }
#define PION_LOG_SETLEVEL_DOWN(LOG) { if (LOG) {} }
#define PION_LOG_DEBUG(LOG, MSG) { if (LOG) {} }
#define PION_LOG_INFO(LOG, MSG) { if (LOG) {} }
#define PION_LOG_WARN(LOG, MSG) { if (LOG) {} }
#define PION_LOG_ERROR(LOG, MSG) { if (LOG) {} }
#define PION_LOG_FATAL(LOG, MSG) { if (LOG) {} }
#else
#define PION_USE_OSTREAM_LOGGING
// Logging uses std::cout and std::cerr
#include
#include
#include
namespace pion {
struct PION_API logger {
enum log_priority_type {
LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN,
LOG_LEVEL_ERROR, LOG_LEVEL_FATAL
};
~logger() {}
logger(void) : m_name("pion") {}
logger(const std::string& name) : m_name(name) {}
logger(const logger& p) : m_name(p.m_name) {}
static void shutdown() {}
std::string m_name;
static log_priority_type m_priority;
};
typedef int log_appender;
typedef log_appender * log_appender_ptr;
}
#undef PION_HAS_LOG_APPENDER
#define PION_LOG_CONFIG_BASIC {}
#define PION_LOG_CONFIG(FILE) {}
#define PION_GET_LOGGER(NAME) pion::logger(NAME)
#define PION_SHUTDOWN_LOGGER {}
#define PION_LOG_SETLEVEL_DEBUG(LOG) { LOG.m_priority = pion::logger::LOG_LEVEL_DEBUG; }
#define PION_LOG_SETLEVEL_INFO(LOG) { LOG.m_priority = pion::logger::LOG_LEVEL_INFO; }
#define PION_LOG_SETLEVEL_WARN(LOG) { LOG.m_priority = pion::logger::LOG_LEVEL_WARN; }
#define PION_LOG_SETLEVEL_ERROR(LOG) { LOG.m_priority = pion::logger::LOG_LEVEL_ERROR; }
#define PION_LOG_SETLEVEL_FATAL(LOG) { LOG.m_priority = pion::logger::LOG_LEVEL_FATAL; }
#define PION_LOG_SETLEVEL_UP(LOG) { ++LOG.m_priority; }
#define PION_LOG_SETLEVEL_DOWN(LOG) { --LOG.m_priority; }
#define PION_LOG_DEBUG(LOG, MSG) if (LOG.m_priority <= pion::logger::LOG_LEVEL_DEBUG) { std::cout << time(NULL) << " DEBUG " << LOG.m_name << ' ' << MSG << std::endl; }
#define PION_LOG_INFO(LOG, MSG) if (LOG.m_priority <= pion::logger::LOG_LEVEL_INFO) { std::cout << time(NULL) << " INFO " << LOG.m_name << ' ' << MSG << std::endl; }
#define PION_LOG_WARN(LOG, MSG) if (LOG.m_priority <= pion::logger::LOG_LEVEL_WARN) { std::cerr << time(NULL) << " WARN " << LOG.m_name << ' ' << MSG << std::endl; }
#define PION_LOG_ERROR(LOG, MSG) if (LOG.m_priority <= pion::logger::LOG_LEVEL_ERROR) { std::cerr << time(NULL) << " ERROR " << LOG.m_name << ' ' << MSG << std::endl; }
#define PION_LOG_FATAL(LOG, MSG) if (LOG.m_priority <= pion::logger::LOG_LEVEL_FATAL) { std::cerr << time(NULL) << " FATAL " << LOG.m_name << ' ' << MSG << std::endl; }
#endif
#endif
pion-5.0.7+dfsg.orig/include/pion/config.hpp.in 0000644 0003720 0000144 00000004564 12420270445 020724 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_PIONCONFIG_HEADER__
#define __PION_PIONCONFIG_HEADER__
// DO NOT USE autoheader ; this file is not automanaged!!!
/* Define to the version number of pion. */
#undef PION_VERSION
/* Define to the directory where Pion plug-ins are installed. */
#undef PION_PLUGINS_DIRECTORY
/* Define to the directory where cygwin is installed. */
#undef PION_CYGWIN_DIRECTORY
/* Define to 1 if C library supports malloc_trim() */
#undef PION_HAVE_MALLOC_TRIM
// -----------------------------------------------------------------------
// hash_map support
//
// At least one of the following options should be defined.
/* Define to 1 if you have the header file. */
#undef PION_HAVE_EXT_HASH_MAP
/* Define to 1 if you have the header file. */
#undef PION_HAVE_HASH_MAP
/* Define to 1 if you have the header file. */
#undef PION_HAVE_TR1_UNORDERED_MAP
/* Define to 1 if you have the header file. */
#undef PION_HAVE_UNORDERED_MAP
// -----------------------------------------------------------------------
// Logging Options
//
// At most one of the logging options below should be defined. If none of
// them are defined, std::cout and std::cerr will be used for logging.
/* Define to 1 to use the `log4cplus' library (-llog4cplus) for logging. */
#undef PION_USE_LOG4CPLUS
/* Define to 1 to use the `log4cxx' library (-llog4cxx) for logging. */
#undef PION_USE_LOG4CXX
/* Define to 1 to use the `log4cpp' library (-llog4cpp) for logging. */
#undef PION_USE_LOG4CPP
/* Define to 1 to disable logging. */
#undef PION_DISABLE_LOGGING
// -----------------------------------------------------------------------
/* Define to 1 if you have the `zlib' library. */
#undef PION_HAVE_ZLIB
/* Define to 1 if you have the `bzlib' library. */
#undef PION_HAVE_BZLIB
/* Define to 1 if you have the `OpenSSL' library. */
#undef PION_HAVE_SSL
/* This is used by Windows projects to flag exported symbols */
#define PION_API
#define PION_PLUGIN
#endif
pion-5.0.7+dfsg.orig/include/pion/http/ 0000755 0003720 0000144 00000000000 12420270445 017307 5 ustar roberto users pion-5.0.7+dfsg.orig/include/pion/http/message.hpp 0000644 0003720 0000144 00000064771 12420270445 021463 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_MESSAGE_HEADER__
#define __PION_HTTP_MESSAGE_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef BOOST_SYSTEM_NOEXCEPT
// if 'BOOST_NOEXCEPT' is not defined, as with some older versions of
// boost, setting it to nothing should be harmless.
#ifndef BOOST_NOEXCEPT
#define BOOST_SYSTEM_NOEXCEPT
#else
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
#endif
#endif
namespace pion { // begin namespace pion
namespace tcp {
// forward declaration for class used by send() and receive()
class connection;
}
namespace http { // begin namespace http
// forward declaration of parser class
class parser;
///
/// message: base container for HTTP messages
///
class PION_API message
: public http::types
{
public:
/// data type for I/O write buffers (these wrap existing data to be sent)
typedef std::vector write_buffers_t;
/// used to cache chunked data
typedef std::vector chunk_cache_t;
/// data type for library errors returned during receive() operations
struct receive_error_t
: public boost::system::error_category
{
virtual ~receive_error_t() {}
virtual inline const char *name() const BOOST_SYSTEM_NOEXCEPT { return "receive_error_t"; }
virtual inline std::string message(int ev) const {
std::string result;
switch(ev) {
case 1:
result = "HTTP message parsing error";
break;
default:
result = "Unknown receive error";
break;
}
return result;
}
};
/// defines message data integrity status codes
enum data_status_t
{
STATUS_NONE, // no data received (i.e. all lost)
STATUS_TRUNCATED, // one or more missing packets at the end
STATUS_PARTIAL, // one or more missing packets but NOT at the end
STATUS_OK // no missing packets
};
/// constructs a new HTTP message object
message(void)
: m_is_valid(false), m_is_chunked(false), m_chunks_supported(false),
m_do_not_send_content_length(false),
m_version_major(1), m_version_minor(1), m_content_length(0), m_content_buf(),
m_status(STATUS_NONE), m_has_missing_packets(false), m_has_data_after_missing(false)
{}
/// copy constructor
message(const message& http_msg)
: m_first_line(http_msg.m_first_line),
m_is_valid(http_msg.m_is_valid),
m_is_chunked(http_msg.m_is_chunked),
m_chunks_supported(http_msg.m_chunks_supported),
m_do_not_send_content_length(http_msg.m_do_not_send_content_length),
m_remote_ip(http_msg.m_remote_ip),
m_version_major(http_msg.m_version_major),
m_version_minor(http_msg.m_version_minor),
m_content_length(http_msg.m_content_length),
m_content_buf(http_msg.m_content_buf),
m_chunk_cache(http_msg.m_chunk_cache),
m_headers(http_msg.m_headers),
m_status(http_msg.m_status),
m_has_missing_packets(http_msg.m_has_missing_packets),
m_has_data_after_missing(http_msg.m_has_data_after_missing)
{}
/// assignment operator
inline message& operator=(const message& http_msg) {
m_first_line = http_msg.m_first_line;
m_is_valid = http_msg.m_is_valid;
m_is_chunked = http_msg.m_is_chunked;
m_chunks_supported = http_msg.m_chunks_supported;
m_do_not_send_content_length = http_msg.m_do_not_send_content_length;
m_remote_ip = http_msg.m_remote_ip;
m_version_major = http_msg.m_version_major;
m_version_minor = http_msg.m_version_minor;
m_content_length = http_msg.m_content_length;
m_content_buf = http_msg.m_content_buf;
m_chunk_cache = http_msg.m_chunk_cache;
m_headers = http_msg.m_headers;
m_status = http_msg.m_status;
m_has_missing_packets = http_msg.m_has_missing_packets;
m_has_data_after_missing = http_msg.m_has_data_after_missing;
return *this;
}
/// virtual destructor
virtual ~message() {}
/// clears all message data
virtual void clear(void) {
clear_first_line();
m_is_valid = m_is_chunked = m_chunks_supported
= m_do_not_send_content_length = false;
m_remote_ip = boost::asio::ip::address_v4(0);
m_version_major = m_version_minor = 1;
m_content_length = 0;
m_content_buf.clear();
m_chunk_cache.clear();
m_headers.clear();
m_cookie_params.clear();
m_status = STATUS_NONE;
m_has_missing_packets = false;
m_has_data_after_missing = false;
}
/// should return true if the content length can be implied without headers
virtual bool is_content_length_implied(void) const = 0;
/// returns true if the message is valid
inline bool is_valid(void) const { return m_is_valid; }
/// returns true if chunked transfer encodings are supported
inline bool get_chunks_supported(void) const { return m_chunks_supported; }
/// returns IP address of the remote endpoint
inline boost::asio::ip::address& get_remote_ip(void) {
return m_remote_ip;
}
/// returns the major HTTP version number
inline boost::uint16_t get_version_major(void) const { return m_version_major; }
/// returns the minor HTTP version number
inline boost::uint16_t get_version_minor(void) const { return m_version_minor; }
/// returns a string representation of the HTTP version (i.e. "HTTP/1.1")
inline std::string get_version_string(void) const {
std::string http_version(STRING_HTTP_VERSION);
http_version += boost::lexical_cast(get_version_major());
http_version += '.';
http_version += boost::lexical_cast(get_version_minor());
return http_version;
}
/// returns the length of the payload content (in bytes)
inline size_t get_content_length(void) const { return m_content_length; }
/// returns true if the message content is chunked
inline bool is_chunked(void) const { return m_is_chunked; }
/// returns true if buffer for content is allocated
bool is_content_buffer_allocated() const { return !m_content_buf.is_empty(); }
/// returns size of allocated buffer
inline std::size_t get_content_buffer_size() const { return m_content_buf.size(); }
/// returns a pointer to the payload content, or empty string if there is none
inline char *get_content(void) { return m_content_buf.get(); }
/// returns a const pointer to the payload content, or empty string if there is none
inline const char *get_content(void) const { return m_content_buf.get(); }
/// returns a reference to the chunk cache
inline chunk_cache_t& get_chunk_cache(void) { return m_chunk_cache; }
/// returns a value for the header if any are defined; otherwise, an empty string
inline const std::string& get_header(const std::string& key) const {
return get_value(m_headers, key);
}
/// returns a reference to the HTTP headers
inline ihash_multimap& get_headers(void) {
return m_headers;
}
/// returns true if at least one value for the header is defined
inline bool has_header(const std::string& key) const {
return(m_headers.find(key) != m_headers.end());
}
/// returns a value for the cookie if any are defined; otherwise, an empty string
/// since cookie names are insensitive, key should use lowercase alpha chars
inline const std::string& get_cookie(const std::string& key) const {
return get_value(m_cookie_params, key);
}
/// returns the cookie parameters
inline ihash_multimap& get_cookies(void) {
return m_cookie_params;
}
/// returns true if at least one value for the cookie is defined
/// since cookie names are insensitive, key should use lowercase alpha chars
inline bool has_cookie(const std::string& key) const {
return(m_cookie_params.find(key) != m_cookie_params.end());
}
/// adds a value for the cookie
/// since cookie names are insensitive, key should use lowercase alpha chars
inline void add_cookie(const std::string& key, const std::string& value) {
m_cookie_params.insert(std::make_pair(key, value));
}
/// changes the value of a cookie
/// since cookie names are insensitive, key should use lowercase alpha chars
inline void change_cookie(const std::string& key, const std::string& value) {
change_value(m_cookie_params, key, value);
}
/// removes all values for a cookie
/// since cookie names are insensitive, key should use lowercase alpha chars
inline void delete_cookie(const std::string& key) {
delete_value(m_cookie_params, key);
}
/// returns a string containing the first line for the HTTP message
inline const std::string& get_first_line(void) const {
if (m_first_line.empty())
update_first_line();
return m_first_line;
}
/// true if there were missing packets
inline bool has_missing_packets() const { return m_has_missing_packets; }
/// set to true when missing packets detected
inline void set_missing_packets(bool newVal) { m_has_missing_packets = newVal; }
/// true if more data seen after the missing packets
inline bool has_data_after_missing_packets() const { return m_has_data_after_missing; }
inline void set_data_after_missing_packet(bool newVal) { m_has_data_after_missing = newVal; }
/// sets whether or not the message is valid
inline void set_is_valid(bool b = true) { m_is_valid = b; }
/// set to true if chunked transfer encodings are supported
inline void set_chunks_supported(bool b) { m_chunks_supported = b; }
/// sets IP address of the remote endpoint
inline void set_remote_ip(const boost::asio::ip::address& ip) { m_remote_ip = ip; }
/// sets the major HTTP version number
inline void set_version_major(const boost::uint16_t n) {
m_version_major = n;
clear_first_line();
}
/// sets the minor HTTP version number
inline void set_version_minor(const boost::uint16_t n) {
m_version_minor = n;
clear_first_line();
}
/// sets the length of the payload content (in bytes)
inline void set_content_length(size_t n) { m_content_length = n; }
/// if called, the content-length will not be sent in the HTTP headers
inline void set_do_not_send_content_length(void) { m_do_not_send_content_length = true; }
/// return the data receival status
inline data_status_t get_status() const { return m_status; }
///
inline void set_status(data_status_t newVal) { m_status = newVal; }
/// sets the length of the payload content using the Content-Length header
inline void update_content_length_using_header(void) {
ihash_multimap::const_iterator i = m_headers.find(HEADER_CONTENT_LENGTH);
if (i == m_headers.end()) {
m_content_length = 0;
} else {
std::string trimmed_length(i->second);
boost::algorithm::trim(trimmed_length);
m_content_length = boost::lexical_cast(trimmed_length);
}
}
/// sets the transfer coding using the Transfer-Encoding header
inline void update_transfer_encoding_using_header(void) {
m_is_chunked = false;
ihash_multimap::const_iterator i = m_headers.find(HEADER_TRANSFER_ENCODING);
if (i != m_headers.end()) {
// From RFC 2616, sec 3.6: All transfer-coding values are case-insensitive.
m_is_chunked = boost::regex_match(i->second, REGEX_ICASE_CHUNKED);
// ignoring other possible values for now
}
}
///creates a payload content buffer of size m_content_length and returns
/// a pointer to the new buffer (memory is managed by message class)
inline char *create_content_buffer(void) {
m_content_buf.resize(m_content_length);
return m_content_buf.get();
}
/// resets payload content to match the value of a string
inline void set_content(const std::string& content) {
set_content_length(content.size());
create_content_buffer();
memcpy(m_content_buf.get(), content.c_str(), content.size());
}
/// clears payload content buffer
inline void clear_content(void) {
set_content_length(0);
create_content_buffer();
delete_value(m_headers, HEADER_CONTENT_TYPE);
}
/// sets the content type for the message payload
inline void set_content_type(const std::string& type) {
change_value(m_headers, HEADER_CONTENT_TYPE, type);
}
/// adds a value for the HTTP header named key
inline void add_header(const std::string& key, const std::string& value) {
m_headers.insert(std::make_pair(key, value));
}
/// changes the value for the HTTP header named key
inline void change_header(const std::string& key, const std::string& value) {
change_value(m_headers, key, value);
}
/// removes all values for the HTTP header named key
inline void delete_header(const std::string& key) {
delete_value(m_headers, key);
}
/// returns true if the HTTP connection may be kept alive
inline bool check_keep_alive(void) const {
return (get_header(HEADER_CONNECTION) != "close"
&& (get_version_major() > 1
|| (get_version_major() >= 1 && get_version_minor() >= 1)) );
}
/**
* initializes a vector of write buffers with the HTTP message information
*
* @param write_buffers vector of write buffers to initialize
* @param keep_alive true if the connection should be kept alive
* @param using_chunks true if the payload content will be sent in chunks
*/
inline void prepare_buffers_for_send(write_buffers_t& write_buffers,
const bool keep_alive,
const bool using_chunks)
{
// update message headers
prepare_headers_for_send(keep_alive, using_chunks);
// add first message line
write_buffers.push_back(boost::asio::buffer(get_first_line()));
write_buffers.push_back(boost::asio::buffer(STRING_CRLF));
// append cookie headers (if any)
append_cookie_headers();
// append HTTP headers
append_headers(write_buffers);
}
/**
* sends the message over a TCP connection (blocks until finished)
*
* @param tcp_conn TCP connection to use
* @param ec contains error code if the send fails
* @param headers_only if true then only HTTP headers are sent
*
* @return std::size_t number of bytes written to the connection
*/
std::size_t send(tcp::connection& tcp_conn,
boost::system::error_code& ec,
bool headers_only = false);
/**
* receives a new message from a TCP connection (blocks until finished)
*
* @param tcp_conn TCP connection to use
* @param ec contains error code if the receive fails
* @param http_parser http parser object to use
*
* @return std::size_t number of bytes read from the connection
*/
std::size_t receive(tcp::connection& tcp_conn,
boost::system::error_code& ec,
parser& http_parser);
/**
* receives a new message from a TCP connection (blocks until finished)
*
* @param tcp_conn TCP connection to use
* @param ec contains error code if the receive fails
* @param headers_only if true then only HTTP headers are received
* @param max_content_length maximum number of content bytes received
*
* @return std::size_t number of bytes read from the connection
*/
std::size_t receive(tcp::connection& tcp_conn,
boost::system::error_code& ec,
bool headers_only = false,
std::size_t max_content_length = static_cast(-1));
/**
* writes the message to a std::ostream (blocks until finished)
*
* @param out std::ostream to use
* @param ec contains error code if the write fails
* @param headers_only if true then only HTTP headers are written
*
* @return std::size_t number of bytes written to the connection
*/
std::size_t write(std::ostream& out,
boost::system::error_code& ec,
bool headers_only = false);
/**
* reads a new message from a std::istream (blocks until finished)
*
* @param in std::istream to use
* @param ec contains error code if the read fails
* @param http_parser http parser object to use
*
* @return std::size_t number of bytes read from the connection
*/
std::size_t read(std::istream& in,
boost::system::error_code& ec,
parser& http_parser);
/**
* reads a new message from a std::istream (blocks until finished)
*
* @param in std::istream to use
* @param ec contains error code if the read fails
* @param headers_only if true then only HTTP headers are read
* @param max_content_length maximum number of content bytes received
*
* @return std::size_t number of bytes read from the connection
*/
std::size_t read(std::istream& in,
boost::system::error_code& ec,
bool headers_only = false,
std::size_t max_content_length = static_cast(-1));
/**
* pieces together all the received chunks
*/
void concatenate_chunks(void);
protected:
/// a simple helper class used to manage a fixed-size payload content buffer
class content_buffer_t {
public:
/// simple destructor
~content_buffer_t() {}
/// default constructor
content_buffer_t() : m_buf(), m_len(0), m_empty(0), m_ptr(&m_empty) {}
/// copy constructor
content_buffer_t(const content_buffer_t& buf)
: m_buf(), m_len(0), m_empty(0), m_ptr(&m_empty)
{
if (buf.size()) {
resize(buf.size());
memcpy(get(), buf.get(), buf.size());
}
}
/// assignment operator
content_buffer_t& operator=(const content_buffer_t& buf) {
if (buf.size()) {
resize(buf.size());
memcpy(get(), buf.get(), buf.size());
} else {
clear();
}
return *this;
}
/// returns true if buffer is empty
inline bool is_empty() const { return m_len == 0; }
/// returns size in bytes
inline std::size_t size() const { return m_len; }
/// returns const pointer to data
inline const char *get() const { return m_ptr; }
/// returns mutable pointer to data
inline char *get() { return m_ptr; }
/// changes the size of the content buffer
inline void resize(std::size_t len) {
m_len = len;
if (len == 0) {
m_buf.reset();
m_ptr = &m_empty;
} else {
m_buf.reset(new char[len+1]);
m_buf[len] = '\0';
m_ptr = m_buf.get();
}
}
/// clears the content buffer
inline void clear() { resize(0); }
private:
boost::scoped_array m_buf;
std::size_t m_len;
char m_empty;
char *m_ptr;
};
/**
* prepares HTTP headers for a send operation
*
* @param keep_alive true if the connection should be kept alive
* @param using_chunks true if the payload content will be sent in chunks
*/
inline void prepare_headers_for_send(const bool keep_alive,
const bool using_chunks)
{
change_header(HEADER_CONNECTION, (keep_alive ? "Keep-Alive" : "close") );
if (using_chunks) {
if (get_chunks_supported())
change_header(HEADER_TRANSFER_ENCODING, "chunked");
} else if (! m_do_not_send_content_length) {
change_header(HEADER_CONTENT_LENGTH, boost::lexical_cast(get_content_length()));
}
}
/**
* appends the message's HTTP headers to a vector of write buffers
*
* @param write_buffers the buffers to append HTTP headers into
*/
inline void append_headers(write_buffers_t& write_buffers) {
// add HTTP headers
for (ihash_multimap::const_iterator i = m_headers.begin(); i != m_headers.end(); ++i) {
write_buffers.push_back(boost::asio::buffer(i->first));
write_buffers.push_back(boost::asio::buffer(HEADER_NAME_VALUE_DELIMITER));
write_buffers.push_back(boost::asio::buffer(i->second));
write_buffers.push_back(boost::asio::buffer(STRING_CRLF));
}
// add an extra CRLF to end HTTP headers
write_buffers.push_back(boost::asio::buffer(STRING_CRLF));
}
/// appends HTTP headers for any cookies defined by the http::message
virtual void append_cookie_headers(void) {}
/**
* Returns the first value in a dictionary if key is found; or an empty
* string if no values are found
*
* @param dict the dictionary to search for key
* @param key the key to search for
* @return value if found; empty string if not
*/
template
inline static const std::string& get_value(const DictionaryType& dict,
const std::string& key)
{
typename DictionaryType::const_iterator i = dict.find(key);
return ( (i==dict.end()) ? STRING_EMPTY : i->second );
}
/**
* Changes the value for a dictionary key. Adds the key if it does not
* already exist. If multiple values exist for the key, they will be
* removed and only the new value will remain.
*
* @param dict the dictionary object to update
* @param key the key to change the value for
* @param value the value to assign to the key
*/
template
inline static void change_value(DictionaryType& dict,
const std::string& key, const std::string& value)
{
// retrieve all current values for key
std::pair
result_pair = dict.equal_range(key);
if (result_pair.first == dict.end()) {
// no values exist -> add a new key
dict.insert(std::make_pair(key, value));
} else {
// set the first value found for the key to the new one
result_pair.first->second = value;
// remove any remaining values
typename DictionaryType::iterator i;
++(result_pair.first);
while (result_pair.first != result_pair.second) {
i = result_pair.first;
++(result_pair.first);
dict.erase(i);
}
}
}
/**
* Deletes all values for a key
*
* @param dict the dictionary object to update
* @param key the key to delete
*/
template
inline static void delete_value(DictionaryType& dict,
const std::string& key)
{
std::pair
result_pair = dict.equal_range(key);
if (result_pair.first != dict.end())
dict.erase(result_pair.first, result_pair.second);
}
/// erases the string containing the first line for the HTTP message
/// (it will be updated the next time get_first_line() is called)
inline void clear_first_line(void) const {
if (! m_first_line.empty())
m_first_line.clear();
}
/// updates the string containing the first line for the HTTP message
virtual void update_first_line(void) const = 0;
/// first line sent in an HTTP message
/// (i.e. "GET / HTTP/1.1" for request, or "HTTP/1.1 200 OK" for response)
mutable std::string m_first_line;
private:
/// Regex used to check for the "chunked" transfer encoding header
static const boost::regex REGEX_ICASE_CHUNKED;
/// True if the HTTP message is valid
bool m_is_valid;
/// whether the message body is chunked
bool m_is_chunked;
/// true if chunked transfer encodings are supported
bool m_chunks_supported;
/// if true, the content length will not be sent in the HTTP headers
bool m_do_not_send_content_length;
/// IP address of the remote endpoint
boost::asio::ip::address m_remote_ip;
/// HTTP major version number
boost::uint16_t m_version_major;
/// HTTP major version number
boost::uint16_t m_version_minor;
/// the length of the payload content (in bytes)
size_t m_content_length;
/// the payload content, if any was sent with the message
content_buffer_t m_content_buf;
/// buffers for holding chunked data
chunk_cache_t m_chunk_cache;
/// HTTP message headers
ihash_multimap m_headers;
/// HTTP cookie parameters parsed from the headers
ihash_multimap m_cookie_params;
/// message data integrity status
data_status_t m_status;
/// missing packet indicator
bool m_has_missing_packets;
/// indicates missing packets in the middle of the data stream
bool m_has_data_after_missing;
};
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/request_reader.hpp 0000644 0003720 0000144 00000010225 12420270445 023032 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_REQUEST_READER_HEADER__
#define __PION_HTTP_REQUEST_READER_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// request_reader: asynchronously reads and parses HTTP requests
///
class request_reader :
public http::reader,
public boost::enable_shared_from_this
{
public:
/// function called after the HTTP message has been parsed
typedef boost::function3 finished_handler_t;
// default destructor
virtual ~request_reader() {}
/**
* creates new request_reader objects
*
* @param tcp_conn TCP connection containing a new message to parse
* @param handler function called after the message has been parsed
*/
static inline boost::shared_ptr
create(tcp::connection_ptr& tcp_conn, finished_handler_t handler)
{
return boost::shared_ptr
(new request_reader(tcp_conn, handler));
}
/// sets a function to be called after HTTP headers have been parsed
inline void set_headers_parsed_callback(finished_handler_t& h) { m_parsed_headers = h; }
protected:
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection containing a new message to parse
* @param handler function called after the message has been parsed
*/
request_reader(tcp::connection_ptr& tcp_conn, finished_handler_t handler)
: http::reader(true, tcp_conn), m_http_msg(new http::request),
m_finished(handler)
{
m_http_msg->set_remote_ip(tcp_conn->get_remote_ip());
set_logger(PION_GET_LOGGER("pion.http.request_reader"));
}
/// Reads more bytes from the TCP connection
virtual void read_bytes(void) {
get_connection()->async_read_some(boost::bind(&request_reader::consume_bytes,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
/// Called after we have finished parsing the HTTP message headers
virtual void finished_parsing_headers(const boost::system::error_code& ec) {
// call the finished headers handler with the HTTP message
if (m_parsed_headers) m_parsed_headers(m_http_msg, get_connection(), ec);
}
/// Called after we have finished reading/parsing the HTTP message
virtual void finished_reading(const boost::system::error_code& ec) {
// call the finished handler with the finished HTTP message
if (m_finished) m_finished(m_http_msg, get_connection(), ec);
}
/// Returns a reference to the HTTP message being parsed
virtual http::message& get_message(void) { return *m_http_msg; }
/// The new HTTP message container being created
http::request_ptr m_http_msg;
/// function called after the HTTP message has been parsed
finished_handler_t m_finished;
/// function called after the HTTP message headers have been parsed
finished_handler_t m_parsed_headers;
};
/// data type for a request_reader pointer
typedef boost::shared_ptr request_reader_ptr;
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/basic_auth.hpp 0000644 0003720 0000144 00000006543 12420270445 022132 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_BASIC_AUTH_HEADER__
#define __PION_HTTP_BASIC_AUTH_HEADER__
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// basic_auth: a base class for handling HTTP Authentication and session management
/// in accordance with RFC 2617 http://tools.ietf.org/html/rfc2617
///
class PION_API basic_auth :
public http::auth
{
public:
/// default constructor
basic_auth(user_manager_ptr userManager, const std::string& realm="PION");
/// virtual destructor
virtual ~basic_auth() {}
/**
* attempts to validate authentication of a new HTTP request.
* If request valid, pointer to user identity object (if any) will be preserved in
* the request and return "true".
* If request not authenticated, appropriate response is sent over tcp_conn
* and return "false";
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*
* @return true if request valid and user identity inserted into request
*/
virtual bool handle_request(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn);
/**
* sets a configuration option
* Valid options:
* - "domain" - name of authentication domain
*
* @param name the name of the option to change
* @param value the value of the option
*/
virtual void set_option(const std::string& name, const std::string& value);
protected:
/**
* used to send responses when access to resource is not authorized
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*/
void handle_unauthorized(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn);
/**
* extracts base64 user credentials from authorization string
*
* @param authorization value of the HEADER_AUTHORIZATION
*/
static bool parse_authorization(std::string const &authorization, std::string &credentials);
/**
* parse base64 credentials and extract username/password
*/
static bool parse_credentials(std::string const &credentials, std::string &username, std::string &password);
private:
/// number of seconds after which entires in the user cache will be expired
static const unsigned int CACHE_EXPIRATION;
/// authentication realm ( "PION" by default)
std::string m_realm;
/// time of the last cache clean up
boost::posix_time::ptime m_cache_cleanup_time;
/// cache of users that are currently active
user_cache_type m_user_cache;
/// mutex used to protect access to the user cache
mutable boost::mutex m_cache_mutex;
};
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/response.hpp 0000644 0003720 0000144 00000021026 12420270445 021657 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_RESPONSE_HEADER__
#define __PION_HTTP_RESPONSE_HEADER__
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// response: container for HTTP response information
///
class response
: public http::message
{
public:
/**
* constructs a new response object for a particular request
*
* @param http_request_ptr the request that this is responding to
*/
response(const http::request& http_request_ptr)
: m_status_code(RESPONSE_CODE_OK),
m_status_message(RESPONSE_MESSAGE_OK)
{
update_request_info(http_request_ptr);
}
/**
* constructs a new response object for a particular request method
*
* @param request_method the method used by the HTTP request we are responding to
*/
response(const std::string& request_method)
: m_status_code(RESPONSE_CODE_OK), m_status_message(RESPONSE_MESSAGE_OK),
m_request_method(request_method)
{}
/// copy constructor
response(const response& http_response)
: message(http_response),
m_status_code(http_response.m_status_code),
m_status_message(http_response.m_status_message),
m_request_method(http_response.m_request_method)
{}
/// default constructor: you are strongly encouraged to use one of the other
/// constructors, since response parsing is influenced by the request method
response(void)
: m_status_code(RESPONSE_CODE_OK),
m_status_message(RESPONSE_MESSAGE_OK)
{}
/// virtual destructor
virtual ~response() {}
/// clears all response data
virtual void clear(void) {
http::message::clear();
m_status_code = RESPONSE_CODE_OK;
m_status_message = RESPONSE_MESSAGE_OK;
m_request_method.clear();
}
/// the content length may be implied for certain types of responses
virtual bool is_content_length_implied(void) const {
return (m_request_method == REQUEST_METHOD_HEAD // HEAD responses have no content
|| (m_status_code >= 100 && m_status_code <= 199) // 1xx responses have no content
|| m_status_code == 204 || m_status_code == 205 // no content & reset content responses
|| m_status_code == 304 // not modified responses have no content
);
}
/**
* Updates HTTP request information for the response object (use
* this if the response cannot be constructed using the request)
*
* @param http_request the request that this is responding to
*/
inline void update_request_info(const http::request& http_request) {
m_request_method = http_request.get_method();
if (http_request.get_version_major() == 1 && http_request.get_version_minor() >= 1) {
set_chunks_supported(true);
} else if (http_request.get_version_major() == 0) {
// the request is likely HTTP 0.9 "simple-request", so expect the response to contain no header and no version info
set_status_code(0U);
set_status_message("");
set_version_major(0);
set_version_minor(0);
}
}
/// sets the HTTP response status code
inline void set_status_code(unsigned int n) {
m_status_code = n;
clear_first_line();
}
/// sets the HTTP response status message
inline void set_status_message(const std::string& msg) {
m_status_message = msg;
clear_first_line();
}
/// returns the HTTP response status code
inline unsigned int get_status_code(void) const { return m_status_code; }
/// returns the HTTP response status message
inline const std::string& get_status_message(void) const { return m_status_message; }
/**
* sets a cookie by adding a Set-Cookie header (see RFC 2109)
* the cookie will be discarded by the user-agent when it closes
*
* @param name the name of the cookie
* @param value the value of the cookie
*/
inline void set_cookie(const std::string& name, const std::string& value) {
std::string set_cookie_header(make_set_cookie_header(name, value, "/"));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/**
* sets a cookie by adding a Set-Cookie header (see RFC 2109)
* the cookie will be discarded by the user-agent when it closes
*
* @param name the name of the cookie
* @param value the value of the cookie
* @param path the path of the cookie
*/
inline void set_cookie(const std::string& name, const std::string& value,
const std::string& path)
{
std::string set_cookie_header(make_set_cookie_header(name, value, path));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/**
* sets a cookie by adding a Set-Cookie header (see RFC 2109)
*
* @param name the name of the cookie
* @param value the value of the cookie
* @param path the path of the cookie
* @param max_age the life of the cookie, in seconds (0 = discard)
*/
inline void set_cookie(const std::string& name, const std::string& value,
const std::string& path, const unsigned long max_age)
{
std::string set_cookie_header(make_set_cookie_header(name, value, path, true, max_age));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/**
* sets a cookie by adding a Set-Cookie header (see RFC 2109)
*
* @param name the name of the cookie
* @param value the value of the cookie
* @param max_age the life of the cookie, in seconds (0 = discard)
*/
inline void set_cookie(const std::string& name, const std::string& value,
const unsigned long max_age)
{
std::string set_cookie_header(make_set_cookie_header(name, value, "/", true, max_age));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/// deletes cookie called name by adding a Set-Cookie header (cookie has no path)
inline void delete_cookie(const std::string& name) {
std::string set_cookie_header(make_set_cookie_header(name, "", "/", true, 0));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/// deletes cookie called name by adding a Set-Cookie header (cookie has a path)
inline void delete_cookie(const std::string& name, const std::string& path) {
std::string set_cookie_header(make_set_cookie_header(name, "", path, true, 0));
add_header(HEADER_SET_COOKIE, set_cookie_header);
}
/// sets the time that the response was last modified (Last-Modified)
inline void set_last_modified(const unsigned long t) {
change_header(HEADER_LAST_MODIFIED, get_date_string(t));
}
protected:
/// updates the string containing the first line for the HTTP message
virtual void update_first_line(void) const {
// start out with the HTTP version
m_first_line = get_version_string();
m_first_line += ' ';
// append the response status code
m_first_line += boost::lexical_cast(m_status_code);
m_first_line += ' ';
// append the response status message
m_first_line += m_status_message;
}
/// appends HTTP headers for any cookies defined by the http::message
virtual void append_cookie_headers(void) {
for (ihash_multimap::const_iterator i = get_cookies().begin(); i != get_cookies().end(); ++i) {
set_cookie(i->first, i->second);
}
}
private:
/// The HTTP response status code
unsigned int m_status_code;
/// The HTTP response status message
std::string m_status_message;
/// HTTP method used by the request
std::string m_request_method;
};
/// data type for a HTTP response pointer
typedef boost::shared_ptr response_ptr;
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/plugin_service.hpp 0000644 0003720 0000144 00000007554 12420270445 023051 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_PLUGIN_SERVICE_HEADER__
#define __PION_PLUGIN_SERVICE_HEADER__
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// plugin_service: interface class for web services
///
class plugin_service :
private boost::noncopyable
{
public:
/// default constructor
plugin_service(void) {}
/// virtual destructor
virtual ~plugin_service() {}
/**
* attempts to handle a new HTTP request
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*/
virtual void operator()(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn) = 0;
/**
* sets a configuration option
*
* @param name the name of the option to change
* @param value the value of the option
*/
virtual void set_option(const std::string& name, const std::string& value) {
BOOST_THROW_EXCEPTION( error::bad_arg() << error::errinfo_arg_name(name) );
}
/// called when the web service's server is starting
virtual void start(void) {}
/// called when the web service's server is stopping
virtual void stop(void) {}
/// sets the URI stem or resource that is bound to the web service
inline void set_resource(const std::string& str) { m_resource = str; }
/// returns the URI stem or resource that is bound to the web service
inline const std::string& get_resource(void) const { return m_resource; }
/// returns the path to the resource requested, relative to the web service's location
inline std::string get_relative_resource(const std::string& resource_requested) const {
if (resource_requested.size() <= get_resource().size()) {
// either the request matches the web service's resource path (a directory)
// or the request does not match (should never happen)
return std::string();
}
// strip the web service's resource path plus the slash after it
return algorithm::url_decode(resource_requested.substr(get_resource().size() + 1));
}
private:
/// the URI stem or resource that is bound to the web service
std::string m_resource;
};
//
// The following symbols must be defined for any web service that you would
// like to be able to load dynamically using the http::server::load_service()
// function. These are not required for any services that you only want to link
// directly into your programs.
//
// Make sure that you replace "MyPluginName" with the name of your derived class.
// This name must also match the name of the object file (excluding the
// extension). These symbols must be linked into your service's object file,
// not included in any headers that it may use (declarations are OK in headers
// but not the definitions).
//
// The "pion_create" function is used to create new instances of your service.
// The "pion_destroy" function is used to destroy instances of your service.
//
// extern "C" MyPluginName *pion_create_MyPluginName(void) {
// return new MyPluginName;
// }
//
// extern "C" void pion_destroy_MyPluginName(MyPluginName *service_ptr) {
// delete service_ptr;
// }
//
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/response_writer.hpp 0000644 0003720 0000144 00000016445 12420270445 023264 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_RESPONSE_WRITER_HEADER__
#define __PION_HTTP_RESPONSE_WRITER_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// response_writer: used to asynchronously send HTTP responses
///
class PION_API response_writer :
public http::writer,
public boost::enable_shared_from_this
{
public:
/// default destructor
virtual ~response_writer() {}
/**
* creates new response_writer objects
*
* @param tcp_conn TCP connection used to send the response
* @param http_response pointer to the response that will be sent
* @param handler function called after the response has been sent
*
* @return boost::shared_ptr shared pointer to
* the new writer object that was created
*/
static inline boost::shared_ptr create(tcp::connection_ptr& tcp_conn,
http::response_ptr& http_response_ptr,
finished_handler_t handler = finished_handler_t())
{
return boost::shared_ptr(new response_writer(tcp_conn, http_response_ptr, handler));
}
/**
* creates new response_writer objects
*
* @param tcp_conn TCP connection used to send the response
* @param http_request the request we are responding to
* @param handler function called after the request has been sent
*
* @return boost::shared_ptr shared pointer to
* the new writer object that was created
*/
static inline boost::shared_ptr create(tcp::connection_ptr& tcp_conn,
const http::request& http_request,
finished_handler_t handler = finished_handler_t())
{
return boost::shared_ptr(new response_writer(tcp_conn, http_request, handler));
}
/// returns a non-const reference to the response that will be sent
inline http::response& get_response(void) { return *m_http_response; }
protected:
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection used to send the response
* @param http_response pointer to the response that will be sent
* @param handler function called after the request has been sent
*/
response_writer(tcp::connection_ptr& tcp_conn, http::response_ptr& http_response_ptr,
finished_handler_t handler)
: http::writer(tcp_conn, handler), m_http_response(http_response_ptr)
{
set_logger(PION_GET_LOGGER("pion.http.response_writer"));
// tell the http::writer base class whether or not the client supports chunks
supports_chunked_messages(m_http_response->get_chunks_supported());
// check if we should initialize the payload content using
// the response's content buffer
if (m_http_response->get_content_length() > 0
&& m_http_response->get_content() != NULL
&& m_http_response->get_content()[0] != '\0')
{
write_no_copy(m_http_response->get_content(), m_http_response->get_content_length());
}
}
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection used to send the response
* @param http_request the request we are responding to
* @param handler function called after the request has been sent
*/
response_writer(tcp::connection_ptr& tcp_conn, const http::request& http_request,
finished_handler_t handler)
: http::writer(tcp_conn, handler), m_http_response(new http::response(http_request))
{
set_logger(PION_GET_LOGGER("pion.http.response_writer"));
// tell the http::writer base class whether or not the client supports chunks
supports_chunked_messages(m_http_response->get_chunks_supported());
}
/**
* initializes a vector of write buffers with the HTTP message information
*
* @param write_buffers vector of write buffers to initialize
*/
virtual void prepare_buffers_for_send(http::message::write_buffers_t& write_buffers) {
if (get_content_length() > 0)
m_http_response->set_content_length(get_content_length());
m_http_response->prepare_buffers_for_send(write_buffers,
get_connection()->get_keep_alive(),
sending_chunked_message());
}
/// returns a function bound to http::writer::handle_write()
virtual write_handler_t bind_to_write_handler(void) {
return boost::bind(&response_writer::handle_write, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred);
}
/**
* called after the response is sent
*
* @param write_error error status from the last write operation
* @param bytes_written number of bytes sent by the last write operation
*/
virtual void handle_write(const boost::system::error_code& write_error,
std::size_t bytes_written)
{
logger log_ptr(get_logger());
if (!write_error) {
// response sent OK
if (sending_chunked_message()) {
PION_LOG_DEBUG(log_ptr, "Sent HTTP response chunk of " << bytes_written << " bytes");
} else {
PION_LOG_DEBUG(log_ptr, "Sent HTTP response of " << bytes_written << " bytes ("
<< (get_connection()->get_keep_alive() ? "keeping alive)" : "closing)"));
}
}
finished_writing(write_error);
}
private:
/// the response that will be sent
http::response_ptr m_http_response;
/// the initial HTTP response header line
std::string m_response_line;
};
/// data type for a response_writer pointer
typedef boost::shared_ptr response_writer_ptr;
/// override operator<< for convenience
template
const response_writer_ptr& operator<<(const response_writer_ptr& writer, const T& data) {
writer->write(data);
return writer;
}
inline response_writer_ptr& operator<<(response_writer_ptr& writer, std::ostream& (*iomanip)(std::ostream&)) {
writer->write(iomanip);
return writer;
}
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/reader.hpp 0000644 0003720 0000144 00000006673 12420270445 021276 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_READER_HEADER__
#define __PION_HTTP_READER_HEADER__
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// reader: asynchronously reads and parses HTTP messages
///
class PION_API reader :
public http::parser
{
public:
// default destructor
virtual ~reader() {}
/// Incrementally reads & parses the HTTP message
void receive(void);
/// returns a shared pointer to the TCP connection
inline tcp::connection_ptr& get_connection(void) { return m_tcp_conn; }
/// sets the maximum number of seconds for read operations
inline void set_timeout(boost::uint32_t seconds) { m_read_timeout = seconds; }
protected:
/**
* protected constructor: only derived classes may create objects
*
* @param is_request if true, the message is parsed as an HTTP request;
* if false, the message is parsed as an HTTP response
* @param tcp_conn TCP connection containing a new message to parse
*/
reader(const bool is_request, tcp::connection_ptr& tcp_conn)
: http::parser(is_request), m_tcp_conn(tcp_conn),
m_read_timeout(DEFAULT_READ_TIMEOUT)
{}
/**
* Consumes bytes that have been read using an HTTP parser
*
* @param read_error error status from the last read operation
* @param bytes_read number of bytes consumed by the last read operation
*/
void consume_bytes(const boost::system::error_code& read_error,
std::size_t bytes_read);
/// Consumes bytes that have been read using an HTTP parser
void consume_bytes(void);
/// Reads more bytes from the TCP connection
virtual void read_bytes(void) = 0;
/// Called after we have finished reading/parsing the HTTP message
virtual void finished_reading(const boost::system::error_code& ec) = 0;
/// Returns a reference to the HTTP message being parsed
virtual http::message& get_message(void) = 0;
private:
/// reads more bytes for parsing, with timeout support
void read_bytes_with_timeout(void);
/**
* Handles errors that occur during read operations
*
* @param read_error error status from the last read operation
*/
void handle_read_error(const boost::system::error_code& read_error);
/// default maximum number of seconds for read operations
static const boost::uint32_t DEFAULT_READ_TIMEOUT;
/// The HTTP connection that has a new HTTP message to parse
tcp::connection_ptr m_tcp_conn;
/// pointer to a tcp::timer object if read timeouts are enabled
tcp::timer_ptr m_timer_ptr;
/// maximum number of seconds for read operations
boost::uint32_t m_read_timeout;
};
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/cookie_auth.hpp 0000644 0003720 0000144 00000014546 12420270445 022324 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_COOKIE_AUTH_HEADER__
#define __PION_HTTP_COOKIE_AUTH_HEADER__
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// cookie_auth: handles HTTP authentication and session management in
/// accordance with RFC 2617 (http://tools.ietf.org/html/rfc2617 ) using cookies.
///
class PION_API cookie_auth :
public http::auth
{
public:
/**
* default constructor
*
* @param userManager
* @param login - URL resource for login request. Typical login request has format:
* http://website/login?user="username"&pass="password"&url="redirection_url"
* @param logout - URL resource for logout request. Typical logout request has format:
* http://website/logout?url="redirection_url"
* @param redirect - if not empty, URL for redirection in case of authentication failure
* if empty - send code 401 on authentication failure
*/
cookie_auth(user_manager_ptr userManager,
const std::string& login="/login",
const std::string& logout="/logout",
const std::string& redirect="");
/// virtual destructor
virtual ~cookie_auth() {}
/**
* attempts to validate authentication of a new HTTP request.
* If request valid, pointer to user identity object (if any) will be preserved in
* the request and return "true".
* If request not authenticated, appropriate response is sent over tcp_conn
* and return "false";
*
* Note: if request matches "login" resource, then login sequences attempted.
* If "name" and "pass" attributes match user definition, a random cookie is created
* and associated with given user session. If request contains "url" attribute,
* then page redirection response returned. Otherwise - empty 204 response.
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*
* @return true if request valid and user identity inserted into request
*/
virtual bool handle_request(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn);
/**
* sets a configuration option
* Valid options:
* - "login" - URL resource for login request. Typical login request has format:
* http://website/login?user="username"&pass="password"&url="redirection_url"
* - "logout" - URL resource for logout request. Typical logout request has format:
* http://website/logout?url="redirection_url"
* - "redirect" - if not empty, URL for redirection in case of authentication failure
* if empty - send code 401 on authentication failure
*
* @param name the name of the option to change
* @param value the value of the option
*/
virtual void set_option(const std::string& name, const std::string& value);
protected:
/**
* check if given request is a login/logout and process it
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*
* @return true if it was a login/logout request and no future processing required.
*/
bool process_login(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn);
/**
* used to send responses when access to resource is not authorized
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*/
void handle_unauthorized(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn);
/**
* used to send redirection responses
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*/
void handle_redirection(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn,
const std::string &redirection_url, const std::string &new_cookie="", bool delete_cookie=false);
/**
* used to send OK responses with new cookie
*
* @param http_request_ptr the new HTTP request to handle
* @param tcp_conn the TCP connection that has the new request
*/
void handle_ok(http::request_ptr& http_request_ptr, tcp::connection_ptr& tcp_conn,
const std::string &new_cookie="", bool delete_cookie=false);
/**
* Cache expiration cleanup. (Call it periodically)
*/
void expire_cache(const boost::posix_time::ptime &time_now);
private:
/// number of seconds after which entries in the user cache will be expired
static const unsigned int CACHE_EXPIRATION;
/// number of random bytes to use for cookie generation
static const unsigned int RANDOM_COOKIE_BYTES;
/// name of cookie used for authentication
static const std::string AUTH_COOKIE_NAME;
/// value of "login" resource
std::string m_login;
/// value of "logout" resource
std::string m_logout;
/// value of "redirection" resource
std::string m_redirect;
/// random number generator used for cookie generation
boost::mt19937 m_random_gen;
/// random number range used for cookie generation
boost::uniform_int<> m_random_range;
/// random dice that uses m_random_gen to produce ints within m_random_range
boost::variate_generator > m_random_die;
/// time of the last cache clean up
boost::posix_time::ptime m_cache_cleanup_time;
/// cache of users that are currently active
user_cache_type m_user_cache;
/// mutex used to protect access to the user cache
mutable boost::mutex m_cache_mutex;
};
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/writer.hpp 0000644 0003720 0000144 00000033564 12420270445 021347 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_WRITER_HEADER__
#define __PION_HTTP_WRITER_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// writer: used to asynchronously send HTTP messages
///
class PION_API writer :
private boost::noncopyable
{
protected:
/// function called after the HTTP message has been sent
typedef boost::function1 finished_handler_t;
/// data type for a function that handles write operations
typedef boost::function2 write_handler_t;
/**
* protected constructor: only derived classes may create objects
*
* @param tcp_conn TCP connection used to send the message
* @param handler function called after the request has been sent
*/
writer(tcp::connection_ptr& tcp_conn, finished_handler_t handler)
: m_logger(PION_GET_LOGGER("pion.http.writer")),
m_tcp_conn(tcp_conn), m_content_length(0), m_stream_is_empty(true),
m_client_supports_chunks(true), m_sending_chunks(false),
m_sent_headers(false), m_finished(handler)
{}
/**
* called after the message is sent
*
* @param write_error error status from the last write operation
* @param bytes_written number of bytes sent by the last write operation
*/
virtual void handle_write(const boost::system::error_code& write_error,
std::size_t bytes_written) = 0;
/**
* initializes a vector of write buffers with the HTTP message information
*
* @param write_buffers vector of write buffers to initialize
*/
virtual void prepare_buffers_for_send(http::message::write_buffers_t& write_buffers) = 0;
/// returns a function bound to writer::handle_write()
virtual write_handler_t bind_to_write_handler(void) = 0;
/// called after we have finished sending the HTTP message
inline void finished_writing(const boost::system::error_code& ec) {
if (m_finished) m_finished(ec);
}
public:
/// default destructor
virtual ~writer() {}
/// clears out all of the memory buffers used to cache payload content data
inline void clear(void) {
m_content_buffers.clear();
m_binary_cache.clear();
m_text_cache.clear();
m_content_stream.str("");
m_stream_is_empty = true;
m_content_length = 0;
}
/**
* write text (non-binary) payload content
*
* @param data the data to append to the payload content
*/
template
inline void write(const T& data) {
m_content_stream << data;
if (m_stream_is_empty) m_stream_is_empty = false;
}
inline void write(std::ostream& (*iomanip)(std::ostream&)) {
m_content_stream << iomanip;
if (m_stream_is_empty) m_stream_is_empty = false;
}
/**
* write binary payload content
*
* @param data points to the binary data to append to the payload content
* @param length the length, in bytes, of the binary data
*/
inline void write(const void *data, size_t length) {
if (length != 0) {
flush_content_stream();
m_content_buffers.push_back(m_binary_cache.add(data, length));
m_content_length += length;
}
}
/**
* write text (non-binary) payload content; the data written is not
* copied, and therefore must persist until the message has finished
* sending
*
* @param data the data to append to the payload content
*/
inline void write_no_copy(const std::string& data) {
if (! data.empty()) {
flush_content_stream();
m_content_buffers.push_back(boost::asio::buffer(data));
m_content_length += data.size();
}
}
/**
* write binary payload content; the data written is not copied, and
* therefore must persist until the message has finished sending
*
* @param data points to the binary data to append to the payload content
* @param length the length, in bytes, of the binary data
*/
inline void write_no_copy(void *data, size_t length) {
if (length > 0) {
flush_content_stream();
m_content_buffers.push_back(boost::asio::buffer(data, length));
m_content_length += length;
}
}
/**
* Sends all data buffered as a single HTTP message (without chunking).
* Following a call to this function, it is not thread safe to use your
* reference to the writer object.
*/
inline void send(void) {
send_more_data(false, bind_to_write_handler());
}
/**
* Sends all data buffered as a single HTTP message (without chunking).
* Following a call to this function, it is not thread safe to use your
* reference to the writer object until the send_handler has been called.
*
* @param send_handler function that is called after the message has been
* sent to the client. Your callback function must end
* the connection by calling connection::finish().
*/
template
inline void send(SendHandler send_handler) {
send_more_data(false, send_handler);
}
/**
* Sends all data buffered as a single HTTP chunk. Following a call to this
* function, it is not thread safe to use your reference to the writer
* object until the send_handler has been called.
*
* @param send_handler function that is called after the chunk has been sent
* to the client. Your callback function must end by
* calling one of send_chunk() or send_final_chunk(). Also,
* be sure to clear() the writer before writing data to it.
*/
template
inline void send_chunk(SendHandler send_handler) {
m_sending_chunks = true;
if (!supports_chunked_messages()) {
// sending data in chunks, but the client does not support chunking;
// make sure that the connection will be closed when we are all done
m_tcp_conn->set_lifecycle(tcp::connection::LIFECYCLE_CLOSE);
}
// send more data
send_more_data(false, send_handler);
}
/**
* Sends all data buffered (if any) and also sends the final HTTP chunk.
* This function (either overloaded version) must be called following any
* calls to send_chunk().
* Following a call to this function, it is not thread safe to use your
* reference to the writer object until the send_handler has been called.
*
* @param send_handler function that is called after the message has been
* sent to the client. Your callback function must end
* the connection by calling connection::finish().
*/
template
inline void send_final_chunk(SendHandler send_handler) {
m_sending_chunks = true;
send_more_data(true, send_handler);
}
/**
* Sends all data buffered (if any) and also sends the final HTTP chunk.
* This function (either overloaded version) must be called following any
* calls to send_chunk().
* Following a call to this function, it is not thread safe to use your
* reference to the writer object.
*/
inline void send_final_chunk(void) {
m_sending_chunks = true;
send_more_data(true, bind_to_write_handler());
}
/// returns a shared pointer to the TCP connection
inline tcp::connection_ptr& get_connection(void) { return m_tcp_conn; }
/// returns the length of the payload content (in bytes)
inline size_t get_content_length(void) const { return m_content_length; }
/// sets whether or not the client supports chunked messages
inline void supports_chunked_messages(bool b) { m_client_supports_chunks = b; }
/// returns true if the client supports chunked messages
inline bool supports_chunked_messages() const { return m_client_supports_chunks; }
/// returns true if we are sending a chunked message to the client
inline bool sending_chunked_message() const { return m_sending_chunks; }
/// sets the logger to be used
inline void set_logger(logger log_ptr) { m_logger = log_ptr; }
/// returns the logger currently in use
inline logger get_logger(void) { return m_logger; }
private:
/**
* sends all of the buffered data to the client
*
* @param send_final_chunk true if the final 0-byte chunk should be included
* @param send_handler function called after the data has been sent
*/
template
inline void send_more_data(const bool send_final_chunk, SendHandler send_handler)
{
// make sure that we did not lose the TCP connection
if (m_tcp_conn->is_open()) {
// make sure that the content-length is up-to-date
flush_content_stream();
// prepare the write buffers to be sent
http::message::write_buffers_t write_buffers;
prepare_write_buffers(write_buffers, send_final_chunk);
// send data in the write buffers
m_tcp_conn->async_write(write_buffers, send_handler);
} else {
finished_writing(boost::asio::error::connection_reset);
}
}
/**
* prepares write_buffers for next send operation
*
* @param write_buffers buffers to which data will be appended
* @param send_final_chunk true if the final 0-byte chunk should be included
*/
void prepare_write_buffers(http::message::write_buffers_t &write_buffers,
const bool send_final_chunk);
/// flushes any text data in the content stream after caching it in the text_cache_t
inline void flush_content_stream(void) {
if (! m_stream_is_empty) {
std::string string_to_add(m_content_stream.str());
if (! string_to_add.empty()) {
m_content_stream.str("");
m_content_length += string_to_add.size();
m_text_cache.push_back(string_to_add);
m_content_buffers.push_back(boost::asio::buffer(m_text_cache.back()));
}
m_stream_is_empty = true;
}
}
/// used to cache binary data included within the payload content
class binary_cache_t : public std::vector > {
public:
~binary_cache_t() {
for (iterator i=begin(); i!=end(); ++i) {
delete[] i->first;
}
}
inline boost::asio::const_buffer add(const void *ptr, const size_t size) {
char *data_ptr = new char[size];
memcpy(data_ptr, ptr, size);
push_back( std::make_pair(data_ptr, size) );
return boost::asio::buffer(data_ptr, size);
}
};
/// used to cache text (non-binary) data included within the payload content
typedef std::list text_cache_t;
/// primary logging interface used by this class
logger m_logger;
/// The HTTP connection that we are writing the message to
tcp::connection_ptr m_tcp_conn;
/// I/O write buffers that wrap the payload content to be written
http::message::write_buffers_t m_content_buffers;
/// caches binary data included within the payload content
binary_cache_t m_binary_cache;
/// caches text (non-binary) data included within the payload content
text_cache_t m_text_cache;
/// incrementally creates strings of text data for the text_cache_t
std::ostringstream m_content_stream;
/// The length (in bytes) of the response content to be sent (Content-Length)
size_t m_content_length;
/// true if the content_stream is empty (avoids unnecessary string copies)
bool m_stream_is_empty;
/// true if the HTTP client supports chunked transfer encodings
bool m_client_supports_chunks;
/// true if data is being sent to the client using multiple chunks
bool m_sending_chunks;
/// true if the HTTP message headers have already been sent
bool m_sent_headers;
/// function called after the HTTP message has been sent
finished_handler_t m_finished;
};
/// data type for a writer pointer
typedef boost::shared_ptr writer_ptr;
/// override operator<< for convenience
template
inline const writer_ptr& operator<<(const writer_ptr& writer, const T& data) {
writer->write(data);
return writer;
}
inline const writer_ptr& operator<<(const writer_ptr& writer, std::ostream& (*iomanip)(std::ostream&)) {
writer->write(iomanip);
return writer;
}
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/parser.hpp 0000644 0003720 0000144 00000070454 12420270445 021326 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_PARSER_HEADER__
#define __PION_HTTP_PARSER_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef BOOST_SYSTEM_NOEXCEPT
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
#endif
namespace pion { // begin namespace pion
namespace http { // begin namespace http
// forward declarations used for finishing HTTP messages
class request;
class response;
///
/// parser: parses HTTP messages
///
class PION_API parser :
private boost::noncopyable
{
public:
/// maximum length for HTTP payload content
static const std::size_t DEFAULT_CONTENT_MAX;
/// callback type used to consume payload content
typedef boost::function2 payload_handler_t;
/// class-specific error code values
enum error_value_t {
ERROR_METHOD_CHAR = 1,
ERROR_METHOD_SIZE,
ERROR_URI_CHAR,
ERROR_URI_SIZE,
ERROR_QUERY_CHAR,
ERROR_QUERY_SIZE,
ERROR_VERSION_EMPTY,
ERROR_VERSION_CHAR,
ERROR_STATUS_EMPTY,
ERROR_STATUS_CHAR,
ERROR_HEADER_CHAR,
ERROR_HEADER_NAME_SIZE,
ERROR_HEADER_VALUE_SIZE,
ERROR_INVALID_CONTENT_LENGTH,
ERROR_CHUNK_CHAR,
ERROR_MISSING_CHUNK_DATA,
ERROR_MISSING_HEADER_DATA,
ERROR_MISSING_TOO_MUCH_CONTENT,
};
/// class-specific error category
class error_category_t
: public boost::system::error_category
{
public:
const char *name() const BOOST_SYSTEM_NOEXCEPT { return "parser"; }
std::string message(int ev) const {
switch (ev) {
case ERROR_METHOD_CHAR:
return "invalid method character";
case ERROR_METHOD_SIZE:
return "method exceeds maximum size";
case ERROR_URI_CHAR:
return "invalid URI character";
case ERROR_URI_SIZE:
return "method exceeds maximum size";
case ERROR_QUERY_CHAR:
return "invalid query string character";
case ERROR_QUERY_SIZE:
return "query string exceeds maximum size";
case ERROR_VERSION_EMPTY:
return "HTTP version undefined";
case ERROR_VERSION_CHAR:
return "invalid version character";
case ERROR_STATUS_EMPTY:
return "HTTP status undefined";
case ERROR_STATUS_CHAR:
return "invalid status character";
case ERROR_HEADER_CHAR:
return "invalid header character";
case ERROR_HEADER_NAME_SIZE:
return "header name exceeds maximum size";
case ERROR_HEADER_VALUE_SIZE:
return "header value exceeds maximum size";
case ERROR_INVALID_CONTENT_LENGTH:
return "invalid Content-Length header";
case ERROR_CHUNK_CHAR:
return "invalid chunk character";
case ERROR_MISSING_HEADER_DATA:
return "missing header data";
case ERROR_MISSING_CHUNK_DATA:
return "missing chunk data";
case ERROR_MISSING_TOO_MUCH_CONTENT:
return "missing too much content";
}
return "parser error";
}
};
/**
* creates new parser objects
*
* @param is_request if true, the message is parsed as an HTTP request;
* if false, the message is parsed as an HTTP response
* @param max_content_length maximum length for HTTP payload content
*/
parser(const bool is_request, std::size_t max_content_length = DEFAULT_CONTENT_MAX)
: m_logger(PION_GET_LOGGER("pion.http.parser")), m_is_request(is_request),
m_read_ptr(NULL), m_read_end_ptr(NULL), m_message_parse_state(PARSE_START),
m_headers_parse_state(is_request ? PARSE_METHOD_START : PARSE_HTTP_VERSION_H),
m_chunked_content_parse_state(PARSE_CHUNK_SIZE_START), m_status_code(0),
m_bytes_content_remaining(0), m_bytes_content_read(0),
m_bytes_last_read(0), m_bytes_total_read(0),
m_max_content_length(max_content_length),
m_parse_headers_only(false), m_save_raw_headers(false)
{}
/// default destructor
virtual ~parser() {}
/**
* parses an HTTP message including all payload content it might contain
*
* @param http_msg the HTTP message object to populate from parsing
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing HTTP message,
* indeterminate = not yet finished parsing HTTP message
*/
boost::tribool parse(http::message& http_msg, boost::system::error_code& ec);
/**
* attempts to continue parsing despite having missed data (length is known but content is not)
*
* @param http_msg the HTTP message object to populate from parsing
* @param len the length in bytes of the missing data
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing HTTP message,
* indeterminate = not yet finished parsing HTTP message
*/
boost::tribool parse_missing_data(http::message& http_msg, std::size_t len,
boost::system::error_code& ec);
/**
* finishes parsing an HTTP response message
*
* @param http_msg the HTTP message object to finish
*/
void finish(http::message& http_msg) const;
/**
* resets the location and size of the read buffer
*
* @param ptr pointer to the first bytes available to be read
* @param len number of bytes available to be read
*/
inline void set_read_buffer(const char *ptr, size_t len) {
m_read_ptr = ptr;
m_read_end_ptr = ptr + len;
}
/**
* loads a read position bookmark
*
* @param read_ptr points to the next character to be consumed in the read_buffer
* @param read_end_ptr points to the end of the read_buffer (last byte + 1)
*/
inline void load_read_pos(const char *&read_ptr, const char *&read_end_ptr) const {
read_ptr = m_read_ptr;
read_end_ptr = m_read_end_ptr;
}
/**
* checks to see if a premature EOF was encountered while parsing. This
* should be called if there is no more data to parse, and if the last
* call to the parse() function returned boost::indeterminate
*
* @param http_msg the HTTP message object being parsed
* @return true if premature EOF, false if message is OK & finished parsing
*/
inline bool check_premature_eof(http::message& http_msg) {
if (m_message_parse_state != PARSE_CONTENT_NO_LENGTH)
return true;
m_message_parse_state = PARSE_END;
http_msg.concatenate_chunks();
finish(http_msg);
return false;
}
/**
* controls headers-only parsing (default is disabled; content parsed also)
*
* @param b if true, then the parse() function returns true after headers
*/
inline void parse_headers_only(bool b = true) { m_parse_headers_only = b; }
/**
* skip parsing all headers and parse payload content only
*
* @param http_msg the HTTP message object being parsed
*/
inline void skip_header_parsing(http::message& http_msg) {
boost::system::error_code ec;
finish_header_parsing(http_msg, ec);
}
/// resets the parser to its initial state
inline void reset(void) {
m_message_parse_state = PARSE_START;
m_headers_parse_state = (m_is_request ? PARSE_METHOD_START : PARSE_HTTP_VERSION_H);
m_chunked_content_parse_state = PARSE_CHUNK_SIZE_START;
m_status_code = 0;
m_status_message.erase();
m_method.erase();
m_resource.erase();
m_query_string.erase();
m_raw_headers.erase();
m_bytes_content_read = m_bytes_last_read = m_bytes_total_read = 0;
}
/// returns true if there are no more bytes available in the read buffer
inline bool eof(void) const { return m_read_ptr == NULL || m_read_ptr >= m_read_end_ptr; }
/// returns the number of bytes available in the read buffer
inline std::size_t bytes_available(void) const { return (eof() ? 0 : (std::size_t)(m_read_end_ptr - m_read_ptr)); }
/// returns the number of bytes read during the last parse operation
inline std::size_t gcount(void) const { return m_bytes_last_read; }
/// returns the total number of bytes read while parsing the HTTP message
inline std::size_t get_total_bytes_read(void) const { return m_bytes_total_read; }
/// returns the total number of bytes read while parsing the payload content
inline std::size_t get_content_bytes_read(void) const { return m_bytes_content_read; }
/// returns the maximum length for HTTP payload content
inline std::size_t get_max_content_length(void) const { return m_max_content_length; }
/// returns the raw HTTP headers saved by the parser
inline const std::string& get_raw_headers(void) const { return m_raw_headers; }
/// returns true if the parser is saving raw HTTP header contents
inline bool get_save_raw_headers(void) const { return m_save_raw_headers; }
/// returns true if parsing headers only
inline bool get_parse_headers_only(void) { return m_parse_headers_only; }
/// returns true if the parser is being used to parse an HTTP request
inline bool is_parsing_request(void) const { return m_is_request; }
/// returns true if the parser is being used to parse an HTTP response
inline bool is_parsing_response(void) const { return ! m_is_request; }
/// defines a callback function to be used for consuming payload content
inline void set_payload_handler(payload_handler_t& h) { m_payload_handler = h; }
/// sets the maximum length for HTTP payload content
inline void set_max_content_length(std::size_t n) { m_max_content_length = n; }
/// resets the maximum length for HTTP payload content to the default value
inline void reset_max_content_length(void) { m_max_content_length = DEFAULT_CONTENT_MAX; }
/// sets parameter for saving raw HTTP header content
inline void set_save_raw_headers(bool b) { m_save_raw_headers = b; }
/// sets the logger to be used
inline void set_logger(logger log_ptr) { m_logger = log_ptr; }
/// returns the logger currently in use
inline logger get_logger(void) { return m_logger; }
/**
* parses a URI string
*
* @param uri the string to parse
* @param proto will be set to the protocol (i.e. "http")
* @param host will be set to the hostname (i.e. "www.cloudmeter.com")
* @param port host port number to use for connection (i.e. 80)
* @param path uri stem or file path
* @param query uri query string
*
* @return true if the URI was successfully parsed, false if there was an error
*/
static bool parse_uri(const std::string& uri, std::string& proto,
std::string& host, boost::uint16_t& port, std::string& path,
std::string& query);
/**
* parse key-value pairs out of a url-encoded string
* (i.e. this=that&a=value)
*
* @param dict dictionary for key-values pairs
* @param ptr points to the start of the encoded string
* @param len length of the encoded string, in bytes
*
* @return bool true if successful
*/
static bool parse_url_encoded(ihash_multimap& dict,
const char *ptr, const std::size_t len);
/**
* parse key-value pairs out of a multipart/form-data payload content
* (http://www.ietf.org/rfc/rfc2388.txt)
*
* @param dict dictionary for key-values pairs
* @param content_type value of the content-type HTTP header
* @param ptr points to the start of the encoded data
* @param len length of the encoded data, in bytes
*
* @return bool true if successful
*/
static bool parse_multipart_form_data(ihash_multimap& dict,
const std::string& content_type,
const char *ptr, const std::size_t len);
/**
* parse key-value pairs out of a "Cookie" request header
* (i.e. this=that; a=value)
*
* @param dict dictionary for key-values pairs
* @param ptr points to the start of the header string to be parsed
* @param len length of the encoded string, in bytes
* @param set_cookie_header set true if parsing Set-Cookie response header
*
* @return bool true if successful
*/
static bool parse_cookie_header(ihash_multimap& dict,
const char *ptr, const std::size_t len,
bool set_cookie_header);
/**
* parse key-value pairs out of a "Cookie" request header
* (i.e. this=that; a=value)
*
* @param dict dictionary for key-values pairs
* @param cookie_header header string to be parsed
* @param set_cookie_header set true if parsing Set-Cookie response header
*
* @return bool true if successful
*/
static inline bool parse_cookie_header(ihash_multimap& dict,
const std::string& cookie_header, bool set_cookie_header)
{
return parse_cookie_header(dict, cookie_header.c_str(), cookie_header.size(), set_cookie_header);
}
/**
* parse key-value pairs out of a url-encoded string
* (i.e. this=that&a=value)
*
* @param dict dictionary for key-values pairs
* @param query the encoded query string to be parsed
*
* @return bool true if successful
*/
static inline bool parse_url_encoded(ihash_multimap& dict,
const std::string& query)
{
return parse_url_encoded(dict, query.c_str(), query.size());
}
/**
* parse key-value pairs out of a multipart/form-data payload content
* (http://www.ietf.org/rfc/rfc2388.txt)
*
* @param dict dictionary for key-values pairs
* @param content_type value of the content-type HTTP header
* @param form_data the encoded form data
*
* @return bool true if successful
*/
static inline bool parse_multipart_form_data(ihash_multimap& dict,
const std::string& content_type,
const std::string& form_data)
{
return parse_multipart_form_data(dict, content_type, form_data.c_str(), form_data.size());
}
/**
* should be called after parsing HTTP headers, to prepare for payload content parsing
* available in the read buffer
*
* @param http_msg the HTTP message object to populate from parsing
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing HTTP message (no content),
* indeterminate = payload content is available to be parsed
*/
boost::tribool finish_header_parsing(http::message& http_msg,
boost::system::error_code& ec);
/**
* parses an X-Forwarded-For HTTP header, and extracts from it an IP
* address that best matches the client's public IP address (if any are found)
*
* @param header the X-Forwarded-For HTTP header to parse
* @param public_ip the extract IP address, if found
*
* @return bool true if a public IP address was found and extracted
*/
static bool parse_forwarded_for(const std::string& header, std::string& public_ip);
/// returns an instance of parser::error_category_t
static inline error_category_t& get_error_category(void) {
boost::call_once(parser::create_error_category, m_instance_flag);
return *m_error_category_ptr;
}
protected:
/// Called after we have finished parsing the HTTP message headers
virtual void finished_parsing_headers(const boost::system::error_code& ec) {}
/**
* parses an HTTP message up to the end of the headers using bytes
* available in the read buffer
*
* @param http_msg the HTTP message object to populate from parsing
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing HTTP headers,
* indeterminate = not yet finished parsing HTTP headers
*/
boost::tribool parse_headers(http::message& http_msg, boost::system::error_code& ec);
/**
* updates an http::message object with data obtained from parsing headers
*
* @param http_msg the HTTP message object to populate from parsing
*/
void update_message_with_header_data(http::message& http_msg) const;
/**
* parses a chunked HTTP message-body using bytes available in the read buffer
*
* @param chunk_buffers buffers to be populated from parsing chunked content
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing message,
* indeterminate = message is not yet finished
*/
boost::tribool parse_chunks(http::message::chunk_cache_t& chunk_buffers,
boost::system::error_code& ec);
/**
* consumes payload content in the parser's read buffer
*
* @param http_msg the HTTP message object to consume content for
* @param ec error_code contains additional information for parsing errors
*
* @return boost::tribool result of parsing:
* false = message has an error,
* true = finished parsing message,
* indeterminate = message is not yet finished
*/
boost::tribool consume_content(http::message& http_msg,
boost::system::error_code& ec);
/**
* consume the bytes available in the read buffer, converting them into
* the next chunk for the HTTP message
*
* @param chunk_buffers buffers to be populated from parsing chunked content
* @return std::size_t number of content bytes consumed, if any
*/
std::size_t consume_content_as_next_chunk(http::message::chunk_cache_t& chunk_buffers);
/**
* compute and sets a HTTP Message data integrity status
* @param http_msg target HTTP message
* @param msg_parsed_ok message parsing result
*/
static void compute_msg_status(http::message& http_msg, bool msg_parsed_ok);
/**
* sets an error code
*
* @param ec error code variable to define
* @param ev error value to raise
*/
static inline void set_error(boost::system::error_code& ec, error_value_t ev) {
ec = boost::system::error_code(static_cast(ev), get_error_category());
}
/// creates the unique parser error_category_t
static void create_error_category(void);
// misc functions used by the parsing functions
inline static bool is_char(int c);
inline static bool is_control(int c);
inline static bool is_special(int c);
inline static bool is_digit(int c);
inline static bool is_hex_digit(int c);
inline static bool is_cookie_attribute(const std::string& name, bool set_cookie_header);
/// maximum length for response status message
static const boost::uint32_t STATUS_MESSAGE_MAX;
/// maximum length for the request method
static const boost::uint32_t METHOD_MAX;
/// maximum length for the resource requested
static const boost::uint32_t RESOURCE_MAX;
/// maximum length for the query string
static const boost::uint32_t QUERY_STRING_MAX;
/// maximum length for an HTTP header name
static const boost::uint32_t HEADER_NAME_MAX;
/// maximum length for an HTTP header value
static const boost::uint32_t HEADER_VALUE_MAX;
/// maximum length for the name of a query string variable
static const boost::uint32_t QUERY_NAME_MAX;
/// maximum length for the value of a query string variable
static const boost::uint32_t QUERY_VALUE_MAX;
/// maximum length for the name of a cookie name
static const boost::uint32_t COOKIE_NAME_MAX;
/// maximum length for the value of a cookie; also used for path and domain
static const boost::uint32_t COOKIE_VALUE_MAX;
/// primary logging interface used by this class
mutable logger m_logger;
/// true if the message is an HTTP request; false if it is an HTTP response
const bool m_is_request;
/// points to the next character to be consumed in the read_buffer
const char * m_read_ptr;
/// points to the end of the read_buffer (last byte + 1)
const char * m_read_end_ptr;
private:
/// state used to keep track of where we are in parsing the HTTP message
enum message_parse_state_t {
PARSE_START, PARSE_HEADERS, PARSE_FOOTERS, PARSE_CONTENT,
PARSE_CONTENT_NO_LENGTH, PARSE_CHUNKS, PARSE_END
};
/// state used to keep track of where we are in parsing the HTTP headers
/// (only used if message_parse_state_t == PARSE_HEADERS)
enum header_parse_state_t {
PARSE_METHOD_START, PARSE_METHOD, PARSE_URI_STEM, PARSE_URI_QUERY,
PARSE_HTTP_VERSION_H, PARSE_HTTP_VERSION_T_1, PARSE_HTTP_VERSION_T_2,
PARSE_HTTP_VERSION_P, PARSE_HTTP_VERSION_SLASH,
PARSE_HTTP_VERSION_MAJOR_START, PARSE_HTTP_VERSION_MAJOR,
PARSE_HTTP_VERSION_MINOR_START, PARSE_HTTP_VERSION_MINOR,
PARSE_STATUS_CODE_START, PARSE_STATUS_CODE, PARSE_STATUS_MESSAGE,
PARSE_EXPECTING_NEWLINE, PARSE_EXPECTING_CR,
PARSE_HEADER_WHITESPACE, PARSE_HEADER_START, PARSE_HEADER_NAME,
PARSE_SPACE_BEFORE_HEADER_VALUE, PARSE_HEADER_VALUE,
PARSE_EXPECTING_FINAL_NEWLINE, PARSE_EXPECTING_FINAL_CR
};
/// state used to keep track of where we are in parsing chunked content
/// (only used if message_parse_state_t == PARSE_CHUNKS)
enum chunk_parse_state_t {
PARSE_CHUNK_SIZE_START, PARSE_CHUNK_SIZE,
PARSE_EXPECTING_IGNORED_TEXT_AFTER_CHUNK_SIZE,
PARSE_EXPECTING_CR_AFTER_CHUNK_SIZE,
PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE, PARSE_CHUNK,
PARSE_EXPECTING_CR_AFTER_CHUNK, PARSE_EXPECTING_LF_AFTER_CHUNK,
PARSE_EXPECTING_FINAL_CR_OR_FOOTERS_AFTER_LAST_CHUNK,
PARSE_EXPECTING_FINAL_LF_AFTER_LAST_CHUNK
};
/// the current state of parsing HTTP headers
message_parse_state_t m_message_parse_state;
/// the current state of parsing HTTP headers
header_parse_state_t m_headers_parse_state;
/// the current state of parsing chunked content
chunk_parse_state_t m_chunked_content_parse_state;
/// if defined, this function is used to consume payload content
payload_handler_t m_payload_handler;
/// Used for parsing the HTTP response status code
boost::uint16_t m_status_code;
/// Used for parsing the HTTP response status message
std::string m_status_message;
/// Used for parsing the request method
std::string m_method;
/// Used for parsing the name of resource requested
std::string m_resource;
/// Used for parsing the query string portion of a URI
std::string m_query_string;
/// Used to store the raw contents of HTTP headers when m_save_raw_headers is true
std::string m_raw_headers;
/// Used for parsing the name of HTTP headers
std::string m_header_name;
/// Used for parsing the value of HTTP headers
std::string m_header_value;
/// Used for parsing the chunk size
std::string m_chunk_size_str;
/// number of bytes in the chunk currently being parsed
std::size_t m_size_of_current_chunk;
/// number of bytes read so far in the chunk currently being parsed
std::size_t m_bytes_read_in_current_chunk;
/// number of payload content bytes that have not yet been read
std::size_t m_bytes_content_remaining;
/// number of bytes read so far into the message's payload content
std::size_t m_bytes_content_read;
/// number of bytes read during last parse operation
std::size_t m_bytes_last_read;
/// total number of bytes read while parsing the HTTP message
std::size_t m_bytes_total_read;
/// maximum length for HTTP payload content
std::size_t m_max_content_length;
/// if true, then only HTTP headers will be parsed (no content parsing)
bool m_parse_headers_only;
/// if true, the raw contents of HTTP headers are stored into m_raw_headers
bool m_save_raw_headers;
/// points to a single and unique instance of the parser error_category_t
static error_category_t * m_error_category_ptr;
/// used to ensure thread safety of the parser error_category_t
static boost::once_flag m_instance_flag;
};
// inline functions for parser
inline bool parser::is_char(int c)
{
return(c >= 0 && c <= 127);
}
inline bool parser::is_control(int c)
{
return( (c >= 0 && c <= 31) || c == 127);
}
inline bool parser::is_special(int c)
{
switch (c) {
case '(': case ')': case '<': case '>': case '@':
case ',': case ';': case ':': case '\\': case '"':
case '/': case '[': case ']': case '?': case '=':
case '{': case '}': case ' ': case '\t':
return true;
default:
return false;
}
}
inline bool parser::is_digit(int c)
{
return(c >= '0' && c <= '9');
}
inline bool parser::is_hex_digit(int c)
{
return((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
}
inline bool parser::is_cookie_attribute(const std::string& name, bool set_cookie_header)
{
return (name.empty() || name[0] == '$' || (set_cookie_header &&
(
// This is needed because of a very lenient determination in parse_cookie_header() of what
// qualifies as a cookie-pair in a Set-Cookie header.
// According to RFC 6265, everything after the first semicolon is a cookie attribute, but RFC 2109,
// which is obsolete, allowed multiple comma separated cookies.
// parse_cookie_header() is very conservatively assuming that any = pair in a
// Set-Cookie header is a cookie-pair unless is a known cookie attribute.
boost::algorithm::iequals(name, "Comment")
|| boost::algorithm::iequals(name, "Domain")
|| boost::algorithm::iequals(name, "Max-Age")
|| boost::algorithm::iequals(name, "Path")
|| boost::algorithm::iequals(name, "Secure")
|| boost::algorithm::iequals(name, "Version")
|| boost::algorithm::iequals(name, "Expires")
|| boost::algorithm::iequals(name, "HttpOnly")
)
));
}
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/response_reader.hpp 0000644 0003720 0000144 00000010646 12420270445 023207 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_HTTP_RESPONSE_READER_HEADER__
#define __PION_HTTP_RESPONSE_READER_HEADER__
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace pion { // begin namespace pion
namespace http { // begin namespace http
///
/// response_reader: asynchronously reads and parses HTTP responses
///
class response_reader :
public http::reader,
public boost::enable_shared_from_this
{
public:
/// function called after the HTTP message has been parsed
typedef boost::function3 finished_handler_t;
// default destructor
virtual ~response_reader() {}
/**
* creates new response_reader objects
*
* @param tcp_conn TCP connection containing a new message to parse
* @param http_request the request we are responding to
* @param handler function called after the message has been parsed
*/
static inline boost::shared_ptr
create(tcp::connection_ptr& tcp_conn, const http::request& http_request,
finished_handler_t handler)
{
return boost::shared_ptr
(new response_reader(tcp_conn, http_request, handler));
}
/// sets a function to be called after HTTP headers have been parsed
inline void set_headers_parsed_callback(finished_handler_t& h) { m_parsed_headers = h; }
protected:
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection containing a new message to parse
* @param http_request the request we are responding to
* @param handler function called after the message has been parsed
*/
response_reader(tcp::connection_ptr& tcp_conn, const http::request& http_request,
finished_handler_t handler)
: http::reader(false, tcp_conn), m_http_msg(new http::response(http_request)),
m_finished(handler)
{
m_http_msg->set_remote_ip(tcp_conn->get_remote_ip());
set_logger(PION_GET_LOGGER("pion.http.response_reader"));
}
/// Reads more bytes from the TCP connection
virtual void read_bytes(void) {
get_connection()->async_read_some(boost::bind(&response_reader::consume_bytes,
shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
/// Called after we have finished parsing the HTTP message headers
virtual void finished_parsing_headers(const boost::system::error_code& ec) {
// call the finished headers handler with the HTTP message
if (m_parsed_headers) m_parsed_headers(m_http_msg, get_connection(), ec);
}
/// Called after we have finished reading/parsing the HTTP message
virtual void finished_reading(const boost::system::error_code& ec) {
// call the finished handler with the finished HTTP message
if (m_finished) m_finished(m_http_msg, get_connection(), ec);
}
/// Returns a reference to the HTTP message being parsed
virtual http::message& get_message(void) { return *m_http_msg; }
/// The new HTTP message container being created
http::response_ptr m_http_msg;
/// function called after the HTTP message has been parsed
finished_handler_t m_finished;
/// function called after the HTTP message headers have been parsed
finished_handler_t m_parsed_headers;
};
/// data type for a response_reader pointer
typedef boost::shared_ptr response_reader_ptr;
} // end namespace http
} // end namespace pion
#endif
pion-5.0.7+dfsg.orig/include/pion/http/plugin_server.hpp 0000644 0003720 0000144 00000012543 12420270445 022711 0 ustar roberto users // ---------------------------------------------------------------------
// pion: a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//
#ifndef __PION_PLUGIN_SERVER_HEADER__
#define __PION_PLUGIN_SERVER_HEADER__
#include
#include
#include
#include
#include
#include
#include