It's a reoccurring issue that users try to build individual components
by pointing cmake at a specific subdirectory, e.g. 'cmake vncviewer'.
CMake, unfortunately, has insufficient protection against this so we'll
need to add a manual check.

This commit only adds it to the most likely places for misuse so we
don't have to pollute every CMakeLists.txt.

These are not valid outside of UTF-16 so seeing them in a UTF-8 sequence
means that something is wrong with that sequence. Best to filter them
out rather than letting them propagate and have unknown effects.

We should handle this in the low-level protocol code as much as possible
to avoid mistakes. This way the rest of the code can assume that strings
are always UTF-8 with \n line endings.

It is more specific, and it properly sets up propagation when include
directories also need to be used further down a dependency chain.

It has now been replaced, mostly by std::string, so remove the actual
type definition.

We mostly use classical C strings, but the memory management around them
can get confusing and error prone. Let's use std::string for the cases
where we need to return a newly allocated string.

Avoid having our own custom stuff and instead use the modern, standard
types, for familiarity.

This allows us to separate accidentally unused, from explicitly unused
parameters, which allows us to turn on such checks in the compiler.

This makes sure the compiler doesn't complain about problems in those
files.

This is to make the code more tolerant of typos when entering a hostname

We should scope these as narrowely as possible to avoid side effects.

Add also missing <stdlib.h> where required.

FFMPEG is needed by the RFB library, so all the details about it should
only be applied there and not for other components.

Modern cmake has better support for adding source files and libraries
incrementally, so let's use that to clean things up.

Linux implementation using ffmpeg

The generally recommended way is to include it from source files, not
headers. We had a mix of both. Let's try to be consistent and follow the
recommended way.

Without this change I get CMake errors due to use of ${FLTK_INCLUDE_DIR}
and references to the non-existent vncviewer target.

This change makes it possible for re-synchronizing the remote cursor on
the vncviewer when in fullscreen mode. This is done by locally moving
the cursor position to what the server thinks it should be.

Now SDL games should work!

Some code points are reserved for the UTF-16 coding itself and must not
appear as input data to the algorithm.

Signed bug prevented anything not ASCII from being coded correctly.

Everything outside of BMP was handled incorrectly and was coded as
completely different code points.

This would mess up most conversions from UTF-8 as the caller wouldn't
know how far to step to get to the next valid character, resulting in
markers for invalid data to be injected here and there.

Also add some unit tests to avoid this reoccurring.

If the difference in angle is larger than 180 degrees we hit a corner
case. This commit modifies the coordinates of an existing test to cover
this.

Makes it easier to understand what the tests do.

It allows us to use the more standard format specifiers.

Allows the user to perform certain important mouse operations using
touch gestures instead.

If you have the setting "Emulate middle mouse button" turned on, a click
and drag can fail if it is done very quickly. The position of the
initial click will be incorrect in such a case because the timeout will
delay events.

Major restructuring of how streams work. Neither input nor output
streams are now blocking. This avoids stalling the rest of the client or
server when a peer is slow or unresponsive.

Note that this puts an extra burden on users of streams to make sure
they are allowed to do their work once the underlying transports are
ready (e.g. monitoring fds).

Just have a simply number of bytes argument to avoid a lot of
complexity.

Makes it more readable to write code that needs to know how much
data/space is available in a stream.

We adapted to the wrong new callback in a previous commit.

The CConnection base class wants to be able to write things these days,
so we need to provide it a place to do so.

Our fast paths assume that each channel fits in to a separate byte.
That means the shift needs to be a multiple of 8. Start actually
checking this so that a client cannot trip us up and possibly cause
incorrect code exection.

Issue found by Pavel Cheremushkin from Kaspersky Lab.

Provides safety against them accidentally becoming negative because
of bugs in the calculations.

Also does the same to CharArray and friends as they were strongly
connection to the stream objects.

Otherwise we might be tricked in to reading and writing things at
incorrect offsets for pixels which ultimately could result in an
attacker writing things to the stack or heap and executing things
they shouldn't.

This only affects the server as the client never uses the pixel
format suggested by th server.

Issue found by Pavel Cheremushkin from Kaspersky Lab.

They have very different purpose, so make things easier to work
with by having multiple directories.

We now filter incoming data, which means we can start assuming the
clipboard data is always null terminated. This allows us to clean
up a lot of the internal handling.

These are not allowed in C++, and have been made optional in C11.
So let's just get rid of them and any issues they may cause.

Avoid using the callbacks used for runtime changes for the initial
setup. They weren't really useful anyway as you could not allocate
a framebuffer without also knowing the pixel format. So make things
more clear by letting serverInit() get the initial settings.

Now that we've split out server state to ServerParams, ConnParams
only contains state for a client. Rename the class and variables
to reflect this.

We need to track different things in the server and client, so
separate things to two independent structures to keep things more
clear.

Avoid direct access to the screen dimensions and layout so that we
can make sure it stays sane. This also makes sure the layout is
properly updated when we only get the screen dimensions from the
server.

We had partial coverage for vncviewer/ already, but fix up the last
pieces.

We use polymorphic exception objects, so catching by value invokes
the copy constructor and stuff that we don't really want.