libs/ardour/file_source.cc

   1 /*
   2     Copyright (C) 2006-2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <vector>
  21
  22 #include <sys/time.h>
  23 #include <sys/stat.h>
  24 #include <stdio.h> // for rename(), sigh
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28
  29 #include "pbd/convert.h"
  30 #include "pbd/basename.h"
  31 #include "pbd/mountpoint.h"
  32 #include "pbd/stl_delete.h"
  33 #include "pbd/strsplit.h"
  34 #include "pbd/shortpath.h"
  35 #include "pbd/enumwriter.h"
  36
  37 #include <glibmm/miscutils.h>
  38 #include <glibmm/fileutils.h>
  39 #include <glibmm/thread.h>
  40
  41 #include "ardour/file_source.h"
  42 #include "ardour/directory_names.h"
  43 #include "ardour/session.h"
  44 #include "ardour/session_directory.h"
  45 #include "ardour/source_factory.h"
  46 #include "ardour/filename_extensions.h"
  47
  48 #include "i18n.h"
  49
  50 using namespace std;
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53 using namespace Glib;
  54
  55 map<DataType, ustring> FileSource::search_paths;
  56
  57 FileSource::FileSource (Session& session, DataType type, const ustring& path, Source::Flag flag)
  58         : Source(session, type, path, flag)
  59         , _path(path)
  60         , _file_is_new(true)
  61         , _channel (0)
  62 {
  63         set_within_session_from_path (path);
  64 }
  65
  66 FileSource::FileSource (Session& session, const XMLNode& node, bool /*must_exist*/)
  67         : Source(session, node)
  68         , _file_is_new (false)
  69 {
  70         /* this setting of _path is temporary - we expect derived classes
  71            to call ::init() which will actually locate the file
  72            and reset _path and _within_session correctly.
  73         */
  74
  75         _path = _name;
  76         _within_session = true;
  77 }
  78
  79 bool
  80 FileSource::removable () const
  81 {
  82         bool r = (_path.find (stub_dir_name) != string::npos) ||
  83                 ((_flags & Removable)
  84                  && ((_flags & RemoveAtDestroy) ||
  85                      ((_flags & RemovableIfEmpty) && empty() == 0)));
  86
  87         cerr << "is " << _path << " removable ? " << r << endl;
  88
  89         return r;
  90 }
  91
  92 int
  93 FileSource::init (const ustring& pathstr, bool must_exist)
  94 {
  95         _timeline_position = 0;
  96
  97         if (!find (_type, pathstr, must_exist, _file_is_new, _channel, _path)) {
  98                 throw MissingSource ();
  99         }
 100
 101         set_within_session_from_path (pathstr);
 102
 103         if (_within_session) {
 104                 _name = Glib::path_get_basename (_name);
 105         }
 106
 107         if (_file_is_new && must_exist) {
 108                 return -1;
 109         }
 110
 111         return 0;
 112 }
 113
 114 int
 115 FileSource::set_state (const XMLNode& node, int /*version*/)
 116 {
 117         const XMLProperty* prop;
 118
 119         if ((prop = node.property (X_("channel"))) != 0) {
 120                 _channel = atoi (prop->value());
 121         } else {
 122                 _channel = 0;
 123         }
 124
 125         return 0;
 126 }
 127
 128 void
 129 FileSource::mark_take (const ustring& id)
 130 {
 131         if (writable ()) {
 132                 _take_id = id;
 133         }
 134 }
 135
 136 int
 137 FileSource::move_to_trash (const ustring& trash_dir_name)
 138 {
 139         if (!within_session() || !writable()) {
 140                 return -1;
 141         }
 142
 143         /* don't move the file across filesystems, just stick it in the
 144            trash_dir_name directory on whichever filesystem it was already on
 145         */
 146
 147         vector<string> v;
 148         v.push_back (Glib::path_get_dirname (Glib::path_get_dirname (_path)));
 149         v.push_back (trash_dir_name);
 150         v.push_back (Glib::path_get_basename (_path));
 151
 152         string newpath = Glib::build_filename (v);
 153
 154         /* the new path already exists, try versioning */
 155
 156         if (Glib::file_test (newpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 157                 char buf[PATH_MAX+1];
 158                 int version = 1;
 159                 ustring newpath_v;
 160
 161                 snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
 162                 newpath_v = buf;
 163
 164                 while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
 165                         snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
 166                         newpath_v = buf;
 167                 }
 168
 169                 if (version == 999) {
 170                         PBD::error << string_compose (
 171                                         _("there are already 1000 files with names like %1; versioning discontinued"),
 172                                         newpath) << endmsg;
 173                 } else {
 174                         newpath = newpath_v;
 175                 }
 176         }
 177
 178         if (::rename (_path.c_str(), newpath.c_str()) != 0) {
 179                 PBD::error << string_compose (
 180                                 _("cannot rename file source from %1 to %2 (%3)"),
 181                                 _path, newpath, strerror (errno)) << endmsg;
 182                 return -1;
 183         }
 184
 185         if (move_dependents_to_trash() != 0) {
 186                 /* try to back out */
 187                 rename (newpath.c_str(), _path.c_str());
 188                 return -1;
 189         }
 190
 191         _path = newpath;
 192
 193         /* file can not be removed twice, since the operation is not idempotent */
 194         _flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
 195
 196         return 0;
 197 }
 198
 199 /** Find the actual source file based on \a filename.
 200  *
 201  * If the source is within the session tree, \a filename should be a simple filename (no slashes).
 202  * If the source is external, \a filename should be a full path.
 203  * In either case, found_path is set to the complete absolute path of the source file.
 204  * \return true iff the file was found.
 205  */
 206 bool
 207 FileSource::find (DataType type, const ustring& path, bool must_exist,
 208                   bool& isnew, uint16_t& chan, ustring& found_path)
 209 {
 210         Glib::ustring search_path = search_paths[type];
 211
 212         ustring pathstr = path;
 213         ustring::size_type pos;
 214         bool ret = false;
 215
 216         isnew = false;
 217
 218         if (pathstr[0] != '/') {
 219
 220                 /* non-absolute pathname: find pathstr in search path */
 221
 222                 vector<ustring> dirs;
 223                 int cnt;
 224                 ustring fullpath;
 225                 ustring keeppath;
 226
 227                 if (search_path.length() == 0) {
 228                         error << _("FileSource: search path not set") << endmsg;
 229                         goto out;
 230                 }
 231
 232                 split (search_path, dirs, ':');
 233
 234                 cnt = 0;
 235
 236                 for (vector<ustring>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
 237                         fullpath = *i;
 238                         if (fullpath[fullpath.length()-1] != '/') {
 239                                 fullpath += '/';
 240                         }
 241
 242                         fullpath += pathstr;
 243
 244                         /* i (paul) made a nasty design error by using ':' as a special character in
 245                            Ardour 0.99 .. this hack tries to make things sort of work.
 246                         */
 247
 248                         if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
 249
 250                                 if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 251
 252                                         /* its a real file, no problem */
 253
 254                                         keeppath = fullpath;
 255                                         ++cnt;
 256
 257                                 } else {
 258
 259                                         if (must_exist) {
 260
 261                                                 /* might be an older session using file:channel syntax. see if the version
 262                                                    without the :suffix exists
 263                                                  */
 264
 265                                                 ustring shorter = pathstr.substr (0, pos);
 266                                                 fullpath = *i;
 267
 268                                                 if (fullpath[fullpath.length()-1] != '/') {
 269                                                         fullpath += '/';
 270                                                 }
 271
 272                                                 fullpath += shorter;
 273
 274                                                 if (Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 275                                                         chan = atoi (pathstr.substr (pos+1));
 276                                                         pathstr = shorter;
 277                                                         keeppath = fullpath;
 278                                                         ++cnt;
 279                                                 }
 280
 281                                         } else {
 282
 283                                                 /* new derived file (e.g. for timefx) being created in a newer session */
 284
 285                                         }
 286                                 }
 287
 288                         } else {
 289
 290                                 if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 291                                         keeppath = fullpath;
 292                                         ++cnt;
 293                                 }
 294                         }
 295                 }
 296
 297                 if (cnt > 1) {
 298
 299                         error << string_compose (
 300                                         _("FileSource: \"%1\" is ambigous when searching %2\n\t"),
 301                                         pathstr, search_path) << endmsg;
 302                         goto out;
 303
 304                 } else if (cnt == 0) {
 305
 306                         if (must_exist) {
 307                                 error << string_compose(
 308                                                 _("Filesource: cannot find required file (%1): while searching %2"),
 309                                                 pathstr, search_path) << endmsg;
 310                                 goto out;
 311                         } else {
 312                                 isnew = true;
 313                         }
 314                 }
 315
 316                 /* Current find() is unable to parse relative path names to yet non-existant
 317                    sources. QuickFix(tm) */
 318                 if (keeppath == "") {
 319                         if (must_exist) {
 320                                 error << "FileSource::find(), keeppath = \"\", but the file must exist" << endl;
 321                         } else {
 322                                 keeppath = pathstr;
 323                         }
 324                 }
 325
 326                 found_path = keeppath;
 327
 328                 ret = true;
 329
 330         } else {
 331
 332                 /* external files and/or very very old style sessions include full paths */
 333
 334                 /* ugh, handle ':' situation */
 335
 336                 if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
 337
 338                         ustring shorter = pathstr.substr (0, pos);
 339
 340                         if (Glib::file_test (shorter, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 341                                 chan = atoi (pathstr.substr (pos+1));
 342                                 pathstr = shorter;
 343                         }
 344                 }
 345
 346                 found_path = pathstr;
 347
 348                 if (!Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
 349
 350                         /* file does not exist or we cannot read it */
 351
 352                         if (must_exist) {
 353                                 error << string_compose(
 354                                                 _("Filesource: cannot find required file (%1): %2"),
 355                                                 path, strerror (errno)) << endmsg;
 356                                 goto out;
 357                         }
 358
 359                         if (errno != ENOENT) {
 360                                 error << string_compose(
 361                                                 _("Filesource: cannot check for existing file (%1): %2"),
 362                                                 path, strerror (errno)) << endmsg;
 363                                 goto out;
 364                         }
 365
 366                         /* a new file */
 367                         isnew = true;
 368                         ret = true;
 369
 370                 } else {
 371
 372                         /* already exists */
 373                         ret = true;
 374                 }
 375         }
 376
 377 out:
 378         return ret;
 379 }
 380
 381 int
 382 FileSource::set_source_name (const ustring& newname, bool destructive)
 383 {
 384         Glib::Mutex::Lock lm (_lock);
 385         ustring oldpath = _path;
 386         ustring newpath = _session.change_source_path_by_name (oldpath, _name, newname, destructive);
 387
 388         if (newpath.empty()) {
 389                 error << string_compose (_("programming error: %1"), "cannot generate a changed file path") << endmsg;
 390                 return -1;
 391         }
 392
 393         // Test whether newpath exists, if yes notify the user but continue.
 394         if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
 395                 error << string_compose (_("Programming error! %1 tried to rename a file over another file! It's safe to continue working, but please report this to the developers."), PROGRAM_NAME) << endmsg;
 396                 return -1;
 397         }
 398
 399         if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
 400                 error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
 401                 return -1;
 402         }
 403
 404         _name = Glib::path_get_basename (newpath);
 405         _path = newpath;
 406
 407         return 0;
 408 }
 409
 410 void
 411 FileSource::set_search_path (DataType type, const ustring& p)
 412 {
 413         search_paths[type] = p;
 414 }
 415
 416 void
 417 FileSource::mark_immutable ()
 418 {
 419         /* destructive sources stay writable, and their other flags don't change.  */
 420         if (!(_flags & Destructive)) {
 421                 _flags = Flag (_flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy|CanRename));
 422         }
 423 }
 424
 425 void
 426 FileSource::mark_nonremovable ()
 427 {
 428         _flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
 429 }
 430
 431 void
 432 FileSource::set_within_session_from_path (const std::string& path)
 433 {
 434         _within_session = _session.path_is_within_session (path);
 435 }
 436
 437 int
 438 FileSource::unstubify ()
 439 {
 440         string::size_type pos = _path.find (stub_dir_name);
 441
 442         if (pos == string::npos || (_flags & Destructive)) {
 443                 return 0;
 444         }
 445
 446         vector<string> v;
 447
 448         v.push_back (Glib::path_get_dirname (Glib::path_get_dirname (_path)));
 449         v.push_back (Glib::path_get_basename(_path));
 450
 451         string newpath = Glib::build_filename (v);
 452
 453         if (::rename (_path.c_str(), newpath.c_str()) != 0) {
 454                 error << string_compose (_("rename from %1 to %2 failed: %3)"), _path, newpath, strerror (errno)) << endmsg;
 455                 return -1;
 456         }
 457
 458         set_path (newpath);
 459
 460         return 0;
 461 }
 462
 463 void
 464 FileSource::set_path (const std::string& newpath)
 465 {
 466         _path = newpath;
 467 }
 468
 469 void
 470 FileSource::inc_use_count ()
 471 {
 472         Source::inc_use_count ();
 473 }
 474