libept
sys.h
Go to the documentation of this file.
1 #ifndef EPT_SYS_H
2 #define EPT_SYS_H
3 
11 #include <string>
12 //#include <iosfwd>
13 #include <memory>
14 #include <iterator>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <unistd.h>
18 #include <dirent.h>
19 
20 namespace ept {
21 namespace sys {
22 
28 std::unique_ptr<struct stat> stat(const std::string& pathname);
29 
34 void stat(const std::string& pathname, struct stat& st);
35 
41 bool isdir(const std::string& pathname);
42 
44 bool isblk(const std::string& pathname);
45 
47 bool ischr(const std::string& pathname);
48 
50 bool isfifo(const std::string& pathname);
51 
53 bool islnk(const std::string& pathname);
54 
56 bool isreg(const std::string& pathname);
57 
59 bool issock(const std::string& pathname);
60 
62 time_t timestamp(const std::string& file);
63 
65 time_t timestamp(const std::string& file, time_t def);
66 
68 size_t size(const std::string& file);
69 
71 size_t size(const std::string& file, size_t def);
72 
74 ino_t inode(const std::string& file);
75 
77 ino_t inode(const std::string& file, ino_t def);
78 
80 bool access(const std::string& s, int m);
81 
83 bool exists(const std::string& s);
84 
86 std::string getcwd();
87 
89 std::string abspath(const std::string& pathname);
90 
96 class MMap
97 {
98  void* addr;
99  size_t length;
100 
101 public:
102  MMap(const MMap&) = delete;
103  MMap(MMap&&);
104  MMap(void* addr, size_t length);
105  ~MMap();
106 
107  MMap& operator=(const MMap&) = delete;
108  MMap& operator=(MMap&&);
109 
110  size_t size() const { return length; }
111 
112  void munmap();
113 
114  template<typename T>
115  operator const T*() const { return reinterpret_cast<const T*>(addr); }
116 
117  template<typename T>
118  operator T*() const { return reinterpret_cast<T*>(addr); };
119 };
120 
133 {
134 protected:
135  int fd = -1;
136 
137 public:
138  FileDescriptor();
140  FileDescriptor(int fd);
141  virtual ~FileDescriptor();
142 
150  [[noreturn]] virtual void throw_error(const char* desc);
151 
152  void close();
153 
154  void fstat(struct stat& st);
155  void fchmod(mode_t mode);
156 
157  size_t write(const void* buf, size_t count);
158 
162  void write_all(const void* buf, size_t count);
163 
164  MMap mmap(size_t length, int prot, int flags, off_t offset=0);
165 
166  operator int() const { return fd; }
167 };
168 
169 
175 {
176 protected:
177  std::string pathname;
178 
179 public:
180  NamedFileDescriptor(int fd, const std::string& pathname);
182 
184 
185  [[noreturn]] virtual void throw_error(const char* desc);
186 
188  const std::string& name() const { return pathname; }
189 };
190 
194 struct Path : public NamedFileDescriptor
195 {
199  struct iterator : public std::iterator<std::input_iterator_tag, struct dirent>
200  {
201  Path* path = nullptr;
202  DIR* dir = nullptr;
203  struct dirent* cur_entry = nullptr;
204 
205  // End iterator
206  iterator();
207  // Start iteration on dir
208  iterator(Path& dir);
209  iterator(iterator&) = delete;
211  : dir(o.dir), cur_entry(o.cur_entry)
212  {
213  o.dir = nullptr;
214  o.cur_entry = nullptr;
215  }
216  ~iterator();
217  iterator& operator=(iterator&) = delete;
218  iterator& operator=(iterator&&) = delete;
219 
220  bool operator==(const iterator& i) const;
221  bool operator!=(const iterator& i) const;
222  struct dirent& operator*() const { return *cur_entry; }
223  struct dirent* operator->() const { return cur_entry; }
224  void operator++();
225 
227  bool isdir() const;
228 
230  bool isblk() const;
231 
233  bool ischr() const;
234 
236  bool isfifo() const;
237 
239  bool islnk() const;
240 
242  bool isreg() const;
243 
245  bool issock() const;
246  };
247 
249 
253  Path(const char* pathname, int flags=0);
257  Path(const std::string& pathname, int flags=0);
261  Path(Path& parent, const char* pathname, int flags=0);
262  Path(const Path&) = delete;
263  Path(Path&&) = default;
264  Path& operator=(const Path&) = delete;
265  Path& operator=(Path&&) = default;
266 
274  ~Path();
275 
276  DIR* fdopendir();
277 
279  iterator begin();
280 
282  iterator end();
283 
284  int openat(const char* pathname, int flags, mode_t mode=0777);
285 
286  void fstatat(const char* pathname, struct stat& st);
287 
289  void lstatat(const char* pathname, struct stat& st);
290 
291  void unlinkat(const char* pathname);
292 
294  void rmdirat(const char* pathname);
295 
301  void rmtree();
302 };
303 
304 
308 class File : public NamedFileDescriptor
309 {
310 public:
312 
313  File(File&&) = default;
314  File(const File&) = delete;
315 
317  File(const std::string& pathname, int flags, mode_t mode=0777);
318 
326  ~File();
327 
328  File& operator=(const File&) = delete;
329  File& operator=(File&&) = default;
330 
331  static File mkstemp(const std::string& prefix);
332 };
333 
335 std::string read_file(const std::string &file);
336 
343 void write_file(const std::string& file, const std::string& data, mode_t mode=0777);
344 
354 void write_file_atomically(const std::string& file, const std::string& data, mode_t mode=0777);
355 
356 #if 0
357 // Create a temporary directory based on a template.
358 std::string mkdtemp(std::string templ);
359 
362 void mkFilePath(const std::string& file);
363 #endif
364 
370 bool unlink_ifexists(const std::string& file);
371 
377 bool rename_ifexists(const std::string& src, const std::string& dst);
378 
382 void mkdir_ifmissing(const char* pathname, mode_t mode=0777);
383 
384 void mkdir_ifmissing(const std::string& pathname, mode_t mode=0777);
385 
388 void makedirs(const std::string& pathname, mode_t=0777);
389 
397 std::string which(const std::string& name);
398 
400 void unlink(const std::string& pathname);
401 
403 void rmdir(const std::string& pathname);
404 
406 void rmtree(const std::string& pathname);
407 
408 #if 0
409 class Directory
411 {
412 protected:
414  std::string m_path;
415 
416 public:
417  class const_iterator
418  {
420  const Directory* dir;
422  void* dirp;
424  struct dirent* direntbuf;
425 
426  public:
427  // Create an end iterator
428  const_iterator();
429  // Create a begin iterator
430  const_iterator(const Directory& dir);
431  // Cleanup properly
432  ~const_iterator();
433 
435  const_iterator(const const_iterator& i);
436  const_iterator& operator=(const const_iterator& i);
437 
439  const_iterator& operator++();
440 
442  std::string operator*() const;
443 
444  bool operator==(const const_iterator& iter) const;
445  bool operator!=(const const_iterator& iter) const;
446  };
447 
448  Directory(const std::string& path);
449  ~Directory();
450 
452  const std::string& path() const { return m_path; }
453 
455  bool exists() const;
456 
458  const_iterator begin() const;
459 
461  const_iterator end() const;
462 };
463 
464 #endif
465 }
466 }
467 
468 #endif
std::string abspath(const std::string &pathname)
Get the absolute path of a file.
Definition: sys.cc:171
bool ischr(const std::string &pathname)
Same as isdir but checks for character devices.
Definition: sys.cc:76
bool isreg(const std::string &pathname)
Same as isdir but checks for regular files.
Definition: sys.cc:91
void mkdir_ifmissing(const char *pathname, mode_t mode)
Create the given directory, if it does not already exists.
Definition: sys.cc:721
Wrap a path on the file system opened with O_PATH.
Definition: sys.h:194
bool rename_ifexists(const std::string &src, const std::string &dst)
Move src to dst, without raising exception if src does not exist.
Definition: sys.cc:659
~MMap()
Definition: sys.cc:208
std::string getcwd()
Get the absolute path of the current working directory.
Definition: sys.cc:153
void write_file(const std::string &file, const std::string &data, mode_t mode)
Write data to file, replacing existing contents if it already exists.
Definition: sys.cc:612
bool exists(const std::string &file)
Same as access(s, F_OK);.
Definition: sys.cc:148
struct dirent * operator->() const
Definition: sys.h:223
size_t size(const std::string &file)
File size.
Definition: sys.cc:116
void makedirs(const std::string &pathname, mode_t mode)
Create all the component of the given directory, including the directory itself.
Definition: sys.cc:731
time_t timestamp(const std::string &file)
File mtime.
Definition: sys.cc:103
bool unlink_ifexists(const std::string &file)
Delete a file if it exists.
Definition: sys.cc:646
Common operations on file descriptors.
Definition: sys.h:132
std::string read_file(const std::string &file)
Read whole file into memory. Throws exceptions on failure.
Definition: sys.cc:598
ino_t inode(const std::string &file)
File inode number.
Definition: sys.cc:129
void munmap()
Definition: sys.cc:213
String functions.
Definition: apt.cc:38
std::string pathname
Definition: sys.h:177
bool isblk(const std::string &pathname)
Same as isdir but checks for block devices.
Definition: sys.cc:71
iterator(iterator &&o)
Definition: sys.h:210
void write_file_atomically(const std::string &file, const std::string &data, mode_t mode)
Write data to file, replacing existing contents if it already exists.
Definition: sys.cc:619
void rmtree(const std::string &pathname)
Delete the directory pathname and all its contents.
Definition: sys.cc:776
void unlink(const std::string &pathname)
Delete the file using unlink()
Definition: sys.cc:764
MMap & operator=(const MMap &)=delete
void rmdir(const std::string &pathname)
Remove the directory using rmdir(2)
Definition: sys.cc:770
Wraps a mmapped memory area, unmapping it on destruction.
Definition: sys.h:96
Iterator for directory entries.
Definition: sys.h:199
bool islnk(const std::string &pathname)
Same as isdir but checks for symbolic links.
Definition: sys.cc:86
MMap(const MMap &)=delete
bool issock(const std::string &pathname)
Same as isdir but checks for sockets.
Definition: sys.cc:96
struct dirent & operator*() const
Definition: sys.h:222
NamedFileDescriptor(int fd, const std::string &pathname)
Definition: sys.cc:287
const std::string & name() const
Return the file pathname.
Definition: sys.h:188
bool isdir(const std::string &pathname)
Returns true if the given pathname is a directory, else false.
Definition: sys.cc:66
std::string which(const std::string &name)
Compute the absolute path of an executable.
Definition: sys.cc:743
bool access(const std::string &s, int m)
access() a filename
Definition: sys.cc:143
size_t size() const
Definition: sys.h:110
std::unique_ptr< struct stat > stat(const std::string &pathname)
stat() the given file and return the struct stat with the results.
Definition: sys.cc:37
bool isfifo(const std::string &pathname)
Same as isdir but checks for FIFOs.
Definition: sys.cc:81
open(2) file descriptors
Definition: sys.h:308
File descriptor with a name.
Definition: sys.h:174