tesses50/tesses-framework
1
0
Fork 0
mirror of https://onedev.site.tesses.net/tesses-framework synced 2026-04-16 01:17:22 +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

1
CMakeLists.txt
View File

@@ -52,7 +52,6 @@ src/Crypto/ClientTLSStream.cpp
src/Crypto/MbedHelpers.cpp
src/Args.cpp
src/TF_Init.cpp
src/wrapper.cpp
src/HiddenField.cpp
)
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)

12
apps/tanonydrop.cpp
View File

@@ -5,16 +5,16 @@ using namespace Tesses::Framework::Streams;
using namespace Tesses::Framework::Http;
using namespace Tesses::Framework::Filesystem;
VFS* vfs;
std::shared_ptr<VFS> vfs;
int main(int argc, char** argv)
{
TF_InitWithConsole();
vfs = new SubdirFilesystem(&LocalFS,Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory(),false);
vfs = std::make_shared<SubdirFilesystem>(LocalFS,Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory());
CallbackServer cb([](ServerContext& ctx)->bool{
std::shared_ptr<CallbackServer> cb = std::make_shared<CallbackServer>([](ServerContext& ctx)->bool{
if(ctx.path == "/")
{
ctx.WithMimeType("text/html")
@@ -39,7 +39,7 @@ int main(int argc, char** argv)
{
if(ctx.NeedToParseFormData())
{
ctx.ParseFormData([](std::string mime, std::string filename,std::string name)->Stream* {
ctx.ParseFormData([](std::string mime, std::string filename,std::string name)->std::shared_ptr<Stream> {
if(name != "file") return nullptr;
VFSPath path("/"+filename);
auto strm = vfs->OpenFile(path,"wb");
@@ -81,8 +81,8 @@ int main(int argc, char** argv)
return false;
});
Tesses::Framework::Http::MountableServer mountable(cb);
mountable.Mount("/files/",new FileServer(vfs,true,true,false),true);
auto mountable = std::make_shared<Tesses::Framework::Http::MountableServer>(cb);
mountable->Mount("/files/",std::make_shared<FileServer>(vfs,true,false));
HttpServer srv(4985,mountable);
srv.StartAccepting();

8
apps/tbin2h.cpp
View File

@@ -7,9 +7,9 @@ int main(int argc, char** argv)
std::cout << "USAGE: " << argv[0] << " BINARYFILE VARNAME HEADERFILE" << std::endl;
return 0;
}
Tesses::Framework::Streams::FileStream fs(argv[1],"rb");
if(!fs.CanRead()) return 1;
Tesses::Framework::TextStreams::StreamWriter writer(argv[3]);
Tesses::Framework::Text::GenerateCHeaderFile(&fs, argv[2], &writer);
auto fs=std::make_shared<Tesses::Framework::Streams::FileStream>(argv[1],"rb");
if(!fs->CanRead()) return 1;
auto writer = std::make_shared<Tesses::Framework::TextStreams::StreamWriter>(argv[3]);
Tesses::Framework::Text::GenerateCHeaderFile(fs, argv[2], writer);
return 0;
}

2
apps/tfileserver.cpp
View File

@@ -59,7 +59,7 @@ int main(int argc, char** argv)
std::cout << "In folder: " << std::filesystem::absolute(directory).string() << std::endl;
FileServer fs(directory,allowListing, spa);
auto fs = std::make_shared<FileServer>(directory,allowListing, spa);
HttpServer server(port,fs);
server.StartAccepting();
TF_RunEventLoop();

25
apps/tjsonpretty.cpp
View File

@@ -2,35 +2,33 @@
using namespace Tesses::Framework::Streams;
using namespace Tesses::Framework::Serialization::Json;
using namespace Tesses::Framework::TextStreams;
FileStream* OpenWrite(std::string dest)
std::shared_ptr<FileStream> OpenWrite(std::string dest)
{
if(dest == "-")
{
return new FileStream(stdout,false,"w");
return std::make_shared<FileStream>(stdout,false,"w");
}
else
{
FileStream* strm = new FileStream(dest,"w");
auto strm = std::make_shared<FileStream>(dest,"w");
if(!strm->CanWrite())
{
delete strm;
return nullptr;
}
return strm;
}
}
FileStream* OpenRead(std::string src)
std::shared_ptr<FileStream> OpenRead(std::string src)
{
if(src == "-")
{
return new FileStream(stdin,false,"r");
return std::make_shared<FileStream>(stdin,false,"r");
}
else
{
FileStream* strm = new FileStream(src,"r");
auto strm = std::make_shared<FileStream>(src,"r");
if(!strm->CanRead())
{
delete strm;
return nullptr;
}
return strm;
@@ -45,25 +43,24 @@ int main(int argc, char** argv)
std::cout << "DEST: prettied file or - for stdout" << std::endl;
return 0;
}
FileStream* src = OpenRead(argv[1]);
auto src = OpenRead(argv[1]);
FileStream* dest = OpenWrite(argv[2]);
auto dest = OpenWrite(argv[2]);
if(src == nullptr)
{
if(dest != nullptr) delete dest;
std::cerr << "ERROR: Input could not be read" << std::endl;
return 1;
}
if(dest == nullptr)
{
delete src;
std::cerr << "ERROR: Output could not be read" << std::endl;
return 1;
}
StreamReader reader(src,true);
StreamWriter writer(dest,true);
StreamReader reader(src);
StreamWriter writer(dest);
auto str = reader.ReadToEnd();
writer.WriteLine(Json::Encode(Json::Decode(str)));

25
apps/tjsonunpretty.cpp
View File

@@ -2,35 +2,33 @@
using namespace Tesses::Framework::Streams;
using namespace Tesses::Framework::Serialization::Json;
using namespace Tesses::Framework::TextStreams;
FileStream* OpenWrite(std::string dest)
std::shared_ptr<FileStream> OpenWrite(std::string dest)
{
if(dest == "-")
{
return new FileStream(stdout,false,"w");
return std::make_shared<FileStream>(stdout,false,"w");
}
else
{
FileStream* strm = new FileStream(dest,"w");
auto strm = std::make_shared<FileStream>(dest,"w");
if(!strm->CanWrite())
{
delete strm;
return nullptr;
}
return strm;
}
}
FileStream* OpenRead(std::string src)
std::shared_ptr<FileStream> OpenRead(std::string src)
{
if(src == "-")
{
return new FileStream(stdin,false,"r");
return std::make_shared<FileStream>(stdin,false,"r");
}
else
{
FileStream* strm = new FileStream(src,"r");
auto strm = std::make_shared<FileStream>(src,"r");
if(!strm->CanRead())
{
delete strm;
return nullptr;
}
return strm;
@@ -45,25 +43,24 @@ int main(int argc, char** argv)
std::cout << "DEST: unprettied file or - for stdout" << std::endl;
return 0;
}
FileStream* src = OpenRead(argv[1]);
auto src = OpenRead(argv[1]);
FileStream* dest = OpenWrite(argv[2]);
auto dest = OpenWrite(argv[2]);
if(src == nullptr)
{
if(dest != nullptr) delete dest;
std::cerr << "ERROR: Input could not be read" << std::endl;
return 1;
}
if(dest == nullptr)
{
delete src;
std::cerr << "ERROR: Output could not be read" << std::endl;
return 1;
}
StreamReader reader(src,true);
StreamWriter writer(dest,true);
StreamReader reader(src);
StreamWriter writer(dest);
auto str = reader.ReadToEnd();
writer.WriteLine(Json::Encode(Json::Decode(str),false));

5
apps/tshell.cpp
View File

@@ -96,7 +96,7 @@ int main(int argc,char** argv)
{
if(args.size()<3) continue;
std::vector<std::string> args2(args.begin()+2,args.end());
auto f = LocalFS.OpenFile(args[1],"rb");
auto f = LocalFS->OpenFile(args[1],"rb");
if(f != nullptr)
{
auto path = Environment::GetRealExecutablePath(args2[0]);
@@ -106,11 +106,10 @@ int main(int argc,char** argv)
{
auto strm = p.GetStdinStream();
f->CopyTo(strm);
delete strm;
p.CloseStdInNow();
p.WaitForExit();
}
delete f;
}
}
else {

4
examples/copyfile.cpp
View File

@@ -9,8 +9,6 @@ int main(int argc, char** argv)
VFSPath dest = fs.SystemToVFSPath(argv[2]);
auto srcs = fs.OpenFile(src,"rb");
auto dests = fs.OpenFile(dest,"wb");
srcs->CopyTo(*dests);
srcs->CopyTo(dests);
delete srcs;
delete dests;
}

21
examples/mountabletest.cpp
View File

@@ -13,23 +13,22 @@ int main(int argc, char** argv)
return 1;
}
LocalFilesystem lfs;
std::string root = "./root";
std::string mountDemi = "./demi";
std::string mountJoelSlashJim = "./joelslashjim";
SubdirFilesystem rootdir(&lfs,root,false);
std::shared_ptr<SubdirFilesystem> rootdir = std::make_shared<SubdirFilesystem>(LocalFS,root);
SubdirFilesystem mountDemidir(&lfs,mountDemi,false);
std::shared_ptr<SubdirFilesystem> mountDemidir = std::make_shared<SubdirFilesystem>(LocalFS,mountDemi);
SubdirFilesystem mountjohnslashjim(&lfs,mountJoelSlashJim,false);
std::shared_ptr<SubdirFilesystem> mountjohnslashjim = std::make_shared<SubdirFilesystem>(LocalFS,mountJoelSlashJim);
MountableFilesystem fs(&rootdir,false);
fs.Mount(std::string("/demi"), &mountDemidir,false);
std::shared_ptr<MountableFilesystem> fs = std::make_shared<MountableFilesystem>(rootdir);
fs->Mount(std::string("/demi"), mountDemidir);
fs.Mount(std::string("/joel/jim"), &mountjohnslashjim,false);
fs->Mount(std::string("/joel/jim"), mountjohnslashjim);
std::string command = argv[1];
@@ -39,22 +38,22 @@ int main(int argc, char** argv)
std::string dir = "/";
if(argc > 2) dir = argv[2];
for(auto item : fs.EnumeratePaths(dir))
for(auto item : fs->EnumeratePaths(dir))
{
std::cout << item.GetFileName() << std::endl;
}
}
else if(command == "cat")
{
FileStream strm(stdout, false,"wb",false);
std::shared_ptr<FileStream> strm = std::make_shared<FileStream>(stdout, false,"wb",false);
for(int a = 2; a < argc; a++)
{
std::string path = argv[a];
auto f = fs.OpenFile(path,"rb");
auto f = fs->OpenFile(path,"rb");
if(f != nullptr)
{
f->CopyTo(strm);
delete f;
}
}
}

18
examples/webserverex.cpp
View File

@@ -25,7 +25,7 @@ class MyWebServer : public IHttpServer {
std::cout << ctx.path << std::endl;
if(ctx.path == "/")
{
FileStream fs("index.html","rb");
std::shared_ptr<FileStream> fs = std::make_shared<FileStream>("index.html","rb");
ctx
.WithMimeType("text/html")
@@ -34,7 +34,7 @@ class MyWebServer : public IHttpServer {
}
else if(ctx.path == "/streaming.html")
{
StreamWriter writer(ctx.OpenResponseStream(),true);
StreamWriter writer(ctx.OpenResponseStream());
writer.WriteLine("<html>");
writer.WriteLine("<head><title>Streaming</title></head>");
writer.WriteLine("<body>");
@@ -58,7 +58,7 @@ class MyWebServer : public IHttpServer {
else if(ctx.path == "/main.js")
{
FileStream fs("main.js","rb");
std::shared_ptr<FileStream> fs = std::make_shared<FileStream>("main.js","rb");
ctx
.WithMimeType("text/js")
@@ -67,8 +67,8 @@ class MyWebServer : public IHttpServer {
}
else if(ctx.path == "/upload")
{
ctx.ParseFormData([](std::string mime, std::string filename, std::string name)->Tesses::Framework::Streams::Stream*{
return new FileStream(filename,"wb");
ctx.ParseFormData([](std::string mime, std::string filename, std::string name)->std::shared_ptr<Tesses::Framework::Streams::Stream>{
return std::make_shared<FileStream>(filename,"wb");
});
}
else if(ctx.path == "/steve")
@@ -117,11 +117,11 @@ class MyOtherWebServer : public IHttpServer
int main(int argc, char** argv)
{
TF_InitWithConsole();
MyOtherWebServer myo;
MyWebServer mws;
std::shared_ptr<MyOtherWebServer> myo = std::make_shared<MyOtherWebServer>();
std::shared_ptr<MyWebServer> mws = std::make_shared<MyWebServer>();
MountableServer mountable(myo);
mountable.Mount("/mymount/",mws);
std::shared_ptr<MountableServer> mountable = std::make_shared<MountableServer>(myo);
mountable->Mount("/mymount/",mws);
HttpServer server(10001,mountable);
server.StartAccepting();
TF_RunEventLoop();

2
examples/wsecho.cpp
View File

@@ -39,7 +39,7 @@ int main(int argc, char** argv)
{
Tesses::Framework::TF_Init();
HttpDictionary reqHeaders;
WebSocketConn conn;
std::shared_ptr<WebSocketConn> conn = std::make_shared<WebSocketConn>();
WebSocketClient("ws://echo.websocket.org/",reqHeaders,conn);
return 0;

4
include/TessesFramework/Crypto/ClientTLSStream.hpp
View File

@@ -11,8 +11,8 @@ namespace Tesses::Framework::Crypto
public:
static std::string GetCertChain();
ClientTLSStream(Tesses::Framework::Streams::Stream* innerStream, bool owns, bool verify, std::string domain);
ClientTLSStream(Tesses::Framework::Streams::Stream* innerStream, bool owns, bool verify, std::string domain, std::string cert);
ClientTLSStream(std::shared_ptr<Tesses::Framework::Streams::Stream> innerStream, bool verify, std::string domain);
ClientTLSStream(std::shared_ptr<Tesses::Framework::Streams::Stream> innerStream, bool verify, std::string domain, std::string cert);
size_t Read(uint8_t* buff, size_t sz);
size_t Write(const uint8_t* buff, size_t sz);
bool CanRead();

22
include/TessesFramework/Crypto/MbedHelpers.hpp
View File

@@ -11,13 +11,11 @@ namespace Tesses::Framework::Crypto
Sha1();
bool Start();
bool Update(const uint8_t* buffer, size_t sz);
bool Update(Tesses::Framework::Streams::Stream* strm);
bool Update(Tesses::Framework::Streams::Stream& strm);
std::vector<uint8_t> Finish();
bool Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::vector<uint8_t> Finish();
~Sha1();
static std::vector<uint8_t> ComputeHash(const uint8_t* buffer, size_t len);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream* strm);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream& strm);
static std::vector<uint8_t> ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
};
class Sha256 {
void* inner;
@@ -27,13 +25,11 @@ namespace Tesses::Framework::Crypto
bool Start(bool is224=false);
bool Is224();
bool Update(const uint8_t* buffer, size_t sz);
bool Update(Tesses::Framework::Streams::Stream* strm);
bool Update(Tesses::Framework::Streams::Stream& strm);
bool Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::vector<uint8_t> Finish();
~Sha256();
static std::vector<uint8_t> ComputeHash(const uint8_t* buffer, size_t len,bool is224=false);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is224=false);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is224=false);
static std::vector<uint8_t> ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,bool is224=false);
};
class Sha512 {
@@ -44,14 +40,12 @@ namespace Tesses::Framework::Crypto
bool Start(bool is384=false);
bool Is384();
bool Update(const uint8_t* buffer, size_t sz);
bool Update(Tesses::Framework::Streams::Stream* strm);
bool Update(Tesses::Framework::Streams::Stream& strm);
std::vector<uint8_t> Finish();
bool Update(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::vector<uint8_t> Finish();
~Sha512();
static std::vector<uint8_t> ComputeHash(const uint8_t* buffer, size_t len,bool is384=false);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is384=false);
static std::vector<uint8_t> ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is384=false);
static std::vector<uint8_t> ComputeHash(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,bool is384=false);
};
typedef enum {
VERSION_SHA1=1,

9
include/TessesFramework/Filesystem/LocalFS.hpp
View File

@@ -8,7 +8,7 @@ namespace Tesses::Framework::Filesystem
{
public:
Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode);
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);
@@ -35,6 +35,11 @@ namespace Tesses::Framework::Filesystem
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
bool StatVFS(VFSPath path, StatVFSData& vfsData);
void Chmod(VFSPath path, uint32_t mode);
};
extern LocalFilesystem LocalFS;
extern std::shared_ptr<LocalFilesystem> LocalFS;
}

2
include/TessesFramework/Filesystem/MemoryFilesystem.hpp
View File

@@ -73,7 +73,7 @@ namespace Tesses::Framework::Filesystem
MemoryEntry* GetEntry(VFSPath path,bool followSymlink);
public:
MemoryFilesystem();
Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode);
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);

20
include/TessesFramework/Filesystem/MountableFilesystem.hpp
View File

@@ -7,29 +7,28 @@ namespace Tesses::Framework::Filesystem
class MountableDirectory {
public:
std::string name;
VFS* vfs;
std::shared_ptr<VFS> vfs;
bool owns;
std::vector<MountableDirectory*> dirs;
void GetFS(VFSPath srcPath, VFSPath curDir, VFSPath& destRoot, VFSPath& destPath, VFS*& vfs);
void GetFS(VFSPath srcPath, VFSPath curDir, VFSPath& destRoot, VFSPath& destPath, std::shared_ptr<VFS>& vfs);
~MountableDirectory();
};
class MountableFilesystem : public VFS
{
bool owns;
VFS* root;
std::shared_ptr<VFS> root;
std::vector<MountableDirectory*> directories;
void GetFS(VFSPath srcPath, VFSPath& destRoot, VFSPath& destPath, VFS*& vfs);
void GetFS(VFSPath srcPath, VFSPath& destRoot, VFSPath& destPath, std::shared_ptr<VFS>& vfs);
public:
MountableFilesystem();
MountableFilesystem(VFS* root, bool owns);
void Mount(VFSPath path, VFS* fs, bool owns);
MountableFilesystem(std::shared_ptr<VFS> root);
void Mount(VFSPath path, std::shared_ptr<VFS> vfs);
void Unmount(VFSPath path);
Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode);
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);
bool SpecialFileExists(VFSPath path);
@@ -53,5 +52,10 @@ namespace Tesses::Framework::Filesystem
~MountableFilesystem();
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
bool StatVFS(VFSPath path, StatVFSData& vfsData);
void Chmod(VFSPath path, uint32_t mode);
};
}

2
include/TessesFramework/Filesystem/NullFilesystem.hpp
View File

@@ -7,7 +7,7 @@ namespace Tesses::Framework::Filesystem
class NullFilesystem : public VFS
{
public:
Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode);
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);
bool RegularFileExists(VFSPath path);

12
include/TessesFramework/Filesystem/SubdirFilesystem.hpp
View File

@@ -6,14 +6,13 @@ namespace Tesses::Framework::Filesystem
{
class SubdirFilesystem : public VFS
{
bool owns;
VFS* parent;
std::shared_ptr<VFS> parent;
VFSPath path;
VFSPath ToParent(VFSPath path);
VFSPath FromParent(VFSPath path);
public:
SubdirFilesystem(VFS* parent, VFSPath path, bool owns);
Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode);
SubdirFilesystem(std::shared_ptr<VFS> parent, VFSPath path);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode);
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);
bool SpecialFileExists(VFSPath path);
@@ -38,6 +37,9 @@ namespace Tesses::Framework::Filesystem
~SubdirFilesystem();
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
bool StatVFS(VFSPath path, StatVFSData& vfsData);
void Chmod(VFSPath path, uint32_t mode);
};
}

20
include/TessesFramework/Filesystem/VFS.hpp
View File

@@ -8,6 +8,20 @@
namespace Tesses::Framework::Filesystem
{
class StatVFSData {
public:
uint64_t BlockSize;
uint64_t FragmentSize;
uint64_t Blocks;
uint64_t BlocksFree;
uint64_t BlocksAvailable;
uint64_t TotalInodes;
uint64_t FreeInodes;
uint64_t AvailableInodes;
uint64_t Id;
uint64_t Flags;
uint64_t MaxNameLength;
};
class VFSPath {
public:
static VFSPath CurrentDirectoryAsRelative();
@@ -107,7 +121,7 @@ namespace Tesses::Framework::Filesystem
class VFS {
public:
virtual Tesses::Framework::Streams::Stream* OpenFile(VFSPath path, std::string mode)=0;
virtual std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(VFSPath path, std::string mode)=0;
virtual void CreateDirectory(VFSPath path)=0;
virtual void DeleteDirectory(VFSPath path)=0;
virtual bool RegularFileExists(VFSPath path)=0;
@@ -134,6 +148,10 @@ namespace Tesses::Framework::Filesystem
virtual void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
virtual void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
virtual bool StatVFS(VFSPath path, StatVFSData& data);
virtual void Chmod(VFSPath path, uint32_t mode);
virtual ~VFS();
};
}

8
include/TessesFramework/Http/FileServer.hpp
View File

@@ -6,8 +6,8 @@ namespace Tesses::Framework::Http
{
class FileServer : public IHttpServer
{
Tesses::Framework::Filesystem::VFS* vfs;
bool ownsVFS;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
bool SendFile(ServerContext& ctx,Tesses::Framework::Filesystem::VFSPath path);
@@ -17,8 +17,8 @@ namespace Tesses::Framework::Http
std::vector<std::string> defaultNames;
FileServer(std::filesystem::path path,bool allowListing,bool spa);
FileServer(std::filesystem::path path,bool allowListing, bool spa, std::vector<std::string> defaultNames);
FileServer(Tesses::Framework::Filesystem::VFS* fs, bool owns, bool allowListing, bool spa);
FileServer(Tesses::Framework::Filesystem::VFS* fs, bool owns, bool allowListing, bool spa, std::vector<std::string> defaultNames);
FileServer(std::shared_ptr<Tesses::Framework::Filesystem::VFS> fs, bool allowListing, bool spa);
FileServer(std::shared_ptr<Tesses::Framework::Filesystem::VFS> fs, bool allowListing, bool spa, std::vector<std::string> defaultNames);
bool Handle(ServerContext& ctx);
~FileServer();
};

47
include/TessesFramework/Http/HttpClient.hpp
View File

@@ -10,18 +10,18 @@ namespace Tesses::Framework::Http
class HttpRequestBody {
public:
virtual void HandleHeaders(HttpDictionary& dict);
virtual void Write(Tesses::Framework::Streams::Stream* strm)=0;
virtual void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)=0;
virtual ~HttpRequestBody();
};
class StreamHttpRequestBody : public HttpRequestBody {
Tesses::Framework::Streams::Stream* strm;
bool owns;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
std::string mimeType;
public:
StreamHttpRequestBody(Tesses::Framework::Streams::Stream* strm, bool owns, std::string mimeType);
StreamHttpRequestBody(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, std::string mimeType);
void HandleHeaders(HttpDictionary& dict);
void Write(Tesses::Framework::Streams::Stream* strm);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
~StreamHttpRequestBody();
};
@@ -31,7 +31,7 @@ namespace Tesses::Framework::Http
public:
TextHttpRequestBody(std::string text, std::string mimeType);
void HandleHeaders(HttpDictionary& dict);
void Write(Tesses::Framework::Streams::Stream* strm);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
~TextHttpRequestBody();
};
@@ -49,52 +49,47 @@ namespace Tesses::Framework::Http
HttpDictionary requestHeaders;
HttpRequestBody* body;
static Tesses::Framework::Streams::Stream* EstablishConnection(Uri uri,bool ignoreSSLErrors,std::string trusted_root_cert_bundle);
static Tesses::Framework::Streams::Stream* EstablishUnixPathConnection(std::string unixPath, Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle);
static std::shared_ptr<Tesses::Framework::Streams::Stream> EstablishConnection(Uri uri,bool ignoreSSLErrors,std::string trusted_root_cert_bundle);
static std::shared_ptr<Tesses::Framework::Streams::Stream> EstablishUnixPathConnection(std::string unixPath, Uri uri, bool ignoreSSLErrors, std::string trusted_root_cert_bundle);
void SendRequest(Tesses::Framework::Streams::Stream* strm);
void SendRequest(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
};
class HttpResponse {
private:
bool owns;
Tesses::Framework::Streams::Stream* handleStrm;
std::shared_ptr<Tesses::Framework::Streams::Stream> handleStrm;
public:
HttpResponse(Tesses::Framework::Streams::Stream* strm, bool owns);
HttpResponse(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
HttpResponse(HttpRequest& request);
std::string version;
StatusCode statusCode;
HttpDictionary responseHeaders;
std::string ReadAsString();
Tesses::Framework::Streams::Stream* ReadAsStream();
void CopyToStream(Tesses::Framework::Streams::Stream* strm);
Tesses::Framework::Streams::Stream* GetInternalStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> ReadAsStream();
void CopyToStream(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::shared_ptr<Tesses::Framework::Streams::Stream> GetInternalStream();
~HttpResponse();
};
void DownloadToStreamSimple(std::string url, Tesses::Framework::Streams::Stream* strm);
void DownloadToStreamSimple(std::string url, Tesses::Framework::Streams::Stream& strm);
void DownloadToStreamSimple(std::string url, std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void DownloadToFileSimple(std::string url, std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path);
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Filesystem::VFSPath path);
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFS& vfs, Tesses::Framework::Filesystem::VFSPath path);
void DownloadToFileSimple(std::string url, Tesses::Framework::Filesystem::VFSPath path);
std::string DownloadToStringSimple(std::string url);
bool WebSocketClientSuccessDefault(HttpDictionary& dict,bool v);
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, WebSocketConnection& wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, WebSocketConnection* wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
void WebSocketClient(std::string url, HttpDictionary& requestHeaders, std::shared_ptr<WebSocketConnection> wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
void DownloadUnixSocketToStreamSimple(std::string unixSocket,std::string url, Tesses::Framework::Streams::Stream* strm);
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);
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, 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);
void DownloadUnixSocketToFileSimple(std::string unixSocket,std::string url, Tesses::Framework::Filesystem::VFSPath path);
std::string DownloadUnixSocketToStringSimple(std::string unixSocket,std::string url);
void WebSocketUnixSocketClient(std::string unixSocket,std::string url, HttpDictionary& requestHeaders, WebSocketConnection& wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
void WebSocketUnixSocketClient(std::string unixSocket,std::string url,HttpDictionary& requestHeaders, WebSocketConnection* wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
void WebSocketUnixSocketClient(std::string unixSocket,std::string url, HttpDictionary& requestHeaders, std::shared_ptr<WebSocketConnection> wsc, std::function<bool(HttpDictionary&,bool)> cb=WebSocketClientSuccessDefault);
}

39
include/TessesFramework/Http/HttpServer.hpp
View File

@@ -17,7 +17,7 @@ namespace Tesses::Framework::Http
class ServerContext {
bool sent;
Tesses::Framework::Streams::Stream* strm;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
std::map<std::string,ServerContextData*> data;
public:
HttpDictionary requestHeaders;
@@ -31,27 +31,25 @@ namespace Tesses::Framework::Http
uint16_t port;
std::string version;
bool encrypted;
ServerContext(Tesses::Framework::Streams::Stream* strm);
ServerContext(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
~ServerContext();
Tesses::Framework::Streams::Stream& GetStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStream();
std::string GetOriginalPathWithQuery();
std::string GetUrlWithQuery();
bool Sent();
bool NeedToParseFormData();
void ParseFormData(std::function<Tesses::Framework::Streams::Stream*(std::string mime, std::string filename, std::string name)> cb);
void ReadStream(Tesses::Framework::Streams::Stream& strm);
void ReadStream(Tesses::Framework::Streams::Stream* strm);
void ParseFormData(std::function<std::shared_ptr<Tesses::Framework::Streams::Stream>(std::string mime, std::string filename, std::string name)> cb);
void ReadStream(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string ReadString();
void SendBytes(std::vector<uint8_t> buffer);
void SendText(std::string text);
void SendStream(Tesses::Framework::Streams::Stream& strm);
void SendStream(Tesses::Framework::Streams::Stream* strm);
void SendStream(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void SendErrorPage(bool showPath);
void SendNotFound();
void SendBadRequest();
void SendException(std::exception& ex);
Tesses::Framework::Streams::Stream* OpenResponseStream();
Tesses::Framework::Streams::Stream* OpenRequestStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenResponseStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenRequestStream();
ServerContext& WithLastModified(Date::DateTime time);
ServerContext& WithHeader(std::string key, std::string value);
ServerContext& WithSingleHeader(std::string key, std::string value);
@@ -59,7 +57,7 @@ namespace Tesses::Framework::Http
ServerContext& WithContentDisposition(std::string filename, bool isInline);
ServerContext& WriteHeaders();
void 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);
void StartWebSocketSession(WebSocketConnection& connection);
void StartWebSocketSession(std::shared_ptr<WebSocketConnection> connection);
template<class T>
T* GetServerContentData(std::string tag)
@@ -81,27 +79,20 @@ namespace Tesses::Framework::Http
};
class HttpServer {
Tesses::Framework::Streams::TcpServer* server;
IHttpServer* http;
std::shared_ptr<Tesses::Framework::Streams::TcpServer> server;
std::shared_ptr<IHttpServer> http;
Tesses::Framework::Threading::Thread* thrd;
bool ownsTCP;
bool ownsHttp;
bool showIPs;
bool showARTL;
public:
HttpServer(Tesses::Framework::Streams::TcpServer& tcpServer, IHttpServer& http, bool showIPs=true);
HttpServer(Tesses::Framework::Streams::TcpServer* tcpServer, bool ownsTCP, IHttpServer& http, bool showIPs=true);
HttpServer(Tesses::Framework::Streams::TcpServer& tcpServer, IHttpServer* http, bool ownsHttpServer, bool showIPs=true);
HttpServer(Tesses::Framework::Streams::TcpServer* tcpServer, bool ownsTCP, IHttpServer* http, bool ownsHttpServer, bool showIPs=true);
HttpServer(uint16_t port, IHttpServer& http, bool showIPs=true);
HttpServer(uint16_t port, IHttpServer* http, bool owns, bool showIPs=true);
HttpServer(std::string unixPath, IHttpServer& http);
HttpServer(std::string unixPath, IHttpServer* http, bool owns);
HttpServer(std::shared_ptr<Tesses::Framework::Streams::TcpServer> tcpServer, std::shared_ptr<IHttpServer> http, bool showIPs=true);
HttpServer(uint16_t port, std::shared_ptr<IHttpServer> http, bool showIPs=true);
HttpServer(std::string unixPath, std::shared_ptr<IHttpServer> http);
uint16_t GetPort();
void StartAccepting();
static void Process(Tesses::Framework::Streams::Stream& strm, IHttpServer& server, std::string ip, uint16_t port, bool encrypted);
static void Process(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port, bool encrypted);
~HttpServer();
};
}

6
include/TessesFramework/Http/HttpStream.hpp
View File

@@ -4,22 +4,20 @@
namespace Tesses::Framework::Http
{
class HttpStream : public Tesses::Framework::Streams::Stream {
Tesses::Framework::Streams::Stream* strm;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
size_t offset;
size_t read;
int64_t length;
int64_t position;
bool owns;
bool recv;
bool http1_1;
bool done;
public:
HttpStream(Tesses::Framework::Streams::Stream* strm, bool owns, int64_t length, bool recv, bool http1_1);
HttpStream(Tesses::Framework::Streams::Stream& strm, int64_t length, bool recv,bool http1_1);
HttpStream(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, int64_t length, bool recv, bool http1_1);
bool CanRead();
bool CanWrite();
bool EndOfStream();

11
include/TessesFramework/Http/MountableServer.hpp
View File

@@ -7,17 +7,14 @@ namespace Tesses::Framework::Http
{
class MountableServer : public IHttpServer
{
IHttpServer* root;
bool owns;
std::vector<std::pair<std::string,std::pair<bool,IHttpServer*>>> servers;
std::shared_ptr<IHttpServer> root;
std::vector<std::pair<std::string,std::shared_ptr<IHttpServer>>> servers;
std::string Subpath(Filesystem::VFSPath fullPath, Filesystem::VFSPath offsetPath);
bool StartsWith(Filesystem::VFSPath fullPath, Filesystem::VFSPath offsetPath);
public:
MountableServer();
MountableServer(IHttpServer* root, bool owns);
MountableServer(IHttpServer& root);
void Mount(std::string path, IHttpServer* server, bool owns);
void Mount(std::string path, IHttpServer& server);
MountableServer(std::shared_ptr<IHttpServer> root);
void Mount(std::string path, std::shared_ptr<IHttpServer> server);
void Unmount(std::string path);
bool Handle(ServerContext& ctx);
~MountableServer();

24
include/TessesFramework/Mail/Smtp.hpp
View File

@@ -6,7 +6,7 @@ class SMTPBody
{
public:
std::string mimeType;
virtual void Write(Tesses::Framework::Streams::Stream* strm)=0;
virtual void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)=0;
virtual ~SMTPBody();
};
@@ -16,27 +16,25 @@ class SMTPStringBody : public SMTPBody
SMTPStringBody();
SMTPStringBody(std::string text, std::string mimeType);
std::string text;
void Write(Tesses::Framework::Streams::Stream* strm);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
};
class SMTPStreamBody : public SMTPBody
{
Tesses::Framework::Streams::Stream* stream;
bool owns;
std::shared_ptr<Tesses::Framework::Streams::Stream> stream;
public:
SMTPStreamBody(std::string mimeType,Tesses::Framework::Streams::Stream& stream);
SMTPStreamBody(std::string mimeType,Tesses::Framework::Streams::Stream* stream, bool owns);
void Write(Tesses::Framework::Streams::Stream* strm);
SMTPStreamBody(std::string mimeType,std::shared_ptr<Tesses::Framework::Streams::Stream> stream);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
~SMTPStreamBody();
};
class SMTPClient {
Tesses::Framework::Streams::Stream* strm;
bool owns;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
public:
SMTPClient(Tesses::Framework::Streams::Stream* stream,bool owns=true);
SMTPClient(Tesses::Framework::Streams::Stream& strm);
SMTPClient(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string domain;
std::string username;
std::string password;
@@ -44,8 +42,8 @@ class SMTPClient {
std::string from_name;
std::string to;
std::string subject;
SMTPBody* body;
std::vector<std::pair<std::string,SMTPBody*>> attachments;
std::shared_ptr<SMTPBody> body;
std::vector<std::pair<std::string,std::shared_ptr<SMTPBody>>> attachments;
void Send();
~SMTPClient();
};

11
include/TessesFramework/Platform/Process.hpp
View File

@@ -27,14 +27,11 @@ class Process {
void CloseStdInNow();
//YOU ARE RESPONSABLE FOR FREEING THIS STREAM OBJECT
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStdinStream();
Tesses::Framework::Streams::Stream* GetStdinStream();
//YOU ARE RESPONSABLE FOR FREEING THIS STREAM OBJECT
Tesses::Framework::Streams::Stream* GetStdoutStream();
//YOU ARE RESPONSABLE FOR FREEING THIS STREAM OBJECT
Tesses::Framework::Streams::Stream* GetStderrStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStdoutStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStderrStream();
Process();
Process(std::string name, std::vector<std::string> args,bool includeThisEnv=true);

6
include/TessesFramework/Streams/BufferedStream.hpp
View File

@@ -6,15 +6,13 @@ namespace Tesses::Framework::Streams
class BufferedStream : public Stream
{
private:
Stream* strm;
bool owns;
std::shared_ptr<Stream> strm;
uint8_t* buffer;
size_t bufferSize;
size_t offset;
size_t read;
public:
BufferedStream(Stream* strm, bool owns, size_t bufferSize=1024);
BufferedStream(Stream& strm, size_t bufferSize=1024);
BufferedStream(std::shared_ptr<Stream> strm, size_t bufferSize=1024);
bool EndOfStream();
bool CanRead();
bool CanWrite();

9
include/TessesFramework/Streams/ByteReader.hpp
View File

@@ -4,12 +4,10 @@
namespace Tesses::Framework::Streams
{
class ByteReader {
Stream* strm;
bool owns;
std::shared_ptr<Stream> strm;
public:
Stream* GetStream();
ByteReader(Stream* strm, bool owns);
ByteReader(Stream& strm);
std::shared_ptr<Stream> GetStream();
ByteReader(std::shared_ptr<Stream> strm);
uint8_t ReadU8();
uint16_t ReadU16BE();
uint16_t ReadU16LE();
@@ -28,6 +26,5 @@ namespace Tesses::Framework::Streams
float ReadF32LE();
double ReadF64BE();
double ReadF64LE();
~ByteReader();
};
}

10
include/TessesFramework/Streams/ByteWriter.hpp
View File

@@ -4,12 +4,11 @@
namespace Tesses::Framework::Streams
{
class ByteWriter {
Stream* strm;
bool owns;
std::shared_ptr<Stream> strm;
public:
Stream* GetStream();
ByteWriter(Stream* strm, bool owns);
ByteWriter(Stream& strm);
std::shared_ptr<Stream> GetStream();
ByteWriter(std::shared_ptr<Stream> strm);
void WriteU8(uint8_t v);
void WriteU16BE(uint16_t v);
void WriteU16LE(uint16_t v);
@@ -28,6 +27,5 @@ namespace Tesses::Framework::Streams
void WriteF32LE(float v);
void WriteF64BE(double v);
void WriteF64LE(double v);
~ByteWriter();
};
}

4
include/TessesFramework/Streams/NetworkStream.hpp
View File

@@ -15,7 +15,7 @@ namespace Tesses::Framework::Streams
TcpServer(uint16_t port, int32_t backlog);
TcpServer(std::string ip, uint16_t port, int32_t backlog);
TcpServer(std::string unixPath,int32_t backlog);
NetworkStream* GetStream(std::string& ip, uint16_t& port);
std::shared_ptr<NetworkStream> GetStream(std::string& ip, uint16_t& port);
uint16_t GetPort();
~TcpServer();
bool IsValid();
@@ -45,7 +45,7 @@ namespace Tesses::Framework::Streams
void Listen(int32_t backlog);
void Bind(std::string ip, uint16_t port);
void SetBroadcast(bool bC);
NetworkStream* Accept(std::string& ip, uint16_t& port);
std::shared_ptr<NetworkStream> Accept(std::string& ip, uint16_t& port);
size_t Read(uint8_t* buff, size_t sz);
size_t Write(const uint8_t* buff, size_t sz);
size_t ReadFrom(uint8_t* buff, size_t sz, std::string& ip, uint16_t& port);

3
include/TessesFramework/Streams/Stream.hpp
View File

@@ -23,8 +23,7 @@ namespace Tesses::Framework::Streams
virtual int64_t GetLength();
virtual void Flush();
virtual void Seek(int64_t pos, SeekOrigin whence);
void CopyTo(Stream* strm, size_t buffSize=1024);
void CopyTo(Stream& strm, size_t buffSize=1024);
void CopyTo(std::shared_ptr<Stream> strm, size_t buffSize=1024);
virtual ~Stream();
};
}

77
include/TessesFramework/TessesFramework.h
View File

@@ -1,77 +0,0 @@
#pragma once
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
typedef void string_t;
typedef void tf_vfs_t;
typedef void tf_stream_t;
typedef void tf_thread_t;
typedef void tf_mutex_t;
typedef void tf_vfs_dir_t;
typedef void (*tf_action_user_data_t)(void* ptr);
typedef enum {
TF_SEEK_BEGIN,
TF_SEEK_CURRENT,
TF_SEEK_END
} TF_WHENCE;
string_t* string_create();
string_t* string_create_from_buff(const void* text, size_t len);
string_t* string_create_from_charpointer(const char* text);
string_t* string_resize(string_t* str, size_t len);
string_t* string_set_char(string_t* str, size_t index, char c);
char string_get_char(string_t* str,size_t index);
string_t* string_append_char(string_t* str, char c);
string_t* string_append_from_buff(string_t* str,const void* text, size_t len);
string_t* string_append_from_charpointer(string_t* str,const char* text);
string_t* string_append(string_t* str, string_t* toAppend);
string_t* string_append_signed(string_t* str, int64_t num);
string_t* string_append_unsigned(string_t* str, uint64_t num);
string_t* string_append_double(string_t* str, double num);
void string_print(string_t* str);
void string_println(string_t* str);
size_t string_size(string_t* str);
const char* string_c_str(string_t* str);
void string_free(string_t* str);
void tf_init();
tf_thread_t* tf_create_thread(void* userData, tf_action_user_data_t cb);
void tf_join_thread(tf_thread_t* thrd);
void tf_detach_thread(tf_thread_t* thrd);
tf_mutex_t* tf_mutex_create();
void tf_mutex_lock(tf_mutex_t* mtx);
bool tf_mutex_trylock(tf_mutex_t* mtx);
void tf_mutex_unlock(tf_mutex_t* mtx);
void tf_mutex_free(tf_mutex_t* mtx);
bool tf_stream_canread(tf_stream_t* strm);
bool tf_stream_canwrite(tf_stream_t* strm);
bool tf_stream_canseek(tf_stream_t* strm);
bool tf_stream_eof(tf_stream_t* strm);
int64_t tf_stream_getlen(tf_stream_t* strm);
int64_t tf_stream_getpos(tf_stream_t* strm);
void tf_stream_seek(tf_stream_t* strm, int64_t pos, TF_WHENCE whence);
size_t tf_stream_read(tf_stream_t* strm, uint8_t* buffer, size_t length);
size_t tf_stream_write(tf_stream_t* strm, const uint8_t* buffer, size_t length);
size_t tf_stream_readblock(tf_stream_t* strm, uint8_t* buffer, size_t length);
void tf_stream_writeblock(tf_stream_t* strm, const uint8_t* buffer, size_t length);
void tf_stream_copyto(tf_stream_t* src, tf_stream_t* dest, size_t blockSize);
void tf_stream_close(tf_stream_t* strm);
void tf_stream_flush(tf_stream_t* strm);
int32_t tf_stream_readbyte(tf_stream_t* strm);
void tf_stream_writebyte(tf_stream_t* strm, uint8_t val);
tf_stream_t* tf_stream_fopen(const char* file, const char* mode);
#if defined(__cplusplus)
}
#endif

6
include/TessesFramework/Text/HeaderGenerator.hpp
View File

@@ -3,9 +3,9 @@
#include "../TextStreams/StringWriter.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);
std::string GenerateCHeaderFile(Streams::Stream* strm,std::string name);
void GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name, TextStreams::TextWriter* writer);
std::string GenerateCHeaderFile(std::shared_ptr<Streams::Stream> strm,std::string name);
void GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name, std::shared_ptr<TextStreams::TextWriter> writer);
std::string GenerateCHeaderFile(const std::vector<uint8_t>& data,std::string name);
}

7
include/TessesFramework/TextStreams/StreamReader.hpp
View File

@@ -6,12 +6,11 @@ namespace Tesses::Framework::TextStreams
class StreamReader : public TextReader
{
private:
Tesses::Framework::Streams::Stream* strm;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
bool owns;
public:
Tesses::Framework::Streams::Stream& GetStream();
StreamReader(Tesses::Framework::Streams::Stream& strm);
StreamReader(Tesses::Framework::Streams::Stream* strm, bool owns);
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStream();
StreamReader(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
StreamReader(std::filesystem::path filename);
bool ReadBlock(std::string& str,size_t sz);
bool Rewind();

8
include/TessesFramework/TextStreams/StreamWriter.hpp
View File

@@ -6,12 +6,10 @@ namespace Tesses::Framework::TextStreams
{
class StreamWriter : public TextWriter {
private:
Tesses::Framework::Streams::Stream* strm;
bool owns;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
public:
Tesses::Framework::Streams::Stream& GetStream();
StreamWriter(Tesses::Framework::Streams::Stream& strm);
StreamWriter(Tesses::Framework::Streams::Stream* strm, bool owns);
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStream();
StreamWriter(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
StreamWriter(std::filesystem::path filename, bool append=false);
void WriteData(const char* text, size_t len);
~StreamWriter();

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