source/file.cpp

   1 /* $Id$
   2
   3 This file is part of libmspio
   4 Copyright © 2007 Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7 #ifndef WIN32
   8 #include <errno.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #endif
  12 #include <msp/strings/formatter.h>
  13 #include "except.h"
  14 #include "file.h"
  15
  16 using namespace std;
  17
  18 namespace Msp {
  19 namespace IO {
  20
  21 /**
  22 Creates a new file object and opens it.  If the
  23 create flag is true and write access is requested and the file does exist, it
  24 is created.  Otherwise a missing file is an error.
  25
  26 @param   fn  Name of the file to open
  27 @param   m   Open mode
  28 @param   cm  Flags controlling creation of a new file
  29 */
  30 File::File(const string &fn, Mode m, CreateMode cm)
  31 {
  32         if(!(m&M_RDWR))
  33                 throw InvalidParameterValue("Invalid read/write mode");
  34         if(cm&~(C_CREATE|C_TRUNCATE))
  35                 throw InvalidParameterValue("Invalid create mode");
  36
  37         mode=m;
  38
  39 #ifdef WIN32
  40         int flags=0;
  41         int create_flags=OPEN_EXISTING;
  42
  43         if(mode&M_READ)
  44                 flags|=GENERIC_READ;
  45         else if(mode&M_WRITE)
  46         {
  47                 flags|=GENERIC_WRITE;
  48
  49                 switch(static_cast<int>(cm))
  50                 {
  51                 case C_NONE:     create_flags=OPEN_EXISTING; break;
  52                 case C_CREATE:   create_flags=OPEN_ALWAYS; break;
  53                 case C_TRUNCATE: create_flags=TRUNCATE_EXISTING; break;
  54                 case C_CREATE+C_TRUNCATE: create_flags=CREATE_ALWAYS; break;
  55                 }
  56         }
  57
  58         handle=CreateFile(fn.c_str(), flags, 0, 0, create_flags, FILE_ATTRIBUTE_NORMAL, 0);
  59         if(handle==INVALID_HANDLE_VALUE)
  60                 throw SystemError(format("Can't open file '%s'", fn), GetLastError());
  61 #else
  62         int flags=0;
  63         switch(mode&M_RDWR)
  64         {
  65         case M_READ:  flags|=O_RDONLY; break;
  66         case M_WRITE: flags|=O_WRONLY; break;
  67         case M_RDWR:  flags|=O_RDWR; break;
  68         default:;
  69         }
  70
  71         if(mode&M_WRITE)
  72         {
  73                 if(cm&C_CREATE)
  74                         flags|=O_CREAT;
  75                 if(cm&C_TRUNCATE)
  76                         flags|=O_TRUNC;
  77         }
  78         if(mode&M_APPEND)
  79                 flags|=O_APPEND;
  80         if(mode&M_NONBLOCK)
  81                 flags|=O_NONBLOCK;
  82
  83         handle=::open(fn.c_str(), flags, 0666);
  84         if(handle==-1)
  85         {
  86                 int err=errno;
  87                 if(err==ENOENT)
  88                         throw FileNotFound("Can't find file "+fn, fn);
  89                 else
  90                         throw SystemError(format("Can't open file '%s'", fn), err);
  91         }
  92 #endif
  93
  94         set_events(P_INPUT);
  95 }
  96
  97 /**
  98 Closes the file.  Any attempt to access the file after this will cause an
  99 exception to be thrown.
 100 */
 101 void File::close()
 102 {
 103         if(handle==MSP_IO_INVALID_HANDLE)
 104                 return;
 105
 106         set_events(P_NONE);
 107
 108         signal_flush_required.emit();
 109
 110 #ifdef WIN32
 111         CloseHandle(handle);
 112 #else
 113         ::close(handle);
 114 #endif
 115
 116         handle=MSP_IO_INVALID_HANDLE;
 117         signal_closed.emit();
 118 }
 119
 120 /**
 121 Sets the blocking state of the file.  If blocking is disabled, all operations
 122 will return immediately, even if they can't be fully completed.
 123 */
 124 void File::set_block(bool b)
 125 {
 126         check_access(M_NONE);
 127
 128         mode=(mode&~M_NONBLOCK);
 129         if(b)
 130                 mode=(mode|M_NONBLOCK);
 131 #ifndef WIN32
 132         int flags=fcntl(handle, F_GETFD);
 133         fcntl(handle, F_SETFL, (flags&O_NONBLOCK)|(b?0:O_NONBLOCK));
 134 #endif
 135 }
 136
 137 void File::sync()
 138 {
 139 #ifndef WIN32
 140         signal_flush_required.emit();
 141
 142         fsync(handle);
 143 #endif
 144 }
 145
 146 /**
 147 Seeks the file to the given byte offset.
 148
 149 @param   off  Offset in bytes
 150 @param   st   Seek type
 151
 152 @return  The resulting offset
 153 */
 154 int File::seek(int off, SeekType st)
 155 {
 156         check_access(M_NONE);
 157
 158         signal_flush_required.emit();
 159
 160         int type=sys_seek_type(st);
 161 #ifdef WIN32
 162         DWORD ret=SetFilePointer(handle, off, 0, type);
 163         if(ret==INVALID_SET_FILE_POINTER)
 164                 throw SystemError("Seek failed", GetLastError());
 165 #else
 166         int ret=lseek(handle, off, type);
 167         if(ret==-1)
 168                 throw SystemError("Seek failed", errno);
 169 #endif
 170
 171         eof_flag=false;
 172
 173         return ret;
 174 }
 175
 176 /**
 177 Returns the current read/write offset of the file.
 178 */
 179 int File::tell() const
 180 {
 181         check_access(M_NONE);
 182
 183 #ifdef WIN32
 184         DWORD ret=SetFilePointer(handle, 0, 0, FILE_CURRENT);
 185         if(ret==INVALID_SET_FILE_POINTER)
 186                 throw SystemError("Tell failed", GetLastError());
 187 #else
 188         int ret=lseek(handle, 0, SEEK_CUR);
 189         if(ret==-1)
 190                 throw SystemError("Tell failed", errno);
 191 #endif
 192
 193         return ret;
 194 }
 195
 196 File::~File()
 197 {
 198         close();
 199 }
 200
 201 void File::check_access(Mode m) const
 202 {
 203         if(handle==MSP_IO_INVALID_HANDLE)
 204                 throw InvalidState("File is not open");
 205         if(m==M_READ && !(mode&M_READ))
 206                 throw InvalidState("File is not readable");
 207         if(m==M_WRITE && !(mode&M_WRITE))
 208                 throw InvalidState("File is not writable");
 209 }
 210
 211 /**
 212 Writes data from a buffer to the file.
 213
 214 @param   buf   Buffer to write from.
 215 @param   size  Length of data to write.
 216
 217 @return  The number of bytes written
 218 */
 219 unsigned File::do_write(const char *buf, unsigned size)
 220 {
 221         check_access(M_WRITE);
 222
 223         if(size==0)
 224                 return 0;
 225
 226 #ifdef WIN32
 227         if(mode&M_APPEND)
 228                 seek(0, S_END);
 229         DWORD ret;
 230         if(WriteFile(handle, buf, size, &ret, 0)==0)
 231                 throw SystemError("Writing to file failed", GetLastError());
 232 #else
 233         int ret=::write(handle, buf, size);
 234         if(ret==-1)
 235         {
 236                 if(errno==EAGAIN)
 237                         return 0;
 238                 else
 239                         throw SystemError("Writing to file failed", errno);
 240         }
 241 #endif
 242
 243         return ret;
 244 }
 245
 246 /**
 247 Reads data from the file.
 248
 249 @param   buf   Buffer to read data into.
 250 @param   size  Maximum size of data to read.
 251
 252 @return  The number of bytes read, possibly zero
 253 */
 254 unsigned File::do_read(char *buf, unsigned size)
 255 {
 256         check_access(M_READ);
 257
 258         if(size==0)
 259                 return 0;
 260
 261 #ifdef WIN32
 262         DWORD ret;
 263         if(ReadFile(handle, buf, size, &ret, 0)==0)
 264                 throw SystemError("Reading from file failed", GetLastError());
 265 #else
 266         int ret=::read(handle, buf, size);
 267         if(ret==-1)
 268         {
 269                 if(errno==EAGAIN)
 270                         return 0;
 271                 else
 272                         throw SystemError("Reading from file failed", errno);
 273         }
 274 #endif
 275
 276         if(ret==0)
 277         {
 278                 eof_flag=true;
 279                 signal_end_of_file.emit();
 280         }
 281
 282         return ret;
 283 }
 284
 285 } // namespace IO
 286 } // namespace Msp