#include "compose.hpp"
#include "crypto.h"
#include "dkdm_recipient.h"
-#include <dcp/raw_convert.h>
-#include <dcp/name_format.h>
+#include "zipper.h"
#include <dcp/certificate_chain.h>
+#include <dcp/name_format.h>
+#include <dcp/raw_convert.h>
#include <libcxml/cxml.h>
#include <glib.h>
#include <libxml++/libxml++.h>
using std::min;
using std::max;
using std::remove;
-using std::exception;
-using std::cerr;
using std::shared_ptr;
using std::make_shared;
using boost::optional;
_default_dcp_audio_channels = 6;
_default_j2k_bandwidth = 150000000;
_default_audio_delay = 0;
- _default_interop = true;
+ _default_interop = false;
+ _default_metadata.clear ();
_upload_after_make_dcp = false;
_mail_server = "";
_mail_port = 25;
#ifdef DCPOMATIC_WINDOWS
_win32_console = false;
#endif
- _cinemas_file = path ("cinemas.xml");
- _dkdm_recipients_file = path ("dkdm_recipients.xml");
+ /* At the moment we don't write these files anywhere new after a version change, so they will be read from
+ * ~/.config/dcpomatic2 (or equivalent) and written back there.
+ */
+ _cinemas_file = read_path ("cinemas.xml");
+ _dkdm_recipients_file = read_path ("dkdm_recipients.xml");
_show_hints_before_make_dcp = true;
_confirm_kdm_email = true;
_kdm_container_name_format = dcp::NameFormat ("KDM %f %c");
_image_display = 0;
_video_view_type = VIDEO_VIEW_SIMPLE;
_respect_kdm_validity_periods = true;
- _player_activity_log_file = boost::none;
_player_debug_log_file = boost::none;
_player_content_directory = boost::none;
_player_playlist_directory = boost::none;
_player_kdm_directory = boost::none;
_audio_mapping = boost::none;
- _minimum_frame_size = 65536;
+ _custom_languages.clear ();
+ _add_files_path = boost::none;
+ _use_isdcf_name_by_default = true;
+ _write_kdms_to_disk = true;
+ _email_kdms = false;
_allowed_dcp_frame_rates.clear ();
_allowed_dcp_frame_rates.push_back (24);
{
return make_shared<dcp::CertificateChain> (
openssl_path(),
+ CERTIFICATE_VALIDITY_PERIOD,
"dcpomatic.com",
"dcpomatic.com",
".dcpomatic.smpte-430-2.ROOT",
void
Config::backup ()
{
- /* Make a copy of the configuration */
- try {
+ using namespace boost::filesystem;
+
+ auto copy_adding_number = [](path const& path_to_copy) {
+
+ auto add_number = [](path const& path, int number) {
+ return String::compose("%1.%2", path, number);
+ };
+
int n = 1;
- while (n < 100 && boost::filesystem::exists(path(String::compose("config.xml.%1", n)))) {
+ while (n < 100 && exists(add_number(path_to_copy, n))) {
++n;
}
+ boost::system::error_code ec;
+ copy_file(path_to_copy, add_number(path_to_copy, n), ec);
+ };
+
+ /* Make a backup copy of any config.xml, cinemas.xml, dkdm_recipients.xml that we might be about
+ * to write over. This is more intended for the situation where we have a corrupted config.xml,
+ * and decide to overwrite it with a new one (possibly losing important details in the corrupted
+ * file). But we might as well back up the other files while we're about it.
+ */
+
+ /* This uses the State::write_path stuff so, e.g. for a current version 2.16 we might copy
+ * ~/.config/dcpomatic2/2.16/config.xml to ~/.config/dcpomatic2/2.16/config.xml.1
+ */
+ copy_adding_number (config_write_file());
- boost::filesystem::copy_file(path("config.xml", false), path(String::compose("config.xml.%1", n), false));
- boost::filesystem::copy_file(path("cinemas.xml", false), path(String::compose("cinemas.xml.%1", n), false));
- boost::filesystem::copy_file(path("dkdm_recipients.xml", false), path(String::compose("dkdm_recipients.xml.%1", n), false));
- } catch (...) {}
+ /* These do not use State::write_path, so whatever path is in the Config we will copy
+ * adding a number.
+ */
+ copy_adding_number (_cinemas_file);
+ copy_adding_number (_dkdm_recipients_file);
}
void
try
{
cxml::Document f ("Config");
- f.read_file (config_file ());
+ f.read_file (config_read_file());
auto version = f.optional_number_child<int> ("Version");
if (version && *version < _current_version) {
_dcp_product_version = f.optional_string_child("DCPProductVersion").get_value_or("");
_dcp_j2k_comment = f.optional_string_child("DCPJ2KComment").get_value_or("");
- if (version && version.get() >= 2) {
- _default_isdcf_metadata = ISDCFMetadata (f.node_child ("ISDCFMetadata"));
- } else {
- _default_isdcf_metadata = ISDCFMetadata (f.node_child ("DCIMetadata"));
- }
-
_default_still_length = f.optional_number_child<int>("DefaultStillLength").get_value_or (10);
_default_j2k_bandwidth = f.optional_number_child<int>("DefaultJ2KBandwidth").get_value_or (200000000);
_default_audio_delay = f.optional_number_child<int>("DefaultAudioDelay").get_value_or (0);
_default_interop = f.optional_bool_child("DefaultInterop").get_value_or (false);
+
+ for (auto const& i: f.node_children("DefaultMetadata")) {
+ _default_metadata[i->string_attribute("key")] = i->content();
+ }
+
_default_kdm_directory = f.optional_string_child("DefaultKDMDirectory");
/* Read any cinemas that are still lying around in the config file
}
}
- optional<BadReason> bad;
-
- for (auto const& i: _signer_chain->unordered()) {
- if (i.has_utf8_strings()) {
- bad = BAD_SIGNER_UTF8_STRINGS;
- }
- }
-
- if (!_signer_chain->chain_valid() || !_signer_chain->private_key_valid()) {
- bad = BAD_SIGNER_INCONSISTENT;
- }
-
- if (!_decryption_chain->chain_valid() || !_decryption_chain->private_key_valid()) {
- bad = BAD_DECRYPTION_INCONSISTENT;
- }
-
+ auto bad = check_certificates ();
if (bad) {
auto const remake = Bad(*bad);
if (remake && *remake) {
switch (*bad) {
case BAD_SIGNER_UTF8_STRINGS:
case BAD_SIGNER_INCONSISTENT:
+ case BAD_SIGNER_VALIDITY_TOO_LONG:
_signer_chain = create_certificate_chain ();
break;
case BAD_DECRYPTION_INCONSISTENT:
_dkdms->add (DKDMBase::read (i));
}
}
- _cinemas_file = f.optional_string_child("CinemasFile").get_value_or (path ("cinemas.xml").string ());
- _dkdm_recipients_file = f.optional_string_child("DKDMRecipientsFile").get_value_or (path("dkdm_recipients.xml").string());
+ _cinemas_file = f.optional_string_child("CinemasFile").get_value_or(read_path("cinemas.xml").string());
+ _dkdm_recipients_file = f.optional_string_child("DKDMRecipientsFile").get_value_or(read_path("dkdm_recipients.xml").string());
_show_hints_before_make_dcp = f.optional_bool_child("ShowHintsBeforeMakeDCP").get_value_or (true);
_confirm_kdm_email = f.optional_bool_child("ConfirmKDMEmail").get_value_or (true);
_kdm_container_name_format = dcp::NameFormat (f.optional_string_child("KDMContainerNameFormat").get_value_or ("KDM %f %c"));
_video_view_type = VIDEO_VIEW_SIMPLE;
}
_respect_kdm_validity_periods = f.optional_bool_child("RespectKDMValidityPeriods").get_value_or(true);
- /* PlayerLogFile is old name */
- _player_activity_log_file = f.optional_string_child("PlayerLogFile");
- if (!_player_activity_log_file) {
- _player_activity_log_file = f.optional_string_child("PlayerActivityLogFile");
- }
_player_debug_log_file = f.optional_string_child("PlayerDebugLogFile");
_player_content_directory = f.optional_string_child("PlayerContentDirectory");
_player_playlist_directory = f.optional_string_child("PlayerPlaylistDirectory");
_audio_mapping = AudioMapping (f.node_child("AudioMapping"), Film::current_state_version);
}
- _minimum_frame_size = f.optional_number_child<int>("MinimumFrameSize").get_value_or(65536);
+ for (auto i: f.node_children("CustomLanguage")) {
+ try {
+ /* This will fail if it's called before dcp::init() as it won't recognise the
+ * tag. That's OK because the Config will be reloaded again later.
+ */
+ _custom_languages.push_back (dcp::LanguageTag(i->content()));
+ } catch (std::runtime_error& e) {}
+ }
+
+ _add_files_path = f.optional_string_child("AddFilesPath");
+ _use_isdcf_name_by_default = f.optional_bool_child("UseISDCFNameByDefault").get_value_or(true);
+ _write_kdms_to_disk = f.optional_bool_child("WriteKDMsToDisk").get_value_or(true);
+ _email_kdms = f.optional_bool_child("EmailKDMs").get_value_or(false);
if (boost::filesystem::exists (_cinemas_file)) {
cxml::Document f ("Cinemas");
}
}
catch (...) {
- if (have_existing ("config.xml")) {
+ if (have_existing("config.xml") || have_existing("cinemas.xml") || have_existing("dkdm_recipients.xml")) {
backup ();
/* We have a config file but it didn't load */
FailedToLoad ();
/* [XML] UploadAfterMakeDCP 1 to upload to a TMS after making a DCP, 0 for no upload. */
root->add_child("UploadAfterMakeDCP")->add_child_text (_upload_after_make_dcp ? "1" : "0");
- /* [XML] ISDCFMetadata Default ISDCF metadata to use for new films; child tags are <code><ContentVersion></code>,
- <code><AudioLanguage></code>, <code><SubtitleLanguage></code>, <code><Territory></code>,
- <code><Rating></code>, <code><Studio></code>, <code><Facility></code>, <code><TempVersion></code>,
- <code><PreRelease></code>, <code><RedBand></code>, <code><Chain></code>, <code><TwoDVersionOFThreeD></code>,
- <code><MasteredLuminance></code>.
- */
- _default_isdcf_metadata.as_xml (root->add_child ("ISDCFMetadata"));
-
/* [XML] DefaultStillLength Default length (in seconds) for still images in new films. */
root->add_child("DefaultStillLength")->add_child_text (raw_convert<string> (_default_still_length));
/* [XML] DefaultJ2KBandwidth Default bitrate (in bits per second) for JPEG2000 data in new films. */
root->add_child("DefaultAudioDelay")->add_child_text (raw_convert<string> (_default_audio_delay));
/* [XML] DefaultInterop 1 to default new films to Interop, 0 for SMPTE. */
root->add_child("DefaultInterop")->add_child_text (_default_interop ? "1" : "0");
+ for (auto const& i: _default_metadata) {
+ auto c = root->add_child("DefaultMetadata");
+ c->set_attribute("key", i.first);
+ c->add_child_text(i.second);
+ }
if (_default_kdm_directory) {
/* [XML:opt] DefaultKDMDirectory Default directory to write KDMs to. */
root->add_child("DefaultKDMDirectory")->add_child_text (_default_kdm_directory->string ());
/* [XML] AutomaticAudioAnalysis 1 to run audio analysis automatically when audio content is added to the film, otherwise 0. */
root->add_child("AutomaticAudioAnalysis")->add_child_text (_automatic_audio_analysis ? "1" : "0");
#ifdef DCPOMATIC_WINDOWS
- /* [XML] Win32Console 1 to open a console when running on Windows, otherwise 0. */
- root->add_child("Win32Console")->add_child_text (_win32_console ? "1" : "0");
+ if (_win32_console) {
+ /* [XML] Win32Console 1 to open a console when running on Windows, otherwise 0.
+ * We only write this if it's true, which is a bit of a hack to allow unit tests to work
+ * more easily on Windows (without a platform-specific reference in config_write_utf8_test)
+ */
+ root->add_child("Win32Console")->add_child_text ("1");
+ }
#endif
/* [XML] Signer Certificate chain and private key to use when signing DCPs and KDMs. Should contain <code><Certificate></code>
}
/* [XML] RespectKDMValidityPeriods 1 to refuse to use KDMs that are out of date, 0 to ignore KDM dates. */
root->add_child("RespectKDMValidityPeriods")->add_child_text(_respect_kdm_validity_periods ? "1" : "0");
- if (_player_activity_log_file) {
- /* [XML] PlayerLogFile Filename to use for player activity logs (e.g starting, stopping, playlist loads) */
- root->add_child("PlayerActivityLogFile")->add_child_text(_player_activity_log_file->string());
- }
if (_player_debug_log_file) {
- /* [XML] PlayerLogFile Filename to use for player debug logs */
+ /* [XML] PlayerLogFile Filename to use for player debug logs. */
root->add_child("PlayerDebugLogFile")->add_child_text(_player_debug_log_file->string());
}
if (_player_content_directory) {
if (_audio_mapping) {
_audio_mapping->as_xml (root->add_child("AudioMapping"));
}
- root->add_child("MinimumFrameSize")->add_child_text(raw_convert<string>(_minimum_frame_size));
+ for (auto const& i: _custom_languages) {
+ root->add_child("CustomLanguage")->add_child_text(i.to_string());
+ }
+ if (_add_files_path) {
+ /* [XML] AddFilesPath The default path that will be offered in the picker when adding files to a film. */
+ root->add_child("AddFilesPath")->add_child_text(_add_files_path->string());
+ }
+ root->add_child("UseISDCFNameByDefault")->add_child_text(_use_isdcf_name_by_default ? "1" : "0");
+ root->add_child("WriteKDMsToDisk")->add_child_text(_write_kdms_to_disk ? "1" : "0");
+ root->add_child("EmailKDMs")->add_child_text(_email_kdms ? "1" : "0");
+
+ auto target = config_write_file();
try {
auto const s = doc.write_to_string_formatted ();
- boost::filesystem::path tmp (string(config_file().string()).append(".tmp"));
+ boost::filesystem::path tmp (string(target.string()).append(".tmp"));
auto f = fopen_boost (tmp, "w");
if (!f) {
throw FileError (_("Could not open file for writing"), tmp);
}
checked_fwrite (s.c_str(), s.bytes(), f, tmp);
fclose (f);
- boost::filesystem::remove (config_file());
- boost::filesystem::rename (tmp, config_file());
+ boost::filesystem::remove (target);
+ boost::filesystem::rename (tmp, target);
} catch (xmlpp::exception& e) {
string s = e.what ();
trim (s);
- throw FileError (s, config_file());
+ throw FileError (s, target);
}
}
}
}
+
bool
Config::have_existing (string file)
{
- return boost::filesystem::exists (path (file, false));
+ return boost::filesystem::exists (read_path(file));
}
+
void
Config::read_cinemas (cxml::Document const & f)
{
}
}
-void
-Config::set_dkdm_recipients_file (boost::filesystem::path file)
-{
- if (file == _dkdm_recipients_file) {
- return;
- }
-
- _dkdm_recipients_file = file;
-
- if (boost::filesystem::exists (_dkdm_recipients_file)) {
- /* Existing file; read it in */
- cxml::Document f ("DKDMRecipients");
- f.read_file (_dkdm_recipients_file);
- read_dkdm_recipients (f);
- }
-
- changed (OTHER);
-}
-
void
Config::save_template (shared_ptr<const Film> film, string name) const
{
- film->write_template (template_path (name));
+ film->write_template (template_write_path(name));
}
+
list<string>
Config::templates () const
{
- if (!boost::filesystem::exists (path ("templates"))) {
+ if (!boost::filesystem::exists(read_path("templates"))) {
return {};
}
list<string> n;
- for (auto const& i: boost::filesystem::directory_iterator(path("templates"))) {
+ for (auto const& i: boost::filesystem::directory_iterator(read_path("templates"))) {
n.push_back (i.path().filename().string());
}
return n;
bool
Config::existing_template (string name) const
{
- return boost::filesystem::exists (template_path (name));
+ return boost::filesystem::exists (template_read_path(name));
}
+
boost::filesystem::path
-Config::template_path (string name) const
+Config::template_read_path (string name) const
{
- return path("templates") / tidy_for_filename (name);
+ return read_path("templates") / tidy_for_filename (name);
}
+
+boost::filesystem::path
+Config::template_write_path (string name) const
+{
+ return write_path("templates") / tidy_for_filename (name);
+}
+
+
void
Config::rename_template (string old_name, string new_name) const
{
- boost::filesystem::rename (template_path (old_name), template_path (new_name));
+ boost::filesystem::rename (template_read_path(old_name), template_write_path(new_name));
}
void
Config::delete_template (string name) const
{
- boost::filesystem::remove (template_path (name));
+ boost::filesystem::remove (template_write_path(name));
}
/** @return Path to the config.xml containing the actual settings, following a link if required */
boost::filesystem::path
-Config::config_file ()
+config_file (boost::filesystem::path main)
{
cxml::Document f ("Config");
- auto main = path("config.xml", false);
if (!boost::filesystem::exists (main)) {
/* It doesn't exist, so there can't be any links; just return it */
return main;
return main;
}
+
+boost::filesystem::path
+Config::config_read_file ()
+{
+ return config_file (read_path("config.xml"));
+}
+
+
+boost::filesystem::path
+Config::config_write_file ()
+{
+ return config_file (write_path("config.xml"));
+}
+
+
void
Config::reset_cover_sheet ()
{
xmlpp::Document doc;
doc.create_root_node("Config")->add_child("Link")->add_child_text(new_file.string());
try {
- doc.write_to_file_formatted(path("config.xml", true).string());
+ doc.write_to_file_formatted(write_path("config.xml").string());
} catch (xmlpp::exception& e) {
string s = e.what ();
trim (s);
- throw FileError (s, path("config.xml"));
+ throw FileError (s, write_path("config.xml"));
}
}
Config::copy_and_link (boost::filesystem::path new_file) const
{
write ();
- boost::filesystem::copy_file (config_file(), new_file, boost::filesystem::copy_option::overwrite_if_exists);
+ boost::filesystem::copy_file (config_read_file(), new_file, boost::filesystem::copy_option::overwrite_if_exists);
link (new_file);
}
bool
Config::have_write_permission () const
{
- auto f = fopen_boost (config_file(), "r+");
+ auto f = fopen_boost (config_write_file(), "r+");
if (!f) {
return false;
}
_audio_mapping = audio_mapping (ch);
changed (AUDIO_MAPPING);
}
+
+
+void
+Config::add_custom_language (dcp::LanguageTag tag)
+{
+ if (find(_custom_languages.begin(), _custom_languages.end(), tag) == _custom_languages.end()) {
+ _custom_languages.push_back (tag);
+ changed ();
+ }
+}
+
+
+optional<Config::BadReason>
+Config::check_certificates () const
+{
+ optional<BadReason> bad;
+
+ for (auto const& i: _signer_chain->unordered()) {
+ if (i.has_utf8_strings()) {
+ bad = BAD_SIGNER_UTF8_STRINGS;
+ }
+ if ((i.not_after().year() - i.not_before().year()) > 15) {
+ bad = BAD_SIGNER_VALIDITY_TOO_LONG;
+ }
+ }
+
+ if (!_signer_chain->chain_valid() || !_signer_chain->private_key_valid()) {
+ bad = BAD_SIGNER_INCONSISTENT;
+ }
+
+ if (!_decryption_chain->chain_valid() || !_decryption_chain->private_key_valid()) {
+ bad = BAD_DECRYPTION_INCONSISTENT;
+ }
+
+ return bad;
+}
+
+
+void
+save_all_config_as_zip (boost::filesystem::path zip_file)
+{
+ Zipper zipper (zip_file);
+
+ auto config = Config::instance();
+ zipper.add ("config.xml", dcp::file_to_string(config->config_read_file()));
+ if (boost::filesystem::exists(config->cinemas_file())) {
+ zipper.add ("cinemas.xml", dcp::file_to_string(config->cinemas_file()));
+ }
+ if (boost::filesystem::exists(config->dkdm_recipients_file())) {
+ zipper.add ("dkdm_recipients.xml", dcp::file_to_string(config->dkdm_recipients_file()));
+ }
+
+ zipper.close ();
+}
+