/// <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)); }