import java.lang.reflect.Method;

                    List <String> list = new ArrayList <String> (jarFile.size());

                    List <String> executableList = new ArrayList <String> ();

                    fixPermissions(list,executableList);

    private void fixPermissions(List<String> list, List <String> executableList) {

        if (!isWindows() && !list.isEmpty()) {

            List<String> commands = new ArrayList<String>();

            commands.add("/usr/bin/file");

            commands.addAll(list);

            String filesInfo = readCommandOutput(commands);

            List<String> fileExecutables = new ArrayList<String>();

            for (String s : filesInfo.split("(?:\r\n|\n|\r)")) {//split by lines

                int colonIndex = s.indexOf(":");

                if (colonIndex != -1) {

                    String filePath = s.substring(0, colonIndex).trim();

                    String fileType = s.substring(colonIndex + 1);

                    if (fileType.contains("executable") ||

                            fileType.contains("dynamic lib") ||

                            fileType.contains("shared object") ||

                            fileType.contains("shared library") ||

                            fileType.contains("universal binary") ||

                            fileType.contains("shell script")) {

                        boolean exist = false;

                        try {

                            exist = new File(filePath).exists();

                        } catch (Exception e) {

                        }

                        if(exist) {

                            fileExecutables.add(filePath);

                            //System.out.println("Executable [/usr/bin/file]: " + filePath);

                        }

                    }

                }

            }

            List <String> allExecutables = new ArrayList<String> ();

            allExecutables.addAll(fileExecutables);

            for(String s : executableList) {

                    if(!allExecutables.contains(s)) {

                        //System.out.println("Executable [ interpreter ]: " + s);

                        allExecutables.add(s);

                    }

                }

            chmod(allExecutables);

        }

    }

    private void chmod(List <String> executables) {

        if(executables.isEmpty()) {

            return ;

        }

        if(System.getProperty("java.version").startsWith("1.5")) {

            // Find chmod

            File chmod = new File("/bin/chmod"); // NOI18N

            if (!chmod.isFile()) {

                chmod = new File("/usr/bin/chmod"); // NOI18N

            }

            if (chmod.isFile()) {

                List <String> commands = new ArrayList<String>(executables.size() + 2);

                commands.add(chmod.getAbsolutePath());

                commands.add("a+x"); // NOI18N

                commands.addAll(executables);

                try {

                    System.out.println("Executing command : " + commands);

                    new ProcessBuilder(commands).start().waitFor();

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        } else {

            // Determine if java.io.File.setExecutable method is supported

            try {

                Method setExecutableMethod = File.class.getMethod("setExecutable", Boolean.TYPE, Boolean.TYPE);

                for(String s : executables) {

                    setExecutableMethod.invoke(new File(s), true, false);

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

    }

    private String readCommandOutput(List<String> command) {

        ProcessBuilder builder = new ProcessBuilder(command);

        boolean doRun = true;

        StringBuilder sb = new StringBuilder();

        byte[] bytes = new byte[8192];

        int c = 0;

        try {

            Process process = builder.start();

            while (doRun) {

                try {

                    Thread.sleep(20);

                } catch (InterruptedException e) {

                }

                try {

                    process.exitValue();

                    doRun = false;

                } catch (IllegalThreadStateException e) {

                    ; // do nothing - the process is still running

                }

                InputStream is = process.getInputStream();

                while ((c = is.read(bytes)) != -1) {

                    sb.append(new String(bytes, 0, c));

                }

            }

            return sb.toString();

        } catch (IOException e) {

            e.printStackTrace();

            return new String();

        }

    }

                if (!read) {

                    read = true;

                    if (c >= 4) { // length of ELF header and min length of "#!/X" string

                        if (bytes[0] == '\177' &&

                                bytes[1] == 'E' &&

                                bytes[2] == 'L' &&

                                bytes[3] == 'F') {

                            executableList.add(destFile.getAbsolutePath());

                        } else if (bytes[0] == '#' && bytes[1] == '!') {

                            String s = new String(bytes, 0, c);

                            String[] array = s.split("(?:\r\n|\n|\r)");

                            if (array.length > 0) {

                                //read the first line only

                                //allow lines like "#! /bin/sh"

                                if (array[0].replaceAll("#!(\\s)+/", "#!/").startsWith("#!/")) {

                                    executableList.add(destFile.getAbsolutePath());

                                }

                            }

                        }

                    }

                }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.netbeans.modules.autoupdate.services;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

import org.netbeans.api.autoupdate.UpdateUnit;

import org.netbeans.spi.autoupdate.UpdateItem;

import org.netbeans.spi.autoupdate.UpdateProvider;

/**

 *

 * @author Dmitry Lipin

 */

public class ExecutablePermissionsTest extends NbmAdvancedTestCase {

    private UpdateProvider p = null;

    private String testModuleVersion = "1.0";

    private String testModuleName = "org.yourorghere.executable.permissions";

    public ExecutablePermissionsTest(String name) {

        super(name);

    }

    @Override

    protected void setUp() throws IOException, Exception {

        super.setUp();

    }

    @Override

    public boolean canRun() {

        return super.canRun() && !System.getProperty("os.name").startsWith("Windows");

    }

    private String generateExecutablePermissionsModuleElement() {

        String res = "\n<module codenamebase=\"" + testModuleName + "\" " +

                "homepage=\"http://www.netbeans.org/\" distribution=\"nbresloc:/org/netbeans/api/autoupdate/data/org-yourorghere-executable-permissions.nbm\" " +

                "license=\"standard-nbm-license.txt\" downloadsize=\"5122\" " +

                "needsrestart=\"false\" moduleauthor=\"\" " +

                "eager=\"false\" " +

                "releasedate=\"2006/02/23\">\n";

        res += "<manifest OpenIDE-Module=\"" + testModuleName + "\" " +

                "OpenIDE-Module-Name=\"" + testModuleName + "\" " +

                "AutoUpdate-Show-In-Client=\"true\" " +

                "OpenIDE-Module-Specification-Version=\"" + testModuleVersion + "\"/>\n";

        res += "</module>";

        return res;

    }

    public void testExecutablePermissionsModule() throws IOException {

        String os = !org.openide.util.Utilities.isUnix() ? "Windows" : "Unix";

        String catalog = generateCatalog(generateExecutablePermissionsModuleElement());

        p = createUpdateProvider(catalog);

        p.refresh(true);

        Map<String, UpdateUnit> unitImpls = new HashMap<String, UpdateUnit>();

        Map<String, UpdateItem> updates = p.getUpdateItems();

        assertNotNull("Some modules are installed.", updates);

        assertFalse("Some modules are installed.", updates.isEmpty());

        assertTrue(testModuleName + " found in parsed items.", updates.keySet().contains(testModuleName + "_" + testModuleVersion));

        Map<String, UpdateUnit> newImpls = UpdateUnitFactory.getDefault().appendUpdateItems(unitImpls, p);

        assertNotNull("Some units found.", newImpls);

        assertFalse("Some units found.", newImpls.isEmpty());

        UpdateUnit u1 = newImpls.get(testModuleName);

        installUpdateUnit(u1);

        File binDir = new File(userDir, "bin");

        File elfFile = new File(binDir, "elf");

        File runFile = new File(binDir, "run.sh");

        File runSpaceFile = new File(binDir, "run_space.sh");

        for (File f : new File[]{elfFile, runFile, runSpaceFile}) {

            assertTrue("File " + f + " should exist after module installation", f.exists());

            if (System.getProperty("java.version").startsWith("1.5")) {

                File ls = new File("/bin/ls");

                if (!ls.isFile()) {

                    ls = new File("/usr/bin/ls");

                }

                String output = readCommandOutput(ls.getAbsolutePath(), "-la", f.getAbsolutePath()).trim();

                int index = output.indexOf(" ");

                assertFalse("Can`t read permissions from output:\n" + output, index == -1);

                String permissions = output.substring(0, index);

                assertTrue("File " + f + " does not have executable permissions after installation, actual perms : " + permissions,

                        permissions.matches(".*x.*x.*x.*"));

            } else {

                Method canExecuteMethod = null;

                try {

                    canExecuteMethod = File.class.getMethod("canExecute", new Class[]{});

                } catch (Exception e) {

                    assertTrue("java.io.File.canExecute method is not accessible", false);

                }

                boolean canExecute = false;

                try {

                    canExecute = (Boolean) canExecuteMethod.invoke(f);

                } catch (Exception e) {

                    assertTrue("File " + f + " is not executable after module installation", canExecute);

                    e.printStackTrace();

                }

            }

        }

    }

    private String readCommandOutput(String... command) {

        ProcessBuilder builder = new ProcessBuilder(command);

        boolean doRun = true;

        StringBuilder sb = new StringBuilder();

        byte[] bytes = new byte[8192];

        int c = 0;

        try {

            Process process = builder.start();

            while (doRun) {

                try {

                    Thread.sleep(20);

                } catch (InterruptedException e) {

                }

                try {

                    process.exitValue();

                    doRun = false;

                } catch (IllegalThreadStateException e) {

                    ; // do nothing - the process is still running

                }

                InputStream is = process.getInputStream();

                while ((c = is.read(bytes)) != -1) {

                    sb.append(new String(bytes, 0, c));

                }

            }

            return sb.toString();

        } catch (IOException e) {

            e.printStackTrace();

            return new String();

        }

    }

}