src/file.cc

   1 /*
   2     Copyright (C) 2022 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 #include "dcp_assert.h"
  36 #include "file.h"
  37
  38
  39 using namespace dcp;
  40
  41
  42 File::~File()
  43 {
  44         close();
  45 }
  46
  47
  48 File::File(boost::filesystem::path path, std::string mode)
  49         : _path(path)
  50 {
  51 #ifdef LIBDCP_WINDOWS
  52         std::wstring mode_wide(mode.begin(), mode.end());
  53         /* c_str() here should give a UTF-16 string */
  54         _file = _wfopen(fix_long_path(path).c_str(), mode_wide.c_str());
  55 #else
  56         _file = fopen(path.c_str(), mode.c_str());
  57 #endif
  58 }
  59
  60
  61 void
  62 File::close()
  63 {
  64         if (_file) {
  65                 fclose(_file);
  66                 _file = nullptr;
  67         }
  68 }
  69
  70
  71 size_t
  72 File::write(const void *ptr, size_t size, size_t nmemb)
  73 {
  74         DCP_ASSERT(_file);
  75         return fwrite(ptr, size, nmemb, _file);
  76 }
  77
  78
  79 size_t
  80 File::read(void *ptr, size_t size, size_t nmemb)
  81 {
  82         DCP_ASSERT(_file);
  83         return fread(ptr, size, nmemb, _file);
  84 }
  85
  86
  87 int
  88 File::eof()
  89 {
  90         DCP_ASSERT(_file);
  91         return feof(_file);
  92 }
  93
  94
  95 char *
  96 File::gets(char *s, int size)
  97 {
  98         DCP_ASSERT(_file);
  99         return fgets(s, size, _file);
 100 }
 101
 102
 103 File::operator bool() const
 104 {
 105         return _file != nullptr;
 106 }
 107
 108
 109 void
 110 File::checked_write(void const * ptr, size_t size)
 111 {
 112         size_t N = write(ptr, 1, size);
 113         if (N != size) {
 114                 if (ferror(_file)) {
 115                         throw FileError("fwrite error", _path, errno);
 116                 } else {
 117                         throw FileError("Unexpected short write", _path, 0);
 118                 }
 119         }
 120 }
 121
 122
 123 void
 124 File::checked_read(void* ptr, size_t size)
 125 {
 126         size_t N = read(ptr, 1, size);
 127         if (N != size) {
 128                 if (ferror(_file)) {
 129                         throw FileError("fread error %1", _path, errno);
 130                 } else {
 131                         throw FileError("Unexpected short read", _path, 0);
 132                 }
 133         }
 134 }
 135
 136
 137 FILE*
 138 File::take()
 139 {
 140         auto give = _file;
 141         _file = nullptr;
 142         return give;
 143 }
 144
 145
 146 int
 147 File::seek(int64_t offset, int whence)
 148 {
 149         DCP_ASSERT(_file);
 150 #ifdef LIBDCP_WINDOWS
 151         return fseeki64(_file, offset, whence);
 152 #else
 153         return fseek(_file, offset, whence);
 154 #endif
 155 }
 156
 157
 158 /** Windows can't "by default" cope with paths longer than 260 characters, so if you pass such a path to
 159  *  any boost::filesystem method it will fail.  There is a "fix" for this, which is to prepend
 160  *  the string \\?\ to the path.  This will make it work, so long as:
 161  *  - the path is absolute.
 162  *  - the path only uses backslashes.
 163  *  - individual path components are "short enough" (probably less than 255 characters)
 164  *
 165  *  See https://www.boost.org/doc/libs/1_57_0/libs/filesystem/doc/reference.html under
 166  *  "Warning: Long paths on Windows" for some details.
 167  *
 168  *  Our fopen_boost uses this method to get this fix, but any other calls to boost::filesystem
 169  *  will not unless this method is explicitly called to pre-process the pathname.
 170  */
 171 boost::filesystem::path
 172 dcp::fix_long_path (boost::filesystem::path long_path)
 173 {
 174 #ifdef LIBDCP_WINDOWS
 175         using namespace boost::filesystem;
 176
 177         if (boost::algorithm::starts_with(long_path.string(), "\\\\")) {
 178                 /* This could mean it starts with \\ (i.e. a SMB path) or \\?\ (a long path)
 179                  * or a variety of other things... anyway, we'll leave it alone.
 180                  */
 181                 return long_path;
 182         }
 183
 184         /* We have to make the path canonical but we can't call canonical() on the long path
 185          * as it will fail.  So we'll sort of do it ourselves (possibly badly).
 186          */
 187         path fixed = "\\\\?\\";
 188         if (long_path.is_absolute()) {
 189                 fixed += long_path.make_preferred();
 190         } else {
 191                 fixed += boost::filesystem::current_path() / long_path.make_preferred();
 192         }
 193         return fixed;
 194 #else
 195         return long_path;
 196 #endif
 197 }