mcs/class/Mono.Posix/Mono.Posix/PosixFileInfo.cs

   1 //
   2 // Mono.Posix/PosixFileInfo.cs
   3 //
   4 // Authors:
   5 //   Jonathan Pryor (jonpryor@vt.edu)
   6 //
   7 // (C) 2004 Jonathan Pryor
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.IO;
  31 using System.Text;
  32 using Mono.Posix;
  33
  34 namespace Mono.Posix {
  35
  36         public class PosixFileInfo : PosixFileSystemInfo
  37         {
  38                 public PosixFileInfo (string path)
  39                         : base (path)
  40                 {
  41                 }
  42
  43                 internal PosixFileInfo (string path, Stat stat)
  44                         : base (path, stat)
  45                 {
  46                 }
  47
  48                 public override void Delete ()
  49                 {
  50                         int r = Syscall.unlink (Path);
  51                         PosixMarshal.ThrowExceptionForLastErrorIf (r);
  52                         base.Refresh ();
  53                 }
  54
  55                 public PosixStream Create ()
  56                 {
  57                         FilePermissions mode = // 0644
  58                                 FilePermissions.S_IRUSR | FilePermissions.S_IWUSR |
  59                                 FilePermissions.S_IRGRP | FilePermissions.S_IROTH;
  60                         return Create (mode);
  61                 }
  62
  63                 public PosixStream Create (FilePermissions mode)
  64                 {
  65                         int fd = Syscall.creat (Path, mode);
  66                         if (fd < 0)
  67                                 PosixMarshal.ThrowExceptionForLastError ();
  68                         base.Refresh ();
  69                         return new PosixStream (fd);
  70                 }
  71
  72                 public PosixStream Open (OpenFlags flags)
  73                 {
  74                         int fd = Syscall.open (Path, flags);
  75                         if (fd < 0)
  76                                 PosixMarshal.ThrowExceptionForLastError ();
  77                         return new PosixStream (fd);
  78                 }
  79
  80                 public PosixStream Open (OpenFlags flags, FilePermissions mode)
  81                 {
  82                         int fd = Syscall.open (Path, flags, mode);
  83                         if (fd < 0)
  84                                 PosixMarshal.ThrowExceptionForLastError ();
  85                         return new PosixStream (fd);
  86                 }
  87
  88                 public PosixStream Open (FileMode mode)
  89                 {
  90                         OpenFlags flags = ToOpenFlags (mode, FileAccess.ReadWrite);
  91                         int fd = Syscall.open (Path, flags);
  92                         if (fd < 0)
  93                                 PosixMarshal.ThrowExceptionForLastError ();
  94                         return new PosixStream (fd);
  95                 }
  96
  97                 public PosixStream Open (FileMode mode, FileAccess access)
  98                 {
  99                         OpenFlags flags = ToOpenFlags (mode, access);
 100                         int fd = Syscall.open (Path, flags);
 101                         if (fd < 0)
 102                                 PosixMarshal.ThrowExceptionForLastError ();
 103                         return new PosixStream (fd);
 104                 }
 105
 106                 public PosixStream Open (FileMode mode, FileAccess access, FilePermissions perms)
 107                 {
 108                         OpenFlags flags = ToOpenFlags (mode, access);
 109                         int fd = Syscall.open (Path, flags, perms);
 110                         if (fd < 0)
 111                                 PosixMarshal.ThrowExceptionForLastError ();
 112                         return new PosixStream (fd);
 113                 }
 114
 115                 public PosixStream OpenRead ()
 116                 {
 117                         return Open (FileMode.Open, FileAccess.Read);
 118                 }
 119
 120                 public PosixStream OpenWrite ()
 121                 {
 122                         return Open (FileMode.OpenOrCreate, FileAccess.Write);
 123                 }
 124
 125                 public static OpenFlags ToOpenFlags (FileMode mode, FileAccess access)
 126                 {
 127                         OpenFlags flags = 0;
 128                         switch (mode) {
 129                         case FileMode.CreateNew:
 130                                 flags = OpenFlags.O_CREAT | OpenFlags.O_EXCL;
 131                                 break;
 132                         case FileMode.Create:
 133                                 flags = OpenFlags.O_CREAT | OpenFlags.O_TRUNC;
 134                                 break;
 135                         case FileMode.Open:
 136                                 // do nothing
 137                                 break;
 138                         case FileMode.OpenOrCreate:
 139                                 flags = OpenFlags.O_CREAT;
 140                                 break;
 141                         case FileMode.Truncate:
 142                                 flags = OpenFlags.O_TRUNC;
 143                                 break;
 144                         case FileMode.Append:
 145                                 flags = OpenFlags.O_APPEND;
 146                                 break;
 147                         default:
 148                                 throw new ArgumentOutOfRangeException ("mode", mode,
 149                                                 Locale.GetText ("Unsupported mode value"));
 150                         }
 151
 152                         int _ignored;
 153                         if (PosixConvert.TryFromOpenFlags (OpenFlags.O_LARGEFILE, out _ignored))
 154                                 flags |= OpenFlags.O_LARGEFILE;
 155
 156                         switch (access) {
 157                         case FileAccess.Read:
 158                                 flags |= OpenFlags.O_RDONLY;
 159                                 break;
 160                         case FileAccess.Write:
 161                                 flags |= OpenFlags.O_WRONLY;
 162                                 break;
 163                         case FileAccess.ReadWrite:
 164                                 flags |= OpenFlags.O_RDWR;
 165                                 break;
 166                         default:
 167                                 throw new ArgumentOutOfRangeException ("access", access,
 168                                                 Locale.GetText ("Unsupported access value"));
 169                         }
 170
 171                         return flags;
 172                 }
 173         }
 174 }
 175
 176 // vim: noexpandtab