2 The software in this package is distributed under the GNU General
3 Public License version 2 (with a special exception described below).
5 A copy of GNU General Public License (GPL) is included in this distribution,
6 in the file COPYING.GPL.
8 As a special exception, if other files instantiate templates or use macros
9 or inline functions from this file, or you compile this file and link it
10 with other works to produce a work based on this file, this file
11 does not by itself cause the resulting work to be covered
12 by the GNU General Public License.
14 However the source code for this file must still be made available
15 in accordance with section (3) of the GNU General Public License.
17 This exception does not invalidate any other reasons why a work based
18 on this file might be covered by the GNU General Public License.
20 /***************************************************************************
21 filefunc.cpp - functions for working with FS
23 begin : Sun Nov 14 1999
24 copyright : (C) 1999 by Intra2net AG
25 ***************************************************************************/
34 #include <sys/types.h>
36 #include <sys/statvfs.h>
46 #include <boost/scoped_array.hpp>
47 #include <boost/foreach.hpp>
48 #include "filefunc.hxx"
49 #include "stringfunc.hxx"
57 ** implementation of Stat
68 Stat::Stat(const std::string& path, bool follow_links)
70 stat(path,follow_links);
71 } // eo Stat::Stat(const std::string&,bool)
80 * @brief updates the internal data.
82 * In other words: stat()'s the file again.
88 // pass a copy of Path: otherwise clear() would leave an empty reference
89 stat(string(Path), FollowLinks);
91 } // eo Stat::recheck()
95 * @brief calls stat() or lstat() to get the information for the given path
96 * and stores that information.
97 * @param path the path which should be checked
98 * @param follow_links determine if (symbalic) links should be followed.
100 void Stat::stat(const std::string& path, bool follow_links)
104 FollowLinks= follow_links;
105 struct stat stat_info;
107 res = ( follow_links ? ::stat(path.c_str(), &stat_info) : ::lstat(path.c_str(), &stat_info) );
110 Device = stat_info.st_dev;
111 Inode = stat_info.st_ino;
112 Mode = (stat_info.st_mode & ~(S_IFMT));
113 NumLinks = stat_info.st_nlink;
114 Uid = stat_info.st_uid;
115 Gid = stat_info.st_gid;
116 DeviceType = stat_info.st_rdev;
117 Size = stat_info.st_size;
118 Atime = stat_info.st_atime;
119 Mtime = stat_info.st_mtime;
120 Ctime = stat_info.st_atime;
122 // the stat(2) manpage for linux defines that st_blocks is given in a number of 512-byte-blocks.
123 BytesOnDisk = stat_info.st_blocks;
124 BytesOnDisk*=(long long)512;
126 IsLink= S_ISLNK( stat_info.st_mode );
127 IsRegular= S_ISREG( stat_info.st_mode );
128 IsDirectory= S_ISDIR( stat_info.st_mode );
129 IsCharacterDevice= S_ISCHR( stat_info.st_mode );
130 IsBlockDevice= S_ISBLK( stat_info.st_mode );
131 IsFifo= S_ISFIFO( stat_info.st_mode );
132 IsSocket= S_ISSOCK( stat_info.st_mode );
135 } // eo Stat::stat(const std::string&,bool)
139 * @brief clears the internal data.
162 IsCharacterDevice= false;
163 IsBlockDevice= false;
166 } // eo Stat::clear()
170 * @brief checks if another instance describes the same file.
171 * @param rhs the other instance.
172 * @return @a true iff the other instance describes the same file.
174 * The "same file" means that the files are located on the same device and use the same inode.
175 * They might still have two different directory entries (different paths)!
177 bool Stat::is_same_as(const Stat& rhs)
179 return Valid and rhs.Valid
180 and ( Device == rhs.Device)
181 and ( Inode == rhs.Inode);
182 } // eo Stat::is_same_as(const Stat& rhs);
186 * @brief checks if this and the other instance describe the same device.
187 * @param rhs the other instance.
188 * @return @a true if we and the other instance describe a device and the same device.
190 * "Same device" means that the devices have the same type and the same major and minor id.
192 bool Stat::is_same_device_as(const Stat& rhs)
194 return is_device() and rhs.is_device()
195 and ( IsBlockDevice == rhs.IsBlockDevice )
196 and ( IsCharacterDevice == rhs.IsCharacterDevice )
197 and ( DeviceType == rhs.DeviceType);
198 } // eo Stat::is_same_device_as(const Stat&)
201 * @brief check existence of a path.
202 * @param path path which should be tested.
203 * @return @a true iff path exists.
205 bool path_exists(const std::string& path)
207 struct stat stat_info;
208 int res = ::stat(path.c_str(), &stat_info);
209 if (res) return false;
211 } // eo path_exists(const std::string&)
214 * @brief check existence of a regular file.
215 * @param path path which should be tested.
216 * @return @a true if path exists and is a regular file (or a link pointing to a regular file).
217 * @note this checks for regular files; not for the pure exitsnace of a path; use pathExists() for that.
220 bool file_exists(const std::string& path)
222 struct stat stat_info;
223 int res = ::stat(path.c_str(), &stat_info);
224 if (res) return false;
225 return S_ISREG(stat_info.st_mode);
226 } // eo file_exists(const std::string&)
228 // TODO: Use Stat class
231 * @param name filename to get size for
232 * @return file size or -1 if file does not exist
234 long file_size (const string &name)
238 struct stat statbuff;
240 if (lstat(name.c_str(), &statbuff) < 0)
243 if (!S_ISREG(statbuff.st_mode))
246 iReturn=statbuff.st_size;
252 * @brief tests the last modification time stamp of a path.
253 * @param path path which should be tested.
254 * @return the last modification time or 0 if the path doen't exist.
256 time_t file_mtime(const std::string& path)
258 struct stat stat_info;
259 int res = ::stat(path.c_str(), &stat_info);
261 return stat_info.st_mtime;
262 } // eo file_mtime(const std::string&)
266 * @brief Check if two files differ
268 * Note: Reads the whole file into memory
269 * if the file size is identical.
271 * @param old_filename Filename of old file
272 * @param new_filename Filename of new file
274 * @return bool True if files differ, false otherwise.
275 * If one file does not exist, also returns true
277 bool file_content_differs(const std::string &old_filename, const std::string &new_filename)
279 if (I2n::file_exists(old_filename) == false ||
280 I2n::file_exists(new_filename) == false)
283 // check if size differs
284 if (I2n::file_size(old_filename) != I2n::file_size(new_filename))
287 const std::string old_content = I2n::read_file(old_filename);
288 const std::string new_content = I2n::read_file(new_filename);
290 // check if content differs
291 if (old_content == new_content)
294 // Differ by default (fallback)
300 * @brief reads the contents of a directory.
301 * @param path the path to the directory whose contents should be read.
302 * @param[out] result the resulting list of names.
303 * @param include_dot_names determines if dot-files should be included in the list.
304 * @return @a true if reading the directory was succesful, @a false on error.
307 const std::string& path,
308 std::vector< std::string >& result,
309 bool include_dot_names )
311 DIR* dir = ::opendir( path.c_str());
316 struct dirent store, *entry = NULL;
317 while (readdir_r(dir, &store, &entry) == 0 && entry != NULL)
319 std::string name( entry->d_name );
320 if (! include_dot_names && (name[0] == '.') )
324 result.push_back( name );
328 } // eo get_dir(const std::string&,std::vector< std::string >&,bool)
332 * @brief reads the contents of a directory
333 * @param path the path to the directory whose contents should be read.
334 * @param include_dot_names determines if dot-files should be included in the list.
335 * @return the list of names (empty on error).
337 std::vector< std::string > get_dir(const std::string& path, bool include_dot_names )
339 std::vector< std::string > result;
340 get_dir(path,result,include_dot_names);
342 } // eo get_dir(const std::string&,bool)
347 * @brief removes a file from a filesystem.
348 * @param path path to the file.
349 * @return @a true if the unlink was successful.
351 bool unlink( const std::string& path )
353 int res = ::unlink( path.c_str() );
355 } // eo unlink(const std::string&)
360 * @brief creates a symbolic link named @a link_name to @a target.
361 * @param target the target the link should point to.
362 * @param link_name the name of the link.
363 * @param force if @a true, the (file or link) @a link_name is removed if it exists.
364 * @return @a true iff the symlink was successfully created.
366 bool symlink(const std::string& target, const std::string& link_name, bool force)
369 if (target.empty() or link_name.empty() or target == link_name)
371 // no, we don't do this!
374 std::string n_target;
375 if (target[0] == '/') // absolute target?
379 else // relative target
381 // for stat'ing: prepend dir of link_name:
382 n_target= dirname(link_name)+"/"+ target;
384 Stat target_stat(n_target, false);
385 Stat link_name_stat(link_name, false);
386 if (target_stat.exists() && link_name_stat.exists())
388 if (link_name_stat.is_same_as(target_stat)
389 or link_name_stat.is_same_device_as(target_stat) )
393 //TODO: more consistency checks?!
395 if (link_name_stat.exists())
397 // the link name already exists.
400 // "force" as given, so try to remove the link_name:
403 link_name_stat.recheck();
406 if (link_name_stat.exists())
408 // well, if the link_name still exists; we cannot create that link:
412 res= ::symlink(target.c_str(), link_name.c_str());
414 } // eo symlink(const std::string&,const std::string&,bool)
419 * @brief reads the target of a symbolic link.
420 * @param path path to the symbolic link
421 * @return the target of the link or an empty string on error.
423 std::string read_link(const std::string& path)
426 Stat stat(path,false);
427 if (!stat || !stat.is_link())
429 return std::string();
431 int buffer_size= PATH_MAX+1 + 128;
432 boost::scoped_array<char> buffer_ptr( new char[buffer_size] );
433 int res= ::readlink( path.c_str(), buffer_ptr.get(), buffer_size-1 );
436 return std::string( buffer_ptr.get(), res );
438 return std::string();
439 } // eo read_link(const std::string&)
444 * @brief returns content of a file as string.
446 * A simple (q'n'd) function for retrieving content of a file as string.<br>
447 * Also able to read special (but regular) files which don't provide a size when stat'ed
448 * (like files in the /proc filesystem).
450 * @param path path to the file.
451 * @return the content of the file as string (empty if file could be opened).
453 std::string read_file(const std::string& path)
458 return std::string();
460 std::ifstream f( path.c_str(), std::ios::in | std::ios::binary );
464 // NOTE: there are cases where we don't know the correct size (/proc files...)
465 // therefore we only use the size for reserving space if we know it, but don't
466 // use it when reading the file!
469 // if we know the size, we reserve enough space.
470 result.reserve( stat.size() );
475 f.read(buffer, sizeof(buffer));
476 result.append(buffer, f.gcount());
480 } // eo read_file(const std::string&)
484 * @brief writes a string to a file.
485 * @param path path to the file
486 * @param data the data which should be written into the file
487 * @param trunc set the trunc flag when opening the file. Do not use for files in /proc and /sys
488 * @return @a true if the data was written to the file.
490 * A simple (q'n'd) function for writing a string to a file.
492 bool write_file(const std::string& path, const std::string& data, bool trunc)
494 // set the correct openmode flags
495 std::ios_base::openmode flags = std::ios::out | std::ios::binary;
497 flags |= std::ios::trunc;
499 std::ofstream f( path.c_str(), flags);
502 f.write( data.data(), data.size() );
509 } // eo write_file(const std::string&,const std::string&)
513 * Copy file in 4k blocks from source to target.
514 * Overwrites the target if it already exists.
516 * On error the target file gets removed.
518 * @param src source file
519 * @param dest target file
520 * @return true if all is ok, false on error
522 bool copy_file(const std::string& src, const std::string& dest)
524 std::ifstream input( src.c_str(), std::ios::in | std::ios::binary );
528 std::ofstream output( dest.c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
532 // Out of disc space?
533 if (!copy_stream(input,output))
544 * Copy streams in 4k blocks.
546 * @param is source stream
547 * @param os target stream
548 * @return true if all is ok, false on error
550 bool copy_stream(std::istream& is, std::ostream& os)
561 is.read(buffer, sizeof(buffer));
562 os.write(buffer, is.gcount());
573 * @brief returns the filename part of a path (last component)
574 * @param path the path.
575 * @return the last component of the path.
577 std::string basename(const std::string& path)
579 std::string::size_type pos= path.rfind('/');
580 if (pos != std::string::npos)
582 return path.substr(pos+1);
585 } // eo basename(const std::string&)
589 * @brief returns the directory part of a path.
590 * @param path the path.
591 * @return the directory part of the path.
593 std::string dirname(const std::string& path)
595 std::string::size_type pos= path.rfind('/');
596 if (pos != std::string::npos)
598 std::string result(path,0,pos);
606 } // eo dirname(const std::string&)
610 * @brief normalizes a path.
612 * This method removes empty and "." elements.
613 * It also resolves ".." parts by removing previous path elements if possible.
614 * Leading ".." elements are preserved when a relative path was given; else they are removed.
615 * Trailing slashes are removed.
617 * @param path the path which should be normalized.
618 * @return the normalized path.
621 std::string normalize_path(const std::string& path)
625 return std::string();
627 // remember if the given path was absolute since this information vanishes when
628 // we split the path (since we split with omitting empty parts...)
629 bool is_absolute= (path[0]=='/');
630 std::list< std::string > parts;
631 std::list< std::string > result_parts;
633 split_string(path,parts,"/",true);
635 for(std::list< std::string >::const_iterator it_parts= parts.begin();
636 it_parts != parts.end();
639 std::string part(*it_parts); //convenience..
640 if (part == std::string(".") )
642 // single dot is "current path"; ignore!
645 if (part == std::string("..") )
647 // double dot is "one part back"
648 if (result_parts.empty())
652 // ignore since we cannot move behind / on absolute paths...
656 // on relative path, we need to store the "..":
657 result_parts.push_back(part);
660 else if (result_parts.back() == std::string("..") )
662 // if last element was already "..", we need to store the new one again...
663 // (PS: no need for "absolute" check; this can only be the case on relative path)
664 result_parts.push_back(part);
668 // remove last element.
669 result_parts.pop_back();
673 result_parts.push_back(part);
680 result+= join_string(result_parts,"/");
682 } // eo normalize_path(const std::string&)
686 * @brief calls fsync on a given directory to sync all it's metadata
687 * @param path the path of the directory.
688 * @return true if successful
690 bool dirsync(const std::string& path)
692 // sync the directory the file is in
693 DIR* dir=opendir(path.c_str());
697 int ret=fsync(dirfd(dir));
705 * @brief changes the file(/path) mode.
706 * @param path the path to change the mode for.
707 * @param mode the new file mode.
708 * @return @a true iff the file mode was sucessfully changed.
710 bool chmod(const std::string& path, int mode)
712 int res= ::chmod(path.c_str(), mode);
714 } // eo chmod(const std::string&,int)
718 * @brief changed the owner of a file(/path)
719 * @param path the path to change the owner for.
720 * @param user the new file owner.
721 * @param group the new file group.
722 * @return @a true iff the file owner was succesfully changed.
725 * the validity of user and group within the system is not checked.
726 * This is intentional since this way we can use id's which are not assigned.
728 bool chown(const std::string& path, const I2n::User& user, const I2n::Group& group)
731 if (uid<0) return false;
732 gid_t gid= group.Gid;
733 if (gid<0) gid= user.Gid;
734 if (gid<0) return false;
735 int res= ::chown( path.c_str(), uid, gid);
737 } // eo chown(const std::string&,const User&,const Group&)
740 * Recursive delete of files and directories
741 * @param path File or directory to delete
742 * @param keep_parent_dir Keep parent directory (=empty out directory) [optional]
743 * @param error Will contain the error if the return value is false [optional]
744 * @return true on success, false otherwise
746 bool recursive_delete(const std::string &path,
747 bool keep_parent_dir,
754 Stat sp(path, false);
756 throw runtime_error("can't stat " + path);
758 if (sp.is_directory())
760 std::vector<std::string> dirents = get_dir(path, false);
761 BOOST_FOREACH(const std::string &filename, dirents)
763 // Delete subdir or file.
764 rtn = recursive_delete(path + "/" + filename, false, error);
769 if (keep_parent_dir == false && !rmdir(path))
770 throw runtime_error("can't remove directory " + path);
775 throw runtime_error("can't unlink " + path);
783 out << e.what() << " (" << strerror(errno) << ")";
793 out << "unknown error (" << strerror(errno) << ")";
800 } // eo recursive_delete(const std::string&,std::string*)
803 Create a unique temporary directory from path_template.
804 @param Path template. The last six characters must be XXXXXX.
805 @param error Will contain the error if the return value is false [optional]
806 @return Name of new directory or empty string on error.
808 @seealso: classes in tmpfstream which offers funktionality based on mkstemp
810 std::string mkdtemp(const std::string &path_template, std::string *error)
812 boost::scoped_array<char> buf( new char[path_template.size()+1] );
813 path_template.copy(buf.get(), path_template.size());
814 buf[path_template.size()]=0;
816 char *unique_dir = ::mkdtemp(buf.get());
820 *error = strerror(errno);
824 // Scoped pointer is still valid
825 return std::string(unique_dir);
830 @param path Path to create
831 @param error Will contain the error if the return value is false [optional]
832 @return True on success, false on error
834 bool mkdir(const std::string &path, const mode_t &mode, std::string *error)
836 if ( ::mkdir(path.c_str(), mode) == 0)
840 *error = strerror(errno);
846 @param path Path to removed
847 @param error Will contain the error if the return value is false [optional]
848 @return True on successs, false otherwise
850 bool rmdir(const std::string &path, std::string *error)
852 if ( ::rmdir(path.c_str() ) == 0)
856 *error = strerror(errno);
860 /// Small helper class for scoped free
864 scoped_C_free(void *ptr)
865 : pointer_to_free(ptr)
871 free (pointer_to_free);
872 pointer_to_free = NULL;
876 void *pointer_to_free;
880 Get current working directory
881 @return Current working directory. Empty string on error.
885 char *cwd = ::getcwd(NULL, 0);
889 // Make deallocation of cwd exception safe
890 scoped_C_free holder(cwd);
892 string current_dir(cwd);
897 Change current working directory
898 @param path Path to change to
899 @param error Will contain the error if the return value is false [optional]
900 @return True on successs, false otherwise
902 bool chdir(const std::string &path, std::string *error)
904 if ( ::chdir(path.c_str() ) == 0)
908 *error = strerror(errno);
913 Set file mode creation mask
914 @param mask Creation mask
915 @return Previous creation mask (function call always succeeds)
917 mode_t umask(mode_t mask)
919 return ::umask(mask);
924 * @brief Remove unlisted files
926 * @param directory Directory to look for files
927 * @param keep_files List of files or directories to keep
928 * @param prefix Filename prefix to match. Empty prefix matches all.
930 * @return bool True if the directory was scanned, false on error (directory not found, permission denied)
932 bool remove_unlisted_files(const std::string &directory,
933 const std::set<std::string> &keep_files,
934 const std::string &prefix)
936 std::vector<std::string> content;
937 if (!get_dir(directory, content, false))
940 bool all_fine = true;
941 BOOST_FOREACH(const std::string &file, content)
943 // Check for filename prefix (if any)
944 if (!prefix.empty() && file.find(prefix) != 0)
947 // Check if file is whitelisted
948 if (keep_files.find(file) != keep_files.end())
951 // Try to unlink file. (Continue on error)
952 if (!unlink(directory + "/" + file))
960 * @brief Get free size in bytes on a given path or filename
962 * @param path Directory or filename to look in
964 * @return Number of bytes available to a regular user, -1 in case of an error
966 long long get_free_diskspace(const std::string& path)
972 while ( ((ret=statvfs(path.c_str(),&sf)) == -1) && (errno==EINTR) && looplimit > 0)
977 // a real error occured
981 long long free_bytes=0;
984 free_bytes=sf.f_bsize;
986 // multiply by number of free blocks accessible by normal users
987 // make sure we really multiply long long by long long and don't overflow at 2 GB
988 free_bytes*=(long long)sf.f_bavail;
995 // anonymous namespace to make du_internal inaccessible from outside
997 // internally used by du, do not use for other things
998 void du_internal(const std::string &path, long long &sum, std::map<dev_t, std::set<ino_t> > &counted_inodes)
1001 Stat sp(path, false); // don't dereference symlinks here
1003 throw runtime_error("can't stat " + path);
1005 // make sure we don't count hardlinked files twice
1006 bool count_file=true;
1008 // dirs can't be hardlinked, their nlink is the size of entries -> doesn't matter for us here
1009 if (!sp.is_directory() && sp.nlink() > 1)
1011 // see if we have remembered this dev / inode combination
1012 if (counted_inodes[sp.device()].count(sp.inode()))
1015 counted_inodes[sp.device()].insert(sp.inode());
1018 // always add the space used, even if we have a directory, symlink or whatever:
1019 // they need space on disk too
1022 sum+=sp.bytes_on_disk();
1024 if (sp.is_directory())
1026 std::vector<std::string> dirents = get_dir(path, false);
1027 BOOST_FOREACH(const std::string &filename, dirents)
1029 // calculate size of subdir or file
1030 du_internal(path + "/" + filename, sum, counted_inodes);
1035 } // eo anon namespace
1038 * like du(1): return the number bytes used by a directory structure, counting hardlinked files only once
1039 * @param path File or directory to start counting recursively
1040 * @param error Will contain the error if the return value is -1 [optional]
1041 * @return size in bytes on success, -1 on error
1043 long long du(const std::string &path, std::string *error)
1047 std::map<dev_t, std::set<ino_t> > counted_inodes;
1051 du_internal(path, sum, counted_inodes);
1053 catch (exception &e)
1058 out << e.what() << " (" << strerror(errno) << ")";
1068 out << "unknown error (" << strerror(errno) << ")";
1078 } // eo namespace I2n