src/util.cc

   1 /*
   2     Copyright (C) 2012-2020 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 /** @file  src/util.cc
  35  *  @brief Utility methods.
  36  */
  37
  38 #include "util.h"
  39 #include "language_tag.h"
  40 #include "exceptions.h"
  41 #include "types.h"
  42 #include "certificate.h"
  43 #include "openjpeg_image.h"
  44 #include "dcp_assert.h"
  45 #include "compose.hpp"
  46 #include <openjpeg.h>
  47 #include <asdcp/KM_util.h>
  48 #include <asdcp/KM_fileio.h>
  49 #include <asdcp/AS_DCP.h>
  50 #include <xmlsec/xmldsig.h>
  51 #include <xmlsec/dl.h>
  52 #include <xmlsec/app.h>
  53 #include <xmlsec/crypto.h>
  54 #include <libxml++/nodes/element.h>
  55 #include <libxml++/document.h>
  56 #include <openssl/sha.h>
  57 #include <boost/filesystem.hpp>
  58 #include <boost/algorithm/string.hpp>
  59 #include <stdexcept>
  60 #include <iostream>
  61 #include <iomanip>
  62
  63 using std::string;
  64 using std::wstring;
  65 using std::cout;
  66 using std::min;
  67 using std::max;
  68 using std::setw;
  69 using std::setfill;
  70 using std::ostream;
  71 using std::shared_ptr;
  72 using std::vector;
  73 using boost::shared_array;
  74 using boost::optional;
  75 using boost::function;
  76 using boost::algorithm::trim;
  77 using namespace dcp;
  78
  79
  80 /* Some ASDCP objects store this as a *&, for reasons which are not
  81  * at all clear, so we have to keep this around forever.
  82  */
  83 ASDCP::Dictionary const* dcp::asdcp_smpte_dict = 0;
  84
  85
  86 /** Create a UUID.
  87  *  @return UUID.
  88  */
  89 string
  90 dcp::make_uuid ()
  91 {
  92         char buffer[64];
  93         Kumu::UUID id;
  94         Kumu::GenRandomValue (id);
  95         id.EncodeHex (buffer, 64);
  96         return string (buffer);
  97 }
  98
  99 string
 100 dcp::make_digest (ArrayData data)
 101 {
 102         SHA_CTX sha;
 103         SHA1_Init (&sha);
 104         SHA1_Update (&sha, data.data(), data.size());
 105         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 106         SHA1_Final (byte_buffer, &sha);
 107         char digest[64];
 108         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 109 }
 110
 111 /** Create a digest for a file.
 112  *  @param filename File name.
 113  *  @param progress Optional progress reporting function.  The function will be called
 114  *  with a progress value between 0 and 1.
 115  *  @return Digest.
 116  */
 117 string
 118 dcp::make_digest (boost::filesystem::path filename, function<void (float)> progress)
 119 {
 120         Kumu::FileReader reader;
 121         Kumu::Result_t r = reader.OpenRead (filename.string().c_str ());
 122         if (ASDCP_FAILURE (r)) {
 123                 boost::throw_exception (FileError ("could not open file to compute digest", filename, r));
 124         }
 125
 126         SHA_CTX sha;
 127         SHA1_Init (&sha);
 128
 129         int const buffer_size = 65536;
 130         Kumu::ByteString read_buffer (buffer_size);
 131
 132         Kumu::fsize_t done = 0;
 133         Kumu::fsize_t const size = reader.Size ();
 134         while (1) {
 135                 ui32_t read = 0;
 136                 Kumu::Result_t r = reader.Read (read_buffer.Data(), read_buffer.Capacity(), &read);
 137
 138                 if (r == Kumu::RESULT_ENDOFFILE) {
 139                         break;
 140                 } else if (ASDCP_FAILURE (r)) {
 141                         boost::throw_exception (FileError ("could not read file to compute digest", filename, r));
 142                 }
 143
 144                 SHA1_Update (&sha, read_buffer.Data(), read);
 145
 146                 if (progress) {
 147                         progress (float (done) / size);
 148                         done += read;
 149                 }
 150         }
 151
 152         byte_t byte_buffer[SHA_DIGEST_LENGTH];
 153         SHA1_Final (byte_buffer, &sha);
 154
 155         char digest[64];
 156         return Kumu::base64encode (byte_buffer, SHA_DIGEST_LENGTH, digest, 64);
 157 }
 158
 159 /** @param s A string.
 160  *  @return true if the string contains only space, newline or tab characters, or is empty.
 161  */
 162 bool
 163 dcp::empty_or_white_space (string s)
 164 {
 165         for (size_t i = 0; i < s.length(); ++i) {
 166                 if (s[i] != ' ' && s[i] != '\n' && s[i] != '\t') {
 167                         return false;
 168                 }
 169         }
 170
 171         return true;
 172 }
 173
 174 /** Set up various bits that the library needs.  Should be called once
 175  *  by client applications.
 176  *
 177  *  @param tags_directory Path to a copy of the tags directory from the source code;
 178  *  if none is specified libdcp will look for a tags directory inside the environment
 179  *  variable LIBDCP_SHARE_PREFIX or the LIBDCP_SHARE_PREFIX #defined during the build.
 180  */
 181 void
 182 dcp::init (optional<boost::filesystem::path> tags_directory)
 183 {
 184         if (xmlSecInit() < 0) {
 185                 throw MiscError ("could not initialise xmlsec");
 186         }
 187
 188 #ifdef XMLSEC_CRYPTO_DYNAMIC_LOADING
 189         if (xmlSecCryptoDLLoadLibrary(BAD_CAST "openssl") < 0) {
 190                 throw MiscError ("unable to load openssl xmlsec-crypto library");
 191         }
 192 #endif
 193
 194         if (xmlSecCryptoAppInit(0) < 0) {
 195                 throw MiscError ("could not initialise crypto");
 196         }
 197
 198         if (xmlSecCryptoInit() < 0) {
 199                 throw MiscError ("could not initialise xmlsec-crypto");
 200         }
 201
 202         OpenSSL_add_all_algorithms();
 203
 204         asdcp_smpte_dict = &ASDCP::DefaultSMPTEDict();
 205
 206         if (!tags_directory) {
 207                 char* prefix = getenv("LIBDCP_SHARE_PREFIX");
 208                 if (prefix) {
 209                         tags_directory = boost::filesystem::path(prefix) / "tags";
 210                 } else {
 211                         tags_directory = LIBDCP_SHARE_PREFIX "/tags";
 212                 }
 213         }
 214
 215         load_language_tag_lists (*tags_directory);
 216 }
 217
 218 /** Decode a base64 string.  The base64 decode routine in KM_util.cpp
 219  *  gives different values to both this and the command-line base64
 220  *  for some inputs.  Not sure why.
 221  *
 222  *  @param in base64-encoded string.
 223  *  @param out Output buffer.
 224  *  @param out_length Length of output buffer.
 225  *  @return Number of characters written to the output buffer.
 226  */
 227 int
 228 dcp::base64_decode (string const & in, unsigned char* out, int out_length)
 229 {
 230         BIO* b64 = BIO_new (BIO_f_base64 ());
 231
 232         /* This means the input should have no newlines */
 233         BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
 234
 235         /* Copy our input string, removing newlines */
 236         char in_buffer[in.size() + 1];
 237         char* p = in_buffer;
 238         for (size_t i = 0; i < in.size(); ++i) {
 239                 if (in[i] != '\n' && in[i] != '\r') {
 240                         *p++ = in[i];
 241                 }
 242         }
 243
 244         BIO* bmem = BIO_new_mem_buf (in_buffer, p - in_buffer);
 245         bmem = BIO_push (b64, bmem);
 246         int const N = BIO_read (bmem, out, out_length);
 247         BIO_free_all (bmem);
 248
 249         return N;
 250 }
 251
 252 /** @param p Path to open.
 253  *  @param t mode flags, as for fopen(3).
 254  *  @return FILE pointer or 0 on error.
 255  *
 256  *  Apparently there is no way to create an ofstream using a UTF-8
 257  *  filename under Windows.  We are hence reduced to using fopen
 258  *  with this wrapper.
 259  */
 260 FILE *
 261 dcp::fopen_boost (boost::filesystem::path p, string t)
 262 {
 263 #ifdef LIBDCP_WINDOWS
 264         wstring w (t.begin(), t.end());
 265         /* c_str() here should give a UTF-16 string */
 266         return _wfopen (p.c_str(), w.c_str ());
 267 #else
 268         return fopen (p.c_str(), t.c_str ());
 269 #endif
 270 }
 271
 272 optional<boost::filesystem::path>
 273 dcp::relative_to_root (boost::filesystem::path root, boost::filesystem::path file)
 274 {
 275         boost::filesystem::path::const_iterator i = root.begin ();
 276         boost::filesystem::path::const_iterator j = file.begin ();
 277
 278         while (i != root.end() && j != file.end() && *i == *j) {
 279                 ++i;
 280                 ++j;
 281         }
 282
 283         if (i != root.end ()) {
 284                 return optional<boost::filesystem::path> ();
 285         }
 286
 287         boost::filesystem::path rel;
 288         while (j != file.end ()) {
 289                 rel /= *j++;
 290         }
 291
 292         return rel;
 293 }
 294
 295 bool
 296 dcp::ids_equal (string a, string b)
 297 {
 298         transform (a.begin(), a.end(), a.begin(), ::tolower);
 299         transform (b.begin(), b.end(), b.begin(), ::tolower);
 300         trim (a);
 301         trim (b);
 302         return a == b;
 303 }
 304
 305 string
 306 dcp::file_to_string (boost::filesystem::path p, uintmax_t max_length)
 307 {
 308         uintmax_t len = boost::filesystem::file_size (p);
 309         if (len > max_length) {
 310                 throw MiscError (String::compose ("Unexpectedly long file (%1)", p.string()));
 311         }
 312
 313         FILE* f = fopen_boost (p, "r");
 314         if (!f) {
 315                 throw FileError ("could not open file", p, errno);
 316         }
 317
 318         char* c = new char[len];
 319         /* This may read less than `len' if we are on Windows and we have CRLF in the file */
 320         int const N = fread (c, 1, len, f);
 321         fclose (f);
 322
 323         string s (c, N);
 324         delete[] c;
 325
 326         return s;
 327 }
 328
 329 /** @param key RSA private key in PEM format (optionally with -----BEGIN... / -----END...)
 330  *  @return SHA1 fingerprint of key
 331  */
 332 string
 333 dcp::private_key_fingerprint (string key)
 334 {
 335         boost::replace_all (key, "-----BEGIN RSA PRIVATE KEY-----\n", "");
 336         boost::replace_all (key, "\n-----END RSA PRIVATE KEY-----\n", "");
 337
 338         unsigned char buffer[4096];
 339         int const N = base64_decode (key, buffer, sizeof (buffer));
 340
 341         SHA_CTX sha;
 342         SHA1_Init (&sha);
 343         SHA1_Update (&sha, buffer, N);
 344         uint8_t digest[20];
 345         SHA1_Final (digest, &sha);
 346
 347         char digest_base64[64];
 348         return Kumu::base64encode (digest, 20, digest_base64, 64);
 349 }
 350
 351 xmlpp::Node *
 352 dcp::find_child (xmlpp::Node const * node, string name)
 353 {
 354         xmlpp::Node::NodeList c = node->get_children ();
 355         xmlpp::Node::NodeList::iterator i = c.begin();
 356         while (i != c.end() && (*i)->get_name() != name) {
 357                 ++i;
 358         }
 359
 360         DCP_ASSERT (i != c.end ());
 361         return *i;
 362 }
 363
 364 string
 365 dcp::remove_urn_uuid (string raw)
 366 {
 367         DCP_ASSERT (raw.substr(0, 9) == "urn:uuid:");
 368         return raw.substr (9);
 369 }
 370
 371 string
 372 dcp::openjpeg_version ()
 373 {
 374         return opj_version ();
 375 }
 376
 377 string
 378 dcp::spaces (int n)
 379 {
 380         string s = "";
 381         for (int i = 0; i < n; ++i) {
 382                 s += " ";
 383         }
 384         return s;
 385 }
 386
 387 void
 388 dcp::indent (xmlpp::Element* element, int initial)
 389 {
 390         xmlpp::Node* last = 0;
 391         for (auto n: element->get_children()) {
 392                 auto e = dynamic_cast<xmlpp::Element*>(n);
 393                 if (e) {
 394                         element->add_child_text_before (e, "\n" + spaces(initial + 2));
 395                         indent (e, initial + 2);
 396                         last = n;
 397                 }
 398         }
 399         if (last) {
 400                 element->add_child_text (last, "\n" + spaces(initial));
 401         }
 402 }
 403
 404 /** @return true if the day represented by \ref a is less than or
 405  *  equal to the one represented by \ref b, ignoring the time parts.
 406  */
 407 bool
 408 dcp::day_less_than_or_equal (LocalTime a, LocalTime b)
 409 {
 410         if (a.year() != b.year()) {
 411                 return a.year() < b.year();
 412         }
 413
 414         if (a.month() != b.month()) {
 415                 return a.month() < b.month();
 416         }
 417
 418         return a.day() <= b.day();
 419 }
 420
 421 /** @return true if the day represented by \ref a is greater than or
 422  *  equal to the one represented by \ref b, ignoring the time parts.
 423  */
 424 bool
 425 dcp::day_greater_than_or_equal (LocalTime a, LocalTime b)
 426 {
 427         if (a.year() != b.year()) {
 428                 return a.year() > b.year();
 429         }
 430
 431         if (a.month() != b.month()) {
 432                 return a.month() > b.month();
 433         }
 434
 435         return a.day() >= b.day();
 436 }
 437
 438 /** Try quite hard to find a string which starts with \ref base and is
 439  *  not in \ref existing.
 440  */
 441 string
 442 dcp::unique_string (vector<string> existing, string base)
 443 {
 444         int const max_tries = existing.size() + 1;
 445         for (int i = 0; i < max_tries; ++i) {
 446                 string trial = String::compose("%1%2", base, i);
 447                 if (find(existing.begin(), existing.end(), trial) == existing.end()) {
 448                         return trial;
 449                 }
 450         }
 451
 452         DCP_ASSERT (false);
 453 }
 454
 455
 456 ASDCPErrorSuspender::ASDCPErrorSuspender ()
 457         : _old (Kumu::DefaultLogSink())
 458 {
 459         _sink = new Kumu::EntryListLogSink(_log);
 460         Kumu::SetDefaultLogSink (_sink);
 461 }
 462
 463
 464 ASDCPErrorSuspender::~ASDCPErrorSuspender ()
 465 {
 466         Kumu::SetDefaultLogSink (&_old);
 467         delete _sink;
 468 }
 469