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 "language_tag.h"
  46 #include "openjpeg_image.h"
  47 #include "rating.h"
  48 #include "types.h"
  49 #include "util.h"
  50 #include <openjpeg.h>
  51 #include <asdcp/KM_util.h>
  52 #include <asdcp/KM_fileio.h>
  53 #include <asdcp/AS_DCP.h>
  54 #include <xmlsec/xmldsig.h>
  55 #include <xmlsec/dl.h>
  56 #include <xmlsec/app.h>
  57 #include <xmlsec/crypto.h>
  58 #include <libxml++/nodes/element.h>
  59 #include <libxml++/document.h>
  60 #include <openssl/sha.h>
  61 #include <boost/algorithm/string.hpp>
  62 #if BOOST_VERSION >= 106100
  63 #include <boost/dll/runtime_symbol_info.hpp>
  64 #endif
  65 #include <boost/filesystem.hpp>
  66 #include <stdexcept>
  67 #include <iostream>
  68 #include <iomanip>
  69
  70
  71 using std::string;
  72 using std::wstring;
  73 using std::cout;
  74 using std::min;
  75 using std::max;
  76 using std::setw;
  77 using std::setfill;
  78 using std::ostream;
  79 using std::shared_ptr;
  80 using std::vector;
  81 using boost::shared_array;
  82 using boost::optional;
  83 using boost::function;
  84 using boost::algorithm::trim;
  85 using namespace dcp;
  86
  87
  88 /* Some ASDCP objects store this as a *&, for reasons which are not
  89  * at all clear, so we have to keep this around forever.
  90  */
  91 ASDCP::Dictionary const* dcp::asdcp_smpte_dict = nullptr;
  92
  93
  94 string
  95 dcp::make_uuid ()
  96 {
  97         char buffer[64];
  98         Kumu::UUID id;
  99         Kumu::GenRandomValue (id);
 100         id.EncodeHex (buffer, 64);
 101         return string (buffer);
 102 }
 103
 104
 105 string
 106 dcp::make_digest (ArrayData data)
 107 {
 108         SHA_CTX sha;
 109         SHA1_Init (&sha);
 110         SHA1_Update (&sha, data.data(), data.size());
 111         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 112         SHA1_Final (byte_buffer, &sha);
 113         char digest[64];
 114         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 115 }
 116
 117
 118 string
 119 dcp::make_digest (boost::filesystem::path filename, function<void (float)> progress)
 120 {
 121         Kumu::FileReader reader;
 122         auto r = reader.OpenRead (filename.string().c_str ());
 123         if (ASDCP_FAILURE(r)) {
 124                 boost::throw_exception (FileError("could not open file to compute digest", filename, r));
 125         }
 126
 127         SHA_CTX sha;
 128         SHA1_Init (&sha);
 129
 130         int const buffer_size = 65536;
 131         Kumu::ByteString read_buffer (buffer_size);
 132
 133         Kumu::fsize_t done = 0;
 134         Kumu::fsize_t const size = reader.Size ();
 135         while (true) {
 136                 ui32_t read = 0;
 137                 auto r = reader.Read (read_buffer.Data(), read_buffer.Capacity(), &read);
 138
 139                 if (r == Kumu::RESULT_ENDOFFILE) {
 140                         break;
 141                 } else if (ASDCP_FAILURE (r)) {
 142                         boost::throw_exception (FileError("could not read file to compute digest", filename, r));
 143                 }
 144
 145                 SHA1_Update (&sha, read_buffer.Data(), read);
 146
 147                 if (progress) {
 148                         progress (float (done) / size);
 149                         done += read;
 150                 }
 151         }
 152
 153         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 154         SHA1_Final (byte_buffer, &sha);
 155
 156         char digest[64];
 157         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 158 }
 159
 160
 161 void
 162 dcp::init (optional<boost::filesystem::path> given_resources_directory)
 163 {
 164         if (xmlSecInit() < 0) {
 165                 throw MiscError ("could not initialise xmlsec");
 166         }
 167
 168 #ifdef XMLSEC_CRYPTO_DYNAMIC_LOADING
 169         if (xmlSecCryptoDLLoadLibrary(BAD_CAST "openssl") < 0) {
 170                 throw MiscError ("unable to load openssl xmlsec-crypto library");
 171         }
 172 #endif
 173
 174         if (xmlSecCryptoAppInit(0) < 0) {
 175                 throw MiscError ("could not initialise crypto");
 176         }
 177
 178         if (xmlSecCryptoInit() < 0) {
 179                 throw MiscError ("could not initialise xmlsec-crypto");
 180         }
 181
 182         OpenSSL_add_all_algorithms();
 183
 184         asdcp_smpte_dict = &ASDCP::DefaultSMPTEDict();
 185
 186         auto res = given_resources_directory.get_value_or(resources_directory());
 187
 188         load_language_tag_lists (res / "tags");
 189         load_rating_list (res / "ratings");
 190 }
 191
 192
 193 int
 194 dcp::base64_decode (string const & in, unsigned char* out, int out_length)
 195 {
 196         auto b64 = BIO_new (BIO_f_base64());
 197
 198         /* This means the input should have no newlines */
 199         BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
 200
 201         /* Copy our input string, removing newlines */
 202         char in_buffer[in.size() + 1];
 203         char* p = in_buffer;
 204         for (size_t i = 0; i < in.size(); ++i) {
 205                 if (in[i] != '\n' && in[i] != '\r') {
 206                         *p++ = in[i];
 207                 }
 208         }
 209
 210         auto bmem = BIO_new_mem_buf (in_buffer, p - in_buffer);
 211         bmem = BIO_push (b64, bmem);
 212         int const N = BIO_read (bmem, out, out_length);
 213         BIO_free_all (bmem);
 214
 215         return N;
 216 }
 217
 218
 219 optional<boost::filesystem::path>
 220 dcp::relative_to_root (boost::filesystem::path root, boost::filesystem::path file)
 221 {
 222         auto i = root.begin ();
 223         auto j = file.begin ();
 224
 225         while (i != root.end() && j != file.end() && *i == *j) {
 226                 ++i;
 227                 ++j;
 228         }
 229
 230         if (i != root.end()) {
 231                 return {};
 232         }
 233
 234         boost::filesystem::path rel;
 235         while (j != file.end()) {
 236                 rel /= *j++;
 237         }
 238
 239         return rel;
 240 }
 241
 242
 243 bool
 244 dcp::ids_equal (string a, string b)
 245 {
 246         transform (a.begin(), a.end(), a.begin(), ::tolower);
 247         transform (b.begin(), b.end(), b.begin(), ::tolower);
 248         trim (a);
 249         trim (b);
 250         return a == b;
 251 }
 252
 253
 254 string
 255 dcp::file_to_string (boost::filesystem::path p, uintmax_t max_length)
 256 {
 257         auto len = boost::filesystem::file_size (p);
 258         if (len > max_length) {
 259                 throw MiscError (String::compose("Unexpectedly long file (%1)", p.string()));
 260         }
 261
 262         File f(p, "r");
 263         if (!f) {
 264                 throw FileError ("could not open file", p, errno);
 265         }
 266
 267         char* c = new char[len];
 268         /* This may read less than `len' if we are on Windows and we have CRLF in the file */
 269         int const N = f.read(c, 1, len);
 270
 271         string s (c, N);
 272         delete[] c;
 273
 274         return s;
 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         DCP_ASSERT (raw.substr(0, 9) == "urn:uuid:");
 318         return raw.substr (9);
 319 }
 320
 321
 322 string
 323 dcp::openjpeg_version ()
 324 {
 325         return opj_version ();
 326 }
 327
 328
 329 string
 330 dcp::spaces (int n)
 331 {
 332         string s = "";
 333         for (int i = 0; i < n; ++i) {
 334                 s += " ";
 335         }
 336         return s;
 337 }
 338
 339
 340 void
 341 dcp::indent (xmlpp::Element* element, int initial)
 342 {
 343         xmlpp::Node* last = nullptr;
 344         for (auto n: element->get_children()) {
 345                 auto e = dynamic_cast<xmlpp::Element*>(n);
 346                 if (e) {
 347                         element->add_child_text_before (e, "\n" + spaces(initial + 2));
 348                         indent (e, initial + 2);
 349                         last = n;
 350                 }
 351         }
 352         if (last) {
 353                 element->add_child_text (last, "\n" + spaces(initial));
 354         }
 355 }
 356
 357
 358 bool
 359 dcp::day_less_than_or_equal (LocalTime a, LocalTime b)
 360 {
 361         if (a.year() != b.year()) {
 362                 return a.year() < b.year();
 363         }
 364
 365         if (a.month() != b.month()) {
 366                 return a.month() < b.month();
 367         }
 368
 369         return a.day() <= b.day();
 370 }
 371
 372
 373 bool
 374 dcp::day_greater_than_or_equal (LocalTime a, LocalTime b)
 375 {
 376         if (a.year() != b.year()) {
 377                 return a.year() > b.year();
 378         }
 379
 380         if (a.month() != b.month()) {
 381                 return a.month() > b.month();
 382         }
 383
 384         return a.day() >= b.day();
 385 }
 386
 387
 388 string
 389 dcp::unique_string (vector<string> existing, string base)
 390 {
 391         int const max_tries = existing.size() + 1;
 392         for (int i = 0; i < max_tries; ++i) {
 393                 string trial = String::compose("%1%2", base, i);
 394                 if (find(existing.begin(), existing.end(), trial) == existing.end()) {
 395                         return trial;
 396                 }
 397         }
 398
 399         DCP_ASSERT (false);
 400 }
 401
 402
 403 ASDCPErrorSuspender::ASDCPErrorSuspender ()
 404         : _old (Kumu::DefaultLogSink())
 405 {
 406         _sink = new Kumu::EntryListLogSink(_log);
 407         Kumu::SetDefaultLogSink (_sink);
 408 }
 409
 410
 411 ASDCPErrorSuspender::~ASDCPErrorSuspender ()
 412 {
 413         Kumu::SetDefaultLogSink (&_old);
 414         delete _sink;
 415 }
 416
 417
 418 boost::filesystem::path dcp::directory_containing_executable ()
 419 {
 420 #if BOOST_VERSION >= 106100
 421         return boost::filesystem::canonical(boost::dll::program_location().parent_path());
 422 #else
 423         char buffer[PATH_MAX];
 424         ssize_t N = readlink ("/proc/self/exe", buffer, PATH_MAX);
 425         return boost::filesystem::path(string(buffer, N)).parent_path();
 426 #endif
 427 }
 428
 429
 430 boost::filesystem::path dcp::resources_directory ()
 431 {
 432         /* We need a way to specify the tags directory for running un-installed binaries */
 433         char* prefix = getenv("LIBDCP_RESOURCES");
 434         if (prefix) {
 435                 return prefix;
 436         }
 437
 438 #if defined(LIBDCP_OSX)
 439         return directory_containing_executable().parent_path() / "Resources";
 440 #elif defined(LIBDCP_WINDOWS)
 441         return directory_containing_executable().parent_path();
 442 #else
 443         return directory_containing_executable().parent_path() / "share" / "libdcp";
 444 #endif
 445 }
 446
 447