tesses50/tesses-framework
1
0
Fork 0
mirror of https://onedev.site.tesses.net/tesses-framework synced 2026-02-08 15:55:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make streams and vfs and http shared_ptr

Browse Source
This commit is contained in:
Mike Nolan
2025-09-29 02:22:27 -05:00
parent 71d0e36a5c
commit d785508571
61 changed files with 541 additions and 951 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/Crypto/ClientTLSStream.cpp
View File

@@ -25,9 +25,8 @@ namespace Tesses::Framework::Crypto
class ClientTLSPrivateData {
public:
bool eos;
bool owns;
bool success;
Stream* strm;
std::shared_ptr<Stream> strm;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
mbedtls_ssl_context ssl;
@@ -40,7 +39,6 @@ namespace Tesses::Framework::Crypto
mbedtls_entropy_free(&entropy);
mbedtls_ssl_config_free(&conf);
mbedtls_ssl_free(&ssl);
if(this->owns) delete strm;
}
};
#endif
@@ -59,12 +57,12 @@ namespace Tesses::Framework::Crypto
return "";
}
ClientTLSStream::ClientTLSStream(Tesses::Framework::Streams::Stream* innerStream, bool owns, bool verify, std::string domain) : ClientTLSStream(innerStream,owns,verify,domain,"")
ClientTLSStream::ClientTLSStream(std::shared_ptr<Tesses::Framework::Streams::Stream> innerStream, bool verify, std::string domain) : ClientTLSStream(innerStream,verify,domain,"")
{
}
ClientTLSStream::ClientTLSStream(Tesses::Framework::Streams::Stream* innerStream, bool owns, bool verify, std::string domain, std::string cert)
ClientTLSStream::ClientTLSStream(std::shared_ptr<Tesses::Framework::Streams::Stream> innerStream, bool verify, std::string domain, std::string cert)
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
if(cert.empty())
@@ -77,7 +75,7 @@ namespace Tesses::Framework::Crypto
data->eos=false;
data->success=false;
data->strm = innerStream;
data->owns = owns;
mbedtls_ssl_init(&data->ssl);
mbedtls_ssl_config_init(&data->conf);

51
src/Crypto/MbedHelpers.cpp
View File

@@ -83,7 +83,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha1::Update(Tesses::Framework::Streams::Stream* strm)
bool Sha1::Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
if(strm == nullptr) return false;
@@ -97,10 +97,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha1::Update(Tesses::Framework::Streams::Stream& strm)
{
return Update(&strm);
}
std::vector<uint8_t> Sha1::Finish()
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
@@ -127,20 +124,14 @@ namespace Tesses::Framework::Crypto
if(!sha1.Update(buffer,len)) return {};
return sha1.Finish();
}
std::vector<uint8_t> Sha1::ComputeHash(Tesses::Framework::Streams::Stream* strm)
{
Sha1 sha1;
if(!sha1.Start()) return {};
if(!sha1.Update(strm)) return {};
return sha1.Finish();
}
std::vector<uint8_t> Sha1::ComputeHash(Tesses::Framework::Streams::Stream& strm)
std::vector<uint8_t> Sha1::ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
Sha1 sha1;
if(!sha1.Start()) return {};
if(!sha1.Update(strm)) return {};
return sha1.Finish();
}
Sha256::Sha256()
{
@@ -175,7 +166,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha256::Update(Tesses::Framework::Streams::Stream* strm)
bool Sha256::Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
if(strm == nullptr) return false;
@@ -189,10 +180,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha256::Update(Tesses::Framework::Streams::Stream& strm)
{
return Update(&strm);
}
std::vector<uint8_t> Sha256::Finish()
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
@@ -219,14 +207,7 @@ namespace Tesses::Framework::Crypto
if(!sha256.Update(buffer,len)) return {};
return sha256.Finish();
}
std::vector<uint8_t> Sha256::ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is224)
{
Sha256 sha256;
if(!sha256.Start(is224)) return {};
if(!sha256.Update(strm)) return {};
return sha256.Finish();
}
std::vector<uint8_t> Sha256::ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is224)
std::vector<uint8_t> Sha256::ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,bool is224)
{
Sha256 sha256;
if(!sha256.Start(is224)) return {};
@@ -234,6 +215,7 @@ namespace Tesses::Framework::Crypto
return sha256.Finish();
}
Sha512::Sha512()
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
@@ -265,7 +247,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha512::Update(Tesses::Framework::Streams::Stream* strm)
bool Sha512::Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
if(strm == nullptr) return false;
@@ -279,10 +261,7 @@ namespace Tesses::Framework::Crypto
#endif
return false;
}
bool Sha512::Update(Tesses::Framework::Streams::Stream& strm)
{
return Update(&strm);
}
std::vector<uint8_t> Sha512::Finish()
{
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
@@ -310,20 +289,14 @@ namespace Tesses::Framework::Crypto
if(!sha512.Update(buffer,len)) return {};
return sha512.Finish();
}
std::vector<uint8_t> Sha512::ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is384)
{
Sha512 sha512;
if(!sha512.Start(is384)) return {};
if(!sha512.Update(strm)) return {};
return sha512.Finish();
}
std::vector<uint8_t> Sha512::ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is384)
std::vector<uint8_t> Sha512::ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,bool is384)
{
Sha512 sha512;
if(!sha512.Start(is384)) return {};
if(!sha512.Update(strm)) return {};
return sha512.Finish();
}
bool PBKDF2(std::vector<uint8_t>& output,std::string pass, std::vector<uint8_t>& salt, long itterations, ShaVersion version)

45
src/Filesystem/LocalFS.cpp
View File

@@ -8,6 +8,7 @@
#undef min
#else
#include <utime.h>
#include <sys/statvfs.h>
#endif
namespace Tesses::Framework::Filesystem
{
@@ -71,9 +72,9 @@ namespace Tesses::Framework::Filesystem
auto res = std::filesystem::read_symlink(this->VFSPathToSystem(path)).string();
return this->SystemToVFSPath(res.c_str());
}
Tesses::Framework::Streams::Stream* LocalFilesystem::OpenFile(VFSPath path, std::string mode)
std::shared_ptr<Tesses::Framework::Streams::Stream> LocalFilesystem::OpenFile(VFSPath path, std::string mode)
{
return new Tesses::Framework::Streams::FileStream(VFSPathToSystem(path), mode);
return std::make_shared<Tesses::Framework::Streams::FileStream>(VFSPathToSystem(path), mode);
}
void LocalFilesystem::DeleteDirectory(VFSPath path)
@@ -191,7 +192,45 @@ namespace Tesses::Framework::Filesystem
delete dir;
});
}
LocalFilesystem LocalFS;
bool LocalFilesystem::StatVFS(VFSPath path, StatVFSData& data)
{
auto pathStr = this->VFSPathToSystem(path);
#if defined(_WIN32)
//not supporting windows yet
VFS::StatVFS(path, data);
return true;
#else
struct statvfs vfs;
if(statvfs(pathStr.c_str(), &vfs) == 0)
{
data.BlockSize = vfs.f_bsize;
data.FragmentSize = vfs.f_frsize;
data.Blocks = vfs.f_blocks;
data.BlocksFree = vfs.f_bfree;
data.BlocksAvailable = vfs.f_bavail;
data.TotalInodes = vfs.f_files;
data.FreeInodes = vfs.f_ffree;
data.AvailableInodes = vfs.f_favail;
data.Id = vfs.f_fsid;
data.Flags = vfs.f_flag;
data.MaxNameLength = vfs.f_namemax;
return true;
}
return false;
#endif
}
void LocalFilesystem::Chmod(VFSPath path, uint32_t mode)
{
auto pathStr = this->VFSPathToSystem(path);
#if defined(_WIN32)
#else
chmod(pathStr.c_str(), (mode_t)mode);
#endif
}
std::shared_ptr<LocalFilesystem> LocalFS;
}
// C:/Users/Jim/Joel

10
src/Filesystem/MemoryFilesystem.cpp
View File

@@ -116,7 +116,7 @@ namespace Tesses::Framework::Filesystem
return nullptr;
}
Streams::Stream* MemoryFilesystem::OpenFile(VFSPath path, std::string mode)
std::shared_ptr<Streams::Stream> MemoryFilesystem::OpenFile(VFSPath path, std::string mode)
{
bool canRead=false;
bool canWrite=false;
@@ -181,7 +181,7 @@ namespace Tesses::Framework::Filesystem
if(canWrite) f->data->canAccess=false;
mtx->Unlock();
return new MemoryFilesystemStream(mtx,f->data,canRead,canWrite,canSeek);
return std::make_shared<MemoryFilesystemStream>(mtx,f->data,canRead,canWrite,canSeek);
}
else
{
@@ -204,7 +204,7 @@ namespace Tesses::Framework::Filesystem
file->data->readers++;
if(truncate) {file->data->file.clear(); file->data->lastWrite=Date::DateTime::NowUTC();}
mtx->Unlock();
return new MemoryFilesystemStream(mtx,file->data,canRead,canWrite,canSeek);
return std::make_shared<MemoryFilesystemStream>(mtx,file->data,canRead,canWrite,canSeek);
}
@@ -287,7 +287,7 @@ namespace Tesses::Framework::Filesystem
myDir->entries.push_back(f);
mtx->Unlock();
return new MemoryFilesystemStream(mtx,f->data,canRead,canWrite,canSeek);
return std::make_shared<MemoryFilesystemStream>(mtx,f->data,canRead,canWrite,canSeek);
}
if(thefile != nullptr)
{
@@ -305,7 +305,7 @@ namespace Tesses::Framework::Filesystem
thefile->data->readers++;
if(truncate) {thefile->data->file.clear(); thefile->data->lastWrite=Date::DateTime::NowUTC();}
mtx->Unlock();
return new MemoryFilesystemStream(mtx,thefile->data,canRead,canWrite,canSeek);
return std::make_shared<MemoryFilesystemStream>(mtx,thefile->data,canRead,canWrite,canSeek);
}
}

96
src/Filesystem/MountableFilesystem.cpp
View File

@@ -3,29 +3,26 @@
#include <iostream>
namespace Tesses::Framework::Filesystem
{
MountableFilesystem::MountableFilesystem() : MountableFilesystem(new NullFilesystem(),true)
MountableFilesystem::MountableFilesystem() : MountableFilesystem(std::make_shared<NullFilesystem>())
{
}
MountableFilesystem::MountableFilesystem(VFS* root, bool owns)
MountableFilesystem::MountableFilesystem(std::shared_ptr<VFS> root)
{
this->root = root;
this->owns = owns;
}
MountableDirectory::~MountableDirectory()
{
if(this->owns && this->vfs) delete this->vfs;
for(auto dir : this->dirs) delete dir;
}
MountableFilesystem::~MountableFilesystem()
{
if(this->owns && this->root) delete root;
for(auto item : this->directories) delete item;
}
void MountableFilesystem::GetFS(VFSPath srcPath, VFSPath& destRoot, VFSPath& destPath, VFS*& vfs)
void MountableFilesystem::GetFS(VFSPath srcPath, VFSPath& destRoot, VFSPath& destPath, std::shared_ptr<VFS>& vfs)
{
if(srcPath.path.empty()) return;
for(auto item : this->directories)
@@ -52,7 +49,7 @@ namespace Tesses::Framework::Filesystem
void MountableDirectory::GetFS(VFSPath srcPath, VFSPath curDir, VFSPath& destRoot, VFSPath& destPath, VFS*& vfs)
void MountableDirectory::GetFS(VFSPath srcPath, VFSPath curDir, VFSPath& destRoot, VFSPath& destPath, std::shared_ptr<VFS>& vfs)
{
if(srcPath.path.empty()) return;
for(auto item : this->dirs)
@@ -83,7 +80,7 @@ namespace Tesses::Framework::Filesystem
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
@@ -91,12 +88,37 @@ namespace Tesses::Framework::Filesystem
return VFSPath();
}
Tesses::Framework::Streams::Stream* MountableFilesystem::OpenFile(VFSPath path, std::string mode)
bool MountableFilesystem::StatVFS(VFSPath path, StatVFSData& data)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->StatVFS(destPath,data);
return false;
}
void MountableFilesystem::Chmod(VFSPath path, uint32_t mode)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
vfs->Chmod(destPath,mode);
}
std::shared_ptr<Tesses::Framework::Streams::Stream> MountableFilesystem::OpenFile(VFSPath path, std::string mode)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -110,7 +132,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -128,7 +150,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -145,7 +167,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -160,7 +182,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -174,7 +196,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -189,7 +211,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -203,7 +225,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -217,7 +239,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -232,7 +254,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -248,7 +270,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -265,7 +287,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(destPath.path.empty()) return true;
@@ -280,7 +302,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -295,7 +317,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -309,7 +331,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -323,10 +345,10 @@ namespace Tesses::Framework::Filesystem
VFSPath existingDestRoot;
VFSPath existingDestPath = existingFile;
VFS* existingVFS = root;
std::shared_ptr<VFS> existingVFS = root;
VFSPath symlinkDestRoot;
VFSPath symlinkDestPath = symlinkFile;
VFS* symlinkVFS = root;
std::shared_ptr<VFS> symlinkVFS = root;
GetFS(existingFile, existingDestRoot, existingDestPath, existingVFS);
GetFS(symlinkFile, symlinkDestRoot, symlinkDestPath, symlinkVFS);
@@ -342,10 +364,10 @@ namespace Tesses::Framework::Filesystem
VFSPath srcDestRoot;
VFSPath srcDestPath = src;
VFS* srcVFS = root;
std::shared_ptr<VFS> srcVFS = root;
VFSPath destDestRoot;
VFSPath destDestPath = dest;
VFS* destVFS = root;
std::shared_ptr<VFS> destVFS = root;
GetFS(src, srcDestRoot, srcDestPath, srcVFS);
GetFS(dest, destDestRoot, destDestPath, destVFS);
@@ -360,10 +382,10 @@ namespace Tesses::Framework::Filesystem
VFSPath srcDestRoot;
VFSPath srcDestPath = src;
VFS* srcVFS = root;
std::shared_ptr<VFS> srcVFS = root;
VFSPath destDestRoot;
VFSPath destDestPath = dest;
VFS* destVFS = root;
std::shared_ptr<VFS> destVFS = root;
GetFS(src, srcDestRoot, srcDestPath, srcVFS);
GetFS(dest, destDestRoot, destDestPath, destVFS);
@@ -378,10 +400,10 @@ namespace Tesses::Framework::Filesystem
VFSPath existingDestRoot;
VFSPath existingDestPath = existingFile;
VFS* existingVFS = root;
std::shared_ptr<VFS> existingVFS = root;
VFSPath newNameRoot;
VFSPath newNamePath = newName;
VFS* newNameVFS = root;
std::shared_ptr<VFS> newNameVFS = root;
GetFS(existingFile, existingDestRoot, existingDestPath, existingVFS);
GetFS(newName, newNameRoot, newNamePath, newNameVFS);
@@ -427,7 +449,7 @@ namespace Tesses::Framework::Filesystem
VFSPath destRoot;
VFSPath destPath = path;
VFS* vfs = root;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
@@ -476,13 +498,12 @@ namespace Tesses::Framework::Filesystem
});
}
void MountableFilesystem::Mount(VFSPath path, VFS* fs, bool owns)
void MountableFilesystem::Mount(VFSPath path, std::shared_ptr<VFS> fs)
{
path = path.CollapseRelativeParents();
if(path.path.empty())
{
if(owns) delete fs;
return;
}
@@ -520,7 +541,7 @@ namespace Tesses::Framework::Filesystem
if(item->name == lastDir)
{
needToCreate=false;
if(item->owns && item->vfs) delete item->vfs;
item->vfs = fs;
break;
}
@@ -530,7 +551,7 @@ namespace Tesses::Framework::Filesystem
{
MountableDirectory* dir = new MountableDirectory();
dir->name = lastDir;
dir->owns=owns;
dir->vfs=fs;
fsLs->push_back(dir);
}
@@ -541,7 +562,6 @@ namespace Tesses::Framework::Filesystem
{
if(path.path.empty())
{
if(dir->owns && dir->vfs) delete dir->vfs;
dir->vfs = nullptr;
}

2
src/Filesystem/NullFilesystem.cpp
View File

@@ -2,7 +2,7 @@
namespace Tesses::Framework::Filesystem
{
Tesses::Framework::Streams::Stream* NullFilesystem::OpenFile(VFSPath path, std::string mode)
std::shared_ptr<Tesses::Framework::Streams::Stream> NullFilesystem::OpenFile(VFSPath path, std::string mode)
{
return nullptr;
}

21
src/Filesystem/SubdirFilesystem.cpp
View File

@@ -29,10 +29,10 @@ namespace Tesses::Framework::Filesystem
{
return this->path / path.CollapseRelativeParents();
}
SubdirFilesystem::SubdirFilesystem(VFS* parent, VFSPath path, bool owns)
SubdirFilesystem::SubdirFilesystem(std::shared_ptr<VFS> parent, VFSPath path)
{
this->parent = parent;
if(path.relative && dynamic_cast<LocalFilesystem*>(parent) != nullptr)
if(path.relative && std::dynamic_pointer_cast<LocalFilesystem>(parent) != nullptr)
{
Tesses::Framework::Filesystem::LocalFilesystem lfs;
auto curDir = std::filesystem::current_path();
@@ -41,9 +41,9 @@ namespace Tesses::Framework::Filesystem
}
else
this->path = path;
this->owns=owns;
}
Tesses::Framework::Streams::Stream* SubdirFilesystem::OpenFile(VFSPath path, std::string mode)
std::shared_ptr<Tesses::Framework::Streams::Stream> SubdirFilesystem::OpenFile(VFSPath path, std::string mode)
{
return this->parent->OpenFile(ToParent(path),mode);
}
@@ -151,7 +151,16 @@ namespace Tesses::Framework::Filesystem
SubdirFilesystem::~SubdirFilesystem()
{
if(this->owns)
delete this->parent;
}
bool SubdirFilesystem::StatVFS(VFSPath path, StatVFSData& vfsData)
{
return this->parent->StatVFS(path, vfsData);
}
void SubdirFilesystem::Chmod(VFSPath path, uint32_t mode)
{
return this->parent->Chmod(path, mode);
}
}

22
src/Filesystem/VFS.cpp
View File

@@ -194,11 +194,11 @@ namespace Tesses::Framework::Filesystem
VFSPath VFSPath::GetAbsoluteCurrentDirectory()
{
auto p = std::filesystem::current_path();
return LocalFS.SystemToVFSPath(p.string());
return LocalFS->SystemToVFSPath(p.string());
}
void VFSPath::SetAbsoluteCurrentDirectory(VFSPath path)
{
auto res = LocalFS.VFSPathToSystem(path);
auto res = LocalFS->VFSPathToSystem(path);
std::filesystem::path mpath=res;
std::filesystem::current_path(mpath);
}
@@ -499,5 +499,23 @@ namespace Tesses::Framework::Filesystem
{
}
bool VFS::StatVFS(VFSPath path, StatVFSData& data)
{
data.BlockSize = 512;
data.Blocks=10000000000000;
data.BlocksFree=10000000000000;
data.BlocksAvailable=10000000000000;
data.AvailableInodes=10000000000000;
data.TotalInodes=10000000000000;
data.FreeInodes=10000000000000;
data.FragmentSize=512;
data.Id = 85138;
data.Flags = 0;
data.MaxNameLength=255;
return true;
}
void VFS::Chmod(VFSPath path, uint32_t mode) {
}
}

14
src/Http/FileServer.cpp
View File

@@ -15,23 +15,20 @@ namespace Tesses::Framework::Http
}
FileServer::FileServer(std::filesystem::path path,bool allowListing, bool spa, std::vector<std::string> defaultNames)
{
LocalFilesystem* lfs=new LocalFilesystem();
SubdirFilesystem* sdfs=new SubdirFilesystem(lfs,lfs->SystemToVFSPath(path.string()),true);
std::shared_ptr<SubdirFilesystem> sdfs=std::make_shared<SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(path.string()));
this->vfs = sdfs;
this->spa = spa;
this->ownsVFS=true;
this->allowListing = allowListing;
this->defaultNames = defaultNames;
}
FileServer::FileServer(Tesses::Framework::Filesystem::VFS* fs, bool owns, bool allowListing,bool spa) : FileServer(fs,owns,allowListing,spa,{"index.html","default.html","index.htm","default.htm"})
FileServer::FileServer(std::shared_ptr<Tesses::Framework::Filesystem::VFS> fs, bool allowListing,bool spa) : FileServer(fs,allowListing,spa,{"index.html","default.html","index.htm","default.htm"})
{
}
FileServer::FileServer(Tesses::Framework::Filesystem::VFS* fs, bool owns, bool allowListing, bool spa, std::vector<std::string> defaultNames)
FileServer::FileServer(std::shared_ptr<Tesses::Framework::Filesystem::VFS> fs, bool allowListing, bool spa, std::vector<std::string> defaultNames)
{
this->vfs = fs;
this->ownsVFS = owns;
this->allowListing = allowListing;
this->defaultNames = defaultNames;
this->spa = spa;
@@ -49,8 +46,6 @@ namespace Tesses::Framework::Http
retVal = true;
}
delete strm;
return retVal;
}
@@ -130,7 +125,6 @@ namespace Tesses::Framework::Http
}
FileServer::~FileServer()
{
if(this->ownsVFS)
delete this->vfs;
}
}

109
src/Http/HttpClient.cpp
View File

@@ -41,7 +41,7 @@ namespace Tesses::Framework::Http
dict.SetValue("Content-Type",this->mimeType);
dict.SetValue("Content-Length",std::to_string(this->text.size()));
}
void TextHttpRequestBody::Write(Tesses::Framework::Streams::Stream* strm)
void TextHttpRequestBody::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
strm->WriteBlock((const uint8_t*)this->text.c_str(),this->text.size());
}
@@ -50,10 +50,9 @@ namespace Tesses::Framework::Http
}
StreamHttpRequestBody::StreamHttpRequestBody(Stream* strm, bool owns, std::string mimeType)
StreamHttpRequestBody::StreamHttpRequestBody(std::shared_ptr<Stream> strm, std::string mimeType)
{
this->strm = strm;
this->owns = owns;
this->mimeType = mimeType;
}
void StreamHttpRequestBody::HandleHeaders(HttpDictionary& dict)
@@ -63,14 +62,12 @@ namespace Tesses::Framework::Http
if(len > -1) dict.AddValue("Content-Length",std::to_string(len));
}
void StreamHttpRequestBody::Write(Tesses::Framework::Streams::Stream* strm)
void StreamHttpRequestBody::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
this->strm->CopyTo(strm);
}
StreamHttpRequestBody::~StreamHttpRequestBody()
{
if(this->owns)
delete this->strm;
}
HttpRequest::HttpRequest()
{
@@ -82,7 +79,7 @@ namespace Tesses::Framework::Http
this->requestHeaders.SetValue("Connection","close");
}
void HttpRequest::SendRequest(Tesses::Framework::Streams::Stream* strm)
void HttpRequest::SendRequest(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
Uri uri;
if(!Uri::TryParse(this->url, uri)) return;
@@ -109,7 +106,7 @@ namespace Tesses::Framework::Http
request.append("\r\n");
StreamWriter writer(strm, false);
StreamWriter writer(strm);
writer.Write(request);
if(body != nullptr)
@@ -117,52 +114,51 @@ namespace Tesses::Framework::Http
body->Write(strm);
}
}
Stream* HttpRequest::EstablishConnection(Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle)
std::shared_ptr<Stream> HttpRequest::EstablishConnection(Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle)
{
if(uri.scheme == "http:" || uri.scheme == "ws:")
{
return new NetworkStream(uri.host,uri.GetPort(),false,false,false);
return std::make_shared<NetworkStream>(uri.host,uri.GetPort(),false,false,false);
}
else if(uri.scheme == "https:" || uri.scheme == "wss:")
{
auto netStrm = new NetworkStream(uri.host,uri.GetPort(),false,false,false);
auto netStrm = std::make_shared<NetworkStream>(uri.host,uri.GetPort(),false,false,false);
if(netStrm == nullptr) return nullptr;
return new ClientTLSStream(netStrm, true, !ignoreSSLErrors,uri.host, trusted_root_cert_bundle);
return std::make_shared<ClientTLSStream>(netStrm, !ignoreSSLErrors,uri.host, trusted_root_cert_bundle);
}
return nullptr;
}
Stream* HttpRequest::EstablishUnixPathConnection(std::string unixPath,Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle)
std::shared_ptr<Stream> HttpRequest::EstablishUnixPathConnection(std::string unixPath,Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle)
{
if(uri.scheme == "http:" || uri.scheme == "ws:")
{
return new NetworkStream(unixPath,false);
return std::make_shared<NetworkStream>(unixPath,false);
}
else if(uri.scheme == "https:" || uri.scheme == "wss:")
{
auto netStrm = new NetworkStream(unixPath,false);
auto netStrm = std::make_shared <NetworkStream>(unixPath,false);
if(netStrm == nullptr) return nullptr;
return new ClientTLSStream(netStrm, true, !ignoreSSLErrors,uri.host, trusted_root_cert_bundle);
return std::make_shared<ClientTLSStream>(netStrm, !ignoreSSLErrors,uri.host, trusted_root_cert_bundle);
}
return nullptr;
}
Tesses::Framework::Streams::Stream* HttpResponse::GetInternalStream()
std::shared_ptr<Tesses::Framework::Streams::Stream> HttpResponse::GetInternalStream()
{
return this->handleStrm;
}
HttpResponse::~HttpResponse()
{
if(this->owns)
delete this->handleStrm;
}
HttpResponse::HttpResponse(Stream* strm, bool owns)
HttpResponse::HttpResponse(std::shared_ptr<Stream> strm)
{
this->handleStrm=nullptr;
this->owns=owns;
StreamReader reader(strm, false);
StreamReader reader(strm);
std::string statusLine;
if(!reader.ReadLine(statusLine)) return;
auto statusLinesPart = HttpUtils::SplitString(statusLine," ",3);
@@ -178,7 +174,6 @@ namespace Tesses::Framework::Http
auto v = HttpUtils::SplitString(line,": ", 2);
if(v.size() != 2)
{
delete strm;
return;
}
this->responseHeaders.AddValue(v[0],v[1]);
@@ -222,7 +217,7 @@ namespace Tesses::Framework::Http
request.append("\r\n");
StreamWriter writer(strm, false);
StreamWriter writer(strm);
writer.Write(request);
if(req.body != nullptr)
@@ -230,7 +225,7 @@ namespace Tesses::Framework::Http
req.body->Write(strm);
}
StreamReader reader(strm, false);
StreamReader reader(strm);
std::string statusLine;
if(!reader.ReadLine(statusLine)) break;
auto statusLinesPart = HttpUtils::SplitString(statusLine," ",3);
@@ -246,7 +241,6 @@ namespace Tesses::Framework::Http
auto v = HttpUtils::SplitString(line,": ", 2);
if(v.size() != 2)
{
delete strm;
return;
}
this->responseHeaders.AddValue(v[0],v[1]);
@@ -264,7 +258,6 @@ namespace Tesses::Framework::Http
url = uri2.ToString();
delete strm;
continue;
}
this->handleStrm = strm;
@@ -275,18 +268,18 @@ namespace Tesses::Framework::Http
{
auto strm = ReadAsStream();
if(strm == nullptr) return {};
StreamReader r(strm, true);
StreamReader r(strm);
return r.ReadToEnd();
}
void HttpResponse::CopyToStream(Stream* strm)
void HttpResponse::CopyToStream(std::shared_ptr<Stream> strm)
{
if(strm == nullptr) return;
auto src = ReadAsStream();
if(src == nullptr) return;
src->CopyTo(*strm);
delete src;
src->CopyTo(strm);
}
Stream* HttpResponse::ReadAsStream()
std::shared_ptr<Stream> HttpResponse::ReadAsStream()
{
if(this->handleStrm == nullptr) return nullptr;
int64_t length = -1;
@@ -295,10 +288,10 @@ namespace Tesses::Framework::Http
length = -1;
}
return new HttpStream(this->handleStrm,false,length,true,version=="HTTP/1.1");
return std::make_shared<HttpStream>(this->handleStrm,length,true,version=="HTTP/1.1");
}
void DownloadUnixSocketToStreamSimple(std::string unixSocket,std::string url, Tesses::Framework::Streams::Stream* strm)
void DownloadUnixSocketToStreamSimple(std::string unixSocket,std::string url, std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
if(strm == nullptr) throw std::runtime_error("strm is null");
HttpRequest request;
@@ -310,26 +303,17 @@ namespace Tesses::Framework::Http
if(response.statusCode < 200 || response.statusCode > 299) throw std::runtime_error("Status code does not indicate success: " + std::to_string(response.statusCode) + " " + HttpUtils::StatusCodeString(response.statusCode));
response.CopyToStream(strm);
}
void DownloadUnixSocketToStreamSimple(std::string unixSocket,std::string url, Tesses::Framework::Streams::Stream& strm)
{
DownloadUnixSocketToStreamSimple(unixSocket,url,&strm);
}
void DownloadUnixSocketToFileSimple(std::string unixSocket,std::string url, Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Filesystem::VFSPath path)
void DownloadUnixSocketToFileSimple(std::string unixSocket,std::string url, std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
{
if(vfs == nullptr) throw std::runtime_error("vfs is null");
auto strm = vfs->OpenFile(path,"wb");
if(strm == nullptr) throw std::runtime_error("strm is null");
DownloadUnixSocketToStreamSimple(unixSocket,url,strm);
delete strm;
}
void DownloadUnixSocketToFileSimple(std::string unixSocket,std::string url, Tesses::Framework::Filesystem::VFS& vfs, Tesses::Framework::Filesystem::VFSPath path)
{
auto strm = vfs.OpenFile(path,"wb");
if(strm == nullptr) throw std::runtime_error("strm is null");
DownloadUnixSocketToStreamSimple(unixSocket,url,strm);
delete strm;
}
void DownloadUnixSocketToFileSimple(std::string unixSocket,std::string url, Tesses::Framework::Filesystem::VFSPath path)
{
DownloadUnixSocketToFileSimple(unixSocket,url,Tesses::Framework::Filesystem::LocalFS,path);
@@ -345,23 +329,17 @@ namespace Tesses::Framework::Http
if(response.statusCode < 200 || response.statusCode > 299) throw std::runtime_error("Status code does not indicate success: " + std::to_string(response.statusCode) + " " + HttpUtils::StatusCodeString(response.statusCode));
return response.ReadAsString();
}
void DownloadToStreamSimple(std::string url, Tesses::Framework::Streams::Stream* strm)
{
DownloadUnixSocketToStreamSimple("",url,strm);
}
void DownloadToStreamSimple(std::string url, Tesses::Framework::Streams::Stream& strm)
void DownloadToStreamSimple(std::string url, std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
DownloadUnixSocketToStreamSimple("",url,strm);
}
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Filesystem::VFSPath path)
{
DownloadUnixSocketToFileSimple("",url,vfs,path);
}
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFS& vfs, Tesses::Framework::Filesystem::VFSPath path)
void DownloadToFileSimple(std::string url, std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
{
DownloadUnixSocketToFileSimple("",url,vfs,path);
}
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFSPath path)
{
DownloadUnixSocketToFileSimple("",url,path);
@@ -381,22 +359,15 @@ namespace Tesses::Framework::Http
{
return true;
}
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, WebSocketConnection& wsc, std::function<bool(HttpDictionary&,bool)> cb)
{
WebSocketUnixSocketClient("",url,requestHeaders,wsc,cb);
}
void WebSocketUnixSocketClient(std::string unixSocket,std::string url, HttpDictionary& requestHeaders, WebSocketConnection& wsc, std::function<bool(HttpDictionary&,bool)> cb)
{
WebSocketUnixSocketClient(unixSocket,url,requestHeaders, &wsc,cb);
}
class WSClient {
public:
std::atomic<bool> closed;
Threading::Mutex mtx;
WebSocketConnection* conn;
Stream* strm;
std::shared_ptr<WebSocketConnection> conn;
std::shared_ptr<Stream> strm;
void close()
{
mtx.Lock();
@@ -557,7 +528,7 @@ namespace Tesses::Framework::Http
return true;
}
WSClient(Tesses::Framework::Streams::Stream* strm,WebSocketConnection* conn)
WSClient(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::shared_ptr<WebSocketConnection> conn)
{
this->strm = strm;
this->conn = conn;
@@ -626,12 +597,12 @@ namespace Tesses::Framework::Http
};
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, WebSocketConnection* wsc, std::function<bool(HttpDictionary&,bool)> cb)
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, std::shared_ptr<WebSocketConnection> wsc, std::function<bool(HttpDictionary&,bool)> cb)
{
WebSocketUnixSocketClient("",url,requestHeaders,wsc,cb);
}
void WebSocketUnixSocketClient(std::string unixSocket,std::string url, HttpDictionary& requestHeaders, WebSocketConnection* wsc, std::function<bool(HttpDictionary&,bool)> cb)
void WebSocketUnixSocketClient(std::string unixSocket,std::string url, HttpDictionary& requestHeaders, std::shared_ptr<WebSocketConnection> wsc, std::function<bool(HttpDictionary&,bool)> cb)
{
HttpRequest req;
req.url = url;

149
src/Http/HttpServer.cpp
View File

@@ -29,8 +29,8 @@ namespace Tesses::Framework::Http
public:
Threading::Mutex mtx;
ServerContext* ctx;
WebSocketConnection* conn;
Stream* strm;
std::shared_ptr<WebSocketConnection> conn;
std::shared_ptr<Stream> strm;
std::atomic_bool hasInit;
std::atomic<bool> closed;
void close()
@@ -42,7 +42,6 @@ namespace Tesses::Framework::Http
strm->WriteByte(firstByte);
strm->WriteByte(0);
delete strm;
this->strm = nullptr;
mtx.Unlock();
this->conn->OnClose(true);
@@ -180,11 +179,11 @@ namespace Tesses::Framework::Http
return true;
}
WSServer(ServerContext* ctx,WebSocketConnection* conn)
WSServer(ServerContext* ctx,std::shared_ptr<WebSocketConnection> conn)
{
this->ctx = ctx;
this->conn = conn;
this->strm = &this->ctx->GetStream();
this->strm = this->ctx->GetStream();
this->hasInit=false;
@@ -352,27 +351,23 @@ namespace Tesses::Framework::Http
if(this->queryParams.kvp.empty()) return this->originalPath;
return this->originalPath + "?" + HttpUtils::QueryParamsEncode(this->queryParams);
}
void ServerContext::ReadStream(Stream* strm)
void ServerContext::ReadStream(std::shared_ptr<Stream> strm)
{
if(strm == nullptr) return;
auto strm2 = this->OpenRequestStream();
if(strm2 != nullptr)
{
strm2->CopyTo(strm);
delete strm2;
}
}
void ServerContext::ReadStream(Stream& strm)
{
ReadStream(&strm);
}
std::string ServerContext::ReadString()
{
if(strm == nullptr) return {};
auto strm2 = this->OpenRequestStream();
if(strm2 != nullptr)
{
TextStreams::StreamReader reader(strm2,true);
TextStreams::StreamReader reader(strm2);
return reader.ReadToEnd();
}
return {};
@@ -389,7 +384,7 @@ namespace Tesses::Framework::Http
}
return false;
}
static bool parseUntillBoundaryEnd(Tesses::Framework::Streams::Stream* src, Tesses::Framework::Streams::Stream* dest, std::string boundary)
static bool parseUntillBoundaryEnd(std::shared_ptr<Tesses::Framework::Streams::Stream> src, std::shared_ptr<Tesses::Framework::Streams::Stream> dest, std::string boundary)
{
bool hasMore=true;
#if defined(_WIN32)
@@ -466,7 +461,7 @@ namespace Tesses::Framework::Http
return hasMore;
}
static bool parseSection(ServerContext* ctx, std::string boundary, std::function<Tesses::Framework::Streams::Stream*(std::string mime, std::string filename, std::string name)> cb)
static bool parseSection(ServerContext* ctx, std::string boundary, std::function<std::shared_ptr<Tesses::Framework::Streams::Stream>(std::string mime, std::string filename, std::string name)> cb)
{
HttpDictionary req;
StreamReader reader(ctx->GetStream());
@@ -489,10 +484,10 @@ namespace Tesses::Framework::Http
{
if(cd1.filename.empty())
{
MemoryStream ms(true);
std::shared_ptr<MemoryStream> ms=std::make_shared<MemoryStream>(true);
bool retVal = parseUntillBoundaryEnd(&ctx->GetStream(),&ms,boundary);
auto& buff = ms.GetBuffer();
bool retVal = parseUntillBoundaryEnd(ctx->GetStream(),ms,boundary);
auto& buff = ms->GetBuffer();
ctx->queryParams.AddValue(cd1.fieldName, std::string(buff.begin(),buff.end()));
@@ -502,16 +497,16 @@ namespace Tesses::Framework::Http
else
{
auto strm = cb(ct, cd1.filename, cd1.fieldName);
if(strm == nullptr) strm = new Stream();
bool retVal = parseUntillBoundaryEnd(&ctx->GetStream(),strm,boundary);
delete strm;
if(strm == nullptr) strm = std::make_shared<Stream>();
bool retVal = parseUntillBoundaryEnd(ctx->GetStream(),strm,boundary);
return retVal;
}
}
return false;
}
void ServerContext::ParseFormData(std::function<Tesses::Framework::Streams::Stream*(std::string mime, std::string filename, std::string name)> cb)
void ServerContext::ParseFormData(std::function<std::shared_ptr<Tesses::Framework::Streams::Stream>(std::string mime, std::string filename, std::string name)> cb)
{
std::string ct;
if(this->requestHeaders.TryGetFirst("Content-Type",ct))
@@ -525,51 +520,33 @@ namespace Tesses::Framework::Http
if(res == std::string::npos) return;
ct = "--" + ct.substr(res+9);
}
Stream nullStrm;
parseUntillBoundaryEnd(this->strm,&nullStrm, ct);
std::shared_ptr<Stream> nullStrm=std::make_shared<Stream>();
parseUntillBoundaryEnd(this->strm,nullStrm, ct);
while(parseSection(this, ct, cb));
}
HttpServer::HttpServer(Tesses::Framework::Streams::TcpServer& tcpServer, IHttpServer& http, bool showIPs) : HttpServer(&tcpServer,false,&http,false,showIPs)
{
}
HttpServer::HttpServer(Tesses::Framework::Streams::TcpServer* tcpServer, bool ownsTCP, IHttpServer& http, bool showIPs) : HttpServer(tcpServer,ownsTCP,&http,false,showIPs)
{
}
HttpServer::HttpServer(Tesses::Framework::Streams::TcpServer& tcpServer, IHttpServer* http, bool ownsHttpServer, bool showIPs) : HttpServer(&tcpServer,false,http,ownsHttpServer,showIPs)
{
}
HttpServer::HttpServer(Tesses::Framework::Streams::TcpServer* tcpServer, bool ownsTCP, IHttpServer* http, bool ownsHttpServer, bool showIPs)
HttpServer::HttpServer(std::shared_ptr<Tesses::Framework::Streams::TcpServer> tcpServer, std::shared_ptr<IHttpServer> http, bool showIPs)
{
this->server = tcpServer;
this->ownsTCP = ownsTCP;
this->http = http;
this->ownsHttp = ownsHttpServer;
this->showIPs = showIPs;
this->thrd=nullptr;
this->showARTL = showIPs;
}
HttpServer::HttpServer(uint16_t port, IHttpServer* http, bool owns, bool showIPs) : HttpServer(new TcpServer(port,10),true,http,owns,showIPs)
HttpServer::HttpServer(uint16_t port, std::shared_ptr<IHttpServer> http, bool showIPs) : HttpServer(std::make_shared<TcpServer>(port,10),http,showIPs)
{
}
HttpServer::HttpServer(uint16_t port, IHttpServer& http,bool showIPs) : HttpServer(port,&http,false,showIPs)
{
}
HttpServer::HttpServer(std::string unixPath, IHttpServer* http, bool owns) : HttpServer(new TcpServer(unixPath,10),true,http,owns,false)
HttpServer::HttpServer(std::string unixPath, std::shared_ptr<IHttpServer> http) : HttpServer(std::make_shared<TcpServer>(unixPath,10),http,false)
{
this->showARTL=true;
}
HttpServer::HttpServer(std::string unixPath, IHttpServer& http) : HttpServer(unixPath,&http,false)
{
}
uint16_t HttpServer::GetPort()
{
@@ -577,7 +554,7 @@ namespace Tesses::Framework::Http
return server->GetPort();
return 0;
}
Stream* ServerContext::OpenResponseStream()
std::shared_ptr<Stream> ServerContext::OpenResponseStream()
{
if(sent) return nullptr;
int64_t length = -1;
@@ -588,14 +565,14 @@ namespace Tesses::Framework::Http
this->responseHeaders.SetValue("Transfer-Encoding","chunked");
this->WriteHeaders();
return new HttpStream(this->strm,false,length,false,version == "HTTP/1.1");
return std::make_shared<HttpStream>(this->strm,length,false,version == "HTTP/1.1");
}
Stream* ServerContext::OpenRequestStream()
std::shared_ptr<Stream> ServerContext::OpenRequestStream()
{
int64_t length = -1;
if(!this->requestHeaders.TryGetFirstInt("Content-Length",length))
length = -1;
return new HttpStream(this->strm,false,length,true,version == "HTTP/1.1");
return std::make_shared<HttpStream>(this->strm,length,true,version == "HTTP/1.1");
}
void HttpServer::StartAccepting()
{
@@ -622,9 +599,9 @@ namespace Tesses::Framework::Http
TF_LOG("Before entering socket thread");
Threading::Thread thrd2([sock,http,ip,port]()->void {
TF_LOG("In thread to process");
HttpServer::Process(*sock,*http,ip,port,false);
HttpServer::Process(sock,http,ip,port,false);
TF_LOG("In thread after process");
delete sock;
});
TF_LOG("Before attach");
thrd2.Detach();
@@ -664,16 +641,13 @@ namespace Tesses::Framework::Http
this->thrd->Join();
delete this->thrd;
}
if(this->ownsHttp)
delete http;
if(this->ownsTCP)
delete this->server;
}
IHttpServer::~IHttpServer()
{
}
ServerContext::ServerContext(Stream* strm)
ServerContext::ServerContext(std::shared_ptr<Stream> strm)
{
this->statusCode = OK;
this->strm = strm;
@@ -681,14 +655,14 @@ namespace Tesses::Framework::Http
this->queryParams.SetCaseSensitive(true);
this->responseHeaders.AddValue("Server","TessesFrameworkWebServer");
}
Stream& ServerContext::GetStream()
std::shared_ptr<Stream> ServerContext::GetStream()
{
return *this->strm;
return this->strm;
}
void ServerContext::SendBytes(std::vector<uint8_t> buff)
{
MemoryStream strm(false);
strm.GetBuffer() = buff;
std::shared_ptr<MemoryStream> strm=std::make_shared<MemoryStream>(false);
strm->GetBuffer() = buff;
SendStream(strm);
}
ServerContext& ServerContext::WithLastModified(Date::DateTime dt)
@@ -699,8 +673,9 @@ namespace Tesses::Framework::Http
void ServerContext::SendText(std::string text)
{
MemoryStream strm(false);
auto& buff= strm.GetBuffer();
std::shared_ptr<MemoryStream> strm=std::make_shared<MemoryStream>(false);
auto& buff= strm->GetBuffer();
buff.insert(buff.end(),text.begin(),text.end());
SendStream(strm);
}
@@ -711,11 +686,7 @@ namespace Tesses::Framework::Http
WithMimeType("text/html").SendText(errorHtml);
}
void ServerContext::SendStream(Stream* strm)
{
if(strm == nullptr) return;
SendStream(*strm);
}
ServerContext::~ServerContext()
{
for(auto item : this->data)
@@ -727,14 +698,14 @@ namespace Tesses::Framework::Http
{
}
void ServerContext::SendStream(Stream& strm)
void ServerContext::SendStream(std::shared_ptr<Stream> strm)
{
if(sent) return;
if(!strm.CanRead()) throw std::runtime_error("Cannot read from stream");
if(strm.EndOfStream()) throw std::runtime_error("End of stream");
if(strm.CanSeek())
if(!strm->CanRead()) throw std::runtime_error("Cannot read from stream");
if(strm->EndOfStream()) throw std::runtime_error("End of stream");
if(strm->CanSeek())
{
int64_t len=strm.GetLength();
int64_t len=strm->GetLength();
std::string range={};
if(this->requestHeaders.TryGetFirst("Range",range))
{
@@ -815,7 +786,7 @@ namespace Tesses::Framework::Http
this->WithSingleHeader("Content-Range","bytes " + std::to_string(begin) + "-" + std::to_string(end) + "/" + std::to_string(len));
this->statusCode = PartialContent;
this->WriteHeaders();
strm.Seek(begin,SeekOrigin::Begin);
strm->Seek(begin,SeekOrigin::Begin);
uint8_t buffer[1024];
@@ -825,7 +796,7 @@ namespace Tesses::Framework::Http
myLen = (end - begin)+1;
if(myLen < read) read = (size_t)myLen;
if(read == 0) break;
read = strm.Read(buffer,read);
read = strm->Read(buffer,read);
if(read == 0) break;
this->strm->WriteBlock(buffer,read);
@@ -848,7 +819,7 @@ namespace Tesses::Framework::Http
this->WithSingleHeader("Accept-Range","bytes");
this->WithSingleHeader("Content-Length",std::to_string(len));
this->WriteHeaders();
strm.CopyTo(*this->strm);
strm->CopyTo(this->strm);
}
}
@@ -857,7 +828,7 @@ namespace Tesses::Framework::Http
{
auto chunkedStream = this->OpenResponseStream();
this->strm->CopyTo(chunkedStream);
delete chunkedStream;
}
}
@@ -920,7 +891,7 @@ namespace Tesses::Framework::Http
if(this->sent) return *this;
this->sent = true;
StreamWriter writer(this->strm,false);
StreamWriter writer(this->strm);
writer.newline = "\r\n";
writer.WriteLine("HTTP/1.1 " + std::to_string((int)statusCode) + " " + HttpUtils::StatusCodeString(statusCode));
for(auto& hdr : responseHeaders.kvp)
@@ -935,14 +906,14 @@ namespace Tesses::Framework::Http
return *this;
}
void HttpServer::Process(Stream& strm, IHttpServer& server, std::string ip, uint16_t port, bool encrypted)
void HttpServer::Process(std::shared_ptr<Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port, bool encrypted)
{
TF_LOG("In process");
while(true)
{
BufferedStream bStrm(strm);
std::shared_ptr<BufferedStream> bStrm = std::make_shared<BufferedStream>(strm);
StreamReader reader(bStrm);
ServerContext ctx(&bStrm);
ServerContext ctx(bStrm);
ctx.ip = ip;
ctx.port = port;
ctx.encrypted = encrypted;
@@ -1002,13 +973,13 @@ namespace Tesses::Framework::Http
{
size_t len = (size_t)length;
uint8_t* buffer = new uint8_t[len];
len = bStrm.ReadBlock(buffer,len);
len = bStrm->ReadBlock(buffer,len);
std::string query((const char*)buffer,len);
delete[] buffer;
HttpUtils::QueryParamsDecode(ctx.queryParams, query);
}
if(!server.Handle(ctx))
if(!server->Handle(ctx))
{
ctx.SendNotFound();
}
@@ -1047,7 +1018,7 @@ namespace Tesses::Framework::Http
if(HttpUtils::ToLower(connection) != "keep-alive") return;
}
if(bStrm.EndOfStream()) {
if(bStrm->EndOfStream()) {
return;
}
}
@@ -1059,16 +1030,16 @@ namespace Tesses::Framework::Http
}
void ServerContext::StartWebSocketSession(std::function<void(std::function<void(WebSocketMessage&)>,std::function<void()>,std::function<void()>)> onOpen, std::function<void(WebSocketMessage&)> onReceive, std::function<void(bool)> onClose)
{
CallbackWebSocketConnection wsc(onOpen,onReceive,onClose);
std::shared_ptr<CallbackWebSocketConnection> wsc = std::make_shared<CallbackWebSocketConnection>(onOpen,onReceive,onClose);
StartWebSocketSession(wsc);
}
void ServerContext::StartWebSocketSession(WebSocketConnection& connection)
void ServerContext::StartWebSocketSession(std::shared_ptr<WebSocketConnection> connection)
{
WSServer svr(this,&connection);
WSServer svr(this,connection);
Threading::Thread thrd([&svr,&connection]()->void{
try {
connection.OnOpen([&svr](WebSocketMessage& msg)->void {
connection->OnOpen([&svr](WebSocketMessage& msg)->void {
svr.send_msg(&msg);
},[&svr]()->void {
std::vector<uint8_t> p = {(uint8_t)'p',(uint8_t)'i',(uint8_t)'n',(uint8_t)'g'};

16
src/Http/HttpStream.cpp
View File

@@ -7,10 +7,9 @@ using StreamWriter = Tesses::Framework::TextStreams::StreamWriter;
using StreamReader = Tesses::Framework::TextStreams::StreamReader;
namespace Tesses::Framework::Http
{
HttpStream::HttpStream(Tesses::Framework::Streams::Stream* strm, bool owns, int64_t length, bool recv, bool http1_1)
HttpStream::HttpStream(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, int64_t length, bool recv, bool http1_1)
{
this->strm = strm;
this->owns = owns;
this->length = length;
this->recv = recv;
this->http1_1 = http1_1;
@@ -18,10 +17,6 @@ namespace Tesses::Framework::Http
this->read = 0;
this->position = 0;
this->done=false;
}
HttpStream::HttpStream(Tesses::Framework::Streams::Stream& strm, int64_t length, bool recv,bool http1_1) : HttpStream(&strm,false,length,recv,http1_1)
{
}
bool HttpStream::CanRead()
{
@@ -79,14 +74,14 @@ namespace Tesses::Framework::Http
this->position += len;
if(this->offset >= this->read)
{
StreamReader reader(this->strm, false);
StreamReader reader(this->strm);
reader.ReadLine();
}
return len;
}
else
{
StreamReader reader(this->strm, false);
StreamReader reader(this->strm);
std::string line = reader.ReadLine();
if(!line.empty())
{
@@ -141,7 +136,7 @@ namespace Tesses::Framework::Http
std::stringstream strm;
strm << std::hex << len;
StreamWriter writer(this->strm,false);
StreamWriter writer(this->strm);
writer.newline = "\r\n";
writer.WriteLine(strm.str());
@@ -160,11 +155,10 @@ namespace Tesses::Framework::Http
{
if(this->length == -1 && this->http1_1)
{
StreamWriter writer(this->strm,false);
StreamWriter writer(this->strm);
writer.newline = "\r\n";
writer.WriteLine("0");
writer.WriteLine();
}
if(this->owns) delete this->strm;
}
}

23
src/Http/MountableServer.cpp
View File

@@ -22,26 +22,18 @@ bool MountableServer::StartsWith(Filesystem::VFSPath fullPath, Filesystem::VFSPa
}
return true;
}
MountableServer::MountableServer() : MountableServer(nullptr,false)
MountableServer::MountableServer() : MountableServer(nullptr)
{
}
MountableServer::MountableServer(IHttpServer* root, bool owns)
MountableServer::MountableServer(std::shared_ptr<IHttpServer> root)
{
this->root = root;
this->owns = owns;
}
MountableServer::MountableServer(IHttpServer& root) : MountableServer(&root,false)
void MountableServer::Mount(std::string path, std::shared_ptr<IHttpServer> server)
{
}
void MountableServer::Mount(std::string path, IHttpServer* server, bool owns)
{
this->servers.insert(this->servers.begin(), std::pair<std::string,std::pair<bool,IHttpServer*>>(path, std::pair<bool,IHttpServer*>(owns,server)));
}
void MountableServer::Mount(std::string path, IHttpServer& server)
{
Mount(path,&server,false);
this->servers.insert(this->servers.begin(), std::pair<std::string,std::shared_ptr<IHttpServer>>(path, server));
}
void MountableServer::Unmount(std::string path)
{
@@ -50,7 +42,6 @@ void MountableServer::Unmount(std::string path)
auto& item = *i;
if(item.first == path)
{
if(item.second.first) delete item.second.second;
this->servers.erase(i);
return;
}
@@ -64,7 +55,7 @@ bool MountableServer::Handle(ServerContext& ctx)
if(StartsWith(oldPath, item.first))
{
ctx.path = Subpath(oldPath, item.first);
if(item.second.second->Handle(ctx))
if(item.second->Handle(ctx))
{
ctx.path = oldPath;
return true;
@@ -79,7 +70,5 @@ bool MountableServer::Handle(ServerContext& ctx)
}
MountableServer::~MountableServer()
{
if(this->owns) delete this->root;
for(auto svr : this->servers) if(svr.second.first) delete svr.second.second;
}
}

38
src/Mail/Smtp.cpp
View File

@@ -5,9 +5,9 @@
#include "TessesFramework/Http/HttpUtils.hpp"
namespace Tesses::Framework::Mail
{
static void SMTP_ATTACHMENT_WRITE(std::string& myStr, Tesses::Framework::Streams::MemoryStream& strm)
static void SMTP_ATTACHMENT_WRITE(std::string& myStr, std::shared_ptr<Tesses::Framework::Streams::MemoryStream> strm)
{
std::string txt = Tesses::Framework::Crypto::Base64_Encode(strm.GetBuffer());
std::string txt = Tesses::Framework::Crypto::Base64_Encode(strm->GetBuffer());
bool first=true;
size_t read;
size_t offset = 0;
@@ -39,40 +39,30 @@ namespace Tesses::Framework::Mail
this->text = text;
this->mimeType=mimeType;
}
void SMTPStringBody::Write(Tesses::Framework::Streams::Stream* strm)
void SMTPStringBody::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
strm->WriteBlock((const uint8_t*)this->text.c_str(),this->text.size());
}
SMTPStreamBody::SMTPStreamBody(std::string mimeType,Tesses::Framework::Streams::Stream* strm, bool owns)
SMTPStreamBody::SMTPStreamBody(std::string mimeType,std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
this->mimeType = mimeType;
this->stream = strm;
this->owns=owns;
}
SMTPStreamBody::SMTPStreamBody(std::string mimeType,Tesses::Framework::Streams::Stream& strm) : SMTPStreamBody(mimeType,&strm,false)
{
}
void SMTPStreamBody::Write(Tesses::Framework::Streams::Stream* strm)
void SMTPStreamBody::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
this->stream->Seek(0L,Tesses::Framework::Streams::SeekOrigin::Begin);
this->stream->CopyTo(strm);
}
SMTPStreamBody::~SMTPStreamBody()
{
if(this->owns)
delete this->stream;
}
SMTPClient::SMTPClient(Tesses::Framework::Streams::Stream* stream,bool owns)
SMTPClient::SMTPClient(std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{
this->strm = stream;
this->owns = owns;
this->body = nullptr;
}
SMTPClient::SMTPClient(Tesses::Framework::Streams::Stream& strm) : SMTPClient(&strm,false)
{
}
void SMTPClient::Send()
{
std::string emailHeaders = "EHLO ";
@@ -112,7 +102,7 @@ namespace Tesses::Framework::Mail
emailHeaders.append("\r\nContent-Type: ");
emailHeaders.append(this->body->mimeType);
emailHeaders.append("; charset=utf-8\r\n\r\n");
Tesses::Framework::TextStreams::StreamWriter writer(this->strm,false);
Tesses::Framework::TextStreams::StreamWriter writer(this->strm);
writer.Write(emailHeaders);
this->body->Write(this->strm);
@@ -138,8 +128,8 @@ namespace Tesses::Framework::Mail
emailHeaders.append("\"\r\nContent-Transfer-Encoding: base64\r\nContent-Disposition: attachment; filename=\"");
emailHeaders.append(name);
emailHeaders.append("\"\r\n\r\n");
Tesses::Framework::Streams::MemoryStream ms(true);
item.second->Write(&ms);
std::shared_ptr<Tesses::Framework::Streams::MemoryStream> ms = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
item.second->Write(ms);
SMTP_ATTACHMENT_WRITE(emailHeaders,ms);
//emailHeaders.append(Tesses::Framework::Crypto::Base64_Encode(ms.GetBuffer()));
writer.Write(emailHeaders);
@@ -154,10 +144,6 @@ namespace Tesses::Framework::Mail
SMTPClient::~SMTPClient()
{
delete this->body;
for(auto& item : this->attachments)
{
delete item.second;
}
}
}

12
src/Platform/Environment.cpp
View File

@@ -124,7 +124,7 @@ namespace Tesses::Framework::Platform::Environment
if(!realPath.relative) return realPath;
if(LocalFS.FileExists(realPath)) return realPath.MakeAbsolute();
if(LocalFS->FileExists(realPath)) return realPath.MakeAbsolute();
const char* path = std::getenv("PATH");
#if defined(_WIN32)
const char* pathext = std::getenv("PATHEXT");
@@ -134,13 +134,13 @@ namespace Tesses::Framework::Platform::Environment
for(auto item : pathParts)
{
auto newPath = LocalFS.SystemToVFSPath(item) / realPath;
auto newPath = LocalFS->SystemToVFSPath(item) / realPath;
for(auto item2 : pext)
{
auto newPathExt = newPath + item2;
if(LocalFS.FileExists(newPathExt)) return newPathExt;
if(LocalFS->FileExists(newPathExt)) return newPathExt;
}
if(LocalFS.FileExists(newPath)) return newPath;
if(LocalFS->FileExists(newPath)) return newPath;
}
return realPath;
#else
@@ -148,8 +148,8 @@ namespace Tesses::Framework::Platform::Environment
auto pathParts = HttpUtils::SplitString(path,":");
for(auto item : pathParts)
{
auto newPath = LocalFS.SystemToVFSPath(item) / realPath;
if(LocalFS.FileExists(newPath)) return newPath;
auto newPath = LocalFS->SystemToVFSPath(item) / realPath;
if(LocalFS->FileExists(newPath)) return newPath;
}
return realPath.MakeAbsolute();
#endif

12
src/Platform/Process.cpp
View File

@@ -685,34 +685,34 @@ CreateProcessW(
#endif
}
Tesses::Framework::Streams::Stream* Process::GetStdinStream()
std::shared_ptr<Tesses::Framework::Streams::Stream> Process::GetStdinStream()
{
if (this->exited) return nullptr;
#if defined(GEKKO) || defined(__PS2__) || defined(__SWITCH__) || !defined(TESSESFRAMEWORK_ENABLE_PROCESS)
return nullptr;
#else
return new ProcessStream(this->hidden.GetField<ProcessData*>()->stdin_strm,true);
return std::make_shared<ProcessStream>(this->hidden.GetField<ProcessData*>()->stdin_strm,true);
#endif
}
Tesses::Framework::Streams::Stream* Process::GetStdoutStream()
std::shared_ptr<Tesses::Framework::Streams::Stream> Process::GetStdoutStream()
{
if (this->exited) return nullptr;
#if defined(GEKKO) || defined(__PS2__) || defined(__SWITCH__) || !defined(TESSESFRAMEWORK_ENABLE_PROCESS)
return nullptr;
#else
return new ProcessStream(this->hidden.GetField<ProcessData*>()->stdout_strm,false);
return std::make_shared<ProcessStream>(this->hidden.GetField<ProcessData*>()->stdout_strm,false);
#endif
}
Tesses::Framework::Streams::Stream* Process::GetStderrStream()
std::shared_ptr<Tesses::Framework::Streams::Stream> Process::GetStderrStream()
{
if (this->exited) return nullptr;
#if defined(GEKKO) || defined(__PS2__) || defined(__SWITCH__) || !defined(TESSESFRAMEWORK_ENABLE_PROCESS)
return nullptr;
#else
return new ProcessStream(this->hidden.GetField<ProcessData*>()->stderr_strm,false);
return std::make_shared<ProcessStream>(this->hidden.GetField<ProcessData*>()->stderr_strm,false);
#endif
}

10
src/Streams/BufferedStream.cpp
View File

@@ -1,18 +1,14 @@
#include "TessesFramework/Streams/BufferedStream.hpp"
namespace Tesses::Framework::Streams {
BufferedStream::BufferedStream(Stream* strm, bool owns, size_t bufferSize)
BufferedStream::BufferedStream(std::shared_ptr<Stream> strm, size_t bufferSize)
{
this->strm = strm;
this->owns = owns;
this->bufferSize = bufferSize;
this->buffer = new uint8_t[bufferSize];
this->read = 0;
this->offset = 0;
}
BufferedStream::BufferedStream(Stream& strm, size_t bufferSize) : BufferedStream(&strm,false, bufferSize)
{
}
bool BufferedStream::EndOfStream()
{
if(this->offset < this->read) return false;
@@ -60,8 +56,6 @@ namespace Tesses::Framework::Streams {
BufferedStream::~BufferedStream()
{
if(this->owns)
delete this->strm;
delete buffer;
}
}

15
src/Streams/ByteReader.cpp
View File

@@ -1,19 +1,15 @@
#include "TessesFramework/Streams/ByteReader.hpp"
namespace Tesses::Framework::Streams
{
Stream* ByteReader::GetStream()
std::shared_ptr<Stream> ByteReader::GetStream()
{
return this->strm;
}
ByteReader::ByteReader(Stream* strm, bool owns)
ByteReader::ByteReader(std::shared_ptr<Stream> strm)
{
this->strm = strm;
this->owns = owns;
}
ByteReader::ByteReader(Stream& strm) : ByteReader(&strm,false)
{
}
uint8_t ByteReader::ReadU8()
{
auto r = this->strm->ReadByte();
@@ -153,8 +149,5 @@ namespace Tesses::Framework::Streams
auto v=ReadU64LE();
return *(double*)&v;
}
ByteReader::~ByteReader()
{
if(this->owns) delete this->strm;
}
}

15
src/Streams/ByteWriter.cpp
View File

@@ -1,19 +1,15 @@
#include "TessesFramework/Streams/ByteWriter.hpp"
namespace Tesses::Framework::Streams
{
Stream* ByteWriter::GetStream()
std::shared_ptr<Stream> ByteWriter::GetStream()
{
return this->strm;
}
ByteWriter::ByteWriter(Stream* strm, bool owns)
ByteWriter::ByteWriter(std::shared_ptr<Stream> strm)
{
this->strm = strm;
this->owns = owns;
}
ByteWriter::ByteWriter(Stream& strm) : ByteWriter(&strm,false)
{
}
void ByteWriter::WriteU8(uint8_t v)
{
strm->WriteByte(v);
@@ -133,8 +129,5 @@ namespace Tesses::Framework::Streams
uint64_t data = *(uint64_t*)&v;
WriteU64LE(data);
}
ByteWriter::~ByteWriter()
{
if(this->owns) delete this->strm;
}
}

12
src/Streams/NetworkStream.cpp
View File

@@ -507,7 +507,7 @@ namespace Tesses::Framework::Streams {
NETWORK_CLOSE(this->sock);
this->valid=false;
}
NetworkStream* TcpServer::GetStream(std::string& ip, uint16_t& port)
std::shared_ptr<NetworkStream> TcpServer::GetStream(std::string& ip, uint16_t& port)
{
struct sockaddr_storage storage;
memset(&storage,0, sizeof(storage));
@@ -522,7 +522,7 @@ namespace Tesses::Framework::Streams {
ip = StringifyIP((struct sockaddr*)&storage);
port = getPort((struct sockaddr*)&storage);
return new NetworkStream(s,true);
return std::make_shared<NetworkStream>(s,true);
}
bool NetworkStream::CanRead()
{
@@ -690,7 +690,7 @@ namespace Tesses::Framework::Streams {
}
}
NetworkStream* NetworkStream::Accept(std::string& ip, uint16_t& port)
std::shared_ptr<NetworkStream> NetworkStream::Accept(std::string& ip, uint16_t& port)
{
if(!this->success) return nullptr;
struct sockaddr_storage storage;
@@ -704,7 +704,7 @@ namespace Tesses::Framework::Streams {
ip = StringifyIP((struct sockaddr*)&storage);
port = getPort((struct sockaddr*)&storage);
return new NetworkStream((int32_t)s,(bool)true);
return std::make_shared<NetworkStream>((int32_t)s,(bool)true);
}
size_t NetworkStream::Read(uint8_t* buff, size_t sz)
{
@@ -803,7 +803,7 @@ TcpServer::TcpServer(std::string unixPath,int32_t backlog)
{
}
NetworkStream* TcpServer::GetStream(std::string& ip, uint16_t& port)
std::shared_ptr<NetworkStream> TcpServer::GetStream(std::string& ip, uint16_t& port)
{
return nullptr;
}
@@ -857,7 +857,7 @@ void NetworkStream::SetBroadcast(bool bC)
{
}
NetworkStream* NetworkStream::Accept(std::string& ip, uint16_t& port)
std::shared_ptr<NetworkStream> NetworkStream::Accept(std::string& ip, uint16_t& port)
{
return nullptr;
}

20
src/Streams/Stream.cpp
View File

@@ -92,30 +92,22 @@ namespace Tesses::Framework::Streams {
{
}
void Stream::CopyTo(Stream* strm, size_t buffSize)
{
if(strm != nullptr)
this->CopyTo(*strm, buffSize);
}
void Stream::CopyTo(Stream& strm, size_t buffSize)
void Stream::CopyTo(std::shared_ptr<Stream> strm, size_t buffSize)
{
size_t read;
#if defined(_WIN32)
uint8_t* buffer = new uint8_t[buffSize];
#else
uint8_t buffer[buffSize];
#endif
do {
read = this->Read(buffer,buffSize);
strm.WriteBlock(buffer, read);
strm->WriteBlock(buffer, read);
} while(read > 0);
strm.Flush();
strm->Flush();
#if defined(_WIN32)
delete[] buffer;
#endif
}
Stream::~Stream()
{

3
src/TF_Init.cpp
View File

@@ -1,6 +1,7 @@
#include "TessesFramework/Common.hpp"
#include "TessesFramework/Streams/NetworkStream.hpp"
#include "TessesFramework/Lazy.hpp"
#include "TessesFramework/Filesystem/LocalFS.hpp"
#include <atomic>
#include <csignal>
#include <iostream>
@@ -181,7 +182,7 @@ namespace Tesses::Framework
}
void TF_Init()
{
Tesses::Framework::Filesystem::LocalFS = std::make_shared<Tesses::Framework::Filesystem::LocalFilesystem>();
#if defined(TESSESFRAMEWORK_ENABLE_SQLITE)
sqlite3_initialize();
#if defined(GEKKO) || defined(__SWITCH__) || defined(__PS2__)

24
src/Text/HeaderGenerator.cpp
View File

@@ -1,7 +1,7 @@
#include "TessesFramework/Text/HeaderGenerator.hpp"
namespace Tesses::Framework::Text {
void GenerateCHeaderFile(Streams::Stream* strm,std::string name, TextStreams::TextWriter* writer)
void GenerateCHeaderFile(std::shared_ptr<Streams::Stream> strm,std::string name, std::shared_ptr<TextStreams::TextWriter> writer)
{
const size_t BLK_SZ=1024;
writer->WriteLine("#pragma once");
@@ -48,22 +48,22 @@ namespace Tesses::Framework::Text {
}
std::string GenerateCHeaderFile(Streams::Stream* strm,std::string name)
std::string GenerateCHeaderFile(std::shared_ptr<Streams::Stream> strm,std::string name)
{
TextStreams::StringWriter writer;
GenerateCHeaderFile(strm,name,&writer);
return writer.GetString();
auto writer=std::make_shared<TextStreams::StringWriter>();
GenerateCHeaderFile(strm,name,writer);
return writer->GetString();
}
void GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name, TextStreams::TextWriter* writer)
void GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name, std::shared_ptr<TextStreams::TextWriter> writer)
{
Tesses::Framework::Streams::MemoryStream ms(false);
ms.GetBuffer() = data;
GenerateCHeaderFile(&ms,name,writer);
auto ms = std::make_shared<Tesses::Framework::Streams::MemoryStream>(false);
ms->GetBuffer() = data;
GenerateCHeaderFile(ms,name,writer);
}
std::string GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name)
{
TextStreams::StringWriter writer;
GenerateCHeaderFile(data,name,&writer);
return writer.GetString();
auto writer = std::make_shared<TextStreams::StringWriter>();
GenerateCHeaderFile(data,name,writer);
return writer->GetString();
}
};

28
src/TextStreams/StreamReader.cpp
View File

@@ -4,11 +4,8 @@ using Stream = Tesses::Framework::Streams::Stream;
using FileStream = Tesses::Framework::Streams::FileStream;
namespace Tesses::Framework::TextStreams {
StreamReader::StreamReader(Stream& strm) : StreamReader(&strm, false)
{
}
StreamReader::StreamReader(std::filesystem::path path) : StreamReader(new FileStream(path,"rb"),true)
StreamReader::StreamReader(std::filesystem::path path) : StreamReader(std::make_shared<FileStream>(path,"rb"))
{
}
@@ -21,35 +18,30 @@ namespace Tesses::Framework::TextStreams {
}
return false;
}
StreamReader::StreamReader(Stream* strm, bool owns) : TextReader()
StreamReader::StreamReader(std::shared_ptr<Stream> strm) : TextReader()
{
this->strm = strm;
this->owns = owns;
}
Stream& StreamReader::GetStream()
std::shared_ptr<Stream> StreamReader::GetStream()
{
return *(this->strm);
return (this->strm);
}
bool StreamReader::ReadBlock(std::string& str, size_t len)
{
#if defined(_WIN32)
uint8_t* buff = new uint8_t[len];
#else
uint8_t buff[len];
#endif
len = strm->ReadBlock(buff,len);
if(len == 0) return false;
if(len == 0) {delete buff; return false;}
str.append((const char*)buff, len);
#if defined(_WIN32)
delete buff;
#endif
return true;
}
StreamReader::~StreamReader()
{
if(this->owns)
delete this->strm;
}
};

14
src/TextStreams/StreamWriter.cpp
View File

@@ -5,20 +5,16 @@ using FileStream = Tesses::Framework::Streams::FileStream;
namespace Tesses::Framework::TextStreams
{
Stream& StreamWriter::GetStream()
std::shared_ptr<Stream> StreamWriter::GetStream()
{
return *(this->strm);
return this->strm;
}
StreamWriter::StreamWriter(Stream& strm) : StreamWriter(&strm, false)
StreamWriter::StreamWriter(std::shared_ptr<Stream> strm) : TextWriter()
{
}
StreamWriter::StreamWriter(Stream* strm, bool owns) : TextWriter()
{
this->strm = strm;
this->owns = owns;
}
StreamWriter::StreamWriter(std::filesystem::path filename, bool append) : StreamWriter(new FileStream(filename, append ? "ab" : "wb"),true)
StreamWriter::StreamWriter(std::filesystem::path filename, bool append) : StreamWriter(std::make_shared<FileStream>(filename, append ? "ab" : "wb"))
{
}
@@ -28,7 +24,5 @@ namespace Tesses::Framework::TextStreams
}
StreamWriter::~StreamWriter()
{
if(this->owns)
delete this->strm;
}
}

231
src/wrapper.cpp
View File

@@ -1,231 +0,0 @@
#include "TessesFramework/TessesFramework.hpp"
#include "TessesFramework/TessesFramework.h"
#include <iostream>
using namespace Tesses::Framework;
using namespace Tesses::Framework::Streams;
using namespace Tesses::Framework::Filesystem;
using namespace Tesses::Framework::Threading;
#if defined(__cplusplus)
extern "C" {
#endif
string_t* string_create()
{
return static_cast<string_t*>(new std::string());
}
string_t* string_create_from_buff(const void* text, size_t len)
{
return static_cast<string_t*>(new std::string((const char*)text,len));
}
string_t* string_create_from_charpointer(const char* text)
{
return static_cast<string_t*>(new std::string(text));
}
string_t* string_resize(string_t* str, size_t len)
{
static_cast<std::string*>(str)->resize(len);
return str;
}
string_t* string_set_char(string_t* str, size_t index, char c)
{
static_cast<std::string*>(str)->at(index) = c;
return str;
}
char string_get_char(string_t* str,size_t index)
{
return static_cast<std::string*>(str)->at(index);
}
string_t* string_append_char(string_t* str, char c)
{
static_cast<std::string*>(str)->push_back(c);
return str;
}
string_t* string_append_from_buff(string_t* str,const void* text, size_t len)
{
static_cast<std::string*>(str)->append((const char*)text,len);
return str;
}
string_t* string_append_from_charpointer(string_t* str,const char* text)
{
static_cast<std::string*>(str)->append(text);
return str;
}
string_t* string_append(string_t* str, string_t* toAppend)
{
if(str == NULL) return NULL;
static_cast<std::string*>(str)->append(*static_cast<std::string*>(str));
return str;
}
string_t* string_append_signed(string_t* str, int64_t num)
{
static_cast<std::string*>(str)->append(std::to_string(num));
return str;
}
string_t* string_append_unsigned(string_t* str, uint64_t num)
{
static_cast<std::string*>(str)->append(std::to_string(num));
return str;
}
string_t* string_append_double(string_t* str, double num)
{
static_cast<std::string*>(str)->append(std::to_string(num));
return str;
}
void string_print(string_t* str)
{
std::cout << *static_cast<std::string*>(str);
}
void string_println(string_t* str)
{
std::cout << *static_cast<std::string*>(str) << std::endl;
}
size_t string_size(string_t* str)
{
return static_cast<std::string*>(str)->size();
}
const char* string_c_str(string_t* str)
{
return static_cast<std::string*>(str)->c_str();
}
void string_free(string_t* str)
{
delete static_cast<std::string*>(str);
}
void tf_init()
{
TF_Init();
}
tf_thread_t* tf_create_thread(void* userData, tf_action_user_data_t cb)
{
Thread* thrd = new Thread([userData,cb]()->void{
cb(userData);
});
return static_cast<tf_thread_t*>(thrd);
}
void tf_join_thread(tf_thread_t* thrd)
{
auto thrd2 = static_cast<Thread*>(thrd);
if(thrd2 != nullptr)
{
thrd2->Join();
delete thrd2;
}
}
void tf_detach_thread(tf_thread_t* thrd)
{
auto thrd2 = static_cast<Thread*>(thrd);
if(thrd2 != nullptr)
{
thrd2->Detach();
delete thrd2;
}
}
tf_mutex_t* tf_mutex_create()
{
return static_cast<tf_mutex_t*>(new Mutex());
}
void tf_mutex_lock(tf_mutex_t* mtx)
{
static_cast<Mutex*>(mtx)->Lock();
}
bool tf_mutex_trylock(tf_mutex_t* mtx)
{
return static_cast<Mutex*>(mtx)->TryLock();
}
void tf_mutex_unlock(tf_mutex_t* mtx)
{
static_cast<Mutex*>(mtx)->Unlock();
}
void tf_mutex_free(tf_mutex_t* mtx)
{
delete static_cast<Mutex*>(mtx);
}
bool tf_stream_canread(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->CanRead();
}
bool tf_stream_canwrite(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->CanWrite();
}
bool tf_stream_canseek(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->CanSeek();
}
bool tf_stream_eof(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->EndOfStream();
}
int64_t tf_stream_getlen(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->GetLength();
}
int64_t tf_stream_getpos(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->GetPosition();
}
void tf_stream_seek(tf_stream_t* strm, int64_t pos, TF_WHENCE whence)
{
static_cast<Stream*>(strm)->Seek(pos,whence == TF_SEEK_BEGIN ? SeekOrigin::Begin : whence == TF_SEEK_CURRENT ? SeekOrigin::Current : SeekOrigin::End);
}
size_t tf_stream_read(tf_stream_t* strm, uint8_t* buffer, size_t length)
{
return static_cast<Stream*>(strm)->Read(buffer,length);
}
size_t tf_stream_write(tf_stream_t* strm, const uint8_t* buffer, size_t length)
{
return static_cast<Stream*>(strm)->Write(buffer,length);
}
size_t tf_stream_readblock(tf_stream_t* strm, uint8_t* buffer, size_t length)
{
return static_cast<Stream*>(strm)->ReadBlock(buffer,length);
}
void tf_stream_writeblock(tf_stream_t* strm, const uint8_t* buffer, size_t length)
{
static_cast<Stream*>(strm)->WriteBlock(buffer,length);
}
void tf_stream_copyto(tf_stream_t* src, tf_stream_t* dest, size_t blockSize)
{
static_cast<Stream*>(src)->CopyTo(static_cast<Stream*>(dest),blockSize);
}
void tf_stream_close(tf_stream_t* strm)
{
delete static_cast<Stream*>(strm);
}
void tf_stream_flush(tf_stream_t* strm)
{
static_cast<Stream*>(strm)->Flush();
}
int32_t tf_stream_readbyte(tf_stream_t* strm)
{
return static_cast<Stream*>(strm)->ReadByte();
}
void tf_stream_writebyte(tf_stream_t* strm, uint8_t val)
{
static_cast<Stream*>(strm)->WriteByte(val);
}
tf_stream_t* tf_stream_fopen(const char* file, const char* mode)
{
FILE* f = fopen(file,mode);
if(f == NULL) return NULL;
return static_cast<tf_stream_t*>(new FileStream(f,true,std::string(mode)));
}
#if defined(__cplusplus)
}
#endif