https://developer.ibm.com/linuxonpower/2017/07/28/travis-multi-architecture-ci-workflow/

https://codeburst.io/sicuro-ci-2f40ba138233

Write unit test with illegal header and where write call in write_header blocks (so effectively goes via the eventloop)

It should be possible to write a struct without any function pointers. Then write the "methods" by just prefixing them, i.e. cio_buffered_stream_

In tests this should be also easy to mock.

http://www.hello2morrow.com/products/sonargraph/architect9

Currently the Linux eventloop cancel relies on the fact that a signal is delivered in addition.
While this works perfectly when the eventloop cancel is called from a signal handler, it does not work when called from a timer callback, for instance.

• Just send, or
• close client connection immediately

In both on_message_complete and accept the same code is used to start reading an http request.

http://cgi.cs.indiana.edu/~geobrown/stm32/Main/Simulation

If no CMakeLists.txt file changes when a source is added or removed then the generated build system cannot know when to ask CMake to regenerate.

https://github.com/NASA-SW-VnV/ikos

Good candidate:
https://tls.mbed.org/

Lot's of functions are called via function pointers sitting in structs. This effectively prevents compilers to perform link time optimization (LTO) and is in general no the most efficient way to do. It also make the structs smaller, so less memory (RAM) is consumed.

The original intention was to make unit testing easier. This is not true (the functions could be easily mocked by the fff).

Implement a shutdown function which closes the server socket used.
The shutdown function should have a "closed" callback.
Use the server sockets close callback to call the "closed" callback.
Rework example http_server to shutdown the server in the signal handler and destroy the eventloop in the "closed" callback.

• Websockets
  • Perform websocket close() directly in onconnect callback function

Currently the error callback int the epoll eventloop implementation is not used.
So if epoll_wait comes out with an event where an error is signaled, this error will not be processed.

• Rename enum cio_error to cio_socket_error
• Introduce enum cio_eventloop error
• try to share CIO_SUCCESS between both enums
• Rework all callback function hooked into the eventloop accordingly
• Check socket timeout error with getsockopt in connect_callback, not in epoll_run

Closing a stream is currently a mess. The code needs to track the number of currently running reads and write to avoid accessing memory that was already freed.

Write function no_user_callback_in_handler in cio_http_location_handler.

Use this function in cio_http_server on_url to check and send responses. Eliminate User_handler flag in on_url.

Web browser (namely Chrome and it's derivatives) do not perform a nice socket close. If you have a http connection with keepalive, cio closes the TCP connection after a certain timeout. cio correctly sends a FIN packet. The OS Chrome runs on ACKs the FIN, but Chrome does not send a FIN to close down it's own socket.
This leaves the socket quite long in FIN_WAIT_2 state on the cio side, which effectively prevents freeing resources associated with that socket.

A solution in cio might shutdown with SHUT_WR, keep reading until read() returns 0 (close from the other side). This read is monitored by a timeout. If the timeout occurs, a connection reset (TCP RST) is performed. This can be done by enabling the linger, setting the linger timeout to 0 and then closing the socket.

After sending ah http response, no handler callbacks will be called afterwards.

Platform independent test are named:
cio_test_http_server

platform specific tests are name:
test_cio_linux_timer

• take out struct cio_http_client *client from struct cio_http_location_handler
• take out bs, rb, loop from ws_private structure
• rework close_server_websocket to use client pointer from websocket structure

Currently the writebuffer_heads are always copied before sending the data.

This could be optimized to copy only if not all data was sent.
Check with: valgrind --tool=callgrind ./examples/linux/uds_socket_ping_pong 1000000

If alloc_client() fails in accept callback of the linux server socket implementation, the client_fd must be closed and the accept handler should be called with an appropriate error code.

Test that free handler of cio_http_location_hander is called if accept in cio_http_server fails (for instance because a timer could not be started).

Currently the read buffer in struct cio_http_client must be at least big enough to hold a complete binary/text message.

This is not necessary. IF we introduce a function read_at_most() in buffered_stream we can use this function when reading the payload of a websocket message and call the handler in read_message always if some data arrives.

Care must be taken that we do not read more data then announced via the websocket frame length.

The autobahn test server code should then run with just 1kbyte of buffer memory.

It must be possible to use the generic infrastructure to send an upgrade response in websocket_location_handler

• Ensure correct keepalive handling if no handler for an URL was found and a correct request comes afterwards. So the test should receive a request with header and body which should be answered with 404. The client is not closed now. Then a second request comes in which should be answered with 200.

• response_written within the context of on_message_complete (write succeeds immediately)

• response_written comes after on_message_complete (write was blocked in socket write)

If the http server sees an header/body timeout it should:

• Rename read_header_timer to something that shows that this timer is used to check header and body
• Send a response message with status code 408 (Request Timeout) even without a request coming in
• the timeout message header should include the "Connection: close" field.
• The TCP connection must be closed after the response message was sent.

Some browsers (namely chrome) open multiple TCP connections and use only one. This currently leads to a memory leak because the memory allocated in alloc_http_client is never freed (because the socket connection is never closed).

Should be done globally in http-server to prevent DOS as early as possible.
Two options:

• Immediately close the socket connection after accept.
• Close the server socket if above limit and reopen again if below limit.