Implement get_handle in File and Pipe
[libs/core.git] / source / io / file.cpp
1 #ifndef WIN32
2 #include <errno.h>
3 #include <fcntl.h>
4 #include <unistd.h>
5 #endif
6 #include <msp/strings/format.h>
7 #include <msp/core/systemerror.h>
8 #include "file.h"
9 #include "handle_private.h"
10
11 using namespace std;
12
13 namespace Msp {
14 namespace IO {
15
16 File::File(const string &fn, Mode m, CreateMode cm)
17 {
18         if(!(m&M_RDWR))
19                 throw invalid_argument("File::File mode");
20         if(cm&~(C_CREATE|C_TRUNCATE))
21                 throw invalid_argument("File::File create");
22
23         mode = m;
24
25 #ifdef WIN32
26         int flags = 0;
27         int create_flags = OPEN_EXISTING;
28
29         if(mode&M_READ)
30                 flags |= GENERIC_READ;
31         else if(mode&M_WRITE)
32         {
33                 flags |= GENERIC_WRITE;
34
35                 switch(static_cast<int>(cm))
36                 {
37                 case C_NONE:     create_flags = OPEN_EXISTING; break;
38                 case C_CREATE:   create_flags = OPEN_ALWAYS; break;
39                 case C_TRUNCATE: create_flags = TRUNCATE_EXISTING; break;
40                 case C_CREATE+C_TRUNCATE: create_flags = CREATE_ALWAYS; break;
41                 }
42         }
43
44         *handle = CreateFile(fn.c_str(), flags, 0, 0, create_flags, FILE_ATTRIBUTE_NORMAL, 0);
45         if(!handle)
46         {
47                 int err = GetLastError();
48                 if(err==ERROR_FILE_NOT_FOUND)
49                         throw file_not_found(fn);
50                 else
51                         throw system_error(format("CreateFile(%s)", fn), err);
52         }
53 #else
54         int flags = 0;
55         switch(mode&M_RDWR)
56         {
57         case M_READ:  flags |= O_RDONLY; break;
58         case M_WRITE: flags |= O_WRONLY; break;
59         case M_RDWR:  flags |= O_RDWR; break;
60         default:;
61         }
62
63         if(mode&M_WRITE)
64         {
65                 if(cm&C_CREATE)
66                         flags |= O_CREAT;
67                 if(cm&C_TRUNCATE)
68                         flags |= O_TRUNC;
69         }
70         if(mode&M_APPEND)
71                 flags |= O_APPEND;
72         if(mode&M_NONBLOCK)
73                 flags |= O_NONBLOCK;
74
75         *handle = ::open(fn.c_str(), flags, 0666);
76         if(!handle)
77         {
78                 int err = errno;
79                 if(err==ENOENT)
80                         throw file_not_found(fn);
81                 else
82                         throw system_error(format("open(%s)", fn), err);
83         }
84 #endif
85 }
86
87 File::~File()
88 {
89         signal_flush_required.emit();
90         sys_close(handle);
91 }
92
93 void File::set_block(bool b)
94 {
95         mode = (mode&~M_NONBLOCK);
96         if(b)
97                 mode = (mode|M_NONBLOCK);
98 #ifndef WIN32
99         int flags = fcntl(*handle, F_GETFD);
100         fcntl(*handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
101 #endif
102 }
103
104 unsigned File::do_write(const char *buf, unsigned size)
105 {
106         check_access(M_WRITE);
107
108         if(size==0)
109                 return 0;
110
111 #ifdef WIN32
112         if(mode&M_APPEND)
113                 seek(0, S_END);
114 #endif
115
116         return sys_write(handle, buf, size);
117 }
118
119 unsigned File::do_read(char *buf, unsigned size)
120 {
121         check_access(M_READ);
122
123         if(size==0)
124                 return 0;
125
126         unsigned ret = sys_read(handle, buf, size);
127         if(ret==0)
128                 set_eof();
129
130         return ret;
131 }
132
133 void File::sync()
134 {
135 #ifndef WIN32
136         signal_flush_required.emit();
137
138         fsync(*handle);
139 #endif
140 }
141
142 SeekOffset File::seek(SeekOffset off, SeekType type)
143 {
144         signal_flush_required.emit();
145         off = sys_seek(handle, off, type);
146         eof_flag = false;
147
148         return off;
149 }
150
151 SeekOffset File::tell() const
152 {
153         return sys_seek(const_cast<Handle &>(handle), 0, S_CUR);
154 }
155
156 const Handle &File::get_handle(Mode m)
157 {
158         check_access(m);
159         return handle;
160 }
161
162 } // namespace IO
163 } // namespace Msp