While the FamFamFam icons have served us well, we really
need SVG flag icons for HiDPI scenarios.
This is one of the last pieces missing to allow us to
claim we fully support Retina displays on OS X.
In each generated file we want to have a banner that warns of
modification by hand and indicates the generator responsible
for the file. This patch extends mkwrapper.pl to write such
a header.
It also switches mkwrapper.pl away from barewords for file-handles.
Apparently those are no longer considered idiomatic Perl and they
broke the "iterate over list of handles" thing this patch does.
This change removes our qmake-based Qt translation embedding.
That system uses mumble_qt.qrc resource file with
hardcoded filenames for Qt translations, and some logic
implemented in qmake that copies Qt translations into
the Mumble source tree such that the paths in the
mumble_qt.qrc file match.
The new system introduces a simple Python script that
takes an output filename for the .qrc file the tool
will write, along with a set of directories containing
Qt translations.
The tool will generate a Qt resource file containing
references to all the translation files found in the
specified directories. However, the tool takes care
to only include language files once.
In typical use, the first directory parameter passed
to the tool is the QT_INSTALL_TRANSLATIONS directory,
which is where Qt stores its own translation files.
The second directory is Mumble's fallback directory.
The tool then goes through all files in the first
directory, and notes down which languages have been
processed. Multiple files for a single langauge can
be included from the a directory (qt_help_da.qm,
and qtbase_da.qm), but once a language has been
added from one directory, it will not be added
if found in the next one in line.
We use this to include a set of 'fallback'
translations for versions of Qt that do not
include them. This also allows this new style
of Qt translation embedding to be forward
compatible with newer versions of Qt that
add new translations.
Once Qt includes a translation that we have
in our fallback directory, the Qt translation
is used instead.
This change removes the "RCC Error:" output that appears
when running "qmake -recursive main.pro".
The qmake tool's resources feature (resources.prf) invokes
"rcc -list <input>.qrc" to determine which files to add as
dependencies for the rcc target (for the given <input>.qrc)
in the generated Makefile.
When invoking "rcc -list [...]" on some of our .qrc files,
we get errors, such as:
RCC: Error in 'mumble.qrc': Cannot find file 'mumble_cs.qm'
RCC: Error in 'mumble.qrc': Cannot find file 'mumble_da.qm'
RCC: Error in 'mumble.qrc': Cannot find file 'mumble_de.qm'
[...]
This is because our .qrc files include references to files
that are generated when we invoke the Makefile.
Unfortunately, the invocation of "rcc -list [...]" happens
during the qmake invocation, and not when running "make".
So the files simply do not exist yet.
This change replaces the qmake "rcc" extra compiler's
"depend_command" to be a script we wrote ourselves, namely
rcc-depends.py, that lives in the scripts directory.
This script does practically the same thing as invoking
"rcc -list", but it does not care if the files exist yet
or not. It expects that they do.
The result is that all files listed in a .qrc file are now
properly added as dependencies for the Makefile rule that
invokes rcc to process the .qrc file. This did not happen
before.
So, a positive side-effect of this change is that our
Makefile is now able to order things correctly itself,
even for auto-generated files in .qrc files. Before, we
had to give it hints. These hints are still in place,
such as:
lrel.variable_out = rcc.depends
and
copytrans.variable_out = rcc.depends
both from mumble.pro. These hints are used to order
the lrel and copytrans targets before rcc is invoked
in the generated Makefile. However, now that all files
are output as dependency information in the Makefile,
this should not strictly be necessary.
This change has been tested with both Qt 4 and Qt 5, on
Windows and Linux.
This patch introduces a lookup table that allows us to retrieve
additional IETF TLS parameters based on the ciphersuite name
provided by Qt/OpenSSL. With this additional information we can
have the detailed output we want to have for the connection
info dialog.
The table is generated by the generate-cipherinfo.py script
which uses a heuristic to select a representative set of
suites we might to expect to see from the the official IETF
TLS parameter descriptions.
Should we not find the cipher suite a connection ended up
using in this table we will fall back to less detailed output
which the user can use to find the specific parameters.
This patch also contains some other minor changes to the dialog.
This change allows server admins to specify Diffie-Hellman
parameters for Murmur to use. This is done using the sslDHParams
option in the config file. Diffie-Hellman parameters can also be
set on a per-server basis using the sslDHParams option.
Note: the functionality implemented in this change requires the
QSslDiffieHellmanParameters class in Qt, which has not yet landed
upstream in the Qt 5 'dev' branch. This means that the functionality
discussed in this change will, for now, only work in binaries provided
by the Mumble project, or binaries that are built using our build
environments, and not binaries that link against any released versions
of Qt at present.
This change modifies the default TLS cipher suite string to add
EDH+aRSA+AESGCM, DHE-RSA-AES256-SHA and DHE-RSA-AES128-SHA.
This yields the following ciphers, in TLS/RFC notation:
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
TLS_DHE_RSA_WITH_AES_256_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
This change also allows Murmur servers to provide forward secrecy
to older clients, such as our own pre-built binaries before 1.2.9.
It also provides forward secrecy for users that use Mumble 1.2.x
versions on Linux distros, and other Unix-like systems. This is
because Mumble 1.2.x on Unix-like systems builds against Qt 4, which
limits the connection to TLS 1.0.
Before this change, Murmur was not able to negotiate an ephemeral
Diffie-Hellman key exchange for those clients. This is now possible.
Lines starting with a hash are not considered to be comments!!
The QSettings() class has no formal support for comments. In fact,
there's no mention of comments at all in the class documentation:
http://doc.qt.io/qt-5/qsettings.html
There is some limited support for comments by denoting a line with a
semicolon. You can confirm this via the associated source code:
https://github.com/qtproject/qtbase/blob/5.6/src/corelib/io/qsettings.cpp
However, if saving the file via the Qt interfaces, comments will
generally be stripped out. This isn't to my knowledge a problem for
Murmur as there's no case where the server itself will update its
configuration and save the changes back to its INI file automatically.
The existing sample INI file prior to this commit only ever worked as
there's an even number of unescaped special characters in the header!
One can use rcc -project to emit .qrc files for the contents of
a directory. However this functionality seems to be woefully incomplete
to the point of being broken.
This small python script offers the same functionality with more
options to customize and configure behaviour. This includes custom
prefixes, better handling of qrc file path vs. alias and exclusions.
This commit adds the 'sslCiphers' option to Murmur.
The 'sslCiphers' option is used to configure the list of advertised
TLS cipher suites. The option lives on Meta, so it is a server-wide
configuration, and cannot be configured on a per-virtual-server basis.
The 'sslCiphers' option uses the OpenSSL's cipher list format to
describe the cipher suite selection. For more information on this
format, see:
https://www.openssl.org/docs/apps/ciahers.html#CIPHER-LIST-FORMAT
This commit adds MinHook as a 3rd party
dependency and adds an alternative HardHook
implementation that makes use of MinHook.
This new MinHook-based HardHook implementation
allows us to provide an overlay for Mumble on
Windows x64.
The x64 overlay hasn't seen much testing in
real-world x64 games, except some minor testing
for World of Warcraft running in x64 mode, where
it works just fine.
There seems to be a compatibility with the Uplay
overlay, which causes Far Cry 4 to crash at the
"Press any key to continue" screen that is shown
just after launching the game. However,
Assassin's Creed: Unity works fine, so it might
just be a Far Cry 4 issue.
The x64 overlay also seems to interoperate with
the Steam overlay just fine.
I think this is a good starting point for the
feature. Let us get it into snapshots and let
us try to squash any addition bugs we find.
* Changed naming scheme from "qproperty-<group>_<role>"
to "qproperty-<role>_<group>".
* Introduced "qproperty-<group>" to set all roles of the
group to the same brush
Qt allows setting custom QPROPERTY values from QSS themes. As we cannot
style QPalettes this class has a property for each color group and
color role in a palette and acts as a stand-in for QApplication::palette
in the theme. When setting a qproperty-<group>-<role> on it in QSS
the brush will be set on the application palette.
The ApplicationPalette is derived from QWidget but never visible.
It listens to style changes on itself as those indicate the
application palette should be updated again. Variables not set
in the QSS will not be touched in the palette.
There might be some interactions with system style or theme changes
that have not yet been explored. Those are edge cases though and
can be fixed later.
ApplicationPalette.h is generated from ApplicationPaletteTemplate.h using
the generate-ApplicationPalette-class.py script. While it isn't expected
that this file has to change a lot in the future auto-generation is much
easier than writing all that boilerplate from hand.
Fixes#1438
* Adjusted to coding guidelines
* Pulled out PBKDF2 functionality into own class
* Make benchmark a best of N approach with guaranteed minimum
* Fixed broken database migration code. Don't try to alter
tables and instead rely on them being re-created with the
new fields.
* Fixed some typos in ini. Also move to the setting to the
end so ppl. don't get the idea they have to change this.
* Chose a scarier name for the plain hash function
* Use int instead of size_t for iteration counts as it is
the datatype used in the OpenSSL API. Otherwise we just
have to much pain with constantly converting and might
expose ourselves to size issues in the future.
* Moved new UserInfo enum entry to the end as to preserve
the order
Script will do an lupdate run on mumble_en.ts, apply the duplication
of numerus tags workaround for the transifex missing string issue
(see #1195) and then create a commit with the updated translation
file. This file - at least for now - is meant to be run manually.
Make sure to check the created commit before pushing.
Previously release.pl did complex parsing of .pro
files to figure out which files to include in the
tar ball.
This change removes this logic and instead performs
the minimal modifications needed under the assumption
of a clean tree and then uses system tools to create
the tar.gz and zip files.
Using '!' as the delimiter has an unfortunate clash with cmd.exe's
delayed expansion feature. When delayed expansion is enabled, the
substitution would fail with a syntax error because cmd.exe had
mangled the substitution string before passing it to Perl.
This commit also fixes the regular expression to match the one
found in mkini.sh.
Nobody is using release.pl for deploying tarballs
automatically anymore.
Our builder bots were manually sed'ing out these
parts of the code before running release.pl, so by
dropping it completely, we can clean up their build
scripts a bit.
This is the modern way to handle application-specific URL schemes
on the various desktop environments on Unix-like systems.
Fixes#1061 (reported by Chris Knadle; thanks!)
Originally fixed in Ubuntu via
https://bugs.launchpad.net/ubuntu/+source/mumble/+bug/934239
- Channel comment flags were no longer clickable because
filters weren't considered in offset calculation.
- What's this text didn't contain the flag icon
- Lowercased Flag.svg
- Magic numbers and abbreviation refactoring
- Lowercased Filter.svg and improved license display
With this change, CONFIG(static) on Windows will cause the Mumble client's
application logic to be built into a .DLL called mumble_app.dll
(based on pcgod's previous DLL changeset).
Since src/mumble will now be built as a DLL, a wrapper executable is available
in src/mumble_exe. This wrapper is currently implemented such that it will
load mumble_app.dll from the directory that it resides in.
This means that when building statically, src/mumble and src/mumble_exe will
now give us the following products:
src/mumble: mumble_app.dll
src/mumble_exe: mumble.exe
Along with the two major points above, this change also adds a Python script
to the build, 'gen-mumble_app-qt-def.py', whose job is to construct a module
definition (.def) file for mumble_app.dll. The generated module definition
lists the Qt symbols that are needed for the manual positioning plugin to work.
If we need to expose more symbols in the future (say we want to implement
more plugin kinds than the current positional audio plugins), we now have
the infrastructure in place to do that.
* Adjust the mklic.pl so it generates and uses the newly introduced ThirdPartyLicense struct
* Misc improvements (newline cleanups, varnaming)
* Generate new licenses.h file via mklic.pl
* Move Icon creation script/program to the scripts folder.
It is definitely not a test.
* Introduce scripts/development folder for development scripts, in contrary to scripts/server for example.
