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 std::string & 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.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                 /* filesystem may be mounted read-only, so even though file
 115                  * permissions permit access, the mount status does not.
 116                  * access(2) seems like the best test for this.
 117                  */
 118                 if (g_access (p.to_string().c_str(), W_OK) != 0) {
 119                         return false;
 120                 }
 121         }
 122
 123         return true;
 124 }
 125
 126
 127 bool
 128 is_directory (const path & p)
 129 {
 130         return Glib::file_test (p.to_string(), Glib::FILE_TEST_IS_DIR);
 131 }
 132
 133 bool
 134 create_directory(const path & p)
 135 {
 136         if(is_directory(p)) return false;
 137
 138         int error = g_mkdir (p.to_string().c_str(), S_IRWXU|S_IRWXG|S_IRWXO);
 139
 140         if(error == -1)
 141         {
 142                 throw filesystem_error(g_strerror(errno), errno);
 143         }
 144         return true;
 145 }
 146
 147 bool
 148 create_directories(const path & p)
 149 {
 150         if(is_directory(p)) return false;
 151
 152         int error = g_mkdir_with_parents (p.to_string().c_str(), S_IRWXU|S_IRWXG|S_IRWXO);
 153
 154         if(error == -1)
 155         {
 156                 throw filesystem_error(g_strerror(errno), errno);
 157         }
 158         return true;
 159 }
 160
 161 bool
 162 remove(const path & p)
 163 {
 164         if(!exists(p)) return false;
 165
 166         int error = g_unlink (p.to_string().c_str());
 167
 168         if(error == -1)
 169         {
 170                 throw filesystem_error(g_strerror(errno), errno);
 171         }
 172         return true;
 173 }
 174
 175 void
 176 rename (const path & from_path, const path & to_path)
 177 {
 178         // g_rename is a macro that evaluates to ::rename on
 179         // POSIX systems, without the global namespace qualifier
 180         // it would evaluate to a recursive call(if it compiled)
 181         if ( ::g_rename( from_path.to_string().c_str(),
 182                                 to_path.to_string().c_str() ) == -1 )
 183         {
 184                 throw filesystem_error(g_strerror(errno), errno);
 185         }
 186 }
 187
 188 string
 189 basename (const path & p)
 190 {
 191         string base(p.leaf());
 192
 193         string::size_type n = base.rfind ('.');
 194
 195         return base.substr (0, n);
 196 }
 197
 198 string
 199 extension (const path & p)
 200 {
 201         string base(p.leaf());
 202
 203         string::size_type n = base.rfind ('.');
 204
 205         if (n != string::npos)
 206         {
 207                 return base.substr(n);
 208         }
 209
 210         return string();
 211
 212 }
 213
 214 } // namespace sys
 215
 216 } // namespace PBD