899 lines
30 KiB
C++
899 lines
30 KiB
C++
#include "rename_object.hpp"
|
|
#include "functions.hpp"
|
|
#include <climits>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <restbed>
|
|
#include <sstream>
|
|
#include <rapidjson/document.h>
|
|
#include <rapidjson/stringbuffer.h>
|
|
#include <rapidjson/writer.h>
|
|
#include <string>
|
|
#include <chrono>
|
|
|
|
#include "jwt.hpp"
|
|
#include "filesystem/filesystem.hpp"
|
|
#include "config/config.hpp"
|
|
#include "fileobject.hpp"
|
|
|
|
std::vector< RenameLibrary > libraries{};
|
|
Configuration cfg;
|
|
|
|
void sendResponse( const std::string &response, int status_code,
|
|
const std::shared_ptr< restbed::Session > &session ) {
|
|
session->close( status_code, response,
|
|
{ { "Content-Length", std::to_string( response.length() ) },
|
|
{ "Access-Control-Allow-Origin", "*" } } );
|
|
}
|
|
|
|
void performPostFunc(
|
|
const std::shared_ptr< restbed::Session > &session,
|
|
const std::function< void(
|
|
const std::shared_ptr< restbed::Session >,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > & ) > &callback ) {
|
|
const auto request = session->get_request();
|
|
|
|
int content_length = request->get_header( "Content-Length", 0 );
|
|
|
|
session->fetch(
|
|
content_length,
|
|
[callback]( const std::shared_ptr< restbed::Session > &session,
|
|
const restbed::Bytes &body ) {
|
|
rapidjson::Document doc;
|
|
doc.Parse( reinterpret_cast< const char * >( body.data() ),
|
|
body.size() );
|
|
if ( doc.HasParseError() ) {
|
|
sendResponse( "ERROR: Invalid body!", 401, session );
|
|
return;
|
|
}
|
|
callback( session, doc );
|
|
} );
|
|
}
|
|
|
|
bool verifyLogin( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "token" ) == doc.MemberEnd() ||
|
|
!doc["token"].IsString() ) {
|
|
sendResponse( "ERROR: Invalid token!", 401, session );
|
|
return false;
|
|
}
|
|
const auto *token = doc["token"].GetString();
|
|
auto res = verifyJWT( token );
|
|
if ( !res ) {
|
|
sendResponse( "ERROR: Invalid token!", 401, session );
|
|
}
|
|
return res;
|
|
}
|
|
|
|
std::vector< std::pair< RenameLibrary *, size_t > > getLibraries() {
|
|
std::vector< std::pair< RenameLibrary *, size_t > > result{};
|
|
for ( size_t i = 0; i < libraries.size(); i++ ) {
|
|
result.emplace_back( &libraries[i], i );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string getLibrariesJson() {
|
|
auto libraries = getLibraries();
|
|
std::ostringstream result;
|
|
result << "{\n \"libraries\": [\n";
|
|
if ( !libraries.empty() ) {
|
|
for ( const auto &library : libraries ) {
|
|
result << " {\n \"id\": " << library.second << ",\n";
|
|
result << " \"name\": \"" << safeJson( library.first->getName() )
|
|
<< "\"\n,";
|
|
result << " \"multiple_files\": "
|
|
<< ( library.first->canRenameMultipleFiles() ? "true"
|
|
: "false" )
|
|
<< ",\n";
|
|
result << " \"should_search\": "
|
|
<< ( library.first->shouldPerformSearch() ? "true"
|
|
: "false" )
|
|
<< "\n },\n";
|
|
}
|
|
result.seekp( -2, std::ios_base::end );
|
|
result << "\n";
|
|
}
|
|
result << " ]\n}";
|
|
auto res = result.str();
|
|
return res;
|
|
}
|
|
|
|
void getLibrariesRest( const std::shared_ptr< restbed::Session > &session ) {
|
|
sendResponse( getLibrariesJson(), restbed::OK, session );
|
|
}
|
|
|
|
std::vector< RenameObject > getOptions( const RenameObject &search ) {
|
|
auto library_id = search.getLibraryId();
|
|
if ( library_id >= libraries.size() ) {
|
|
return {};
|
|
}
|
|
auto result = libraries[library_id].getOptions( search );
|
|
for ( auto &res : result ) {
|
|
res.setLibraryId( library_id );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string getOptionsJson( const RenameObject &search ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"options\": [\n";
|
|
auto options = getOptions( search );
|
|
if ( !options.empty() ) {
|
|
for ( auto &option : options ) {
|
|
res << option.toJson();
|
|
res << ",\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
res << "\n";
|
|
}
|
|
res << " ]\n}";
|
|
auto result = res.str();
|
|
return result;
|
|
}
|
|
|
|
void getOptionsRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.HasParseError() ) {
|
|
sendResponse( "ERROR: Invalid body!", 401, session );
|
|
return;
|
|
}
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "info" ) == doc.MemberEnd() ||
|
|
!doc["info"].IsObject() ) {
|
|
sendResponse( "ERROR: Invalid search!", 401, session );
|
|
return;
|
|
}
|
|
RenameObject search;
|
|
rapidjson::StringBuffer sb;
|
|
rapidjson::Writer< rapidjson::StringBuffer > writer( sb );
|
|
doc["info"].Accept( writer );
|
|
std::string s = sb.GetString();
|
|
search.fromJson( s );
|
|
if ( search.getPresentedName().empty() ) {
|
|
sendResponse( "Empty search", 401, session );
|
|
return;
|
|
}
|
|
sendResponse( getOptionsJson( search ), 200, session );
|
|
}
|
|
|
|
std::vector< std::unordered_map< std::string, std::string > >
|
|
getCustomKeys( size_t library_id ) {
|
|
if ( library_id >= libraries.size() ) {
|
|
return {};
|
|
}
|
|
return libraries[library_id].getCustomKeys();
|
|
}
|
|
|
|
std::vector< std::pair< string, string > >
|
|
getFieldOptions( size_t library_id, const std::string &field ) {
|
|
if ( library_id >= libraries.size() ) {
|
|
return {};
|
|
}
|
|
return libraries[library_id].getCustomKeyOptions( field );
|
|
}
|
|
|
|
std::string getFieldDefault( size_t library_id, const std::string &field ) {
|
|
if ( library_id >= libraries.size() ) {
|
|
return "";
|
|
}
|
|
return libraries[library_id].getCustomKeyDefault( field );
|
|
}
|
|
|
|
std::string getLibraryPattern( size_t library_id ) {
|
|
if ( library_id >= libraries.size() ) {
|
|
return "";
|
|
}
|
|
return libraries[library_id].choiceDisplay();
|
|
}
|
|
|
|
std::string getCustomKeysJson( size_t library_id ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"custom_keys\": [\n";
|
|
auto custom_keys = getCustomKeys( library_id );
|
|
if ( !custom_keys.empty() ) {
|
|
for ( auto &key : custom_keys ) {
|
|
res << " {\n";
|
|
res << " \"name\": \"" << safeJson( key["name"] ) << "\",\n";
|
|
res << " \"display_name\": \""
|
|
<< safeJson( key["display_name"] ) << "\",\n";
|
|
res << " \"type\": \"" << safeJson( key["type"] ) << "\",\n";
|
|
res << " \"input\": " << safeJson( key["input"] ) << "\n";
|
|
res << " },\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
res << "\n";
|
|
}
|
|
res << " ]\n}";
|
|
return res.str();
|
|
}
|
|
|
|
std::string getFieldOptionsJson( size_t library_id, const std::string &field ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"options\": [\n";
|
|
auto options = getFieldOptions( library_id, field );
|
|
if ( !options.empty() ) {
|
|
for ( auto &option : options ) {
|
|
res << " {\n";
|
|
// TODO replace first/second with a proper name, create option
|
|
// struct or something
|
|
res << " \"code\": \"" << safeJson( option.first ) << "\",\n";
|
|
res << " \"name\": \"" << safeJson( option.second ) << "\"\n";
|
|
res << " },\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
res << "\n";
|
|
}
|
|
res << " ]\n}";
|
|
return res.str();
|
|
}
|
|
|
|
std::string getFieldDefaultJson( size_t library_id, const std::string &field ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"default\": \"" << getFieldDefault( library_id, field )
|
|
<< "\"}";
|
|
return res.str();
|
|
}
|
|
|
|
std::string getLibraryPatternJson( size_t library_id ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"pattern\": \"" << getLibraryPattern( library_id ) << "\"}";
|
|
return res.str();
|
|
}
|
|
|
|
void getCustomKeysRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "library_id" ) == doc.MemberEnd() ||
|
|
!doc["library_id"].IsUint64() ) {
|
|
sendResponse( "ERROR: Invalid library_id!", 401, session );
|
|
return;
|
|
}
|
|
size_t library_id = doc["library_id"].GetUint64();
|
|
sendResponse( getCustomKeysJson( library_id ), 200, session );
|
|
}
|
|
|
|
void getFieldOptionsRest(
|
|
const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "library_id" ) == doc.MemberEnd() ||
|
|
!doc["library_id"].IsUint64() ) {
|
|
sendResponse( "ERROR: Invalid library_id!", 401, session );
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "field" ) == doc.MemberEnd() ||
|
|
!doc["field"].IsString() ) {
|
|
sendResponse( "ERROR: Invalid field!", 401, session );
|
|
return;
|
|
}
|
|
auto library_id = doc["library_id"].GetUint64();
|
|
auto field = doc["field"].GetString();
|
|
sendResponse( getFieldOptionsJson( library_id, field ), 200, session );
|
|
}
|
|
|
|
void getFieldDefaultRest(
|
|
const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "library_id" ) == doc.MemberEnd() ||
|
|
!doc["library_id"].IsUint64() ) {
|
|
sendResponse( "ERROR: Invalid library_id!", 401, session );
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "field" ) == doc.MemberEnd() ||
|
|
!doc["field"].IsString() ) {
|
|
sendResponse( "ERROR: Invalid field!", 401, session );
|
|
return;
|
|
}
|
|
auto library_id = doc["library_id"].GetUint64();
|
|
auto field = doc["field"].GetString();
|
|
sendResponse( getFieldDefaultJson( library_id, field ), 200, session );
|
|
}
|
|
|
|
void getLibraryPatternRest(
|
|
const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "library_id" ) == doc.MemberEnd() ||
|
|
!doc["library_id"].IsUint64() ) {
|
|
sendResponse( "ERROR: Invalid library_id!", 401, session );
|
|
return;
|
|
}
|
|
auto library_id = doc["library_id"].GetUint64();
|
|
sendResponse( getLibraryPatternJson( library_id ), 200, session );
|
|
}
|
|
|
|
std::pair< bool, std::string > renamePath( std::string path,
|
|
const RenameObject &renamer ) {
|
|
if ( renamer.getLibraryId() >= libraries.size() ) {
|
|
return { false, "Invalid library id" };
|
|
}
|
|
if ( path[0] != '/' ) {
|
|
path = cfg.getSourcePath() + "/" + path;
|
|
}
|
|
|
|
auto canon_path = FSLib::canonical( path );
|
|
if ( canon_path.substr( 0, cfg.getSourcePath().length() ) !=
|
|
cfg.getSourcePath() ) {
|
|
return { false, "Invalid path" };
|
|
}
|
|
|
|
if ( !FSLib::exists( path ) ) {
|
|
return { false, "Source doesn't exist" };
|
|
}
|
|
return { libraries[renamer.getLibraryId()].renamePath( path, renamer ),
|
|
"Library error" };
|
|
}
|
|
|
|
std::string renamePathJson( const std::string &path,
|
|
const RenameObject &renamer ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"success\": ";
|
|
auto rename_result = renamePath( path, renamer );
|
|
if ( rename_result.first ) {
|
|
res << "true";
|
|
} else {
|
|
res << "false";
|
|
}
|
|
if ( !rename_result.first ) {
|
|
res << ",\n";
|
|
res << " \"error\": \"" << safeJson( rename_result.second ) << "\"\n";
|
|
} else {
|
|
res << "\n";
|
|
}
|
|
res << "}";
|
|
return res.str();
|
|
}
|
|
|
|
void renamePathRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "path" ) == doc.MemberEnd() ||
|
|
!doc["path"].IsString() ) {
|
|
// TODO validate path, also validate against config
|
|
sendResponse( "ERROR: Invalid path!", 401, session );
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "info" ) == doc.MemberEnd() ||
|
|
!doc["info"].IsObject() ) {
|
|
sendResponse( "ERROR: Invalid info!", 401, session );
|
|
return;
|
|
}
|
|
std::string path = doc["path"].GetString();
|
|
RenameObject renamer;
|
|
rapidjson::StringBuffer sb;
|
|
rapidjson::Writer< rapidjson::StringBuffer > writer( sb );
|
|
doc["info"].Accept( writer );
|
|
std::string s = sb.GetString();
|
|
renamer.fromJson( s );
|
|
sendResponse( renamePathJson( path, renamer ), 200, session );
|
|
}
|
|
|
|
std::string getFilesJson() {
|
|
std::ostringstream res;
|
|
res << "{\n \"files\": [\n";
|
|
auto files = getFilesInSource( cfg.getSourcePath() );
|
|
if ( !files.empty() ) {
|
|
for ( const auto &file : files ) {
|
|
res << " {\n \"path\": \"" << safeJson( file.getPath() )
|
|
<< "\",\n";
|
|
res << " \"depth\": " << file.getDepth() << ",\n";
|
|
res << " \"type\": \""
|
|
<< ( file.getFileType() == TYPE_FILE ? "file" : "directory" )
|
|
<< "\"\n },\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
}
|
|
res << "\n ]\n}";
|
|
return res.str();
|
|
}
|
|
|
|
void getFilesRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
sendResponse( getFilesJson(), restbed::OK, session );
|
|
}
|
|
|
|
std::vector< std::pair< uint64_t, std::string > > getTargets() {
|
|
std::vector< std::pair< uint64_t, std::string > > result;
|
|
const auto &targets = cfg.getTargetPaths();
|
|
for ( uint64_t i = 0; i < targets.size(); i++ ) {
|
|
result.emplace_back( i, targets[i].second );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string getTargetsJson() {
|
|
std::ostringstream res;
|
|
res << "{\n \"targets\": [\n";
|
|
auto targets = getTargets();
|
|
if ( !targets.empty() ) {
|
|
for ( const auto &target : targets ) {
|
|
res << " {\n"
|
|
<< " \"id\": " << target.first << ",\n";
|
|
res << " \"name\": \"" << safeJson( target.second )
|
|
<< "\"\n },\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
}
|
|
res << "\n ]\n}";
|
|
return res.str();
|
|
}
|
|
|
|
void getTargetsRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
sendResponse( getTargetsJson(), restbed::OK, session );
|
|
}
|
|
|
|
std::string getTargetDirectoriesJson( uint64_t id ) {
|
|
if ( id >= cfg.getTargetPaths().size() ) {
|
|
return "";
|
|
}
|
|
std::ostringstream res;
|
|
res << "{\n \"target_directories\": [\n";
|
|
auto dirs = getTargetDirectories( cfg.getTargetPaths()[id].first );
|
|
if ( !dirs.empty() ) {
|
|
for ( const auto &dir : dirs ) {
|
|
res << " \"" << safeJson( dir.getPath() ) << "\",\n";
|
|
}
|
|
res.seekp( -2, std::ios_base::end );
|
|
}
|
|
res << "\n ]\n}";
|
|
return res.str();
|
|
}
|
|
|
|
void getTargetDirectoriesRest(
|
|
const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
uint64_t id = 0;
|
|
if ( doc.FindMember( "path_id" ) == doc.MemberEnd() ||
|
|
!doc["path_id"].IsUint64() ||
|
|
( id = doc["path_id"].GetUint64() ) >= cfg.getTargetPaths().size() ) {
|
|
sendResponse( "ERROR: Invalid path_id!", 401, session );
|
|
return;
|
|
}
|
|
sendResponse( getTargetDirectoriesJson( id ), restbed::OK, session );
|
|
}
|
|
|
|
std::pair< bool, std::string > move( std::string path, uint64_t target_id,
|
|
const std::string &containing_dir ) {
|
|
if ( path[0] != '/' ) {
|
|
path = cfg.getSourcePath() + "/" + path;
|
|
}
|
|
auto canon_path = FSLib::canonical( path );
|
|
if ( canon_path.substr( 0, cfg.getSourcePath().length() ) !=
|
|
cfg.getSourcePath() ) {
|
|
return { false, "Invalid path" };
|
|
}
|
|
|
|
if ( target_id >= cfg.getTargetPaths().size() ) {
|
|
return { false, "Invalid target_id" };
|
|
}
|
|
if ( !FSLib::exists( path ) ) {
|
|
return { false, "Source doesn't exist" };
|
|
}
|
|
auto target_start = cfg.getTargetPaths()[target_id].first;
|
|
auto target_dir = target_start + FSLib::dir_divisor + containing_dir;
|
|
auto target_canon = FSLib::canonical( target_dir );
|
|
if ( target_canon.substr( 0, target_start.length() ) != target_start &&
|
|
!target_canon.empty() ) {
|
|
return { false, "Invalid target" };
|
|
}
|
|
// might result in needless false positives, but better be safe than sorry
|
|
if ( target_canon.empty() &&
|
|
target_dir.find( ".." ) != std::string::npos ) {
|
|
return { false, "Invalid target" };
|
|
}
|
|
if ( !FSLib::exists( target_dir ) ) {
|
|
FSLib::createDirectoryFull( target_dir );
|
|
}
|
|
return { FSLib::rename( path, target_dir + FSLib::dir_divisor +
|
|
FSLib::getFileName( path ) ),
|
|
"Library error" };
|
|
}
|
|
|
|
std::string moveJson( const std::string &path, uint64_t target_id,
|
|
const std::string &containing_dir ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"success\": ";
|
|
auto move_result = move( path, target_id, containing_dir );
|
|
if ( move_result.first ) {
|
|
res << "true";
|
|
} else {
|
|
res << "false";
|
|
}
|
|
if ( !move_result.first ) {
|
|
res << ",\n";
|
|
res << " \"error\": \"" << safeJson( move_result.second ) << "\"\n";
|
|
} else {
|
|
res << "\n";
|
|
}
|
|
res << "}";
|
|
return res.str();
|
|
}
|
|
|
|
void moveRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
std::string containing_dir;
|
|
if ( doc.FindMember( "path" ) == doc.MemberEnd() ||
|
|
!doc["path"].IsString() ) {
|
|
// TODO validate path, also validate against config
|
|
sendResponse( "ERROR: Invalid path!", 401, session );
|
|
return;
|
|
}
|
|
uint64_t id = 0;
|
|
if ( doc.FindMember( "target_id" ) == doc.MemberEnd() ||
|
|
!doc["target_id"].IsUint64() ||
|
|
( id = doc["target_id"].GetUint64() ) >=
|
|
cfg.getTargetPaths().size() ) {
|
|
sendResponse( "ERROR: Invalid target_id!", 401, session );
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "containing_dir" ) != doc.MemberEnd() &&
|
|
doc["containing_dir"].IsString() ) {
|
|
containing_dir = doc["containing_dir"].GetString();
|
|
}
|
|
std::string path = doc["path"].GetString();
|
|
// TODO correct response code
|
|
sendResponse( moveJson( path, id, containing_dir ), 200, session );
|
|
}
|
|
|
|
std::pair< bool, std::string > remove( std::string path ) {
|
|
if ( path[0] != '/' ) {
|
|
path = cfg.getSourcePath() + "/" + path;
|
|
}
|
|
|
|
auto canon_path = FSLib::canonical( path );
|
|
if ( canon_path.substr( 0, cfg.getSourcePath().length() ) !=
|
|
cfg.getSourcePath() ) {
|
|
return { false, "Invalid path" };
|
|
}
|
|
|
|
if ( !FSLib::exists( path ) ) {
|
|
return { false, "Source doesn't exist" };
|
|
}
|
|
return { FSLib::deleteFile( path ), "Library error" };
|
|
}
|
|
|
|
std::string removeJson( const std::string &path ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"success\": ";
|
|
auto remove_result = remove( path );
|
|
if ( remove_result.first ) {
|
|
res << "true";
|
|
} else {
|
|
res << "false";
|
|
}
|
|
if ( !remove_result.first ) {
|
|
res << ",\n";
|
|
res << " \"error\": \"" << safeJson( remove_result.second ) << "\"\n";
|
|
} else {
|
|
res << "\n";
|
|
}
|
|
res << "}";
|
|
return res.str();
|
|
}
|
|
|
|
void removeRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "path" ) == doc.MemberEnd() ||
|
|
!doc["path"].IsString() ) {
|
|
// TODO validate path, also validate against config
|
|
sendResponse( "ERROR: Invalid path!", 401, session );
|
|
return;
|
|
}
|
|
std::string path = doc["path"].GetString();
|
|
// TODO correct response code
|
|
sendResponse( removeJson( path ), 200, session );
|
|
}
|
|
|
|
std::string loginJson( const std::string &user ) {
|
|
std::ostringstream res;
|
|
res << "{\n \"token\": \"" << createLoginToken( user ) << "\"\n}";
|
|
return res.str();
|
|
}
|
|
|
|
void loginRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( doc.FindMember( "user" ) == doc.MemberEnd() ||
|
|
!doc["user"].IsString() ) {
|
|
sendResponse( "ERROR: Invalid user!", 401, session );
|
|
return;
|
|
}
|
|
if ( doc.FindMember( "password" ) == doc.MemberEnd() ||
|
|
!doc["password"].IsString() ) {
|
|
sendResponse( "ERROR: Invalid password!", 401, session );
|
|
return;
|
|
}
|
|
const auto *user = doc["user"].GetString();
|
|
const auto *password = doc["password"].GetString();
|
|
bool valid = false;
|
|
for ( const auto &user_cfg : cfg.getUsers() ) {
|
|
if ( user_cfg.first == user ) {
|
|
valid = user_cfg.second == password;
|
|
break;
|
|
}
|
|
}
|
|
if ( valid ) {
|
|
sendResponse( loginJson( user ), 200, session );
|
|
} else {
|
|
sendResponse( "Invalid user/password", 401, session );
|
|
}
|
|
}
|
|
|
|
std::tuple< bool, bool, std::string >
|
|
exists( std::string path, bool is_in_source, uint64_t target_id ) {
|
|
if ( target_id >= cfg.getTargetPaths().size() && !is_in_source ) {
|
|
return { false, false, "Invalid target_id" };
|
|
}
|
|
if ( path[0] != '/' ) {
|
|
if ( is_in_source ) {
|
|
path = cfg.getSourcePath() + "/" + path;
|
|
} else {
|
|
path = cfg.getTargetPaths()[target_id].first + "/" + path;
|
|
}
|
|
}
|
|
|
|
// check non-canon path doesn't point outside of scope
|
|
if ( is_in_source ) {
|
|
if ( path.substr( 0, cfg.getSourcePath().length() ) !=
|
|
cfg.getSourcePath() ) {
|
|
return { false, false, "Invalid path" };
|
|
}
|
|
} else {
|
|
auto target_dir = cfg.getTargetPaths()[target_id].first;
|
|
if ( path.substr( 0, target_dir.length() ) != target_dir ) {
|
|
return { false, false, "Invalid path" };
|
|
}
|
|
}
|
|
// if file doesn't exist it cannot be a symlink to outside of scope
|
|
if ( !FSLib::exists( path ) ) {
|
|
return { true, false, "" };
|
|
}
|
|
|
|
// now check if it's not a symlink pointing somewhere outside of scope
|
|
auto canon_path = FSLib::canonical( path );
|
|
if ( is_in_source ) {
|
|
if ( canon_path.substr( 0, cfg.getSourcePath().length() ) !=
|
|
cfg.getSourcePath() ) {
|
|
return { false, false, "Invalid path" };
|
|
}
|
|
} else {
|
|
auto target_dir = cfg.getTargetPaths()[target_id].first;
|
|
if ( canon_path.substr( 0, target_dir.length() ) != target_dir ) {
|
|
return { false, false, "Invalid path" };
|
|
}
|
|
}
|
|
|
|
// we've already checked if file exists
|
|
return { true, true, "" };
|
|
}
|
|
|
|
std::string existsJson( const std::string &path, bool is_in_source,
|
|
uint64_t target_id ) {
|
|
auto exists_result = exists( path, is_in_source, target_id );
|
|
auto success = std::get< 0 >( exists_result );
|
|
auto exists = std::get< 1 >( exists_result );
|
|
auto error = std::get< 2 >( exists_result );
|
|
std::ostringstream res;
|
|
res << "{\n \"success\": ";
|
|
if ( success ) {
|
|
res << "true";
|
|
} else {
|
|
res << "false";
|
|
}
|
|
res << ",\n";
|
|
res << " \"exists\": ";
|
|
if ( exists ) {
|
|
res << "true";
|
|
} else {
|
|
res << "false";
|
|
}
|
|
if ( !success ) {
|
|
res << ",\n";
|
|
res << " \"error\": \"" << safeJson( error ) << "\"\n";
|
|
} else {
|
|
res << "\n";
|
|
}
|
|
res << "}";
|
|
return res.str();
|
|
}
|
|
|
|
void existsRest( const std::shared_ptr< restbed::Session > &session,
|
|
rapidjson::GenericDocument< rapidjson::UTF8<> > &doc ) {
|
|
if ( !verifyLogin( session, doc ) ) {
|
|
return;
|
|
}
|
|
std::string containing_dir;
|
|
if ( doc.FindMember( "path" ) == doc.MemberEnd() ||
|
|
!doc["path"].IsString() ) {
|
|
// TODO validate path, also validate against config
|
|
sendResponse( "ERROR: Invalid path!", 401, session );
|
|
return;
|
|
}
|
|
auto path = doc["path"].GetString();
|
|
bool source = false;
|
|
if ( doc.FindMember( "source" ) != doc.MemberEnd() ) {
|
|
if ( !doc["source"].IsBool() ) {
|
|
sendResponse( "ERROR: source must be a bool!", 401, session );
|
|
} else {
|
|
source = doc["source"].GetBool();
|
|
}
|
|
}
|
|
uint64_t target_id = -1;
|
|
if ( doc.FindMember( "target_id" ) != doc.MemberEnd() ) {
|
|
if ( !doc["target_id"].IsUint64() ) {
|
|
sendResponse( "ERROR: Invalid target_id!", 401, session );
|
|
} else {
|
|
target_id = doc["target_id"].GetInt();
|
|
}
|
|
}
|
|
if ( !source && target_id == ( uint64_t )-1 ) {
|
|
sendResponse(
|
|
"ERROR: path is not in source, but no target_id was provided!", 401,
|
|
session );
|
|
}
|
|
// TODO correct response code
|
|
sendResponse( existsJson( path, source, target_id ), 200, session );
|
|
}
|
|
|
|
void getOptionsCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getOptionsRest );
|
|
}
|
|
|
|
void getCustomKeysCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getCustomKeysRest );
|
|
}
|
|
|
|
void getFieldOptionsCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getFieldOptionsRest );
|
|
}
|
|
|
|
void getFieldDefaultCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getFieldDefaultRest );
|
|
}
|
|
|
|
void getLibraryPatternCall(
|
|
const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getLibraryPatternRest );
|
|
}
|
|
|
|
void renameCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, renamePathRest );
|
|
}
|
|
|
|
void getFilesCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getFilesRest );
|
|
}
|
|
|
|
void getTargetsCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getTargetsRest );
|
|
}
|
|
|
|
void getTargetDirectoriesCall(
|
|
const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, getTargetDirectoriesRest );
|
|
}
|
|
|
|
void moveCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, moveRest );
|
|
}
|
|
|
|
void removeCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, removeRest );
|
|
}
|
|
|
|
void loginCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, loginRest );
|
|
}
|
|
|
|
void existsCall( const std::shared_ptr< restbed::Session > &session ) {
|
|
performPostFunc( session, existsRest );
|
|
}
|
|
|
|
int main( int argc, char **argv ) {
|
|
cfg.readConfiguration( "/etc/renameserver/main.cfg" );
|
|
|
|
libraries = getLibraries( cfg.getLibraries() );
|
|
for ( auto &library : libraries ) {
|
|
library.init( library.config );
|
|
}
|
|
|
|
restbed::Service service;
|
|
|
|
auto get_libraries = std::make_shared< restbed::Resource >();
|
|
get_libraries->set_path( "/get_libraries" );
|
|
get_libraries->set_method_handler( "GET", getLibrariesRest );
|
|
service.publish( get_libraries );
|
|
|
|
auto search = std::make_shared< restbed::Resource >();
|
|
search->set_path( "/search" );
|
|
search->set_method_handler( "POST", getOptionsCall );
|
|
service.publish( search );
|
|
|
|
auto custom_fields = std::make_shared< restbed::Resource >();
|
|
custom_fields->set_path( "/get_custom_fields" );
|
|
custom_fields->set_method_handler( "POST", getCustomKeysCall );
|
|
service.publish( custom_fields );
|
|
|
|
auto field_options = std::make_shared< restbed::Resource >();
|
|
field_options->set_path( "/get_field_options" );
|
|
field_options->set_method_handler( "POST", getFieldOptionsCall );
|
|
service.publish( field_options );
|
|
|
|
auto field_default = std::make_shared< restbed::Resource >();
|
|
field_default->set_path( "/get_field_default" );
|
|
field_default->set_method_handler( "POST", getFieldDefaultCall );
|
|
service.publish( field_default );
|
|
|
|
auto library_pattern = std::make_shared< restbed::Resource >();
|
|
library_pattern->set_path( "/get_library_pattern" );
|
|
library_pattern->set_method_handler( "POST", getLibraryPatternCall );
|
|
service.publish( library_pattern );
|
|
|
|
// TODO multifile rename
|
|
auto rename_path = std::make_shared< restbed::Resource >();
|
|
rename_path->set_path( "/rename" );
|
|
rename_path->set_method_handler( "POST", renameCall );
|
|
service.publish( rename_path );
|
|
|
|
auto get_files = std::make_shared< restbed::Resource >();
|
|
get_files->set_path( "/get_files" );
|
|
get_files->set_method_handler( "POST", getFilesCall );
|
|
service.publish( get_files );
|
|
|
|
auto get_targets = std::make_shared< restbed::Resource >();
|
|
get_targets->set_path( "/get_targets" );
|
|
get_targets->set_method_handler( "POST", getTargetsCall );
|
|
service.publish( get_targets );
|
|
|
|
auto get_target_directories = std::make_shared< restbed::Resource >();
|
|
get_target_directories->set_path( "/get_target_directories" );
|
|
get_target_directories->set_method_handler( "POST",
|
|
getTargetDirectoriesCall );
|
|
service.publish( get_target_directories );
|
|
|
|
auto move = std::make_shared< restbed::Resource >();
|
|
move->set_path( "/move" );
|
|
move->set_method_handler( "POST", moveCall );
|
|
service.publish( move );
|
|
|
|
auto remove = std::make_shared< restbed::Resource >();
|
|
remove->set_path( "/remove" );
|
|
remove->set_method_handler( "POST", removeCall );
|
|
service.publish( remove );
|
|
|
|
auto login = std::make_shared< restbed::Resource >();
|
|
login->set_path( "/login" );
|
|
login->set_method_handler( "POST", loginCall );
|
|
service.publish( login );
|
|
|
|
auto exists = std::make_shared< restbed::Resource >();
|
|
exists->set_path( "/exists" );
|
|
exists->set_method_handler( "POST", existsCall );
|
|
service.publish( exists );
|
|
|
|
auto settings = std::make_shared< restbed::Settings >();
|
|
settings->set_port( 1984 );
|
|
settings->set_default_header( "Connection", "close" );
|
|
|
|
service.start( settings );
|
|
|
|
return 0;
|
|
}
|