* Adding an incrementing peer ID for easier connection identification on peer disconnect

* Removing the private override of onDisconnection in http::Handler

* Adding unit test for onDisconnection

* - Exposing a peer handle from the ResponseWriter
- Making disconnection test a bit more deterministic; there appears to be a race condition between server.shutdown() returning and the onDisconnection() callback succeeding.
- Adding Active Connections info in test case to demonstrate usage.

* Reducing verbosity of test output

* Fixing getID vs getId call, removing block comment around other tests
Co-authored-by: Ian Roddis <gitlab@ie2r.com>

This reverts commit eb9102dd.

* Adding an incrementing peer ID for easier connection identification on peer disconnect

* Removing the private override of onDisconnection in http::Handler

* Adding unit test for onDisconnection

* - Exposing a peer handle from the ResponseWriter
- Making disconnection test a bit more deterministic; there appears to be a race condition between server.shutdown() returning and the onDisconnection() callback succeeding.
- Adding Active Connections info in test case to demonstrate usage.

* Reducing verbosity of test output
Co-authored-by: Ian Roddis <gitlab@ie2r.com>

fix chunked transfer decoding

Don't build and install pistache_shared if the standard cmake
BUILD_SHARED_LIBS is set to OFF
Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>

- usage of complete body_.size() seems is wrong (only valid if there is one chunk?)
- use separate var to count already received bytes of chunk

* fix issue-193

The client implementation isn't compliant with HTTP 1.1 standard, to be
specific, it doesn't honor the "Connection: close" response header. As a
result, whenever a new request is sent, a new tcp connection is opened
to the server and is never closed (unless the server close it).

The best place to close the connection is in Connection::OnDone() method,
however, that method is provided too early, in the Connection::asyncPerform()
method, where the Http::Response object is not yet available. It's also
incorrect to blindly close the connection in OnDone() method, as there might
be more data from server.

This commit explicitly closes all opened connections on Client::shutdown(),
to guarantee all network resources are recycled on that call.

It's impossible to write any unit test case verify it, the connection pool
is invisible to Client users. It passed manual tests on crafted scenarios.

To verify this, start a Pistache server from the examples, then use the Client
library to send some requests to the server, and don't terminate client side
program. Use "netstat -an | grep <server_port>" to see if there are remaining
connections in ESTABLISHED state after client.shutdown() is called.
Signed-off-by: Jiankun Yu <yujiankun@hotmail.com>

* fix formatting issue

Revert "Use a std::shared_ptr<std::string> instead of std::string for the body_ member variable in Pistache::Http::Message (#814)" (#816)

This reverts commit a09290ee.

Use a std::shared_ptr<std::string> instead of std::string for the body_ member variable in Pistache::Http::Message (#814)

As a Pistache::Http::Message object is copied several times during the handling of a request this leads to a significant reduction in memory usage when uploading files through a http post.
Signed-off-by: Messiaen Arno <a.messiaen@televic.com>
Co-authored-by: Messiaen Arno <a.messiaen@televic.com>

This will fix the detection of atomic:

-- Performing Test HAVE_CXX_ATOMICS64_WITHOUT_LIB
-- Performing Test HAVE_CXX_ATOMICS64_WITHOUT_LIB - Failed
-- Looking for __atomic_load_8 in atomic
-- Looking for __atomic_load_8 in atomic - not found
CMake Error at CMakeModules/CheckAtomic.cmake:76 (message):
  Host compiler appears to require libatomic for 64-bit operations, but
  cannot find it.
Call Stack (most recent call first):
  CMakeLists.txt:19 (include)

Indeed if C language is not enabled, the test will be run with the C++
compiler resulting in the following error:

Building CXX object CMakeFiles/cmTC_fad22.dir/CheckFunctionExists.cxx.o
/tmp/instance-0/output-1/host/bin/mipsel-linux-g++ --sysroot=/tmp/instance-0/output-1/host/mipsel-buildroot-linux-gnu/sysroot    -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Os -D_FORTIFY_SOURCE=1 -Wall -Wconversion -pedantic -Wextra -Wno-missing-field-initializers -DCHECK_FUNCTION_EXISTS=__atomic_load_8  -DNDEBUG   -o CMakeFiles/cmTC_fad22.dir/CheckFunctionExists.cxx.o -c /tmp/instance-0/output-1/build/pistache-f2f5a50f/CMakeFiles/CheckLibraryExists/CheckFunctionExists.cxx
<command-line>: error: new declaration 'char __atomic_load_8()' ambiguates built-in declaration 'long long unsigned int __atomic_load_8(const volatile void*, int)' [-fpermissive]
/tmp/instance-0/output-1/build/pistache-f2f5a50f/CMakeFiles/CheckLibraryExists/CheckFunctionExists.cxx:7:3: note: in expansion of macro 'CHECK_FUNCTION_EXISTS'
   CHECK_FUNCTION_EXISTS(void);
   ^~~~~~~~~~~~~~~~~~~~~
/tmp/instance-0/output-1/build/pistache-f2f5a50f/CMakeFiles/CheckLibraryExists/CheckFunctionExists.cxx: In function 'int main(int, char**)':
/tmp/instance-0/output-1/build/pistache-f2f5a50f/CMakeFiles/CheckLibraryExists/CheckFunctionExists.cxx:17:25: error: too few arguments to function 'long long unsigned int __atomic_load_8(const volatile void*, int)'
   CHECK_FUNCTION_EXISTS();
                         ^

whereas with a C compiler, we'll get:

Building C object CMakeFiles/cmTC_4b0f4.dir/CheckFunctionExists.c.o
/home/fabrice/buildroot/output/host/bin/riscv32-linux-gcc --sysroot=/home/fabrice/buildroot/output/host/riscv32-buildroot-linux-gnu/sysroot   -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Os -DCHECK_FUNCTION_EXISTS=__atomic_load_8  -DNDEBUG   -o CMakeFiles/cmTC_4b0f4.dir/CheckFunctionExists.c.o   -c /usr/share/cmake-3.16/Modules/CheckFunctionExists.c
<command-line>: warning: conflicting types for built-in function ‘__atomic_load_8’ [-Wbuiltin-declaration-mismatch]
/usr/share/cmake-3.16/Modules/CheckFunctionExists.c:7:3: note: in expansion of macro ‘CHECK_FUNCTION_EXISTS’
   CHECK_FUNCTION_EXISTS(void);
   ^~~~~~~~~~~~~~~~~~~~~
Linking C executable cmTC_4b0f4
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_4b0f4.dir/link.txt --verbose=1
/home/fabrice/buildroot/output/host/bin/riscv32-linux-gcc --sysroot=/home/fabrice/buildroot/output/host/riscv32-buildroot-linux-gnu/sysroot -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Os -DCHECK_FUNCTION_EXISTS=__atomic_load_8  -DNDEBUG    CMakeFiles/cmTC_4b0f4.dir/CheckFunctionExists.c.o  -o cmTC_4b0f4  -latomic

Fixes:
 - http://autobuild.buildroot.org/results/2bf06c6a9e55b449ec5875cf9415a9e55b2065d6Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>

* Add support for interface versioning so applications don't break...

* {CMakeLists.txt,src/CMakeLists.txt}: Shared-library soname is now generated correctly...
version.txt: Added SONAME major and minor fields...
README.md: Add versioning notes. In particular, when to update interface version...
debian/changelog: Fixed lintian complaining about a malformed changelog for non-native package...

* feat router: Implement static checks

* Actualize checks

* RawBuffer refactoring + tests

* apply clang-format

* Small refactoring in asyncWriteImpl

* Trigger CI

* Trigger CI

* Fix typo and add const

* revert one change

* Set default build type using _INIT variable

Language support checking offers a standardized method to set default
build type using CMAKE_BUILD_TYPE_INIT variable. The variable must be
set before enable_language is called implicitly from project

* Enable only C++ compiler

* Let C++ compiler detection to check for standard support

Setting CMAKE_CXX_STANDARD variables before implicit call to
enable_language handles checking for standard support automatically.

* Fix pistache_shared export

Exporting targets allows find_package(Pistache) to import them
correctly. The import makes it easier to use Pistache in a porject using
cmake build system.

* Add wildcard ignore for multiple build directories

I used multiple build directories to test different configurations work.
My alternative test configuration is a Debian Stretch chroot for an old
distro test.

* Detect Threads which is implicit requirement

Static library requires PistancheConfig.cmake to detect all dependencies
to allow simple linking to imported library to work.

* Use find_package to detect OpenSSL

Add OpenSSL configure time detection for the development package.
FindOpenSSL.cmake started support IMPORTED libraries only in 3.4. The
IMPORTED library helps users to link correctly to pistache static
library.

Headers use libssl directly which forces pistache to use public
definition and library link.

* Export include directories to IMPORTED library

* Do not add pistache to global build configuration

PistacheConfig shouldn't add include directories and libraries to the
global build configuration. Imported libraries provide all required
build configurations to a depending target.

* Check if atomic library is required

Pistache should link to atomic library only if system requires the
library. The easiest method appears to be use a modified LLVM
CheckAtomic helper.

* Use target include directories for GTest

* Detect libcurl and remove pthread linking

* Update CMake Pistache example

* Add CMake ConfigVersion file

* Update the date part of version

* client, string_view: fix warnings

Discarded qualifier and implicit fallthrough

* common: http: fix ResponseStream flush

An error existed in transport.cc where it incorrectly assumed that
it would not receive epoll events relating to a closed peer
connection. This is not the case because file descriptors can be
shared between processes e.g. on exec. When they are, events could
still be generated. The solution is to explicitly de-register our
interest in the file descriptor before we close it using
epoll_ctl(EPOLL_CTL_DEL). In addition the call to accept in
listener.cc has been updated to set CLOEXEC on the peer file
descriptors as these should not be shared with other processes
anyway.
Co-authored-by: Roberts, Chris (UK Gloucester) <chris.v.roberts@baesystems.com>

* Small improvements in Listener constructor

* Trigger CI

* Update transport.cc

fix throw but no catch bug

* Update transport.cc

disconnect peers for all other errors

* adjust indent level
Co-authored-by: zhanb <zhangbo@caict.ac.cn>

Co-authored-by: Dennis Jenkins <dennisjenkins@google.com>

This commit partially resolves #24, which is a common requirement on
many RESTful services.

A vector of middleware handlers is added to Router, these handlers are
executed before the URL match and handler invocation, in the order of
registration.

A middleware function has the signature:

bool func(Pistache::Http::Request &request,
          Pistache::Http::ResponseWriter &response);

The first parameter is a reference to Http::Request, not Rest::Request,
at the moment middlewares are called, the request parameters are not yet
filled. This allows some generic operation on the request, such as
authentication or rate limiting.

Parameters are passed as references, to allow the middlewares be able to
modify them, such as injecting custom headers.

If a function returns true, the next function is executed, until all
middleware functions are called and all of them return true, the
registered handler is called.

If one of them returns false, this means there is no need to further
call the subsequent functions and the handler, the handling of this
request completes. Typical case is missing auth info or reaching limit.
Basically, the middleware function that returns false is responsible to
call response.send() to send the response to client.

Like Route::bind, a new method, Route::middleware(), with different
signatures, is added, to convert different callables into a middleware.

There is also requirements on the "post-handling" handlers, such as
logging response, measuring handler latency, and so on, in a centralized
place. This commit doesn't implement it: The response is passed to
handler using std::move, it's not retrievable again after handler
processing.
Signed-off-by: Jiankun Yu <yujiankun@hotmail.com>

The separation of the impl from the API means that it is more possible
to independently test variations of the API by changing the macro
definitions in log.h.

The default StringLogger impl is now called StringToStreamLogger, and
takes an optional ostream pointer on input - this makes it more
testable. It is assumed that std::cerr will be used here nearly all of
the time in practice.

* Travis fix to collect coredumps from build configuration subdirs - #720

Previously, Travis would only attempt to collect coredumps from the last
directory the build script was in, or the home directory. This meant
that most coredumps were missed, and debug information was lost.

The new setup configures apport to watch for crashes on any executables
(by default it watches for executables from Ubuntu packages). These
crash dumps are picked up, extracted, and analysed using GDB to provide
a backtrace (this needs the executable to be passed to GDB as well so
that debug symbols are provided).

* Restructured .travis.yml to avoid underspecified builds.

* Added a basic logger object and relevant macros.

* Modify logging macros for more flexibility.

Supplied logger types and sample values using macros for flexibility in
recompiling the library against a different logging engine - the macros
can be redefined to make calls to the relevant functions.

* Updated endpoint and listener to use new logging structure.

It remains to update the SSL portions of listener.cc to output SSL
errors via the new loggers.

* Add error logging for SSL errors in listener.cc.

This needed an extension to the RAII setup for SSL objects to handle BIO
objects. Also modified some exception types to ensure they get caught
and logged by existing code. Moved anonymous function definitions to the
top of listener.cc so that they are available in the entire file.

These changes don't significantly change the behaviour of the Pistache
library - it still logs errors and throws an exception for most errors
that occur internally. It would likely be more sensible to only throw
a descriptive exception and not log if the exception is expected to be
handled by the library user - this gives them better control of the
output of the software. Logging could be reserved for tracking events
and debug; when the user is not expected to provide input.

* Renamed macros and types to "string logger" and similar.

This aligns the names of the types and macros, as well as leaving space
for future logging APIs that handle different message types.

* Update test certificate generation to use explicit cert config.

Previously, no configuration was supplied on certificate generation, so
the certificates being used for testing were completely generic. This
limited the effectiveness and transparency of testing.

* Fix listener.cc to load a cert chain and provide it for server auth.

Added test with a server cert signed by an intermediate CA.

Previously, listener.cc would only load the first cert in a cert pack
and use this to authenticate itself to clients. This meant that if the
server held a cert signed by an intermediate CA, a client trusting only
the root CA would be unable to authenticate the server's cert.

See the OpenSSL docs here:
https://www.openssl.org/docs/man1.0.2/man3/SSL_CTX_use_certificate_file.html
for an overview of the SSL_CTX_use_certificate_file() and
SSL_CTX_use_certificate_chain_file() functions.

added GetSSLContext() at line  393 to prevent compilation with OpenSSL From fail  (see issue #769)

* Add third party dependencies to README.md

* Add additional third party dependencies to README.md

* Add CMake to third party dependency list in README.md

* Fix -wConversion warning in async.h #748

Fix a warning about problematic conversion from 'long int' to 'int'
appearing when compiling http.cc with -wConversion flag

* Suppress -wConversion warnings in date.h #748

Suppress warnings originating in date.h. The similar suppression appears
in the newer version of date.h appearing in its original repository
https://github.com/HowardHinnant/dateCo-authored-by: Michael Tseitlin <michael.tseitlin@concertio.com>

A race exists between the runThreaded and shutdown/dtor as follows:

 runThreaded - called
 shutdown - called
 shutdown - check for shutdownFd.isBound returns false (so no notify)
 runThreaded - thread executing 'run' starts
 runThreaded - thread calls shutdownFd.bind
 shutdown - blocks waiting for run thread
 runThreaded - continues to run as no notification received

This deadlock avoided by ensuring the shutdownFd.bind is called before
the thread is created rather than doing it at the start of the thread's
execution.