tesses50/tessesframework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Change html to dark mode by default and stat in vfs

Browse Source
This commit is contained in:
Mike Nolan
2026-04-19 23:07:17 -05:00
parent 5435280209
commit c5cf13e1b7
40 changed files with 1110 additions and 1956 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
.gitea/workflows/tag.yaml
View File

@@ -2,7 +2,7 @@ name: Build and Deploy on Tag
on:
push:
tags:
- 'v*'
- "v*"
env:
GITEA_AUTH: ${{ secrets.MY_GITEA_AUTH }}
@@ -20,24 +20,3 @@ jobs:
- run: chown build:build /home/build/PKGBUILD
- run: chown build:build /home/build/build-arch.sh
- run: su build -c /home/build/build-arch.sh
build-jammy:
runs-on: deb-builder-jammy
steps:
- uses: actions/checkout@v4
- name: Build for jammy, noble
run: |
bash build-ubuntu-jammy.sh
bash push-ubuntu-jammy.sh
working-directory: ./Packaging/Linux
build-plucky:
runs-on: deb-builder-plucky
steps:
- uses: actions/checkout@v4
- name: Build for plucky, resolute
run: |
bash build-ubuntu-plucky.sh
bash push-ubuntu-plucky.sh
working-directory: ./Packaging/Linux
- uses: akkuman/gitea-release-action@v1
env:
NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18

52
.onedev-buildspec.yml
View File

@@ -1,52 +0,0 @@
version: 43
jobs:
- name: Build for x86_64
steps:
- type: CheckoutStep
name: Checkout
cloneCredential:
type: DefaultCredential
withLfs: true
withSubmodules: false
condition: SUCCESSFUL
optional: false
- type: CommandStep
name: Execute build
runInContainer: true
image: onedev.site.tesses.net/dependencies/dependencies:latest
interpreter:
type: DefaultInterpreter
commands: |
mkdir build
cd build
cmake -S .. -B . -DTESSESFRAMEWORK_FETCHCONTENT=OFF
make -j12
make install DESTDIR=out
useTTY: true
condition: SUCCESSFUL
optional: false
- type: BuildImageStep
name: Build Docker Image
dockerfile: Dockerfile.run
output:
type: RegistryOutput
tags: onedev.site.tesses.net/tesses-framework/tesses-framework:latest onedev.site.tesses.net/tesses-framework/tesses-framework:@commit_hash@ git.tesseslanguage.com/tesses50/tesses-framework:latest git.tesseslanguage.com/tesses50/tesses-framework:@commit_hash@
registryLogins:
- registryUrl: '@server_url@'
userName: '@job_token@'
passwordSecret: dockersecret
- registryUrl: git.tesseslanguage.com
userName: tesses50
passwordSecret: GITEA_AUTH
platforms: linux/amd64
condition: SUCCESSFUL
optional: false
triggers:
- type: BranchUpdateTrigger
branches: master
userMatch: anyone
projects: tesses-framework
retryCondition: never
maxRetries: 3
retryDelay: 30
timeout: 14400

71
CMakeLists.txt
View File

@@ -7,68 +7,7 @@ set(TESSESFRAMEWORK_PATCH_VERSION 2)
project(TessesFramework VERSION ${TESSESFRAMEWORK_MAJOR_VERSION}.${TESSESFRAMEWORK_MINOR_VERSION}.${TESSESFRAMEWORK_PATCH_VERSION})
set(CMAKE_CXX_STANDARD 17)
list(APPEND TESSESFRAMEWORK_SOURCE
src/Random.cpp
src/Date/Date.cpp
src/Http/FileServer.cpp
src/Http/MountableServer.cpp
src/Http/RouteServer.cpp
src/Http/CallbackServer.cpp
src/Http/HttpServer.cpp
src/Http/HttpUtils.cpp
src/Http/HttpClient.cpp
src/Http/HttpStream.cpp
src/Http/ContentDisposition.cpp
src/Http/WebSocket.cpp
src/Http/ChangeableServer.cpp
src/Http/BasicAuthServer.cpp
src/Http/CGIServer.cpp
src/Mail/Smtp.cpp
src/Serialization/Json.cpp
src/Serialization/SQLite.cpp
src/Serialization/BitConverter.cpp
src/Serialization/Bencode.cpp
src/Platform/Environment.cpp
src/Platform/Process.cpp
src/Streams/FileStream.cpp
src/Streams/MemoryStream.cpp
src/Streams/NetworkStream.cpp
src/Streams/Stream.cpp
src/Streams/BufferedStream.cpp
src/Streams/ByteReader.cpp
src/Streams/ByteWriter.cpp
src/Streams/PtyStream.cpp
src/Text/StringConverter.cpp
src/Text/HeaderGenerator.cpp
src/TextStreams/StreamReader.cpp
src/TextStreams/StreamWriter.cpp
src/TextStreams/TextReader.cpp
src/TextStreams/TextWriter.cpp
src/TextStreams/StdIOReader.cpp
src/TextStreams/StdIOWriter.cpp
src/TextStreams/StringReader.cpp
src/TextStreams/StringWriter.cpp
src/Threading/Thread.cpp
src/Threading/Mutex.cpp
src/Threading/ThreadPool.cpp
src/Filesystem/VFS.cpp
src/Filesystem/LocalFS.cpp
src/Filesystem/MemoryFilesystem.cpp
src/Filesystem/SubdirFilesystem.cpp
src/Filesystem/NullFilesystem.cpp
src/Filesystem/MountableFilesystem.cpp
src/Filesystem/FSHelpers.cpp
src/Filesystem/TempFS.cpp
src/Crypto/MbedTLS/ClientTLSStream.cpp
src/Crypto/MbedTLS/Crypto.cpp
src/Args.cpp
src/TF_Init.cpp
src/HiddenField.cpp
src/Uuid.cpp
src/BitTorrent/TorrentFile.cpp
src/BitTorrent/TorrentStream.cpp
)
include(cmake/sources.cmake)
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
@@ -150,7 +89,7 @@ FetchContent_Declare(
FetchContent_MakeAvailable(mbedtls)
else()
set(MBEDTLS_DIR "" CACHE PATH "Mbed tls directory")
find_package(MbedTLS REQUIRED)
endif()
endif()
@@ -280,7 +219,7 @@ if(TESSESFRAMEWORK_FETCHCONTENT)
target_link_libraries(tessesframework_shared PUBLIC mbedtls mbedx509 mbedcrypto everest p256m)
else()
target_link_libraries(tessesframework_shared PUBLIC mbedtls mbedx509 mbedcrypto)
target_link_libraries(tessesframework_shared PUBLIC MbedTLS::mbedcrypto MbedTLS::mbedtls MbedTLS::mbedx509)
endif()
endif()
@@ -329,6 +268,8 @@ DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesFramework)
endif()
if(TESSESFRAMEWORK_ENABLE_EXAMPLES)
add_executable(timer examples/timer.cpp)
target_link_libraries(timer PUBLIC tessesframework)
add_executable(copyfile examples/copyfile.cpp)
target_link_libraries(copyfile PUBLIC tessesframework)
@@ -351,8 +292,6 @@ if(TESSESFRAMEWORK_ENABLE_EXAMPLES)
add_executable(wsecho examples/wsecho.cpp)
target_link_libraries(wsecho PUBLIC tessesframework)
add_executable(runevent examples/runevent.cpp)
target_link_libraries(runevent PUBLIC tessesframework)
add_executable(tests examples/tests.cpp)
target_link_libraries(tests PUBLIC tessesframework)

5
Dockerfile
View File

@@ -1,5 +0,0 @@
FROM ubuntu:noble
RUN apt update && apt install -y cmake g++ gcc libmbedtls-dev build-essential git ca-certificates
RUN mkdir /src && cd /src && git clone https://onedev.site.tesses.net/tesses-framework . && mkdir build && cd build && cmake -S .. -B . && make -j12 && make install && cd / && rm -r /src

3
Dockerfile.run
View File

@@ -1,3 +0,0 @@
FROM onedev.site.tesses.net/dependencies/dependencies:latest
COPY build/out /

14
Packaging/Linux/PKGBUILD
View File

@@ -1,16 +1,16 @@
# Maintainer: Mike Nolan <tesses@tesses.net>
pkgname=tesses-framework # '-bzr', '-git', '-hg' or '-svn'
pkgver=0.0.2
pkgname=tessesframework # '-bzr', '-git', '-hg' or '-svn'
pkgver=0.0.3
pkgrel=1
pkgdesc=""
arch=('x86_64' 'powerpc')
url="https://onedev.site.tesses.net/tesses-framework"
url="https://git.tesses.org/tessesframework"
license=('MIT')
groups=()
depends=('mbedtls')
makedepends=('git' 'cmake' 'make' 'base-devel' 'wget') # 'bzr', 'git', 'mercurial' or 'subversion'
install=
source=('tesses-framework::git+https://onedev.site.tesses.net/tesses-framework')
source=('tessesframework::git+https://git.tesses.org/tesses-framework')
noextract=()
sha256sums=('SKIP')
if [[ -z "$CMAKE_TOOLCHAIN" ]]; then
@@ -22,7 +22,6 @@ fi
prepare() {
cd "$srcdir/${pkgname}"
wget https://downloads.tesses.net/ShellPackage.crvm
}
build() {
@@ -30,9 +29,9 @@ build() {
mkdir build
if [[ -z "$CMAKE_TOOLCHAIN" ]]; then
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release
else
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE="$CMAKE_TOOLCHAIN"
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE="$CMAKE_TOOLCHAIN"
fi
cd build
@@ -47,4 +46,3 @@ package() {
cd "$srcdir/${pkgname}/build"
make install DESTDIR="$pkgdir/"
}

4
Packaging/Linux/build-arch.sh
View File

@@ -6,7 +6,7 @@ cp ../PKGBUILD .
makepkg
curl --user tesses50:$GITEA_AUTH \
--upload-file *.pkg.tar.zst \
https://git.tesseslanguage.com/api/packages/tesses50/arch/core
https://git.tesses.org/api/packages/tesses50/arch/core
cd ..
mkdir powerpc
cd powerpc
@@ -14,4 +14,4 @@ cp ../PKGBUILD .
CARCH=powerpc CMAKE_TOOLCHAIN=/opt/cross/ppc/toolchain.cmake makepkg
curl --user tesses50:$GITEA_AUTH \
--upload-file *.pkg.tar.zst \
https://git.tesseslanguage.com/api/packages/tesses50/arch/core
https://git.tesses.org/api/packages/tesses50/arch/core

46
Packaging/Linux/build-ubuntu-jammy.sh
View File

@@ -1,46 +0,0 @@
#!/bin/bash
source ./version.sh
mkdir -p build/jammy
cd build/jammy
mkdir build-amd64
cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF
cd build-amd64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_amd64
mkdir -p ../tessesframework_$DEB_VERSION\_amd64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_amd64/DEBIAN/control amd64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_amd64
# ARM64
mkdir build-arm64
cmake -S ../../../../ -B build-arm64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/arm64.cmake
cd build-arm64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_arm64
mkdir -p ../tessesframework_$DEB_VERSION\_arm64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_arm64/DEBIAN/control arm64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_arm64
# RISCV64
mkdir build-riscv64
cmake -S ../../../../ -B build-riscv64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/riscv64.cmake
cd build-riscv64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_riscv64
mkdir -p ../tessesframework_$DEB_VERSION\_riscv64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_riscv64/DEBIAN/control riscv64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_riscv64
# ARMHF
mkdir build-armhf
cmake -S ../../../../ -B build-armhf -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/armhf.cmake
cd build-armhf
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_armhf
mkdir -p ../tessesframework_$DEB_VERSION\_armhf/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_armhf/DEBIAN/control armhf
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_armhf

57
Packaging/Linux/build-ubuntu-plucky.sh
View File

@@ -1,57 +0,0 @@
#!/bin/bash
source ./version.sh
mkdir -p build/plucky
cd build/plucky
mkdir build-amd64
cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF
cd build-amd64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_amd64
mkdir -p ../tessesframework_$DEB_VERSION\_amd64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_amd64/DEBIAN/control amd64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_amd64
# ARM64
mkdir build-arm64
cmake -S ../../../../ -B build-arm64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/arm64.cmake
cd build-arm64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_arm64
mkdir -p ../tessesframework_$DEB_VERSION\_arm64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_arm64/DEBIAN/control arm64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_arm64
# RISCV64
mkdir build-riscv64
cmake -S ../../../../ -B build-riscv64 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/riscv64.cmake
cd build-riscv64
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_riscv64
mkdir -p ../tessesframework_$DEB_VERSION\_riscv64/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_riscv64/DEBIAN/control riscv64
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_riscv64
# ARMHF
mkdir build-armhf
cmake -S ../../../../ -B build-armhf -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/armhf.cmake
cd build-armhf
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_armhf
mkdir -p ../tessesframework_$DEB_VERSION\_armhf/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_armhf/DEBIAN/control armhf
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_armhf
# I386
mkdir build-i386
cmake -S ../../../../ -B build-i386 -DCMAKE_INSTALL_PREFIX=/usr -DTESSESFRAMEWORK_VENDERCERTCHAIN=OFF -DTESSESFRAMEWORK_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/i386.cmake
cd build-i386
make -j`nproc`
make install DESTDIR=../tessesframework_$DEB_VERSION\_i386
mkdir -p ../tessesframework_$DEB_VERSION\_i386/DEBIAN
bash ../../../make-control.sh ../tessesframework_$DEB_VERSION\_i386/DEBIAN/control i386
cd ../
dpkg-deb --build tessesframework_$DEB_VERSION\_i386

8
Packaging/Linux/make-control.sh
View File

@@ -1,8 +0,0 @@
echo "Package: tessesframework" > "$1"
echo "Version: $DEB_VERSION" >> "$1"
echo "Architecture: $2" >> "$1"
echo "Essential: no" >> "$1"
echo "Priority: optional" >> "$1"
echo "Depends: libmbedtls-dev" >> "$1"
echo "Maintainer: Mike Nolan" >> "$1"
echo "Description: A cross platform wrapper library" >> "$1"

22
Packaging/Linux/push-ubuntu-jammy.sh
View File

@@ -1,22 +0,0 @@
#!/bin/bash
source ./version.sh
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/tessesframework/$DEB_VERSION/amd64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/tessesframework/$DEB_VERSION/arm64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/tessesframework/$DEB_VERSION/riscv64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/tessesframework/$DEB_VERSION/armhf
curl --user tesses50:$GITEA_AUTH \
--upload-file build/jammy/tessesframework_$DEB_VERSION\_amd64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/jammy/tessesframework_$DEB_VERSION\_arm64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/jammy/tessesframework_$DEB_VERSION\_riscv64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/jammy/tessesframework_$DEB_VERSION\_armhf.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/upload

27
Packaging/Linux/push-ubuntu-plucky.sh
View File

@@ -1,27 +0,0 @@
#!/bin/bash
source ./version.sh
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/tessesframework/$DEB_VERSION/amd64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/tessesframework/$DEB_VERSION/arm64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/tessesframework/$DEB_VERSION/i386
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/tessesframework/$DEB_VERSION/riscv64
curl --user tesses50:$GITEA_AUTH -X DELETE \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/tessesframework/$DEB_VERSION/armhf
curl --user tesses50:$GITEA_AUTH \
--upload-file build/plucky/tessesframework_$DEB_VERSION\_amd64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/plucky/tessesframework_$DEB_VERSION\_arm64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/plucky/tessesframework_$DEB_VERSION\_i386.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/plucky/tessesframework_$DEB_VERSION\_riscv64.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload
curl --user tesses50:$GITEA_AUTH \
--upload-file build/plucky/tessesframework_$DEB_VERSION\_armhf.deb \
https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload

1
Packaging/Linux/version.sh
View File

@@ -1 +0,0 @@
export DEB_VERSION=0.0.2

7
apps/tanonydrop.cpp
View File

@@ -21,9 +21,9 @@ int main(int argc, char** argv)
.SendText(
"<!DOCTYPE html>"
"<html>"
"<head><meta charset=\"UTF-8\"><title>AnonyDump</title></head>"
"<head><meta charset=\"UTF-8\"><title>AnonyDrop</title><meta name=\"color-scheme\" content=\"dark light\"></head>"
"<body>"
"<h1>AnonyDump</h1>"
"<h1>AnonyDrop</h1>"
"<a href=\"./files/\">Files</a>"
"<form action=\"./upload\" method=\"post\" enctype=\"multipart/form-data\" accept-charset=\"UTF-8\">"
"<input type=\"file\" name=\"file\" multiple>"
@@ -50,12 +50,11 @@ int main(int argc, char** argv)
.SendText(
"<!DOCTYPE html>"
"<html>"
"<head><title>AnonyDump - Uploaded successfully</title>"
"<head><title>AnonyDrop - Uploaded successfully</title>"
"<body>"
"<h1>Uploaded successfully</h1>"
"<a href=\"./\">Back</a>"
"</form>"
"</body>"
"</html>"
);

60
cmake/sources.cmake Normal file
View File

@@ -0,0 +1,60 @@
list(APPEND TESSESFRAMEWORK_SOURCE
src/Random.cpp
src/Date/Date.cpp
src/Http/FileServer.cpp
src/Http/MountableServer.cpp
src/Http/RouteServer.cpp
src/Http/CallbackServer.cpp
src/Http/HttpServer.cpp
src/Http/HttpUtils.cpp
src/Http/HttpClient.cpp
src/Http/HttpStream.cpp
src/Http/ContentDisposition.cpp
src/Http/WebSocket.cpp
src/Http/ChangeableServer.cpp
src/Http/BasicAuthServer.cpp
src/Http/CGIServer.cpp
src/Mail/Smtp.cpp
src/Serialization/Json.cpp
src/Serialization/SQLite.cpp
src/Serialization/BitConverter.cpp
src/Serialization/Bencode.cpp
src/Platform/Environment.cpp
src/Platform/Process.cpp
src/Streams/FileStream.cpp
src/Streams/MemoryStream.cpp
src/Streams/NetworkStream.cpp
src/Streams/Stream.cpp
src/Streams/BufferedStream.cpp
src/Streams/ByteReader.cpp
src/Streams/ByteWriter.cpp
src/Streams/PtyStream.cpp
src/Text/StringConverter.cpp
src/Text/HeaderGenerator.cpp
src/TextStreams/StreamReader.cpp
src/TextStreams/StreamWriter.cpp
src/TextStreams/TextReader.cpp
src/TextStreams/TextWriter.cpp
src/TextStreams/StdIOReader.cpp
src/TextStreams/StdIOWriter.cpp
src/TextStreams/StringReader.cpp
src/TextStreams/StringWriter.cpp
src/Threading/Thread.cpp
src/Threading/Mutex.cpp
src/Threading/ThreadPool.cpp
src/Filesystem/VFS.cpp
src/Filesystem/LocalFS.cpp
src/Filesystem/SubdirFilesystem.cpp
src/Filesystem/NullFilesystem.cpp
src/Filesystem/MountableFilesystem.cpp
src/Filesystem/FSHelpers.cpp
src/Filesystem/TempFS.cpp
src/Crypto/MbedTLS/ClientTLSStream.cpp
src/Crypto/MbedTLS/Crypto.cpp
src/Args.cpp
src/TF_Init.cpp
src/HiddenField.cpp
src/Uuid.cpp
src/BitTorrent/TorrentFile.cpp
src/BitTorrent/TorrentStream.cpp
)

2
docker-compose/portable-json-creator/docker-compose.yml
View File

@@ -1,5 +1,5 @@
services:
portable-json:
image: onedev.site.tesses.net/tesses-framework/portable-json-creator:latest
image: git.tesses.org/tesses50/portable-json-creator:latest
ports:
- "4999:4999"

22
examples/runevent.cpp
View File

@@ -1,22 +0,0 @@
#include "TessesFramework/TessesFramework.hpp"
using namespace Tesses::Framework;
int main(int argc, char** argv)
{
TF_Init();
auto event = std::make_shared<FunctionalEvent<uint64_t>>([](uint64_t n)->void {
std::cout << n << std::endl;
});
OnItteraton += event;
auto event2 = std::make_shared<FunctionalEvent<uint64_t>>([&event](uint64_t n)->void{
if(n == 10000) OnItteraton -= event;
});
OnItteraton += event2;
TF_RunEventLoop();
return 0;
}

17
examples/timer.cpp Normal file
View File

@@ -0,0 +1,17 @@
#include "TessesFramework/Common.hpp"
#include "TessesFramework/TessesFramework.hpp"
int main(int argc, char** argv)
{
using namespace Tesses::Framework;
TF_Init();
auto timer = TF_Timer([]()->void {
std::cout << "Hi, I am a timer" << std::endl;
});
TF_RunEventLoop();
TF_Quit();
}

23
examples/webserverex.cpp
View File

@@ -1,5 +1,8 @@
#include "TessesFramework/TessesFramework.hpp"
#include <TessesFramework/Platform/Environment.hpp>
#include <exception>
#include <iostream>
#include <stdexcept>
using namespace Tesses::Framework;
using namespace Tesses::Framework::Http;
using namespace Tesses::Framework::Streams;
@@ -119,6 +122,26 @@ class MyOtherWebServer : public IHttpServer
return true;
}
}
else if(ctx.path == "/status")
{
int64_t num;
if(ctx.queryParams.TryGetFirstInt("code", num))
{
ctx.statusCode = (StatusCode)num;
}
ctx.SendErrorPage(true);
return true;
}
else if(ctx.path == "/error")
{
throw std::runtime_error("This is a error");
}
else if(ctx.path == "/error-debug")
{
ctx.WithDebug(true);
throw std::runtime_error("Platform is " + Tesses::Framework::Platform::Environment::GetPlatform());
}
else if(ctx.path == "/mymount/steve")
{
Johnny* data = ctx.GetServerContentData<Johnny>("mytag");

125
include/TessesFramework/Common.hpp
View File

@@ -1,8 +1,11 @@
#pragma once
#include <chrono>
#include <cstring>
#include <cstdint>
#include <cstddef>
#include <memory>
#include <ratio>
#include <string>
#include <filesystem>
#include <map>
@@ -15,83 +18,55 @@
namespace Tesses::Framework
{
template<typename...TArgs>
class Event {
public:
virtual void Invoke(TArgs... args)=0;
virtual ~Event()
{}
};
template<typename...TArgs>
class FunctionalEvent : public Event<TArgs...> {
std::function<void(TArgs...)> cb;
public:
FunctionalEvent(std::function<void(TArgs...)> cb)
{
this->cb = cb;
}
void Invoke(TArgs... args)
{
this->cb(args...);
}
};
template<typename...TArgs>
class EventList : public Event<TArgs...> {
Threading::Mutex mtx;
std::vector<std::shared_ptr<Event<TArgs...>>> items;
public:
void operator+=(std::shared_ptr<Event<TArgs...>> event)
{
mtx.Lock();
for(std::shared_ptr<Event<TArgs...>>& item : this->items)
{
if(item.get() == event.get()) {
mtx.Unlock();
return;
}
}
this->items.push_back(event);
mtx.Unlock();
}
void operator-=(std::shared_ptr<Event<TArgs...>> event)
{
mtx.Lock();
for(auto i = this->items.begin(); i != this->items.end(); i++)
{
if(i->get() == event.get())
{
this->items.erase(i);
mtx.Unlock();
return;
}
}
mtx.Unlock();
}
void Invoke(TArgs... args)
{
mtx.Lock();
for(auto& item : this->items)
{
item->Invoke(args...);
}
mtx.Unlock();
}
void Remove(std::function<bool(std::shared_ptr<Event<TArgs...>>)> cb)
{
for(auto index = this->items.begin(); index != this->items.end(); index++)
{
if(cb(*index))
{
this->items.erase(index);
index--;
}
}
}
};
extern EventList<uint64_t> OnItteraton;
std::optional<std::string> TF_GetCommandName();
class TF_Timer_Handle;
//Used for internal purposes, don't use unless you want to run timer events on another thread
class TF_Timer_Handler {
private:
std::vector<std::weak_ptr<TF_Timer_Handle>> handles;
public:
void Update();
static std::shared_ptr<TF_Timer_Handle> Make(std::shared_ptr<TF_Timer_Handler> handler);
friend class TF_Timer_Handle;
};
class TF_Timer_Handle {
private:
std::shared_ptr<TF_Timer_Handler> timerHandler;
std::function<void()> cb;
std::chrono::milliseconds interval;
std::chrono::time_point<std::chrono::steady_clock, std::chrono::milliseconds> last;
bool enabled;
TF_Timer_Handle() = delete;
TF_Timer_Handle(std::shared_ptr<TF_Timer_Handler> timerHandler);
public:
void SetCallback(std::function<void()> cb);
int64_t GetIntervalMilliseconds();
std::chrono::duration<int64_t,std::milli> GetIntervalDuration();
void SetIntervalFromMilliseconds(int64_t ms);
void SetIntervalFromDuration(std::chrono::milliseconds dur);
void SetEnabled(bool enabled);
bool GetEnabled();
friend class TF_Timer_Handler;
};
std::shared_ptr<TF_Timer_Handle> TF_Timer();
std::shared_ptr<TF_Timer_Handle> TF_Timer(std::function<void()> cb, int64_t interval=1000, bool enabled=true);
std::shared_ptr<TF_Timer_Handle> TF_Timer(std::function<void()> cb, std::chrono::milliseconds interval, bool enabled=true);
void TF_Init();
void TF_InitWithConsole();

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

@@ -12,13 +12,7 @@ namespace Tesses::Framework::Filesystem
void CreateDirectory(VFSPath path);
void DeleteDirectory(VFSPath path);
bool RegularFileExists(VFSPath path);
bool SymlinkExists(VFSPath path);
bool CharacterDeviceExists(VFSPath path);
bool BlockDeviceExists(VFSPath path);
bool SocketFileExists(VFSPath path);
bool FIFOFileExists(VFSPath path);
bool DirectoryExists(VFSPath path);
void DeleteFile(VFSPath path);
void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
@@ -32,16 +26,18 @@ namespace Tesses::Framework::Filesystem
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
bool Stat(VFSPath path, StatData& stat);
bool StatVFS(VFSPath path, StatVFSData& vfsData);
void Chmod(VFSPath path, uint32_t mode);
void Chown(VFSPath path, uint32_t uid, uint32_t gid);
void Lock(VFSPath path);
void Unlock(VFSPath path);
FIFOCreationResult CreateFIFO(VFSPath path, uint32_t mod);
protected:
std::shared_ptr<FSWatcher> CreateWatcher(std::shared_ptr<VFS> vfs, VFSPath path);

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

@@ -1,100 +0,0 @@
#pragma once
#include "VFS.hpp"
#include "VFSFix.hpp"
#include "../Threading/Mutex.hpp"
#include <atomic>
namespace Tesses::Framework::Filesystem
{
class MemoryEntry {
public:
std::string name;
virtual ~MemoryEntry();
};
class MemoryFileData {
public:
MemoryFileData();
Date::DateTime lastWrite;
bool canAccess;
size_t readers;
std::vector<uint8_t> file;
};
class MemoryFile : public MemoryEntry
{
public:
std::shared_ptr<MemoryFileData> data;
~MemoryFile();
};
class MemoryDirectory : public MemoryEntry
{
public:
MemoryDirectory();
Date::DateTime lastWrite;
std::vector<MemoryEntry*> entries;
~MemoryDirectory();
};
class MemorySymlink : public MemoryEntry
{
public:
Date::DateTime lastWrite;
VFSPath linkedTo;
};
class MemoryFilesystemStream : public Streams::Stream
{
public:
std::shared_ptr<Tesses::Framework::Threading::Mutex> mtx;
std::shared_ptr<MemoryFileData> data;
bool canRead;
bool canWrite;
bool canSeek;
int64_t pos;
MemoryFilesystemStream(std::shared_ptr<Tesses::Framework::Threading::Mutex> mtx, std::shared_ptr<MemoryFileData> data,bool canRead, bool canWrite, bool canSeek);
size_t Read(uint8_t* buff, size_t sz);
size_t Write(const uint8_t* buff, size_t sz);
bool CanRead();
bool CanWrite();
bool CanSeek();
int64_t GetPosition();
void Flush();
void Seek(int64_t pos, Streams::SeekOrigin whence);
~MemoryFilesystemStream();
};
class MemoryFilesystem : public VFS
{
std::shared_ptr<Tesses::Framework::Threading::Mutex> mtx;
MemoryDirectory root;
MemoryEntry* GetEntry(VFSPath path,bool followSymlink);
public:
MemoryFilesystem();
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);
bool SymlinkExists(VFSPath path);
bool DirectoryExists(VFSPath path);
void DeleteFile(VFSPath path);
void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
VFSPathEnumerator EnumeratePaths(VFSPath path);
void CreateHardlink(VFSPath existingFile, VFSPath newName);
void MoveFile(VFSPath src, VFSPath dest);
void MoveDirectory(VFSPath src, VFSPath dest);
VFSPath ReadLink(VFSPath path);
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
~MemoryFilesystem();
};
};

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

@@ -31,15 +31,7 @@ namespace Tesses::Framework::Filesystem
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);
bool FileExists(VFSPath path);
bool RegularFileExists(VFSPath path);
bool SymlinkExists(VFSPath path);
bool CharacterDeviceExists(VFSPath path);
bool BlockDeviceExists(VFSPath path);
bool SocketFileExists(VFSPath path);
bool FIFOFileExists(VFSPath path);
bool DirectoryExists(VFSPath path);
bool Stat(VFSPath path, StatData& data);
void DeleteFile(VFSPath path);
void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
VFSPathEnumerator EnumeratePaths(VFSPath path);
@@ -50,14 +42,18 @@ namespace Tesses::Framework::Filesystem
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
~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);
void Chown(VFSPath path, uint32_t uid, uint32_t gid);
FIFOCreationResult CreateFIFO(VFSPath path, uint32_t mode);
void Lock(VFSPath path);
void Unlock(VFSPath path);
};
}

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

@@ -8,13 +8,8 @@ namespace Tesses::Framework::Filesystem
{
public:
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);
bool DirectoryExists(VFSPath path);
void DeleteFile(VFSPath path);
VFSPathEnumerator EnumeratePaths(VFSPath path);
void MoveFile(VFSPath src, VFSPath dest);
bool Stat(VFSPath path, StatData& data);
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
};

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

@@ -15,15 +15,6 @@ namespace Tesses::Framework::Filesystem
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);
bool FileExists(VFSPath path);
bool RegularFileExists(VFSPath path);
bool SymlinkExists(VFSPath path);
bool CharacterDeviceExists(VFSPath path);
bool BlockDeviceExists(VFSPath path);
bool SocketFileExists(VFSPath path);
bool FIFOFileExists(VFSPath path);
bool DirectoryExists(VFSPath path);
void DeleteFile(VFSPath path);
void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
VFSPathEnumerator EnumeratePaths(VFSPath path);
@@ -35,12 +26,13 @@ namespace Tesses::Framework::Filesystem
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
~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);
bool Stat(VFSPath path, StatData& data);
void Chown(VFSPath path, uint32_t uid, uint32_t gid);
void Chmod(VFSPath path, uint32_t mode);
FIFOCreationResult CreateFIFO(VFSPath path, uint32_t mode);
void Lock(VFSPath path);
void Unlock(VFSPath path);
};

14
include/TessesFramework/Filesystem/TempFS.hpp
View File

@@ -20,15 +20,6 @@ namespace Tesses::Framework::Filesystem
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);
bool FileExists(VFSPath path);
bool RegularFileExists(VFSPath path);
bool SymlinkExists(VFSPath path);
bool CharacterDeviceExists(VFSPath path);
bool BlockDeviceExists(VFSPath path);
bool SocketFileExists(VFSPath path);
bool FIFOFileExists(VFSPath path);
bool DirectoryExists(VFSPath path);
void DeleteFile(VFSPath path);
void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
VFSPathEnumerator EnumeratePaths(VFSPath path);
@@ -40,11 +31,14 @@ namespace Tesses::Framework::Filesystem
std::string VFSPathToSystem(VFSPath path);
VFSPath SystemToVFSPath(std::string path);
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);
bool Stat(VFSPath path, StatData& data);
void Chmod(VFSPath path, uint32_t mode);
void Chown(VFSPath path, uint32_t uid, uint32_t gid);
FIFOCreationResult CreateFIFO(VFSPath path, uint32_t mode);
void Close();
void Lock(VFSPath path);

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

@@ -1,6 +1,8 @@
#pragma once
#include "../Common.hpp"
#include "../Streams/Stream.hpp"
#include <TessesFramework/Common.hpp>
#include <TessesFramework/Date/Date.hpp>
#include <functional>
#include <memory>
#include "../Date/Date.hpp"
@@ -9,8 +11,8 @@
namespace Tesses::Framework::Filesystem
{
class StatVFSData {
public:
struct StatVFSData {
uint64_t BlockSize;
uint64_t FragmentSize;
uint64_t Blocks;
@@ -23,6 +25,88 @@ namespace Tesses::Framework::Filesystem
uint64_t Flags;
uint64_t MaxNameLength;
};
constexpr uint32_t MODE_USER_READ = 0400;
constexpr uint32_t MODE_USER_WRITE = 0200;
constexpr uint32_t MODE_USER_EXEC = 0100;
constexpr uint32_t MODE_GROUP_READ = (MODE_USER_READ >> 3);
constexpr uint32_t MODE_GROUP_WRITE = (MODE_USER_WRITE >> 3);
constexpr uint32_t MODE_GROUP_EXEC = (MODE_USER_EXEC >> 3);
constexpr uint32_t MODE_OTHER_READ = (MODE_GROUP_READ >> 3);
constexpr uint32_t MODE_OTHER_WRITE = (MODE_GROUP_WRITE >> 3);
constexpr uint32_t MODE_OTHER_EXEC = (MODE_GROUP_EXEC >> 3);
constexpr uint32_t MODE_REGULAR = 0100000;
constexpr uint32_t MODE_DIRECTORY = 0040000;
constexpr uint32_t MODE_CHAR_DEVICE = 0020000;
constexpr uint32_t MODE_BLOCK_DEVICE = 0060000;
constexpr uint32_t MODE_SOCKET = 0140000;
constexpr uint32_t MODE_FIFO = 0010000;
constexpr uint32_t MODE_SYMLINK = 0120000;
struct StatData {
uint64_t Device;
uint64_t Inode;
uint32_t Mode;
uint64_t HardLinks;
uint32_t UserId;
uint32_t GroupId;
uint64_t DeviceId;
uint64_t Size;
uint64_t BlockSize;
uint64_t BlockCount;
Date::DateTime LastAccess;
Date::DateTime LastModified;
Date::DateTime LastStatus;
bool IsRegularFile()
{
return (Mode & MODE_REGULAR) > 0;
}
bool IsDirectory()
{
return (Mode & MODE_DIRECTORY) > 0;
}
bool IsCharDevice()
{
return (Mode & MODE_CHAR_DEVICE) > 0;
}
bool IsBlockDevice()
{
return (Mode & MODE_BLOCK_DEVICE) > 0;
}
bool IsSocket()
{
return (Mode & MODE_SOCKET) > 0;
}
bool IsFIFO()
{
return (Mode & MODE_FIFO) > 0;
}
bool IsSymlink()
{
return (Mode & MODE_SYMLINK) > 0;
}
bool IsSpecial()
{
if(IsRegularFile()) return false;
if(IsDirectory()) return false;
return true;
}
std::string ToSizeString(bool usesBin=true)
{
return TF_FileSize(this->Size, usesBin);
}
};
class VFSPath {
public:
static VFSPath CurrentDirectoryAsRelative();
@@ -189,43 +273,55 @@ namespace Tesses::Framework::Filesystem
static std::shared_ptr<FSWatcher> Create(std::shared_ptr<VFS> vfs, VFSPath path);
};
enum class FIFOCreationResult {
Success=0,
Exists = 1,
ReadOnlyFS = 2,
Denied = 3,
OutOfInodes = 4,
UnknownError = 5,
Unsupported = 255
};
class VFS {
public:
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;
virtual bool SymlinkExists(VFSPath path);
virtual bool CharacterDeviceExists(VFSPath path);
virtual bool BlockDeviceExists(VFSPath path);
virtual bool SocketFileExists(VFSPath path);
virtual bool FIFOFileExists(VFSPath path);
virtual bool FileExists(VFSPath path);
virtual bool SpecialFileExists(VFSPath path);
virtual void CreateDirectory(VFSPath path);
virtual void DeleteDirectory(VFSPath path);
bool DirectoryExists(VFSPath path);
bool RegularFileExists(VFSPath path);
bool SymlinkExists(VFSPath path);
bool CharacterDeviceExists(VFSPath path);
bool BlockDeviceExists(VFSPath path);
bool SocketFileExists(VFSPath path);
bool FIFOFileExists(VFSPath path);
bool FileExists(VFSPath path);
bool SpecialFileExists(VFSPath path);
virtual void CreateSymlink(VFSPath existingFile, VFSPath symlinkFile);
virtual void CreateHardlink(VFSPath existingFile, VFSPath newName);
virtual bool DirectoryExists(VFSPath path)=0;
virtual void DeleteFile(VFSPath path)=0;
virtual void DeleteFile(VFSPath path);
virtual void DeleteDirectoryRecurse(VFSPath path);
virtual VFSPathEnumerator EnumeratePaths(VFSPath path) = 0;
virtual void MoveFile(VFSPath src, VFSPath dest)=0;
virtual void MoveFile(VFSPath src, VFSPath dest);
virtual void MoveDirectory(VFSPath src, VFSPath dest);
virtual VFSPath ReadLink(VFSPath path);
virtual std::string VFSPathToSystem(VFSPath path)=0;
virtual VFSPath SystemToVFSPath(std::string path)=0;
virtual void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
void GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess);
virtual void SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess);
virtual bool Stat(VFSPath path, StatData& data) = 0;
virtual bool StatVFS(VFSPath path, StatVFSData& data);
virtual void Chmod(VFSPath path, uint32_t mode);
virtual void Chown(VFSPath path, uint32_t userId, uint32_t groupId);
virtual void Lock(VFSPath path);
virtual void Unlock(VFSPath path);
virtual FIFOCreationResult CreateFIFO(VFSPath path, uint32_t mode);
virtual ~VFS();
@@ -237,7 +333,6 @@ namespace Tesses::Framework::Filesystem
};
namespace Literals
{
inline VFSPath operator""_tpath(const char* path)
@@ -246,4 +341,3 @@ namespace Tesses::Framework::Filesystem
}
}
}

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

@@ -6,6 +6,7 @@
#include "../Date/Date.hpp"
#include <unordered_map>
#include "WebSocket.hpp"
#include <queue>
namespace Tesses::Framework::Http
{
class ServerContextData {
@@ -17,8 +18,10 @@ namespace Tesses::Framework::Http
class ServerContext {
bool sent;
bool debug;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
std::map<std::string,ServerContextData*> data;
std::queue<std::function<bool(ServerContext& ctx)>> headerhandlers;
public:
HttpDictionary requestHeaders;
HttpDictionary responseHeaders;
@@ -34,7 +37,7 @@ namespace Tesses::Framework::Http
uint16_t serverPort;
std::string version;
bool encrypted;
ServerContext(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
ServerContext(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, bool debug=false);
~ServerContext();
std::shared_ptr<Tesses::Framework::Streams::Stream> GetStream();
std::string GetOriginalPathWithQuery();
@@ -53,6 +56,7 @@ namespace Tesses::Framework::Http
void SendException(std::exception& ex);
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenResponseStream();
std::shared_ptr<Tesses::Framework::Streams::Stream> OpenRequestStream();
ServerContext& WithStatusCode(StatusCode code);
ServerContext& WithLastModified(Date::DateTime time);
ServerContext& WithHeader(std::string key, std::string value);
ServerContext& WithSingleHeader(std::string key, std::string value);
@@ -61,6 +65,9 @@ namespace Tesses::Framework::Http
ServerContext& WriteHeaders();
ServerContext& WithLocationHeader(std::string url);
ServerContext& WithLocationHeader(std::string url,StatusCode sc);
ServerContext& WithHeaderIntercepter(std::function<bool(ServerContext&)> cb);
ServerContext& WithDebug(bool debug=true);
bool Debug();
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(std::shared_ptr<WebSocketConnection> connection);
std::string GetServerRoot();
@@ -95,14 +102,15 @@ namespace Tesses::Framework::Http
bool showIPs;
bool showARTL;
bool debug;
public:
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);
HttpServer(std::shared_ptr<Tesses::Framework::Streams::TcpServer> tcpServer, std::shared_ptr<IHttpServer> http, bool showIPs=true, bool debug=false);
HttpServer(uint16_t port, std::shared_ptr<IHttpServer> http, bool showIPs=true, bool debug=false);
HttpServer(std::string unixPath, std::shared_ptr<IHttpServer> http, bool debug=false);
uint16_t GetPort();
void StartAccepting();
static void Process(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port,uint16_t serverPort, bool encrypted);
static void Process(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port,uint16_t serverPort, bool encrypted, bool debug=false);
~HttpServer();
};
}

1
include/TessesFramework/TessesFramework.hpp
View File

@@ -31,7 +31,6 @@
#include "Filesystem/SubdirFilesystem.hpp"
#include "Filesystem/NullFilesystem.hpp"
#include "Filesystem/MountableFilesystem.hpp"
#include "Filesystem/MemoryFilesystem.hpp"
#include "Filesystem/FSHelpers.hpp"
#include "Crypto/ClientTLSStream.hpp"
#include "Crypto/Crypto.hpp"

2
pkgconfig/CMakeLists.txt
View File

@@ -2,7 +2,7 @@ set(PKGCONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
set(PKGCONFIG_LIBDIR "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
set(PKGCONFIG_PROJECT_DESCRIPTION "A cross platform wrapper library")
set(PKGCONFIG_PROJECT_HOMEPAGE_URL "https://onedev.site.tesses.net/tesses-framework")
set(PKGCONFIG_PROJECT_HOMEPAGE_URL "https://git.tesses.org/tessesframework")
if(TESSESFRAMEWORK_ENABLE_MBED)
set(PKGCONFIG_DEPS "Requires: mbedtls")

96
src/Filesystem/LocalFS.cpp
View File

@@ -1,7 +1,10 @@
#include "TessesFramework/Filesystem/LocalFS.hpp"
#include "TessesFramework/Streams/FileStream.hpp"
#include <cerrno>
#include <filesystem>
#include <iostream>
#include <sys/stat.h>
#include <sys/types.h>
#if defined(_WIN32)
#include <windows.h>
#include "TessesFramework/Filesystem/VFSFix.hpp"
@@ -27,16 +30,31 @@ namespace Tesses::Framework::Filesystem
pft->dwHighDateTime = time_value.HighPart;
}
#endif
void LocalFilesystem::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
bool LocalFilesystem::Stat(VFSPath path, StatData& sfs)
{
std::string s = VFSPathToSystem(path);
struct stat st;
if(stat(s.c_str(),&st) == 0)
{
lastAccess = Date::DateTime((int64_t)st.st_atime);
lastWrite = Date::DateTime((int64_t)st.st_mtime);
sfs.Device = (uint64_t)st.st_dev;
sfs.Inode = (uint64_t)st.st_ino;
sfs.Mode = (uint32_t)st.st_mode;
sfs.HardLinks = (uint64_t)st.st_nlink;
sfs.UserId = (uint32_t)st.st_uid;
sfs.GroupId = (uint32_t)st.st_gid;
sfs.DeviceId = (uint64_t)st.st_rdev;
sfs.Size = (uint64_t)st.st_size;
sfs.BlockSize = (uint64_t)st.st_blksize;
sfs.BlockCount = (uint64_t)st.st_blocks;
sfs.LastAccess = Date::DateTime((int64_t)st.st_atime);
sfs.LastModified = Date::DateTime((int64_t)st.st_mtime);
sfs.LastStatus = Date::DateTime((int64_t)st.st_ctime);
return true;
}
return false;
}
void LocalFilesystem::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{
std::string s = VFSPathToSystem(path);
@@ -96,34 +114,6 @@ namespace Tesses::Framework::Filesystem
{
std::filesystem::create_directories(VFSPathToSystem(path));
}
bool LocalFilesystem::DirectoryExists(VFSPath path)
{
return std::filesystem::is_directory(VFSPathToSystem(path));
}
bool LocalFilesystem::RegularFileExists(VFSPath path)
{
return std::filesystem::is_regular_file(VFSPathToSystem(path));
}
bool LocalFilesystem::SymlinkExists(VFSPath path)
{
return std::filesystem::is_symlink(VFSPathToSystem(path));
}
bool LocalFilesystem::BlockDeviceExists(VFSPath path)
{
return std::filesystem::is_block_file(VFSPathToSystem(path));
}
bool LocalFilesystem::CharacterDeviceExists(VFSPath path)
{
return std::filesystem::is_character_file(VFSPathToSystem(path));
}
bool LocalFilesystem::SocketFileExists(VFSPath path)
{
return std::filesystem::is_socket(VFSPathToSystem(path));
}
bool LocalFilesystem::FIFOFileExists(VFSPath path)
{
return std::filesystem::is_fifo(VFSPathToSystem(path));
}
void LocalFilesystem::CreateSymlink(VFSPath existingFile, VFSPath symlinkFile)
{
if(std::filesystem::is_directory(VFSPathToSystem(existingFile)))
@@ -185,7 +175,10 @@ namespace Tesses::Framework::Filesystem
VFSPathEnumerator LocalFilesystem::EnumeratePaths(VFSPath path)
{
auto dir = new std::filesystem::directory_iterator(VFSPathToSystem(path));
std::filesystem::path sysPath = VFSPathToSystem(path);
if(!std::filesystem::is_directory(sysPath)) return VFSPathEnumerator();
auto dir = new std::filesystem::directory_iterator(sysPath);
return VFSPathEnumerator([dir,path](VFSPath& path0)->bool {
std::filesystem::directory_iterator& ittr = *dir;
if(ittr != std::filesystem::directory_iterator())
@@ -236,6 +229,45 @@ namespace Tesses::Framework::Filesystem
chmod(pathStr.c_str(), (mode_t)mode);
#endif
}
void LocalFilesystem::Chown(VFSPath path, uint32_t uid, uint32_t gid)
{
auto pathStr = this->VFSPathToSystem(path);
#if defined(_WIN32)
#else
chown(pathStr.c_str(), (uid_t)uid, (gid_t)gid);
#endif
}
FIFOCreationResult LocalFilesystem::CreateFIFO(VFSPath path, uint32_t mod)
{
auto pathStr = this->VFSPathToSystem(path);
#if defined(_WIN32)
return FIFOCreationResult::Unsupported;
#else
int res = mkfifo(pathStr.c_str(), (mode_t)mod);
if(res == 0) return FIFOCreationResult::Success;
else if(res == -1)
{
switch(res)
{
case EEXIST:
return FIFOCreationResult::Exists;
case ENOTSUP:
return FIFOCreationResult::Unsupported;
case EACCES:
return FIFOCreationResult::Denied;
case ENOSPC:
return FIFOCreationResult::OutOfInodes;
case EROFS:
return FIFOCreationResult::ReadOnlyFS;
}
}
return FIFOCreationResult::UnknownError;
#endif
}
void LocalFilesystem::Lock(VFSPath path)

669
src/Filesystem/MemoryFilesystem.cpp
View File

@@ -1,669 +0,0 @@
#include "TessesFramework/Filesystem/MemoryFilesystem.hpp"
#include <iostream>
namespace Tesses::Framework::Filesystem
{
MemoryFilesystemStream::MemoryFilesystemStream(std::shared_ptr<Tesses::Framework::Threading::Mutex> mtx, std::shared_ptr<MemoryFileData> data,bool canRead, bool canWrite, bool canSeek)
{
this->mtx = mtx;
this->data = data;
this->canRead = canRead;
this->canWrite = canWrite;
this->canSeek = canSeek;
this->pos=0;
}
size_t MemoryFilesystemStream::Read(uint8_t* buff, size_t sz)
{
if(!this->canRead) return 0;
if(this->pos >= this->data->file.size()) return 0;
size_t toRead = std::min(sz, (size_t)(this->data->file.size()-this->pos));
memcpy(buff, this->data->file.data() + this->pos, toRead);
this->pos += toRead;
return toRead;
}
size_t MemoryFilesystemStream::Write(const uint8_t* buff, size_t sz)
{
if(!this->canWrite) return 0;
if(this->canSeek)
{
if(this->pos > this->data->file.size())
{
this->data->file.resize(this->pos+sz);
}
this->data->file.insert(this->data->file.begin()+this->pos, buff, buff+sz);
this->pos+=sz;
}
else
{
this->data->file.insert(this->data->file.end(), buff, buff+sz);
}
return sz;
}
bool MemoryFilesystemStream::CanRead()
{
return canRead;
}
bool MemoryFilesystemStream::CanWrite()
{
return canWrite;
}
bool MemoryFilesystemStream::CanSeek()
{
return canSeek;
}
int64_t MemoryFilesystemStream::GetPosition()
{
if(!this->canSeek) return (int64_t)this->data->file.size();
return pos;
}
void MemoryFilesystemStream::Flush()
{
//its already flushed
}
void MemoryFilesystemStream::Seek(int64_t pos, Streams::SeekOrigin whence)
{
if(canSeek) return;
switch(whence)
{
case Streams::SeekOrigin::Begin:
this->pos = (size_t)pos;
break;
case Streams::SeekOrigin::Current:
this->pos += (size_t)pos;
break;
case Streams::SeekOrigin::End:
this->pos = (size_t)(this->data->file.size() + pos);
break;
}
}
MemoryFilesystemStream::~MemoryFilesystemStream()
{
mtx->Lock();
if(this->canWrite) this->data->canAccess=true;
this->data->readers--;
mtx->Unlock();
}
MemoryEntry* MemoryFilesystem::GetEntry(VFSPath path,bool followSymlink)
{
if(path.relative) return nullptr;
if(path.path.empty()) return &this->root;
auto entry = GetEntry(path.GetParent(),true);
if(entry == nullptr) return nullptr;
auto dir = dynamic_cast<MemoryDirectory*>(entry);
if(dir != nullptr)
{
for(auto item : dir->entries)
{
if(item->name == path.GetFileName())
{
auto link = dynamic_cast<MemorySymlink*>(item);
if(followSymlink && link != nullptr)
{
item = GetEntry(link->linkedTo,true);
}
return item;
}
}
}
return nullptr;
}
std::shared_ptr<Streams::Stream> MemoryFilesystem::OpenFile(VFSPath path, std::string mode)
{
bool canRead=false;
bool canWrite=false;
bool canSeek=true;
bool mustExist=false;
bool truncate=false;
if(mode.size() >= 1)
{
if(mode[0] == 'r')
{
canRead = true;
mustExist=true;
}
else if(mode[0] == 'w')
{
canWrite = true;
truncate=true;
}
else if(mode[0] == 'a')
{
canSeek = false;
canWrite = true;
}
}
if(((mode.size() >= 2 && mode[1] == '+') || (mode.size() >= 2 && mode[1] == 'b' && mode[2] == '+')))
{
canRead = true;
canWrite = true;
}
mtx->Lock();
if(mustExist)
{
auto file = GetEntry(path,true);
if(file == nullptr)
{
mtx->Unlock();
return nullptr;
}
auto f = dynamic_cast<MemoryFile*>(file);
if(f == nullptr)
{
mtx->Unlock();
return nullptr;
}
if(!f->data->canAccess)
{
mtx->Unlock();
return nullptr;
}
if(canWrite && f->data->readers > 0)
{
mtx->Unlock();
return nullptr;
}
f->data->readers++;
if(canWrite) f->data->canAccess=false;
mtx->Unlock();
return std::make_shared<MemoryFilesystemStream>(mtx,f->data,canRead,canWrite,canSeek);
}
else
{
auto file = dynamic_cast<MemoryFile*>(GetEntry(path,true));
if(file != nullptr)
{
if(!file->data->canAccess)
{
mtx->Unlock();
return nullptr;
}
if(file->data->readers > 0)
{
mtx->Unlock();
return nullptr;
}
file->data->canAccess=false;
file->data->readers++;
if(truncate) {file->data->file.clear(); file->data->lastWrite=Date::DateTime::NowUTC();}
mtx->Unlock();
return std::make_shared<MemoryFilesystemStream>(mtx,file->data,canRead,canWrite,canSeek);
}
auto dir = GetEntry(path.GetParent(),true);
if(dir == nullptr)
{
mtx->Unlock();
return nullptr;
}
auto myDir = dynamic_cast<MemoryDirectory*>(dir);
if(myDir == nullptr)
{
mtx->Unlock();
return nullptr;
}
MemoryFile* thefile=nullptr;
for(auto f : myDir->entries)
{
if(f->name == path.GetFileName())
{
auto symlink = dynamic_cast<MemorySymlink*>(f);
while(symlink != nullptr)
{
auto ent = GetEntry(symlink->name,false);
auto sym = dynamic_cast<MemorySymlink*>(f);
if(sym != nullptr)
symlink = sym;
else
{
auto myDir0 = dynamic_cast<MemoryDirectory*>(GetEntry(symlink->linkedTo.GetParent(),true));
if(myDir0 != nullptr)
{
for(auto f2 : myDir0->entries)
{
if(f2->name == symlink->linkedTo.GetFileName())
{
auto myFile = dynamic_cast<MemoryFile*>(f2);
if(myFile != nullptr)
{
thefile = myFile;
break;
}
else
{
mtx->Unlock();
return nullptr;
}
}
}
myDir = myDir0;
}
else
{
mtx->Unlock();
return nullptr;
}
break;
}
}
break;
}
}
if(thefile == nullptr)
{
MemoryFile* f = new MemoryFile();
f->name = path.GetFileName();
f->data = std::make_shared<MemoryFileData>();
f->data->canAccess=false;
f->data->readers++;
myDir->entries.push_back(f);
mtx->Unlock();
return std::make_shared<MemoryFilesystemStream>(mtx,f->data,canRead,canWrite,canSeek);
}
if(thefile != nullptr)
{
if(!thefile->data->canAccess)
{
mtx->Unlock();
return nullptr;
}
if(thefile->data->readers > 0)
{
mtx->Unlock();
return nullptr;
}
thefile->data->canAccess=false;
thefile->data->readers++;
if(truncate) {thefile->data->file.clear(); thefile->data->lastWrite=Date::DateTime::NowUTC();}
mtx->Unlock();
return std::make_shared<MemoryFilesystemStream>(mtx,thefile->data,canRead,canWrite,canSeek);
}
}
mtx->Unlock();
return nullptr;
}
void MemoryFilesystem::CreateDirectory(VFSPath path)
{
if(path.relative) return;
if(path.path.empty()) return;
mtx->Lock();
MemoryDirectory* dir=&root;
for(auto part : path.path)
{
bool have=false;
for(auto dirent : dir->entries)
{
if(dirent->name == part)
{
auto symlink = dynamic_cast<MemorySymlink*>(dirent);
if(symlink != nullptr)
{
dirent = GetEntry(symlink->linkedTo,true);
}
auto dirdirent = dynamic_cast<MemoryDirectory*>(dirent);
if(dirdirent != nullptr)
{
dir = dirdirent;
have=true;
break;
}
else
{
mtx->Unlock();
return;
}
}
}
if(!have)
{
MemoryDirectory* dir2 = new MemoryDirectory();
dir2->name = part;
dir2->lastWrite=Date::DateTime::NowUTC();
dir->entries.push_back(dir2);
dir->lastWrite=Date::DateTime::NowUTC();
dir=dir2;
}
}
mtx->Unlock();
}
void MemoryFilesystem::DeleteFile(VFSPath path)
{
if(path.relative || path.path.empty()) return;
mtx->Lock();
MemoryDirectory* dir=&root;
if(path.path.size() > 1)
{
dir = dynamic_cast<MemoryDirectory*>(GetEntry(path.GetParent(),true));
}
if(dir == nullptr)
{
mtx->Unlock();
return;
}
std::string fname = path.GetFileName();
for(auto index = dir->entries.begin(); index < dir->entries.end(); index++)
{
auto item = *index;
if(item->name == fname)
{
auto p = dynamic_cast<MemoryDirectory*>(item);
if(p == nullptr)
{
delete item;
dir->entries.erase(index);
dir->lastWrite=Date::DateTime::NowUTC();
}
break;
}
}
mtx->Unlock();
}
bool MemoryFilesystem::RegularFileExists(VFSPath path)
{
if(path.relative) return false;
if(path.path.empty()) return false;
mtx->Lock();
auto f = GetEntry(path,false);
mtx->Unlock();
return dynamic_cast<MemoryFile*>(f) != nullptr;
}
bool MemoryFilesystem::SymlinkExists(VFSPath path)
{
if(path.relative) return false;
if(path.path.empty()) return false;
mtx->Lock();
auto f = GetEntry(path,false);
mtx->Unlock();
return dynamic_cast<MemorySymlink*>(f) != nullptr;
}
bool MemoryFilesystem::DirectoryExists(VFSPath path)
{
if(path.relative) return false;
if(path.path.empty()) return true;
mtx->Lock();
auto f = GetEntry(path,false);
mtx->Unlock();
return dynamic_cast<MemoryDirectory*>(f) != nullptr;
}
void MemoryFilesystem::DeleteDirectory(VFSPath path)
{
if(path.relative || path.path.empty()) return;
mtx->Lock();
MemoryDirectory* dir=&root;
if(path.path.size() > 1)
{
dir = dynamic_cast<MemoryDirectory*>(GetEntry(path.GetParent(),true));
}
if(dir == nullptr)
{
mtx->Unlock();
return;
}
std::string fname = path.GetFileName();
for(auto index = dir->entries.begin(); index < dir->entries.end(); index++)
{
auto item = *index;
if(item->name == fname)
{
auto p = dynamic_cast<MemoryDirectory*>(item);
if(p != nullptr)
{
delete item;
dir->entries.erase(index);
dir->lastWrite=Date::DateTime::NowUTC();
}
break;
}
}
mtx->Unlock();
}
void MemoryFilesystem::CreateSymlink(VFSPath existingFile, VFSPath symlinkFile)
{
if(existingFile.relative || symlinkFile.relative || symlinkFile.path.empty()) return;
mtx->Lock();
MemoryDirectory* dir=&root;
if(symlinkFile.path.size() > 1)
{
dir = dynamic_cast<MemoryDirectory*>(GetEntry(symlinkFile.GetParent(),true));
}
if(dir == nullptr)
{
mtx->Unlock();
return;
}
std::string fname = symlinkFile.GetFileName();
for(auto index = dir->entries.begin(); index < dir->entries.end(); index++)
{
auto item = *index;
if(item->name == fname)
{
auto p = dynamic_cast<MemorySymlink*>(item);
if(p != nullptr)
{
p->linkedTo = existingFile;
p->lastWrite = Date::DateTime::NowUTC();
}
mtx->Unlock();
return;
}
}
MemorySymlink* symlink = new MemorySymlink();
symlink->name = fname;
symlink->linkedTo = existingFile;
symlink->lastWrite = Date::DateTime::NowUTC();
dir->entries.push_back(symlink);
dir->lastWrite = Date::DateTime::NowUTC();
mtx->Unlock();
}
VFSPathEnumerator MemoryFilesystem::EnumeratePaths(VFSPath path)
{
std::pair<size_t,std::vector<std::string>>* paths=new std::pair<size_t,std::vector<std::string>>();
paths->first=0;
mtx->Lock();
auto dir = dynamic_cast<MemoryDirectory*>(GetEntry(path,true));
if(dir != nullptr)
{
for(auto item : dir->entries) paths->second.push_back(item->name);
}
mtx->Unlock();
return VFSPathEnumerator([paths,path](VFSPath& _path)->bool{
if(paths->first < paths->second.size())
{
_path = path / paths->second[paths->first++];
return true;
}
return false;
},[paths]()->void{
delete paths;
});
}
void MemoryFilesystem::CreateHardlink(VFSPath existingFile, VFSPath newName)
{
mtx->Lock();
auto existing = dynamic_cast<MemoryFile*>(GetEntry(existingFile,true));
if(existing == nullptr)
{
mtx->Unlock();
return;
}
MemoryDirectory* dir=&root;
if(newName.path.size() > 1)
{
dir = dynamic_cast<MemoryDirectory*>(GetEntry(newName.GetParent(),true));
}
if(dir == nullptr)
{
mtx->Unlock();
return;
}
std::string fname = newName.GetFileName();
for(auto index = dir->entries.begin(); index < dir->entries.end(); index++)
{
auto item = *index;
if(item->name == fname)
{
mtx->Unlock();
return;
}
}
MemoryFile* memFile = new MemoryFile();
memFile->name = fname;
memFile->data = existing->data;
dir->entries.push_back(memFile);
dir->lastWrite=Date::DateTime::NowUTC();
mtx->Unlock();
}
void MemoryFilesystem::MoveFile(VFSPath src, VFSPath dest)
{
DeleteFile(dest);
CreateHardlink(src,dest);
DeleteFile(src);
}
void MemoryFilesystem::MoveDirectory(VFSPath src, VFSPath dest)
{
CreateDirectory(dest);
for(auto ent : EnumeratePaths(src))
{
VFSPath destPath = dest / ent.GetFileName();
if(FileExists(ent)) MoveFile(ent,destPath);
if(DirectoryExists(ent)) MoveDirectory(ent,destPath);
}
DeleteDirectory(src);
}
VFSPath MemoryFilesystem::ReadLink(VFSPath p)
{
mtx->Lock();
VFSPath p2;
auto symlink = dynamic_cast<MemorySymlink*>(GetEntry(p,false));
if(symlink != nullptr)
{
p2 = symlink->linkedTo;
}
mtx->Unlock();
return p2;
}
std::string MemoryFilesystem::VFSPathToSystem(VFSPath path)
{
return path.ToString();
}
VFSPath MemoryFilesystem::SystemToVFSPath(std::string path)
{
return path;
}
void MemoryFilesystem::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
{
mtx->Lock();
auto node = GetEntry(path,false);
auto dir = dynamic_cast<MemoryDirectory*>(node);
auto file = dynamic_cast<MemoryFile*>(node);
auto sym = dynamic_cast<MemorySymlink*>(node);
if(dir != nullptr) lastWrite = dir->lastWrite;
if(file != nullptr) lastWrite = file->data->lastWrite;
if(sym != nullptr) lastWrite = sym->lastWrite;
mtx->Unlock();
lastAccess = lastWrite;
}
void MemoryFilesystem::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{
mtx->Lock();
auto node = GetEntry(path,false);
auto dir = dynamic_cast<MemoryDirectory*>(node);
auto file = dynamic_cast<MemoryFile*>(node);
auto sym = dynamic_cast<MemorySymlink*>(node);
if(dir != nullptr) dir->lastWrite = lastWrite;
if(file != nullptr) file->data->lastWrite = lastWrite;
if(sym != nullptr) sym->lastWrite = lastWrite;
mtx->Unlock();
}
MemoryFilesystem::~MemoryFilesystem()
{
}
MemoryFilesystem::MemoryFilesystem()
{
mtx = std::make_shared<Threading::Mutex>();
}
MemoryEntry::~MemoryEntry()
{
}
MemoryFile::~MemoryFile()
{
}
MemoryDirectory::MemoryDirectory()
{
this->lastWrite = Date::DateTime::NowUTC();
}
MemoryDirectory::~MemoryDirectory()
{
for(auto item : this->entries) delete item;
}
MemoryFileData::MemoryFileData()
{
this->lastWrite = Date::DateTime::NowUTC();
this->canAccess=true;
this->readers=0;
}
}

187
src/Filesystem/MountableFilesystem.cpp
View File

@@ -102,6 +102,21 @@ namespace Tesses::Framework::Filesystem
return vfs->StatVFS(destPath,data);
return false;
}
bool MountableFilesystem::Stat(VFSPath path, StatData& data)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->Stat(destPath,data);
return false;
}
void MountableFilesystem::Chmod(VFSPath path, uint32_t mode)
{
path = path.CollapseRelativeParents();
@@ -114,6 +129,32 @@ namespace Tesses::Framework::Filesystem
vfs->Chmod(destPath,mode);
}
void MountableFilesystem::Chown(VFSPath path, uint32_t uid, uint32_t gid)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
vfs->Chown(destPath,uid, gid);
}
FIFOCreationResult MountableFilesystem::CreateFIFO(VFSPath path, uint32_t mod)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->CreateFIFO(destPath,mod);
return FIFOCreationResult::UnknownError;
}
std::shared_ptr<Tesses::Framework::Streams::Stream> MountableFilesystem::OpenFile(VFSPath path, std::string mode)
{
@@ -163,141 +204,9 @@ namespace Tesses::Framework::Filesystem
}
bool MountableFilesystem::SpecialFileExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->SpecialFileExists(destPath);
return false;
}
bool MountableFilesystem::FileExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->FileExists(destPath);
return false;
}
bool MountableFilesystem::RegularFileExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->RegularFileExists(destPath);
return false;
}
bool MountableFilesystem::SymlinkExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->SymlinkExists(destPath);
return false;
}
bool MountableFilesystem::CharacterDeviceExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->CharacterDeviceExists(destPath);
return false;
}
bool MountableFilesystem::BlockDeviceExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->BlockDeviceExists(destPath);
return false;
}
bool MountableFilesystem::SocketFileExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->SocketFileExists(destPath);
return false;
}
bool MountableFilesystem::FIFOFileExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
return vfs->FIFOFileExists(destPath);
return false;
}
bool MountableFilesystem::DirectoryExists(VFSPath path)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(destPath.path.empty()) return true;
if(vfs != nullptr)
return vfs->DirectoryExists(destPath);
return false;
}
void MountableFilesystem::DeleteFile(VFSPath path)
{
path = path.CollapseRelativeParents();
@@ -339,20 +248,6 @@ namespace Tesses::Framework::Filesystem
if(vfs != nullptr)
vfs->Unlock(destPath);
}
void MountableFilesystem::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
{
path = path.CollapseRelativeParents();
VFSPath destRoot;
VFSPath destPath = path;
std::shared_ptr<VFS> vfs = root;
GetFS(path, destRoot, destPath, vfs);
if(vfs != nullptr)
vfs->GetDate(destPath,lastWrite,lastAccess);
}
void MountableFilesystem::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{

27
src/Filesystem/NullFilesystem.cpp
View File

@@ -6,33 +6,11 @@ namespace Tesses::Framework::Filesystem
{
return nullptr;
}
void NullFilesystem::CreateDirectory(VFSPath path)
{
}
void NullFilesystem::DeleteDirectory(VFSPath path)
{
}
bool NullFilesystem::RegularFileExists(VFSPath path)
{
return false;
}
bool NullFilesystem::DirectoryExists(VFSPath path)
{
return false;
}
void NullFilesystem::DeleteFile(VFSPath path)
{
}
VFSPathEnumerator NullFilesystem::EnumeratePaths(VFSPath path)
{
return VFSPathEnumerator();
}
void NullFilesystem::MoveFile(VFSPath src, VFSPath dest)
{
}
std::string NullFilesystem::VFSPathToSystem(VFSPath path)
{
@@ -42,4 +20,9 @@ namespace Tesses::Framework::Filesystem
{
return VFSPath(path);
}
bool NullFilesystem::Stat(VFSPath path, StatData& data)
{
return false;
}
}

56
src/Filesystem/SubdirFilesystem.cpp
View File

@@ -55,34 +55,6 @@ namespace Tesses::Framework::Filesystem
{
this->parent->DeleteDirectory(ToParent(path));
}
bool SubdirFilesystem::RegularFileExists(VFSPath path)
{
return this->parent->RegularFileExists(ToParent(path));
}
bool SubdirFilesystem::SymlinkExists(VFSPath path)
{
return this->parent->SymlinkExists(ToParent(path));
}
bool SubdirFilesystem::CharacterDeviceExists(VFSPath path)
{
return this->parent->CharacterDeviceExists(ToParent(path));
}
bool SubdirFilesystem::BlockDeviceExists(VFSPath path)
{
return this->parent->BlockDeviceExists(ToParent(path));
}
bool SubdirFilesystem::SocketFileExists(VFSPath path)
{
return this->parent->SocketFileExists(ToParent(path));
}
bool SubdirFilesystem::FIFOFileExists(VFSPath path)
{
return this->parent->FIFOFileExists(ToParent(path));
}
bool SubdirFilesystem::DirectoryExists(VFSPath path)
{
return this->parent->DirectoryExists(ToParent(path));
}
void SubdirFilesystem::DeleteFile(VFSPath path)
{
this->parent->DeleteFile(ToParent(path));
@@ -116,10 +88,7 @@ namespace Tesses::Framework::Filesystem
delete enumerator;
});
}
void SubdirFilesystem::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
{
this->parent->GetDate(ToParent(path),lastWrite,lastAccess);
}
void SubdirFilesystem::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{
this->parent->SetDate(ToParent(path),lastWrite,lastAccess);
@@ -149,14 +118,7 @@ namespace Tesses::Framework::Filesystem
{
this->parent->DeleteDirectoryRecurse(ToParent(path));
}
bool SubdirFilesystem::SpecialFileExists(VFSPath path)
{
return this->parent->SpecialFileExists(ToParent(path));
}
bool SubdirFilesystem::FileExists(VFSPath path)
{
return this->parent->FileExists(ToParent(path));
}
SubdirFilesystem::~SubdirFilesystem()
{
@@ -166,10 +128,22 @@ namespace Tesses::Framework::Filesystem
{
return this->parent->StatVFS(ToParent(path), vfsData);
}
bool SubdirFilesystem::Stat(VFSPath path, StatData& data)
{
return this->parent->Stat(ToParent(path), data);
}
void SubdirFilesystem::Chmod(VFSPath path, uint32_t mode)
{
return this->parent->Chmod(ToParent(path), mode);
}
void SubdirFilesystem::Chown(VFSPath path, uint32_t uid, uint32_t gid)
{
return this->parent->Chown(ToParent(path), uid, gid);
}
FIFOCreationResult SubdirFilesystem::CreateFIFO(VFSPath path, uint32_t mod)
{
return this->parent->CreateFIFO(path, mod);
}
}

72
src/Filesystem/TempFS.cpp
View File

@@ -54,56 +54,7 @@ namespace Tesses::Framework::Filesystem {
if(this->vfs == nullptr) return;
this->vfs->DeleteDirectory(path);
}
bool TempFS::SpecialFileExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->SpecialFileExists(path);
}
bool TempFS::FileExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->FileExists(path);
}
bool TempFS::RegularFileExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->RegularFileExists(path);
}
bool TempFS::SymlinkExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->SymlinkExists(path);
}
bool TempFS::CharacterDeviceExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->CharacterDeviceExists(path);
}
bool TempFS::BlockDeviceExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->BlockDeviceExists(path);
}
bool TempFS::SocketFileExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->SocketFileExists(path);
}
bool TempFS::FIFOFileExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->FIFOFileExists(path);
}
bool TempFS::DirectoryExists(VFSPath path)
{
if(this->vfs == nullptr) return false;
return this->vfs->DirectoryExists(path);
}
void TempFS::DeleteFile(VFSPath path)
{
if(this->vfs == nullptr) return;
@@ -173,12 +124,6 @@ namespace Tesses::Framework::Filesystem {
return this->vfs->SystemToVFSPath(path);
}
void TempFS::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
{
if(this->vfs == nullptr) return;
this->vfs->GetDate(path,lastWrite,lastAccess);
}
void TempFS::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{
@@ -191,6 +136,12 @@ namespace Tesses::Framework::Filesystem {
if(this->vfs == nullptr) return false;
return this->vfs->StatVFS(path, vfsData);
}
bool TempFS::Stat(VFSPath path, StatData& data)
{
if(this->vfs == nullptr) return false;
return this->vfs->Stat(path, data);
}
void TempFS::Chmod(VFSPath path, uint32_t mode)
{
@@ -198,6 +149,17 @@ namespace Tesses::Framework::Filesystem {
if(this->vfs == nullptr) return;
this->vfs->Chmod(path,mode);
}
void TempFS::Chown(VFSPath path, uint32_t uid, uint32_t gid)
{
if(this->vfs == nullptr) return;
this->vfs->Chown(path,uid, gid);
}
FIFOCreationResult TempFS::CreateFIFO(VFSPath path, uint32_t mod)
{
if(this->vfs == nullptr) return FIFOCreationResult::UnknownError;
return this->vfs->CreateFIFO(path, mod);
}
void TempFS::Close()
{

132
src/Filesystem/VFS.cpp
View File

@@ -1,6 +1,7 @@
#include "TessesFramework/Filesystem/VFS.hpp"
#include "TessesFramework/Http/HttpUtils.hpp"
#include "TessesFramework/Filesystem/LocalFS.hpp"
#include <TessesFramework/Filesystem/FSHelpers.hpp>
namespace Tesses::Framework::Filesystem
{
VFSPathEnumeratorItterator::VFSPathEnumeratorItterator()
@@ -216,6 +217,91 @@ namespace Tesses::Framework::Filesystem
{
return MakeRelative(GetAbsoluteCurrentDirectory());
}
FIFOCreationResult VFS::CreateFIFO(VFSPath path, uint32_t mode)
{
return FIFOCreationResult::Unsupported;
}
bool VFS::DirectoryExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsDirectory();
}
return false;
}
bool VFS::RegularFileExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsRegularFile();
}
return false;
}
bool VFS::SymlinkExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsSymlink();
}
return false;
}
bool VFS::CharacterDeviceExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsCharDevice();
}
return false;
}
bool VFS::BlockDeviceExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsBlockDevice();
}
return false;
}
bool VFS::SocketFileExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsSocket();
}
return false;
}
bool VFS::FIFOFileExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsFIFO();
}
return false;
}
bool VFS::FileExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return !data.IsDirectory();
}
return false;
}
bool VFS::SpecialFileExists(VFSPath path)
{
StatData data;
if(this->Stat(path, data))
{
return data.IsSpecial();
}
return false;
}
VFSPath VFSPath::MakeRelative(VFSPath toMakeRelativeTo) const
{
@@ -418,6 +504,14 @@ namespace Tesses::Framework::Filesystem
if(!firstPartPath.empty() && firstPartPath.back() == ':') this->relative=false;
}
}
}
void VFS::CreateDirectory(VFSPath path)
{
}
void VFS::DeleteDirectory(VFSPath path)
{
}
VFSPath::VFSPath(VFSPath p1, VFSPath p2)
{
@@ -462,17 +556,27 @@ namespace Tesses::Framework::Filesystem
}
return p;
}
void VFS::DeleteFile(VFSPath path)
{
}
void VFS::MoveFile(VFSPath src, VFSPath dest)
{
{
auto srcStrm = this->OpenFile(src, "rb");
if(!srcStrm->CanRead()) return;
auto destStrm = this->OpenFile(dest, "wb");
if(!destStrm->CanWrite()) return;
srcStrm->CopyTo(destStrm);
}
VFS::DeleteFile(src);
}
VFS::~VFS()
{
}
bool VFS::FIFOFileExists(VFSPath path) {return false;}
bool VFS::SocketFileExists(VFSPath path) {return false;}
bool VFS::CharacterDeviceExists(VFSPath path) {return false;}
bool VFS::BlockDeviceExists(VFSPath path) {return false;}
bool VFS::SymlinkExists(VFSPath path) {return false;}
void VFS::MoveDirectory(VFSPath src, VFSPath dest)
{
@@ -499,14 +603,6 @@ namespace Tesses::Framework::Filesystem
}
bool VFS::SpecialFileExists(VFSPath path)
{
return SymlinkExists(path) || BlockDeviceExists(path) || CharacterDeviceExists(path) || SocketFileExists(path) || FIFOFileExists(path);
}
bool VFS::FileExists(VFSPath path)
{
return RegularFileExists(path) || SpecialFileExists(path);
}
void VFS::DeleteDirectoryRecurse(VFSPath path)
{
@@ -527,7 +623,12 @@ namespace Tesses::Framework::Filesystem
}
void VFS::GetDate(VFSPath path, Date::DateTime& lastWrite, Date::DateTime& lastAccess)
{
StatData data;
if(Stat(path, data))
{
lastWrite = data.LastModified;
lastAccess = data.LastAccess;
}
}
void VFS::SetDate(VFSPath path, Date::DateTime lastWrite, Date::DateTime lastAccess)
{
@@ -550,6 +651,9 @@ namespace Tesses::Framework::Filesystem
}
void VFS::Chmod(VFSPath path, uint32_t mode) {
}
void VFS::Chown(VFSPath path, uint32_t uid, uint32_t gid) {
}
void VFS::Close() {

2
src/Http/FileServer.cpp
View File

@@ -73,7 +73,7 @@ namespace Tesses::Framework::Http
std::string p = HttpUtils::HtmlEncode(ctx.originalPath);
std::string html = "<!DOCTYPE html><html><head><meta charset=\"UTF-8\"><title>Index of ";
html.append(p);
html.append("</title></head><body><h1>Index of ");
html.append("</title><meta name=\"color-scheme\" content=\"dark light\"></head><body><h1>Index of ");
html.append(p);
html.append("</h1><hr><pre><a href=\"../\">../</a>\r\n");

95
src/Http/HttpServer.cpp
View File

@@ -13,6 +13,7 @@
#include "TessesFramework/Filesystem/VFSFix.hpp"
#include "TessesFramework/Filesystem/VFS.hpp"
#include <TessesFramework/Http/HttpUtils.hpp>
#include <iostream>
using FileStream = Tesses::Framework::Streams::FileStream;
using Stream = Tesses::Framework::Streams::Stream;
@@ -523,7 +524,7 @@ namespace Tesses::Framework::Http
while(parseSection(this, ct, cb));
}
HttpServer::HttpServer(std::shared_ptr<Tesses::Framework::Streams::TcpServer> tcpServer, std::shared_ptr<IHttpServer> http, bool showIPs)
HttpServer::HttpServer(std::shared_ptr<Tesses::Framework::Streams::TcpServer> tcpServer, std::shared_ptr<IHttpServer> http, bool showIPs, bool debug)
{
this->server = tcpServer;
this->http = http;
@@ -531,15 +532,16 @@ namespace Tesses::Framework::Http
this->showIPs = showIPs;
this->thrd=nullptr;
this->showARTL = showIPs;
this->debug = debug;
}
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, std::shared_ptr<IHttpServer> http, bool showIPs, bool debug) : HttpServer(std::make_shared<TcpServer>(port,10),http,showIPs, debug)
{
}
HttpServer::HttpServer(std::string unixPath, std::shared_ptr<IHttpServer> http) : HttpServer(std::make_shared<TcpServer>(unixPath,10),http,false)
HttpServer::HttpServer(std::string unixPath, std::shared_ptr<IHttpServer> http, bool debug) : HttpServer(std::make_shared<TcpServer>(unixPath,10),http,false, debug)
{
this->showARTL=true;
}
@@ -584,7 +586,8 @@ namespace Tesses::Framework::Http
auto serverPort = this->server->GetPort();
auto http = this->http;
TF_LOG("Before Creating Thread");
thrd = new Threading::Thread([svr,http,serverPort]()->void {
bool debug = this->debug;
thrd = new Threading::Thread([svr,http,serverPort,debug]()->void {
while(TF_IsRunning())
{
TF_LOG("after TF_IsRunning");
@@ -600,9 +603,10 @@ namespace Tesses::Framework::Http
return;
}
TF_LOG("Before entering socket thread");
Threading::Thread thrd2([sock,http,ip,port,serverPort]()->void {
Threading::Thread thrd2([sock,http,ip,port,serverPort,debug]()->void {
TF_LOG("In thread to process");
HttpServer::Process(sock,http,ip,port,serverPort,false);
HttpServer::Process(sock,http,ip,port,serverPort,false, debug);
TF_LOG("In thread after process");
});
@@ -650,12 +654,14 @@ namespace Tesses::Framework::Http
{
}
ServerContext::ServerContext(std::shared_ptr<Stream> strm)
ServerContext::ServerContext(std::shared_ptr<Stream> strm, bool debug)
{
this->statusCode = OK;
this->strm = strm;
this->debug = debug;
this->sent = false;
this->queryParams.SetCaseSensitive(true);
this->pathArguments.SetCaseSensitive(true);
this->responseHeaders.AddValue("Server","TessesFrameworkWebServer");
}
std::shared_ptr<Stream> ServerContext::GetStream()
@@ -685,7 +691,9 @@ namespace Tesses::Framework::Http
void ServerContext::SendErrorPage(bool showPath)
{
if(sent) return;
std::string errorHtml = showPath ? ("<html><head><title>File " + HttpUtils::HtmlEncode(this->originalPath) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</title></head><body><h1>" + std::to_string((int)this->statusCode) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</h1><h4>" + HttpUtils::HtmlEncode(this->originalPath) + "</h4></body></html>") : "";
std::string errorHtml = showPath ? ("<html><head><title>File " + HttpUtils::HtmlEncode(this->originalPath) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</title><meta name=\"color-scheme\" content=\"dark light\"></head><body><h1>" + std::to_string((int)this->statusCode) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</h1><h4>" + HttpUtils::HtmlEncode(this->originalPath) + "</h4></body></html>") : (
"<html><head><title>" + std::to_string(this->statusCode) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</title><meta name=\"color-scheme\" content=\"dark light\"></head><body><h1>" + std::to_string((int)this->statusCode) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</h1></body></html>"
);
WithMimeType("text/html").SendText(errorHtml);
}
@@ -900,24 +908,40 @@ namespace Tesses::Framework::Http
statusCode = StatusCode::BadRequest;
SendErrorPage(false);
}
ServerContext& ServerContext::WithStatusCode(StatusCode code)
{
this->statusCode = code;
return *this;
}
void ServerContext::SendException(std::exception& ex)
{
/*<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Internal Server Error at /</title>
</head>
<body>
<h1>Internal Server Error at /</h1>
<p>what(): std::exception</p>
</body>
</html>*/
this->WithMimeType("text/html").SendText("<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"UTF-8\"> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>Internal Server Error at " + HttpUtils::HtmlEncode(this->originalPath) + "</title></head><body><h1>Internal Server Error at " + HttpUtils::HtmlEncode(this->originalPath) + "</h1><p>what(): " + HttpUtils::HtmlEncode(ex.what()) + "</p></body></html>");
if(this->debug)
{
this->WithMimeType("text/html").WithStatusCode(StatusCode::InternalServerError).SendText("<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"UTF-8\"> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>Internal Server Error at " + HttpUtils::HtmlEncode(this->originalPath) + "</title><meta name=\"color-scheme\" content=\"dark light\"></head><body><h1>Internal Server Error at " + HttpUtils::HtmlEncode(this->originalPath) + "</h1><p>what(): " + HttpUtils::HtmlEncode(ex.what()) + "</p></body></html>");
}
else {
this->WithStatusCode(StatusCode::InternalServerError).SendErrorPage(true);
}
}
ServerContext& ServerContext::WithHeaderIntercepter(std::function<bool(ServerContext&)> cb)
{
this->headerhandlers.push(cb);
return *this;
}
ServerContext& ServerContext::WriteHeaders()
{
if(this->sent) return *this;
while(!this->headerhandlers.empty())
{
auto header = this->headerhandlers.front();
this->headerhandlers.pop();
if(header(*this)) {
break;
}
}
if(this->sent) return *this;
this->sent = true;
@@ -936,11 +960,9 @@ namespace Tesses::Framework::Http
return *this;
}
void HttpServer::Process(std::shared_ptr<Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port,uint16_t serverPort, bool encrypted)
void HttpServer::Process(std::shared_ptr<Stream> strm, std::shared_ptr<IHttpServer> server, std::string ip, uint16_t port,uint16_t serverPort, bool encrypted, bool debug)
{
TF_LOG("In process");
while(true)
{
std::shared_ptr<BufferedStream> bStrm = std::make_shared<BufferedStream>(strm);
StreamReader reader(bStrm);
ServerContext ctx(bStrm);
@@ -1012,7 +1034,10 @@ namespace Tesses::Framework::Http
if(!server->Handle(ctx))
{
if((int)ctx.statusCode < 400)
ctx.SendNotFound();
else
ctx.SendErrorPage(true);
}
}
@@ -1036,23 +1061,20 @@ namespace Tesses::Framework::Http
ctx.SendException(ex);
}
if(ctx.version != "HTTP/1.1" ) return;
std::string connection;
if(ctx.requestHeaders.TryGetFirst("Connection", connection))
}
bool ServerContext::Debug()
{
if(HttpUtils::ToLower(connection) != "keep-alive") return;
return this->debug;
}
if(ctx.responseHeaders.TryGetFirst("Connection", connection))
ServerContext& ServerContext::WithDebug(bool debug)
{
if(HttpUtils::ToLower(connection) != "keep-alive") return;
}
if(bStrm->EndOfStream()) {
return;
}
}
this->debug = debug;
return *this;
}
WebSocketConnection::~WebSocketConnection()
@@ -1105,4 +1127,3 @@ namespace Tesses::Framework::Http
}

139
src/TF_Init.cpp
View File

@@ -6,9 +6,13 @@
#include "TessesFramework/Filesystem/FSHelpers.hpp"
#include "TessesFramework/Serialization/Json.hpp"
#include <atomic>
#include <chrono>
#include <csignal>
#include <functional>
#include <iostream>
#include <memory>
#include <queue>
#include <ratio>
#if defined(TESSESFRAMEWORK_ENABLE_SQLITE)
extern "C" {
@@ -52,8 +56,6 @@ static GXRModeObj *rmode = NULL;
namespace Tesses::Framework
{
EventList<uint64_t> OnItteraton;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING) && (defined(GEKKO) || defined(__SWITCH__))
namespace Threading
{
@@ -66,6 +68,7 @@ namespace Tesses::Framework
volatile static std::atomic<bool> gaming_console_events=true;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
Threading::Mutex timers_mtx;
Threading::Mutex invokings_mtx;
std::queue<std::function<void()>> invokings;
@@ -109,10 +112,136 @@ namespace Tesses::Framework
PadState default_pad;
#endif
uint64_t ittr=0;
void TF_RunEventLoopItteration()
static std::shared_ptr<TF_Timer_Handler> timer_handler = std::make_shared<TF_Timer_Handler>();
std::shared_ptr<TF_Timer_Handle> TF_Timer_Handler::Make(std::shared_ptr<TF_Timer_Handler> handler)
{
auto timer = new TF_Timer_Handle(handler);
std::shared_ptr<TF_Timer_Handle> handle(timer);
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Lock();
#endif
handler->handles.push_back(handle);
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Unlock();
#endif
return handle;
}
std::shared_ptr<TF_Timer_Handle> TF_Timer()
{
return TF_Timer_Handler::Make(timer_handler);
}
std::shared_ptr<TF_Timer_Handle> TF_Timer(std::function<void()> cb, int64_t interval, bool enabled)
{
auto handle = TF_Timer();
handle->SetCallback(cb);
handle->SetIntervalFromMilliseconds(interval);
handle->SetEnabled(enabled);
return handle;
}
std::shared_ptr<TF_Timer_Handle> TF_Timer(std::function<void()> cb, std::chrono::duration<int64_t,std::milli> interval, bool enabled)
{
auto handle = TF_Timer();
handle->SetCallback(cb);
handle->SetIntervalFromDuration(interval);
handle->SetEnabled(enabled);
return handle;
}
void TF_Timer_Handler::Update()
{
std::chrono::time_point<std::chrono::steady_clock,std::chrono::milliseconds> cur = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now());
std::vector<std::function<void()>> cbs;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Lock();
#endif
for(auto index = this->handles.begin(); index != this->handles.end(); index++)
{
if(index->expired())
{
this->handles.erase(index);
index--;
}
else {
auto handle = index->lock();
if(handle && handle->enabled && (handle->last + handle->interval) <= cur && handle->cb)
{
handle->last = cur;
cbs.push_back(handle->cb);
}
}
}
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Unlock();
#endif
for(auto item : cbs)
{
item();
}
}
void TF_Timer_Handle::SetCallback(std::function<void()> cb)
{
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Lock();
#endif
this->cb = cb;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Unlock();
#endif
}
TF_Timer_Handle::TF_Timer_Handle(std::shared_ptr<TF_Timer_Handler> handler) : timerHandler(handler)
{
OnItteraton.Invoke(ittr++);
}
void TF_Timer_Handle::SetEnabled(bool enabled)
{
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Lock();
#endif
this->enabled = enabled;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Unlock();
#endif
}
bool TF_Timer_Handle::GetEnabled()
{
return this->enabled;
}
void TF_Timer_Handle::SetIntervalFromDuration(std::chrono::milliseconds ms)
{
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Lock();
#endif
this->interval = ms;
#if defined(TESSESFRAMEWORK_ENABLE_THREADING)
timers_mtx.Unlock();
#endif
}
void TF_Timer_Handle::SetIntervalFromMilliseconds(int64_t ms)
{
SetIntervalFromDuration(std::chrono::milliseconds(ms));
}
std::chrono::duration<int64_t,std::milli> TF_Timer_Handle::GetIntervalDuration()
{
return this->interval;
}
int64_t TF_Timer_Handle::GetIntervalMilliseconds()
{
return this->interval.count();
}
void TF_RunEventLoopItteration()
{
#if defined(TESSESFRAMEWORK_ENABLE_THREADING) && (defined(GEKKO) || defined(__SWITCH__))
Tesses::Framework::Threading::LookForFinishedThreads();
@@ -165,6 +294,8 @@ namespace Tesses::Framework
#endif
timer_handler->Update();
}
void TF_SetIsRunning(bool _isRunning)
{