Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

641 lines (569 sloc) 18.05 kB
// VfsStream.cs - System.IO.Stream wrapper around gnome-vfs.
//
// Authors: Jeroen Zwartepoorte <jeroen@xs4all.nl>
//
// Copyright (c) 2004 Jeroen Zwartepoorte
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the Lesser GNU General
// Public License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
using GLib;
using System;
using System.IO;
namespace Gnome.Vfs {
class VfsStreamAsync {
private Handle handle;
private byte[] buffer;
private int count;
private int offset;
private int bytesRemaining;
private System.AsyncCallback cback;
private object state;
private VfsStreamAsyncResult asyncResult;
public VfsStreamAsync (Handle handle, byte[] buffer, int offset,
int count, System.AsyncCallback cback, object state)
{
this.handle = handle;
this.buffer = buffer;
this.offset = offset;
this.count = count;
this.cback = cback;
bytesRemaining = count;
}
public VfsStreamAsyncResult BeginRead ()
{
asyncResult = new VfsStreamAsyncResult (state);
Async.Read (handle, out buffer[offset], (uint)count, new AsyncReadCallback (AsyncRead));
return asyncResult;
}
public VfsStreamAsyncResult BeginWrite ()
{
asyncResult = new VfsStreamAsyncResult (state);
Async.Write (handle, out buffer[offset], (uint)count, new AsyncWriteCallback (AsyncWrite));
return asyncResult;
}
private void AsyncRead (Handle handle, Result result, byte[] buf,
ulong bytesRequested, ulong bytesRead)
{
if (result == Result.Ok) {
Array.Copy (buf, 0, buffer, offset + count - bytesRemaining, (int)bytesRead);
bytesRemaining -= (int)bytesRead;
if (bytesRemaining > 0) {
buf = new byte[bytesRemaining];
Async.Read (handle, out buf[0], (uint)bytesRemaining,
new AsyncReadCallback (AsyncRead));
} else if (cback != null) {
asyncResult.SetComplete (null, count);
cback (asyncResult);
}
} else if (result == Result.ErrorEof) {
Array.Copy (buf, 0, buffer, offset + count - bytesRemaining, (int)bytesRead);
bytesRemaining -= (int)bytesRead;
asyncResult.SetComplete (null, count - bytesRemaining);
if (cback != null)
cback (asyncResult);
} else if (cback != null) {
Exception e = new IOException (Vfs.ResultToString (result));
asyncResult.SetComplete (e, -1);
cback (asyncResult);
}
}
private void AsyncWrite (Handle handle, Result result, byte[] buffer,
ulong bytesRequested, ulong bytesWritten)
{
if (result == Result.Ok) {
bytesRemaining -= (int)bytesWritten;
if (bytesRemaining > 0) {
Async.Write (handle, out buffer[offset + count - bytesRemaining],
(uint)bytesRemaining, new AsyncWriteCallback (AsyncWrite));
} else if (cback != null) {
asyncResult.SetComplete (null, count);
cback (asyncResult);
}
} else if (result == Result.ErrorEof) {
bytesRemaining -= (int)bytesWritten;
asyncResult.SetComplete (null, count - bytesRemaining);
if (cback != null)
cback (asyncResult);
} else if (cback != null) {
Exception e = new IOException (Vfs.ResultToString (result));
asyncResult.SetComplete (e, -1);
cback (asyncResult);
}
}
}
public class VfsStream : System.IO.Stream {
private Gnome.Vfs.Uri uri;
private Handle handle;
private FileMode mode;
private FileAccess access;
private bool async;
private bool canseek;
// Async state variables.
private AsyncCallback callback;
private AsyncReadCallback readCallback;
private AsyncWriteCallback writeCallback;
private bool asyncCompleted = false;
private Result asyncResult;
private ulong asyncBytesRead;
private ulong asyncBytesWritten;
public VfsStream (string uri, FileMode mode)
: this (uri, mode, false) { }
public VfsStream (string text_uri, FileMode mode, bool async)
{
if (text_uri == null)
throw new ArgumentNullException ("uri");
if (text_uri == "")
throw new ArgumentNullException ("Uri is empty");
if (mode < FileMode.CreateNew || mode > FileMode.Append)
throw new ArgumentOutOfRangeException ("mode");
if (text_uri.IndexOfAny (Path.InvalidPathChars) != -1)
throw new ArgumentException ("Uri has invalid chars");
uri = new Gnome.Vfs.Uri (text_uri);
if (mode == FileMode.Open && !uri.Exists)
throw new FileNotFoundException ("Could not find uri \"" + text_uri + "\".");
if (mode == FileMode.CreateNew) {
string dname = uri.ExtractDirname ();
if (dname != "" && !new Uri (dname).Exists)
throw new DirectoryNotFoundException ("Could not find a part of " +
"the path \"" + dname + "\".");
}
if (async) {
callback = new AsyncCallback (OnAsyncCallback);
readCallback = new AsyncReadCallback (OnAsyncReadCallback);
writeCallback = new AsyncWriteCallback (OnAsyncWriteCallback);
}
OpenMode om = OpenMode.None;
switch (mode) {
case FileMode.CreateNew:
case FileMode.Create:
case FileMode.Truncate:
case FileMode.Append:
om = OpenMode.Write;
access = FileAccess.Write;
break;
case FileMode.OpenOrCreate:
if (uri.Exists) {
om = OpenMode.Read;
access = FileAccess.Read;
} else {
om = OpenMode.Write;
access = FileAccess.Write;
}
break;
case FileMode.Open:
om = OpenMode.Read;
access = FileAccess.Read;
break;
}
/* 644 */
FilePermissions perms = FilePermissions.UserRead |
FilePermissions.UserWrite |
FilePermissions.GroupRead |
FilePermissions.OtherRead;
Result result;
handle = null;
switch (mode) {
case FileMode.Append:
if (uri.Exists) {
if (async) {
handle = Async.Open (uri, om,
(int)Async.Priority.Default,
callback);
Wait ();
Async.Seek (handle, SeekPosition.End, 0, callback);
Wait ();
} else {
handle = Sync.Open (uri, om);
result = Sync.Seek (handle, SeekPosition.End, 0);
Vfs.ThrowException (uri, result);
}
} else {
if (async) {
handle = Async.Create (uri, om, true, perms,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Create (uri, om, true, perms);
}
}
break;
case FileMode.Create:
if (uri.Exists) {
if (async) {
handle = Async.Open (uri, om,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Open (uri, om);
result = uri.Truncate (0);
Vfs.ThrowException (uri, result);
}
} else {
handle = Sync.Create (uri, om, true, perms);
}
break;
case FileMode.CreateNew:
if (uri.Exists) {
throw new IOException ("Uri \"" + text_uri + "\" already exists.");
} else {
if (async) {
handle = Async.Create (uri, om, true, perms,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Create (uri, om, true, perms);
}
}
break;
case FileMode.Open:
if (uri.Exists) {
if (async) {
handle = Async.Open (uri, om,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Open (uri, om);
}
} else {
throw new FileNotFoundException (text_uri);
}
break;
case FileMode.OpenOrCreate:
if (uri.Exists) {
if (async) {
handle = Async.Open (uri, om,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Open (uri, om);
}
} else {
if (async) {
handle = Async.Create (uri, om, true, perms,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Create (uri, om, true, perms);
}
}
break;
case FileMode.Truncate:
if (uri.Exists) {
result = uri.Truncate (0);
if (async) {
handle = Async.Open (uri, om,
(int)Async.Priority.Default,
callback);
Wait ();
} else {
handle = Sync.Open (uri, om);
Vfs.ThrowException (uri, result);
}
} else {
throw new FileNotFoundException (text_uri);
}
break;
}
this.mode = mode;
this.canseek = true;
this.async = async;
}
public override bool CanRead {
get {
return access == FileAccess.Read ||
access == FileAccess.ReadWrite;
}
}
public override bool CanWrite {
get {
return access == FileAccess.Write ||
access == FileAccess.ReadWrite;
}
}
public override bool CanSeek {
get {
return canseek;
}
}
public virtual bool IsAsync {
get {
return async;
}
}
public string Uri {
get {
return uri.ToString ();
}
}
public override long Length {
get {
FileInfo info = uri.GetFileInfo ();
return info.Size;
}
}
public override long Position {
get {
if (IsAsync)
throw new NotSupportedException ("Cannot tell what the offset is in async mode");
ulong pos;
Result result = Sync.Tell (handle, out pos);
Vfs.ThrowException (Uri, result);
return (long)pos;
}
set {
Seek (value, SeekOrigin.Begin);
}
}
public override int ReadByte ()
{
if (!CanRead)
throw new NotSupportedException ("The stream does not support reading");
byte[] buffer = new byte[1];
ulong bytesRead;
Result result;
if (async) {
Async.Read (handle, out buffer[0], 1, readCallback);
Wait ();
result = asyncResult;
} else {
result = Sync.Read (handle, out buffer[0], 1UL, out bytesRead);
}
if (result == Result.ErrorEof)
return -1;
Vfs.ThrowException (Uri, result);
return buffer[0];
}
public override void WriteByte (byte value)
{
if (!CanWrite)
throw new NotSupportedException ("The stream does not support writing");
byte[] buffer = new byte[1];
buffer[0] = value;
ulong bytesWritten;
Result result;
if (async) {
Async.Write (handle, out buffer[0], 1, writeCallback);
Wait ();
result = asyncResult;
} else {
result = Sync.Write (handle, out buffer[0], 1UL, out bytesWritten);
}
Vfs.ThrowException (Uri, result);
}
public override int Read (byte[] buffer, int offset, int count)
{
if (buffer == null)
throw new ArgumentNullException ("buffer");
else if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
else if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
else if (count > buffer.Length - offset)
throw new ArgumentException ("Buffer too small, count/offset wrong");
else if (!CanRead)
throw new NotSupportedException ("The stream does not support reading");
ulong bytesRead;
Result result;
if (async) {
Async.Read (handle, out buffer[offset], (uint)count, readCallback);
Wait ();
result = asyncResult;
bytesRead = asyncBytesRead;
} else {
result = Sync.Read (handle, out buffer[offset], (ulong)count, out bytesRead);
}
if (result == Result.ErrorEof)
return 0;
Vfs.ThrowException (Uri, result);
return (int)bytesRead;
}
public override IAsyncResult BeginRead (byte[] buffer, int offset, int count,
System.AsyncCallback cback, object state)
{
if (buffer == null)
throw new ArgumentNullException ("buffer");
else if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
else if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
else if (count > buffer.Length - offset)
throw new ArgumentException ("Buffer too small, count/offset wrong");
else if (!CanRead)
throw new NotSupportedException ("The stream does not support reading");
if (!IsAsync)
return base.BeginRead (buffer, offset, count, cback, state);
VfsStreamAsync async = new VfsStreamAsync (handle, buffer, offset, count, cback, state);
return async.BeginRead ();
}
public override int EndRead (IAsyncResult result)
{
if (result == null)
throw new ArgumentNullException ("result");
if (!IsAsync)
base.EndRead (result);
if (!(result is VfsStreamAsyncResult))
throw new ArgumentException ("Invalid IAsyncResult object", "result");
VfsStreamAsyncResult asyncResult = (VfsStreamAsyncResult)result;
if (asyncResult.Done)
throw new InvalidOperationException ("EndRead already called");
asyncResult.Done = true;
while (!asyncResult.IsCompleted)
MainContext.Iteration ();
if (asyncResult.Exception != null)
throw asyncResult.Exception;
return asyncResult.NBytes;
}
public override void Write (byte[] buffer, int offset, int count)
{
if (buffer == null)
throw new ArgumentNullException ("buffer");
else if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
else if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
else if (count > buffer.Length - offset)
throw new ArgumentException ("Buffer too small, count/offset wrong");
else if (!CanWrite)
throw new NotSupportedException ("The stream does not support writing");
ulong bytesWritten;
Result result;
if (async) {
Async.Write (handle, out buffer[offset], (uint)count, writeCallback);
Wait ();
result = asyncResult;
bytesWritten = asyncBytesWritten;
} else {
result = Sync.Write (handle, out buffer[offset], (ulong)count, out bytesWritten);
}
Vfs.ThrowException (Uri, result);
}
public override IAsyncResult BeginWrite (byte [] buffer, int offset, int count,
System.AsyncCallback cback, object state)
{
if (buffer == null)
throw new ArgumentNullException ("buffer");
else if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
else if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
else if (count > buffer.Length - offset)
throw new ArgumentException ("Buffer too small, count/offset wrong");
else if (!CanWrite)
throw new NotSupportedException ("The stream does not support writing");
if (!IsAsync)
return base.BeginRead (buffer, offset, count, cback, state);
VfsStreamAsync async = new VfsStreamAsync (handle, buffer, offset, count, cback, state);
return async.BeginWrite ();
}
public override void EndWrite (IAsyncResult result)
{
if (result == null)
throw new ArgumentNullException ("result");
if (!IsAsync)
base.EndWrite (result);
if (!(result is VfsStreamAsyncResult))
throw new ArgumentException ("Invalid IAsyncResult object", "result");
VfsStreamAsyncResult asyncResult = (VfsStreamAsyncResult)result;
if (asyncResult.Done)
throw new InvalidOperationException ("EndWrite already called");
asyncResult.Done = true;
while (!asyncResult.IsCompleted)
MainContext.Iteration ();
if (asyncResult.Exception != null)
throw asyncResult.Exception;
}
public override long Seek (long offset, SeekOrigin origin)
{
if (!CanSeek)
throw new NotSupportedException ("The stream does not support seeking");
if (IsAsync && origin == SeekOrigin.Current)
throw new NotSupportedException ("Cannot tell what the offset is in async mode");
SeekPosition seekPos = SeekPosition.Start;
long newOffset = -1;
switch (origin) {
case SeekOrigin.Begin:
seekPos = SeekPosition.Start;
newOffset = offset;
break;
case SeekOrigin.Current:
seekPos = SeekPosition.Current;
break;
case SeekOrigin.End:
seekPos = SeekPosition.End;
newOffset = Length + offset;
break;
}
Result result;
if (async) {
Async.Seek (handle, seekPos, offset, callback);
Wait ();
result = asyncResult;
} else {
result = Sync.Seek (handle, seekPos, offset);
}
Vfs.ThrowException (Uri, result);
return newOffset;
}
public override void SetLength (long length)
{
if (!CanSeek)
throw new NotSupportedException ("The stream does not support seeking");
else if (!CanWrite)
throw new NotSupportedException ("The stream does not support writing");
Result result = Sync.Truncate (handle, (ulong)length);
Vfs.ThrowException (Uri, result);
}
public override void Flush ()
{
}
public override void Close ()
{
Result result = Sync.Close (handle);
Vfs.ThrowException (Uri, result);
}
private void OnAsyncCallback (Handle handle, Result result)
{
asyncResult = result;
asyncCompleted = true;
}
private void OnAsyncReadCallback (Handle handle, Result result,
byte[] buffer, ulong bytes_requested,
ulong bytes_read)
{
asyncResult = result;
asyncBytesRead = bytes_read;
asyncCompleted = true;
}
private void OnAsyncWriteCallback (Handle handle, Result result,
byte[] buffer, ulong bytes_requested,
ulong bytes_written)
{
asyncResult = result;
asyncBytesWritten = bytes_written;
asyncCompleted = true;
}
private void Wait ()
{
while (!asyncCompleted)
MainContext.Iteration ();
asyncCompleted = false;
}
}
}
Jump to Line
Something went wrong with that request. Please try again.