libs/pbd/filesystem.cc

   1 /*
   2         Copyright (C) 2007 Tim Mayberry
   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 #include <sys/stat.h>
  20
  21 #include <glib.h>
  22 #include <glib/gstdio.h>
  23
  24 #include <giomm/file.h>
  25
  26 #include <cerrno>
  27 #include <fstream>
  28
  29 #include <glibmm/fileutils.h>
  30 #include <glibmm/miscutils.h>
  31
  32 #include "pbd/filesystem.h"
  33 #include "pbd/error.h"
  34 #include "pbd/compose.h"
  35 #include "pbd/pathscanner.h"
  36
  37 #include "i18n.h"
  38
  39 using namespace std;
  40
  41 namespace PBD {
  42
  43 namespace sys {
  44
  45 path&
  46 path::operator/=(const path& rhs)
  47 {
  48         m_path = Glib::build_filename(m_path, rhs.m_path);
  49         return *this;
  50 }
  51
  52 path&
  53 path::operator/=(const string& rhs)
  54 {
  55         m_path = Glib::build_filename(m_path, rhs);
  56         return *this;
  57 }
  58
  59 path&
  60 path::operator/=(const char* rhs)
  61 {
  62         m_path = Glib::build_filename(m_path, rhs);
  63         return *this;
  64 }
  65
  66 string
  67 path::leaf () const
  68 {
  69         return Glib::path_get_basename(m_path);
  70 }
  71
  72 path
  73 path::branch_path () const
  74 {
  75         string dir = Glib::path_get_dirname (m_path);
  76
  77         /*
  78          * glib returns "." to signify that the path
  79          * has no directory components(branch path)
  80          * whereas boost::filesystem returns an empty
  81          * string
  82          */
  83         if(dir == ".")
  84         {
  85                 return "";
  86         }
  87         return dir;
  88 }
  89
  90 bool
  91 exists (const path & p)
  92 {
  93         return Glib::file_test (p.to_string(), Glib::FILE_TEST_EXISTS);
  94 }
  95
  96 bool
  97 exists_and_writable (const path & p)
  98 {
  99         /* writable() really reflects the whole folder, but if for any
 100            reason the session state file can't be written to, still
 101            make us unwritable.
 102         */
 103
 104         struct stat statbuf;
 105
 106         if (g_stat (p.to_string().c_str(), &statbuf) != 0) {
 107                 /* doesn't exist - not writable */
 108                 return false;
 109         } else {
 110                 if (!(statbuf.st_mode & S_IWUSR)) {
 111                         /* exists and is not writable */
 112                         return false;
 113                 }
 114         }
 115
 116         return true;
 117 }
 118
 119
 120 bool
 121 is_directory (const path & p)
 122 {
 123         return Glib::file_test (p.to_string(), Glib::FILE_TEST_IS_DIR);
 124 }
 125
 126 bool
 127 create_directory(const path & p)
 128 {
 129         if(is_directory(p)) return false;
 130
 131         int error = g_mkdir (p.to_string().c_str(), S_IRWXU|S_IRWXG|S_IRWXO);
 132
 133         if(error == -1)
 134         {
 135                 throw filesystem_error(g_strerror(errno), errno);
 136         }
 137         return true;
 138 }
 139
 140 bool
 141 create_directories(const path & p)
 142 {
 143         if(is_directory(p)) return false;
 144
 145         int error = g_mkdir_with_parents (p.to_string().c_str(), S_IRWXU|S_IRWXG|S_IRWXO);
 146
 147         if(error == -1)
 148         {
 149                 throw filesystem_error(g_strerror(errno), errno);
 150         }
 151         return true;
 152 }
 153
 154 bool
 155 remove(const path & p)
 156 {
 157         if(!exists(p)) return false;
 158
 159         int error = g_unlink (p.to_string().c_str());
 160
 161         if(error == -1)
 162         {
 163                 throw filesystem_error(g_strerror(errno), errno);
 164         }
 165         return true;
 166 }
 167
 168 void
 169 rename (const path & from_path, const path & to_path)
 170 {
 171         // g_rename is a macro that evaluates to ::rename on
 172         // POSIX systems, without the global namespace qualifier
 173         // it would evaluate to a recursive call(if it compiled)
 174         if ( ::g_rename( from_path.to_string().c_str(),
 175                                 to_path.to_string().c_str() ) == -1 )
 176         {
 177                 throw filesystem_error(g_strerror(errno), errno);
 178         }
 179 }
 180
 181 // XXX character encoding.
 182 void
 183 copy_file(const path & from_path, const path & to_path)
 184 {
 185         std::ifstream in(from_path.to_string().c_str());
 186         std::ofstream out(to_path.to_string().c_str());
 187
 188         if (!in || !out) {
 189                 throw filesystem_error(string_compose(_("Could not open files %1 and %2 for copying"),
 190                                         from_path.to_string(), to_path.to_string()));
 191         }
 192
 193         out << in.rdbuf();
 194
 195         if (!in || !out) {
 196                 remove (to_path);
 197                 throw filesystem_error(string_compose(_("Could not copy existing file %1 to %2"),
 198                                         from_path.to_string(), to_path.to_string()));
 199         }
 200 }
 201
 202 static
 203 bool accept_all_files (string const &, void *)
 204 {
 205         return true;
 206 }
 207
 208 void
 209 copy_files(const path & from_path, const path & to_dir)
 210 {
 211         PathScanner scanner;
 212         vector<string*>* files = scanner (from_path.to_string(), accept_all_files, 0, true, false);
 213         for (vector<string*>::iterator i = files->begin(); i != files->end(); ++i) {
 214                 sys::path from = from_path;
 215                 from /= **i;
 216                 sys::path to = to_dir;
 217                 to /= **i;
 218
 219                 copy_file (from, to);
 220         }
 221 }
 222
 223 string
 224 basename (const path & p)
 225 {
 226         string base(p.leaf());
 227
 228         string::size_type n = base.rfind ('.');
 229
 230         return base.substr (0, n);
 231 }
 232
 233 string
 234 extension (const path & p)
 235 {
 236         string base(p.leaf());
 237
 238         string::size_type n = base.rfind ('.');
 239
 240         if (n != string::npos)
 241         {
 242                 return base.substr(n);
 243         }
 244
 245         return string();
 246
 247 }
 248
 249 /** Take a (possibly) relative path and make it absolute */
 250 path
 251 get_absolute_path (const path & p)
 252 {
 253         Glib::RefPtr<Gio::File> f = Gio::File::create_for_path (p.to_string ());
 254         return f->get_path ();
 255 }
 256
 257 /** @return true if a and b have the same inode */
 258 bool
 259 inodes_same (const path& a, const path& b)
 260 {
 261         struct stat bA;
 262         int const rA = stat (a.to_string().c_str(), &bA);
 263         struct stat bB;
 264         int const rB = stat (b.to_string().c_str(), &bB);
 265
 266         return (rA == 0 && rB == 0 && bA.st_ino == bB.st_ino);
 267 }
 268
 269 /** Find out if `needle' is a file or directory within the
 270  *  directory `haystack'.
 271  *  @return true if it is.
 272  */
 273 bool
 274 path_is_within (path const & haystack, path needle)
 275 {
 276         while (1) {
 277                 if (inodes_same (haystack, needle)) {
 278                         return true;
 279                 }
 280
 281                 needle = needle.branch_path ();
 282                 if (needle.to_string().empty() || needle.to_string() == "/") {
 283                         break;
 284                 }
 285         }
 286
 287         return false;
 288 }
 289
 290 } // namespace sys
 291
 292 } // namespace PBD