Dépôt officiel du code source de l'ERP OpenConcerto

/*

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

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html 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.

 */

 package org.openconcerto.utils;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.InetAddress;

import java.net.NetworkInterface;

import java.net.ServerSocket;

import java.net.SocketException;

import java.net.URL;

import java.net.URLEncoder;

import java.nio.charset.StandardCharsets;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.security.cert.X509Certificate;

import java.util.Enumeration;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Map.Entry;

import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.SSLSession;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

public class NetUtils {

    public static int findFreePort(final int preferred) {

        return findFreePort(null, preferred);

    }

    /**

     * Returns a free port number on localhost.

     *

     * @param addr the bind address, <code>null</code> meaning an address of the loopback interface.

     * @param preferred if this port is free, then it's returned.

     * @return preferred if free otherwise any free port.

     */

    public static int findFreePort(final String addr, final int preferred) {

        if (isPortFree(addr, preferred))

            return preferred;

        else

            return findFreePort(addr);

    }

    /**

     * Returns a free port number on localhost.

     *

     * @return a free port number on localhost, or -1 if unable to find a free port

     */

    public static int findFreePort() {

        return findFreePort(null);

    }

    public static int findFreePort(final String addr) {

        return checkPort(addr, 0);

    }

    public static boolean isPortFree(final String addr, final int port) {

        if (port <= 0)

            throw new IllegalArgumentException(port + " is negative");

        return checkPort(addr, port) == port;

    }

    // with code from from org/eclipse/jdt/launching/SocketUtil.java

    private static int checkPort(final String addr, final int port) {

        ServerSocket socket = null;

        try {

            // ATTN InetAddress.getByName(null) means an address of the loopback interface, while

            // passing null means any/all local addresses. The problem is that the constructor will

            // succeed for a given port even if it is already bound with the other address.

            socket = new ServerSocket(port, 0, InetAddress.getByName(addr));

            return socket.getLocalPort();

        } catch (IOException e) {

        } finally {

            if (socket != null) {

                try {

                    socket.close();

                } catch (IOException e) {

                }

            }

        }

        return -1;

    }

    /**

     * Whether the passed address refers to this computer.

     *

     * @param addr an ip or dns address, eg "192.168.28.52".

     * @return <code>true</code> if <code>addr</code> is bound to an interface of this computer.

     */

    static public final boolean isSelfAddr(String addr) {

        if (addr == null)

            return false;

        if (addr.startsWith("127.") || addr.startsWith("localhost"))

            return true;

        try {

            final Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();

            while (en.hasMoreElements()) {

                final NetworkInterface ni = en.nextElement();

                final Enumeration<InetAddress> addresses = ni.getInetAddresses();

                while (addresses.hasMoreElements()) {

                    final InetAddress inetAddress = addresses.nextElement();

                    if (addr.startsWith(inetAddress.getHostAddress()))

                        return true;

                }

            }

            return false;

        } catch (SocketException e) {

            e.printStackTrace();

            return false;

        }

    }

    public static final HostnameVerifier HostnameNonVerifier = new HostnameVerifier() {

        @Override

        public boolean verify(String hostname, SSLSession session) {

            return true;

        }

    };

    public static final String getHTTPContent(String address) {

        return getHTTPContent(address, false);

    }

    public static final String getHTTPContent(String address, final boolean dontVerify) {

        String content = "";

        OutputStream out = null;

        HttpsURLConnection conn = null;

        InputStream in = null;

        try {

            URL url = new URL(address);

            out = new ByteArrayOutputStream();

            conn = (HttpsURLConnection) url.openConnection();

            // Sur la connexion

            if (dontVerify) {

                conn.setHostnameVerifier(HostnameNonVerifier);

                // ou globalement

                // HttpsURLConnection.setDefaultHostnameVerifier(new CustomizedHostnameVerifier());

            }

            in = conn.getInputStream();

            final byte[] buffer = new byte[1024];

            int numRead;

            while ((numRead = in.read(buffer)) != -1) {

                out.write(buffer, 0, numRead);

            }

            content = out.toString();

        } catch (Exception exception) {

            exception.printStackTrace();

        } finally {

            try {

                if (in != null) {

                    in.close();

                }

                if (out != null) {

                    out.close();

                }

            } catch (IOException ioe) {

            }

        }

        return content;

    }

    /**

     * Encode for POST message application/x-www-form-urlencoded

     */

    static public final String urlEncode(final String... kv) {

        final int size = kv.length;

        if (size % 2 != 0)

            throw new IllegalArgumentException("Odd number of items : " + size);

        final LinkedHashMap<String, Object> map = new LinkedHashMap<>(size / 2, 1);

        for (int i = 0; i < size; i += 2) {

            map.put(kv[i], kv[i + 1]);

        }

        return urlEncode(map);

    }

    /**

     * Encode for POST message application/x-www-form-urlencoded

     */

    static public final String urlEncode(final Map<String, ?> map) {

        if (map.isEmpty())

            return "";

        final String charset = StandardCharsets.UTF_8.name();

        final StringBuilder sb = new StringBuilder(256);

        for (final Entry<String, ?> e : map.entrySet()) {

            final Object value = e.getValue();

            // Avoid null and "null" confusion.

            if (value != null) {

                try {

                    sb.append(URLEncoder.encode(e.getKey(), charset).replace("+", "%20"));

                    sb.append('=');

                    sb.append(URLEncoder.encode(String.valueOf(value), charset).replace("+", "%20"));

                    sb.append('&');

                } catch (UnsupportedEncodingException exn) {

                    throw new IllegalStateException("UTF-8 should be standard", exn);

                }

            }

        }

        // remove last '&'

        sb.setLength(sb.length() - 1);

        return sb.toString();

    }

    // Create a trust manager that does not validate certificate chains

    static private final TrustManager[] TRUSTALL_MANAGERS = new TrustManager[] { new X509TrustManager() {

        public java.security.cert.X509Certificate[] getAcceptedIssuers() {

            return null;

        }

        public void checkClientTrusted(X509Certificate[] certs, String authType) {

        }

        public void checkServerTrusted(X509Certificate[] certs, String authType) {

        }

    } };

    static public final SSLContext createTrustAllContext() throws KeyManagementException, NoSuchAlgorithmException {

        final SSLContext sc = SSLContext.getInstance("TLS");

        sc.init(null, TRUSTALL_MANAGERS, new java.security.SecureRandom());

        return sc;

    }

}