src/util.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp 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     libdcp 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 libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 /** @file  src/util.cc
  36  *  @brief Utility methods and classes
  37  */
  38
  39
  40 #include "certificate.h"
  41 #include "compose.hpp"
  42 #include "dcp_assert.h"
  43 #include "exceptions.h"
  44 #include "file.h"
  45 #include "filesystem.h"
  46 #include "language_tag.h"
  47 #include "openjpeg_image.h"
  48 #include "rating.h"
  49 #include "types.h"
  50 #include "util.h"
  51 #include <openjpeg.h>
  52 #include <asdcp/KM_util.h>
  53 #include <asdcp/KM_fileio.h>
  54 #include <asdcp/AS_DCP.h>
  55 #include <xmlsec/xmldsig.h>
  56 #include <xmlsec/dl.h>
  57 #include <xmlsec/app.h>
  58 #include <xmlsec/crypto.h>
  59 #include <libxml++/nodes/element.h>
  60 #include <libxml++/document.h>
  61 #include <openssl/sha.h>
  62 #include <boost/algorithm/string.hpp>
  63 #if BOOST_VERSION >= 106100
  64 #include <boost/dll/runtime_symbol_info.hpp>
  65 #endif
  66 #include <boost/filesystem.hpp>
  67 #include <stdexcept>
  68 #include <iostream>
  69 #include <iomanip>
  70
  71
  72 using std::string;
  73 using std::wstring;
  74 using std::cout;
  75 using std::min;
  76 using std::max;
  77 using std::setw;
  78 using std::setfill;
  79 using std::ostream;
  80 using std::shared_ptr;
  81 using std::vector;
  82 using boost::shared_array;
  83 using boost::optional;
  84 using boost::function;
  85 using boost::algorithm::trim;
  86 using namespace dcp;
  87
  88
  89 /* Some ASDCP objects store this as a *&, for reasons which are not
  90  * at all clear, so we have to keep this around forever.
  91  */
  92 ASDCP::Dictionary const* dcp::asdcp_smpte_dict = nullptr;
  93
  94
  95 string
  96 dcp::make_uuid ()
  97 {
  98         char buffer[64];
  99         Kumu::UUID id;
 100         Kumu::GenRandomValue (id);
 101         id.EncodeHex (buffer, 64);
 102         return string (buffer);
 103 }
 104
 105
 106 string
 107 dcp::make_digest (ArrayData data)
 108 {
 109         SHA_CTX sha;
 110         SHA1_Init (&sha);
 111         SHA1_Update (&sha, data.data(), data.size());
 112         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 113         SHA1_Final (byte_buffer, &sha);
 114         char digest[64];
 115         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 116 }
 117
 118
 119 string
 120 dcp::make_digest(boost::filesystem::path filename, function<void (int64_t, int64_t)> progress)
 121 {
 122         Kumu::FileReader reader;
 123         auto r = reader.OpenRead(dcp::filesystem::fix_long_path(filename).string().c_str());
 124         if (ASDCP_FAILURE(r)) {
 125                 boost::throw_exception (FileError("could not open file to compute digest", filename, r));
 126         }
 127
 128         SHA_CTX sha;
 129         SHA1_Init (&sha);
 130
 131         int const buffer_size = 65536;
 132         Kumu::ByteString read_buffer (buffer_size);
 133
 134         Kumu::fsize_t done = 0;
 135         Kumu::fsize_t const size = reader.Size ();
 136         while (true) {
 137                 ui32_t read = 0;
 138                 auto r = reader.Read (read_buffer.Data(), read_buffer.Capacity(), &read);
 139
 140                 if (r == Kumu::RESULT_ENDOFFILE) {
 141                         break;
 142                 } else if (ASDCP_FAILURE (r)) {
 143                         boost::throw_exception (FileError("could not read file to compute digest", filename, r));
 144                 }
 145
 146                 SHA1_Update (&sha, read_buffer.Data(), read);
 147
 148                 if (progress) {
 149                         progress(done, size);
 150                         done += read;
 151                 }
 152         }
 153
 154         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 155         SHA1_Final (byte_buffer, &sha);
 156
 157         char digest[64];
 158         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 159 }
 160
 161
 162 void
 163 dcp::init (optional<boost::filesystem::path> given_resources_directory)
 164 {
 165         if (xmlSecInit() < 0) {
 166                 throw MiscError ("could not initialise xmlsec");
 167         }
 168
 169 #ifdef XMLSEC_CRYPTO_DYNAMIC_LOADING
 170         if (xmlSecCryptoDLLoadLibrary(BAD_CAST "openssl") < 0) {
 171                 throw MiscError ("unable to load openssl xmlsec-crypto library");
 172         }
 173 #endif
 174
 175         if (xmlSecCryptoAppInit(0) < 0) {
 176                 throw MiscError ("could not initialise crypto");
 177         }
 178
 179         if (xmlSecCryptoInit() < 0) {
 180                 throw MiscError ("could not initialise xmlsec-crypto");
 181         }
 182
 183         OpenSSL_add_all_algorithms();
 184
 185         asdcp_smpte_dict = &ASDCP::DefaultSMPTEDict();
 186
 187         auto res = given_resources_directory.get_value_or(resources_directory());
 188
 189         load_language_tag_lists (res / "tags");
 190         load_rating_list (res / "ratings");
 191 }
 192
 193
 194 int
 195 dcp::base64_decode (string const & in, unsigned char* out, int out_length)
 196 {
 197         auto b64 = BIO_new (BIO_f_base64());
 198
 199         /* This means the input should have no newlines */
 200         BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
 201
 202         /* Copy our input string, removing newlines */
 203         char in_buffer[in.size() + 1];
 204         char* p = in_buffer;
 205         for (size_t i = 0; i < in.size(); ++i) {
 206                 if (in[i] != '\n' && in[i] != '\r') {
 207                         *p++ = in[i];
 208                 }
 209         }
 210
 211         auto bmem = BIO_new_mem_buf (in_buffer, p - in_buffer);
 212         bmem = BIO_push (b64, bmem);
 213         int const N = BIO_read (bmem, out, out_length);
 214         BIO_free_all (bmem);
 215
 216         return N;
 217 }
 218
 219
 220 optional<boost::filesystem::path>
 221 dcp::relative_to_root (boost::filesystem::path root, boost::filesystem::path file)
 222 {
 223         auto i = root.begin ();
 224         auto j = file.begin ();
 225
 226         while (i != root.end() && j != file.end() && *i == *j) {
 227                 ++i;
 228                 ++j;
 229         }
 230
 231         if (i != root.end()) {
 232                 return {};
 233         }
 234
 235         boost::filesystem::path rel;
 236         while (j != file.end()) {
 237                 rel /= *j++;
 238         }
 239
 240         return rel;
 241 }
 242
 243
 244 bool
 245 dcp::ids_equal (string a, string b)
 246 {
 247         transform (a.begin(), a.end(), a.begin(), ::tolower);
 248         transform (b.begin(), b.end(), b.begin(), ::tolower);
 249         trim (a);
 250         trim (b);
 251         return a == b;
 252 }
 253
 254
 255 string
 256 dcp::file_to_string (boost::filesystem::path p, uintmax_t max_length)
 257 {
 258         auto len = filesystem::file_size(p);
 259         if (len > max_length) {
 260                 throw MiscError (String::compose("Unexpectedly long file (%1)", p.string()));
 261         }
 262
 263         File f(p, "r");
 264         if (!f) {
 265                 throw FileError ("could not open file", p, errno);
 266         }
 267
 268         std::vector<char> buffer(len);
 269         /* This may read less than `len' if we are on Windows and we have CRLF in the file */
 270         int const N = f.read(buffer.data(), 1, len);
 271         return string(buffer.data(), N);
 272 }
 273
 274
 275 }
 276
 277
 278 string
 279 dcp::private_key_fingerprint (string key)
 280 {
 281         boost::replace_all (key, "-----BEGIN RSA PRIVATE KEY-----\n", "");
 282         boost::replace_all (key, "\n-----END RSA PRIVATE KEY-----\n", "");
 283         boost::replace_all (key, "-----BEGIN PRIVATE KEY-----\n", "");
 284         boost::replace_all (key, "\n-----END PRIVATE KEY-----\n", "");
 285
 286         unsigned char buffer[4096];
 287         int const N = base64_decode (key, buffer, sizeof (buffer));
 288
 289         SHA_CTX sha;
 290         SHA1_Init (&sha);
 291         SHA1_Update (&sha, buffer, N);
 292         uint8_t digest[20];
 293         SHA1_Final (digest, &sha);
 294
 295         char digest_base64[64];
 296         return Kumu::base64encode (digest, 20, digest_base64, 64);
 297 }
 298
 299
 300 xmlpp::Node *
 301 dcp::find_child (xmlpp::Node const * node, string name)
 302 {
 303         auto c = node->get_children ();
 304         auto i = c.begin();
 305         while (i != c.end() && (*i)->get_name() != name) {
 306                 ++i;
 307         }
 308
 309         DCP_ASSERT (i != c.end ());
 310         return *i;
 311 }
 312
 313
 314 string
 315 dcp::remove_urn_uuid (string raw)
 316 {
 317         if (raw.substr(0, 9) != "urn:uuid:") {
 318                 throw BadURNUUIDError(raw);
 319         }
 320
 321         return raw.substr (9);
 322 }
 323
 324
 325 string
 326 dcp::openjpeg_version ()
 327 {
 328         return opj_version ();
 329 }
 330
 331
 332 string
 333 dcp::spaces (int n)
 334 {
 335         string s = "";
 336         for (int i = 0; i < n; ++i) {
 337                 s += " ";
 338         }
 339         return s;
 340 }
 341
 342
 343 void
 344 dcp::indent (xmlpp::Element* element, int initial)
 345 {
 346         xmlpp::Node* last = nullptr;
 347         for (auto n: element->get_children()) {
 348                 auto e = dynamic_cast<xmlpp::Element*>(n);
 349                 if (e) {
 350                         element->add_child_text_before (e, "\n" + spaces(initial + 2));
 351                         indent (e, initial + 2);
 352                         last = n;
 353                 }
 354         }
 355         if (last) {
 356                 element->add_child_text (last, "\n" + spaces(initial));
 357         }
 358 }
 359
 360
 361 bool
 362 dcp::day_less_than_or_equal (LocalTime a, LocalTime b)
 363 {
 364         if (a.year() != b.year()) {
 365                 return a.year() < b.year();
 366         }
 367
 368         if (a.month() != b.month()) {
 369                 return a.month() < b.month();
 370         }
 371
 372         return a.day() <= b.day();
 373 }
 374
 375
 376 bool
 377 dcp::day_greater_than_or_equal (LocalTime a, LocalTime b)
 378 {
 379         if (a.year() != b.year()) {
 380                 return a.year() > b.year();
 381         }
 382
 383         if (a.month() != b.month()) {
 384                 return a.month() > b.month();
 385         }
 386
 387         return a.day() >= b.day();
 388 }
 389
 390
 391 string
 392 dcp::unique_string (vector<string> existing, string base)
 393 {
 394         int const max_tries = existing.size() + 1;
 395         for (int i = 0; i < max_tries; ++i) {
 396                 string trial = String::compose("%1%2", base, i);
 397                 if (find(existing.begin(), existing.end(), trial) == existing.end()) {
 398                         return trial;
 399                 }
 400         }
 401
 402         DCP_ASSERT (false);
 403 }
 404
 405
 406 ASDCPErrorSuspender::ASDCPErrorSuspender ()
 407         : _old (Kumu::DefaultLogSink())
 408 {
 409         _sink = new Kumu::EntryListLogSink(_log);
 410         Kumu::SetDefaultLogSink (_sink);
 411 }
 412
 413
 414 ASDCPErrorSuspender::~ASDCPErrorSuspender ()
 415 {
 416         Kumu::SetDefaultLogSink (&_old);
 417         delete _sink;
 418 }
 419
 420
 421 boost::filesystem::path dcp::directory_containing_executable ()
 422 {
 423 #if BOOST_VERSION >= 106100
 424         return filesystem::canonical(boost::dll::program_location().parent_path());
 425 #else
 426         char buffer[PATH_MAX];
 427         ssize_t N = readlink ("/proc/self/exe", buffer, PATH_MAX);
 428         return boost::filesystem::path(string(buffer, N)).parent_path();
 429 #endif
 430 }
 431
 432
 433 boost::filesystem::path dcp::resources_directory ()
 434 {
 435         /* We need a way to specify the tags directory for running un-installed binaries */
 436         char* prefix = getenv("LIBDCP_RESOURCES");
 437         if (prefix) {
 438                 return prefix;
 439         }
 440
 441 #if defined(LIBDCP_OSX)
 442         return directory_containing_executable().parent_path() / "Resources";
 443 #elif defined(LIBDCP_WINDOWS)
 444         return directory_containing_executable().parent_path();
 445 #else
 446         return directory_containing_executable().parent_path() / "share" / "libdcp";
 447 #endif
 448 }
 449
 450