/// <summary>
/// Calles library function is not supported.
/// </summary>
/// <param name="severity">A severity of the error.</param>
public static void FunctionNotSupported(PhpError severity)
{
Throw(severity, CoreResources.GetString("function_not_supported"));
}
/// <include file='Doc/Wrappers.xml' path='docs/method[@name="Stat"]/*'/>
/// <remarks>
/// <seealso cref="StreamStatOptions"/> for the list of additional options.
/// </remarks>
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);
PhpException.Throw(PhpError.Warning, CoreResources.GetString("wrapper_op_unsupported", "Stat"));
return(new StatStruct());
}
internal void Add(ErrorInfo info, SourceUnit sourceUnit, Position pos)
{
Add(info, CoreResources.GetString(info.MessageId), sourceUnit, pos);
}
public static void NoSuitableOverload(string className, string /*!*/ methodName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString(
(className != null) ? "no_suitable_method_overload" : "no_suitable_function_overload",
className, methodName));
}
/// <summary>
/// Performs all checks on a path passed to a PHP function.
/// </summary>
/// <remarks>
/// <para>
/// This method performs a check similar to <c>safe_mode.c: php_checkuid_ex()</c>
/// together with <c>open_basedir</c> check.
/// </para>
/// <para>
/// The <paramref name="filename"/> may be one of the following:
/// <list type="bullet">
/// <item>A relative path. The path is resolved regarding the <c>include_path</c> too if required
/// and checking continues as in the next case.</item>
/// <item>An absolute path. The file or directory is checked for existence and for access permissions<sup>1</sup>
/// according to the given <paramref name="mode"/>.</item>
/// </list>
/// <sup>1</sup> Regarding the <c>open_basedir</c> configuration option.
/// File access permissions are checked at the time of file manipulation
/// (opening, copying etc.).
/// </para>
/// </remarks>
/// <param name="filename">A resolved path. Must be an absolute path to a local file.</param>
/// <param name="mode">One of the <see cref="CheckAccessMode"/>.</param>
/// <param name="options"><c>true</c> to suppress error messages.</param>
/// <returns><c>true</c> if the function may continue with file access,
/// <c>false</c>to fail.</returns>
/// <exception cref="PhpException">If the file can not be accessed
/// and the <see cref="CheckAccessOptions.Quiet"/> is not set.</exception>
public static bool CheckAccess(string filename, CheckAccessMode mode, CheckAccessOptions options)
{
Debug.Assert(Path.IsPathRooted(filename));
string url = FileSystemUtils.StripPassword(filename);
bool quiet = (options & CheckAccessOptions.Quiet) > 0;
switch (mode)
{
case CheckAccessMode.FileMayExist:
break;
case CheckAccessMode.FileExists:
if (!File.Exists(filename))
{
if (!quiet)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_not_exists", url));
}
return(false);
}
break;
case CheckAccessMode.FileNotExists:
if (File.Exists(filename))
{
if (!quiet)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_exists", url));
}
return(false);
}
break;
case CheckAccessMode.FileOrDirectory:
if ((!Directory.Exists(filename)) && (!File.Exists(filename)))
{
if (!quiet)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_path_not_exists", url));
}
return(false);
}
break;
case CheckAccessMode.Directory:
if (!Directory.Exists(filename))
{
if (!quiet)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_directory_not_exists", url));
}
return(false);
}
break;
default:
Debug.Assert(false);
return(false);
}
return(true);
}
public static void ConstantNotAccessible(string className, string constName, string context, bool isProtected)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString(
isProtected ? "protected_constant_accessed" : "private_constant_accessed", className, constName, context));
}
public static void MethodNotAccessible(string className, string methodName, string context, bool isProtected)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString(
isProtected ? "protected_method_called" : "private_method_called", className, methodName, context));
}
public static void InvalidBreakLevelCount(int levelCount)
{
Throw(PhpError.Error, CoreResources.GetString("invalid_break_level_count", levelCount));
}
public static void UndefinedVariable(string name)
{
Throw(PhpError.Notice, CoreResources.GetString("undefined_variable", name));
}
public static void UnsupportedOperandTypes()
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("unsupported_operand_types"));
}
public static void InvalidForeachArgument()
{
Throw(PhpError.Warning, CoreResources.GetString("invalid_foreach_argument"));
}
/// <summary>
/// The value of an argument is not invalid but unsupported.
/// </summary>
/// <param name="argument">The argument which value is unsupported.</param>
/// <param name="value">The value which is unsupported.</param>
public static void ArgumentValueNotSupported(string argument, object value)
{
Throw(PhpError.Warning, CoreResources.GetString("argument_value_not_supported", value, argument));
}
/// <summary>
/// Calls by the Class Library methods which need variables but get a <b>null</b> reference.
/// </summary>
public static void NeedsVariables()
{
Throw(PhpError.Warning, CoreResources.GetString("function_needs_variables"));
}
///// <summary>
///// Called library function is deprecated.
///// </summary>
//public static void FunctionDeprecated()
//{
// ErrorStackInfo info = PhpStackTrace.TraceErrorFrame(ScriptContext.CurrentContext);
// FunctionDeprecated(info.LibraryCaller ? info.Caller : null);
//}
/// <summary>
/// Called library function is deprecated.
/// </summary>
public static void FunctionDeprecated(string functionName)
{
Throw(PhpError.Deprecated, CoreResources.GetString("function_is_deprecated", functionName));
}
public static void UndefinedMethodCalled(string className, string methodName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("undefined_method_called", className, methodName));
}
public static void CannotReassignThis()
{
Throw(PhpError.Error, CoreResources.GetString("cannot_reassign_this"));
}
public static void AbstractMethodCalled(string className, string methodName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("abstract_method_called", className, methodName));
}
public static void InvalidArgumentType(string argName, string typeName)
{
Throw(PhpError.Error, CoreResources.GetString("invalid_argument_type", argName, typeName));
}
public static void PropertyNotAccessible(string className, string fieldName, string context, bool isProtected)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString(
isProtected ? "protected_property_accessed" : "private_property_accessed", className, fieldName, context));
}
/// <summary>
/// Array operators reports this error if an value of illegal type is used for indexation.
/// </summary>
public static void IllegalOffsetType()
{
Throw(PhpError.Warning, CoreResources.GetString("illegal_offset_type"));
}
public static void CannotInstantiateType(string typeName, bool isInterface)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString(
isInterface ? "interface_instantiated" : "abstract_class_instantiated", typeName));
}
/// <summary>
/// Array does not contain given <paramref name="key"/>.
/// </summary>
/// <param name="key">Key which was not found in the array.</param>
public static void UndefinedOffset(object key)
{
Throw(PhpError.Notice, CoreResources.GetString("undefined_offset", key));
}
public static void PropertyTypeMismatch(string /*!*/ className, string /*!*/ propertyName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("property_type_mismatch",
className, propertyName));
}
public static void ThisUsedOutOfObjectContext()
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("this_used_out_of_object"));
}
/// <summary>
/// Merges the path with the current working directory
/// to get a canonicalized absolute pathname representing the same file.
/// </summary>
/// <remarks>
/// This method is an analogy of <c>main/safe_mode.c: php_checkuid</c>.
/// Looks for the file in the <c>include_path</c> and checks for <c>open_basedir</c> restrictions.
/// </remarks>
/// <param name="path">An absolute or relative path to a file.</param>
/// <param name="wrapper">The wrapper found for the specified file or <c>null</c> if the path resolution fails.</param>
/// <param name="mode">The checking mode of the <see cref="CheckAccess"/> method (file, directory etc.).</param>
/// <param name="options">Additional options for the <see cref="CheckAccess"/> method.</param>
/// <returns><c>true</c> if all the resolution and checking passed without an error, <b>false</b> otherwise.</returns>
/// <exception cref="PhpException">Security violation - when the target file
/// lays outside the tree defined by <c>open_basedir</c> configuration option.</exception>
public static bool ResolvePath(ref string path, out StreamWrapper wrapper, CheckAccessMode mode, CheckAccessOptions options)
{
// Path will contain the absolute path without file:// or the complete URL; filename is the relative path.
string filename, scheme = GetSchemeInternal(path, out filename);
wrapper = StreamWrapper.GetWrapper(scheme, (StreamOptions)options);
if (wrapper == null)
{
return(false);
}
if (wrapper.IsUrl)
{
// Note: path contains the whole URL, filename the same without the scheme:// portion.
// What to check more?
}
else if (scheme != "php")
{
try
{
// Filename contains the original path without the scheme:// portion, check for include path.
bool isInclude = false;
if ((options & CheckAccessOptions.UseIncludePath) > 0)
{
isInclude = CheckIncludePath(filename, ref path);
}
// Path will now contain an absolute path (either to an include or actual directory).
if (!isInclude)
{
path = Path.GetFullPath(Path.Combine(ScriptContext.CurrentContext.WorkingDirectory, filename));
}
}
catch (Exception)
{
if ((options & CheckAccessOptions.Quiet) == 0)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_filename_invalid",
FileSystemUtils.StripPassword(path)));
}
return(false);
}
GlobalConfiguration global_config = Configuration.Global;
// Note: extensions check open_basedir too -> double check..
if (!global_config.SafeMode.IsPathAllowed(path))
{
if ((options & CheckAccessOptions.Quiet) == 0)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("open_basedir_effect",
path, global_config.SafeMode.GetAllowedPathPrefixesJoin()));
}
return(false);
}
// Replace all '/' with '\'.
// path = path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
Debug.Assert(
path.IndexOf(Path.AltDirectorySeparatorChar) == -1 ||
(Path.AltDirectorySeparatorChar == Path.DirectorySeparatorChar), // on Mono, so ignore it
string.Format("'{0}' should not contain '{1}' char.", path, Path.AltDirectorySeparatorChar));
// The file wrapper expects an absolute path w/o the scheme, others expect the scheme://url.
if (scheme != "file")
{
path = String.Format("{0}://{1}", scheme, path);
}
}
return(true);
}
public static void UndeclaredStaticProperty(string className, string fieldName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("undeclared_static_property_accessed", className, fieldName));
}
/// <include file='Doc/Wrappers.xml' path='docs/method[@name="Open"]/*'/>
public override PhpStream Open(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
this.storageFile = IsolatedStorageFile.GetUserStoreForApplication();
FileStream stream = null;
try
{
stream = new IsolatedStorageFileStream(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete, storageFile);
}
catch (FileNotFoundException)
{
// Note: There may still be an URL in the path here.
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_not_exists",
FileSystemUtils.StripPassword(path)));
return(null);
}
catch (IOException e)
{
if ((ao & StreamAccessOptions.Exclusive) > 0)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_exists",
FileSystemUtils.StripPassword(path)));
}
else
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_io_error",
FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message)));
}
return(null);
}
catch (UnauthorizedAccessException)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_access_denied",
FileSystemUtils.StripPassword(path)));
return(null);
}
catch (Exception)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("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(stream, this, ao, path, context));
}
public static void StaticPropertyUnset(string className, string fieldName)
{
PhpException.Throw(PhpError.Error, CoreResources.GetString("static_property_unset", className, fieldName));
}
internal void Add(ErrorInfo info, SourceUnit sourceUnit, Position pos, object arg1, object arg2)
{
Add(info, CoreResources.GetString(info.MessageId, arg1, arg2), sourceUnit, pos);
}
public static void FunctionNotSupported(string /*!*/ function)
{
Debug.Assert(!string.IsNullOrEmpty(function));
Throw(PhpError.Warning, CoreResources.GetString("notsupported_function_called", function));
}
