src/lib/config.cc

   1 /*
   2     Copyright (C) 2012-2022 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "cinema.h"
  23 #include "colour_conversion.h"
  24 #include "compose.hpp"
  25 #include "config.h"
  26 #include "constants.h"
  27 #include "cross.h"
  28 #include "dcp_content_type.h"
  29 #include "dkdm_recipient.h"
  30 #include "dkdm_wrapper.h"
  31 #include "film.h"
  32 #include "filter.h"
  33 #include "log.h"
  34 #include "ratio.h"
  35 #include "zipper.h"
  36 #include <dcp/certificate_chain.h>
  37 #include <dcp/name_format.h>
  38 #include <dcp/raw_convert.h>
  39 #include <libcxml/cxml.h>
  40 #include <glib.h>
  41 #include <libxml++/libxml++.h>
  42 #include <boost/filesystem.hpp>
  43 #include <boost/algorithm/string.hpp>
  44 #include <boost/thread.hpp>
  45 #include <cstdlib>
  46 #include <fstream>
  47 #include <iostream>
  48
  49 #include "i18n.h"
  50
  51
  52 using std::cout;
  53 using std::dynamic_pointer_cast;
  54 using std::ifstream;
  55 using std::list;
  56 using std::make_shared;
  57 using std::max;
  58 using std::min;
  59 using std::remove;
  60 using std::shared_ptr;
  61 using std::string;
  62 using std::vector;
  63 using boost::algorithm::trim;
  64 using boost::optional;
  65 using dcp::raw_convert;
  66
  67
  68 Config* Config::_instance = 0;
  69 int const Config::_current_version = 3;
  70 boost::signals2::signal<void (Config::LoadFailure)> Config::FailedToLoad;
  71 boost::signals2::signal<void (string)> Config::Warning;
  72 boost::signals2::signal<bool (Config::BadReason)> Config::Bad;
  73
  74
  75 /** Construct default configuration */
  76 Config::Config ()
  77         /* DKDMs are not considered a thing to reset on set_defaults() */
  78         : _dkdms (new DKDMGroup ("root"))
  79         , _default_kdm_duration (1, RoughDuration::Unit::WEEKS)
  80         , _export(this)
  81 {
  82         set_defaults ();
  83 }
  84
  85 void
  86 Config::set_defaults ()
  87 {
  88         _master_encoding_threads = max (2U, boost::thread::hardware_concurrency ());
  89         _server_encoding_threads = max (2U, boost::thread::hardware_concurrency ());
  90         _server_port_base = 6192;
  91         _use_any_servers = true;
  92         _servers.clear ();
  93         _only_servers_encode = false;
  94         _tms_protocol = FileTransferProtocol::SCP;
  95         _tms_passive = true;
  96         _tms_ip = "";
  97         _tms_path = ".";
  98         _tms_user = "";
  99         _tms_password = "";
 100         _allow_any_dcp_frame_rate = false;
 101         _allow_any_container = false;
 102         _allow_96khz_audio = false;
 103         _use_all_audio_channels = false;
 104         _show_experimental_audio_processors = false;
 105         _language = optional<string> ();
 106         _default_still_length = 10;
 107         _default_dcp_content_type = DCPContentType::from_isdcf_name ("FTR");
 108         _default_dcp_audio_channels = 8;
 109         _default_j2k_bandwidth = 150000000;
 110         _default_audio_delay = 0;
 111         _default_interop = false;
 112         _default_metadata.clear ();
 113         _upload_after_make_dcp = false;
 114         _mail_server = "";
 115         _mail_port = 25;
 116         _mail_protocol = EmailProtocol::AUTO;
 117         _mail_user = "";
 118         _mail_password = "";
 119         _kdm_from = "";
 120         _kdm_cc.clear ();
 121         _kdm_bcc = "";
 122         _notification_from = "";
 123         _notification_to = "";
 124         _notification_cc.clear ();
 125         _notification_bcc = "";
 126         _check_for_updates = false;
 127         _check_for_test_updates = false;
 128         _maximum_j2k_bandwidth = 250000000;
 129         _log_types = LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | LogEntry::TYPE_ERROR | LogEntry::TYPE_DISK;
 130         _analyse_ebur128 = true;
 131         _automatic_audio_analysis = false;
 132 #ifdef DCPOMATIC_WINDOWS
 133         _win32_console = false;
 134 #endif
 135         /* At the moment we don't write these files anywhere new after a version change, so they will be read from
 136          * ~/.config/dcpomatic2 (or equivalent) and written back there.
 137          */
 138         _cinemas_file = read_path ("cinemas.xml");
 139         _dkdm_recipients_file = read_path ("dkdm_recipients.xml");
 140         _show_hints_before_make_dcp = true;
 141         _confirm_kdm_email = true;
 142         _kdm_container_name_format = dcp::NameFormat("KDM_%f_%c");
 143         _kdm_filename_format = dcp::NameFormat("KDM_%f_%c_%s");
 144         _dkdm_filename_format = dcp::NameFormat("DKDM_%f_%c_%s");
 145         _dcp_metadata_filename_format = dcp::NameFormat ("%t");
 146         _dcp_asset_filename_format = dcp::NameFormat ("%t");
 147         _jump_to_selected = true;
 148         for (int i = 0; i < NAG_COUNT; ++i) {
 149                 _nagged[i] = false;
 150         }
 151         _sound = true;
 152         _sound_output = optional<string> ();
 153         _last_kdm_write_type = KDM_WRITE_FLAT;
 154         _last_dkdm_write_type = DKDM_WRITE_INTERNAL;
 155         _default_add_file_location = DefaultAddFileLocation::SAME_AS_LAST_TIME;
 156
 157         /* I think the scaling factor here should be the ratio of the longest frame
 158            encode time to the shortest; if the thread count is T, longest time is L
 159            and the shortest time S we could encode L/S frames per thread whilst waiting
 160            for the L frame to encode so we might have to store LT/S frames.
 161
 162            However we don't want to use too much memory, so keep it a bit lower than we'd
 163            perhaps like.  A J2K frame is typically about 1Mb so 3 here will mean we could
 164            use about 240Mb with 72 encoding threads.
 165         */
 166         _frames_in_memory_multiplier = 3;
 167         _decode_reduction = optional<int>();
 168         _default_notify = false;
 169         for (int i = 0; i < NOTIFICATION_COUNT; ++i) {
 170                 _notification[i] = false;
 171         }
 172         _barco_username = optional<string>();
 173         _barco_password = optional<string>();
 174         _christie_username = optional<string>();
 175         _christie_password = optional<string>();
 176         _gdc_username = optional<string>();
 177         _gdc_password = optional<string>();
 178         _player_mode = PLAYER_MODE_WINDOW;
 179         _image_display = 0;
 180         _video_view_type = VIDEO_VIEW_SIMPLE;
 181         _respect_kdm_validity_periods = true;
 182         _player_debug_log_file = boost::none;
 183         _player_content_directory = boost::none;
 184         _player_playlist_directory = boost::none;
 185         _player_kdm_directory = boost::none;
 186         _audio_mapping = boost::none;
 187         _custom_languages.clear ();
 188         _initial_paths.clear();
 189         _initial_paths["AddFilesPath"] = boost::none;
 190         _initial_paths["AddKDMPath"] = boost::none;
 191         _initial_paths["AddDKDMPath"] = boost::none;
 192         _initial_paths["SelectCertificatePath"] = boost::none;
 193         _initial_paths["AddCombinerInputPath"] = boost::none;
 194         _use_isdcf_name_by_default = true;
 195         _write_kdms_to_disk = true;
 196         _email_kdms = false;
 197         _default_kdm_type = dcp::Formulation::MODIFIED_TRANSITIONAL_1;
 198         _default_kdm_duration = RoughDuration(1, RoughDuration::Unit::WEEKS);
 199         _auto_crop_threshold = 0.1;
 200         _last_release_notes_version = boost::none;
 201         _allow_smpte_bv20 = false;
 202         _isdcf_name_part_length = 14;
 203
 204         _allowed_dcp_frame_rates.clear ();
 205         _allowed_dcp_frame_rates.push_back (24);
 206         _allowed_dcp_frame_rates.push_back (25);
 207         _allowed_dcp_frame_rates.push_back (30);
 208         _allowed_dcp_frame_rates.push_back (48);
 209         _allowed_dcp_frame_rates.push_back (50);
 210         _allowed_dcp_frame_rates.push_back (60);
 211
 212         set_kdm_email_to_default ();
 213         set_notification_email_to_default ();
 214         set_cover_sheet_to_default ();
 215
 216         _main_divider_sash_position = {};
 217         _main_content_divider_sash_position = {};
 218
 219         _export.set_defaults();
 220 }
 221
 222 void
 223 Config::restore_defaults ()
 224 {
 225         Config::instance()->set_defaults ();
 226         Config::instance()->changed ();
 227 }
 228
 229 shared_ptr<dcp::CertificateChain>
 230 Config::create_certificate_chain ()
 231 {
 232         return make_shared<dcp::CertificateChain> (
 233                 openssl_path(),
 234                 CERTIFICATE_VALIDITY_PERIOD,
 235                 "dcpomatic.com",
 236                 "dcpomatic.com",
 237                 ".dcpomatic.smpte-430-2.ROOT",
 238                 ".dcpomatic.smpte-430-2.INTERMEDIATE",
 239                 "CS.dcpomatic.smpte-430-2.LEAF"
 240                 );
 241 }
 242
 243 void
 244 Config::backup ()
 245 {
 246         using namespace boost::filesystem;
 247
 248         auto copy_adding_number = [](path const& path_to_copy) {
 249
 250                 auto add_number = [](path const& path, int number) {
 251                         return String::compose("%1.%2", path, number);
 252                 };
 253
 254                 int n = 1;
 255                 while (n < 100 && exists(add_number(path_to_copy, n))) {
 256                         ++n;
 257                 }
 258                 boost::system::error_code ec;
 259                 copy_file(path_to_copy, add_number(path_to_copy, n), ec);
 260         };
 261
 262         /* Make a backup copy of any config.xml, cinemas.xml, dkdm_recipients.xml that we might be about
 263          * to write over.  This is more intended for the situation where we have a corrupted config.xml,
 264          * and decide to overwrite it with a new one (possibly losing important details in the corrupted
 265          * file).  But we might as well back up the other files while we're about it.
 266          */
 267
 268         /* This uses the State::write_path stuff so, e.g. for a current version 2.16 we might copy
 269          * ~/.config/dcpomatic2/2.16/config.xml to ~/.config/dcpomatic2/2.16/config.xml.1
 270          */
 271         copy_adding_number (config_write_file());
 272
 273         /* These do not use State::write_path, so whatever path is in the Config we will copy
 274          * adding a number.
 275          */
 276         copy_adding_number (_cinemas_file);
 277         copy_adding_number (_dkdm_recipients_file);
 278 }
 279
 280 void
 281 Config::read ()
 282 {
 283         read_config();
 284         read_cinemas();
 285         read_dkdm_recipients();
 286 }
 287
 288
 289 void
 290 Config::read_config()
 291 try
 292 {
 293         cxml::Document f ("Config");
 294         f.read_file(dcp::filesystem::fix_long_path(config_read_file()));
 295
 296         auto version = f.optional_number_child<int> ("Version");
 297         if (version && *version < _current_version) {
 298                 /* Back up the old config before we re-write it in a back-incompatible way */
 299                 backup ();
 300         }
 301
 302         if (f.optional_number_child<int>("NumLocalEncodingThreads")) {
 303                 _master_encoding_threads = _server_encoding_threads = f.optional_number_child<int>("NumLocalEncodingThreads").get();
 304         } else {
 305                 _master_encoding_threads = f.number_child<int>("MasterEncodingThreads");
 306                 _server_encoding_threads = f.number_child<int>("ServerEncodingThreads");
 307         }
 308
 309         _default_directory = f.optional_string_child ("DefaultDirectory");
 310         if (_default_directory && _default_directory->empty ()) {
 311                 /* We used to store an empty value for this to mean "none set" */
 312                 _default_directory = boost::optional<boost::filesystem::path> ();
 313         }
 314
 315         auto b = f.optional_number_child<int> ("ServerPort");
 316         if (!b) {
 317                 b = f.optional_number_child<int> ("ServerPortBase");
 318         }
 319         _server_port_base = b.get ();
 320
 321         auto u = f.optional_bool_child ("UseAnyServers");
 322         _use_any_servers = u.get_value_or (true);
 323
 324         for (auto i: f.node_children("Server")) {
 325                 if (i->node_children("HostName").size() == 1) {
 326                         _servers.push_back (i->string_child ("HostName"));
 327                 } else {
 328                         _servers.push_back (i->content ());
 329                 }
 330         }
 331
 332         _only_servers_encode = f.optional_bool_child ("OnlyServersEncode").get_value_or (false);
 333         _tms_protocol = static_cast<FileTransferProtocol>(f.optional_number_child<int>("TMSProtocol").get_value_or(static_cast<int>(FileTransferProtocol::SCP)));
 334         _tms_passive = f.optional_bool_child("TMSPassive").get_value_or(true);
 335         _tms_ip = f.string_child ("TMSIP");
 336         _tms_path = f.string_child ("TMSPath");
 337         _tms_user = f.string_child ("TMSUser");
 338         _tms_password = f.string_child ("TMSPassword");
 339
 340         _language = f.optional_string_child ("Language");
 341
 342         _default_dcp_content_type = DCPContentType::from_isdcf_name(f.optional_string_child("DefaultDCPContentType").get_value_or("FTR"));
 343         _default_dcp_audio_channels = f.optional_number_child<int>("DefaultDCPAudioChannels").get_value_or (6);
 344
 345         if (f.optional_string_child ("DCPMetadataIssuer")) {
 346                 _dcp_issuer = f.string_child ("DCPMetadataIssuer");
 347         } else if (f.optional_string_child ("DCPIssuer")) {
 348                 _dcp_issuer = f.string_child ("DCPIssuer");
 349         }
 350
 351         auto up = f.optional_bool_child("UploadAfterMakeDCP");
 352         if (!up) {
 353                 up = f.optional_bool_child("DefaultUploadAfterMakeDCP");
 354         }
 355         _upload_after_make_dcp = up.get_value_or (false);
 356         _dcp_creator = f.optional_string_child ("DCPCreator").get_value_or ("");
 357         _dcp_company_name = f.optional_string_child("DCPCompanyName").get_value_or("");
 358         _dcp_product_name = f.optional_string_child("DCPProductName").get_value_or("");
 359         _dcp_product_version = f.optional_string_child("DCPProductVersion").get_value_or("");
 360         _dcp_j2k_comment = f.optional_string_child("DCPJ2KComment").get_value_or("");
 361
 362         _default_still_length = f.optional_number_child<int>("DefaultStillLength").get_value_or (10);
 363         _default_j2k_bandwidth = f.optional_number_child<int>("DefaultJ2KBandwidth").get_value_or (200000000);
 364         _default_audio_delay = f.optional_number_child<int>("DefaultAudioDelay").get_value_or (0);
 365         _default_interop = f.optional_bool_child("DefaultInterop").get_value_or (false);
 366
 367         try {
 368                 auto al = f.optional_string_child("DefaultAudioLanguage");
 369                 if (al) {
 370                         _default_audio_language = dcp::LanguageTag(*al);
 371                 }
 372         } catch (std::runtime_error&) {}
 373
 374         try {
 375                 auto te = f.optional_string_child("DefaultTerritory");
 376                 if (te) {
 377                         _default_territory = dcp::LanguageTag::RegionSubtag(*te);
 378                 }
 379         } catch (std::runtime_error&) {}
 380
 381         for (auto const& i: f.node_children("DefaultMetadata")) {
 382                 _default_metadata[i->string_attribute("key")] = i->content();
 383         }
 384
 385         _default_kdm_directory = f.optional_string_child("DefaultKDMDirectory");
 386
 387         /* Read any cinemas that are still lying around in the config file
 388          * from an old version.
 389          */
 390         read_cinemas (f);
 391
 392         _mail_server = f.string_child ("MailServer");
 393         _mail_port = f.optional_number_child<int> ("MailPort").get_value_or (25);
 394
 395         {
 396                 /* Make sure this matches the code in write_config */
 397                 string const protocol = f.optional_string_child("MailProtocol").get_value_or("Auto");
 398                 if (protocol == "Auto") {
 399                         _mail_protocol = EmailProtocol::AUTO;
 400                 } else if (protocol == "Plain") {
 401                         _mail_protocol = EmailProtocol::PLAIN;
 402                 } else if (protocol == "STARTTLS") {
 403                         _mail_protocol = EmailProtocol::STARTTLS;
 404                 } else if (protocol == "SSL") {
 405                         _mail_protocol = EmailProtocol::SSL;
 406                 }
 407         }
 408
 409         _mail_user = f.optional_string_child("MailUser").get_value_or ("");
 410         _mail_password = f.optional_string_child("MailPassword").get_value_or ("");
 411
 412         _kdm_subject = f.optional_string_child ("KDMSubject").get_value_or (_("KDM delivery: $CPL_NAME"));
 413         _kdm_from = f.string_child ("KDMFrom");
 414         for (auto i: f.node_children("KDMCC")) {
 415                 if (!i->content().empty()) {
 416                         _kdm_cc.push_back (i->content ());
 417                 }
 418         }
 419         _kdm_bcc = f.optional_string_child ("KDMBCC").get_value_or ("");
 420         _kdm_email = f.string_child ("KDMEmail");
 421
 422         _notification_subject = f.optional_string_child("NotificationSubject").get_value_or(_("DCP-o-matic notification"));
 423         _notification_from = f.optional_string_child("NotificationFrom").get_value_or("");
 424         _notification_to = f.optional_string_child("NotificationTo").get_value_or("");
 425         for (auto i: f.node_children("NotificationCC")) {
 426                 if (!i->content().empty()) {
 427                         _notification_cc.push_back (i->content ());
 428                 }
 429         }
 430         _notification_bcc = f.optional_string_child("NotificationBCC").get_value_or("");
 431         if (f.optional_string_child("NotificationEmail")) {
 432                 _notification_email = f.string_child("NotificationEmail");
 433         }
 434
 435         _check_for_updates = f.optional_bool_child("CheckForUpdates").get_value_or (false);
 436         _check_for_test_updates = f.optional_bool_child("CheckForTestUpdates").get_value_or (false);
 437
 438         _maximum_j2k_bandwidth = f.optional_number_child<int> ("MaximumJ2KBandwidth").get_value_or (250000000);
 439         _allow_any_dcp_frame_rate = f.optional_bool_child ("AllowAnyDCPFrameRate").get_value_or (false);
 440         _allow_any_container = f.optional_bool_child ("AllowAnyContainer").get_value_or (false);
 441         _allow_96khz_audio = f.optional_bool_child("Allow96kHzAudio").get_value_or(false);
 442         _use_all_audio_channels = f.optional_bool_child("UseAllAudioChannels").get_value_or(false);
 443         _show_experimental_audio_processors = f.optional_bool_child ("ShowExperimentalAudioProcessors").get_value_or (false);
 444
 445         _log_types = f.optional_number_child<int> ("LogTypes").get_value_or (LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | LogEntry::TYPE_ERROR);
 446         _analyse_ebur128 = f.optional_bool_child("AnalyseEBUR128").get_value_or (true);
 447         _automatic_audio_analysis = f.optional_bool_child ("AutomaticAudioAnalysis").get_value_or (false);
 448 #ifdef DCPOMATIC_WINDOWS
 449         _win32_console = f.optional_bool_child ("Win32Console").get_value_or (false);
 450 #endif
 451
 452         for (auto i: f.node_children("History")) {
 453                 _history.push_back (i->content ());
 454         }
 455
 456         for (auto i: f.node_children("PlayerHistory")) {
 457                 _player_history.push_back (i->content ());
 458         }
 459
 460         auto signer = f.optional_node_child ("Signer");
 461         if (signer) {
 462                 auto c = make_shared<dcp::CertificateChain>();
 463                 /* Read the signing certificates and private key in from the config file */
 464                 for (auto i: signer->node_children ("Certificate")) {
 465                         c->add (dcp::Certificate (i->content ()));
 466                 }
 467                 c->set_key (signer->string_child ("PrivateKey"));
 468                 _signer_chain = c;
 469         } else {
 470                 /* Make a new set of signing certificates and key */
 471                 _signer_chain = create_certificate_chain ();
 472         }
 473
 474         auto decryption = f.optional_node_child ("Decryption");
 475         if (decryption) {
 476                 auto c = make_shared<dcp::CertificateChain>();
 477                 for (auto i: decryption->node_children ("Certificate")) {
 478                         c->add (dcp::Certificate (i->content ()));
 479                 }
 480                 c->set_key (decryption->string_child ("PrivateKey"));
 481                 _decryption_chain = c;
 482         } else {
 483                 _decryption_chain = create_certificate_chain ();
 484         }
 485
 486         /* These must be done before we call Bad as that might set one
 487            of the nags.
 488         */
 489         for (auto i: f.node_children("Nagged")) {
 490                 auto const id = i->number_attribute<int>("Id");
 491                 if (id >= 0 && id < NAG_COUNT) {
 492                         _nagged[id] = raw_convert<int>(i->content());
 493                 }
 494         }
 495
 496         auto bad = check_certificates ();
 497         if (bad) {
 498                 auto const remake = Bad(*bad);
 499                 if (remake && *remake) {
 500                         switch (*bad) {
 501                         case BAD_SIGNER_UTF8_STRINGS:
 502                         case BAD_SIGNER_INCONSISTENT:
 503                         case BAD_SIGNER_VALIDITY_TOO_LONG:
 504                         case BAD_SIGNER_DN_QUALIFIER:
 505                                 _signer_chain = create_certificate_chain ();
 506                                 break;
 507                         case BAD_DECRYPTION_INCONSISTENT:
 508                                 _decryption_chain = create_certificate_chain ();
 509                                 break;
 510                         }
 511                 }
 512         }
 513
 514         if (f.optional_node_child("DKDMGroup")) {
 515                 /* New-style: all DKDMs in a group */
 516                 _dkdms = dynamic_pointer_cast<DKDMGroup> (DKDMBase::read (f.node_child("DKDMGroup")));
 517         } else {
 518                 /* Old-style: one or more DKDM nodes */
 519                 _dkdms = make_shared<DKDMGroup>("root");
 520                 for (auto i: f.node_children("DKDM")) {
 521                         _dkdms->add (DKDMBase::read (i));
 522                 }
 523         }
 524         _cinemas_file = f.optional_string_child("CinemasFile").get_value_or(read_path("cinemas.xml").string());
 525         _dkdm_recipients_file = f.optional_string_child("DKDMRecipientsFile").get_value_or(read_path("dkdm_recipients.xml").string());
 526         _show_hints_before_make_dcp = f.optional_bool_child("ShowHintsBeforeMakeDCP").get_value_or (true);
 527         _confirm_kdm_email = f.optional_bool_child("ConfirmKDMEmail").get_value_or (true);
 528         _kdm_container_name_format = dcp::NameFormat (f.optional_string_child("KDMContainerNameFormat").get_value_or ("KDM %f %c"));
 529         _kdm_filename_format = dcp::NameFormat (f.optional_string_child("KDMFilenameFormat").get_value_or ("KDM %f %c %s"));
 530         _dkdm_filename_format = dcp::NameFormat (f.optional_string_child("DKDMFilenameFormat").get_value_or("DKDM %f %c %s"));
 531         _dcp_metadata_filename_format = dcp::NameFormat (f.optional_string_child("DCPMetadataFilenameFormat").get_value_or ("%t"));
 532         _dcp_asset_filename_format = dcp::NameFormat (f.optional_string_child("DCPAssetFilenameFormat").get_value_or ("%t"));
 533         _jump_to_selected = f.optional_bool_child("JumpToSelected").get_value_or (true);
 534         /* The variable was renamed but not the XML tag */
 535         _sound = f.optional_bool_child("PreviewSound").get_value_or (true);
 536         _sound_output = f.optional_string_child("PreviewSoundOutput");
 537         if (f.optional_string_child("CoverSheet")) {
 538                 _cover_sheet = f.optional_string_child("CoverSheet").get();
 539         }
 540         _last_player_load_directory = f.optional_string_child("LastPlayerLoadDirectory");
 541         if (f.optional_string_child("LastKDMWriteType")) {
 542                 if (f.optional_string_child("LastKDMWriteType").get() == "flat") {
 543                         _last_kdm_write_type = KDM_WRITE_FLAT;
 544                 } else if (f.optional_string_child("LastKDMWriteType").get() == "folder") {
 545                         _last_kdm_write_type = KDM_WRITE_FOLDER;
 546                 } else if (f.optional_string_child("LastKDMWriteType").get() == "zip") {
 547                         _last_kdm_write_type = KDM_WRITE_ZIP;
 548                 }
 549         }
 550         if (f.optional_string_child("LastDKDMWriteType")) {
 551                 if (f.optional_string_child("LastDKDMWriteType").get() == "internal") {
 552                         _last_dkdm_write_type = DKDM_WRITE_INTERNAL;
 553                 } else if (f.optional_string_child("LastDKDMWriteType").get() == "file") {
 554                         _last_dkdm_write_type = DKDM_WRITE_FILE;
 555                 }
 556         }
 557         _frames_in_memory_multiplier = f.optional_number_child<int>("FramesInMemoryMultiplier").get_value_or(3);
 558         _decode_reduction = f.optional_number_child<int>("DecodeReduction");
 559         _default_notify = f.optional_bool_child("DefaultNotify").get_value_or(false);
 560
 561         for (auto i: f.node_children("Notification")) {
 562                 int const id = i->number_attribute<int>("Id");
 563                 if (id >= 0 && id < NOTIFICATION_COUNT) {
 564                         _notification[id] = raw_convert<int>(i->content());
 565                 }
 566         }
 567
 568         _barco_username = f.optional_string_child("BarcoUsername");
 569         _barco_password = f.optional_string_child("BarcoPassword");
 570         _christie_username = f.optional_string_child("ChristieUsername");
 571         _christie_password = f.optional_string_child("ChristiePassword");
 572         _gdc_username = f.optional_string_child("GDCUsername");
 573         _gdc_password = f.optional_string_child("GDCPassword");
 574
 575         auto pm = f.optional_string_child("PlayerMode");
 576         if (pm && *pm == "window") {
 577                 _player_mode = PLAYER_MODE_WINDOW;
 578         } else if (pm && *pm == "full") {
 579                 _player_mode = PLAYER_MODE_FULL;
 580         } else if (pm && *pm == "dual") {
 581                 _player_mode = PLAYER_MODE_DUAL;
 582         }
 583
 584         _image_display = f.optional_number_child<int>("ImageDisplay").get_value_or(0);
 585         auto vc = f.optional_string_child("VideoViewType");
 586         if (vc && *vc == "opengl") {
 587                 _video_view_type = VIDEO_VIEW_OPENGL;
 588         } else if (vc && *vc == "simple") {
 589                 _video_view_type = VIDEO_VIEW_SIMPLE;
 590         }
 591         _respect_kdm_validity_periods = f.optional_bool_child("RespectKDMValidityPeriods").get_value_or(true);
 592         _player_debug_log_file = f.optional_string_child("PlayerDebugLogFile");
 593         _player_content_directory = f.optional_string_child("PlayerContentDirectory");
 594         _player_playlist_directory = f.optional_string_child("PlayerPlaylistDirectory");
 595         _player_kdm_directory = f.optional_string_child("PlayerKDMDirectory");
 596
 597         if (f.optional_node_child("AudioMapping")) {
 598                 _audio_mapping = AudioMapping (f.node_child("AudioMapping"), Film::current_state_version);
 599         }
 600
 601         for (auto i: f.node_children("CustomLanguage")) {
 602                 try {
 603                         /* This will fail if it's called before dcp::init() as it won't recognise the
 604                          * tag.  That's OK because the Config will be reloaded again later.
 605                          */
 606                         _custom_languages.push_back (dcp::LanguageTag(i->content()));
 607                 } catch (std::runtime_error& e) {}
 608         }
 609
 610         for (auto& initial: _initial_paths) {
 611                 initial.second = f.optional_string_child(initial.first);
 612         }
 613         _use_isdcf_name_by_default = f.optional_bool_child("UseISDCFNameByDefault").get_value_or(true);
 614         _write_kdms_to_disk = f.optional_bool_child("WriteKDMsToDisk").get_value_or(true);
 615         _email_kdms = f.optional_bool_child("EmailKDMs").get_value_or(false);
 616         _default_kdm_type = dcp::string_to_formulation(f.optional_string_child("DefaultKDMType").get_value_or("modified-transitional-1"));
 617         if (auto duration = f.optional_node_child("DefaultKDMDuration")) {
 618                 _default_kdm_duration = RoughDuration(duration);
 619         } else {
 620                 _default_kdm_duration = RoughDuration(1, RoughDuration::Unit::WEEKS);
 621         }
 622         _auto_crop_threshold = f.optional_number_child<double>("AutoCropThreshold").get_value_or(0.1);
 623         _last_release_notes_version = f.optional_string_child("LastReleaseNotesVersion");
 624         _main_divider_sash_position = f.optional_number_child<int>("MainDividerSashPosition");
 625         _main_content_divider_sash_position = f.optional_number_child<int>("MainContentDividerSashPosition");
 626
 627         if (auto loc = f.optional_string_child("DefaultAddFileLocation")) {
 628                 if (*loc == "last") {
 629                         _default_add_file_location = DefaultAddFileLocation::SAME_AS_LAST_TIME;
 630                 } else if (*loc == "project") {
 631                         _default_add_file_location = DefaultAddFileLocation::SAME_AS_PROJECT;
 632                 }
 633         }
 634
 635         _allow_smpte_bv20 = f.optional_bool_child("AllowSMPTEBv20").get_value_or(false);
 636         _isdcf_name_part_length = f.optional_number_child<int>("ISDCFNamePartLength").get_value_or(14);
 637
 638         _export.read(f.optional_node_child("Export"));
 639 }
 640 catch (...) {
 641         if (have_existing("config.xml")) {
 642                 backup ();
 643                 /* We have a config file but it didn't load */
 644                 FailedToLoad(LoadFailure::CONFIG);
 645         }
 646         set_defaults ();
 647         /* Make a new set of signing certificates and key */
 648         _signer_chain = create_certificate_chain ();
 649         /* And similar for decryption of KDMs */
 650         _decryption_chain = create_certificate_chain ();
 651         write_config();
 652 }
 653
 654
 655 void
 656 Config::read_cinemas()
 657 {
 658         if (dcp::filesystem::exists(_cinemas_file)) {
 659                 try {
 660                         cxml::Document f("Cinemas");
 661                         f.read_file(dcp::filesystem::fix_long_path(_cinemas_file));
 662                         read_cinemas(f);
 663                 } catch (...) {
 664                         backup();
 665                         FailedToLoad(LoadFailure::CINEMAS);
 666                         write_cinemas();
 667                 }
 668         }
 669 }
 670
 671
 672 void
 673 Config::read_dkdm_recipients()
 674 {
 675         if (dcp::filesystem::exists(_dkdm_recipients_file)) {
 676                 try {
 677                         cxml::Document f("DKDMRecipients");
 678                         f.read_file(dcp::filesystem::fix_long_path(_dkdm_recipients_file));
 679                         read_dkdm_recipients(f);
 680                 } catch (...) {
 681                         backup();
 682                         FailedToLoad(LoadFailure::DKDM_RECIPIENTS);
 683                         write_dkdm_recipients();
 684                 }
 685         }
 686 }
 687
 688
 689 /** @return Singleton instance */
 690 Config *
 691 Config::instance ()
 692 {
 693         if (_instance == nullptr) {
 694                 _instance = new Config;
 695                 _instance->read ();
 696         }
 697
 698         return _instance;
 699 }
 700
 701 /** Write our configuration to disk */
 702 void
 703 Config::write () const
 704 {
 705         write_config ();
 706         write_cinemas ();
 707         write_dkdm_recipients ();
 708 }
 709
 710 void
 711 Config::write_config () const
 712 {
 713         xmlpp::Document doc;
 714         auto root = doc.create_root_node ("Config");
 715
 716         /* [XML] Version The version number of the configuration file format. */
 717         root->add_child("Version")->add_child_text (raw_convert<string>(_current_version));
 718         /* [XML] MasterEncodingThreads Number of encoding threads to use when running as master. */
 719         root->add_child("MasterEncodingThreads")->add_child_text (raw_convert<string> (_master_encoding_threads));
 720         /* [XML] ServerEncodingThreads Number of encoding threads to use when running as server. */
 721         root->add_child("ServerEncodingThreads")->add_child_text (raw_convert<string> (_server_encoding_threads));
 722         if (_default_directory) {
 723                 /* [XML:opt] DefaultDirectory Default directory when creating a new film in the GUI. */
 724                 root->add_child("DefaultDirectory")->add_child_text (_default_directory->string ());
 725         }
 726         /* [XML] ServerPortBase Port number to use for frame encoding requests.  <code>ServerPortBase</code> + 1 and
 727            <code>ServerPortBase</code> + 2 are used for querying servers.  <code>ServerPortBase</code> + 3 is used
 728            by the batch converter to listen for job requests.
 729         */
 730         root->add_child("ServerPortBase")->add_child_text (raw_convert<string> (_server_port_base));
 731         /* [XML] UseAnyServers 1 to broadcast to look for encoding servers to use, 0 to use only those configured. */
 732         root->add_child("UseAnyServers")->add_child_text (_use_any_servers ? "1" : "0");
 733
 734         for (auto i: _servers) {
 735                 /* [XML:opt] Server IP address or hostname of an encoding server to use; you can use as many of these tags
 736                    as you like.
 737                 */
 738                 root->add_child("Server")->add_child_text (i);
 739         }
 740
 741         /* [XML] OnlyServersEncode 1 to set the master to do decoding of source content no JPEG2000 encoding; all encoding
 742            is done by the encoding servers.  0 to set the master to do some encoding as well as coordinating the job.
 743         */
 744         root->add_child("OnlyServersEncode")->add_child_text (_only_servers_encode ? "1" : "0");
 745         /* [XML] TMSProtocol Protocol to use to copy files to a TMS; 0 to use SCP, 1 for FTP. */
 746         root->add_child("TMSProtocol")->add_child_text (raw_convert<string> (static_cast<int> (_tms_protocol)));
 747         /* [XML] TMSPassive True to use PASV mode with TMS FTP connections. */
 748         root->add_child("TMSPassive")->add_child_text(_tms_passive ? "1" : "0");
 749         /* [XML] TMSIP IP address of TMS. */
 750         root->add_child("TMSIP")->add_child_text (_tms_ip);
 751         /* [XML] TMSPath Path on the TMS to copy files to. */
 752         root->add_child("TMSPath")->add_child_text (_tms_path);
 753         /* [XML] TMSUser Username to log into the TMS with. */
 754         root->add_child("TMSUser")->add_child_text (_tms_user);
 755         /* [XML] TMSPassword Password to log into the TMS with. */
 756         root->add_child("TMSPassword")->add_child_text (_tms_password);
 757         if (_language) {
 758                 /* [XML:opt] Language Language to use in the GUI e.g. <code>fr_FR</code>. */
 759                 root->add_child("Language")->add_child_text (_language.get());
 760         }
 761         if (_default_dcp_content_type) {
 762                 /* [XML:opt] DefaultDCPContentType Default content type to use when creating new films (<code>FTR</code>, <code>SHR</code>,
 763                    <code>TLR</code>, <code>TST</code>, <code>XSN</code>, <code>RTG</code>, <code>TSR</code>, <code>POL</code>,
 764                    <code>PSA</code> or <code>ADV</code>). */
 765                 root->add_child("DefaultDCPContentType")->add_child_text (_default_dcp_content_type->isdcf_name ());
 766         }
 767         /* [XML] DefaultDCPAudioChannels Default number of audio channels to use when creating new films. */
 768         root->add_child("DefaultDCPAudioChannels")->add_child_text (raw_convert<string> (_default_dcp_audio_channels));
 769         /* [XML] DCPIssuer Issuer text to write into CPL files. */
 770         root->add_child("DCPIssuer")->add_child_text (_dcp_issuer);
 771         /* [XML] DCPCreator Creator text to write into CPL files. */
 772         root->add_child("DCPCreator")->add_child_text (_dcp_creator);
 773         /* [XML] Company name to write into MXF files. */
 774         root->add_child("DCPCompanyName")->add_child_text (_dcp_company_name);
 775         /* [XML] Product name to write into MXF files. */
 776         root->add_child("DCPProductName")->add_child_text (_dcp_product_name);
 777         /* [XML] Product version to write into MXF files. */
 778         root->add_child("DCPProductVersion")->add_child_text (_dcp_product_version);
 779         /* [XML] Comment to write into JPEG2000 data. */
 780         root->add_child("DCPJ2KComment")->add_child_text (_dcp_j2k_comment);
 781         /* [XML] UploadAfterMakeDCP 1 to upload to a TMS after making a DCP, 0 for no upload. */
 782         root->add_child("UploadAfterMakeDCP")->add_child_text (_upload_after_make_dcp ? "1" : "0");
 783
 784         /* [XML] DefaultStillLength Default length (in seconds) for still images in new films. */
 785         root->add_child("DefaultStillLength")->add_child_text (raw_convert<string> (_default_still_length));
 786         /* [XML] DefaultJ2KBandwidth Default bitrate (in bits per second) for JPEG2000 data in new films. */
 787         root->add_child("DefaultJ2KBandwidth")->add_child_text (raw_convert<string> (_default_j2k_bandwidth));
 788         /* [XML] DefaultAudioDelay Default delay to apply to audio (positive moves audio later) in milliseconds. */
 789         root->add_child("DefaultAudioDelay")->add_child_text (raw_convert<string> (_default_audio_delay));
 790         /* [XML] DefaultInterop 1 to default new films to Interop, 0 for SMPTE. */
 791         root->add_child("DefaultInterop")->add_child_text (_default_interop ? "1" : "0");
 792         if (_default_audio_language) {
 793                 /* [XML] DefaultAudioLanguage Default audio language to use for new films */
 794                 root->add_child("DefaultAudioLanguage")->add_child_text(_default_audio_language->to_string());
 795         }
 796         if (_default_territory) {
 797                 /* [XML] DefaultTerritory Default territory to use for new films */
 798                 root->add_child("DefaultTerritory")->add_child_text(_default_territory->subtag());
 799         }
 800         for (auto const& i: _default_metadata) {
 801                 auto c = root->add_child("DefaultMetadata");
 802                 c->set_attribute("key", i.first);
 803                 c->add_child_text(i.second);
 804         }
 805         if (_default_kdm_directory) {
 806                 /* [XML:opt] DefaultKDMDirectory Default directory to write KDMs to. */
 807                 root->add_child("DefaultKDMDirectory")->add_child_text (_default_kdm_directory->string ());
 808         }
 809         _default_kdm_duration.as_xml(root->add_child("DefaultKDMDuration"));
 810         /* [XML] MailServer Hostname of SMTP server to use. */
 811         root->add_child("MailServer")->add_child_text (_mail_server);
 812         /* [XML] MailPort Port number to use on SMTP server. */
 813         root->add_child("MailPort")->add_child_text (raw_convert<string> (_mail_port));
 814         /* [XML] MailProtocol Protocol to use on SMTP server (Auto, Plain, STARTTLS or SSL) */
 815         switch (_mail_protocol) {
 816         case EmailProtocol::AUTO:
 817                 root->add_child("MailProtocol")->add_child_text("Auto");
 818                 break;
 819         case EmailProtocol::PLAIN:
 820                 root->add_child("MailProtocol")->add_child_text("Plain");
 821                 break;
 822         case EmailProtocol::STARTTLS:
 823                 root->add_child("MailProtocol")->add_child_text("STARTTLS");
 824                 break;
 825         case EmailProtocol::SSL:
 826                 root->add_child("MailProtocol")->add_child_text("SSL");
 827                 break;
 828         }
 829         /* [XML] MailUser Username to use on SMTP server. */
 830         root->add_child("MailUser")->add_child_text (_mail_user);
 831         /* [XML] MailPassword Password to use on SMTP server. */
 832         root->add_child("MailPassword")->add_child_text (_mail_password);
 833
 834         /* [XML] KDMSubject Subject to use for KDM emails. */
 835         root->add_child("KDMSubject")->add_child_text (_kdm_subject);
 836         /* [XML] KDMFrom From address to use for KDM emails. */
 837         root->add_child("KDMFrom")->add_child_text (_kdm_from);
 838         for (auto i: _kdm_cc) {
 839                 /* [XML] KDMCC CC address to use for KDM emails; you can use as many of these tags as you like. */
 840                 root->add_child("KDMCC")->add_child_text (i);
 841         }
 842         /* [XML] KDMBCC BCC address to use for KDM emails. */
 843         root->add_child("KDMBCC")->add_child_text (_kdm_bcc);
 844         /* [XML] KDMEmail Text of KDM email. */
 845         root->add_child("KDMEmail")->add_child_text (_kdm_email);
 846
 847         /* [XML] NotificationSubject Subject to use for notification emails. */
 848         root->add_child("NotificationSubject")->add_child_text (_notification_subject);
 849         /* [XML] NotificationFrom From address to use for notification emails. */
 850         root->add_child("NotificationFrom")->add_child_text (_notification_from);
 851         /* [XML] NotificationFrom To address to use for notification emails. */
 852         root->add_child("NotificationTo")->add_child_text (_notification_to);
 853         for (auto i: _notification_cc) {
 854                 /* [XML] NotificationCC CC address to use for notification emails; you can use as many of these tags as you like. */
 855                 root->add_child("NotificationCC")->add_child_text (i);
 856         }
 857         /* [XML] NotificationBCC BCC address to use for notification emails. */
 858         root->add_child("NotificationBCC")->add_child_text (_notification_bcc);
 859         /* [XML] NotificationEmail Text of notification email. */
 860         root->add_child("NotificationEmail")->add_child_text (_notification_email);
 861
 862         /* [XML] CheckForUpdates 1 to check dcpomatic.com for new versions, 0 to check only on request. */
 863         root->add_child("CheckForUpdates")->add_child_text (_check_for_updates ? "1" : "0");
 864         /* [XML] CheckForUpdates 1 to check dcpomatic.com for new text versions, 0 to check only on request. */
 865         root->add_child("CheckForTestUpdates")->add_child_text (_check_for_test_updates ? "1" : "0");
 866
 867         /* [XML] MaximumJ2KBandwidth Maximum J2K bandwidth (in bits per second) that can be specified in the GUI. */
 868         root->add_child("MaximumJ2KBandwidth")->add_child_text (raw_convert<string> (_maximum_j2k_bandwidth));
 869         /* [XML] AllowAnyDCPFrameRate 1 to allow users to specify any frame rate when creating DCPs, 0 to limit the GUI to standard rates. */
 870         root->add_child("AllowAnyDCPFrameRate")->add_child_text (_allow_any_dcp_frame_rate ? "1" : "0");
 871         /* [XML] AllowAnyContainer 1 to allow users to user any container ratio for their DCP, 0 to limit the GUI to DCI Flat/Scope */
 872         root->add_child("AllowAnyContainer")->add_child_text (_allow_any_container ? "1" : "0");
 873         /* [XML] Allow96kHzAudio 1 to allow users to make DCPs with 96kHz audio, 0 to always make 48kHz DCPs */
 874         root->add_child("Allow96kHzAudio")->add_child_text(_allow_96khz_audio ? "1" : "0");
 875         /* [XML] UseAllAudioChannels 1 to allow users to map audio to all 16 DCP channels, 0 to limit to the channels used in standard DCPs */
 876         root->add_child("UseAllAudioChannels")->add_child_text(_use_all_audio_channels ? "1" : "0");
 877         /* [XML] ShowExperimentalAudioProcessors 1 to offer users the (experimental) audio upmixer processors, 0 to hide them */
 878         root->add_child("ShowExperimentalAudioProcessors")->add_child_text (_show_experimental_audio_processors ? "1" : "0");
 879         /* [XML] LogTypes Types of logging to write; a bitfield where 1 is general notes, 2 warnings, 4 errors, 8 debug information related
 880            to 3D, 16 debug information related to encoding, 32 debug information for timing purposes, 64 debug information related
 881            to sending email, 128 debug information related to the video view, 256 information about disk writing, 512 debug information
 882            related to the player, 1024 debug information related to audio analyses.
 883         */
 884         root->add_child("LogTypes")->add_child_text (raw_convert<string> (_log_types));
 885         /* [XML] AnalyseEBUR128 1 to do EBUR128 analyses when analysing audio, otherwise 0. */
 886         root->add_child("AnalyseEBUR128")->add_child_text (_analyse_ebur128 ? "1" : "0");
 887         /* [XML] AutomaticAudioAnalysis 1 to run audio analysis automatically when audio content is added to the film, otherwise 0. */
 888         root->add_child("AutomaticAudioAnalysis")->add_child_text (_automatic_audio_analysis ? "1" : "0");
 889 #ifdef DCPOMATIC_WINDOWS
 890         if (_win32_console) {
 891                 /* [XML] Win32Console 1 to open a console when running on Windows, otherwise 0.
 892                  * We only write this if it's true, which is a bit of a hack to allow unit tests to work
 893                  * more easily on Windows (without a platform-specific reference in config_write_utf8_test)
 894                  */
 895                 root->add_child("Win32Console")->add_child_text ("1");
 896         }
 897 #endif
 898
 899         /* [XML] Signer Certificate chain and private key to use when signing DCPs and KDMs.  Should contain <code>&lt;Certificate&gt;</code>
 900            tags in order and a <code>&lt;PrivateKey&gt;</code> tag all containing PEM-encoded certificates or private keys as appropriate.
 901         */
 902         auto signer = root->add_child ("Signer");
 903         DCPOMATIC_ASSERT (_signer_chain);
 904         for (auto const& i: _signer_chain->unordered()) {
 905                 signer->add_child("Certificate")->add_child_text (i.certificate (true));
 906         }
 907         signer->add_child("PrivateKey")->add_child_text (_signer_chain->key().get ());
 908
 909         /* [XML] Decryption Certificate chain and private key to use when decrypting KDMs */
 910         auto decryption = root->add_child ("Decryption");
 911         DCPOMATIC_ASSERT (_decryption_chain);
 912         for (auto const& i: _decryption_chain->unordered()) {
 913                 decryption->add_child("Certificate")->add_child_text (i.certificate (true));
 914         }
 915         decryption->add_child("PrivateKey")->add_child_text (_decryption_chain->key().get ());
 916
 917         /* [XML] History Filename of DCP to present in the <guilabel>File</guilabel> menu of the GUI; there can be more than one
 918            of these tags.
 919         */
 920         for (auto i: _history) {
 921                 root->add_child("History")->add_child_text (i.string ());
 922         }
 923
 924         /* [XML] History Filename of DCP to present in the <guilabel>File</guilabel> menu of the player; there can be more than one
 925            of these tags.
 926         */
 927         for (auto i: _player_history) {
 928                 root->add_child("PlayerHistory")->add_child_text (i.string ());
 929         }
 930
 931         /* [XML] DKDMGroup A group of DKDMs, each with a <code>Name</code> attribute, containing other <code>&lt;DKDMGroup&gt;</code>
 932            or <code>&lt;DKDM&gt;</code> tags.
 933         */
 934         /* [XML] DKDM A DKDM as XML */
 935         _dkdms->as_xml (root);
 936
 937         /* [XML] CinemasFile Filename of cinemas list file. */
 938         root->add_child("CinemasFile")->add_child_text (_cinemas_file.string());
 939         /* [XML] DKDMRecipientsFile Filename of DKDM recipients list file. */
 940         root->add_child("DKDMRecipientsFile")->add_child_text (_dkdm_recipients_file.string());
 941         /* [XML] ShowHintsBeforeMakeDCP 1 to show hints in the GUI before making a DCP, otherwise 0. */
 942         root->add_child("ShowHintsBeforeMakeDCP")->add_child_text (_show_hints_before_make_dcp ? "1" : "0");
 943         /* [XML] ConfirmKDMEmail 1 to confirm before sending KDM emails in the GUI, otherwise 0. */
 944         root->add_child("ConfirmKDMEmail")->add_child_text (_confirm_kdm_email ? "1" : "0");
 945         /* [XML] KDMFilenameFormat Format for KDM filenames. */
 946         root->add_child("KDMFilenameFormat")->add_child_text (_kdm_filename_format.specification ());
 947         /* [XML] KDMFilenameFormat Format for DKDM filenames. */
 948         root->add_child("DKDMFilenameFormat")->add_child_text(_dkdm_filename_format.specification());
 949         /* [XML] KDMContainerNameFormat Format for KDM containers (directories or ZIP files). */
 950         root->add_child("KDMContainerNameFormat")->add_child_text (_kdm_container_name_format.specification ());
 951         /* [XML] DCPMetadataFilenameFormat Format for DCP metadata filenames. */
 952         root->add_child("DCPMetadataFilenameFormat")->add_child_text (_dcp_metadata_filename_format.specification ());
 953         /* [XML] DCPAssetFilenameFormat Format for DCP asset filenames. */
 954         root->add_child("DCPAssetFilenameFormat")->add_child_text (_dcp_asset_filename_format.specification ());
 955         /* [XML] JumpToSelected 1 to make the GUI jump to the start of content when it is selected, otherwise 0. */
 956         root->add_child("JumpToSelected")->add_child_text (_jump_to_selected ? "1" : "0");
 957         /* [XML] Nagged 1 if a particular nag screen has been shown and should not be shown again, otherwise 0. */
 958         for (int i = 0; i < NAG_COUNT; ++i) {
 959                 xmlpp::Element* e = root->add_child ("Nagged");
 960                 e->set_attribute ("Id", raw_convert<string>(i));
 961                 e->add_child_text (_nagged[i] ? "1" : "0");
 962         }
 963         /* [XML] PreviewSound 1 to use sound in the GUI preview and player, otherwise 0. */
 964         root->add_child("PreviewSound")->add_child_text (_sound ? "1" : "0");
 965         if (_sound_output) {
 966                 /* [XML:opt] PreviewSoundOutput Name of the audio output to use. */
 967                 root->add_child("PreviewSoundOutput")->add_child_text (_sound_output.get());
 968         }
 969         /* [XML] CoverSheet Text of the cover sheet to write when making DCPs. */
 970         root->add_child("CoverSheet")->add_child_text (_cover_sheet);
 971         if (_last_player_load_directory) {
 972                 root->add_child("LastPlayerLoadDirectory")->add_child_text(_last_player_load_directory->string());
 973         }
 974         /* [XML] LastKDMWriteType Last type of KDM-write: <code>flat</code> for a flat file, <code>folder</code> for a folder or <code>zip</code> for a ZIP file. */
 975         if (_last_kdm_write_type) {
 976                 switch (_last_kdm_write_type.get()) {
 977                 case KDM_WRITE_FLAT:
 978                         root->add_child("LastKDMWriteType")->add_child_text("flat");
 979                         break;
 980                 case KDM_WRITE_FOLDER:
 981                         root->add_child("LastKDMWriteType")->add_child_text("folder");
 982                         break;
 983                 case KDM_WRITE_ZIP:
 984                         root->add_child("LastKDMWriteType")->add_child_text("zip");
 985                         break;
 986                 }
 987         }
 988         /* [XML] LastDKDMWriteType Last type of DKDM-write: <code>file</code> for a file, <code>internal</code> to add to DCP-o-matic's list. */
 989         if (_last_dkdm_write_type) {
 990                 switch (_last_dkdm_write_type.get()) {
 991                 case DKDM_WRITE_INTERNAL:
 992                         root->add_child("LastDKDMWriteType")->add_child_text("internal");
 993                         break;
 994                 case DKDM_WRITE_FILE:
 995                         root->add_child("LastDKDMWriteType")->add_child_text("file");
 996                         break;
 997                 }
 998         }
 999         /* [XML] FramesInMemoryMultiplier value to multiply the encoding threads count by to get the maximum number of
1000            frames to be held in memory at once.
1001         */
1002         root->add_child("FramesInMemoryMultiplier")->add_child_text(raw_convert<string>(_frames_in_memory_multiplier));
1003
1004         /* [XML] DecodeReduction power of 2 to reduce DCP images by before decoding in the player. */
1005         if (_decode_reduction) {
1006                 root->add_child("DecodeReduction")->add_child_text(raw_convert<string>(_decode_reduction.get()));
1007         }
1008
1009         /* [XML] DefaultNotify 1 to default jobs to notify when complete, otherwise 0. */
1010         root->add_child("DefaultNotify")->add_child_text(_default_notify ? "1" : "0");
1011
1012         /* [XML] Notification 1 if a notification type is enabled, otherwise 0. */
1013         for (int i = 0; i < NOTIFICATION_COUNT; ++i) {
1014                 xmlpp::Element* e = root->add_child ("Notification");
1015                 e->set_attribute ("Id", raw_convert<string>(i));
1016                 e->add_child_text (_notification[i] ? "1" : "0");
1017         }
1018
1019         if (_barco_username) {
1020                 /* [XML] BarcoUsername Username for logging into Barco's servers when downloading server certificates. */
1021                 root->add_child("BarcoUsername")->add_child_text(*_barco_username);
1022         }
1023         if (_barco_password) {
1024                 /* [XML] BarcoPassword Password for logging into Barco's servers when downloading server certificates. */
1025                 root->add_child("BarcoPassword")->add_child_text(*_barco_password);
1026         }
1027
1028         if (_christie_username) {
1029                 /* [XML] ChristieUsername Username for logging into Christie's servers when downloading server certificates. */
1030                 root->add_child("ChristieUsername")->add_child_text(*_christie_username);
1031         }
1032         if (_christie_password) {
1033                 /* [XML] ChristiePassword Password for logging into Christie's servers when downloading server certificates. */
1034                 root->add_child("ChristiePassword")->add_child_text(*_christie_password);
1035         }
1036
1037         if (_gdc_username) {
1038                 /* [XML] GDCUsername Username for logging into GDC's servers when downloading server certificates. */
1039                 root->add_child("GDCUsername")->add_child_text(*_gdc_username);
1040         }
1041         if (_gdc_password) {
1042                 /* [XML] GDCPassword Password for logging into GDC's servers when downloading server certificates. */
1043                 root->add_child("GDCPassword")->add_child_text(*_gdc_password);
1044         }
1045
1046         /* [XML] PlayerMode <code>window</code> for a single window, <code>full</code> for full-screen and <code>dual</code> for full screen playback
1047            with separate (advanced) controls.
1048         */
1049         switch (_player_mode) {
1050         case PLAYER_MODE_WINDOW:
1051                 root->add_child("PlayerMode")->add_child_text("window");
1052                 break;
1053         case PLAYER_MODE_FULL:
1054                 root->add_child("PlayerMode")->add_child_text("full");
1055                 break;
1056         case PLAYER_MODE_DUAL:
1057                 root->add_child("PlayerMode")->add_child_text("dual");
1058                 break;
1059         }
1060
1061         /* [XML] ImageDisplay Screen number to put image on in dual-screen player mode. */
1062         root->add_child("ImageDisplay")->add_child_text(raw_convert<string>(_image_display));
1063         switch (_video_view_type) {
1064         case VIDEO_VIEW_SIMPLE:
1065                 root->add_child("VideoViewType")->add_child_text("simple");
1066                 break;
1067         case VIDEO_VIEW_OPENGL:
1068                 root->add_child("VideoViewType")->add_child_text("opengl");
1069                 break;
1070         }
1071         /* [XML] RespectKDMValidityPeriods 1 to refuse to use KDMs that are out of date, 0 to ignore KDM dates. */
1072         root->add_child("RespectKDMValidityPeriods")->add_child_text(_respect_kdm_validity_periods ? "1" : "0");
1073         if (_player_debug_log_file) {
1074                 /* [XML] PlayerLogFile Filename to use for player debug logs. */
1075                 root->add_child("PlayerDebugLogFile")->add_child_text(_player_debug_log_file->string());
1076         }
1077         if (_player_content_directory) {
1078                 /* [XML] PlayerContentDirectory Directory to use for player content in the dual-screen mode. */
1079                 root->add_child("PlayerContentDirectory")->add_child_text(_player_content_directory->string());
1080         }
1081         if (_player_playlist_directory) {
1082                 /* [XML] PlayerPlaylistDirectory Directory to use for player playlists in the dual-screen mode. */
1083                 root->add_child("PlayerPlaylistDirectory")->add_child_text(_player_playlist_directory->string());
1084         }
1085         if (_player_kdm_directory) {
1086                 /* [XML] PlayerKDMDirectory Directory to use for player KDMs in the dual-screen mode. */
1087                 root->add_child("PlayerKDMDirectory")->add_child_text(_player_kdm_directory->string());
1088         }
1089         if (_audio_mapping) {
1090                 _audio_mapping->as_xml (root->add_child("AudioMapping"));
1091         }
1092         for (auto const& i: _custom_languages) {
1093                 root->add_child("CustomLanguage")->add_child_text(i.to_string());
1094         }
1095         for (auto const& initial: _initial_paths) {
1096                 if (initial.second) {
1097                         root->add_child(initial.first)->add_child_text(initial.second->string());
1098                 }
1099         }
1100         root->add_child("UseISDCFNameByDefault")->add_child_text(_use_isdcf_name_by_default ? "1" : "0");
1101         root->add_child("WriteKDMsToDisk")->add_child_text(_write_kdms_to_disk ? "1" : "0");
1102         root->add_child("EmailKDMs")->add_child_text(_email_kdms ? "1" : "0");
1103         root->add_child("DefaultKDMType")->add_child_text(dcp::formulation_to_string(_default_kdm_type));
1104         root->add_child("AutoCropThreshold")->add_child_text(raw_convert<string>(_auto_crop_threshold));
1105         if (_last_release_notes_version) {
1106                 root->add_child("LastReleaseNotesVersion")->add_child_text(*_last_release_notes_version);
1107         }
1108         if (_main_divider_sash_position) {
1109                 root->add_child("MainDividerSashPosition")->add_child_text(raw_convert<string>(*_main_divider_sash_position));
1110         }
1111         if (_main_content_divider_sash_position) {
1112                 root->add_child("MainContentDividerSashPosition")->add_child_text(raw_convert<string>(*_main_content_divider_sash_position));
1113         }
1114
1115         root->add_child("DefaultAddFileLocation")->add_child_text(
1116                 _default_add_file_location == DefaultAddFileLocation::SAME_AS_LAST_TIME ? "last" : "project"
1117                 );
1118
1119         /* [XML] AllowSMPTEBv20 1 to allow the user to choose SMPTE (Bv2.0 only) as a standard, otherwise 0 */
1120         root->add_child("AllowSMPTEBv20")->add_child_text(_allow_smpte_bv20 ? "1" : "0");
1121         /* [XML] ISDCFNamePartLength Maximum length of the "name" part of an ISDCF name, which should be 14 according to the standard */
1122         root->add_child("ISDCFNamePartLength")->add_child_text(raw_convert<string>(_isdcf_name_part_length));
1123
1124         _export.write(root->add_child("Export"));
1125
1126         auto target = config_write_file();
1127
1128         try {
1129                 auto const s = doc.write_to_string_formatted ();
1130                 boost::filesystem::path tmp (string(target.string()).append(".tmp"));
1131                 dcp::File f(tmp, "w");
1132                 if (!f) {
1133                         throw FileError (_("Could not open file for writing"), tmp);
1134                 }
1135                 f.checked_write(s.c_str(), s.bytes());
1136                 f.close();
1137                 dcp::filesystem::remove(target);
1138                 dcp::filesystem::rename(tmp, target);
1139         } catch (xmlpp::exception& e) {
1140                 string s = e.what ();
1141                 trim (s);
1142                 throw FileError (s, target);
1143         }
1144 }
1145
1146
1147 template <class T>
1148 void
1149 write_file (string root_node, string node, string version, list<shared_ptr<T>> things, boost::filesystem::path file)
1150 {
1151         xmlpp::Document doc;
1152         auto root = doc.create_root_node (root_node);
1153         root->add_child("Version")->add_child_text(version);
1154
1155         for (auto i: things) {
1156                 i->as_xml (root->add_child(node));
1157         }
1158
1159         try {
1160                 doc.write_to_file_formatted (file.string() + ".tmp");
1161                 dcp::filesystem::remove(file);
1162                 dcp::filesystem::rename(file.string() + ".tmp", file);
1163         } catch (xmlpp::exception& e) {
1164                 string s = e.what ();
1165                 trim (s);
1166                 throw FileError (s, file);
1167         }
1168 }
1169
1170
1171 void
1172 Config::write_cinemas () const
1173 {
1174         write_file ("Cinemas", "Cinema", "1", _cinemas, _cinemas_file);
1175 }
1176
1177
1178 void
1179 Config::write_dkdm_recipients () const
1180 {
1181         write_file ("DKDMRecipients", "DKDMRecipient", "1", _dkdm_recipients, _dkdm_recipients_file);
1182 }
1183
1184
1185 boost::filesystem::path
1186 Config::default_directory_or (boost::filesystem::path a) const
1187 {
1188         return directory_or (_default_directory, a);
1189 }
1190
1191 boost::filesystem::path
1192 Config::default_kdm_directory_or (boost::filesystem::path a) const
1193 {
1194         return directory_or (_default_kdm_directory, a);
1195 }
1196
1197 boost::filesystem::path
1198 Config::directory_or (optional<boost::filesystem::path> dir, boost::filesystem::path a) const
1199 {
1200         if (!dir) {
1201                 return a;
1202         }
1203
1204         boost::system::error_code ec;
1205         auto const e = dcp::filesystem::exists(*dir, ec);
1206         if (ec || !e) {
1207                 return a;
1208         }
1209
1210         return *dir;
1211 }
1212
1213 void
1214 Config::drop ()
1215 {
1216         delete _instance;
1217         _instance = 0;
1218 }
1219
1220 void
1221 Config::changed (Property what)
1222 {
1223         Changed (what);
1224 }
1225
1226 void
1227 Config::set_kdm_email_to_default ()
1228 {
1229         _kdm_subject = _("KDM delivery: $CPL_NAME");
1230
1231         _kdm_email = _(
1232                 "Dear Projectionist\n\n"
1233                 "Please find attached KDMs for $CPL_NAME.\n\n"
1234                 "Cinema: $CINEMA_NAME\n"
1235                 "Screen(s): $SCREENS\n\n"
1236                 "The KDMs are valid from $START_TIME until $END_TIME.\n\n"
1237                 "Best regards,\nDCP-o-matic"
1238                 );
1239 }
1240
1241 void
1242 Config::set_notification_email_to_default ()
1243 {
1244         _notification_subject = _("DCP-o-matic notification");
1245
1246         _notification_email = _(
1247                 "$JOB_NAME: $JOB_STATUS"
1248                 );
1249 }
1250
1251 void
1252 Config::reset_kdm_email ()
1253 {
1254         set_kdm_email_to_default ();
1255         changed ();
1256 }
1257
1258 void
1259 Config::reset_notification_email ()
1260 {
1261         set_notification_email_to_default ();
1262         changed ();
1263 }
1264
1265 void
1266 Config::set_cover_sheet_to_default ()
1267 {
1268         _cover_sheet = _(
1269                 "$CPL_NAME\n\n"
1270                 "CPL Filename: $CPL_FILENAME\n"
1271                 "Type: $TYPE\n"
1272                 "Format: $CONTAINER\n"
1273                 "Audio: $AUDIO\n"
1274                 "Audio Language: $AUDIO_LANGUAGE\n"
1275                 "Subtitle Language: $SUBTITLE_LANGUAGE\n"
1276                 "Length: $LENGTH\n"
1277                 "Size: $SIZE\n"
1278                 );
1279 }
1280
1281 void
1282 Config::add_to_history (boost::filesystem::path p)
1283 {
1284         add_to_history_internal (_history, p);
1285 }
1286
1287 /** Remove non-existent items from the history */
1288 void
1289 Config::clean_history ()
1290 {
1291         clean_history_internal (_history);
1292 }
1293
1294 void
1295 Config::add_to_player_history (boost::filesystem::path p)
1296 {
1297         add_to_history_internal (_player_history, p);
1298 }
1299
1300 /** Remove non-existent items from the player history */
1301 void
1302 Config::clean_player_history ()
1303 {
1304         clean_history_internal (_player_history);
1305 }
1306
1307 void
1308 Config::add_to_history_internal (vector<boost::filesystem::path>& h, boost::filesystem::path p)
1309 {
1310         /* Remove existing instances of this path in the history */
1311         h.erase (remove (h.begin(), h.end(), p), h.end ());
1312
1313         h.insert (h.begin (), p);
1314         if (h.size() > HISTORY_SIZE) {
1315                 h.pop_back ();
1316         }
1317
1318         changed (HISTORY);
1319 }
1320
1321 void
1322 Config::clean_history_internal (vector<boost::filesystem::path>& h)
1323 {
1324         auto old = h;
1325         h.clear ();
1326         for (auto i: old) {
1327                 try {
1328                         if (dcp::filesystem::is_directory(i)) {
1329                                 h.push_back (i);
1330                         }
1331                 } catch (...) {
1332                         /* We couldn't find out if it's a directory for some reason; just ignore it */
1333                 }
1334         }
1335 }
1336
1337
1338 bool
1339 Config::have_existing (string file)
1340 {
1341         return dcp::filesystem::exists(read_path(file));
1342 }
1343
1344
1345 void
1346 Config::read_cinemas (cxml::Document const & f)
1347 {
1348         _cinemas.clear ();
1349         for (auto i: f.node_children("Cinema")) {
1350                 /* Slightly grotty two-part construction of Cinema here so that we can use
1351                    shared_from_this.
1352                 */
1353                 auto cinema = make_shared<Cinema>(i);
1354                 cinema->read_screens (i);
1355                 _cinemas.push_back (cinema);
1356         }
1357 }
1358
1359 void
1360 Config::set_cinemas_file (boost::filesystem::path file)
1361 {
1362         if (file == _cinemas_file) {
1363                 return;
1364         }
1365
1366         _cinemas_file = file;
1367
1368         if (dcp::filesystem::exists(_cinemas_file)) {
1369                 /* Existing file; read it in */
1370                 cxml::Document f ("Cinemas");
1371                 f.read_file(dcp::filesystem::fix_long_path(_cinemas_file));
1372                 read_cinemas (f);
1373         }
1374
1375         changed (CINEMAS);
1376         changed (OTHER);
1377 }
1378
1379
1380 void
1381 Config::read_dkdm_recipients (cxml::Document const & f)
1382 {
1383         _dkdm_recipients.clear ();
1384         for (auto i: f.node_children("DKDMRecipient")) {
1385                 _dkdm_recipients.push_back (make_shared<DKDMRecipient>(i));
1386         }
1387 }
1388
1389
1390 void
1391 Config::save_template (shared_ptr<const Film> film, string name) const
1392 {
1393         film->write_template (template_write_path(name));
1394 }
1395
1396
1397 list<string>
1398 Config::templates () const
1399 {
1400         if (!dcp::filesystem::exists(read_path("templates"))) {
1401                 return {};
1402         }
1403
1404         list<string> n;
1405         for (auto const& i: dcp::filesystem::directory_iterator(read_path("templates"))) {
1406                 n.push_back (i.path().filename().string());
1407         }
1408         return n;
1409 }
1410
1411 bool
1412 Config::existing_template (string name) const
1413 {
1414         return dcp::filesystem::exists(template_read_path(name));
1415 }
1416
1417
1418 boost::filesystem::path
1419 Config::template_read_path (string name) const
1420 {
1421         return read_path("templates") / tidy_for_filename (name);
1422 }
1423
1424
1425 boost::filesystem::path
1426 Config::template_write_path (string name) const
1427 {
1428         return write_path("templates") / tidy_for_filename (name);
1429 }
1430
1431
1432 void
1433 Config::rename_template (string old_name, string new_name) const
1434 {
1435         dcp::filesystem::rename(template_read_path(old_name), template_write_path(new_name));
1436 }
1437
1438 void
1439 Config::delete_template (string name) const
1440 {
1441         dcp::filesystem::remove(template_write_path(name));
1442 }
1443
1444 /** @return Path to the config.xml containing the actual settings, following a link if required */
1445 boost::filesystem::path
1446 config_file (boost::filesystem::path main)
1447 {
1448         cxml::Document f ("Config");
1449         if (!dcp::filesystem::exists(main)) {
1450                 /* It doesn't exist, so there can't be any links; just return it */
1451                 return main;
1452         }
1453
1454         /* See if there's a link */
1455         try {
1456                 f.read_file(dcp::filesystem::fix_long_path(main));
1457                 auto link = f.optional_string_child("Link");
1458                 if (link) {
1459                         return *link;
1460                 }
1461         } catch (xmlpp::exception& e) {
1462                 /* There as a problem reading the main configuration file,
1463                    so there can't be a link.
1464                 */
1465         }
1466
1467         return main;
1468 }
1469
1470
1471 boost::filesystem::path
1472 Config::config_read_file ()
1473 {
1474         return config_file (read_path("config.xml"));
1475 }
1476
1477
1478 boost::filesystem::path
1479 Config::config_write_file ()
1480 {
1481         return config_file (write_path("config.xml"));
1482 }
1483
1484
1485 void
1486 Config::reset_cover_sheet ()
1487 {
1488         set_cover_sheet_to_default ();
1489         changed ();
1490 }
1491
1492 void
1493 Config::link (boost::filesystem::path new_file) const
1494 {
1495         xmlpp::Document doc;
1496         doc.create_root_node("Config")->add_child("Link")->add_child_text(new_file.string());
1497         try {
1498                 doc.write_to_file_formatted(write_path("config.xml").string());
1499         } catch (xmlpp::exception& e) {
1500                 string s = e.what ();
1501                 trim (s);
1502                 throw FileError (s, write_path("config.xml"));
1503         }
1504 }
1505
1506 void
1507 Config::copy_and_link (boost::filesystem::path new_file) const
1508 {
1509         write ();
1510         dcp::filesystem::copy_file(config_read_file(), new_file, boost::filesystem::copy_option::overwrite_if_exists);
1511         link (new_file);
1512 }
1513
1514 bool
1515 Config::have_write_permission () const
1516 {
1517         dcp::File f(config_write_file(), "r+");
1518         return static_cast<bool>(f);
1519 }
1520
1521 /** @param  output_channels Number of output channels in use.
1522  *  @return Audio mapping for this output channel count (may be a default).
1523  */
1524 AudioMapping
1525 Config::audio_mapping (int output_channels)
1526 {
1527         if (!_audio_mapping || _audio_mapping->output_channels() != output_channels) {
1528                 /* Set up a default */
1529                 _audio_mapping = AudioMapping (MAX_DCP_AUDIO_CHANNELS, output_channels);
1530                 if (output_channels == 2) {
1531                         /* Special case for stereo output.
1532                            Map so that Lt = L(-3dB) + Ls(-3dB) + C(-6dB) + Lfe(-10dB)
1533                            Rt = R(-3dB) + Rs(-3dB) + C(-6dB) + Lfe(-10dB)
1534                         */
1535                         _audio_mapping->set (dcp::Channel::LEFT,   0, 1 / sqrt(2));  // L   -> Lt
1536                         _audio_mapping->set (dcp::Channel::RIGHT,  1, 1 / sqrt(2));  // R   -> Rt
1537                         _audio_mapping->set (dcp::Channel::CENTRE, 0, 1 / 2.0);      // C   -> Lt
1538                         _audio_mapping->set (dcp::Channel::CENTRE, 1, 1 / 2.0);      // C   -> Rt
1539                         _audio_mapping->set (dcp::Channel::LFE,    0, 1 / sqrt(10)); // Lfe -> Lt
1540                         _audio_mapping->set (dcp::Channel::LFE,    1, 1 / sqrt(10)); // Lfe -> Rt
1541                         _audio_mapping->set (dcp::Channel::LS,     0, 1 / sqrt(2));  // Ls  -> Lt
1542                         _audio_mapping->set (dcp::Channel::RS,     1, 1 / sqrt(2));  // Rs  -> Rt
1543                 } else {
1544                         /* 1:1 mapping */
1545                         for (int i = 0; i < min (MAX_DCP_AUDIO_CHANNELS, output_channels); ++i) {
1546                                 _audio_mapping->set (i, i, 1);
1547                         }
1548                 }
1549         }
1550
1551         return *_audio_mapping;
1552 }
1553
1554 void
1555 Config::set_audio_mapping (AudioMapping m)
1556 {
1557         _audio_mapping = m;
1558         changed (AUDIO_MAPPING);
1559 }
1560
1561 void
1562 Config::set_audio_mapping_to_default ()
1563 {
1564         DCPOMATIC_ASSERT (_audio_mapping);
1565         auto const ch = _audio_mapping->output_channels ();
1566         _audio_mapping = boost::none;
1567         _audio_mapping = audio_mapping (ch);
1568         changed (AUDIO_MAPPING);
1569 }
1570
1571
1572 void
1573 Config::add_custom_language (dcp::LanguageTag tag)
1574 {
1575         if (find(_custom_languages.begin(), _custom_languages.end(), tag) == _custom_languages.end()) {
1576                 _custom_languages.push_back (tag);
1577                 changed ();
1578         }
1579 }
1580
1581
1582 optional<Config::BadReason>
1583 Config::check_certificates () const
1584 {
1585         optional<BadReason> bad;
1586
1587         for (auto const& i: _signer_chain->unordered()) {
1588                 if (i.has_utf8_strings()) {
1589                         bad = BAD_SIGNER_UTF8_STRINGS;
1590                 }
1591                 if ((i.not_after().year() - i.not_before().year()) > 15) {
1592                         bad = BAD_SIGNER_VALIDITY_TOO_LONG;
1593                 }
1594                 if (dcp::escape_digest(i.subject_dn_qualifier()) != dcp::public_key_digest(i.public_key())) {
1595                         bad = BAD_SIGNER_DN_QUALIFIER;
1596                 }
1597         }
1598
1599         if (!_signer_chain->chain_valid() || !_signer_chain->private_key_valid()) {
1600                 bad = BAD_SIGNER_INCONSISTENT;
1601         }
1602
1603         if (!_decryption_chain->chain_valid() || !_decryption_chain->private_key_valid()) {
1604                 bad = BAD_DECRYPTION_INCONSISTENT;
1605         }
1606
1607         return bad;
1608 }
1609
1610
1611 void
1612 save_all_config_as_zip (boost::filesystem::path zip_file)
1613 {
1614         Zipper zipper (zip_file);
1615
1616         auto config = Config::instance();
1617         zipper.add ("config.xml", dcp::file_to_string(config->config_read_file()));
1618         if (dcp::filesystem::exists(config->cinemas_file())) {
1619                 zipper.add ("cinemas.xml", dcp::file_to_string(config->cinemas_file()));
1620         }
1621         if (dcp::filesystem::exists(config->dkdm_recipients_file())) {
1622                 zipper.add ("dkdm_recipients.xml", dcp::file_to_string(config->dkdm_recipients_file()));
1623         }
1624
1625         zipper.close ();
1626 }
1627
1628
1629 void
1630 Config::set_initial_path(string id, boost::filesystem::path path)
1631 {
1632         auto iter = _initial_paths.find(id);
1633         DCPOMATIC_ASSERT(iter != _initial_paths.end());
1634         iter->second = path;
1635         changed();
1636 }
1637
1638
1639 optional<boost::filesystem::path>
1640 Config::initial_path(string id) const
1641 {
1642         auto iter = _initial_paths.find(id);
1643         DCPOMATIC_ASSERT(iter != _initial_paths.end());
1644         return iter->second;
1645 }
1646