forked from latticeware/Cytoplasm
Import new Cytoplasm library based off of code from Telodendria.
Telodendria doesn't use this library yet, but it will soon.
This commit is contained in:
commit
40eac30b5c
60 changed files with 15048 additions and 0 deletions
3
.cvsignore
Normal file
3
.cvsignore
Normal file
|
@ -0,0 +1,3 @@
|
||||||
|
build
|
||||||
|
out
|
||||||
|
*-leaked.txt
|
28
.indent.pro
vendored
Normal file
28
.indent.pro
vendored
Normal file
|
@ -0,0 +1,28 @@
|
||||||
|
-bad
|
||||||
|
-bap
|
||||||
|
-bbb
|
||||||
|
-nbc
|
||||||
|
-bl
|
||||||
|
-c36
|
||||||
|
-cd36
|
||||||
|
-ncdb
|
||||||
|
-nce
|
||||||
|
-ci8
|
||||||
|
-cli1
|
||||||
|
-d0
|
||||||
|
-di1
|
||||||
|
-ndj
|
||||||
|
-ei
|
||||||
|
-fc1
|
||||||
|
-i4
|
||||||
|
-ip
|
||||||
|
-l72
|
||||||
|
-lc72
|
||||||
|
-lp
|
||||||
|
-npcs
|
||||||
|
-psl
|
||||||
|
-sc
|
||||||
|
-nsob
|
||||||
|
-nut
|
||||||
|
-nv
|
||||||
|
|
24
LICENSE.txt
Normal file
24
LICENSE.txt
Normal file
|
@ -0,0 +1,24 @@
|
||||||
|
/*
|
||||||
|
* Cytoplasm (libcytoplasm)
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
158
README.txt
Normal file
158
README.txt
Normal file
|
@ -0,0 +1,158 @@
|
||||||
|
Cytoplasm (libcytoplasm)
|
||||||
|
========================================================================
|
||||||
|
|
||||||
|
Cytoplasm is a general-purpose C library and runtime stub for
|
||||||
|
creating high-level (particularly networked and multi-threaded) C
|
||||||
|
applications. It allows applications to take advantage of the speed,
|
||||||
|
flexibility, and simplicity of the C programming language, while
|
||||||
|
providing helpful code to perform various complex tasks. Cytoplasm
|
||||||
|
provides high-level data structures, a basic logging facility, an
|
||||||
|
HTTP client and server, and more.
|
||||||
|
|
||||||
|
Cytoplasm aims not to only do one thing well, but to do many things
|
||||||
|
good enough. The primary target of Cytoplasm is simple, yet higher
|
||||||
|
level C applications that have to perform relatively complex tasks,
|
||||||
|
but don't want to pull in a large number of dependencies.
|
||||||
|
|
||||||
|
Cytoplasm is extremely opinionated on the way programs using it are
|
||||||
|
written. It strives to create a comprehensive and tightly-integrated
|
||||||
|
programming environment, while also maintaining C programming
|
||||||
|
correctness. It doesn't do any macro magic or make C look like
|
||||||
|
anything other than C. It is written entirely in C89, and depends
|
||||||
|
only on a POSIX environment. This differentiates it from other
|
||||||
|
general-purpose libraries that often require modern compilers and
|
||||||
|
non-standard language and environment features. Cytoplasm is intended
|
||||||
|
to be extremely portable and simple, while still providing some of
|
||||||
|
the functionality expected in higher-level programming languages
|
||||||
|
in a platform-agnostic manner. In the case of TLS, Cytoplasm wraps
|
||||||
|
low-level TLS libraries to offer a single, unified interface to TLS
|
||||||
|
so that programs do not have to care about the underlying
|
||||||
|
implementation.
|
||||||
|
|
||||||
|
Cytoplasm is probably not suitable for embedded programming. It makes
|
||||||
|
liberal use of the heap, and while data structures are designed to
|
||||||
|
conserve memory where possible and practical, minimal memory usage
|
||||||
|
is not really a design goal for Cytoplasm, although Cytoplasm takes
|
||||||
|
care not to use any more memory than it absolutely needs. Cytoplasm
|
||||||
|
also wraps a few standard libraries with additional logic and
|
||||||
|
checking. While this ensures better runtime safetly, this inevitably
|
||||||
|
adds a little overhead.
|
||||||
|
|
||||||
|
Originally a part of Telodendria (https://telodendria.io), a Matrix
|
||||||
|
homeserver written in C, Cytoplasm was split off into its own project
|
||||||
|
due to the desire of some Telodendria developers to use Telodendria's
|
||||||
|
code in other projects. Cytoplasm is still a Telodendria project,
|
||||||
|
and is maintained along side of Telodendria itself, even living in
|
||||||
|
the same CVS module, but it is designed specifically to be distributed
|
||||||
|
and used totally independent of Telodendria.
|
||||||
|
|
||||||
|
The name "Cytoplasm" was chosen for a few reasons. It plays off the
|
||||||
|
precedent set up by the Matrix organization in naming projects after
|
||||||
|
the parts of a neuron. It also speaks to the function of Cytoplasm.
|
||||||
|
The cytoplasm of a cell is the supporting material. It is what gives
|
||||||
|
the cell its shape, and it facilitates the movement of materials
|
||||||
|
to the other cell parts. Likewise, Cytoplasm aims to provide a
|
||||||
|
support mechanism for C applications that have to perform complex
|
||||||
|
tasks.
|
||||||
|
|
||||||
|
Cytoplasm also starts with a C, which I think is a nice touch for C
|
||||||
|
libraries. It's also fun to say and unique enough that searching for
|
||||||
|
"libcytoplasm" should bring you to this project and not some other
|
||||||
|
one.
|
||||||
|
|
||||||
|
Building
|
||||||
|
------------------------------------------------------------------------
|
||||||
|
|
||||||
|
If your operating system or software distribution provides a pre-built
|
||||||
|
package of Cytoplasm, you should prefer to use that instead of
|
||||||
|
building it from source.
|
||||||
|
|
||||||
|
Cytoplasm aims to have zero dependencies beyond what is mandated
|
||||||
|
by POSIX. You only need the standard math and pthread libraries to
|
||||||
|
build it. TLS support can optionally be enabled by setting the
|
||||||
|
TLS_IMPL environment variable. The supported TLS implementations
|
||||||
|
are as follows:
|
||||||
|
|
||||||
|
* OpenSSL
|
||||||
|
* LibreSSL
|
||||||
|
|
||||||
|
If TLS support is not enabled, all APIs that use it should fall
|
||||||
|
back to non-TLS behavior in a sensible manner. For example, if TLS
|
||||||
|
support is not enabled, then the HTTP client API will simply return
|
||||||
|
an error if a TLS connection is requested.
|
||||||
|
|
||||||
|
Cytoplasm uses a custom build script instead of Make, for the sake
|
||||||
|
of portability. To build everything, just run the script:
|
||||||
|
|
||||||
|
$ sh make.sh
|
||||||
|
|
||||||
|
This will produce the following out/ directory:
|
||||||
|
|
||||||
|
out/
|
||||||
|
lib/
|
||||||
|
libcytoplasm.so - The Cytoplasm shared library.
|
||||||
|
libcytoplasm.a - The Cytoplasm static library.
|
||||||
|
cytoplasm.o - The Cytoplasm runtime stub.
|
||||||
|
bin/
|
||||||
|
hdoc - The documentation generator tool.
|
||||||
|
man/ - All Cytoplasm API documentation.
|
||||||
|
|
||||||
|
Usage
|
||||||
|
------------------------------------------------------------------------
|
||||||
|
|
||||||
|
Cytoplasm provides the typical .so and .a files, which can be used
|
||||||
|
to link programs with it in the usual way. However, Cytoplasm also
|
||||||
|
provides a minimal runtime environment that is intended to be used
|
||||||
|
with the library. As such, it also provides a runtime stub, which
|
||||||
|
is intended to be linked in with programs using Cytoplasm. This
|
||||||
|
stub is responsible for setting up and tearing down some Cytoplasm
|
||||||
|
APIs. While it isn't required by any means, it makes Cytoplasm a
|
||||||
|
lot easier to use for programmers by abstracting out all of the
|
||||||
|
common logic that most programs will want to use.
|
||||||
|
|
||||||
|
Here is the canonical Hello World written with Cytoplasm:
|
||||||
|
|
||||||
|
#include <Log.h>
|
||||||
|
|
||||||
|
int Main(void)
|
||||||
|
{
|
||||||
|
Log(LOG_INFO, "Hello World!");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
If this file is Hello.c, then you can compile it by doing something
|
||||||
|
like this:
|
||||||
|
|
||||||
|
$ cc -o hello Hello.c cytoplasm.o -lcytoplasm
|
||||||
|
|
||||||
|
This command assumes that the runtime stub resides in the current
|
||||||
|
working directory, and that libcytoplasm.so is in your library path.
|
||||||
|
If you're using the version of Cytoplasm installed by your operating
|
||||||
|
system or software distribution, consult the documentation for the
|
||||||
|
location of the runtime stub. It may be located in
|
||||||
|
/usr/local/libexec or some other similar location. If you've built
|
||||||
|
Cytoplasm from source and wish to link to it from there, you may wish
|
||||||
|
to do something like this:
|
||||||
|
|
||||||
|
$ export CYTOPLASM=/path/to/Cytoplasm/out/lib
|
||||||
|
$ cc -o hello Hello.c "${CYTOPLASM}/cytoplasm.o" \
|
||||||
|
"-L${CYTOPLASM}" -lcytoplasm
|
||||||
|
|
||||||
|
As you may have noticed, C programs using Cytoplasm's runtime stub
|
||||||
|
don't write the main() function. Instead, they use Main(). The main()
|
||||||
|
function is provided by the runtime stub. The full form of Main()
|
||||||
|
expected by the stub is as follows:
|
||||||
|
|
||||||
|
int Main(Array *args, HashMap *env);
|
||||||
|
|
||||||
|
The first argument is a Cytoplasm array of the command line
|
||||||
|
arguments, and the second is a Cytoplasm hash map of environment
|
||||||
|
variables. Most linkers will let programs omit the env argument,
|
||||||
|
or both arguments if you don't need either. The return value of
|
||||||
|
Main() is returned to the operating system.
|
||||||
|
|
||||||
|
Note that both arguments to Main may be treated like any other
|
||||||
|
array or hash map. However, do not invoke ArrayFree() or HashMapFree()
|
||||||
|
on the passed pointers, because memory is cleaned up after Main()
|
||||||
|
returns.
|
||||||
|
|
301
make.sh
Executable file
301
make.sh
Executable file
|
@ -0,0 +1,301 @@
|
||||||
|
#!/usr/bin/env sh
|
||||||
|
|
||||||
|
addprefix() {
|
||||||
|
prefix="$1"
|
||||||
|
shift
|
||||||
|
for thing in "$@"; do
|
||||||
|
echo "${prefix}${thing}"
|
||||||
|
done
|
||||||
|
|
||||||
|
unset prefix
|
||||||
|
unset thing
|
||||||
|
}
|
||||||
|
|
||||||
|
: "${NAME:=Cytoplasm}"
|
||||||
|
: "${LIB_NAME:=$(echo ${NAME} | tr '[A-Z]' '[a-z]')}"
|
||||||
|
: "${VERSION:=0.3.0}"
|
||||||
|
|
||||||
|
: "${CVS_TAG:=${NAME}-$(echo ${VERSION} | sed 's/\./_/g')}"
|
||||||
|
|
||||||
|
|
||||||
|
: "${SRC:=src}"
|
||||||
|
: "${TOOLS:=tools}"
|
||||||
|
: "${BUILD:=build}"
|
||||||
|
: "${OUT:=out}"
|
||||||
|
: "${STUB:=RtStub}"
|
||||||
|
: "${LICENSE:=LICENSE.txt}"
|
||||||
|
|
||||||
|
: "${CC:=cc}"
|
||||||
|
: "${AR:=ar}"
|
||||||
|
|
||||||
|
: "${DEFINES:=-D_DEFAULT_SOURCE -DLIB_NAME=\"${NAME}\" -DLIB_VERSION=\"${VERSION}\"}"
|
||||||
|
: "${INCLUDE:=${SRC}/include}"
|
||||||
|
|
||||||
|
: "${CFLAGS:=-Wall -Wextra -pedantic -std=c89 -O3 -pipe}"
|
||||||
|
: "${LD_EXTRA:=-flto -fdata-sections -ffunction-sections -s -Wl,-gc-sections}"
|
||||||
|
: "${LDFLAGS:=-lm -pthread}"
|
||||||
|
|
||||||
|
if [ -n "${TLS_IMPL}" ]; then
|
||||||
|
case "${TLS_IMPL}" in
|
||||||
|
"LIBRESSL")
|
||||||
|
TLS_LIBS="-ltls -lcrypto -lssl"
|
||||||
|
;;
|
||||||
|
"OPENSSL")
|
||||||
|
TLS_LIBS="-lcrypto -lssl"
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
echo "Unrecognized TLS implementation: ${TLS_IMPL}"
|
||||||
|
echo "Consult Tls.h for supported implementations."
|
||||||
|
echo "Note that the TLS_ prefix is omitted in TLS_IMPL."
|
||||||
|
exit 1
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
DEFINES="${DEFINES} -DTLS_IMPL=TLS_${TLS_IMPL}"
|
||||||
|
LDFLAGS="${LDFLAGS} ${TLS_LIBS}"
|
||||||
|
fi
|
||||||
|
|
||||||
|
CFLAGS="${CFLAGS} ${DEFINES} $(addprefix -I$(pwd)/ ${INCLUDE})"
|
||||||
|
LDFLAGS="${LDFLAGS} ${LD_EXTRA}"
|
||||||
|
|
||||||
|
# Check the modificiation time of a file. This is used to do
|
||||||
|
# incremental builds; we only want to rebuild files that have
|
||||||
|
# have changed.
|
||||||
|
mod_time() {
|
||||||
|
if [ -n "$1" ] && [ -f "$1" ]; then
|
||||||
|
case "$(uname)" in
|
||||||
|
Linux | CYGWIN_NT* | Haiku)
|
||||||
|
stat -c %Y "$1"
|
||||||
|
;;
|
||||||
|
*BSD | DragonFly | Minix)
|
||||||
|
stat -f %m "$1"
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
# Platform unknown, force rebuilding the whole
|
||||||
|
# project every time.
|
||||||
|
echo "0"
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
else
|
||||||
|
echo "0"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Substitute shell variables in a stream with their actual value
|
||||||
|
# in this shell.
|
||||||
|
setsubst() {
|
||||||
|
SED="/tmp/sed-$RANDOM.txt"
|
||||||
|
|
||||||
|
(
|
||||||
|
set | while IFS='=' read -r var val; do
|
||||||
|
val=$(echo "$val" | cut -d "'" -f 2- | rev | cut -d "'" -f 2- | rev)
|
||||||
|
echo "s|\\\${$var}|$val|g"
|
||||||
|
done
|
||||||
|
|
||||||
|
echo "s|\\\${[a-zA-Z_]*}||g"
|
||||||
|
echo "s|'''|'|g"
|
||||||
|
) >"$SED"
|
||||||
|
|
||||||
|
sed -f "$SED" $@
|
||||||
|
rm "$SED"
|
||||||
|
}
|
||||||
|
|
||||||
|
recipe_docs() {
|
||||||
|
export LD_LIBRARY_PATH="${OUT}/lib"
|
||||||
|
mkdir -p "${OUT}/man/man3"
|
||||||
|
|
||||||
|
for header in $(find ${INCLUDE} -name '*.h'); do
|
||||||
|
basename=$(basename "$header")
|
||||||
|
man=$(echo "${OUT}/man/man3/$basename" | sed -e 's/\.h$/\.3/')
|
||||||
|
|
||||||
|
if [ $(mod_time "$header") -ge $(mod_time "$man") ]; then
|
||||||
|
echo "DOC $basename"
|
||||||
|
if ! "${OUT}/bin/hdoc" -D "Os=${NAME}" -i "$header" -o "$man"; then
|
||||||
|
rm "$man"
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
if which makewhatis 2>&1 > /dev/null; then
|
||||||
|
makewhatis "${OUT}/man"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
recipe_build() {
|
||||||
|
mkdir -p "${BUILD}" ${OUT}/{bin,lib}
|
||||||
|
cd "${SRC}"
|
||||||
|
|
||||||
|
echo "CC = ${CC}"
|
||||||
|
echo "CFLAGS = ${CFLAGS}"
|
||||||
|
echo "LDFLAGS = ${LDFLAGS}"
|
||||||
|
echo
|
||||||
|
|
||||||
|
do_rebuild=0
|
||||||
|
objs=""
|
||||||
|
for src in $(find . -name '*.c' | cut -d '/' -f 2-); do
|
||||||
|
obj=$(echo "${BUILD}/$src" | sed -e 's/\.c$/\.o/')
|
||||||
|
|
||||||
|
if [ $(basename "$obj" .o) != "${STUB}" ]; then
|
||||||
|
objs="$objs $obj"
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ $(mod_time "$src") -ge $(mod_time "../$obj") ]; then
|
||||||
|
echo "CC $(basename $obj)"
|
||||||
|
obj_dir=$(dirname "../$obj")
|
||||||
|
mkdir -p "$obj_dir"
|
||||||
|
if ! $CC $CFLAGS -fPIC -c -o "../$obj" "$src"; then
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
do_rebuild=1
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
cd ..
|
||||||
|
|
||||||
|
if [ $do_rebuild -eq 1 ] || [ ! -f "${OUT}/lib/lib${LIB_NAME}.a" ]; then
|
||||||
|
echo "AR lib${LIB_NAME}.a"
|
||||||
|
if ! $AR rcs "${OUT}/lib/lib${LIB_NAME}.a" $objs; then
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ $do_rebuild -eq 1 ] || [ ! -f "${OUT}/lib/lib${LIB_NAME}.so" ]; then
|
||||||
|
echo "LD lib${LIB_NAME}.so"
|
||||||
|
if ! $CC -shared -o "${OUT}/lib/lib${LIB_NAME}.so" $objs ${LDFLAGS}; then
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
cp "${BUILD}/${STUB}.o" "${OUT}/lib/${LIB_NAME}.o"
|
||||||
|
|
||||||
|
for src in $(find "${TOOLS}" -name '*.c'); do
|
||||||
|
out=$(basename "$src" .c)
|
||||||
|
out="${OUT}/bin/$out"
|
||||||
|
|
||||||
|
if [ $(mod_time "$src") -ge $(mod_time "$out") ] || [ $do_rebuild -eq 1 ]; then
|
||||||
|
echo "CC $(basename $out)"
|
||||||
|
mkdir -p "$(dirname $out)"
|
||||||
|
if ! $CC $CFLAGS -o "$out" "$src" "${OUT}/lib/${LIB_NAME}.o" "-L${OUT}/lib" "-l${LIB_NAME}" ${LDFLAGS}; then
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
|
||||||
|
recipe_docs
|
||||||
|
}
|
||||||
|
|
||||||
|
recipe_clean() {
|
||||||
|
rm -r "${BUILD}" "${OUT}"
|
||||||
|
}
|
||||||
|
|
||||||
|
# Update copyright comments in sources and header files.
|
||||||
|
recipe_license() {
|
||||||
|
find . -name '*.[ch]' | while IFS= read -r src; do
|
||||||
|
if [ -t 1 ]; then
|
||||||
|
printf "LICENSE %s%*c\r" $(basename "$src") "16" " "
|
||||||
|
fi
|
||||||
|
srcHeader=$(grep -n -m 1 '^ \*/' "$src" | cut -d ':' -f 1)
|
||||||
|
head "-n$srcHeader" "$src" |
|
||||||
|
diff -u -p - "${LICENSE}" |
|
||||||
|
patch "$src" | grep -v "^Hmm"
|
||||||
|
done
|
||||||
|
if [ -t 1 ]; then
|
||||||
|
printf "%*c\n" "50" " "
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Format source code files by running indent(1) on them.
|
||||||
|
recipe_format() {
|
||||||
|
find . -name '*.c' | while IFS= read -r src; do
|
||||||
|
if [ -t 1 ]; then
|
||||||
|
printf "FMT %s%*c\r" $(basename "$src") "16" " "
|
||||||
|
fi
|
||||||
|
if indent "$src"; then
|
||||||
|
rm $(basename "$src").BAK
|
||||||
|
fi
|
||||||
|
done
|
||||||
|
if [ -t 1 ]; then
|
||||||
|
printf "%*c\n" "50" " "
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Generate a release tarball, checksum and sign it, and push it to
|
||||||
|
# the web root.
|
||||||
|
recipe_release() {
|
||||||
|
# Tag the release at this point in time.
|
||||||
|
cvs tag "$CVS_TAG"
|
||||||
|
|
||||||
|
mkdir -p "${OUT}/release"
|
||||||
|
cd "${OUT}/release"
|
||||||
|
|
||||||
|
# Generate the release tarball.
|
||||||
|
cvs export "-r$CVS_TAG" "${NAME}"
|
||||||
|
mv "${NAME}" "${NAME}-v${VERSION}"
|
||||||
|
tar -czf "${NAME}-v${VERSION}.tar.gz" "${NAME}-v${VERSION}"
|
||||||
|
rm -r "${NAME}-v${VERSION}"
|
||||||
|
|
||||||
|
# Checksum the release tarball.
|
||||||
|
sha256 "${NAME}-v${VERSION}.tar.gz" > "${NAME}-v${VERSION}.tar.gz.sha256"
|
||||||
|
|
||||||
|
# Sign the release tarball.
|
||||||
|
if [ ! -z "${SIGNIFY_SECRET}" ]; then
|
||||||
|
signify -S -s "${SIGNIFY_SECRET}" \
|
||||||
|
-m "${NAME}-v${VERSION}.tar.gz" \
|
||||||
|
-x "${NAME}-v${VERSION}.tar.gz.sig"
|
||||||
|
else
|
||||||
|
echo "Warning: SIGNIFY_SECRET not net."
|
||||||
|
echo "The built tarball will not be signed."
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
recipe_patch() {
|
||||||
|
# If the user has not set their MXID, try to deduce one from
|
||||||
|
# their system.
|
||||||
|
if [ -z "$MXID" ]; then
|
||||||
|
MXID="@${USER}:$(hostname)"
|
||||||
|
fi
|
||||||
|
|
||||||
|
# If the user has not set their EDITOR, use a safe default.
|
||||||
|
# (vi should be available on any POSIX system)
|
||||||
|
if [ -z "$EDITOR" ]; then
|
||||||
|
EDITOR=vi
|
||||||
|
fi
|
||||||
|
|
||||||
|
NORMALIZED_MXID=$(echo "$MXID" | sed -e 's/@//g' -e 's/:/-/g')
|
||||||
|
PATCH_FILE="${NORMALIZED_MXID}_$(date +%s).patch"
|
||||||
|
|
||||||
|
# Generate the actual patch file
|
||||||
|
# Here we write some nice headers, and then do a cvs diff.
|
||||||
|
(
|
||||||
|
printf 'From: "%s" <%s>\n' "$DISPLAY_NAME" "$MXID"
|
||||||
|
echo "Date: $(date)"
|
||||||
|
echo "Subject: "
|
||||||
|
echo
|
||||||
|
cvs -q diff -uNp $PATCHSET | grep -v '^\? '
|
||||||
|
) >"$PATCH_FILE"
|
||||||
|
|
||||||
|
"$EDITOR" "$PATCH_FILE"
|
||||||
|
echo "$PATCH_FILE"
|
||||||
|
}
|
||||||
|
|
||||||
|
recipe_diff() {
|
||||||
|
tmp_patch="/tmp/${NAME}-$(date +%s).patch"
|
||||||
|
cvs -q diff -uNp $PATCHSET >"$tmp_patch"
|
||||||
|
if [ -z "$PAGER" ]; then
|
||||||
|
PAGER="less -F"
|
||||||
|
fi
|
||||||
|
|
||||||
|
$PAGER "$tmp_patch"
|
||||||
|
rm "$tmp_patch"
|
||||||
|
}
|
||||||
|
|
||||||
|
# Execute the user-specified recipes.
|
||||||
|
for recipe in $@; do
|
||||||
|
recipe_$recipe
|
||||||
|
done
|
||||||
|
|
||||||
|
# If no recipe was provided, run a build.
|
||||||
|
if [ -z "$1" ]; then
|
||||||
|
recipe_build
|
||||||
|
fi
|
118
src/Args.c
Normal file
118
src/Args.c
Normal file
|
@ -0,0 +1,118 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Args.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Log.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
void
|
||||||
|
ArgParseStateInit(ArgParseState * state)
|
||||||
|
{
|
||||||
|
state->optPos = 1;
|
||||||
|
state->optErr = 1;
|
||||||
|
state->optInd = 1;
|
||||||
|
state->optOpt = 0;
|
||||||
|
state->optArg = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
ArgParse(ArgParseState * state, Array * args, const char *optStr)
|
||||||
|
{
|
||||||
|
const char *arg;
|
||||||
|
|
||||||
|
arg = ArrayGet(args, state->optInd);
|
||||||
|
|
||||||
|
if (arg && StrEquals(arg, "--"))
|
||||||
|
{
|
||||||
|
state->optInd++;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
else if (!arg || arg[0] != '-' || !isalnum((unsigned char) arg[1]))
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
const char *opt = strchr(optStr, arg[state->optPos]);
|
||||||
|
|
||||||
|
state->optOpt = arg[state->optPos];
|
||||||
|
|
||||||
|
if (!opt)
|
||||||
|
{
|
||||||
|
if (state->optErr && *optStr != ':')
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "Illegal option: %c", ArrayGet(args, 0), state->optOpt);
|
||||||
|
}
|
||||||
|
if (!arg[++state->optPos])
|
||||||
|
{
|
||||||
|
state->optInd++;
|
||||||
|
state->optPos = 1;
|
||||||
|
}
|
||||||
|
return '?';
|
||||||
|
}
|
||||||
|
else if (opt[1] == ':')
|
||||||
|
{
|
||||||
|
if (arg[state->optPos + 1])
|
||||||
|
{
|
||||||
|
state->optArg = (char *) arg + state->optPos + 1;
|
||||||
|
state->optInd++;
|
||||||
|
state->optPos = 1;
|
||||||
|
return state->optOpt;
|
||||||
|
}
|
||||||
|
else if (ArrayGet(args, state->optInd + 1))
|
||||||
|
{
|
||||||
|
state->optArg = (char *) ArrayGet(args, state->optInd + 1);
|
||||||
|
state->optInd += 2;
|
||||||
|
state->optPos = 1;
|
||||||
|
return state->optOpt;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (state->optErr && *optStr != ':')
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "Option requires an argument: %c", state->optOpt);
|
||||||
|
}
|
||||||
|
if (!arg[++state->optPos])
|
||||||
|
{
|
||||||
|
state->optInd++;
|
||||||
|
state->optPos = 1;
|
||||||
|
}
|
||||||
|
return *optStr == ':' ? ':' : '?';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (!arg[++state->optPos])
|
||||||
|
{
|
||||||
|
state->optInd++;
|
||||||
|
state->optPos = 1;
|
||||||
|
}
|
||||||
|
return state->optOpt;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
339
src/Array.c
Normal file
339
src/Array.c
Normal file
|
@ -0,0 +1,339 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
#ifndef ARRAY_BLOCK
|
||||||
|
#define ARRAY_BLOCK 16
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
struct Array
|
||||||
|
{
|
||||||
|
void **entries; /* An array of void pointers, to
|
||||||
|
* store any data */
|
||||||
|
size_t allocated; /* Elements allocated on the heap */
|
||||||
|
size_t size; /* Elements actually filled */
|
||||||
|
};
|
||||||
|
|
||||||
|
int
|
||||||
|
ArrayAdd(Array * array, void *value)
|
||||||
|
{
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ArrayInsert(array, array->size, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
Array *
|
||||||
|
ArrayCreate(void)
|
||||||
|
{
|
||||||
|
Array *array = Malloc(sizeof(Array));
|
||||||
|
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
array->size = 0;
|
||||||
|
array->allocated = ARRAY_BLOCK;
|
||||||
|
array->entries = Malloc(sizeof(void *) * ARRAY_BLOCK);
|
||||||
|
|
||||||
|
if (!array->entries)
|
||||||
|
{
|
||||||
|
Free(array);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return array;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
ArrayDelete(Array * array, size_t index)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
void *element;
|
||||||
|
|
||||||
|
if (!array || array->size <= index)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
element = array->entries[index];
|
||||||
|
|
||||||
|
for (i = index; i < array->size - 1; i++)
|
||||||
|
{
|
||||||
|
array->entries[i] = array->entries[i + 1];
|
||||||
|
}
|
||||||
|
|
||||||
|
array->size--;
|
||||||
|
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
ArrayFree(Array * array)
|
||||||
|
{
|
||||||
|
if (array)
|
||||||
|
{
|
||||||
|
Free(array->entries);
|
||||||
|
Free(array);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
ArrayGet(Array * array, size_t index)
|
||||||
|
{
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (index >= array->size)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return array->entries[index];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
extern int
|
||||||
|
ArrayInsert(Array * array, size_t index, void *value)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (!array || !value || index > array->size)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (array->size >= array->allocated)
|
||||||
|
{
|
||||||
|
void **tmp;
|
||||||
|
size_t newSize = array->allocated + ARRAY_BLOCK;
|
||||||
|
|
||||||
|
tmp = array->entries;
|
||||||
|
|
||||||
|
array->entries = Realloc(array->entries,
|
||||||
|
sizeof(void *) * newSize);
|
||||||
|
|
||||||
|
if (!array->entries)
|
||||||
|
{
|
||||||
|
array->entries = tmp;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
array->allocated = newSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = array->size; i > index; i--)
|
||||||
|
{
|
||||||
|
array->entries[i] = array->entries[i - 1];
|
||||||
|
}
|
||||||
|
|
||||||
|
array->size++;
|
||||||
|
|
||||||
|
array->entries[index] = value;
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern void *
|
||||||
|
ArraySet(Array * array, size_t index, void *value)
|
||||||
|
{
|
||||||
|
void *oldValue;
|
||||||
|
|
||||||
|
if (!value)
|
||||||
|
{
|
||||||
|
return ArrayDelete(array, index);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (index >= array->size)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
oldValue = array->entries[index];
|
||||||
|
array->entries[index] = value;
|
||||||
|
|
||||||
|
return oldValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t
|
||||||
|
ArraySize(Array * array)
|
||||||
|
{
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return array->size;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
ArrayTrim(Array * array)
|
||||||
|
{
|
||||||
|
void **tmp;
|
||||||
|
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = array->entries;
|
||||||
|
|
||||||
|
array->entries = Realloc(array->entries,
|
||||||
|
sizeof(void *) * array->size);
|
||||||
|
|
||||||
|
if (!array->entries)
|
||||||
|
{
|
||||||
|
array->entries = tmp;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
ArraySwap(Array * array, size_t i, size_t j)
|
||||||
|
{
|
||||||
|
void *p = array->entries[i];
|
||||||
|
|
||||||
|
array->entries[i] = array->entries[j];
|
||||||
|
array->entries[j] = p;
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t
|
||||||
|
ArrayPartition(Array * array, size_t low, size_t high, int (*compare) (void *, void *))
|
||||||
|
{
|
||||||
|
void *pivot = array->entries[high];
|
||||||
|
size_t i = low - 1;
|
||||||
|
size_t j;
|
||||||
|
|
||||||
|
for (j = low; j <= high - 1; j++)
|
||||||
|
{
|
||||||
|
if (compare(array->entries[j], pivot) < 0)
|
||||||
|
{
|
||||||
|
i++;
|
||||||
|
ArraySwap(array, i, j);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ArraySwap(array, i + 1, high);
|
||||||
|
return i + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
ArrayQuickSort(Array * array, size_t low, size_t high, int (*compare) (void *, void *))
|
||||||
|
{
|
||||||
|
if (low < high)
|
||||||
|
{
|
||||||
|
size_t pi = ArrayPartition(array, low, high, compare);
|
||||||
|
|
||||||
|
ArrayQuickSort(array, low, pi - 1, compare);
|
||||||
|
ArrayQuickSort(array, pi + 1, high, compare);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
ArraySort(Array * array, int (*compare) (void *, void *))
|
||||||
|
{
|
||||||
|
if (!array)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
ArrayQuickSort(array, 0, array->size, compare);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Even though the following operations could be done using only the
|
||||||
|
* public Array API defined above, I opted for low-level struct
|
||||||
|
* manipulation because it allows much more efficient copying; we only
|
||||||
|
* allocate what we for sure need upfront, and don't have to
|
||||||
|
* re-allocate during the operation. */
|
||||||
|
|
||||||
|
Array *
|
||||||
|
ArrayFromVarArgs(size_t n, va_list ap)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
Array *arr = Malloc(sizeof(Array));
|
||||||
|
|
||||||
|
if (!arr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
arr->size = n;
|
||||||
|
arr->allocated = n;
|
||||||
|
arr->entries = Malloc(sizeof(void *) * arr->allocated);
|
||||||
|
|
||||||
|
if (!arr->entries)
|
||||||
|
{
|
||||||
|
Free(arr);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < n; i++)
|
||||||
|
{
|
||||||
|
arr->entries[i] = va_arg(ap, void *);
|
||||||
|
}
|
||||||
|
|
||||||
|
return arr;
|
||||||
|
}
|
||||||
|
|
||||||
|
Array *
|
||||||
|
ArrayDuplicate(Array * arr)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
Array *arr2 = Malloc(sizeof(Array));
|
||||||
|
|
||||||
|
if (!arr2)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
arr2->size = arr->size;
|
||||||
|
arr2->allocated = arr->size;
|
||||||
|
arr2->entries = Malloc(sizeof(void *) * arr->allocated);
|
||||||
|
|
||||||
|
if (!arr2->entries)
|
||||||
|
{
|
||||||
|
Free(arr2);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < arr2->size; i++)
|
||||||
|
{
|
||||||
|
arr2->entries[i] = arr->entries[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
return arr2;
|
||||||
|
}
|
244
src/Base64.c
Normal file
244
src/Base64.c
Normal file
|
@ -0,0 +1,244 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Base64.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
static const char Base64EncodeMap[] =
|
||||||
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||||
|
|
||||||
|
static const int Base64DecodeMap[] = {
|
||||||
|
62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58,
|
||||||
|
59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5,
|
||||||
|
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
||||||
|
21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
|
||||||
|
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
|
||||||
|
43, 44, 45, 46, 47, 48, 49, 50, 51
|
||||||
|
};
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Base64EncodedSize(size_t inputSize)
|
||||||
|
{
|
||||||
|
size_t size = inputSize;
|
||||||
|
|
||||||
|
if (inputSize % 3)
|
||||||
|
{
|
||||||
|
size += 3 - (inputSize % 3);
|
||||||
|
}
|
||||||
|
|
||||||
|
size /= 3;
|
||||||
|
size *= 4;
|
||||||
|
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t
|
||||||
|
Base64DecodedSize(const char *base64, size_t len)
|
||||||
|
{
|
||||||
|
size_t ret;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (!base64)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = len / 4 * 3;
|
||||||
|
|
||||||
|
for (i = len; i > 0; i--)
|
||||||
|
{
|
||||||
|
if (base64[i] == '=')
|
||||||
|
{
|
||||||
|
ret--;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
Base64Encode(const char *input, size_t len)
|
||||||
|
{
|
||||||
|
char *out;
|
||||||
|
size_t outLen;
|
||||||
|
size_t i, j, v;
|
||||||
|
|
||||||
|
if (!input || !len)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
outLen = Base64EncodedSize(len);
|
||||||
|
out = Malloc(outLen + 1);
|
||||||
|
if (!out)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
out[outLen] = '\0';
|
||||||
|
|
||||||
|
for (i = 0, j = 0; i < len; i += 3, j += 4)
|
||||||
|
{
|
||||||
|
v = input[i];
|
||||||
|
v = i + 1 < len ? v << 8 | input[i + 1] : v << 8;
|
||||||
|
v = i + 2 < len ? v << 8 | input[i + 2] : v << 8;
|
||||||
|
|
||||||
|
out[j] = Base64EncodeMap[(v >> 18) & 0x3F];
|
||||||
|
out[j + 1] = Base64EncodeMap[(v >> 12) & 0x3F];
|
||||||
|
|
||||||
|
if (i + 1 < len)
|
||||||
|
{
|
||||||
|
out[j + 2] = Base64EncodeMap[(v >> 6) & 0x3F];
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
out[j + 2] = '=';
|
||||||
|
}
|
||||||
|
if (i + 2 < len)
|
||||||
|
{
|
||||||
|
out[j + 3] = Base64EncodeMap[v & 0x3F];
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
out[j + 3] = '=';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
Base64IsValidChar(char c)
|
||||||
|
{
|
||||||
|
return (c >= '0' && c <= '9') ||
|
||||||
|
(c >= 'A' && c <= 'Z') ||
|
||||||
|
(c >= 'a' && c <= 'z') ||
|
||||||
|
(c == '+') ||
|
||||||
|
(c == '/') ||
|
||||||
|
(c == '=');
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
Base64Decode(const char *input, size_t len)
|
||||||
|
{
|
||||||
|
size_t i, j;
|
||||||
|
int v;
|
||||||
|
size_t outLen;
|
||||||
|
char *out;
|
||||||
|
|
||||||
|
if (!input)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
outLen = Base64DecodedSize(input, len);
|
||||||
|
if (len % 4)
|
||||||
|
{
|
||||||
|
/* Invalid length; must have incorrect padding */
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Scan for invalid characters. */
|
||||||
|
for (i = 0; i < len; i++)
|
||||||
|
{
|
||||||
|
if (!Base64IsValidChar(input[i]))
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
out = Malloc(outLen + 1);
|
||||||
|
if (!out)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
out[outLen] = '\0';
|
||||||
|
|
||||||
|
for (i = 0, j = 0; i < len; i += 4, j += 3)
|
||||||
|
{
|
||||||
|
v = Base64DecodeMap[input[i] - 43];
|
||||||
|
v = (v << 6) | Base64DecodeMap[input[i + 1] - 43];
|
||||||
|
v = input[i + 2] == '=' ? v << 6 : (v << 6) | Base64DecodeMap[input[i + 2] - 43];
|
||||||
|
v = input[i + 3] == '=' ? v << 6 : (v << 6) | Base64DecodeMap[input[i + 3] - 43];
|
||||||
|
|
||||||
|
out[j] = (v >> 16) & 0xFF;
|
||||||
|
if (input[i + 2] != '=')
|
||||||
|
out[j + 1] = (v >> 8) & 0xFF;
|
||||||
|
if (input[i + 3] != '=')
|
||||||
|
out[j + 2] = v & 0xFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern void
|
||||||
|
Base64Unpad(char *base64, size_t length)
|
||||||
|
{
|
||||||
|
if (!base64)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (base64[length - 1] == '=')
|
||||||
|
{
|
||||||
|
length--;
|
||||||
|
}
|
||||||
|
|
||||||
|
base64[length] = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
extern int
|
||||||
|
Base64Pad(char **base64Ptr, size_t length)
|
||||||
|
{
|
||||||
|
char *tmp;
|
||||||
|
size_t newSize;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (length % 4 == 0)
|
||||||
|
{
|
||||||
|
return length; /* Success: no padding needed */
|
||||||
|
}
|
||||||
|
|
||||||
|
newSize = length + (4 - (length % 4));
|
||||||
|
|
||||||
|
tmp = Realloc(*base64Ptr, newSize + 100);;
|
||||||
|
if (!tmp)
|
||||||
|
{
|
||||||
|
return 0; /* Memory error */
|
||||||
|
}
|
||||||
|
*base64Ptr = tmp;
|
||||||
|
|
||||||
|
for (i = length; i < newSize; i++)
|
||||||
|
{
|
||||||
|
(*base64Ptr)[i] = '=';
|
||||||
|
}
|
||||||
|
|
||||||
|
(*base64Ptr)[newSize] = '\0';
|
||||||
|
|
||||||
|
return newSize;
|
||||||
|
}
|
249
src/Cron.c
Normal file
249
src/Cron.c
Normal file
|
@ -0,0 +1,249 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Cron.h>
|
||||||
|
|
||||||
|
#include <Array.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Util.h>
|
||||||
|
|
||||||
|
#include <pthread.h>
|
||||||
|
|
||||||
|
struct Cron
|
||||||
|
{
|
||||||
|
unsigned long tick;
|
||||||
|
Array *jobs;
|
||||||
|
pthread_mutex_t lock;
|
||||||
|
volatile unsigned int stop:1;
|
||||||
|
pthread_t thread;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct Job
|
||||||
|
{
|
||||||
|
unsigned long interval;
|
||||||
|
unsigned long lastExec;
|
||||||
|
JobFunc *func;
|
||||||
|
void *args;
|
||||||
|
} Job;
|
||||||
|
|
||||||
|
static Job *
|
||||||
|
JobCreate(long interval, JobFunc * func, void *args)
|
||||||
|
{
|
||||||
|
Job *job;
|
||||||
|
|
||||||
|
if (!func)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
job = Malloc(sizeof(Job));
|
||||||
|
if (!job)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
job->interval = interval;
|
||||||
|
job->lastExec = 0;
|
||||||
|
job->func = func;
|
||||||
|
job->args = args;
|
||||||
|
|
||||||
|
return job;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void *
|
||||||
|
CronThread(void *args)
|
||||||
|
{
|
||||||
|
Cron *cron = args;
|
||||||
|
|
||||||
|
while (!cron->stop)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
unsigned long ts; /* tick start */
|
||||||
|
unsigned long te; /* tick end */
|
||||||
|
|
||||||
|
pthread_mutex_lock(&cron->lock);
|
||||||
|
|
||||||
|
ts = UtilServerTs();
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(cron->jobs); i++)
|
||||||
|
{
|
||||||
|
Job *job = ArrayGet(cron->jobs, i);
|
||||||
|
|
||||||
|
if (ts - job->lastExec > job->interval)
|
||||||
|
{
|
||||||
|
job->func(job->args);
|
||||||
|
job->lastExec = ts;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!job->interval)
|
||||||
|
{
|
||||||
|
ArrayDelete(cron->jobs, i);
|
||||||
|
Free(job);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
te = UtilServerTs();
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&cron->lock);
|
||||||
|
|
||||||
|
/* Only sleep if the jobs didn't overrun the tick */
|
||||||
|
if (cron->tick > (te - ts))
|
||||||
|
{
|
||||||
|
const unsigned long microTick = 100;
|
||||||
|
unsigned long remainingTick = cron->tick - (te - ts);
|
||||||
|
|
||||||
|
/* Only sleep for microTick ms at a time because if the job
|
||||||
|
* scheduler is supposed to stop before the tick is up, we
|
||||||
|
* don't want to be stuck in a long sleep */
|
||||||
|
while (remainingTick >= microTick && !cron->stop)
|
||||||
|
{
|
||||||
|
UtilSleepMillis(microTick);
|
||||||
|
remainingTick -= microTick;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (remainingTick && !cron->stop)
|
||||||
|
{
|
||||||
|
UtilSleepMillis(remainingTick);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
Cron *
|
||||||
|
CronCreate(unsigned long tick)
|
||||||
|
{
|
||||||
|
Cron *cron = Malloc(sizeof(Cron));
|
||||||
|
|
||||||
|
if (!cron)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
cron->jobs = ArrayCreate();
|
||||||
|
if (!cron->jobs)
|
||||||
|
{
|
||||||
|
Free(cron);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
cron->tick = tick;
|
||||||
|
cron->stop = 1;
|
||||||
|
|
||||||
|
pthread_mutex_init(&cron->lock, NULL);
|
||||||
|
|
||||||
|
return cron;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CronOnce(Cron * cron, JobFunc * func, void *args)
|
||||||
|
{
|
||||||
|
Job *job;
|
||||||
|
|
||||||
|
if (!cron || !func)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
job = JobCreate(0, func, args);
|
||||||
|
if (!job)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&cron->lock);
|
||||||
|
ArrayAdd(cron->jobs, job);
|
||||||
|
pthread_mutex_unlock(&cron->lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CronEvery(Cron * cron, unsigned long interval, JobFunc * func, void *args)
|
||||||
|
{
|
||||||
|
Job *job;
|
||||||
|
|
||||||
|
if (!cron || !func)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
job = JobCreate(interval, func, args);
|
||||||
|
if (!job)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&cron->lock);
|
||||||
|
ArrayAdd(cron->jobs, job);
|
||||||
|
pthread_mutex_unlock(&cron->lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CronStart(Cron * cron)
|
||||||
|
{
|
||||||
|
if (!cron || !cron->stop)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
cron->stop = 0;
|
||||||
|
|
||||||
|
pthread_create(&cron->thread, NULL, CronThread, cron);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CronStop(Cron * cron)
|
||||||
|
{
|
||||||
|
if (!cron || cron->stop)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
cron->stop = 1;
|
||||||
|
|
||||||
|
pthread_join(cron->thread, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
CronFree(Cron * cron)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (!cron)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
CronStop(cron);
|
||||||
|
|
||||||
|
pthread_mutex_lock(&cron->lock);
|
||||||
|
for (i = 0; i < ArraySize(cron->jobs); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(cron->jobs, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(cron->jobs);
|
||||||
|
pthread_mutex_unlock(&cron->lock);
|
||||||
|
pthread_mutex_destroy(&cron->lock);
|
||||||
|
|
||||||
|
Free(cron);
|
||||||
|
}
|
968
src/Db.c
Normal file
968
src/Db.c
Normal file
|
@ -0,0 +1,968 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Db.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Json.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Str.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
#include <Log.h>
|
||||||
|
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <dirent.h>
|
||||||
|
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
#include <errno.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
struct Db
|
||||||
|
{
|
||||||
|
char *dir;
|
||||||
|
pthread_mutex_t lock;
|
||||||
|
|
||||||
|
size_t cacheSize;
|
||||||
|
size_t maxCache;
|
||||||
|
HashMap *cache;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The cache uses a double linked list (see DbRef
|
||||||
|
* below) to know which objects are most and least
|
||||||
|
* recently used. The following diagram helps me
|
||||||
|
* know what way all the pointers go, because it
|
||||||
|
* can get very confusing sometimes. For example,
|
||||||
|
* there's nothing stopping "next" from pointing to
|
||||||
|
* least recent, and "prev" from pointing to most
|
||||||
|
* recent, so hopefully this clarifies the pointer
|
||||||
|
* terminology used when dealing with the linked
|
||||||
|
* list:
|
||||||
|
*
|
||||||
|
* mostRecent leastRecent
|
||||||
|
* | prev prev | prev
|
||||||
|
* +---+ ---> +---+ ---> +---+ ---> NULL
|
||||||
|
* |ref| |ref| |ref|
|
||||||
|
* NULL <--- +---+ <--- +---+ <--- +---+
|
||||||
|
* next next next
|
||||||
|
*/
|
||||||
|
DbRef *mostRecent;
|
||||||
|
DbRef *leastRecent;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct DbRef
|
||||||
|
{
|
||||||
|
HashMap *json;
|
||||||
|
|
||||||
|
unsigned long ts;
|
||||||
|
size_t size;
|
||||||
|
|
||||||
|
Array *name;
|
||||||
|
|
||||||
|
DbRef *prev;
|
||||||
|
DbRef *next;
|
||||||
|
|
||||||
|
int fd;
|
||||||
|
Stream *stream;
|
||||||
|
};
|
||||||
|
|
||||||
|
static void
|
||||||
|
StringArrayFree(Array * arr)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(arr); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(arr, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(arr);
|
||||||
|
}
|
||||||
|
|
||||||
|
static ssize_t DbComputeSize(HashMap *);
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
DbComputeSizeOfValue(JsonValue * val)
|
||||||
|
{
|
||||||
|
MemoryInfo *a;
|
||||||
|
ssize_t total = 0;
|
||||||
|
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
union
|
||||||
|
{
|
||||||
|
char *str;
|
||||||
|
Array *arr;
|
||||||
|
} u;
|
||||||
|
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
a = MemoryInfoGet(val);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
total += MemoryInfoGetSize(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (JsonValueType(val))
|
||||||
|
{
|
||||||
|
case JSON_OBJECT:
|
||||||
|
total += DbComputeSize(JsonValueAsObject(val));
|
||||||
|
break;
|
||||||
|
case JSON_ARRAY:
|
||||||
|
u.arr = JsonValueAsArray(val);
|
||||||
|
a = MemoryInfoGet(u.arr);
|
||||||
|
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
total += MemoryInfoGetSize(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(u.arr); i++)
|
||||||
|
{
|
||||||
|
total += DbComputeSizeOfValue(ArrayGet(u.arr, i));
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case JSON_STRING:
|
||||||
|
u.str = JsonValueAsString(val);
|
||||||
|
a = MemoryInfoGet(u.str);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
total += MemoryInfoGetSize(a);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case JSON_NULL:
|
||||||
|
case JSON_INTEGER:
|
||||||
|
case JSON_FLOAT:
|
||||||
|
case JSON_BOOLEAN:
|
||||||
|
default:
|
||||||
|
/* These don't use any extra heap space */
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
DbComputeSize(HashMap * json)
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
JsonValue *val;
|
||||||
|
MemoryInfo *a;
|
||||||
|
size_t total;
|
||||||
|
|
||||||
|
if (!json)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
total = 0;
|
||||||
|
|
||||||
|
a = MemoryInfoGet(json);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
total += MemoryInfoGetSize(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(json, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
a = MemoryInfoGet(key);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
total += MemoryInfoGetSize(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
total += DbComputeSizeOfValue(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
DbHashKey(Array * args)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
char *str = NULL;
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(args); i++)
|
||||||
|
{
|
||||||
|
char *tmp = StrConcat(2, str, ArrayGet(args, i));
|
||||||
|
|
||||||
|
Free(str);
|
||||||
|
str = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
DbDirName(Db * db, Array * args, size_t strip)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
char *str = StrConcat(2, db->dir, "/");
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(args) - strip; i++)
|
||||||
|
{
|
||||||
|
char *tmp;
|
||||||
|
|
||||||
|
tmp = StrConcat(3, str, ArrayGet(args, i), "/");
|
||||||
|
|
||||||
|
Free(str);
|
||||||
|
|
||||||
|
str = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
DbFileName(Db * db, Array * args)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
char *str = StrConcat(2, db->dir, "/");
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(args); i++)
|
||||||
|
{
|
||||||
|
char *tmp;
|
||||||
|
char *arg = StrDuplicate(ArrayGet(args, i));
|
||||||
|
size_t j = 0;
|
||||||
|
|
||||||
|
/* Sanitize name to prevent directory traversal attacks */
|
||||||
|
while (arg[j])
|
||||||
|
{
|
||||||
|
switch (arg[j])
|
||||||
|
{
|
||||||
|
case '/':
|
||||||
|
arg[j] = '_';
|
||||||
|
break;
|
||||||
|
case '.':
|
||||||
|
arg[j] = '-';
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = StrConcat(3, str, arg,
|
||||||
|
(i < ArraySize(args) - 1) ? "/" : ".json");
|
||||||
|
|
||||||
|
Free(arg);
|
||||||
|
Free(str);
|
||||||
|
|
||||||
|
str = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
DbCacheEvict(Db * db)
|
||||||
|
{
|
||||||
|
DbRef *ref = db->leastRecent;
|
||||||
|
DbRef *tmp;
|
||||||
|
|
||||||
|
while (ref && db->cacheSize > db->maxCache)
|
||||||
|
{
|
||||||
|
char *hash;
|
||||||
|
|
||||||
|
JsonFree(ref->json);
|
||||||
|
|
||||||
|
hash = DbHashKey(ref->name);
|
||||||
|
HashMapDelete(db->cache, hash);
|
||||||
|
Free(hash);
|
||||||
|
|
||||||
|
StringArrayFree(ref->name);
|
||||||
|
|
||||||
|
db->cacheSize -= ref->size;
|
||||||
|
|
||||||
|
if (ref->next)
|
||||||
|
{
|
||||||
|
ref->next->prev = ref->prev;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->mostRecent = ref->prev;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ref->prev)
|
||||||
|
{
|
||||||
|
ref->prev->next = ref->next;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->leastRecent = ref->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = ref->next;
|
||||||
|
Free(ref);
|
||||||
|
|
||||||
|
ref = tmp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Db *
|
||||||
|
DbOpen(char *dir, size_t cache)
|
||||||
|
{
|
||||||
|
Db *db;
|
||||||
|
pthread_mutexattr_t attr;
|
||||||
|
|
||||||
|
if (!dir)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
db = Malloc(sizeof(Db));
|
||||||
|
if (!db)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
db->dir = dir;
|
||||||
|
db->maxCache = cache;
|
||||||
|
|
||||||
|
pthread_mutexattr_init(&attr);
|
||||||
|
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||||
|
pthread_mutex_init(&db->lock, &attr);
|
||||||
|
pthread_mutexattr_destroy(&attr);
|
||||||
|
|
||||||
|
db->mostRecent = NULL;
|
||||||
|
db->leastRecent = NULL;
|
||||||
|
db->cacheSize = 0;
|
||||||
|
|
||||||
|
if (db->maxCache)
|
||||||
|
{
|
||||||
|
db->cache = HashMapCreate();
|
||||||
|
if (!db->cache)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->cache = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return db;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DbMaxCacheSet(Db * db, size_t cache)
|
||||||
|
{
|
||||||
|
if (!db)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
db->maxCache = cache;
|
||||||
|
if (db->maxCache && !db->cache)
|
||||||
|
{
|
||||||
|
db->cache = HashMapCreate();
|
||||||
|
db->cacheSize = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
DbCacheEvict(db);
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DbClose(Db * db)
|
||||||
|
{
|
||||||
|
if (!db)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
DbMaxCacheSet(db, 0);
|
||||||
|
DbCacheEvict(db);
|
||||||
|
HashMapFree(db->cache);
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
pthread_mutex_destroy(&db->lock);
|
||||||
|
|
||||||
|
Free(db);
|
||||||
|
}
|
||||||
|
|
||||||
|
static DbRef *
|
||||||
|
DbLockFromArr(Db * db, Array * args)
|
||||||
|
{
|
||||||
|
char *file;
|
||||||
|
char *hash;
|
||||||
|
DbRef *ref;
|
||||||
|
struct flock lock;
|
||||||
|
|
||||||
|
int fd;
|
||||||
|
Stream *stream;
|
||||||
|
|
||||||
|
if (!db || !args)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
ref = NULL;
|
||||||
|
hash = NULL;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
/* Check if the item is in the cache */
|
||||||
|
hash = DbHashKey(args);
|
||||||
|
ref = HashMapGet(db->cache, hash);
|
||||||
|
file = DbFileName(db, args);
|
||||||
|
|
||||||
|
fd = open(file, O_RDWR);
|
||||||
|
if (fd == -1)
|
||||||
|
{
|
||||||
|
if (ref)
|
||||||
|
{
|
||||||
|
HashMapDelete(db->cache, hash);
|
||||||
|
JsonFree(ref->json);
|
||||||
|
StringArrayFree(ref->name);
|
||||||
|
|
||||||
|
db->cacheSize -= ref->size;
|
||||||
|
|
||||||
|
if (ref->next)
|
||||||
|
{
|
||||||
|
ref->next->prev = ref->prev;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->mostRecent = ref->prev;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ref->prev)
|
||||||
|
{
|
||||||
|
ref->prev->next = ref->next;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->leastRecent = ref->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!db->leastRecent)
|
||||||
|
{
|
||||||
|
db->leastRecent = db->mostRecent;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(ref);
|
||||||
|
}
|
||||||
|
ref = NULL;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream = StreamFd(fd);
|
||||||
|
|
||||||
|
lock.l_start = 0;
|
||||||
|
lock.l_len = 0;
|
||||||
|
lock.l_type = F_WRLCK;
|
||||||
|
lock.l_whence = SEEK_SET;
|
||||||
|
|
||||||
|
/* Lock the file on the disk */
|
||||||
|
if (fcntl(fd, F_SETLK, &lock) < 0)
|
||||||
|
{
|
||||||
|
StreamClose(stream);
|
||||||
|
ref = NULL;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ref) /* In cache */
|
||||||
|
{
|
||||||
|
unsigned long diskTs = UtilLastModified(file);
|
||||||
|
|
||||||
|
ref->fd = fd;
|
||||||
|
ref->stream = stream;
|
||||||
|
|
||||||
|
if (diskTs > ref->ts)
|
||||||
|
{
|
||||||
|
/* File was modified on disk since it was cached */
|
||||||
|
HashMap *json = JsonDecode(ref->stream);
|
||||||
|
|
||||||
|
if (!json)
|
||||||
|
{
|
||||||
|
StreamClose(ref->stream);
|
||||||
|
ref = NULL;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
JsonFree(ref->json);
|
||||||
|
ref->json = json;
|
||||||
|
ref->ts = diskTs;
|
||||||
|
ref->size = DbComputeSize(ref->json);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Float this ref to mostRecent */
|
||||||
|
if (ref->next)
|
||||||
|
{
|
||||||
|
ref->next->prev = ref->prev;
|
||||||
|
|
||||||
|
if (!ref->prev)
|
||||||
|
{
|
||||||
|
db->leastRecent = ref->next;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ref->prev->next = ref->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
ref->prev = db->mostRecent;
|
||||||
|
ref->next = NULL;
|
||||||
|
if (db->mostRecent)
|
||||||
|
{
|
||||||
|
db->mostRecent->next = ref;
|
||||||
|
}
|
||||||
|
db->mostRecent = ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If there is no least recent, this is the only thing in the
|
||||||
|
* cache, so it is also least recent. */
|
||||||
|
if (!db->leastRecent)
|
||||||
|
{
|
||||||
|
db->leastRecent = ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The file on disk may be larger than what we have in memory,
|
||||||
|
* which may require items in cache to be evicted. */
|
||||||
|
DbCacheEvict(db);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Array *name;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
/* Not in cache; load from disk */
|
||||||
|
|
||||||
|
ref = Malloc(sizeof(DbRef));
|
||||||
|
if (!ref)
|
||||||
|
{
|
||||||
|
StreamClose(stream);
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
ref->json = JsonDecode(stream);
|
||||||
|
|
||||||
|
if (!ref->json)
|
||||||
|
{
|
||||||
|
Free(ref);
|
||||||
|
StreamClose(stream);
|
||||||
|
ref = NULL;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
ref->fd = fd;
|
||||||
|
ref->stream = stream;
|
||||||
|
|
||||||
|
name = ArrayCreate();
|
||||||
|
for (i = 0; i < ArraySize(args); i++)
|
||||||
|
{
|
||||||
|
ArrayAdd(name, StrDuplicate(ArrayGet(args, i)));
|
||||||
|
}
|
||||||
|
ref->name = name;
|
||||||
|
|
||||||
|
if (db->cache)
|
||||||
|
{
|
||||||
|
ref->ts = UtilServerTs();
|
||||||
|
ref->size = DbComputeSize(ref->json);
|
||||||
|
HashMapSet(db->cache, hash, ref);
|
||||||
|
db->cacheSize += ref->size;
|
||||||
|
|
||||||
|
ref->next = NULL;
|
||||||
|
ref->prev = db->mostRecent;
|
||||||
|
if (db->mostRecent)
|
||||||
|
{
|
||||||
|
db->mostRecent->next = ref;
|
||||||
|
}
|
||||||
|
db->mostRecent = ref;
|
||||||
|
|
||||||
|
if (!db->leastRecent)
|
||||||
|
{
|
||||||
|
db->leastRecent = ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Adding this item to the cache may case it to grow too
|
||||||
|
* large, requiring some items to be evicted */
|
||||||
|
DbCacheEvict(db);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
finish:
|
||||||
|
if (!ref)
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(file);
|
||||||
|
Free(hash);
|
||||||
|
|
||||||
|
return ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
DbRef *
|
||||||
|
DbCreate(Db * db, size_t nArgs,...)
|
||||||
|
{
|
||||||
|
Stream *fp;
|
||||||
|
char *file;
|
||||||
|
char *dir;
|
||||||
|
va_list ap;
|
||||||
|
Array *args;
|
||||||
|
DbRef *ret;
|
||||||
|
|
||||||
|
if (!db)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
va_start(ap, nArgs);
|
||||||
|
args = ArrayFromVarArgs(nArgs, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
if (!args)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
file = DbFileName(db, args);
|
||||||
|
|
||||||
|
if (UtilLastModified(file))
|
||||||
|
{
|
||||||
|
Free(file);
|
||||||
|
ArrayFree(args);
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
dir = DbDirName(db, args, 1);
|
||||||
|
if (UtilMkdir(dir, 0750) < 0)
|
||||||
|
{
|
||||||
|
Free(file);
|
||||||
|
ArrayFree(args);
|
||||||
|
Free(dir);
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(dir);
|
||||||
|
|
||||||
|
fp = StreamOpen(file, "w");
|
||||||
|
Free(file);
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
ArrayFree(args);
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPuts(fp, "{}");
|
||||||
|
StreamClose(fp);
|
||||||
|
|
||||||
|
/* DbLockFromArr() will lock again for us */
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
|
||||||
|
ret = DbLockFromArr(db, args);
|
||||||
|
|
||||||
|
ArrayFree(args);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
DbDelete(Db * db, size_t nArgs,...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
Array *args;
|
||||||
|
char *file;
|
||||||
|
char *hash;
|
||||||
|
int ret = 1;
|
||||||
|
DbRef *ref;
|
||||||
|
|
||||||
|
if (!db)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
va_start(ap, nArgs);
|
||||||
|
args = ArrayFromVarArgs(nArgs, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
hash = DbHashKey(args);
|
||||||
|
file = DbFileName(db, args);
|
||||||
|
|
||||||
|
ref = HashMapGet(db->cache, hash);
|
||||||
|
if (ref)
|
||||||
|
{
|
||||||
|
HashMapDelete(db->cache, hash);
|
||||||
|
JsonFree(ref->json);
|
||||||
|
StringArrayFree(ref->name);
|
||||||
|
|
||||||
|
db->cacheSize -= ref->size;
|
||||||
|
|
||||||
|
if (ref->next)
|
||||||
|
{
|
||||||
|
ref->next->prev = ref->prev;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->mostRecent = ref->prev;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ref->prev)
|
||||||
|
{
|
||||||
|
ref->prev->next = ref->next;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
db->leastRecent = ref->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!db->leastRecent)
|
||||||
|
{
|
||||||
|
db->leastRecent = db->mostRecent;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(ref);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(hash);
|
||||||
|
|
||||||
|
if (UtilLastModified(file))
|
||||||
|
{
|
||||||
|
ret = remove(file) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
|
||||||
|
ArrayFree(args);
|
||||||
|
Free(file);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
DbRef *
|
||||||
|
DbLock(Db * db, size_t nArgs,...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
Array *args;
|
||||||
|
DbRef *ret;
|
||||||
|
|
||||||
|
va_start(ap, nArgs);
|
||||||
|
args = ArrayFromVarArgs(nArgs, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
if (!args)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = DbLockFromArr(db, args);
|
||||||
|
|
||||||
|
ArrayFree(args);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
DbUnlock(Db * db, DbRef * ref)
|
||||||
|
{
|
||||||
|
int destroy;
|
||||||
|
|
||||||
|
if (!db || !ref)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
lseek(ref->fd, 0L, SEEK_SET);
|
||||||
|
if (ftruncate(ref->fd, 0) < 0)
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
Log(LOG_ERR, "Failed to truncate file on disk.");
|
||||||
|
Log(LOG_ERR, "Error on fd %d: %s", ref->fd, strerror(errno));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
JsonEncode(ref->json, ref->stream, JSON_DEFAULT);
|
||||||
|
StreamClose(ref->stream);
|
||||||
|
|
||||||
|
if (db->cache)
|
||||||
|
{
|
||||||
|
char *key = DbHashKey(ref->name);
|
||||||
|
|
||||||
|
if (HashMapGet(db->cache, key))
|
||||||
|
{
|
||||||
|
db->cacheSize -= ref->size;
|
||||||
|
ref->size = DbComputeSize(ref->json);
|
||||||
|
db->cacheSize += ref->size;
|
||||||
|
|
||||||
|
/* If this ref has grown significantly since we last
|
||||||
|
* computed its size, it may have filled the cache and
|
||||||
|
* require some items to be evicted. */
|
||||||
|
DbCacheEvict(db);
|
||||||
|
|
||||||
|
destroy = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
destroy = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(key);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
destroy = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (destroy)
|
||||||
|
{
|
||||||
|
JsonFree(ref->json);
|
||||||
|
StringArrayFree(ref->name);
|
||||||
|
|
||||||
|
Free(ref);
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
DbExists(Db * db, size_t nArgs,...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
Array *args;
|
||||||
|
char *file;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
va_start(ap, nArgs);
|
||||||
|
args = ArrayFromVarArgs(nArgs, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
if (!args)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
file = DbFileName(db, args);
|
||||||
|
ret = UtilLastModified(file);
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
|
||||||
|
Free(file);
|
||||||
|
ArrayFree(args);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
Array *
|
||||||
|
DbList(Db * db, size_t nArgs,...)
|
||||||
|
{
|
||||||
|
Array *result;
|
||||||
|
Array *path;
|
||||||
|
DIR *files;
|
||||||
|
struct dirent *file;
|
||||||
|
char *dir;
|
||||||
|
va_list ap;
|
||||||
|
|
||||||
|
if (!db || !nArgs)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = ArrayCreate();
|
||||||
|
if (!result)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
va_start(ap, nArgs);
|
||||||
|
path = ArrayFromVarArgs(nArgs, ap);
|
||||||
|
dir = DbDirName(db, path, 0);
|
||||||
|
|
||||||
|
pthread_mutex_lock(&db->lock);
|
||||||
|
|
||||||
|
files = opendir(dir);
|
||||||
|
if (!files)
|
||||||
|
{
|
||||||
|
ArrayFree(path);
|
||||||
|
ArrayFree(result);
|
||||||
|
Free(dir);
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
while ((file = readdir(files)))
|
||||||
|
{
|
||||||
|
size_t namlen = strlen(file->d_name);
|
||||||
|
|
||||||
|
if (namlen > 5)
|
||||||
|
{
|
||||||
|
int nameOffset = namlen - 5;
|
||||||
|
|
||||||
|
if (StrEquals(file->d_name + nameOffset, ".json"))
|
||||||
|
{
|
||||||
|
file->d_name[nameOffset] = '\0';
|
||||||
|
ArrayAdd(result, StrDuplicate(file->d_name));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
closedir(files);
|
||||||
|
|
||||||
|
ArrayFree(path);
|
||||||
|
Free(dir);
|
||||||
|
pthread_mutex_unlock(&db->lock);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DbListFree(Array * arr)
|
||||||
|
{
|
||||||
|
StringArrayFree(arr);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
DbJson(DbRef * ref)
|
||||||
|
{
|
||||||
|
return ref ? ref->json : NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
DbJsonSet(DbRef * ref, HashMap * json)
|
||||||
|
{
|
||||||
|
if (!ref || !json)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
JsonFree(ref->json);
|
||||||
|
ref->json = JsonDuplicate(json);
|
||||||
|
return 1;
|
||||||
|
}
|
401
src/HashMap.c
Normal file
401
src/HashMap.c
Normal file
|
@ -0,0 +1,401 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HashMap.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
typedef struct HashMapBucket
|
||||||
|
{
|
||||||
|
unsigned long hash;
|
||||||
|
char *key;
|
||||||
|
void *value;
|
||||||
|
} HashMapBucket;
|
||||||
|
|
||||||
|
struct HashMap
|
||||||
|
{
|
||||||
|
size_t count;
|
||||||
|
size_t capacity;
|
||||||
|
HashMapBucket **entries;
|
||||||
|
|
||||||
|
unsigned long (*hashFunc) (const char *);
|
||||||
|
|
||||||
|
float maxLoad;
|
||||||
|
size_t iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
static unsigned long
|
||||||
|
HashMapHashKey(const char *key)
|
||||||
|
{
|
||||||
|
unsigned long hash = 2166136261u;
|
||||||
|
size_t i = 0;
|
||||||
|
|
||||||
|
while (key[i])
|
||||||
|
{
|
||||||
|
hash ^= (unsigned char) key[i];
|
||||||
|
hash *= 16777619;
|
||||||
|
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return hash;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
HashMapGrow(HashMap * map)
|
||||||
|
{
|
||||||
|
size_t oldCapacity;
|
||||||
|
size_t i;
|
||||||
|
HashMapBucket **newEntries;
|
||||||
|
|
||||||
|
if (!map)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
oldCapacity = map->capacity;
|
||||||
|
map->capacity *= 2;
|
||||||
|
|
||||||
|
newEntries = Malloc(map->capacity * sizeof(HashMapBucket *));
|
||||||
|
if (!newEntries)
|
||||||
|
{
|
||||||
|
map->capacity /= 2;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(newEntries, 0, map->capacity * sizeof(HashMapBucket *));
|
||||||
|
|
||||||
|
for (i = 0; i < oldCapacity; i++)
|
||||||
|
{
|
||||||
|
/* If there is a value here, and it isn't a tombstone */
|
||||||
|
if (map->entries[i] && map->entries[i]->hash)
|
||||||
|
{
|
||||||
|
/* Copy it to the new entries array */
|
||||||
|
size_t index = map->entries[i]->hash % map->capacity;
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
if (newEntries[index])
|
||||||
|
{
|
||||||
|
if (!newEntries[index]->hash)
|
||||||
|
{
|
||||||
|
Free(newEntries[index]);
|
||||||
|
newEntries[index] = map->entries[i];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
newEntries[index] = map->entries[i];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
index = (index + 1) % map->capacity;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Either NULL or a tombstone */
|
||||||
|
Free(map->entries[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(map->entries);
|
||||||
|
map->entries = newEntries;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HashMapCreate(void)
|
||||||
|
{
|
||||||
|
HashMap *map = Malloc(sizeof(HashMap));
|
||||||
|
|
||||||
|
if (!map)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
map->maxLoad = 0.75;
|
||||||
|
map->count = 0;
|
||||||
|
map->capacity = 16;
|
||||||
|
map->iterator = 0;
|
||||||
|
map->hashFunc = HashMapHashKey;
|
||||||
|
|
||||||
|
map->entries = Malloc(map->capacity * sizeof(HashMapBucket *));
|
||||||
|
if (!map->entries)
|
||||||
|
{
|
||||||
|
Free(map);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(map->entries, 0, map->capacity * sizeof(HashMapBucket *));
|
||||||
|
|
||||||
|
return map;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
HashMapDelete(HashMap * map, const char *key)
|
||||||
|
{
|
||||||
|
unsigned long hash;
|
||||||
|
size_t index;
|
||||||
|
|
||||||
|
if (!map || !key)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
hash = map->hashFunc(key);
|
||||||
|
index = hash % map->capacity;
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
HashMapBucket *bucket = map->entries[index];
|
||||||
|
|
||||||
|
if (!bucket)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bucket->hash == hash)
|
||||||
|
{
|
||||||
|
bucket->hash = 0;
|
||||||
|
return bucket->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
index = (index + 1) % map->capacity;
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HashMapFree(HashMap * map)
|
||||||
|
{
|
||||||
|
if (map)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
for (i = 0; i < map->capacity; i++)
|
||||||
|
{
|
||||||
|
if (map->entries[i])
|
||||||
|
{
|
||||||
|
Free(map->entries[i]->key);
|
||||||
|
Free(map->entries[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Free(map->entries);
|
||||||
|
Free(map);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
HashMapGet(HashMap * map, const char *key)
|
||||||
|
{
|
||||||
|
unsigned long hash;
|
||||||
|
size_t index;
|
||||||
|
|
||||||
|
if (!map || !key)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
hash = map->hashFunc(key);
|
||||||
|
index = hash % map->capacity;
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
HashMapBucket *bucket = map->entries[index];
|
||||||
|
|
||||||
|
if (!bucket)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bucket->hash == hash)
|
||||||
|
{
|
||||||
|
return bucket->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
index = (index + 1) % map->capacity;
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
HashMapIterateReentrant(HashMap * map, char **key, void **value, size_t * i)
|
||||||
|
{
|
||||||
|
if (!map)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*i >= map->capacity)
|
||||||
|
{
|
||||||
|
*i = 0;
|
||||||
|
*key = NULL;
|
||||||
|
*value = NULL;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*i < map->capacity)
|
||||||
|
{
|
||||||
|
HashMapBucket *bucket = map->entries[*i];
|
||||||
|
|
||||||
|
*i = *i + 1;
|
||||||
|
|
||||||
|
if (bucket && bucket->hash)
|
||||||
|
{
|
||||||
|
*key = bucket->key;
|
||||||
|
*value = bucket->value;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*i = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
HashMapIterate(HashMap * map, char **key, void **value)
|
||||||
|
{
|
||||||
|
if (!map)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return HashMapIterateReentrant(map, key, value, &map->iterator);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HashMapMaxLoadSet(HashMap * map, float load)
|
||||||
|
{
|
||||||
|
if (!map || (load > 1.0 || load <= 0))
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
map->maxLoad = load;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HashMapFunctionSet(HashMap * map, unsigned long (*hashFunc) (const char *))
|
||||||
|
{
|
||||||
|
if (!map || !hashFunc)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
map->hashFunc = hashFunc;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
HashMapSet(HashMap * map, char *key, void *value)
|
||||||
|
{
|
||||||
|
unsigned long hash;
|
||||||
|
size_t index;
|
||||||
|
|
||||||
|
if (!map || !key || !value)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
key = StrDuplicate(key);
|
||||||
|
if (!key)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (map->count + 1 > map->capacity * map->maxLoad)
|
||||||
|
{
|
||||||
|
HashMapGrow(map);
|
||||||
|
}
|
||||||
|
|
||||||
|
hash = map->hashFunc(key);
|
||||||
|
index = hash % map->capacity;
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
HashMapBucket *bucket = map->entries[index];
|
||||||
|
|
||||||
|
if (!bucket)
|
||||||
|
{
|
||||||
|
bucket = Malloc(sizeof(HashMapBucket));
|
||||||
|
if (!bucket)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
bucket->hash = hash;
|
||||||
|
bucket->key = key;
|
||||||
|
bucket->value = value;
|
||||||
|
map->entries[index] = bucket;
|
||||||
|
map->count++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!bucket->hash)
|
||||||
|
{
|
||||||
|
bucket->hash = hash;
|
||||||
|
Free(bucket->key);
|
||||||
|
bucket->key = key;
|
||||||
|
bucket->value = value;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bucket->hash == hash)
|
||||||
|
{
|
||||||
|
void *oldValue = bucket->value;
|
||||||
|
|
||||||
|
Free(bucket->key);
|
||||||
|
bucket->key = key;
|
||||||
|
|
||||||
|
bucket->value = value;
|
||||||
|
return oldValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
index = (index + 1) % map->capacity;
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HashMapIterateFree(char *key, void *value)
|
||||||
|
{
|
||||||
|
if (key)
|
||||||
|
{
|
||||||
|
Free(key);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (value)
|
||||||
|
{
|
||||||
|
Free(value);
|
||||||
|
}
|
||||||
|
}
|
664
src/HeaderParser.c
Normal file
664
src/HeaderParser.c
Normal file
|
@ -0,0 +1,664 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HeaderParser.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
static int
|
||||||
|
HeaderConsumeWhitespace(HeaderExpr * expr)
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_EOF;
|
||||||
|
expr->data.error.msg = "End of stream reached.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isspace(c))
|
||||||
|
{
|
||||||
|
if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
HeaderConsumeWord(HeaderExpr * expr)
|
||||||
|
{
|
||||||
|
char *str = Malloc(16 * sizeof(char));
|
||||||
|
int len = 16;
|
||||||
|
int i;
|
||||||
|
int c;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (!isspace(c = StreamGetc(expr->state.stream)))
|
||||||
|
{
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len *= 2;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len++;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = '\0';
|
||||||
|
|
||||||
|
if (c != EOF)
|
||||||
|
{
|
||||||
|
StreamUngetc(expr->state.stream, c);
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
HeaderConsumeAlnum(HeaderExpr * expr)
|
||||||
|
{
|
||||||
|
char *str = Malloc(16 * sizeof(char));
|
||||||
|
int len = 16;
|
||||||
|
int i;
|
||||||
|
int c;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (isalnum(c = StreamGetc(expr->state.stream)))
|
||||||
|
{
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len *= 2;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len++;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = '\0';
|
||||||
|
|
||||||
|
if (c != EOF)
|
||||||
|
{
|
||||||
|
StreamUngetc(expr->state.stream, c);
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
HeaderConsumeArg(HeaderExpr * expr)
|
||||||
|
{
|
||||||
|
char *str = Malloc(16 * sizeof(char));
|
||||||
|
int len = 16;
|
||||||
|
int i;
|
||||||
|
int c;
|
||||||
|
int block = 0;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (((c = StreamGetc(expr->state.stream)) != ',' && c != ')') || block > 0)
|
||||||
|
{
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len *= 2;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
if (c == '(')
|
||||||
|
{
|
||||||
|
block++;
|
||||||
|
}
|
||||||
|
else if (c == ')')
|
||||||
|
{
|
||||||
|
block--;
|
||||||
|
}
|
||||||
|
else if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i >= len)
|
||||||
|
{
|
||||||
|
len++;
|
||||||
|
str = Realloc(str, len * sizeof(char));
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = '\0';
|
||||||
|
|
||||||
|
if (c != EOF)
|
||||||
|
{
|
||||||
|
StreamUngetc(expr->state.stream, c);
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HeaderParse(Stream * stream, HeaderExpr * expr)
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
|
||||||
|
if (!expr)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "NULL pointer to stream.";
|
||||||
|
expr->data.error.lineNo = -1;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (expr->type == HP_DECLARATION && expr->data.declaration.args)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(expr->data.declaration.args); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(expr->data.declaration.args, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayFree(expr->data.declaration.args);
|
||||||
|
}
|
||||||
|
|
||||||
|
expr->state.stream = stream;
|
||||||
|
if (!expr->state.lineNo)
|
||||||
|
{
|
||||||
|
expr->state.lineNo = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
|
||||||
|
if (StreamEof(stream) || StreamError(stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_EOF;
|
||||||
|
expr->data.error.msg = "End of stream reached.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == '/')
|
||||||
|
{
|
||||||
|
int i = 0;
|
||||||
|
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
if (c != '*')
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Expected comment opening.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
expr->type = HP_COMMENT;
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (i >= HEADER_EXPR_MAX - 1)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Memory limit exceeded while parsing comment.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Unterminated comment.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == '*')
|
||||||
|
{
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
if (c == '/')
|
||||||
|
{
|
||||||
|
expr->data.text[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
expr->data.text[i] = '*';
|
||||||
|
i++;
|
||||||
|
expr->data.text[i] = c;
|
||||||
|
i++;
|
||||||
|
if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
expr->data.text[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (c == '#')
|
||||||
|
{
|
||||||
|
int i = 0;
|
||||||
|
char *word;
|
||||||
|
|
||||||
|
expr->type = HP_PREPROCESSOR_DIRECTIVE;
|
||||||
|
expr->data.text[i] = '#';
|
||||||
|
i++;
|
||||||
|
|
||||||
|
word = HeaderConsumeWord(expr);
|
||||||
|
|
||||||
|
strncpy(expr->data.text + i, word, HEADER_EXPR_MAX - i - 1);
|
||||||
|
i += strlen(word);
|
||||||
|
|
||||||
|
if (StrEquals(word, "include") ||
|
||||||
|
StrEquals(word, "undef") ||
|
||||||
|
StrEquals(word, "ifdef") ||
|
||||||
|
StrEquals(word, "ifndef"))
|
||||||
|
{
|
||||||
|
/* Read one more word */
|
||||||
|
Free(word);
|
||||||
|
word = HeaderConsumeWord(expr);
|
||||||
|
|
||||||
|
if (i + strlen(word) + 1 >= HEADER_EXPR_MAX)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Memory limit reached parsing preprocessor directive.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
strncpy(expr->data.text + i + 1, word, HEADER_EXPR_MAX - i - 1);
|
||||||
|
expr->data.text[i] = ' ';
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(word);
|
||||||
|
}
|
||||||
|
else if (StrEquals(word, "define") ||
|
||||||
|
StrEquals(word, "if") ||
|
||||||
|
StrEquals(word, "elif") ||
|
||||||
|
StrEquals(word, "error"))
|
||||||
|
{
|
||||||
|
int pC = 0;
|
||||||
|
|
||||||
|
Free(word);
|
||||||
|
expr->data.text[i] = ' ';
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (i >= HEADER_EXPR_MAX - 1)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Memory limit reached parsing preprocessor directive.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Unterminated preprocessor directive.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
if (pC != '\\')
|
||||||
|
{
|
||||||
|
expr->data.text[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
expr->data.text[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
pC = c;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (StrEquals(word, "else") ||
|
||||||
|
StrEquals(word, "endif"))
|
||||||
|
{
|
||||||
|
/* Read no more words, that's the whole directive */
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Free(word);
|
||||||
|
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Unknown preprocessor directive.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
char *word;
|
||||||
|
|
||||||
|
StreamUngetc(expr->state.stream, c);
|
||||||
|
word = HeaderConsumeWord(expr);
|
||||||
|
|
||||||
|
if (StrEquals(word, "typedef"))
|
||||||
|
{
|
||||||
|
int block = 0;
|
||||||
|
int i = 0;
|
||||||
|
|
||||||
|
expr->type = HP_TYPEDEF;
|
||||||
|
strncpy(expr->data.text, word, HEADER_EXPR_MAX - 1);
|
||||||
|
i += strlen(word);
|
||||||
|
expr->data.text[i] = ' ';
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (i >= HEADER_EXPR_MAX - 1)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Memory limit exceeded while parsing typedef.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Unterminated typedef.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
expr->data.text[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
if (c == '{')
|
||||||
|
{
|
||||||
|
block++;
|
||||||
|
}
|
||||||
|
else if (c == '}')
|
||||||
|
{
|
||||||
|
block--;
|
||||||
|
}
|
||||||
|
else if (c == '\n')
|
||||||
|
{
|
||||||
|
expr->state.lineNo++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (block <= 0 && c == ';')
|
||||||
|
{
|
||||||
|
expr->data.text[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (StrEquals(word, "extern"))
|
||||||
|
{
|
||||||
|
int wordLimit = sizeof(expr->data.declaration.returnType) - 8;
|
||||||
|
int wordLen;
|
||||||
|
|
||||||
|
Free(word);
|
||||||
|
|
||||||
|
word = HeaderConsumeWord(expr);
|
||||||
|
wordLen = strlen(word);
|
||||||
|
if (wordLen > wordLimit)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Return of declaration exceeds length limit.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
int i = wordLen;
|
||||||
|
|
||||||
|
expr->type = HP_GLOBAL;
|
||||||
|
strncpy(expr->data.global.type, word, wordLimit);
|
||||||
|
|
||||||
|
if (StrEquals(word, "struct") ||
|
||||||
|
StrEquals(word, "enum") ||
|
||||||
|
StrEquals(word, "const") ||
|
||||||
|
StrEquals(word, "unsigned"))
|
||||||
|
{
|
||||||
|
Free(word);
|
||||||
|
word = HeaderConsumeWord(expr);
|
||||||
|
wordLen = strlen(word);
|
||||||
|
expr->data.global.type[i] = ' ';
|
||||||
|
|
||||||
|
strncpy(expr->data.global.type + i + 1, word, wordLen + 1);
|
||||||
|
i += wordLen + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(word);
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
if (c == '*')
|
||||||
|
{
|
||||||
|
expr->data.global.type[i] = ' ';
|
||||||
|
|
||||||
|
i++;
|
||||||
|
expr->data.global.type[i] = '*';
|
||||||
|
|
||||||
|
i++;
|
||||||
|
while ((c = HeaderConsumeWhitespace(expr)) == '*')
|
||||||
|
{
|
||||||
|
expr->data.global.type[i] = c;
|
||||||
|
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamUngetc(expr->state.stream, c);
|
||||||
|
word = HeaderConsumeAlnum(expr);
|
||||||
|
|
||||||
|
wordLen = strlen(word);
|
||||||
|
wordLimit = sizeof(expr->data.declaration.name) - 1;
|
||||||
|
|
||||||
|
if (wordLen > wordLimit)
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Function name too long.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
strncpy(expr->data.global.name, word, wordLimit);
|
||||||
|
Free(word);
|
||||||
|
word = NULL;
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
|
||||||
|
if (c == ';')
|
||||||
|
{
|
||||||
|
/* That's the end of the global. */
|
||||||
|
}
|
||||||
|
else if (c == '[')
|
||||||
|
{
|
||||||
|
/* Looks like we have an array. Slurp all the
|
||||||
|
* dimensions */
|
||||||
|
int i = wordLen;
|
||||||
|
|
||||||
|
expr->data.global.name[i] = '[';
|
||||||
|
|
||||||
|
i++;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
if (i >= HEADER_EXPR_MAX - wordLen)
|
||||||
|
{
|
||||||
|
expr->type = HP_PARSE_ERROR;
|
||||||
|
expr->data.error.msg = "Memory limit exceeded while parsing global array.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = StreamGetc(expr->state.stream);
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream) || StreamError(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Unterminated global array.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == ';')
|
||||||
|
{
|
||||||
|
expr->data.global.name[i] = '\0';
|
||||||
|
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
expr->data.global.name[i] = c;
|
||||||
|
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (c == '(')
|
||||||
|
{
|
||||||
|
expr->type = HP_DECLARATION;
|
||||||
|
expr->data.declaration.args = ArrayCreate();
|
||||||
|
do
|
||||||
|
{
|
||||||
|
word = HeaderConsumeArg(expr);
|
||||||
|
ArrayAdd(expr->data.declaration.args, word);
|
||||||
|
word = NULL;
|
||||||
|
}
|
||||||
|
while ((!StreamEof(expr->state.stream)) && ((c = HeaderConsumeWhitespace(expr)) != ')'));
|
||||||
|
|
||||||
|
if (StreamEof(expr->state.stream))
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "End of file reached before ')'.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = HeaderConsumeWhitespace(expr);
|
||||||
|
if (c != ';')
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Expected ';'.";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
expr->type = HP_SYNTAX_ERROR;
|
||||||
|
expr->data.error.msg = "Expected ';', '[', or '('";
|
||||||
|
expr->data.error.lineNo = expr->state.lineNo;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Cope with preprocessor macro expansions at the top
|
||||||
|
* level. */
|
||||||
|
expr->type = HP_UNKNOWN;
|
||||||
|
strncpy(expr->data.text, word, HEADER_EXPR_MAX);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(word);
|
||||||
|
}
|
||||||
|
}
|
642
src/Http.c
Normal file
642
src/Http.c
Normal file
|
@ -0,0 +1,642 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Http.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_STRING_CHUNK
|
||||||
|
#define CYTOPLASM_STRING_CHUNK 64
|
||||||
|
#endif
|
||||||
|
|
||||||
|
const char *
|
||||||
|
HttpRequestMethodToString(const HttpRequestMethod method)
|
||||||
|
{
|
||||||
|
switch (method)
|
||||||
|
{
|
||||||
|
case HTTP_GET:
|
||||||
|
return "GET";
|
||||||
|
case HTTP_HEAD:
|
||||||
|
return "HEAD";
|
||||||
|
case HTTP_POST:
|
||||||
|
return "POST";
|
||||||
|
case HTTP_PUT:
|
||||||
|
return "PUT";
|
||||||
|
case HTTP_DELETE:
|
||||||
|
return "DELETE";
|
||||||
|
case HTTP_CONNECT:
|
||||||
|
return "CONNECT";
|
||||||
|
case HTTP_OPTIONS:
|
||||||
|
return "OPTIONS";
|
||||||
|
case HTTP_TRACE:
|
||||||
|
return "TRACE";
|
||||||
|
case HTTP_PATCH:
|
||||||
|
return "PATCH";
|
||||||
|
default:
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpRequestMethod
|
||||||
|
HttpRequestMethodFromString(const char *str)
|
||||||
|
{
|
||||||
|
if (StrEquals(str, "GET"))
|
||||||
|
{
|
||||||
|
return HTTP_GET;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "HEAD"))
|
||||||
|
{
|
||||||
|
return HTTP_HEAD;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "POST"))
|
||||||
|
{
|
||||||
|
return HTTP_POST;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "PUT"))
|
||||||
|
{
|
||||||
|
return HTTP_PUT;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "DELETE"))
|
||||||
|
{
|
||||||
|
return HTTP_DELETE;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "CONNECT"))
|
||||||
|
{
|
||||||
|
return HTTP_CONNECT;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "OPTIONS"))
|
||||||
|
{
|
||||||
|
return HTTP_OPTIONS;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "TRACE"))
|
||||||
|
{
|
||||||
|
return HTTP_TRACE;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(str, "PATCH"))
|
||||||
|
{
|
||||||
|
return HTTP_PATCH;
|
||||||
|
}
|
||||||
|
|
||||||
|
return HTTP_METHOD_UNKNOWN;
|
||||||
|
}
|
||||||
|
|
||||||
|
const char *
|
||||||
|
HttpStatusToString(const HttpStatus status)
|
||||||
|
{
|
||||||
|
switch (status)
|
||||||
|
{
|
||||||
|
case HTTP_CONTINUE:
|
||||||
|
return "Continue";
|
||||||
|
case HTTP_SWITCHING_PROTOCOLS:
|
||||||
|
return "Switching Protocols";
|
||||||
|
case HTTP_EARLY_HINTS:
|
||||||
|
return "Early Hints";
|
||||||
|
case HTTP_OK:
|
||||||
|
return "Ok";
|
||||||
|
case HTTP_CREATED:
|
||||||
|
return "Created";
|
||||||
|
case HTTP_ACCEPTED:
|
||||||
|
return "Accepted";
|
||||||
|
case HTTP_NON_AUTHORITATIVE_INFORMATION:
|
||||||
|
return "Non-Authoritative Information";
|
||||||
|
case HTTP_NO_CONTENT:
|
||||||
|
return "No Content";
|
||||||
|
case HTTP_RESET_CONTENT:
|
||||||
|
return "Reset Content";
|
||||||
|
case HTTP_PARTIAL_CONTENT:
|
||||||
|
return "Partial Content";
|
||||||
|
case HTTP_MULTIPLE_CHOICES:
|
||||||
|
return "Multiple Choices";
|
||||||
|
case HTTP_MOVED_PERMANENTLY:
|
||||||
|
return "Moved Permanently";
|
||||||
|
case HTTP_FOUND:
|
||||||
|
return "Found";
|
||||||
|
case HTTP_SEE_OTHER:
|
||||||
|
return "See Other";
|
||||||
|
case HTTP_NOT_MODIFIED:
|
||||||
|
return "Not Modified";
|
||||||
|
case HTTP_TEMPORARY_REDIRECT:
|
||||||
|
return "Temporary Redirect";
|
||||||
|
case HTTP_PERMANENT_REDIRECT:
|
||||||
|
return "Permanent Redirect";
|
||||||
|
case HTTP_BAD_REQUEST:
|
||||||
|
return "Bad Request";
|
||||||
|
case HTTP_UNAUTHORIZED:
|
||||||
|
return "Unauthorized";
|
||||||
|
case HTTP_FORBIDDEN:
|
||||||
|
return "Forbidden";
|
||||||
|
case HTTP_NOT_FOUND:
|
||||||
|
return "Not Found";
|
||||||
|
case HTTP_METHOD_NOT_ALLOWED:
|
||||||
|
return "Method Not Allowed";
|
||||||
|
case HTTP_NOT_ACCEPTABLE:
|
||||||
|
return "Not Acceptable";
|
||||||
|
case HTTP_PROXY_AUTH_REQUIRED:
|
||||||
|
return "Proxy Authentication Required";
|
||||||
|
case HTTP_REQUEST_TIMEOUT:
|
||||||
|
return "Request Timeout";
|
||||||
|
case HTTP_CONFLICT:
|
||||||
|
return "Conflict";
|
||||||
|
case HTTP_GONE:
|
||||||
|
return "Gone";
|
||||||
|
case HTTP_LENGTH_REQUIRED:
|
||||||
|
return "Length Required";
|
||||||
|
case HTTP_PRECONDITION_FAILED:
|
||||||
|
return "Precondition Failed";
|
||||||
|
case HTTP_PAYLOAD_TOO_LARGE:
|
||||||
|
return "Payload Too Large";
|
||||||
|
case HTTP_URI_TOO_LONG:
|
||||||
|
return "URI Too Long";
|
||||||
|
case HTTP_UNSUPPORTED_MEDIA_TYPE:
|
||||||
|
return "Unsupported Media Type";
|
||||||
|
case HTTP_RANGE_NOT_SATISFIABLE:
|
||||||
|
return "Range Not Satisfiable";
|
||||||
|
case HTTP_EXPECTATION_FAILED:
|
||||||
|
return "Expectation Failed";
|
||||||
|
case HTTP_TEAPOT:
|
||||||
|
return "I'm a Teapot";
|
||||||
|
case HTTP_UPGRADE_REQUIRED:
|
||||||
|
return "Upgrade Required";
|
||||||
|
case HTTP_PRECONDITION_REQUIRED:
|
||||||
|
return "Precondition Required";
|
||||||
|
case HTTP_TOO_MANY_REQUESTS:
|
||||||
|
return "Too Many Requests";
|
||||||
|
case HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE:
|
||||||
|
return "Request Header Fields Too Large";
|
||||||
|
case HTTP_UNAVAILABLE_FOR_LEGAL_REASONS:
|
||||||
|
return "Unavailable For Legal Reasons";
|
||||||
|
case HTTP_INTERNAL_SERVER_ERROR:
|
||||||
|
return "Internal Server Error";
|
||||||
|
case HTTP_NOT_IMPLEMENTED:
|
||||||
|
return "Not Implemented";
|
||||||
|
case HTTP_BAD_GATEWAY:
|
||||||
|
return "Bad Gateway";
|
||||||
|
case HTTP_SERVICE_UNAVAILABLE:
|
||||||
|
return "Service Unavailable";
|
||||||
|
case HTTP_GATEWAY_TIMEOUT:
|
||||||
|
return "Gateway Timeout";
|
||||||
|
case HTTP_VERSION_NOT_SUPPORTED:
|
||||||
|
return "Version Not Supported";
|
||||||
|
case HTTP_VARIANT_ALSO_NEGOTIATES:
|
||||||
|
return "Variant Also Negotiates";
|
||||||
|
case HTTP_NOT_EXTENDED:
|
||||||
|
return "Not Extended";
|
||||||
|
case HTTP_NETWORK_AUTH_REQUIRED:
|
||||||
|
return "Network Authentication Required";
|
||||||
|
default:
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
HttpUrlEncode(char *str)
|
||||||
|
{
|
||||||
|
size_t size;
|
||||||
|
size_t len;
|
||||||
|
char *encoded;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
size = CYTOPLASM_STRING_CHUNK;
|
||||||
|
len = 0;
|
||||||
|
encoded = Malloc(size);
|
||||||
|
if (!encoded)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*str)
|
||||||
|
{
|
||||||
|
char c = *str;
|
||||||
|
|
||||||
|
if (len >= size - 4)
|
||||||
|
{
|
||||||
|
char *tmp;
|
||||||
|
|
||||||
|
size += CYTOPLASM_STRING_CHUNK;
|
||||||
|
tmp = Realloc(encoded, size);
|
||||||
|
if (!tmp)
|
||||||
|
{
|
||||||
|
Free(encoded);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
encoded = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Control characters and extended characters */
|
||||||
|
if (c <= 0x1F || c >= 0x7F)
|
||||||
|
{
|
||||||
|
goto percentEncode;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Reserved and unsafe characters */
|
||||||
|
switch (c)
|
||||||
|
{
|
||||||
|
case '$':
|
||||||
|
case '&':
|
||||||
|
case '+':
|
||||||
|
case ',':
|
||||||
|
case '/':
|
||||||
|
case ':':
|
||||||
|
case ';':
|
||||||
|
case '=':
|
||||||
|
case '?':
|
||||||
|
case '@':
|
||||||
|
case ' ':
|
||||||
|
case '"':
|
||||||
|
case '<':
|
||||||
|
case '>':
|
||||||
|
case '#':
|
||||||
|
case '%':
|
||||||
|
case '{':
|
||||||
|
case '}':
|
||||||
|
case '|':
|
||||||
|
case '\\':
|
||||||
|
case '^':
|
||||||
|
case '~':
|
||||||
|
case '[':
|
||||||
|
case ']':
|
||||||
|
case '`':
|
||||||
|
goto percentEncode;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
encoded[len] = c;
|
||||||
|
len++;
|
||||||
|
str++;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
percentEncode:
|
||||||
|
encoded[len] = '%';
|
||||||
|
len++;
|
||||||
|
snprintf(encoded + len, 3, "%2X", c);
|
||||||
|
len += 2;
|
||||||
|
|
||||||
|
str++;
|
||||||
|
}
|
||||||
|
|
||||||
|
encoded[len] = '\0';
|
||||||
|
return encoded;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
HttpUrlDecode(char *str)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
size_t inputLen;
|
||||||
|
char *decoded;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
inputLen = strlen(str);
|
||||||
|
decoded = Malloc(inputLen + 1);
|
||||||
|
|
||||||
|
if (!decoded)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*str)
|
||||||
|
{
|
||||||
|
char c = *str;
|
||||||
|
|
||||||
|
if (c == '%')
|
||||||
|
{
|
||||||
|
unsigned int d;
|
||||||
|
|
||||||
|
str++;
|
||||||
|
|
||||||
|
if (sscanf(str, "%2X", &d) != 1)
|
||||||
|
{
|
||||||
|
/* Decoding error */
|
||||||
|
Free(decoded);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!d)
|
||||||
|
{
|
||||||
|
/* Null character given, don't put that in the string. */
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
c = (char) d;
|
||||||
|
|
||||||
|
str++;
|
||||||
|
}
|
||||||
|
|
||||||
|
decoded[i] = c;
|
||||||
|
i++;
|
||||||
|
|
||||||
|
str++;
|
||||||
|
}
|
||||||
|
|
||||||
|
decoded[i] = '\0';
|
||||||
|
|
||||||
|
return decoded;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HttpParamDecode(char *in)
|
||||||
|
{
|
||||||
|
HashMap *params;
|
||||||
|
|
||||||
|
if (!in)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
params = HashMapCreate();
|
||||||
|
if (!params)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*in)
|
||||||
|
{
|
||||||
|
char *buf;
|
||||||
|
size_t allocated;
|
||||||
|
size_t len;
|
||||||
|
|
||||||
|
char *decKey;
|
||||||
|
char *decVal;
|
||||||
|
|
||||||
|
/* Read in key */
|
||||||
|
|
||||||
|
allocated = CYTOPLASM_STRING_CHUNK;
|
||||||
|
buf = Malloc(allocated);
|
||||||
|
len = 0;
|
||||||
|
|
||||||
|
while (*in && *in != '=')
|
||||||
|
{
|
||||||
|
if (len >= allocated - 1)
|
||||||
|
{
|
||||||
|
allocated += CYTOPLASM_STRING_CHUNK;
|
||||||
|
buf = Realloc(buf, allocated);
|
||||||
|
}
|
||||||
|
|
||||||
|
buf[len] = *in;
|
||||||
|
len++;
|
||||||
|
in++;
|
||||||
|
}
|
||||||
|
|
||||||
|
buf[len] = '\0';
|
||||||
|
|
||||||
|
/* Sanity check */
|
||||||
|
if (*in != '=')
|
||||||
|
{
|
||||||
|
/* Malformed param */
|
||||||
|
Free(buf);
|
||||||
|
HashMapFree(params);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
in++;
|
||||||
|
|
||||||
|
/* Decode key */
|
||||||
|
decKey = HttpUrlDecode(buf);
|
||||||
|
Free(buf);
|
||||||
|
|
||||||
|
if (!decKey)
|
||||||
|
{
|
||||||
|
/* Decoding error */
|
||||||
|
HashMapFree(params);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Read in value */
|
||||||
|
allocated = CYTOPLASM_STRING_CHUNK;
|
||||||
|
buf = Malloc(allocated);
|
||||||
|
len = 0;
|
||||||
|
|
||||||
|
while (*in && *in != '&')
|
||||||
|
{
|
||||||
|
if (len >= allocated - 1)
|
||||||
|
{
|
||||||
|
allocated += CYTOPLASM_STRING_CHUNK;
|
||||||
|
buf = Realloc(buf, allocated);
|
||||||
|
}
|
||||||
|
|
||||||
|
buf[len] = *in;
|
||||||
|
len++;
|
||||||
|
in++;
|
||||||
|
}
|
||||||
|
|
||||||
|
buf[len] = '\0';
|
||||||
|
|
||||||
|
/* Decode value */
|
||||||
|
decVal = HttpUrlDecode(buf);
|
||||||
|
Free(buf);
|
||||||
|
|
||||||
|
if (!decVal)
|
||||||
|
{
|
||||||
|
/* Decoding error */
|
||||||
|
HashMapFree(params);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
buf = HashMapSet(params, decKey, decVal);
|
||||||
|
if (buf)
|
||||||
|
{
|
||||||
|
Free(buf);
|
||||||
|
}
|
||||||
|
Free(decKey);
|
||||||
|
|
||||||
|
if (*in == '&')
|
||||||
|
{
|
||||||
|
in++;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return params;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
HttpParamEncode(HashMap * params)
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
char *val;
|
||||||
|
char *out = NULL;
|
||||||
|
|
||||||
|
if (!params || !out)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(params, &key, (void *) &val))
|
||||||
|
{
|
||||||
|
char *encKey;
|
||||||
|
char *encVal;
|
||||||
|
|
||||||
|
encKey = HttpUrlEncode(key);
|
||||||
|
encVal = HttpUrlEncode(val);
|
||||||
|
|
||||||
|
if (!encKey || !encVal)
|
||||||
|
{
|
||||||
|
/* Memory error */
|
||||||
|
Free(encKey);
|
||||||
|
Free(encVal);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* TODO */
|
||||||
|
|
||||||
|
Free(encKey);
|
||||||
|
Free(encVal);
|
||||||
|
}
|
||||||
|
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HttpParseHeaders(Stream * fp)
|
||||||
|
{
|
||||||
|
HashMap *headers;
|
||||||
|
|
||||||
|
char *line;
|
||||||
|
ssize_t lineLen;
|
||||||
|
size_t lineSize;
|
||||||
|
|
||||||
|
char *headerKey;
|
||||||
|
char *headerValue;
|
||||||
|
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
headers = HashMapCreate();
|
||||||
|
if (!headers)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
line = NULL;
|
||||||
|
lineLen = 0;
|
||||||
|
|
||||||
|
while ((lineLen = UtilGetLine(&line, &lineSize, fp)) != -1)
|
||||||
|
{
|
||||||
|
char *headerPtr;
|
||||||
|
|
||||||
|
ssize_t i;
|
||||||
|
size_t len;
|
||||||
|
|
||||||
|
if (StrEquals(line, "\r\n") || StrEquals(line, "\n"))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < lineLen; i++)
|
||||||
|
{
|
||||||
|
if (line[i] == ':')
|
||||||
|
{
|
||||||
|
line[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
line[i] = tolower((unsigned char) line[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
len = i + 1;
|
||||||
|
headerKey = Malloc(len * sizeof(char));
|
||||||
|
if (!headerKey)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
strncpy(headerKey, line, len);
|
||||||
|
|
||||||
|
headerPtr = line + i + 1;
|
||||||
|
|
||||||
|
while (isspace((unsigned char) *headerPtr))
|
||||||
|
{
|
||||||
|
headerPtr++;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = lineLen - 1; i > (line + lineLen) - headerPtr; i--)
|
||||||
|
{
|
||||||
|
if (!isspace((unsigned char) line[i]))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
line[i] = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
len = strlen(headerPtr) + 1;
|
||||||
|
headerValue = Malloc(len * sizeof(char));
|
||||||
|
if (!headerValue)
|
||||||
|
{
|
||||||
|
Free(headerKey);
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
strncpy(headerValue, headerPtr, len);
|
||||||
|
|
||||||
|
HashMapSet(headers, headerKey, headerValue);
|
||||||
|
Free(headerKey);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(line);
|
||||||
|
return headers;
|
||||||
|
|
||||||
|
error:
|
||||||
|
Free(line);
|
||||||
|
|
||||||
|
while (HashMapIterate(headers, &headerKey, (void **) &headerValue))
|
||||||
|
{
|
||||||
|
Free(headerValue);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(headers);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
298
src/HttpClient.c
Normal file
298
src/HttpClient.c
Normal file
|
@ -0,0 +1,298 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HttpClient.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/socket.h>
|
||||||
|
#include <netdb.h>
|
||||||
|
|
||||||
|
#include <Http.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Tls.h>
|
||||||
|
|
||||||
|
struct HttpClientContext
|
||||||
|
{
|
||||||
|
HashMap *responseHeaders;
|
||||||
|
Stream *stream;
|
||||||
|
};
|
||||||
|
|
||||||
|
HttpClientContext *
|
||||||
|
HttpRequest(HttpRequestMethod method, int flags, unsigned short port, char *host, char *path)
|
||||||
|
{
|
||||||
|
HttpClientContext *context;
|
||||||
|
|
||||||
|
int sd = -1;
|
||||||
|
struct addrinfo hints, *res, *res0;
|
||||||
|
int error;
|
||||||
|
|
||||||
|
char serv[8];
|
||||||
|
|
||||||
|
if (!method || !host || !path)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef TLS_IMPL
|
||||||
|
if (flags & HTTP_FLAG_TLS)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!port)
|
||||||
|
{
|
||||||
|
if (flags & HTTP_FLAG_TLS)
|
||||||
|
{
|
||||||
|
strcpy(serv, "https");
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
strcpy(serv, "www");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
snprintf(serv, sizeof(serv), "%hu", port);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
context = Malloc(sizeof(HttpClientContext));
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(&hints, 0, sizeof(hints));
|
||||||
|
hints.ai_family = AF_UNSPEC;
|
||||||
|
hints.ai_socktype = SOCK_STREAM;
|
||||||
|
error = getaddrinfo(host, serv, &hints, &res0);
|
||||||
|
|
||||||
|
if (error)
|
||||||
|
{
|
||||||
|
Free(context);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (res = res0; res; res = res->ai_next)
|
||||||
|
{
|
||||||
|
sd = socket(res->ai_family, res->ai_socktype,
|
||||||
|
res->ai_protocol);
|
||||||
|
|
||||||
|
if (sd < 0)
|
||||||
|
{
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (connect(sd, res->ai_addr, res->ai_addrlen) < 0)
|
||||||
|
{
|
||||||
|
close(sd);
|
||||||
|
sd = -1;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sd < 0)
|
||||||
|
{
|
||||||
|
Free(context);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
freeaddrinfo(res0);
|
||||||
|
|
||||||
|
#ifdef TLS_IMPL
|
||||||
|
if (flags & HTTP_FLAG_TLS)
|
||||||
|
{
|
||||||
|
context->stream = TlsClientStream(sd, host);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
context->stream = StreamFd(sd);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
context->stream = StreamFd(sd);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!context->stream)
|
||||||
|
{
|
||||||
|
Free(context);
|
||||||
|
close(sd);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPrintf(context->stream, "%s %s HTTP/1.0\r\n",
|
||||||
|
HttpRequestMethodToString(method), path);
|
||||||
|
|
||||||
|
HttpRequestHeader(context, "Connection", "close");
|
||||||
|
HttpRequestHeader(context, "User-Agent", LIB_NAME "/" LIB_VERSION);
|
||||||
|
HttpRequestHeader(context, "Host", host);
|
||||||
|
|
||||||
|
return context;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpRequestHeader(HttpClientContext * context, char *key, char *val)
|
||||||
|
{
|
||||||
|
if (!context || !key || !val)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPrintf(context->stream, "%s: %s\r\n", key, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpRequestSendHeaders(HttpClientContext * context)
|
||||||
|
{
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPuts(context->stream, "\r\n");
|
||||||
|
StreamFlush(context->stream);
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpStatus
|
||||||
|
HttpRequestSend(HttpClientContext * context)
|
||||||
|
{
|
||||||
|
HttpStatus status;
|
||||||
|
|
||||||
|
char *line = NULL;
|
||||||
|
ssize_t lineLen;
|
||||||
|
size_t lineSize = 0;
|
||||||
|
char *tmp;
|
||||||
|
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamFlush(context->stream);
|
||||||
|
|
||||||
|
lineLen = UtilGetLine(&line, &lineSize, context->stream);
|
||||||
|
|
||||||
|
while (lineLen == -1 && errno == EAGAIN)
|
||||||
|
{
|
||||||
|
StreamClearError(context->stream);
|
||||||
|
lineLen = UtilGetLine(&line, &lineSize, context->stream);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lineLen == -1)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Line must contain at least "HTTP/x.x xxx" */
|
||||||
|
if (lineLen < 12)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(strncmp(line, "HTTP/1.0", 8) == 0 ||
|
||||||
|
strncmp(line, "HTTP/1.1", 8) == 0))
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = line + 9;
|
||||||
|
|
||||||
|
while (isspace((unsigned char) *tmp) && *tmp != '\0')
|
||||||
|
{
|
||||||
|
tmp++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!*tmp)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
status = atoi(tmp);
|
||||||
|
|
||||||
|
if (!status)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
context->responseHeaders = HttpParseHeaders(context->stream);
|
||||||
|
if (!context->responseHeaders)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return status;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HttpResponseHeaders(HttpClientContext * context)
|
||||||
|
{
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return context->responseHeaders;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
HttpClientStream(HttpClientContext * context)
|
||||||
|
{
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return context->stream;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpClientContextFree(HttpClientContext * context)
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
void *val;
|
||||||
|
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(context->responseHeaders, &key, &val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(context->responseHeaders);
|
||||||
|
|
||||||
|
StreamClose(context->stream);
|
||||||
|
Free(context);
|
||||||
|
}
|
296
src/HttpRouter.c
Normal file
296
src/HttpRouter.c
Normal file
|
@ -0,0 +1,296 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HttpRouter.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <regex.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#define REG_FLAGS (REG_EXTENDED)
|
||||||
|
#define REG_MAX_SUB 8
|
||||||
|
|
||||||
|
typedef struct RouteNode
|
||||||
|
{
|
||||||
|
HttpRouteFunc *exec;
|
||||||
|
HashMap *children;
|
||||||
|
|
||||||
|
regex_t regex;
|
||||||
|
} RouteNode;
|
||||||
|
|
||||||
|
struct HttpRouter
|
||||||
|
{
|
||||||
|
RouteNode *root;
|
||||||
|
};
|
||||||
|
|
||||||
|
static RouteNode *
|
||||||
|
RouteNodeCreate(char *regex, HttpRouteFunc * exec)
|
||||||
|
{
|
||||||
|
RouteNode *node;
|
||||||
|
|
||||||
|
if (!regex)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
node = Malloc(sizeof(RouteNode));
|
||||||
|
|
||||||
|
if (!node)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
node->children = HashMapCreate();
|
||||||
|
if (!node->children)
|
||||||
|
{
|
||||||
|
Free(node);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Force the regex to match the entire path part exactly. */
|
||||||
|
regex = StrConcat(3, "^", regex, "$");
|
||||||
|
if (!regex)
|
||||||
|
{
|
||||||
|
Free(node);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (regcomp(&node->regex, regex, REG_FLAGS) != 0)
|
||||||
|
{
|
||||||
|
HashMapFree(node->children);
|
||||||
|
Free(node);
|
||||||
|
Free(regex);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
node->exec = exec;
|
||||||
|
|
||||||
|
Free(regex);
|
||||||
|
return node;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
RouteNodeFree(RouteNode * node)
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
RouteNode *val;
|
||||||
|
|
||||||
|
if (!node)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(node->children, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
RouteNodeFree(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(node->children);
|
||||||
|
|
||||||
|
regfree(&node->regex);
|
||||||
|
|
||||||
|
Free(node);
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpRouter *
|
||||||
|
HttpRouterCreate(void)
|
||||||
|
{
|
||||||
|
HttpRouter *router = Malloc(sizeof(HttpRouter));
|
||||||
|
|
||||||
|
if (!router)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
router->root = RouteNodeCreate("/", NULL);
|
||||||
|
|
||||||
|
return router;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpRouterFree(HttpRouter * router)
|
||||||
|
{
|
||||||
|
if (!router)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
RouteNodeFree(router->root);
|
||||||
|
Free(router);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
HttpRouterAdd(HttpRouter * router, char *regPath, HttpRouteFunc * exec)
|
||||||
|
{
|
||||||
|
RouteNode *node;
|
||||||
|
char *pathPart;
|
||||||
|
char *tmp;
|
||||||
|
|
||||||
|
if (!router || !regPath || !exec)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(regPath, "/"))
|
||||||
|
{
|
||||||
|
router->root->exec = exec;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
regPath = StrDuplicate(regPath);
|
||||||
|
if (!regPath)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = regPath;
|
||||||
|
node = router->root;
|
||||||
|
|
||||||
|
while ((pathPart = strtok_r(tmp, "/", &tmp)))
|
||||||
|
{
|
||||||
|
RouteNode *tNode = HashMapGet(node->children, pathPart);
|
||||||
|
|
||||||
|
if (!tNode)
|
||||||
|
{
|
||||||
|
tNode = RouteNodeCreate(pathPart, NULL);
|
||||||
|
RouteNodeFree(HashMapSet(node->children, pathPart, tNode));
|
||||||
|
}
|
||||||
|
|
||||||
|
node = tNode;
|
||||||
|
}
|
||||||
|
|
||||||
|
node->exec = exec;
|
||||||
|
|
||||||
|
Free(regPath);
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
HttpRouterRoute(HttpRouter * router, char *path, void *args, void **ret)
|
||||||
|
{
|
||||||
|
RouteNode *node;
|
||||||
|
char *pathPart;
|
||||||
|
char *tmp;
|
||||||
|
HttpRouteFunc *exec = NULL;
|
||||||
|
Array *matches;
|
||||||
|
size_t i;
|
||||||
|
int retval;
|
||||||
|
|
||||||
|
if (!router || !path)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
matches = ArrayCreate();
|
||||||
|
if (!matches)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
node = router->root;
|
||||||
|
|
||||||
|
if (StrEquals(path, "/"))
|
||||||
|
{
|
||||||
|
exec = node->exec;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
path = StrDuplicate(path);
|
||||||
|
tmp = path;
|
||||||
|
while ((pathPart = strtok_r(tmp, "/", &tmp)))
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
RouteNode *val = NULL;
|
||||||
|
|
||||||
|
regmatch_t pmatch[REG_MAX_SUB];
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
|
||||||
|
while (HashMapIterateReentrant(node->children, &key, (void **) &val, &i))
|
||||||
|
{
|
||||||
|
if (regexec(&val->regex, pathPart, REG_MAX_SUB, pmatch, 0) == 0)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
val = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
exec = NULL;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
node = val;
|
||||||
|
exec = node->exec;
|
||||||
|
|
||||||
|
/* If we want to pass an arg, the match must be in parens */
|
||||||
|
if (val->regex.re_nsub)
|
||||||
|
{
|
||||||
|
/* pmatch[0] is the whole string, not the first
|
||||||
|
* subexpression */
|
||||||
|
for (i = 1; i < REG_MAX_SUB; i++)
|
||||||
|
{
|
||||||
|
if (pmatch[i].rm_so == -1)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayAdd(matches, StrSubstr(pathPart, pmatch[i].rm_so, pmatch[i].rm_eo));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Free(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!exec)
|
||||||
|
{
|
||||||
|
retval = 0;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ret)
|
||||||
|
{
|
||||||
|
*ret = exec(matches, args);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
exec(matches, args);
|
||||||
|
}
|
||||||
|
|
||||||
|
retval = 1;
|
||||||
|
|
||||||
|
finish:
|
||||||
|
for (i = 0; i < ArraySize(matches); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(matches, i));
|
||||||
|
}
|
||||||
|
ArrayFree(matches);
|
||||||
|
|
||||||
|
return retval;
|
||||||
|
}
|
753
src/HttpServer.c
Normal file
753
src/HttpServer.c
Normal file
|
@ -0,0 +1,753 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HttpServer.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Queue.h>
|
||||||
|
#include <Array.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Tls.h>
|
||||||
|
#include <Log.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <poll.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
#include <sys/socket.h>
|
||||||
|
#include <netinet/in.h>
|
||||||
|
#include <arpa/inet.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
|
#include <errno.h>
|
||||||
|
|
||||||
|
static const char ENABLE = 1;
|
||||||
|
|
||||||
|
struct HttpServer
|
||||||
|
{
|
||||||
|
HttpServerConfig config;
|
||||||
|
int sd;
|
||||||
|
pthread_t socketThread;
|
||||||
|
|
||||||
|
volatile unsigned int stop:1;
|
||||||
|
volatile unsigned int isRunning:1;
|
||||||
|
|
||||||
|
Queue *connQueue;
|
||||||
|
pthread_mutex_t connQueueMutex;
|
||||||
|
|
||||||
|
Array *threadPool;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct HttpServerContext
|
||||||
|
{
|
||||||
|
HashMap *requestHeaders;
|
||||||
|
HttpRequestMethod requestMethod;
|
||||||
|
char *requestPath;
|
||||||
|
HashMap *requestParams;
|
||||||
|
|
||||||
|
HashMap *responseHeaders;
|
||||||
|
HttpStatus responseStatus;
|
||||||
|
|
||||||
|
Stream *stream;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct HttpServerWorkerThreadArgs
|
||||||
|
{
|
||||||
|
HttpServer *server;
|
||||||
|
int id;
|
||||||
|
pthread_t thread;
|
||||||
|
} HttpServerWorkerThreadArgs;
|
||||||
|
|
||||||
|
static HttpServerContext *
|
||||||
|
HttpServerContextCreate(HttpRequestMethod requestMethod,
|
||||||
|
char *requestPath, HashMap * requestParams, Stream * stream)
|
||||||
|
{
|
||||||
|
HttpServerContext *c;
|
||||||
|
|
||||||
|
c = Malloc(sizeof(HttpServerContext));
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
c->responseHeaders = HashMapCreate();
|
||||||
|
if (!c->responseHeaders)
|
||||||
|
{
|
||||||
|
Free(c->requestHeaders);
|
||||||
|
Free(c);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
c->requestMethod = requestMethod;
|
||||||
|
c->requestPath = requestPath;
|
||||||
|
c->requestParams = requestParams;
|
||||||
|
c->stream = stream;
|
||||||
|
c->responseStatus = HTTP_OK;
|
||||||
|
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
HttpServerContextFree(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
char *key;
|
||||||
|
void *val;
|
||||||
|
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(c->requestHeaders, &key, &val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
HashMapFree(c->requestHeaders);
|
||||||
|
|
||||||
|
while (HashMapIterate(c->responseHeaders, &key, &val))
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* These are generated by code. As such, they may be either
|
||||||
|
* on the heap, or on the stack, depending on how they were
|
||||||
|
* added.
|
||||||
|
*
|
||||||
|
* Basically, if the memory API knows about a pointer, then
|
||||||
|
* it can be freed. If it doesn't know about a pointer, skip
|
||||||
|
* freeing it because it's probably a stack pointer.
|
||||||
|
*/
|
||||||
|
|
||||||
|
if (MemoryInfoGet(val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(c->responseHeaders);
|
||||||
|
|
||||||
|
while (HashMapIterate(c->requestParams, &key, &val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(c->requestParams);
|
||||||
|
|
||||||
|
Free(c->requestPath);
|
||||||
|
StreamClose(c->stream);
|
||||||
|
|
||||||
|
Free(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HttpRequestHeaders(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->requestHeaders;
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpRequestMethod
|
||||||
|
HttpRequestMethodGet(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return HTTP_METHOD_UNKNOWN;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->requestMethod;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
HttpRequestPath(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->requestPath;
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMap *
|
||||||
|
HttpRequestParams(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->requestParams;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
HttpResponseHeader(HttpServerContext * c, char *key, char *val)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return HashMapSet(c->responseHeaders, key, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpResponseStatus(HttpServerContext * c, HttpStatus status)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
c->responseStatus = status;
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpStatus
|
||||||
|
HttpResponseStatusGet(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return HTTP_STATUS_UNKNOWN;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->responseStatus;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
HttpServerStream(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
if (!c)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c->stream;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpSendHeaders(HttpServerContext * c)
|
||||||
|
{
|
||||||
|
Stream *fp = c->stream;
|
||||||
|
|
||||||
|
char *key;
|
||||||
|
char *val;
|
||||||
|
|
||||||
|
StreamPrintf(fp, "HTTP/1.0 %d %s\n", c->responseStatus, HttpStatusToString(c->responseStatus));
|
||||||
|
|
||||||
|
while (HashMapIterate(c->responseHeaders, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
StreamPrintf(fp, "%s: %s\n", key, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPuts(fp, "\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
static Stream *
|
||||||
|
DequeueConnection(HttpServer * server)
|
||||||
|
{
|
||||||
|
Stream *fp;
|
||||||
|
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&server->connQueueMutex);
|
||||||
|
fp = QueuePop(server->connQueue);
|
||||||
|
pthread_mutex_unlock(&server->connQueueMutex);
|
||||||
|
|
||||||
|
return fp;
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpServer *
|
||||||
|
HttpServerCreate(HttpServerConfig * config)
|
||||||
|
{
|
||||||
|
HttpServer *server;
|
||||||
|
struct sockaddr_in sa;
|
||||||
|
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!config->handler)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef TLS_IMPL
|
||||||
|
if (config->flags & HTTP_FLAG_TLS)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
server = Malloc(sizeof(HttpServer));
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(server, 0, sizeof(HttpServer));
|
||||||
|
|
||||||
|
server->config = *config;
|
||||||
|
server->config.tlsCert = StrDuplicate(config->tlsCert);
|
||||||
|
server->config.tlsKey = StrDuplicate(config->tlsKey);
|
||||||
|
|
||||||
|
server->threadPool = ArrayCreate();
|
||||||
|
if (!server->threadPool)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
server->connQueue = QueueCreate(config->maxConnections);
|
||||||
|
if (!server->connQueue)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pthread_mutex_init(&server->connQueueMutex, NULL) != 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
server->sd = socket(AF_INET, SOCK_STREAM, 0);
|
||||||
|
|
||||||
|
if (server->sd < 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (fcntl(server->sd, F_SETFL, O_NONBLOCK) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (setsockopt(server->sd, SOL_SOCKET, SO_REUSEADDR, &ENABLE, sizeof(int)) < 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef SO_REUSEPORT
|
||||||
|
if (setsockopt(server->sd, SOL_SOCKET, SO_REUSEPORT, &ENABLE, sizeof(int)) < 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
memset(&sa, 0, sizeof(struct sockaddr_in));
|
||||||
|
|
||||||
|
sa.sin_family = AF_INET;
|
||||||
|
sa.sin_port = htons(config->port);
|
||||||
|
sa.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||||
|
|
||||||
|
if (bind(server->sd, (struct sockaddr *) & sa, sizeof(sa)) < 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (listen(server->sd, config->maxConnections) < 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
server->stop = 0;
|
||||||
|
server->isRunning = 0;
|
||||||
|
|
||||||
|
return server;
|
||||||
|
|
||||||
|
error:
|
||||||
|
if (server)
|
||||||
|
{
|
||||||
|
if (server->connQueue)
|
||||||
|
{
|
||||||
|
QueueFree(server->connQueue);
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_destroy(&server->connQueueMutex);
|
||||||
|
|
||||||
|
if (server->threadPool)
|
||||||
|
{
|
||||||
|
ArrayFree(server->threadPool);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (server->sd)
|
||||||
|
{
|
||||||
|
close(server->sd);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(server);
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
HttpServerConfig *
|
||||||
|
HttpServerConfigGet(HttpServer * server)
|
||||||
|
{
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return &server->config;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpServerFree(HttpServer * server)
|
||||||
|
{
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
close(server->sd);
|
||||||
|
QueueFree(server->connQueue);
|
||||||
|
pthread_mutex_destroy(&server->connQueueMutex);
|
||||||
|
ArrayFree(server->threadPool);
|
||||||
|
Free(server->config.tlsCert);
|
||||||
|
Free(server->config.tlsKey);
|
||||||
|
Free(server);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void *
|
||||||
|
HttpServerWorkerThread(void *args)
|
||||||
|
{
|
||||||
|
HttpServerWorkerThreadArgs *wArgs = (HttpServerWorkerThreadArgs *) args;
|
||||||
|
HttpServer *server = wArgs->server;
|
||||||
|
|
||||||
|
while (!server->stop)
|
||||||
|
{
|
||||||
|
Stream *fp;
|
||||||
|
HttpServerContext *context;
|
||||||
|
|
||||||
|
char *line = NULL;
|
||||||
|
size_t lineSize = 0;
|
||||||
|
ssize_t lineLen = 0;
|
||||||
|
|
||||||
|
char *requestMethodPtr;
|
||||||
|
char *pathPtr;
|
||||||
|
char *requestPath;
|
||||||
|
char *requestProtocol;
|
||||||
|
|
||||||
|
HashMap *requestParams;
|
||||||
|
ssize_t requestPathLen;
|
||||||
|
|
||||||
|
ssize_t i = 0;
|
||||||
|
HttpRequestMethod requestMethod;
|
||||||
|
|
||||||
|
long firstRead;
|
||||||
|
|
||||||
|
fp = DequeueConnection(server);
|
||||||
|
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
/* Block for 1 millisecond before continuing so we don't
|
||||||
|
* murder the CPU if the queue is empty. */
|
||||||
|
UtilSleepMillis(1);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Get the first line of the request.
|
||||||
|
*
|
||||||
|
* Every once in a while, we're too fast for the client. When this
|
||||||
|
* happens, UtilGetLine() sets errno to EAGAIN. If we get
|
||||||
|
* EAGAIN, then clear the error on the stream and try again
|
||||||
|
* after a few ms. This is typically more than enough time for
|
||||||
|
* the client to send data. */
|
||||||
|
firstRead = UtilServerTs();
|
||||||
|
while ((lineLen = UtilGetLine(&line, &lineSize, fp)) == -1
|
||||||
|
&& errno == EAGAIN)
|
||||||
|
{
|
||||||
|
StreamClearError(fp);
|
||||||
|
|
||||||
|
/* If the server is stopped, or it's been a while, just
|
||||||
|
* give up so we aren't wasting a thread on this client. */
|
||||||
|
if (server->stop || (UtilServerTs() - firstRead) > 1000 * 30)
|
||||||
|
{
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
UtilSleepMillis(5);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lineLen == -1)
|
||||||
|
{
|
||||||
|
goto bad_request;
|
||||||
|
}
|
||||||
|
|
||||||
|
requestMethodPtr = line;
|
||||||
|
for (i = 0; i < lineLen; i++)
|
||||||
|
{
|
||||||
|
if (line[i] == ' ')
|
||||||
|
{
|
||||||
|
line[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i == lineLen)
|
||||||
|
{
|
||||||
|
goto bad_request;
|
||||||
|
}
|
||||||
|
|
||||||
|
requestMethod = HttpRequestMethodFromString(requestMethodPtr);
|
||||||
|
if (requestMethod == HTTP_METHOD_UNKNOWN)
|
||||||
|
{
|
||||||
|
goto bad_request;
|
||||||
|
}
|
||||||
|
|
||||||
|
pathPtr = line + i + 1;
|
||||||
|
|
||||||
|
for (i = 0; i < (line + lineLen) - pathPtr; i++)
|
||||||
|
{
|
||||||
|
if (pathPtr[i] == ' ')
|
||||||
|
{
|
||||||
|
pathPtr[i] = '\0';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
requestPathLen = i;
|
||||||
|
requestPath = Malloc(((requestPathLen + 1) * sizeof(char)));
|
||||||
|
strncpy(requestPath, pathPtr, requestPathLen + 1);
|
||||||
|
|
||||||
|
requestProtocol = &pathPtr[i + 1];
|
||||||
|
line[lineLen - 2] = '\0'; /* Get rid of \r and \n */
|
||||||
|
|
||||||
|
if (!StrEquals(requestProtocol, "HTTP/1.1") && !StrEquals(requestProtocol, "HTTP/1.0"))
|
||||||
|
{
|
||||||
|
Free(requestPath);
|
||||||
|
goto bad_request;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Find request params */
|
||||||
|
for (i = 0; i < requestPathLen; i++)
|
||||||
|
{
|
||||||
|
if (requestPath[i] == '?')
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
requestPath[i] = '\0';
|
||||||
|
requestParams = (i == requestPathLen) ? NULL : HttpParamDecode(requestPath + i + 1);
|
||||||
|
|
||||||
|
context = HttpServerContextCreate(requestMethod, requestPath, requestParams, fp);
|
||||||
|
if (!context)
|
||||||
|
{
|
||||||
|
Free(requestPath);
|
||||||
|
goto internal_error;
|
||||||
|
}
|
||||||
|
|
||||||
|
context->requestHeaders = HttpParseHeaders(fp);
|
||||||
|
if (!context->requestHeaders)
|
||||||
|
{
|
||||||
|
goto internal_error;
|
||||||
|
}
|
||||||
|
|
||||||
|
server->config.handler(context, server->config.handlerArgs);
|
||||||
|
|
||||||
|
HttpServerContextFree(context);
|
||||||
|
fp = NULL; /* The above call will close this
|
||||||
|
* Stream */
|
||||||
|
goto finish;
|
||||||
|
|
||||||
|
internal_error:
|
||||||
|
StreamPuts(fp, "HTTP/1.0 500 Internal Server Error\n");
|
||||||
|
StreamPuts(fp, "Connection: close\n");
|
||||||
|
goto finish;
|
||||||
|
|
||||||
|
bad_request:
|
||||||
|
StreamPuts(fp, "HTTP/1.0 400 Bad Request\n");
|
||||||
|
StreamPuts(fp, "Connection: close\n");
|
||||||
|
goto finish;
|
||||||
|
|
||||||
|
finish:
|
||||||
|
Free(line);
|
||||||
|
if (fp)
|
||||||
|
{
|
||||||
|
StreamClose(fp);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void *
|
||||||
|
HttpServerEventThread(void *args)
|
||||||
|
{
|
||||||
|
HttpServer *server = (HttpServer *) args;
|
||||||
|
struct pollfd pollFds[1];
|
||||||
|
Stream *fp;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
server->isRunning = 1;
|
||||||
|
server->stop = 0;
|
||||||
|
|
||||||
|
pollFds[0].fd = server->sd;
|
||||||
|
pollFds[0].events = POLLIN;
|
||||||
|
|
||||||
|
for (i = 0; i < server->config.threads; i++)
|
||||||
|
{
|
||||||
|
HttpServerWorkerThreadArgs *workerThread = Malloc(sizeof(HttpServerWorkerThreadArgs));
|
||||||
|
|
||||||
|
if (!workerThread)
|
||||||
|
{
|
||||||
|
/* TODO: Make the event thread return an error to the main
|
||||||
|
* thread */
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
workerThread->server = server;
|
||||||
|
workerThread->id = i;
|
||||||
|
|
||||||
|
if (pthread_create(&workerThread->thread, NULL, HttpServerWorkerThread, workerThread) != 0)
|
||||||
|
{
|
||||||
|
/* TODO: Make the event thread return an error to the main
|
||||||
|
* thread */
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
ArrayAdd(server->threadPool, workerThread);
|
||||||
|
}
|
||||||
|
|
||||||
|
while (!server->stop)
|
||||||
|
{
|
||||||
|
struct sockaddr_storage addr;
|
||||||
|
socklen_t addrLen = sizeof(addr);
|
||||||
|
int connFd;
|
||||||
|
int pollResult;
|
||||||
|
|
||||||
|
|
||||||
|
pollResult = poll(pollFds, 1, 500);
|
||||||
|
|
||||||
|
if (pollResult < 0)
|
||||||
|
{
|
||||||
|
/* The poll either timed out, or was interrupted. */
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&server->connQueueMutex);
|
||||||
|
|
||||||
|
/* Don't even accept connections if the queue is full. */
|
||||||
|
if (!QueueFull(server->connQueue))
|
||||||
|
{
|
||||||
|
connFd = accept(server->sd, (struct sockaddr *) & addr, &addrLen);
|
||||||
|
|
||||||
|
if (connFd < 0)
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&server->connQueueMutex);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef TLS_IMPL
|
||||||
|
if (server->config.flags & HTTP_FLAG_TLS)
|
||||||
|
{
|
||||||
|
fp = TlsServerStream(connFd, server->config.tlsCert, server->config.tlsKey);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
fp = StreamFd(connFd);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
fp = StreamFd(connFd);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&server->connQueueMutex);
|
||||||
|
close(connFd);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
QueuePush(server->connQueue, fp);
|
||||||
|
}
|
||||||
|
pthread_mutex_unlock(&server->connQueueMutex);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < server->config.threads; i++)
|
||||||
|
{
|
||||||
|
HttpServerWorkerThreadArgs *workerThread = ArrayGet(server->threadPool, i);
|
||||||
|
|
||||||
|
pthread_join(workerThread->thread, NULL);
|
||||||
|
Free(workerThread);
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((fp = DequeueConnection(server)))
|
||||||
|
{
|
||||||
|
StreamClose(fp);
|
||||||
|
}
|
||||||
|
|
||||||
|
server->isRunning = 0;
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
HttpServerStart(HttpServer * server)
|
||||||
|
{
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (server->isRunning)
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pthread_create(&server->socketThread, NULL, HttpServerEventThread, server) != 0)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpServerJoin(HttpServer * server)
|
||||||
|
{
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_join(server->socketThread, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
HttpServerStop(HttpServer * server)
|
||||||
|
{
|
||||||
|
if (!server)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
server->stop = 1;
|
||||||
|
}
|
212
src/Io.c
Normal file
212
src/Io.c
Normal file
|
@ -0,0 +1,212 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Io.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
|
struct Io
|
||||||
|
{
|
||||||
|
IoFunctions io;
|
||||||
|
void *cookie;
|
||||||
|
};
|
||||||
|
|
||||||
|
Io *
|
||||||
|
IoCreate(void *cookie, IoFunctions funcs)
|
||||||
|
{
|
||||||
|
Io *io;
|
||||||
|
|
||||||
|
/* Must have at least read or write */
|
||||||
|
if (!funcs.read && !funcs.write)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
io = Malloc(sizeof(Io));
|
||||||
|
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
io->cookie = cookie;
|
||||||
|
|
||||||
|
io->io.read = funcs.read;
|
||||||
|
io->io.write = funcs.write;
|
||||||
|
io->io.seek = funcs.seek;
|
||||||
|
io->io.close = funcs.close;
|
||||||
|
|
||||||
|
return io;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
IoRead(Io * io, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
if (!io || !io->io.read)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return io->io.read(io->cookie, buf, nBytes);
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
IoWrite(Io * io, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
if (!io || !io->io.write)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return io->io.write(io->cookie, buf, nBytes);
|
||||||
|
}
|
||||||
|
|
||||||
|
off_t
|
||||||
|
IoSeek(Io * io, off_t offset, int whence)
|
||||||
|
{
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!io->io.seek)
|
||||||
|
{
|
||||||
|
errno = EINVAL;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return io->io.seek(io->cookie, offset, whence);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
IoClose(Io * io)
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (io->io.close)
|
||||||
|
{
|
||||||
|
ret = io->io.close(io->cookie);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ret = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(io);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
IoVprintf(Io * io, const char *fmt, va_list ap)
|
||||||
|
{
|
||||||
|
char *buf = NULL;
|
||||||
|
size_t bufSize = 0;
|
||||||
|
FILE *fp;
|
||||||
|
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (!io || !fmt)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
fp = open_memstream(&buf, &bufSize);
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = vfprintf(fp, fmt, ap);
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
if (ret >= 0)
|
||||||
|
{
|
||||||
|
ret = IoWrite(io, buf, bufSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
free(buf); /* Allocated by stdlib, not Memory
|
||||||
|
* API */
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
IoPrintf(Io * io, const char *fmt,...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
va_start(ap, fmt);
|
||||||
|
ret = IoVprintf(io, fmt, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
IoCopy(Io * in, Io * out)
|
||||||
|
{
|
||||||
|
ssize_t nBytes = 0;
|
||||||
|
char buf[IO_BUFFER];
|
||||||
|
ssize_t rRes;
|
||||||
|
ssize_t wRes;
|
||||||
|
|
||||||
|
if (!in || !out)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((rRes = IoRead(in, &buf, IO_BUFFER)) != 0)
|
||||||
|
{
|
||||||
|
if (rRes == -1)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
wRes = IoWrite(out, &buf, rRes);
|
||||||
|
|
||||||
|
if (wRes == -1)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
nBytes += wRes;
|
||||||
|
}
|
||||||
|
|
||||||
|
return nBytes;
|
||||||
|
}
|
95
src/Io/IoFd.c
Normal file
95
src/Io/IoFd.c
Normal file
|
@ -0,0 +1,95 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Io.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
IoReadFd(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
int fd = *((int *) cookie);
|
||||||
|
|
||||||
|
return read(fd, buf, nBytes);
|
||||||
|
}
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
IoWriteFd(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
int fd = *((int *) cookie);
|
||||||
|
|
||||||
|
return write(fd, buf, nBytes);
|
||||||
|
}
|
||||||
|
|
||||||
|
static off_t
|
||||||
|
IoSeekFd(void *cookie, off_t offset, int whence)
|
||||||
|
{
|
||||||
|
int fd = *((int *) cookie);
|
||||||
|
|
||||||
|
return lseek(fd, offset, whence);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
IoCloseFd(void *cookie)
|
||||||
|
{
|
||||||
|
int fd = *((int *) cookie);
|
||||||
|
|
||||||
|
Free(cookie);
|
||||||
|
return close(fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
Io *
|
||||||
|
IoFd(int fd)
|
||||||
|
{
|
||||||
|
int *cookie = Malloc(sizeof(int));
|
||||||
|
IoFunctions f;
|
||||||
|
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
*cookie = fd;
|
||||||
|
|
||||||
|
f.read = IoReadFd;
|
||||||
|
f.write = IoWriteFd;
|
||||||
|
f.seek = IoSeekFd;
|
||||||
|
f.close = IoCloseFd;
|
||||||
|
|
||||||
|
return IoCreate(cookie, f);
|
||||||
|
}
|
||||||
|
|
||||||
|
Io *
|
||||||
|
IoOpen(const char *path, int flags, mode_t mode)
|
||||||
|
{
|
||||||
|
int fd = open(path, flags, mode);
|
||||||
|
|
||||||
|
if (fd == -1)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return IoFd(fd);
|
||||||
|
}
|
91
src/Io/IoFile.c
Normal file
91
src/Io/IoFile.c
Normal file
|
@ -0,0 +1,91 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Io.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
IoReadFile(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
FILE *fp = cookie;
|
||||||
|
|
||||||
|
return fread(buf, 1, nBytes, fp);
|
||||||
|
}
|
||||||
|
|
||||||
|
static ssize_t
|
||||||
|
IoWriteFile(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
FILE *fp = cookie;
|
||||||
|
size_t res = fwrite(buf, 1, nBytes, fp);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* fwrite() may be buffered on some platforms, but at this low level,
|
||||||
|
* it should not be; buffering happens in Stream, not Io.
|
||||||
|
*/
|
||||||
|
fflush(fp);
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static off_t
|
||||||
|
IoSeekFile(void *cookie, off_t offset, int whence)
|
||||||
|
{
|
||||||
|
FILE *fp = cookie;
|
||||||
|
off_t ret = fseeko(fp, offset, whence);
|
||||||
|
|
||||||
|
if (ret > -1)
|
||||||
|
{
|
||||||
|
return ftello(fp);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
IoCloseFile(void *cookie)
|
||||||
|
{
|
||||||
|
FILE *fp = cookie;
|
||||||
|
|
||||||
|
return fclose(fp);
|
||||||
|
}
|
||||||
|
|
||||||
|
Io *
|
||||||
|
IoFile(FILE * fp)
|
||||||
|
{
|
||||||
|
IoFunctions f;
|
||||||
|
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
f.read = IoReadFile;
|
||||||
|
f.write = IoWriteFile;
|
||||||
|
f.seek = IoSeekFile;
|
||||||
|
f.close = IoCloseFile;
|
||||||
|
|
||||||
|
return IoCreate(fp, f);
|
||||||
|
}
|
1384
src/Json.c
Normal file
1384
src/Json.c
Normal file
File diff suppressed because it is too large
Load diff
388
src/Log.c
Normal file
388
src/Log.c
Normal file
|
@ -0,0 +1,388 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Log.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <time.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
|
||||||
|
#define LOG_TSBUFFER 64
|
||||||
|
|
||||||
|
struct LogConfig
|
||||||
|
{
|
||||||
|
int level;
|
||||||
|
size_t indent;
|
||||||
|
Stream *out;
|
||||||
|
int flags;
|
||||||
|
char *tsFmt;
|
||||||
|
|
||||||
|
pthread_mutex_t lock;
|
||||||
|
};
|
||||||
|
|
||||||
|
LogConfig *globalConfig = NULL;
|
||||||
|
|
||||||
|
LogConfig *
|
||||||
|
LogConfigCreate(void)
|
||||||
|
{
|
||||||
|
LogConfig *config;
|
||||||
|
|
||||||
|
config = Malloc(sizeof(LogConfig));
|
||||||
|
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(config, 0, sizeof(LogConfig));
|
||||||
|
|
||||||
|
LogConfigLevelSet(config, LOG_INFO);
|
||||||
|
LogConfigIndentSet(config, 0);
|
||||||
|
LogConfigOutputSet(config, NULL); /* Will set to stdout */
|
||||||
|
LogConfigFlagSet(config, LOG_FLAG_COLOR);
|
||||||
|
LogConfigTimeStampFormatSet(config, "%y-%m-%d %H:%M:%S");
|
||||||
|
|
||||||
|
return config;
|
||||||
|
}
|
||||||
|
|
||||||
|
LogConfig *
|
||||||
|
LogConfigGlobal(void)
|
||||||
|
{
|
||||||
|
if (!globalConfig)
|
||||||
|
{
|
||||||
|
globalConfig = LogConfigCreate();
|
||||||
|
}
|
||||||
|
|
||||||
|
return globalConfig;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigFlagClear(LogConfig * config, int flags)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
config->flags &= ~flags;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
LogConfigFlagGet(LogConfig * config, int flags)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return config->flags & flags;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigFlagSet(LogConfig * config, int flags)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
config->flags |= flags;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigFree(LogConfig * config)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(config);
|
||||||
|
|
||||||
|
if (config == globalConfig)
|
||||||
|
{
|
||||||
|
globalConfig = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigIndent(LogConfig * config)
|
||||||
|
{
|
||||||
|
if (config)
|
||||||
|
{
|
||||||
|
config->indent += 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigIndentSet(LogConfig * config, size_t indent)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
config->indent = indent;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
LogConfigLevelGet(LogConfig * config)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return config->level;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigLevelSet(LogConfig * config, int level)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (level)
|
||||||
|
{
|
||||||
|
case LOG_ERR:
|
||||||
|
case LOG_WARNING:
|
||||||
|
case LOG_INFO:
|
||||||
|
case LOG_DEBUG:
|
||||||
|
config->level = level;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigOutputSet(LogConfig * config, Stream * out)
|
||||||
|
{
|
||||||
|
if (!config)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (out)
|
||||||
|
{
|
||||||
|
config->out = out;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
config->out = StreamStdout();
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigTimeStampFormatSet(LogConfig * config, char *tsFmt)
|
||||||
|
{
|
||||||
|
if (config)
|
||||||
|
{
|
||||||
|
config->tsFmt = tsFmt;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogConfigUnindent(LogConfig * config)
|
||||||
|
{
|
||||||
|
if (config && config->indent >= 2)
|
||||||
|
{
|
||||||
|
config->indent -= 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
Logv(LogConfig * config, int level, const char *msg, va_list argp)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
int doColor;
|
||||||
|
char indicator;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Only proceed if we have a config and its log level is set to a
|
||||||
|
* value that permits us to log. This is as close as we can get
|
||||||
|
* to a no-op function if we aren't logging anything, without doing
|
||||||
|
* some crazy macro magic.
|
||||||
|
*/
|
||||||
|
if (!config || level > config->level)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Misconfiguration */
|
||||||
|
if (!config->out)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_lock(&config->lock);
|
||||||
|
|
||||||
|
if (LogConfigFlagGet(config, LOG_FLAG_SYSLOG))
|
||||||
|
{
|
||||||
|
/* No further print logic is needed; syslog will handle it all
|
||||||
|
* for us. */
|
||||||
|
vsyslog(level, msg, argp);
|
||||||
|
pthread_mutex_unlock(&config->lock);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
doColor = LogConfigFlagGet(config, LOG_FLAG_COLOR)
|
||||||
|
&& isatty(StreamFileno(config->out));
|
||||||
|
|
||||||
|
if (doColor)
|
||||||
|
{
|
||||||
|
char *ansi;
|
||||||
|
|
||||||
|
switch (level)
|
||||||
|
{
|
||||||
|
case LOG_EMERG:
|
||||||
|
case LOG_ALERT:
|
||||||
|
case LOG_CRIT:
|
||||||
|
case LOG_ERR:
|
||||||
|
/* Bold Red */
|
||||||
|
ansi = "\033[1;31m";
|
||||||
|
break;
|
||||||
|
case LOG_WARNING:
|
||||||
|
/* Bold Yellow */
|
||||||
|
ansi = "\033[1;33m";
|
||||||
|
break;
|
||||||
|
case LOG_NOTICE:
|
||||||
|
/* Bold Magenta */
|
||||||
|
ansi = "\033[1;35m";
|
||||||
|
break;
|
||||||
|
case LOG_INFO:
|
||||||
|
/* Bold Green */
|
||||||
|
ansi = "\033[1;32m";
|
||||||
|
break;
|
||||||
|
case LOG_DEBUG:
|
||||||
|
/* Bold Blue */
|
||||||
|
ansi = "\033[1;34m";
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ansi = "";
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPuts(config->out, ansi);
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPutc(config->out, '[');
|
||||||
|
|
||||||
|
if (config->tsFmt)
|
||||||
|
{
|
||||||
|
time_t timer = time(NULL);
|
||||||
|
struct tm *timeInfo = localtime(&timer);
|
||||||
|
char tsBuffer[LOG_TSBUFFER];
|
||||||
|
|
||||||
|
int tsLength = strftime(tsBuffer, LOG_TSBUFFER, config->tsFmt,
|
||||||
|
timeInfo);
|
||||||
|
|
||||||
|
if (tsLength)
|
||||||
|
{
|
||||||
|
StreamPuts(config->out, tsBuffer);
|
||||||
|
if (!isspace((unsigned char) tsBuffer[tsLength - 1]))
|
||||||
|
{
|
||||||
|
StreamPutc(config->out, ' ');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (level)
|
||||||
|
{
|
||||||
|
case LOG_EMERG:
|
||||||
|
indicator = '#';
|
||||||
|
break;
|
||||||
|
case LOG_ALERT:
|
||||||
|
indicator = '@';
|
||||||
|
break;
|
||||||
|
case LOG_CRIT:
|
||||||
|
indicator = 'X';
|
||||||
|
break;
|
||||||
|
case LOG_ERR:
|
||||||
|
indicator = 'x';
|
||||||
|
break;
|
||||||
|
case LOG_WARNING:
|
||||||
|
indicator = '!';
|
||||||
|
break;
|
||||||
|
case LOG_NOTICE:
|
||||||
|
indicator = '~';
|
||||||
|
break;
|
||||||
|
case LOG_INFO:
|
||||||
|
indicator = '>';
|
||||||
|
break;
|
||||||
|
case LOG_DEBUG:
|
||||||
|
indicator = '*';
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
indicator = '?';
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPrintf(config->out, "%c]", indicator);
|
||||||
|
|
||||||
|
if (doColor)
|
||||||
|
{
|
||||||
|
/* ANSI Reset */
|
||||||
|
StreamPuts(config->out, "\033[0m");
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPutc(config->out, ' ');
|
||||||
|
for (i = 0; i < config->indent; i++)
|
||||||
|
{
|
||||||
|
StreamPutc(config->out, ' ');
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamVprintf(config->out, msg, argp);
|
||||||
|
StreamPutc(config->out, '\n');
|
||||||
|
|
||||||
|
StreamFlush(config->out);
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&config->lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
LogTo(LogConfig * config, int level, const char *fmt,...)
|
||||||
|
{
|
||||||
|
va_list argp;
|
||||||
|
|
||||||
|
va_start(argp, fmt);
|
||||||
|
Logv(config, level, fmt, argp);
|
||||||
|
va_end(argp);
|
||||||
|
}
|
||||||
|
|
||||||
|
extern void
|
||||||
|
Log(int level, const char *fmt,...)
|
||||||
|
{
|
||||||
|
va_list argp;
|
||||||
|
|
||||||
|
va_start(argp, fmt);
|
||||||
|
Logv(LogConfigGlobal(), level, fmt, argp);
|
||||||
|
va_end(argp);
|
||||||
|
}
|
493
src/Memory.c
Normal file
493
src/Memory.c
Normal file
|
@ -0,0 +1,493 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
|
||||||
|
#ifndef MEMORY_TABLE_CHUNK
|
||||||
|
#define MEMORY_TABLE_CHUNK 256
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef MEMORY_HEXDUMP_WIDTH
|
||||||
|
#define MEMORY_HEXDUMP_WIDTH 16
|
||||||
|
#endif
|
||||||
|
|
||||||
|
struct MemoryInfo
|
||||||
|
{
|
||||||
|
size_t size;
|
||||||
|
const char *file;
|
||||||
|
int line;
|
||||||
|
void *pointer;
|
||||||
|
};
|
||||||
|
|
||||||
|
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
||||||
|
static void (*hook) (MemoryAction, MemoryInfo *, void *) = NULL;
|
||||||
|
static void *hookArgs = NULL;
|
||||||
|
|
||||||
|
static MemoryInfo **allocations = NULL;
|
||||||
|
static size_t allocationsSize = 0;
|
||||||
|
static size_t allocationsLen = 0;
|
||||||
|
|
||||||
|
static size_t
|
||||||
|
MemoryHash(void *p)
|
||||||
|
{
|
||||||
|
return (((size_t) p) >> 2 * 7) % allocationsSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
MemoryInsert(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
size_t hash;
|
||||||
|
|
||||||
|
if (!allocations)
|
||||||
|
{
|
||||||
|
allocationsSize = MEMORY_TABLE_CHUNK;
|
||||||
|
allocations = calloc(allocationsSize, sizeof(void *));
|
||||||
|
if (!allocations)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If the next insertion would cause the table to be at least 3/4
|
||||||
|
* full, re-allocate and re-hash. */
|
||||||
|
if ((allocationsLen + 1) >= ((allocationsSize * 3) >> 2))
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
size_t tmpAllocationsSize = allocationsSize;
|
||||||
|
MemoryInfo **tmpAllocations;
|
||||||
|
|
||||||
|
allocationsSize += MEMORY_TABLE_CHUNK;
|
||||||
|
tmpAllocations = calloc(allocationsSize, sizeof(void *));
|
||||||
|
|
||||||
|
if (!tmpAllocations)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < tmpAllocationsSize; i++)
|
||||||
|
{
|
||||||
|
if (allocations[i])
|
||||||
|
{
|
||||||
|
hash = MemoryHash(allocations[i]->pointer);
|
||||||
|
|
||||||
|
while (tmpAllocations[hash])
|
||||||
|
{
|
||||||
|
hash = (hash + 1) % allocationsSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmpAllocations[hash] = allocations[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
free(allocations);
|
||||||
|
allocations = tmpAllocations;
|
||||||
|
}
|
||||||
|
|
||||||
|
hash = MemoryHash(a->pointer);
|
||||||
|
|
||||||
|
while (allocations[hash])
|
||||||
|
{
|
||||||
|
hash = (hash + 1) % allocationsSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
allocations[hash] = a;
|
||||||
|
allocationsLen++;
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
MemoryDelete(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
size_t hash = MemoryHash(a->pointer);
|
||||||
|
size_t count = 0;
|
||||||
|
|
||||||
|
while (count <= allocationsSize)
|
||||||
|
{
|
||||||
|
if (allocations[hash] && allocations[hash] == a)
|
||||||
|
{
|
||||||
|
allocations[hash] = NULL;
|
||||||
|
allocationsLen--;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
hash = (hash + 1) % allocationsSize;
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
MemoryAllocate(size_t size, const char *file, int line)
|
||||||
|
{
|
||||||
|
void *p;
|
||||||
|
MemoryInfo *a;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
|
||||||
|
p = malloc(size);
|
||||||
|
if (!p)
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
a = malloc(sizeof(MemoryInfo));
|
||||||
|
if (!a)
|
||||||
|
{
|
||||||
|
free(p);
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
a->size = size;
|
||||||
|
a->file = file;
|
||||||
|
a->line = line;
|
||||||
|
a->pointer = p;
|
||||||
|
|
||||||
|
if (!MemoryInsert(a))
|
||||||
|
{
|
||||||
|
free(a);
|
||||||
|
free(p);
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (hook)
|
||||||
|
{
|
||||||
|
hook(MEMORY_ALLOCATE, a, hookArgs);
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
MemoryReallocate(void *p, size_t size, const char *file, int line)
|
||||||
|
{
|
||||||
|
MemoryInfo *a;
|
||||||
|
void *new = NULL;
|
||||||
|
|
||||||
|
if (!p)
|
||||||
|
{
|
||||||
|
return MemoryAllocate(size, file, line);
|
||||||
|
}
|
||||||
|
|
||||||
|
a = MemoryInfoGet(p);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
new = realloc(a->pointer, size);
|
||||||
|
if (new)
|
||||||
|
{
|
||||||
|
MemoryDelete(a);
|
||||||
|
a->size = size;
|
||||||
|
a->file = file;
|
||||||
|
a->line = line;
|
||||||
|
|
||||||
|
a->pointer = new;
|
||||||
|
MemoryInsert(a);
|
||||||
|
|
||||||
|
if (hook)
|
||||||
|
{
|
||||||
|
hook(MEMORY_REALLOCATE, a, hookArgs);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
}
|
||||||
|
else if (hook)
|
||||||
|
{
|
||||||
|
a = malloc(sizeof(MemoryInfo));
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
a->size = 0;
|
||||||
|
a->file = file;
|
||||||
|
a->line = line;
|
||||||
|
a->pointer = p;
|
||||||
|
hook(MEMORY_BAD_POINTER, a, hookArgs);
|
||||||
|
free(a);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
return new;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
MemoryFree(void *p, const char *file, int line)
|
||||||
|
{
|
||||||
|
MemoryInfo *a;
|
||||||
|
|
||||||
|
if (!p)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
a = MemoryInfoGet(p);
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
if (hook)
|
||||||
|
{
|
||||||
|
a->file = file;
|
||||||
|
a->line = line;
|
||||||
|
hook(MEMORY_FREE, a, hookArgs);
|
||||||
|
}
|
||||||
|
MemoryDelete(a);
|
||||||
|
free(a->pointer);
|
||||||
|
free(a);
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
}
|
||||||
|
else if (hook)
|
||||||
|
{
|
||||||
|
a = malloc(sizeof(MemoryInfo));
|
||||||
|
if (a)
|
||||||
|
{
|
||||||
|
a->file = file;
|
||||||
|
a->line = line;
|
||||||
|
a->size = 0;
|
||||||
|
a->pointer = p;
|
||||||
|
hook(MEMORY_BAD_POINTER, a, hookArgs);
|
||||||
|
free(a);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t
|
||||||
|
MemoryAllocated(void)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
size_t total = 0;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
|
||||||
|
for (i = 0; i < allocationsSize; i++)
|
||||||
|
{
|
||||||
|
if (allocations[i])
|
||||||
|
{
|
||||||
|
total += allocations[i]->size;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
|
||||||
|
return total;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
MemoryFreeAll(void)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
|
||||||
|
for (i = 0; i < allocationsSize; i++)
|
||||||
|
{
|
||||||
|
if (allocations[i])
|
||||||
|
{
|
||||||
|
free(allocations[i]->pointer);
|
||||||
|
free(allocations[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
free(allocations);
|
||||||
|
allocations = NULL;
|
||||||
|
allocationsSize = 0;
|
||||||
|
allocationsLen = 0;
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
MemoryInfo *
|
||||||
|
MemoryInfoGet(void *p)
|
||||||
|
{
|
||||||
|
size_t hash, count;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
|
||||||
|
hash = MemoryHash(p);
|
||||||
|
|
||||||
|
count = 0;
|
||||||
|
while (count <= allocationsSize)
|
||||||
|
{
|
||||||
|
if (!allocations[hash] || allocations[hash]->pointer != p)
|
||||||
|
{
|
||||||
|
hash = (hash + 1) % allocationsSize;
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return allocations[hash];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t
|
||||||
|
MemoryInfoGetSize(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
if (!a)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return a->size;
|
||||||
|
}
|
||||||
|
|
||||||
|
const char *
|
||||||
|
MemoryInfoGetFile(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
if (!a)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return a->file;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
MemoryInfoGetLine(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
if (!a)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return a->line;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
MemoryInfoGetPointer(MemoryInfo * a)
|
||||||
|
{
|
||||||
|
if (!a)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return a->pointer;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
MemoryIterate(void (*iterFunc) (MemoryInfo *, void *), void *args)
|
||||||
|
{
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
|
||||||
|
for (i = 0; i < allocationsSize; i++)
|
||||||
|
{
|
||||||
|
if (allocations[i])
|
||||||
|
{
|
||||||
|
iterFunc(allocations[i], args);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
MemoryHook(void (*memHook) (MemoryAction, MemoryInfo *, void *), void *args)
|
||||||
|
{
|
||||||
|
pthread_mutex_lock(&lock);
|
||||||
|
hook = memHook;
|
||||||
|
hookArgs = args;
|
||||||
|
pthread_mutex_unlock(&lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
MemoryHexDump(MemoryInfo * info, void (*printFunc) (size_t, char *, char *, void *), void *args)
|
||||||
|
{
|
||||||
|
char hexBuf[(MEMORY_HEXDUMP_WIDTH * 2) + MEMORY_HEXDUMP_WIDTH + 1];
|
||||||
|
char asciiBuf[MEMORY_HEXDUMP_WIDTH + 1];
|
||||||
|
size_t pI = 0;
|
||||||
|
size_t hI = 0;
|
||||||
|
size_t aI = 0;
|
||||||
|
const unsigned char *pc;
|
||||||
|
|
||||||
|
if (!info || !printFunc)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
pc = MemoryInfoGetPointer(info);
|
||||||
|
|
||||||
|
for (pI = 0; pI < MemoryInfoGetSize(info); pI++)
|
||||||
|
{
|
||||||
|
if (pI > 0 && pI % MEMORY_HEXDUMP_WIDTH == 0)
|
||||||
|
{
|
||||||
|
hexBuf[hI - 1] = '\0';
|
||||||
|
asciiBuf[aI] = '\0';
|
||||||
|
|
||||||
|
printFunc(pI - MEMORY_HEXDUMP_WIDTH, hexBuf, asciiBuf, args);
|
||||||
|
|
||||||
|
snprintf(hexBuf, 4, "%02x ", pc[pI]);
|
||||||
|
hI = 3;
|
||||||
|
|
||||||
|
asciiBuf[0] = isprint(pc[pI]) ? pc[pI] : '.';
|
||||||
|
asciiBuf[1] = '\0';
|
||||||
|
aI = 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
asciiBuf[aI] = isprint(pc[pI]) ? pc[pI] : '.';
|
||||||
|
aI++;
|
||||||
|
|
||||||
|
snprintf(hexBuf + hI, 4, "%02x ", pc[pI]);
|
||||||
|
hI += 3;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
hexBuf[hI] = '\0';
|
||||||
|
hI--;
|
||||||
|
|
||||||
|
while (hI < sizeof(hexBuf) - 2)
|
||||||
|
{
|
||||||
|
hexBuf[hI] = ' ';
|
||||||
|
hI++;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (aI < sizeof(asciiBuf) - 1)
|
||||||
|
{
|
||||||
|
asciiBuf[aI] = ' ';
|
||||||
|
aI++;
|
||||||
|
}
|
||||||
|
|
||||||
|
hexBuf[hI] = '\0';
|
||||||
|
asciiBuf[aI] = '\0';
|
||||||
|
|
||||||
|
printFunc(pI - ((pI % MEMORY_HEXDUMP_WIDTH) ?
|
||||||
|
(pI % MEMORY_HEXDUMP_WIDTH) : MEMORY_HEXDUMP_WIDTH),
|
||||||
|
hexBuf, asciiBuf, args);
|
||||||
|
printFunc(pI, NULL, NULL, args);
|
||||||
|
}
|
176
src/Queue.c
Normal file
176
src/Queue.c
Normal file
|
@ -0,0 +1,176 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Queue.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
struct Queue
|
||||||
|
{
|
||||||
|
void **items;
|
||||||
|
size_t size;
|
||||||
|
size_t front;
|
||||||
|
size_t rear;
|
||||||
|
};
|
||||||
|
|
||||||
|
Queue *
|
||||||
|
QueueCreate(size_t size)
|
||||||
|
{
|
||||||
|
Queue *q;
|
||||||
|
|
||||||
|
if (!size)
|
||||||
|
{
|
||||||
|
/* Can't have a queue of length zero */
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
q = Malloc(sizeof(Queue));
|
||||||
|
if (!q)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
q->items = Malloc(size * sizeof(void *));
|
||||||
|
if (!q->items)
|
||||||
|
{
|
||||||
|
Free(q);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
q->size = size;
|
||||||
|
q->front = size + 1;
|
||||||
|
q->rear = size + 1;
|
||||||
|
|
||||||
|
return q;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
QueueFree(Queue * q)
|
||||||
|
{
|
||||||
|
if (q)
|
||||||
|
{
|
||||||
|
Free(q->items);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(q);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
QueueFull(Queue * q)
|
||||||
|
{
|
||||||
|
if (!q)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ((q->front == q->rear + 1) || (q->front == 0 && q->rear == q->size - 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
QueueEmpty(Queue * q)
|
||||||
|
{
|
||||||
|
if (!q)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return q->front == q->size + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
QueuePush(Queue * q, void *element)
|
||||||
|
{
|
||||||
|
if (!q || !element)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (QueueFull(q))
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (q->front == q->size + 1)
|
||||||
|
{
|
||||||
|
q->front = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (q->rear == q->size + 1)
|
||||||
|
{
|
||||||
|
q->rear = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
q->rear = (q->rear + 1) % q->size;
|
||||||
|
}
|
||||||
|
|
||||||
|
q->items[q->rear] = element;
|
||||||
|
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
QueuePop(Queue * q)
|
||||||
|
{
|
||||||
|
void *element;
|
||||||
|
|
||||||
|
if (!q)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (QueueEmpty(q))
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
element = q->items[q->front];
|
||||||
|
|
||||||
|
if (q->front == q->rear)
|
||||||
|
{
|
||||||
|
q->front = q->size + 1;
|
||||||
|
q->rear = q->size + 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
q->front = (q->front + 1) % q->size;
|
||||||
|
}
|
||||||
|
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
QueuePeek(Queue * q)
|
||||||
|
{
|
||||||
|
if (!q)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (QueueEmpty(q))
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return q->items[q->front];
|
||||||
|
}
|
172
src/Rand.c
Normal file
172
src/Rand.c
Normal file
|
@ -0,0 +1,172 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Rand.h>
|
||||||
|
|
||||||
|
#include <Int.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
#define RAND_STATE_VECTOR_LENGTH 624
|
||||||
|
#define RAND_STATE_VECTOR_M 397
|
||||||
|
|
||||||
|
#define RAND_UPPER_MASK 0x80000000
|
||||||
|
#define RAND_LOWER_MASK 0x7FFFFFFF
|
||||||
|
#define RAND_TEMPER_B 0x9D2C5680
|
||||||
|
#define RAND_TEMPER_C 0xEFC60000
|
||||||
|
|
||||||
|
typedef struct RandState
|
||||||
|
{
|
||||||
|
UInt32 mt[RAND_STATE_VECTOR_LENGTH];
|
||||||
|
int index;
|
||||||
|
} RandState;
|
||||||
|
|
||||||
|
static void
|
||||||
|
RandSeed(RandState * state, UInt32 seed)
|
||||||
|
{
|
||||||
|
state->mt[0] = seed & 0xFFFFFFFF;
|
||||||
|
|
||||||
|
for (state->index = 1; state->index < RAND_STATE_VECTOR_LENGTH; state->index++)
|
||||||
|
{
|
||||||
|
state->mt[state->index] = (6069 * state->mt[state->index - 1]) & 0xFFFFFFFF;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static UInt32
|
||||||
|
RandGenerate(RandState * state)
|
||||||
|
{
|
||||||
|
static const UInt32 mag[2] = {0x0, 0x9908B0DF};
|
||||||
|
|
||||||
|
UInt32 result;
|
||||||
|
|
||||||
|
if (state->index >= RAND_STATE_VECTOR_LENGTH || state->index < 0)
|
||||||
|
{
|
||||||
|
int kk;
|
||||||
|
|
||||||
|
if (state->index >= RAND_STATE_VECTOR_LENGTH + 1 || state->index < 0)
|
||||||
|
{
|
||||||
|
RandSeed(state, 4357);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (kk = 0; kk < RAND_STATE_VECTOR_LENGTH - RAND_STATE_VECTOR_M; kk++)
|
||||||
|
{
|
||||||
|
result = (state->mt[kk] & RAND_UPPER_MASK) | (state->mt[kk + 1] & RAND_LOWER_MASK);
|
||||||
|
state->mt[kk] = state->mt[kk + RAND_STATE_VECTOR_M] ^ (result >> 1) ^ mag[result & 0x1];
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; kk < RAND_STATE_VECTOR_LENGTH - 1; kk++)
|
||||||
|
{
|
||||||
|
result = (state->mt[kk] & RAND_UPPER_MASK) | (state->mt[kk + 1] & RAND_LOWER_MASK);
|
||||||
|
state->mt[kk] = state->mt[kk + (RAND_STATE_VECTOR_M - RAND_STATE_VECTOR_LENGTH)] ^ (result >> 1) ^ mag[result & 0x1];
|
||||||
|
}
|
||||||
|
|
||||||
|
result = (state->mt[RAND_STATE_VECTOR_LENGTH - 1] & RAND_UPPER_MASK) | (state->mt[0] & RAND_LOWER_MASK);
|
||||||
|
state->mt[RAND_STATE_VECTOR_LENGTH - 1] = state->mt[RAND_STATE_VECTOR_M - 1] ^ (result >> 1) ^ mag[result & 0x1];
|
||||||
|
state->index = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = state->mt[state->index++];
|
||||||
|
result ^= (result >> 11);
|
||||||
|
result ^= (result << 7) & RAND_TEMPER_B;
|
||||||
|
result ^= (result << 15) & RAND_TEMPER_C;
|
||||||
|
result ^= (result >> 18);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
RandDestructor(void *p)
|
||||||
|
{
|
||||||
|
Free(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Generate random numbers using rejection sampling. The basic idea is
|
||||||
|
* to "reroll" if a number happens to be outside the range. However
|
||||||
|
* this could be extremely inefficient.
|
||||||
|
*
|
||||||
|
* Another idea would just be to "reroll" if the generated number ends up
|
||||||
|
* in the previously "biased" range, and THEN do a modulo.
|
||||||
|
*
|
||||||
|
* This would be far more efficient for small values of max, and fixes the
|
||||||
|
* bias issue. */
|
||||||
|
|
||||||
|
/* This algorithm therefore computes N random numbers generally in O(N)
|
||||||
|
* time, while being less biased. */
|
||||||
|
void
|
||||||
|
RandIntN(int *buf, size_t size, unsigned int max)
|
||||||
|
{
|
||||||
|
static pthread_key_t stateKey;
|
||||||
|
static int createdKey = 0;
|
||||||
|
|
||||||
|
/* Limit the range to banish all previously biased results */
|
||||||
|
const int allowed = RAND_MAX - RAND_MAX % max;
|
||||||
|
|
||||||
|
RandState *state;
|
||||||
|
int tmp;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (!createdKey)
|
||||||
|
{
|
||||||
|
pthread_key_create(&stateKey, RandDestructor);
|
||||||
|
createdKey = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
state = pthread_getspecific(stateKey);
|
||||||
|
|
||||||
|
if (!state)
|
||||||
|
{
|
||||||
|
/* Generate a seed from the system time, PID, and TID */
|
||||||
|
UInt32 seed = UtilServerTs() ^ getpid() ^ (unsigned long) pthread_self();
|
||||||
|
|
||||||
|
state = Malloc(sizeof(RandState));
|
||||||
|
RandSeed(state, seed);
|
||||||
|
|
||||||
|
pthread_setspecific(stateKey, state);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Generate {size} random numbers. */
|
||||||
|
for (i = 0; i < size; i++)
|
||||||
|
{
|
||||||
|
/* Most of the time, this will take about 1 loop */
|
||||||
|
do
|
||||||
|
{
|
||||||
|
tmp = RandGenerate(state);
|
||||||
|
} while (tmp > allowed);
|
||||||
|
|
||||||
|
buf[i] = tmp % max;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Generate just 1 random number */
|
||||||
|
int
|
||||||
|
RandInt(unsigned int max)
|
||||||
|
{
|
||||||
|
int val = 0;
|
||||||
|
|
||||||
|
RandIntN(&val, 1, max);
|
||||||
|
return val;
|
||||||
|
}
|
162
src/RtStub.c
Normal file
162
src/RtStub.c
Normal file
|
@ -0,0 +1,162 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Runtime.h>
|
||||||
|
#include <Array.h>
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
#include <Log.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
|
||||||
|
/* Specified by POSIX to contain environment variables */
|
||||||
|
extern char **environ;
|
||||||
|
|
||||||
|
/* The linking program is expected to provide Main */
|
||||||
|
extern int Main(Array *, HashMap *);
|
||||||
|
|
||||||
|
typedef struct MainArgs
|
||||||
|
{
|
||||||
|
Array *args;
|
||||||
|
HashMap *env;
|
||||||
|
} MainArgs;
|
||||||
|
|
||||||
|
static void *
|
||||||
|
MainThread(void *argp)
|
||||||
|
{
|
||||||
|
long ret;
|
||||||
|
MainArgs *args = argp;
|
||||||
|
|
||||||
|
args = argp;
|
||||||
|
ret = Main(args->args, args->env);
|
||||||
|
|
||||||
|
return (void *) ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
main(int argc, char **argv)
|
||||||
|
{
|
||||||
|
pthread_t mainThread;
|
||||||
|
size_t i;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
char *key;
|
||||||
|
char *val;
|
||||||
|
char **envp;
|
||||||
|
|
||||||
|
MainArgs args;
|
||||||
|
|
||||||
|
args.args = NULL;
|
||||||
|
args.env = NULL;
|
||||||
|
|
||||||
|
args.args = ArrayCreate();
|
||||||
|
|
||||||
|
if (!args.args)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "Bootstrap error: Unable to allocate memory for arguments.");
|
||||||
|
ret = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
args.env = HashMapCreate();
|
||||||
|
if (!args.env)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "Bootstrap error: Unable to allocate memory for environment.");
|
||||||
|
ret = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < (size_t) argc; i++)
|
||||||
|
{
|
||||||
|
ArrayAdd(args.args, StrDuplicate(argv[i]));
|
||||||
|
}
|
||||||
|
|
||||||
|
envp = environ;
|
||||||
|
while (*envp)
|
||||||
|
{
|
||||||
|
size_t valInd;
|
||||||
|
|
||||||
|
/* It is unclear whether or not envp strings are writable, so
|
||||||
|
* we make our own copy to manipulate it */
|
||||||
|
key = StrDuplicate(*envp);
|
||||||
|
valInd = strcspn(key, "=");
|
||||||
|
|
||||||
|
key[valInd] = '\0';
|
||||||
|
val = key + valInd + 1;
|
||||||
|
HashMapSet(args.env, key, StrDuplicate(val));
|
||||||
|
Free(key);
|
||||||
|
envp++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pthread_create(&mainThread, NULL, MainThread, &args) != 0)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "Bootstrap error: Unable to create main thread.");
|
||||||
|
ret = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pthread_join(mainThread, (void **) &ret) != 0)
|
||||||
|
{
|
||||||
|
/* Should never happen */
|
||||||
|
Log(LOG_ERR, "Unable to join main thread.");
|
||||||
|
ret = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
finish:
|
||||||
|
if (args.args)
|
||||||
|
{
|
||||||
|
for (i = 0; i < ArraySize(args.args); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(args.args, i));
|
||||||
|
}
|
||||||
|
ArrayFree(args.args);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (args.env)
|
||||||
|
{
|
||||||
|
while (HashMapIterate(args.env, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
HashMapFree(args.env);
|
||||||
|
}
|
||||||
|
|
||||||
|
Log(LOG_DEBUG, "Exitting with code: %d", ret);
|
||||||
|
|
||||||
|
LogConfigFree(LogConfigGlobal());
|
||||||
|
|
||||||
|
StreamClose(StreamStdout());
|
||||||
|
StreamClose(StreamStdin());
|
||||||
|
StreamClose(StreamStderr());
|
||||||
|
|
||||||
|
GenerateMemoryReport(argv[0]);
|
||||||
|
|
||||||
|
MemoryFreeAll();
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
111
src/Runtime.c
Normal file
111
src/Runtime.c
Normal file
|
@ -0,0 +1,111 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Runtime.h>
|
||||||
|
#include <Array.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
#include <Log.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <time.h>
|
||||||
|
#include <libgen.h>
|
||||||
|
|
||||||
|
static void
|
||||||
|
HexDump(size_t off, char *hexBuf, char *asciiBuf, void *args)
|
||||||
|
{
|
||||||
|
FILE *report = args;
|
||||||
|
|
||||||
|
if (hexBuf && asciiBuf)
|
||||||
|
{
|
||||||
|
fprintf(report, "%04lx: %s | %s |\n", off, hexBuf, asciiBuf);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
fprintf(report, "%04lx\n", off);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void
|
||||||
|
MemoryIterator(MemoryInfo * i, void *args)
|
||||||
|
{
|
||||||
|
FILE *report = args;
|
||||||
|
|
||||||
|
fprintf(report, "%s:%d: %lu bytes at %p\n",
|
||||||
|
MemoryInfoGetFile(i), MemoryInfoGetLine(i),
|
||||||
|
MemoryInfoGetSize(i), MemoryInfoGetPointer(i));
|
||||||
|
|
||||||
|
MemoryHexDump(i, HexDump, report);
|
||||||
|
|
||||||
|
fprintf(report, "\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
GenerateMemoryReport(const char *prog)
|
||||||
|
{
|
||||||
|
char reportName[128];
|
||||||
|
char *namePtr;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Use C standard IO instead of the Stream or Io APIs, because
|
||||||
|
* those use the Memory API, and that's exactly what we're trying
|
||||||
|
* to assess, so using it would generate false positives. None of
|
||||||
|
* this code should leak memory.
|
||||||
|
*/
|
||||||
|
FILE *report;
|
||||||
|
time_t currentTime;
|
||||||
|
struct tm *timeInfo;
|
||||||
|
char tsBuffer[1024];
|
||||||
|
|
||||||
|
if (!MemoryAllocated())
|
||||||
|
{
|
||||||
|
/* No memory leaked, no need to write the report. This is the
|
||||||
|
* ideal situation; we only want the report to show up if leaks
|
||||||
|
* occurred. */
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
snprintf(reportName, sizeof(reportName), "%s-leaked.txt", prog);
|
||||||
|
/* Make sure the report goes in the current working directory. */
|
||||||
|
namePtr = basename(reportName);
|
||||||
|
report = fopen(namePtr, "a");
|
||||||
|
if (!report)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
currentTime = time(NULL);
|
||||||
|
timeInfo = localtime(¤tTime);
|
||||||
|
strftime(tsBuffer, sizeof(tsBuffer), "%c", timeInfo);
|
||||||
|
|
||||||
|
fprintf(report, "---------- Memory Report ----------\n");
|
||||||
|
fprintf(report, "Program: %s\n", prog);
|
||||||
|
fprintf(report, "Date: %s\n", tsBuffer);
|
||||||
|
fprintf(report, "Total Bytes: %lu\n", MemoryAllocated());
|
||||||
|
fprintf(report, "\n");
|
||||||
|
|
||||||
|
MemoryIterate(MemoryIterator, report);
|
||||||
|
|
||||||
|
fclose(report);
|
||||||
|
}
|
238
src/Sha2.c
Normal file
238
src/Sha2.c
Normal file
|
@ -0,0 +1,238 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Sha2.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Int.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include <limits.h>
|
||||||
|
|
||||||
|
#define GET_UINT32(x) \
|
||||||
|
(((UInt32)(x)[0] << 24) | \
|
||||||
|
((UInt32)(x)[1] << 16) | \
|
||||||
|
((UInt32)(x)[2] << 8) | \
|
||||||
|
((UInt32)(x)[3]))
|
||||||
|
|
||||||
|
#define PUT_UINT32(dst, x) { \
|
||||||
|
(dst)[0] = (x) >> 24; \
|
||||||
|
(dst)[1] = (x) >> 16; \
|
||||||
|
(dst)[2] = (x) >> 8; \
|
||||||
|
(dst)[3] = (x); \
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
|
||||||
|
|
||||||
|
#define S0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
|
||||||
|
#define S1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
|
||||||
|
|
||||||
|
#define T0(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
|
||||||
|
#define T1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
|
||||||
|
|
||||||
|
#define CH(a, b, c) (((a) & (b)) ^ ((~(a)) & (c)))
|
||||||
|
#define MAJ(a, b, c) (((a) & (b)) ^ ((a) & (c)) ^ ((b) & (c)))
|
||||||
|
#define WW(i) (w[i] = w[i - 16] + S0(w[i - 15]) + w[i - 7] + S1(w[i - 2]))
|
||||||
|
|
||||||
|
#define ROUND(a, b, c, d, e, f, g, h, k, w) { \
|
||||||
|
UInt32 tmp0 = h + T0(e) + CH(e, f, g) + k + w; \
|
||||||
|
UInt32 tmp1 = T1(a) + MAJ(a, b, c); \
|
||||||
|
h = tmp0 + tmp1; \
|
||||||
|
d += tmp0; \
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct Sha256Context
|
||||||
|
{
|
||||||
|
size_t length;
|
||||||
|
UInt32 state[8];
|
||||||
|
size_t bufLen;
|
||||||
|
unsigned char buffer[64];
|
||||||
|
} Sha256Context;
|
||||||
|
|
||||||
|
static void
|
||||||
|
Sha256Chunk(Sha256Context * context, unsigned char chunk[64])
|
||||||
|
{
|
||||||
|
const UInt32 rk[64] = {
|
||||||
|
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
|
||||||
|
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
|
||||||
|
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
|
||||||
|
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||||
|
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
|
||||||
|
0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
|
||||||
|
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
|
||||||
|
0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
||||||
|
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
|
||||||
|
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
|
||||||
|
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
||||||
|
};
|
||||||
|
|
||||||
|
UInt32 w[64];
|
||||||
|
UInt32 a, b, c, d, e, f, g, h;
|
||||||
|
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
w[i] = GET_UINT32(&chunk[4 * i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
a = context->state[0];
|
||||||
|
b = context->state[1];
|
||||||
|
c = context->state[2];
|
||||||
|
d = context->state[3];
|
||||||
|
e = context->state[4];
|
||||||
|
f = context->state[5];
|
||||||
|
g = context->state[6];
|
||||||
|
h = context->state[7];
|
||||||
|
|
||||||
|
for (i = 0; i < 16; i += 8)
|
||||||
|
{
|
||||||
|
ROUND(a, b, c, d, e, f, g, h, rk[i], w[i]);
|
||||||
|
ROUND(h, a, b, c, d, e, f, g, rk[i + 1], w[i + 1]);
|
||||||
|
ROUND(g, h, a, b, c, d, e, f, rk[i + 2], w[i + 2]);
|
||||||
|
ROUND(f, g, h, a, b, c, d, e, rk[i + 3], w[i + 3]);
|
||||||
|
ROUND(e, f, g, h, a, b, c, d, rk[i + 4], w[i + 4]);
|
||||||
|
ROUND(d, e, f, g, h, a, b, c, rk[i + 5], w[i + 5]);
|
||||||
|
ROUND(c, d, e, f, g, h, a, b, rk[i + 6], w[i + 6]);
|
||||||
|
ROUND(b, c, d, e, f, g, h, a, rk[i + 7], w[i + 7]);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 16; i < 64; i += 8)
|
||||||
|
{
|
||||||
|
ROUND(a, b, c, d, e, f, g, h, rk[i], WW(i));
|
||||||
|
ROUND(h, a, b, c, d, e, f, g, rk[i + 1], WW(i + 1));
|
||||||
|
ROUND(g, h, a, b, c, d, e, f, rk[i + 2], WW(i + 2));
|
||||||
|
ROUND(f, g, h, a, b, c, d, e, rk[i + 3], WW(i + 3));
|
||||||
|
ROUND(e, f, g, h, a, b, c, d, rk[i + 4], WW(i + 4));
|
||||||
|
ROUND(d, e, f, g, h, a, b, c, rk[i + 5], WW(i + 5));
|
||||||
|
ROUND(c, d, e, f, g, h, a, b, rk[i + 6], WW(i + 6));
|
||||||
|
ROUND(b, c, d, e, f, g, h, a, rk[i + 7], WW(i + 7));
|
||||||
|
}
|
||||||
|
|
||||||
|
context->state[0] += a;
|
||||||
|
context->state[1] += b;
|
||||||
|
context->state[2] += c;
|
||||||
|
context->state[3] += d;
|
||||||
|
context->state[4] += e;
|
||||||
|
context->state[5] += f;
|
||||||
|
context->state[6] += g;
|
||||||
|
context->state[7] += h;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
Sha256Process(Sha256Context * context, unsigned char *data, size_t length)
|
||||||
|
{
|
||||||
|
context->length += length;
|
||||||
|
|
||||||
|
if (context->bufLen && context->bufLen + length >= 64)
|
||||||
|
{
|
||||||
|
int len = 64 - context->bufLen;
|
||||||
|
|
||||||
|
memcpy(context->buffer + context->bufLen, data, len);
|
||||||
|
Sha256Chunk(context, context->buffer);
|
||||||
|
data += len;
|
||||||
|
length -= len;
|
||||||
|
context->bufLen = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (length >= 64)
|
||||||
|
{
|
||||||
|
Sha256Chunk(context, data);
|
||||||
|
data += 64;
|
||||||
|
length -= 64;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (length)
|
||||||
|
{
|
||||||
|
memcpy(context->buffer + context->bufLen, data, length);
|
||||||
|
context->bufLen += length;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
Sha256(char *str)
|
||||||
|
{
|
||||||
|
Sha256Context context;
|
||||||
|
size_t i;
|
||||||
|
unsigned char out[32];
|
||||||
|
char *outStr;
|
||||||
|
|
||||||
|
unsigned char fill[64];
|
||||||
|
UInt32 fillLen;
|
||||||
|
unsigned char buf[8];
|
||||||
|
UInt32 hiLen;
|
||||||
|
UInt32 loLen;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
outStr = Malloc(65);
|
||||||
|
if (!outStr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
context.state[0] = 0x6a09e667;
|
||||||
|
context.state[1] = 0xbb67ae85;
|
||||||
|
context.state[2] = 0x3c6ef372;
|
||||||
|
context.state[3] = 0xa54ff53a;
|
||||||
|
context.state[4] = 0x510e527f;
|
||||||
|
context.state[5] = 0x9b05688c;
|
||||||
|
context.state[6] = 0x1f83d9ab;
|
||||||
|
context.state[7] = 0x5be0cd19;
|
||||||
|
|
||||||
|
context.bufLen = 0;
|
||||||
|
context.length = 0;
|
||||||
|
memset(context.buffer, 0, 64);
|
||||||
|
|
||||||
|
Sha256Process(&context, (unsigned char *) str, strlen(str));
|
||||||
|
|
||||||
|
memset(fill, 0, 64);
|
||||||
|
fill[0] = 0x80;
|
||||||
|
|
||||||
|
fillLen = (context.bufLen < 56) ? 56 - context.bufLen : 120 - context.bufLen;
|
||||||
|
hiLen = (UInt32) (context.length >> 29);
|
||||||
|
loLen = (UInt32) (context.length << 3);
|
||||||
|
|
||||||
|
PUT_UINT32(&buf[0], hiLen);
|
||||||
|
PUT_UINT32(&buf[4], loLen);
|
||||||
|
|
||||||
|
Sha256Process(&context, fill, fillLen);
|
||||||
|
Sha256Process(&context, buf, 8);
|
||||||
|
|
||||||
|
for (i = 0; i < 8; i++)
|
||||||
|
{
|
||||||
|
PUT_UINT32(&out[4 * i], context.state[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Convert to string */
|
||||||
|
for (i = 0; i < 32; i++)
|
||||||
|
{
|
||||||
|
snprintf(outStr + (2 * i), 3, "%02x", out[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
return outStr;
|
||||||
|
}
|
297
src/Str.c
Normal file
297
src/Str.c
Normal file
|
@ -0,0 +1,297 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Str.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Util.h>
|
||||||
|
#include <Rand.h>
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrUtf8Encode(unsigned long utf8)
|
||||||
|
{
|
||||||
|
char *str;
|
||||||
|
|
||||||
|
str = Malloc(5 * sizeof(char));
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (utf8 <= 0x7F) /* Plain ASCII */
|
||||||
|
{
|
||||||
|
str[0] = (char) utf8;
|
||||||
|
str[1] = '\0';
|
||||||
|
}
|
||||||
|
else if (utf8 <= 0x07FF) /* 2-byte */
|
||||||
|
{
|
||||||
|
str[0] = (char) (((utf8 >> 6) & 0x1F) | 0xC0);
|
||||||
|
str[1] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
|
||||||
|
str[2] = '\0';
|
||||||
|
}
|
||||||
|
else if (utf8 <= 0xFFFF) /* 3-byte */
|
||||||
|
{
|
||||||
|
str[0] = (char) (((utf8 >> 12) & 0x0F) | 0xE0);
|
||||||
|
str[1] = (char) (((utf8 >> 6) & 0x3F) | 0x80);
|
||||||
|
str[2] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
|
||||||
|
str[3] = '\0';
|
||||||
|
}
|
||||||
|
else if (utf8 <= 0x10FFFF) /* 4-byte */
|
||||||
|
{
|
||||||
|
str[0] = (char) (((utf8 >> 18) & 0x07) | 0xF0);
|
||||||
|
str[1] = (char) (((utf8 >> 12) & 0x3F) | 0x80);
|
||||||
|
str[2] = (char) (((utf8 >> 6) & 0x3F) | 0x80);
|
||||||
|
str[3] = (char) (((utf8 >> 0) & 0x3F) | 0x80);
|
||||||
|
str[4] = '\0';
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/* Send replacement character */
|
||||||
|
str[0] = (char) 0xEF;
|
||||||
|
str[1] = (char) 0xBF;
|
||||||
|
str[2] = (char) 0xBD;
|
||||||
|
str[3] = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrDuplicate(const char *inStr)
|
||||||
|
{
|
||||||
|
size_t len;
|
||||||
|
char *outStr;
|
||||||
|
|
||||||
|
if (!inStr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
len = strlen(inStr);
|
||||||
|
outStr = Malloc(len + 1); /* For the null terminator */
|
||||||
|
if (!outStr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
strncpy(outStr, inStr, len + 1);
|
||||||
|
|
||||||
|
return outStr;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrSubstr(const char *inStr, size_t start, size_t end)
|
||||||
|
{
|
||||||
|
size_t len;
|
||||||
|
size_t i;
|
||||||
|
size_t j;
|
||||||
|
|
||||||
|
char *outStr;
|
||||||
|
|
||||||
|
if (!inStr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (start >= end)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
len = end - start;
|
||||||
|
|
||||||
|
outStr = Malloc(len + 1);
|
||||||
|
if (!outStr)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
j = 0;
|
||||||
|
for (i = start; i < end; i++)
|
||||||
|
{
|
||||||
|
if (inStr[i] == '\0')
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
outStr[j] = inStr[i];
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
|
||||||
|
outStr[j] = '\0';
|
||||||
|
|
||||||
|
return outStr;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrConcat(size_t nStr,...)
|
||||||
|
{
|
||||||
|
va_list argp;
|
||||||
|
char *str;
|
||||||
|
char *strp;
|
||||||
|
size_t strLen = 0;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
va_start(argp, nStr);
|
||||||
|
for (i = 0; i < nStr; i++)
|
||||||
|
{
|
||||||
|
char *argStr = va_arg(argp, char *);
|
||||||
|
|
||||||
|
if (argStr)
|
||||||
|
{
|
||||||
|
strLen += strlen(argStr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
va_end(argp);
|
||||||
|
|
||||||
|
str = Malloc(strLen + 1);
|
||||||
|
strp = str;
|
||||||
|
|
||||||
|
va_start(argp, nStr);
|
||||||
|
|
||||||
|
for (i = 0; i < nStr; i++)
|
||||||
|
{
|
||||||
|
/* Manually copy chars instead of using strcopy() so we don't
|
||||||
|
* have to call strlen() on the strings again, and we aren't
|
||||||
|
* writing useless null chars. */
|
||||||
|
|
||||||
|
char *argStr = va_arg(argp, char *);
|
||||||
|
|
||||||
|
if (argStr)
|
||||||
|
{
|
||||||
|
while (*argStr)
|
||||||
|
{
|
||||||
|
*strp = *argStr;
|
||||||
|
strp++;
|
||||||
|
argStr++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
va_end(argp);
|
||||||
|
str[strLen] = '\0';
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StrBlank(const char *str)
|
||||||
|
{
|
||||||
|
int blank = 1;
|
||||||
|
size_t i = 0;
|
||||||
|
|
||||||
|
while (str[i])
|
||||||
|
{
|
||||||
|
blank &= isspace((unsigned char) str[i]);
|
||||||
|
/* No need to continue if we don't have a blank */
|
||||||
|
if (!blank)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
return blank;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrRandom(size_t len)
|
||||||
|
{
|
||||||
|
static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||||
|
|
||||||
|
char *str;
|
||||||
|
int *nums;
|
||||||
|
size_t i;
|
||||||
|
|
||||||
|
if (!len)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
str = Malloc(len + 1);
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
nums = Malloc(len * sizeof(int));
|
||||||
|
if (!nums)
|
||||||
|
{
|
||||||
|
Free(str);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* TODO: This seems slow. */
|
||||||
|
RandIntN(nums, len, sizeof(charset) - 1);
|
||||||
|
for (i = 0; i < len; i++)
|
||||||
|
{
|
||||||
|
str[i] = charset[nums[i]];
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(nums);
|
||||||
|
str[len] = '\0';
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StrInt(long i)
|
||||||
|
{
|
||||||
|
char *str;
|
||||||
|
int len;
|
||||||
|
|
||||||
|
len = snprintf(NULL, 0, "%ld", i);
|
||||||
|
str = Malloc(len + 1);
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
snprintf(str, len + 1, "%ld", i);
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StrEquals(const char *str1, const char *str2)
|
||||||
|
{
|
||||||
|
/* Both strings are NULL, they're equal */
|
||||||
|
if (!str1 && !str2)
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* One or the other is NULL, they're not equal */
|
||||||
|
if (!str1 || !str2)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Neither are NULL, do a regular string comparison */
|
||||||
|
return strcmp(str1, str2) == 0;
|
||||||
|
}
|
657
src/Stream.c
Normal file
657
src/Stream.c
Normal file
|
@ -0,0 +1,657 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#include <Io.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Util.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
|
||||||
|
#ifndef STREAM_RETRIES
|
||||||
|
#define STREAM_RETRIES 10
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef STREAM_DELAY
|
||||||
|
#define STREAM_DELAY 2
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define STREAM_EOF (1 << 0)
|
||||||
|
#define STREAM_ERR (1 << 1)
|
||||||
|
#define STREAM_TTY (1 << 2)
|
||||||
|
|
||||||
|
struct Stream
|
||||||
|
{
|
||||||
|
Io *io;
|
||||||
|
|
||||||
|
char *rBuf;
|
||||||
|
size_t rLen;
|
||||||
|
size_t rOff;
|
||||||
|
|
||||||
|
char *wBuf;
|
||||||
|
size_t wLen;
|
||||||
|
|
||||||
|
char *ugBuf;
|
||||||
|
size_t ugSize;
|
||||||
|
size_t ugLen;
|
||||||
|
|
||||||
|
int flags;
|
||||||
|
|
||||||
|
int fd;
|
||||||
|
};
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamIo(Io * io)
|
||||||
|
{
|
||||||
|
Stream *stream;
|
||||||
|
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream = Malloc(sizeof(Stream));
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(stream, 0, sizeof(Stream));
|
||||||
|
stream->io = io;
|
||||||
|
stream->fd = -1;
|
||||||
|
|
||||||
|
return stream;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamFd(int fd)
|
||||||
|
{
|
||||||
|
Io *io = IoFd(fd);
|
||||||
|
Stream *stream;
|
||||||
|
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream = StreamIo(io);
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->fd = fd;
|
||||||
|
|
||||||
|
if (isatty(stream->fd))
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_TTY;
|
||||||
|
}
|
||||||
|
|
||||||
|
return stream;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamFile(FILE * fp)
|
||||||
|
{
|
||||||
|
Io *io = IoFile(fp);
|
||||||
|
Stream *stream;
|
||||||
|
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream = StreamIo(io);
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->fd = fileno(fp);
|
||||||
|
|
||||||
|
if (isatty(stream->fd))
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_TTY;
|
||||||
|
}
|
||||||
|
|
||||||
|
return stream;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamOpen(const char *path, const char *mode)
|
||||||
|
{
|
||||||
|
FILE *fp = fopen(path, mode);
|
||||||
|
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return StreamFile(fp);
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamStdout(void)
|
||||||
|
{
|
||||||
|
static Stream *stdOut = NULL;
|
||||||
|
|
||||||
|
if (!stdOut)
|
||||||
|
{
|
||||||
|
stdOut = StreamFd(STDOUT_FILENO);
|
||||||
|
}
|
||||||
|
|
||||||
|
return stdOut;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamStderr(void)
|
||||||
|
{
|
||||||
|
static Stream *stdErr = NULL;
|
||||||
|
|
||||||
|
if (!stdErr)
|
||||||
|
{
|
||||||
|
stdErr = StreamFd(STDERR_FILENO);
|
||||||
|
}
|
||||||
|
|
||||||
|
return stdErr;
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
StreamStdin(void)
|
||||||
|
{
|
||||||
|
static Stream *stdIn = NULL;
|
||||||
|
|
||||||
|
if (!stdIn)
|
||||||
|
{
|
||||||
|
stdIn = StreamFd(STDIN_FILENO);
|
||||||
|
}
|
||||||
|
|
||||||
|
return stdIn;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamClose(Stream * stream)
|
||||||
|
{
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->rBuf)
|
||||||
|
{
|
||||||
|
Free(stream->rBuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->wBuf)
|
||||||
|
{
|
||||||
|
ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
|
||||||
|
|
||||||
|
Free(stream->wBuf);
|
||||||
|
|
||||||
|
if (writeRes == -1)
|
||||||
|
{
|
||||||
|
ret = EOF;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->ugBuf)
|
||||||
|
{
|
||||||
|
Free(stream->ugBuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = IoClose(stream->io);
|
||||||
|
Free(stream);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamVprintf(Stream * stream, const char *fmt, va_list ap)
|
||||||
|
{
|
||||||
|
/* This might look like very similar code to IoVprintf(), but I
|
||||||
|
* chose not to defer to IoVprintf() because that would require us
|
||||||
|
* to immediately flush the buffer, since the Io API is unbuffered.
|
||||||
|
* StreamPuts() uses StreamPutc() under the hood, which is
|
||||||
|
* buffered. It therefore allows us to finish filling the buffer
|
||||||
|
* and then only flush it when necessary, preventing superfluous
|
||||||
|
* writes. */
|
||||||
|
|
||||||
|
char *buf = NULL;
|
||||||
|
size_t bufSize = 0;
|
||||||
|
FILE *fp;
|
||||||
|
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (!fmt)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
fp = open_memstream(&buf, &bufSize);
|
||||||
|
if (!fp)
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = vfprintf(fp, fmt, ap);
|
||||||
|
fclose(fp);
|
||||||
|
|
||||||
|
if (ret >= 0 && stream)
|
||||||
|
{
|
||||||
|
if (StreamPuts(stream, buf) < 0)
|
||||||
|
{
|
||||||
|
ret = -1;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
free(buf); /* Allocated by stdlib, not Memory
|
||||||
|
* API */
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamPrintf(Stream * stream, const char *fmt,...)
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
va_list ap;
|
||||||
|
|
||||||
|
va_start(ap, fmt);
|
||||||
|
ret = StreamVprintf(stream, fmt, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamGetc(Stream * stream)
|
||||||
|
{
|
||||||
|
int c;
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Empty the ungetc stack first */
|
||||||
|
if (stream->ugLen)
|
||||||
|
{
|
||||||
|
c = stream->ugBuf[stream->ugLen - 1];
|
||||||
|
stream->ugLen--;
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->flags & STREAM_EOF)
|
||||||
|
{
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!stream->rBuf)
|
||||||
|
{
|
||||||
|
/* No buffer allocated yet */
|
||||||
|
stream->rBuf = Malloc(IO_BUFFER);
|
||||||
|
if (!stream->rBuf)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->rOff = 0;
|
||||||
|
stream->rLen = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->rOff >= stream->rLen)
|
||||||
|
{
|
||||||
|
/* We read through the entire buffer; get a new one */
|
||||||
|
ssize_t readRes = IoRead(stream->io, stream->rBuf, IO_BUFFER);
|
||||||
|
|
||||||
|
if (readRes == 0)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_EOF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (readRes == -1)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->rOff = 0;
|
||||||
|
stream->rLen = readRes;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Read the character in the buffer and advance the offset */
|
||||||
|
c = stream->rBuf[stream->rOff];
|
||||||
|
stream->rOff++;
|
||||||
|
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamUngetc(Stream * stream, int c)
|
||||||
|
{
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!stream->ugBuf)
|
||||||
|
{
|
||||||
|
stream->ugSize = IO_BUFFER;
|
||||||
|
stream->ugBuf = Malloc(stream->ugSize);
|
||||||
|
|
||||||
|
if (!stream->ugBuf)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->ugLen >= stream->ugSize)
|
||||||
|
{
|
||||||
|
char *new;
|
||||||
|
|
||||||
|
stream->ugSize += IO_BUFFER;
|
||||||
|
new = Realloc(stream->ugBuf, stream->ugSize);
|
||||||
|
if (!new)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
Free(stream->ugBuf);
|
||||||
|
stream->ugBuf = NULL;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(stream->ugBuf);
|
||||||
|
stream->ugBuf = new;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->ugBuf[stream->ugLen] = c;
|
||||||
|
stream->ugLen++;
|
||||||
|
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamPutc(Stream * stream, int c)
|
||||||
|
{
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!stream->wBuf)
|
||||||
|
{
|
||||||
|
stream->wBuf = Malloc(IO_BUFFER);
|
||||||
|
if (!stream->wBuf)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->wLen == IO_BUFFER)
|
||||||
|
{
|
||||||
|
/* Buffer full; write it */
|
||||||
|
ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
|
||||||
|
|
||||||
|
if (writeRes == -1)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->wLen = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->wBuf[stream->wLen] = c;
|
||||||
|
stream->wLen++;
|
||||||
|
|
||||||
|
if (stream->flags & STREAM_TTY && c == '\n')
|
||||||
|
{
|
||||||
|
/* Newline encountered on a TTY; write now. This fixes some
|
||||||
|
* strange behavior on certain TTYs where a newline is written
|
||||||
|
* to the screen upon flush even when no newline exists in the
|
||||||
|
* stream. We just flush on newlines, but only if we're
|
||||||
|
* directly writing to a TTY. */
|
||||||
|
ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
|
||||||
|
|
||||||
|
if (writeRes == -1)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->wLen = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamPuts(Stream * stream, char *str)
|
||||||
|
{
|
||||||
|
int ret = 0;
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (*str)
|
||||||
|
{
|
||||||
|
if (StreamPutc(stream, *str) == EOF)
|
||||||
|
{
|
||||||
|
ret = -1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
str++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
StreamGets(Stream * stream, char *str, int size)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (size <= 0)
|
||||||
|
{
|
||||||
|
errno = EINVAL;
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < size - 1; i++)
|
||||||
|
{
|
||||||
|
int c = StreamGetc(stream);
|
||||||
|
|
||||||
|
if (StreamEof(stream) || StreamError(stream))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = c;
|
||||||
|
|
||||||
|
if (c == '\n')
|
||||||
|
{
|
||||||
|
i++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
str[i] = '\0';
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
off_t
|
||||||
|
StreamSeek(Stream * stream, off_t offset, int whence)
|
||||||
|
{
|
||||||
|
off_t result;
|
||||||
|
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
result = IoSeek(stream->io, offset, whence);
|
||||||
|
if (result < 0)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Successful seek; clear the buffers */
|
||||||
|
stream->rOff = 0;
|
||||||
|
stream->wLen = 0;
|
||||||
|
stream->ugLen = 0;
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamEof(Stream * stream)
|
||||||
|
{
|
||||||
|
return stream && (stream->flags & STREAM_EOF);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamError(Stream * stream)
|
||||||
|
{
|
||||||
|
return stream && (stream->flags & STREAM_ERR);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
StreamClearError(Stream * stream)
|
||||||
|
{
|
||||||
|
if (stream)
|
||||||
|
{
|
||||||
|
stream->flags &= ~STREAM_ERR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamFlush(Stream * stream)
|
||||||
|
{
|
||||||
|
if (!stream)
|
||||||
|
{
|
||||||
|
errno = EBADF;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream->wLen)
|
||||||
|
{
|
||||||
|
ssize_t writeRes = IoWrite(stream->io, stream->wBuf, stream->wLen);
|
||||||
|
|
||||||
|
if (writeRes == -1)
|
||||||
|
{
|
||||||
|
stream->flags |= STREAM_ERR;
|
||||||
|
return EOF;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream->wLen = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
StreamCopy(Stream * in, Stream * out)
|
||||||
|
{
|
||||||
|
ssize_t nBytes = 0;
|
||||||
|
int c;
|
||||||
|
int tries = 0;
|
||||||
|
int readFlg = 0;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
c = StreamGetc(in);
|
||||||
|
|
||||||
|
if (StreamEof(in))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StreamError(in))
|
||||||
|
{
|
||||||
|
if (errno == EAGAIN)
|
||||||
|
{
|
||||||
|
StreamClearError(in);
|
||||||
|
tries++;
|
||||||
|
|
||||||
|
if (tries >= STREAM_RETRIES || readFlg)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
UtilSleepMillis(STREAM_DELAY);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* As soon as we've successfully read a byte, treat future
|
||||||
|
* EAGAINs as EOF, because somebody might have forgotten to
|
||||||
|
* close their stream. */
|
||||||
|
|
||||||
|
readFlg = 1;
|
||||||
|
tries = 0;
|
||||||
|
|
||||||
|
StreamPutc(out, c);
|
||||||
|
nBytes++;
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamFlush(out);
|
||||||
|
return nBytes;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
StreamFileno(Stream * stream)
|
||||||
|
{
|
||||||
|
return stream ? stream->fd : -1;
|
||||||
|
}
|
85
src/Tls.c
Normal file
85
src/Tls.c
Normal file
|
@ -0,0 +1,85 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Tls.h>
|
||||||
|
|
||||||
|
#ifdef TLS_IMPL
|
||||||
|
|
||||||
|
#include <Io.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
TlsClientStream(int fd, const char *serverName)
|
||||||
|
{
|
||||||
|
Io *io;
|
||||||
|
void *cookie;
|
||||||
|
IoFunctions funcs;
|
||||||
|
|
||||||
|
cookie = TlsInitClient(fd, serverName);
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
funcs.read = TlsRead;
|
||||||
|
funcs.write = TlsWrite;
|
||||||
|
funcs.seek = NULL;
|
||||||
|
funcs.close = TlsClose;
|
||||||
|
|
||||||
|
io = IoCreate(cookie, funcs);
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return StreamIo(io);
|
||||||
|
}
|
||||||
|
|
||||||
|
Stream *
|
||||||
|
TlsServerStream(int fd, const char *crt, const char *key)
|
||||||
|
{
|
||||||
|
Io *io;
|
||||||
|
void *cookie;
|
||||||
|
IoFunctions funcs;
|
||||||
|
|
||||||
|
cookie = TlsInitServer(fd, crt, key);
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
funcs.read = TlsRead;
|
||||||
|
funcs.write = TlsWrite;
|
||||||
|
funcs.seek = NULL;
|
||||||
|
funcs.close = TlsClose;
|
||||||
|
|
||||||
|
io = IoCreate(cookie, funcs);
|
||||||
|
if (!io)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return StreamIo(io);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
247
src/Tls/TlsLibreSSL.c
Normal file
247
src/Tls/TlsLibreSSL.c
Normal file
|
@ -0,0 +1,247 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Tls.h>
|
||||||
|
|
||||||
|
#if TLS_IMPL == TLS_LIBRESSL
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Log.h>
|
||||||
|
|
||||||
|
#include <errno.h>
|
||||||
|
|
||||||
|
#include <tls.h> /* LibreSSL TLS */
|
||||||
|
|
||||||
|
typedef struct LibreSSLCookie
|
||||||
|
{
|
||||||
|
int fd;
|
||||||
|
struct tls *ctx;
|
||||||
|
struct tls *cctx;
|
||||||
|
struct tls_config *cfg;
|
||||||
|
} LibreSSLCookie;
|
||||||
|
|
||||||
|
void *
|
||||||
|
TlsInitClient(int fd, const char *serverName)
|
||||||
|
{
|
||||||
|
LibreSSLCookie *cookie = Malloc(sizeof(LibreSSLCookie));
|
||||||
|
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
cookie->ctx = tls_client();
|
||||||
|
cookie->cctx = NULL;
|
||||||
|
cookie->cfg = tls_config_new();
|
||||||
|
cookie->fd = fd;
|
||||||
|
|
||||||
|
|
||||||
|
if (!cookie->ctx || !cookie->cfg)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_config_set_ca_file(cookie->cfg, tls_default_ca_cert_file()) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_configure(cookie->ctx, cookie->cfg) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_connect_socket(cookie->ctx, fd, serverName) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_handshake(cookie->ctx) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return cookie;
|
||||||
|
|
||||||
|
error:
|
||||||
|
if (cookie->ctx)
|
||||||
|
{
|
||||||
|
if (tls_error(cookie->ctx))
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitClient(): %s", tls_error(cookie->ctx));
|
||||||
|
}
|
||||||
|
|
||||||
|
tls_free(cookie->ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cookie->cfg)
|
||||||
|
{
|
||||||
|
tls_config_free(cookie->cfg);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(cookie);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
TlsInitServer(int fd, const char *crt, const char *key)
|
||||||
|
{
|
||||||
|
LibreSSLCookie *cookie = Malloc(sizeof(LibreSSLCookie));
|
||||||
|
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
cookie->ctx = tls_server();
|
||||||
|
cookie->cctx = NULL;
|
||||||
|
cookie->cfg = tls_config_new();
|
||||||
|
cookie->fd = fd;
|
||||||
|
|
||||||
|
if (!cookie->ctx || !cookie->cfg)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_config_set_cert_file(cookie->cfg, crt) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_config_set_key_file(cookie->cfg, key) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_configure(cookie->ctx, cookie->cfg) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_accept_fds(cookie->ctx, &cookie->cctx, fd, fd) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tls_handshake(cookie->cctx) == -1)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return cookie;
|
||||||
|
|
||||||
|
error:
|
||||||
|
if (cookie->ctx)
|
||||||
|
{
|
||||||
|
if (tls_error(cookie->ctx))
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): %s", tls_error(cookie->ctx));
|
||||||
|
}
|
||||||
|
tls_free(cookie->ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cookie->cctx)
|
||||||
|
{
|
||||||
|
if (tls_error(cookie->cctx))
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): %s", tls_error(cookie->cctx));
|
||||||
|
}
|
||||||
|
|
||||||
|
tls_free(cookie->cctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cookie->cfg)
|
||||||
|
{
|
||||||
|
tls_config_free(cookie->cfg);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(cookie);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
TlsRead(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
LibreSSLCookie *tls = cookie;
|
||||||
|
struct tls *ctx = tls->cctx ? tls->cctx : tls->ctx;
|
||||||
|
ssize_t ret = tls_read(ctx, buf, nBytes);
|
||||||
|
|
||||||
|
if (ret == -1)
|
||||||
|
{
|
||||||
|
errno = EIO;
|
||||||
|
}
|
||||||
|
else if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT)
|
||||||
|
{
|
||||||
|
errno = EAGAIN;
|
||||||
|
ret = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
TlsWrite(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
LibreSSLCookie *tls = cookie;
|
||||||
|
struct tls *ctx = tls->cctx ? tls->cctx : tls->ctx;
|
||||||
|
ssize_t ret = tls_write(ctx, buf, nBytes);
|
||||||
|
|
||||||
|
if (ret == -1)
|
||||||
|
{
|
||||||
|
errno = EIO;
|
||||||
|
}
|
||||||
|
else if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT)
|
||||||
|
{
|
||||||
|
errno = EAGAIN;
|
||||||
|
ret = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
TlsClose(void *cookie)
|
||||||
|
{
|
||||||
|
LibreSSLCookie *tls = cookie;
|
||||||
|
|
||||||
|
int tlsRet = tls_close(tls->cctx ? tls->cctx : tls->ctx);
|
||||||
|
int sdRet;
|
||||||
|
|
||||||
|
if (tls->cctx)
|
||||||
|
{
|
||||||
|
tls_free(tls->cctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
tls_free(tls->ctx);
|
||||||
|
tls_config_free(tls->cfg);
|
||||||
|
|
||||||
|
sdRet = close(tls->fd);
|
||||||
|
|
||||||
|
Free(tls);
|
||||||
|
|
||||||
|
return (tlsRet == -1 || sdRet == -1) ? -1 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
296
src/Tls/TlsOpenSSL.c
Normal file
296
src/Tls/TlsOpenSSL.c
Normal file
|
@ -0,0 +1,296 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Tls.h>
|
||||||
|
|
||||||
|
#if TLS_IMPL == TLS_OPENSSL
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Log.h>
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include <openssl/ssl.h>
|
||||||
|
#include <openssl/err.h>
|
||||||
|
|
||||||
|
typedef struct OpenSSLCookie
|
||||||
|
{
|
||||||
|
int fd;
|
||||||
|
const SSL_METHOD *method;
|
||||||
|
SSL_CTX *ctx;
|
||||||
|
SSL *ssl;
|
||||||
|
} OpenSSLCookie;
|
||||||
|
|
||||||
|
static char *
|
||||||
|
SSLErrorString(int err)
|
||||||
|
{
|
||||||
|
switch (err)
|
||||||
|
{
|
||||||
|
case SSL_ERROR_NONE:
|
||||||
|
return "No error.";
|
||||||
|
case SSL_ERROR_ZERO_RETURN:
|
||||||
|
return "The TLS/SSL connection has been closed.";
|
||||||
|
case SSL_ERROR_WANT_READ:
|
||||||
|
case SSL_ERROR_WANT_WRITE:
|
||||||
|
case SSL_ERROR_WANT_CONNECT:
|
||||||
|
case SSL_ERROR_WANT_ACCEPT:
|
||||||
|
return "The operation did not complete.";
|
||||||
|
case SSL_ERROR_WANT_X509_LOOKUP:
|
||||||
|
return "X509 lookup failed.";
|
||||||
|
case SSL_ERROR_SYSCALL:
|
||||||
|
return "I/O Error.";
|
||||||
|
case SSL_ERROR_SSL:
|
||||||
|
return "SSL library error.";
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
TlsInitClient(int fd, const char *serverName)
|
||||||
|
{
|
||||||
|
OpenSSLCookie *cookie;
|
||||||
|
char errorStr[256];
|
||||||
|
|
||||||
|
/*
|
||||||
|
* TODO: Seems odd that this isn't needed to make the
|
||||||
|
* connection... we should figure out how to verify the
|
||||||
|
* certificate matches the server we think we're
|
||||||
|
* connecting to.
|
||||||
|
*/
|
||||||
|
(void) serverName;
|
||||||
|
|
||||||
|
cookie = Malloc(sizeof(OpenSSLCookie));
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(cookie, 0, sizeof(OpenSSLCookie));
|
||||||
|
|
||||||
|
cookie->method = TLS_client_method();
|
||||||
|
cookie->ctx = SSL_CTX_new(cookie->method);
|
||||||
|
if (!cookie->ctx)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
cookie->ssl = SSL_new(cookie->ctx);
|
||||||
|
if (!cookie->ssl)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!SSL_set_fd(cookie->ssl, fd))
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (SSL_connect(cookie->ssl) <= 0)
|
||||||
|
{
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return cookie;
|
||||||
|
|
||||||
|
error:
|
||||||
|
Log(LOG_ERR, "TlsClientInit(): %s", ERR_error_string(ERR_get_error(), errorStr));
|
||||||
|
|
||||||
|
if (cookie->ssl)
|
||||||
|
{
|
||||||
|
SSL_shutdown(cookie->ssl);
|
||||||
|
SSL_free(cookie->ssl);
|
||||||
|
}
|
||||||
|
|
||||||
|
close(cookie->fd);
|
||||||
|
|
||||||
|
if (cookie->ctx)
|
||||||
|
{
|
||||||
|
SSL_CTX_free(cookie->ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
TlsInitServer(int fd, const char *crt, const char *key)
|
||||||
|
{
|
||||||
|
OpenSSLCookie *cookie;
|
||||||
|
char errorStr[256];
|
||||||
|
int acceptRet = 0;
|
||||||
|
|
||||||
|
cookie = Malloc(sizeof(OpenSSLCookie));
|
||||||
|
if (!cookie)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(cookie, 0, sizeof(OpenSSLCookie));
|
||||||
|
|
||||||
|
cookie->method = TLS_server_method();
|
||||||
|
cookie->ctx = SSL_CTX_new(cookie->method);
|
||||||
|
if (!cookie->ctx)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to create SSL Context.");
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (SSL_CTX_use_certificate_file(cookie->ctx, crt, SSL_FILETYPE_PEM) <= 0)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to set certificate file: %s", crt);
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (SSL_CTX_use_PrivateKey_file(cookie->ctx, key, SSL_FILETYPE_PEM) <= 0)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to set key file.");
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
cookie->ssl = SSL_new(cookie->ctx);
|
||||||
|
if (!cookie->ssl)
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to create SSL object.");
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!SSL_set_fd(cookie->ssl, fd))
|
||||||
|
{
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to set file descriptor.");
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((acceptRet = SSL_accept(cookie->ssl)) <= 0)
|
||||||
|
{
|
||||||
|
switch (SSL_get_error(cookie->ssl, acceptRet))
|
||||||
|
{
|
||||||
|
case SSL_ERROR_WANT_READ:
|
||||||
|
case SSL_ERROR_WANT_WRITE:
|
||||||
|
case SSL_ERROR_WANT_CONNECT:
|
||||||
|
case SSL_ERROR_WANT_ACCEPT:
|
||||||
|
continue;
|
||||||
|
default:
|
||||||
|
Log(LOG_ERR, "TlsInitServer(): Unable to accept connection.");
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return cookie;
|
||||||
|
|
||||||
|
error:
|
||||||
|
Log(LOG_ERR, "TlsServerInit(): %s", SSLErrorString(SSL_get_error(cookie->ssl, acceptRet)));
|
||||||
|
Log(LOG_ERR, "TlsServerInit(): %s", ERR_error_string(ERR_get_error(), errorStr));
|
||||||
|
|
||||||
|
if (cookie->ssl)
|
||||||
|
{
|
||||||
|
SSL_shutdown(cookie->ssl);
|
||||||
|
SSL_free(cookie->ssl);
|
||||||
|
}
|
||||||
|
|
||||||
|
close(cookie->fd);
|
||||||
|
|
||||||
|
if (cookie->ctx)
|
||||||
|
{
|
||||||
|
SSL_CTX_free(cookie->ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
Free(cookie);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
TlsRead(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
OpenSSLCookie *ssl = cookie;
|
||||||
|
int ret = SSL_read(ssl->ssl, buf, nBytes);
|
||||||
|
|
||||||
|
if (ret <= 0)
|
||||||
|
{
|
||||||
|
switch (SSL_get_error(ssl->ssl, ret))
|
||||||
|
{
|
||||||
|
case SSL_ERROR_WANT_READ:
|
||||||
|
case SSL_ERROR_WANT_WRITE:
|
||||||
|
case SSL_ERROR_WANT_CONNECT:
|
||||||
|
case SSL_ERROR_WANT_ACCEPT:
|
||||||
|
case SSL_ERROR_WANT_X509_LOOKUP:
|
||||||
|
errno = EAGAIN;
|
||||||
|
break;
|
||||||
|
case SSL_ERROR_ZERO_RETURN:
|
||||||
|
ret = 0;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
errno = EIO;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
ret = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
TlsWrite(void *cookie, void *buf, size_t nBytes)
|
||||||
|
{
|
||||||
|
OpenSSLCookie *ssl = cookie;
|
||||||
|
int ret = SSL_write(ssl->ssl, buf, nBytes);
|
||||||
|
|
||||||
|
if (ret <= 0)
|
||||||
|
{
|
||||||
|
switch (SSL_get_error(ssl->ssl, ret))
|
||||||
|
{
|
||||||
|
case SSL_ERROR_WANT_READ:
|
||||||
|
case SSL_ERROR_WANT_WRITE:
|
||||||
|
case SSL_ERROR_WANT_CONNECT:
|
||||||
|
case SSL_ERROR_WANT_ACCEPT:
|
||||||
|
case SSL_ERROR_WANT_X509_LOOKUP:
|
||||||
|
errno = EAGAIN;
|
||||||
|
break;
|
||||||
|
case SSL_ERROR_ZERO_RETURN:
|
||||||
|
ret = 0;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
errno = EIO;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
ret = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
TlsClose(void *cookie)
|
||||||
|
{
|
||||||
|
OpenSSLCookie *ssl = cookie;
|
||||||
|
|
||||||
|
SSL_shutdown(ssl->ssl);
|
||||||
|
SSL_free(ssl->ssl);
|
||||||
|
close(ssl->fd);
|
||||||
|
SSL_CTX_free(ssl->ctx);
|
||||||
|
|
||||||
|
Free(ssl);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
73
src/Uri.c
Normal file
73
src/Uri.c
Normal file
|
@ -0,0 +1,73 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Uri.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
Uri *
|
||||||
|
UriParse(const char *str)
|
||||||
|
{
|
||||||
|
Uri *uri;
|
||||||
|
int res;
|
||||||
|
|
||||||
|
if (!str)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
uri = Malloc(sizeof(Uri));
|
||||||
|
if (!uri)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(uri, 0, sizeof(Uri));
|
||||||
|
|
||||||
|
res = sscanf(str, "%7[^:]://%127[^:]:%hu%255[^\n]", uri->proto, uri->host, &uri->port, uri->path) == 4
|
||||||
|
|| sscanf(str, "%7[^:]://%127[^/]%255[^\n]", uri->proto, uri->host, uri->path) == 3
|
||||||
|
|| sscanf(str, "%7[^:]://%127[^:]:%hu[^\n]", uri->proto, uri->host, &uri->port) == 3
|
||||||
|
|| sscanf(str, "%7[^:]://%127[^\n]", uri->proto, uri->host) == 2;
|
||||||
|
|
||||||
|
if (!res)
|
||||||
|
{
|
||||||
|
Free(uri);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!uri->path[0])
|
||||||
|
{
|
||||||
|
strcpy(uri->path, "/");
|
||||||
|
}
|
||||||
|
|
||||||
|
return uri;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
UriFree(Uri * uri)
|
||||||
|
{
|
||||||
|
Free(uri);
|
||||||
|
}
|
246
src/Util.c
Normal file
246
src/Util.c
Normal file
|
@ -0,0 +1,246 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <Util.h>
|
||||||
|
|
||||||
|
#include <Memory.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <sys/time.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <limits.h>
|
||||||
|
#include <pthread.h>
|
||||||
|
|
||||||
|
#ifndef PATH_MAX
|
||||||
|
#define PATH_MAX 256
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef SSIZE_MAX
|
||||||
|
#define SSIZE_MAX LONG_MAX
|
||||||
|
#endif
|
||||||
|
|
||||||
|
unsigned long
|
||||||
|
UtilServerTs(void)
|
||||||
|
{
|
||||||
|
struct timeval tv;
|
||||||
|
unsigned long ts;
|
||||||
|
|
||||||
|
gettimeofday(&tv, NULL);
|
||||||
|
ts = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
|
||||||
|
|
||||||
|
return ts;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned long
|
||||||
|
UtilLastModified(char *path)
|
||||||
|
{
|
||||||
|
struct stat st;
|
||||||
|
unsigned long ts;
|
||||||
|
|
||||||
|
if (stat(path, &st) == 0)
|
||||||
|
{
|
||||||
|
ts = (st.st_mtim.tv_sec * 1000) + (st.st_mtim.tv_nsec / 1000000);
|
||||||
|
return ts;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
UtilMkdir(const char *dir, const mode_t mode)
|
||||||
|
{
|
||||||
|
char tmp[PATH_MAX];
|
||||||
|
char *p = NULL;
|
||||||
|
|
||||||
|
struct stat st;
|
||||||
|
|
||||||
|
size_t len;
|
||||||
|
|
||||||
|
len = strnlen(dir, PATH_MAX);
|
||||||
|
if (!len || len == PATH_MAX)
|
||||||
|
{
|
||||||
|
errno = ENAMETOOLONG;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
memcpy(tmp, dir, len);
|
||||||
|
tmp[len] = '\0';
|
||||||
|
|
||||||
|
if (tmp[len - 1] == '/')
|
||||||
|
{
|
||||||
|
tmp[len - 1] = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stat(tmp, &st) == 0 && S_ISDIR(st.st_mode))
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (p = tmp + 1; *p; p++)
|
||||||
|
{
|
||||||
|
if (*p == '/')
|
||||||
|
{
|
||||||
|
*p = 0;
|
||||||
|
|
||||||
|
if (stat(tmp, &st) != 0)
|
||||||
|
{
|
||||||
|
if (mkdir(tmp, mode) < 0)
|
||||||
|
{
|
||||||
|
/* errno already set by mkdir() */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (!S_ISDIR(st.st_mode))
|
||||||
|
{
|
||||||
|
errno = ENOTDIR;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
*p = '/';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stat(tmp, &st) != 0)
|
||||||
|
{
|
||||||
|
if (mkdir(tmp, mode) < 0)
|
||||||
|
{
|
||||||
|
/* errno already set by mkdir() */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (!S_ISDIR(st.st_mode))
|
||||||
|
{
|
||||||
|
errno = ENOTDIR;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
UtilSleepMillis(long ms)
|
||||||
|
{
|
||||||
|
struct timespec ts;
|
||||||
|
int res;
|
||||||
|
|
||||||
|
ts.tv_sec = ms / 1000;
|
||||||
|
ts.tv_nsec = (ms % 1000) * 1000000;
|
||||||
|
|
||||||
|
res = nanosleep(&ts, &ts);
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
UtilGetDelim(char **linePtr, size_t * n, int delim, Stream * stream)
|
||||||
|
{
|
||||||
|
char *curPos, *newLinePtr;
|
||||||
|
size_t newLinePtrLen;
|
||||||
|
int c;
|
||||||
|
|
||||||
|
if (!linePtr || !n || !stream)
|
||||||
|
{
|
||||||
|
errno = EINVAL;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*linePtr == NULL)
|
||||||
|
{
|
||||||
|
*n = 128;
|
||||||
|
|
||||||
|
if (!(*linePtr = Malloc(*n)))
|
||||||
|
{
|
||||||
|
errno = ENOMEM;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
curPos = *linePtr;
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
c = StreamGetc(stream);
|
||||||
|
|
||||||
|
if (StreamError(stream) || (c == EOF && curPos == *linePtr))
|
||||||
|
{
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (c == EOF)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((*linePtr + *n - curPos) < 2)
|
||||||
|
{
|
||||||
|
if (SSIZE_MAX / 2 < *n)
|
||||||
|
{
|
||||||
|
#ifdef EOVERFLOW
|
||||||
|
errno = EOVERFLOW;
|
||||||
|
#else
|
||||||
|
errno = ERANGE;
|
||||||
|
#endif
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
newLinePtrLen = *n * 2;
|
||||||
|
|
||||||
|
if (!(newLinePtr = Realloc(*linePtr, newLinePtrLen)))
|
||||||
|
{
|
||||||
|
errno = ENOMEM;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
curPos = newLinePtr + (curPos - *linePtr);
|
||||||
|
*linePtr = newLinePtr;
|
||||||
|
*n = newLinePtrLen;
|
||||||
|
}
|
||||||
|
|
||||||
|
*curPos++ = (char) c;
|
||||||
|
|
||||||
|
if (c == delim)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*curPos = '\0';
|
||||||
|
return (ssize_t) (curPos - *linePtr);
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t
|
||||||
|
UtilGetLine(char **linePtr, size_t * n, Stream * stream)
|
||||||
|
{
|
||||||
|
return UtilGetDelim(linePtr, n, '\n', stream);
|
||||||
|
}
|
82
src/include/Args.h
Normal file
82
src/include/Args.h
Normal file
|
@ -0,0 +1,82 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_ARGS_H
|
||||||
|
#define CYTOPLASM_ARGS_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Args
|
||||||
|
* @Nd Getopt-style argument parser that operates on arrays.
|
||||||
|
* @Dd May 12 2023
|
||||||
|
* @Xr Array
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides a simple argument parser in the style of
|
||||||
|
* .Xr getopt 3 .
|
||||||
|
* It exists because the runtime passes the program arguments as
|
||||||
|
* an Array, and it is often useful to parse the arguments to
|
||||||
|
* provide the standard command line interface.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* All state is stored in this structure, instead of global
|
||||||
|
* variables. This makes
|
||||||
|
* .Nm
|
||||||
|
* thread-safe and easy to reset.
|
||||||
|
*/
|
||||||
|
typedef struct ArgParseState
|
||||||
|
{
|
||||||
|
int optInd;
|
||||||
|
int optErr;
|
||||||
|
int optOpt;
|
||||||
|
char *optArg;
|
||||||
|
|
||||||
|
int optPos;
|
||||||
|
} ArgParseState;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initialize the variables in the given parser state structure
|
||||||
|
* to their default values. This should be called before
|
||||||
|
* .Fn ArgParse
|
||||||
|
* is called with the parser state. It should also be called if
|
||||||
|
* .Fn ArgParse
|
||||||
|
* will be used again on a different array, or the same array all
|
||||||
|
* over again.
|
||||||
|
*/
|
||||||
|
extern void ArgParseStateInit(ArgParseState *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Parse command line arguments stored in the given array, using
|
||||||
|
* the given state and option string. This function behaves
|
||||||
|
* identically to the POSIX
|
||||||
|
* .Fn getopt
|
||||||
|
* function, and should be used in exactly the same way. Refer to
|
||||||
|
* your system's
|
||||||
|
* .Xr getopt 3
|
||||||
|
* page for details.
|
||||||
|
*/
|
||||||
|
extern int ArgParse(ArgParseState *, Array *, const char *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_ARGS_H */
|
164
src/include/Array.h
Normal file
164
src/include/Array.h
Normal file
|
@ -0,0 +1,164 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_ARRAY_H
|
||||||
|
#define CYTOPLASM_ARRAY_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Array
|
||||||
|
* @Nd A simple dynamic array data structure.
|
||||||
|
* @Dd November 24 2022
|
||||||
|
* @Xr HashMap Queue
|
||||||
|
*
|
||||||
|
* These functions implement a simple array data structure that is
|
||||||
|
* automatically resized as necessary when new values are added. This
|
||||||
|
* implementation does not actually store the values of the items in it;
|
||||||
|
* it only stores pointers to the data. As such, you will still have to
|
||||||
|
* manually maintain all your data. The advantage of this is that these
|
||||||
|
* functions don't have to copy data, and thus don't care how big the
|
||||||
|
* data is. Furthermore, arbitrary data can be stored in the array.
|
||||||
|
* .Pp
|
||||||
|
* This array implementation is optimized for storage space and
|
||||||
|
* appending. Deletions are expensive in that all the items of the list
|
||||||
|
* above a deletion are moved down to fill the hole where the deletion
|
||||||
|
* occurred. Insertions are also expensive in that all the elements
|
||||||
|
* above the given index must be shifted up to make room for the new
|
||||||
|
* element.
|
||||||
|
* .Pp
|
||||||
|
* Due to these design choices, this array implementation is best
|
||||||
|
* suited to linear writing, and then linear or random reading.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The functions in this API operate on an array structure which is
|
||||||
|
* opaque to the caller.
|
||||||
|
*/
|
||||||
|
typedef struct Array Array;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Allocate a new array. This function returns a pointer that can be
|
||||||
|
* used with the other functions in this API, or NULL if there was an
|
||||||
|
* error allocating memory for the array.
|
||||||
|
*/
|
||||||
|
extern Array * ArrayCreate(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Deallocate an array. Note that this function does not free any of
|
||||||
|
* the values stored in the array; it is the caller's job to manage the
|
||||||
|
* memory for each item. Typically, the caller would iterate over all
|
||||||
|
* the items in the array and free them before freeing the array.
|
||||||
|
*/
|
||||||
|
extern void ArrayFree(Array *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the size, in number of elements, of the given array.
|
||||||
|
*/
|
||||||
|
extern size_t ArraySize(Array *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the element at the specified index from the specified array.
|
||||||
|
* This function will return NULL if the array is NULL, or the index
|
||||||
|
* is out of bounds. Otherwise, it will return a pointer to a value
|
||||||
|
* put into the array using
|
||||||
|
* .Fn ArrayInsert
|
||||||
|
* or
|
||||||
|
* .Fn ArraySet .
|
||||||
|
*/
|
||||||
|
extern void * ArrayGet(Array *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Insert the specified element at the specified index in the specified
|
||||||
|
* array. This function will shift the element currently at that index,
|
||||||
|
* and any elements after it before inserting the given element.
|
||||||
|
* .Pp
|
||||||
|
* This function returns a boolean value indicating whether or not it
|
||||||
|
* suceeded.
|
||||||
|
*/
|
||||||
|
extern int ArrayInsert(Array *, size_t, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the value at the specified index in the specified array to the
|
||||||
|
* specified value. This function will return the old value at that
|
||||||
|
* index, if any.
|
||||||
|
*/
|
||||||
|
extern void * ArraySet(Array *, size_t, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Append the specified element to the end of the specified array. This
|
||||||
|
* function uses
|
||||||
|
* .Fn ArrayInsert
|
||||||
|
* under the hood to insert an element at the end. It thus has the same
|
||||||
|
* return value as
|
||||||
|
* .Fn ArrayInsert .
|
||||||
|
*/
|
||||||
|
extern int ArrayAdd(Array *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Remove the element at the specified index from the specified array.
|
||||||
|
* This function returns the element removed, if any.
|
||||||
|
*/
|
||||||
|
extern void * ArrayDelete(Array *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sort the specified array using the specified sort function. The
|
||||||
|
* sort function compares two elements. It takes two void pointers as
|
||||||
|
* parameters, and returns an integer. The return value indicates to
|
||||||
|
* the sorting algorithm how the elements relate to each other. A
|
||||||
|
* return value of 0 indicates that the elements are identical. A
|
||||||
|
* return value greater than 0 indicates that the first item is
|
||||||
|
* ``bigger'' than the second item and should thus appear after it in
|
||||||
|
* the array. A return value less than 0 indicates the opposite: the
|
||||||
|
* second element should appear after the first in the array.
|
||||||
|
*/
|
||||||
|
extern void ArraySort(Array *, int (*) (void *, void *));
|
||||||
|
|
||||||
|
/**
|
||||||
|
* If possible, reduce the amount of memory allocated to this array
|
||||||
|
* by calling
|
||||||
|
* .Fn Realloc
|
||||||
|
* on the internal structure to perfectly fit the elements in the
|
||||||
|
* array. This function is intended to be used by functions that return
|
||||||
|
* relatively read-only arrays that will be long-lived.
|
||||||
|
*/
|
||||||
|
extern int ArrayTrim(Array *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert a variadic arguments list into an Array. In most cases, the
|
||||||
|
* Array API is much easier to work with than
|
||||||
|
* .Fn va_arg
|
||||||
|
* and friends.
|
||||||
|
*/
|
||||||
|
extern Array * ArrayFromVarArgs(size_t, va_list);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Duplicate an existing array. Note that arrays only hold pointers to
|
||||||
|
* their data, not the data itself, so the duplicated array will point
|
||||||
|
* to the same places in memory as the original array.
|
||||||
|
*/
|
||||||
|
extern Array * ArrayDuplicate(Array *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_ARRAY_H */
|
99
src/include/Base64.h
Normal file
99
src/include/Base64.h
Normal file
|
@ -0,0 +1,99 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_BASE64_H
|
||||||
|
#define CYTOPLASM_BASE64_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Base64
|
||||||
|
* @Nd A simple base64 encoder/decoder with unpadded base64 support.
|
||||||
|
* @Dd September 30 2022
|
||||||
|
* @Xr Sha2
|
||||||
|
*
|
||||||
|
* This is an efficient yet simple base64 encoding and decoding API
|
||||||
|
* that supports regular base64, as well as the Matrix specification's
|
||||||
|
* extension to base64, called ``unpadded base64.'' This API provides
|
||||||
|
* the ability to convert between the two, instead of just implementing
|
||||||
|
* unpadded base64.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function computes the amount of bytes needed to store a message
|
||||||
|
* of the specified number of bytes as base64.
|
||||||
|
*/
|
||||||
|
extern size_t
|
||||||
|
Base64EncodedSize(size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function computes the amount of bytes needed to store a decoded
|
||||||
|
* representation of the encoded message. It takes a pointer to the
|
||||||
|
* encoded string because it must read a few bytes off the end in order
|
||||||
|
* to accurately compute the size.
|
||||||
|
*/
|
||||||
|
extern size_t
|
||||||
|
Base64DecodedSize(const char *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode the specified number of bytes from the specified buffer as
|
||||||
|
* base64. This function returns a string on the heap that should be
|
||||||
|
* freed with
|
||||||
|
* .Fn Free ,
|
||||||
|
* or NULL if a memory allocation error ocurred.
|
||||||
|
*/
|
||||||
|
extern char *
|
||||||
|
Base64Encode(const char *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode the specified number of bytes from the specified buffer of
|
||||||
|
* base64. This function returns a string on the heap that should be
|
||||||
|
* freed with
|
||||||
|
* .Fn Free ,
|
||||||
|
* or NULL if a memory allocation error occured.
|
||||||
|
*/
|
||||||
|
extern char *
|
||||||
|
Base64Decode(const char *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Remove the padding from a specified base64 string. This function
|
||||||
|
* modifies the specified string in place. It thus has no return value
|
||||||
|
* because it cannot fail. If the passed pointer is invalid, the
|
||||||
|
* behavior is undefined.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
Base64Unpad(char *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Add padding to an unpadded base64 string. This function takes a
|
||||||
|
* pointer to a pointer because it may be necessary to grow the memory
|
||||||
|
* allocated to the string. This function returns a boolean value
|
||||||
|
* indicating whether the pad operation was successful. In practice,
|
||||||
|
* this means it will only fail if a bigger string is necessary, but it
|
||||||
|
* could not be automatically allocated on the heap.
|
||||||
|
*/
|
||||||
|
extern int
|
||||||
|
Base64Pad(char **, size_t);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_BASE64_H */
|
139
src/include/Cron.h
Normal file
139
src/include/Cron.h
Normal file
|
@ -0,0 +1,139 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_CRON_H
|
||||||
|
#define CYTOPLASM_CRON_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Cron
|
||||||
|
* @Nd Basic periodic job scheduler.
|
||||||
|
* @Dd December 24 2022
|
||||||
|
*
|
||||||
|
* This is an extremely basic job scheduler. So basic, in fact, that
|
||||||
|
* it currently runs all jobs on a single thread, which means that it
|
||||||
|
* is intended for short-lived jobs. In the future, it might be
|
||||||
|
* extended to support a one-thread-per-job model, but for now, jobs
|
||||||
|
* should take into consideration the fact that they are sharing their
|
||||||
|
* thread, so they should not be long-running.
|
||||||
|
* .Pp
|
||||||
|
* .Nm
|
||||||
|
* works by ``ticking'' at an interval defined by the caller of
|
||||||
|
* .Fn CronCreate .
|
||||||
|
* At each tick, all the registered jobs are queried, and if they are
|
||||||
|
* due to run again, their function is executed. As much as possible,
|
||||||
|
* .Nm
|
||||||
|
* tries to tick at constant intervals, however it is possible that one
|
||||||
|
* or more jobs may overrun the tick duration. If this happens,
|
||||||
|
* .Nm
|
||||||
|
* ticks again immediately after all the jobs for the previous tick
|
||||||
|
* have completed. This is in an effort to compensate for lost time,
|
||||||
|
* however it is important to note that when jobs overrun the tick
|
||||||
|
* interval, the interval is pushed back by the amount that it was
|
||||||
|
* overrun. Because of this,
|
||||||
|
* .Nm
|
||||||
|
* is best suited for scheduling jobs that should happen
|
||||||
|
* ``aproximately'' every so often; it is not a real-time scheduler
|
||||||
|
* by any means.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* All functions defined here operate on a structure opaque to the
|
||||||
|
* caller.
|
||||||
|
*/
|
||||||
|
typedef struct Cron Cron;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A job function is a function that takes a void pointer and returns
|
||||||
|
* nothing. The pointer is passed when the job is scheduled, and
|
||||||
|
* is expected to remain valid until the job is no longer registered.
|
||||||
|
* The pointer is passed each time the job executes.
|
||||||
|
*/
|
||||||
|
typedef void (JobFunc) (void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new
|
||||||
|
* .Nm
|
||||||
|
* object that all other functions operate on. Like most of the other
|
||||||
|
* APIs in this project, it must be freed with
|
||||||
|
* .Fn CronFree
|
||||||
|
* when it is no longer needed.
|
||||||
|
* .Pp
|
||||||
|
* This function takes the tick interval in milliseconds.
|
||||||
|
*/
|
||||||
|
extern Cron *
|
||||||
|
CronCreate(unsigned long);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Schedule a one-off job to be executed only at the next tick, and
|
||||||
|
* then immediately discarded. This is useful for scheduling tasks that
|
||||||
|
* only have to happen once, or very infrequently depending on
|
||||||
|
* conditions other than the current time, but don't have to happen
|
||||||
|
* immediately. The caller simply indicates that it wishes for the task
|
||||||
|
* to execute at some time in the future. How far into the future this
|
||||||
|
* practically ends up being is determined by how long it takes for
|
||||||
|
* other registered jobs to finish, and what the tick interval is.
|
||||||
|
* .Pp
|
||||||
|
* This function takes a job function and a pointer to pass to that
|
||||||
|
* function when it is executed.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
CronOnce(Cron *, JobFunc *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Schedule a repetitive task to be executed at aproximately the given
|
||||||
|
* interval. As stated above, this is as fuzzy interval; depending on
|
||||||
|
* the jobs being run and the tick interval, tasks may not execute at
|
||||||
|
* exactly the scheduled time, but they will eventually execute.
|
||||||
|
* .Pp
|
||||||
|
* This function takes an interval in milliseconds, a job function,
|
||||||
|
* and a pointer to pass to that function when it is executed.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
CronEvery(Cron *, unsigned long, JobFunc *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Start ticking the clock and executing registered jobs.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
CronStart(Cron *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Stop ticking the clock. Jobs that are already executing will
|
||||||
|
* continue to execute, but when they are finished, no new jobs will
|
||||||
|
* be executed until
|
||||||
|
* .Fn CronStart
|
||||||
|
* is called.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
CronStop(Cron *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Discard all job references and free all memory associated with the
|
||||||
|
* given
|
||||||
|
* .Nm Cron
|
||||||
|
* instance.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
CronFree(Cron *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_CRON_H */
|
169
src/include/Db.h
Normal file
169
src/include/Db.h
Normal file
|
@ -0,0 +1,169 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_DB_H
|
||||||
|
#define CYTOPLASM_DB_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Db
|
||||||
|
* @Nd A minimal flat-file database with mutex locking and cache.
|
||||||
|
* @Dd April 27 2023
|
||||||
|
* @Xr Json
|
||||||
|
*
|
||||||
|
* Cytoplasm operates on a flat-file database instead of a
|
||||||
|
* traditional relational database. This greatly simplifies the
|
||||||
|
* persistent storage code, and creates a relatively basic API,
|
||||||
|
* described here.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* All functions in this API operate on a database structure that is
|
||||||
|
* opaque to the caller.
|
||||||
|
*/
|
||||||
|
typedef struct Db Db;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* When an object is locked, a reference is returned. This reference
|
||||||
|
* is owned by the current thread, and the database is inaccessible to
|
||||||
|
* other threads until all references have been returned to the
|
||||||
|
* database.
|
||||||
|
* .Pp
|
||||||
|
* This reference is opaque, but can be manipulated by the functions
|
||||||
|
* defined here.
|
||||||
|
*/
|
||||||
|
typedef struct DbRef DbRef;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Open a data directory. This function takes a path to open, and a
|
||||||
|
* cache size in bytes. If the cache size is 0, then caching is
|
||||||
|
* disabled and objects are loaded off the disk every time they are
|
||||||
|
* locked. Otherwise, objects are stored in the cache, and they are
|
||||||
|
* evicted in a least-recently-used manner.
|
||||||
|
*/
|
||||||
|
extern Db * DbOpen(char *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Close the database. This function will flush anything in the cache
|
||||||
|
* to the disk, and then close the data directory. It assumes that
|
||||||
|
* all references have been unlocked. If a reference has not been
|
||||||
|
* unlocked, undefined behavior results.
|
||||||
|
*/
|
||||||
|
extern void DbClose(Db *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the maximum cache size allowed before
|
||||||
|
* .Nm
|
||||||
|
* starts evicting old objects. If this is set to 0, everything in the
|
||||||
|
* cache is immediately evicted and caching is disabled. If the
|
||||||
|
* database was opened with a cache size of 0, setting this will
|
||||||
|
* initialize the cache, and subsequent calls to
|
||||||
|
* .Fn DbLock
|
||||||
|
* will begin caching objects.
|
||||||
|
*/
|
||||||
|
extern void DbMaxCacheSet(Db *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new object in the database with the specified name. This
|
||||||
|
* function will fail if the object already exists in the database. It
|
||||||
|
* takes a variable number of C strings, with the exact number being
|
||||||
|
* specified by the second parameter. These C strings are used to
|
||||||
|
* generate a filesystem path at which to store the object. These paths
|
||||||
|
* ensure each object is uniquely identifiable, and provides semantic
|
||||||
|
* meaning to an object.
|
||||||
|
*/
|
||||||
|
extern DbRef * DbCreate(Db *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Lock an existing object in the database. This function will fail
|
||||||
|
* if the object does not exist. It takes a variable number of C
|
||||||
|
* strings, with the exact number being specified by the second
|
||||||
|
* parameter. These C strings are used to generate the filesystem path
|
||||||
|
* at which to load the object. These paths ensure each object is
|
||||||
|
* uniquely identifiable, and provides semantic meaning to an object.
|
||||||
|
*/
|
||||||
|
extern DbRef * DbLock(Db *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Immediately and permanently remove an object from the database.
|
||||||
|
* This function assumes the object is not locked, otherwise undefined
|
||||||
|
* behavior will result.
|
||||||
|
*/
|
||||||
|
extern int DbDelete(Db *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unlock an object and return it back to the database. This function
|
||||||
|
* immediately syncs the object to the filesystem. The cache is a
|
||||||
|
* read cache; writes are always immediate to ensure data integrity in
|
||||||
|
* the event of a system failure.
|
||||||
|
*/
|
||||||
|
extern int DbUnlock(Db *, DbRef *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check the existence of the given database object in a more efficient
|
||||||
|
* manner than attempting to lock it with
|
||||||
|
* .Fn DbLock .
|
||||||
|
* This function does not lock the object, nor does it load it into
|
||||||
|
* memory if it exists.
|
||||||
|
*/
|
||||||
|
extern int DbExists(Db *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* List all of the objects at a given path. Unlike the other varargs
|
||||||
|
* functions, this one does not take a path to a specific object; it
|
||||||
|
* takes a directory to be iterated, where each path part is its own
|
||||||
|
* C string. Note that the resulting list only contains the objects
|
||||||
|
* in the specified directory, it does not list any subdirectories.
|
||||||
|
* .Pp
|
||||||
|
* The array returned is an array of C strings containing the object
|
||||||
|
* name.
|
||||||
|
*/
|
||||||
|
extern Array * DbList(Db *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the list returned by
|
||||||
|
* .Fn DbListFree .
|
||||||
|
*/
|
||||||
|
extern void DbListFree(Array *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert a database reference into JSON that can be manipulated.
|
||||||
|
* At this time, the database actually stores objects as JSON on the
|
||||||
|
* disk, so this function just returns an internal pointer, but in the
|
||||||
|
* future it may have to be generated by decompressing a binary blob,
|
||||||
|
* or something of that nature.
|
||||||
|
*/
|
||||||
|
extern HashMap * DbJson(DbRef *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the existing JSON associated with the given reference, and
|
||||||
|
* replace it with new JSON. This is more efficient than duplicating
|
||||||
|
* a separate object into the database reference.
|
||||||
|
*/
|
||||||
|
extern int DbJsonSet(DbRef *, HashMap *);
|
||||||
|
|
||||||
|
#endif
|
167
src/include/HashMap.h
Normal file
167
src/include/HashMap.h
Normal file
|
@ -0,0 +1,167 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_HASHMAP_H
|
||||||
|
#define CYTOPLASM_HASHMAP_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm HashMap
|
||||||
|
* @Nd A simple hash map implementation.
|
||||||
|
* @Dd October 11 2022
|
||||||
|
* @Xr Array Queue
|
||||||
|
*
|
||||||
|
* This is the public interface for Cytoplasm's hash map
|
||||||
|
* implementation. This hash map is designed to be simple,
|
||||||
|
* well-documented, and generally readable and understandable, yet also
|
||||||
|
* performant enough to be useful, because it is used extensively
|
||||||
|
* throughout the project.
|
||||||
|
* .Pp
|
||||||
|
* Fundamentally, this is an entirely generic map implementation. It
|
||||||
|
* can be used for many general purposes, but it is designed only to
|
||||||
|
* implement the features Cytoplasm needs to be functional. One
|
||||||
|
* example of a Cytoplasm-specific feature is that keys cannot be
|
||||||
|
* arbitrary data; they are NULL-terminated C strings.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* These functions operate on an opaque structure, which the caller
|
||||||
|
* has no knowledge about.
|
||||||
|
*/
|
||||||
|
typedef struct HashMap HashMap;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new hash map that is ready to be used with the rest of the
|
||||||
|
* functions defined here.
|
||||||
|
*/
|
||||||
|
extern HashMap * HashMapCreate(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the specified hash map such that it becomes invalid and any
|
||||||
|
* future use results in undefined behavior. Note that this function
|
||||||
|
* does not free the values stored in the hash map, but since it stores
|
||||||
|
* the keys internally, it will free the keys. You should use
|
||||||
|
* .Fn HashMapIterate
|
||||||
|
* to free the values stored in this map appropriately before calling
|
||||||
|
* this function.
|
||||||
|
*/
|
||||||
|
extern void HashMapFree(HashMap *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Control the maximum load of the hash map before it is expanded.
|
||||||
|
* When the hash map reaches the given capacity, it is grown. You
|
||||||
|
* don't want to only grow hash maps when they are full, because that
|
||||||
|
* makes them perform very poorly. The maximum load value is a
|
||||||
|
* percentage of how full the hash map is, and it should be between
|
||||||
|
* 0 and 1, where 0 means that no elements will cause the map to be
|
||||||
|
* expanded, and 1 means that the hash map must be completely full
|
||||||
|
* before it is expanded. The default maximum load on a new hash map
|
||||||
|
* is 0.75, which should be good enough for most purposes, however,
|
||||||
|
* this function exists specifically so that the maximum load can be
|
||||||
|
* fine-tuned.
|
||||||
|
*/
|
||||||
|
extern void HashMapMaxLoadSet(HashMap *, float);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Use a custom hashing function with the given hash map. New hash
|
||||||
|
* maps have a sane hashing function that should work okay for most
|
||||||
|
* use cases, but if you have a better hashing function, it can be
|
||||||
|
* specified this way. Do not change the hash function after keys have
|
||||||
|
* been added; doing so results in undefined behavior. Only set a new
|
||||||
|
* hash function immediately after constructing a new hash map, before
|
||||||
|
* anything has been added to it.
|
||||||
|
* .Pp
|
||||||
|
* The hash function takes a pointer to a C string, and is expected
|
||||||
|
* to return a fairly unique numerical hash value which will be
|
||||||
|
* converted into an array index.
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
HashMapFunctionSet(HashMap *, unsigned long (*) (const char *));
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the given string key to the given value. Note that the key is
|
||||||
|
* copied into the hash map's own memory space, but the value is not.
|
||||||
|
* It is the caller's job to ensure that the value pointer remains
|
||||||
|
* valid for the life of the hash map, and are freed when no longer
|
||||||
|
* needed.
|
||||||
|
*/
|
||||||
|
extern void * HashMapSet(HashMap *, char *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve the value for the given key, or return NULL if no such
|
||||||
|
* key exists in the hash map.
|
||||||
|
*/
|
||||||
|
extern void * HashMapGet(HashMap *, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Remove a value specified by the given key from the hash map, and
|
||||||
|
* return it to the caller to deal with. This function returns NULL
|
||||||
|
* if no such key exists.
|
||||||
|
*/
|
||||||
|
extern void * HashMapDelete(HashMap *, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Iterate over all the keys and values of a hash map. This function
|
||||||
|
* works very similarly to
|
||||||
|
* .Xr getopt 3 ,
|
||||||
|
* where calls are repeatedly made in a while loop until there are no
|
||||||
|
* more items to go over. The difference is that this function does not
|
||||||
|
* rely on globals; it takes pointer pointers, and stores all
|
||||||
|
* necessary state inside the hash map itself.
|
||||||
|
* .Pp
|
||||||
|
* Note that this function is not thread-safe; two threads cannot be
|
||||||
|
* iterating over any given hash map at the same time, though they
|
||||||
|
* can each be iterating over different hash maps.
|
||||||
|
* .Pp
|
||||||
|
* This function can be tricky to use in some scenarios, as it
|
||||||
|
* continues where it left off on each call, until there are no more
|
||||||
|
* elements to go through in the hash map. If you are not iterating
|
||||||
|
* over the entire map in one go, and happen to break the loop, then
|
||||||
|
* the next time you attempt to iterate the hash map, you'll start
|
||||||
|
* somewhere in the middle, which is most likely not the intended
|
||||||
|
* behavior. Thus, it is always recommended to iterate over the entire
|
||||||
|
* hash map if you're going to use this function.
|
||||||
|
* .Pp
|
||||||
|
* Also note that the behavior of this function is undefined if
|
||||||
|
* insertions or deletions occur during the iteration. This
|
||||||
|
* functionality has not been tested, and will likely not work.
|
||||||
|
*/
|
||||||
|
extern int HashMapIterate(HashMap *, char **, void **);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A reentrant version of
|
||||||
|
* .Fn HashMapIterate
|
||||||
|
* that allows the caller to overcome the flaws of that function by
|
||||||
|
* storing the cursor outside of the hash map structure itself. This
|
||||||
|
* allows multiple threads to iterate over the same hash map at the
|
||||||
|
* same time, and it allows the iteration to be halted midway through
|
||||||
|
* without causing any unintended side effects.
|
||||||
|
* .Pp
|
||||||
|
* The cursor should be initialized to 0 at the start of iteration.
|
||||||
|
*/
|
||||||
|
extern int
|
||||||
|
HashMapIterateReentrant(HashMap *, char **, void **, size_t *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_HASHMAP_H */
|
125
src/include/HeaderParser.h
Normal file
125
src/include/HeaderParser.h
Normal file
|
@ -0,0 +1,125 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_HEADERPARSER_H
|
||||||
|
#define CYTOPLASM_HEADERPARSER_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm HeaderParser
|
||||||
|
* @Nd Parse simple C header files.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is an extremely simple parser that lacks most of the functionality
|
||||||
|
* one would expect from a C code parser. It simply maps a stream
|
||||||
|
* of tokens into a few categories, parsing major ``milestones'' in
|
||||||
|
* a header, without actually understanding any of the details.
|
||||||
|
* .Pp
|
||||||
|
* This exists because it is used to generate man pages from headers.
|
||||||
|
* See
|
||||||
|
* .Xr hdoc 1
|
||||||
|
* for example usage of this parser.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Stream.h>
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
#define HEADER_EXPR_MAX 4096
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Headers are parsed as expressions. These are the expressions that
|
||||||
|
* this parser recognizes.
|
||||||
|
*/
|
||||||
|
typedef enum HeaderExprType
|
||||||
|
{
|
||||||
|
HP_COMMENT,
|
||||||
|
HP_PREPROCESSOR_DIRECTIVE,
|
||||||
|
HP_TYPEDEF,
|
||||||
|
HP_DECLARATION,
|
||||||
|
HP_GLOBAL,
|
||||||
|
HP_UNKNOWN,
|
||||||
|
HP_SYNTAX_ERROR,
|
||||||
|
HP_PARSE_ERROR,
|
||||||
|
HP_EOF
|
||||||
|
} HeaderExprType;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A representation of a function declaration.
|
||||||
|
*/
|
||||||
|
typedef struct HeaderDeclaration
|
||||||
|
{
|
||||||
|
char returnType[64];
|
||||||
|
char name[32]; /* Enforced by ANSI C */
|
||||||
|
Array *args;
|
||||||
|
} HeaderDeclaration;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A global variable declaration. The type must be of the same size
|
||||||
|
* as the function declaration's return type due to the way parsing
|
||||||
|
* them is implemented.
|
||||||
|
*/
|
||||||
|
typedef struct HeaderGlobal
|
||||||
|
{
|
||||||
|
char type[64];
|
||||||
|
char name[HEADER_EXPR_MAX - 64];
|
||||||
|
} HeaderGlobal;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A representation of a single header expression. Note that that state
|
||||||
|
* structure is entirely internally managed, so it should not be
|
||||||
|
* accessed or manipulated by functions outside the functions defined
|
||||||
|
* here.
|
||||||
|
* .Pp
|
||||||
|
* The type field should be used to determine which field in the data
|
||||||
|
* union is valid.
|
||||||
|
*/
|
||||||
|
typedef struct HeaderExpr
|
||||||
|
{
|
||||||
|
HeaderExprType type;
|
||||||
|
union
|
||||||
|
{
|
||||||
|
char text[HEADER_EXPR_MAX];
|
||||||
|
HeaderDeclaration declaration;
|
||||||
|
HeaderGlobal global;
|
||||||
|
struct
|
||||||
|
{
|
||||||
|
int lineNo;
|
||||||
|
char *msg;
|
||||||
|
} error;
|
||||||
|
} data;
|
||||||
|
|
||||||
|
struct
|
||||||
|
{
|
||||||
|
Stream *stream;
|
||||||
|
int lineNo;
|
||||||
|
} state;
|
||||||
|
} HeaderExpr;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Parse the next expression into the given header expression structure.
|
||||||
|
* To parse an entire C header, this function should be called in a
|
||||||
|
* loop until the type of the expression is HP_EOF.
|
||||||
|
*/
|
||||||
|
extern void HeaderParse(Stream *, HeaderExpr *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_HEADERPARSER_H */
|
211
src/include/Http.h
Normal file
211
src/include/Http.h
Normal file
|
@ -0,0 +1,211 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_HTTP_H
|
||||||
|
#define CYTOPLASM_HTTP_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Http
|
||||||
|
* @Nd Encode and decode various parts of the HTTP protocol.
|
||||||
|
* @Dd March 12 2023
|
||||||
|
* @Xr HttpClient HttpServer HashMap Queue Memory
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is a collection of utility functions and type definitions that are
|
||||||
|
* useful for dealing with HTTP. HTTP is not a complex protocol, but
|
||||||
|
* this API makes it a lot easier to work with.
|
||||||
|
* .Pp
|
||||||
|
* Note that this API doesn't target any particular HTTP version, but
|
||||||
|
* it is currently used with HTTP 1.0 clients and servers, and
|
||||||
|
* therefore may be lacking functionality added in later HTTP versions.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#define HTTP_FLAG_NONE 0
|
||||||
|
#define HTTP_FLAG_TLS (1 << 0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The request methods defined by the HTTP standard. These numeric
|
||||||
|
* constants should be preferred to strings when building HTTP APIs
|
||||||
|
* because they are more efficient.
|
||||||
|
*/
|
||||||
|
typedef enum HttpRequestMethod
|
||||||
|
{
|
||||||
|
HTTP_METHOD_UNKNOWN,
|
||||||
|
HTTP_GET,
|
||||||
|
HTTP_HEAD,
|
||||||
|
HTTP_POST,
|
||||||
|
HTTP_PUT,
|
||||||
|
HTTP_DELETE,
|
||||||
|
HTTP_CONNECT,
|
||||||
|
HTTP_OPTIONS,
|
||||||
|
HTTP_TRACE,
|
||||||
|
HTTP_PATCH
|
||||||
|
} HttpRequestMethod;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An enumeration that corresponds to the actual integer values of the
|
||||||
|
* valid HTTP response codes.
|
||||||
|
*/
|
||||||
|
typedef enum HttpStatus
|
||||||
|
{
|
||||||
|
HTTP_STATUS_UNKNOWN = 0,
|
||||||
|
|
||||||
|
/* Informational responses */
|
||||||
|
HTTP_CONTINUE = 100,
|
||||||
|
HTTP_SWITCHING_PROTOCOLS = 101,
|
||||||
|
HTTP_EARLY_HINTS = 103,
|
||||||
|
|
||||||
|
/* Successful responses */
|
||||||
|
HTTP_OK = 200,
|
||||||
|
HTTP_CREATED = 201,
|
||||||
|
HTTP_ACCEPTED = 202,
|
||||||
|
HTTP_NON_AUTHORITATIVE_INFORMATION = 203,
|
||||||
|
HTTP_NO_CONTENT = 204,
|
||||||
|
HTTP_RESET_CONTENT = 205,
|
||||||
|
HTTP_PARTIAL_CONTENT = 206,
|
||||||
|
|
||||||
|
/* Redirection messages */
|
||||||
|
HTTP_MULTIPLE_CHOICES = 300,
|
||||||
|
HTTP_MOVED_PERMANENTLY = 301,
|
||||||
|
HTTP_FOUND = 302,
|
||||||
|
HTTP_SEE_OTHER = 303,
|
||||||
|
HTTP_NOT_MODIFIED = 304,
|
||||||
|
HTTP_TEMPORARY_REDIRECT = 307,
|
||||||
|
HTTP_PERMANENT_REDIRECT = 308,
|
||||||
|
|
||||||
|
/* Client error messages */
|
||||||
|
HTTP_BAD_REQUEST = 400,
|
||||||
|
HTTP_UNAUTHORIZED = 401,
|
||||||
|
HTTP_FORBIDDEN = 403,
|
||||||
|
HTTP_NOT_FOUND = 404,
|
||||||
|
HTTP_METHOD_NOT_ALLOWED = 405,
|
||||||
|
HTTP_NOT_ACCEPTABLE = 406,
|
||||||
|
HTTP_PROXY_AUTH_REQUIRED = 407,
|
||||||
|
HTTP_REQUEST_TIMEOUT = 408,
|
||||||
|
HTTP_CONFLICT = 409,
|
||||||
|
HTTP_GONE = 410,
|
||||||
|
HTTP_LENGTH_REQUIRED = 411,
|
||||||
|
HTTP_PRECONDITION_FAILED = 412,
|
||||||
|
HTTP_PAYLOAD_TOO_LARGE = 413,
|
||||||
|
HTTP_URI_TOO_LONG = 414,
|
||||||
|
HTTP_UNSUPPORTED_MEDIA_TYPE = 415,
|
||||||
|
HTTP_RANGE_NOT_SATISFIABLE = 416,
|
||||||
|
HTTP_EXPECTATION_FAILED = 417,
|
||||||
|
HTTP_TEAPOT = 418,
|
||||||
|
HTTP_UPGRADE_REQUIRED = 426,
|
||||||
|
HTTP_PRECONDITION_REQUIRED = 428,
|
||||||
|
HTTP_TOO_MANY_REQUESTS = 429,
|
||||||
|
HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
|
||||||
|
HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
|
||||||
|
|
||||||
|
/* Server error responses */
|
||||||
|
HTTP_INTERNAL_SERVER_ERROR = 500,
|
||||||
|
HTTP_NOT_IMPLEMENTED = 501,
|
||||||
|
HTTP_BAD_GATEWAY = 502,
|
||||||
|
HTTP_SERVICE_UNAVAILABLE = 503,
|
||||||
|
HTTP_GATEWAY_TIMEOUT = 504,
|
||||||
|
HTTP_VERSION_NOT_SUPPORTED = 505,
|
||||||
|
HTTP_VARIANT_ALSO_NEGOTIATES = 506,
|
||||||
|
HTTP_NOT_EXTENDED = 510,
|
||||||
|
HTTP_NETWORK_AUTH_REQUIRED = 511
|
||||||
|
} HttpStatus;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert an HTTP status enumeration value into a string description
|
||||||
|
* of the status, which is to be used in server response to a client,
|
||||||
|
* or a client response to a user. For example, calling
|
||||||
|
* .Fn HttpStatusToString "HTTP_GATEWAY_TIMEOUT"
|
||||||
|
* (or
|
||||||
|
* .Fn HttpStatusToString "504" )
|
||||||
|
* produces the string "Gateway Timeout". Note that the returned
|
||||||
|
* pointers point to static space, so their manipulation is forbidden.
|
||||||
|
*/
|
||||||
|
extern const char * HttpStatusToString(const HttpStatus);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert a string into a numeric code that can be used throughout
|
||||||
|
* the code of a program in an efficient manner. See the definition
|
||||||
|
* of HttpRequestMethod. This function does case-sensitive matching,
|
||||||
|
* and does not trim or otherwise process the input string.
|
||||||
|
*/
|
||||||
|
extern HttpRequestMethod HttpRequestMethodFromString(const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert a numeric code as defined by HttpRequestMethod into a
|
||||||
|
* string that can be sent to a server. Note that the returned pointers
|
||||||
|
* point to static space, so their manipulation is forbidden.
|
||||||
|
*/
|
||||||
|
extern const char * HttpRequestMethodToString(const HttpRequestMethod);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a C string such that it can safely appear in a URL by
|
||||||
|
* performing the necessary percent escaping. A new string on the
|
||||||
|
* heap is returned. It should be freed with
|
||||||
|
* .Fn Free ,
|
||||||
|
* defined in the
|
||||||
|
* .Xr Memory 3
|
||||||
|
* API.
|
||||||
|
*/
|
||||||
|
extern char * HttpUrlEncode(char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode a percent-encoded string into a C string, ignoring encoded
|
||||||
|
* null characters entirely, because those would do nothing but cause
|
||||||
|
* problems.
|
||||||
|
*/
|
||||||
|
extern char * HttpUrlDecode(char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode an encoded parameter string in the form of
|
||||||
|
* ``key=val&key2=val2'' into a hash map whose values are C strings.
|
||||||
|
* This function properly decodes keys and values using the functions
|
||||||
|
* defined above.
|
||||||
|
*/
|
||||||
|
extern HashMap * HttpParamDecode(char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a hash map whose values are strings as an HTTP parameter
|
||||||
|
* string suitable for GET or POST requests.
|
||||||
|
*/
|
||||||
|
extern char * HttpParamEncode(HashMap *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read HTTP headers from a stream and return a hash map whose values
|
||||||
|
* are strings. All keys are lowercased to make querying them
|
||||||
|
* consistent and not dependent on the case that was read from the
|
||||||
|
* stream. This is useful for both client and server code, since the
|
||||||
|
* headers are in the same format. This function should be used after
|
||||||
|
* parsing the HTTP status line, because it does not parse that line.
|
||||||
|
* It will stop when it encounters the first blank line, which
|
||||||
|
* indicates that the body is beginning. After this function completes,
|
||||||
|
* the body may be immediately read from the stream without any
|
||||||
|
* additional processing.
|
||||||
|
*/
|
||||||
|
extern HashMap * HttpParseHeaders(Stream *);
|
||||||
|
|
||||||
|
#endif
|
104
src/include/HttpClient.h
Normal file
104
src/include/HttpClient.h
Normal file
|
@ -0,0 +1,104 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_HTTPCLIENT_H
|
||||||
|
#define CYTOPLASM_HTTPCLIENT_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm HttpClient
|
||||||
|
* @Nd Extremely simple HTTP client.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr Http HttpServer Tls
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* HttpClient
|
||||||
|
* builds on the HTTP API to provide a simple yet functional HTTP
|
||||||
|
* client. It aims at being easy to use and minimal, yet also
|
||||||
|
* efficient.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Http.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A server response is represented by a client context. It is
|
||||||
|
* opaque, so the functions defined in this API should be used to
|
||||||
|
* fetch data from and manipulate it.
|
||||||
|
*/
|
||||||
|
typedef struct HttpClientContext HttpClientContext;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Make an HTTP request. This function takes the request method,
|
||||||
|
* any flags defined in the HTTP API, the port, hostname, and path,
|
||||||
|
* all in that order. It returns NULL if there was an error making
|
||||||
|
* the request. Otherwise it returns a client context. Note that this
|
||||||
|
* function does not actually send any data, it simply makes the
|
||||||
|
* connection. Use
|
||||||
|
* .Fn HttpRequestHeader
|
||||||
|
* to add headers to the request. Then, send headers with
|
||||||
|
* .Fn HttpRequestSendHeaders .
|
||||||
|
* Finally, the request body, if any, can be written to the output
|
||||||
|
* stream, and then the request can be fully sent using
|
||||||
|
* .Fn HttpRequestSend .
|
||||||
|
*/
|
||||||
|
extern HttpClientContext *
|
||||||
|
HttpRequest(HttpRequestMethod, int, unsigned short, char *, char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set a request header to send to the server when making the
|
||||||
|
* request.
|
||||||
|
*/
|
||||||
|
extern void HttpRequestHeader(HttpClientContext *, char *, char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Send the request headers to the server. This must be called before
|
||||||
|
* the request body can be written or a response body can be read.
|
||||||
|
*/
|
||||||
|
extern void HttpRequestSendHeaders(HttpClientContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Flush the request stream to the server. This function should be
|
||||||
|
* called before the response body is read.
|
||||||
|
*/
|
||||||
|
extern HttpStatus HttpRequestSend(HttpClientContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the headers returned by the server.
|
||||||
|
*/
|
||||||
|
extern HashMap * HttpResponseHeaders(HttpClientContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the stream used to write the request body and read the
|
||||||
|
* response body.
|
||||||
|
*/
|
||||||
|
extern Stream * HttpClientStream(HttpClientContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free all memory associated with the client context. This closes the
|
||||||
|
* connection, if it was still open.
|
||||||
|
*/
|
||||||
|
extern void HttpClientContextFree(HttpClientContext *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_HTTPCLIENT_H */
|
91
src/include/HttpRouter.h
Normal file
91
src/include/HttpRouter.h
Normal file
|
@ -0,0 +1,91 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_HTTPROUTER_H
|
||||||
|
#define CYTOPLASM_HTTPROUTER_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm HttpRouter
|
||||||
|
* @Nd Simple HTTP request router with regular expression support.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr HttpServer Http
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides a simple mechanism for assigning functions to an HTTP
|
||||||
|
* request path. It is a simple tree data structure that parses the
|
||||||
|
* registered request paths and maps functions onto each part of the
|
||||||
|
* path. Then, requests can be easily routed to their appropriate
|
||||||
|
* handler functions.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The router structure is opaque and thus managed entirely by the
|
||||||
|
* functions defined in this API.
|
||||||
|
*/
|
||||||
|
typedef struct HttpRouter HttpRouter;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A function written to handle an HTTP request takes an array
|
||||||
|
* consisting of the matched path parts in the order they appear in
|
||||||
|
* the path, and a pointer to caller-provided arguments, if any.
|
||||||
|
* It returns a pointer that the caller is assumed to know how to
|
||||||
|
* handle.
|
||||||
|
*/
|
||||||
|
typedef void *(HttpRouteFunc) (Array *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new empty routing tree.
|
||||||
|
*/
|
||||||
|
extern HttpRouter * HttpRouterCreate(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free all the memory associated with the given routing tree.
|
||||||
|
*/
|
||||||
|
extern void HttpRouterFree(HttpRouter *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Register the specified route function to be executed upon requests
|
||||||
|
* for the specified HTTP path. The path is parsed by splitting at
|
||||||
|
* each path separator. Each part of the path is a regular expression
|
||||||
|
* that matches the entire path part. A regular expression cannot
|
||||||
|
* match more than one path part. This allows for paths like
|
||||||
|
* .Pa /some/path/(.*)/parts
|
||||||
|
* to work as one would expect.
|
||||||
|
*/
|
||||||
|
extern int HttpRouterAdd(HttpRouter *, char *, HttpRouteFunc *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Route the specified request path using the specified routing
|
||||||
|
* tree. This function will parse the path and match it to the
|
||||||
|
* appropriate route handler function. The return value is a boolean
|
||||||
|
* value that indicates whether or not an appropriate route function
|
||||||
|
* was found. If an appropriate function was found, then the void
|
||||||
|
* pointer is passed to it as arguments that it is expected to know
|
||||||
|
* how to handle, and the pointer to a void pointer is where the
|
||||||
|
* route function's response will be placed.
|
||||||
|
*/
|
||||||
|
extern int HttpRouterRoute(HttpRouter *, char *, void *, void **);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_HTTPROUTER_H */
|
234
src/include/HttpServer.h
Normal file
234
src/include/HttpServer.h
Normal file
|
@ -0,0 +1,234 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_HTTPSERVER_H
|
||||||
|
#define CYTOPLASM_HTTPSERVER_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm HttpServer
|
||||||
|
* @Nd Extremely simple HTTP server.
|
||||||
|
* @Dd December 13 2022
|
||||||
|
* @Xr Http HttpClient
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* builds on the
|
||||||
|
* .Xr Http 3
|
||||||
|
* API, and provides a very simple, yet very functional API for
|
||||||
|
* creating an HTTP server. It aims at being easy to use and minimal,
|
||||||
|
* yet also efficient. It uses non-blocking I/O, is fully
|
||||||
|
* multi-threaded, and is very configurable. It can be set up in just
|
||||||
|
* two function calls and minimal supporting code.
|
||||||
|
* .Pp
|
||||||
|
* This API should be familar to those that have dealt with the HTTP
|
||||||
|
* server libraries of other programming languages, particularly Java.
|
||||||
|
* In fact, much of the terminology used in this API came from Java,
|
||||||
|
* and you'll notice that the way responses are sent and received very
|
||||||
|
* closely resembles Java.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Http.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The functions on this API operate on an opaque structure.
|
||||||
|
*/
|
||||||
|
typedef struct HttpServer HttpServer;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Each request receives a context structure. It is opaque, so the
|
||||||
|
* functions defined in this API should be used to fetch data from
|
||||||
|
* it. These functions allow the handler to figure out the context of
|
||||||
|
* the request, which includes the path requested, any parameters,
|
||||||
|
* and the headers and method used to make the request. The context
|
||||||
|
* also provides the means by which the handler responds to the
|
||||||
|
* request, allowing it to set the status code, headers, and body.
|
||||||
|
*/
|
||||||
|
typedef struct HttpServerContext HttpServerContext;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The request handler function is executed when an HTTP request is
|
||||||
|
* received. It takes a request context, and a pointer as specified
|
||||||
|
* in the server configuration.
|
||||||
|
*/
|
||||||
|
typedef void (HttpHandler) (HttpServerContext *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The number of arguments to
|
||||||
|
* .Fn HttpServerCreate
|
||||||
|
* has grown so large that arguments are now stuffed into a
|
||||||
|
* configuration structure, which is in turn passed to
|
||||||
|
* .Fn HttpServerCreate .
|
||||||
|
* This configuration is copied by value into the internal
|
||||||
|
* structures of the server. It is copied with very minimal
|
||||||
|
* validation, so ensure that all values are sensible. It may
|
||||||
|
* make sense to use
|
||||||
|
* .Fn memset
|
||||||
|
* to zero out everything in here before assigning values.
|
||||||
|
*/
|
||||||
|
typedef struct HttpServerConfig
|
||||||
|
{
|
||||||
|
unsigned short port;
|
||||||
|
unsigned int threads;
|
||||||
|
unsigned int maxConnections;
|
||||||
|
|
||||||
|
int flags; /* Http(3) flags */
|
||||||
|
char *tlsCert; /* File path */
|
||||||
|
char *tlsKey; /* File path */
|
||||||
|
|
||||||
|
HttpHandler *handler;
|
||||||
|
void *handlerArgs;
|
||||||
|
} HttpServerConfig;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new HTTP server using the specified configuration.
|
||||||
|
* This will set up all internal structures used by the server,
|
||||||
|
* and bind the socket and start listening for connections. However,
|
||||||
|
* it will not start accepting connections.
|
||||||
|
*/
|
||||||
|
extern HttpServer * HttpServerCreate(HttpServerConfig *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve the configuration that was used to instantiate the given
|
||||||
|
* server. Note that this configuration is not necessarily the exact
|
||||||
|
* one that was provided; even though its values are the same, it
|
||||||
|
* should be treated as an entirely separate configuration with no
|
||||||
|
* connection to the original.
|
||||||
|
*/
|
||||||
|
extern HttpServerConfig * HttpServerConfigGet(HttpServer *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the resources associated with the given HTTP server. Note that
|
||||||
|
* the server can only be freed after it has been stopped. Calling this
|
||||||
|
* function while the server is still running results in undefined
|
||||||
|
* behavior.
|
||||||
|
*/
|
||||||
|
extern void HttpServerFree(HttpServer *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Attempt to start the HTTP server, and return immediately with the
|
||||||
|
* status. This API is fully multi-threaded and asynchronous, so the
|
||||||
|
* caller can continue working while the HTTP server is running in a
|
||||||
|
* separate thread and managing a pool of threads to handle responses.
|
||||||
|
*/
|
||||||
|
extern int HttpServerStart(HttpServer *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Typically, at some point after calling
|
||||||
|
* .Fn HttpServerStart ,
|
||||||
|
* the program will have no more work to do, so it will want to wait
|
||||||
|
* for the HTTP server to finish. This is accomplished via this
|
||||||
|
* function, which joins the HTTP worker thread to the calling thread,
|
||||||
|
* pausing the calling thread until the HTTP server has stopped.
|
||||||
|
*/
|
||||||
|
extern void HttpServerJoin(HttpServer *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Stop the HTTP server. Only the execution of this function will
|
||||||
|
* cause the proper shutdown of the HTTP server. If the main program
|
||||||
|
* is joined to the HTTP thread, then either another thread or a
|
||||||
|
* signal handler will have to stop the server using this function.
|
||||||
|
* The typical use case is to install a signal handler that executes
|
||||||
|
* this function on a global HTTP server.
|
||||||
|
*/
|
||||||
|
extern void HttpServerStop(HttpServer *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the request headers for the request represented by the given
|
||||||
|
* context. The data in the returned hash map should be treated as
|
||||||
|
* read only and should not be freed; it is managed entirely by the
|
||||||
|
* server.
|
||||||
|
*/
|
||||||
|
extern HashMap * HttpRequestHeaders(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the request method used to make the request represented by
|
||||||
|
* the given context.
|
||||||
|
*/
|
||||||
|
extern HttpRequestMethod HttpRequestMethodGet(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the request path for the request represented by the given
|
||||||
|
* context. The return value of this function should be treated as
|
||||||
|
* read-only, and should not be freed; it is managed entirely by the
|
||||||
|
* server.
|
||||||
|
*/
|
||||||
|
extern char * HttpRequestPath(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve the parsed GET parameters for the request represented by
|
||||||
|
* the given context. The returned hash map should be treated as
|
||||||
|
* read-only, and should not be freed; it is managed entirely by the
|
||||||
|
* server.
|
||||||
|
*/
|
||||||
|
extern HashMap * HttpRequestParams(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set a response header to return to the client. The old value for
|
||||||
|
* the given header is returned, if any, otherwise NULL is returned.
|
||||||
|
*/
|
||||||
|
extern char * HttpResponseHeader(HttpServerContext *, char *, char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the response status to return to the client.
|
||||||
|
*/
|
||||||
|
extern void HttpResponseStatus(HttpServerContext *, HttpStatus);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the current response status that will be sent to the client
|
||||||
|
* making the request represented by the given context.
|
||||||
|
*/
|
||||||
|
extern HttpStatus HttpResponseStatusGet(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Send the response headers to the client that made the request
|
||||||
|
* represented by the specified context. This function must be called
|
||||||
|
* before the response body can be written, otherwise a malformed
|
||||||
|
* response will be sent.
|
||||||
|
*/
|
||||||
|
extern void HttpSendHeaders(HttpServerContext *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a stream that is both readable and writable. Reading from the
|
||||||
|
* stream reads the request body that the client sent, if there is one.
|
||||||
|
* Note that the rquest headers have already been read, so the stream
|
||||||
|
* is correctly positioned at the beginning of the body of the request.
|
||||||
|
* .Fn HttpSendHeaders
|
||||||
|
* must be called before the stream is written, otherwise a malformed
|
||||||
|
* HTTP response will be sent. An HTTP handler should properly set all
|
||||||
|
* the headers it itends to send, send those headers, and then write
|
||||||
|
* the response body to this stream.
|
||||||
|
* .Pp
|
||||||
|
* Note that the stream does not need to be closed by the HTTP
|
||||||
|
* handler; in fact doing so results in undefined behavior. The stream
|
||||||
|
* is managed entirely by the server itself, so it will close it when
|
||||||
|
* necessary. This allows the underlying protocol to differ: for
|
||||||
|
* instance, an HTTP/1.1 connection may stay for multiple requests and
|
||||||
|
* responses.
|
||||||
|
*/
|
||||||
|
extern Stream * HttpServerStream(HttpServerContext *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_HTTPSERVER_H */
|
125
src/include/Int.h
Normal file
125
src/include/Int.h
Normal file
|
@ -0,0 +1,125 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_INT_H
|
||||||
|
#define CYTOPLASM_INT_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Int
|
||||||
|
* @Nd Fixed-width integer types.
|
||||||
|
* @Dd April 27 2023
|
||||||
|
*
|
||||||
|
* This header provides cross-platform, fixed-width integer types.
|
||||||
|
* Specifically, it uses preprocessor magic to define the following
|
||||||
|
* types:
|
||||||
|
* .Bl -bullet -offset indent
|
||||||
|
* .It
|
||||||
|
* Int8 and UInt8
|
||||||
|
* .It
|
||||||
|
* Int16 and UInt16
|
||||||
|
* .It
|
||||||
|
* Int32 and UInt32
|
||||||
|
* .El
|
||||||
|
* .Pp
|
||||||
|
* Note that there is no 64-bit integer type, because the ANSI C
|
||||||
|
* standard makes no guarantee that such a type will exist, even
|
||||||
|
* though it does on most platforms.
|
||||||
|
* .Pp
|
||||||
|
* The reason Cytoplasm provides its own header for this is
|
||||||
|
* because ANSI C does not define fixed-width types, and while it
|
||||||
|
* should be safe to rely on C99 fixed-width types in most cases,
|
||||||
|
* there may be cases where even that is not possible.
|
||||||
|
*
|
||||||
|
* @ignore-typedefs
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <limits.h>
|
||||||
|
|
||||||
|
#define BIT64_MAX 18446744073709551615
|
||||||
|
#define BIT32_MAX 4294967295
|
||||||
|
#define BIT16_MAX 65535
|
||||||
|
#define BIT8_MAX 255
|
||||||
|
|
||||||
|
#ifndef UCHAR_MAX
|
||||||
|
#error Size of char data type is unknown. Define UCHAR_MAX.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef USHRT_MAX
|
||||||
|
#error Size of short data type is unknown. Define USHRT_MAX.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef UINT_MAX
|
||||||
|
#error Size of int data type is unknown. Define UINT_MAX.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef ULONG_MAX
|
||||||
|
#error Size of long data type is unknown. Define ULONG_MAX.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if UCHAR_MAX == BIT8_MAX
|
||||||
|
typedef signed char Int8;
|
||||||
|
typedef unsigned char UInt8;
|
||||||
|
|
||||||
|
#else
|
||||||
|
#error Unable to determine suitable data type for 8-bit integers.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if UINT_MAX == BIT16_MAX
|
||||||
|
typedef signed int Int16;
|
||||||
|
typedef unsigned int UInt16;
|
||||||
|
|
||||||
|
#elif USHRT_MAX == BIT16_MAX
|
||||||
|
typedef signed short Int16;
|
||||||
|
typedef unsigned short UInt16;
|
||||||
|
|
||||||
|
#elif UCHAR_MAX == BIT16_MAX
|
||||||
|
typedef signed char Int16;
|
||||||
|
typedef unsigned char UInt16;
|
||||||
|
|
||||||
|
#else
|
||||||
|
#error Unable to determine suitable data type for 16-bit integers.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if ULONG_MAX == BIT32_MAX
|
||||||
|
typedef signed long Int32;
|
||||||
|
typedef unsigned long UInt32;
|
||||||
|
|
||||||
|
#elif UINT_MAX == BIT32_MAX
|
||||||
|
typedef signed int Int32;
|
||||||
|
typedef unsigned int UInt32;
|
||||||
|
|
||||||
|
#elif USHRT_MAX == BIT32_MAX
|
||||||
|
typedef signed short Int32;
|
||||||
|
typedef unsigned short UInt32;
|
||||||
|
|
||||||
|
#elif UCHAR_MAX == BIT32_MAX
|
||||||
|
typedef signed char Int32;
|
||||||
|
typedef unsigned char UInt32;
|
||||||
|
|
||||||
|
#else
|
||||||
|
#error Unable to determine suitable data type for 32-bit integers.
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* The ANSI C standard only guarantees a data size of up to 32 bits. */
|
||||||
|
|
||||||
|
#endif
|
222
src/include/Io.h
Normal file
222
src/include/Io.h
Normal file
|
@ -0,0 +1,222 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_IO_H
|
||||||
|
#define CYTOPLASM_IO_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Io
|
||||||
|
* @Nd Source/sink-agnostic I/O for implementing custom streams.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr Stream Tls
|
||||||
|
*
|
||||||
|
* Many systems provide platform-specific means of implementing custom
|
||||||
|
* streams using file pointers. However, POSIX does not define a way
|
||||||
|
* of programmatically creating custom streams.
|
||||||
|
* .Nm
|
||||||
|
* therefore fills this gap in POSIX by mimicking all of the
|
||||||
|
* functionality of these platform-specific functions, but in pure
|
||||||
|
* POSIX C. It defines a number of callback funtions to be executed
|
||||||
|
* in place of the standard POSIX I/O functions, which are used to
|
||||||
|
* implement arbitrary streams that may not be to a file or socket.
|
||||||
|
* Additionally, streams can now be pipelined; the sink of one stream
|
||||||
|
* may be the source of another lower-level stream. Additionally, all
|
||||||
|
* streams, regardless of their source or sink, share the same API, so
|
||||||
|
* streams can be handled in a much more generic manner. This allows
|
||||||
|
* the HTTP client and server libraries to seemlessly support TLS and
|
||||||
|
* plain connections without having to handle each separately.
|
||||||
|
* .Pp
|
||||||
|
* .Nm
|
||||||
|
* was heavily inspired by GNU's
|
||||||
|
* .Fn fopencookie
|
||||||
|
* and BSD's
|
||||||
|
* .Fn funopen .
|
||||||
|
* It aims to combine the best of both of these functions into a single
|
||||||
|
* API that is intuitive and easy to use.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
|
#ifndef IO_BUFFER
|
||||||
|
#define IO_BUFFER 4096
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An opaque structure analogous to a POSIX file descriptor.
|
||||||
|
*/
|
||||||
|
typedef struct Io Io;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read input from the source of a stream. This function should
|
||||||
|
* attempt to read the specified number of bytes of data from the
|
||||||
|
* given cookie into the given buffer. It should behave identically
|
||||||
|
* to the POSIX
|
||||||
|
* .Xr read 2
|
||||||
|
* system call, except instead of using an integer descriptor as the
|
||||||
|
* first parameter, a pointer to an implementation-defined cookie
|
||||||
|
* stores any information the function needs to read from the source.
|
||||||
|
*/
|
||||||
|
typedef ssize_t (IoReadFunc) (void *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write output to a sink. This function should attempt to write the
|
||||||
|
* specified number of bytes of data from the given buffer into the
|
||||||
|
* stream described by the given cookie. It should behave identically
|
||||||
|
* to the POSIX
|
||||||
|
* .Xr write 2
|
||||||
|
* system call, except instead of using an integer descriptor as the
|
||||||
|
* first parameter, a pointer to an implementation-defined cookie
|
||||||
|
* stores any information the function needs to write to the sink.
|
||||||
|
*/
|
||||||
|
typedef ssize_t (IoWriteFunc) (void *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Repositions the offset of the stream described by the specified
|
||||||
|
* cookie. This function should behave identically to the POSIX
|
||||||
|
* .Xr lseek 2
|
||||||
|
* system call, except instead of using an integer descriptor as the
|
||||||
|
* first parameter, a pointer to an implementation-defined cookie
|
||||||
|
* stores any information the function needs to seek the stream.
|
||||||
|
*/
|
||||||
|
typedef off_t (IoSeekFunc) (void *, off_t, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Close the given stream, making future reads or writes result in
|
||||||
|
* undefined behavior. This function should also free all memory
|
||||||
|
* associated with the cookie. It should behave identically to the
|
||||||
|
* .Xr close 2
|
||||||
|
* system call, except instead of using an integer descriptor for the
|
||||||
|
* parameter, a pointer to an implementation-defined cookie stores any
|
||||||
|
* information the function needs to close the stream.
|
||||||
|
*/
|
||||||
|
typedef int (IoCloseFunc) (void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A simple mechanism for grouping together a set of stream functions,
|
||||||
|
* to be passed to
|
||||||
|
* .Fn IoCreate .
|
||||||
|
*/
|
||||||
|
typedef struct IoFunctions
|
||||||
|
{
|
||||||
|
IoReadFunc *read;
|
||||||
|
IoWriteFunc *write;
|
||||||
|
IoSeekFunc *seek;
|
||||||
|
IoCloseFunc *close;
|
||||||
|
} IoFunctions;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new stream using the specified cookie and the specified
|
||||||
|
* I/O functions.
|
||||||
|
*/
|
||||||
|
extern Io * IoCreate(void *, IoFunctions);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read the specified number of bytes from the specified stream into
|
||||||
|
* the specified buffer. This calls the stream's underlying IoReadFunc,
|
||||||
|
* which should behave identically to the POSIX
|
||||||
|
* .Xr read 2
|
||||||
|
* system call.
|
||||||
|
*/
|
||||||
|
extern ssize_t IoRead(Io *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write the specified number of bytes from the specified stream into
|
||||||
|
* the specified buffer. This calls the stream's underlying
|
||||||
|
* IoWriteFunc, which should behave identically to the POSIX
|
||||||
|
* .Xr write 2
|
||||||
|
* system call.
|
||||||
|
*/
|
||||||
|
extern ssize_t IoWrite(Io *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Seek the specified stream using the specified offset and whence
|
||||||
|
* value. This calls the stream's underlying IoSeekFunc, which should
|
||||||
|
* behave identically to the POSIX
|
||||||
|
* .Xr lseek 2
|
||||||
|
* system call.
|
||||||
|
*/
|
||||||
|
extern off_t IoSeek(Io *, off_t, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Close the specified stream. This calls the stream's underlying
|
||||||
|
* IoCloseFunc, which should behave identically to the POSIX
|
||||||
|
* .Xr close 2
|
||||||
|
* system call.
|
||||||
|
*/
|
||||||
|
extern int IoClose(Io *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Print a formatted string to the given stream. This is a
|
||||||
|
* re-implementation of the standard library function
|
||||||
|
* .Xr vfprintf 3 ,
|
||||||
|
* and behaves identically.
|
||||||
|
*/
|
||||||
|
extern int IoVprintf(Io *, const char *, va_list);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Print a formatted string to the given stream. This is a
|
||||||
|
* re-implementation of the standard library function
|
||||||
|
* .Xr fprintf 3 ,
|
||||||
|
* and behaves identically.
|
||||||
|
*/
|
||||||
|
extern int IoPrintf(Io *, const char *,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read all the bytes from the first stream and write them to the
|
||||||
|
* second stream. Neither stream is closed upon the completion of this
|
||||||
|
* function. This can be used for quick and convenient buffered
|
||||||
|
* copying of data from one stream into another.
|
||||||
|
*/
|
||||||
|
extern ssize_t IoCopy(Io *, Io *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Wrap a POSIX file descriptor to take advantage of this API. The
|
||||||
|
* common use case for this function is when a regular file descriptor
|
||||||
|
* needs to be accessed by an application that uses this API to also
|
||||||
|
* access non-POSIX streams.
|
||||||
|
*/
|
||||||
|
extern Io * IoFd(int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Open or create a file for reading or writing. The specified file
|
||||||
|
* name is opened for reading or writing as specified by the given
|
||||||
|
* flags and mode. This function is a simple convenience wrapper around
|
||||||
|
* the POSIX
|
||||||
|
* .Xr open 2
|
||||||
|
* system call that passes the opened file descriptor into
|
||||||
|
* .Fn IoFd .
|
||||||
|
*/
|
||||||
|
extern Io * IoOpen(const char *, int, mode_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Wrap a standard C file pointer to take advantage of this API. The
|
||||||
|
* common use case for this function is when a regular C file pointer
|
||||||
|
* needs to be accessed by an application that uses this API to also
|
||||||
|
* access custom streams.
|
||||||
|
*/
|
||||||
|
extern Io * IoFile(FILE *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_IO_H */
|
322
src/include/Json.h
Normal file
322
src/include/Json.h
Normal file
|
@ -0,0 +1,322 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_JSON_H
|
||||||
|
#define CYTOPLASM_JSON_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Json
|
||||||
|
* @Nd A fully-featured JSON API.
|
||||||
|
* @Dd March 12 2023
|
||||||
|
* @Xr HashMap Array Stream
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is a fully-featured JSON API for C using the array and hash map
|
||||||
|
* APIs. It can parse JSON, ans serialize an in-memory structure to
|
||||||
|
* JSON. It build on the foundation of Array and HashMap because that's
|
||||||
|
* all JSON really is, just arrays and maps.
|
||||||
|
* .Nm
|
||||||
|
* also provides a structure for encapsulating an arbitrary value and
|
||||||
|
* identifying its type, making it easy for a strictly-typed language
|
||||||
|
* like C to work with loosely-typed JSON data.
|
||||||
|
* .Nm
|
||||||
|
* is very strict and tries to adhere as closely as possible to the
|
||||||
|
* proper definition of JSON. It will fail on syntax errors of any
|
||||||
|
* kind, which is fine for a Matrix homeserver that can just return
|
||||||
|
* M_BAD_JSON if anything in here fails, but this behavior may not be
|
||||||
|
* suitable for other purposes.
|
||||||
|
* .Pp
|
||||||
|
* This JSON implementation focuses primarily on serialization and
|
||||||
|
* deserialization to and from streams. It does not provide facilities
|
||||||
|
* for handling JSON strings; it only writes JSON to output streams,
|
||||||
|
* and reads them from input streams. Of course, you can use the
|
||||||
|
* POSIX
|
||||||
|
* .Xr fmemopen 3
|
||||||
|
* and
|
||||||
|
* .Xr open_memstream 3
|
||||||
|
* functions if you want to deal with JSON strings, but JSON is
|
||||||
|
* intended to be an exchange format. Data should be converted to JSON
|
||||||
|
* right when it is leaving the program, and converted from JSON to the
|
||||||
|
* in-memory format as soon as it is coming in.
|
||||||
|
* .Pp
|
||||||
|
* JSON objects are represented as hash maps consisting entirely of
|
||||||
|
* JsonValue structures, and arrays are represented as arrays
|
||||||
|
* consisting entirely of JsonValue structures. When generating a
|
||||||
|
* JSON object, any attempt to stuff a value into a hash map or array
|
||||||
|
* without first encoding it as a JsonValue will result in undefined
|
||||||
|
* behavior.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Array.h>
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
#define JSON_DEFAULT -1
|
||||||
|
#define JSON_PRETTY 0
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This opaque structure encapsulates all the possible types that can
|
||||||
|
* be stored in JSON. It is managed entirely by the functions defined
|
||||||
|
* in this API. It is important to note that strings, integers, floats,
|
||||||
|
* booleans, and the NULL value are all stored by value, but objects
|
||||||
|
* and arrays are stored by reference. That is, it doesn't store these
|
||||||
|
* itself, just pointers to them, however, the data
|
||||||
|
* .Em is
|
||||||
|
* freed when using
|
||||||
|
* .Fn JsonFree .
|
||||||
|
*/
|
||||||
|
typedef struct JsonValue JsonValue;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* These are the types that can be used to identify a JsonValue
|
||||||
|
* and act on it accordingly.
|
||||||
|
*/
|
||||||
|
typedef enum JsonType
|
||||||
|
{
|
||||||
|
JSON_NULL, /* Maps to a C NULL */
|
||||||
|
JSON_OBJECT, /* Maps to a HashMap of JsonValues */
|
||||||
|
JSON_ARRAY, /* Maps to an Array of JsonValues */
|
||||||
|
JSON_STRING, /* Maps to a null-terminated C string */
|
||||||
|
JSON_INTEGER, /* Maps to a C long */
|
||||||
|
JSON_FLOAT, /* Maps to a C double */
|
||||||
|
JSON_BOOLEAN /* Maps to a C integer of either 0 or 1 */
|
||||||
|
} JsonType;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Determine the type of the specified JSON value.
|
||||||
|
*/
|
||||||
|
extern JsonType JsonValueType(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a JSON object as a JSON value that can be added to another
|
||||||
|
* object, or an array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueObject(HashMap *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents an object. This function will
|
||||||
|
* return NULL if the value is not actually an object.
|
||||||
|
*/
|
||||||
|
extern HashMap * JsonValueAsObject(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a JSON array as a JSON value that can be added to an object
|
||||||
|
* or another array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueArray(Array *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents an array. This function will
|
||||||
|
* return NULL if the value is not actually an array.
|
||||||
|
*/
|
||||||
|
extern Array * JsonValueAsArray(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a C string as a JSON value that can be added to an object or
|
||||||
|
* an array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueString(char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents a string. This function will
|
||||||
|
* return NULL if the value is not actually a string.
|
||||||
|
*/
|
||||||
|
extern char * JsonValueAsString(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a number as a JSON value that can be added to an object or
|
||||||
|
* an array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueInteger(long);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents a number. This function will
|
||||||
|
* return 0 if the value is not actually a number, which may be
|
||||||
|
* misleading. Check the type of the value before making assumptions
|
||||||
|
* about its value.
|
||||||
|
*/
|
||||||
|
extern long JsonValueAsInteger(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a floating point number as a JSON value that can be added
|
||||||
|
* to an object or an array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueFloat(double);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents a floating point number. This
|
||||||
|
* function will return 0 if the value is not actually a floating
|
||||||
|
* point number, which may be misleading. Check the type of the value
|
||||||
|
* before making assumptions about its type.
|
||||||
|
*/
|
||||||
|
extern double JsonValueAsFloat(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a C integer according to the way C treats integers in boolean
|
||||||
|
* expressions as a JSON value that can be added to an object or an
|
||||||
|
* array.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueBoolean(int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Unwrap a JSON value that represents a boolean. This function will
|
||||||
|
* return 0 if the value is not actually a boolean, which may be
|
||||||
|
* misleading. Check the type of the value before making assumptions
|
||||||
|
* about its type.
|
||||||
|
*/
|
||||||
|
extern int JsonValueAsBoolean(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This is a special case that represents a JSON null. Because the
|
||||||
|
* Array and HashMap APIs do not accept NULL values, this function
|
||||||
|
* should be used to represent NULL in JSON. Even though a small
|
||||||
|
* amount of memory is allocated just to be a placeholder for nothing,
|
||||||
|
* this keeps the APIs clean.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueNull(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the memory being used by a JSON value. Note that this will
|
||||||
|
* recursively free all Arrays, HashMaps, and other JsonValues that are
|
||||||
|
* reachable from the given value, including any strings attached to
|
||||||
|
* this value.
|
||||||
|
*/
|
||||||
|
extern void JsonValueFree(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Recursively duplicate the given JSON value. This returns a new
|
||||||
|
* JSON value that is completely identical to the specified value, but
|
||||||
|
* in no way connected to it.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonValueDuplicate(JsonValue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Recursively duplicate the given JSON object. This returns a new
|
||||||
|
* JSON object that is completely identical to the specified object,
|
||||||
|
* but in no way connect to it.
|
||||||
|
*/
|
||||||
|
extern HashMap * JsonDuplicate(HashMap *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Recursively free a JSON object by iterating over all of its values
|
||||||
|
* and freeing them using
|
||||||
|
* .Fn JsonValueFree .
|
||||||
|
*/
|
||||||
|
extern void JsonFree(HashMap *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode the given string in such a way that it can be safely
|
||||||
|
* embedded in a JSON stream. This entails:
|
||||||
|
* .Bl -bullet -offset indent
|
||||||
|
* .It
|
||||||
|
* Escaping quotes, backslashes, and other special characters using
|
||||||
|
* their backslash escape.
|
||||||
|
* .It
|
||||||
|
* Encoding bytes that are not UTF-8 using escapes.
|
||||||
|
* .It
|
||||||
|
* Wrapping the entire string in double quotes.
|
||||||
|
* .El
|
||||||
|
* .Pp
|
||||||
|
* This function is only provided via the public
|
||||||
|
* .Nm
|
||||||
|
* API so that it is accessible to custom JSON encoders, such as the
|
||||||
|
* CanonicalJson encoder. This will typically be used for encoding
|
||||||
|
* object keys; to encode values, just use
|
||||||
|
* .Fn JsonEncodeValue .
|
||||||
|
* .Pp
|
||||||
|
* This function returns the number of bytes written to the stream,
|
||||||
|
* or if the stream is NULL, the number of bytes that would have
|
||||||
|
* been written.
|
||||||
|
*/
|
||||||
|
extern int JsonEncodeString(const char *, Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Serialize a JSON value as it would appear in JSON output. This is
|
||||||
|
* a recursive function that also encodes all child values reachable
|
||||||
|
* from the given value. This function is exposed via the public
|
||||||
|
* .Nm
|
||||||
|
* API so that it is accessible to custom JSON encoders. Normal users
|
||||||
|
* that are not writing custom encoders should in most cases just use
|
||||||
|
* .Fn JsonEncode
|
||||||
|
* to encode an entire object.
|
||||||
|
* .Pp
|
||||||
|
* The third parameter is an integer that represents the indent level
|
||||||
|
* of the value to be printed, or a negative number if pretty-printing
|
||||||
|
* should be disabled and JSON should be printed as minimized as
|
||||||
|
* possible. To pretty-print a JSON object, set this to
|
||||||
|
* .Va JSON_PRETTY .
|
||||||
|
* To get minified output, set it to
|
||||||
|
* .Va JSON_DEFAULT .
|
||||||
|
* .Pp
|
||||||
|
* This function returns the number of bytes written to the stream,
|
||||||
|
* or if the stream is NULL, the number of bytes that would have
|
||||||
|
* been written.
|
||||||
|
*/
|
||||||
|
extern int JsonEncodeValue(JsonValue *, Stream *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Encode a JSON object as it would appear in JSON output, writing it
|
||||||
|
* to the given output stream. This function is recursive; it will
|
||||||
|
* serialize everything accessible from the passed object. The third
|
||||||
|
* parameter has the same behavior as described above.
|
||||||
|
* .Pp
|
||||||
|
* This function returns the number of bytes written to the stream,
|
||||||
|
* or if the stream is NULL, the number of bytes that would have
|
||||||
|
* been written.
|
||||||
|
*/
|
||||||
|
extern int JsonEncode(HashMap *, Stream *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode a JSON object from the given input stream and parse it into
|
||||||
|
* a hash map of JSON values.
|
||||||
|
*/
|
||||||
|
extern HashMap * JsonDecode(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A convenience function that allows the caller to retrieve and
|
||||||
|
* arbitrarily deep keys within a JSON object. It takes a root JSON
|
||||||
|
* object, the number of levels deep to go, and then that number of
|
||||||
|
* keys as a varargs list. All keys must have objects as values, with
|
||||||
|
* the exception of the last one, which is the value that will be
|
||||||
|
* returned. Otherwise, NULL indicates the specified path doas not
|
||||||
|
* exist.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonGet(HashMap *, size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A convenience function that allows the caller to set arbitrarily
|
||||||
|
* deep keys within a JSON object. It takes a root JSON object, the
|
||||||
|
* number of levels deep to go, and then that number of keys as a
|
||||||
|
* varargs list. All keys must have object as values, with the
|
||||||
|
* exception of the last one, which is the value that will be set.
|
||||||
|
* The value currently at that key, if any, will be returned.
|
||||||
|
* This function will create any intermediate objects as necessary to
|
||||||
|
* set the proper key.
|
||||||
|
*/
|
||||||
|
extern JsonValue * JsonSet(HashMap *, JsonValue *, size_t,...);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_JSON_H */
|
196
src/include/Log.h
Normal file
196
src/include/Log.h
Normal file
|
@ -0,0 +1,196 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_LOG_H
|
||||||
|
#define CYTOPLASM_LOG_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Log
|
||||||
|
* @Nd A simple logging framework for logging to multiple destinations.
|
||||||
|
* @Dd April 27 2023
|
||||||
|
* @Xr Stream
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is a simple C logging library that allows for colorful outputs,
|
||||||
|
* timestamps, and custom log levels. It also features the ability to
|
||||||
|
* have multiple logs open at one time, although Cytoplasm primarily
|
||||||
|
* utilizes the global log. All logs are thread safe.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <syslog.h>
|
||||||
|
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#define LOG_FLAG_COLOR (1 << 0)
|
||||||
|
#define LOG_FLAG_SYSLOG (1 << 1)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A log is defined as a configuration that describes the properties
|
||||||
|
* of the log. This opaque structure can be manipulated by the
|
||||||
|
* functions defined in this API.
|
||||||
|
*/
|
||||||
|
typedef struct LogConfig LogConfig;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new log configuration with sane defaults that can be used
|
||||||
|
* immediately with the logging functions.
|
||||||
|
*/
|
||||||
|
extern LogConfig * LogConfigCreate(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the global log configuration, creating a new one with
|
||||||
|
* .Fn LogConfigCreate
|
||||||
|
* if necessary.
|
||||||
|
*/
|
||||||
|
extern LogConfig * LogConfigGlobal(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the given log configuration. Note that this does not close the
|
||||||
|
* underlying stream associated with the log, if there is one. Also
|
||||||
|
* note that to avoid memory leaks, the global log configuration must
|
||||||
|
* also be freed, but it cannot be used after it is freed.
|
||||||
|
*/
|
||||||
|
extern void LogConfigFree(LogConfig *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the current log level on the specified log configuration.
|
||||||
|
* This indicates that only messages at or above this level should be
|
||||||
|
* logged; all others are silently discarded. The passed log level
|
||||||
|
* should be one of the log levels defined by
|
||||||
|
* .Xr syslog 3 .
|
||||||
|
* Refer to that page for a complete list of acceptable log levels,
|
||||||
|
* and note that passing an invalid log level will result in undefined
|
||||||
|
* behavior.
|
||||||
|
*/
|
||||||
|
extern void LogConfigLevelSet(LogConfig *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Cause the log output to be indented two more spaces than it was
|
||||||
|
* previously. This can be helpful when generating stack traces or
|
||||||
|
* other hierarchical output. This is a simple convenience wrapper
|
||||||
|
* around
|
||||||
|
* .Fn LogConfigIndentSet .
|
||||||
|
*/
|
||||||
|
extern void LogConfigIndent(LogConfig *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Cause the log output to be indented two less spaces than it was
|
||||||
|
* previously. This is a simple convenience wrapper around
|
||||||
|
* .Fn LogConfigIndentSet .
|
||||||
|
*/
|
||||||
|
extern void LogConfigUnindent(LogConfig *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Indent future log output using the specified config by some
|
||||||
|
* arbitrary amount.
|
||||||
|
*/
|
||||||
|
extern void LogConfigIndentSet(LogConfig *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the file stream that logging output should be written to. This
|
||||||
|
* defaults to standard output, but it can be set to standard error,
|
||||||
|
* or any other arbitrary stream. Passing a NULL value for the stream
|
||||||
|
* pointer sets the log output to the standard output. Note that the
|
||||||
|
* output stream is only used if
|
||||||
|
* .Va LOG_FLAG_SYSLOG
|
||||||
|
* is not set.
|
||||||
|
*/
|
||||||
|
extern void LogConfigOutputSet(LogConfig *, Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set a number of boolean options on a log configuration. This
|
||||||
|
* function uses bitwise operators, so multiple options can be set with
|
||||||
|
* a single function call using bitwise OR operators. The flags are
|
||||||
|
* defined as preprocessor macros, and are as follows:
|
||||||
|
* .Bl -tag -width Ds
|
||||||
|
* .It LOG_FLAG_COLOR
|
||||||
|
* When set, enable color-coded output on TTYs. Note that colors are
|
||||||
|
* implemented as ANSI escape sequences, and are not written to file
|
||||||
|
* streams that are not actually connected to a TTY, to prevent those
|
||||||
|
* sequences from being written to a file.
|
||||||
|
* .Xr isatty 3
|
||||||
|
* is checked before writing any terminal sequences.
|
||||||
|
* .It LOG_FLAG_SYSLOG
|
||||||
|
* When set, log output to the syslog using
|
||||||
|
* .Xr syslog 3 ,
|
||||||
|
* instead of logging to the file set by
|
||||||
|
* .Fn LogConfigOutputSet .
|
||||||
|
* This flag always overrides the stream set by that function,
|
||||||
|
* regardless of when it was set, even if it was set after this flag
|
||||||
|
* was set.
|
||||||
|
* .El
|
||||||
|
*/
|
||||||
|
extern void LogConfigFlagSet(LogConfig *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clear a boolean flag from the specified log format. See above for
|
||||||
|
* the list of flags.
|
||||||
|
*/
|
||||||
|
extern void LogConfigFlagClear(LogConfig *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set a custom timestamp to be prepended to each message if the
|
||||||
|
* output is not going to the system log. Consult your system's
|
||||||
|
* documentation for
|
||||||
|
* .Xr strftime 3 .
|
||||||
|
* A value of NULL disables the timestamp output before messages.
|
||||||
|
*/
|
||||||
|
extern void LogConfigTimeStampFormatSet(LogConfig *, char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function does the actual logging of messages using a
|
||||||
|
* specified configuration. It takes the configuration, the log
|
||||||
|
* level, a format string, and then a list of arguments, all in that
|
||||||
|
* order. This function only logs messages if their level is above
|
||||||
|
* or equal to the currently configured log level, making it easy to
|
||||||
|
* turn some messages on or off.
|
||||||
|
* .Pp
|
||||||
|
* This function has the same usage as
|
||||||
|
* .Xr vprintf 3 .
|
||||||
|
* Consult that page for the list of format specifiers and their
|
||||||
|
* arguments. This function is typically not used directly, see the
|
||||||
|
* other log functions for the most common use cases.
|
||||||
|
*/
|
||||||
|
extern void Logv(LogConfig *, int, const char *, va_list);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Log a message using
|
||||||
|
* .Fn Logv .
|
||||||
|
* with the specified configuration. This function has the same usage
|
||||||
|
* as
|
||||||
|
* .Xr printf 3 .
|
||||||
|
*/
|
||||||
|
extern void LogTo(LogConfig *, int, const char *, ...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Log a message to the global log using
|
||||||
|
* .Fn Logv .
|
||||||
|
* This function has the same usage as
|
||||||
|
* .Xr printf 3 .
|
||||||
|
*/
|
||||||
|
extern void Log(int, const char *, ...);
|
||||||
|
|
||||||
|
#endif
|
225
src/include/Memory.h
Normal file
225
src/include/Memory.h
Normal file
|
@ -0,0 +1,225 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_MEMORY_H
|
||||||
|
#define CYTOPLASM_MEMORY_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Memory
|
||||||
|
* @Nd Smart memory management.
|
||||||
|
* @Dd January 9 2023
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is an API that allows for smart memory management and profiling. It
|
||||||
|
* wraps the standard library functions
|
||||||
|
* .Xr malloc 3 ,
|
||||||
|
* .Xr realloc 3 ,
|
||||||
|
* and
|
||||||
|
* .Xr free 3 ,
|
||||||
|
* and offers identical semantics, while providing functionality that
|
||||||
|
* the standard library doesn't have, such as getting statistics on the
|
||||||
|
* total memory allocated on the heap, and getting the size of a block
|
||||||
|
* given a pointer. Additionally, thanks to preprocessor macros, the
|
||||||
|
* exact file and line number at which an allocation, re-allocation, or
|
||||||
|
* free occured can be obtained given a pointer. Finally, all the
|
||||||
|
* blocks allocated on the heap can be iterated and evaluated, and a
|
||||||
|
* callback function can be executed every time a memory operation
|
||||||
|
* occurs.
|
||||||
|
* .Pp
|
||||||
|
* In the future, this API could include a garbage collector that
|
||||||
|
* automatically frees memory it detects as being no longer in use.
|
||||||
|
* However, this feature does not yet exist.
|
||||||
|
* .Pp
|
||||||
|
* A number of macros are available, which make the
|
||||||
|
* .Nm
|
||||||
|
* API much easier to use. They are as follows:
|
||||||
|
* .Bl -bullet -offset indent
|
||||||
|
* .It
|
||||||
|
* .Fn Malloc "x"
|
||||||
|
* .It
|
||||||
|
* .Fn Realloc "x" "y"
|
||||||
|
* .It
|
||||||
|
* .Fn Free "x"
|
||||||
|
* .El
|
||||||
|
* .Pp
|
||||||
|
* These macros expand to
|
||||||
|
* .Fn MemoryAllocate ,
|
||||||
|
* .Fn MemoryReallocate ,
|
||||||
|
* and
|
||||||
|
* .Fn MemoryFree
|
||||||
|
* with the second and third parameters set to __FILE__ and __LINE__.
|
||||||
|
* This allows
|
||||||
|
* .Nm
|
||||||
|
* to be used exactly how the standard library functions would be
|
||||||
|
* used. In fact, the functions to which these macros expand are not
|
||||||
|
* intended to be used directly; for the best results, use these
|
||||||
|
* macros.
|
||||||
|
*/
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* These values are passed into the memory hook function to indicate
|
||||||
|
* the action that just happened.
|
||||||
|
*/
|
||||||
|
typedef enum MemoryAction
|
||||||
|
{
|
||||||
|
MEMORY_ALLOCATE,
|
||||||
|
MEMORY_REALLOCATE,
|
||||||
|
MEMORY_FREE,
|
||||||
|
MEMORY_BAD_POINTER
|
||||||
|
} MemoryAction;
|
||||||
|
|
||||||
|
#define Malloc(x) MemoryAllocate(x, __FILE__, __LINE__)
|
||||||
|
#define Realloc(x, s) MemoryReallocate(x, s, __FILE__, __LINE__)
|
||||||
|
#define Free(x) MemoryFree(x, __FILE__, __LINE__)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The memory information is opaque, but can be accessed using the
|
||||||
|
* functions defined by this API.
|
||||||
|
*/
|
||||||
|
typedef struct MemoryInfo MemoryInfo;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Allocate the specified number of bytes on the heap. This function
|
||||||
|
* has the same semantics as
|
||||||
|
* .Xr malloc 3 ,
|
||||||
|
* except that it takes the file name and line number at which the
|
||||||
|
* allocation occurred.
|
||||||
|
*/
|
||||||
|
extern void * MemoryAllocate(size_t, const char *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Change the size of the object pointed to by the given pointer
|
||||||
|
* to the given number of bytes. This function has the same semantics
|
||||||
|
* as
|
||||||
|
* .Xr realloc 3 ,
|
||||||
|
* except that it takes the file name and line number at which the
|
||||||
|
* reallocation occurred.
|
||||||
|
*/
|
||||||
|
extern void * MemoryReallocate(void *, size_t, const char *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the memory at the given pointer. This function has the same
|
||||||
|
* semantics as
|
||||||
|
* .Xr free 3 ,
|
||||||
|
* except that it takes the file name and line number at which the
|
||||||
|
* free occurred.
|
||||||
|
*/
|
||||||
|
extern void MemoryFree(void *, const char *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the total number of bytes that the program has allocated on the
|
||||||
|
* heap. This operation iterates over all heap allocations made with
|
||||||
|
* .Fn MemoryAllocate
|
||||||
|
* and then returns a total count, in bytes.
|
||||||
|
*/
|
||||||
|
extern size_t MemoryAllocated(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Iterate over all heap allocations made with
|
||||||
|
* .Fn MemoryAllocate
|
||||||
|
* and call
|
||||||
|
* .Fn MemoryFree
|
||||||
|
* on them. This function immediately invalidates all pointers to
|
||||||
|
* blocks on the heap, and any subsequent attempt to read or write to
|
||||||
|
* data on the heap will result in undefined behavior. This is
|
||||||
|
* typically called at the end of the program, just before exit.
|
||||||
|
*/
|
||||||
|
extern void MemoryFreeAll(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Fetch information about an allocation. This function takes a raw
|
||||||
|
* pointer, and if
|
||||||
|
* . Nm
|
||||||
|
* knows about the pointer, it returns a structure that can be used
|
||||||
|
* to obtain information about the block of memory that the pointer
|
||||||
|
* points to.
|
||||||
|
*/
|
||||||
|
extern MemoryInfo * MemoryInfoGet(void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the size in bytes of the block of memory represented by the
|
||||||
|
* specified memory info structure.
|
||||||
|
*/
|
||||||
|
extern size_t MemoryInfoGetSize(MemoryInfo *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the file name in which the block of memory represented by the
|
||||||
|
* specified memory info structure was allocated.
|
||||||
|
*/
|
||||||
|
extern const char * MemoryInfoGetFile(MemoryInfo *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the line number on which the block of memory represented by the
|
||||||
|
* specified memory info structure was allocated.
|
||||||
|
*/
|
||||||
|
extern int MemoryInfoGetLine(MemoryInfo *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a pointer to the block of memory represented by the specified
|
||||||
|
* memory info structure.
|
||||||
|
*/
|
||||||
|
extern void * MemoryInfoGetPointer(MemoryInfo *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function takes a pointer to a function that takes the memory
|
||||||
|
* info structure, as well as a void pointer for caller-provided
|
||||||
|
* arguments. It iterates over all the heap memory currently allocated
|
||||||
|
* at the time of calling, executing the function on each allocation.
|
||||||
|
*/
|
||||||
|
extern void MemoryIterate(void (*) (MemoryInfo *, void *), void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Specify a function to be executed whenever a memory operation
|
||||||
|
* occurs. The MemoryAction argument specifies the operation that
|
||||||
|
* occurred on the block of memory represented by the memory info
|
||||||
|
* structure. The function also takes a void pointer to caller-provided
|
||||||
|
* arguments.
|
||||||
|
*/
|
||||||
|
extern void MemoryHook(void (*) (MemoryAction, MemoryInfo *, void *), void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read over the block of memory represented by the given memory info
|
||||||
|
* structure and generate a hexadecimal and ASCII string for each
|
||||||
|
* chunk of the block. This function takes a callback function that
|
||||||
|
* takes the following parameters in order:
|
||||||
|
* .Bl -bullet -offset indent
|
||||||
|
* .It
|
||||||
|
* The current offset from the beginning of the block of memory in
|
||||||
|
* bytes.
|
||||||
|
* .It
|
||||||
|
* A null-terminated string containing the next 16 bytes of the block
|
||||||
|
* encoded as space-separated hex values.
|
||||||
|
* .It
|
||||||
|
* A null-terminated string containing the ASCII representation of the
|
||||||
|
* same 16 bytes of memory. This ASCII representation is safe to print
|
||||||
|
* to a terminal or other text device, because non-printable characters
|
||||||
|
* are encoded as a . (period).
|
||||||
|
* .It
|
||||||
|
* Caller-passed pointer.
|
||||||
|
* .El
|
||||||
|
*/
|
||||||
|
extern void
|
||||||
|
MemoryHexDump(MemoryInfo *, void (*) (size_t, char *, char *, void *), void *);
|
||||||
|
|
||||||
|
#endif
|
105
src/include/Queue.h
Normal file
105
src/include/Queue.h
Normal file
|
@ -0,0 +1,105 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_QUEUE_H
|
||||||
|
#define CYTOPLASM_QUEUE_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Queue
|
||||||
|
* @Nd A simple static queue data structure.
|
||||||
|
* @Dd November 25 2022
|
||||||
|
* @Xr Array HashMap
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* implements a simple queue data structure that is statically sized.
|
||||||
|
* This implementation does not actually store the values of the items
|
||||||
|
* in it; it only stores pointers to the data. As such, you will have
|
||||||
|
* to manually maintain data and make sure it remains valid as long as
|
||||||
|
* it is in the queue. The advantage of this is that
|
||||||
|
* .Nm
|
||||||
|
* doesn't have to copy data, and thus doesn't care how big the data
|
||||||
|
* is. Furthermore, any arbitrary data can be stored in the queue.
|
||||||
|
* .Pp
|
||||||
|
* This queue implementation operates on the heap. It is a circular
|
||||||
|
* queue, and it does not grow as it is used. Once the size is set,
|
||||||
|
* the queue never gets any bigger.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* These functions operate on a queue structure that is opaque to the
|
||||||
|
* caller.
|
||||||
|
*/
|
||||||
|
typedef struct Queue Queue;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Allocate a new queue that is able to store the specified number of
|
||||||
|
* items in it.
|
||||||
|
*/
|
||||||
|
extern Queue * QueueCreate(size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the memory associated with the specified queue structure. Note
|
||||||
|
* that this function does not free any of the values stored in the
|
||||||
|
* queue; it is the caller's job to manage memory for each item.
|
||||||
|
* Typically, the caller would dequeue all the items in the queue and
|
||||||
|
* deal with them before freeing the queue itself.
|
||||||
|
*/
|
||||||
|
extern void QueueFree(Queue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Push an element into the queue. This function returns a boolean
|
||||||
|
* value indicating whether or not the push succeeded. Pushing items
|
||||||
|
* into the queue will fail if the queue is full.
|
||||||
|
*/
|
||||||
|
extern int QueuePush(Queue *, void *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pop an element out of the queue. This function returns NULL if the
|
||||||
|
* queue is empty. Otherwise, it returns a pointer to the item that is
|
||||||
|
* next up in the queue.
|
||||||
|
*/
|
||||||
|
extern void * QueuePop(Queue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve a pointer to the item that is next up in the queue without
|
||||||
|
* actually discarding it, such that the next call to
|
||||||
|
* .Fn QueuePeek
|
||||||
|
* or
|
||||||
|
* .Fn QueuePop
|
||||||
|
* will return the same pointer.
|
||||||
|
*/
|
||||||
|
extern void * QueuePeek(Queue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Determine whether or not the queue is full.
|
||||||
|
*/
|
||||||
|
extern int QueueFull(Queue *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Determine whether or not the queue is empty.
|
||||||
|
*/
|
||||||
|
extern int QueueEmpty(Queue *);
|
||||||
|
|
||||||
|
#endif
|
81
src/include/Rand.h
Normal file
81
src/include/Rand.h
Normal file
|
@ -0,0 +1,81 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_RAND_H
|
||||||
|
#define CYTOPLASM_RAND_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Rand
|
||||||
|
* @Nd Thread-safe random numbers.
|
||||||
|
* @Dd February 16 2023
|
||||||
|
* @Xr Util
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* is used for generating random numbers in a thread-safe way.
|
||||||
|
* Currently, one generator state is shared across all threads, which
|
||||||
|
* means that only one thread can generate random numbers at a time.
|
||||||
|
* This state is protected with a mutex to guarantee this behavior.
|
||||||
|
* In the future, a seed pool may be maintained to allow multiple
|
||||||
|
* threads to generate random numbers at the same time.
|
||||||
|
* .Pp
|
||||||
|
* The generator state is seeded on the first call to a function that
|
||||||
|
* needs it. The seed is determined by the current timestamp, the ID
|
||||||
|
* of the process, and the thread ID. These should all be sufficiently
|
||||||
|
* random sources, so the seed should be secure enough.
|
||||||
|
* .Pp
|
||||||
|
* .Nm
|
||||||
|
* currently uses a simple Mersenne Twister algorithm to generate
|
||||||
|
* random numbers. This algorithm was chosen because it is extremely
|
||||||
|
* popular and widespread. While it is likely not cryptographically
|
||||||
|
* secure, and does suffer some unfortunate pitfalls, this algorithm
|
||||||
|
* has stood the test of time and is simple enough to implement, so
|
||||||
|
* it was chosen over the alternatives.
|
||||||
|
* .Pp
|
||||||
|
* .Nm
|
||||||
|
* does not use any random number generator functions from the C
|
||||||
|
* standard library, since these are often flawed.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Generate a single random integer between 0 and the passed value.
|
||||||
|
*/
|
||||||
|
extern int RandInt(unsigned int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Generate the number of integers specified by the second argument
|
||||||
|
* storing them into the buffer pointed to in the first argument.
|
||||||
|
* Ensure that each number is between 0 and the third argument.
|
||||||
|
* .Pp
|
||||||
|
* This function allows a caller to get multiple random numbers at once
|
||||||
|
* in a more efficient manner than repeatedly calling
|
||||||
|
* .Fn RandInt ,
|
||||||
|
* since each call to these functions
|
||||||
|
* has to lock and unlock a mutex. It is therefore better to obtain
|
||||||
|
* multiple random numbers in one pass if multiple are needed.
|
||||||
|
*/
|
||||||
|
extern void RandIntN(int *, size_t, unsigned int);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_RAND_H */
|
53
src/include/Runtime.h
Normal file
53
src/include/Runtime.h
Normal file
|
@ -0,0 +1,53 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_RUNTIME_H
|
||||||
|
#define CYTOPLASM_RUNTIME_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Runtime
|
||||||
|
* @Nd Supporting functions for the Cytoplasm runtime.
|
||||||
|
* @Dd May 23 2023
|
||||||
|
* @Xr Memory
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides supporting functions for the Cytoplasm runtime. These
|
||||||
|
* functions are not intended to be called directly by programs,
|
||||||
|
* but are used internally. They're exposed via a header because
|
||||||
|
* the runtime stub needs to know their definitions.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Array.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write a memory report to a file in the current directory, using
|
||||||
|
* the provided string as the name of the program currently being
|
||||||
|
* executed. This function is to be called after all memory is
|
||||||
|
* supposed to have been freed. It iterates over all remaining
|
||||||
|
* memory and generates a text file containing all of the
|
||||||
|
* recorded information about each block, including a hex dump of
|
||||||
|
* the data stored in them.
|
||||||
|
*/
|
||||||
|
extern void GenerateMemoryReport(const char *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_RUNTIME_H */
|
50
src/include/Sha2.h
Normal file
50
src/include/Sha2.h
Normal file
|
@ -0,0 +1,50 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_SHA2_H
|
||||||
|
#define CYTOPLASM_SHA2_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Sha2
|
||||||
|
* @Nd A simple implementation of the SHA2 hashing functions.
|
||||||
|
* @Dd December 19 2022
|
||||||
|
* @Xr Memory Base64
|
||||||
|
*
|
||||||
|
* This API defines simple functions for computing SHA2 hashes.
|
||||||
|
* At the moment, it only defines
|
||||||
|
* .Fn Sha256 ,
|
||||||
|
* which computes the SHA-256 hash of the given C string. It is
|
||||||
|
* not trivial to implement SHA-512 in ANSI C due to the lack of
|
||||||
|
* a 64-bit integer type, so that hash function has been omitted.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function takes a pointer to a NULL-terminated C string, and
|
||||||
|
* returns a string allocated on the heap using the Memory API, or
|
||||||
|
* NULL if there was an error allocating memory. The returned string
|
||||||
|
* should be freed when it is no longer needed.
|
||||||
|
*/
|
||||||
|
extern char * Sha256(char *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_SHA2_H */
|
113
src/include/Str.h
Normal file
113
src/include/Str.h
Normal file
|
@ -0,0 +1,113 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_STR_H
|
||||||
|
#define CYTOPLASM_STR_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Str
|
||||||
|
* @Nd Functions for creating and manipulating strings.
|
||||||
|
* @Dd February 15 2023
|
||||||
|
* @Xr Memory
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides string-related functions. It is called
|
||||||
|
* .Nm ,
|
||||||
|
* not String, because some platforms (Windows) do not have
|
||||||
|
* case-sensitive filesystems, which poses a problem since
|
||||||
|
* .Pa string.h
|
||||||
|
* is a standard library header.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Take a UTF-8 codepoint and encode it into a string buffer containing
|
||||||
|
* between 1 and 4 bytes. The string buffer is allocated on the heap,
|
||||||
|
* so it should be freed when it is no longer needed.
|
||||||
|
*/
|
||||||
|
extern char * StrUtf8Encode(unsigned long);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Duplicate a null-terminated string, returning a new string on the
|
||||||
|
* heap. This is useful when a function takes in a string that it needs
|
||||||
|
* to store for long amounts of time, even perhaps after the original
|
||||||
|
* string is gone.
|
||||||
|
*/
|
||||||
|
extern char * StrDuplicate(const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Extract part of a null-terminated string, returning a new string on
|
||||||
|
* the heap containing only the requested subsection. Like the
|
||||||
|
* substring functions included with most programming languages, the
|
||||||
|
* starting index is inclusive, and the ending index is exclusive.
|
||||||
|
*/
|
||||||
|
extern char * StrSubstr(const char *, size_t, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A varargs function that takes a number of null-terminated strings
|
||||||
|
* specified by the first argument, and returns a new string that
|
||||||
|
* contains their concatenation. It works similarly to
|
||||||
|
* .Xr strcat 3 ,
|
||||||
|
* but it takes care of allocating memory big enough to hold all the
|
||||||
|
* strings. Any string in the list may be NULL. If a NULL pointer is
|
||||||
|
* passed, it is treated like an empty string.
|
||||||
|
*/
|
||||||
|
extern char * StrConcat(size_t,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return a boolean value indicating whether or not the null-terminated
|
||||||
|
* string consists only of blank characters, as determined by
|
||||||
|
* .Xr isblank 3 .
|
||||||
|
*/
|
||||||
|
extern int StrBlank(const char *str);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Generate a string of the specified length, containing random
|
||||||
|
* lowercase and uppercase letters.
|
||||||
|
*/
|
||||||
|
extern char * StrRandom(size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert the specified integer into a string, returning the string
|
||||||
|
* on the heap, or NULL if there was a memory allocation error. The
|
||||||
|
* returned string should be freed by the caller after it is no longer
|
||||||
|
* needed.
|
||||||
|
*/
|
||||||
|
extern char * StrInt(long);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Compare two strings and determine whether or not they are equal.
|
||||||
|
* This is the most common use case of strcmp() in Cytoplasm, but
|
||||||
|
* strcmp() doesn't like NULL pointers, so these have to be checked
|
||||||
|
* explicitly and can cause problems if they aren't. This function,
|
||||||
|
* on the other hand, makes NULL pointers special cases. If both
|
||||||
|
* arguments are NULL, then they are considered equal. If only one
|
||||||
|
* argument is NULL, they are considered not equal. Otherwise, if
|
||||||
|
* no arguments are NULL, a regular strcmp() takes place and this
|
||||||
|
* function returns a boolean value indicating whether or not
|
||||||
|
* strcmp() returned 0.
|
||||||
|
*/
|
||||||
|
extern int StrEquals(const char *, const char *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_STR_H */
|
223
src/include/Stream.h
Normal file
223
src/include/Stream.h
Normal file
|
@ -0,0 +1,223 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_STREAM_H
|
||||||
|
#define CYTOPLASM_STREAM_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Stream
|
||||||
|
* @Nd An abstraction over the Io API that implements standard C I/O.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr Io
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* implements an abstraction layer over the Io API. This layer buffers
|
||||||
|
* I/O and makes it much easier to work with, mimicking the standard
|
||||||
|
* C library and offering some more convenience features.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Io.h>
|
||||||
|
|
||||||
|
#include <stdarg.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An opaque structure analogous to C's FILE pointers.
|
||||||
|
*/
|
||||||
|
typedef struct Stream Stream;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new stream using the specified Io for underlying I/O
|
||||||
|
* operations.
|
||||||
|
*/
|
||||||
|
extern Stream * StreamIo(Io * io);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new stream using the specified POSIX file descriptor.
|
||||||
|
* This is a convenience function for calling
|
||||||
|
* .Fn IoFd
|
||||||
|
* and then passing the result into
|
||||||
|
* .Fn StreamIo .
|
||||||
|
*/
|
||||||
|
extern Stream * StreamFd(int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new stream using the specified C FILE pointer. This is a
|
||||||
|
* convenience function for calling
|
||||||
|
* .Fn IoFile
|
||||||
|
* and then passing the result into
|
||||||
|
* .Fn StreamIo .
|
||||||
|
*/
|
||||||
|
extern Stream * StreamFile(FILE *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new stream using the specified path and mode. This is a
|
||||||
|
* convenience function for calling
|
||||||
|
* .Xr fopen 3
|
||||||
|
* and then passing the result into
|
||||||
|
* .Fn StreamFile .
|
||||||
|
*/
|
||||||
|
extern Stream * StreamOpen(const char *, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a stream that writes to the standard output.
|
||||||
|
*/
|
||||||
|
extern Stream * StreamStdout(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a stream that writes to the standard error.
|
||||||
|
*/
|
||||||
|
extern Stream * StreamStderr(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a stream that reads from the standard input.
|
||||||
|
*/
|
||||||
|
extern Stream * StreamStdin(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Close the stream. This flushes the buffers and closes the underlying
|
||||||
|
* Io. It is analogous to the standard
|
||||||
|
* .Xr fclose 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamClose(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Print a formatted string. This function is analogous to the standard
|
||||||
|
* .Xr vfprintf 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamVprintf(Stream *, const char *, va_list);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Print a formatted string. This function is analogous to the
|
||||||
|
* standard
|
||||||
|
* .Xr fprintf 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamPrintf(Stream *, const char *,...);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get a single character from a stream. This function is analogous to
|
||||||
|
* the standard
|
||||||
|
* .Xr fgetc 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamGetc(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Push a character back onto the input stream. This function is
|
||||||
|
* analogous to the standard
|
||||||
|
* .Xr ungetc 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamUngetc(Stream *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write a single character to the stream. This function is analogous
|
||||||
|
* to the standard
|
||||||
|
* .Xr fputc 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamPutc(Stream *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write a null-terminated string to the stream. This function is
|
||||||
|
* analogous to the standard
|
||||||
|
* .Xr fputs 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamPuts(Stream *, char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read at most the specified number of characters minus 1 from the
|
||||||
|
* specified stream and store them at the memory located at the
|
||||||
|
* specified pointer. This function is analogous to the standard
|
||||||
|
* .Xr fgets 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern char * StreamGets(Stream *, char *, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the file position indicator for the specified stream. This
|
||||||
|
* function is analogous to the standard
|
||||||
|
* .Xr fseeko
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern off_t StreamSeek(Stream *, off_t, int);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Test the end-of-file indicator for the given stream, returning a
|
||||||
|
* boolean value indicating whether or not it is set. This is analogous
|
||||||
|
* to the standard
|
||||||
|
* .Xr feof 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamEof(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Test the stream for an error condition, returning a boolean value
|
||||||
|
* indicating whether or not one is present. This is analogous to the
|
||||||
|
* standard
|
||||||
|
* .Xr ferror 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamError(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clear the error condition associated with the given stream, allowing
|
||||||
|
* future reads or writes to potentially be successful. This functio
|
||||||
|
* is analogous to the standard
|
||||||
|
* .Xr clearerr 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern void StreamClearError(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Flush all buffered data using the streams underlying write function.
|
||||||
|
* This function is analogous to the standard
|
||||||
|
* .Xr fflush 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamFlush(Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read all the bytes from the first stream and write them to the
|
||||||
|
* second stream. This is analogous to
|
||||||
|
* .Fn IoCopy ,
|
||||||
|
* but it uses the internal buffers of the streams. It is probably
|
||||||
|
* less efficient than doing a
|
||||||
|
* .Fn IoCopy
|
||||||
|
* instead, but it is more convenient.
|
||||||
|
*/
|
||||||
|
extern ssize_t StreamCopy(Stream *, Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the file descriptor associated with the given stream, or -1 if
|
||||||
|
* the stream is not associated with any file descriptor. This function
|
||||||
|
* is analogous to the standard
|
||||||
|
* .Xr fileno 3
|
||||||
|
* function.
|
||||||
|
*/
|
||||||
|
extern int StreamFileno(Stream *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_STREAM_H */
|
109
src/include/Tls.h
Normal file
109
src/include/Tls.h
Normal file
|
@ -0,0 +1,109 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_TLS_H
|
||||||
|
#define CYTOPLASM_TLS_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Tls
|
||||||
|
* @Nd Interface to platform-dependent TLS libraries.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr Stream Io
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides an interface to platform-dependent TLS libraries. It allows
|
||||||
|
* Cytoplasm to support any TLS library with no changes to existing
|
||||||
|
* code. Support for additional TLS libraries is added by creating a
|
||||||
|
* new compilation unit that implements all the functions here, with
|
||||||
|
* the exception of a few, which are noted.
|
||||||
|
* .Pp
|
||||||
|
* Currently, Cytoplasm has support for the following TLS libraries:
|
||||||
|
* .Bl -bullet -offset indent
|
||||||
|
* .It
|
||||||
|
* LibreSSL
|
||||||
|
* .It
|
||||||
|
* OpenSSL
|
||||||
|
* .El
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
#define TLS_LIBRESSL 2
|
||||||
|
#define TLS_OPENSSL 3
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new TLS client stream using the given file descriptor and
|
||||||
|
* the given server hostname. The hostname should be used to verify
|
||||||
|
* that the server actually is who it says it is.
|
||||||
|
* .Pp
|
||||||
|
* This function does not need to be implemented by the individual
|
||||||
|
* TLS support stubs.
|
||||||
|
*/
|
||||||
|
extern Stream * TlsClientStream(int, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new TLS server stream using the given certificate and key
|
||||||
|
* file, in the format natively supported by the TLS library.
|
||||||
|
* .Pp
|
||||||
|
* This function does not need to be implemented by the individual
|
||||||
|
* TLS support stubs.
|
||||||
|
*/
|
||||||
|
extern Stream * TlsServerStream(int, const char *, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initialize a cookie that stores information about the given client
|
||||||
|
* connection. This cookie will be passed into the other functions
|
||||||
|
* defined by this API.
|
||||||
|
*/
|
||||||
|
extern void * TlsInitClient(int, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initialize a cookie that stores information about the given
|
||||||
|
* server connection. This cookie will be passed into the other
|
||||||
|
* functions defined by this API.
|
||||||
|
*/
|
||||||
|
extern void * TlsInitServer(int, const char *, const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read from a TLS stream, decrypting it and storing the result in the
|
||||||
|
* specified buffer. This function takes the cookie, buffer, and
|
||||||
|
* number of decrypted bytes to read into it. See the documentation for
|
||||||
|
* .Fn IoRead .
|
||||||
|
*/
|
||||||
|
extern ssize_t TlsRead(void *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write to a TLS stream, encrypting the buffer. This function takes
|
||||||
|
* the cookie, buffer, and number of unencrypted bytes to write to
|
||||||
|
* the stream. See the documentation for
|
||||||
|
* .Fn IoWrite .
|
||||||
|
*/
|
||||||
|
extern ssize_t TlsWrite(void *, void *, size_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Close the TLS stream, also freeing all memory associated with the
|
||||||
|
* cookie.
|
||||||
|
*/
|
||||||
|
extern int TlsClose(void *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_TLS_H */
|
69
src/include/Uri.h
Normal file
69
src/include/Uri.h
Normal file
|
@ -0,0 +1,69 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#ifndef CYTOPLASM_URI_H
|
||||||
|
#define CYTOPLASM_URI_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Uri
|
||||||
|
* @Nd Parse a URI. Typically used to parse HTTP(s) URLs.
|
||||||
|
* @Dd April 29 2023
|
||||||
|
* @Xr Http
|
||||||
|
*
|
||||||
|
* .Nm
|
||||||
|
* provides a simple mechanism for parsing URIs. This is an extremely
|
||||||
|
* basic parser that (ab)uses
|
||||||
|
* .Xr sscanf 3
|
||||||
|
* to parse URIs, so it may not be the most reliable, but it should
|
||||||
|
* work in most cases and on reasonable URIs that aren't too long, as
|
||||||
|
* the _MAX definitions are modest.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define URI_PROTO_MAX 8
|
||||||
|
#define URI_HOST_MAX 128
|
||||||
|
#define URI_PATH_MAX 256
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The parsed URI is stored in this structure.
|
||||||
|
*/
|
||||||
|
typedef struct Uri
|
||||||
|
{
|
||||||
|
char proto[URI_PROTO_MAX];
|
||||||
|
char host[URI_HOST_MAX];
|
||||||
|
char path[URI_PATH_MAX];
|
||||||
|
unsigned short port;
|
||||||
|
} Uri;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Parse a URI string into the Uri structure as described above, or
|
||||||
|
* return NULL if there was a parsing error.
|
||||||
|
*/
|
||||||
|
extern Uri * UriParse(const char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Free the memory associated with a Uri structure returned by
|
||||||
|
* .Fn UriParse .
|
||||||
|
*/
|
||||||
|
extern void UriFree(Uri *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_URI_H */
|
105
src/include/Util.h
Normal file
105
src/include/Util.h
Normal file
|
@ -0,0 +1,105 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CYTOPLASM_UTIL_H
|
||||||
|
#define CYTOPLASM_UTIL_H
|
||||||
|
|
||||||
|
/***
|
||||||
|
* @Nm Util
|
||||||
|
* @Nd Some misc. helper functions that don't need their own headers.
|
||||||
|
* @Dd February 15 2023
|
||||||
|
*
|
||||||
|
* This header holds a number of random functions related to strings,
|
||||||
|
* time, the filesystem, and other simple tasks that don't require a
|
||||||
|
* full separate API. For the most part, the functions here are
|
||||||
|
* entirely standalone, depending only on POSIX functions, however
|
||||||
|
* there are a few that depend explicitly on a few other APIs. Those
|
||||||
|
* are noted.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
|
#include <Stream.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the current timestamp in milliseconds since the Unix epoch. This
|
||||||
|
* uses
|
||||||
|
* .Xr gettimeofday 2
|
||||||
|
* and time_t, and converts it to a single number, which is then
|
||||||
|
* returned to the caller.
|
||||||
|
* .Pp
|
||||||
|
* A note on the 2038 problem: as long as sizeof(long) >= 8, that is,
|
||||||
|
* as long as the long data type is 64 bits or more, then everything
|
||||||
|
* should be fine. On most, if not, all, 64-bit systems, long is 64
|
||||||
|
* bits. I would expect Cytoplasm to break for 32 bit systems
|
||||||
|
* eventually, but we should have a ways to go before that happens.
|
||||||
|
* I didn't want to try to hack together some system to store larger
|
||||||
|
* numbers than the architecture supports. But we can always
|
||||||
|
* re-evaluate over the next few years.
|
||||||
|
*/
|
||||||
|
extern unsigned long UtilServerTs(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Use
|
||||||
|
* .Xr stat 2
|
||||||
|
* to get the last modified time of the given file, or zero if there
|
||||||
|
* was an error getting the last modified time of a file. This is
|
||||||
|
* primarily useful for caching file data.
|
||||||
|
*/
|
||||||
|
extern unsigned long UtilLastModified(char *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function behaves just like the system call
|
||||||
|
* .Xr mkdir 2 ,
|
||||||
|
* but it creates any intermediate directories as necessary, unlike
|
||||||
|
* .Xr mkdir 2 .
|
||||||
|
*/
|
||||||
|
extern int UtilMkdir(const char *, const mode_t);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sleep the calling thread for the given number of milliseconds.
|
||||||
|
* POSIX does not have a very friendly way to sleep, so this wraps
|
||||||
|
* .Xr nanosleep 2
|
||||||
|
* to make its usage much, much simpler.
|
||||||
|
*/
|
||||||
|
extern int UtilSleepMillis(long);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function works identically to the POSIX
|
||||||
|
* .Xr getdelim 3 ,
|
||||||
|
* except that it assumes pointers were allocated with the Memory API
|
||||||
|
* and it reads from a Stream instead of a file pointer.
|
||||||
|
*/
|
||||||
|
extern ssize_t UtilGetDelim(char **, size_t *, int, Stream *);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This function is just a special case of
|
||||||
|
* .Fn UtilGetDelim
|
||||||
|
* that sets the delimiter to the newline character.
|
||||||
|
*/
|
||||||
|
extern ssize_t UtilGetLine(char **, size_t *, Stream *);
|
||||||
|
|
||||||
|
#endif /* CYTOPLASM_UTIL_H */
|
556
tools/hdoc.c
Normal file
556
tools/hdoc.c
Normal file
|
@ -0,0 +1,556 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person
|
||||||
|
* obtaining a copy of this software and associated documentation files
|
||||||
|
* (the "Software"), to deal in the Software without restriction,
|
||||||
|
* including without limitation the rights to use, copy, modify, merge,
|
||||||
|
* publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so,
|
||||||
|
* subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be
|
||||||
|
* included in all copies or portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||||
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||||
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||||
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||||
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
* SOFTWARE.
|
||||||
|
*/
|
||||||
|
#include <HeaderParser.h>
|
||||||
|
|
||||||
|
#include <HashMap.h>
|
||||||
|
#include <Str.h>
|
||||||
|
#include <Memory.h>
|
||||||
|
#include <Args.h>
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include <errno.h>
|
||||||
|
|
||||||
|
typedef struct DocDecl
|
||||||
|
{
|
||||||
|
char docs[HEADER_EXPR_MAX];
|
||||||
|
HeaderDeclaration decl;
|
||||||
|
} DocDecl;
|
||||||
|
|
||||||
|
typedef struct DocTypedef
|
||||||
|
{
|
||||||
|
char docs[HEADER_EXPR_MAX];
|
||||||
|
char text[HEADER_EXPR_MAX];
|
||||||
|
} DocTypedef;
|
||||||
|
|
||||||
|
typedef struct DocGlobal
|
||||||
|
{
|
||||||
|
char docs[HEADER_EXPR_MAX];
|
||||||
|
HeaderGlobal global;
|
||||||
|
} DocGlobal;
|
||||||
|
|
||||||
|
static void
|
||||||
|
ParseMainBlock(HashMap * registers, Array * descr, char *comment)
|
||||||
|
{
|
||||||
|
char *line = strtok(comment, "\n");
|
||||||
|
|
||||||
|
while (line)
|
||||||
|
{
|
||||||
|
while (*line && (isspace(*line) || *line == '*'))
|
||||||
|
{
|
||||||
|
line++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!*line)
|
||||||
|
{
|
||||||
|
goto next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*line == '@')
|
||||||
|
{
|
||||||
|
int i = 0;
|
||||||
|
|
||||||
|
line++;
|
||||||
|
|
||||||
|
while (!isspace(line[i]))
|
||||||
|
{
|
||||||
|
i++;
|
||||||
|
}
|
||||||
|
|
||||||
|
line[i] = '\0';
|
||||||
|
|
||||||
|
Free(HashMapSet(registers, line, StrDuplicate(line + i + 1)));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ArrayAdd(descr, StrDuplicate(line));
|
||||||
|
}
|
||||||
|
|
||||||
|
next:
|
||||||
|
line = strtok(NULL, "\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
Main(Array * args)
|
||||||
|
{
|
||||||
|
HeaderExpr expr;
|
||||||
|
size_t i;
|
||||||
|
char *key;
|
||||||
|
char *val;
|
||||||
|
int exit = EXIT_SUCCESS;
|
||||||
|
ArgParseState arg;
|
||||||
|
|
||||||
|
HashMap *registers = HashMapCreate();
|
||||||
|
Array *descr = ArrayCreate();
|
||||||
|
|
||||||
|
Array *declarations = ArrayCreate();
|
||||||
|
DocDecl *decl = NULL;
|
||||||
|
|
||||||
|
Array *typedefs = ArrayCreate();
|
||||||
|
DocTypedef *type = NULL;
|
||||||
|
|
||||||
|
Array *globals = ArrayCreate();
|
||||||
|
DocGlobal *global = NULL;
|
||||||
|
|
||||||
|
char comment[HEADER_EXPR_MAX];
|
||||||
|
int isDocumented = 0;
|
||||||
|
|
||||||
|
Stream *in = NULL;
|
||||||
|
Stream *out = NULL;
|
||||||
|
|
||||||
|
int opt;
|
||||||
|
|
||||||
|
ArgParseStateInit(&arg);
|
||||||
|
while ((opt = ArgParse(&arg, args, "i:o:D:")) != -1)
|
||||||
|
{
|
||||||
|
switch (opt)
|
||||||
|
{
|
||||||
|
case 'i':
|
||||||
|
if (in)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(arg.optArg, "-"))
|
||||||
|
{
|
||||||
|
in = StreamStdin();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
int len = strlen(arg.optArg);
|
||||||
|
|
||||||
|
in = StreamOpen(arg.optArg, "r");
|
||||||
|
if (!in)
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(), "Error: %s:%s",
|
||||||
|
arg.optArg, strerror(errno));
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (arg.optArg[len - 1] != '.')
|
||||||
|
{
|
||||||
|
arg.optArg[len - 1] = '\0';
|
||||||
|
len--;
|
||||||
|
}
|
||||||
|
|
||||||
|
arg.optArg[len - 1] = '\0';
|
||||||
|
len--;
|
||||||
|
|
||||||
|
HashMapSet(registers, "Nm", StrDuplicate(arg.optArg));
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 'o':
|
||||||
|
if (out)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (StrEquals(arg.optArg, "-"))
|
||||||
|
{
|
||||||
|
out = StreamStdout();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
out = StreamOpen(arg.optArg, "w");
|
||||||
|
if (!out)
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(), "Error: %s:%s",
|
||||||
|
arg.optArg, strerror(errno));
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 'D':
|
||||||
|
val = arg.optArg;
|
||||||
|
while (*val && *val != '=')
|
||||||
|
{
|
||||||
|
val++;
|
||||||
|
}
|
||||||
|
if (!*val || *val != '=')
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(), "Bad register definition: %s",
|
||||||
|
arg.optArg);
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
|
||||||
|
*val = '\0';
|
||||||
|
val++;
|
||||||
|
HashMapSet(registers, arg.optArg, StrDuplicate(val));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!in)
|
||||||
|
{
|
||||||
|
in = StreamStdin();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!out)
|
||||||
|
{
|
||||||
|
out = StreamStdout();
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(&expr, 0, sizeof(expr));
|
||||||
|
|
||||||
|
while (1)
|
||||||
|
{
|
||||||
|
HeaderParse(in, &expr);
|
||||||
|
|
||||||
|
switch (expr.type)
|
||||||
|
{
|
||||||
|
case HP_PREPROCESSOR_DIRECTIVE:
|
||||||
|
/* Ignore */
|
||||||
|
break;
|
||||||
|
case HP_EOF:
|
||||||
|
/* Done parsing */
|
||||||
|
goto last;
|
||||||
|
case HP_PARSE_ERROR:
|
||||||
|
case HP_SYNTAX_ERROR:
|
||||||
|
StreamPrintf(StreamStderr(), "Parse Error: (line %d) %s\n",
|
||||||
|
expr.data.error.lineNo, expr.data.error.msg);
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
case HP_COMMENT:
|
||||||
|
if (expr.data.text[0] != '*')
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (strncmp(expr.data.text, "**", 2) == 0)
|
||||||
|
{
|
||||||
|
ParseMainBlock(registers, descr, expr.data.text);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
strncpy(comment, expr.data.text, sizeof(comment));
|
||||||
|
isDocumented = 1;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case HP_TYPEDEF:
|
||||||
|
if (HashMapGet(registers, "ignore-typedefs"))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!isDocumented)
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(),
|
||||||
|
"Error: Undocumented typedef:\n%s\n",
|
||||||
|
expr.data.text);
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
type = Malloc(sizeof(DocTypedef));
|
||||||
|
strncpy(type->docs, comment, sizeof(type->docs));
|
||||||
|
strncpy(type->text, expr.data.text, sizeof(type->text));
|
||||||
|
ArrayAdd(typedefs, type);
|
||||||
|
isDocumented = 0;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case HP_DECLARATION:
|
||||||
|
if (!isDocumented)
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(),
|
||||||
|
"Error: %s() is undocumented.\n",
|
||||||
|
expr.data.declaration.name);
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
decl = Malloc(sizeof(DocDecl));
|
||||||
|
decl->decl = expr.data.declaration;
|
||||||
|
decl->decl.args = ArrayCreate();
|
||||||
|
strncpy(decl->docs, comment, sizeof(decl->docs));
|
||||||
|
for (i = 0; i < ArraySize(expr.data.declaration.args); i++)
|
||||||
|
{
|
||||||
|
ArrayAdd(decl->decl.args, StrDuplicate(ArrayGet(expr.data.declaration.args, i)));
|
||||||
|
}
|
||||||
|
ArrayAdd(declarations, decl);
|
||||||
|
isDocumented = 0;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case HP_GLOBAL:
|
||||||
|
if (!isDocumented)
|
||||||
|
{
|
||||||
|
StreamPrintf(StreamStderr(),
|
||||||
|
"Error: Global %s is undocumented.\n",
|
||||||
|
expr.data.global.name);
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
global = Malloc(sizeof(DocGlobal));
|
||||||
|
global->global = expr.data.global;
|
||||||
|
|
||||||
|
strncpy(global->docs, comment, sizeof(global->docs));
|
||||||
|
ArrayAdd(globals, global);
|
||||||
|
isDocumented = 0;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case HP_UNKNOWN:
|
||||||
|
if (HashMapGet(registers, "suppress-warnings"))
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
StreamPrintf(StreamStderr(), "Warning: Unknown expression: %s\n",
|
||||||
|
expr.data.text);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
StreamPrintf(StreamStderr(), "Unknown header type: %d\n", expr.type);
|
||||||
|
StreamPrintf(StreamStderr(), "This is a programming error.\n");
|
||||||
|
exit = EXIT_FAILURE;
|
||||||
|
goto finish;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
last:
|
||||||
|
val = HashMapGet(registers, "Nm");
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
HashMapSet(registers, "Nm", StrDuplicate("Unnamed"));
|
||||||
|
}
|
||||||
|
|
||||||
|
val = HashMapGet(registers, "Dd");
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
time_t currentTime;
|
||||||
|
struct tm *timeInfo;
|
||||||
|
char tsBuf[1024];
|
||||||
|
|
||||||
|
currentTime = time(NULL);
|
||||||
|
timeInfo = localtime(¤tTime);
|
||||||
|
strftime(tsBuf, sizeof(tsBuf), "%B %d %Y", timeInfo);
|
||||||
|
|
||||||
|
val = tsBuf;
|
||||||
|
}
|
||||||
|
StreamPrintf(out, ".Dd $%s: %s $\n", "Mdocdate", val);
|
||||||
|
|
||||||
|
val = HashMapGet(registers, "Os");
|
||||||
|
if (val)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, ".Os %s\n", val);
|
||||||
|
}
|
||||||
|
|
||||||
|
val = HashMapGet(registers, "Nm");
|
||||||
|
StreamPrintf(out, ".Dt %s 3\n", val);
|
||||||
|
StreamPrintf(out, ".Sh NAME\n");
|
||||||
|
StreamPrintf(out, ".Nm %s\n", val);
|
||||||
|
|
||||||
|
val = HashMapGet(registers, "Nd");
|
||||||
|
if (!val)
|
||||||
|
{
|
||||||
|
val = "No Description.";
|
||||||
|
}
|
||||||
|
StreamPrintf(out, ".Nd %s\n", val);
|
||||||
|
|
||||||
|
StreamPrintf(out, ".Sh SYNOPSIS\n");
|
||||||
|
val = HashMapGet(registers, "Nm");
|
||||||
|
StreamPrintf(out, ".In %s.h\n", val);
|
||||||
|
for (i = 0; i < ArraySize(declarations); i++)
|
||||||
|
{
|
||||||
|
size_t j;
|
||||||
|
|
||||||
|
decl = ArrayGet(declarations, i);
|
||||||
|
StreamPrintf(out, ".Ft %s\n", decl->decl.returnType);
|
||||||
|
StreamPrintf(out, ".Fn %s ", decl->decl.name);
|
||||||
|
for (j = 0; j < ArraySize(decl->decl.args); j++)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "\"%s\" ", ArrayGet(decl->decl.args, j));
|
||||||
|
}
|
||||||
|
StreamPutc(out, '\n');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ArraySize(globals))
|
||||||
|
{
|
||||||
|
StreamPrintf(out, ".Sh GLOBALS\n");
|
||||||
|
for (i = 0; i < ArraySize(globals); i++)
|
||||||
|
{
|
||||||
|
char *line;
|
||||||
|
global = ArrayGet(globals, i);
|
||||||
|
|
||||||
|
StreamPrintf(out, ".Ss %s %s\n", global->global.type, global->global.name);
|
||||||
|
|
||||||
|
line = strtok(global->docs, "\n");
|
||||||
|
while (line)
|
||||||
|
{
|
||||||
|
while (*line && (isspace(*line) || *line == '*'))
|
||||||
|
{
|
||||||
|
line++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*line)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "%s\n", line);
|
||||||
|
}
|
||||||
|
|
||||||
|
line = strtok(NULL, "\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ArraySize(typedefs))
|
||||||
|
{
|
||||||
|
StreamPrintf(out, ".Sh TYPE DECLARATIONS\n");
|
||||||
|
for (i = 0; i < ArraySize(typedefs); i++)
|
||||||
|
{
|
||||||
|
char *line;
|
||||||
|
|
||||||
|
type = ArrayGet(typedefs, i);
|
||||||
|
StreamPrintf(out, ".Bd -literal -offset indent\n");
|
||||||
|
StreamPrintf(out, "%s\n", type->text);
|
||||||
|
StreamPrintf(out, ".Ed\n.Pp\n");
|
||||||
|
|
||||||
|
line = strtok(type->docs, "\n");
|
||||||
|
while (line)
|
||||||
|
{
|
||||||
|
while (*line && (isspace(*line) || *line == '*'))
|
||||||
|
{
|
||||||
|
line++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*line)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "%s\n", line);
|
||||||
|
}
|
||||||
|
|
||||||
|
line = strtok(NULL, "\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
StreamPrintf(out, ".Sh DESCRIPTION\n");
|
||||||
|
for (i = 0; i < ArraySize(descr); i++)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "%s\n", ArrayGet(descr, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(declarations); i++)
|
||||||
|
{
|
||||||
|
size_t j;
|
||||||
|
char *line;
|
||||||
|
|
||||||
|
decl = ArrayGet(declarations, i);
|
||||||
|
StreamPrintf(out, ".Ss %s %s(",
|
||||||
|
decl->decl.returnType, decl->decl.name);
|
||||||
|
for (j = 0; j < ArraySize(decl->decl.args); j++)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "%s", ArrayGet(decl->decl.args, j));
|
||||||
|
if (j < ArraySize(decl->decl.args) - 1)
|
||||||
|
{
|
||||||
|
StreamPuts(out, ", ");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
StreamPuts(out, ")\n");
|
||||||
|
|
||||||
|
line = strtok(decl->docs, "\n");
|
||||||
|
while (line)
|
||||||
|
{
|
||||||
|
while (*line && (isspace(*line) || *line == '*'))
|
||||||
|
{
|
||||||
|
line++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (*line)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, "%s\n", line);
|
||||||
|
}
|
||||||
|
|
||||||
|
line = strtok(NULL, "\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val = HashMapGet(registers, "Xr");
|
||||||
|
if (val)
|
||||||
|
{
|
||||||
|
char *xr = strtok(val, " ");
|
||||||
|
|
||||||
|
StreamPrintf(out, ".Sh SEE ALSO\n");
|
||||||
|
while (xr)
|
||||||
|
{
|
||||||
|
if (*xr)
|
||||||
|
{
|
||||||
|
StreamPrintf(out, ".Xr %s 3 ", xr);
|
||||||
|
}
|
||||||
|
|
||||||
|
xr = strtok(NULL, " ");
|
||||||
|
|
||||||
|
if (xr)
|
||||||
|
{
|
||||||
|
StreamPutc(out, ',');
|
||||||
|
}
|
||||||
|
StreamPutc(out, '\n');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
finish:
|
||||||
|
if (in != StreamStdin())
|
||||||
|
{
|
||||||
|
StreamClose(in);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (out != StreamStdout())
|
||||||
|
{
|
||||||
|
StreamClose(out);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(declarations); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(declarations, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(typedefs); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(typedefs, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(globals); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(globals, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < ArraySize(descr); i++)
|
||||||
|
{
|
||||||
|
Free(ArrayGet(descr, i));
|
||||||
|
}
|
||||||
|
|
||||||
|
while (HashMapIterate(registers, &key, (void **) &val))
|
||||||
|
{
|
||||||
|
Free(val);
|
||||||
|
}
|
||||||
|
|
||||||
|
HashMapFree(registers);
|
||||||
|
|
||||||
|
return exit;
|
||||||
|
}
|
Loading…
Reference in a new issue