public SocketStream(Context ctx, Socket socket, string openedPath, StreamContext context, bool isAsync = false)
: base(ctx, null, StreamAccessOptions.Read | StreamAccessOptions.Write, openedPath, context)
{
Debug.Assert(socket != null);
this.socket = socket;
this.IsWriteBuffered = false;
this.eof = false;
this.isAsync = isAsync;
this.IsReadBuffered = false;
}
public NativeStream(Context ctx, Stream nativeStream, StreamWrapper openingWrapper, StreamAccessOptions accessOptions, string openedPath, StreamContext context)
: base(ctx, openingWrapper, accessOptions, openedPath, context)
{
Debug.Assert(nativeStream != null);
this.stream = nativeStream;
}
public override string[] Listing(string path, StreamListingOptions options, StreamContext context)
{
Debug.Assert(path != null);
Debug.Assert(Path.IsPathRooted(path));
try
{
string[] listing = Directory.GetFileSystemEntries(path);
bool root = Path.GetPathRoot(path) == path;
int index = root ? 0 : 2;
string[] rv = new string[listing.Length + index];
// Remove the absolute path information (PHP returns only filenames)
int pathLength = path.Length;
if (path[pathLength - 1] != Path.DirectorySeparatorChar) pathLength++;
// Check for the '.' and '..'; they should be present
if (!root)
{
rv[0] = ".";
rv[1] = "..";
}
for (int i = 0; i < listing.Length; i++)
{
rv[index++] = listing[i].Substring(pathLength);
}
return rv;
}
catch (DirectoryNotFoundException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_bad_directory, FileSystemUtils.StripPassword(path));
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(path));
}
catch (System.Exception e)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_error, FileSystemUtils.StripPassword(path), e.Message);
}
return null;
}
public override bool Rename(string fromPath, string toPath, StreamRenameOptions options, StreamContext context)
{
try
{
File.Move(fromPath, toPath);
return true;
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(fromPath));
}
catch (IOException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_rename_file_exists, FileSystemUtils.StripPassword(fromPath), FileSystemUtils.StripPassword(toPath));
}
catch (System.Exception e)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_error, FileSystemUtils.StripPassword(fromPath), e.Message);
}
return false;
}
public override StatStruct Stat(string path, StreamStatOptions options, StreamContext context, bool streamStat)
{
StatStruct invalid = new StatStruct();
invalid.st_size = -1;
Debug.Assert(path != null);
// Note: path is already absolute w/o the scheme, the permissions have already been checked.
return PhpPath.HandleFileSystemInfo(invalid, path, (p) =>
{
FileSystemInfo info = null;
info = new DirectoryInfo(p);
if (!info.Exists)
{
info = new FileInfo(p);
if (!info.Exists)
{
return invalid;
}
}
return BuildStatStruct(info, info.Attributes, p);
});
}
public override bool Unlink(string path, StreamUnlinkOptions options, StreamContext context)
{
Debug.Assert(path != null);
Debug.Assert(Path.IsPathRooted(path));
try
{
File.Delete(path);
return true;
}
catch (DirectoryNotFoundException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_unlink_file_not_found, FileSystemUtils.StripPassword(path));
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(path));
}
catch (IOException e)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_unlink_io_error, FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message));
}
catch (System.Exception)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_unlink_error, FileSystemUtils.StripPassword(path));
}
return false;
}
public virtual bool RemoveDirectory(string path, StreamRemoveDirectoryOptions options, StreamContext context)
{
// int (*stream_rmdir)(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC);
PhpException.Throw(PhpError.Warning, ErrResources.wrapper_op_unsupported, "Rmdir");
return false;
}
public override bool RemoveDirectory(string path, StreamRemoveDirectoryOptions options, StreamContext context)
{
try
{
// Deletes the directory (but not the contents - must be empty)
Directory.Delete(path, false);
return true;
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(path));
}
catch (IOException)
{
// Directory not empty.
PhpException.Throw(PhpError.Warning, ErrResources.stream_rmdir_io_error, FileSystemUtils.StripPassword(path));
}
return false;
}
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context)
{
Debug.Assert(path != null);
//Debug.Assert(PhpPath.IsLocalFile(path));
// Get the File.Open modes from the mode string
FileMode fileMode;
FileAccess fileAccess;
StreamAccessOptions ao;
if (!ParseMode(mode, options, out fileMode, out fileAccess, out ao)) return null;
// Open the native stream
FileStream stream = null;
try
{
// stream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite);
stream = new FileStream(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete);
}
catch (FileNotFoundException)
{
// Note: There may still be an URL in the path here.
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_not_exists, FileSystemUtils.StripPassword(path));
return null;
}
catch (IOException e)
{
if ((ao & StreamAccessOptions.Exclusive) > 0)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_exists, FileSystemUtils.StripPassword(path));
}
else
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_io_error, FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message));
}
return null;
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(path));
return null;
}
catch (System.Exception)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_file_invalid, FileSystemUtils.StripPassword(path));
return null;
}
if ((ao & StreamAccessOptions.SeekEnd) > 0)
{
// Read/Write Append is not supported. Seek to the end of file manually.
stream.Seek(0, SeekOrigin.End);
}
if ((ao & StreamAccessOptions.Temporary) > 0)
{
// Set the file attributes to Temporary too.
File.SetAttributes(path, FileAttributes.Temporary);
}
return new NativeStream(ctx, stream, this, ao, path, context);
}
public virtual bool Rename(string fromPath, string toPath, StreamRenameOptions options, StreamContext context)
{
// int (*rename)(php_stream_wrapper *wrapper, char *url_from, char *url_to, int options, php_stream_context *context TSRMLS_DC);
PhpException.Throw(PhpError.Warning, ErrResources.wrapper_op_unsupported, "Rename");
return false;
}
public virtual string[] Listing(string path, StreamListingOptions options, StreamContext context)
{
// php_stream *(*dir_opener)(php_stream_wrapper *wrapper, char *filename, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC);
PhpException.Throw(PhpError.Warning, ErrResources.wrapper_op_unsupported, "Opendir");
return null;
}
/// <remarks>
/// <seealso cref="StreamUnlinkOptions"/> for the list of additional options.
/// </remarks>
public virtual bool Unlink(string path, StreamUnlinkOptions options, StreamContext context)
{
// int (*unlink)(php_stream_wrapper *wrapper, char *url, int options, php_stream_context *context TSRMLS_DC);
PhpException.Throw(PhpError.Warning, ErrResources.wrapper_op_unsupported, "Unlink");
return false;
}
public abstract PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context);
/// <summary>
/// Openes a PhpStream using the appropriate StreamWrapper.
/// </summary>
/// <param name="ctx">Current runtime context.</param>
/// <param name="path">URI or filename of the resource to be opened.</param>
/// <param name="mode">A file-access mode as passed to the PHP function.</param>
/// <param name="options">A combination of <see cref="StreamOpenOptions"/>.</param>
/// <param name="context">A valid StreamContext. Must not be <c>null</c>.</param>
/// <returns></returns>
public static PhpStream Open(Context ctx, string path, string mode, StreamOpenOptions options, StreamContext context)
{
if (context == null)
throw new ArgumentNullException("context");
Debug.Assert(ctx != null);
StreamWrapper wrapper;
if (!PhpStream.ResolvePath(ctx, ref path, out wrapper, CheckAccessMode.FileMayExist, (CheckAccessOptions)options))
return null;
return wrapper.Open(ctx, ref path, mode, options, context);
}
public virtual StatStruct Stat(string path, StreamStatOptions options, StreamContext context, bool streamStat)
{
// int (*url_stat)(php_stream_wrapper *wrapper, char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC);
return StatUnsupported();
}
/// <summary>
/// PhpStream is created by a StreamWrapper together with the
/// encapsulated RawStream (the actual file opening is handled
/// by the wrapper).
/// </summary>
/// <remarks>
/// This class newly implements the auto-remove behavior too
/// (see <see cref="StreamAccessOptions.Temporary"/>).
/// </remarks>
/// <param name="ctx">Runtime context.</param>
/// <param name="openingWrapper">The parent instance.</param>
/// <param name="accessOptions">The additional options parsed from the <c>fopen()</c> mode.</param>
/// <param name="openedPath">The absolute path to the opened resource.</param>
/// <param name="context">The stream context passed to fopen().</param>
public PhpStream(Context ctx, StreamWrapper openingWrapper, StreamAccessOptions accessOptions, string openedPath, StreamContext context)
: base(PhpStreamTypeName)
{
Debug.Assert(ctx != null);
Debug.Assert(context != null);
_ctx = ctx;
_context = context;
this.Wrapper = openingWrapper;
this.OpenedPath = openedPath;
// Stream modifiers (defined in open-time).
this.Options = accessOptions;
// Allocate the text conversion filters for this stream.
if ((accessOptions & StreamAccessOptions.UseText) > 0)
{
if ((accessOptions & StreamAccessOptions.Read) > 0)
{
textReadFilter = new TextReadFilter();
}
if ((accessOptions & StreamAccessOptions.Write) > 0)
{
textWriteFilter = new TextWriteFilter();
}
}
// this.readTimeout = ScriptContext.CurrentContext.Config.FileSystem.DefaultSocketTimeout;
}
public override bool MakeDirectory(string path, int accessMode, StreamMakeDirectoryOptions options, StreamContext context)
{
if ((path == null) || (path == string.Empty))
{
PhpException.Throw(PhpError.Warning, ErrResources.path_argument_empty);
return false;
}
try
{
// Default Framework MakeDirectory is RECURSIVE, check for other intention.
if ((options & StreamMakeDirectoryOptions.Recursive) == 0)
{
int pos = path.Length - 1;
if (path[pos] == Path.DirectorySeparatorChar) pos--;
pos = path.LastIndexOf(Path.DirectorySeparatorChar, pos);
if (pos <= 0)
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_directory_make_root, FileSystemUtils.StripPassword(path));
return false;
}
// Parent must exist if not recursive.
string parent = path.Substring(0, pos);
if (!Directory.Exists(parent))
{
PhpException.Throw(PhpError.Warning, ErrResources.stream_directory_make_parent, FileSystemUtils.StripPassword(path));
return false;
}
}
// Creates the whole path
Directory.CreateDirectory(path);
return true;
}
catch (UnauthorizedAccessException)
{
// The caller does not have the required permission.
PhpException.Throw(PhpError.Warning, ErrResources.stream_directory_access_denied, FileSystemUtils.StripPassword(path));
}
catch (IOException)
{
// The directory specified by path is read-only or is not empty.
PhpException.Throw(PhpError.Warning, ErrResources.stream_directory_error, FileSystemUtils.StripPassword(path));
}
catch (System.Exception e)
{
// The specified path is invalid, such as being on an unmapped drive ...
PhpException.Throw(PhpError.Warning, ErrResources.stream_error, FileSystemUtils.StripPassword(path), e.Message);
}
return false;
}
