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
20namespace ept {
21namespace sys {
22
28std::unique_ptr<struct stat> stat(const std::string& pathname);
29
34void stat(const std::string& pathname, struct stat& st);
35
41bool isdir(const std::string& pathname);
42
44bool isblk(const std::string& pathname);
45
47bool ischr(const std::string& pathname);
48
50bool isfifo(const std::string& pathname);
51
53bool islnk(const std::string& pathname);
54
56bool isreg(const std::string& pathname);
57
59bool issock(const std::string& pathname);
60
62time_t timestamp(const std::string& file);
63
65time_t timestamp(const std::string& file, time_t def);
66
68size_t size(const std::string& file);
69
71size_t size(const std::string& file, size_t def);
72
74ino_t inode(const std::string& file);
75
77ino_t inode(const std::string& file, ino_t def);
78
80bool access(const std::string& s, int m);
81
83bool exists(const std::string& s);
84
86std::string getcwd();
87
89std::string abspath(const std::string& pathname);
90
96class MMap
97{
98 void* addr;
99 size_t length;
100
101public:
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{
134protected:
135 int fd = -1;
136
137public:
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{
176protected:
177 std::string pathname;
178
179public:
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
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();
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
309{
310public:
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
335std::string read_file(const std::string &file);
336
343void write_file(const std::string& file, const std::string& data, mode_t mode=0777);
344
354void 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.
358std::string mkdtemp(std::string templ);
359
362void mkFilePath(const std::string& file);
363#endif
364
370bool unlink_ifexists(const std::string& file);
371
377bool rename_ifexists(const std::string& src, const std::string& dst);
378
382void mkdir_ifmissing(const char* pathname, mode_t mode=0777);
383
384void mkdir_ifmissing(const std::string& pathname, mode_t mode=0777);
385
388void makedirs(const std::string& pathname, mode_t=0777);
389
397std::string which(const std::string& name);
398
400void unlink(const std::string& pathname);
401
403void rmdir(const std::string& pathname);
404
406void rmtree(const std::string& pathname);
407
408#if 0
410class Directory
411{
412protected:
414 std::string m_path;
415
416public:
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
Common operations on file descriptors.
Definition sys.h:133
MMap mmap(size_t length, int prot, int flags, off_t offset=0)
Definition sys.cc:274
virtual ~FileDescriptor()
Definition sys.cc:232
void fstat(struct stat &st)
Definition sys.cc:247
FileDescriptor()
Definition sys.cc:225
virtual void throw_error(const char *desc)
Throw an exception based on errno and the given message.
Definition sys.cc:234
size_t write(const void *buf, size_t count)
Definition sys.cc:259
void close()
Definition sys.cc:239
void fchmod(mode_t mode)
Definition sys.cc:253
void write_all(const void *buf, size_t count)
Write all the data in buf, retrying partial writes.
Definition sys.cc:267
int fd
Definition sys.h:135
open(2) file descriptors
Definition sys.h:309
static File mkstemp(const std::string &prefix)
Definition sys.cc:587
File & operator=(const File &)=delete
File & operator=(File &&)=default
~File()
The destructor closes the file descriptor, but does not check errors on close().
Definition sys.cc:582
File(File &&)=default
File(const File &)=delete
Wraps a mmapped memory area, unmapping it on destruction.
Definition sys.h:97
MMap & operator=(const MMap &)=delete
~MMap()
Definition sys.cc:208
size_t size() const
Definition sys.h:110
MMap(const MMap &)=delete
void munmap()
Definition sys.cc:213
File descriptor with a name.
Definition sys.h:175
NamedFileDescriptor & operator=(NamedFileDescriptor &&)
Definition sys.cc:297
const std::string & name() const
Return the file pathname.
Definition sys.h:188
NamedFileDescriptor(int fd, const std::string &pathname)
Definition sys.cc:287
std::string pathname
Definition sys.h:177
virtual void throw_error(const char *desc)
Throw an exception based on errno and the given message.
Definition sys.cc:306
std::string abspath(const std::string &pathname)
Get the absolute path of a file.
Definition sys.cc:171
std::string getcwd()
Get the absolute path of the current working directory.
Definition sys.cc:153
bool isblk(const std::string &pathname)
Same as isdir but checks for block devices.
Definition sys.cc:71
bool issock(const std::string &pathname)
Same as isdir but checks for sockets.
Definition sys.cc:96
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
void mkdir_ifmissing(const char *pathname, mode_t mode)
Create the given directory, if it does not already exists.
Definition sys.cc:721
bool isreg(const std::string &pathname)
Same as isdir but checks for regular files.
Definition sys.cc:91
void rmtree(const std::string &pathname)
Delete the directory pathname and all its contents.
Definition sys.cc:776
std::string which(const std::string &name)
Compute the absolute path of an executable.
Definition sys.cc:743
void rmdir(const std::string &pathname)
Remove the directory using rmdir(2)
Definition sys.cc:770
bool islnk(const std::string &pathname)
Same as isdir but checks for symbolic links.
Definition sys.cc:86
bool unlink_ifexists(const std::string &file)
Delete a file if it exists.
Definition sys.cc:646
ino_t inode(const std::string &file)
File inode number.
Definition sys.cc:129
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
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
std::string read_file(const std::string &file)
Read whole file into memory. Throws exceptions on failure.
Definition sys.cc:598
bool isdir(const std::string &pathname)
Returns true if the given pathname is a directory, else false.
Definition sys.cc:66
bool ischr(const std::string &pathname)
Same as isdir but checks for character devices.
Definition sys.cc:76
time_t timestamp(const std::string &file)
File mtime.
Definition sys.cc:103
bool access(const std::string &s, int m)
access() a filename
Definition sys.cc:143
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 unlink(const std::string &pathname)
Delete the file using unlink()
Definition sys.cc:764
size_t size(const std::string &file)
File size.
Definition sys.cc:116
bool isfifo(const std::string &pathname)
Same as isdir but checks for FIFOs.
Definition sys.cc:81
bool exists(const std::string &file)
Same as access(s, F_OK);.
Definition sys.cc:148
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
String functions.
Definition apt.cc:40
Iterator for directory entries.
Definition sys.h:200
bool islnk() const
Definition sys.cc:513
bool operator!=(const iterator &i) const
Definition sys.cc:434
struct dirent & operator*() const
Definition sys.h:222
iterator & operator=(iterator &&)=delete
iterator(iterator &)=delete
Path * path
Definition sys.h:201
bool issock() const
Definition sys.cc:539
iterator()
Definition sys.cc:402
DIR * dir
Definition sys.h:202
iterator(iterator &&o)
Definition sys.h:210
void operator++()
Definition sys.cc:441
bool operator==(const iterator &i) const
Definition sys.cc:428
~iterator()
Definition sys.cc:422
bool ischr() const
Definition sys.cc:485
iterator & operator=(iterator &)=delete
struct dirent * operator->() const
Definition sys.h:223
bool isfifo() const
Definition sys.cc:499
struct dirent * cur_entry
Definition sys.h:203
bool isreg() const
Definition sys.cc:526
bool isdir() const
Definition sys.cc:457
bool isblk() const
Definition sys.cc:471
Wrap a path on the file system opened with O_PATH.
Definition sys.h:195
iterator end()
End iterator on all directory entries.
Definition sys.cc:365
void fstatat(const char *pathname, struct stat &st)
Definition sys.cc:378
Path(const Path &)=delete
DIR * fdopendir()
Definition sys.cc:344
~Path()
The destructor closes the file descriptor, but does not check errors on close().
Definition sys.cc:338
Path & operator=(const Path &)=delete
iterator begin()
Begin iterator on all directory entries.
Definition sys.cc:357
Path(Path &&)=default
void unlinkat(const char *pathname)
Definition sys.cc:390
void lstatat(const char *pathname, struct stat &st)
fstatat with the AT_SYMLINK_NOFOLLOW flag set
Definition sys.cc:384
void rmdirat(const char *pathname)
unlinkat with the AT_REMOVEDIR flag set
Definition sys.cc:396
Path & operator=(Path &&)=default
void rmtree()
Delete the directory pointed to by this Path, with all its contents.
Definition sys.cc:553
int openat(const char *pathname, int flags, mode_t mode=0777)
Definition sys.cc:370