libwreport  3.5
sys.h
1 #ifndef WREPORT_SYS_H
2 #define WREPORT_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 wreport {
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;
210  iterator(iterator&& o)
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 
248  using NamedFileDescriptor::NamedFileDescriptor;
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:
311  using NamedFileDescriptor::NamedFileDescriptor;
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
virtual void throw_error(const char *desc)
Throw an exception based on errno and the given message.
const std::string & name() const
Return the file pathname.
Definition: sys.h:188
Wraps a mmapped memory area, unmapping it on destruction.
Definition: sys.h:96
Common operations on file descriptors.
Definition: sys.h:132
open(2) file descriptors
Definition: sys.h:308
~File()
The destructor closes the file descriptor, but does not check errors on ::close().
iterator begin()
Begin iterator on all directory entries.
File descriptor with a name.
Definition: sys.h:174
void lstatat(const char *pathname, struct stat &st)
fstatat with the AT_SYMLINK_NOFOLLOW flag set
Iterator for directory entries.
Definition: sys.h:199
Path(const char *pathname, int flags=0)
Open the given pathname with flags | O_PATH.
iterator end()
End iterator on all directory entries.
void write_all(const void *buf, size_t count)
Write all the data in buf, retrying partial writes.
String functions.
Definition: benchmark.h:13
void rmtree()
Delete the directory pointed to by this Path, with all its contents.
~Path()
The destructor closes the file descriptor, but does not check errors on ::close().
virtual void throw_error(const char *desc)
Throw an exception based on errno and the given message.
Wrap a path on the file system opened with O_PATH.
Definition: sys.h:194
void rmdirat(const char *pathname)
unlinkat with the AT_REMOVEDIR flag set