Attachment #143037 for bug #239310

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 239310
Collapse All | Expand All




    private static byte[] ZIP_HEADER_1 = {0x50, 0x4b, 0x03, 0x04};
    /** Also seems to be used at least in apisupport/project/test/unit/data/example-external-projects/suite3/nbplatform/random/modules/ext/stuff.jar; not known why */
    private static byte[] ZIP_HEADER_2 = {0x50, 0x4b, 0x05, 0x06};

    /** transient attributes which should not be copied
    * of type Set<String>
    */

            return file.getPath() + "(" + file.getClass() + ")"; // NOI18N
        }
    }

    static boolean assertNormalized(File path) {
        if (path != null) {
            File np;
            assert path.getClass().getName().startsWith("sun.awt.shell") ||
                path.equals(np = FileUtil.normalizeFileCached(path)) :
                "Need to normalize " + toDebugString(path) + " was " + toDebugString(np);  //NOI18N
        }
        return true;


    private FileUtil() {
    }

    /**
     * Refreshes all necessary filesystems. Not all instances of <code>FileObject</code> are refreshed
     * but just those that represent passed <code>files</code> and their children recursively.

            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    /**
     * Refreshes all <code>FileObject</code> that represent files <code>File.listRoots()</code>
     * and their children recursively.
     * @since 7.7
     */

    /**
     * Registers <code>listener</code> so that it will receive
     * <code>FileEvent</code>s from <code>FileSystem</code>s providing instances
     * of <code>FileObject</code> convertible to <code>java.io.File</code>.
     * @param fcl
     * @see #toFileObject
     * @since 7.7

            fs.addFileChangeListener(fcl);
        }
    }

    /**
     * Unregisters <code>listener</code> so that it will no longer receive
     * <code>FileEvent</code>s from <code>FileSystem</code>s providing instances
     * of <code>FileObject</code> convertible to <code>java.io.File</code>
     * @param fcl
     * @see #toFileObject
     * @since 7.7

     * <li>fileRenamed event is fired when the folder is renamed or a child file/folder is renamed</li>
     * <li>fileAttributeChanged is fired when FileObject's attribute is changed</li>
     *</ul>
     * Can only add a given [listener, path] pair once. However a listener can
     * listen to any number of paths. Note that listeners are always held weakly
     * - if the listener is collected, it is quietly removed.
     *

        FileChangeImpl.removeFileChangeListenerImpl(LOG, listener, path);
    }
    /**
     * Works like {@link #addRecursiveListener(org.openide.filesystems.FileChangeListener, java.io.File, java.io.FileFilter, java.util.concurrent.Callable)
     * addRecursiveListener(listener, path, null, null)}.
     *
     * @param listener FileChangeListener to listen to changes in path

        addRecursiveListener(listener, path, null, null);
    }

    /** Works like {@link #addRecursiveListener(org.openide.filesystems.FileChangeListener, java.io.File, java.io.FileFilter, java.util.concurrent.Callable)
     * addRecursiveListener(listener, path, null, stop)}.
     *
     * @param listener FileChangeListener to listen to changes in path

        addRecursiveListener(listener, path, null, stop);
    }

    /**
     * Adds a listener to changes under given path. It permits you to listen to a file
     * which does not yet exist, or continue listening to it after it is deleted and recreated, etc.
     * <br/>

     * next recursive items is interrupted. The listener may or may not get
     * some events from already registered folders.
     * </div>
     *
     * Those who provide {@link FileFilter recurseInto} callback can prevent
     * the system to enter, and register operating system level listeners
     * to certain subtrees under the provided <code>path</code>. This does
     * not prevent delivery of changes, if they are made via the filesystem API.
     * External changes however will not be detected.
     *
     * @param listener FileChangeListener to listen to changes in path
     * @param path File path to listen to (even not existing)
     * @param stop an interface to interrupt the process of registering

    }

    /**
     * Executes atomic action. For more info see {@link FileSystem#runAtomicAction}.
     * <p>
     * All events about filesystem changes (related to events on all affected instances of <code>FileSystem</code>)
     * are postponed after the whole <code>atomicCode</code>
     * is executed.
     * </p>
     * @param atomicCode code that is supposed to be run as atomic action. See {@link FileSystem#runAtomicAction}

    }

    /**
     * Executes atomic action. For more info see {@link FileSystem#runAtomicAction}.
     * <p>
     * All events about filesystem changes (related to events on all affected instances of <code>FileSystem</code>)
     * are postponed after the whole <code>atomicCode</code>
     * is executed.
     * </p>
     * @param atomicCode code that is supposed to be run as atomic action. See {@link FileSystem#runAtomicAction}

        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        }
    }
    /**
     * Returns FileObject for a folder.
     * If such a folder does not exist then it is created, including any necessary but nonexistent parent
     * folders. Note that if this operation fails it may have succeeded in creating some of the necessary
     * parent folders.
     * @param folder folder to be created

        }
        if (existingFolder == null) {
            throw new IOException(folder.getAbsolutePath());
        }

        FileObject retval = null;
        FileObject folderFo = FileUtil.toFileObject(existingFolder);
        assert folderFo != null : existingFolder.getAbsolutePath();
        final String relativePath = getRelativePath(existingFolder, folder);
        try {
            retval = FileUtil.createFolder(folderFo,relativePath);
        } catch (IOException ex) {
            //thus retval = null;
        }
        //if refresh needed because of external changes
        if (retval == null || !retval.isValid()) {
            folderFo.getFileSystem().refresh(false);
            retval = FileUtil.createFolder(folderFo,relativePath);
        }
        assert retval != null;
        return retval;
    }

    /**Returns FileObject for a data file.
     * If such a data file does not exist then it is created, including any necessary but nonexistent parent
     * folders. Note that if this operation fails it may have succeeded in creating some of the necessary

     * @throws java.io.IOException if the creation fails
     * @since 7.0
     */
    public static FileObject createData (final File data) throws IOException {
        File folder = data;
        while(folder != null && !folder.isDirectory()) {
            folder = folder.getParentFile();
        }
        if (folder == null) {
            throw new IOException(data.getAbsolutePath());
        }

        FileObject retval = null;
        FileObject folderFo = FileUtil.toFileObject(folder);
        assert folderFo != null : folder.getAbsolutePath();
        final String relativePath = getRelativePath(folder, data);
        try {
            retval = FileUtil.createData(folderFo,relativePath);
        } catch (IOException ex) {
            //thus retval = null;
        }
        //if refresh needed because of external changes
        if (retval == null || !retval.isValid()) {
            folderFo.getFileSystem().refresh(false);
            retval = FileUtil.createData(folderFo,relativePath);
        }
        assert retval != null;
        return retval;
    }

    private static String getRelativePath(final File dir, final File file) {
        Stack<String> stack = new Stack<String>();
        File tempFile = file;

            if (!stack.isEmpty()) {
                retval.append('/');//NOI18N
            }
        }
        return retval.toString();
    }

    /** Copies stream of files.
    * <P>
    * Please be aware, that this method doesn't close any of passed streams.

        }
    }

    /** Returns a folder on given filesystem if such a folder exists.
     * If not then a folder is created, including any necessary but nonexistent parent
     * folders. Note that if this operation fails it may have succeeded in creating some of the necessary
     * parent folders.
     * The name of the new folder can be
     * specified as a multi-component pathname whose components are separated
     * by File.separatorChar or &quot;/&quot; (forward slash).

        return folder;
    }

    /** Returns a data file on given filesystem if such a data file exists.
    * If not then a data file is created, including any necessary but nonexistent parent
    * folders. Note that if this operation fails it may have succeeded in creating some of the necessary
    * parent folders. The name of
    * data file can be composed as resource name (e. g. org/netbeans/myfolder/mydata ).

     * @since 1.29
     */
    public static File toFile(FileObject fo) {
        File retVal = (File) fo.getAttribute("java.io.File"); // NOI18N;

        if (retVal == null) {
            URL fileURL = URLMapper.findURL(fo, URLMapper.INTERNAL);

     * <pre>
     * OpenIDE-Module-Needs: org.openide.filesystems.FileUtil.toFileObject
     * </pre>
     *
     * @param file a disk file (may or may not exist). This file
     * must be {@linkplain #normalizeFile normalized}.
     * @return a corresponding file object, or null if the file does not exist

        if (asserts) {
            File normFile = normalizeFile(file);
            if (!file.equals(normFile)) {
                final String msg = "Parameter file was not " + // NOI18N
                    "normalized. Was " + toDebugString(file) + " instead of " + toDebugString(normFile); // NOI18N
                LOG.log(Level.WARNING, msg);
                LOG.log(Level.INFO, msg, new IllegalArgumentException(msg));

        }
        return retVal;
    }

    /** Finds appropriate FileObjects to java.io.File if possible.
     * If not possible then empty array is returned. More FileObjects may
     * correspond to one java.io.File that`s why array is returned.

            AtomicBoolean isRawValue = new AtomicBoolean();
            Object value = XMLMapAttr.getRawAttribute(source, key, isRawValue);

            // #132801 and #16761 - don't set attributes where value is
            // instance of VoidValue because these attributes were previously written
            // by mistake in code. So it should happen only if you import some
            // settings from old version.
            if (value != null && !(value instanceof MultiFileObject.VoidValue)) {

     * {@link MIMEResolver#getMIMETypes} contain one or more of the requested
     * MIME types will be asked if they recognize the file. It is possible for
     * the resulting MIME type to not be a member of this list.
     * @return the MIME type for the FileObject, or <code>null</code> if
     * the FileObject is unrecognized. It may return {@code content/unknown} instead of {@code null}.
     * It is possible for the resulting MIME type to not be a member of given list.
     * @since 7.13

        Parameters.notNull("withinMIMETypes", withinMIMETypes);  //NOI18N
        return MIMESupport.findMIMEType(fo, withinMIMETypes);
    }

    /** Registers specified extension to be recognized as specified MIME type.
     * If MIME type parameter is null, it cancels previous registration.
     * Note that you may register a case-sensitive extension if that is

        }
        return normalized;
    }

    /**
     * Normalize a file path to a clean form.
     * This method may for example make sure that the returned file uses

        assert assertNormalized(ret);
        return ret;
    }

    private static File normalizeFileCached(final File file) {
        Map<String, String> normalizedPaths = getNormalizedFilesMap();
        String unnormalized = file.getPath();
        String normalized = normalizedPaths.get(unnormalized);
        if (
            normalized != null &&
                normalized.equalsIgnoreCase(unnormalized) &&
                !normalized.equals(unnormalized)
        ) {
            normalized = null;

        File retVal = file;

        try {
            // URI.normalize removes ../ and ./ sequences nicely.
            File absoluteFile = Utilities.toFile(Utilities.toURI(file).normalize());
            File canonicalFile = file.getCanonicalFile();
            String absolutePath = absoluteFile.getAbsolutePath();

        File retVal = File.listRoots()[0];
        File pureCanonicalFile = retVal;

        final String pattern = File.separator + ".." + File.separator; //NOI18N
        final String fileName;

        { // strips insufficient non-<tt>".."</tt> segments preceding them

        return retVal;
    }

    /**
     * Fast normalization of local file paths located on a drive without using IO
     *
     * Notes: Declared public to allow unit testing of this method
     *
     * @param filePath
     * @throws Exception
     * @return String  Normalized file path
     */
    public static String getNormalizedPathOnWindows(String filePath)
    throws Exception {
        /* Check for wildcards - Canonicalization is not globbing */
        if (filePath.contains("?") || filePath.contains("*"))
            throw new Exception();

        String[] pathParts = filePath.split("[\\\\/]");
        ArrayList<String> normalizedPathParts;
        normalizedPathParts = new ArrayList(pathParts.length);

        for (String subPath : pathParts) {
            /* Skip the dot and empty(sequence of slashes) names */
            if (subPath.equals(".") || subPath.length() == 0)
                continue;

            /* Do not remove drive letter and : */
            if (subPath.equals("..")) {
                if (normalizedPathParts.size() > 1)
                    normalizedPathParts.remove(normalizedPathParts.size() - 1);
                continue;
            }

            /* Path chunk should not end with a dot(Except special "." and ".." notations which are specially checked above) */
            if (subPath.endsWith("."))
                throw new Exception();

            normalizedPathParts.add(subPath);
        }

        String fileName = normalizedPathParts.get(normalizedPathParts.size() - 1);
        normalizedPathParts.remove(normalizedPathParts.size() - 1);

        String normalizedPath = "";
        for (String pathPart : normalizedPathParts)
            normalizedPath += pathPart + File.separator;
        normalizedPath += fileName;
        /* Process shorts like "C:" correctly -> Shall return "C:\" */
        if (normalizedPath.length() == 2)
            normalizedPath += File.separator;

        char driveLetter = normalizedPath.charAt(0);
        normalizedPath = normalizedPath.replaceFirst(Character.toString(driveLetter), Character.toString(Character.toUpperCase(driveLetter)));

        return normalizedPath;
    }

	private static File normalizeFileOnWindows(final File file) {
        File retVal = null;

        if (file.getClass().getName().startsWith("sun.awt.shell")) { // NOI18N
            return file;
        }

        String filePath = file.getAbsolutePath();

        /* Check if path starts with a standard drive letter */
        if (filePath.length() > 1 && filePath.charAt(1) == ':') {
            try {
                String normalizedPath = getNormalizedPathOnWindows(filePath);
                retVal = new File(normalizedPath);
            } catch (Exception e) {
                String path = file.getPath();
                LOG.log(Level.FINE, path, e);
            }
        }
        else {
            try {
                retVal = file.getCanonicalFile();
                if (retVal.getName().equals(".")) { // NOI18Ny
                    // try one more time
                    retVal = retVal.getCanonicalFile();
                }
            } catch (IOException e) {
                String path = file.getPath();
                // report only other than UNC path \\ or \\computerName because these cannot be canonicalized
                if (!path.equals("\\\\") && !("\\\\".equals(file.getParent()))) {  //NOI18N
                    LOG.log(Level.FINE, path, e);
                }
            }
        }
        // #135547 - on Windows Vista map "Documents and Settings\<username>\My Documents" to "Users\<username>\Documents"

                    }
                    return new URL(jarPath);

                } catch (MalformedURLException mue) {
                    LOG.log(
                        Level.WARNING,
                        "Invalid URL ({0}): {1}, jarPath: {2}", //NOI18N

        try {
            boolean wasDir;
            boolean isDir;
            URL u;
            do {
                wasDir = entry.isDirectory();
                LOG.finest("urlForArchiveOrDir:toURI:entry");   //NOI18N

        Parameters.notNull("path", path);  //NOI18N
        return Repository.getDefault().getDefaultFileSystem().findResource(path);
    }

    /** Finds a config object under given path. The path contains the extension
     * of a file e.g.:
     * <pre>

     * @param filePath path to .instance or .settings file
     * @param type the requested type for given object
     * @return either null or instance of requrested type
     * @since 7.49
     */
    public static <T> T getConfigObject(String path, Class<T> type) {
        FileObject fo = getConfigFile(path);

            return wrapFileNoCanonicalize(delegate.createFileObject(path));
        }
    }

    private static FileSystem getDiskFileSystem() {
        synchronized (FileUtil.class) {
            return diskFileSystem;

Return to bug 239310