This is mainly a copy of XKeysymToString() from libX11. We've also added
a wrapper that still gives a string, even if there is no name for the
requested keysym.

This grows the binaries a bit, but not with any extreme amount so is
hopefully worth it to get better debug logging.

This permits to enable PAM for the effective user of the Xvnc process by
adding this to ~/.vnc/config or /etc/tigervnc/vncserver-config-defaults:

   SecurityTypes=TLSPlain
   PlainUsers=%u

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=2233204
Signed-off-by: Carlos Santos <casantos@redhat.com>

Don't assume a lack of TCP listeners means the server will be
unreachable. There might be other methods of access, so let the higher
levels do that sanity check instead.

These aren't supported in C2x, and clang will already now complain.

Let's log a bit more details when we need to deal with certificate
exceptions to make it easier to debug things.

The browsers let you add an exception for this case, so we should as
well.

GnuTLS can help use translate certificate issues in to user presentable
strings, so let's clean up that reporting.

The browsers let you add an exception for this case, so we should as
well.

This should have been done in 5f46d55.

The browsers let you add an exception for this case, so we should as
well.

We don't want to proceed unless we've made sure the user has approved
the issues with the certificate. So add an extra check that all status
flags have been dealt with.

GnuTLS should hopefully never set just this flag, but let's be fully
prepared for all scenarios.

We've required GnuTLS 3.x for a long time, so this code has been dead
for a while.

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.

If we can't rely on the OS to handle corking for us, then we need to
enable our own handling of it.

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

This is important in case there are build flags that need to propagate
between libraries for things to build correctly.

These will always be byte streams at heart, so let's try to keep them
with a proper type. Should make it clearer how they will be used.

An assert will kill the entire server, which is overly harsh when there
is a problem with a single connection. Instead, throw an exception which
will just disconnect that specific client.

Clipboard functions may run on connections that are not yet at
RFBSTATE_NORMAL. Due to recent hardening of the accessCheck() function,
it is important to validate that the state is RFBSTATE_NORMAL before
calling accessCheck().

Fixes #1599.

It's a type specific to that class, so let's keep them close for
clarity.

It is much more natural than custom methods for this very common
operation.

It is easy to get confused if these methods modify the existing object,
or return a new one. So let's mark the return value as critical so the
compiler can help out if someone gets it wrong.

This can have unexpected consequences as some code may rely on it being
a simple variable. Instead to what we do in Socket, which is to define a
unique name for getting socket error numbers.

It doesn't use any exceptions, so stop including the header for it.

These files don't use anything from this header, so remove the include.

This exposes some missing includes in other places, though. So add an
explicit include in the files that were relying on an indirect
inclusion.

This matches the naming in STL, which is what we are mostly mimicing now
that we are using std::string for these functions.

It's just confusing that we have our own variety that isn't compatible.

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

Avoids a bit of complexity by delegating that handling to a string
object.

Let's use a more common type instead of something homegrown. Should be
more familiar to new developers.

It's more standard and familiar than our custom CharArray type, and it
still gives us automatic freeing of the buffer.

We could probably have used std::unique_ptr instead, but we are
currently targeting older compilers where C++11 isn't standard yet.

Get rid of all the magical re-allocation and shuffling and instead just
return a new set of strings that is fully splitted. Will consume a bit
more memory, but is a lot safer to use as there is less confusion about
ownership of memory.

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.

The compiler doesn't enforce this, but it at least documents the
expected array size.

We know the needed space here, so let's keep it simple with a constant
size string buffer.

It should return a path to the directory itself, just like its sister
function getuserhomedir().

All library functions should be in a proper namespace.

A blank string might be very confusing, depending on where this will be
used. Let's give something more visible back in the cases where we
cannot get the proper name for the peer.

This mimics how some system functions (like inet_ntop()) work, and
avoids complexity around ownership of the returned string buffer.

The downside is that the string must be consumed directly as it will be
overwritten on the next call, but that is not an issue with the current
usage.

Use the same indentation we use in all other files.

It's unclear why this was initially added. The function takes string
constants, so it is not going to modify these.

Avoid complicating things by moving things in to a second buffer here as
there is no need for it.

We don't need to make extra copies of the string in most cases, so let's
simplify the code and access the string directly when we can.

We never use Windows' "UNICODE" mode anyway, so let's get rid of this
complexity.

This makes memory management more clear and robust when using these
helper functions.

Let the string helpers call the more fancy setParam(). This makes sure
we can avoid duplicating things.

Otherwise the old length is preserved, which will result in NULL pointer
dereferencing if the parameter is ever accessed.

This is explicitly a byte sequence, so let's try to keep a consistent
typing.